xref: /titanic_50/usr/src/tools/protocmp/protocmp.c (revision 3d729aecc03ea6ebb9bd5d56b8dccd24f57daa41)
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 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <stdio.h>
28 #include <fcntl.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <dirent.h>
34 #include <sys/param.h>
35 #include <errno.h>
36 #include <unistd.h>
37 #include <ftw.h>
38 
39 #include "list.h"
40 #include "protocmp.h"
41 #include "proto_list.h"
42 #include "protodir.h"
43 #include "exception_list.h"
44 #include "stdusers.h"
45 
46 #define	MAX_PROTO_REFS			5
47 #define	MAX_EXCEPTION_FILES		5
48 #define	MAX_DEPTH			50
49 
50 /*
51  * default flag values
52  */
53 static int check_group = 1;
54 static int set_group = 0;
55 static int check_user = 1;
56 static int set_user = 0;
57 static int check_perm = 1;
58 static int set_perm = 0;
59 static int check_link = 1;
60 static int check_sym = 1;
61 static int check_majmin = 1;
62 
63 static elem_list first_list;
64 static char *first_file_name;
65 
66 static elem_list second_list;
67 static char *second_file_name;
68 
69 static FILE *need_add_fp;
70 static char *need_add_file;
71 static FILE *need_rm_fp;
72 static char *need_rm_file;
73 static FILE *differ_fp;
74 static char *differ_file;
75 
76 static char *myname;
77 
78 /*
79  * default flag values
80  */
81 static int verbose = 0;
82 
83 static void
84 usage(void)
85 {
86 	(void) fputs("usage: protocmp [-gupGUPlmsLv] "
87 	    "[-e <exception-list> ...] "
88 	    "-d <protolist|pkg dir>\n\t[-d <protolist|pkg dir> ...] "
89 	    "[<protolist|pkg dir>...]|<root>]\n",
90 	    stderr);
91 	(void) fputs("   where:\n", stderr);
92 	(void) fputs("\t-g       : don't compare group\n", stderr);
93 	(void) fputs("\t-u       : don't compare owner\n", stderr);
94 	(void) fputs("\t-p       : don't compare permissions\n", stderr);
95 	(void) fputs("\t-G       : set group\n", stderr);
96 	(void) fputs("\t-U       : set owner\n", stderr);
97 	(void) fputs("\t-P       : set permissions\n", stderr);
98 	(void) fputs("\t-l       : don't compare link counts\n", stderr);
99 	(void) fputs("\t-m       : don't compare major/minor numbers\n",
100 	    stderr);
101 	(void) fputs("\t-s       : don't compare symlink values\n", stderr);
102 	(void) fputs("\t-d <protolist|pkg dir>:\n", stderr);
103 	(void) fputs("\t           proto list or packaging to check\n", stderr);
104 	(void) fputs("\t-e <file>: exceptions file\n", stderr);
105 	(void) fputs("\t-L       : list filtered exceptions\n", stderr);
106 	(void) fputs("\t-v       : verbose output\n", stderr);
107 	(void) fputs("\n"
108 "If any of the -[GUP] flags are given, then the final argument must be the\n"
109 "proto root directory itself on which to set permissions according to the\n"
110 "packaging data specified via -d options.\n", stderr);
111 }
112 
113 
114 static void
115 open_output_files(void)
116 {
117 	if ((need_add_fp =
118 	    fopen((need_add_file = tempnam(NULL, "add")), "w")) == NULL) {
119 		perror(need_add_file);
120 		exit(1);
121 	}
122 
123 	if ((need_rm_fp =
124 	    fopen((need_rm_file = tempnam(NULL, "rm")), "w")) == NULL) {
125 		perror(need_rm_file);
126 		exit(1);
127 	}
128 
129 	if ((differ_fp =
130 	    fopen((differ_file = tempnam(NULL, "diff")), "w")) == NULL) {
131 		perror(differ_file);
132 		exit(1);
133 	}
134 }
135 
136 static void
137 close_output_files(void)
138 {
139 	(void) fclose(need_add_fp);
140 	(void) fclose(need_rm_fp);
141 	(void) fclose(differ_fp);
142 }
143 
144 static void
145 print_file(char *file)
146 {
147 	FILE	*fp;
148 	int	count;
149 	char	buff[BUF_SIZE];
150 
151 	if ((fp = fopen(file, "r")) == NULL) {
152 		perror(need_add_file);
153 	}
154 
155 	while (count = fread(buff, sizeof (char), BUF_SIZE, fp))
156 		(void) fwrite(buff, sizeof (char), count, stdout);
157 	(void) fclose(fp);
158 }
159 
160 static void
161 print_header(void)
162 {
163 	(void) printf("%c %-30s %-20s %-4s %-5s %-5s %-5s %-2s %2s %2s %-9s\n",
164 	    'T', "File Name", "Reloc/Sym name", "perm", "owner", "group",
165 	    "inode", "lnk", "maj", "min", "package(s)");
166 	(void) puts("-------------------------------------------------------"
167 	    "-----------------------------------------------------");
168 }
169 
170 static void
171 print_results(void)
172 {
173 	(void) puts("*******************************************************");
174 	(void) puts("*");
175 	(void) printf("* Entries found in %s, but not found in %s\n",
176 	    first_file_name, second_file_name);
177 	(void) puts("*");
178 	(void) puts("*******************************************************");
179 	print_header();
180 	print_file(need_add_file);
181 	(void) puts("*******************************************************");
182 	(void) puts("*");
183 	(void) printf("* Entries found in %s, but not found in %s\n",
184 	    second_file_name, first_file_name);
185 	(void) puts("*");
186 	(void) puts("*******************************************************");
187 	print_header();
188 	print_file(need_rm_file);
189 	(void) puts("*******************************************************");
190 	(void) puts("*");
191 	(void) printf("* Entries that differ between %s and %s\n",
192 	    first_file_name, second_file_name);
193 	(void) puts("*");
194 	(void) printf("* filea == %s\n", first_file_name);
195 	(void) printf("* fileb == %s\n", second_file_name);
196 	(void) puts("*");
197 	(void) puts("*******************************************************");
198 	(void) fputs("Unit   ", stdout);
199 	print_header();
200 	print_file(differ_file);
201 }
202 
203 static void
204 clean_up(void)
205 {
206 	(void) unlink(need_add_file);
207 	(void) unlink(need_rm_file);
208 	(void) unlink(differ_file);
209 }
210 
211 /*
212  * elem_compare(a,b)
213  *
214  * Args:
215  *	a 		- element a
216  *	b 		- element b
217  *	different_types -
218  *		value = 0  -> comparing two elements of same
219  *			      type (eg: protodir elem vs. protodir elem).
220  *		value != 0 -> comparing two elements of different type
221  *			      (eg: protodir elem vs. protolist elem).
222  *
223  * Returns:
224  *	0   - elements are identical
225  *	>0  - elements differ
226  *	      check flags to see which fields differ.
227  */
228 static int
229 elem_compare(elem *a, elem *b, int different_types)
230 {
231 	int	res = 0;
232 	elem	*i, *j;
233 
234 	/*
235 	 * if these are hard links to other files - those are the
236 	 * files that should be compared.
237 	 */
238 	i = a->link_parent ? a->link_parent : a;
239 	j = b->link_parent ? b->link_parent : b;
240 
241 	/*
242 	 * We do not compare inodes - they always differ.
243 	 * We do not compare names because we assume that was
244 	 * checked before.
245 	 */
246 
247 	/*
248 	 * Special rules for comparison:
249 	 *
250 	 * 1) if directory - ignore ref_cnt.
251 	 * 2) if sym_link - only check file_type & symlink
252 	 * 3) elem type of FILE_T, EDIT_T, & VOLATILE_T are equivilant when
253 	 *    comparing a protodir entry to a protolist entry.
254 	 */
255 	if (i->file_type != j->file_type) {
256 		if (different_types) {
257 			/*
258 			 * Check to see if filetypes are FILE_T vs.
259 			 * EDIT_T/VOLATILE_T/LINK_T comparisons.
260 			 */
261 			if ((i->file_type == FILE_T) &&
262 			    ((j->file_type == EDIT_T) ||
263 			    (j->file_type == VOLATILE_T) ||
264 			    (j->file_type == LINK_T))) {
265 				/*EMPTY*/
266 			} else if ((j->file_type == FILE_T) &&
267 			    ((i->file_type == EDIT_T) ||
268 			    (i->file_type == VOLATILE_T) ||
269 			    (i->file_type == LINK_T))) {
270 				/*EMPTY*/
271 			} else
272 				res |= TYPE_F;
273 		} else
274 			res |= TYPE_F;
275 	}
276 
277 	/*
278 	 * if symlink - check the symlink value and then
279 	 * return.  symlink is the only field of concern
280 	 * in SYMLINKS.
281 	 */
282 	if (check_sym && ((res == 0) && (i->file_type == SYM_LINK_T))) {
283 		if ((!i->symsrc) || (!j->symsrc))
284 			res |= SYM_F;
285 		else {
286 			/*
287 			 * if either symlink starts with a './' strip it off,
288 			 * its irrelevant.
289 			 */
290 			if ((i->symsrc[0] == '.') && (i->symsrc[1] == '/'))
291 				i->symsrc += 2;
292 			if ((j->symsrc[0] == '.') && (j->symsrc[1] == '/'))
293 				j->symsrc += 2;
294 
295 			if (strncmp(i->symsrc, j->symsrc, MAXNAME) != 0)
296 				res |= SYM_F;
297 		}
298 		return (res);
299 	}
300 
301 	if ((i->file_type != DIR_T) && check_link &&
302 	    (i->ref_cnt != j->ref_cnt))
303 		res |= REF_F;
304 	if (check_user && (strncmp(i->owner, j->owner, TYPESIZE) != 0))
305 		res |= OWNER_F;
306 	if (check_group && (strncmp(i->group, j->group, TYPESIZE) != 0))
307 		res |= GROUP_F;
308 	if (check_perm && (i->perm != j->perm))
309 		res |= PERM_F;
310 	if (check_majmin && ((i->major != j->major) || (i->minor != j->minor)))
311 		res |= MAJMIN_F;
312 
313 	return (res);
314 }
315 
316 static void
317 print_elem(FILE *fp, elem *e)
318 {
319 	elem		p;
320 	pkg_list	*l;
321 	char		maj[TYPESIZE], min[TYPESIZE];
322 	char		perm[12], ref_cnt[12];
323 
324 	/*
325 	 * If this is a LINK to another file, then adopt
326 	 * the permissions of that file.
327 	 */
328 	if (e->link_parent) {
329 		p = *((elem *)e->link_parent);
330 		(void) strcpy(p.name, e->name);
331 		p.symsrc = e->symsrc;
332 		p.file_type = e->file_type;
333 		e = &p;
334 	}
335 
336 	if (!check_majmin || e->major == -1) {
337 		maj[0] = '-';
338 		maj[1] = '\0';
339 	} else {
340 		(void) sprintf(maj, "%d", e->major);
341 	}
342 
343 	if (!check_majmin || e->minor == -1) {
344 		min[0] = '-';
345 		min[1] = '\0';
346 	} else {
347 		(void) sprintf(min, "%d", e->minor);
348 	}
349 
350 	if (!check_perm) {
351 		perm[0] = '-';
352 		perm[1] = '\0';
353 	} else {
354 		(void) snprintf(perm, sizeof (perm), "%o", e->perm);
355 	}
356 
357 	if (!check_link) {
358 		ref_cnt[0] = '-';
359 		ref_cnt[1] = '\0';
360 	} else {
361 		(void) snprintf(ref_cnt, sizeof (ref_cnt), "%d", e->ref_cnt);
362 	}
363 
364 	(void) fprintf(fp, "%c %-30s %-20s %4s %-5s %-5s %6d %2s %2s %2s   ",
365 	    e->file_type, e->name,
366 	    check_sym && e->symsrc != NULL ? e->symsrc : "-", perm,
367 	    check_user ? e->owner : "-",
368 	    check_group ? e->group : "-",
369 	    e->inode, ref_cnt, maj, min);
370 	/*
371 	 * dump package list - if any.
372 	 */
373 	if (!e->pkgs)
374 		(void) fputs(" proto", fp);
375 
376 	for (l = e->pkgs; l; l = l->next) {
377 		(void) fputc(' ', fp);
378 		(void) fputs(l->pkg_name, fp);
379 	}
380 	(void) fputc('\n', fp);
381 }
382 
383 /*
384  * do_compare(a,b)
385  *
386  * Args:
387  *	different_types - see elem_compare() for explanation.
388  */
389 static void
390 do_compare(elem *a, elem *b, int different_types)
391 {
392 	int	rc;
393 
394 	if ((rc = elem_compare(a, b, different_types)) != 0) {
395 		(void) fputs("filea: ", differ_fp);
396 		print_elem(differ_fp, a);
397 		(void) fputs("fileb: ", differ_fp);
398 		print_elem(differ_fp, b);
399 		(void) fputs("    differ: ", differ_fp);
400 
401 		if (rc & SYM_F)
402 			(void) fputs("symlink", differ_fp);
403 		if (rc & PERM_F)
404 			(void) fputs("perm ", differ_fp);
405 		if (rc & REF_F)
406 			(void) fputs("ref_cnt ", differ_fp);
407 		if (rc & TYPE_F)
408 			(void) fputs("file_type ", differ_fp);
409 		if (rc & OWNER_F)
410 			(void) fputs("owner ", differ_fp);
411 		if (rc & GROUP_F)
412 			(void) fputs("group ", differ_fp);
413 		if (rc & MAJMIN_F)
414 			(void) fputs("major/minor ", differ_fp);
415 		(void) putc('\n', differ_fp);
416 		(void) putc('\n', differ_fp);
417 	}
418 }
419 
420 static void
421 check_second_vs_first(int verbose)
422 {
423 	int	i;
424 	elem	*cur;
425 
426 	for (i = 0; i < second_list.num_of_buckets; i++) {
427 		for (cur = second_list.list[i]; cur; cur = cur->next) {
428 			if (!(cur->flag & VISITED_F)) {
429 				if ((first_list.type != second_list.type) &&
430 				    find_elem(&exception_list, cur,
431 				    FOLLOW_LINK)) {
432 					/*
433 					 * this entry is filtered, we don't
434 					 * need to do any more processing.
435 					 */
436 					if (verbose) {
437 						(void) printf(
438 						    "Filtered: Need Deletion "
439 						    "of:\n\t");
440 						print_elem(stdout, cur);
441 					}
442 					continue;
443 				}
444 				/*
445 				 * It is possible for arch specific files to be
446 				 * found in a protodir but listed as arch
447 				 * independent in a protolist file.  If this is
448 				 * a protodir vs. a protolist we will make
449 				 * that check.
450 				 */
451 				if ((second_list.type == PROTODIR_LIST) &&
452 				    (cur->arch != P_ISA) &&
453 				    (first_list.type != PROTODIR_LIST)) {
454 					/*
455 					 * do a lookup for same file, but as
456 					 * type ISA.
457 					 */
458 					elem	*e;
459 
460 					e = find_elem_isa(&first_list, cur,
461 					    NO_FOLLOW_LINK);
462 					if (e) {
463 						do_compare(e, cur,
464 						    first_list.type -
465 						    second_list.type);
466 						continue;
467 					}
468 				}
469 
470 				print_elem(need_rm_fp, cur);
471 			}
472 		}
473 	}
474 }
475 
476 static void
477 check_first_vs_second(int verbose)
478 {
479 	int	i;
480 	elem	*e;
481 	elem	*cur;
482 
483 	for (i = 0; i < first_list.num_of_buckets; i++) {
484 		for (cur = first_list.list[i]; cur; cur = cur->next) {
485 			if ((first_list.type != second_list.type) &&
486 			    find_elem(&exception_list, cur, FOLLOW_LINK)) {
487 				/*
488 				 * this entry is filtered, we don't need to do
489 				 * any more processing.
490 				 */
491 				if (verbose) {
492 					(void) printf("Filtered: Need "
493 					    "Addition of:\n\t");
494 					print_elem(stdout, cur);
495 				}
496 				continue;
497 			}
498 
499 			/*
500 			 * Search package database for file.
501 			 */
502 			e = find_elem(&second_list, cur, NO_FOLLOW_LINK);
503 
504 			/*
505 			 * It is possible for arch specific files to be found
506 			 * in a protodir but listed as arch independent in a
507 			 * protolist file.  If this is a protodir vs. a
508 			 * protolist we will make that check.
509 			 */
510 			if (!e && (first_list.type == PROTODIR_LIST) &&
511 			    (cur->arch != P_ISA) &&
512 			    (second_list.type != PROTODIR_LIST)) {
513 				/*
514 				 * do a lookup for same file, but as type ISA.
515 				 */
516 				e = find_elem_isa(&second_list, cur,
517 				    NO_FOLLOW_LINK);
518 			}
519 
520 			if (!e && (first_list.type != PROTODIR_LIST) &&
521 			    (cur->arch == P_ISA) &&
522 			    (second_list.type == PROTODIR_LIST)) {
523 				/*
524 				 * do a lookup for same file, but as any
525 				 * type but ISA
526 				 */
527 				e = find_elem_mach(&second_list, cur,
528 				    NO_FOLLOW_LINK);
529 			}
530 
531 			if (e == NULL)
532 				print_elem(need_add_fp, cur);
533 			else {
534 				do_compare(cur, e,
535 				    first_list.type - second_list.type);
536 				e->flag |= VISITED_F;
537 			}
538 		}
539 	}
540 }
541 
542 static int
543 read_in_file(const char *file_name, elem_list *list)
544 {
545 	struct stat	st_buf;
546 	int		count = 0;
547 
548 	if (stat(file_name, &st_buf) == 0) {
549 		if (S_ISREG(st_buf.st_mode)) {
550 			if (verbose) {
551 				(void) printf("file(%s): trying to process "
552 				    "as protolist...\n", file_name);
553 			}
554 			count = read_in_protolist(file_name, list, verbose);
555 		} else if (S_ISDIR(st_buf.st_mode)) {
556 			if (verbose)
557 				(void) printf("directory(%s): trying to "
558 				    "process as protodir...\n", file_name);
559 			count = read_in_protodir(file_name, list, verbose);
560 		} else {
561 			(void) fprintf(stderr,
562 			    "%s not a file or a directory.\n", file_name);
563 			usage();
564 			exit(1);
565 		}
566 	} else {
567 		perror(file_name);
568 		usage();
569 		exit(1);
570 	}
571 
572 	return (count);
573 }
574 
575 /* ARGSUSED */
576 static int
577 set_values(const char *fname, const struct stat *sbp, int otype,
578     struct FTW *ftw)
579 {
580 	elem *ep;
581 	uid_t uid;
582 	gid_t gid;
583 	elem keyelem;
584 	mode_t perm;
585 
586 	if (fname[0] == '\0' || fname[1] == '\0' || fname[2] == '\0')
587 		return (0);
588 	/* skip leading "./" */
589 	fname += 2;
590 	switch (otype) {
591 	case FTW_F:
592 	case FTW_D:
593 	case FTW_DP:
594 		if (strlcpy(keyelem.name, fname, sizeof (keyelem.name)) >=
595 		    sizeof (keyelem.name)) {
596 			(void) fprintf(stderr, "%s: %s: name too long\n",
597 			    myname, fname);
598 			return (1);
599 		}
600 		keyelem.arch = P_ISA;
601 		ep = find_elem(&first_list, &keyelem, NO_FOLLOW_LINK);
602 		if (ep == NULL) {
603 			ep = find_elem_mach(&first_list, &keyelem,
604 			    NO_FOLLOW_LINK);
605 		}
606 		/*
607 		 * Do nothing if this is a hard or symbolic link,
608 		 * since links don't have this information.
609 		 *
610 		 * Assume it's a file on the exception list if it's
611 		 * not found in the packaging.  Those are root:bin 755.
612 		 */
613 		if (ep != NULL &&
614 		    (ep->file_type == SYM_LINK_T || ep->file_type == LINK_T)) {
615 			return (0);
616 		}
617 		if (!set_group) {
618 			gid = -1;
619 		} else if (ep == NULL) {
620 			gid = 0;
621 		} else if ((gid = stdfind(ep->group, groupnames)) == -1) {
622 			(void) fprintf(stderr, "%s: %s: group '%s' unknown\n",
623 			    myname, fname, ep->group);
624 			return (1);
625 		}
626 		if (!set_user) {
627 			uid = -1;
628 		} else if (ep == NULL) {
629 			uid = 2;
630 		} else if ((uid = stdfind(ep->owner, usernames)) == -1) {
631 			(void) fprintf(stderr, "%s: %s: user '%s' unknown\n",
632 			    myname, fname, ep->owner);
633 			return (1);
634 		}
635 		if ((set_group && gid != -1 && gid != sbp->st_gid) ||
636 		    (set_user && uid != -1 && uid != sbp->st_uid)) {
637 			if (verbose) {
638 				const char *owner, *group;
639 
640 				owner = ep == NULL ? "root" : ep->owner;
641 				group = ep == NULL ? "bin" : ep->group;
642 				if (set_group && set_user) {
643 					(void) printf("chown %s:%s %s\n",
644 					    owner, group, fname);
645 				} else if (set_user) {
646 					(void) printf("chown %s %s\n", owner,
647 					    fname);
648 				} else {
649 					(void) printf("chgrp %s %s\n", group,
650 					    fname);
651 				}
652 			}
653 			if (lchown(fname, uid, gid) == -1) {
654 				perror(fname);
655 				return (1);
656 			}
657 		}
658 		perm = ep == NULL ? 0755 : ep->perm;
659 		if (set_perm && ((perm ^ sbp->st_mode) & ~S_IFMT) != 0) {
660 			if (verbose)
661 				(void) printf("chmod %lo %s\n", perm, fname);
662 			if (chmod(fname, perm) == -1) {
663 				perror(fname);
664 				return (1);
665 			}
666 		}
667 		return (0);
668 	case FTW_DNR:
669 	case FTW_NS:
670 		(void) fprintf(stderr, "%s: %s: permission denied\n",
671 		    myname, fname);
672 		return (1);
673 	case FTW_SL:
674 	case FTW_SLN:
675 		return (0);
676 	default:
677 		return (1);
678 	}
679 }
680 
681 int
682 main(int argc, char **argv)
683 {
684 	int	errflg = 0;
685 	int	i, c;
686 	int	list_filtered_exceptions = 0;
687 	int	n_proto_refs = 0;
688 	int	n_exception_files = 0;
689 	char	*proto_refs[MAX_PROTO_REFS];
690 	char	*exception_files[MAX_EXCEPTION_FILES];
691 	struct stat st_buf;
692 
693 	if ((myname = argv[0]) == NULL)
694 		myname = "protocmp";
695 
696 	while ((c = getopt(argc, argv, "gupGUPlmsLe:vd:")) != EOF) {
697 		switch (c) {
698 		case 's':
699 			check_sym = 0;
700 			break;
701 		case 'm':
702 			check_majmin = 0;
703 			break;
704 		case 'g':
705 			check_group = 0;
706 			break;
707 		case 'G':
708 			set_group = 1;
709 			break;
710 		case 'u':
711 			check_user = 0;
712 			break;
713 		case 'U':
714 			set_user = 1;
715 			break;
716 		case 'l':
717 			check_link = 0;
718 			break;
719 		case 'p':
720 			check_perm = 0;
721 			break;
722 		case 'P':
723 			set_perm = 1;
724 			break;
725 		case 'e':
726 			if (n_exception_files >= MAX_EXCEPTION_FILES) {
727 				errflg++;
728 				(void) fprintf(stderr,
729 				    "Only %d exception files supported\n",
730 				    MAX_EXCEPTION_FILES);
731 			} else {
732 				exception_files[n_exception_files++] = optarg;
733 			}
734 			break;
735 		case 'L':
736 			list_filtered_exceptions++;
737 			break;
738 		case 'v':
739 			verbose++;
740 			break;
741 		case 'd':
742 			if (n_proto_refs >= MAX_PROTO_REFS) {
743 				errflg++;
744 				(void) fprintf(stderr,
745 				    "Only %d proto references supported\n",
746 				    MAX_PROTO_REFS);
747 			} else {
748 				proto_refs[n_proto_refs++] = optarg;
749 			}
750 			break;
751 		case '?':
752 		default:
753 			errflg++;
754 			break;
755 		}
756 	}
757 
758 	if (argc == optind || n_proto_refs == 0) {
759 		usage();
760 		exit(1);
761 	}
762 
763 	if (set_group || set_user || set_perm) {
764 		if (optind != argc - 1) {
765 			usage();
766 			exit(1);
767 		}
768 		if (stat(argv[optind], &st_buf) == -1) {
769 			perror(argv[optind]);
770 			exit(1);
771 		}
772 		if (!S_ISDIR(st_buf.st_mode)) {
773 			(void) fprintf(stderr, "%s: %s: not a directory\n",
774 			    myname, argv[optind]);
775 			exit(1);
776 		}
777 	}
778 
779 	init_list(&first_list, HASH_SIZE);
780 	init_list(&second_list, HASH_SIZE);
781 	init_list(&exception_list, HASH_SIZE);
782 
783 	for (i = 0; i < n_exception_files; i++) {
784 		(void) read_in_exceptions(exception_files[i], verbose);
785 	}
786 
787 	for (i = 0; i < n_proto_refs; i++) {
788 		first_file_name = proto_refs[i];
789 		(void) read_in_file(first_file_name, &first_list);
790 	}
791 
792 	if (set_group || set_user || set_perm) {
793 		if (chdir(argv[optind]) == -1) {
794 			perror(argv[optind]);
795 			exit(1);
796 		}
797 		i = nftw(".", set_values, MAX_DEPTH, FTW_PHYS|FTW_DEPTH);
798 		if (i == -1) {
799 			perror("nftw");
800 			i = 1;
801 		}
802 		exit(i);
803 	}
804 
805 	for (i = optind; i < argc; i++) {
806 		second_file_name = argv[i];
807 		(void) read_in_file(second_file_name, &second_list);
808 	}
809 
810 	open_output_files();
811 
812 	if (verbose)
813 		(void) puts("comparing build to packages...");
814 
815 	check_first_vs_second(list_filtered_exceptions);
816 
817 	if (verbose)
818 		(void) puts("checking over packages...");
819 	check_second_vs_first(list_filtered_exceptions);
820 
821 	close_output_files();
822 
823 	print_results();
824 
825 	clean_up();
826 
827 	return (0);
828 }
829