Home | History | Annotate | Line # | Download | only in rdist
expand.c revision 1.1 
      1 /*
      2  * Copyright (c) 1983 Regents of the University of California.
      3  * All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  * 3. All advertising materials mentioning features or use of this software
     14  *    must display the following acknowledgement:
     15  *	This product includes software developed by the University of
     16  *	California, Berkeley and its contributors.
     17  * 4. Neither the name of the University nor the names of its contributors
     18  *    may be used to endorse or promote products derived from this software
     19  *    without specific prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     31  * SUCH DAMAGE.
     32  */
     33 
     34 #ifndef lint
     35 static char sccsid[] = "@(#)expand.c	5.6 (Berkeley) 6/1/90";
     36 #endif /* not lint */
     37 
     38 #include "defs.h"
     39 
     40 #define	GAVSIZ	NCARGS / 6
     41 #define LC '{'
     42 #define RC '}'
     43 
     44 static char	shchars[] = "${[*?";
     45 
     46 int	which;		/* bit mask of types to expand */
     47 int	eargc;		/* expanded arg count */
     48 char	**eargv;	/* expanded arg vectors */
     49 char	*path;
     50 char	*pathp;
     51 char	*lastpathp;
     52 char	*tilde;		/* "~user" if not expanding tilde, else "" */
     53 char	*tpathp;
     54 int	nleft;
     55 
     56 int	expany;		/* any expansions done? */
     57 char	*entp;
     58 char	**sortbase;
     59 
     60 char	*index();
     61 int	argcmp();
     62 
     63 #define sort()	qsort((char *)sortbase, &eargv[eargc] - sortbase, \
     64 		      sizeof(*sortbase), argcmp), sortbase = &eargv[eargc]
     65 
     66 /*
     67  * Take a list of names and expand any macros, etc.
     68  * wh = E_VARS if expanding variables.
     69  * wh = E_SHELL if expanding shell characters.
     70  * wh = E_TILDE if expanding `~'.
     71  * or any of these or'ed together.
     72  *
     73  * Major portions of this were snarfed from csh/sh.glob.c.
     74  */
     75 struct namelist *
     76 expand(list, wh)
     77 	struct namelist *list;
     78 	int wh;
     79 {
     80 	register struct namelist *nl, *prev;
     81 	register int n;
     82 	char pathbuf[BUFSIZ];
     83 	char *argvbuf[GAVSIZ];
     84 
     85 	if (debug) {
     86 		printf("expand(%x, %d)\nlist = ", list, wh);
     87 		prnames(list);
     88 	}
     89 
     90 	if (wh == 0) {
     91 		register char *cp;
     92 
     93 		for (nl = list; nl != NULL; nl = nl->n_next)
     94 			for (cp = nl->n_name; *cp; cp++)
     95 				*cp = *cp & TRIM;
     96 		return(list);
     97 	}
     98 
     99 	which = wh;
    100 	path = tpathp = pathp = pathbuf;
    101 	*pathp = '\0';
    102 	lastpathp = &path[sizeof pathbuf - 2];
    103 	tilde = "";
    104 	eargc = 0;
    105 	eargv = sortbase = argvbuf;
    106 	*eargv = 0;
    107 	nleft = NCARGS - 4;
    108 	/*
    109 	 * Walk the name list and expand names into eargv[];
    110 	 */
    111 	for (nl = list; nl != NULL; nl = nl->n_next)
    112 		expstr(nl->n_name);
    113 	/*
    114 	 * Take expanded list of names from eargv[] and build a new list.
    115 	 */
    116 	list = prev = NULL;
    117 	for (n = 0; n < eargc; n++) {
    118 		nl = makenl(NULL);
    119 		nl->n_name = eargv[n];
    120 		if (prev == NULL)
    121 			list = prev = nl;
    122 		else {
    123 			prev->n_next = nl;
    124 			prev = nl;
    125 		}
    126 	}
    127 	if (debug) {
    128 		printf("expanded list = ");
    129 		prnames(list);
    130 	}
    131 	return(list);
    132 }
    133 
    134 expstr(s)
    135 	char *s;
    136 {
    137 	register char *cp, *cp1;
    138 	register struct namelist *tp;
    139 	char *tail;
    140 	char buf[BUFSIZ];
    141 	int savec, oeargc;
    142 	extern char homedir[];
    143 
    144 	if (s == NULL || *s == '\0')
    145 		return;
    146 
    147 	if ((which & E_VARS) && (cp = index(s, '$')) != NULL) {
    148 		*cp++ = '\0';
    149 		if (*cp == '\0') {
    150 			yyerror("no variable name after '$'");
    151 			return;
    152 		}
    153 		if (*cp == LC) {
    154 			cp++;
    155 			if ((tail = index(cp, RC)) == NULL) {
    156 				yyerror("unmatched '{'");
    157 				return;
    158 			}
    159 			*tail++ = savec = '\0';
    160 			if (*cp == '\0') {
    161 				yyerror("no variable name after '$'");
    162 				return;
    163 			}
    164 		} else {
    165 			tail = cp + 1;
    166 			savec = *tail;
    167 			*tail = '\0';
    168 		}
    169 		tp = lookup(cp, NULL, 0);
    170 		if (savec != '\0')
    171 			*tail = savec;
    172 		if (tp != NULL) {
    173 			for (; tp != NULL; tp = tp->n_next) {
    174 				sprintf(buf, "%s%s%s", s, tp->n_name, tail);
    175 				expstr(buf);
    176 			}
    177 			return;
    178 		}
    179 		sprintf(buf, "%s%s", s, tail);
    180 		expstr(buf);
    181 		return;
    182 	}
    183 	if ((which & ~E_VARS) == 0 || !strcmp(s, "{") || !strcmp(s, "{}")) {
    184 		Cat(s, "");
    185 		sort();
    186 		return;
    187 	}
    188 	if (*s == '~') {
    189 		cp = ++s;
    190 		if (*cp == '\0' || *cp == '/') {
    191 			tilde = "~";
    192 			cp1 = homedir;
    193 		} else {
    194 			tilde = cp1 = buf;
    195 			*cp1++ = '~';
    196 			do
    197 				*cp1++ = *cp++;
    198 			while (*cp && *cp != '/');
    199 			*cp1 = '\0';
    200 			if (pw == NULL || strcmp(pw->pw_name, buf+1) != 0) {
    201 				if ((pw = getpwnam(buf+1)) == NULL) {
    202 					strcat(buf, ": unknown user name");
    203 					yyerror(buf+1);
    204 					return;
    205 				}
    206 			}
    207 			cp1 = pw->pw_dir;
    208 			s = cp;
    209 		}
    210 		for (cp = path; *cp++ = *cp1++; )
    211 			;
    212 		tpathp = pathp = cp - 1;
    213 	} else {
    214 		tpathp = pathp = path;
    215 		tilde = "";
    216 	}
    217 	*pathp = '\0';
    218 	if (!(which & E_SHELL)) {
    219 		if (which & E_TILDE)
    220 			Cat(path, s);
    221 		else
    222 			Cat(tilde, s);
    223 		sort();
    224 		return;
    225 	}
    226 	oeargc = eargc;
    227 	expany = 0;
    228 	expsh(s);
    229 	if (eargc == oeargc)
    230 		Cat(s, "");		/* "nonomatch" is set */
    231 	sort();
    232 }
    233 
    234 static
    235 argcmp(a1, a2)
    236 	char **a1, **a2;
    237 {
    238 
    239 	return (strcmp(*a1, *a2));
    240 }
    241 
    242 /*
    243  * If there are any Shell meta characters in the name,
    244  * expand into a list, after searching directory
    245  */
    246 expsh(s)
    247 	char *s;
    248 {
    249 	register char *cp;
    250 	register char *spathp, *oldcp;
    251 	struct stat stb;
    252 
    253 	spathp = pathp;
    254 	cp = s;
    255 	while (!any(*cp, shchars)) {
    256 		if (*cp == '\0') {
    257 			if (!expany || stat(path, &stb) >= 0) {
    258 				if (which & E_TILDE)
    259 					Cat(path, "");
    260 				else
    261 					Cat(tilde, tpathp);
    262 			}
    263 			goto endit;
    264 		}
    265 		addpath(*cp++);
    266 	}
    267 	oldcp = cp;
    268 	while (cp > s && *cp != '/')
    269 		cp--, pathp--;
    270 	if (*cp == '/')
    271 		cp++, pathp++;
    272 	*pathp = '\0';
    273 	if (*oldcp == '{') {
    274 		execbrc(cp, NULL);
    275 		return;
    276 	}
    277 	matchdir(cp);
    278 endit:
    279 	pathp = spathp;
    280 	*pathp = '\0';
    281 }
    282 
    283 matchdir(pattern)
    284 	char *pattern;
    285 {
    286 	struct stat stb;
    287 	register struct direct *dp;
    288 	DIR *dirp;
    289 
    290 	dirp = opendir(path);
    291 	if (dirp == NULL) {
    292 		if (expany)
    293 			return;
    294 		goto patherr2;
    295 	}
    296 	if (fstat(dirp->dd_fd, &stb) < 0)
    297 		goto patherr1;
    298 	if (!ISDIR(stb.st_mode)) {
    299 		errno = ENOTDIR;
    300 		goto patherr1;
    301 	}
    302 	while ((dp = readdir(dirp)) != NULL)
    303 		if (match(dp->d_name, pattern)) {
    304 			if (which & E_TILDE)
    305 				Cat(path, dp->d_name);
    306 			else {
    307 				strcpy(pathp, dp->d_name);
    308 				Cat(tilde, tpathp);
    309 				*pathp = '\0';
    310 			}
    311 		}
    312 	closedir(dirp);
    313 	return;
    314 
    315 patherr1:
    316 	closedir(dirp);
    317 patherr2:
    318 	strcat(path, ": ");
    319 	strcat(path, strerror(errno));
    320 	yyerror(path);
    321 }
    322 
    323 execbrc(p, s)
    324 	char *p, *s;
    325 {
    326 	char restbuf[BUFSIZ + 2];
    327 	register char *pe, *pm, *pl;
    328 	int brclev = 0;
    329 	char *lm, savec, *spathp;
    330 
    331 	for (lm = restbuf; *p != '{'; *lm++ = *p++)
    332 		continue;
    333 	for (pe = ++p; *pe; pe++)
    334 		switch (*pe) {
    335 
    336 		case '{':
    337 			brclev++;
    338 			continue;
    339 
    340 		case '}':
    341 			if (brclev == 0)
    342 				goto pend;
    343 			brclev--;
    344 			continue;
    345 
    346 		case '[':
    347 			for (pe++; *pe && *pe != ']'; pe++)
    348 				continue;
    349 			if (!*pe)
    350 				yyerror("Missing ']'");
    351 			continue;
    352 		}
    353 pend:
    354 	if (brclev || !*pe) {
    355 		yyerror("Missing '}'");
    356 		return (0);
    357 	}
    358 	for (pl = pm = p; pm <= pe; pm++)
    359 		switch (*pm & (QUOTE|TRIM)) {
    360 
    361 		case '{':
    362 			brclev++;
    363 			continue;
    364 
    365 		case '}':
    366 			if (brclev) {
    367 				brclev--;
    368 				continue;
    369 			}
    370 			goto doit;
    371 
    372 		case ',':
    373 			if (brclev)
    374 				continue;
    375 doit:
    376 			savec = *pm;
    377 			*pm = 0;
    378 			strcpy(lm, pl);
    379 			strcat(restbuf, pe + 1);
    380 			*pm = savec;
    381 			if (s == 0) {
    382 				spathp = pathp;
    383 				expsh(restbuf);
    384 				pathp = spathp;
    385 				*pathp = 0;
    386 			} else if (amatch(s, restbuf))
    387 				return (1);
    388 			sort();
    389 			pl = pm + 1;
    390 			continue;
    391 
    392 		case '[':
    393 			for (pm++; *pm && *pm != ']'; pm++)
    394 				continue;
    395 			if (!*pm)
    396 				yyerror("Missing ']'");
    397 			continue;
    398 		}
    399 	return (0);
    400 }
    401 
    402 match(s, p)
    403 	char *s, *p;
    404 {
    405 	register int c;
    406 	register char *sentp;
    407 	char sexpany = expany;
    408 
    409 	if (*s == '.' && *p != '.')
    410 		return (0);
    411 	sentp = entp;
    412 	entp = s;
    413 	c = amatch(s, p);
    414 	entp = sentp;
    415 	expany = sexpany;
    416 	return (c);
    417 }
    418 
    419 amatch(s, p)
    420 	register char *s, *p;
    421 {
    422 	register int scc;
    423 	int ok, lc;
    424 	char *spathp;
    425 	struct stat stb;
    426 	int c, cc;
    427 
    428 	expany = 1;
    429 	for (;;) {
    430 		scc = *s++ & TRIM;
    431 		switch (c = *p++) {
    432 
    433 		case '{':
    434 			return (execbrc(p - 1, s - 1));
    435 
    436 		case '[':
    437 			ok = 0;
    438 			lc = 077777;
    439 			while (cc = *p++) {
    440 				if (cc == ']') {
    441 					if (ok)
    442 						break;
    443 					return (0);
    444 				}
    445 				if (cc == '-') {
    446 					if (lc <= scc && scc <= *p++)
    447 						ok++;
    448 				} else
    449 					if (scc == (lc = cc))
    450 						ok++;
    451 			}
    452 			if (cc == 0) {
    453 				yyerror("Missing ']'");
    454 				return (0);
    455 			}
    456 			continue;
    457 
    458 		case '*':
    459 			if (!*p)
    460 				return (1);
    461 			if (*p == '/') {
    462 				p++;
    463 				goto slash;
    464 			}
    465 			for (s--; *s; s++)
    466 				if (amatch(s, p))
    467 					return (1);
    468 			return (0);
    469 
    470 		case '\0':
    471 			return (scc == '\0');
    472 
    473 		default:
    474 			if ((c & TRIM) != scc)
    475 				return (0);
    476 			continue;
    477 
    478 		case '?':
    479 			if (scc == '\0')
    480 				return (0);
    481 			continue;
    482 
    483 		case '/':
    484 			if (scc)
    485 				return (0);
    486 slash:
    487 			s = entp;
    488 			spathp = pathp;
    489 			while (*s)
    490 				addpath(*s++);
    491 			addpath('/');
    492 			if (stat(path, &stb) == 0 && ISDIR(stb.st_mode))
    493 				if (*p == '\0') {
    494 					if (which & E_TILDE)
    495 						Cat(path, "");
    496 					else
    497 						Cat(tilde, tpathp);
    498 				} else
    499 					expsh(p);
    500 			pathp = spathp;
    501 			*pathp = '\0';
    502 			return (0);
    503 		}
    504 	}
    505 }
    506 
    507 smatch(s, p)
    508 	register char *s, *p;
    509 {
    510 	register int scc;
    511 	int ok, lc;
    512 	int c, cc;
    513 
    514 	for (;;) {
    515 		scc = *s++ & TRIM;
    516 		switch (c = *p++) {
    517 
    518 		case '[':
    519 			ok = 0;
    520 			lc = 077777;
    521 			while (cc = *p++) {
    522 				if (cc == ']') {
    523 					if (ok)
    524 						break;
    525 					return (0);
    526 				}
    527 				if (cc == '-') {
    528 					if (lc <= scc && scc <= *p++)
    529 						ok++;
    530 				} else
    531 					if (scc == (lc = cc))
    532 						ok++;
    533 			}
    534 			if (cc == 0) {
    535 				yyerror("Missing ']'");
    536 				return (0);
    537 			}
    538 			continue;
    539 
    540 		case '*':
    541 			if (!*p)
    542 				return (1);
    543 			for (s--; *s; s++)
    544 				if (smatch(s, p))
    545 					return (1);
    546 			return (0);
    547 
    548 		case '\0':
    549 			return (scc == '\0');
    550 
    551 		default:
    552 			if ((c & TRIM) != scc)
    553 				return (0);
    554 			continue;
    555 
    556 		case '?':
    557 			if (scc == 0)
    558 				return (0);
    559 			continue;
    560 
    561 		}
    562 	}
    563 }
    564 
    565 Cat(s1, s2)
    566 	register char *s1, *s2;
    567 {
    568 	int len = strlen(s1) + strlen(s2) + 1;
    569 	register char *s;
    570 
    571 	nleft -= len;
    572 	if (nleft <= 0 || ++eargc >= GAVSIZ)
    573 		yyerror("Arguments too long");
    574 	eargv[eargc] = 0;
    575 	eargv[eargc - 1] = s = malloc(len);
    576 	if (s == NULL)
    577 		fatal("ran out of memory\n");
    578 	while (*s++ = *s1++ & TRIM)
    579 		;
    580 	s--;
    581 	while (*s++ = *s2++ & TRIM)
    582 		;
    583 }
    584 
    585 addpath(c)
    586 	char c;
    587 {
    588 
    589 	if (pathp >= lastpathp)
    590 		yyerror("Pathname too long");
    591 	else {
    592 		*pathp++ = c & TRIM;
    593 		*pathp = '\0';
    594 	}
    595 }
    596 
    597 /*
    598  * Expand file names beginning with `~' into the
    599  * user's home directory path name. Return a pointer in buf to the
    600  * part corresponding to `file'.
    601  */
    602 char *
    603 exptilde(buf, file)
    604 	char buf[];
    605 	register char *file;
    606 {
    607 	register char *s1, *s2, *s3;
    608 	extern char homedir[];
    609 
    610 	if (*file != '~') {
    611 		strcpy(buf, file);
    612 		return(buf);
    613 	}
    614 	if (*++file == '\0') {
    615 		s2 = homedir;
    616 		s3 = NULL;
    617 	} else if (*file == '/') {
    618 		s2 = homedir;
    619 		s3 = file;
    620 	} else {
    621 		s3 = file;
    622 		while (*s3 && *s3 != '/')
    623 			s3++;
    624 		if (*s3 == '/')
    625 			*s3 = '\0';
    626 		else
    627 			s3 = NULL;
    628 		if (pw == NULL || strcmp(pw->pw_name, file) != 0) {
    629 			if ((pw = getpwnam(file)) == NULL) {
    630 				error("%s: unknown user name\n", file);
    631 				if (s3 != NULL)
    632 					*s3 = '/';
    633 				return(NULL);
    634 			}
    635 		}
    636 		if (s3 != NULL)
    637 			*s3 = '/';
    638 		s2 = pw->pw_dir;
    639 	}
    640 	for (s1 = buf; *s1++ = *s2++; )
    641 		;
    642 	s2 = --s1;
    643 	if (s3 != NULL) {
    644 		s2++;
    645 		while (*s1++ = *s3++)
    646 			;
    647 	}
    648 	return(s2);
    649 }
    650