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