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