| /* $OpenBSD: c_ksh.c,v 1.33 2009/02/07 14:03:24 kili Exp $ */ |
| /* $OpenBSD: c_sh.c,v 1.41 2010/03/27 09:10:01 jmc Exp $ */ |
| /* $OpenBSD: c_test.c,v 1.18 2009/03/01 20:11:06 otto Exp $ */ |
| /* $OpenBSD: c_ulimit.c,v 1.17 2008/03/21 12:51:19 millert Exp $ */ |
| |
| /*- |
| * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
| * Thorsten Glaser <tg@mirbsd.org> |
| * |
| * Provided that these terms and disclaimer and all copyright notices |
| * are retained or reproduced in an accompanying document, permission |
| * is granted to deal in this work without restriction, including un- |
| * limited rights to use, publicly perform, distribute, sell, modify, |
| * merge, give away, or sublicence. |
| * |
| * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to |
| * the utmost extent permitted by applicable law, neither express nor |
| * implied; without malicious intent or gross negligence. In no event |
| * may a licensor, author or contributor be held liable for indirect, |
| * direct, other damage, loss, or other issues arising in any way out |
| * of dealing in the work, even if advised of the possibility of such |
| * damage or existence of a defect, except proven that it results out |
| * of said person's immediate fault when using the work as intended. |
| */ |
| |
| #include "sh.h" |
| |
| __RCSID("$MirOS: src/bin/mksh/funcs.c,v 1.157 2010/08/24 14:42:01 tg Exp $"); |
| |
| #if HAVE_KILLPG |
| /* |
| * use killpg if < -1 since -1 does special things |
| * for some non-killpg-endowed kills |
| */ |
| #define mksh_kill(p,s) ((p) < -1 ? killpg(-(p), (s)) : kill((p), (s))) |
| #else |
| /* cross fingers and hope kill is killpg-endowed */ |
| #define mksh_kill kill |
| #endif |
| |
| /* XXX conditions correct? */ |
| #if !defined(RLIM_INFINITY) && !defined(MKSH_NO_LIMITS) |
| #define MKSH_NO_LIMITS |
| #endif |
| |
| #ifdef MKSH_NO_LIMITS |
| #define c_ulimit c_label |
| #endif |
| |
| extern uint8_t set_refflag; |
| |
| /* A leading = means assignments before command are kept; |
| * a leading * means a POSIX special builtin; |
| * a leading + means a POSIX regular builtin |
| * (* and + should not be combined). |
| */ |
| const struct builtin mkshbuiltins[] = { |
| {"*=.", c_dot}, |
| {"*=:", c_label}, |
| {"[", c_test}, |
| {"*=break", c_brkcont}, |
| {"=builtin", c_builtin}, |
| {"*=continue", c_brkcont}, |
| {"*=eval", c_eval}, |
| {"*=exec", c_exec}, |
| {"*=exit", c_exitreturn}, |
| {"+false", c_label}, |
| {"*=return", c_exitreturn}, |
| {"*=set", c_set}, |
| {"*=shift", c_shift}, |
| {"=times", c_times}, |
| {"*=trap", c_trap}, |
| {"+=wait", c_wait}, |
| {"+read", c_read}, |
| {"test", c_test}, |
| {"+true", c_label}, |
| {"ulimit", c_ulimit}, |
| {"+umask", c_umask}, |
| {"*=unset", c_unset}, |
| {"+alias", c_alias}, /* no =: AT&T manual wrong */ |
| {"+cd", c_cd}, |
| {"chdir", c_cd}, /* dash compatibility hack */ |
| {"+command", c_command}, |
| {"echo", c_print}, |
| {"*=export", c_typeset}, |
| {"+fc", c_fc}, |
| {"+getopts", c_getopts}, |
| {"+jobs", c_jobs}, |
| {"+kill", c_kill}, |
| {"let", c_let}, |
| {"print", c_print}, |
| #ifdef MKSH_PRINTF_BUILTIN |
| {"printf", c_printf}, |
| #endif |
| {"pwd", c_pwd}, |
| {"*=readonly", c_typeset}, |
| {T__typeset, c_typeset}, |
| {"+unalias", c_unalias}, |
| {"whence", c_whence}, |
| #ifndef MKSH_UNEMPLOYED |
| {"+bg", c_fgbg}, |
| {"+fg", c_fgbg}, |
| #endif |
| {"bind", c_bind}, |
| #if HAVE_MKNOD |
| {"mknod", c_mknod}, |
| #endif |
| {"realpath", c_realpath}, |
| {"rename", c_rename}, |
| {NULL, (int (*)(const char **))NULL} |
| }; |
| |
| struct kill_info { |
| int num_width; |
| int name_width; |
| }; |
| |
| static const struct t_op { |
| char op_text[4]; |
| Test_op op_num; |
| } u_ops[] = { |
| {"-a", TO_FILAXST }, |
| {"-b", TO_FILBDEV }, |
| {"-c", TO_FILCDEV }, |
| {"-d", TO_FILID }, |
| {"-e", TO_FILEXST }, |
| {"-f", TO_FILREG }, |
| {"-G", TO_FILGID }, |
| {"-g", TO_FILSETG }, |
| {"-h", TO_FILSYM }, |
| {"-H", TO_FILCDF }, |
| {"-k", TO_FILSTCK }, |
| {"-L", TO_FILSYM }, |
| {"-n", TO_STNZE }, |
| {"-O", TO_FILUID }, |
| {"-o", TO_OPTION }, |
| {"-p", TO_FILFIFO }, |
| {"-r", TO_FILRD }, |
| {"-s", TO_FILGZ }, |
| {"-S", TO_FILSOCK }, |
| {"-t", TO_FILTT }, |
| {"-u", TO_FILSETU }, |
| {"-w", TO_FILWR }, |
| {"-x", TO_FILEX }, |
| {"-z", TO_STZER }, |
| {"", TO_NONOP } |
| }; |
| static const struct t_op b_ops[] = { |
| {"=", TO_STEQL }, |
| {"==", TO_STEQL }, |
| {"!=", TO_STNEQ }, |
| {"<", TO_STLT }, |
| {">", TO_STGT }, |
| {"-eq", TO_INTEQ }, |
| {"-ne", TO_INTNE }, |
| {"-gt", TO_INTGT }, |
| {"-ge", TO_INTGE }, |
| {"-lt", TO_INTLT }, |
| {"-le", TO_INTLE }, |
| {"-ef", TO_FILEQ }, |
| {"-nt", TO_FILNT }, |
| {"-ot", TO_FILOT }, |
| {"", TO_NONOP } |
| }; |
| |
| static int test_eaccess(const char *, int); |
| static int test_oexpr(Test_env *, bool); |
| static int test_aexpr(Test_env *, bool); |
| static int test_nexpr(Test_env *, bool); |
| static int test_primary(Test_env *, bool); |
| static Test_op ptest_isa(Test_env *, Test_meta); |
| static const char *ptest_getopnd(Test_env *, Test_op, bool); |
| static void ptest_error(Test_env *, int, const char *); |
| static char *kill_fmt_entry(char *, int, int, const void *); |
| static void p_time(struct shf *, bool, long, int, int, |
| const char *, const char *) |
| MKSH_A_NONNULL((nonnull (6, 7))); |
| static char *do_realpath(const char *); |
| |
| static char * |
| do_realpath(const char *upath) |
| { |
| char *xp, *ip, *tp, *ipath, *ldest = NULL; |
| XString xs; |
| ptrdiff_t pos; |
| size_t len; |
| int symlinks = 32; /* max. recursion depth */ |
| int llen; |
| struct stat sb; |
| #ifdef NO_PATH_MAX |
| size_t ldestlen = 0; |
| #define pathlen sb.st_size |
| #define pathcnd (ldestlen < (pathlen + 1)) |
| #else |
| #define pathlen PATH_MAX |
| #define pathcnd (!ldest) |
| #endif |
| |
| if (upath[0] == '/') { |
| /* upath is an absolute pathname */ |
| strdupx(ipath, upath, ATEMP); |
| } else { |
| /* upath is a relative pathname, prepend cwd */ |
| if ((tp = ksh_get_wd(NULL)) == NULL || tp[0] != '/') |
| return (NULL); |
| ipath = shf_smprintf("%s/%s", tp, upath); |
| afree(tp, ATEMP); |
| } |
| |
| Xinit(xs, xp, strlen(ip = ipath) + 1, ATEMP); |
| |
| while (*ip) { |
| /* skip slashes in input */ |
| while (*ip == '/') |
| ++ip; |
| if (!*ip) |
| break; |
| |
| /* get next pathname component from input */ |
| tp = ip; |
| while (*ip && *ip != '/') |
| ++ip; |
| len = ip - tp; |
| |
| /* check input for "." and ".." */ |
| if (tp[0] == '.') { |
| if (len == 1) |
| /* just continue with the next one */ |
| continue; |
| else if (len == 2 && tp[1] == '.') { |
| /* strip off last pathname component */ |
| while (xp > Xstring(xs, xp)) |
| if (*--xp == '/') |
| break; |
| /* then continue with the next one */ |
| continue; |
| } |
| } |
| |
| /* store output position away, then append slash to output */ |
| pos = Xsavepos(xs, xp); |
| /* 1 for the '/' and len + 1 for tp and the NUL from below */ |
| XcheckN(xs, xp, 1 + len + 1); |
| Xput(xs, xp, '/'); |
| |
| /* append next pathname component to output */ |
| memcpy(xp, tp, len); |
| xp += len; |
| *xp = '\0'; |
| |
| /* lstat the current output, see if it's a symlink */ |
| if (lstat(Xstring(xs, xp), &sb)) { |
| /* lstat failed */ |
| if (errno == ENOENT) { |
| /* because the pathname does not exist */ |
| while (*ip == '/') |
| /* skip any trailing slashes */ |
| ++ip; |
| /* no more components left? */ |
| if (!*ip) |
| /* we can still return successfully */ |
| break; |
| /* more components left? fall through */ |
| } |
| /* not ENOENT or not at the end of ipath */ |
| goto notfound; |
| } |
| |
| /* check if we encountered a symlink? */ |
| if (S_ISLNK(sb.st_mode)) { |
| /* reached maximum recursion depth? */ |
| if (!symlinks--) { |
| /* yep, prevent infinite loops */ |
| errno = ELOOP; |
| goto notfound; |
| } |
| |
| /* get symlink(7) target */ |
| if (pathcnd) |
| ldest = aresize(ldest, pathlen + 1, ATEMP); |
| llen = readlink(Xstring(xs, xp), ldest, pathlen); |
| if (llen < 0) |
| /* oops... */ |
| goto notfound; |
| ldest[llen] = '\0'; |
| |
| /* |
| * restart if symlink target is an absolute path, |
| * otherwise continue with currently resolved prefix |
| */ |
| xp = (ldest[0] == '/') ? Xstring(xs, xp) : |
| Xrestpos(xs, xp, pos); |
| tp = shf_smprintf("%s%s%s", ldest, *ip ? "/" : "", ip); |
| afree(ipath, ATEMP); |
| ip = ipath = tp; |
| } |
| /* otherwise (no symlink) merely go on */ |
| } |
| |
| /* |
| * either found the target and successfully resolved it, |
| * or found its parent directory and may create it |
| */ |
| if (Xlength(xs, xp) == 0) |
| /* |
| * if the resolved pathname is "", make it "/", |
| * otherwise do not add a trailing slash |
| */ |
| Xput(xs, xp, '/'); |
| Xput(xs, xp, '\0'); |
| |
| /* |
| * if source path had a trailing slash, check if target path |
| * is not a non-directory existing file |
| */ |
| if (ip > ipath && ip[-1] == '/') { |
| if (stat(Xstring(xs, xp), &sb)) { |
| if (errno != ENOENT) |
| goto notfound; |
| } else if (!S_ISDIR(sb.st_mode)) { |
| errno = ENOTDIR; |
| goto notfound; |
| } |
| /* target now either does not exist or is a directory */ |
| } |
| |
| /* return target path */ |
| if (ldest != NULL) |
| afree(ldest, ATEMP); |
| afree(ipath, ATEMP); |
| return (Xclose(xs, xp)); |
| |
| notfound: |
| llen = errno; /* save; free(3) might trash it */ |
| if (ldest != NULL) |
| afree(ldest, ATEMP); |
| afree(ipath, ATEMP); |
| Xfree(xs, xp); |
| errno = llen; |
| return (NULL); |
| |
| #undef pathlen |
| #undef pathcnd |
| } |
| |
| int |
| c_cd(const char **wp) |
| { |
| int optc, rv, phys_path; |
| bool physical = Flag(FPHYSICAL) ? true : false; |
| int cdnode; /* was a node from cdpath added in? */ |
| bool printpath = false; /* print where we cd'd? */ |
| struct tbl *pwd_s, *oldpwd_s; |
| XString xs; |
| char *dir, *allocd = NULL, *tryp, *pwd, *cdpath; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1) |
| switch (optc) { |
| case 'L': |
| physical = false; |
| break; |
| case 'P': |
| physical = true; |
| break; |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| |
| if (Flag(FRESTRICTED)) { |
| bi_errorf("restricted shell - can't cd"); |
| return (1); |
| } |
| |
| pwd_s = global("PWD"); |
| oldpwd_s = global("OLDPWD"); |
| |
| if (!wp[0]) { |
| /* No arguments - go home */ |
| if ((dir = str_val(global("HOME"))) == null) { |
| bi_errorf("no home directory (HOME not set)"); |
| return (1); |
| } |
| } else if (!wp[1]) { |
| /* One argument: - or dir */ |
| strdupx(allocd, wp[0], ATEMP); |
| if (ksh_isdash((dir = allocd))) { |
| afree(allocd, ATEMP); |
| allocd = NULL; |
| dir = str_val(oldpwd_s); |
| if (dir == null) { |
| bi_errorf("no OLDPWD"); |
| return (1); |
| } |
| printpath = true; |
| } |
| } else if (!wp[2]) { |
| /* Two arguments - substitute arg1 in PWD for arg2 */ |
| int ilen, olen, nlen, elen; |
| char *cp; |
| |
| if (!current_wd[0]) { |
| bi_errorf("don't know current directory"); |
| return (1); |
| } |
| /* substitute arg1 for arg2 in current path. |
| * if the first substitution fails because the cd fails |
| * we could try to find another substitution. For now |
| * we don't |
| */ |
| if ((cp = strstr(current_wd, wp[0])) == NULL) { |
| bi_errorf("bad substitution"); |
| return (1); |
| } |
| ilen = cp - current_wd; |
| olen = strlen(wp[0]); |
| nlen = strlen(wp[1]); |
| elen = strlen(current_wd + ilen + olen) + 1; |
| dir = allocd = alloc(ilen + nlen + elen, ATEMP); |
| memcpy(dir, current_wd, ilen); |
| memcpy(dir + ilen, wp[1], nlen); |
| memcpy(dir + ilen + nlen, current_wd + ilen + olen, elen); |
| printpath = true; |
| } else { |
| bi_errorf("too many arguments"); |
| return (1); |
| } |
| |
| #ifdef NO_PATH_MAX |
| /* only a first guess; make_path will enlarge xs if necessary */ |
| XinitN(xs, 1024, ATEMP); |
| #else |
| XinitN(xs, PATH_MAX, ATEMP); |
| #endif |
| |
| cdpath = str_val(global("CDPATH")); |
| do { |
| cdnode = make_path(current_wd, dir, &cdpath, &xs, &phys_path); |
| if (physical) |
| rv = chdir(tryp = Xstring(xs, xp) + phys_path); |
| else { |
| simplify_path(Xstring(xs, xp)); |
| rv = chdir(tryp = Xstring(xs, xp)); |
| } |
| } while (rv < 0 && cdpath != NULL); |
| |
| if (rv < 0) { |
| if (cdnode) |
| bi_errorf("%s: bad directory", dir); |
| else |
| bi_errorf("%s - %s", tryp, strerror(errno)); |
| afree(allocd, ATEMP); |
| return (1); |
| } |
| |
| /* allocd (above) => dir, which is no longer used */ |
| afree(allocd, ATEMP); |
| allocd = NULL; |
| |
| /* Clear out tracked aliases with relative paths */ |
| flushcom(0); |
| |
| /* Set OLDPWD (note: unsetting OLDPWD does not disable this |
| * setting in AT&T ksh) |
| */ |
| if (current_wd[0]) |
| /* Ignore failure (happens if readonly or integer) */ |
| setstr(oldpwd_s, current_wd, KSH_RETURN_ERROR); |
| |
| if (Xstring(xs, xp)[0] != '/') { |
| pwd = NULL; |
| } else if (!physical || !(pwd = allocd = do_realpath(Xstring(xs, xp)))) |
| pwd = Xstring(xs, xp); |
| |
| /* Set PWD */ |
| if (pwd) { |
| char *ptmp = pwd; |
| |
| set_current_wd(ptmp); |
| /* Ignore failure (happens if readonly or integer) */ |
| setstr(pwd_s, ptmp, KSH_RETURN_ERROR); |
| } else { |
| set_current_wd(null); |
| pwd = Xstring(xs, xp); |
| /* XXX unset $PWD? */ |
| } |
| if (printpath || cdnode) |
| shprintf("%s\n", pwd); |
| |
| afree(allocd, ATEMP); |
| return (0); |
| } |
| |
| int |
| c_pwd(const char **wp) |
| { |
| int optc; |
| bool physical = Flag(FPHYSICAL) ? true : false; |
| char *p, *allocd = NULL; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1) |
| switch (optc) { |
| case 'L': |
| physical = false; |
| break; |
| case 'P': |
| physical = true; |
| break; |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| |
| if (wp[0]) { |
| bi_errorf("too many arguments"); |
| return (1); |
| } |
| p = current_wd[0] ? (physical ? allocd = do_realpath(current_wd) : |
| current_wd) : NULL; |
| if (p && access(p, R_OK) < 0) |
| p = NULL; |
| if (!p && !(p = allocd = ksh_get_wd(NULL))) { |
| bi_errorf("can't get current directory - %s", strerror(errno)); |
| return (1); |
| } |
| shprintf("%s\n", p); |
| afree(allocd, ATEMP); |
| return (0); |
| } |
| |
| static const char *s_ptr; |
| static int s_get(void); |
| static void s_put(int); |
| |
| int |
| c_print(const char **wp) |
| { |
| #define PO_NL BIT(0) /* print newline */ |
| #define PO_EXPAND BIT(1) /* expand backslash sequences */ |
| #define PO_PMINUSMINUS BIT(2) /* print a -- argument */ |
| #define PO_HIST BIT(3) /* print to history instead of stdout */ |
| #define PO_COPROC BIT(4) /* printing to coprocess: block SIGPIPE */ |
| int fd = 1, c; |
| int flags = PO_EXPAND|PO_NL; |
| const char *s, *emsg; |
| XString xs; |
| char *xp; |
| |
| if (wp[0][0] == 'e') { |
| /* echo builtin */ |
| wp++; |
| if (Flag(FPOSIX) || Flag(FSH)) { |
| /* Debian Policy 10.4 compliant "echo" builtin */ |
| if (*wp && !strcmp(*wp, "-n")) { |
| /* we recognise "-n" only as the first arg */ |
| flags = 0; |
| wp++; |
| } else |
| /* otherwise, we print everything as-is */ |
| flags = PO_NL; |
| } else { |
| int nflags = flags; |
| |
| /** |
| * a compromise between sysV and BSD echo commands: |
| * escape sequences are enabled by default, and -n, |
| * -e and -E are recognised if they appear in argu- |
| * ments with no illegal options (ie, echo -nq will |
| * print -nq). |
| * Different from sysV echo since options are reco- |
| * gnised, different from BSD echo since escape se- |
| * quences are enabled by default. |
| */ |
| |
| while ((s = *wp) && *s == '-' && s[1]) { |
| while (*++s) |
| if (*s == 'n') |
| nflags &= ~PO_NL; |
| else if (*s == 'e') |
| nflags |= PO_EXPAND; |
| else if (*s == 'E') |
| nflags &= ~PO_EXPAND; |
| else |
| /* |
| * bad option: don't use |
| * nflags, print argument |
| */ |
| break; |
| |
| if (*s) |
| break; |
| wp++; |
| flags = nflags; |
| } |
| } |
| } else { |
| int optc; |
| const char *opts = "Rnprsu,"; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1) |
| switch (optc) { |
| case 'R': /* fake BSD echo command */ |
| flags |= PO_PMINUSMINUS; |
| flags &= ~PO_EXPAND; |
| opts = "ne"; |
| break; |
| case 'e': |
| flags |= PO_EXPAND; |
| break; |
| case 'n': |
| flags &= ~PO_NL; |
| break; |
| case 'p': |
| if ((fd = coproc_getfd(W_OK, &emsg)) < 0) { |
| bi_errorf("-p: %s", emsg); |
| return (1); |
| } |
| break; |
| case 'r': |
| flags &= ~PO_EXPAND; |
| break; |
| case 's': |
| flags |= PO_HIST; |
| break; |
| case 'u': |
| if (!*(s = builtin_opt.optarg)) |
| fd = 0; |
| else if ((fd = check_fd(s, W_OK, &emsg)) < 0) { |
| bi_errorf("-u: %s: %s", s, emsg); |
| return (1); |
| } |
| break; |
| case '?': |
| return (1); |
| } |
| |
| if (!(builtin_opt.info & GI_MINUSMINUS)) { |
| /* treat a lone - like -- */ |
| if (wp[builtin_opt.optind] && |
| ksh_isdash(wp[builtin_opt.optind])) |
| builtin_opt.optind++; |
| } else if (flags & PO_PMINUSMINUS) |
| builtin_opt.optind--; |
| wp += builtin_opt.optind; |
| } |
| |
| Xinit(xs, xp, 128, ATEMP); |
| |
| while (*wp != NULL) { |
| s = *wp; |
| while ((c = *s++) != '\0') { |
| Xcheck(xs, xp); |
| if ((flags & PO_EXPAND) && c == '\\') { |
| s_ptr = s; |
| c = unbksl(false, s_get, s_put); |
| s = s_ptr; |
| if (c == -1) { |
| /* rejected by generic function */ |
| switch ((c = *s++)) { |
| case 'c': |
| flags &= ~PO_NL; |
| /* AT&T brain damage */ |
| continue; |
| case '\0': |
| s--; |
| c = '\\'; |
| break; |
| default: |
| Xput(xs, xp, '\\'); |
| } |
| } else if ((unsigned int)c > 0xFF) { |
| /* generic function returned Unicode */ |
| char ts[4]; |
| |
| c = utf_wctomb(ts, c - 0x100); |
| ts[c] = 0; |
| for (c = 0; ts[c]; ++c) |
| Xput(xs, xp, ts[c]); |
| continue; |
| } |
| } |
| Xput(xs, xp, c); |
| } |
| if (*++wp != NULL) |
| Xput(xs, xp, ' '); |
| } |
| if (flags & PO_NL) |
| Xput(xs, xp, '\n'); |
| |
| if (flags & PO_HIST) { |
| Xput(xs, xp, '\0'); |
| histsave(&source->line, Xstring(xs, xp), true, false); |
| Xfree(xs, xp); |
| } else { |
| int len = Xlength(xs, xp); |
| int opipe = 0; |
| |
| /* Ensure we aren't killed by a SIGPIPE while writing to |
| * a coprocess. AT&T ksh doesn't seem to do this (seems |
| * to just check that the co-process is alive which is |
| * not enough). |
| */ |
| if (coproc.write >= 0 && coproc.write == fd) { |
| flags |= PO_COPROC; |
| opipe = block_pipe(); |
| } |
| for (s = Xstring(xs, xp); len > 0; ) { |
| if ((c = write(fd, s, len)) < 0) { |
| if (flags & PO_COPROC) |
| restore_pipe(opipe); |
| if (errno == EINTR) { |
| /* allow user to ^C out */ |
| intrcheck(); |
| if (flags & PO_COPROC) |
| opipe = block_pipe(); |
| continue; |
| } |
| return (1); |
| } |
| s += c; |
| len -= c; |
| } |
| if (flags & PO_COPROC) |
| restore_pipe(opipe); |
| } |
| |
| return (0); |
| } |
| |
| static int |
| s_get(void) |
| { |
| return (*s_ptr++); |
| } |
| |
| static void |
| s_put(int c MKSH_A_UNUSED) |
| { |
| --s_ptr; |
| } |
| |
| int |
| c_whence(const char **wp) |
| { |
| struct tbl *tp; |
| const char *id; |
| bool pflag = false, vflag = false, Vflag = false; |
| int rv = 0, optc, fcflags; |
| bool iam_whence = wp[0][0] == 'w'; |
| const char *opts = iam_whence ? "pv" : "pvV"; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1) |
| switch (optc) { |
| case 'p': |
| pflag = true; |
| break; |
| case 'v': |
| vflag = true; |
| break; |
| case 'V': |
| Vflag = true; |
| break; |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| |
| fcflags = FC_BI | FC_PATH | FC_FUNC; |
| if (!iam_whence) { |
| /* Note that -p on its own is deal with in comexec() */ |
| if (pflag) |
| fcflags |= FC_DEFPATH; |
| /* Convert command options to whence options - note that |
| * command -pV uses a different path search than whence -v |
| * or whence -pv. This should be considered a feature. |
| */ |
| vflag = Vflag; |
| } |
| if (pflag) |
| fcflags &= ~(FC_BI | FC_FUNC); |
| |
| while ((vflag || rv == 0) && (id = *wp++) != NULL) { |
| uint32_t h = 0; |
| |
| tp = NULL; |
| if ((iam_whence || vflag) && !pflag) |
| tp = ktsearch(&keywords, id, h = hash(id)); |
| if (!tp && !pflag) { |
| tp = ktsearch(&aliases, id, h ? h : hash(id)); |
| if (tp && !(tp->flag & ISSET)) |
| tp = NULL; |
| } |
| if (!tp) |
| tp = findcom(id, fcflags); |
| if (vflag || (tp->type != CALIAS && tp->type != CEXEC && |
| tp->type != CTALIAS)) |
| shf_puts(id, shl_stdout); |
| switch (tp->type) { |
| case CKEYWD: |
| if (vflag) |
| shf_puts(" is a reserved word", shl_stdout); |
| break; |
| case CALIAS: |
| if (vflag) |
| shprintf(" is an %salias for ", |
| (tp->flag & EXPORT) ? "exported " : null); |
| if (!iam_whence && !vflag) |
| shprintf("alias %s=", id); |
| print_value_quoted(tp->val.s); |
| break; |
| case CFUNC: |
| if (vflag) { |
| shf_puts(" is a", shl_stdout); |
| if (tp->flag & EXPORT) |
| shf_puts("n exported", shl_stdout); |
| if (tp->flag & TRACE) |
| shf_puts(" traced", shl_stdout); |
| if (!(tp->flag & ISSET)) { |
| shf_puts(" undefined", shl_stdout); |
| if (tp->u.fpath) |
| shprintf(" (autoload from %s)", |
| tp->u.fpath); |
| } |
| shf_puts(" function", shl_stdout); |
| } |
| break; |
| case CSHELL: |
| if (vflag) |
| shprintf(" is a%s shell builtin", |
| (tp->flag & SPEC_BI) ? " special" : null); |
| break; |
| case CTALIAS: |
| case CEXEC: |
| if (tp->flag & ISSET) { |
| if (vflag) { |
| shf_puts(" is ", shl_stdout); |
| if (tp->type == CTALIAS) |
| shprintf("a tracked %salias for ", |
| (tp->flag & EXPORT) ? |
| "exported " : null); |
| } |
| shf_puts(tp->val.s, shl_stdout); |
| } else { |
| if (vflag) |
| shf_puts(" not found", shl_stdout); |
| rv = 1; |
| } |
| break; |
| default: |
| shprintf("%s is *GOK*", id); |
| break; |
| } |
| if (vflag || !rv) |
| shf_putc('\n', shl_stdout); |
| } |
| return (rv); |
| } |
| |
| /* Deal with command -vV - command -p dealt with in comexec() */ |
| int |
| c_command(const char **wp) |
| { |
| /* Let c_whence do the work. Note that c_command() must be |
| * a distinct function from c_whence() (tested in comexec()). |
| */ |
| return (c_whence(wp)); |
| } |
| |
| /* typeset, export, and readonly */ |
| int |
| c_typeset(const char **wp) |
| { |
| struct block *l; |
| struct tbl *vp, **p; |
| Tflag fset = 0, fclr = 0, flag; |
| int thing = 0, field, base, optc; |
| const char *opts; |
| const char *fieldstr, *basestr; |
| bool localv = false, func = false, pflag = false, istset = true; |
| |
| switch (**wp) { |
| case 'e': /* export */ |
| fset |= EXPORT; |
| istset = false; |
| break; |
| case 'r': /* readonly */ |
| fset |= RDONLY; |
| istset = false; |
| break; |
| case 's': /* set */ |
| /* called with 'typeset -' */ |
| break; |
| case 't': /* typeset */ |
| localv = true; |
| break; |
| } |
| |
| /* see comment below regarding possible opions */ |
| opts = istset ? "L#R#UZ#afi#lnprtux" : "p"; |
| |
| fieldstr = basestr = NULL; |
| builtin_opt.flags |= GF_PLUSOPT; |
| /* AT&T ksh seems to have 0-9 as options which are multiplied |
| * to get a number that is used with -L, -R, -Z or -i (eg, -1R2 |
| * sets right justify in a field of 12). This allows options |
| * to be grouped in an order (eg, -Lu12), but disallows -i8 -L3 and |
| * does not allow the number to be specified as a separate argument |
| * Here, the number must follow the RLZi option, but is optional |
| * (see the # kludge in ksh_getopt()). |
| */ |
| while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1) { |
| flag = 0; |
| switch (optc) { |
| case 'L': |
| flag = LJUST; |
| fieldstr = builtin_opt.optarg; |
| break; |
| case 'R': |
| flag = RJUST; |
| fieldstr = builtin_opt.optarg; |
| break; |
| case 'U': |
| /* AT&T ksh uses u, but this conflicts with |
| * upper/lower case. If this option is changed, |
| * need to change the -U below as well |
| */ |
| flag = INT_U; |
| break; |
| case 'Z': |
| flag = ZEROFIL; |
| fieldstr = builtin_opt.optarg; |
| break; |
| case 'a': |
| /* |
| * this is supposed to set (-a) or unset (+a) the |
| * indexed array attribute; it does nothing on an |
| * existing regular string or indexed array though |
| */ |
| break; |
| case 'f': |
| func = true; |
| break; |
| case 'i': |
| flag = INTEGER; |
| basestr = builtin_opt.optarg; |
| break; |
| case 'l': |
| flag = LCASEV; |
| break; |
| case 'n': |
| set_refflag = (builtin_opt.info & GI_PLUS) ? 2 : 1; |
| break; |
| case 'p': |
| /* export, readonly: POSIX -p flag */ |
| /* typeset: show values as well */ |
| pflag = true; |
| if (istset) |
| continue; |
| break; |
| case 'r': |
| flag = RDONLY; |
| break; |
| case 't': |
| flag = TRACE; |
| break; |
| case 'u': |
| flag = UCASEV_AL; /* upper case / autoload */ |
| break; |
| case 'x': |
| flag = EXPORT; |
| break; |
| case '?': |
| return (1); |
| } |
| if (builtin_opt.info & GI_PLUS) { |
| fclr |= flag; |
| fset &= ~flag; |
| thing = '+'; |
| } else { |
| fset |= flag; |
| fclr &= ~flag; |
| thing = '-'; |
| } |
| } |
| |
| field = 0; |
| if (fieldstr && !bi_getn(fieldstr, &field)) |
| return (1); |
| base = 0; |
| if (basestr && !bi_getn(basestr, &base)) |
| return (1); |
| |
| if (!(builtin_opt.info & GI_MINUSMINUS) && wp[builtin_opt.optind] && |
| (wp[builtin_opt.optind][0] == '-' || |
| wp[builtin_opt.optind][0] == '+') && |
| wp[builtin_opt.optind][1] == '\0') { |
| thing = wp[builtin_opt.optind][0]; |
| builtin_opt.optind++; |
| } |
| |
| if (func && (((fset|fclr) & ~(TRACE|UCASEV_AL|EXPORT)) || set_refflag)) { |
| bi_errorf("only -t, -u and -x options may be used with -f"); |
| set_refflag = 0; |
| return (1); |
| } |
| if (wp[builtin_opt.optind]) { |
| /* Take care of exclusions. |
| * At this point, flags in fset are cleared in fclr and vice |
| * versa. This property should be preserved. |
| */ |
| if (fset & LCASEV) /* LCASEV has priority over UCASEV_AL */ |
| fset &= ~UCASEV_AL; |
| if (fset & LJUST) /* LJUST has priority over RJUST */ |
| fset &= ~RJUST; |
| if ((fset & (ZEROFIL|LJUST)) == ZEROFIL) { /* -Z implies -ZR */ |
| fset |= RJUST; |
| fclr &= ~RJUST; |
| } |
| /* Setting these attributes clears the others, unless they |
| * are also set in this command |
| */ |
| if ((fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL | LCASEV | |
| INTEGER | INT_U | INT_L)) || set_refflag) |
| fclr |= ~fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL | |
| LCASEV | INTEGER | INT_U | INT_L); |
| } |
| |
| /* set variables and attributes */ |
| if (wp[builtin_opt.optind]) { |
| int i, rv = 0; |
| struct tbl *f; |
| |
| if (localv && !func) |
| fset |= LOCAL; |
| for (i = builtin_opt.optind; wp[i]; i++) { |
| if (func) { |
| f = findfunc(wp[i], hash(wp[i]), |
| (fset&UCASEV_AL) ? true : false); |
| if (!f) { |
| /* AT&T ksh does ++rv: bogus */ |
| rv = 1; |
| continue; |
| } |
| if (fset | fclr) { |
| f->flag |= fset; |
| f->flag &= ~fclr; |
| } else |
| fptreef(shl_stdout, 0, |
| f->flag & FKSH ? |
| "function %s %T\n" : |
| "%s() %T\n", wp[i], f->val.t); |
| } else if (!typeset(wp[i], fset, fclr, field, base)) { |
| bi_errorf("%s: not identifier", wp[i]); |
| set_refflag = 0; |
| return (1); |
| } |
| } |
| set_refflag = 0; |
| return (rv); |
| } |
| |
| /* list variables and attributes */ |
| flag = fset | fclr; /* no difference at this point.. */ |
| if (func) { |
| for (l = e->loc; l; l = l->next) { |
| for (p = ktsort(&l->funs); (vp = *p++); ) { |
| if (flag && (vp->flag & flag) == 0) |
| continue; |
| if (thing == '-') |
| fptreef(shl_stdout, 0, vp->flag & FKSH ? |
| "function %s %T\n" : "%s() %T\n", |
| vp->name, vp->val.t); |
| else |
| shprintf("%s\n", vp->name); |
| } |
| } |
| } else { |
| for (l = e->loc; l; l = l->next) { |
| for (p = ktsort(&l->vars); (vp = *p++); ) { |
| struct tbl *tvp; |
| bool any_set = false; |
| /* |
| * See if the parameter is set (for arrays, if any |
| * element is set). |
| */ |
| for (tvp = vp; tvp; tvp = tvp->u.array) |
| if (tvp->flag & ISSET) { |
| any_set = true; |
| break; |
| } |
| |
| /* |
| * Check attributes - note that all array elements |
| * have (should have?) the same attributes, so checking |
| * the first is sufficient. |
| * |
| * Report an unset param only if the user has |
| * explicitly given it some attribute (like export); |
| * otherwise, after "echo $FOO", we would report FOO... |
| */ |
| if (!any_set && !(vp->flag & USERATTRIB)) |
| continue; |
| if (flag && (vp->flag & flag) == 0) |
| continue; |
| for (; vp; vp = vp->u.array) { |
| /* Ignore array elements that aren't |
| * set unless there are no set elements, |
| * in which case the first is reported on */ |
| if ((vp->flag&ARRAY) && any_set && |
| !(vp->flag & ISSET)) |
| continue; |
| /* no arguments */ |
| if (thing == 0 && flag == 0) { |
| /* AT&T ksh prints things |
| * like export, integer, |
| * leftadj, zerofill, etc., |
| * but POSIX says must |
| * be suitable for re-entry... |
| */ |
| shf_puts("typeset ", shl_stdout); |
| if (((vp->flag&(ARRAY|ASSOC))==ASSOC)) |
| shf_puts("-n ", shl_stdout); |
| if ((vp->flag&INTEGER)) |
| shf_puts("-i ", shl_stdout); |
| if ((vp->flag&EXPORT)) |
| shf_puts("-x ", shl_stdout); |
| if ((vp->flag&RDONLY)) |
| shf_puts("-r ", shl_stdout); |
| if ((vp->flag&TRACE)) |
| shf_puts("-t ", shl_stdout); |
| if ((vp->flag&LJUST)) |
| shprintf("-L%d ", vp->u2.field); |
| if ((vp->flag&RJUST)) |
| shprintf("-R%d ", vp->u2.field); |
| if ((vp->flag&ZEROFIL)) |
| shf_puts("-Z ", shl_stdout); |
| if ((vp->flag&LCASEV)) |
| shf_puts("-l ", shl_stdout); |
| if ((vp->flag&UCASEV_AL)) |
| shf_puts("-u ", shl_stdout); |
| if ((vp->flag&INT_U)) |
| shf_puts("-U ", shl_stdout); |
| shf_puts(vp->name, shl_stdout); |
| if (pflag) { |
| char *s = str_val(vp); |
| |
| shf_putc('=', shl_stdout); |
| /* AT&T ksh can't have |
| * justified integers.. */ |
| if ((vp->flag & |
| (INTEGER|LJUST|RJUST)) == |
| INTEGER) |
| shf_puts(s, shl_stdout); |
| else |
| print_value_quoted(s); |
| } |
| shf_putc('\n', shl_stdout); |
| if (vp->flag & ARRAY) |
| break; |
| } else { |
| if (pflag) |
| shf_puts(istset ? |
| "typeset " : |
| (flag & EXPORT) ? |
| "export " : |
| "readonly ", |
| shl_stdout); |
| if ((vp->flag&ARRAY) && any_set) |
| shprintf("%s[%lu]", |
| vp->name, |
| arrayindex(vp)); |
| else |
| shf_puts(vp->name, shl_stdout); |
| if (thing == '-' && (vp->flag&ISSET)) { |
| char *s = str_val(vp); |
| |
| shf_putc('=', shl_stdout); |
| /* AT&T ksh can't have |
| * justified integers.. */ |
| if ((vp->flag & |
| (INTEGER|LJUST|RJUST)) == |
| INTEGER) |
| shf_puts(s, shl_stdout); |
| else |
| print_value_quoted(s); |
| } |
| shf_putc('\n', shl_stdout); |
| } |
| /* Only report first 'element' of an array with |
| * no set elements. |
| */ |
| if (!any_set) |
| break; |
| } |
| } |
| } |
| } |
| return (0); |
| } |
| |
| int |
| c_alias(const char **wp) |
| { |
| struct table *t = &aliases; |
| int rv = 0, prefix = 0; |
| bool rflag = false, tflag, Uflag = false, pflag = false; |
| Tflag xflag = 0; |
| int optc; |
| |
| builtin_opt.flags |= GF_PLUSOPT; |
| while ((optc = ksh_getopt(wp, &builtin_opt, "dprtUx")) != -1) { |
| prefix = builtin_opt.info & GI_PLUS ? '+' : '-'; |
| switch (optc) { |
| case 'd': |
| #ifdef MKSH_NOPWNAM |
| t = NULL; /* fix "alias -dt" */ |
| #else |
| t = &homedirs; |
| #endif |
| break; |
| case 'p': |
| pflag = true; |
| break; |
| case 'r': |
| rflag = true; |
| break; |
| case 't': |
| t = &taliases; |
| break; |
| case 'U': |
| /* |
| * kludge for tracked alias initialization |
| * (don't do a path search, just make an entry) |
| */ |
| Uflag = true; |
| break; |
| case 'x': |
| xflag = EXPORT; |
| break; |
| case '?': |
| return (1); |
| } |
| } |
| #ifdef MKSH_NOPWNAM |
| if (t == NULL) |
| return (0); |
| #endif |
| wp += builtin_opt.optind; |
| |
| if (!(builtin_opt.info & GI_MINUSMINUS) && *wp && |
| (wp[0][0] == '-' || wp[0][0] == '+') && wp[0][1] == '\0') { |
| prefix = wp[0][0]; |
| wp++; |
| } |
| |
| tflag = t == &taliases; |
| |
| /* "hash -r" means reset all the tracked aliases.. */ |
| if (rflag) { |
| static const char *args[] = { |
| "unalias", "-ta", NULL |
| }; |
| |
| if (!tflag || *wp) { |
| shf_puts("alias: -r flag can only be used with -t" |
| " and without arguments\n", shl_stdout); |
| return (1); |
| } |
| ksh_getopt_reset(&builtin_opt, GF_ERROR); |
| return (c_unalias(args)); |
| } |
| |
| if (*wp == NULL) { |
| struct tbl *ap, **p; |
| |
| for (p = ktsort(t); (ap = *p++) != NULL; ) |
| if ((ap->flag & (ISSET|xflag)) == (ISSET|xflag)) { |
| if (pflag) |
| shf_puts("alias ", shl_stdout); |
| shf_puts(ap->name, shl_stdout); |
| if (prefix != '+') { |
| shf_putc('=', shl_stdout); |
| print_value_quoted(ap->val.s); |
| } |
| shf_putc('\n', shl_stdout); |
| } |
| } |
| |
| for (; *wp != NULL; wp++) { |
| const char *alias = *wp, *val, *newval; |
| char *xalias = NULL; |
| struct tbl *ap; |
| uint32_t h; |
| |
| if ((val = cstrchr(alias, '='))) { |
| strndupx(xalias, alias, val++ - alias, ATEMP); |
| alias = xalias; |
| } |
| h = hash(alias); |
| if (val == NULL && !tflag && !xflag) { |
| ap = ktsearch(t, alias, h); |
| if (ap != NULL && (ap->flag&ISSET)) { |
| if (pflag) |
| shf_puts("alias ", shl_stdout); |
| shf_puts(ap->name, shl_stdout); |
| if (prefix != '+') { |
| shf_putc('=', shl_stdout); |
| print_value_quoted(ap->val.s); |
| } |
| shf_putc('\n', shl_stdout); |
| } else { |
| shprintf("%s alias not found\n", alias); |
| rv = 1; |
| } |
| continue; |
| } |
| ap = ktenter(t, alias, h); |
| ap->type = tflag ? CTALIAS : CALIAS; |
| /* Are we setting the value or just some flags? */ |
| if ((val && !tflag) || (!val && tflag && !Uflag)) { |
| if (ap->flag&ALLOC) { |
| ap->flag &= ~(ALLOC|ISSET); |
| afree(ap->val.s, APERM); |
| } |
| /* ignore values for -t (AT&T ksh does this) */ |
| newval = tflag ? search(alias, path, X_OK, NULL) : val; |
| if (newval) { |
| strdupx(ap->val.s, newval, APERM); |
| ap->flag |= ALLOC|ISSET; |
| } else |
| ap->flag &= ~ISSET; |
| } |
| ap->flag |= DEFINED; |
| if (prefix == '+') |
| ap->flag &= ~xflag; |
| else |
| ap->flag |= xflag; |
| afree(xalias, ATEMP); |
| } |
| |
| return (rv); |
| } |
| |
| int |
| c_unalias(const char **wp) |
| { |
| struct table *t = &aliases; |
| struct tbl *ap; |
| int optc, rv = 0; |
| bool all = false; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "adt")) != -1) |
| switch (optc) { |
| case 'a': |
| all = true; |
| break; |
| case 'd': |
| #ifdef MKSH_NOPWNAM |
| t = NULL; /* fix "unalias -dt" */ |
| #else |
| t = &homedirs; |
| #endif |
| break; |
| case 't': |
| t = &taliases; |
| break; |
| case '?': |
| return (1); |
| } |
| #ifdef MKSH_NOPWNAM |
| if (t == NULL) |
| return (0); |
| #endif |
| wp += builtin_opt.optind; |
| |
| for (; *wp != NULL; wp++) { |
| ap = ktsearch(t, *wp, hash(*wp)); |
| if (ap == NULL) { |
| rv = 1; /* POSIX */ |
| continue; |
| } |
| if (ap->flag&ALLOC) { |
| ap->flag &= ~(ALLOC|ISSET); |
| afree(ap->val.s, APERM); |
| } |
| ap->flag &= ~(DEFINED|ISSET|EXPORT); |
| } |
| |
| if (all) { |
| struct tstate ts; |
| |
| for (ktwalk(&ts, t); (ap = ktnext(&ts)); ) { |
| if (ap->flag&ALLOC) { |
| ap->flag &= ~(ALLOC|ISSET); |
| afree(ap->val.s, APERM); |
| } |
| ap->flag &= ~(DEFINED|ISSET|EXPORT); |
| } |
| } |
| |
| return (rv); |
| } |
| |
| int |
| c_let(const char **wp) |
| { |
| int rv = 1; |
| mksh_ari_t val; |
| |
| if (wp[1] == NULL) /* AT&T ksh does this */ |
| bi_errorf("no arguments"); |
| else |
| for (wp++; *wp; wp++) |
| if (!evaluate(*wp, &val, KSH_RETURN_ERROR, true)) { |
| rv = 2; /* distinguish error from zero result */ |
| break; |
| } else |
| rv = val == 0; |
| return (rv); |
| } |
| |
| int |
| c_jobs(const char **wp) |
| { |
| int optc, flag = 0, nflag = 0, rv = 0; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "lpnz")) != -1) |
| switch (optc) { |
| case 'l': |
| flag = 1; |
| break; |
| case 'p': |
| flag = 2; |
| break; |
| case 'n': |
| nflag = 1; |
| break; |
| case 'z': /* debugging: print zombies */ |
| nflag = -1; |
| break; |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| if (!*wp) { |
| if (j_jobs(NULL, flag, nflag)) |
| rv = 1; |
| } else { |
| for (; *wp; wp++) |
| if (j_jobs(*wp, flag, nflag)) |
| rv = 1; |
| } |
| return (rv); |
| } |
| |
| #ifndef MKSH_UNEMPLOYED |
| int |
| c_fgbg(const char **wp) |
| { |
| bool bg = strcmp(*wp, "bg") == 0; |
| int rv = 0; |
| |
| if (!Flag(FMONITOR)) { |
| bi_errorf("job control not enabled"); |
| return (1); |
| } |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| wp += builtin_opt.optind; |
| if (*wp) |
| for (; *wp; wp++) |
| rv = j_resume(*wp, bg); |
| else |
| rv = j_resume("%%", bg); |
| return (bg ? 0 : rv); |
| } |
| #endif |
| |
| /* format a single kill item */ |
| static char * |
| kill_fmt_entry(char *buf, int buflen, int i, const void *arg) |
| { |
| const struct kill_info *ki = (const struct kill_info *)arg; |
| |
| i++; |
| shf_snprintf(buf, buflen, "%*d %*s %s", |
| ki->num_width, i, |
| ki->name_width, sigtraps[i].name, |
| sigtraps[i].mess); |
| return (buf); |
| } |
| |
| int |
| c_kill(const char **wp) |
| { |
| Trap *t = NULL; |
| const char *p; |
| bool lflag = false; |
| int i, n, rv, sig; |
| |
| /* assume old style options if -digits or -UPPERCASE */ |
| if ((p = wp[1]) && *p == '-' && (ksh_isdigit(p[1]) || |
| ksh_isupper(p[1]))) { |
| if (!(t = gettrap(p + 1, true))) { |
| bi_errorf("bad signal '%s'", p + 1); |
| return (1); |
| } |
| i = (wp[2] && strcmp(wp[2], "--") == 0) ? 3 : 2; |
| } else { |
| int optc; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "ls:")) != -1) |
| switch (optc) { |
| case 'l': |
| lflag = true; |
| break; |
| case 's': |
| if (!(t = gettrap(builtin_opt.optarg, true))) { |
| bi_errorf("bad signal '%s'", |
| builtin_opt.optarg); |
| return (1); |
| } |
| break; |
| case '?': |
| return (1); |
| } |
| i = builtin_opt.optind; |
| } |
| if ((lflag && t) || (!wp[i] && !lflag)) { |
| #ifndef MKSH_SMALL |
| shf_puts("usage:\tkill [-s signame | -signum | -signame]" |
| " { job | pid | pgrp } ...\n" |
| "\tkill -l [exit_status ...]\n", shl_out); |
| #endif |
| bi_errorfz(); |
| return (1); |
| } |
| |
| if (lflag) { |
| if (wp[i]) { |
| for (; wp[i]; i++) { |
| if (!bi_getn(wp[i], &n)) |
| return (1); |
| if (n > 128 && n < 128 + NSIG) |
| n -= 128; |
| if (n > 0 && n < NSIG) |
| shprintf("%s\n", sigtraps[n].name); |
| else |
| shprintf("%d\n", n); |
| } |
| } else { |
| int w, j, mess_cols, mess_octs; |
| struct kill_info ki; |
| |
| for (j = NSIG, ki.num_width = 1; j >= 10; j /= 10) |
| ki.num_width++; |
| ki.name_width = mess_cols = mess_octs = 0; |
| for (j = 0; j < NSIG; j++) { |
| w = strlen(sigtraps[j].name); |
| if (w > ki.name_width) |
| ki.name_width = w; |
| w = strlen(sigtraps[j].mess); |
| if (w > mess_octs) |
| mess_octs = w; |
| w = utf_mbswidth(sigtraps[j].mess); |
| if (w > mess_cols) |
| mess_cols = w; |
| } |
| |
| print_columns(shl_stdout, NSIG - 1, |
| kill_fmt_entry, (void *)&ki, |
| ki.num_width + 1 + ki.name_width + 1 + mess_octs, |
| ki.num_width + 1 + ki.name_width + 1 + mess_cols, |
| true); |
| } |
| return (0); |
| } |
| rv = 0; |
| sig = t ? t->signal : SIGTERM; |
| for (; (p = wp[i]); i++) { |
| if (*p == '%') { |
| if (j_kill(p, sig)) |
| rv = 1; |
| } else if (!getn(p, &n)) { |
| bi_errorf("%s: arguments must be jobs or process IDs", |
| p); |
| rv = 1; |
| } else { |
| if (mksh_kill(n, sig) < 0) { |
| bi_errorf("%s: %s", p, strerror(errno)); |
| rv = 1; |
| } |
| } |
| } |
| return (rv); |
| } |
| |
| void |
| getopts_reset(int val) |
| { |
| if (val >= 1) { |
| ksh_getopt_reset(&user_opt, GF_NONAME | GF_PLUSOPT); |
| user_opt.optind = user_opt.uoptind = val; |
| } |
| } |
| |
| int |
| c_getopts(const char **wp) |
| { |
| int argc, optc, rv; |
| const char *opts, *var; |
| char buf[3]; |
| struct tbl *vq, *voptarg; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| wp += builtin_opt.optind; |
| |
| opts = *wp++; |
| if (!opts) { |
| bi_errorf("missing options argument"); |
| return (1); |
| } |
| |
| var = *wp++; |
| if (!var) { |
| bi_errorf("missing name argument"); |
| return (1); |
| } |
| if (!*var || *skip_varname(var, true)) { |
| bi_errorf("%s: is not an identifier", var); |
| return (1); |
| } |
| |
| if (e->loc->next == NULL) { |
| internal_warningf("c_getopts: no argv"); |
| return (1); |
| } |
| /* Which arguments are we parsing... */ |
| if (*wp == NULL) |
| wp = e->loc->next->argv; |
| else |
| *--wp = e->loc->next->argv[0]; |
| |
| /* Check that our saved state won't cause a core dump... */ |
| for (argc = 0; wp[argc]; argc++) |
| ; |
| if (user_opt.optind > argc || |
| (user_opt.p != 0 && |
| user_opt.p > strlen(wp[user_opt.optind - 1]))) { |
| bi_errorf("arguments changed since last call"); |
| return (1); |
| } |
| |
| user_opt.optarg = NULL; |
| optc = ksh_getopt(wp, &user_opt, opts); |
| |
| if (optc >= 0 && optc != '?' && (user_opt.info & GI_PLUS)) { |
| buf[0] = '+'; |
| buf[1] = optc; |
| buf[2] = '\0'; |
| } else { |
| /* POSIX says var is set to ? at end-of-options, AT&T ksh |
| * sets it to null - we go with POSIX... |
| */ |
| buf[0] = optc < 0 ? '?' : optc; |
| buf[1] = '\0'; |
| } |
| |
| /* AT&T ksh93 in fact does change OPTIND for unknown options too */ |
| user_opt.uoptind = user_opt.optind; |
| |
| voptarg = global("OPTARG"); |
| voptarg->flag &= ~RDONLY; /* AT&T ksh clears ro and int */ |
| /* Paranoia: ensure no bizarre results. */ |
| if (voptarg->flag & INTEGER) |
| typeset("OPTARG", 0, INTEGER, 0, 0); |
| if (user_opt.optarg == NULL) |
| unset(voptarg, 1); |
| else |
| /* This can't fail (have cleared readonly/integer) */ |
| setstr(voptarg, user_opt.optarg, KSH_RETURN_ERROR); |
| |
| rv = 0; |
| |
| vq = global(var); |
| /* Error message already printed (integer, readonly) */ |
| if (!setstr(vq, buf, KSH_RETURN_ERROR)) |
| rv = 1; |
| if (Flag(FEXPORT)) |
| typeset(var, EXPORT, 0, 0, 0); |
| |
| return (optc < 0 ? 1 : rv); |
| } |
| |
| int |
| c_bind(const char **wp) |
| { |
| int optc, rv = 0; |
| #ifndef MKSH_SMALL |
| bool macro = false; |
| #endif |
| bool list = false; |
| const char *cp; |
| char *up; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, |
| #ifndef MKSH_SMALL |
| "lm" |
| #else |
| "l" |
| #endif |
| )) != -1) |
| switch (optc) { |
| case 'l': |
| list = true; |
| break; |
| #ifndef MKSH_SMALL |
| case 'm': |
| macro = true; |
| break; |
| #endif |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| |
| if (*wp == NULL) /* list all */ |
| rv = x_bind(NULL, NULL, |
| #ifndef MKSH_SMALL |
| false, |
| #endif |
| list); |
| |
| for (; *wp != NULL; wp++) { |
| if ((cp = cstrchr(*wp, '=')) == NULL) |
| up = NULL; |
| else { |
| strdupx(up, *wp, ATEMP); |
| up[cp++ - *wp] = '\0'; |
| } |
| if (x_bind(up ? up : *wp, cp, |
| #ifndef MKSH_SMALL |
| macro, |
| #endif |
| false)) |
| rv = 1; |
| afree(up, ATEMP); |
| } |
| |
| return (rv); |
| } |
| |
| /* :, false and true (and ulimit if MKSH_NO_LIMITS) */ |
| int |
| c_label(const char **wp) |
| { |
| return (wp[0][0] == 'f' ? 1 : 0); |
| } |
| |
| int |
| c_shift(const char **wp) |
| { |
| struct block *l = e->loc; |
| int n; |
| mksh_ari_t val; |
| const char *arg; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| arg = wp[builtin_opt.optind]; |
| |
| if (arg) { |
| evaluate(arg, &val, KSH_UNWIND_ERROR, false); |
| n = val; |
| } else |
| n = 1; |
| if (n < 0) { |
| bi_errorf("%s: bad number", arg); |
| return (1); |
| } |
| if (l->argc < n) { |
| bi_errorf("nothing to shift"); |
| return (1); |
| } |
| l->argv[n] = l->argv[0]; |
| l->argv += n; |
| l->argc -= n; |
| return (0); |
| } |
| |
| int |
| c_umask(const char **wp) |
| { |
| int i, optc; |
| const char *cp; |
| bool symbolic = false; |
| mode_t old_umask; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "S")) != -1) |
| switch (optc) { |
| case 'S': |
| symbolic = true; |
| break; |
| case '?': |
| return (1); |
| } |
| cp = wp[builtin_opt.optind]; |
| if (cp == NULL) { |
| old_umask = umask((mode_t)0); |
| umask(old_umask); |
| if (symbolic) { |
| char buf[18], *p; |
| int j; |
| |
| old_umask = ~old_umask; |
| p = buf; |
| for (i = 0; i < 3; i++) { |
| *p++ = "ugo"[i]; |
| *p++ = '='; |
| for (j = 0; j < 3; j++) |
| if (old_umask & (1 << (8 - (3*i + j)))) |
| *p++ = "rwx"[j]; |
| *p++ = ','; |
| } |
| p[-1] = '\0'; |
| shprintf("%s\n", buf); |
| } else |
| shprintf("%#3.3o\n", (unsigned int)old_umask); |
| } else { |
| mode_t new_umask; |
| |
| if (ksh_isdigit(*cp)) { |
| for (new_umask = 0; *cp >= '0' && *cp <= '7'; cp++) |
| new_umask = new_umask * 8 + (*cp - '0'); |
| if (*cp) { |
| bi_errorf("bad number"); |
| return (1); |
| } |
| } else { |
| /* symbolic format */ |
| int positions, new_val; |
| char op; |
| |
| old_umask = umask((mode_t)0); |
| umask(old_umask); /* in case of error */ |
| old_umask = ~old_umask; |
| new_umask = old_umask; |
| positions = 0; |
| while (*cp) { |
| while (*cp && vstrchr("augo", *cp)) |
| switch (*cp++) { |
| case 'a': |
| positions |= 0111; |
| break; |
| case 'u': |
| positions |= 0100; |
| break; |
| case 'g': |
| positions |= 0010; |
| break; |
| case 'o': |
| positions |= 0001; |
| break; |
| } |
| if (!positions) |
| positions = 0111; /* default is a */ |
| if (!vstrchr("=+-", op = *cp)) |
| break; |
| cp++; |
| new_val = 0; |
| while (*cp && vstrchr("rwxugoXs", *cp)) |
| switch (*cp++) { |
| case 'r': new_val |= 04; break; |
| case 'w': new_val |= 02; break; |
| case 'x': new_val |= 01; break; |
| case 'u': |
| new_val |= old_umask >> 6; |
| break; |
| case 'g': |
| new_val |= old_umask >> 3; |
| break; |
| case 'o': |
| new_val |= old_umask >> 0; |
| break; |
| case 'X': |
| if (old_umask & 0111) |
| new_val |= 01; |
| break; |
| case 's': |
| /* ignored */ |
| break; |
| } |
| new_val = (new_val & 07) * positions; |
| switch (op) { |
| case '-': |
| new_umask &= ~new_val; |
| break; |
| case '=': |
| new_umask = new_val | |
| (new_umask & ~(positions * 07)); |
| break; |
| case '+': |
| new_umask |= new_val; |
| } |
| if (*cp == ',') { |
| positions = 0; |
| cp++; |
| } else if (!vstrchr("=+-", *cp)) |
| break; |
| } |
| if (*cp) { |
| bi_errorf("bad mask"); |
| return (1); |
| } |
| new_umask = ~new_umask; |
| } |
| umask(new_umask); |
| } |
| return (0); |
| } |
| |
| int |
| c_dot(const char **wp) |
| { |
| const char *file, *cp, **argv; |
| int argc, i, errcode; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| |
| if ((cp = wp[builtin_opt.optind]) == NULL) { |
| bi_errorf("missing argument"); |
| return (1); |
| } |
| if ((file = search(cp, path, R_OK, &errcode)) == NULL) { |
| bi_errorf("%s: %s", cp, |
| errcode ? strerror(errcode) : "not found"); |
| return (1); |
| } |
| |
| /* Set positional parameters? */ |
| if (wp[builtin_opt.optind + 1]) { |
| argv = wp + builtin_opt.optind; |
| argv[0] = e->loc->argv[0]; /* preserve $0 */ |
| for (argc = 0; argv[argc + 1]; argc++) |
| ; |
| } else { |
| argc = 0; |
| argv = NULL; |
| } |
| if ((i = include(file, argc, argv, 0)) < 0) { |
| /* should not happen */ |
| bi_errorf("%s: %s", cp, strerror(errno)); |
| return (1); |
| } |
| return (i); |
| } |
| |
| int |
| c_wait(const char **wp) |
| { |
| int rv = 0, sig; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| wp += builtin_opt.optind; |
| if (*wp == NULL) { |
| while (waitfor(NULL, &sig) >= 0) |
| ; |
| rv = sig; |
| } else { |
| for (; *wp; wp++) |
| rv = waitfor(*wp, &sig); |
| if (rv < 0) |
| rv = sig ? sig : 127; /* magic exit code: bad job-id */ |
| } |
| return (rv); |
| } |
| |
| int |
| c_read(const char **wp) |
| { |
| int c = 0, ecode = 0, fd = 0, optc; |
| bool expande = true, historyr = false, expanding; |
| const char *cp, *emsg; |
| struct shf *shf; |
| XString cs, xs = { NULL, NULL, 0, NULL}; |
| struct tbl *vp; |
| char *ccp, *xp = NULL, *wpalloc = NULL; |
| static char REPLY[] = "REPLY"; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "prsu,")) != -1) |
| switch (optc) { |
| case 'p': |
| if ((fd = coproc_getfd(R_OK, &emsg)) < 0) { |
| bi_errorf("-p: %s", emsg); |
| return (1); |
| } |
| break; |
| case 'r': |
| expande = false; |
| break; |
| case 's': |
| historyr = true; |
| break; |
| case 'u': |
| if (!*(cp = builtin_opt.optarg)) |
| fd = 0; |
| else if ((fd = check_fd(cp, R_OK, &emsg)) < 0) { |
| bi_errorf("-u: %s: %s", cp, emsg); |
| return (1); |
| } |
| break; |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| |
| if (*wp == NULL) |
| *--wp = REPLY; |
| |
| /* Since we can't necessarily seek backwards on non-regular files, |
| * don't buffer them so we can't read too much. |
| */ |
| shf = shf_reopen(fd, SHF_RD | SHF_INTERRUPT | can_seek(fd), shl_spare); |
| |
| if ((cp = cstrchr(*wp, '?')) != NULL) { |
| strdupx(wpalloc, *wp, ATEMP); |
| wpalloc[cp - *wp] = '\0'; |
| *wp = wpalloc; |
| if (isatty(fd)) { |
| /* AT&T ksh says it prints prompt on fd if it's open |
| * for writing and is a tty, but it doesn't do it |
| * (it also doesn't check the interactive flag, |
| * as is indicated in the Kornshell book). |
| */ |
| shellf("%s", cp+1); |
| } |
| } |
| |
| /* If we are reading from the co-process for the first time, |
| * make sure the other side of the pipe is closed first. This allows |
| * the detection of eof. |
| * |
| * This is not compatible with AT&T ksh... the fd is kept so another |
| * coproc can be started with same output, however, this means eof |
| * can't be detected... This is why it is closed here. |
| * If this call is removed, remove the eof check below, too. |
| * coproc_readw_close(fd); |
| */ |
| |
| if (historyr) |
| Xinit(xs, xp, 128, ATEMP); |
| expanding = false; |
| Xinit(cs, ccp, 128, ATEMP); |
| for (; *wp != NULL; wp++) { |
| for (ccp = Xstring(cs, ccp); ; ) { |
| if (c == '\n' || c == EOF) |
| break; |
| while (1) { |
| c = shf_getc(shf); |
| if (c == '\0') |
| continue; |
| if (c == EOF && shf_error(shf) && |
| shf_errno(shf) == EINTR) { |
| /* Was the offending signal one that |
| * would normally kill a process? |
| * If so, pretend the read was killed. |
| */ |
| ecode = fatal_trap_check(); |
| |
| /* non fatal (eg, CHLD), carry on */ |
| if (!ecode) { |
| shf_clearerr(shf); |
| continue; |
| } |
| } |
| break; |
| } |
| if (historyr) { |
| Xcheck(xs, xp); |
| Xput(xs, xp, c); |
| } |
| Xcheck(cs, ccp); |
| if (expanding) { |
| expanding = false; |
| if (c == '\n') { |
| c = 0; |
| if (Flag(FTALKING_I) && isatty(fd)) { |
| /* set prompt in case this is |
| * called from .profile or $ENV |
| */ |
| set_prompt(PS2, NULL); |
| pprompt(prompt, 0); |
| } |
| } else if (c != EOF) |
| Xput(cs, ccp, c); |
| continue; |
| } |
| if (expande && c == '\\') { |
| expanding = true; |
| continue; |
| } |
| if (c == '\n' || c == EOF) |
| break; |
| if (ctype(c, C_IFS)) { |
| if (Xlength(cs, ccp) == 0 && ctype(c, C_IFSWS)) |
| continue; |
| if (wp[1]) |
| break; |
| } |
| Xput(cs, ccp, c); |
| } |
| /* strip trailing IFS white space from last variable */ |
| if (!wp[1]) |
| while (Xlength(cs, ccp) && ctype(ccp[-1], C_IFS) && |
| ctype(ccp[-1], C_IFSWS)) |
| ccp--; |
| Xput(cs, ccp, '\0'); |
| vp = global(*wp); |
| /* Must be done before setting export. */ |
| if (vp->flag & RDONLY) { |
| shf_flush(shf); |
| bi_errorf("%s is read only", *wp); |
| afree(wpalloc, ATEMP); |
| return (1); |
| } |
| if (Flag(FEXPORT)) |
| typeset(*wp, EXPORT, 0, 0, 0); |
| if (!setstr(vp, Xstring(cs, ccp), KSH_RETURN_ERROR)) { |
| shf_flush(shf); |
| afree(wpalloc, ATEMP); |
| return (1); |
| } |
| } |
| |
| shf_flush(shf); |
| if (historyr) { |
| Xput(xs, xp, '\0'); |
| histsave(&source->line, Xstring(xs, xp), true, false); |
| Xfree(xs, xp); |
| } |
| /* if this is the co-process fd, close the file descriptor |
| * (can get eof if and only if all processes are have died, ie, |
| * coproc.njobs is 0 and the pipe is closed). |
| */ |
| if (c == EOF && !ecode) |
| coproc_read_close(fd); |
| |
| afree(wpalloc, ATEMP); |
| return (ecode ? ecode : c == EOF); |
| } |
| |
| int |
| c_eval(const char **wp) |
| { |
| struct source *s, *saves = source; |
| unsigned char savef; |
| int rv; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| s = pushs(SWORDS, ATEMP); |
| s->u.strv = wp + builtin_opt.optind; |
| |
| /*- |
| * The following code handles the case where the command is |
| * empty due to failed command substitution, for example by |
| * eval "$(false)" |
| * This has historically returned 1 by AT&T ksh88. In this |
| * case, shell() will not set or change exstat because the |
| * compiled tree is empty, so it will use the value we pass |
| * from subst_exstat, which is cleared in execute(), so it |
| * should have been 0 if there were no substitutions. |
| * |
| * POSIX however says we don't do this, even though it is |
| * traditionally done. AT&T ksh93 agrees with POSIX, so we |
| * do. The following is an excerpt from SUSv4 [1003.2-2008]: |
| * |
| * 2.9.1: Simple Commands |
| * ... If there is a command name, execution shall |
| * continue as described in 2.9.1.1 [Command Search |
| * and Execution]. If there is no command name, but |
| * the command contained a command substitution, the |
| * command shall complete with the exit status of the |
| * last command substitution performed. |
| * 2.9.1.1: Command Search and Execution |
| * (1) a. If the command name matches the name of a |
| * special built-in utility, that special built-in |
| * utility shall be invoked. |
| * 2.14.5: eval |
| * If there are no arguments, or only null arguments, |
| * eval shall return a zero exit status; ... |
| */ |
| /* exstat = subst_exstat; */ /* AT&T ksh88 */ |
| exstat = 0; /* SUSv4 */ |
| |
| savef = Flag(FERREXIT); |
| Flag(FERREXIT) = 0; |
| rv = shell(s, false); |
| Flag(FERREXIT) = savef; |
| source = saves; |
| afree(s, ATEMP); |
| return (rv); |
| } |
| |
| int |
| c_trap(const char **wp) |
| { |
| int i; |
| const char *s; |
| Trap *p; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| wp += builtin_opt.optind; |
| |
| if (*wp == NULL) { |
| for (p = sigtraps, i = NSIG+1; --i >= 0; p++) |
| if (p->trap != NULL) { |
| shf_puts("trap -- ", shl_stdout); |
| print_value_quoted(p->trap); |
| shprintf(" %s\n", p->name); |
| } |
| return (0); |
| } |
| |
| /* |
| * Use case sensitive lookup for first arg so the |
| * command 'exit' isn't confused with the pseudo-signal |
| * 'EXIT'. |
| */ |
| s = (gettrap(*wp, false) == NULL) ? *wp++ : NULL; /* get command */ |
| if (s != NULL && s[0] == '-' && s[1] == '\0') |
| s = NULL; |
| |
| /* set/clear traps */ |
| while (*wp != NULL) { |
| p = gettrap(*wp++, true); |
| if (p == NULL) { |
| bi_errorf("bad signal %s", wp[-1]); |
| return (1); |
| } |
| settrap(p, s); |
| } |
| return (0); |
| } |
| |
| int |
| c_exitreturn(const char **wp) |
| { |
| int n, how = LEXIT; |
| const char *arg; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| arg = wp[builtin_opt.optind]; |
| |
| if (arg) { |
| if (!getn(arg, &n)) { |
| exstat = 1; |
| warningf(true, "%s: bad number", arg); |
| } else |
| exstat = n; |
| } |
| if (wp[0][0] == 'r') { /* return */ |
| struct env *ep; |
| |
| /* need to tell if this is exit or return so trap exit will |
| * work right (POSIX) |
| */ |
| for (ep = e; ep; ep = ep->oenv) |
| if (STOP_RETURN(ep->type)) { |
| how = LRETURN; |
| break; |
| } |
| } |
| |
| if (how == LEXIT && !really_exit && j_stopped_running()) { |
| really_exit = 1; |
| how = LSHELL; |
| } |
| |
| quitenv(NULL); /* get rid of any i/o redirections */ |
| unwind(how); |
| /* NOTREACHED */ |
| } |
| |
| int |
| c_brkcont(const char **wp) |
| { |
| int n, quit; |
| struct env *ep, *last_ep = NULL; |
| const char *arg; |
| |
| if (ksh_getopt(wp, &builtin_opt, null) == '?') |
| return (1); |
| arg = wp[builtin_opt.optind]; |
| |
| if (!arg) |
| n = 1; |
| else if (!bi_getn(arg, &n)) |
| return (1); |
| quit = n; |
| if (quit <= 0) { |
| /* AT&T ksh does this for non-interactive shells only - weird */ |
| bi_errorf("%s: bad value", arg); |
| return (1); |
| } |
| |
| /* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */ |
| for (ep = e; ep && !STOP_BRKCONT(ep->type); ep = ep->oenv) |
| if (ep->type == E_LOOP) { |
| if (--quit == 0) |
| break; |
| ep->flags |= EF_BRKCONT_PASS; |
| last_ep = ep; |
| } |
| |
| if (quit) { |
| /* AT&T ksh doesn't print a message - just does what it |
| * can. We print a message 'cause it helps in debugging |
| * scripts, but don't generate an error (ie, keep going). |
| */ |
| if (n == quit) { |
| warningf(true, "%s: cannot %s", wp[0], wp[0]); |
| return (0); |
| } |
| /* POSIX says if n is too big, the last enclosing loop |
| * shall be used. Doesn't say to print an error but we |
| * do anyway 'cause the user messed up. |
| */ |
| if (last_ep) |
| last_ep->flags &= ~EF_BRKCONT_PASS; |
| warningf(true, "%s: can only %s %d level(s)", |
| wp[0], wp[0], n - quit); |
| } |
| |
| unwind(*wp[0] == 'b' ? LBREAK : LCONTIN); |
| /* NOTREACHED */ |
| } |
| |
| int |
| c_set(const char **wp) |
| { |
| int argi; |
| bool setargs; |
| struct block *l = e->loc; |
| const char **owp; |
| |
| if (wp[1] == NULL) { |
| static const char *args[] = { "set", "-", NULL }; |
| return (c_typeset(args)); |
| } |
| |
| argi = parse_args(wp, OF_SET, &setargs); |
| if (argi < 0) |
| return (1); |
| /* set $# and $* */ |
| if (setargs) { |
| wp += argi - 1; |
| owp = wp; |
| wp[0] = l->argv[0]; /* save $0 */ |
| while (*++wp != NULL) |
| strdupx(*wp, *wp, &l->area); |
| l->argc = wp - owp - 1; |
| l->argv = alloc((l->argc + 2) * sizeof(char *), &l->area); |
| for (wp = l->argv; (*wp++ = *owp++) != NULL; ) |
| ; |
| } |
| /*- |
| * POSIX says set exit status is 0, but old scripts that use |
| * getopt(1) use the construct |
| * set -- $(getopt ab:c "$@") |
| * which assumes the exit value set will be that of the $() |
| * (subst_exstat is cleared in execute() so that it will be 0 |
| * if there are no command substitutions). |
| * Switched ksh (!posix !sh) to POSIX in mksh R39b. |
| */ |
| return (Flag(FSH) ? subst_exstat : 0); |
| } |
| |
| int |
| c_unset(const char **wp) |
| { |
| const char *id; |
| int optc; |
| bool unset_var = true; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "fv")) != -1) |
| switch (optc) { |
| case 'f': |
| unset_var = false; |
| break; |
| case 'v': |
| unset_var = true; |
| break; |
| case '?': |
| return (1); |
| } |
| wp += builtin_opt.optind; |
| for (; (id = *wp) != NULL; wp++) |
| if (unset_var) { /* unset variable */ |
| struct tbl *vp; |
| char *cp = NULL; |
| size_t n; |
| |
| n = strlen(id); |
| if (n > 3 && id[n-3] == '[' && id[n-2] == '*' && |
| id[n-1] == ']') { |
| strndupx(cp, id, n - 3, ATEMP); |
| id = cp; |
| optc = 3; |
| } else |
| optc = vstrchr(id, '[') ? 0 : 1; |
| |
| vp = global(id); |
| afree(cp, ATEMP); |
| |
| if ((vp->flag&RDONLY)) { |
| bi_errorf("%s is read only", vp->name); |
| return (1); |
| } |
| unset(vp, optc); |
| } else /* unset function */ |
| define(id, NULL); |
| return (0); |
| } |
| |
| static void |
| p_time(struct shf *shf, bool posix, long tv_sec, int tv_usec, int width, |
| const char *prefix, const char *suffix) |
| { |
| tv_usec /= 10000; |
| if (posix) |
| shf_fprintf(shf, "%s%*ld.%02d%s", prefix, width, |
| tv_sec, tv_usec, suffix); |
| else |
| shf_fprintf(shf, "%s%*ldm%d.%02ds%s", prefix, width, |
| tv_sec / 60, (int)(tv_sec % 60), tv_usec, suffix); |
| } |
| |
| int |
| c_times(const char **wp MKSH_A_UNUSED) |
| { |
| struct rusage usage; |
| |
| getrusage(RUSAGE_SELF, &usage); |
| p_time(shl_stdout, false, usage.ru_utime.tv_sec, |
| usage.ru_utime.tv_usec, 0, null, " "); |
| p_time(shl_stdout, false, usage.ru_stime.tv_sec, |
| usage.ru_stime.tv_usec, 0, null, "\n"); |
| |
| getrusage(RUSAGE_CHILDREN, &usage); |
| p_time(shl_stdout, false, usage.ru_utime.tv_sec, |
| usage.ru_utime.tv_usec, 0, null, " "); |
| p_time(shl_stdout, false, usage.ru_stime.tv_sec, |
| usage.ru_stime.tv_usec, 0, null, "\n"); |
| |
| return (0); |
| } |
| |
| /* |
| * time pipeline (really a statement, not a built-in command) |
| */ |
| int |
| timex(struct op *t, int f, volatile int *xerrok) |
| { |
| #define TF_NOARGS BIT(0) |
| #define TF_NOREAL BIT(1) /* don't report real time */ |
| #define TF_POSIX BIT(2) /* report in POSIX format */ |
| int rv = 0, tf = 0; |
| struct rusage ru0, ru1, cru0, cru1; |
| struct timeval usrtime, systime, tv0, tv1; |
| |
| gettimeofday(&tv0, NULL); |
| getrusage(RUSAGE_SELF, &ru0); |
| getrusage(RUSAGE_CHILDREN, &cru0); |
| if (t->left) { |
| /* |
| * Two ways of getting cpu usage of a command: just use t0 |
| * and t1 (which will get cpu usage from other jobs that |
| * finish while we are executing t->left), or get the |
| * cpu usage of t->left. AT&T ksh does the former, while |
| * pdksh tries to do the later (the j_usrtime hack doesn't |
| * really work as it only counts the last job). |
| */ |
| timerclear(&j_usrtime); |
| timerclear(&j_systime); |
| rv = execute(t->left, f | XTIME, xerrok); |
| if (t->left->type == TCOM) |
| tf |= t->left->str[0]; |
| gettimeofday(&tv1, NULL); |
| getrusage(RUSAGE_SELF, &ru1); |
| getrusage(RUSAGE_CHILDREN, &cru1); |
| } else |
| tf = TF_NOARGS; |
| |
| if (tf & TF_NOARGS) { /* ksh93 - report shell times (shell+kids) */ |
| tf |= TF_NOREAL; |
| timeradd(&ru0.ru_utime, &cru0.ru_utime, &usrtime); |
| timeradd(&ru0.ru_stime, &cru0.ru_stime, &systime); |
| } else { |
| timersub(&ru1.ru_utime, &ru0.ru_utime, &usrtime); |
| timeradd(&usrtime, &j_usrtime, &usrtime); |
| timersub(&ru1.ru_stime, &ru0.ru_stime, &systime); |
| timeradd(&systime, &j_systime, &systime); |
| } |
| |
| if (!(tf & TF_NOREAL)) { |
| timersub(&tv1, &tv0, &tv1); |
| if (tf & TF_POSIX) |
| p_time(shl_out, true, tv1.tv_sec, tv1.tv_usec, |
| 5, "real ", "\n"); |
| else |
| p_time(shl_out, false, tv1.tv_sec, tv1.tv_usec, |
| 5, null, " real "); |
| } |
| if (tf & TF_POSIX) |
| p_time(shl_out, true, usrtime.tv_sec, usrtime.tv_usec, |
| 5, "user ", "\n"); |
| else |
| p_time(shl_out, false, usrtime.tv_sec, usrtime.tv_usec, |
| 5, null, " user "); |
| if (tf & TF_POSIX) |
| p_time(shl_out, true, systime.tv_sec, systime.tv_usec, |
| 5, "sys ", "\n"); |
| else |
| p_time(shl_out, false, systime.tv_sec, systime.tv_usec, |
| 5, null, " system\n"); |
| shf_flush(shl_out); |
| |
| return (rv); |
| } |
| |
| void |
| timex_hook(struct op *t, char **volatile *app) |
| { |
| char **wp = *app; |
| int optc, i, j; |
| Getopt opt; |
| |
| ksh_getopt_reset(&opt, 0); |
| opt.optind = 0; /* start at the start */ |
| while ((optc = ksh_getopt((const char **)wp, &opt, ":p")) != -1) |
| switch (optc) { |
| case 'p': |
| t->str[0] |= TF_POSIX; |
| break; |
| case '?': |
| errorf("time: -%s unknown option", opt.optarg); |
| case ':': |
| errorf("time: -%s requires an argument", |
| opt.optarg); |
| } |
| /* Copy command words down over options. */ |
| if (opt.optind != 0) { |
| for (i = 0; i < opt.optind; i++) |
| afree(wp[i], ATEMP); |
| for (i = 0, j = opt.optind; (wp[i] = wp[j]); i++, j++) |
| ; |
| } |
| if (!wp[0]) |
| t->str[0] |= TF_NOARGS; |
| *app = wp; |
| } |
| |
| /* exec with no args - args case is taken care of in comexec() */ |
| int |
| c_exec(const char **wp MKSH_A_UNUSED) |
| { |
| int i; |
| |
| /* make sure redirects stay in place */ |
| if (e->savefd != NULL) { |
| for (i = 0; i < NUFILE; i++) { |
| if (e->savefd[i] > 0) |
| close(e->savefd[i]); |
| /* |
| * keep all file descriptors > 2 private for ksh, |
| * but not for POSIX or legacy/kludge sh |
| */ |
| if (!Flag(FPOSIX) && !Flag(FSH) && i > 2 && |
| e->savefd[i]) |
| fcntl(i, F_SETFD, FD_CLOEXEC); |
| } |
| e->savefd = NULL; |
| } |
| return (0); |
| } |
| |
| #if HAVE_MKNOD |
| int |
| c_mknod(const char **wp) |
| { |
| int argc, optc, rv = 0; |
| bool ismkfifo = false; |
| const char **argv; |
| void *set = NULL; |
| mode_t mode = 0, oldmode = 0; |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, "m:")) != -1) { |
| switch (optc) { |
| case 'm': |
| set = setmode(builtin_opt.optarg); |
| if (set == NULL) { |
| bi_errorf("invalid file mode"); |
| return (1); |
| } |
| mode = getmode(set, (mode_t)(DEFFILEMODE)); |
| free(set); |
| break; |
| default: |
| goto c_mknod_usage; |
| } |
| } |
| argv = &wp[builtin_opt.optind]; |
| if (argv[0] == NULL) |
| goto c_mknod_usage; |
| for (argc = 0; argv[argc]; argc++) |
| ; |
| if (argc == 2 && argv[1][0] == 'p') |
| ismkfifo = true; |
| else if (argc != 4 || (argv[1][0] != 'b' && argv[1][0] != 'c')) |
| goto c_mknod_usage; |
| |
| if (set != NULL) |
| oldmode = umask((mode_t)0); |
| else |
| mode = DEFFILEMODE; |
| |
| mode |= (argv[1][0] == 'b') ? S_IFBLK : |
| (argv[1][0] == 'c') ? S_IFCHR : 0; |
| |
| if (!ismkfifo) { |
| unsigned long majnum, minnum; |
| dev_t dv; |
| char *c; |
| |
| majnum = strtoul(argv[2], &c, 0); |
| if ((c == argv[2]) || (*c != '\0')) { |
| bi_errorf("non-numeric device major '%s'", argv[2]); |
| goto c_mknod_err; |
| } |
| minnum = strtoul(argv[3], &c, 0); |
| if ((c == argv[3]) || (*c != '\0')) { |
| bi_errorf("non-numeric device minor '%s'", argv[3]); |
| goto c_mknod_err; |
| } |
| dv = makedev(majnum, minnum); |
| if ((unsigned long)(major(dv)) != majnum) { |
| bi_errorf("device major too large: %lu", majnum); |
| goto c_mknod_err; |
| } |
| if ((unsigned long)(minor(dv)) != minnum) { |
| bi_errorf("device minor too large: %lu", minnum); |
| goto c_mknod_err; |
| } |
| if (mknod(argv[0], mode, dv)) |
| goto c_mknod_failed; |
| } else if (mkfifo(argv[0], mode)) { |
| c_mknod_failed: |
| bi_errorf("%s: %s", *wp, strerror(errno)); |
| c_mknod_err: |
| rv = 1; |
| } |
| |
| if (set) |
| umask(oldmode); |
| return (rv); |
| c_mknod_usage: |
| bi_errorf("usage: mknod [-m mode] name b|c major minor"); |
| bi_errorf("usage: mknod [-m mode] name p"); |
| return (1); |
| } |
| #endif |
| |
| /* dummy function, special case in comexec() */ |
| int |
| c_builtin(const char **wp MKSH_A_UNUSED) |
| { |
| return (0); |
| } |
| |
| /* test(1) accepts the following grammar: |
| oexpr ::= aexpr | aexpr "-o" oexpr ; |
| aexpr ::= nexpr | nexpr "-a" aexpr ; |
| nexpr ::= primary | "!" nexpr ; |
| primary ::= unary-operator operand |
| | operand binary-operator operand |
| | operand |
| | "(" oexpr ")" |
| ; |
| |
| unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"| |
| "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"| |
| "-L"|"-h"|"-S"|"-H"; |
| |
| binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| |
| "-nt"|"-ot"|"-ef"| |
| "<"|">" # rules used for [[ .. ]] expressions |
| ; |
| operand ::= <any thing> |
| */ |
| |
| #define T_ERR_EXIT 2 /* POSIX says > 1 for errors */ |
| |
| int |
| c_test(const char **wp) |
| { |
| int argc, res; |
| Test_env te; |
| |
| te.flags = 0; |
| te.isa = ptest_isa; |
| te.getopnd = ptest_getopnd; |
| te.eval = test_eval; |
| te.error = ptest_error; |
| |
| for (argc = 0; wp[argc]; argc++) |
| ; |
| |
| if (strcmp(wp[0], "[") == 0) { |
| if (strcmp(wp[--argc], "]") != 0) { |
| bi_errorf("missing ]"); |
| return (T_ERR_EXIT); |
| } |
| } |
| |
| te.pos.wp = wp + 1; |
| te.wp_end = wp + argc; |
| |
| /* |
| * Handle the special cases from POSIX.2, section 4.62.4. |
| * Implementation of all the rules isn't necessary since |
| * our parser does the right thing for the omitted steps. |
| */ |
| if (argc <= 5) { |
| const char **owp = wp; |
| int invert = 0; |
| Test_op op; |
| const char *opnd1, *opnd2; |
| |
| while (--argc >= 0) { |
| if ((*te.isa)(&te, TM_END)) |
| return (!0); |
| if (argc == 3) { |
| opnd1 = (*te.getopnd)(&te, TO_NONOP, 1); |
| if ((op = (*te.isa)(&te, TM_BINOP))) { |
| opnd2 = (*te.getopnd)(&te, op, 1); |
| res = (*te.eval)(&te, op, opnd1, |
| opnd2, 1); |
| if (te.flags & TEF_ERROR) |
| return (T_ERR_EXIT); |
| if (invert & 1) |
| res = !res; |
| return (!res); |
| } |
| /* back up to opnd1 */ |
| te.pos.wp--; |
| } |
| if (argc == 1) { |
| opnd1 = (*te.getopnd)(&te, TO_NONOP, 1); |
| if (strcmp(opnd1, "-t") == 0) |
| break; |
| res = (*te.eval)(&te, TO_STNZE, opnd1, |
| NULL, 1); |
| if (invert & 1) |
| res = !res; |
| return (!res); |
| } |
| if ((*te.isa)(&te, TM_NOT)) { |
| invert++; |
| } else |
| break; |
| } |
| te.pos.wp = owp + 1; |
| } |
| |
| return (test_parse(&te)); |
| } |
| |
| /* |
| * Generic test routines. |
| */ |
| |
| Test_op |
| test_isop(Test_meta meta, const char *s) |
| { |
| char sc1; |
| const struct t_op *tbl; |
| |
| tbl = meta == TM_UNOP ? u_ops : b_ops; |
| if (*s) { |
| sc1 = s[1]; |
| for (; tbl->op_text[0]; tbl++) |
| if (sc1 == tbl->op_text[1] && !strcmp(s, tbl->op_text)) |
| return (tbl->op_num); |
| } |
| return (TO_NONOP); |
| } |
| |
| int |
| test_eval(Test_env *te, Test_op op, const char *opnd1, const char *opnd2, |
| bool do_eval) |
| { |
| int i, s; |
| size_t k; |
| struct stat b1, b2; |
| mksh_ari_t v1, v2; |
| |
| if (!do_eval) |
| return (0); |
| |
| switch ((int)op) { |
| /* |
| * Unary Operators |
| */ |
| case TO_STNZE: /* -n */ |
| return (*opnd1 != '\0'); |
| case TO_STZER: /* -z */ |
| return (*opnd1 == '\0'); |
| case TO_OPTION: /* -o */ |
| if ((i = *opnd1) == '!' || i == '?') |
| opnd1++; |
| if ((k = option(opnd1)) == (size_t)-1) |
| return (0); |
| return (i == '?' ? 1 : i == '!' ? !Flag(k) : Flag(k)); |
| case TO_FILRD: /* -r */ |
| return (test_eaccess(opnd1, R_OK) == 0); |
| case TO_FILWR: /* -w */ |
| return (test_eaccess(opnd1, W_OK) == 0); |
| case TO_FILEX: /* -x */ |
| return (test_eaccess(opnd1, X_OK) == 0); |
| case TO_FILAXST: /* -a */ |
| case TO_FILEXST: /* -e */ |
| return (stat(opnd1, &b1) == 0); |
| case TO_FILREG: /* -r */ |
| return (stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode)); |
| case TO_FILID: /* -d */ |
| return (stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode)); |
| case TO_FILCDEV: /* -c */ |
| return (stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode)); |
| case TO_FILBDEV: /* -b */ |
| return (stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode)); |
| case TO_FILFIFO: /* -p */ |
| return (stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode)); |
| case TO_FILSYM: /* -h -L */ |
| return (lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode)); |
| case TO_FILSOCK: /* -S */ |
| return (stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode)); |
| case TO_FILCDF:/* -H HP context dependent files (directories) */ |
| return (0); |
| case TO_FILSETU: /* -u */ |
| return (stat(opnd1, &b1) == 0 && |
| (b1.st_mode & S_ISUID) == S_ISUID); |
| case TO_FILSETG: /* -g */ |
| return (stat(opnd1, &b1) == 0 && |
| (b1.st_mode & S_ISGID) == S_ISGID); |
| case TO_FILSTCK: /* -k */ |
| #ifdef S_ISVTX |
| return (stat(opnd1, &b1) == 0 && |
| (b1.st_mode & S_ISVTX) == S_ISVTX); |
| #else |
| return (0); |
| #endif |
| case TO_FILGZ: /* -s */ |
| return (stat(opnd1, &b1) == 0 && b1.st_size > 0L); |
| case TO_FILTT: /* -t */ |
| if (opnd1 && !bi_getn(opnd1, &i)) { |
| te->flags |= TEF_ERROR; |
| i = 0; |
| } else |
| i = isatty(opnd1 ? i : 0); |
| return (i); |
| case TO_FILUID: /* -O */ |
| return (stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid); |
| case TO_FILGID: /* -G */ |
| return (stat(opnd1, &b1) == 0 && b1.st_gid == getegid()); |
| /* |
| * Binary Operators |
| */ |
| case TO_STEQL: /* = */ |
| if (te->flags & TEF_DBRACKET) |
| return (gmatchx(opnd1, opnd2, false)); |
| return (strcmp(opnd1, opnd2) == 0); |
| case TO_STNEQ: /* != */ |
| if (te->flags & TEF_DBRACKET) |
| return (!gmatchx(opnd1, opnd2, false)); |
| return (strcmp(opnd1, opnd2) != 0); |
| case TO_STLT: /* < */ |
| return (strcmp(opnd1, opnd2) < 0); |
| case TO_STGT: /* > */ |
| return (strcmp(opnd1, opnd2) > 0); |
| case TO_INTEQ: /* -eq */ |
| case TO_INTNE: /* -ne */ |
| case TO_INTGE: /* -ge */ |
| case TO_INTGT: /* -gt */ |
| case TO_INTLE: /* -le */ |
| case TO_INTLT: /* -lt */ |
| if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR, false) || |
| !evaluate(opnd2, &v2, KSH_RETURN_ERROR, false)) { |
| /* error already printed.. */ |
| te->flags |= TEF_ERROR; |
| return (1); |
| } |
| switch ((int)op) { |
| case TO_INTEQ: |
| return (v1 == v2); |
| case TO_INTNE: |
| return (v1 != v2); |
| case TO_INTGE: |
| return (v1 >= v2); |
| case TO_INTGT: |
| return (v1 > v2); |
| case TO_INTLE: |
| return (v1 <= v2); |
| case TO_INTLT: |
| return (v1 < v2); |
| } |
| case TO_FILNT: /* -nt */ |
| /* ksh88/ksh93 succeed if file2 can't be stated |
| * (subtly different from 'does not exist'). |
| */ |
| return (stat(opnd1, &b1) == 0 && |
| (((s = stat(opnd2, &b2)) == 0 && |
| b1.st_mtime > b2.st_mtime) || s < 0)); |
| case TO_FILOT: /* -ot */ |
| /* ksh88/ksh93 succeed if file1 can't be stated |
| * (subtly different from 'does not exist'). |
| */ |
| return (stat(opnd2, &b2) == 0 && |
| (((s = stat(opnd1, &b1)) == 0 && |
| b1.st_mtime < b2.st_mtime) || s < 0)); |
| case TO_FILEQ: /* -ef */ |
| return (stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0 && |
| b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino); |
| } |
| (*te->error)(te, 0, "internal error: unknown op"); |
| return (1); |
| } |
| |
| /* On most/all unixen, access() says everything is executable for root... */ |
| static int |
| test_eaccess(const char *pathl, int mode) |
| { |
| int rv; |
| |
| if ((rv = access(pathl, mode)) == 0 && ksheuid == 0 && (mode & X_OK)) { |
| struct stat statb; |
| |
| if (stat(pathl, &statb) < 0) |
| rv = -1; |
| else if (S_ISDIR(statb.st_mode)) |
| rv = 0; |
| else |
| rv = (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) ? |
| 0 : -1; |
| } |
| return (rv); |
| } |
| |
| int |
| test_parse(Test_env *te) |
| { |
| int rv; |
| |
| rv = test_oexpr(te, 1); |
| |
| if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END)) |
| (*te->error)(te, 0, "unexpected operator/operand"); |
| |
| return ((te->flags & TEF_ERROR) ? T_ERR_EXIT : !rv); |
| } |
| |
| static int |
| test_oexpr(Test_env *te, bool do_eval) |
| { |
| int rv; |
| |
| if ((rv = test_aexpr(te, do_eval))) |
| do_eval = false; |
| if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR)) |
| return (test_oexpr(te, do_eval) || rv); |
| return (rv); |
| } |
| |
| static int |
| test_aexpr(Test_env *te, bool do_eval) |
| { |
| int rv; |
| |
| if (!(rv = test_nexpr(te, do_eval))) |
| do_eval = false; |
| if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND)) |
| return (test_aexpr(te, do_eval) && rv); |
| return (rv); |
| } |
| |
| static int |
| test_nexpr(Test_env *te, bool do_eval) |
| { |
| if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT)) |
| return (!test_nexpr(te, do_eval)); |
| return (test_primary(te, do_eval)); |
| } |
| |
| static int |
| test_primary(Test_env *te, bool do_eval) |
| { |
| const char *opnd1, *opnd2; |
| int rv; |
| Test_op op; |
| |
| if (te->flags & TEF_ERROR) |
| return (0); |
| if ((*te->isa)(te, TM_OPAREN)) { |
| rv = test_oexpr(te, do_eval); |
| if (te->flags & TEF_ERROR) |
| return (0); |
| if (!(*te->isa)(te, TM_CPAREN)) { |
| (*te->error)(te, 0, "missing closing paren"); |
| return (0); |
| } |
| return (rv); |
| } |
| /* |
| * Binary should have precedence over unary in this case |
| * so that something like test \( -f = -f \) is accepted |
| */ |
| if ((te->flags & TEF_DBRACKET) || (&te->pos.wp[1] < te->wp_end && |
| !test_isop(TM_BINOP, te->pos.wp[1]))) { |
| if ((op = (*te->isa)(te, TM_UNOP))) { |
| /* unary expression */ |
| opnd1 = (*te->getopnd)(te, op, do_eval); |
| if (!opnd1) { |
| (*te->error)(te, -1, "missing argument"); |
| return (0); |
| } |
| |
| return ((*te->eval)(te, op, opnd1, NULL, do_eval)); |
| } |
| } |
| opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval); |
| if (!opnd1) { |
| (*te->error)(te, 0, "expression expected"); |
| return (0); |
| } |
| if ((op = (*te->isa)(te, TM_BINOP))) { |
| /* binary expression */ |
| opnd2 = (*te->getopnd)(te, op, do_eval); |
| if (!opnd2) { |
| (*te->error)(te, -1, "missing second argument"); |
| return (0); |
| } |
| |
| return ((*te->eval)(te, op, opnd1, opnd2, do_eval)); |
| } |
| return ((*te->eval)(te, TO_STNZE, opnd1, NULL, do_eval)); |
| } |
| |
| /* |
| * Plain test (test and [ .. ]) specific routines. |
| */ |
| |
| /* |
| * Test if the current token is a whatever. Accepts the current token if |
| * it is. Returns 0 if it is not, non-zero if it is (in the case of |
| * TM_UNOP and TM_BINOP, the returned value is a Test_op). |
| */ |
| static Test_op |
| ptest_isa(Test_env *te, Test_meta meta) |
| { |
| /* Order important - indexed by Test_meta values */ |
| static const char *const tokens[] = { |
| "-o", "-a", "!", "(", ")" |
| }; |
| Test_op rv; |
| |
| if (te->pos.wp >= te->wp_end) |
| return (meta == TM_END ? TO_NONNULL : TO_NONOP); |
| |
| if (meta == TM_UNOP || meta == TM_BINOP) |
| rv = test_isop(meta, *te->pos.wp); |
| else if (meta == TM_END) |
| rv = TO_NONOP; |
| else |
| rv = !strcmp(*te->pos.wp, tokens[(int)meta]) ? |
| TO_NONNULL : TO_NONOP; |
| |
| /* Accept the token? */ |
| if (rv != TO_NONOP) |
| te->pos.wp++; |
| |
| return (rv); |
| } |
| |
| static const char * |
| ptest_getopnd(Test_env *te, Test_op op, bool do_eval MKSH_A_UNUSED) |
| { |
| if (te->pos.wp >= te->wp_end) |
| return (op == TO_FILTT ? "1" : NULL); |
| return (*te->pos.wp++); |
| } |
| |
| static void |
| ptest_error(Test_env *te, int ofs, const char *msg) |
| { |
| const char *op; |
| |
| te->flags |= TEF_ERROR; |
| if ((op = te->pos.wp + ofs >= te->wp_end ? NULL : te->pos.wp[ofs])) |
| bi_errorf("%s: %s", op, msg); |
| else |
| bi_errorf("%s", msg); |
| } |
| |
| #ifndef MKSH_NO_LIMITS |
| #define SOFT 0x1 |
| #define HARD 0x2 |
| |
| struct limits { |
| const char *name; |
| int resource; /* resource to get/set */ |
| int factor; /* multiply by to get rlim_{cur,max} values */ |
| char option; |
| }; |
| |
| static void print_ulimit(const struct limits *, int); |
| static int set_ulimit(const struct limits *, const char *, int); |
| |
| /* Magic to divine the 'm' and 'v' limits */ |
| |
| #ifdef RLIMIT_AS |
| #if !defined(RLIMIT_VMEM) || (RLIMIT_VMEM == RLIMIT_AS) || \ |
| !defined(RLIMIT_RSS) || (RLIMIT_VMEM == RLIMIT_RSS) |
| #define ULIMIT_V_IS_AS |
| #elif defined(RLIMIT_VMEM) |
| #if !defined(RLIMIT_RSS) || (RLIMIT_RSS == RLIMIT_AS) |
| #define ULIMIT_V_IS_AS |
| #else |
| #define ULIMIT_V_IS_VMEM |
| #endif |
| #endif |
| #endif |
| |
| #ifdef RLIMIT_RSS |
| #ifdef ULIMIT_V_IS_VMEM |
| #define ULIMIT_M_IS_RSS |
| #elif defined(RLIMIT_VMEM) && (RLIMIT_VMEM == RLIMIT_RSS) |
| #define ULIMIT_M_IS_VMEM |
| #else |
| #define ULIMIT_M_IS_RSS |
| #endif |
| #if defined(ULIMIT_M_IS_RSS) && defined(RLIMIT_AS) && (RLIMIT_RSS == RLIMIT_AS) |
| #undef ULIMIT_M_IS_RSS |
| #endif |
| #endif |
| |
| #if !defined(RLIMIT_AS) && !defined(ULIMIT_M_IS_VMEM) && defined(RLIMIT_VMEM) |
| #define ULIMIT_V_IS_VMEM |
| #endif |
| |
| #if !defined(ULIMIT_V_IS_VMEM) && defined(RLIMIT_VMEM) && \ |
| (!defined(RLIMIT_RSS) || (defined(RLIMIT_AS) && (RLIMIT_RSS == RLIMIT_AS))) |
| #define ULIMIT_M_IS_VMEM |
| #endif |
| |
| #if defined(ULIMIT_M_IS_VMEM) && defined(RLIMIT_AS) && \ |
| (RLIMIT_VMEM == RLIMIT_AS) |
| #undef ULIMIT_M_IS_VMEM |
| #endif |
| |
| |
| int |
| c_ulimit(const char **wp) |
| { |
| static const struct limits limits[] = { |
| /* do not use options -H, -S or -a or change the order */ |
| #ifdef RLIMIT_CPU |
| { "time(cpu-seconds)", RLIMIT_CPU, 1, 't' }, |
| #endif |
| #ifdef RLIMIT_FSIZE |
| { "file(blocks)", RLIMIT_FSIZE, 512, 'f' }, |
| #endif |
| #ifdef RLIMIT_CORE |
| { "coredump(blocks)", RLIMIT_CORE, 512, 'c' }, |
| #endif |
| #ifdef RLIMIT_DATA |
| { "data(KiB)", RLIMIT_DATA, 1024, 'd' }, |
| #endif |
| #ifdef RLIMIT_STACK |
| { "stack(KiB)", RLIMIT_STACK, 1024, 's' }, |
| #endif |
| #ifdef RLIMIT_MEMLOCK |
| { "lockedmem(KiB)", RLIMIT_MEMLOCK, 1024, 'l' }, |
| #endif |
| #ifdef RLIMIT_NOFILE |
| { "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' }, |
| #endif |
| #ifdef RLIMIT_NPROC |
| { "processes", RLIMIT_NPROC, 1, 'p' }, |
| #endif |
| #ifdef RLIMIT_SWAP |
| { "swap(KiB)", RLIMIT_SWAP, 1024, 'w' }, |
| #endif |
| #ifdef RLIMIT_LOCKS |
| { "flocks", RLIMIT_LOCKS, -1, 'L' }, |
| #endif |
| #ifdef RLIMIT_TIME |
| { "humantime(seconds)", RLIMIT_TIME, 1, 'T' }, |
| #endif |
| #ifdef RLIMIT_NOVMON |
| { "vnodemonitors", RLIMIT_NOVMON, 1, 'V' }, |
| #endif |
| #ifdef RLIMIT_SIGPENDING |
| { "sigpending", RLIMIT_SIGPENDING, 1, 'i' }, |
| #endif |
| #ifdef RLIMIT_MSGQUEUE |
| { "msgqueue(bytes)", RLIMIT_MSGQUEUE, 1, 'q' }, |
| #endif |
| #ifdef RLIMIT_AIO_MEM |
| { "AIOlockedmem(KiB)", RLIMIT_AIO_MEM, 1024, 'M' }, |
| #endif |
| #ifdef RLIMIT_AIO_OPS |
| { "AIOoperations", RLIMIT_AIO_OPS, 1, 'O' }, |
| #endif |
| #ifdef RLIMIT_TCACHE |
| { "cachedthreads", RLIMIT_TCACHE, 1, 'C' }, |
| #endif |
| #ifdef RLIMIT_SBSIZE |
| { "sockbufsiz(KiB)", RLIMIT_SBSIZE, 1024, 'B' }, |
| #endif |
| #ifdef RLIMIT_PTHREAD |
| { "threadsperprocess", RLIMIT_PTHREAD, 1, 'P' }, |
| #endif |
| #ifdef RLIMIT_NICE |
| { "maxnice", RLIMIT_NICE, 1, 'e' }, |
| #endif |
| #ifdef RLIMIT_RTPRIO |
| { "maxrtprio", RLIMIT_RTPRIO, 1, 'r' }, |
| #endif |
| #if defined(ULIMIT_M_IS_RSS) |
| { "resident-set(KiB)", RLIMIT_RSS, 1024, 'm' }, |
| #elif defined(ULIMIT_M_IS_VMEM) |
| { "memory(KiB)", RLIMIT_VMEM, 1024, 'm' }, |
| #endif |
| #if defined(ULIMIT_V_IS_VMEM) |
| { "virtual-memory(KiB)", RLIMIT_VMEM, 1024, 'v' }, |
| #elif defined(ULIMIT_V_IS_AS) |
| { "address-space(KiB)", RLIMIT_AS, 1024, 'v' }, |
| #endif |
| { NULL, 0, 0, 0 } |
| }; |
| static char opts[3 + NELEM(limits)]; |
| int how = SOFT | HARD, optc, what = 'f'; |
| bool all = false; |
| const struct limits *l; |
| |
| if (!opts[0]) { |
| /* build options string on first call - yuck */ |
| char *p = opts; |
| |
| *p++ = 'H'; *p++ = 'S'; *p++ = 'a'; |
| for (l = limits; l->name; l++) |
| *p++ = l->option; |
| *p = '\0'; |
| } |
| |
| while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1) |
| switch (optc) { |
| case 'H': |
| how = HARD; |
| break; |
| case 'S': |
| how = SOFT; |
| break; |
| case 'a': |
| all = true; |
| break; |
| case '?': |
| bi_errorf("usage: ulimit [-acdfHLlmnpSsTtvw] [value]"); |
| return (1); |
| default: |
| what = optc; |
| } |
| |
| for (l = limits; l->name && l->option != what; l++) |
| ; |
| if (!l->name) { |
| internal_warningf("ulimit: %c", what); |
| return (1); |
| } |
| |
| if (wp[builtin_opt.optind]) { |
| if (all || wp[builtin_opt.optind + 1]) { |
| bi_errorf("too many arguments"); |
| return (1); |
| } |
| return (set_ulimit(l, wp[builtin_opt.optind], how)); |
| } |
| if (!all) |
| print_ulimit(l, how); |
| else for (l = limits; l->name; l++) { |
| shprintf("%-20s ", l->name); |
| print_ulimit(l, how); |
| } |
| return (0); |
| } |
| |
| static int |
| set_ulimit(const struct limits *l, const char *v, int how) |
| { |
| rlim_t val = (rlim_t)0; |
| struct rlimit limit; |
| |
| if (strcmp(v, "unlimited") == 0) |
| val = (rlim_t)RLIM_INFINITY; |
| else { |
| mksh_ari_t rval; |
| |
| if (!evaluate(v, &rval, KSH_RETURN_ERROR, false)) |
| return (1); |
| /* |
| * Avoid problems caused by typos that evaluate misses due |
| * to evaluating unset parameters to 0... |
| * If this causes problems, will have to add parameter to |
| * evaluate() to control if unset params are 0 or an error. |
| */ |
| if (!rval && !ksh_isdigit(v[0])) { |
| bi_errorf("invalid %s limit: %s", l->name, v); |
| return (1); |
| } |
| val = (rlim_t)((rlim_t)rval * l->factor); |
| } |
| |
| if (getrlimit(l->resource, &limit) < 0) { |
| /* some cannot be read, e.g. Linux RLIMIT_LOCKS */ |
| limit.rlim_cur = RLIM_INFINITY; |
| limit.rlim_max = RLIM_INFINITY; |
| } |
| if (how & SOFT) |
| limit.rlim_cur = val; |
| if (how & HARD) |
| limit.rlim_max = val; |
| if (!setrlimit(l->resource, &limit)) |
| return (0); |
| if (errno == EPERM) |
| bi_errorf("%s exceeds allowable %s limit", v, l->name); |
| else |
| bi_errorf("bad %s limit: %s", l->name, strerror(errno)); |
| return (1); |
| } |
| |
| static void |
| print_ulimit(const struct limits *l, int how) |
| { |
| rlim_t val = (rlim_t)0; |
| struct rlimit limit; |
| |
| if (getrlimit(l->resource, &limit)) { |
| shf_puts("unknown\n", shl_stdout); |
| return; |
| } |
| if (how & SOFT) |
| val = limit.rlim_cur; |
| else if (how & HARD) |
| val = limit.rlim_max; |
| if (val == (rlim_t)RLIM_INFINITY) |
| shf_puts("unlimited\n", shl_stdout); |
| else |
| shprintf("%ld\n", (long)(val / l->factor)); |
| } |
| #endif |
| |
| int |
| c_rename(const char **wp) |
| { |
| int rv = 1; |
| |
| if (wp == NULL /* argv */ || |
| wp[0] == NULL /* name of builtin */ || |
| wp[1] == NULL /* first argument */ || |
| wp[2] == NULL /* second argument */ || |
| wp[3] != NULL /* no further args please */) |
| bi_errorf(T_synerr); |
| else if ((rv = rename(wp[1], wp[2])) != 0) { |
| rv = errno; |
| bi_errorf("failed: %s", strerror(rv)); |
| } |
| |
| return (rv); |
| } |
| |
| int |
| c_realpath(const char **wp) |
| { |
| int rv = 1; |
| char *buf; |
| |
| if (wp != NULL && wp[0] != NULL && wp[1] != NULL) { |
| if (strcmp(wp[1], "--")) { |
| if (wp[2] == NULL) { |
| wp += 1; |
| rv = 0; |
| } |
| } else { |
| if (wp[2] != NULL && wp[3] == NULL) { |
| wp += 2; |
| rv = 0; |
| } |
| } |
| } |
| |
| if (rv) |
| bi_errorf(T_synerr); |
| else if ((buf = do_realpath(*wp)) == NULL) { |
| rv = errno; |
| bi_errorf("%s: %s", *wp, strerror(rv)); |
| if ((unsigned int)rv > 255) |
| rv = 255; |
| } else { |
| shprintf("%s\n", buf); |
| afree(buf, ATEMP); |
| } |
| |
| return (rv); |
| } |