1 /* $NetBSD: misc.c,v 1.15 2011/10/16 17:12:11 joerg Exp $ */
2
3 /*
4 * Miscellaneous functions
5 */
6 #include <sys/cdefs.h>
7
8 #ifndef lint
9 __RCSID("$NetBSD: misc.c,v 1.15 2011/10/16 17:12:11 joerg Exp $");
10 #endif
11
12
13 #include "sh.h"
14 #include <ctype.h> /* for FILECHCONV */
15 #ifdef HAVE_LIMITS_H
16 # include <limits.h>
17 #endif
18
19 #ifndef UCHAR_MAX
20 # define UCHAR_MAX 0xFF
21 #endif
22
23 short ctypes [UCHAR_MAX+1]; /* type bits for unsigned char */
24
25 static int do_gmatch ARGS((const unsigned char *s, const unsigned char *p,
26 const unsigned char *se, const unsigned char *pe,
27 int isfile));
28 static const unsigned char *cclass ARGS((const unsigned char *p, int sub));
29
30 /*
31 * Fast character classes
32 */
33 void
setctypes(s,t)34 setctypes(s, t)
35 register const char *s;
36 register int t;
37 {
38 register int i;
39
40 if (t & C_IFS) {
41 for (i = 0; i < UCHAR_MAX+1; i++)
42 ctypes[i] &= ~C_IFS;
43 ctypes[0] |= C_IFS; /* include \0 in C_IFS */
44 }
45 while (*s != 0)
46 ctypes[(unsigned char) *s++] |= t;
47 }
48
49 void
initctypes()50 initctypes()
51 {
52 register int c;
53
54 for (c = 'a'; c <= 'z'; c++)
55 ctypes[c] |= C_ALPHA;
56 for (c = 'A'; c <= 'Z'; c++)
57 ctypes[c] |= C_ALPHA;
58 ctypes['_'] |= C_ALPHA;
59 setctypes("0123456789", C_DIGIT);
60 setctypes(" \t\n|&;<>()", C_LEX1); /* \0 added automatically */
61 setctypes("*@#!$-?", C_VAR1);
62 setctypes(" \t\n", C_IFSWS);
63 setctypes("=-+?", C_SUBOP1);
64 setctypes("#%", C_SUBOP2);
65 setctypes(" \n\t\"#$&'()*;<>?[\\`|", C_QUOTE);
66 }
67
68 /* convert unsigned long to base N string */
69
70 char *
ulton(n,base)71 ulton(n, base)
72 register unsigned long n;
73 int base;
74 {
75 register char *p;
76 static char buf [20];
77
78 p = &buf[sizeof(buf)];
79 *--p = '\0';
80 do {
81 *--p = "0123456789ABCDEF"[n%base];
82 n /= base;
83 } while (n != 0);
84 return p;
85 }
86
87 char *
str_save(s,ap)88 str_save(s, ap)
89 register const char *s;
90 Area *ap;
91 {
92 size_t len;
93 char *p;
94
95 if (!s)
96 return NULL;
97 len = strlen(s)+1;
98 p = alloc(len, ap);
99 strlcpy(p, s, len);
100 return (p);
101 }
102
103 /* Allocate a string of size n+1 and copy upto n characters from the possibly
104 * null terminated string s into it. Always returns a null terminated string
105 * (unless n < 0).
106 */
107 char *
str_nsave(s,n,ap)108 str_nsave(s, n, ap)
109 register const char *s;
110 int n;
111 Area *ap;
112 {
113 char *ns;
114
115 if (n < 0)
116 return 0;
117 ns = alloc(n + 1, ap);
118 ns[0] = '\0';
119 return strncat(ns, s, n);
120 }
121
122 /* called from expand.h:XcheckN() to grow buffer */
123 char *
Xcheck_grow_(xsp,xp,more)124 Xcheck_grow_(xsp, xp, more)
125 XString *xsp;
126 char *xp;
127 int more;
128 {
129 char *old_beg = xsp->beg;
130
131 xsp->len += (size_t)more > xsp->len ? (size_t)more : xsp->len;
132 xsp->beg = aresize(xsp->beg, xsp->len + 8, xsp->areap);
133 xsp->end = xsp->beg + xsp->len;
134 return xsp->beg + (xp - old_beg);
135 }
136
137 const struct option goptions[] = {
138 /* Special cases (see parse_args()): -A, -o, -s.
139 * Options are sorted by their longnames - the order of these
140 * entries MUST match the order of sh_flag F* enumerations in sh.h.
141 */
142 { "allexport", 'a', OF_ANY },
143 #ifdef BRACE_EXPAND
144 { "braceexpand", 0, OF_ANY }, /* non-standard */
145 #endif
146 { "bgnice", 0, OF_ANY },
147 { (char *) 0, 'c', OF_CMDLINE },
148 #ifdef EMACS
149 { "emacs", 0, OF_ANY },
150 { "emacs-usemeta", 0, OF_ANY }, /* non-standard */
151 #endif
152 { "errexit", 'e', OF_ANY },
153 #ifdef EMACS
154 { "gmacs", 0, OF_ANY },
155 #endif
156 { "ignoreeof", 0, OF_ANY },
157 { "interactive",'i', OF_CMDLINE },
158 { "keyword", 'k', OF_ANY },
159 { "login", 'l', OF_CMDLINE },
160 { "markdirs", 'X', OF_ANY },
161 #ifdef JOBS
162 { "monitor", 'm', OF_ANY },
163 #else /* JOBS */
164 { (char *) 0, 'm', 0 }, /* so FMONITOR not ifdef'd */
165 #endif /* JOBS */
166 { "noclobber", 'C', OF_ANY },
167 { "noexec", 'n', OF_ANY },
168 { "noglob", 'f', OF_ANY },
169 { "nohup", 0, OF_ANY },
170 { "nolog", 0, OF_ANY }, /* no effect */
171 #ifdef JOBS
172 { "notify", 'b', OF_ANY },
173 #endif /* JOBS */
174 { "nounset", 'u', OF_ANY },
175 { "physical", 0, OF_ANY }, /* non-standard */
176 { "posix", 0, OF_ANY }, /* non-standard */
177 { "privileged", 'p', OF_ANY },
178 { "restricted", 'r', OF_CMDLINE },
179 { "stdin", 's', OF_CMDLINE }, /* pseudo non-standard */
180 { "trackall", 'h', OF_ANY },
181 { "verbose", 'v', OF_ANY },
182 #ifdef VI
183 { "vi", 0, OF_ANY },
184 { "viraw", 0, OF_ANY }, /* no effect */
185 { "vi-show8", 0, OF_ANY }, /* non-standard */
186 { "vi-tabcomplete", 0, OF_ANY }, /* non-standard */
187 { "vi-esccomplete", 0, OF_ANY }, /* non-standard */
188 #endif
189 { "xtrace", 'x', OF_ANY },
190 /* Anonymous flags: used internally by shell only
191 * (not visible to user)
192 */
193 { (char *) 0, 0, OF_INTERNAL }, /* FTALKING_I */
194 };
195
196 /*
197 * translate -o option into F* constant (also used for test -o option)
198 */
199 int
option(n)200 option(n)
201 const char *n;
202 {
203 int i;
204
205 for (i = 0; i < (int)NELEM(goptions); i++)
206 if (goptions[i].name && strcmp(goptions[i].name, n) == 0)
207 return i;
208
209 return -1;
210 }
211
212 struct options_info {
213 int opt_width;
214 struct {
215 const char *name;
216 int flag;
217 } opts[NELEM(goptions)];
218 };
219
220 static char *options_fmt_entry ARGS((void *arg, int i, char *buf, int buflen));
221 static void printoptions ARGS((int verbose));
222
223 /* format a single select menu item */
224 static char *
options_fmt_entry(arg,i,buf,buflen)225 options_fmt_entry(arg, i, buf, buflen)
226 void *arg;
227 int i;
228 char *buf;
229 int buflen;
230 {
231 struct options_info *oi = (struct options_info *) arg;
232
233 shf_snprintf(buf, buflen, "%-*s %s",
234 oi->opt_width, oi->opts[i].name,
235 Flag(oi->opts[i].flag) ? "on" : "off");
236 return buf;
237 }
238
239 static void
printoptions(verbose)240 printoptions(verbose)
241 int verbose;
242 {
243 int i;
244
245 if (verbose) {
246 struct options_info oi;
247 int n, len;
248
249 /* verbose version */
250 shprintf("Current option settings\n");
251
252 for (i = n = oi.opt_width = 0; i < (int)NELEM(goptions); i++)
253 if (goptions[i].name) {
254 len = strlen(goptions[i].name);
255 oi.opts[n].name = goptions[i].name;
256 oi.opts[n++].flag = i;
257 if (len > oi.opt_width)
258 oi.opt_width = len;
259 }
260 print_columns(shl_stdout, n, options_fmt_entry, &oi,
261 oi.opt_width + 5, 1);
262 } else {
263 /* short version ala ksh93 */
264 shprintf("set");
265 for (i = 0; i < (int)NELEM(goptions); i++)
266 if (Flag(i) && goptions[i].name)
267 shprintf(" -o %s", goptions[i].name);
268 shprintf("%s", newline);
269 }
270 }
271
272 char *
getoptions()273 getoptions()
274 {
275 size_t i;
276 char m[(int) FNFLAGS + 1];
277 register char *cp = m;
278
279 for (i = 0; i < NELEM(goptions); i++)
280 if (goptions[i].c && Flag(i))
281 *cp++ = goptions[i].c;
282 *cp = 0;
283 return str_save(m, ATEMP);
284 }
285
286 /* change a Flag(*) value; takes care of special actions */
287 void
change_flag(f,what,newval)288 change_flag(f, what, newval)
289 enum sh_flag f; /* flag to change */
290 int what; /* what is changing the flag (command line vs set) */
291 int newval;
292 {
293 int oldval;
294
295 oldval = Flag(f);
296 Flag(f) = newval;
297 #ifdef JOBS
298 if (f == FMONITOR) {
299 if (what != OF_CMDLINE && newval != oldval)
300 j_change();
301 } else
302 #endif /* JOBS */
303 #ifdef EDIT
304 if (0
305 # ifdef VI
306 || f == FVI
307 # endif /* VI */
308 # ifdef EMACS
309 || f == FEMACS || f == FGMACS
310 # endif /* EMACS */
311 )
312 {
313 if (newval) {
314 # ifdef VI
315 Flag(FVI) = 0;
316 # endif /* VI */
317 # ifdef EMACS
318 Flag(FEMACS) = Flag(FGMACS) = 0;
319 # endif /* EMACS */
320 Flag(f) = newval;
321 }
322 } else
323 #endif /* EDIT */
324 /* Turning off -p? */
325 if (f == FPRIVILEGED && oldval && !newval) {
326 #ifdef OS2
327 ;
328 #else /* OS2 */
329 seteuid(ksheuid = getuid());
330 setuid(ksheuid);
331 setegid(getgid());
332 setgid(getgid());
333 #endif /* OS2 */
334 } else if (f == FPOSIX && newval) {
335 #ifdef BRACE_EXPAND
336 Flag(FBRACEEXPAND) = 0
337 #endif /* BRACE_EXPAND */
338 ;
339 }
340 /* Changing interactive flag? */
341 if (f == FTALKING) {
342 if ((what == OF_CMDLINE || what == OF_SET) && procpid == kshpid)
343 Flag(FTALKING_I) = newval;
344 }
345 }
346
347 /* parse command line & set command arguments. returns the index of
348 * non-option arguments, -1 if there is an error.
349 */
350 int
parse_args(argv,what,setargsp)351 parse_args(argv, what, setargsp)
352 char **argv;
353 int what; /* OF_CMDLINE or OF_SET */
354 int *setargsp;
355 {
356 static char cmd_opts[NELEM(goptions) + 3]; /* o:\0 */
357 static char set_opts[NELEM(goptions) + 5]; /* Ao;s\0 */
358 char *opts;
359 char *array = (char *) 0;
360 Getopt go;
361 int i, optc, set, sortargs = 0, arrayset = 0;
362
363 /* First call? Build option strings... */
364 if (cmd_opts[0] == '\0') {
365 char *p, *q;
366
367 /* see cmd_opts[] declaration */
368 strlcpy(cmd_opts, "o:", sizeof cmd_opts);
369 p = cmd_opts + strlen(cmd_opts);
370 /* see set_opts[] declaration */
371 strlcpy(set_opts, "A:o;s", sizeof set_opts);
372 q = set_opts + strlen(set_opts);
373 for (i = 0; i < (int)NELEM(goptions); i++) {
374 if (goptions[i].c) {
375 if (goptions[i].flags & OF_CMDLINE)
376 *p++ = goptions[i].c;
377 if (goptions[i].flags & OF_SET)
378 *q++ = goptions[i].c;
379 }
380 }
381 *p = '\0';
382 *q = '\0';
383 }
384
385 if (what == OF_CMDLINE) {
386 char *p;
387 /* Set FLOGIN before parsing options so user can clear
388 * flag using +l.
389 */
390 Flag(FLOGIN) = (argv[0][0] == '-'
391 || ((p = ksh_strrchr_dirsep(argv[0]))
392 && *++p == '-'));
393 opts = cmd_opts;
394 } else
395 opts = set_opts;
396 ksh_getopt_reset(&go, GF_ERROR|GF_PLUSOPT);
397 while ((optc = ksh_getopt(argv, &go, opts)) != EOF) {
398 set = (go.info & GI_PLUS) ? 0 : 1;
399 switch (optc) {
400 case 'A':
401 arrayset = set ? 1 : -1;
402 array = go.optarg;
403 break;
404
405 case 'o':
406 if (go.optarg == (char *) 0) {
407 /* lone -o: print options
408 *
409 * Note that on the command line, -o requires
410 * an option (ie, can't get here if what is
411 * OF_CMDLINE).
412 */
413 printoptions(set);
414 break;
415 }
416 i = option(go.optarg);
417 if (i >= 0 && set == Flag(i))
418 /* Don't check the context if the flag
419 * isn't changing - makes "set -o interactive"
420 * work if you're already interactive. Needed
421 * if the output of "set +o" is to be used.
422 */
423 ;
424 else if (i >= 0 && (goptions[i].flags & what))
425 change_flag((enum sh_flag) i, what, set);
426 else {
427 bi_errorf("%s: bad option", go.optarg);
428 return -1;
429 }
430 break;
431
432 case '?':
433 return -1;
434
435 default:
436 /* -s: sort positional params (at&t ksh stupidity) */
437 if (what == OF_SET && optc == 's') {
438 sortargs = 1;
439 break;
440 }
441 for (i = 0; i < (int)NELEM(goptions); i++)
442 if (optc == goptions[i].c
443 && (what & goptions[i].flags))
444 {
445 change_flag((enum sh_flag) i, what,
446 set);
447 break;
448 }
449 if (i == NELEM(goptions)) {
450 internal_errorf(1, "parse_args: `%c'", optc);
451 return -1; /* not reached */
452 }
453 }
454 }
455 if (!(go.info & GI_MINUSMINUS) && argv[go.optind]
456 && (argv[go.optind][0] == '-' || argv[go.optind][0] == '+')
457 && argv[go.optind][1] == '\0')
458 {
459 /* lone - clears -v and -x flags */
460 if (argv[go.optind][0] == '-' && !Flag(FPOSIX))
461 Flag(FVERBOSE) = Flag(FXTRACE) = 0;
462 /* set skips lone - or + option */
463 go.optind++;
464 }
465 if (setargsp)
466 /* -- means set $#/$* even if there are no arguments */
467 *setargsp = !arrayset && ((go.info & GI_MINUSMINUS)
468 || argv[go.optind]);
469
470 if (arrayset && (!*array || *skip_varname(array, FALSE))) {
471 bi_errorf("%s: is not an identifier", array);
472 return -1;
473 }
474 if (sortargs) {
475 for (i = go.optind; argv[i]; i++)
476 ;
477 qsortp((void **) &argv[go.optind], (size_t) (i - go.optind),
478 xstrcmp);
479 }
480 if (arrayset) {
481 set_array(array, arrayset, argv + go.optind);
482 for (; argv[go.optind]; go.optind++)
483 ;
484 }
485
486 return go.optind;
487 }
488
489 /* parse a decimal number: returns 0 if string isn't a number, 1 otherwise */
490 int
getn(as,ai)491 getn(as, ai)
492 const char *as;
493 int *ai;
494 {
495 char *p;
496 long n;
497
498 n = strtol(as, &p, 10);
499
500 if (!*as || *p || INT_MIN >= n || n >= INT_MAX)
501 return 0;
502
503 *ai = (int)n;
504 return 1;
505 }
506
507 /* getn() that prints error */
508 int
bi_getn(as,ai)509 bi_getn(as, ai)
510 const char *as;
511 int *ai;
512 {
513 int rv = getn(as, ai);
514
515 if (!rv)
516 bi_errorf("%s: bad number", as);
517 return rv;
518 }
519
520 /* -------- gmatch.c -------- */
521
522 /*
523 * int gmatch(string, pattern)
524 * char *string, *pattern;
525 *
526 * Match a pattern as in sh(1).
527 * pattern character are prefixed with MAGIC by expand.
528 */
529
530 int
gmatch(s,p,isfile)531 gmatch(s, p, isfile)
532 const char *s, *p;
533 int isfile;
534 {
535 const char *se, *pe;
536
537 if (s == NULL || p == NULL)
538 return 0;
539 se = s + strlen(s);
540 pe = p + strlen(p);
541 /* isfile is false iff no syntax check has been done on
542 * the pattern. If check fails, just to a strcmp().
543 */
544 if (!isfile && !has_globbing(p, pe)) {
545 int len = pe - p + 1;
546 char tbuf[64];
547 char *t = len <= (int)sizeof(tbuf) ? tbuf
548 : (char *) alloc(len, ATEMP);
549 debunk(t, p, len);
550 return !strcmp(t, s);
551 }
552 return do_gmatch((const unsigned char *) s, (const unsigned char *) se,
553 (const unsigned char *) p, (const unsigned char *) pe,
554 isfile);
555 }
556
557 /* Returns if p is a syntacticly correct globbing pattern, false
558 * if it contains no pattern characters or if there is a syntax error.
559 * Syntax errors are:
560 * - [ with no closing ]
561 * - imbalanced $(...) expression
562 * - [...] and *(...) not nested (eg, [a$(b|]c), *(a[b|c]d))
563 */
564 /*XXX
565 - if no magic,
566 if dest given, copy to dst
567 return ?
568 - if magic && (no globbing || syntax error)
569 debunk to dst
570 return ?
571 - return ?
572 */
573 int
has_globbing(xp,xpe)574 has_globbing(xp, xpe)
575 const char *xp, *xpe;
576 {
577 const unsigned char *p = (const unsigned char *) xp;
578 const unsigned char *pe = (const unsigned char *) xpe;
579 int c;
580 int nest = 0, bnest = 0;
581 int saw_glob = 0;
582 int in_bracket = 0; /* inside [...] */
583
584 for (; p < pe; p++) {
585 if (!ISMAGIC(*p))
586 continue;
587 if ((c = *++p) == '*' || c == '?')
588 saw_glob = 1;
589 else if (c == '[') {
590 if (!in_bracket) {
591 saw_glob = 1;
592 in_bracket = 1;
593 if (ISMAGIC(p[1]) && p[2] == NOT)
594 p += 2;
595 if (ISMAGIC(p[1]) && p[2] == ']')
596 p += 2;
597 }
598 /* XXX Do we need to check ranges here? POSIX Q */
599 } else if (c == ']') {
600 if (in_bracket) {
601 if (bnest) /* [a*(b]) */
602 return 0;
603 in_bracket = 0;
604 }
605 } else if ((c & 0x80) && strchr("*+?@! ", c & 0x7f)) {
606 saw_glob = 1;
607 if (in_bracket)
608 bnest++;
609 else
610 nest++;
611 } else if (c == '|') {
612 if (in_bracket && !bnest) /* *(a[foo|bar]) */
613 return 0;
614 } else if (c == /*(*/ ')') {
615 if (in_bracket) {
616 if (!bnest--) /* *(a[b)c] */
617 return 0;
618 } else if (nest)
619 nest--;
620 }
621 /* else must be a MAGIC-MAGIC, or MAGIC-!, MAGIC--, MAGIC-]
622 MAGIC-{, MAGIC-,, MAGIC-} */
623 }
624 return saw_glob && !in_bracket && !nest;
625 }
626
627 /* Function must return either 0 or 1 (assumed by code for 0x80|'!') */
628 static int
do_gmatch(s,se,p,pe,isfile)629 do_gmatch(s, se, p, pe, isfile)
630 const unsigned char *s, *p;
631 const unsigned char *se, *pe;
632 int isfile;
633 {
634 register int sc, pc;
635 const unsigned char *prest, *psub, *pnext;
636 const unsigned char *srest;
637
638 if (s == NULL || p == NULL)
639 return 0;
640 while (p < pe) {
641 pc = *p++;
642 sc = s < se ? *s : '\0';
643 s++;
644 if (isfile) {
645 sc = FILECHCONV((unsigned char)sc);
646 pc = FILECHCONV((unsigned char)pc);
647 }
648 if (!ISMAGIC(pc)) {
649 if (sc != pc)
650 return 0;
651 continue;
652 }
653 switch (*p++) {
654 case '[':
655 if (sc == 0 || (p = cclass(p, sc)) == NULL)
656 return 0;
657 break;
658
659 case '?':
660 if (sc == 0)
661 return 0;
662 break;
663
664 case '*':
665 if (p == pe)
666 return 1;
667 s--;
668 do {
669 if (do_gmatch(s, se, p, pe, isfile))
670 return 1;
671 } while (s++ < se);
672 return 0;
673
674 /*
675 * [*+?@!](pattern|pattern|..)
676 *
677 * Not ifdef'd KSH as this is needed for ${..%..}, etc.
678 */
679 case 0x80|'+': /* matches one or more times */
680 case 0x80|'*': /* matches zero or more times */
681 if (!(prest = pat_scan(p, pe, 0)))
682 return 0;
683 s--;
684 /* take care of zero matches */
685 if (p[-1] == (0x80 | '*')
686 && do_gmatch(s, se, prest, pe, isfile))
687 return 1;
688 for (psub = p; ; psub = pnext) {
689 pnext = pat_scan(psub, pe, 1);
690 for (srest = s; srest <= se; srest++) {
691 if (do_gmatch(s, srest,
692 psub, pnext - 2, isfile)
693 && (do_gmatch(srest, se,
694 prest, pe, isfile)
695 || (s != srest
696 && do_gmatch(srest, se,
697 p - 2, pe, isfile))))
698 return 1;
699 }
700 if (pnext == prest)
701 break;
702 }
703 return 0;
704
705 case 0x80|'?': /* matches zero or once */
706 case 0x80|'@': /* matches one of the patterns */
707 case 0x80|' ': /* simile for @ */
708 if (!(prest = pat_scan(p, pe, 0)))
709 return 0;
710 s--;
711 /* Take care of zero matches */
712 if (p[-1] == (0x80 | '?')
713 && do_gmatch(s, se, prest, pe, isfile))
714 return 1;
715 for (psub = p; ; psub = pnext) {
716 pnext = pat_scan(psub, pe, 1);
717 srest = prest == pe ? se : s;
718 for (; srest <= se; srest++) {
719 if (do_gmatch(s, srest,
720 psub, pnext - 2, isfile)
721 && do_gmatch(srest, se,
722 prest, pe, isfile))
723 return 1;
724 }
725 if (pnext == prest)
726 break;
727 }
728 return 0;
729
730 case 0x80|'!': /* matches none of the patterns */
731 if (!(prest = pat_scan(p, pe, 0)))
732 return 0;
733 s--;
734 for (srest = s; srest <= se; srest++) {
735 int matched = 0;
736
737 for (psub = p; ; psub = pnext) {
738 pnext = pat_scan(psub, pe, 1);
739 if (do_gmatch(s, srest,
740 psub, pnext - 2, isfile))
741 {
742 matched = 1;
743 break;
744 }
745 if (pnext == prest)
746 break;
747 }
748 if (!matched && do_gmatch(srest, se,
749 prest, pe, isfile))
750 return 1;
751 }
752 return 0;
753
754 default:
755 if (sc != p[-1])
756 return 0;
757 break;
758 }
759 }
760 return s == se;
761 }
762
763 static const unsigned char *
cclass(p,sub)764 cclass(p, sub)
765 const unsigned char *p;
766 register int sub;
767 {
768 register int c, d, not, found = 0;
769 const unsigned char *orig_p = p;
770
771 if ((not = (ISMAGIC(*p) && *++p == NOT)))
772 p++;
773 do {
774 c = *p++;
775 if (ISMAGIC(c)) {
776 c = *p++;
777 if ((c & 0x80) && !ISMAGIC(c)) {
778 c &= 0x7f;/* extended pattern matching: *+?@! */
779 /* XXX the ( char isn't handled as part of [] */
780 if (c == ' ') /* simile for @: plain (..) */
781 c = '(' /*)*/;
782 }
783 }
784 if (c == '\0')
785 /* No closing ] - act as if the opening [ was quoted */
786 return sub == '[' ? orig_p : NULL;
787 if (ISMAGIC(p[0]) && p[1] == '-'
788 && (!ISMAGIC(p[2]) || p[3] != ']'))
789 {
790 p += 2; /* MAGIC- */
791 d = *p++;
792 if (ISMAGIC(d)) {
793 d = *p++;
794 if ((d & 0x80) && !ISMAGIC(d))
795 d &= 0x7f;
796 }
797 /* POSIX says this is an invalid expression */
798 if (c > d)
799 return NULL;
800 } else
801 d = c;
802 if (c == sub || (c <= sub && sub <= d))
803 found = 1;
804 } while (!(ISMAGIC(p[0]) && p[1] == ']'));
805
806 return (found != not) ? p+2 : NULL;
807 }
808
809 /* Look for next ) or | (if match_sep) in *(foo|bar) pattern */
810 const unsigned char *
pat_scan(p,pe,match_sep)811 pat_scan(p, pe, match_sep)
812 const unsigned char *p;
813 const unsigned char *pe;
814 int match_sep;
815 {
816 int nest = 0;
817
818 for (; p < pe; p++) {
819 if (!ISMAGIC(*p))
820 continue;
821 if ((*++p == /*(*/ ')' && nest-- == 0)
822 || (*p == '|' && match_sep && nest == 0))
823 return ++p;
824 if ((*p & 0x80) && strchr("*+?@! ", *p & 0x7f))
825 nest++;
826 }
827 return (const unsigned char *) 0;
828 }
829
830
831 /* -------- qsort.c -------- */
832
833 /*
834 * quick sort of array of generic pointers to objects.
835 */
836 static void qsort1 ARGS((void **base, void **lim, int (*f)(void *, void *)));
837
838 void
qsortp(base,n,f)839 qsortp(base, n, f)
840 void **base; /* base address */
841 size_t n; /* elements */
842 int (*f) ARGS((void *, void *)); /* compare function */
843 {
844 qsort1(base, base + n, f);
845 }
846
847 #define swap2(a, b) {\
848 register void *t; t = *(a); *(a) = *(b); *(b) = t;\
849 }
850 #define swap3(a, b, c) {\
851 register void *t; t = *(a); *(a) = *(c); *(c) = *(b); *(b) = t;\
852 }
853
854 static void
qsort1(base,lim,f)855 qsort1(base, lim, f)
856 void **base, **lim;
857 int (*f) ARGS((void *, void *));
858 {
859 register void **i, **j;
860 register void **lptr, **hptr;
861 size_t n;
862 int c;
863
864 top:
865 n = (lim - base) / 2;
866 if (n == 0)
867 return;
868 hptr = lptr = base+n;
869 i = base;
870 j = lim - 1;
871
872 for (;;) {
873 if (i < lptr) {
874 if ((c = (*f)(*i, *lptr)) == 0) {
875 lptr--;
876 swap2(i, lptr);
877 continue;
878 }
879 if (c < 0) {
880 i += 1;
881 continue;
882 }
883 }
884
885 begin:
886 if (j > hptr) {
887 if ((c = (*f)(*hptr, *j)) == 0) {
888 hptr++;
889 swap2(hptr, j);
890 goto begin;
891 }
892 if (c > 0) {
893 if (i == lptr) {
894 hptr++;
895 swap3(i, hptr, j);
896 i = lptr += 1;
897 goto begin;
898 }
899 swap2(i, j);
900 j -= 1;
901 i += 1;
902 continue;
903 }
904 j -= 1;
905 goto begin;
906 }
907
908 if (i == lptr) {
909 if (lptr-base >= lim-hptr) {
910 qsort1(hptr+1, lim, f);
911 lim = lptr;
912 } else {
913 qsort1(base, lptr, f);
914 base = hptr+1;
915 }
916 goto top;
917 }
918
919 lptr -= 1;
920 swap3(j, lptr, i);
921 j = hptr -= 1;
922 }
923 }
924
925 int
xstrcmp(p1,p2)926 xstrcmp(p1, p2)
927 void *p1, *p2;
928 {
929 return (strcmp((char *)p1, (char *)p2));
930 }
931
932 /* Initialize a Getopt structure */
933 void
ksh_getopt_reset(go,flags)934 ksh_getopt_reset(go, flags)
935 Getopt *go;
936 int flags;
937 {
938 go->optind = 1;
939 go->optarg = (char *) 0;
940 go->p = 0;
941 go->flags = flags;
942 go->info = 0;
943 go->buf[1] = '\0';
944 }
945
946
947 /* getopt() used for shell built-in commands, the getopts command, and
948 * command line options.
949 * A leading ':' in options means don't print errors, instead return '?'
950 * or ':' and set go->optarg to the offending option character.
951 * If GF_ERROR is set (and option doesn't start with :), errors result in
952 * a call to bi_errorf().
953 *
954 * Non-standard features:
955 * - ';' is like ':' in options, except the argument is optional
956 * (if it isn't present, optarg is set to 0).
957 * Used for 'set -o'.
958 * - ',' is like ':' in options, except the argument always immediately
959 * follows the option character (optarg is set to the null string if
960 * the option is missing).
961 * Used for 'read -u2', 'print -u2' and fc -40.
962 * - '#' is like ':' in options, expect that the argument is optional
963 * and must start with a digit. If the argument doesn't start with a
964 * digit, it is assumed to be missing and normal option processing
965 * continues (optarg is set to 0 if the option is missing).
966 * Used for 'typeset -LZ4'.
967 * - accepts +c as well as -c IF the GF_PLUSOPT flag is present. If an
968 * option starting with + is accepted, the GI_PLUS flag will be set
969 * in go->info.
970 */
971 int
ksh_getopt(argv,go,options)972 ksh_getopt(argv, go, options)
973 char **argv;
974 Getopt *go;
975 const char *options;
976 {
977 char c;
978 char *o;
979
980 if (go->p == 0 || (c = argv[go->optind - 1][go->p]) == '\0') {
981 char *arg = argv[go->optind], flag = arg ? *arg : '\0';
982
983 go->p = 1;
984 if (flag == '-' && arg[1] == '-' && arg[2] == '\0') {
985 go->optind++;
986 go->p = 0;
987 go->info |= GI_MINUSMINUS;
988 return EOF;
989 }
990 if (arg == (char *) 0
991 || ((flag != '-' ) /* neither a - nor a + (if + allowed) */
992 && (!(go->flags & GF_PLUSOPT) || flag != '+'))
993 || (c = arg[1]) == '\0')
994 {
995 go->p = 0;
996 return EOF;
997 }
998 go->optind++;
999 go->info &= ~(GI_MINUS|GI_PLUS);
1000 go->info |= flag == '-' ? GI_MINUS : GI_PLUS;
1001 }
1002 go->p++;
1003 if (c == '?' || c == ':' || c == ';' || c == ',' || c == '#'
1004 || !(o = strchr(options, c)))
1005 {
1006 if (options[0] == ':') {
1007 go->buf[0] = c;
1008 go->optarg = go->buf;
1009 } else {
1010 warningf(TRUE, "%s%s-%c: unknown option",
1011 (go->flags & GF_NONAME) ? "" : argv[0],
1012 (go->flags & GF_NONAME) ? "" : ": ", c);
1013 if (go->flags & GF_ERROR)
1014 bi_errorf("%s", null);
1015 }
1016 return '?';
1017 }
1018 /* : means argument must be present, may be part of option argument
1019 * or the next argument
1020 * ; same as : but argument may be missing
1021 * , means argument is part of option argument, and may be null.
1022 */
1023 if (*++o == ':' || *o == ';') {
1024 if (argv[go->optind - 1][go->p])
1025 go->optarg = argv[go->optind - 1] + go->p;
1026 else if (argv[go->optind])
1027 go->optarg = argv[go->optind++];
1028 else if (*o == ';')
1029 go->optarg = (char *) 0;
1030 else {
1031 if (options[0] == ':') {
1032 go->buf[0] = c;
1033 go->optarg = go->buf;
1034 return ':';
1035 }
1036 warningf(TRUE, "%s%s-`%c' requires argument",
1037 (go->flags & GF_NONAME) ? "" : argv[0],
1038 (go->flags & GF_NONAME) ? "" : ": ", c);
1039 if (go->flags & GF_ERROR)
1040 bi_errorf("%s", null);
1041 return '?';
1042 }
1043 go->p = 0;
1044 } else if (*o == ',') {
1045 /* argument is attached to option character, even if null */
1046 go->optarg = argv[go->optind - 1] + go->p;
1047 go->p = 0;
1048 } else if (*o == '#') {
1049 /* argument is optional and may be attached or unattached
1050 * but must start with a digit. optarg is set to 0 if the
1051 * argument is missing.
1052 */
1053 if (argv[go->optind - 1][go->p]) {
1054 if (digit(argv[go->optind - 1][go->p])) {
1055 go->optarg = argv[go->optind - 1] + go->p;
1056 go->p = 0;
1057 } else
1058 go->optarg = (char *) 0;
1059 } else {
1060 if (argv[go->optind] && digit(argv[go->optind][0])) {
1061 go->optarg = argv[go->optind++];
1062 go->p = 0;
1063 } else
1064 go->optarg = (char *) 0;
1065 }
1066 }
1067 return c;
1068 }
1069
1070 /* print variable/alias value using necessary quotes
1071 * (POSIX says they should be suitable for re-entry...)
1072 * No trailing newline is printed.
1073 */
1074 void
print_value_quoted(s)1075 print_value_quoted(s)
1076 const char *s;
1077 {
1078 const char *p;
1079 int inquote = 0;
1080
1081 /* Test if any quotes are needed */
1082 for (p = s; *p; p++)
1083 if (ctype(*p, C_QUOTE))
1084 break;
1085 if (!*p) {
1086 shprintf("%s", s);
1087 return;
1088 }
1089 for (p = s; *p; p++) {
1090 if (*p == '\'') {
1091 shprintf("%s", "'\\'" + 1 - inquote);
1092 inquote = 0;
1093 } else {
1094 if (!inquote) {
1095 shprintf("'");
1096 inquote = 1;
1097 }
1098 shf_putc(*p, shl_stdout);
1099 }
1100 }
1101 if (inquote)
1102 shprintf("'");
1103 }
1104
1105 /* Print things in columns and rows - func() is called to format the ith
1106 * element
1107 */
1108 void
print_columns(shf,n,func,arg,max_width,prefcol)1109 print_columns(shf, n, func, arg, max_width, prefcol)
1110 struct shf *shf;
1111 int n;
1112 char *(*func) ARGS((void *, int, char *, int));
1113 void *arg;
1114 int max_width;
1115 int prefcol;
1116 {
1117 char *str = (char *) alloc(max_width + 1, ATEMP);
1118 int i;
1119 int r, c;
1120 int rows, cols;
1121 int nspace;
1122
1123 /* max_width + 1 for the space. Note that no space
1124 * is printed after the last column to avoid problems
1125 * with terminals that have auto-wrap.
1126 */
1127 cols = x_cols / (max_width + 1);
1128 if (!cols)
1129 cols = 1;
1130 rows = (n + cols - 1) / cols;
1131 if (prefcol && n && cols > rows) {
1132 int tmp = rows;
1133
1134 rows = cols;
1135 cols = tmp;
1136 if (rows > n)
1137 rows = n;
1138 }
1139
1140 nspace = (x_cols - max_width * cols) / cols;
1141 if (nspace <= 0)
1142 nspace = 1;
1143 for (r = 0; r < rows; r++) {
1144 for (c = 0; c < cols; c++) {
1145 i = c * rows + r;
1146 if (i < n) {
1147 shf_fprintf(shf, "%-*s",
1148 max_width,
1149 (*func)(arg, i, str, max_width + 1));
1150 if (c + 1 < cols)
1151 shf_fprintf(shf, "%*s", nspace, null);
1152 }
1153 }
1154 shf_putchar('\n', shf);
1155 }
1156 afree(str, ATEMP);
1157 }
1158
1159 /* Strip any nul bytes from buf - returns new length (nbytes - # of nuls) */
1160 int
strip_nuls(buf,nbytes)1161 strip_nuls(buf, nbytes)
1162 char *buf;
1163 int nbytes;
1164 {
1165 char *dst;
1166
1167 /* nbytes check because some systems (older freebsd's) have a buggy
1168 * memchr()
1169 */
1170 if (nbytes && (dst = memchr(buf, '\0', nbytes))) {
1171 char *end = buf + nbytes;
1172 char *p, *q;
1173
1174 for (p = dst; p < end; p = q) {
1175 /* skip a block of nulls */
1176 while (++p < end && *p == '\0')
1177 ;
1178 /* find end of non-null block */
1179 if (!(q = memchr(p, '\0', end - p)))
1180 q = end;
1181 memmove(dst, p, q - p);
1182 dst += q - p;
1183 }
1184 *dst = '\0';
1185 return dst - buf;
1186 }
1187 return nbytes;
1188 }
1189
1190 /* Copy at most dsize-1 bytes from src to dst, ensuring dst is null terminated.
1191 * Returns dst.
1192 */
1193 char *
str_zcpy(dst,src,dsize)1194 str_zcpy(dst, src, dsize)
1195 char *dst;
1196 const char *src;
1197 int dsize;
1198 {
1199 if (dsize > 0) {
1200 int len = strlen(src);
1201
1202 if (len >= dsize)
1203 len = dsize - 1;
1204 memcpy(dst, src, len);
1205 dst[len] = '\0';
1206 }
1207 return dst;
1208 }
1209
1210 /* Like read(2), but if read fails due to non-blocking flag, resets flag
1211 * and restarts read.
1212 */
1213 int
blocking_read(fd,buf,nbytes)1214 blocking_read(fd, buf, nbytes)
1215 int fd;
1216 char *buf;
1217 int nbytes;
1218 {
1219 int ret;
1220 int tried_reset = 0;
1221
1222 while ((ret = read(fd, buf, nbytes)) < 0) {
1223 if (!tried_reset && (errno == EAGAIN
1224 #ifdef EWOULDBLOCK
1225 || errno == EWOULDBLOCK
1226 #endif /* EWOULDBLOCK */
1227 ))
1228 {
1229 int oerrno = errno;
1230 if (reset_nonblock(fd) > 0) {
1231 tried_reset = 1;
1232 continue;
1233 }
1234 errno = oerrno;
1235 }
1236 break;
1237 }
1238 return ret;
1239 }
1240
1241 /* Reset the non-blocking flag on the specified file descriptor.
1242 * Returns -1 if there was an error, 0 if non-blocking wasn't set,
1243 * 1 if it was.
1244 */
1245 int
reset_nonblock(fd)1246 reset_nonblock(fd)
1247 int fd;
1248 {
1249 int flags;
1250 int blocking_flags;
1251
1252 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1253 return -1;
1254 /* With luck, the C compiler will reduce this to a constant */
1255 blocking_flags = 0;
1256 #ifdef O_NONBLOCK
1257 blocking_flags |= O_NONBLOCK;
1258 #endif /* O_NONBLOCK */
1259 #ifdef O_NDELAY
1260 blocking_flags |= O_NDELAY;
1261 #else /* O_NDELAY */
1262 # ifndef O_NONBLOCK
1263 blocking_flags |= FNDELAY; /* hope this exists... */
1264 # endif /* O_NONBLOCK */
1265 #endif /* O_NDELAY */
1266 if (!(flags & blocking_flags))
1267 return 0;
1268 flags &= ~blocking_flags;
1269 if (fcntl(fd, F_SETFL, flags) < 0)
1270 return -1;
1271 return 1;
1272 }
1273
1274
1275 #ifdef HAVE_SYS_PARAM_H
1276 # include <sys/param.h>
1277 #endif /* HAVE_SYS_PARAM_H */
1278 #ifndef MAXPATHLEN
1279 # define MAXPATHLEN PATH
1280 #endif /* MAXPATHLEN */
1281
1282 #ifdef HPUX_GETWD_BUG
1283 # include "ksh_dir.h"
1284
1285 /*
1286 * Work around bug in hpux 10.x C library - getwd/getcwd dump core
1287 * if current directory is not readable. Done in macro 'cause code
1288 * is needed in GETWD and GETCWD cases.
1289 */
1290 # define HPUX_GETWD_BUG_CODE \
1291 { \
1292 DIR *d = ksh_opendir("."); \
1293 if (!d) \
1294 return (char *) 0; \
1295 closedir(d); \
1296 }
1297 #else /* HPUX_GETWD_BUG */
1298 # define HPUX_GETWD_BUG_CODE
1299 #endif /* HPUX_GETWD_BUG */
1300
1301 /* Like getcwd(), except bsize is ignored if buf is 0 (MAXPATHLEN is used) */
1302 char *
ksh_get_wd(buf,bsize)1303 ksh_get_wd(buf, bsize)
1304 char *buf;
1305 int bsize;
1306 {
1307 #ifdef HAVE_GETCWD
1308 char *b;
1309 char *ret;
1310
1311 /* Before memory allocated */
1312 HPUX_GETWD_BUG_CODE
1313
1314 /* Assume getcwd() available */
1315 if (!buf) {
1316 bsize = MAXPATHLEN;
1317 b = alloc(MAXPATHLEN + 1, ATEMP);
1318 } else
1319 b = buf;
1320
1321 ret = getcwd(b, bsize);
1322
1323 if (!buf) {
1324 if (ret)
1325 ret = aresize(b, strlen(b) + 1, ATEMP);
1326 else
1327 afree(b, ATEMP);
1328 }
1329
1330 return ret;
1331 #else /* HAVE_GETCWD */
1332 extern char *getwd ARGS((char *));
1333 char *b;
1334 int len;
1335
1336 /* Before memory allocated */
1337 HPUX_GETWD_BUG_CODE
1338
1339 if (buf && bsize > MAXPATHLEN)
1340 b = buf;
1341 else
1342 b = alloc(MAXPATHLEN + 1, ATEMP);
1343 if (!getcwd(b, MAXPATHLEN)) {
1344 errno = EACCES;
1345 if (b != buf)
1346 afree(b, ATEMP);
1347 return (char *) 0;
1348 }
1349 len = strlen(b) + 1;
1350 if (!buf)
1351 b = aresize(b, len, ATEMP);
1352 else if (buf != b) {
1353 if (len > bsize) {
1354 errno = ERANGE;
1355 return (char *) 0;
1356 }
1357 memcpy(buf, b, len);
1358 afree(b, ATEMP);
1359 b = buf;
1360 }
1361
1362 return b;
1363 #endif /* HAVE_GETCWD */
1364 }
1365