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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 *
21 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
22 * Use is subject to license terms.
23 */
24
25 /*
26 * Copyright (c) 2018, Joyent, Inc.
27 */
28
29 /*
30 * Finds all unreferenced files in a source tree that do not match a list of
31 * permitted pathnames.
32 */
33
34 #include <ctype.h>
35 #include <errno.h>
36 #include <fnmatch.h>
37 #include <ftw.h>
38 #include <stdarg.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <time.h>
43 #include <unistd.h>
44 #include <sys/param.h>
45 #include <sys/stat.h>
46 #include <sys/types.h>
47
48 /*
49 * Pathname set: a simple datatype for storing pathname pattern globs and
50 * for checking whether a given pathname is matched by a pattern glob in
51 * the set.
52 */
53 typedef struct {
54 char **paths;
55 unsigned int npath;
56 unsigned int maxpaths;
57 } pnset_t;
58
59 /*
60 * Data associated with the current SCM manifest.
61 */
62 typedef struct scmdata {
63 pnset_t *manifest;
64 char metapath[MAXPATHLEN];
65 char root[MAXPATHLEN];
66 unsigned int rootlen;
67 boolean_t rootwarn;
68 } scmdata_t;
69
70 /*
71 * Hooks used to check if a given unreferenced file is known to an SCM
72 * (currently Git, Mercurial and TeamWare).
73 */
74 typedef int checkscm_func_t(const char *, const struct FTW *);
75 typedef void chdirscm_func_t(const char *);
76
77 typedef struct {
78 const char *name;
79 checkscm_func_t *checkfunc;
80 chdirscm_func_t *chdirfunc;
81 } scm_t;
82
83 static checkscm_func_t check_tw, check_scmdata;
84 static chdirscm_func_t chdir_hg, chdir_git;
85 static int pnset_add(pnset_t *, const char *);
86 static int pnset_check(const pnset_t *, const char *);
87 static void pnset_empty(pnset_t *);
88 static void pnset_free(pnset_t *);
89 static int checkpath(const char *, const struct stat *, int, struct FTW *);
90 static pnset_t *make_exset(const char *);
91 static void warn(const char *, ...);
92 static void die(const char *, ...);
93
94 static const scm_t scms[] = {
95 { "tw", check_tw, NULL },
96 { "teamware", check_tw, NULL },
97 { "hg", check_scmdata, chdir_hg },
98 { "mercurial", check_scmdata, chdir_hg },
99 { "git", check_scmdata, chdir_git },
100 { NULL, NULL, NULL }
101 };
102
103 static const scm_t *scm;
104 static scmdata_t scmdata;
105 static time_t tstamp; /* timestamp to compare files to */
106 static pnset_t *exsetp; /* pathname globs to ignore */
107 static const char *progname;
108
109 int
110 main(int argc, char *argv[])
111 {
112 int c;
113 char path[MAXPATHLEN];
114 char subtree[MAXPATHLEN] = "./";
115 char *tstampfile = ".build.tstamp";
116 struct stat tsstat;
117
118 progname = strrchr(argv[0], '/');
119 if (progname == NULL)
120 progname = argv[0];
121 else
122 progname++;
123
124 while ((c = getopt(argc, argv, "as:t:S:")) != EOF) {
125 switch (c) {
126 case 'a':
127 /* for compatibility; now the default */
128 break;
129
130 case 's':
131 (void) strlcat(subtree, optarg, MAXPATHLEN);
132 break;
133
134 case 't':
135 tstampfile = optarg;
136 break;
137
138 case 'S':
139 for (scm = scms; scm->name != NULL; scm++) {
140 if (strcmp(scm->name, optarg) == 0)
141 break;
142 }
143 if (scm->name == NULL)
144 die("unsupported SCM `%s'\n", optarg);
145 break;
146
147 default:
148 case '?':
149 goto usage;
150 }
151 }
152
153 argc -= optind;
154 argv += optind;
155
156 if (argc != 2) {
157 usage: (void) fprintf(stderr, "usage: %s [-s <subtree>] "
158 "[-t <tstampfile>] [-S hg|tw|git] <srcroot> <exceptfile>\n",
159 progname);
160 return (EXIT_FAILURE);
161 }
162
163 /*
164 * Interpret a relative timestamp path as relative to srcroot.
165 */
166 if (tstampfile[0] == '/')
167 (void) strlcpy(path, tstampfile, MAXPATHLEN);
168 else
169 (void) snprintf(path, MAXPATHLEN, "%s/%s", argv[0], tstampfile);
170
171 if (stat(path, &tsstat) == -1)
172 die("cannot stat timestamp file \"%s\"", path);
173 tstamp = tsstat.st_mtime;
174
175 /*
176 * Create the exception pathname set.
177 */
178 exsetp = make_exset(argv[1]);
179 if (exsetp == NULL)
180 die("cannot make exception pathname set\n");
181
182 /*
183 * Walk the specified subtree of the tree rooted at argv[0].
184 */
185 if (chdir(argv[0]) == -1)
186 die("cannot change directory to \"%s\"", argv[0]);
187
188 if (nftw(subtree, checkpath, 100, FTW_PHYS) != 0)
189 die("cannot walk tree rooted at \"%s\"\n", argv[0]);
190
191 pnset_empty(exsetp);
192 return (EXIT_SUCCESS);
193 }
194
195 /*
196 * Load and return a pnset for the manifest for the Mercurial repo at `hgroot'.
197 */
198 static pnset_t *
199 hg_manifest(const char *hgroot)
200 {
201 FILE *fp = NULL;
202 char *hgcmd = NULL;
203 char *newline;
204 pnset_t *pnsetp;
205 char path[MAXPATHLEN];
206
207 pnsetp = calloc(1, sizeof (pnset_t));
208 if (pnsetp == NULL ||
209 asprintf(&hgcmd, "hg manifest -R %s", hgroot) == -1)
210 goto fail;
211
212 fp = popen(hgcmd, "r");
213 if (fp == NULL)
214 goto fail;
215
216 while (fgets(path, sizeof (path), fp) != NULL) {
217 newline = strrchr(path, '\n');
218 if (newline != NULL)
219 *newline = '\0';
220
221 if (pnset_add(pnsetp, path) == 0)
222 goto fail;
223 }
224
225 (void) pclose(fp);
226 free(hgcmd);
227 return (pnsetp);
228 fail:
229 warn("cannot load hg manifest at %s", hgroot);
230 if (fp != NULL)
231 (void) pclose(fp);
232 free(hgcmd);
233 pnset_free(pnsetp);
234 return (NULL);
235 }
236
237 /*
238 * Load and return a pnset for the manifest for the Git repo at `gitroot'.
239 */
240 static pnset_t *
241 git_manifest(const char *gitroot)
242 {
243 FILE *fp = NULL;
244 char *gitcmd = NULL;
245 char *newline;
246 pnset_t *pnsetp;
247 char path[MAXPATHLEN];
248
249 pnsetp = calloc(1, sizeof (pnset_t));
250 if (pnsetp == NULL ||
251 asprintf(&gitcmd, "git --git-dir=%s/.git ls-files", gitroot) == -1)
252 goto fail;
253
254 fp = popen(gitcmd, "r");
255 if (fp == NULL)
256 goto fail;
257
258 while (fgets(path, sizeof (path), fp) != NULL) {
259 newline = strrchr(path, '\n');
260 if (newline != NULL)
261 *newline = '\0';
262
263 if (pnset_add(pnsetp, path) == 0)
264 goto fail;
265 }
266
267 (void) pclose(fp);
268 free(gitcmd);
269 return (pnsetp);
270 fail:
271 warn("cannot load git manifest at %s", gitroot);
272 if (fp != NULL)
273 (void) pclose(fp);
274 free(gitcmd);
275 pnset_free(pnsetp);
276 return (NULL);
277 }
278
279 /*
280 * If necessary, change our active manifest to be appropriate for `path'.
281 */
282 static void
283 chdir_scmdata(const char *path, const char *meta,
284 pnset_t *(*manifest_func)(const char *path))
285 {
286 char scmpath[MAXPATHLEN];
287 char basepath[MAXPATHLEN];
288 char *slash;
289
290 (void) snprintf(scmpath, MAXPATHLEN, "%s/%s", path, meta);
291
292 /*
293 * Change our active manifest if any one of the following is true:
294 *
295 * 1. No manifest is loaded. Find the nearest SCM root to load from.
296 *
297 * 2. A manifest is loaded, but we've moved into a directory with
298 * its own metadata directory (e.g., usr/closed). Load from its
299 * root.
300 *
301 * 3. A manifest is loaded, but no longer applies (e.g., the manifest
302 * under usr/closed is loaded, but we've moved to usr/src).
303 */
304 if (scmdata.manifest == NULL ||
305 (strcmp(scmpath, scmdata.metapath) != 0 &&
306 access(scmpath, X_OK) == 0) ||
307 strncmp(path, scmdata.root, scmdata.rootlen - 1) != 0) {
308 pnset_free(scmdata.manifest);
309 scmdata.manifest = NULL;
310
311 (void) strlcpy(basepath, path, MAXPATHLEN);
312
313 /*
314 * Walk up the directory tree looking for metadata
315 * subdirectories.
316 */
317 while (access(scmpath, X_OK) == -1) {
318 slash = strrchr(basepath, '/');
319 if (slash == NULL) {
320 if (!scmdata.rootwarn) {
321 warn("no metadata directory "
322 "for \"%s\"\n", path);
323 scmdata.rootwarn = B_TRUE;
324 }
325 return;
326 }
327 *slash = '\0';
328 (void) snprintf(scmpath, MAXPATHLEN, "%s/%s", basepath,
329 meta);
330 }
331
332 /*
333 * We found a directory with an SCM metadata directory; record
334 * it and load its manifest.
335 */
336 (void) strlcpy(scmdata.metapath, scmpath, MAXPATHLEN);
337 (void) strlcpy(scmdata.root, basepath, MAXPATHLEN);
338 scmdata.manifest = manifest_func(scmdata.root);
339
340 /*
341 * The logic in check_scmdata() depends on scmdata.root having
342 * a single trailing slash, so only add it if it's missing.
343 */
344 if (scmdata.root[strlen(scmdata.root) - 1] != '/')
345 (void) strlcat(scmdata.root, "/", MAXPATHLEN);
346 scmdata.rootlen = strlen(scmdata.root);
347 }
348 }
349
350 /*
351 * If necessary, change our active manifest to be appropriate for `path'.
352 */
353 static void
354 chdir_git(const char *path)
355 {
356 chdir_scmdata(path, ".git", git_manifest);
357 }
358
359 static void
360 chdir_hg(const char *path)
361 {
362 chdir_scmdata(path, ".hg", hg_manifest);
363 }
364
365 /* ARGSUSED */
366 static int
367 check_scmdata(const char *path, const struct FTW *ftwp)
368 {
369 /*
370 * The manifest paths are relative to the manifest root; skip past it.
371 */
372 path += scmdata.rootlen;
373
374 return (scmdata.manifest != NULL && pnset_check(scmdata.manifest,
375 path));
376 }
377
378 /*
379 * Check if a file is under TeamWare control by checking for its corresponding
380 * SCCS "s-dot" file.
381 */
382 static int
383 check_tw(const char *path, const struct FTW *ftwp)
384 {
385 char sccspath[MAXPATHLEN];
386
387 (void) snprintf(sccspath, MAXPATHLEN, "%.*s/SCCS/s.%s", ftwp->base,
388 path, path + ftwp->base);
389
390 return (access(sccspath, F_OK) == 0);
391 }
392
393 /*
394 * Using `exceptfile' and a built-in list of exceptions, build and return a
395 * pnset_t consisting of all of the pathnames globs which are allowed to be
396 * unreferenced in the source tree.
397 */
398 static pnset_t *
399 make_exset(const char *exceptfile)
400 {
401 FILE *fp;
402 char line[MAXPATHLEN];
403 char *newline;
404 pnset_t *pnsetp;
405 unsigned int i;
406
407 pnsetp = calloc(1, sizeof (pnset_t));
408 if (pnsetp == NULL)
409 return (NULL);
410
411 /*
412 * Add any exceptions from the file.
413 */
414 fp = fopen(exceptfile, "r");
415 if (fp == NULL) {
416 warn("cannot open exception file \"%s\"", exceptfile);
417 goto fail;
418 }
419
420 while (fgets(line, sizeof (line), fp) != NULL) {
421 newline = strrchr(line, '\n');
422 if (newline != NULL)
423 *newline = '\0';
424
425 for (i = 0; isspace(line[i]); i++)
426 ;
427
428 if (line[i] == '#' || line[i] == '\0')
429 continue;
430
431 if (pnset_add(pnsetp, line) == 0) {
432 (void) fclose(fp);
433 goto fail;
434 }
435 }
436
437 (void) fclose(fp);
438 return (pnsetp);
439 fail:
440 pnset_free(pnsetp);
441 return (NULL);
442 }
443
444 /*
445 * FTW callback: print `path' if it's older than `tstamp' and not in `exsetp'.
446 */
447 static int
448 checkpath(const char *path, const struct stat *statp, int type,
449 struct FTW *ftwp)
450 {
451 switch (type) {
452 case FTW_F:
453 /*
454 * Skip if the file is referenced or in the exception list.
455 */
456 if (statp->st_atime >= tstamp || pnset_check(exsetp, path))
457 return (0);
458
459 /*
460 * If requested, restrict ourselves to unreferenced files
461 * under SCM control.
462 */
463 if (scm == NULL || scm->checkfunc(path, ftwp))
464 (void) puts(path);
465 return (0);
466
467 case FTW_D:
468 /*
469 * Prune any directories in the exception list.
470 */
471 if (pnset_check(exsetp, path)) {
472 ftwp->quit = FTW_PRUNE;
473 return (0);
474 }
475
476 /*
477 * If necessary, advise the SCM logic of our new directory.
478 */
479 if (scm != NULL && scm->chdirfunc != NULL)
480 scm->chdirfunc(path);
481
482 return (0);
483
484 case FTW_DNR:
485 warn("cannot read \"%s\"", path);
486 return (0);
487
488 case FTW_NS:
489 warn("cannot stat \"%s\"", path);
490 return (0);
491
492 default:
493 break;
494 }
495
496 return (0);
497 }
498
499 /*
500 * Add `path' to the pnset_t pointed to by `pnsetp'.
501 */
502 static int
503 pnset_add(pnset_t *pnsetp, const char *path)
504 {
505 char **newpaths;
506 unsigned int maxpaths;
507
508 if (pnsetp->npath == pnsetp->maxpaths) {
509 maxpaths = (pnsetp->maxpaths == 0) ? 512 : pnsetp->maxpaths * 2;
510 newpaths = realloc(pnsetp->paths, sizeof (char *) * maxpaths);
511 if (newpaths == NULL)
512 return (0);
513 pnsetp->paths = newpaths;
514 pnsetp->maxpaths = maxpaths;
515 }
516
517 pnsetp->paths[pnsetp->npath] = strdup(path);
518 if (pnsetp->paths[pnsetp->npath] == NULL)
519 return (0);
520
521 pnsetp->npath++;
522 return (1);
523 }
524
525 /*
526 * Check `path' against the pnset_t pointed to by `pnsetp'.
527 */
528 static int
529 pnset_check(const pnset_t *pnsetp, const char *path)
530 {
531 unsigned int i;
532
533 for (i = 0; i < pnsetp->npath; i++) {
534 if (fnmatch(pnsetp->paths[i], path, 0) == 0)
535 return (1);
536 }
537 return (0);
538 }
539
540 /*
541 * Empty the pnset_t pointed to by `pnsetp'.
542 */
543 static void
544 pnset_empty(pnset_t *pnsetp)
545 {
546 while (pnsetp->npath-- != 0)
547 free(pnsetp->paths[pnsetp->npath]);
548
549 free(pnsetp->paths);
550 pnsetp->maxpaths = 0;
551 }
552
553 /*
554 * Free the pnset_t pointed to by `pnsetp'.
555 */
556 static void
557 pnset_free(pnset_t *pnsetp)
558 {
559 if (pnsetp != NULL) {
560 pnset_empty(pnsetp);
561 free(pnsetp);
562 }
563 }
564
565 /* PRINTFLIKE1 */
566 static void
567 warn(const char *format, ...)
568 {
569 va_list alist;
570 char *errstr = strerror(errno);
571
572 if (errstr == NULL)
573 errstr = "<unknown error>";
574
575 (void) fprintf(stderr, "%s: ", progname);
576
577 va_start(alist, format);
578 (void) vfprintf(stderr, format, alist);
579 va_end(alist);
580
581 if (strrchr(format, '\n') == NULL)
582 (void) fprintf(stderr, ": %s\n", errstr);
583 }
584
585 /* PRINTFLIKE1 */
586 static void
587 die(const char *format, ...)
588 {
589 va_list alist;
590 char *errstr = strerror(errno);
591
592 if (errstr == NULL)
593 errstr = "<unknown error>";
594
595 (void) fprintf(stderr, "%s: fatal: ", progname);
596
597 va_start(alist, format);
598 (void) vfprintf(stderr, format, alist);
599 va_end(alist);
600
601 if (strrchr(format, '\n') == NULL)
602 (void) fprintf(stderr, ": %s\n", errstr);
603
604 exit(EXIT_FAILURE);
605 }