1 /* 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Guido van Rossum. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 #if defined(LIBC_SCCS) && !defined(lint) 34 static char sccsid[] = "@(#)glob.c 8.3 (Berkeley) 10/13/93"; 35 /* most changes between the version above and the one below have been ported: 36 static char sscsid[]= "$OpenBSD: glob.c,v 1.8.10.1 2001/04/10 jason Exp $"; 37 */ 38 #endif /* LIBC_SCCS and not lint */ 39 40 /* 41 * glob(3) -- a superset of the one defined in POSIX 1003.2. 42 * 43 * The [!...] convention to negate a range is supported (SysV, Posix, ksh). 44 * 45 * Optional extra services, controlled by flags not defined by POSIX: 46 * 47 * GLOB_QUOTE: 48 * Escaping convention: \ inhibits any special meaning the following 49 * character might have (except \ at end of string is retained). 50 * GLOB_MAGCHAR: 51 * Set in gl_flags if pattern contained a globbing character. 52 * GLOB_NOMAGIC: 53 * Same as GLOB_NOCHECK, but it will only append pattern if it did 54 * not contain any magic characters. [Used in csh style globbing] 55 * GLOB_ALTDIRFUNC: 56 * Use alternately specified directory access functions. 57 * GLOB_TILDE: 58 * expand ~user/foo to the /home/dir/of/user/foo 59 * GLOB_BRACE: 60 * expand {1,2}{a,b} to 1a 1b 2a 2b 61 * gl_matchc: 62 * Number of matches in the current invocation of glob. 63 * GLOB_ALPHASORT: 64 * sort alphabetically like csh (case doesn't matter) instead of in ASCII 65 * order 66 */ 67 68 #include <EXTERN.h> 69 #include <perl.h> 70 #include <XSUB.h> 71 72 #include "bsd_glob.h" 73 #ifdef I_PWD 74 # include <pwd.h> 75 #else 76 #if defined(HAS_PASSWD) && !defined(VMS) 77 struct passwd *getpwnam(char *); 78 struct passwd *getpwuid(Uid_t); 79 #endif 80 #endif 81 82 #ifndef MAXPATHLEN 83 # ifdef PATH_MAX 84 # define MAXPATHLEN PATH_MAX 85 # else 86 # define MAXPATHLEN 1024 87 # endif 88 #endif 89 90 #ifdef I_LIMITS 91 #include <limits.h> 92 #endif 93 94 #ifndef ARG_MAX 95 # ifdef _SC_ARG_MAX 96 # define ARG_MAX (sysconf(_SC_ARG_MAX)) 97 # else 98 # ifdef _POSIX_ARG_MAX 99 # define ARG_MAX _POSIX_ARG_MAX 100 # else 101 # ifdef WIN32 102 # define ARG_MAX 14500 /* from VC's limits.h */ 103 # else 104 # define ARG_MAX 4096 /* from POSIX, be conservative */ 105 # endif 106 # endif 107 # endif 108 #endif 109 110 #define BG_DOLLAR '$' 111 #define BG_DOT '.' 112 #define BG_EOS '\0' 113 #define BG_LBRACKET '[' 114 #define BG_NOT '!' 115 #define BG_QUESTION '?' 116 #define BG_QUOTE '\\' 117 #define BG_RANGE '-' 118 #define BG_RBRACKET ']' 119 #define BG_SEP '/' 120 #ifdef DOSISH 121 #define BG_SEP2 '\\' 122 #endif 123 #define BG_STAR '*' 124 #define BG_TILDE '~' 125 #define BG_UNDERSCORE '_' 126 #define BG_LBRACE '{' 127 #define BG_RBRACE '}' 128 #define BG_SLASH '/' 129 #define BG_COMMA ',' 130 131 #ifndef GLOB_DEBUG 132 133 #define M_QUOTE 0x8000 134 #define M_PROTECT 0x4000 135 #define M_MASK 0xffff 136 #define M_ASCII 0x00ff 137 138 typedef U16 Char; 139 140 #else 141 142 #define M_QUOTE 0x80 143 #define M_PROTECT 0x40 144 #define M_MASK 0xff 145 #define M_ASCII 0x7f 146 147 typedef U8 Char; 148 149 #endif /* !GLOB_DEBUG */ 150 151 152 #define CHAR(c) ((Char)((c)&M_ASCII)) 153 #define META(c) ((Char)((c)|M_QUOTE)) 154 #define M_ALL META('*') 155 #define M_END META(']') 156 #define M_NOT META('!') 157 #define M_ONE META('?') 158 #define M_RNG META('-') 159 #define M_SET META('[') 160 #define ismeta(c) (((c)&M_QUOTE) != 0) 161 162 163 static int compare(const void *, const void *); 164 static int ci_compare(const void *, const void *); 165 static int g_Ctoc(const Char *, char *, STRLEN); 166 static int g_lstat(Char *, Stat_t *, glob_t *); 167 static DIR *g_opendir(Char *, glob_t *); 168 static Char *g_strchr(Char *, int); 169 static int g_stat(Char *, Stat_t *, glob_t *); 170 static int glob0(const Char *, glob_t *); 171 static int glob1(Char *, Char *, glob_t *, size_t *); 172 static int glob2(Char *, Char *, Char *, Char *, Char *, Char *, 173 glob_t *, size_t *); 174 static int glob3(Char *, Char *, Char *, Char *, Char *, Char *, 175 Char *, Char *, glob_t *, size_t *); 176 static int globextend(const Char *, glob_t *, size_t *); 177 static const Char * 178 globtilde(const Char *, Char *, size_t, glob_t *); 179 static int globexp1(const Char *, glob_t *); 180 static int globexp2(const Char *, const Char *, glob_t *, int *); 181 static int match(Char *, Char *, Char *, int); 182 #ifdef GLOB_DEBUG 183 static void qprintf(const char *, Char *); 184 #endif /* GLOB_DEBUG */ 185 186 #ifdef PERL_IMPLICIT_CONTEXT 187 static Direntry_t * my_readdir(DIR*); 188 189 static Direntry_t * 190 my_readdir(DIR *d) 191 { 192 #ifndef NETWARE 193 return PerlDir_read(d); 194 #else 195 return (DIR *)PerlDir_read(d); 196 #endif 197 } 198 #else 199 200 /* ReliantUNIX (OS formerly known as SINIX) defines readdir 201 * in LFS-mode to be a 64-bit version of readdir. */ 202 203 # ifdef sinix 204 static Direntry_t * my_readdir(DIR*); 205 206 static Direntry_t * 207 my_readdir(DIR *d) 208 { 209 return readdir(d); 210 } 211 # else 212 213 # define my_readdir readdir 214 215 # endif 216 217 #endif 218 219 int 220 bsd_glob(const char *pattern, int flags, 221 int (*errfunc)(const char *, int), glob_t *pglob) 222 { 223 const U8 *patnext; 224 int c; 225 Char *bufnext, *bufend, patbuf[MAXPATHLEN]; 226 patnext = (U8 *) pattern; 227 /* TODO: GLOB_APPEND / GLOB_DOOFFS aren't supported yet */ 228 #if 0 229 if (!(flags & GLOB_APPEND)) { 230 pglob->gl_pathc = 0; 231 pglob->gl_pathv = NULL; 232 if (!(flags & GLOB_DOOFFS)) 233 pglob->gl_offs = 0; 234 } 235 #else 236 pglob->gl_pathc = 0; 237 pglob->gl_pathv = NULL; 238 pglob->gl_offs = 0; 239 #endif 240 pglob->gl_flags = flags & ~GLOB_MAGCHAR; 241 pglob->gl_errfunc = errfunc; 242 pglob->gl_matchc = 0; 243 244 bufnext = patbuf; 245 bufend = bufnext + MAXPATHLEN - 1; 246 #ifdef DOSISH 247 /* Nasty hack to treat patterns like "C:*" correctly. In this 248 * case, the * should match any file in the current directory 249 * on the C: drive. However, the glob code does not treat the 250 * colon specially, so it looks for files beginning "C:" in 251 * the current directory. To fix this, change the pattern to 252 * add an explicit "./" at the start (just after the drive 253 * letter and colon - ie change to "C:./"). 254 */ 255 if (isalpha(pattern[0]) && pattern[1] == ':' && 256 pattern[2] != BG_SEP && pattern[2] != BG_SEP2 && 257 bufend - bufnext > 4) { 258 *bufnext++ = pattern[0]; 259 *bufnext++ = ':'; 260 *bufnext++ = '.'; 261 *bufnext++ = BG_SEP; 262 patnext += 2; 263 } 264 #endif 265 266 if (flags & GLOB_QUOTE) { 267 /* Protect the quoted characters. */ 268 while (bufnext < bufend && (c = *patnext++) != BG_EOS) 269 if (c == BG_QUOTE) { 270 #ifdef DOSISH 271 /* To avoid backslashitis on Win32, 272 * we only treat \ as a quoting character 273 * if it precedes one of the 274 * metacharacters []-{}~\ 275 */ 276 if ((c = *patnext++) != '[' && c != ']' && 277 c != '-' && c != '{' && c != '}' && 278 c != '~' && c != '\\') { 279 #else 280 if ((c = *patnext++) == BG_EOS) { 281 #endif 282 c = BG_QUOTE; 283 --patnext; 284 } 285 *bufnext++ = c | M_PROTECT; 286 } else 287 *bufnext++ = c; 288 } else 289 while (bufnext < bufend && (c = *patnext++) != BG_EOS) 290 *bufnext++ = c; 291 *bufnext = BG_EOS; 292 293 if (flags & GLOB_BRACE) 294 return globexp1(patbuf, pglob); 295 else 296 return glob0(patbuf, pglob); 297 } 298 299 /* 300 * Expand recursively a glob {} pattern. When there is no more expansion 301 * invoke the standard globbing routine to glob the rest of the magic 302 * characters 303 */ 304 static int 305 globexp1(const Char *pattern, glob_t *pglob) 306 { 307 const Char* ptr = pattern; 308 int rv; 309 310 /* Protect a single {}, for find(1), like csh */ 311 if (pattern[0] == BG_LBRACE && pattern[1] == BG_RBRACE && pattern[2] == BG_EOS) 312 return glob0(pattern, pglob); 313 314 while ((ptr = (const Char *) g_strchr((Char *) ptr, BG_LBRACE)) != NULL) 315 if (!globexp2(ptr, pattern, pglob, &rv)) 316 return rv; 317 318 return glob0(pattern, pglob); 319 } 320 321 322 /* 323 * Recursive brace globbing helper. Tries to expand a single brace. 324 * If it succeeds then it invokes globexp1 with the new pattern. 325 * If it fails then it tries to glob the rest of the pattern and returns. 326 */ 327 static int 328 globexp2(const Char *ptr, const Char *pattern, 329 glob_t *pglob, int *rv) 330 { 331 int i; 332 Char *lm, *ls; 333 const Char *pe, *pm, *pm1, *pl; 334 Char patbuf[MAXPATHLEN]; 335 336 /* copy part up to the brace */ 337 for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++) 338 ; 339 *lm = BG_EOS; 340 ls = lm; 341 342 /* Find the balanced brace */ 343 for (i = 0, pe = ++ptr; *pe; pe++) 344 if (*pe == BG_LBRACKET) { 345 /* Ignore everything between [] */ 346 for (pm = pe++; *pe != BG_RBRACKET && *pe != BG_EOS; pe++) 347 ; 348 if (*pe == BG_EOS) { 349 /* 350 * We could not find a matching BG_RBRACKET. 351 * Ignore and just look for BG_RBRACE 352 */ 353 pe = pm; 354 } 355 } else if (*pe == BG_LBRACE) 356 i++; 357 else if (*pe == BG_RBRACE) { 358 if (i == 0) 359 break; 360 i--; 361 } 362 363 /* Non matching braces; just glob the pattern */ 364 if (i != 0 || *pe == BG_EOS) { 365 *rv = glob0(patbuf, pglob); 366 return 0; 367 } 368 369 for (i = 0, pl = pm = ptr; pm <= pe; pm++) { 370 switch (*pm) { 371 case BG_LBRACKET: 372 /* Ignore everything between [] */ 373 for (pm1 = pm++; *pm != BG_RBRACKET && *pm != BG_EOS; pm++) 374 ; 375 if (*pm == BG_EOS) { 376 /* 377 * We could not find a matching BG_RBRACKET. 378 * Ignore and just look for BG_RBRACE 379 */ 380 pm = pm1; 381 } 382 break; 383 384 case BG_LBRACE: 385 i++; 386 break; 387 388 case BG_RBRACE: 389 if (i) { 390 i--; 391 break; 392 } 393 /* FALLTHROUGH */ 394 case BG_COMMA: 395 if (i && *pm == BG_COMMA) 396 break; 397 else { 398 /* Append the current string */ 399 for (lm = ls; (pl < pm); *lm++ = *pl++) 400 ; 401 402 /* 403 * Append the rest of the pattern after the 404 * closing brace 405 */ 406 for (pl = pe + 1; (*lm++ = *pl++) != BG_EOS; ) 407 ; 408 409 /* Expand the current pattern */ 410 #ifdef GLOB_DEBUG 411 qprintf("globexp2:", patbuf); 412 #endif /* GLOB_DEBUG */ 413 *rv = globexp1(patbuf, pglob); 414 415 /* move after the comma, to the next string */ 416 pl = pm + 1; 417 } 418 break; 419 420 default: 421 break; 422 } 423 } 424 *rv = 0; 425 return 0; 426 } 427 428 429 430 /* 431 * expand tilde from the passwd file. 432 */ 433 static const Char * 434 globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob_t *pglob) 435 { 436 char *h; 437 const Char *p; 438 Char *b, *eb; 439 440 if (*pattern != BG_TILDE || !(pglob->gl_flags & GLOB_TILDE)) 441 return pattern; 442 443 /* Copy up to the end of the string or / */ 444 eb = &patbuf[patbuf_len - 1]; 445 for (p = pattern + 1, h = (char *) patbuf; 446 h < (char*)eb && *p && *p != BG_SLASH; *h++ = (char)*p++) 447 ; 448 449 *h = BG_EOS; 450 451 #if 0 452 if (h == (char *)eb) 453 return what; 454 #endif 455 456 if (((char *) patbuf)[0] == BG_EOS) { 457 /* 458 * handle a plain ~ or ~/ by expanding $HOME 459 * first and then trying the password file 460 */ 461 if ((h = getenv("HOME")) == NULL) { 462 #ifdef HAS_PASSWD 463 struct passwd *pwd; 464 if ((pwd = getpwuid(getuid())) == NULL) 465 return pattern; 466 else 467 h = pwd->pw_dir; 468 #else 469 return pattern; 470 #endif 471 } 472 } else { 473 /* 474 * Expand a ~user 475 */ 476 #ifdef HAS_PASSWD 477 struct passwd *pwd; 478 if ((pwd = getpwnam((char*) patbuf)) == NULL) 479 return pattern; 480 else 481 h = pwd->pw_dir; 482 #else 483 return pattern; 484 #endif 485 } 486 487 /* Copy the home directory */ 488 for (b = patbuf; b < eb && *h; *b++ = *h++) 489 ; 490 491 /* Append the rest of the pattern */ 492 while (b < eb && (*b++ = *p++) != BG_EOS) 493 ; 494 *b = BG_EOS; 495 496 return patbuf; 497 } 498 499 500 /* 501 * The main glob() routine: compiles the pattern (optionally processing 502 * quotes), calls glob1() to do the real pattern matching, and finally 503 * sorts the list (unless unsorted operation is requested). Returns 0 504 * if things went well, nonzero if errors occurred. It is not an error 505 * to find no matches. 506 */ 507 static int 508 glob0(const Char *pattern, glob_t *pglob) 509 { 510 const Char *qpat, *qpatnext; 511 int c, err, oldflags, oldpathc; 512 Char *bufnext, patbuf[MAXPATHLEN]; 513 size_t limit = 0; 514 515 qpat = globtilde(pattern, patbuf, MAXPATHLEN, pglob); 516 qpatnext = qpat; 517 oldflags = pglob->gl_flags; 518 oldpathc = pglob->gl_pathc; 519 bufnext = patbuf; 520 521 /* We don't need to check for buffer overflow any more. */ 522 while ((c = *qpatnext++) != BG_EOS) { 523 switch (c) { 524 case BG_LBRACKET: 525 c = *qpatnext; 526 if (c == BG_NOT) 527 ++qpatnext; 528 if (*qpatnext == BG_EOS || 529 g_strchr((Char *) qpatnext+1, BG_RBRACKET) == NULL) { 530 *bufnext++ = BG_LBRACKET; 531 if (c == BG_NOT) 532 --qpatnext; 533 break; 534 } 535 *bufnext++ = M_SET; 536 if (c == BG_NOT) 537 *bufnext++ = M_NOT; 538 c = *qpatnext++; 539 do { 540 *bufnext++ = CHAR(c); 541 if (*qpatnext == BG_RANGE && 542 (c = qpatnext[1]) != BG_RBRACKET) { 543 *bufnext++ = M_RNG; 544 *bufnext++ = CHAR(c); 545 qpatnext += 2; 546 } 547 } while ((c = *qpatnext++) != BG_RBRACKET); 548 pglob->gl_flags |= GLOB_MAGCHAR; 549 *bufnext++ = M_END; 550 break; 551 case BG_QUESTION: 552 pglob->gl_flags |= GLOB_MAGCHAR; 553 *bufnext++ = M_ONE; 554 break; 555 case BG_STAR: 556 pglob->gl_flags |= GLOB_MAGCHAR; 557 /* collapse adjacent stars to one, 558 * to avoid exponential behavior 559 */ 560 if (bufnext == patbuf || bufnext[-1] != M_ALL) 561 *bufnext++ = M_ALL; 562 break; 563 default: 564 *bufnext++ = CHAR(c); 565 break; 566 } 567 } 568 *bufnext = BG_EOS; 569 #ifdef GLOB_DEBUG 570 qprintf("glob0:", patbuf); 571 #endif /* GLOB_DEBUG */ 572 573 if ((err = glob1(patbuf, patbuf+MAXPATHLEN-1, pglob, &limit)) != 0) { 574 pglob->gl_flags = oldflags; 575 return(err); 576 } 577 578 /* 579 * If there was no match we are going to append the pattern 580 * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified 581 * and the pattern did not contain any magic characters 582 * GLOB_NOMAGIC is there just for compatibility with csh. 583 */ 584 if (pglob->gl_pathc == oldpathc && 585 ((pglob->gl_flags & GLOB_NOCHECK) || 586 ((pglob->gl_flags & GLOB_NOMAGIC) && 587 !(pglob->gl_flags & GLOB_MAGCHAR)))) 588 { 589 #ifdef GLOB_DEBUG 590 printf("calling globextend from glob0\n"); 591 #endif /* GLOB_DEBUG */ 592 pglob->gl_flags = oldflags; 593 return(globextend(qpat, pglob, &limit)); 594 } 595 else if (!(pglob->gl_flags & GLOB_NOSORT)) 596 qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc, 597 pglob->gl_pathc - oldpathc, sizeof(char *), 598 (pglob->gl_flags & (GLOB_ALPHASORT|GLOB_NOCASE)) 599 ? ci_compare : compare); 600 pglob->gl_flags = oldflags; 601 return(0); 602 } 603 604 static int 605 ci_compare(const void *p, const void *q) 606 { 607 const char *pp = *(const char **)p; 608 const char *qq = *(const char **)q; 609 int ci; 610 while (*pp && *qq) { 611 if (toLOWER(*pp) != toLOWER(*qq)) 612 break; 613 ++pp; 614 ++qq; 615 } 616 ci = toLOWER(*pp) - toLOWER(*qq); 617 if (ci == 0) 618 return compare(p, q); 619 return ci; 620 } 621 622 static int 623 compare(const void *p, const void *q) 624 { 625 return(strcmp(*(char **)p, *(char **)q)); 626 } 627 628 static int 629 glob1(Char *pattern, Char *pattern_last, glob_t *pglob, size_t *limitp) 630 { 631 Char pathbuf[MAXPATHLEN]; 632 633 /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */ 634 if (*pattern == BG_EOS) 635 return(0); 636 return(glob2(pathbuf, pathbuf+MAXPATHLEN-1, 637 pathbuf, pathbuf+MAXPATHLEN-1, 638 pattern, pattern_last, pglob, limitp)); 639 } 640 641 /* 642 * The functions glob2 and glob3 are mutually recursive; there is one level 643 * of recursion for each segment in the pattern that contains one or more 644 * meta characters. 645 */ 646 static int 647 glob2(Char *pathbuf, Char *pathbuf_last, Char *pathend, Char *pathend_last, 648 Char *pattern, Char *pattern_last, glob_t *pglob, size_t *limitp) 649 { 650 Stat_t sb; 651 Char *p, *q; 652 int anymeta; 653 654 /* 655 * Loop over pattern segments until end of pattern or until 656 * segment with meta character found. 657 */ 658 for (anymeta = 0;;) { 659 if (*pattern == BG_EOS) { /* End of pattern? */ 660 *pathend = BG_EOS; 661 if (g_lstat(pathbuf, &sb, pglob)) 662 return(0); 663 664 if (((pglob->gl_flags & GLOB_MARK) && 665 pathend[-1] != BG_SEP 666 #ifdef DOSISH 667 && pathend[-1] != BG_SEP2 668 #endif 669 ) && (S_ISDIR(sb.st_mode) || 670 (S_ISLNK(sb.st_mode) && 671 (g_stat(pathbuf, &sb, pglob) == 0) && 672 S_ISDIR(sb.st_mode)))) { 673 if (pathend+1 > pathend_last) 674 return (1); 675 *pathend++ = BG_SEP; 676 *pathend = BG_EOS; 677 } 678 ++pglob->gl_matchc; 679 #ifdef GLOB_DEBUG 680 printf("calling globextend from glob2\n"); 681 #endif /* GLOB_DEBUG */ 682 return(globextend(pathbuf, pglob, limitp)); 683 } 684 685 /* Find end of next segment, copy tentatively to pathend. */ 686 q = pathend; 687 p = pattern; 688 while (*p != BG_EOS && *p != BG_SEP 689 #ifdef DOSISH 690 && *p != BG_SEP2 691 #endif 692 ) { 693 if (ismeta(*p)) 694 anymeta = 1; 695 if (q+1 > pathend_last) 696 return (1); 697 *q++ = *p++; 698 } 699 700 if (!anymeta) { /* No expansion, do next segment. */ 701 pathend = q; 702 pattern = p; 703 while (*pattern == BG_SEP 704 #ifdef DOSISH 705 || *pattern == BG_SEP2 706 #endif 707 ) { 708 if (pathend+1 > pathend_last) 709 return (1); 710 *pathend++ = *pattern++; 711 } 712 } else 713 /* Need expansion, recurse. */ 714 return(glob3(pathbuf, pathbuf_last, pathend, 715 pathend_last, pattern, pattern_last, 716 p, pattern_last, pglob, limitp)); 717 } 718 /* NOTREACHED */ 719 } 720 721 static int 722 glob3(Char *pathbuf, Char *pathbuf_last, Char *pathend, Char *pathend_last, 723 Char *pattern, Char *pattern_last, 724 Char *restpattern, Char *restpattern_last, glob_t *pglob, size_t *limitp) 725 { 726 register Direntry_t *dp; 727 DIR *dirp; 728 int err; 729 int nocase; 730 char buf[MAXPATHLEN]; 731 732 /* 733 * The readdirfunc declaration can't be prototyped, because it is 734 * assigned, below, to two functions which are prototyped in glob.h 735 * and dirent.h as taking pointers to differently typed opaque 736 * structures. 737 */ 738 Direntry_t *(*readdirfunc)(DIR*); 739 740 if (pathend > pathend_last) 741 return (1); 742 *pathend = BG_EOS; 743 errno = 0; 744 745 #ifdef VMS 746 { 747 Char *q = pathend; 748 if (q - pathbuf > 5) { 749 q -= 5; 750 if (q[0] == '.' && 751 tolower(q[1]) == 'd' && tolower(q[2]) == 'i' && 752 tolower(q[3]) == 'r' && q[4] == '/') 753 { 754 q[0] = '/'; 755 q[1] = BG_EOS; 756 pathend = q+1; 757 } 758 } 759 } 760 #endif 761 762 if ((dirp = g_opendir(pathbuf, pglob)) == NULL) { 763 /* TODO: don't call for ENOENT or ENOTDIR? */ 764 if (pglob->gl_errfunc) { 765 if (g_Ctoc(pathbuf, buf, sizeof(buf))) 766 return (GLOB_ABEND); 767 if (pglob->gl_errfunc(buf, errno) || 768 (pglob->gl_flags & GLOB_ERR)) 769 return (GLOB_ABEND); 770 } 771 return(0); 772 } 773 774 err = 0; 775 nocase = ((pglob->gl_flags & GLOB_NOCASE) != 0); 776 777 /* Search directory for matching names. */ 778 if (pglob->gl_flags & GLOB_ALTDIRFUNC) 779 readdirfunc = (Direntry_t *(*)(DIR *))pglob->gl_readdir; 780 else 781 readdirfunc = (Direntry_t *(*)(DIR *))my_readdir; 782 while ((dp = (*readdirfunc)(dirp))) { 783 register U8 *sc; 784 register Char *dc; 785 786 /* Initial BG_DOT must be matched literally. */ 787 if (dp->d_name[0] == BG_DOT && *pattern != BG_DOT) 788 continue; 789 dc = pathend; 790 sc = (U8 *) dp->d_name; 791 while (dc < pathend_last && (*dc++ = *sc++) != BG_EOS) 792 ; 793 if (dc >= pathend_last) { 794 *dc = BG_EOS; 795 err = 1; 796 break; 797 } 798 799 if (!match(pathend, pattern, restpattern, nocase)) { 800 *pathend = BG_EOS; 801 continue; 802 } 803 err = glob2(pathbuf, pathbuf_last, --dc, pathend_last, 804 restpattern, restpattern_last, pglob, limitp); 805 if (err) 806 break; 807 } 808 809 if (pglob->gl_flags & GLOB_ALTDIRFUNC) 810 (*pglob->gl_closedir)(dirp); 811 else 812 PerlDir_close(dirp); 813 return(err); 814 } 815 816 817 /* 818 * Extend the gl_pathv member of a glob_t structure to accomodate a new item, 819 * add the new item, and update gl_pathc. 820 * 821 * This assumes the BSD realloc, which only copies the block when its size 822 * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic 823 * behavior. 824 * 825 * Return 0 if new item added, error code if memory couldn't be allocated. 826 * 827 * Invariant of the glob_t structure: 828 * Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and 829 * gl_pathv points to (gl_offs + gl_pathc + 1) items. 830 */ 831 static int 832 globextend(const Char *path, glob_t *pglob, size_t *limitp) 833 { 834 register char **pathv; 835 register int i; 836 STRLEN newsize, len; 837 char *copy; 838 const Char *p; 839 840 #ifdef GLOB_DEBUG 841 printf("Adding "); 842 for (p = path; *p; p++) 843 (void)printf("%c", CHAR(*p)); 844 printf("\n"); 845 #endif /* GLOB_DEBUG */ 846 847 newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs); 848 if (pglob->gl_pathv) 849 pathv = Renew(pglob->gl_pathv,newsize,char*); 850 else 851 Newx(pathv,newsize,char*); 852 if (pathv == NULL) { 853 if (pglob->gl_pathv) { 854 Safefree(pglob->gl_pathv); 855 pglob->gl_pathv = NULL; 856 } 857 return(GLOB_NOSPACE); 858 } 859 860 if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) { 861 /* first time around -- clear initial gl_offs items */ 862 pathv += pglob->gl_offs; 863 for (i = pglob->gl_offs; --i >= 0; ) 864 *--pathv = NULL; 865 } 866 pglob->gl_pathv = pathv; 867 868 for (p = path; *p++;) 869 ; 870 len = (STRLEN)(p - path); 871 *limitp += len; 872 Newx(copy, p-path, char); 873 if (copy != NULL) { 874 if (g_Ctoc(path, copy, len)) { 875 Safefree(copy); 876 return(GLOB_NOSPACE); 877 } 878 pathv[pglob->gl_offs + pglob->gl_pathc++] = copy; 879 } 880 pathv[pglob->gl_offs + pglob->gl_pathc] = NULL; 881 882 if ((pglob->gl_flags & GLOB_LIMIT) && 883 newsize + *limitp >= ARG_MAX) { 884 errno = 0; 885 return(GLOB_NOSPACE); 886 } 887 888 return(copy == NULL ? GLOB_NOSPACE : 0); 889 } 890 891 892 /* 893 * pattern matching function for filenames. Each occurrence of the * 894 * pattern causes a recursion level. 895 */ 896 static int 897 match(register Char *name, register Char *pat, register Char *patend, int nocase) 898 { 899 int ok, negate_range; 900 Char c, k; 901 902 while (pat < patend) { 903 c = *pat++; 904 switch (c & M_MASK) { 905 case M_ALL: 906 if (pat == patend) 907 return(1); 908 do 909 if (match(name, pat, patend, nocase)) 910 return(1); 911 while (*name++ != BG_EOS) 912 ; 913 return(0); 914 case M_ONE: 915 if (*name++ == BG_EOS) 916 return(0); 917 break; 918 case M_SET: 919 ok = 0; 920 if ((k = *name++) == BG_EOS) 921 return(0); 922 if ((negate_range = ((*pat & M_MASK) == M_NOT)) != BG_EOS) 923 ++pat; 924 while (((c = *pat++) & M_MASK) != M_END) 925 if ((*pat & M_MASK) == M_RNG) { 926 if (nocase) { 927 if (tolower(c) <= tolower(k) && tolower(k) <= tolower(pat[1])) 928 ok = 1; 929 } else { 930 if (c <= k && k <= pat[1]) 931 ok = 1; 932 } 933 pat += 2; 934 } else if (nocase ? (tolower(c) == tolower(k)) : (c == k)) 935 ok = 1; 936 if (ok == negate_range) 937 return(0); 938 break; 939 default: 940 k = *name++; 941 if (nocase ? (tolower(k) != tolower(c)) : (k != c)) 942 return(0); 943 break; 944 } 945 } 946 return(*name == BG_EOS); 947 } 948 949 /* Free allocated data belonging to a glob_t structure. */ 950 void 951 bsd_globfree(glob_t *pglob) 952 { 953 register int i; 954 register char **pp; 955 956 if (pglob->gl_pathv != NULL) { 957 pp = pglob->gl_pathv + pglob->gl_offs; 958 for (i = pglob->gl_pathc; i--; ++pp) 959 if (*pp) 960 Safefree(*pp); 961 Safefree(pglob->gl_pathv); 962 pglob->gl_pathv = NULL; 963 } 964 } 965 966 static DIR * 967 g_opendir(register Char *str, glob_t *pglob) 968 { 969 char buf[MAXPATHLEN]; 970 971 if (!*str) { 972 my_strlcpy(buf, ".", sizeof(buf)); 973 } else { 974 if (g_Ctoc(str, buf, sizeof(buf))) 975 return(NULL); 976 } 977 978 if (pglob->gl_flags & GLOB_ALTDIRFUNC) 979 return((DIR*)(*pglob->gl_opendir)(buf)); 980 981 return(PerlDir_open(buf)); 982 } 983 984 static int 985 g_lstat(register Char *fn, Stat_t *sb, glob_t *pglob) 986 { 987 char buf[MAXPATHLEN]; 988 989 if (g_Ctoc(fn, buf, sizeof(buf))) 990 return(-1); 991 if (pglob->gl_flags & GLOB_ALTDIRFUNC) 992 return((*pglob->gl_lstat)(buf, sb)); 993 #ifdef HAS_LSTAT 994 return(PerlLIO_lstat(buf, sb)); 995 #else 996 return(PerlLIO_stat(buf, sb)); 997 #endif /* HAS_LSTAT */ 998 } 999 1000 static int 1001 g_stat(register Char *fn, Stat_t *sb, glob_t *pglob) 1002 { 1003 char buf[MAXPATHLEN]; 1004 1005 if (g_Ctoc(fn, buf, sizeof(buf))) 1006 return(-1); 1007 if (pglob->gl_flags & GLOB_ALTDIRFUNC) 1008 return((*pglob->gl_stat)(buf, sb)); 1009 return(PerlLIO_stat(buf, sb)); 1010 } 1011 1012 static Char * 1013 g_strchr(Char *str, int ch) 1014 { 1015 do { 1016 if (*str == ch) 1017 return (str); 1018 } while (*str++); 1019 return (NULL); 1020 } 1021 1022 static int 1023 g_Ctoc(register const Char *str, char *buf, STRLEN len) 1024 { 1025 while (len--) { 1026 if ((*buf++ = (char)*str++) == BG_EOS) 1027 return (0); 1028 } 1029 return (1); 1030 } 1031 1032 #ifdef GLOB_DEBUG 1033 static void 1034 qprintf(const char *str, register Char *s) 1035 { 1036 register Char *p; 1037 1038 (void)printf("%s:\n", str); 1039 for (p = s; *p; p++) 1040 (void)printf("%c", CHAR(*p)); 1041 (void)printf("\n"); 1042 for (p = s; *p; p++) 1043 (void)printf("%c", *p & M_PROTECT ? '"' : ' '); 1044 (void)printf("\n"); 1045 for (p = s; *p; p++) 1046 (void)printf("%c", ismeta(*p) ? '_' : ' '); 1047 (void)printf("\n"); 1048 } 1049 #endif /* GLOB_DEBUG */ 1050