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