开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
glob.c
资源名称：wu-ftpd-2.6.0.tar.gz　[点击查看]
上传用户：zibowangxu
上传日期：2007-01-04
资源大小：331k
文件大小：12k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

glob.c：源码内容
  1. /****************************************************************************    
  2.   Copyright (c) 1999 WU-FTPD Development Group.  
  3.   All rights reserved.
  4.   
  5.   Portions Copyright (c) 1980, 1985, 1988, 1989, 1990, 1991, 1993, 1994 
  6.     The Regents of the University of California.
  7.   Portions Copyright (c) 1993, 1994 Washington University in Saint Louis. 
  8.   Portions Copyright (c) 1996, 1998 Berkeley Software Design, Inc. 
  9.   Portions Copyright (c) 1989 Massachusetts Institute of Technology. 
  10.   Portions Copyright (c) 1998 Sendmail, Inc. 
  11.   Portions Copyright (c) 1983, 1995, 1996, 1997 Eric P.  Allman. 
  12.   Portions Copyright (c) 1997 by Stan Barber. 
  13.   Portions Copyright (c) 1997 by Kent Landfield. 
  14.   Portions Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997 
  15.     Free Software Foundation, Inc.   
  16.   
  17.   Use and distribution of this software and its source code are governed  
  18.   by the terms and conditions of the WU-FTPD Software License ("LICENSE"). 
  19.   
  20.   If you did not receive a copy of the license, it may be obtained online 
  21.   at http://www.wu-ftpd.org/license.html. 
  22.   
  23.   $Id: glob.c,v 1.12 1999/10/05 02:54:42 wuftpd Exp $ 
  24.   
  25. ****************************************************************************/
  26. /*
  27.  * C-shell glob for random programs.
  28.  */
  30. #include "config.h"
  32. #include <sys/param.h>
  33. #include <sys/stat.h>
  35. #ifdef HAVE_DIRENT_H
  36. #include <dirent.h>
  37. #else
  38. #include <sys/dir.h>
  39. #endif
  41. #include <pwd.h>
  42. #include <errno.h>
  43. #include <stdio.h>
  44. #include <string.h>
  46. #include "proto.h"
  48. #define QUOTE 0200
  49. #define TRIM 0177
  50. #define eq(a,b) (strcmp(a, b)==0)
  51. #define GAVSIZ (NCARGS/6)
  52. #define isdir(d) ((d.st_mode & S_IFMT) == S_IFDIR)
  54. static char **gargv; /* Pointer to the (stack) arglist */
  55. static int gargc; /* Number args in gargv */
  56. static size_t gnleft;
  57. static short gflag;
  58. static int tglob(register char);
  60. /* Prototypes */
  62. static char *strend(register char *);
  63. static void addpath(char);
  64. static void ginit(char **);
  65. static void collect(register char *);
  66. static void acollect(register char *);
  67. static void sort(void);
  68. static void expand(char *);
  69. static void matchdir(char *);
  70. static int execbrc(char *, char *);
  71. static int match(char *, char *);
  72. static int amatch(char *, char *);
  73. static void Gcat(register char *, register char *);
  74. static void addpath(char);
  75. static void rscan(register char **, int (*f) (register char));
  76. static int tglob(register char c);
  78. void blkfree(char **);
  79. int letter(register char);
  80. int digit(register char);
  81. int gethdir(char *);
  82. int any(register int, register char *);
  83. int blklen(register char **);
  84. char **ftpglob(register char *);
  85. char *strspl(register char *, register char *);
  86. char **copyblk(register char **);
  87. char **blkcpy(char **, register char **);
  89. char *globerr;
  90. char *home;
  91. extern int errno;
  93. static int globcnt;
  95. char *globchars = "`{[*?";
  97. static char *gpath, *gpathp, *lastgpathp;
  98. static int globbed;
  99. static char *entp;
  100. static char **sortbas;
  102. char **ftpglob(register char *v)
  103. {
  104.     char agpath[BUFSIZ];
  105.     char *agargv[GAVSIZ];
  106.     char *vv[2];
  108.     fixpath(v);
  109.     if (v[0] == '')
  110. v = "*";
  111.     else if ((strlen(v) > 1) && (v[strlen(v) - 1] == '/'))
  112. v[strlen(v) - 1] = '';
  114.     vv[0] = v;
  115.     vv[1] = NULL;
  116.     globerr = NULL;
  117.     gflag = 0;
  118.     rscan(vv, tglob);
  119.     if (gflag == 0) {
  120. vv[0] = strspl(v, "");
  121. return (copyblk(vv));
  122.     }
  124.     globerr = NULL;
  125.     gpath = agpath;
  126.     gpathp = gpath;
  127.     *gpathp = 0;
  128.     lastgpathp = &gpath[sizeof agpath - 2];
  129.     ginit(agargv);
  130.     globcnt = 0;
  131.     collect(v);
  132.     if (globcnt == 0 && (gflag & 1)) {
  133. blkfree(gargv), gargv = 0;
  134. return (0);
  135.     }
  136.     else
  137. return (gargv = copyblk(gargv));
  138. }
  140. static void ginit(char **agargv)
  141. {
  143.     agargv[0] = 0;
  144.     gargv = agargv;
  145.     sortbas = agargv;
  146.     gargc = 0;
  147.     gnleft = NCARGS - 4;
  148. }
  150. static void collect(register char *as)
  151. {
  152.     if (eq(as, "{") || eq(as, "{}")) {
  153. Gcat(as, "");
  154. sort();
  155.     }
  156.     else
  157. acollect(as);
  158. }
  160. static void acollect(register char *as)
  161. {
  162.     register int ogargc = gargc;
  164.     gpathp = gpath;
  165.     *gpathp = 0;
  166.     globbed = 0;
  167.     expand(as);
  168.     if (gargc != ogargc)
  169. sort();
  170. }
  172. static void sort(void)
  173. {
  174.     register char **p1, **p2, *c;
  175.     char **Gvp = &gargv[gargc];
  177.     p1 = sortbas;
  178.     while (p1 < Gvp - 1) {
  179. p2 = p1;
  180. while (++p2 < Gvp)
  181.     if (strcmp(*p1, *p2) > 0)
  182. c = *p1, *p1 = *p2, *p2 = c;
  183. p1++;
  184.     }
  185.     sortbas = Gvp;
  186. }
  188. static void expand(char *as)
  189. {
  190.     register char *cs;
  191.     register char *sgpathp, *oldcs;
  192.     struct stat stb;
  194.     if (globerr)
  195. return;
  196.     sgpathp = gpathp;
  197.     cs = as;
  198.     if (*cs == '~' && gpathp == gpath) {
  199. addpath('~');
  200. for (cs++; letter(*cs) || digit(*cs) || *cs == '-';)
  201.     addpath(*cs++);
  202. if (!*cs || *cs == '/') {
  203.     if (gpathp != gpath + 1) {
  204. *gpathp = 0;
  205. if (gethdir(gpath + 1))
  206.     globerr = "Unknown user name after ~";
  207. (void) strcpy(gpath, gpath + 1);
  208.     }
  209.     else
  210. (void) strcpy(gpath, home);
  211.     gpathp = strend(gpath);
  212. }
  213.     }
  214.     while (!any(*cs, globchars)) {
  215. if (*cs == 0) {
  216.     if (!globbed)
  217. Gcat(gpath, "");
  218.     else if (stat(gpath, &stb) >= 0) {
  219. Gcat(gpath, "");
  220. globcnt++;
  221.     }
  222.     goto endit;
  223. }
  224. addpath(*cs++);
  225.     }
  226.     oldcs = cs;
  227.     while (cs > as && *cs != '/')
  228. cs--, gpathp--;
  229.     if (*cs == '/')
  230. cs++, gpathp++;
  231.     *gpathp = 0;
  232.     if (*oldcs == '{') {
  233. (void) execbrc(cs, ((char *) 0));
  234. return;
  235.     }
  236.     matchdir(cs);
  237.   endit:
  238.     gpathp = sgpathp;
  239.     *gpathp = 0;
  240. }
  242. static void matchdir(char *pattern)
  243. {
  244.     struct stat stb;
  246. #ifdef HAVE_DIRENT_H
  247.     register struct dirent *dp;
  248. #else
  249.     register struct direct *dp;
  250. #endif
  252.     DIR *dirp;
  254.     dirp = opendir(*gpath == '' ? "." : gpath);
  255.     if (dirp == NULL) {
  256. if (globbed)
  257.     return;
  258. goto patherr2;
  259.     }
  260. #ifdef HAVE_DIRFD
  261.     if (fstat(dirfd(dirp), &stb) < 0)
  262. #else /* HAVE_DIRFD */
  263.     if (fstat(dirp->dd_fd, &stb) < 0)
  264. #endif /* HAVE_DIRFD */
  265. goto patherr1;
  266.     if (!isdir(stb)) {
  267. errno = ENOTDIR;
  268. goto patherr1;
  269.     }
  270.     while (!globerr && ((dp = readdir(dirp)) != NULL)) {
  271. if (dp->d_ino == 0)
  272.     continue;
  273. if (match(dp->d_name, pattern)) {
  274.     Gcat(gpath, dp->d_name);
  275.     globcnt++;
  276. }
  277.     }
  278.     closedir(dirp);
  279.     return;
  281.   patherr1:
  282.     closedir(dirp);
  283.   patherr2:
  284.     globerr = "Bad directory components";
  285. }
  287. static int execbrc(char *p, char *s)
  288. {
  289.     char restbuf[BUFSIZ + 2];
  290.     register char *pe, *pm, *pl;
  291.     int brclev = 0;
  292.     char *lm, savec, *sgpathp;
  294.     for (lm = restbuf; *p != '{'; *lm++ = *p++)
  295. continue;
  296.     for (pe = ++p; *pe; pe++)
  297. switch (*pe) {
  299. case '{':
  300.     brclev++;
  301.     continue;
  303. case '}':
  304.     if (brclev == 0)
  305. goto pend;
  306.     brclev--;
  307.     continue;
  309. case '[':
  310.     for (pe++; *pe && *pe != ']'; pe++)
  311. continue;
  312.     continue;
  313. }
  314.   pend:
  315.     brclev = 0;
  316.     for (pl = pm = p; pm <= pe; pm++)
  317. switch (*pm & (QUOTE | TRIM)) {
  319. case '{':
  320.     brclev++;
  321.     continue;
  323. case '}':
  324.     if (brclev) {
  325. brclev--;
  326. continue;
  327.     }
  328.     goto doit;
  330. case ',' | QUOTE:
  331. case ',':
  332.     if (brclev)
  333. continue;
  334.   doit:
  335.     savec = *pm;
  336.     *pm = 0;
  337.     (void) strcpy(lm, pl);
  338.     (void) strcat(restbuf, pe + 1);
  339.     *pm = savec;
  340.     if (s == 0) {
  341. sgpathp = gpathp;
  342. expand(restbuf);
  343. gpathp = sgpathp;
  344. *gpathp = 0;
  345.     }
  346.     else if (amatch(s, restbuf))
  347. return (1);
  348.     sort();
  349.     pl = pm + 1;
  350.     if (brclev)
  351. return (0);
  352.     continue;
  354. case '[':
  355.     for (pm++; *pm && *pm != ']'; pm++)
  356. continue;
  357.     if (!*pm)
  358. pm--;
  359.     continue;
  360. }
  361.     if (brclev)
  362. goto doit;
  363.     return (0);
  364. }
  366. static int match(char *s, char *p)
  367. {
  368.     register int c;
  369.     register char *sentp;
  370.     char sglobbed = globbed;
  372.     if (*s == '.' && *p != '.')
  373. return (0);
  374.     sentp = entp;
  375.     entp = s;
  376.     c = amatch(s, p);
  377.     entp = sentp;
  378.     globbed = sglobbed;
  379.     return (c);
  380. }
  382. static int amatch(char *s, char *p)
  383. {
  384.     register int scc;
  385.     int ok, lc;
  386.     char *sgpathp;
  387.     struct stat stb;
  388.     int c, cc;
  390.     globbed = 1;
  391.     for (;;) {
  392. scc = *s++ & TRIM;
  393. switch (c = *p++) {
  395. case '{':
  396.     return (execbrc(p - 1, s - 1));
  398. case '[':
  399.     ok = 0;
  400.     lc = 077777;
  401.     while ((cc = *p++)) {
  402. if (cc == ']') {
  403.     if (ok)
  404. break;
  405.     return (0);
  406. }
  407. if (cc == '-') {
  408.     if (lc <= scc && scc <= *p++)
  409. ok++;
  410. }
  411. else if (scc == (lc = cc))
  412.     ok++;
  413.     }
  414.     if (cc == 0)
  415. if (ok)
  416.     p--;
  417. else
  418.     return 0;
  419.     continue;
  421. case '*':
  422.     if (!*p)
  423. return (1);
  424.     if (*p == '/') {
  425. p++;
  426. goto slash;
  427.     }
  428.     s--;
  429.     do {
  430. if (amatch(s, p))
  431.     return (1);
  432.     } while (*s++);
  433.     return (0);
  435. case 0:
  436.     return (scc == 0);
  438. default:
  439.     if (c != scc)
  440. return (0);
  441.     continue;
  443. case '?':
  444.     if (scc == 0)
  445. return (0);
  446.     continue;
  448. case '/':
  449.     if (scc)
  450. return (0);
  451.   slash:
  452.     s = entp;
  453.     sgpathp = gpathp;
  454.     while (*s)
  455. addpath(*s++);
  456.     addpath('/');
  457.     if (stat(gpath, &stb) == 0 && isdir(stb))
  458. if (*p == 0) {
  459.     Gcat(gpath, "");
  460.     globcnt++;
  461. }
  462. else
  463.     expand(p);
  464.     gpathp = sgpathp;
  465.     *gpathp = 0;
  466.     return (0);
  467. }
  468.     }
  469. }
  471. /* This function appears to be unused, so why waste time and space on it? */
  472. #if 0 == 1
  473. static int Gmatch(register char *s, register char *p)
  474. {
  475.     register int scc;
  476.     int ok, lc;
  477.     int c, cc;
  479.     for (;;) {
  480. scc = *s++ & TRIM;
  481. switch (c = *p++) {
  483. case '[':
  484.     ok = 0;
  485.     lc = 077777;
  486.     while (cc = *p++) {
  487. if (cc == ']') {
  488.     if (ok)
  489. break;
  490.     return (0);
  491. }
  492. if (cc == '-') {
  493.     if (lc <= scc && scc <= *p++)
  494. ok++;
  495. }
  496. else if (scc == (lc = cc))
  497.     ok++;
  498.     }
  499.     if (cc == 0)
  500. if (ok)
  501.     p--;
  502. else
  503.     return 0;
  504.     continue;
  506. case '*':
  507.     if (!*p)
  508. return (1);
  509.     for (s--; *s; s++)
  510. if (Gmatch(s, p))
  511.     return (1);
  512.     return (0);
  514. case 0:
  515.     return (scc == 0);
  517. default:
  518.     if ((c & TRIM) != scc)
  519. return (0);
  520.     continue;
  522. case '?':
  523.     if (scc == 0)
  524. return (0);
  525.     continue;
  527. }
  528.     }
  529. }
  530. #endif /* Gmatch exclusion */
  532. static void Gcat(register char *s1, register char *s2)
  533. {
  534.     register size_t len = strlen(s1) + strlen(s2) + 1;
  536.     if (len >= gnleft || gargc >= GAVSIZ - 1)
  537. globerr = "Arguments too long";
  538.     else {
  539. gargc++;
  540. gnleft -= len;
  541. gargv[gargc] = 0;
  542. gargv[gargc - 1] = strspl(s1, s2);
  543.     }
  544. }
  546. static void addpath(char c)
  547. {
  549.     if (gpathp >= lastgpathp)
  550. globerr = "Pathname too long";
  551.     else {
  552. *gpathp++ = c;
  553. *gpathp = 0;
  554.     }
  555. }
  557. static void rscan(register char **t, int (*f) (register char))
  558. {
  559.     register char *p, c;
  561.     while ((p = *t++)) {
  562. if (*p == '~')
  563.     gflag |= 2;
  564. else if (eq(p, "{") || eq(p, "{}"))
  565.     continue;
  566. while ((c = *p++))
  567.     (*f) (c);
  568.     }
  569. }
  570. static int tglob(register char c)
  571. {
  572.     if (any(c, globchars))
  573. gflag |= c == '{' ? 2 : 1;
  574.     return (c);
  575. }
  577. int letter(register char c)
  578. {
  579.     return (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))
  580.     || (c == '_'));
  581. }
  583. int digit(register char c)
  584. {
  585.     return (c >= '0' && c <= '9');
  586. }
  588. int any(register int c, register char *s)
  589. {
  590.     while (*s)
  591. if (*s++ == c)
  592.     return (1);
  593.     return (0);
  594. }
  596. int blklen(register char **av)
  597. {
  598.     register int i = 0;
  600.     while (*av++)
  601. i++;
  602.     return (i);
  603. }
  605. char **blkcpy(char **oav, register char **bv)
  606. {
  607.     register char **av = oav;
  609.     while ((*av++ = *bv++))
  610. continue;
  611.     return (oav);
  612. }
  614. void blkfree(char **av0)
  615. {
  616.     register char **av = av0;
  618.     while (*av)
  619. free(*av++);
  620. }
  622. char *strspl(register char *cp, register char *dp)
  623. {
  624.     register char *ep =
  625.     (char *) malloc((unsigned) (strlen(cp) + strlen(dp) + 1));
  627.     if (ep == (char *) 0)
  628. fatal("Out of memory");
  629.     (void) strcpy(ep, cp);
  630.     (void) strcat(ep, dp);
  631.     return (ep);
  632. }
  634. char **copyblk(register char **v)
  635. {
  636.     register char **nv = (char **) malloc((unsigned) ((blklen(v) + 1) *
  637.       sizeof(char **)));
  638.     if (nv == (char **) 0)
  639. fatal("Out of memory");
  641.     return (blkcpy(nv, v));
  642. }
  644. static char *strend(register char *cp)
  645. {
  646.     while (*cp)
  647. cp++;
  648.     return (cp);
  649. }
  650. /*
  651.  * Extract a home directory from the password file
  652.  * The argument points to a buffer where the name of the
  653.  * user whose home directory is sought is currently.
  654.  * We write the home directory of the user back there.
  655.  */
  656. int gethdir(char *home)
  657. {
  658.     register struct passwd *pp = getpwnam(home);
  659.     register char *root = NULL;
  660.     if (!pp || home + strlen(pp->pw_dir) >= lastgpathp)
  661. return (1);
  662.     root = strstr(pp->pw_dir, "/./");
  663.     (void) strcpy(home, root ? (root + 2) : pp->pw_dir);
  665.     return (0);
  666. }