misc-utils/whereis.c

   1 /*-
   2  * Copyright (c) 1980 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
  34  * - added Native Language Support
  35  * 2011-08-12 Davidlohr Bueso <dave@gnu.org>
  36  * - added $PATH lookup
  37  *
  38  * Copyright (C) 2013 Karel Zak <kzak@redhat.com>
  39  *               2013 Sami Kerola <kerolasa@iki.fi>
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45 #include <dirent.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <ctype.h>
  50 #include <assert.h>
  51 #ifdef HAVE_FNMATCH
  52 # include <fnmatch.h>
  53 #endif
  54
  55 #include "xalloc.h"
  56 #include "nls.h"
  57 #include "c.h"
  58 #include "closestream.h"
  59 #include "canonicalize.h"
  60
  61 #include "debug.h"
  62
  63 static UL_DEBUG_DEFINE_MASK(whereis);
  64 UL_DEBUG_DEFINE_MASKNAMES(whereis) = UL_DEBUG_EMPTY_MASKNAMES;
  65
  66 #define WHEREIS_DEBUG_INIT      (1 << 1)
  67 #define WHEREIS_DEBUG_PATH      (1 << 2)
  68 #define WHEREIS_DEBUG_ENV       (1 << 3)
  69 #define WHEREIS_DEBUG_ARGV      (1 << 4)
  70 #define WHEREIS_DEBUG_SEARCH    (1 << 5)
  71 #define WHEREIS_DEBUG_STATIC    (1 << 6)
  72 #define WHEREIS_DEBUG_LIST      (1 << 7)
  73 #define WHEREIS_DEBUG_ALL       0xFFFF
  74
  75 #define DBG(m, x)       __UL_DBG(whereis, WHEREIS_DEBUG_, m, x)
  76 #define ON_DBG(m, x)    __UL_DBG_CALL(whereis, WHEREIS_DEBUG_, m, x)
  77
  78 #define UL_DEBUG_CURRENT_MASK   UL_DEBUG_MASK(whereis)
  79 #include "debugobj.h"
  80
  81 static char uflag;
  82 static char use_glob;
  83
  84 /* supported types */
  85 enum {
  86         BIN_DIR = (1 << 1),
  87         MAN_DIR = (1 << 2),
  88         SRC_DIR = (1 << 3),
  89
  90         ALL_DIRS = BIN_DIR | MAN_DIR | SRC_DIR
  91 };
  92
  93 /* directories */
  94 struct wh_dirlist {
  95         int     type;
  96         dev_t   st_dev;
  97         ino_t   st_ino;
  98         char    *path;
  99
 100         struct wh_dirlist *next;
 101 };
 102
 103 static const char *bindirs[] = {
 104         "/usr/bin",
 105         "/usr/sbin",
 106         "/bin",
 107         "/sbin",
 108 #if defined(MULTIARCHTRIPLET)
 109         "/lib/" MULTIARCHTRIPLET,
 110         "/usr/lib/" MULTIARCHTRIPLET,
 111         "/usr/local/lib/" MULTIARCHTRIPLET,
 112 #endif
 113         "/usr/lib",
 114         "/usr/lib32",
 115         "/usr/lib64",
 116         "/etc",
 117         "/usr/etc",
 118         "/lib",
 119         "/lib32",
 120         "/lib64",
 121         "/usr/games",
 122         "/usr/games/bin",
 123         "/usr/games/lib",
 124         "/usr/emacs/etc",
 125         "/usr/lib/emacs/*/etc",
 126         "/usr/TeX/bin",
 127         "/usr/tex/bin",
 128         "/usr/interviews/bin/LINUX",
 129
 130         "/usr/X11R6/bin",
 131         "/usr/X386/bin",
 132         "/usr/bin/X11",
 133         "/usr/X11/bin",
 134         "/usr/X11R5/bin",
 135
 136         "/usr/local/bin",
 137         "/usr/local/sbin",
 138         "/usr/local/etc",
 139         "/usr/local/lib",
 140         "/usr/local/games",
 141         "/usr/local/games/bin",
 142         "/usr/local/emacs/etc",
 143         "/usr/local/TeX/bin",
 144         "/usr/local/tex/bin",
 145         "/usr/local/bin/X11",
 146
 147         "/usr/contrib",
 148         "/usr/hosts",
 149         "/usr/include",
 150
 151         "/usr/g++-include",
 152
 153         "/usr/ucb",
 154         "/usr/old",
 155         "/usr/new",
 156         "/usr/local",
 157         "/usr/libexec",
 158         "/usr/share",
 159
 160         "/opt/*/bin",
 161         NULL
 162 };
 163
 164 static const char *mandirs[] = {
 165         "/usr/man/*",
 166         "/usr/share/man/*",
 167         "/usr/X386/man/*",
 168         "/usr/X11/man/*",
 169         "/usr/TeX/man/*",
 170         "/usr/interviews/man/mann",
 171         "/usr/share/info",
 172         NULL
 173 };
 174
 175 static const char *srcdirs[] = {
 176         "/usr/src/*",
 177         "/usr/src/lib/libc/*",
 178         "/usr/src/lib/libc/net/*",
 179         "/usr/src/ucb/pascal",
 180         "/usr/src/ucb/pascal/utilities",
 181         "/usr/src/undoc",
 182         NULL
 183 };
 184
 185 static void whereis_init_debug(void)
 186 {
 187         __UL_INIT_DEBUG_FROM_ENV(whereis, WHEREIS_DEBUG_, 0, WHEREIS_DEBUG);
 188 }
 189
 190 static const char *whereis_type_to_name(int type)
 191 {
 192         switch (type) {
 193         case BIN_DIR: return "bin";
 194         case MAN_DIR: return "man";
 195         case SRC_DIR: return "src";
 196         default:      return "???";
 197         }
 198 }
 199
 200 static void __attribute__((__noreturn__)) usage(void)
 201 {
 202         FILE *out = stdout;
 203
 204         fputs(USAGE_HEADER, out);
 205         fprintf(out, _(" %s [options] [-BMS <dir>... -f] <name>\n"), program_invocation_short_name);
 206
 207         fputs(USAGE_SEPARATOR, out);
 208         fputs(_("Locate the binary, source, and manual-page files for a command.\n"), out);
 209
 210         fputs(USAGE_OPTIONS, out);
 211         fputs(_(" -b         search only for binaries\n"), out);
 212         fputs(_(" -B <dirs>  define binaries lookup path\n"), out);
 213         fputs(_(" -m         search only for manuals and infos\n"), out);
 214         fputs(_(" -M <dirs>  define man and info lookup path\n"), out);
 215         fputs(_(" -s         search only for sources\n"), out);
 216         fputs(_(" -S <dirs>  define sources lookup path\n"), out);
 217         fputs(_(" -f         terminate <dirs> argument list\n"), out);
 218         fputs(_(" -u         search for unusual entries\n"), out);
 219         fputs(_(" -g         interpret name as glob (pathnames pattern)\n"), out);
 220         fputs(_(" -l         output effective lookup paths\n"), out);
 221
 222         fputs(USAGE_SEPARATOR, out);
 223         fprintf(out, USAGE_HELP_OPTIONS(16));
 224         fprintf(out, USAGE_MAN_TAIL("whereis(1)"));
 225         exit(EXIT_SUCCESS);
 226 }
 227
 228 static void dirlist_add_dir(struct wh_dirlist **ls0, int type, const char *dir)
 229 {
 230         struct stat st;
 231         struct wh_dirlist *prev = NULL, *ls = *ls0;
 232
 233         if (access(dir, R_OK) != 0)
 234                 return;
 235         if (stat(dir, &st) != 0 || !S_ISDIR(st.st_mode))
 236                 return;
 237
 238         while (ls) {
 239                 if (ls->st_ino == st.st_ino &&
 240                     ls->st_dev == st.st_dev &&
 241                     ls->type == type) {
 242                         DBG(LIST, ul_debugobj(*ls0, "  ignore (already in list): %s", dir));
 243                         return;
 244                 }
 245                 prev = ls;
 246                 ls = ls->next;
 247         }
 248
 249
 250         ls = xcalloc(1, sizeof(*ls));
 251         ls->st_ino = st.st_ino;
 252         ls->st_dev = st.st_dev;
 253         ls->type = type;
 254         ls->path = canonicalize_path(dir);
 255
 256         if (!*ls0)
 257                 *ls0 = ls;              /* first in the list */
 258         else {
 259                 assert(prev);
 260                 prev->next = ls;        /* add to the end of the list */
 261         }
 262
 263         DBG(LIST, ul_debugobj(*ls0, "  add dir: %s", ls->path));
 264 }
 265
 266 /* special case for '*' in the paths */
 267 static void dirlist_add_subdir(struct wh_dirlist **ls, int type, const char *dir)
 268 {
 269         char buf[PATH_MAX], *d;
 270         DIR *dirp;
 271         struct dirent *dp;
 272         char *postfix;
 273         size_t len;
 274
 275         postfix = strchr(dir, '*');
 276         if (!postfix)
 277                 goto ignore;
 278
 279         /* copy begin of the path to the buffer (part before '*') */
 280         len = (postfix - dir) + 1;
 281         xstrncpy(buf, dir, len);
 282
 283         /* remember place where to append subdirs */
 284         d = buf + len - 1;
 285
 286         /* skip '*' */
 287         postfix++;
 288         if (!*postfix)
 289                 postfix = NULL;
 290
 291         /* open parental dir t scan */
 292         dirp = opendir(buf);
 293         if (!dirp)
 294                 goto ignore;
 295
 296         DBG(LIST, ul_debugobj(*ls, " scanning subdirs: %s [%s<subdir>%s]",
 297                                 dir, buf, postfix ? postfix : ""));
 298
 299         while ((dp = readdir(dirp)) != NULL) {
 300                 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
 301                         continue;
 302                 if (postfix)
 303                         snprintf(d, PATH_MAX - len, "%s%s", dp->d_name, postfix);
 304                 else
 305                         snprintf(d, PATH_MAX - len, "%s", dp->d_name);
 306
 307                 dirlist_add_dir(ls, type, buf);
 308         }
 309         closedir(dirp);
 310         return;
 311 ignore:
 312         DBG(LIST, ul_debugobj(*ls, " ignore path: %s", dir));
 313 }
 314
 315 static void construct_dirlist_from_env(const char *env,
 316                                        struct wh_dirlist **ls,
 317                                        int type)
 318 {
 319         char *key = NULL, *tok = NULL, *pathcp, *path = getenv(env);
 320
 321         if (!path)
 322                 return;
 323         pathcp = xstrdup(path);
 324
 325         DBG(ENV, ul_debugobj(*ls, "construct %s dirlist from: %s",
 326                                 whereis_type_to_name(type), path));
 327
 328         for (tok = strtok_r(pathcp, ":", &key); tok;
 329              tok = strtok_r(NULL, ":", &key))
 330                 dirlist_add_dir(ls, type, tok);
 331
 332         free(pathcp);
 333 }
 334
 335 static void construct_dirlist_from_argv(struct wh_dirlist **ls,
 336                                         int *idx,
 337                                         int argc,
 338                                         char *argv[],
 339                                         int type)
 340 {
 341         int i;
 342
 343         DBG(ARGV, ul_debugobj(*ls, "construct %s dirlist from argv[%d..]",
 344                                 whereis_type_to_name(type), *idx));
 345
 346         for (i = *idx; i < argc; i++) {
 347                 if (*argv[i] == '-')                    /* end of the list */
 348                         break;
 349
 350                 DBG(ARGV, ul_debugobj(*ls, "  using argv[%d]: %s", *idx, argv[*idx]));
 351                 dirlist_add_dir(ls, type, argv[i]);
 352                 *idx = i;
 353         }
 354 }
 355
 356 static void construct_dirlist(struct wh_dirlist **ls,
 357                               int type,
 358                               const char **paths)
 359 {
 360         size_t i;
 361
 362         DBG(STATIC, ul_debugobj(*ls, "construct %s dirlist from static array",
 363                                 whereis_type_to_name(type)));
 364
 365         for (i = 0; paths[i]; i++) {
 366                 if (!strchr(paths[i], '*'))
 367                         dirlist_add_dir(ls, type, paths[i]);
 368                 else
 369                         dirlist_add_subdir(ls, type, paths[i]);
 370         }
 371 }
 372
 373 static void free_dirlist(struct wh_dirlist **ls0, int type)
 374 {
 375         struct wh_dirlist *prev = NULL, *next, *ls = *ls0;
 376
 377         *ls0 = NULL;
 378
 379         DBG(LIST, ul_debugobj(*ls0, "free dirlist"));
 380
 381         while (ls) {
 382                 if (ls->type & type) {
 383                         next = ls->next;
 384                         DBG(LIST, ul_debugobj(*ls0, " free: %s", ls->path));
 385                         free(ls->path);
 386                         free(ls);
 387                         ls = next;
 388                         if (prev)
 389                                 prev->next = ls;
 390                 } else {
 391                         if (!prev)
 392                                 *ls0 = ls;      /* first unremoved */
 393                         prev = ls;
 394                         ls = ls->next;
 395                 }
 396         }
 397 }
 398
 399
 400 static int filename_equal(const char *cp, const char *dp, int type)
 401 {
 402         size_t i;
 403
 404         DBG(SEARCH, ul_debug("compare '%s' and '%s'", cp, dp));
 405
 406 #ifdef HAVE_FNMATCH
 407         if (use_glob)
 408                 return fnmatch(cp, dp, 0) == 0;
 409 #endif
 410         if (type & SRC_DIR &&
 411             dp[0] == 's' && dp[1] == '.' && filename_equal(cp, dp + 2, type))
 412                 return 1;
 413
 414         i = strlen(dp);
 415
 416         if (type & MAN_DIR) {
 417                 if (i > 1 && !strcmp(dp + i - 2, ".Z"))
 418                         i -= 2;
 419                 else if (i > 2 && !strcmp(dp + i - 3, ".gz"))
 420                         i -= 3;
 421                 else if (i > 2 && !strcmp(dp + i - 3, ".xz"))
 422                         i -= 3;
 423                 else if (i > 3 && !strcmp(dp + i - 4, ".bz2"))
 424                         i -= 4;
 425                 else if (i > 3 && !strcmp(dp + i - 4, ".zst"))
 426                         i -= 4;
 427         }
 428         while (*cp && *dp && *cp == *dp)
 429                 cp++, dp++, i--;
 430         if (*cp == 0 && *dp == 0)
 431                 return 1;
 432         if (!(type & BIN_DIR) && *cp == 0 && *dp++ == '.') {
 433                 --i;
 434                 while (i > 0 && *dp)
 435                         if (--i, *dp++ == '.')
 436                                 return (*dp++ == 'C' && *dp++ == 0);
 437                 return 1;
 438         }
 439         return 0;
 440 }
 441
 442 static void findin(const char *dir, const char *pattern, int *count,
 443                    char **wait, int type)
 444 {
 445         DIR *dirp;
 446         struct dirent *dp;
 447
 448         dirp = opendir(dir);
 449         if (dirp == NULL)
 450                 return;
 451
 452         DBG(SEARCH, ul_debug("find '%s' in '%s'", pattern, dir));
 453
 454         while ((dp = readdir(dirp)) != NULL) {
 455                 if (!filename_equal(pattern, dp->d_name, type))
 456                         continue;
 457
 458                 if (uflag && *count == 0)
 459                         xasprintf(wait, "%s/%s", dir, dp->d_name);
 460
 461                 else if (uflag && *count == 1 && *wait) {
 462                         printf("%s: %s %s/%s", pattern, *wait, dir,  dp->d_name);
 463                         free(*wait);
 464                         *wait = NULL;
 465                 } else
 466                         printf(" %s/%s", dir, dp->d_name);
 467                 ++(*count);
 468         }
 469         closedir(dirp);
 470 }
 471
 472 static void lookup(const char *pattern, struct wh_dirlist *ls, int want)
 473 {
 474         char patbuf[PATH_MAX];
 475         int count = 0;
 476         char *wait = NULL, *p;
 477
 478         /* canonicalize pattern -- remove path suffix etc. */
 479         p = strrchr(pattern, '/');
 480         p = p ? p + 1 : (char *) pattern;
 481         xstrncpy(patbuf, p, PATH_MAX);
 482
 483         DBG(SEARCH, ul_debug("lookup dirs for '%s' (%s), want: %s %s %s",
 484                                 patbuf, pattern,
 485                                 want & BIN_DIR ? "bin" : "",
 486                                 want & MAN_DIR ? "man" : "",
 487                                 want & SRC_DIR ? "src" : ""));
 488
 489         if (!uflag)
 490                 /* if -u not specified then we always print the pattern */
 491                 printf("%s:", patbuf);
 492
 493         for (; ls; ls = ls->next) {
 494                 if ((ls->type & want) && ls->path)
 495                         findin(ls->path, patbuf, &count, &wait, ls->type);
 496         }
 497
 498         free(wait);
 499
 500         if (!uflag || count > 1)
 501                 putchar('\n');
 502 }
 503
 504 static void list_dirlist(struct wh_dirlist *ls)
 505 {
 506         while (ls) {
 507                 if (ls->path) {
 508                         switch (ls->type) {
 509                         case BIN_DIR:
 510                                 printf("bin: ");
 511                                 break;
 512                         case MAN_DIR:
 513                                 printf("man: ");
 514                                 break;
 515                         case SRC_DIR:
 516                                 printf("src: ");
 517                                 break;
 518                         default:
 519                                 abort();
 520                         }
 521                         printf("%s\n", ls->path);
 522                 }
 523                 ls = ls->next;
 524         }
 525 }
 526
 527 int main(int argc, char **argv)
 528 {
 529         struct wh_dirlist *ls = NULL;
 530         int want = ALL_DIRS;
 531         int i, want_resetable = 0, opt_f_missing = 0;
 532
 533         setlocale(LC_ALL, "");
 534         bindtextdomain(PACKAGE, LOCALEDIR);
 535         textdomain(PACKAGE);
 536         close_stdout_atexit();
 537
 538         if (argc <= 1) {
 539                 warnx(_("not enough arguments"));
 540                 errtryhelp(EXIT_FAILURE);
 541         } else {
 542                 /* first arg may be one of our standard longopts */
 543                 if (!strcmp(argv[1], "--help"))
 544                         usage();
 545                 if (!strcmp(argv[1], "--version"))
 546                         print_version(EXIT_SUCCESS);
 547         }
 548
 549         whereis_init_debug();
 550
 551         construct_dirlist(&ls, BIN_DIR, bindirs);
 552         construct_dirlist_from_env("PATH", &ls, BIN_DIR);
 553
 554         construct_dirlist(&ls, MAN_DIR, mandirs);
 555         construct_dirlist_from_env("MANPATH", &ls, MAN_DIR);
 556
 557         construct_dirlist(&ls, SRC_DIR, srcdirs);
 558
 559         for (i = 1; i < argc; i++) {
 560                 const char *arg = argv[i];
 561                 int arg_i = i;
 562
 563                 DBG(ARGV, ul_debug("argv[%d]: %s", i, arg));
 564
 565                 if (*arg != '-') {
 566                         lookup(arg, ls, want);
 567                         /*
 568                          * The lookup mask ("want") is cumulative and it's
 569                          * resettable only when it has been already used.
 570                          *
 571                          *  whereis -b -m foo     :'foo' mask=BIN|MAN
 572                          *  whereis -b foo bar    :'foo' and 'bar' mask=BIN|MAN
 573                          *  whereis -b foo -m bar :'foo' mask=BIN; 'bar' mask=MAN
 574                          */
 575                         want_resetable = 1;
 576                         continue;
 577                 }
 578
 579                 for (++arg; arg && *arg; arg++) {
 580                         DBG(ARGV, ul_debug("  arg: %s", arg));
 581
 582                         switch (*arg) {
 583                         case 'f':
 584                                 opt_f_missing = 0;
 585                                 break;
 586                         case 'u':
 587                                 uflag = 1;
 588                                 opt_f_missing = 0;
 589                                 break;
 590                         case 'B':
 591                                 if (*(arg + 1)) {
 592                                         warnx(_("bad usage"));
 593                                         errtryhelp(EXIT_FAILURE);
 594                                 }
 595                                 i++;
 596                                 free_dirlist(&ls, BIN_DIR);
 597                                 construct_dirlist_from_argv(
 598                                         &ls, &i, argc, argv, BIN_DIR);
 599                                 opt_f_missing = 1;
 600                                 break;
 601                         case 'M':
 602                                 if (*(arg + 1)) {
 603                                         warnx(_("bad usage"));
 604                                         errtryhelp(EXIT_FAILURE);
 605                                 }
 606                                 i++;
 607                                 free_dirlist(&ls, MAN_DIR);
 608                                 construct_dirlist_from_argv(
 609                                         &ls, &i, argc, argv, MAN_DIR);
 610                                 opt_f_missing = 1;
 611                                 break;
 612                         case 'S':
 613                                 if (*(arg + 1)) {
 614                                         warnx(_("bad usage"));
 615                                         errtryhelp(EXIT_FAILURE);
 616                                 }
 617                                 i++;
 618                                 free_dirlist(&ls, SRC_DIR);
 619                                 construct_dirlist_from_argv(
 620                                         &ls, &i, argc, argv, SRC_DIR);
 621                                 opt_f_missing = 1;
 622                                 break;
 623                         case 'b':
 624                                 if (want_resetable) {
 625                                         want = ALL_DIRS;
 626                                         want_resetable = 0;
 627                                 }
 628                                 want = want == ALL_DIRS ? BIN_DIR : want | BIN_DIR;
 629                                 opt_f_missing = 0;
 630                                 break;
 631                         case 'm':
 632                                 if (want_resetable) {
 633                                         want = ALL_DIRS;
 634                                         want_resetable = 0;
 635                                 }
 636                                 want = want == ALL_DIRS ? MAN_DIR : want | MAN_DIR;
 637                                 opt_f_missing = 0;
 638                                 break;
 639                         case 's':
 640                                 if (want_resetable) {
 641                                         want = ALL_DIRS;
 642                                         want_resetable = 0;
 643                                 }
 644                                 want = want == ALL_DIRS ? SRC_DIR : want | SRC_DIR;
 645                                 opt_f_missing = 0;
 646                                 break;
 647                         case 'l':
 648                                 list_dirlist(ls);
 649                                 break;
 650                         case 'g':
 651                                 use_glob = 1;
 652                                 break;
 653
 654                         case 'V':
 655                                 print_version(EXIT_SUCCESS);
 656                         case 'h':
 657                                 usage();
 658                         default:
 659                                 warnx(_("bad usage"));
 660                                 errtryhelp(EXIT_FAILURE);
 661                         }
 662
 663                         if (arg_i < i)          /* moved to the next argv[] item */
 664                                 break;
 665                 }
 666         }
 667
 668         free_dirlist(&ls, ALL_DIRS);
 669         if (opt_f_missing)
 670                 errx(EXIT_FAILURE, _("option -f is missing"));
 671         return EXIT_SUCCESS;
 672 }