git.gag.com Git - debian/sudo/blob - compat/glob.c

   1 /*
   2  * Copyright (c) 2008-2010 Todd C. Miller <Todd.Miller@courtesan.com>
   3  * Copyright (c) 1989, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Guido van Rossum.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. 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  *      @(#)glob.c      8.3 (Berkeley) 10/13/93
  34  */
  35
  36 /*
  37  * glob(3) -- a superset of the one defined in POSIX 1003.2.
  38  *
  39  * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
  40  *
  41  * Optional extra services, controlled by flags not defined by POSIX:
  42  *
  43  * GLOB_MAGCHAR:
  44  *      Set in gl_flags if pattern contained a globbing character.
  45  * GLOB_TILDE:
  46  *      expand ~user/foo to the /home/dir/of/user/foo
  47  * GLOB_BRACE:
  48  *      expand {1,2}{a,b} to 1a 1b 2a 2b
  49  * gl_matchc:
  50  *      Number of matches in the current invocation of glob.
  51  */
  52
  53 #include <config.h>
  54
  55 #include <sys/param.h>
  56 #include <sys/stat.h>
  57
  58 #include <stdio.h>
  59 #ifdef STDC_HEADERS
  60 # include <stdlib.h>
  61 # include <stddef.h>
  62 #else
  63 # ifdef HAVE_STDLIB_H
  64 #  include <stdlib.h>
  65 # endif
  66 #endif /* STDC_HEADERS */
  67 #if defined(HAVE_MALLOC_H) && !defined(STDC_HEADERS)
  68 # include <malloc.h>
  69 #endif /* HAVE_MALLOC_H && !STDC_HEADERS */
  70 #ifdef HAVE_STRING_H
  71 # include <string.h>
  72 #endif /* HAVE_STRING_H */
  73 #ifdef HAVE_STRINGS_H
  74 # include <strings.h>
  75 #endif /* HAVE_STRINGS_H */
  76 #ifdef HAVE_UNISTD_H
  77 # include <unistd.h>
  78 #endif /* HAVE_UNISTD_H */
  79 #include <ctype.h>
  80 #ifdef HAVE_DIRENT_H
  81 # include <dirent.h>
  82 #else
  83 # define dirent direct
  84 # ifdef HAVE_SYS_NDIR_H
  85 #  include <sys/ndir.h>
  86 # endif
  87 # ifdef HAVE_SYS_DIR_H
  88 #  include <sys/dir.h>
  89 # endif
  90 # ifdef HAVE_NDIR_H
  91 #  include <ndir.h>
  92 # endif
  93 #endif
  94 #include <errno.h>
  95 #include <limits.h>
  96 #include <pwd.h>
  97
  98 #include "missing.h"
  99 #include "compat/glob.h"
 100 #include "compat/charclass.h"
 101
 102 #define DOLLAR          '$'
 103 #define DOT             '.'
 104 #define EOS             '\0'
 105 #define LBRACKET        '['
 106 #define NOT             '!'
 107 #define QUESTION        '?'
 108 #define QUOTE           '\\'
 109 #define RANGE           '-'
 110 #define RBRACKET        ']'
 111 #define SEP             '/'
 112 #define STAR            '*'
 113 #define TILDE           '~'
 114 #define UNDERSCORE      '_'
 115 #define LBRACE          '{'
 116 #define RBRACE          '}'
 117 #define SLASH           '/'
 118 #define COMMA           ','
 119
 120 #ifndef DEBUG
 121
 122 #define M_QUOTE         0x8000
 123 #define M_PROTECT       0x4000
 124 #define M_MASK          0xffff
 125 #define M_ASCII         0x00ff
 126
 127 typedef unsigned short Char;
 128
 129 #else
 130
 131 #define M_QUOTE         0x80
 132 #define M_PROTECT       0x40
 133 #define M_MASK          0xff
 134 #define M_ASCII         0x7f
 135
 136 typedef char Char;
 137
 138 #endif
 139
 140
 141 #define CHAR(c)         ((Char)((c)&M_ASCII))
 142 #define META(c)         ((Char)((c)|M_QUOTE))
 143 #define M_ALL           META('*')
 144 #define M_END           META(']')
 145 #define M_NOT           META('!')
 146 #define M_ONE           META('?')
 147 #define M_RNG           META('-')
 148 #define M_SET           META('[')
 149 #define M_CLASS         META(':')
 150 #define ismeta(c)       (((c)&M_QUOTE) != 0)
 151
 152
 153 static int       compare(const void *, const void *);
 154 static int       g_Ctoc(const Char *, char *, unsigned int);
 155 static int       g_lstat(Char *, struct stat *, glob_t *);
 156 static DIR      *g_opendir(Char *, glob_t *);
 157 static Char     *g_strchr(const Char *, int);
 158 static int       g_strncmp(const Char *, const char *, size_t);
 159 static int       g_stat(Char *, struct stat *, glob_t *);
 160 static int       glob0(const Char *, glob_t *);
 161 static int       glob1(Char *, Char *, glob_t *);
 162 static int       glob2(Char *, Char *, Char *, Char *, Char *, Char *,
 163                     glob_t *);
 164 static int       glob3(Char *, Char *, Char *, Char *, Char *, Char *,
 165                     Char *, Char *, glob_t *);
 166 static int       globextend(const Char *, glob_t *);
 167 static const Char *
 168                  globtilde(const Char *, Char *, size_t, glob_t *);
 169 static int       globexp1(const Char *, glob_t *);
 170 static int       globexp2(const Char *, const Char *, glob_t *, int *);
 171 static int       match(Char *, Char *, Char *);
 172 #ifdef DEBUG
 173 static void      qprintf(const char *, Char *);
 174 #endif
 175
 176 int
 177 rpl_glob(const char *pattern, int flags, int (*errfunc)(const char *, int),
 178         glob_t *pglob)
 179 {
 180         const unsigned char *patnext;
 181         int c;
 182         Char *bufnext, *bufend, patbuf[PATH_MAX];
 183
 184         patnext = (unsigned char *) pattern;
 185         if (!(flags & GLOB_APPEND)) {
 186                 pglob->gl_pathc = 0;
 187                 pglob->gl_pathv = NULL;
 188                 if (!(flags & GLOB_DOOFFS))
 189                         pglob->gl_offs = 0;
 190         }
 191         pglob->gl_flags = flags & ~GLOB_MAGCHAR;
 192         pglob->gl_errfunc = errfunc;
 193         pglob->gl_matchc = 0;
 194
 195         bufnext = patbuf;
 196         bufend = bufnext + PATH_MAX - 1;
 197         if (flags & GLOB_NOESCAPE)
 198                 while (bufnext < bufend && (c = *patnext++) != EOS)
 199                         *bufnext++ = c;
 200         else {
 201                 /* Protect the quoted characters. */
 202                 while (bufnext < bufend && (c = *patnext++) != EOS)
 203                         if (c == QUOTE) {
 204                                 if ((c = *patnext++) == EOS) {
 205                                         c = QUOTE;
 206                                         --patnext;
 207                                 }
 208                                 *bufnext++ = c | M_PROTECT;
 209                         } else
 210                                 *bufnext++ = c;
 211         }
 212         *bufnext = EOS;
 213
 214         if (flags & GLOB_BRACE)
 215                 return globexp1(patbuf, pglob);
 216         else
 217                 return glob0(patbuf, pglob);
 218 }
 219
 220 /*
 221  * Expand recursively a glob {} pattern. When there is no more expansion
 222  * invoke the standard globbing routine to glob the rest of the magic
 223  * characters
 224  */
 225 static int
 226 globexp1(const Char *pattern, glob_t *pglob)
 227 {
 228         const Char* ptr = pattern;
 229         int rv;
 230
 231         /* Protect a single {}, for find(1), like csh */
 232         if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
 233                 return glob0(pattern, pglob);
 234
 235         while ((ptr = (const Char *) g_strchr(ptr, LBRACE)) != NULL)
 236                 if (!globexp2(ptr, pattern, pglob, &rv))
 237                         return rv;
 238
 239         return glob0(pattern, pglob);
 240 }
 241
 242
 243 /*
 244  * Recursive brace globbing helper. Tries to expand a single brace.
 245  * If it succeeds then it invokes globexp1 with the new pattern.
 246  * If it fails then it tries to glob the rest of the pattern and returns.
 247  */
 248 static int
 249 globexp2(const Char *ptr, const Char *pattern, glob_t *pglob, int *rv)
 250 {
 251         int     i;
 252         Char   *lm, *ls;
 253         const Char *pe, *pm, *pl;
 254         Char    patbuf[PATH_MAX];
 255
 256         /* copy part up to the brace */
 257         for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
 258                 continue;
 259         *lm = EOS;
 260         ls = lm;
 261
 262         /* Find the balanced brace */
 263         for (i = 0, pe = ++ptr; *pe; pe++)
 264                 if (*pe == LBRACKET) {
 265                         /* Ignore everything between [] */
 266                         for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
 267                                 continue;
 268                         if (*pe == EOS) {
 269                                 /*
 270                                  * We could not find a matching RBRACKET.
 271                                  * Ignore and just look for RBRACE
 272                                  */
 273                                 pe = pm;
 274                         }
 275                 } else if (*pe == LBRACE)
 276                         i++;
 277                 else if (*pe == RBRACE) {
 278                         if (i == 0)
 279                                 break;
 280                         i--;
 281                 }
 282
 283         /* Non matching braces; just glob the pattern */
 284         if (i != 0 || *pe == EOS) {
 285                 *rv = glob0(patbuf, pglob);
 286                 return 0;
 287         }
 288
 289         for (i = 0, pl = pm = ptr; pm <= pe; pm++) {
 290                 switch (*pm) {
 291                 case LBRACKET:
 292                         /* Ignore everything between [] */
 293                         for (pl = pm++; *pm != RBRACKET && *pm != EOS; pm++)
 294                                 continue;
 295                         if (*pm == EOS) {
 296                                 /*
 297                                  * We could not find a matching RBRACKET.
 298                                  * Ignore and just look for RBRACE
 299                                  */
 300                                 pm = pl;
 301                         }
 302                         break;
 303
 304                 case LBRACE:
 305                         i++;
 306                         break;
 307
 308                 case RBRACE:
 309                         if (i) {
 310                                 i--;
 311                                 break;
 312                         }
 313                         /* FALLTHROUGH */
 314                 case COMMA:
 315                         if (i && *pm == COMMA)
 316                                 break;
 317                         else {
 318                                 /* Append the current string */
 319                                 for (lm = ls; (pl < pm); *lm++ = *pl++)
 320                                         continue;
 321
 322                                 /*
 323                                  * Append the rest of the pattern after the
 324                                  * closing brace
 325                                  */
 326                                 for (pl = pe + 1; (*lm++ = *pl++) != EOS; )
 327                                         continue;
 328
 329                                 /* Expand the current pattern */
 330 #ifdef DEBUG
 331                                 qprintf("globexp2:", patbuf);
 332 #endif
 333                                 *rv = globexp1(patbuf, pglob);
 334
 335                                 /* move after the comma, to the next string */
 336                                 pl = pm + 1;
 337                         }
 338                         break;
 339
 340                 default:
 341                         break;
 342                 }
 343         }
 344         *rv = 0;
 345         return 0;
 346 }
 347
 348
 349
 350 /*
 351  * expand tilde from the passwd file.
 352  */
 353 static const Char *
 354 globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob_t *pglob)
 355 {
 356         struct passwd *pwd;
 357         char *h;
 358         const Char *p;
 359         Char *b, *eb;
 360
 361         if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
 362                 return pattern;
 363
 364         /* Copy up to the end of the string or / */
 365         eb = &patbuf[patbuf_len - 1];
 366         for (p = pattern + 1, h = (char *) patbuf;
 367             h < (char *)eb && *p && *p != SLASH; *h++ = *p++)
 368                 continue;
 369
 370         *h = EOS;
 371
 372         if (((char *) patbuf)[0] == EOS) {
 373                 /*
 374                  * handle a plain ~ or ~/ by expanding $HOME
 375                  * first and then trying the password file
 376                  */
 377                 if ((h = getenv("HOME")) == NULL) {
 378                         if ((pwd = getpwuid(getuid())) == NULL)
 379                                 return pattern;
 380                         else
 381                                 h = pwd->pw_dir;
 382                 }
 383         } else {
 384                 /*
 385                  * Expand a ~user
 386                  */
 387                 if ((pwd = getpwnam((char*) patbuf)) == NULL)
 388                         return pattern;
 389                 else
 390                         h = pwd->pw_dir;
 391         }
 392
 393         /* Copy the home directory */
 394         for (b = patbuf; b < eb && *h; *b++ = *h++)
 395                 continue;
 396
 397         /* Append the rest of the pattern */
 398         while (b < eb && (*b++ = *p++) != EOS)
 399                 continue;
 400         *b = EOS;
 401
 402         return patbuf;
 403 }
 404
 405 static int
 406 g_strncmp(const Char *s1, const char *s2, size_t n)
 407 {
 408         int rv = 0;
 409
 410         while (n--) {
 411                 rv = *(Char *)s1 - *(const unsigned char *)s2++;
 412                 if (rv)
 413                         break;
 414                 if (*s1++ == '\0')
 415                         break;
 416         }
 417         return rv;
 418 }
 419
 420 static int
 421 g_charclass(const Char **patternp, Char **bufnextp)
 422 {
 423         const Char *pattern = *patternp + 1;
 424         Char *bufnext = *bufnextp;
 425         const Char *colon;
 426         struct cclass *cc;
 427         size_t len;
 428
 429         if ((colon = g_strchr(pattern, ':')) == NULL || colon[1] != ']')
 430                 return 1;       /* not a character class */
 431
 432         len = (size_t)(colon - pattern);
 433         for (cc = cclasses; cc->name != NULL; cc++) {
 434                 if (!g_strncmp(pattern, cc->name, len) && cc->name[len] == '\0')
 435                         break;
 436         }
 437         if (cc->name == NULL)
 438                 return -1;      /* invalid character class */
 439         *bufnext++ = M_CLASS;
 440         *bufnext++ = (Char)(cc - &cclasses[0]);
 441         *bufnextp = bufnext;
 442         *patternp += len + 3;
 443
 444         return 0;
 445 }
 446
 447 /*
 448  * The main glob() routine: compiles the pattern (optionally processing
 449  * quotes), calls glob1() to do the real pattern matching, and finally
 450  * sorts the list (unless unsorted operation is requested).  Returns 0
 451  * if things went well, nonzero if errors occurred.  It is not an error
 452  * to find no matches.
 453  */
 454 static int
 455 glob0(const Char *pattern, glob_t *pglob)
 456 {
 457         const Char *qpatnext;
 458         int c, err, oldpathc;
 459         Char *bufnext, patbuf[PATH_MAX];
 460
 461         qpatnext = globtilde(pattern, patbuf, PATH_MAX, pglob);
 462         oldpathc = pglob->gl_pathc;
 463         bufnext = patbuf;
 464
 465         /* We don't need to check for buffer overflow any more. */
 466         while ((c = *qpatnext++) != EOS) {
 467                 switch (c) {
 468                 case LBRACKET:
 469                         c = *qpatnext;
 470                         if (c == NOT)
 471                                 ++qpatnext;
 472                         if (*qpatnext == EOS ||
 473                             g_strchr(qpatnext+1, RBRACKET) == NULL) {
 474                                 *bufnext++ = LBRACKET;
 475                                 if (c == NOT)
 476                                         --qpatnext;
 477                                 break;
 478                         }
 479                         *bufnext++ = M_SET;
 480                         if (c == NOT)
 481                                 *bufnext++ = M_NOT;
 482                         c = *qpatnext++;
 483                         do {
 484                                 if (c == LBRACKET && *qpatnext == ':') {
 485                                         do {
 486                                                 err = g_charclass(&qpatnext,
 487                                                     &bufnext);
 488                                                 if (err)
 489                                                         break;
 490                                                 c = *qpatnext++;
 491                                         } while (c == LBRACKET && *qpatnext == ':');
 492                                         if (err == -1 &&
 493                                             !(pglob->gl_flags & GLOB_NOCHECK))
 494                                                 return GLOB_NOMATCH;
 495                                         if (c == RBRACKET)
 496                                                 break;
 497                                 }
 498                                 *bufnext++ = CHAR(c);
 499                                 if (*qpatnext == RANGE &&
 500                                     (c = qpatnext[1]) != RBRACKET) {
 501                                         *bufnext++ = M_RNG;
 502                                         *bufnext++ = CHAR(c);
 503                                         qpatnext += 2;
 504                                 }
 505                         } while ((c = *qpatnext++) != RBRACKET);
 506                         pglob->gl_flags |= GLOB_MAGCHAR;
 507                         *bufnext++ = M_END;
 508                         break;
 509                 case QUESTION:
 510                         pglob->gl_flags |= GLOB_MAGCHAR;
 511                         *bufnext++ = M_ONE;
 512                         break;
 513                 case STAR:
 514                         pglob->gl_flags |= GLOB_MAGCHAR;
 515                         /* collapse adjacent stars to one,
 516                          * to avoid exponential behavior
 517                          */
 518                         if (bufnext == patbuf || bufnext[-1] != M_ALL)
 519                                 *bufnext++ = M_ALL;
 520                         break;
 521                 default:
 522                         *bufnext++ = CHAR(c);
 523                         break;
 524                 }
 525         }
 526         *bufnext = EOS;
 527 #ifdef DEBUG
 528         qprintf("glob0:", patbuf);
 529 #endif
 530
 531         if ((err = glob1(patbuf, patbuf + PATH_MAX - 1, pglob)) != 0)
 532                 return err;
 533
 534         /*
 535          * If there was no match we are going to append the pattern
 536          * if GLOB_NOCHECK was specified.
 537          */
 538         if (pglob->gl_pathc == oldpathc) {
 539                 if (pglob->gl_flags & GLOB_NOCHECK)
 540                         return globextend(pattern, pglob);
 541                 else
 542                         return GLOB_NOMATCH;
 543         }
 544         if (!(pglob->gl_flags & GLOB_NOSORT))
 545                 qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
 546                     pglob->gl_pathc - oldpathc, sizeof(char *), compare);
 547         return 0;
 548 }
 549
 550 static int
 551 compare(const void *p, const void *q)
 552 {
 553         return strcmp(*(char **)p, *(char **)q);
 554 }
 555
 556 static int
 557 glob1(Char *pattern, Char *pattern_last, glob_t *pglob)
 558 {
 559         Char pathbuf[PATH_MAX];
 560
 561         /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
 562         if (*pattern == EOS)
 563                 return 0;
 564         return glob2(pathbuf, pathbuf + PATH_MAX - 1,
 565             pathbuf, pathbuf + PATH_MAX - 1,
 566             pattern, pattern_last, pglob);
 567 }
 568
 569 /*
 570  * The functions glob2 and glob3 are mutually recursive; there is one level
 571  * of recursion for each segment in the pattern that contains one or more
 572  * meta characters.
 573  */
 574 static int
 575 glob2(Char *pathbuf, Char *pathbuf_last, Char *pathend, Char *pathend_last,
 576         Char *pattern, Char *pattern_last, glob_t *pglob)
 577 {
 578         struct stat sb;
 579         Char *p, *q;
 580         int anymeta;
 581
 582         /*
 583          * Loop over pattern segments until end of pattern or until
 584          * segment with meta character found.
 585          */
 586         for (anymeta = 0;;) {
 587                 if (*pattern == EOS) {          /* End of pattern? */
 588                         *pathend = EOS;
 589                         if (g_lstat(pathbuf, &sb, pglob))
 590                                 return 0;
 591
 592                         if (((pglob->gl_flags & GLOB_MARK) &&
 593                             pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||
 594                             (S_ISLNK(sb.st_mode) &&
 595                             (g_stat(pathbuf, &sb, pglob) == 0) &&
 596                             S_ISDIR(sb.st_mode)))) {
 597                                 if (pathend+1 > pathend_last)
 598                                         return 1;
 599                                 *pathend++ = SEP;
 600                                 *pathend = EOS;
 601                         }
 602                         ++pglob->gl_matchc;
 603                         return globextend(pathbuf, pglob);
 604                 }
 605
 606                 /* Find end of next segment, copy tentatively to pathend. */
 607                 q = pathend;
 608                 p = pattern;
 609                 while (*p != EOS && *p != SEP) {
 610                         if (ismeta(*p))
 611                                 anymeta = 1;
 612                         if (q+1 > pathend_last)
 613                                 return 1;
 614                         *q++ = *p++;
 615                 }
 616
 617                 if (!anymeta) {         /* No expansion, do next segment. */
 618                         pathend = q;
 619                         pattern = p;
 620                         while (*pattern == SEP) {
 621                                 if (pathend+1 > pathend_last)
 622                                         return 1;
 623                                 *pathend++ = *pattern++;
 624                         }
 625                 } else
 626                         /* Need expansion, recurse. */
 627                         return glob3(pathbuf, pathbuf_last, pathend,
 628                             pathend_last, pattern, pattern_last,
 629                             p, pattern_last, pglob);
 630         }
 631         /* NOTREACHED */
 632 }
 633
 634 static int
 635 glob3(Char *pathbuf, Char *pathbuf_last, Char *pathend, Char *pathend_last,
 636         Char *pattern, Char *pattern_last, Char *restpattern,
 637         Char *restpattern_last, glob_t *pglob)
 638 {
 639         struct dirent *dp;
 640         DIR *dirp;
 641         int err;
 642         char buf[PATH_MAX];
 643
 644         if (pathend > pathend_last)
 645                 return 1;
 646         *pathend = EOS;
 647         errno = 0;
 648
 649         if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
 650                 /* TODO: don't call for ENOENT or ENOTDIR? */
 651                 if (pglob->gl_errfunc) {
 652                         if (g_Ctoc(pathbuf, buf, sizeof(buf)))
 653                                 return GLOB_ABORTED;
 654                         if (pglob->gl_errfunc(buf, errno) ||
 655                             pglob->gl_flags & GLOB_ERR)
 656                                 return GLOB_ABORTED;
 657                 }
 658                 return 0;
 659         }
 660
 661         err = 0;
 662
 663         /* Search directory for matching names. */
 664         while ((dp = readdir(dirp))) {
 665                 unsigned char *sc;
 666                 Char *dc;
 667
 668                 /* Initial DOT must be matched literally. */
 669                 if (dp->d_name[0] == DOT && *pattern != DOT)
 670                         continue;
 671                 dc = pathend;
 672                 sc = (unsigned char *) dp->d_name;
 673                 while (dc < pathend_last && (*dc++ = *sc++) != EOS)
 674                         continue;
 675                 if (dc >= pathend_last) {
 676                         *dc = EOS;
 677                         err = 1;
 678                         break;
 679                 }
 680
 681                 if (!match(pathend, pattern, restpattern)) {
 682                         *pathend = EOS;
 683                         continue;
 684                 }
 685                 err = glob2(pathbuf, pathbuf_last, --dc, pathend_last,
 686                     restpattern, restpattern_last, pglob);
 687                 if (err)
 688                         break;
 689         }
 690
 691         closedir(dirp);
 692         return err;
 693 }
 694
 695 /*
 696  * Extend the gl_pathv member of a glob_t structure to accommodate a new item,
 697  * add the new item, and update gl_pathc.
 698  *
 699  * This assumes the BSD realloc, which only copies the block when its size
 700  * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
 701  * behavior.
 702  *
 703  * Return 0 if new item added, error code if memory couldn't be allocated.
 704  *
 705  * Invariant of the glob_t structure:
 706  *      Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
 707  *      gl_pathv points to (gl_offs + gl_pathc + 1) items.
 708  */
 709 static int
 710 globextend(const Char *path, glob_t *pglob)
 711 {
 712         char **pathv;
 713         int i;
 714         unsigned int newsize, len;
 715         char *copy;
 716         const Char *p;
 717
 718         newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
 719         pathv = pglob->gl_pathv ?
 720             (char **)realloc((char *)pglob->gl_pathv, newsize) :
 721             (char **)malloc(newsize);
 722         if (pathv == NULL) {
 723                 if (pglob->gl_pathv) {
 724                         free(pglob->gl_pathv);
 725                         pglob->gl_pathv = NULL;
 726                 }
 727                 return GLOB_NOSPACE;
 728         }
 729
 730         if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
 731                 /* first time around -- clear initial gl_offs items */
 732                 pathv += pglob->gl_offs;
 733                 for (i = pglob->gl_offs; --i >= 0; )
 734                         *--pathv = NULL;
 735         }
 736         pglob->gl_pathv = pathv;
 737
 738         for (p = path; *p++;)
 739                 continue;
 740         len = (size_t)(p - path);
 741         if ((copy = malloc(len)) != NULL) {
 742                 if (g_Ctoc(path, copy, len)) {
 743                         free(copy);
 744                         return GLOB_NOSPACE;
 745                 }
 746                 pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
 747         }
 748         pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
 749
 750         return copy == NULL ? GLOB_NOSPACE : 0;
 751 }
 752
 753 /*
 754  * pattern matching function for filenames.  Each occurrence of the *
 755  * pattern causes a recursion level.
 756  */
 757 static int
 758 match(Char *name, Char *pat, Char *patend)
 759 {
 760         int ok, negate_range;
 761         Char c, k;
 762
 763         while (pat < patend) {
 764                 c = *pat++;
 765                 switch (c & M_MASK) {
 766                 case M_ALL:
 767                         if (pat == patend)
 768                                 return 1;
 769                         do {
 770                             if (match(name, pat, patend))
 771                                     return 1;
 772                         } while (*name++ != EOS);
 773                         return 0;
 774                 case M_ONE:
 775                         if (*name++ == EOS)
 776                                 return 0;
 777                         break;
 778                 case M_SET:
 779                         ok = 0;
 780                         if ((k = *name++) == EOS)
 781                                 return 0;
 782                         if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)
 783                                 ++pat;
 784                         while (((c = *pat++) & M_MASK) != M_END) {
 785                                 if ((c & M_MASK) == M_CLASS) {
 786                                         int idx = *pat & M_MASK;
 787                                         if (idx < NCCLASSES &&
 788                                             cclasses[idx].isctype(k))
 789                                                 ok = 1;
 790                                         ++pat;
 791                                 }
 792                                 if ((*pat & M_MASK) == M_RNG) {
 793                                         if (c <= k && k <= pat[1])
 794                                                 ok = 1;
 795                                         pat += 2;
 796                                 } else if (c == k)
 797                                         ok = 1;
 798                         }
 799                         if (ok == negate_range)
 800                                 return 0;
 801                         break;
 802                 default:
 803                         if (*name++ != c)
 804                                 return 0;
 805                         break;
 806                 }
 807         }
 808         return *name == EOS;
 809 }
 810
 811 /* Free allocated data belonging to a glob_t structure. */
 812 void
 813 rpl_globfree(glob_t *pglob)
 814 {
 815         int i;
 816         char **pp;
 817
 818         if (pglob->gl_pathv != NULL) {
 819                 pp = pglob->gl_pathv + pglob->gl_offs;
 820                 for (i = pglob->gl_pathc; i--; ++pp)
 821                         if (*pp)
 822                                 free(*pp);
 823                 free(pglob->gl_pathv);
 824                 pglob->gl_pathv = NULL;
 825         }
 826 }
 827
 828 static DIR *
 829 g_opendir(Char *str, glob_t *pglob)
 830 {
 831         char buf[PATH_MAX];
 832
 833         if (!*str) {
 834                 buf[0] = '.';
 835                 buf[1] = '\0';
 836         } else {
 837                 if (g_Ctoc(str, buf, sizeof(buf)))
 838                         return NULL;
 839         }
 840         return opendir(buf);
 841 }
 842
 843 static int
 844 g_lstat(Char *fn, struct stat *sb, glob_t *pglob)
 845 {
 846         char buf[PATH_MAX];
 847
 848         if (g_Ctoc(fn, buf, sizeof(buf)))
 849                 return -1;
 850         return lstat(buf, sb);
 851 }
 852
 853 static int
 854 g_stat(Char *fn, struct stat *sb, glob_t *pglob)
 855 {
 856         char buf[PATH_MAX];
 857
 858         if (g_Ctoc(fn, buf, sizeof(buf)))
 859                 return -1;
 860         return stat(buf, sb);
 861 }
 862
 863 static Char *
 864 g_strchr(const Char *str, int ch)
 865 {
 866         do {
 867                 if (*str == ch)
 868                         return (Char *)str;
 869         } while (*str++);
 870         return NULL;
 871 }
 872
 873 static int
 874 g_Ctoc(const Char *str, char *buf, unsigned int len)
 875 {
 876
 877         while (len--) {
 878                 if ((*buf++ = *str++) == EOS)
 879                         return 0;
 880         }
 881         return 1;
 882 }
 883
 884 #ifdef DEBUG
 885 static void
 886 qprintf(const char *str, Char *s)
 887 {
 888         Char *p;
 889
 890         (void)printf("%s:\n", str);
 891         for (p = s; *p; p++)
 892                 (void)printf("%c", CHAR(*p));
 893         (void)printf("\n");
 894         for (p = s; *p; p++)
 895                 (void)printf("%c", *p & M_PROTECT ? '"' : ' ');
 896         (void)printf("\n");
 897         for (p = s; *p; p++)
 898                 (void)printf("%c", ismeta(*p) ? '_' : ' ');
 899         (void)printf("\n");
 900 }
 901 #endif