1 /* $OpenBSD: misc.c,v 1.37 2009/04/19 20:34:05 sthen Exp $ */
2 /* $OpenBSD: path.c,v 1.12 2005/03/30 17:16:37 deraadt Exp $ */
3
4 /*-
5 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
6 * 2011, 2012, 2013
7 * Thorsten Glaser <tg@mirbsd.org>
8 *
9 * Provided that these terms and disclaimer and all copyright notices
10 * are retained or reproduced in an accompanying document, permission
11 * is granted to deal in this work without restriction, including un-
12 * limited rights to use, publicly perform, distribute, sell, modify,
13 * merge, give away, or sublicence.
14 *
15 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
16 * the utmost extent permitted by applicable law, neither express nor
17 * implied; without malicious intent or gross negligence. In no event
18 * may a licensor, author or contributor be held liable for indirect,
19 * direct, other damage, loss, or other issues arising in any way out
20 * of dealing in the work, even if advised of the possibility of such
21 * damage or existence of a defect, except proven that it results out
22 * of said person's immediate fault when using the work as intended.
23 */
24
25 #include "sh.h"
26 #if !HAVE_GETRUSAGE
27 #include <sys/times.h>
28 #endif
29 #if HAVE_GRP_H
30 #include <grp.h>
31 #endif
32
33 __RCSID("$MirOS: src/bin/mksh/misc.c,v 1.214 2013/08/11 14:57:09 tg Exp $");
34
35 #define KSH_CHVT_FLAG
36 #ifdef MKSH_SMALL
37 #undef KSH_CHVT_FLAG
38 #endif
39 #ifdef TIOCSCTTY
40 #define KSH_CHVT_CODE
41 #define KSH_CHVT_FLAG
42 #endif
43 #ifdef MKSH_LEGACY_MODE
44 #undef KSH_CHVT_CODE
45 #undef KSH_CHVT_FLAG
46 #endif
47
48 /* type bits for unsigned char */
49 unsigned char chtypes[UCHAR_MAX + 1];
50
51 static const unsigned char *pat_scan(const unsigned char *,
52 const unsigned char *, bool);
53 static int do_gmatch(const unsigned char *, const unsigned char *,
54 const unsigned char *, const unsigned char *);
55 static const unsigned char *cclass(const unsigned char *, unsigned char);
56 #ifdef KSH_CHVT_CODE
57 static void chvt(const Getopt *);
58 #endif
59
60 /*XXX this should go away */
61 static int make_path(const char *, const char *, char **, XString *, int *);
62
63 #ifdef SETUID_CAN_FAIL_WITH_EAGAIN
64 /* we don't need to check for other codes, EPERM won't happen */
65 #define DO_SETUID(func, argvec) do { \
66 if ((func argvec) && errno == EAGAIN) \
67 errorf("%s failed with EAGAIN, probably due to a" \
68 " too low process limit; aborting", #func); \
69 } while (/* CONSTCOND */ 0)
70 #else
71 #define DO_SETUID(func, argvec) func argvec
72 #endif
73
74 /*
75 * Fast character classes
76 */
77 void
setctypes(const char * s,int t)78 setctypes(const char *s, int t)
79 {
80 unsigned int i;
81
82 if (t & C_IFS) {
83 for (i = 0; i < UCHAR_MAX + 1; i++)
84 chtypes[i] &= ~C_IFS;
85 /* include \0 in C_IFS */
86 chtypes[0] |= C_IFS;
87 }
88 while (*s != 0)
89 chtypes[(unsigned char)*s++] |= t;
90 }
91
92 void
initctypes(void)93 initctypes(void)
94 {
95 int c;
96
97 for (c = 'a'; c <= 'z'; c++)
98 chtypes[c] |= C_ALPHA;
99 for (c = 'A'; c <= 'Z'; c++)
100 chtypes[c] |= C_ALPHA;
101 chtypes['_'] |= C_ALPHA;
102 setctypes("0123456789", C_DIGIT);
103 /* \0 added automatically */
104 setctypes(TC_LEX1, C_LEX1);
105 setctypes("*@#!$-?", C_VAR1);
106 setctypes(TC_IFSWS, C_IFSWS);
107 setctypes("=-+?", C_SUBOP1);
108 setctypes("\t\n \"#$&'()*;<=>?[\\]`|", C_QUOTE);
109 }
110
111 /* called from XcheckN() to grow buffer */
112 char *
Xcheck_grow(XString * xsp,const char * xp,size_t more)113 Xcheck_grow(XString *xsp, const char *xp, size_t more)
114 {
115 const char *old_beg = xsp->beg;
116
117 if (more < xsp->len)
118 more = xsp->len;
119 /* (xsp->len + X_EXTRA) never overflows */
120 checkoktoadd(more, xsp->len + X_EXTRA);
121 xsp->beg = aresize(xsp->beg, (xsp->len += more) + X_EXTRA, xsp->areap);
122 xsp->end = xsp->beg + xsp->len;
123 return (xsp->beg + (xp - old_beg));
124 }
125
126
127 #define SHFLAGS_DEFNS
128 #include "sh_flags.h"
129
130 #define OFC(i) (options[i][-2])
131 #define OFF(i) (((const unsigned char *)options[i])[-1])
132 #define OFN(i) (options[i])
133
134 const char * const options[] = {
135 #define SHFLAGS_ITEMS
136 #include "sh_flags.h"
137 };
138
139 /*
140 * translate -o option into F* constant (also used for test -o option)
141 */
142 size_t
option(const char * n)143 option(const char *n)
144 {
145 size_t i = 0;
146
147 if ((n[0] == '-' || n[0] == '+') && n[1] && !n[2])
148 while (i < NELEM(options)) {
149 if (OFC(i) == n[1])
150 return (i);
151 ++i;
152 }
153 else
154 while (i < NELEM(options)) {
155 if (!strcmp(OFN(i), n))
156 return (i);
157 ++i;
158 }
159
160 return ((size_t)-1);
161 }
162
163 struct options_info {
164 int opt_width;
165 int opts[NELEM(options)];
166 };
167
168 static char *options_fmt_entry(char *, size_t, unsigned int, const void *);
169 static void printoptions(bool);
170
171 /* format a single select menu item */
172 static char *
options_fmt_entry(char * buf,size_t buflen,unsigned int i,const void * arg)173 options_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg)
174 {
175 const struct options_info *oi = (const struct options_info *)arg;
176
177 shf_snprintf(buf, buflen, "%-*s %s",
178 oi->opt_width, OFN(oi->opts[i]),
179 Flag(oi->opts[i]) ? "on" : "off");
180 return (buf);
181 }
182
183 static void
printoptions(bool verbose)184 printoptions(bool verbose)
185 {
186 size_t i = 0;
187
188 if (verbose) {
189 size_t n = 0, len, octs = 0;
190 struct options_info oi;
191
192 /* verbose version */
193 shf_puts("Current option settings\n", shl_stdout);
194
195 oi.opt_width = 0;
196 while (i < NELEM(options)) {
197 if ((len = strlen(OFN(i)))) {
198 oi.opts[n++] = i;
199 if (len > octs)
200 octs = len;
201 len = utf_mbswidth(OFN(i));
202 if ((int)len > oi.opt_width)
203 oi.opt_width = (int)len;
204 }
205 ++i;
206 }
207 print_columns(shl_stdout, n, options_fmt_entry, &oi,
208 octs + 4, oi.opt_width + 4, true);
209 } else {
210 /* short version like AT&T ksh93 */
211 shf_puts(Tset, shl_stdout);
212 while (i < NELEM(options)) {
213 if (Flag(i) && OFN(i)[0])
214 shprintf(" -o %s", OFN(i));
215 ++i;
216 }
217 shf_putc('\n', shl_stdout);
218 }
219 }
220
221 char *
getoptions(void)222 getoptions(void)
223 {
224 size_t i = 0;
225 char c, m[(int)FNFLAGS + 1];
226 char *cp = m;
227
228 while (i < NELEM(options)) {
229 if ((c = OFC(i)) && Flag(i))
230 *cp++ = c;
231 ++i;
232 }
233 strndupx(cp, m, cp - m, ATEMP);
234 return (cp);
235 }
236
237 /* change a Flag(*) value; takes care of special actions */
238 void
change_flag(enum sh_flag f,int what,bool newset)239 change_flag(enum sh_flag f, int what, bool newset)
240 {
241 unsigned char oldval;
242 unsigned char newval = (newset ? 1 : 0);
243
244 if (f == FXTRACE) {
245 change_xtrace(newval, true);
246 return;
247 }
248 oldval = Flag(f);
249 Flag(f) = newval = (newset ? 1 : 0);
250 #ifndef MKSH_UNEMPLOYED
251 if (f == FMONITOR) {
252 if (what != OF_CMDLINE && newval != oldval)
253 j_change();
254 } else
255 #endif
256 #ifndef MKSH_NO_CMDLINE_EDITING
257 if ((
258 #if !MKSH_S_NOVI
259 f == FVI ||
260 #endif
261 f == FEMACS || f == FGMACS) && newval) {
262 #if !MKSH_S_NOVI
263 Flag(FVI) =
264 #endif
265 Flag(FEMACS) = Flag(FGMACS) = 0;
266 Flag(f) = newval;
267 } else
268 #endif
269 if (f == FPRIVILEGED && oldval && !newval) {
270 /* Turning off -p? */
271
272 /*XXX this can probably be optimised */
273 kshegid = kshgid = getgid();
274 #if HAVE_SETRESUGID
275 DO_SETUID(setresgid, (kshegid, kshegid, kshegid));
276 #if HAVE_SETGROUPS
277 /* setgroups doesn't EAGAIN on Linux */
278 setgroups(1, &kshegid);
279 #endif
280 DO_SETUID(setresuid, (ksheuid, ksheuid, ksheuid));
281 #else
282 /* seteuid, setegid, setgid don't EAGAIN on Linux */
283 ksheuid = kshuid = getuid();
284 #ifndef MKSH__NO_SETEUGID
285 seteuid(ksheuid);
286 #endif
287 DO_SETUID(setuid, (ksheuid));
288 #ifndef MKSH__NO_SETEUGID
289 setegid(kshegid);
290 #endif
291 setgid(kshegid);
292 #endif
293 } else if ((f == FPOSIX || f == FSH) && newval) {
294 /* Turning on -o posix or -o sh? */
295 Flag(FBRACEEXPAND) = 0;
296 } else if (f == FTALKING) {
297 /* Changing interactive flag? */
298 if ((what == OF_CMDLINE || what == OF_SET) && procpid == kshpid)
299 Flag(FTALKING_I) = newval;
300 }
301 }
302
303 void
change_xtrace(unsigned char newval,bool dosnapshot)304 change_xtrace(unsigned char newval, bool dosnapshot)
305 {
306 if (!dosnapshot && newval == Flag(FXTRACE))
307 return;
308
309 if (Flag(FXTRACE) == 2) {
310 shf_putc('\n', shl_xtrace);
311 Flag(FXTRACE) = 1;
312 shf_flush(shl_xtrace);
313 }
314
315 if (!dosnapshot && Flag(FXTRACE) == 1)
316 switch (newval) {
317 case 1:
318 return;
319 case 2:
320 goto changed_xtrace;
321 }
322
323 shf_flush(shl_xtrace);
324 if (shl_xtrace->fd != 2)
325 close(shl_xtrace->fd);
326 if (!newval || (shl_xtrace->fd = savefd(2)) == -1)
327 shl_xtrace->fd = 2;
328
329 changed_xtrace:
330 if ((Flag(FXTRACE) = newval) == 2)
331 shf_puts(substitute(str_val(global("PS4")), 0), shl_xtrace);
332 }
333
334 /*
335 * Parse command line and set command arguments. Returns the index of
336 * non-option arguments, -1 if there is an error.
337 */
338 int
parse_args(const char ** argv,int what,bool * setargsp)339 parse_args(const char **argv,
340 /* OF_CMDLINE or OF_SET */
341 int what,
342 bool *setargsp)
343 {
344 static char cmd_opts[NELEM(options) + 5]; /* o:T:\0 */
345 static char set_opts[NELEM(options) + 6]; /* A:o;s\0 */
346 bool set;
347 char *opts;
348 const char *array = NULL;
349 Getopt go;
350 size_t i;
351 int optc, arrayset = 0;
352 bool sortargs = false;
353 bool fcompatseen = false;
354
355 /* First call? Build option strings... */
356 if (cmd_opts[0] == '\0') {
357 char ch, *p = cmd_opts, *q = set_opts;
358
359 /* see cmd_opts[] declaration */
360 *p++ = 'o';
361 *p++ = ':';
362 #ifdef KSH_CHVT_FLAG
363 *p++ = 'T';
364 *p++ = ':';
365 #endif
366 /* see set_opts[] declaration */
367 *q++ = 'A';
368 *q++ = ':';
369 *q++ = 'o';
370 *q++ = ';';
371 *q++ = 's';
372
373 for (i = 0; i < NELEM(options); i++) {
374 if ((ch = OFC(i))) {
375 if (OFF(i) & OF_CMDLINE)
376 *p++ = ch;
377 if (OFF(i) & OF_SET)
378 *q++ = ch;
379 }
380 }
381 *p = '\0';
382 *q = '\0';
383 }
384
385 if (what == OF_CMDLINE) {
386 const char *p = argv[0], *q;
387 /*
388 * Set FLOGIN before parsing options so user can clear
389 * flag using +l.
390 */
391 if (*p != '-')
392 for (q = p; *q; )
393 if (*q++ == '/')
394 p = q;
395 Flag(FLOGIN) = (*p == '-');
396 opts = cmd_opts;
397 } else if (what == OF_FIRSTTIME) {
398 opts = cmd_opts;
399 } else
400 opts = set_opts;
401 ksh_getopt_reset(&go, GF_ERROR|GF_PLUSOPT);
402 while ((optc = ksh_getopt(argv, &go, opts)) != -1) {
403 set = tobool(!(go.info & GI_PLUS));
404 switch (optc) {
405 case 'A':
406 if (what == OF_FIRSTTIME)
407 break;
408 arrayset = set ? 1 : -1;
409 array = go.optarg;
410 break;
411
412 case 'o':
413 if (what == OF_FIRSTTIME)
414 break;
415 if (go.optarg == NULL) {
416 /*
417 * lone -o: print options
418 *
419 * Note that on the command line, -o requires
420 * an option (ie, can't get here if what is
421 * OF_CMDLINE).
422 */
423 printoptions(set);
424 break;
425 }
426 i = option(go.optarg);
427 if ((i == FPOSIX || i == FSH) && set && !fcompatseen) {
428 /*
429 * If running 'set -o posix' or
430 * 'set -o sh', turn off the other;
431 * if running 'set -o posix -o sh'
432 * allow both to be set though.
433 */
434 Flag(FPOSIX) = 0;
435 Flag(FSH) = 0;
436 fcompatseen = true;
437 }
438 if ((i != (size_t)-1) && (set ? 1U : 0U) == Flag(i))
439 /*
440 * Don't check the context if the flag
441 * isn't changing - makes "set -o interactive"
442 * work if you're already interactive. Needed
443 * if the output of "set +o" is to be used.
444 */
445 ;
446 else if ((i != (size_t)-1) && (OFF(i) & what))
447 change_flag((enum sh_flag)i, what, set);
448 else {
449 bi_errorf("%s: %s", go.optarg, "bad option");
450 return (-1);
451 }
452 break;
453
454 #ifdef KSH_CHVT_FLAG
455 case 'T':
456 if (what != OF_FIRSTTIME)
457 break;
458 #ifndef KSH_CHVT_CODE
459 errorf("no TIOCSCTTY ioctl");
460 #else
461 change_flag(FTALKING, OF_CMDLINE, true);
462 chvt(&go);
463 break;
464 #endif
465 #endif
466
467 case '?':
468 return (-1);
469
470 default:
471 if (what == OF_FIRSTTIME)
472 break;
473 /* -s: sort positional params (AT&T ksh stupidity) */
474 if (what == OF_SET && optc == 's') {
475 sortargs = true;
476 break;
477 }
478 for (i = 0; i < NELEM(options); i++)
479 if (optc == OFC(i) &&
480 (what & OFF(i))) {
481 change_flag((enum sh_flag)i, what, set);
482 break;
483 }
484 if (i == NELEM(options))
485 internal_errorf("parse_args: '%c'", optc);
486 }
487 }
488 if (!(go.info & GI_MINUSMINUS) && argv[go.optind] &&
489 (argv[go.optind][0] == '-' || argv[go.optind][0] == '+') &&
490 argv[go.optind][1] == '\0') {
491 /* lone - clears -v and -x flags */
492 if (argv[go.optind][0] == '-') {
493 Flag(FVERBOSE) = 0;
494 change_xtrace(0, false);
495 }
496 /* set skips lone - or + option */
497 go.optind++;
498 }
499 if (setargsp)
500 /* -- means set $#/$* even if there are no arguments */
501 *setargsp = !arrayset && ((go.info & GI_MINUSMINUS) ||
502 argv[go.optind]);
503
504 if (arrayset) {
505 const char *ccp = NULL;
506
507 mkssert(array != NULL);
508 if (*array)
509 ccp = skip_varname(array, false);
510 if (!ccp || !(!ccp[0] || (ccp[0] == '+' && !ccp[1]))) {
511 bi_errorf("%s: %s", array, "is not an identifier");
512 return (-1);
513 }
514 }
515 if (sortargs) {
516 for (i = go.optind; argv[i]; i++)
517 ;
518 qsort(&argv[go.optind], i - go.optind, sizeof(void *),
519 xstrcmp);
520 }
521 if (arrayset)
522 go.optind += set_array(array, tobool(arrayset > 0),
523 argv + go.optind);
524
525 return (go.optind);
526 }
527
528 /* parse a decimal number: returns 0 if string isn't a number, 1 otherwise */
529 int
getn(const char * s,int * ai)530 getn(const char *s, int *ai)
531 {
532 char c;
533 mksh_ari_u num;
534 bool neg = false;
535
536 num.u = 0;
537
538 do {
539 c = *s++;
540 } while (ksh_isspace(c));
541
542 switch (c) {
543 case '-':
544 neg = true;
545 /* FALLTHROUGH */
546 case '+':
547 c = *s++;
548 break;
549 }
550
551 do {
552 if (!ksh_isdigit(c))
553 /* not numeric */
554 return (0);
555 if (num.u > 214748364U)
556 /* overflow on multiplication */
557 return (0);
558 num.u = num.u * 10U + (unsigned int)(c - '0');
559 /* now: num.u <= 2147483649U */
560 } while ((c = *s++));
561
562 if (num.u > (neg ? 2147483648U : 2147483647U))
563 /* overflow for signed 32-bit int */
564 return (0);
565
566 if (neg)
567 num.u = -num.u;
568 *ai = num.i;
569 return (1);
570 }
571
572 /**
573 * pattern simplifications:
574 * - @(x) -> x (not @(x|y) though)
575 * - ** -> *
576 */
577 static void *
simplify_gmatch_pattern(const unsigned char * sp)578 simplify_gmatch_pattern(const unsigned char *sp)
579 {
580 uint8_t c;
581 unsigned char *cp, *dp;
582 const unsigned char *ps, *se;
583
584 cp = alloc(strlen((const void *)sp) + 1, ATEMP);
585 goto simplify_gmatch_pat1a;
586
587 /* foo@(b@(a)r)b@(a|a)z -> foobarb@(a|a)z */
588 simplify_gmatch_pat1:
589 sp = cp;
590 simplify_gmatch_pat1a:
591 dp = cp;
592 se = sp + strlen((const void *)sp);
593 while ((c = *sp++)) {
594 if (!ISMAGIC(c)) {
595 *dp++ = c;
596 continue;
597 }
598 switch ((c = *sp++)) {
599 case 0x80|'@':
600 /* simile for @ */
601 case 0x80|' ':
602 /* check whether it has only one clause */
603 ps = pat_scan(sp, se, true);
604 if (!ps || ps[-1] != /*(*/ ')')
605 /* nope */
606 break;
607 /* copy inner clause until matching close */
608 ps -= 2;
609 while ((const unsigned char *)sp < ps)
610 *dp++ = *sp++;
611 /* skip MAGIC and closing parenthesis */
612 sp += 2;
613 /* copy the rest of the pattern */
614 memmove(dp, sp, strlen((const void *)sp) + 1);
615 /* redo from start */
616 goto simplify_gmatch_pat1;
617 }
618 *dp++ = MAGIC;
619 *dp++ = c;
620 }
621 *dp = '\0';
622
623 /* collapse adjacent asterisk wildcards */
624 sp = dp = cp;
625 while ((c = *sp++)) {
626 if (!ISMAGIC(c)) {
627 *dp++ = c;
628 continue;
629 }
630 switch ((c = *sp++)) {
631 case '*':
632 while (ISMAGIC(sp[0]) && sp[1] == c)
633 sp += 2;
634 break;
635 }
636 *dp++ = MAGIC;
637 *dp++ = c;
638 }
639 *dp = '\0';
640
641 /* return the result, allocated from ATEMP */
642 return (cp);
643 }
644
645 /* -------- gmatch.c -------- */
646
647 /*
648 * int gmatch(string, pattern)
649 * char *string, *pattern;
650 *
651 * Match a pattern as in sh(1).
652 * pattern character are prefixed with MAGIC by expand.
653 */
654 int
gmatchx(const char * s,const char * p,bool isfile)655 gmatchx(const char *s, const char *p, bool isfile)
656 {
657 const char *se, *pe;
658 char *pnew;
659 int rv;
660
661 if (s == NULL || p == NULL)
662 return (0);
663
664 se = s + strlen(s);
665 pe = p + strlen(p);
666 /*
667 * isfile is false iff no syntax check has been done on
668 * the pattern. If check fails, just to a strcmp().
669 */
670 if (!isfile && !has_globbing(p, pe)) {
671 size_t len = pe - p + 1;
672 char tbuf[64];
673 char *t = len <= sizeof(tbuf) ? tbuf : alloc(len, ATEMP);
674 debunk(t, p, len);
675 return (!strcmp(t, s));
676 }
677
678 /*
679 * since the do_gmatch() engine sucks so much, we must do some
680 * pattern simplifications
681 */
682 pnew = simplify_gmatch_pattern((const unsigned char *)p);
683 pe = pnew + strlen(pnew);
684
685 rv = do_gmatch((const unsigned char *)s, (const unsigned char *)se,
686 (const unsigned char *)pnew, (const unsigned char *)pe);
687 afree(pnew, ATEMP);
688 return (rv);
689 }
690
691 /**
692 * Returns if p is a syntacticly correct globbing pattern, false
693 * if it contains no pattern characters or if there is a syntax error.
694 * Syntax errors are:
695 * - [ with no closing ]
696 * - imbalanced $(...) expression
697 * - [...] and *(...) not nested (eg, [a$(b|]c), *(a[b|c]d))
698 */
699 /*XXX
700 * - if no magic,
701 * if dest given, copy to dst
702 * return ?
703 * - if magic && (no globbing || syntax error)
704 * debunk to dst
705 * return ?
706 * - return ?
707 */
708 int
has_globbing(const char * xp,const char * xpe)709 has_globbing(const char *xp, const char *xpe)
710 {
711 const unsigned char *p = (const unsigned char *) xp;
712 const unsigned char *pe = (const unsigned char *) xpe;
713 int c;
714 int nest = 0, bnest = 0;
715 bool saw_glob = false;
716 /* inside [...] */
717 bool in_bracket = false;
718
719 for (; p < pe; p++) {
720 if (!ISMAGIC(*p))
721 continue;
722 if ((c = *++p) == '*' || c == '?')
723 saw_glob = true;
724 else if (c == '[') {
725 if (!in_bracket) {
726 saw_glob = true;
727 in_bracket = true;
728 if (ISMAGIC(p[1]) && p[2] == '!')
729 p += 2;
730 if (ISMAGIC(p[1]) && p[2] == ']')
731 p += 2;
732 }
733 /*XXX Do we need to check ranges here? POSIX Q */
734 } else if (c == ']') {
735 if (in_bracket) {
736 if (bnest)
737 /* [a*(b]) */
738 return (0);
739 in_bracket = false;
740 }
741 } else if ((c & 0x80) && vstrchr("*+?@! ", c & 0x7f)) {
742 saw_glob = true;
743 if (in_bracket)
744 bnest++;
745 else
746 nest++;
747 } else if (c == '|') {
748 if (in_bracket && !bnest)
749 /* *(a[foo|bar]) */
750 return (0);
751 } else if (c == /*(*/ ')') {
752 if (in_bracket) {
753 if (!bnest--)
754 /* *(a[b)c] */
755 return (0);
756 } else if (nest)
757 nest--;
758 }
759 /*
760 * else must be a MAGIC-MAGIC, or MAGIC-!,
761 * MAGIC--, MAGIC-], MAGIC-{, MAGIC-, MAGIC-}
762 */
763 }
764 return (saw_glob && !in_bracket && !nest);
765 }
766
767 /* Function must return either 0 or 1 (assumed by code for 0x80|'!') */
768 static int
do_gmatch(const unsigned char * s,const unsigned char * se,const unsigned char * p,const unsigned char * pe)769 do_gmatch(const unsigned char *s, const unsigned char *se,
770 const unsigned char *p, const unsigned char *pe)
771 {
772 unsigned char sc, pc;
773 const unsigned char *prest, *psub, *pnext;
774 const unsigned char *srest;
775
776 if (s == NULL || p == NULL)
777 return (0);
778 while (p < pe) {
779 pc = *p++;
780 sc = s < se ? *s : '\0';
781 s++;
782 if (!ISMAGIC(pc)) {
783 if (sc != pc)
784 return (0);
785 continue;
786 }
787 switch (*p++) {
788 case '[':
789 if (sc == 0 || (p = cclass(p, sc)) == NULL)
790 return (0);
791 break;
792
793 case '?':
794 if (sc == 0)
795 return (0);
796 if (UTFMODE) {
797 --s;
798 s += utf_ptradj((const void *)s);
799 }
800 break;
801
802 case '*':
803 if (p == pe)
804 return (1);
805 s--;
806 do {
807 if (do_gmatch(s, se, p, pe))
808 return (1);
809 } while (s++ < se);
810 return (0);
811
812 /**
813 * [*+?@!](pattern|pattern|..)
814 * This is also needed for ${..%..}, etc.
815 */
816
817 /* matches one or more times */
818 case 0x80|'+':
819 /* matches zero or more times */
820 case 0x80|'*':
821 if (!(prest = pat_scan(p, pe, false)))
822 return (0);
823 s--;
824 /* take care of zero matches */
825 if (p[-1] == (0x80 | '*') &&
826 do_gmatch(s, se, prest, pe))
827 return (1);
828 for (psub = p; ; psub = pnext) {
829 pnext = pat_scan(psub, pe, true);
830 for (srest = s; srest <= se; srest++) {
831 if (do_gmatch(s, srest, psub, pnext - 2) &&
832 (do_gmatch(srest, se, prest, pe) ||
833 (s != srest && do_gmatch(srest,
834 se, p - 2, pe))))
835 return (1);
836 }
837 if (pnext == prest)
838 break;
839 }
840 return (0);
841
842 /* matches zero or once */
843 case 0x80|'?':
844 /* matches one of the patterns */
845 case 0x80|'@':
846 /* simile for @ */
847 case 0x80|' ':
848 if (!(prest = pat_scan(p, pe, false)))
849 return (0);
850 s--;
851 /* Take care of zero matches */
852 if (p[-1] == (0x80 | '?') &&
853 do_gmatch(s, se, prest, pe))
854 return (1);
855 for (psub = p; ; psub = pnext) {
856 pnext = pat_scan(psub, pe, true);
857 srest = prest == pe ? se : s;
858 for (; srest <= se; srest++) {
859 if (do_gmatch(s, srest, psub, pnext - 2) &&
860 do_gmatch(srest, se, prest, pe))
861 return (1);
862 }
863 if (pnext == prest)
864 break;
865 }
866 return (0);
867
868 /* matches none of the patterns */
869 case 0x80|'!':
870 if (!(prest = pat_scan(p, pe, false)))
871 return (0);
872 s--;
873 for (srest = s; srest <= se; srest++) {
874 int matched = 0;
875
876 for (psub = p; ; psub = pnext) {
877 pnext = pat_scan(psub, pe, true);
878 if (do_gmatch(s, srest, psub,
879 pnext - 2)) {
880 matched = 1;
881 break;
882 }
883 if (pnext == prest)
884 break;
885 }
886 if (!matched &&
887 do_gmatch(srest, se, prest, pe))
888 return (1);
889 }
890 return (0);
891
892 default:
893 if (sc != p[-1])
894 return (0);
895 break;
896 }
897 }
898 return (s == se);
899 }
900
901 static const unsigned char *
cclass(const unsigned char * p,unsigned char sub)902 cclass(const unsigned char *p, unsigned char sub)
903 {
904 unsigned char c, d;
905 bool notp, found = false;
906 const unsigned char *orig_p = p;
907
908 if ((notp = tobool(ISMAGIC(*p) && *++p == '!')))
909 p++;
910 do {
911 c = *p++;
912 if (ISMAGIC(c)) {
913 c = *p++;
914 if ((c & 0x80) && !ISMAGIC(c)) {
915 /* extended pattern matching: *+?@! */
916 c &= 0x7F;
917 /* XXX the ( char isn't handled as part of [] */
918 if (c == ' ')
919 /* simile for @: plain (..) */
920 c = '(' /*)*/;
921 }
922 }
923 if (c == '\0')
924 /* No closing ] - act as if the opening [ was quoted */
925 return (sub == '[' ? orig_p : NULL);
926 if (ISMAGIC(p[0]) && p[1] == '-' &&
927 (!ISMAGIC(p[2]) || p[3] != ']')) {
928 /* MAGIC- */
929 p += 2;
930 d = *p++;
931 if (ISMAGIC(d)) {
932 d = *p++;
933 if ((d & 0x80) && !ISMAGIC(d))
934 d &= 0x7f;
935 }
936 /* POSIX says this is an invalid expression */
937 if (c > d)
938 return (NULL);
939 } else
940 d = c;
941 if (c == sub || (c <= sub && sub <= d))
942 found = true;
943 } while (!(ISMAGIC(p[0]) && p[1] == ']'));
944
945 return ((found != notp) ? p+2 : NULL);
946 }
947
948 /* Look for next ) or | (if match_sep) in *(foo|bar) pattern */
949 static const unsigned char *
pat_scan(const unsigned char * p,const unsigned char * pe,bool match_sep)950 pat_scan(const unsigned char *p, const unsigned char *pe, bool match_sep)
951 {
952 int nest = 0;
953
954 for (; p < pe; p++) {
955 if (!ISMAGIC(*p))
956 continue;
957 if ((*++p == /*(*/ ')' && nest-- == 0) ||
958 (*p == '|' && match_sep && nest == 0))
959 return (p + 1);
960 if ((*p & 0x80) && vstrchr("*+?@! ", *p & 0x7f))
961 nest++;
962 }
963 return (NULL);
964 }
965
966 int
xstrcmp(const void * p1,const void * p2)967 xstrcmp(const void *p1, const void *p2)
968 {
969 return (strcmp(*(const char * const *)p1, *(const char * const *)p2));
970 }
971
972 /* Initialise a Getopt structure */
973 void
ksh_getopt_reset(Getopt * go,int flags)974 ksh_getopt_reset(Getopt *go, int flags)
975 {
976 go->optind = 1;
977 go->optarg = NULL;
978 go->p = 0;
979 go->flags = flags;
980 go->info = 0;
981 go->buf[1] = '\0';
982 }
983
984
985 /**
986 * getopt() used for shell built-in commands, the getopts command, and
987 * command line options.
988 * A leading ':' in options means don't print errors, instead return '?'
989 * or ':' and set go->optarg to the offending option character.
990 * If GF_ERROR is set (and option doesn't start with :), errors result in
991 * a call to bi_errorf().
992 *
993 * Non-standard features:
994 * - ';' is like ':' in options, except the argument is optional
995 * (if it isn't present, optarg is set to 0).
996 * Used for 'set -o'.
997 * - ',' is like ':' in options, except the argument always immediately
998 * follows the option character (optarg is set to the null string if
999 * the option is missing).
1000 * Used for 'read -u2', 'print -u2' and fc -40.
1001 * - '#' is like ':' in options, expect that the argument is optional
1002 * and must start with a digit. If the argument doesn't start with a
1003 * digit, it is assumed to be missing and normal option processing
1004 * continues (optarg is set to 0 if the option is missing).
1005 * Used for 'typeset -LZ4'.
1006 * - accepts +c as well as -c IF the GF_PLUSOPT flag is present. If an
1007 * option starting with + is accepted, the GI_PLUS flag will be set
1008 * in go->info.
1009 */
1010 int
ksh_getopt(const char ** argv,Getopt * go,const char * optionsp)1011 ksh_getopt(const char **argv, Getopt *go, const char *optionsp)
1012 {
1013 char c;
1014 const char *o;
1015
1016 if (go->p == 0 || (c = argv[go->optind - 1][go->p]) == '\0') {
1017 const char *arg = argv[go->optind], flag = arg ? *arg : '\0';
1018
1019 go->p = 1;
1020 if (flag == '-' && arg[1] == '-' && arg[2] == '\0') {
1021 go->optind++;
1022 go->p = 0;
1023 go->info |= GI_MINUSMINUS;
1024 return (-1);
1025 }
1026 if (arg == NULL ||
1027 ((flag != '-' ) &&
1028 /* neither a - nor a + (if + allowed) */
1029 (!(go->flags & GF_PLUSOPT) || flag != '+')) ||
1030 (c = arg[1]) == '\0') {
1031 go->p = 0;
1032 return (-1);
1033 }
1034 go->optind++;
1035 go->info &= ~(GI_MINUS|GI_PLUS);
1036 go->info |= flag == '-' ? GI_MINUS : GI_PLUS;
1037 }
1038 go->p++;
1039 if (c == '?' || c == ':' || c == ';' || c == ',' || c == '#' ||
1040 !(o = cstrchr(optionsp, c))) {
1041 if (optionsp[0] == ':') {
1042 go->buf[0] = c;
1043 go->optarg = go->buf;
1044 } else {
1045 warningf(true, "%s%s-%c: %s",
1046 (go->flags & GF_NONAME) ? "" : argv[0],
1047 (go->flags & GF_NONAME) ? "" : ": ", c,
1048 "unknown option");
1049 if (go->flags & GF_ERROR)
1050 bi_errorfz();
1051 }
1052 return ('?');
1053 }
1054 /**
1055 * : means argument must be present, may be part of option argument
1056 * or the next argument
1057 * ; same as : but argument may be missing
1058 * , means argument is part of option argument, and may be null.
1059 */
1060 if (*++o == ':' || *o == ';') {
1061 if (argv[go->optind - 1][go->p])
1062 go->optarg = argv[go->optind - 1] + go->p;
1063 else if (argv[go->optind])
1064 go->optarg = argv[go->optind++];
1065 else if (*o == ';')
1066 go->optarg = NULL;
1067 else {
1068 if (optionsp[0] == ':') {
1069 go->buf[0] = c;
1070 go->optarg = go->buf;
1071 return (':');
1072 }
1073 warningf(true, "%s%s-%c: %s",
1074 (go->flags & GF_NONAME) ? "" : argv[0],
1075 (go->flags & GF_NONAME) ? "" : ": ", c,
1076 "requires an argument");
1077 if (go->flags & GF_ERROR)
1078 bi_errorfz();
1079 return ('?');
1080 }
1081 go->p = 0;
1082 } else if (*o == ',') {
1083 /* argument is attached to option character, even if null */
1084 go->optarg = argv[go->optind - 1] + go->p;
1085 go->p = 0;
1086 } else if (*o == '#') {
1087 /*
1088 * argument is optional and may be attached or unattached
1089 * but must start with a digit. optarg is set to 0 if the
1090 * argument is missing.
1091 */
1092 if (argv[go->optind - 1][go->p]) {
1093 if (ksh_isdigit(argv[go->optind - 1][go->p])) {
1094 go->optarg = argv[go->optind - 1] + go->p;
1095 go->p = 0;
1096 } else
1097 go->optarg = NULL;
1098 } else {
1099 if (argv[go->optind] && ksh_isdigit(argv[go->optind][0])) {
1100 go->optarg = argv[go->optind++];
1101 go->p = 0;
1102 } else
1103 go->optarg = NULL;
1104 }
1105 }
1106 return (c);
1107 }
1108
1109 /*
1110 * print variable/alias value using necessary quotes
1111 * (POSIX says they should be suitable for re-entry...)
1112 * No trailing newline is printed.
1113 */
1114 void
print_value_quoted(struct shf * shf,const char * s)1115 print_value_quoted(struct shf *shf, const char *s)
1116 {
1117 unsigned char c;
1118 const unsigned char *p = (const unsigned char *)s;
1119 bool inquote = true;
1120
1121 /* first, check whether any quotes are needed */
1122 while ((c = *p++) >= 32)
1123 if (ctype(c, C_QUOTE))
1124 inquote = false;
1125
1126 p = (const unsigned char *)s;
1127 if (c == 0) {
1128 if (inquote) {
1129 /* nope, use the shortcut */
1130 shf_puts(s, shf);
1131 return;
1132 }
1133
1134 /* otherwise, quote nicely via state machine */
1135 while ((c = *p++) != 0) {
1136 if (c == '\'') {
1137 /*
1138 * multiple single quotes or any of them
1139 * at the beginning of a string look nicer
1140 * this way than when simply substituting
1141 */
1142 if (inquote) {
1143 shf_putc('\'', shf);
1144 inquote = false;
1145 }
1146 shf_putc('\\', shf);
1147 } else if (!inquote) {
1148 shf_putc('\'', shf);
1149 inquote = true;
1150 }
1151 shf_putc(c, shf);
1152 }
1153 } else {
1154 unsigned int wc;
1155 size_t n;
1156
1157 /* use $'...' quote format */
1158 shf_putc('$', shf);
1159 shf_putc('\'', shf);
1160 while ((c = *p) != 0) {
1161 if (c >= 0xC2) {
1162 n = utf_mbtowc(&wc, (const char *)p);
1163 if (n != (size_t)-1) {
1164 p += n;
1165 shf_fprintf(shf, "\\u%04X", wc);
1166 continue;
1167 }
1168 }
1169 ++p;
1170 switch (c) {
1171 /* see unbksl() in this file for comments */
1172 case 7:
1173 c = 'a';
1174 if (0)
1175 /* FALLTHROUGH */
1176 case '\b':
1177 c = 'b';
1178 if (0)
1179 /* FALLTHROUGH */
1180 case '\f':
1181 c = 'f';
1182 if (0)
1183 /* FALLTHROUGH */
1184 case '\n':
1185 c = 'n';
1186 if (0)
1187 /* FALLTHROUGH */
1188 case '\r':
1189 c = 'r';
1190 if (0)
1191 /* FALLTHROUGH */
1192 case '\t':
1193 c = 't';
1194 if (0)
1195 /* FALLTHROUGH */
1196 case 11:
1197 c = 'v';
1198 if (0)
1199 /* FALLTHROUGH */
1200 case '\033':
1201 /* take E not e because \e is \ in *roff */
1202 c = 'E';
1203 /* FALLTHROUGH */
1204 case '\\':
1205 shf_putc('\\', shf);
1206
1207 if (0)
1208 /* FALLTHROUGH */
1209 default:
1210 if (c < 32 || c > 0x7E) {
1211 /* FALLTHROUGH */
1212 case '\'':
1213 shf_fprintf(shf, "\\%03o", c);
1214 break;
1215 }
1216
1217 shf_putc(c, shf);
1218 break;
1219 }
1220 }
1221 inquote = true;
1222 }
1223 if (inquote)
1224 shf_putc('\'', shf);
1225 }
1226
1227 /*
1228 * Print things in columns and rows - func() is called to format
1229 * the i-th element
1230 */
1231 void
print_columns(struct shf * shf,unsigned int n,char * (* func)(char *,size_t,unsigned int,const void *),const void * arg,size_t max_oct,size_t max_colz,bool prefcol)1232 print_columns(struct shf *shf, unsigned int n,
1233 char *(*func)(char *, size_t, unsigned int, const void *),
1234 const void *arg, size_t max_oct, size_t max_colz, bool prefcol)
1235 {
1236 unsigned int i, r, c, rows, cols, nspace, max_col;
1237 char *str;
1238
1239 if (!n)
1240 return;
1241
1242 if (max_colz > 2147483646) {
1243 #ifndef MKSH_SMALL
1244 internal_warningf("print_columns called with %s=%zu >= INT_MAX",
1245 "max_col", max_colz);
1246 #endif
1247 return;
1248 }
1249 max_col = (unsigned int)max_colz;
1250
1251 if (max_oct > 2147483646) {
1252 #ifndef MKSH_SMALL
1253 internal_warningf("print_columns called with %s=%zu >= INT_MAX",
1254 "max_oct", max_oct);
1255 #endif
1256 return;
1257 }
1258 ++max_oct;
1259 str = alloc(max_oct, ATEMP);
1260
1261 /*
1262 * We use (max_col + 1) to consider the space separator.
1263 * Note that no space is printed after the last column
1264 * to avoid problems with terminals that have auto-wrap.
1265 */
1266 cols = x_cols / (max_col + 1);
1267
1268 /* if we can only print one column anyway, skip the goo */
1269 if (cols < 2) {
1270 for (i = 0; i < n; ++i)
1271 shf_fprintf(shf, "%s\n",
1272 (*func)(str, max_oct, i, arg));
1273 goto out;
1274 }
1275
1276 rows = (n + cols - 1) / cols;
1277 if (prefcol && cols > rows) {
1278 cols = rows;
1279 rows = (n + cols - 1) / cols;
1280 }
1281
1282 nspace = (x_cols - max_col * cols) / cols;
1283 max_col = -max_col;
1284 if (nspace <= 0)
1285 nspace = 1;
1286 for (r = 0; r < rows; r++) {
1287 for (c = 0; c < cols; c++) {
1288 i = c * rows + r;
1289 if (i < n) {
1290 shf_fprintf(shf, "%*s", max_col,
1291 (*func)(str, max_oct, i, arg));
1292 if (c + 1 < cols)
1293 shf_fprintf(shf, "%*s", nspace, null);
1294 }
1295 }
1296 shf_putchar('\n', shf);
1297 }
1298 out:
1299 afree(str, ATEMP);
1300 }
1301
1302 /* Strip any nul bytes from buf - returns new length (nbytes - # of nuls) */
1303 void
strip_nuls(char * buf,int nbytes)1304 strip_nuls(char *buf, int nbytes)
1305 {
1306 char *dst;
1307
1308 /*
1309 * nbytes check because some systems (older FreeBSDs) have a
1310 * buggy memchr()
1311 */
1312 if (nbytes && (dst = memchr(buf, '\0', nbytes))) {
1313 char *end = buf + nbytes;
1314 char *p, *q;
1315
1316 for (p = dst; p < end; p = q) {
1317 /* skip a block of nulls */
1318 while (++p < end && *p == '\0')
1319 ;
1320 /* find end of non-null block */
1321 if (!(q = memchr(p, '\0', end - p)))
1322 q = end;
1323 memmove(dst, p, q - p);
1324 dst += q - p;
1325 }
1326 *dst = '\0';
1327 }
1328 }
1329
1330 /*
1331 * Like read(2), but if read fails due to non-blocking flag,
1332 * resets flag and restarts read.
1333 */
1334 ssize_t
blocking_read(int fd,char * buf,size_t nbytes)1335 blocking_read(int fd, char *buf, size_t nbytes)
1336 {
1337 ssize_t ret;
1338 bool tried_reset = false;
1339
1340 while ((ret = read(fd, buf, nbytes)) < 0) {
1341 if (!tried_reset && errno == EAGAIN) {
1342 if (reset_nonblock(fd) > 0) {
1343 tried_reset = true;
1344 continue;
1345 }
1346 errno = EAGAIN;
1347 }
1348 break;
1349 }
1350 return (ret);
1351 }
1352
1353 /*
1354 * Reset the non-blocking flag on the specified file descriptor.
1355 * Returns -1 if there was an error, 0 if non-blocking wasn't set,
1356 * 1 if it was.
1357 */
1358 int
reset_nonblock(int fd)1359 reset_nonblock(int fd)
1360 {
1361 int flags;
1362
1363 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1364 return (-1);
1365 if (!(flags & O_NONBLOCK))
1366 return (0);
1367 flags &= ~O_NONBLOCK;
1368 if (fcntl(fd, F_SETFL, flags) < 0)
1369 return (-1);
1370 return (1);
1371 }
1372
1373 /* getcwd(3) equivalent, allocates from ATEMP but doesn't resize */
1374 char *
ksh_get_wd(void)1375 ksh_get_wd(void)
1376 {
1377 #ifdef MKSH__NO_PATH_MAX
1378 char *rv, *cp;
1379
1380 if ((cp = get_current_dir_name())) {
1381 strdupx(rv, cp, ATEMP);
1382 free_gnu_gcdn(cp);
1383 } else
1384 rv = NULL;
1385 #else
1386 char *rv;
1387
1388 if (!getcwd((rv = alloc(PATH_MAX + 1, ATEMP)), PATH_MAX)) {
1389 afree(rv, ATEMP);
1390 rv = NULL;
1391 }
1392 #endif
1393
1394 return (rv);
1395 }
1396
1397 #ifndef ELOOP
1398 #define ELOOP E2BIG
1399 #endif
1400
1401 char *
do_realpath(const char * upath)1402 do_realpath(const char *upath)
1403 {
1404 char *xp, *ip, *tp, *ipath, *ldest = NULL;
1405 XString xs;
1406 ptrdiff_t pos;
1407 size_t len;
1408 int llen;
1409 struct stat sb;
1410 #ifdef MKSH__NO_PATH_MAX
1411 size_t ldestlen = 0;
1412 #define pathlen sb.st_size
1413 #define pathcnd (ldestlen < (pathlen + 1))
1414 #else
1415 #define pathlen PATH_MAX
1416 #define pathcnd (!ldest)
1417 #endif
1418 /* max. recursion depth */
1419 int symlinks = 32;
1420
1421 if (upath[0] == '/') {
1422 /* upath is an absolute pathname */
1423 strdupx(ipath, upath, ATEMP);
1424 } else {
1425 /* upath is a relative pathname, prepend cwd */
1426 if ((tp = ksh_get_wd()) == NULL || tp[0] != '/')
1427 return (NULL);
1428 ipath = shf_smprintf("%s%s%s", tp, "/", upath);
1429 afree(tp, ATEMP);
1430 }
1431
1432 /* ipath and upath are in memory at the same time -> unchecked */
1433 Xinit(xs, xp, strlen(ip = ipath) + 1, ATEMP);
1434
1435 /* now jump into the deep of the loop */
1436 goto beginning_of_a_pathname;
1437
1438 while (*ip) {
1439 /* skip slashes in input */
1440 while (*ip == '/')
1441 ++ip;
1442 if (!*ip)
1443 break;
1444
1445 /* get next pathname component from input */
1446 tp = ip;
1447 while (*ip && *ip != '/')
1448 ++ip;
1449 len = ip - tp;
1450
1451 /* check input for "." and ".." */
1452 if (tp[0] == '.') {
1453 if (len == 1)
1454 /* just continue with the next one */
1455 continue;
1456 else if (len == 2 && tp[1] == '.') {
1457 /* strip off last pathname component */
1458 while (xp > Xstring(xs, xp))
1459 if (*--xp == '/')
1460 break;
1461 /* then continue with the next one */
1462 continue;
1463 }
1464 }
1465
1466 /* store output position away, then append slash to output */
1467 pos = Xsavepos(xs, xp);
1468 /* 1 for the '/' and len + 1 for tp and the NUL from below */
1469 XcheckN(xs, xp, 1 + len + 1);
1470 Xput(xs, xp, '/');
1471
1472 /* append next pathname component to output */
1473 memcpy(xp, tp, len);
1474 xp += len;
1475 *xp = '\0';
1476
1477 /* lstat the current output, see if it's a symlink */
1478 if (mksh_lstat(Xstring(xs, xp), &sb)) {
1479 /* lstat failed */
1480 if (errno == ENOENT) {
1481 /* because the pathname does not exist */
1482 while (*ip == '/')
1483 /* skip any trailing slashes */
1484 ++ip;
1485 /* no more components left? */
1486 if (!*ip)
1487 /* we can still return successfully */
1488 break;
1489 /* more components left? fall through */
1490 }
1491 /* not ENOENT or not at the end of ipath */
1492 goto notfound;
1493 }
1494
1495 /* check if we encountered a symlink? */
1496 if (S_ISLNK(sb.st_mode)) {
1497 #ifndef MKSH__NO_SYMLINK
1498 /* reached maximum recursion depth? */
1499 if (!symlinks--) {
1500 /* yep, prevent infinite loops */
1501 errno = ELOOP;
1502 goto notfound;
1503 }
1504
1505 /* get symlink(7) target */
1506 if (pathcnd) {
1507 #ifdef MKSH__NO_PATH_MAX
1508 if (notoktoadd(pathlen, 1)) {
1509 errno = ENAMETOOLONG;
1510 goto notfound;
1511 }
1512 #endif
1513 ldest = aresize(ldest, pathlen + 1, ATEMP);
1514 }
1515 llen = readlink(Xstring(xs, xp), ldest, pathlen);
1516 if (llen < 0)
1517 /* oops... */
1518 goto notfound;
1519 ldest[llen] = '\0';
1520
1521 /*
1522 * restart if symlink target is an absolute path,
1523 * otherwise continue with currently resolved prefix
1524 */
1525 /* append rest of current input path to link target */
1526 tp = shf_smprintf("%s%s%s", ldest, *ip ? "/" : "", ip);
1527 afree(ipath, ATEMP);
1528 ip = ipath = tp;
1529 if (ldest[0] != '/') {
1530 /* symlink target is a relative path */
1531 xp = Xrestpos(xs, xp, pos);
1532 } else
1533 #endif
1534 {
1535 /* symlink target is an absolute path */
1536 xp = Xstring(xs, xp);
1537 beginning_of_a_pathname:
1538 /* assert: (ip == ipath)[0] == '/' */
1539 /* assert: xp == xs.beg => start of path */
1540
1541 /* exactly two leading slashes? (SUSv4 3.266) */
1542 if (ip[1] == '/' && ip[2] != '/') {
1543 /* keep them, e.g. for UNC pathnames */
1544 Xput(xs, xp, '/');
1545 }
1546 }
1547 }
1548 /* otherwise (no symlink) merely go on */
1549 }
1550
1551 /*
1552 * either found the target and successfully resolved it,
1553 * or found its parent directory and may create it
1554 */
1555 if (Xlength(xs, xp) == 0)
1556 /*
1557 * if the resolved pathname is "", make it "/",
1558 * otherwise do not add a trailing slash
1559 */
1560 Xput(xs, xp, '/');
1561 Xput(xs, xp, '\0');
1562
1563 /*
1564 * if source path had a trailing slash, check if target path
1565 * is not a non-directory existing file
1566 */
1567 if (ip > ipath && ip[-1] == '/') {
1568 if (stat(Xstring(xs, xp), &sb)) {
1569 if (errno != ENOENT)
1570 goto notfound;
1571 } else if (!S_ISDIR(sb.st_mode)) {
1572 errno = ENOTDIR;
1573 goto notfound;
1574 }
1575 /* target now either does not exist or is a directory */
1576 }
1577
1578 /* return target path */
1579 if (ldest != NULL)
1580 afree(ldest, ATEMP);
1581 afree(ipath, ATEMP);
1582 return (Xclose(xs, xp));
1583
1584 notfound:
1585 /* save; freeing memory might trash it */
1586 llen = errno;
1587 if (ldest != NULL)
1588 afree(ldest, ATEMP);
1589 afree(ipath, ATEMP);
1590 Xfree(xs, xp);
1591 errno = llen;
1592 return (NULL);
1593
1594 #undef pathlen
1595 #undef pathcnd
1596 }
1597
1598 /**
1599 * Makes a filename into result using the following algorithm.
1600 * - make result NULL
1601 * - if file starts with '/', append file to result & set cdpathp to NULL
1602 * - if file starts with ./ or ../ append cwd and file to result
1603 * and set cdpathp to NULL
1604 * - if the first element of cdpathp doesnt start with a '/' xx or '.' xx
1605 * then cwd is appended to result.
1606 * - the first element of cdpathp is appended to result
1607 * - file is appended to result
1608 * - cdpathp is set to the start of the next element in cdpathp (or NULL
1609 * if there are no more elements.
1610 * The return value indicates whether a non-null element from cdpathp
1611 * was appended to result.
1612 */
1613 static int
make_path(const char * cwd,const char * file,char ** cdpathp,XString * xsp,int * phys_pathp)1614 make_path(const char *cwd, const char *file,
1615 /* pointer to colon-separated list */
1616 char **cdpathp,
1617 XString *xsp,
1618 int *phys_pathp)
1619 {
1620 int rval = 0;
1621 bool use_cdpath = true;
1622 char *plist;
1623 size_t len, plen = 0;
1624 char *xp = Xstring(*xsp, xp);
1625
1626 if (!file)
1627 file = null;
1628
1629 if (file[0] == '/') {
1630 *phys_pathp = 0;
1631 use_cdpath = false;
1632 } else {
1633 if (file[0] == '.') {
1634 char c = file[1];
1635
1636 if (c == '.')
1637 c = file[2];
1638 if (c == '/' || c == '\0')
1639 use_cdpath = false;
1640 }
1641
1642 plist = *cdpathp;
1643 if (!plist)
1644 use_cdpath = false;
1645 else if (use_cdpath) {
1646 char *pend;
1647
1648 for (pend = plist; *pend && *pend != ':'; pend++)
1649 ;
1650 plen = pend - plist;
1651 *cdpathp = *pend ? pend + 1 : NULL;
1652 }
1653
1654 if ((!use_cdpath || !plen || plist[0] != '/') &&
1655 (cwd && *cwd)) {
1656 len = strlen(cwd);
1657 XcheckN(*xsp, xp, len);
1658 memcpy(xp, cwd, len);
1659 xp += len;
1660 if (cwd[len - 1] != '/')
1661 Xput(*xsp, xp, '/');
1662 }
1663 *phys_pathp = Xlength(*xsp, xp);
1664 if (use_cdpath && plen) {
1665 XcheckN(*xsp, xp, plen);
1666 memcpy(xp, plist, plen);
1667 xp += plen;
1668 if (plist[plen - 1] != '/')
1669 Xput(*xsp, xp, '/');
1670 rval = 1;
1671 }
1672 }
1673
1674 len = strlen(file) + 1;
1675 XcheckN(*xsp, xp, len);
1676 memcpy(xp, file, len);
1677
1678 if (!use_cdpath)
1679 *cdpathp = NULL;
1680
1681 return (rval);
1682 }
1683
1684 /*-
1685 * Simplify pathnames containing "." and ".." entries.
1686 *
1687 * simplify_path(this) = that
1688 * /a/b/c/./../d/.. /a/b
1689 * //./C/foo/bar/../baz //C/foo/baz
1690 * /foo/ /foo
1691 * /foo/../../bar /bar
1692 * /foo/./blah/.. /foo
1693 * . .
1694 * .. ..
1695 * ./foo foo
1696 * foo/../../../bar ../../bar
1697 */
1698 void
simplify_path(char * p)1699 simplify_path(char *p)
1700 {
1701 char *dp, *ip, *sp, *tp;
1702 size_t len;
1703 bool needslash;
1704
1705 switch (*p) {
1706 case 0:
1707 return;
1708 case '/':
1709 /* exactly two leading slashes? (SUSv4 3.266) */
1710 if (p[1] == '/' && p[2] != '/')
1711 /* keep them, e.g. for UNC pathnames */
1712 ++p;
1713 needslash = true;
1714 break;
1715 default:
1716 needslash = false;
1717 }
1718 dp = ip = sp = p;
1719
1720 while (*ip) {
1721 /* skip slashes in input */
1722 while (*ip == '/')
1723 ++ip;
1724 if (!*ip)
1725 break;
1726
1727 /* get next pathname component from input */
1728 tp = ip;
1729 while (*ip && *ip != '/')
1730 ++ip;
1731 len = ip - tp;
1732
1733 /* check input for "." and ".." */
1734 if (tp[0] == '.') {
1735 if (len == 1)
1736 /* just continue with the next one */
1737 continue;
1738 else if (len == 2 && tp[1] == '.') {
1739 /* parent level, but how? */
1740 if (*p == '/')
1741 /* absolute path, only one way */
1742 goto strip_last_component;
1743 else if (dp > sp) {
1744 /* relative path, with subpaths */
1745 needslash = false;
1746 strip_last_component:
1747 /* strip off last pathname component */
1748 while (dp > sp)
1749 if (*--dp == '/')
1750 break;
1751 } else {
1752 /* relative path, at its beginning */
1753 if (needslash)
1754 /* or already dotdot-slash'd */
1755 *dp++ = '/';
1756 /* keep dotdot-slash if not absolute */
1757 *dp++ = '.';
1758 *dp++ = '.';
1759 needslash = true;
1760 sp = dp;
1761 }
1762 /* then continue with the next one */
1763 continue;
1764 }
1765 }
1766
1767 if (needslash)
1768 *dp++ = '/';
1769
1770 /* append next pathname component to output */
1771 memmove(dp, tp, len);
1772 dp += len;
1773
1774 /* append slash if we continue */
1775 needslash = true;
1776 /* try next component */
1777 }
1778 if (dp == p)
1779 /* empty path -> dot */
1780 *dp++ = needslash ? '/' : '.';
1781 *dp = '\0';
1782 }
1783
1784 void
set_current_wd(const char * nwd)1785 set_current_wd(const char *nwd)
1786 {
1787 char *allocd = NULL;
1788
1789 if (nwd == NULL) {
1790 allocd = ksh_get_wd();
1791 nwd = allocd ? allocd : null;
1792 }
1793
1794 afree(current_wd, APERM);
1795 strdupx(current_wd, nwd, APERM);
1796
1797 afree(allocd, ATEMP);
1798 }
1799
1800 int
c_cd(const char ** wp)1801 c_cd(const char **wp)
1802 {
1803 int optc, rv, phys_path;
1804 bool physical = tobool(Flag(FPHYSICAL));
1805 /* was a node from cdpath added in? */
1806 int cdnode;
1807 /* show where we went?, error for $PWD */
1808 bool printpath = false, eflag = false;
1809 struct tbl *pwd_s, *oldpwd_s;
1810 XString xs;
1811 char *dir, *allocd = NULL, *tryp, *pwd, *cdpath;
1812
1813 while ((optc = ksh_getopt(wp, &builtin_opt, "eLP")) != -1)
1814 switch (optc) {
1815 case 'e':
1816 eflag = true;
1817 break;
1818 case 'L':
1819 physical = false;
1820 break;
1821 case 'P':
1822 physical = true;
1823 break;
1824 case '?':
1825 return (2);
1826 }
1827 wp += builtin_opt.optind;
1828
1829 if (Flag(FRESTRICTED)) {
1830 bi_errorf("restricted shell - can't cd");
1831 return (2);
1832 }
1833
1834 pwd_s = global("PWD");
1835 oldpwd_s = global("OLDPWD");
1836
1837 if (!wp[0]) {
1838 /* No arguments - go home */
1839 if ((dir = str_val(global("HOME"))) == null) {
1840 bi_errorf("no home directory (HOME not set)");
1841 return (2);
1842 }
1843 } else if (!wp[1]) {
1844 /* One argument: - or dir */
1845 strdupx(allocd, wp[0], ATEMP);
1846 if (ksh_isdash((dir = allocd))) {
1847 afree(allocd, ATEMP);
1848 allocd = NULL;
1849 dir = str_val(oldpwd_s);
1850 if (dir == null) {
1851 bi_errorf("no OLDPWD");
1852 return (2);
1853 }
1854 printpath = true;
1855 }
1856 } else if (!wp[2]) {
1857 /* Two arguments - substitute arg1 in PWD for arg2 */
1858 size_t ilen, olen, nlen, elen;
1859 char *cp;
1860
1861 if (!current_wd[0]) {
1862 bi_errorf("can't determine current directory");
1863 return (2);
1864 }
1865 /*
1866 * substitute arg1 for arg2 in current path.
1867 * if the first substitution fails because the cd fails
1868 * we could try to find another substitution. For now
1869 * we don't
1870 */
1871 if ((cp = strstr(current_wd, wp[0])) == NULL) {
1872 bi_errorf("bad substitution");
1873 return (2);
1874 }
1875 /*-
1876 * ilen = part of current_wd before wp[0]
1877 * elen = part of current_wd after wp[0]
1878 * because current_wd and wp[1] need to be in memory at the
1879 * same time beforehand the addition can stay unchecked
1880 */
1881 ilen = cp - current_wd;
1882 olen = strlen(wp[0]);
1883 nlen = strlen(wp[1]);
1884 elen = strlen(current_wd + ilen + olen) + 1;
1885 dir = allocd = alloc(ilen + nlen + elen, ATEMP);
1886 memcpy(dir, current_wd, ilen);
1887 memcpy(dir + ilen, wp[1], nlen);
1888 memcpy(dir + ilen + nlen, current_wd + ilen + olen, elen);
1889 printpath = true;
1890 } else {
1891 bi_errorf("too many arguments");
1892 return (2);
1893 }
1894
1895 #ifdef MKSH__NO_PATH_MAX
1896 /* only a first guess; make_path will enlarge xs if necessary */
1897 XinitN(xs, 1024, ATEMP);
1898 #else
1899 XinitN(xs, PATH_MAX, ATEMP);
1900 #endif
1901
1902 cdpath = str_val(global("CDPATH"));
1903 do {
1904 cdnode = make_path(current_wd, dir, &cdpath, &xs, &phys_path);
1905 if (physical)
1906 rv = chdir(tryp = Xstring(xs, xp) + phys_path);
1907 else {
1908 simplify_path(Xstring(xs, xp));
1909 rv = chdir(tryp = Xstring(xs, xp));
1910 }
1911 } while (rv < 0 && cdpath != NULL);
1912
1913 if (rv < 0) {
1914 if (cdnode)
1915 bi_errorf("%s: %s", dir, "bad directory");
1916 else
1917 bi_errorf("%s: %s", tryp, cstrerror(errno));
1918 afree(allocd, ATEMP);
1919 Xfree(xs, xp);
1920 return (2);
1921 }
1922
1923 rv = 0;
1924
1925 /* allocd (above) => dir, which is no longer used */
1926 afree(allocd, ATEMP);
1927 allocd = NULL;
1928
1929 /* Clear out tracked aliases with relative paths */
1930 flushcom(false);
1931
1932 /*
1933 * Set OLDPWD (note: unsetting OLDPWD does not disable this
1934 * setting in AT&T ksh)
1935 */
1936 if (current_wd[0])
1937 /* Ignore failure (happens if readonly or integer) */
1938 setstr(oldpwd_s, current_wd, KSH_RETURN_ERROR);
1939
1940 if (Xstring(xs, xp)[0] != '/') {
1941 pwd = NULL;
1942 } else if (!physical) {
1943 goto norealpath_PWD;
1944 } else if ((pwd = allocd = do_realpath(Xstring(xs, xp))) == NULL) {
1945 if (eflag)
1946 rv = 1;
1947 norealpath_PWD:
1948 pwd = Xstring(xs, xp);
1949 }
1950
1951 /* Set PWD */
1952 if (pwd) {
1953 char *ptmp = pwd;
1954
1955 set_current_wd(ptmp);
1956 /* Ignore failure (happens if readonly or integer) */
1957 setstr(pwd_s, ptmp, KSH_RETURN_ERROR);
1958 } else {
1959 set_current_wd(null);
1960 pwd = Xstring(xs, xp);
1961 /* XXX unset $PWD? */
1962 if (eflag)
1963 rv = 1;
1964 }
1965 if (printpath || cdnode)
1966 shprintf("%s\n", pwd);
1967
1968 afree(allocd, ATEMP);
1969 Xfree(xs, xp);
1970 return (rv);
1971 }
1972
1973
1974 #ifdef KSH_CHVT_CODE
1975 extern uint32_t chvt_rndsetup(const void *, size_t);
1976 extern void chvt_reinit(void);
1977
1978 static void
chvt(const Getopt * go)1979 chvt(const Getopt *go)
1980 {
1981 const char *dv = go->optarg;
1982 char *cp = NULL;
1983 int fd;
1984
1985 switch (*dv) {
1986 case '-':
1987 dv = "/dev/null";
1988 break;
1989 case '!':
1990 ++dv;
1991 /* FALLTHROUGH */
1992 default: {
1993 struct stat sb;
1994
1995 if (stat(dv, &sb)) {
1996 cp = shf_smprintf("/dev/ttyC%s", dv);
1997 dv = cp;
1998 if (stat(dv, &sb)) {
1999 memmove(cp + 1, cp, /* /dev/tty */ 8);
2000 dv = cp + 1;
2001 if (stat(dv, &sb)) {
2002 errorf("%s: %s: %s", "chvt",
2003 "can't find tty", go->optarg);
2004 }
2005 }
2006 }
2007 if (!(sb.st_mode & S_IFCHR))
2008 errorf("%s: %s: %s", "chvt", "not a char device", dv);
2009 #ifndef MKSH_DISABLE_REVOKE_WARNING
2010 #if HAVE_REVOKE
2011 if (revoke(dv))
2012 #endif
2013 warningf(false, "%s: %s %s", "chvt",
2014 "new shell is potentially insecure, can't revoke",
2015 dv);
2016 #endif
2017 }
2018 }
2019 if ((fd = open(dv, O_RDWR)) < 0) {
2020 sleep(1);
2021 if ((fd = open(dv, O_RDWR)) < 0) {
2022 errorf("%s: %s %s", "chvt", "can't open", dv);
2023 }
2024 }
2025 if (go->optarg[0] != '!') {
2026 switch (fork()) {
2027 case -1:
2028 errorf("%s: %s %s", "chvt", "fork", "failed");
2029 case 0:
2030 break;
2031 default:
2032 exit(0);
2033 }
2034 }
2035 if (setsid() == -1)
2036 errorf("%s: %s %s", "chvt", "setsid", "failed");
2037 if (go->optarg[0] != '-') {
2038 if (ioctl(fd, TIOCSCTTY, NULL) == -1)
2039 errorf("%s: %s %s", "chvt", "TIOCSCTTY", "failed");
2040 if (tcflush(fd, TCIOFLUSH))
2041 errorf("%s: %s %s", "chvt", "TCIOFLUSH", "failed");
2042 }
2043 ksh_dup2(fd, 0, false);
2044 ksh_dup2(fd, 1, false);
2045 ksh_dup2(fd, 2, false);
2046 if (fd > 2)
2047 close(fd);
2048 rndset((unsigned long)chvt_rndsetup(go, sizeof(Getopt)));
2049 chvt_reinit();
2050 }
2051 #endif
2052
2053 #ifdef DEBUG
2054 char *
strchr(char * p,int ch)2055 strchr(char *p, int ch)
2056 {
2057 for (;; ++p) {
2058 if (*p == ch)
2059 return (p);
2060 if (!*p)
2061 return (NULL);
2062 }
2063 /* NOTREACHED */
2064 }
2065
2066 char *
strstr(char * b,const char * l)2067 strstr(char *b, const char *l)
2068 {
2069 char first, c;
2070 size_t n;
2071
2072 if ((first = *l++) == '\0')
2073 return (b);
2074 n = strlen(l);
2075 strstr_look:
2076 while ((c = *b++) != first)
2077 if (c == '\0')
2078 return (NULL);
2079 if (strncmp(b, l, n))
2080 goto strstr_look;
2081 return (b - 1);
2082 }
2083 #endif
2084
2085 #if defined(MKSH_SMALL) && !defined(MKSH_SMALL_BUT_FAST)
2086 char *
strndup_i(const char * src,size_t len,Area * ap)2087 strndup_i(const char *src, size_t len, Area *ap)
2088 {
2089 char *dst = NULL;
2090
2091 if (src != NULL) {
2092 dst = alloc(len + 1, ap);
2093 memcpy(dst, src, len);
2094 dst[len] = '\0';
2095 }
2096 return (dst);
2097 }
2098
2099 char *
strdup_i(const char * src,Area * ap)2100 strdup_i(const char *src, Area *ap)
2101 {
2102 return (src == NULL ? NULL : strndup_i(src, strlen(src), ap));
2103 }
2104 #endif
2105
2106 #if !HAVE_GETRUSAGE
2107 #define INVTCK(r,t) do { \
2108 r.tv_usec = ((t) % (1000000 / CLK_TCK)) * (1000000 / CLK_TCK); \
2109 r.tv_sec = (t) / CLK_TCK; \
2110 } while (/* CONSTCOND */ 0)
2111
2112 int
getrusage(int what,struct rusage * ru)2113 getrusage(int what, struct rusage *ru)
2114 {
2115 struct tms tms;
2116 clock_t u, s;
2117
2118 if (/* ru == NULL || */ times(&tms) == (clock_t)-1)
2119 return (-1);
2120
2121 switch (what) {
2122 case RUSAGE_SELF:
2123 u = tms.tms_utime;
2124 s = tms.tms_stime;
2125 break;
2126 case RUSAGE_CHILDREN:
2127 u = tms.tms_cutime;
2128 s = tms.tms_cstime;
2129 break;
2130 default:
2131 errno = EINVAL;
2132 return (-1);
2133 }
2134 INVTCK(ru->ru_utime, u);
2135 INVTCK(ru->ru_stime, s);
2136 return (0);
2137 }
2138 #endif
2139
2140 /*
2141 * process the string available via fg (get a char)
2142 * and fp (put back a char) for backslash escapes,
2143 * assuming the first call to *fg gets the char di-
2144 * rectly after the backslash; return the character
2145 * (0..0xFF), Unicode (wc + 0x100), or -1 if no known
2146 * escape sequence was found
2147 */
2148 int
unbksl(bool cstyle,int (* fg)(void),void (* fp)(int))2149 unbksl(bool cstyle, int (*fg)(void), void (*fp)(int))
2150 {
2151 int wc, i, c, fc;
2152
2153 fc = (*fg)();
2154 switch (fc) {
2155 case 'a':
2156 /*
2157 * according to the comments in pdksh, \007 seems
2158 * to be more portable than \a (due to HP-UX cc,
2159 * Ultrix cc, old pcc, etc.) so we avoid the escape
2160 * sequence altogether in mksh and assume ASCII
2161 */
2162 wc = 7;
2163 break;
2164 case 'b':
2165 wc = '\b';
2166 break;
2167 case 'c':
2168 if (!cstyle)
2169 goto unknown_escape;
2170 c = (*fg)();
2171 wc = CTRL(c);
2172 break;
2173 case 'E':
2174 case 'e':
2175 wc = 033;
2176 break;
2177 case 'f':
2178 wc = '\f';
2179 break;
2180 case 'n':
2181 wc = '\n';
2182 break;
2183 case 'r':
2184 wc = '\r';
2185 break;
2186 case 't':
2187 wc = '\t';
2188 break;
2189 case 'v':
2190 /* assume ASCII here as well */
2191 wc = 11;
2192 break;
2193 case '1':
2194 case '2':
2195 case '3':
2196 case '4':
2197 case '5':
2198 case '6':
2199 case '7':
2200 if (!cstyle)
2201 goto unknown_escape;
2202 /* FALLTHROUGH */
2203 case '0':
2204 if (cstyle)
2205 (*fp)(fc);
2206 /*
2207 * look for an octal number with up to three
2208 * digits, not counting the leading zero;
2209 * convert it to a raw octet
2210 */
2211 wc = 0;
2212 i = 3;
2213 while (i--)
2214 if ((c = (*fg)()) >= '0' && c <= '7')
2215 wc = (wc << 3) + (c - '0');
2216 else {
2217 (*fp)(c);
2218 break;
2219 }
2220 break;
2221 case 'U':
2222 i = 8;
2223 if (/* CONSTCOND */ 0)
2224 /* FALLTHROUGH */
2225 case 'u':
2226 i = 4;
2227 if (/* CONSTCOND */ 0)
2228 /* FALLTHROUGH */
2229 case 'x':
2230 i = cstyle ? -1 : 2;
2231 /**
2232 * x: look for a hexadecimal number with up to
2233 * two (C style: arbitrary) digits; convert
2234 * to raw octet (C style: Unicode if >0xFF)
2235 * u/U: look for a hexadecimal number with up to
2236 * four (U: eight) digits; convert to Unicode
2237 */
2238 wc = 0;
2239 while (i--) {
2240 wc <<= 4;
2241 if ((c = (*fg)()) >= '0' && c <= '9')
2242 wc += c - '0';
2243 else if (c >= 'A' && c <= 'F')
2244 wc += c - 'A' + 10;
2245 else if (c >= 'a' && c <= 'f')
2246 wc += c - 'a' + 10;
2247 else {
2248 wc >>= 4;
2249 (*fp)(c);
2250 break;
2251 }
2252 }
2253 if ((cstyle && wc > 0xFF) || fc != 'x')
2254 /* Unicode marker */
2255 wc += 0x100;
2256 break;
2257 case '\'':
2258 if (!cstyle)
2259 goto unknown_escape;
2260 wc = '\'';
2261 break;
2262 case '\\':
2263 wc = '\\';
2264 break;
2265 default:
2266 unknown_escape:
2267 (*fp)(fc);
2268 return (-1);
2269 }
2270
2271 return (wc);
2272 }
2273