1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <unistd.h>
29 #include "bart.h"
30
31 static int compare_manifests(FILE *rulesfile, char *control, char *test,
32 boolean_t prog_fmt, uint_t flags);
33 static void extract_fname_ftype(char *line, char *fname, char *type);
34 static int report_add(char *fname, char *type);
35 static int report_delete(char *fname, char *type);
36 static int evaluate_differences(char *control_line, char *test_line,
37 boolean_t prog_fmt, int flags);
38 static void report_error(char *fname, char *type, char *ctrl_val,
39 char *test_val, boolean_t prog_fmt);
40 static int read_manifest_line(FILE *fd, char *buf, int buf_size, int start_pos,
41 char **line, char *fname);
42 static void parse_line(char *line, char *fname, char *type, char *size,
43 char *mode, char *acl, char *mtime, char *uid, char *gid, char *contents,
44 char *devnode, char *dest);
45 static void init_default_flags(uint_t *flags);
46 static void get_token(char *line, int *curr_pos, int line_len, char *buf,
47 int buf_size);
48
49 int
50 bart_compare(int argc, char **argv)
51 {
52 char *control_fname, *test_fname;
53 int c;
54 FILE *rules_fd = NULL;
55 uint_t glob_flags;
56 boolean_t prog_fmt = B_FALSE;
57
58 init_default_flags(&glob_flags);
59
60 while ((c = getopt(argc, argv, "pr:i:")) != EOF) {
61 switch (c) {
62 case 'p':
63 prog_fmt = B_TRUE;
64 break;
65
66 case 'r':
67 if (optarg == NULL)
68 usage();
69
70 if (strcmp(optarg, "-") == 0)
71 rules_fd = stdin;
72 else
73 rules_fd = fopen(optarg, "r");
74 if (rules_fd == NULL) {
75 perror(optarg);
76 usage();
77 }
78 break;
79
80 case 'i':
81 process_glob_ignores(optarg, &glob_flags);
82 break;
83
84 case '?':
85 default:
86 usage();
87 }
88 }
89
90 /* Make sure we have the right number of args */
91 if ((optind + 2) != argc)
92 usage();
93 argv += optind;
94 control_fname = argv[0];
95 test_fname = argv[1];
96 /* At this point, the filenames are sane, so do the comparison */
97 return (compare_manifests(rules_fd, control_fname, test_fname,
98 prog_fmt, glob_flags));
99 }
100
101 static int
102 compare_manifests(FILE *rulesfile, char *control, char *test,
103 boolean_t prog_fmt, uint_t flags)
104 {
105 FILE *control_fd, *test_fd;
106 char *control_line, *test_line, control_buf[BUF_SIZE],
107 test_buf[BUF_SIZE], control_fname[PATH_MAX],
108 control_type[TYPE_SIZE], test_fname[PATH_MAX],
109 test_type[TYPE_SIZE];
110 int control_pos, test_pos, ret, fname_cmp, return_status;
111
112 return_status = EXIT;
113
114 return_status = read_rules(rulesfile, "", flags, 0);
115
116 control_fd = fopen(control, "r");
117 if (control_fd == NULL) {
118 perror(control);
119 return (FATAL_EXIT);
120 }
121
122 test_fd = fopen(test, "r");
123 if (test_fd == NULL) {
124 perror(test);
125 return (FATAL_EXIT);
126 }
127
128 control_pos = read_manifest_line(control_fd, control_buf,
129 BUF_SIZE, 0, &control_line, control);
130 test_pos = read_manifest_line(test_fd, test_buf, BUF_SIZE, 0,
131 &test_line, test);
132
133 while ((control_pos != -1) && (test_pos != -1)) {
134 ret = strcmp(control_line, test_line);
135 if (ret == 0) {
136 /* Lines compare OK, just read the next lines.... */
137 control_pos = read_manifest_line(control_fd,
138 control_buf, BUF_SIZE, control_pos, &control_line,
139 control);
140 test_pos = read_manifest_line(test_fd, test_buf,
141 BUF_SIZE, test_pos, &test_line, test);
142 continue;
143 }
144
145 /*
146 * Something didn't compare properly.
147 */
148 extract_fname_ftype(control_line, control_fname, control_type);
149 extract_fname_ftype(test_line, test_fname, test_type);
150 fname_cmp = strcmp(control_fname, test_fname);
151
152 if (fname_cmp == 0) {
153 /*
154 * Filenames were the same, see what was
155 * different and continue.
156 */
157 if (evaluate_differences(control_line, test_line,
158 prog_fmt, flags) != 0)
159 return_status = WARNING_EXIT;
160
161 control_pos = read_manifest_line(control_fd,
162 control_buf, BUF_SIZE, control_pos, &control_line,
163 control);
164 test_pos = read_manifest_line(test_fd, test_buf,
165 BUF_SIZE, test_pos, &test_line, test);
166 } else if (fname_cmp > 0) {
167 /* Filenames were different, a files was ADDED */
168 if (report_add(test_fname, test_type)) {
169 report_error(test_fname, ADD_KEYWORD, NULL,
170 NULL, prog_fmt);
171 return_status = WARNING_EXIT;
172 }
173 test_pos = read_manifest_line(test_fd, test_buf,
174 BUF_SIZE, test_pos, &test_line, test);
175 } else if (fname_cmp < 0) {
176 /* Filenames were different, a files was DELETED */
177 if (report_delete(control_fname, control_type)) {
178 report_error(control_fname, DELETE_KEYWORD,
179 NULL, NULL, prog_fmt);
180 return_status = WARNING_EXIT;
181 }
182 control_pos = read_manifest_line(control_fd,
183 control_buf, BUF_SIZE, control_pos, &control_line,
184 control);
185 }
186 }
187
188 /*
189 * Entering this while loop means files were DELETED from the test
190 * manifest.
191 */
192 while (control_pos != -1) {
193 (void) sscanf(control_line, "%1023s", control_fname);
194 if (report_delete(control_fname, control_type)) {
195 report_error(control_fname, DELETE_KEYWORD, NULL,
196 NULL, prog_fmt);
197 return_status = WARNING_EXIT;
198 }
199 control_pos = read_manifest_line(control_fd, control_buf,
200 BUF_SIZE, control_pos, &control_line, control);
201 }
202
203 /*
204 * Entering this while loop means files were ADDED to the test
205 * manifest.
206 */
207 while (test_pos != -1) {
208 (void) sscanf(test_line, "%1023s", test_fname);
209 if (report_add(test_fname, test_type)) {
210 report_error(test_fname, ADD_KEYWORD, NULL,
211 NULL, prog_fmt);
212 return_status = WARNING_EXIT;
213 }
214 test_pos = read_manifest_line(test_fd, test_buf,
215 BUF_SIZE, test_pos, &test_line, test);
216 }
217
218 (void) fclose(control_fd);
219 (void) fclose(test_fd);
220
221 /* For programmatic mode, add a newline for cosmetic reasons */
222 if (prog_fmt && (return_status != 0))
223 (void) printf("\n");
224
225 return (return_status);
226 }
227
228 static void
229 parse_line(char *line, char *fname, char *type, char *size, char *mode,
230 char *acl, char *mtime, char *uid, char *gid, char *contents, char *devnode,
231 char *dest)
232 {
233 int pos, line_len;
234
235 line_len = strlen(line);
236 pos = 0;
237
238 get_token(line, &pos, line_len, fname, PATH_MAX);
239 get_token(line, &pos, line_len, type, TYPE_SIZE);
240 get_token(line, &pos, line_len, size, MISC_SIZE);
241 get_token(line, &pos, line_len, mode, MISC_SIZE);
242 get_token(line, &pos, line_len, acl, ACL_SIZE);
243 get_token(line, &pos, line_len, mtime, MISC_SIZE);
244 get_token(line, &pos, line_len, uid, MISC_SIZE);
245 get_token(line, &pos, line_len, gid, MISC_SIZE);
246
247 /* Reset these fields... */
248
249 *contents = '\0';
250 *devnode = '\0';
251 *dest = '\0';
252
253 /* Handle filetypes which have a last field..... */
254 if (type[0] == 'F')
255 get_token(line, &pos, line_len, contents, PATH_MAX);
256 else if ((type[0] == 'B') || (type[0] == 'C'))
257 get_token(line, &pos, line_len, devnode, PATH_MAX);
258 else if (type[0] == 'L')
259 get_token(line, &pos, line_len, dest, PATH_MAX);
260 }
261
262 static void
263 get_token(char *line, int *curr_pos, int line_len, char *buf, int buf_size)
264 {
265 int cnt = 0;
266
267 while (isspace(line[*curr_pos]) && (*curr_pos < line_len))
268 (*curr_pos)++;
269
270 while (!isspace(line[*curr_pos]) &&
271 (*curr_pos < line_len) && (cnt < (buf_size-1))) {
272 buf[cnt] = line[*curr_pos];
273 (*curr_pos)++;
274 cnt++;
275 }
276 buf[cnt] = '\0';
277 }
278
279 /*
280 * Utility function: extract fname and type from this line
281 */
282 static void
283 extract_fname_ftype(char *line, char *fname, char *type)
284 {
285 int line_len, pos;
286
287 pos = 0;
288 line_len = strlen(line);
289
290 get_token(line, &pos, line_len, fname, PATH_MAX);
291 get_token(line, &pos, line_len, type, TYPE_SIZE);
292 }
293
294 /*
295 * Utility function: tells us whether or not this addition should be reported
296 *
297 * Returns 0 if the discrepancy is ignored, non-zero if the discrepancy is
298 * reported.
299 */
300 static int
301 report_add(char *fname, char *type)
302 {
303 struct rule *rule_ptr;
304
305 rule_ptr = check_rules(fname, type[0]);
306 if ((rule_ptr != NULL) && (rule_ptr->attr_list & ATTR_ADD))
307 return (1);
308 else
309 return (0);
310 }
311
312 /*
313 * Utility function: tells us whether or not this deletion should be reported
314 *
315 * Returns 0 if the discrepancy is ignored, non-zero if the discrepancy is
316 * reported.
317 */
318 static int
319 report_delete(char *fname, char *type)
320 {
321 struct rule *rule_ptr;
322
323 rule_ptr = check_rules(fname, type[0]);
324
325 if ((rule_ptr != NULL) && (rule_ptr->attr_list & ATTR_DELETE))
326 return (1);
327 else
328 return (0);
329 }
330
331 /*
332 * This function takes in the two entries, which have been flagged as
333 * different, breaks them up and reports discrepancies. Note, discrepancies
334 * are affected by the 'CHECK' and 'IGNORE' stanzas which may apply to
335 * these entries.
336 *
337 * Returns the number of discrepancies reported.
338 */
339 static int
340 evaluate_differences(char *control_line, char *test_line,
341 boolean_t prog_fmt, int flags)
342 {
343 char ctrl_fname[PATH_MAX], test_fname[PATH_MAX],
344 ctrl_type[TYPE_SIZE], test_type[TYPE_SIZE],
345 ctrl_size[MISC_SIZE], ctrl_mode[MISC_SIZE],
346 ctrl_acl[ACL_SIZE], ctrl_mtime[MISC_SIZE],
347 ctrl_uid[MISC_SIZE], ctrl_gid[MISC_SIZE],
348 ctrl_dest[PATH_MAX], ctrl_contents[PATH_MAX],
349 ctrl_devnode[PATH_MAX], test_size[MISC_SIZE],
350 test_mode[MISC_SIZE], test_acl[ACL_SIZE],
351 test_mtime[MISC_SIZE], test_uid[MISC_SIZE],
352 test_gid[MISC_SIZE], test_dest[PATH_MAX],
353 test_contents[PATH_MAX], test_devnode[PATH_MAX],
354 *tag;
355 int ret_val;
356 struct rule *rule_ptr;
357
358 ret_val = 0;
359
360 parse_line(control_line, ctrl_fname, ctrl_type, ctrl_size, ctrl_mode,
361 ctrl_acl, ctrl_mtime, ctrl_uid, ctrl_gid, ctrl_contents,
362 ctrl_devnode, ctrl_dest);
363
364 /*
365 * Now we know the fname and type, let's get the rule that matches this
366 * manifest entry. If there is a match, make sure to setup the
367 * correct reporting flags.
368 */
369 rule_ptr = check_rules(ctrl_fname, ctrl_type[0]);
370 if (rule_ptr != NULL)
371 flags = rule_ptr->attr_list;
372
373 parse_line(test_line, test_fname, test_type, test_size, test_mode,
374 test_acl, test_mtime, test_uid, test_gid, test_contents,
375 test_devnode, test_dest);
376
377 /*
378 * Report the errors based upon which keywords have been set by
379 * the user.
380 */
381 if ((flags & ATTR_TYPE) && (ctrl_type[0] != test_type[0])) {
382 report_error(ctrl_fname, TYPE_KEYWORD, ctrl_type,
383 test_type, prog_fmt);
384 ret_val++;
385 }
386
387 if ((flags & ATTR_SIZE) && (strcmp(ctrl_size, test_size) != 0)) {
388 report_error(ctrl_fname, SIZE_KEYWORD, ctrl_size,
389 test_size, prog_fmt);
390 ret_val++;
391 }
392
393 if ((flags & ATTR_MODE) && (strcmp(ctrl_mode, test_mode) != 0)) {
394 report_error(ctrl_fname, MODE_KEYWORD, ctrl_mode,
395 test_mode, prog_fmt);
396 ret_val++;
397 }
398
399 if ((flags & ATTR_ACL) && (strcmp(ctrl_acl, test_acl) != 0)) {
400 report_error(ctrl_fname, ACL_KEYWORD, ctrl_acl,
401 test_acl, prog_fmt);
402 ret_val++;
403 }
404
405 if ((flags & ATTR_MTIME) && (ctrl_type[0] == test_type[0])) {
406 if (strcmp(ctrl_mtime, test_mtime) != 0) {
407 switch (ctrl_type[0]) {
408 case 'D':
409 tag = "dirmtime";
410 break;
411 case 'L':
412 tag = "lnmtime";
413 break;
414 default:
415 tag = "mtime";
416 break;
417 }
418 if (flags == 0) {
419 report_error(ctrl_fname, tag, ctrl_mtime,
420 test_mtime, prog_fmt);
421 ret_val++;
422 }
423 }
424
425 if ((ctrl_type[0] == 'F') && (flags & ATTR_MTIME) &&
426 (strcmp(ctrl_mtime, test_mtime) != 0)) {
427 report_error(ctrl_fname, MTIME_KEYWORD, ctrl_mtime, test_mtime,
428 prog_fmt);
429 ret_val++;
430 }
431
432 if ((ctrl_type[0] == 'D') && (flags & ATTR_DIRMTIME) &&
433 (strcmp(ctrl_mtime, test_mtime) != 0)) {
434 report_error(ctrl_fname, DIRMTIME_KEYWORD, ctrl_mtime,
435 test_mtime, prog_fmt);
436 ret_val++;
437 }
438
439 if ((ctrl_type[0] == 'L') && (flags & ATTR_LNMTIME) &&
440 (strcmp(ctrl_mtime, test_mtime) != 0)) {
441 report_error(ctrl_fname, LNMTIME_KEYWORD, ctrl_mtime,
442 test_mtime, prog_fmt);
443 ret_val++;
444 }
445 } else if ((flags & ATTR_MTIME) &&
446 (strcmp(ctrl_mtime, test_mtime) != 0)) {
447 report_error(ctrl_fname, MTIME_KEYWORD, ctrl_mtime,
448 test_mtime, prog_fmt);
449 ret_val++;
450 }
451
452 if ((flags & ATTR_UID) && (strcmp(ctrl_uid, test_uid) != 0)) {
453 report_error(ctrl_fname, UID_KEYWORD, ctrl_uid,
454 test_uid, prog_fmt);
455 ret_val++;
456 }
457
458 if ((flags & ATTR_GID) && (strcmp(ctrl_gid, test_gid) != 0)) {
459 report_error(ctrl_fname, GID_KEYWORD, ctrl_gid,
460 test_gid, prog_fmt);
461 ret_val++;
462 }
463
464 if ((flags & ATTR_DEVNODE) &&
465 (strcmp(ctrl_devnode, test_devnode) != 0)) {
466 report_error(ctrl_fname, DEVNODE_KEYWORD, ctrl_devnode,
467 test_devnode, prog_fmt);
468 ret_val++;
469 }
470
471 if ((flags & ATTR_DEST) && (strcmp(ctrl_dest, test_dest) != 0)) {
472 report_error(ctrl_fname, DEST_KEYWORD, ctrl_dest,
473 test_dest, prog_fmt);
474 ret_val++;
475 }
476
477 if ((flags & ATTR_CONTENTS) &&
478 (strcmp(ctrl_contents, test_contents)) != 0) {
479 report_error(ctrl_fname, CONTENTS_KEYWORD, ctrl_contents,
480 test_contents, prog_fmt);
481 ret_val++;
482 }
483
484 return (ret_val);
485 }
486
487 /*
488 * Function responsible for reporting errors.
489 */
490 static void
491 report_error(char *fname, char *type, char *ctrl_val, char *test_val,
492 boolean_t prog_fmt)
493 {
494 static char last_fname[PATH_MAX] = "";
495
496 if (!prog_fmt) {
497 /* Verbose mode */
498 if (strcmp(fname, last_fname) != 0) {
499 (void) printf("%s:\n", fname);
500 (void) strlcpy(last_fname, fname, sizeof (last_fname));
501 }
502
503 if (strcmp(type, ADD_KEYWORD) == 0 ||
504 strcmp(type, DELETE_KEYWORD) == 0)
505 (void) printf(" %s\n", type);
506 else
507 (void) printf(" %s control:%s test:%s\n", type,
508 ctrl_val, test_val);
509 } else {
510 /* Programmatic mode */
511 if (strcmp(fname, last_fname) != 0) {
512 /* Ensure a line is not printed for the initial case */
513 if (strlen(last_fname) != 0)
514 (void) printf("\n");
515 (void) strlcpy(last_fname, fname, sizeof (last_fname));
516 (void) printf("%s ", fname);
517 }
518
519 (void) printf("%s ", type);
520 if (strcmp(type, ADD_KEYWORD) != 0 &&
521 strcmp(type, DELETE_KEYWORD) != 0) {
522 (void) printf("%s ", ctrl_val);
523 (void) printf("%s ", test_val);
524 }
525 }
526 }
527
528 /*
529 * Function responsible for reading in a line from the manifest.
530 * Takes in the file ptr and a buffer, parses the buffer and sets the 'line'
531 * ptr correctly. In the case when the buffer is fully parsed, this function
532 * reads more data from the file ptr and refills the buffer.
533 */
534 static int
535 read_manifest_line(FILE *fd, char *buf, int buf_size, int start_pos,
536 char **line, char *fname)
537 {
538 int end_pos, len, iscomment = 0, filepos;
539
540 /*
541 * Initialization case: make sure the manifest version is OK
542 */
543 if (start_pos == 0) {
544 end_pos = 0;
545 buf[0] = '\0';
546 filepos = ftell(fd);
547 (void) fread((void *) buf, (size_t)buf_size, (size_t)1, fd);
548
549 *line = buf;
550
551 if (filepos == 0) {
552 if (strncmp(buf, MANIFEST_VER,
553 strlen(MANIFEST_VER)) != 0)
554 (void) fprintf(stderr, MISSING_VER, fname);
555 if ((*line[0] == '!') || (*line[0] == '#'))
556 iscomment++;
557
558 while (iscomment) {
559 while ((buf[end_pos] != '\n') &&
560 (buf[end_pos] != '\0') &&
561 (end_pos < buf_size))
562 end_pos++;
563
564 if (end_pos >= buf_size)
565 return (-1);
566
567 end_pos++;
568 *line = &(buf[end_pos]);
569 iscomment = 0;
570 if ((*line[0] == '!') || (*line[0] == '#'))
571 iscomment++;
572 }
573 }
574
575 while ((buf[end_pos] != '\n') && (buf[end_pos] != '\0') &&
576 (end_pos < buf_size))
577 end_pos++;
578
579 if (end_pos < buf_size) {
580 if (buf[end_pos] == '\n') {
581 buf[end_pos] = '\0';
582 return (end_pos);
583 }
584
585 if (buf[end_pos] == '\0')
586 return (-1);
587 }
588
589 (void) fprintf(stderr, MANIFEST_ERR);
590 exit(FATAL_EXIT);
591 }
592
593 end_pos = (start_pos+1);
594 *line = &(buf[end_pos]);
595
596 /* Read the buffer until EOL or the buffer is empty */
597 while ((buf[end_pos] != '\n') && (buf[end_pos] != '\0') &&
598 (end_pos < buf_size))
599 end_pos++;
600
601 if (end_pos < buf_size) {
602 /* Found the end of the line, normal exit */
603 if (buf[end_pos] == '\n') {
604 buf[end_pos] = '\0';
605 return (end_pos);
606 }
607
608 /* No more input to read */
609 if (buf[end_pos] == '\0')
610 return (-1);
611 }
612
613 /*
614 * The following code takes the remainder of the buffer and
615 * puts it at the beginning. The space after the remainder, which
616 * is now at the beginning, is blanked.
617 * At this point, read in more data and continue to find the EOL....
618 */
619 len = end_pos - (start_pos + 1);
620 (void) memcpy(buf, &(buf[start_pos+1]), (size_t)len);
621 (void) memset(&buf[len], '\0', (buf_size - len));
622 (void) fread((void *) &buf[len], (size_t)(buf_size-len), (size_t)1, fd);
623 *line = buf;
624 end_pos = len;
625
626 /* Read the buffer until EOL or the buffer is empty */
627 while ((buf[end_pos] != '\n') && (buf[end_pos] != '\0') &&
628 (end_pos < buf_size))
629 end_pos++;
630
631 if (end_pos < buf_size) {
632 /* Found the end of the line, normal exit */
633 if (buf[end_pos] == '\n') {
634 buf[end_pos] = '\0';
635 return (end_pos);
636 }
637
638 /* No more input to read */
639 if (buf[end_pos] == '\0')
640 return (-1);
641 }
642
643 (void) fprintf(stderr, MANIFEST_ERR);
644 exit(FATAL_EXIT);
645
646 /* NOTREACHED */
647 }
648
649 static void
650 init_default_flags(uint_t *flags)
651 {
652 /* Default behavior: everything is checked *except* dirmtime */
653 *flags = ATTR_ALL & ~(ATTR_DIRMTIME);
654 }