contrib/opie/glob.c

   1 /* glob.c: The csh et al glob pattern matching routines.
   2
   3 %%% copyright-cmetz-96
   4 This software is Copyright 1996-2001 by Craig Metz, All Rights Reserved.
   5 The Inner Net License Version 3 applies to this software.
   6 You should have received a copy of the license with this software. If
   7 you didn't get a copy, you may request one from <license@inner.net>.
   8
   9 Portions of this software are Copyright 1995 by Randall Atkinson and Dan
  10 McDonald, All Rights Reserved. All Rights under this copyright are assigned
  11 to the U.S. Naval Research Laboratory (NRL). The NRL Copyright Notice and
  12 License Agreement applies to this software.
  13
  14         History:
  15
  16         Modified by cmetz for OPIE 2.32. Remove include of dirent.h here; it's
  17                 done already (and conditionally) in opie_cfg.h.
  18         Modified by cmetz for OPIE 2.2. Use FUNCTION declaration et al.
  19              Remove useless strings. Prototype right.
  20         Modified at NRL for OPIE 2.0.
  21         Originally from BSD.
  22 */
  23 /*
  24  * Copyright (c) 1980 Regents of the University of California.
  25  * All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. All advertising materials mentioning features or use of this software
  36  *    must display the following acknowledgement:
  37  *      This product includes software developed by the University of
  38  *      California, Berkeley and its contributors.
  39  * 4. Neither the name of the University nor the names of its contributors
  40  *    may be used to endorse or promote products derived from this software
  41  *    without specific prior written permission.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  */
  55
  56 /*
  57  * C-shell glob for random programs.
  58  */
  59
  60 #include "opie_cfg.h"
  61
  62 #if HAVE_SYS_PARAM_H
  63 #include <sys/param.h>
  64 #endif /* HAVE_SYS_PARAM_H */
  65 #include <sys/stat.h>
  66
  67 #if HAVE_PWD_H
  68 #include <pwd.h>
  69 #endif /* HAVE_PWD_H */
  70 #include <errno.h>
  71 #include <stdio.h>
  72 #include <string.h>
  73 #if HAVE_LIMITS_H
  74 #include <limits.h>
  75 #endif /* HAVE_LIMITS_H */
  76
  77 #include "opie.h"
  78
  79 #ifndef NCARGS
  80 #define NCARGS 600
  81 #endif  /* NCARGS */
  82 #define QUOTE 0200
  83 #define TRIM 0177
  84 #define eq(a,b)         (strcmp((a),(b)) == (0))
  85 #define GAVSIZ          (NCARGS/6)
  86 #define isdir(d)        (((d.st_mode) & S_IFMT) == S_IFDIR)
  87
  88 static char **gargv;    /* Pointer to the (stack) arglist */
  89 static int gargc;       /* Number args in gargv */
  90 static int gnleft;
  91 static short gflag;
  92
  93 static int letter __P((register char));
  94 static int digit __P((register char));
  95 static int any __P((int, char *));
  96 static int blklen __P((register char **));
  97 VOIDRET blkfree __P((char **));
  98 static char *strspl __P((register char *, register char *));
  99
 100 static int tglob __P((register char c));
 101
 102 extern int errno;
 103 static char *strend __P((char *));
 104
 105 static int globcnt;
 106
 107 static char *globchars = "`{[*?";
 108 char *globerr = NULL;
 109 char *home = NULL;
 110
 111 static char *gpath, *gpathp, *lastgpathp;
 112 static int globbed;
 113 static char *entp;
 114 static char **sortbas;
 115
 116 static int amatch __P((char *p, char *s));
 117 static int execbrc __P((register char *p, register char *s));
 118 VOIDRET opiefatal __P((char *));
 119 char **copyblk __P((char **));
 120
 121 static int match FUNCTION((s, p), char *s AND char *p)
 122 {
 123   register int c;
 124   register char *sentp;
 125   char sglobbed = globbed;
 126
 127   if (*s == '.' && *p != '.')
 128     return (0);
 129   sentp = entp;
 130   entp = s;
 131   c = amatch(s, p);
 132   entp = sentp;
 133   globbed = sglobbed;
 134   return (c);
 135 }
 136
 137
 138 static int Gmatch FUNCTION((s, p), register char *s AND register char *p)
 139 {
 140   register int scc;
 141   int ok, lc;
 142   int c, cc;
 143
 144   for (;;) {
 145     scc = *s++ & TRIM;
 146     switch (c = *p++) {
 147
 148     case '[':
 149       ok = 0;
 150       lc = 077777;
 151       while (cc = *p++) {
 152         if (cc == ']') {
 153           if (ok)
 154             break;
 155           return (0);
 156         }
 157         if (cc == '-') {
 158           if (lc <= scc && scc <= *p++)
 159             ok++;
 160         } else
 161           if (scc == (lc = cc))
 162             ok++;
 163       }
 164       if (cc == 0)
 165         if (ok)
 166           p--;
 167         else
 168           return 0;
 169       continue;
 170
 171     case '*':
 172       if (!*p)
 173         return (1);
 174       for (s--; *s; s++)
 175         if (Gmatch(s, p))
 176           return (1);
 177       return (0);
 178
 179     case 0:
 180       return (scc == 0);
 181
 182     default:
 183       if ((c & TRIM) != scc)
 184         return (0);
 185       continue;
 186
 187     case '?':
 188       if (scc == 0)
 189         return (0);
 190       continue;
 191
 192     }
 193   }
 194 }
 195
 196 static VOIDRET Gcat FUNCTION((s1, s2), register char *s1 AND register char *s2)
 197 {
 198   register int len = strlen(s1) + strlen(s2) + 1;
 199
 200   if (len >= gnleft || gargc >= GAVSIZ - 1)
 201     globerr = "Arguments too long";
 202   else {
 203     gargc++;
 204     gnleft -= len;
 205     gargv[gargc] = 0;
 206     gargv[gargc - 1] = strspl(s1, s2);
 207   }
 208 }
 209
 210 static VOIDRET addpath FUNCTION((c), char c)
 211 {
 212
 213   if (gpathp >= lastgpathp)
 214     globerr = "Pathname too long";
 215   else {
 216     *gpathp++ = c;
 217     *gpathp = 0;
 218   }
 219 }
 220
 221 static VOIDRET rscan FUNCTION((t, f), register char **t AND int (*f)__P((char)))
 222 {
 223   register char *p, c;
 224
 225   while (p = *t++) {
 226     if (f == tglob)
 227       if (*p == '~')
 228         gflag |= 2;
 229       else
 230         if (eq(p, "{") || eq(p, "{}"))
 231           continue;
 232     while (c = *p++)
 233       (*f) (c);
 234   }
 235 }
 236
 237 static int tglob FUNCTION((c), register char c)
 238 {
 239   if (any(c, globchars))
 240     gflag |= c == '{' ? 2 : 1;
 241   return (c);
 242 }
 243
 244 static int letter FUNCTION((c), register char c)
 245 {
 246   return (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '_');
 247 }
 248
 249 static int digit FUNCTION((c), register char c)
 250 {
 251   return (c >= '0' && c <= '9');
 252 }
 253
 254 static int any FUNCTION((c, s), int c AND char *s)
 255 {
 256   while (*s)
 257     if (*s++ == c)
 258       return (1);
 259   return (0);
 260 }
 261
 262 static int blklen FUNCTION((av), register char **av)
 263 {
 264   register int i = 0;
 265
 266   while (*av++)
 267     i++;
 268   return (i);
 269 }
 270
 271 static char **blkcpy FUNCTION((oav, bv), char **oav AND register char **bv)
 272 {
 273   register char **av = oav;
 274
 275   while (*av++ = *bv++)
 276     continue;
 277   return (oav);
 278 }
 279
 280 VOIDRET blkfree FUNCTION((av0), char **av0)
 281 {
 282   register char **av = av0;
 283
 284   while (*av)
 285     free(*av++);
 286 }
 287
 288 static char *strspl FUNCTION((cp, dp), register char *cp AND register char *dp)
 289 {
 290   register char *ep = (char *) malloc((unsigned) (strlen(cp) +
 291                                                   strlen(dp) + 1));
 292
 293   if (ep == (char *) 0)
 294     opiefatal("Out of memory");
 295   strcpy(ep, cp);
 296   strcat(ep, dp);
 297   return (ep);
 298 }
 299
 300 char **copyblk FUNCTION((v), char **v)
 301 {
 302   register char **nv = (char **) malloc((unsigned) ((blklen(v) + 1) *
 303                                                     sizeof(char **)));
 304
 305   if (nv == (char **) 0)
 306     opiefatal("Out of memory");
 307
 308   return (blkcpy(nv, v));
 309 }
 310
 311 static char *strend FUNCTION((cp), register char *cp)
 312 {
 313
 314   while (*cp)
 315     cp++;
 316   return (cp);
 317 }
 318
 319 /*
 320  * Extract a home directory from the password file
 321  * The argument points to a buffer where the name of the
 322  * user whose home directory is sought is currently.
 323  * We write the home directory of the user back there.
 324  */
 325 static int gethdir FUNCTION((home), char *home)
 326 {
 327   register struct passwd *pp = getpwnam(home);
 328
 329   if (!pp || home + strlen(pp->pw_dir) >= lastgpathp)
 330     return (1);
 331   strcpy(home, pp->pw_dir);
 332   return (0);
 333 }
 334
 335 static VOIDRET ginit FUNCTION((agargv), char **agargv)
 336 {
 337   agargv[0] = 0;
 338   gargv = agargv;
 339   sortbas = agargv;
 340   gargc = 0;
 341   gnleft = NCARGS - 4;
 342 }
 343
 344 static VOIDRET sort FUNCTION_NOARGS
 345 {
 346   register char **p1, **p2, *c;
 347   char **Gvp = &gargv[gargc];
 348
 349   p1 = sortbas;
 350   while (p1 < Gvp - 1) {
 351     p2 = p1;
 352     while (++p2 < Gvp)
 353       if (strcmp(*p1, *p2) > 0)
 354         c = *p1, *p1 = *p2, *p2 = c;
 355     p1++;
 356   }
 357   sortbas = Gvp;
 358 }
 359
 360 static VOIDRET matchdir FUNCTION((pattern), char *pattern)
 361 {
 362   struct stat stb;
 363
 364   register struct dirent *dp;
 365
 366   DIR *dirp;
 367
 368   dirp = opendir(*gpath == '\0' ? "." : gpath);
 369   if (dirp == NULL) {
 370     if (globbed)
 371       return;
 372     goto patherr2;
 373   }
 374 #if !defined(linux)
 375   if (fstat(dirp->dd_fd, &stb) < 0)
 376     goto patherr1;
 377   if (!isdir(stb)) {
 378     errno = ENOTDIR;
 379     goto patherr1;
 380   }
 381 #endif /* !defined(linux) */
 382   while ((dp = readdir(dirp)) != NULL) {
 383     if (dp->d_ino == 0)
 384       continue;
 385     if (match(dp->d_name, pattern)) {
 386       Gcat(gpath, dp->d_name);
 387       globcnt++;
 388     }
 389   }
 390   closedir(dirp);
 391   return;
 392
 393 patherr1:
 394   closedir(dirp);
 395 patherr2:
 396   globerr = "Bad directory components";
 397 }
 398
 399 static VOIDRET expand FUNCTION((as), char *as)
 400 {
 401   register char *cs;
 402   register char *sgpathp, *oldcs;
 403   struct stat stb;
 404
 405   sgpathp = gpathp;
 406   cs = as;
 407   if (*cs == '~' && gpathp == gpath) {
 408     addpath('~');
 409     for (cs++; letter(*cs) || digit(*cs) || *cs == '-';)
 410       addpath(*cs++);
 411     if (!*cs || *cs == '/') {
 412       if (gpathp != gpath + 1) {
 413         *gpathp = 0;
 414         if (gethdir(gpath + 1))
 415           globerr = "Unknown user name after ~";
 416         strcpy(gpath, gpath + 1);
 417       } else
 418         strcpy(gpath, home);
 419       gpathp = strend(gpath);
 420     }
 421   }
 422   while (!any(*cs, globchars)) {
 423     if (*cs == 0) {
 424       if (!globbed)
 425         Gcat(gpath, "");
 426       else
 427         if (stat(gpath, &stb) >= 0) {
 428           Gcat(gpath, "");
 429           globcnt++;
 430         }
 431       goto endit;
 432     }
 433     addpath(*cs++);
 434   }
 435   oldcs = cs;
 436   while (cs > as && *cs != '/')
 437     cs--, gpathp--;
 438   if (*cs == '/')
 439     cs++, gpathp++;
 440   *gpathp = 0;
 441   if (*oldcs == '{') {
 442     execbrc(cs, ((char *) 0));
 443     return;
 444   }
 445   matchdir(cs);
 446 endit:
 447   gpathp = sgpathp;
 448   *gpathp = 0;
 449 }
 450
 451 static int execbrc FUNCTION((p, s), char *p AND char *s)
 452 {
 453   char restbuf[BUFSIZ + 2];
 454   register char *pe, *pm, *pl;
 455   int brclev = 0;
 456   char *lm, savec, *sgpathp;
 457
 458   for (lm = restbuf; *p != '{'; *lm++ = *p++)
 459     continue;
 460   for (pe = ++p; *pe; pe++)
 461     switch (*pe) {
 462
 463     case '{':
 464       brclev++;
 465       continue;
 466
 467     case '}':
 468       if (brclev == 0)
 469         goto pend;
 470       brclev--;
 471       continue;
 472
 473     case '[':
 474       for (pe++; *pe && *pe != ']'; pe++)
 475         continue;
 476       continue;
 477     }
 478 pend:
 479   brclev = 0;
 480   for (pl = pm = p; pm <= pe; pm++)
 481     switch (*pm & (QUOTE | TRIM)) {
 482
 483     case '{':
 484       brclev++;
 485       continue;
 486
 487     case '}':
 488       if (brclev) {
 489         brclev--;
 490         continue;
 491       }
 492       goto doit;
 493
 494     case ',' | QUOTE:
 495     case ',':
 496       if (brclev)
 497         continue;
 498   doit:
 499       savec = *pm;
 500       *pm = 0;
 501       strcpy(lm, pl);
 502       strcat(restbuf, pe + 1);
 503       *pm = savec;
 504       if (s == 0) {
 505         sgpathp = gpathp;
 506         expand(restbuf);
 507         gpathp = sgpathp;
 508         *gpathp = 0;
 509       } else
 510         if (amatch(s, restbuf))
 511           return (1);
 512       sort();
 513       pl = pm + 1;
 514       if (brclev)
 515         return (0);
 516       continue;
 517
 518     case '[':
 519       for (pm++; *pm && *pm != ']'; pm++)
 520         continue;
 521       if (!*pm)
 522         pm--;
 523       continue;
 524     }
 525   if (brclev)
 526     goto doit;
 527   return (0);
 528 }
 529
 530 static VOIDRET acollect FUNCTION((as), register char *as)
 531 {
 532   register int ogargc = gargc;
 533
 534   gpathp = gpath;
 535   *gpathp = 0;
 536   globbed = 0;
 537   expand(as);
 538   if (gargc != ogargc)
 539     sort();
 540 }
 541
 542 static VOIDRET collect FUNCTION((as), register char *as)
 543 {
 544   if (eq(as, "{") || eq(as, "{}")) {
 545     Gcat(as, "");
 546     sort();
 547   } else
 548     acollect(as);
 549 }
 550
 551 static int amatch FUNCTION((s, p), register char *s AND register char *p)
 552 {
 553   register int scc;
 554   int ok, lc;
 555   char *sgpathp;
 556   struct stat stb;
 557   int c, cc;
 558
 559   globbed = 1;
 560   for (;;) {
 561     scc = *s++ & TRIM;
 562     switch (c = *p++) {
 563
 564     case '{':
 565       return (execbrc(p - 1, s - 1));
 566
 567     case '[':
 568       ok = 0;
 569       lc = 077777;
 570       while (cc = *p++) {
 571         if (cc == ']') {
 572           if (ok)
 573             break;
 574           return (0);
 575         }
 576         if (cc == '-') {
 577           if (lc <= scc && scc <= *p++)
 578             ok++;
 579         } else
 580           if (scc == (lc = cc))
 581             ok++;
 582       }
 583       if (cc == 0)
 584         if (ok)
 585           p--;
 586         else
 587           return 0;
 588       continue;
 589
 590     case '*':
 591       if (!*p)
 592         return (1);
 593       if (*p == '/') {
 594         p++;
 595         goto slash;
 596       }
 597       s--;
 598       do {
 599         if (amatch(s, p))
 600           return (1);
 601       }
 602       while (*s++);
 603       return (0);
 604
 605     case 0:
 606       return (scc == 0);
 607
 608     default:
 609       if (c != scc)
 610         return (0);
 611       continue;
 612
 613     case '?':
 614       if (scc == 0)
 615         return (0);
 616       continue;
 617
 618     case '/':
 619       if (scc)
 620         return (0);
 621   slash:
 622       s = entp;
 623       sgpathp = gpathp;
 624       while (*s)
 625         addpath(*s++);
 626       addpath('/');
 627       if (stat(gpath, &stb) == 0 && isdir(stb))
 628         if (*p == 0) {
 629           Gcat(gpath, "");
 630           globcnt++;
 631         } else
 632           expand(p);
 633       gpathp = sgpathp;
 634       *gpathp = 0;
 635       return (0);
 636     }
 637   }
 638 }
 639
 640
 641 char **ftpglob FUNCTION((v), register char *v)
 642 {
 643   char agpath[BUFSIZ];
 644   char *agargv[GAVSIZ];
 645   char *vv[2];
 646
 647   vv[0] = v;
 648   vv[1] = 0;
 649   gflag = 0;
 650   rscan(vv, tglob);
 651   if (gflag == 0) {
 652     vv[0] = strspl(v, "");
 653     return (copyblk(vv));
 654   }
 655   globerr = 0;
 656   gpath = agpath;
 657   gpathp = gpath;
 658   *gpathp = 0;
 659   lastgpathp = &gpath[sizeof agpath - 2];
 660   ginit(agargv);
 661   globcnt = 0;
 662   collect(v);
 663   if (globcnt == 0 && (gflag & 1)) {
 664     blkfree(gargv), gargv = 0;
 665     return (0);
 666   } else
 667     return (gargv = copyblk(gargv));
 668 }