usr/src/tools/findunref/findunref.c

   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 }