| /* vi: set sw=4 ts=4: */ |
| /* |
| * A prototype Bourne shell grammar parser. |
| * Intended to follow the original Thompson and Ritchie |
| * "small and simple is beautiful" philosophy, which |
| * incidentally is a good match to today's BusyBox. |
| * |
| * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org> |
| * Copyright (C) 2008,2009 Denys Vlasenko <vda.linux@googlemail.com> |
| * |
| * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
| * |
| * Credits: |
| * The parser routines proper are all original material, first |
| * written Dec 2000 and Jan 2001 by Larry Doolittle. The |
| * execution engine, the builtins, and much of the underlying |
| * support has been adapted from busybox-0.49pre's lash, which is |
| * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> |
| * written by Erik Andersen <andersen@codepoet.org>. That, in turn, |
| * is based in part on ladsh.c, by Michael K. Johnson and Erik W. |
| * Troan, which they placed in the public domain. I don't know |
| * how much of the Johnson/Troan code has survived the repeated |
| * rewrites. |
| * |
| * Other credits: |
| * o_addchr derived from similar w_addchar function in glibc-2.2. |
| * parse_redirect, redirect_opt_num, and big chunks of main |
| * and many builtins derived from contributions by Erik Andersen. |
| * Miscellaneous bugfixes from Matt Kraai. |
| * |
| * There are two big (and related) architecture differences between |
| * this parser and the lash parser. One is that this version is |
| * actually designed from the ground up to understand nearly all |
| * of the Bourne grammar. The second, consequential change is that |
| * the parser and input reader have been turned inside out. Now, |
| * the parser is in control, and asks for input as needed. The old |
| * way had the input reader in control, and it asked for parsing to |
| * take place as needed. The new way makes it much easier to properly |
| * handle the recursion implicit in the various substitutions, especially |
| * across continuation lines. |
| * |
| * TODOs: |
| * grep for "TODO" and fix (some of them are easy) |
| * make complex ${var%...} constructs support optional |
| * make here documents optional |
| * special variables (done: PWD, PPID, RANDOM) |
| * follow IFS rules more precisely, including update semantics |
| * tilde expansion |
| * aliases |
| * "command" missing features: |
| * command -p CMD: run CMD using default $PATH |
| * (can use this to override standalone shell as well?) |
| * command BLTIN: disables special-ness (e.g. errors do not abort) |
| * command -V CMD1 CMD2 CMD3 (multiple args) (not in standard) |
| * builtins mandated by standards we don't support: |
| * [un]alias, fc: |
| * fc -l[nr] [BEG] [END]: list range of commands in history |
| * fc [-e EDITOR] [BEG] [END]: edit/rerun range of commands |
| * fc -s [PAT=REP] [CMD]: rerun CMD, replacing PAT with REP |
| * |
| * Bash compat TODO: |
| * redirection of stdout+stderr: &> and >& |
| * reserved words: function select |
| * advanced test: [[ ]] |
| * process substitution: <(list) and >(list) |
| * =~: regex operator |
| * let EXPR [EXPR...] |
| * Each EXPR is an arithmetic expression (ARITHMETIC EVALUATION) |
| * If the last arg evaluates to 0, let returns 1; 0 otherwise. |
| * NB: let `echo 'a=a + 1'` - error (IOW: multi-word expansion is used) |
| * ((EXPR)) |
| * The EXPR is evaluated according to ARITHMETIC EVALUATION. |
| * This is exactly equivalent to let "EXPR". |
| * $[EXPR]: synonym for $((EXPR)) |
| * indirect expansion: ${!VAR} |
| * substring op on @: ${@:n:m} |
| * |
| * Won't do: |
| * Some builtins mandated by standards: |
| * newgrp [GRP]: not a builtin in bash but a suid binary |
| * which spawns a new shell with new group ID |
| * |
| * Status of [[ support: |
| * [[ args ]] are CMD_SINGLEWORD_NOGLOB: |
| * v='a b'; [[ $v = 'a b' ]]; echo 0:$? |
| * [[ /bin/n* ]]; echo 0:$? |
| * TODO: |
| * &&/|| are AND/OR ops, -a/-o are not |
| * quoting needs to be considered (-f is an operator, "-f" and ""-f are not; etc) |
| * = is glob match operator, not equality operator: STR = GLOB |
| * (in GLOB, quoting is significant on char-by-char basis: a*cd"*") |
| * == same as = |
| * add =~ regex match operator: STR =~ REGEX |
| */ |
| //config:config HUSH |
| //config: bool "hush (68 kb)" |
| //config: default y |
| //config: help |
| //config: hush is a small shell. It handles the normal flow control |
| //config: constructs such as if/then/elif/else/fi, for/in/do/done, while loops, |
| //config: case/esac. Redirections, here documents, $((arithmetic)) |
| //config: and functions are supported. |
| //config: |
| //config: It will compile and work on no-mmu systems. |
| //config: |
| //config: It does not handle select, aliases, tilde expansion, |
| //config: &>file and >&file redirection of stdout+stderr. |
| //config: |
| //config:config HUSH_BASH_COMPAT |
| //config: bool "bash-compatible extensions" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_BRACE_EXPANSION |
| //config: bool "Brace expansion" |
| //config: default y |
| //config: depends on HUSH_BASH_COMPAT |
| //config: help |
| //config: Enable {abc,def} extension. |
| //config: |
| //config:config HUSH_LINENO_VAR |
| //config: bool "$LINENO variable" |
| //config: default y |
| //config: depends on HUSH_BASH_COMPAT |
| //config: |
| //config:config HUSH_BASH_SOURCE_CURDIR |
| //config: bool "'source' and '.' builtins search current directory after $PATH" |
| //config: default n # do not encourage non-standard behavior |
| //config: depends on HUSH_BASH_COMPAT |
| //config: help |
| //config: This is not compliant with standards. Avoid if possible. |
| //config: |
| //config:config HUSH_INTERACTIVE |
| //config: bool "Interactive mode" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: Enable interactive mode (prompt and command editing). |
| //config: Without this, hush simply reads and executes commands |
| //config: from stdin just like a shell script from a file. |
| //config: No prompt, no PS1/PS2 magic shell variables. |
| //config: |
| //config:config HUSH_SAVEHISTORY |
| //config: bool "Save command history to .hush_history" |
| //config: default y |
| //config: depends on HUSH_INTERACTIVE && FEATURE_EDITING_SAVEHISTORY |
| //config: |
| //config:config HUSH_JOB |
| //config: bool "Job control" |
| //config: default y |
| //config: depends on HUSH_INTERACTIVE |
| //config: help |
| //config: Enable job control: Ctrl-Z backgrounds, Ctrl-C interrupts current |
| //config: command (not entire shell), fg/bg builtins work. Without this option, |
| //config: "cmd &" still works by simply spawning a process and immediately |
| //config: prompting for next command (or executing next command in a script), |
| //config: but no separate process group is formed. |
| //config: |
| //config:config HUSH_TICK |
| //config: bool "Support command substitution" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: Enable `command` and $(command). |
| //config: |
| //config:config HUSH_IF |
| //config: bool "Support if/then/elif/else/fi" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_LOOPS |
| //config: bool "Support for, while and until loops" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_CASE |
| //config: bool "Support case ... esac statement" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: Enable case ... esac statement. +400 bytes. |
| //config: |
| //config:config HUSH_FUNCTIONS |
| //config: bool "Support funcname() { commands; } syntax" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: Enable support for shell functions. +800 bytes. |
| //config: |
| //config:config HUSH_LOCAL |
| //config: bool "local builtin" |
| //config: default y |
| //config: depends on HUSH_FUNCTIONS |
| //config: help |
| //config: Enable support for local variables in functions. |
| //config: |
| //config:config HUSH_RANDOM_SUPPORT |
| //config: bool "Pseudorandom generator and $RANDOM variable" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: Enable pseudorandom generator and dynamic variable "$RANDOM". |
| //config: Each read of "$RANDOM" will generate a new pseudorandom value. |
| //config: |
| //config:config HUSH_MODE_X |
| //config: bool "Support 'hush -x' option and 'set -x' command" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: This instructs hush to print commands before execution. |
| //config: Adds ~300 bytes. |
| //config: |
| //config:config HUSH_ECHO |
| //config: bool "echo builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_PRINTF |
| //config: bool "printf builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_TEST |
| //config: bool "test builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_HELP |
| //config: bool "help builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_EXPORT |
| //config: bool "export builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_EXPORT_N |
| //config: bool "Support 'export -n' option" |
| //config: default y |
| //config: depends on HUSH_EXPORT |
| //config: help |
| //config: export -n unexports variables. It is a bash extension. |
| //config: |
| //config:config HUSH_READONLY |
| //config: bool "readonly builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: help |
| //config: Enable support for read-only variables. |
| //config: |
| //config:config HUSH_KILL |
| //config: bool "kill builtin (supports kill %jobspec)" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_WAIT |
| //config: bool "wait builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_COMMAND |
| //config: bool "command builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_TRAP |
| //config: bool "trap builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_TYPE |
| //config: bool "type builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_TIMES |
| //config: bool "times builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_READ |
| //config: bool "read builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_SET |
| //config: bool "set builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_UNSET |
| //config: bool "unset builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_ULIMIT |
| //config: bool "ulimit builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_UMASK |
| //config: bool "umask builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_GETOPTS |
| //config: bool "getopts builtin" |
| //config: default y |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| //config: |
| //config:config HUSH_MEMLEAK |
| //config: bool "memleak builtin (debugging)" |
| //config: default n |
| //config: depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH |
| |
| //applet:IF_HUSH(APPLET(hush, BB_DIR_BIN, BB_SUID_DROP)) |
| // APPLET_ODDNAME:name main location suid_type help |
| //applet:IF_SH_IS_HUSH( APPLET_ODDNAME(sh, hush, BB_DIR_BIN, BB_SUID_DROP, hush)) |
| //applet:IF_BASH_IS_HUSH(APPLET_ODDNAME(bash, hush, BB_DIR_BIN, BB_SUID_DROP, hush)) |
| |
| //kbuild:lib-$(CONFIG_HUSH) += hush.o match.o shell_common.o |
| //kbuild:lib-$(CONFIG_SH_IS_HUSH) += hush.o match.o shell_common.o |
| //kbuild:lib-$(CONFIG_BASH_IS_HUSH) += hush.o match.o shell_common.o |
| //kbuild:lib-$(CONFIG_HUSH_RANDOM_SUPPORT) += random.o |
| |
| /* -i (interactive) is also accepted, |
| * but does nothing, therefore not shown in help. |
| * NOMMU-specific options are not meant to be used by users, |
| * therefore we don't show them either. |
| */ |
| //usage:#define hush_trivial_usage |
| //usage: "[-enxl] [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS] / -s [ARGS]]" |
| //usage:#define hush_full_usage "\n\n" |
| //usage: "Unix shell interpreter" |
| |
| #if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \ |
| || defined(__APPLE__) \ |
| ) |
| # include <malloc.h> /* for malloc_trim */ |
| #endif |
| #include <glob.h> |
| /* #include <dmalloc.h> */ |
| #if ENABLE_HUSH_CASE |
| # include <fnmatch.h> |
| #endif |
| #include <sys/times.h> |
| #include <sys/utsname.h> /* for setting $HOSTNAME */ |
| |
| #include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */ |
| #include "unicode.h" |
| #include "shell_common.h" |
| #include "math.h" |
| #include "match.h" |
| #if ENABLE_HUSH_RANDOM_SUPPORT |
| # include "random.h" |
| #else |
| # define CLEAR_RANDOM_T(rnd) ((void)0) |
| #endif |
| #ifndef O_CLOEXEC |
| # define O_CLOEXEC 0 |
| #endif |
| #ifndef F_DUPFD_CLOEXEC |
| # define F_DUPFD_CLOEXEC F_DUPFD |
| #endif |
| |
| #if ENABLE_FEATURE_SH_EMBEDDED_SCRIPTS && !(ENABLE_ASH || ENABLE_SH_IS_ASH || ENABLE_BASH_IS_ASH) |
| # include "embedded_scripts.h" |
| #else |
| # define NUM_SCRIPTS 0 |
| #endif |
| |
| /* So far, all bash compat is controlled by one config option */ |
| /* Separate defines document which part of code implements what */ |
| #define BASH_PATTERN_SUBST ENABLE_HUSH_BASH_COMPAT |
| #define BASH_SUBSTR ENABLE_HUSH_BASH_COMPAT |
| #define BASH_SOURCE ENABLE_HUSH_BASH_COMPAT |
| #define BASH_HOSTNAME_VAR ENABLE_HUSH_BASH_COMPAT |
| #define BASH_EPOCH_VARS ENABLE_HUSH_BASH_COMPAT |
| #define BASH_TEST2 (ENABLE_HUSH_BASH_COMPAT && ENABLE_HUSH_TEST) |
| #define BASH_READ_D ENABLE_HUSH_BASH_COMPAT |
| |
| |
| /* Build knobs */ |
| #define LEAK_HUNTING 0 |
| #define BUILD_AS_NOMMU 0 |
| /* Enable/disable sanity checks. Ok to enable in production, |
| * only adds a bit of bloat. Set to >1 to get non-production level verbosity. |
| * Keeping 1 for now even in released versions. |
| */ |
| #define HUSH_DEBUG 1 |
| /* Slightly bigger (+200 bytes), but faster hush. |
| * So far it only enables a trick with counting SIGCHLDs and forks, |
| * which allows us to do fewer waitpid's. |
| * (we can detect a case where neither forks were done nor SIGCHLDs happened |
| * and therefore waitpid will return the same result as last time) |
| */ |
| #define ENABLE_HUSH_FAST 0 |
| /* TODO: implement simplified code for users which do not need ${var%...} ops |
| * So far ${var%...} ops are always enabled: |
| */ |
| #define ENABLE_HUSH_DOLLAR_OPS 1 |
| |
| |
| #if BUILD_AS_NOMMU |
| # undef BB_MMU |
| # undef USE_FOR_NOMMU |
| # undef USE_FOR_MMU |
| # define BB_MMU 0 |
| # define USE_FOR_NOMMU(...) __VA_ARGS__ |
| # define USE_FOR_MMU(...) |
| #endif |
| |
| #include "NUM_APPLETS.h" |
| #if NUM_APPLETS == 1 |
| /* STANDALONE does not make sense, and won't compile */ |
| # undef CONFIG_FEATURE_SH_STANDALONE |
| # undef ENABLE_FEATURE_SH_STANDALONE |
| # undef IF_FEATURE_SH_STANDALONE |
| # undef IF_NOT_FEATURE_SH_STANDALONE |
| # define ENABLE_FEATURE_SH_STANDALONE 0 |
| # define IF_FEATURE_SH_STANDALONE(...) |
| # define IF_NOT_FEATURE_SH_STANDALONE(...) __VA_ARGS__ |
| #endif |
| |
| #if !ENABLE_HUSH_INTERACTIVE |
| # undef ENABLE_FEATURE_EDITING |
| # define ENABLE_FEATURE_EDITING 0 |
| # undef ENABLE_FEATURE_EDITING_FANCY_PROMPT |
| # define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0 |
| # undef ENABLE_FEATURE_EDITING_SAVE_ON_EXIT |
| # define ENABLE_FEATURE_EDITING_SAVE_ON_EXIT 0 |
| #endif |
| |
| /* Do we support ANY keywords? */ |
| #if ENABLE_HUSH_IF || ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE |
| # define HAS_KEYWORDS 1 |
| # define IF_HAS_KEYWORDS(...) __VA_ARGS__ |
| # define IF_HAS_NO_KEYWORDS(...) |
| #else |
| # define HAS_KEYWORDS 0 |
| # define IF_HAS_KEYWORDS(...) |
| # define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__ |
| #endif |
| |
| /* If you comment out one of these below, it will be #defined later |
| * to perform debug printfs to stderr: */ |
| #define debug_printf(...) do {} while (0) |
| /* Finer-grained debug switches */ |
| #define debug_printf_parse(...) do {} while (0) |
| #define debug_printf_heredoc(...) do {} while (0) |
| #define debug_print_tree(a, b) do {} while (0) |
| #define debug_printf_exec(...) do {} while (0) |
| #define debug_printf_env(...) do {} while (0) |
| #define debug_printf_jobs(...) do {} while (0) |
| #define debug_printf_expand(...) do {} while (0) |
| #define debug_printf_varexp(...) do {} while (0) |
| #define debug_printf_glob(...) do {} while (0) |
| #define debug_printf_redir(...) do {} while (0) |
| #define debug_printf_list(...) do {} while (0) |
| #define debug_printf_subst(...) do {} while (0) |
| #define debug_printf_prompt(...) do {} while (0) |
| #define debug_printf_clean(...) do {} while (0) |
| |
| #define ERR_PTR ((void*)(long)1) |
| |
| #define JOB_STATUS_FORMAT "[%u] %-22s %.40s\n" |
| |
| #define _SPECIAL_VARS_STR "_*@$!?#-" |
| #define SPECIAL_VARS_STR ("_*@$!?#-" + 1) |
| #define NUMERIC_SPECVARS_STR ("_*@$!?#-" + 3) |
| #if BASH_PATTERN_SUBST |
| /* Support / and // replace ops */ |
| /* Note that // is stored as \ in "encoded" string representation */ |
| # define VAR_ENCODED_SUBST_OPS "\\/%#:-=+?" |
| # define VAR_SUBST_OPS ("\\/%#:-=+?" + 1) |
| # define MINUS_PLUS_EQUAL_QUESTION ("\\/%#:-=+?" + 5) |
| #else |
| # define VAR_ENCODED_SUBST_OPS "%#:-=+?" |
| # define VAR_SUBST_OPS "%#:-=+?" |
| # define MINUS_PLUS_EQUAL_QUESTION ("%#:-=+?" + 3) |
| #endif |
| |
| #define SPECIAL_VAR_SYMBOL_STR "\3" |
| #define SPECIAL_VAR_SYMBOL 3 |
| /* The "variable" with name "\1" emits string "\3". Testcase: "echo ^C" */ |
| #define SPECIAL_VAR_QUOTED_SVS 1 |
| |
| struct variable; |
| |
| static const char hush_version_str[] ALIGN1 = "HUSH_VERSION="BB_VER; |
| |
| /* This supports saving pointers malloced in vfork child, |
| * to be freed in the parent. |
| */ |
| #if !BB_MMU |
| typedef struct nommu_save_t { |
| struct variable *old_vars; |
| char **argv; |
| char **argv_from_re_execing; |
| } nommu_save_t; |
| #endif |
| |
| enum { |
| RES_NONE = 0, |
| #if ENABLE_HUSH_IF |
| RES_IF , |
| RES_THEN , |
| RES_ELIF , |
| RES_ELSE , |
| RES_FI , |
| #endif |
| #if ENABLE_HUSH_LOOPS |
| RES_FOR , |
| RES_WHILE , |
| RES_UNTIL , |
| RES_DO , |
| RES_DONE , |
| #endif |
| #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE |
| RES_IN , |
| #endif |
| #if ENABLE_HUSH_CASE |
| RES_CASE , |
| /* three pseudo-keywords support contrived "case" syntax: */ |
| RES_CASE_IN, /* "case ... IN", turns into RES_MATCH when IN is observed */ |
| RES_MATCH , /* "word)" */ |
| RES_CASE_BODY, /* "this command is inside CASE" */ |
| RES_ESAC , |
| #endif |
| RES_XXXX , |
| RES_SNTX |
| }; |
| |
| typedef struct o_string { |
| char *data; |
| int length; /* position where data is appended */ |
| int maxlen; |
| int o_expflags; |
| /* At least some part of the string was inside '' or "", |
| * possibly empty one: word"", wo''rd etc. */ |
| smallint has_quoted_part; |
| smallint has_empty_slot; |
| smallint ended_in_ifs; |
| } o_string; |
| enum { |
| EXP_FLAG_SINGLEWORD = 0x80, /* must be 0x80 */ |
| EXP_FLAG_GLOB = 0x2, |
| /* Protect newly added chars against globbing |
| * by prepending \ to *, ?, [, \ */ |
| EXP_FLAG_ESC_GLOB_CHARS = 0x1, |
| }; |
| /* Used for initialization: o_string foo = NULL_O_STRING; */ |
| #define NULL_O_STRING { NULL } |
| |
| #ifndef debug_printf_parse |
| static const char *const assignment_flag[] = { |
| "MAYBE_ASSIGNMENT", |
| "DEFINITELY_ASSIGNMENT", |
| "NOT_ASSIGNMENT", |
| "WORD_IS_KEYWORD", |
| }; |
| #endif |
| |
| /* We almost can use standard FILE api, but we need an ability to move |
| * its fd when redirects coincide with it. No api exists for that |
| * (RFE for it at https://sourceware.org/bugzilla/show_bug.cgi?id=21902). |
| * HFILE is our internal alternative. Only supports reading. |
| * Since we now can, we incorporate linked list of all opened HFILEs |
| * into the struct (used to be a separate mini-list). |
| */ |
| typedef struct HFILE { |
| char *cur; |
| char *end; |
| struct HFILE *next_hfile; |
| int fd; |
| char buf[1024]; |
| } HFILE; |
| |
| typedef struct in_str { |
| const char *p; |
| int peek_buf[2]; |
| int last_char; |
| HFILE *file; |
| } in_str; |
| |
| /* The descrip member of this structure is only used to make |
| * debugging output pretty */ |
| static const struct { |
| int mode; |
| signed char default_fd; |
| char descrip[3]; |
| } redir_table[] = { |
| { O_RDONLY, 0, "<" }, |
| { O_CREAT|O_TRUNC|O_WRONLY, 1, ">" }, |
| { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" }, |
| { O_CREAT|O_RDWR, 1, "<>" }, |
| { O_RDONLY, 0, "<<" }, |
| /* Should not be needed. Bogus default_fd helps in debugging */ |
| /* { O_RDONLY, 77, "<<" }, */ |
| }; |
| |
| struct redir_struct { |
| struct redir_struct *next; |
| char *rd_filename; /* filename */ |
| int rd_fd; /* fd to redirect */ |
| /* fd to redirect to, or -3 if rd_fd is to be closed (n>&-) */ |
| int rd_dup; |
| smallint rd_type; /* (enum redir_type) */ |
| /* note: for heredocs, rd_filename contains heredoc delimiter, |
| * and subsequently heredoc itself; and rd_dup is a bitmask: |
| * bit 0: do we need to trim leading tabs? |
| * bit 1: is heredoc quoted (<<'delim' syntax) ? |
| */ |
| }; |
| typedef enum redir_type { |
| REDIRECT_INPUT = 0, |
| REDIRECT_OVERWRITE = 1, |
| REDIRECT_APPEND = 2, |
| REDIRECT_IO = 3, |
| REDIRECT_HEREDOC = 4, |
| REDIRECT_HEREDOC2 = 5, /* REDIRECT_HEREDOC after heredoc is loaded */ |
| |
| REDIRFD_CLOSE = -3, |
| REDIRFD_SYNTAX_ERR = -2, |
| REDIRFD_TO_FILE = -1, |
| /* otherwise, rd_fd is redirected to rd_dup */ |
| |
| HEREDOC_SKIPTABS = 1, |
| HEREDOC_QUOTED = 2, |
| } redir_type; |
| |
| |
| struct command { |
| pid_t pid; /* 0 if exited */ |
| unsigned assignment_cnt; /* how many argv[i] are assignments? */ |
| #if ENABLE_HUSH_LINENO_VAR |
| unsigned lineno; |
| #endif |
| smallint cmd_type; /* CMD_xxx */ |
| #define CMD_NORMAL 0 |
| #define CMD_SUBSHELL 1 |
| #if BASH_TEST2 || ENABLE_HUSH_LOCAL || ENABLE_HUSH_EXPORT || ENABLE_HUSH_READONLY |
| /* used for "[[ EXPR ]]", and to prevent word splitting and globbing in |
| * "export v=t*" |
| */ |
| # define CMD_SINGLEWORD_NOGLOB 2 |
| #endif |
| #if ENABLE_HUSH_FUNCTIONS |
| # define CMD_FUNCDEF 3 |
| #endif |
| |
| smalluint cmd_exitcode; |
| /* if non-NULL, this "command" is { list }, ( list ), or a compound statement */ |
| struct pipe *group; |
| #if !BB_MMU |
| char *group_as_string; |
| #endif |
| #if ENABLE_HUSH_FUNCTIONS |
| struct function *child_func; |
| /* This field is used to prevent a bug here: |
| * while...do f1() {a;}; f1; f1() {b;}; f1; done |
| * When we execute "f1() {a;}" cmd, we create new function and clear |
| * cmd->group, cmd->group_as_string, cmd->argv[0]. |
| * When we execute "f1() {b;}", we notice that f1 exists, |
| * and that its "parent cmd" struct is still "alive", |
| * we put those fields back into cmd->xxx |
| * (struct function has ->parent_cmd ptr to facilitate that). |
| * When we loop back, we can execute "f1() {a;}" again and set f1 correctly. |
| * Without this trick, loop would execute a;b;b;b;... |
| * instead of correct sequence a;b;a;b;... |
| * When command is freed, it severs the link |
| * (sets ->child_func->parent_cmd to NULL). |
| */ |
| #endif |
| char **argv; /* command name and arguments */ |
| /* argv vector may contain variable references (^Cvar^C, ^C0^C etc) |
| * and on execution these are substituted with their values. |
| * Substitution can make _several_ words out of one argv[n]! |
| * Example: argv[0]=='.^C*^C.' here: echo .$*. |
| * References of the form ^C`cmd arg^C are `cmd arg` substitutions. |
| */ |
| struct redir_struct *redirects; /* I/O redirections */ |
| }; |
| /* Is there anything in this command at all? */ |
| #define IS_NULL_CMD(cmd) \ |
| (!(cmd)->group && !(cmd)->argv && !(cmd)->redirects) |
| |
| struct pipe { |
| struct pipe *next; |
| int num_cmds; /* total number of commands in pipe */ |
| int alive_cmds; /* number of commands running (not exited) */ |
| int stopped_cmds; /* number of commands alive, but stopped */ |
| #if ENABLE_HUSH_JOB |
| unsigned jobid; /* job number */ |
| pid_t pgrp; /* process group ID for the job */ |
| char *cmdtext; /* name of job */ |
| #endif |
| struct command *cmds; /* array of commands in pipe */ |
| smallint followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */ |
| IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */ |
| IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */ |
| }; |
| typedef enum pipe_style { |
| PIPE_SEQ = 0, |
| PIPE_AND = 1, |
| PIPE_OR = 2, |
| PIPE_BG = 3, |
| } pipe_style; |
| /* Is there anything in this pipe at all? */ |
| #define IS_NULL_PIPE(pi) \ |
| ((pi)->num_cmds == 0 IF_HAS_KEYWORDS( && (pi)->res_word == RES_NONE)) |
| |
| /* This holds pointers to the various results of parsing */ |
| struct parse_context { |
| /* linked list of pipes */ |
| struct pipe *list_head; |
| /* last pipe (being constructed right now) */ |
| struct pipe *pipe; |
| /* last command in pipe (being constructed right now) */ |
| struct command *command; |
| /* last redirect in command->redirects list */ |
| struct redir_struct *pending_redirect; |
| o_string word; |
| #if !BB_MMU |
| o_string as_string; |
| #endif |
| smallint is_assignment; /* 0:maybe, 1:yes, 2:no, 3:keyword */ |
| #if HAS_KEYWORDS |
| smallint ctx_res_w; |
| smallint ctx_inverted; /* "! cmd | cmd" */ |
| #if ENABLE_HUSH_CASE |
| smallint ctx_dsemicolon; /* ";;" seen */ |
| #endif |
| /* bitmask of FLAG_xxx, for figuring out valid reserved words */ |
| int old_flag; |
| /* group we are enclosed in: |
| * example: "if pipe1; pipe2; then pipe3; fi" |
| * when we see "if" or "then", we malloc and copy current context, |
| * and make ->stack point to it. then we parse pipeN. |
| * when closing "then" / fi" / whatever is found, |
| * we move list_head into ->stack->command->group, |
| * copy ->stack into current context, and delete ->stack. |
| * (parsing of { list } and ( list ) doesn't use this method) |
| */ |
| struct parse_context *stack; |
| #endif |
| }; |
| enum { |
| MAYBE_ASSIGNMENT = 0, |
| DEFINITELY_ASSIGNMENT = 1, |
| NOT_ASSIGNMENT = 2, |
| /* Not an assignment, but next word may be: "if v=xyz cmd;" */ |
| WORD_IS_KEYWORD = 3, |
| }; |
| |
| /* On program start, environ points to initial environment. |
| * putenv adds new pointers into it, unsetenv removes them. |
| * Neither of these (de)allocates the strings. |
| * setenv allocates new strings in malloc space and does putenv, |
| * and thus setenv is unusable (leaky) for shell's purposes */ |
| #define setenv(...) setenv_is_leaky_dont_use() |
| struct variable { |
| struct variable *next; |
| char *varstr; /* points to "name=" portion */ |
| int max_len; /* if > 0, name is part of initial env; else name is malloced */ |
| uint16_t var_nest_level; |
| smallint flg_export; /* putenv should be done on this var */ |
| smallint flg_read_only; |
| }; |
| |
| enum { |
| BC_BREAK = 1, |
| BC_CONTINUE = 2, |
| }; |
| |
| #if ENABLE_HUSH_FUNCTIONS |
| struct function { |
| struct function *next; |
| char *name; |
| struct command *parent_cmd; |
| struct pipe *body; |
| # if !BB_MMU |
| char *body_as_string; |
| # endif |
| }; |
| #endif |
| |
| |
| /* set -/+o OPT support. (TODO: make it optional) |
| * bash supports the following opts: |
| * allexport off |
| * braceexpand on |
| * emacs on |
| * errexit off |
| * errtrace off |
| * functrace off |
| * hashall on |
| * histexpand off |
| * history on |
| * ignoreeof off |
| * interactive-comments on |
| * keyword off |
| * monitor on |
| * noclobber off |
| * noexec off |
| * noglob off |
| * nolog off |
| * notify off |
| * nounset off |
| * onecmd off |
| * physical off |
| * pipefail off |
| * posix off |
| * privileged off |
| * verbose off |
| * vi off |
| * xtrace off |
| */ |
| static const char o_opt_strings[] ALIGN1 = |
| "pipefail\0" |
| "noexec\0" |
| "errexit\0" |
| #if ENABLE_HUSH_MODE_X |
| "xtrace\0" |
| #endif |
| ; |
| enum { |
| OPT_O_PIPEFAIL, |
| OPT_O_NOEXEC, |
| OPT_O_ERREXIT, |
| #if ENABLE_HUSH_MODE_X |
| OPT_O_XTRACE, |
| #endif |
| NUM_OPT_O |
| }; |
| |
| /* "Globals" within this file */ |
| /* Sorted roughly by size (smaller offsets == smaller code) */ |
| struct globals { |
| /* interactive_fd != 0 means we are an interactive shell. |
| * If we are, then saved_tty_pgrp can also be != 0, meaning |
| * that controlling tty is available. With saved_tty_pgrp == 0, |
| * job control still works, but terminal signals |
| * (^C, ^Z, ^Y, ^\) won't work at all, and background |
| * process groups can only be created with "cmd &". |
| * With saved_tty_pgrp != 0, hush will use tcsetpgrp() |
| * to give tty to the foreground process group, |
| * and will take it back when the group is stopped (^Z) |
| * or killed (^C). |
| */ |
| #if ENABLE_HUSH_INTERACTIVE |
| /* 'interactive_fd' is a fd# open to ctty, if we have one |
| * _AND_ if we decided to act interactively */ |
| int interactive_fd; |
| IF_NOT_FEATURE_EDITING_FANCY_PROMPT(char *PS1;) |
| # define G_interactive_fd (G.interactive_fd) |
| #else |
| # define G_interactive_fd 0 |
| #endif |
| #if ENABLE_FEATURE_EDITING |
| line_input_t *line_input_state; |
| #endif |
| pid_t root_pid; |
| pid_t root_ppid; |
| pid_t last_bg_pid; |
| #if ENABLE_HUSH_RANDOM_SUPPORT |
| random_t random_gen; |
| #endif |
| #if ENABLE_HUSH_JOB |
| int run_list_level; |
| unsigned last_jobid; |
| pid_t saved_tty_pgrp; |
| struct pipe *job_list; |
| # define G_saved_tty_pgrp (G.saved_tty_pgrp) |
| #else |
| # define G_saved_tty_pgrp 0 |
| #endif |
| /* How deeply are we in context where "set -e" is ignored */ |
| int errexit_depth; |
| /* "set -e" rules (do we follow them correctly?): |
| * Exit if pipe, list, or compound command exits with a non-zero status. |
| * Shell does not exit if failed command is part of condition in |
| * if/while, part of && or || list except the last command, any command |
| * in a pipe but the last, or if the command's return value is being |
| * inverted with !. If a compound command other than a subshell returns a |
| * non-zero status because a command failed while -e was being ignored, the |
| * shell does not exit. A trap on ERR, if set, is executed before the shell |
| * exits [ERR is a bashism]. |
| * |
| * If a compound command or function executes in a context where -e is |
| * ignored, none of the commands executed within are affected by the -e |
| * setting. If a compound command or function sets -e while executing in a |
| * context where -e is ignored, that setting does not have any effect until |
| * the compound command or the command containing the function call completes. |
| */ |
| |
| char o_opt[NUM_OPT_O]; |
| #if ENABLE_HUSH_MODE_X |
| # define G_x_mode (G.o_opt[OPT_O_XTRACE]) |
| #else |
| # define G_x_mode 0 |
| #endif |
| char opt_s; |
| char opt_c; |
| #if ENABLE_HUSH_INTERACTIVE |
| smallint promptmode; /* 0: PS1, 1: PS2 */ |
| #endif |
| smallint flag_SIGINT; |
| #if ENABLE_HUSH_LOOPS |
| smallint flag_break_continue; |
| #endif |
| #if ENABLE_HUSH_FUNCTIONS |
| /* 0: outside of a function (or sourced file) |
| * -1: inside of a function, ok to use return builtin |
| * 1: return is invoked, skip all till end of func |
| */ |
| smallint flag_return_in_progress; |
| # define G_flag_return_in_progress (G.flag_return_in_progress) |
| #else |
| # define G_flag_return_in_progress 0 |
| #endif |
| smallint exiting; /* used to prevent EXIT trap recursion */ |
| /* These support $? */ |
| smalluint last_exitcode; |
| smalluint expand_exitcode; |
| smalluint last_bg_pid_exitcode; |
| #if ENABLE_HUSH_SET |
| /* are global_argv and global_argv[1..n] malloced? (note: not [0]) */ |
| smalluint global_args_malloced; |
| # define G_global_args_malloced (G.global_args_malloced) |
| #else |
| # define G_global_args_malloced 0 |
| #endif |
| #if ENABLE_HUSH_BASH_COMPAT |
| int dead_job_exitcode; /* for "wait -n" */ |
| #endif |
| /* how many non-NULL argv's we have. NB: $# + 1 */ |
| int global_argc; |
| char **global_argv; |
| #if !BB_MMU |
| char *argv0_for_re_execing; |
| #endif |
| #if ENABLE_HUSH_LOOPS |
| unsigned depth_break_continue; |
| unsigned depth_of_loop; |
| #endif |
| #if ENABLE_HUSH_GETOPTS |
| unsigned getopt_count; |
| #endif |
| const char *ifs; |
| char *ifs_whitespace; /* = G.ifs or malloced */ |
| const char *cwd; |
| struct variable *top_var; |
| char **expanded_assignments; |
| struct variable **shadowed_vars_pp; |
| unsigned var_nest_level; |
| #if ENABLE_HUSH_FUNCTIONS |
| # if ENABLE_HUSH_LOCAL |
| unsigned func_nest_level; /* solely to prevent "local v" in non-functions */ |
| # endif |
| struct function *top_func; |
| #endif |
| /* Signal and trap handling */ |
| #if ENABLE_HUSH_FAST |
| unsigned count_SIGCHLD; |
| unsigned handled_SIGCHLD; |
| smallint we_have_children; |
| #endif |
| #if ENABLE_HUSH_LINENO_VAR |
| unsigned parse_lineno; |
| unsigned execute_lineno; |
| #endif |
| HFILE *HFILE_list; |
| HFILE *HFILE_stdin; |
| /* Which signals have non-DFL handler (even with no traps set)? |
| * Set at the start to: |
| * (SIGQUIT + maybe SPECIAL_INTERACTIVE_SIGS + maybe SPECIAL_JOBSTOP_SIGS) |
| * SPECIAL_INTERACTIVE_SIGS are cleared after fork. |
| * The rest is cleared right before execv syscalls. |
| * Other than these two times, never modified. |
| */ |
| unsigned special_sig_mask; |
| #if ENABLE_HUSH_JOB |
| unsigned fatal_sig_mask; |
| # define G_fatal_sig_mask (G.fatal_sig_mask) |
| #else |
| # define G_fatal_sig_mask 0 |
| #endif |
| #if ENABLE_HUSH_TRAP |
| int pre_trap_exitcode; |
| # if ENABLE_HUSH_FUNCTIONS |
| int return_exitcode; |
| # endif |
| char **traps; /* char *traps[NSIG] */ |
| # define G_traps G.traps |
| #else |
| # define G_traps ((char**)NULL) |
| #endif |
| sigset_t pending_set; |
| #if ENABLE_HUSH_MEMLEAK |
| unsigned long memleak_value; |
| #endif |
| #if ENABLE_HUSH_MODE_X |
| unsigned x_mode_depth; |
| /* "set -x" output should not be redirectable with subsequent 2>FILE. |
| * We dup fd#2 to x_mode_fd when "set -x" is executed, and use it |
| * for all subsequent output. |
| */ |
| int x_mode_fd; |
| o_string x_mode_buf; |
| #endif |
| #if HUSH_DEBUG >= 2 |
| int debug_indent; |
| #endif |
| struct sigaction sa; |
| char optstring_buf[sizeof("eixcs")]; |
| #if BASH_EPOCH_VARS |
| char epoch_buf[sizeof("%lu.nnnnnn") + sizeof(long)*3]; |
| #endif |
| #if ENABLE_FEATURE_EDITING |
| char user_input_buf[CONFIG_FEATURE_EDITING_MAX_LEN]; |
| #endif |
| }; |
| #define G (*ptr_to_globals) |
| /* Not #defining name to G.name - this quickly gets unwieldy |
| * (too many defines). Also, I actually prefer to see when a variable |
| * is global, thus "G." prefix is a useful hint */ |
| #define INIT_G() do { \ |
| SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ |
| /* memset(&G.sa, 0, sizeof(G.sa)); */ \ |
| sigfillset(&G.sa.sa_mask); \ |
| G.sa.sa_flags = SA_RESTART; \ |
| } while (0) |
| |
| |
| /* Function prototypes for builtins */ |
| static int builtin_cd(char **argv) FAST_FUNC; |
| #if ENABLE_HUSH_ECHO |
| static int builtin_echo(char **argv) FAST_FUNC; |
| #endif |
| static int builtin_eval(char **argv) FAST_FUNC; |
| static int builtin_exec(char **argv) FAST_FUNC; |
| static int builtin_exit(char **argv) FAST_FUNC; |
| #if ENABLE_HUSH_EXPORT |
| static int builtin_export(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_READONLY |
| static int builtin_readonly(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_JOB |
| static int builtin_fg_bg(char **argv) FAST_FUNC; |
| static int builtin_jobs(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_GETOPTS |
| static int builtin_getopts(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_HELP |
| static int builtin_help(char **argv) FAST_FUNC; |
| #endif |
| #if MAX_HISTORY && ENABLE_FEATURE_EDITING |
| static int builtin_history(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_LOCAL |
| static int builtin_local(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_MEMLEAK |
| static int builtin_memleak(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_PRINTF |
| static int builtin_printf(char **argv) FAST_FUNC; |
| #endif |
| static int builtin_pwd(char **argv) FAST_FUNC; |
| #if ENABLE_HUSH_READ |
| static int builtin_read(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_SET |
| static int builtin_set(char **argv) FAST_FUNC; |
| #endif |
| static int builtin_shift(char **argv) FAST_FUNC; |
| static int builtin_source(char **argv) FAST_FUNC; |
| #if ENABLE_HUSH_TEST || BASH_TEST2 |
| static int builtin_test(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_TRAP |
| static int builtin_trap(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_TYPE |
| static int builtin_type(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_TIMES |
| static int builtin_times(char **argv) FAST_FUNC; |
| #endif |
| static int builtin_true(char **argv) FAST_FUNC; |
| #if ENABLE_HUSH_UMASK |
| static int builtin_umask(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_UNSET |
| static int builtin_unset(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_KILL |
| static int builtin_kill(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_WAIT |
| static int builtin_wait(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_LOOPS |
| static int builtin_break(char **argv) FAST_FUNC; |
| static int builtin_continue(char **argv) FAST_FUNC; |
| #endif |
| #if ENABLE_HUSH_FUNCTIONS |
| static int builtin_return(char **argv) FAST_FUNC; |
| #endif |
| |
| /* Table of built-in functions. They can be forked or not, depending on |
| * context: within pipes, they fork. As simple commands, they do not. |
| * When used in non-forking context, they can change global variables |
| * in the parent shell process. If forked, of course they cannot. |
| * For example, 'unset foo | whatever' will parse and run, but foo will |
| * still be set at the end. */ |
| struct built_in_command { |
| const char *b_cmd; |
| int (*b_function)(char **argv) FAST_FUNC; |
| #if ENABLE_HUSH_HELP |
| const char *b_descr; |
| # define BLTIN(cmd, func, help) { cmd, func, help } |
| #else |
| # define BLTIN(cmd, func, help) { cmd, func } |
| #endif |
| }; |
| |
| static const struct built_in_command bltins1[] = { |
| BLTIN("." , builtin_source , "Run commands in file"), |
| BLTIN(":" , builtin_true , NULL), |
| #if ENABLE_HUSH_JOB |
| BLTIN("bg" , builtin_fg_bg , "Resume job in background"), |
| #endif |
| #if ENABLE_HUSH_LOOPS |
| BLTIN("break" , builtin_break , "Exit loop"), |
| #endif |
| BLTIN("cd" , builtin_cd , "Change directory"), |
| #if ENABLE_HUSH_LOOPS |
| BLTIN("continue" , builtin_continue, "Start new loop iteration"), |
| #endif |
| BLTIN("eval" , builtin_eval , "Construct and run shell command"), |
| BLTIN("exec" , builtin_exec , "Execute command, don't return to shell"), |
| BLTIN("exit" , builtin_exit , NULL), |
| #if ENABLE_HUSH_EXPORT |
| BLTIN("export" , builtin_export , "Set environment variables"), |
| #endif |
| #if ENABLE_HUSH_JOB |
| BLTIN("fg" , builtin_fg_bg , "Bring job to foreground"), |
| #endif |
| #if ENABLE_HUSH_GETOPTS |
| BLTIN("getopts" , builtin_getopts , NULL), |
| #endif |
| #if ENABLE_HUSH_HELP |
| BLTIN("help" , builtin_help , NULL), |
| #endif |
| #if MAX_HISTORY && ENABLE_FEATURE_EDITING |
| BLTIN("history" , builtin_history , "Show history"), |
| #endif |
| #if ENABLE_HUSH_JOB |
| BLTIN("jobs" , builtin_jobs , "List jobs"), |
| #endif |
| #if ENABLE_HUSH_KILL |
| BLTIN("kill" , builtin_kill , "Send signals to processes"), |
| #endif |
| #if ENABLE_HUSH_LOCAL |
| BLTIN("local" , builtin_local , "Set local variables"), |
| #endif |
| #if ENABLE_HUSH_MEMLEAK |
| BLTIN("memleak" , builtin_memleak , NULL), |
| #endif |
| #if ENABLE_HUSH_READ |
| BLTIN("read" , builtin_read , "Input into variable"), |
| #endif |
| #if ENABLE_HUSH_READONLY |
| BLTIN("readonly" , builtin_readonly, "Make variables read-only"), |
| #endif |
| #if ENABLE_HUSH_FUNCTIONS |
| BLTIN("return" , builtin_return , "Return from function"), |
| #endif |
| #if ENABLE_HUSH_SET |
| BLTIN("set" , builtin_set , "Set positional parameters"), |
| #endif |
| BLTIN("shift" , builtin_shift , "Shift positional parameters"), |
| #if BASH_SOURCE |
| BLTIN("source" , builtin_source , NULL), |
| #endif |
| #if ENABLE_HUSH_TIMES |
| BLTIN("times" , builtin_times , NULL), |
| #endif |
| #if ENABLE_HUSH_TRAP |
| BLTIN("trap" , builtin_trap , "Trap signals"), |
| #endif |
| BLTIN("true" , builtin_true , NULL), |
| #if ENABLE_HUSH_TYPE |
| BLTIN("type" , builtin_type , "Show command type"), |
| #endif |
| #if ENABLE_HUSH_ULIMIT |
| BLTIN("ulimit" , shell_builtin_ulimit, "Control resource limits"), |
| #endif |
| #if ENABLE_HUSH_UMASK |
| BLTIN("umask" , builtin_umask , "Set file creation mask"), |
| #endif |
| #if ENABLE_HUSH_UNSET |
| BLTIN("unset" , builtin_unset , "Unset variables"), |
| #endif |
| #if ENABLE_HUSH_WAIT |
| BLTIN("wait" , builtin_wait , "Wait for process to finish"), |
| #endif |
| }; |
| /* These builtins won't be used if we are on NOMMU and need to re-exec |
| * (it's cheaper to run an external program in this case): |
| */ |
| static const struct built_in_command bltins2[] = { |
| #if ENABLE_HUSH_TEST |
| BLTIN("[" , builtin_test , NULL), |
| #endif |
| #if BASH_TEST2 |
| BLTIN("[[" , builtin_test , NULL), |
| #endif |
| #if ENABLE_HUSH_ECHO |
| BLTIN("echo" , builtin_echo , NULL), |
| #endif |
| #if ENABLE_HUSH_PRINTF |
| BLTIN("printf" , builtin_printf , NULL), |
| #endif |
| BLTIN("pwd" , builtin_pwd , NULL), |
| #if ENABLE_HUSH_TEST |
| BLTIN("test" , builtin_test , NULL), |
| #endif |
| }; |
| |
| |
| /* Debug printouts. |
| */ |
| #if HUSH_DEBUG >= 2 |
| /* prevent disasters with G.debug_indent < 0 */ |
| # define indent() fdprintf(2, "%*s", (G.debug_indent * 2) & 0xff, "") |
| # define debug_enter() (G.debug_indent++) |
| # define debug_leave() (G.debug_indent--) |
| #else |
| # define indent() ((void)0) |
| # define debug_enter() ((void)0) |
| # define debug_leave() ((void)0) |
| #endif |
| |
| #ifndef debug_printf |
| # define debug_printf(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_parse |
| # define debug_printf_parse(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_heredoc |
| # define debug_printf_heredoc(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_exec |
| #define debug_printf_exec(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_env |
| # define debug_printf_env(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_jobs |
| # define debug_printf_jobs(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| # define DEBUG_JOBS 1 |
| #else |
| # define DEBUG_JOBS 0 |
| #endif |
| |
| #ifndef debug_printf_expand |
| # define debug_printf_expand(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| # define DEBUG_EXPAND 1 |
| #else |
| # define DEBUG_EXPAND 0 |
| #endif |
| |
| #ifndef debug_printf_varexp |
| # define debug_printf_varexp(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_glob |
| # define debug_printf_glob(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| # define DEBUG_GLOB 1 |
| #else |
| # define DEBUG_GLOB 0 |
| #endif |
| |
| #ifndef debug_printf_redir |
| # define debug_printf_redir(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_list |
| # define debug_printf_list(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_subst |
| # define debug_printf_subst(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_prompt |
| # define debug_printf_prompt(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| #endif |
| |
| #ifndef debug_printf_clean |
| # define debug_printf_clean(...) (indent(), fdprintf(2, __VA_ARGS__)) |
| # define DEBUG_CLEAN 1 |
| #else |
| # define DEBUG_CLEAN 0 |
| #endif |
| |
| #if DEBUG_EXPAND |
| static void debug_print_strings(const char *prefix, char **vv) |
| { |
| indent(); |
| fdprintf(2, "%s:\n", prefix); |
| while (*vv) |
| fdprintf(2, " '%s'\n", *vv++); |
| } |
| #else |
| # define debug_print_strings(prefix, vv) ((void)0) |
| #endif |
| |
| |
| /* Leak hunting. Use hush_leaktool.sh for post-processing. |
| */ |
| #if LEAK_HUNTING |
| static void *xxmalloc(int lineno, size_t size) |
| { |
| void *ptr = xmalloc((size + 0xff) & ~0xff); |
| fdprintf(2, "line %d: malloc %p\n", lineno, ptr); |
| return ptr; |
| } |
| static void *xxrealloc(int lineno, void *ptr, size_t size) |
| { |
| ptr = xrealloc(ptr, (size + 0xff) & ~0xff); |
| fdprintf(2, "line %d: realloc %p\n", lineno, ptr); |
| return ptr; |
| } |
| static char *xxstrdup(int lineno, const char *str) |
| { |
| char *ptr = xstrdup(str); |
| fdprintf(2, "line %d: strdup %p\n", lineno, ptr); |
| return ptr; |
| } |
| static void xxfree(void *ptr) |
| { |
| fdprintf(2, "free %p\n", ptr); |
| free(ptr); |
| } |
| # define xmalloc(s) xxmalloc(__LINE__, s) |
| # define xrealloc(p, s) xxrealloc(__LINE__, p, s) |
| # define xstrdup(s) xxstrdup(__LINE__, s) |
| # define free(p) xxfree(p) |
| #endif |
| |
| |
| /* Syntax and runtime errors. They always abort scripts. |
| * In interactive use they usually discard unparsed and/or unexecuted commands |
| * and return to the prompt. |
| * HUSH_DEBUG >= 2 prints line number in this file where it was detected. |
| */ |
| #if HUSH_DEBUG < 2 |
| # define msg_and_die_if_script(lineno, ...) msg_and_die_if_script(__VA_ARGS__) |
| # define syntax_error(lineno, msg) syntax_error(msg) |
| # define syntax_error_at(lineno, msg) syntax_error_at(msg) |
| # define syntax_error_unterm_ch(lineno, ch) syntax_error_unterm_ch(ch) |
| # define syntax_error_unterm_str(lineno, s) syntax_error_unterm_str(s) |
| # define syntax_error_unexpected_ch(lineno, ch) syntax_error_unexpected_ch(ch) |
| #endif |
| |
| static void die_if_script(void) |
| { |
| if (!G_interactive_fd) { |
| if (G.last_exitcode) /* sometines it's 2, not 1 (bash compat) */ |
| xfunc_error_retval = G.last_exitcode; |
| xfunc_die(); |
| } |
| } |
| |
| static void msg_and_die_if_script(unsigned lineno, const char *fmt, ...) |
| { |
| va_list p; |
| |
| #if HUSH_DEBUG >= 2 |
| bb_error_msg("hush.c:%u", lineno); |
| #endif |
| va_start(p, fmt); |
| bb_verror_msg(fmt, p, NULL); |
| va_end(p); |
| die_if_script(); |
| } |
| |
| static void syntax_error(unsigned lineno UNUSED_PARAM, const char *msg) |
| { |
| if (msg) |
| bb_error_msg("syntax error: %s", msg); |
| else |
| bb_simple_error_msg("syntax error"); |
| die_if_script(); |
| } |
| |
| static void syntax_error_at(unsigned lineno UNUSED_PARAM, const char *msg) |
| { |
| bb_error_msg("syntax error at '%s'", msg); |
| die_if_script(); |
| } |
| |
| static void syntax_error_unterm_str(unsigned lineno UNUSED_PARAM, const char *s) |
| { |
| bb_error_msg("syntax error: unterminated %s", s); |
| //? source4.tests fails: in bash, echo ${^} in script does not terminate the script |
| // die_if_script(); |
| } |
| |
| static void syntax_error_unterm_ch(unsigned lineno, char ch) |
| { |
| char msg[2] = { ch, '\0' }; |
| syntax_error_unterm_str(lineno, msg); |
| } |
| |
| static void syntax_error_unexpected_ch(unsigned lineno UNUSED_PARAM, int ch) |
| { |
| char msg[2]; |
| msg[0] = ch; |
| msg[1] = '\0'; |
| #if HUSH_DEBUG >= 2 |
| bb_error_msg("hush.c:%u", lineno); |
| #endif |
| bb_error_msg("syntax error: unexpected %s", ch == EOF ? "EOF" : msg); |
| die_if_script(); |
| } |
| |
| #if HUSH_DEBUG < 2 |
| # undef msg_and_die_if_script |
| # undef syntax_error |
| # undef syntax_error_at |
| # undef syntax_error_unterm_ch |
| # undef syntax_error_unterm_str |
| # undef syntax_error_unexpected_ch |
| #else |
| # define msg_and_die_if_script(...) msg_and_die_if_script(__LINE__, __VA_ARGS__) |
| # define syntax_error(msg) syntax_error(__LINE__, msg) |
| # define syntax_error_at(msg) syntax_error_at(__LINE__, msg) |
| # define syntax_error_unterm_ch(ch) syntax_error_unterm_ch(__LINE__, ch) |
| # define syntax_error_unterm_str(s) syntax_error_unterm_str(__LINE__, s) |
| # define syntax_error_unexpected_ch(ch) syntax_error_unexpected_ch(__LINE__, ch) |
| #endif |
| |
| |
| /* Utility functions |
| */ |
| /* Replace each \x with x in place, return ptr past NUL. */ |
| static char *unbackslash(char *src) |
| { |
| char *dst = src = strchrnul(src, '\\'); |
| while (1) { |
| if (*src == '\\') { |
| src++; |
| if (*src != '\0') { |
| /* \x -> x */ |
| *dst++ = *src++; |
| continue; |
| } |
| /* else: "\<nul>". Do not delete this backslash. |
| * Testcase: eval 'echo ok\' |
| */ |
| *dst++ = '\\'; |
| /* fallthrough */ |
| } |
| if ((*dst++ = *src++) == '\0') |
| break; |
| } |
| return dst; |
| } |
| |
| static char **add_strings_to_strings(char **strings, char **add, int need_to_dup) |
| { |
| int i; |
| unsigned count1; |
| unsigned count2; |
| char **v; |
| |
| v = strings; |
| count1 = 0; |
| if (v) { |
| while (*v) { |
| count1++; |
| v++; |
| } |
| } |
| count2 = 0; |
| v = add; |
| while (*v) { |
| count2++; |
| v++; |
| } |
| v = xrealloc(strings, (count1 + count2 + 1) * sizeof(char*)); |
| v[count1 + count2] = NULL; |
| i = count2; |
| while (--i >= 0) |
| v[count1 + i] = (need_to_dup ? xstrdup(add[i]) : add[i]); |
| return v; |
| } |
| #if LEAK_HUNTING |
| static char **xx_add_strings_to_strings(int lineno, char **strings, char **add, int need_to_dup) |
| { |
| char **ptr = add_strings_to_strings(strings, add, need_to_dup); |
| fdprintf(2, "line %d: add_strings_to_strings %p\n", lineno, ptr); |
| return ptr; |
| } |
| #define add_strings_to_strings(strings, add, need_to_dup) \ |
| xx_add_strings_to_strings(__LINE__, strings, add, need_to_dup) |
| #endif |
| |
| /* Note: takes ownership of "add" ptr (it is not strdup'ed) */ |
| static char **add_string_to_strings(char **strings, char *add) |
| { |
| char *v[2]; |
| v[0] = add; |
| v[1] = NULL; |
| return add_strings_to_strings(strings, v, /*dup:*/ 0); |
| } |
| #if LEAK_HUNTING |
| static char **xx_add_string_to_strings(int lineno, char **strings, char *add) |
| { |
| char **ptr = add_string_to_strings(strings, add); |
| fdprintf(2, "line %d: add_string_to_strings %p\n", lineno, ptr); |
| return ptr; |
| } |
| #define add_string_to_strings(strings, add) \ |
| xx_add_string_to_strings(__LINE__, strings, add) |
| #endif |
| |
| static void free_strings(char **strings) |
| { |
| char **v; |
| |
| if (!strings) |
| return; |
| v = strings; |
| while (*v) { |
| free(*v); |
| v++; |
| } |
| free(strings); |
| } |
| |
| static int dup_CLOEXEC(int fd, int avoid_fd) |
| { |
| int newfd; |
| repeat: |
| newfd = fcntl(fd, F_DUPFD_CLOEXEC, avoid_fd + 1); |
| if (newfd >= 0) { |
| if (F_DUPFD_CLOEXEC == F_DUPFD) /* if old libc (w/o F_DUPFD_CLOEXEC) */ |
| fcntl(newfd, F_SETFD, FD_CLOEXEC); |
| } else { /* newfd < 0 */ |
| if (errno == EBUSY) |
| goto repeat; |
| if (errno == EINTR) |
| goto repeat; |
| } |
| return newfd; |
| } |
| |
| static int xdup_CLOEXEC_and_close(int fd, int avoid_fd) |
| { |
| int newfd; |
| repeat: |
| newfd = fcntl(fd, F_DUPFD_CLOEXEC, avoid_fd + 1); |
| if (newfd < 0) { |
| if (errno == EBUSY) |
| goto repeat; |
| if (errno == EINTR) |
| goto repeat; |
| /* fd was not open? */ |
| if (errno == EBADF) |
| return fd; |
| xfunc_die(); |
| } |
| if (F_DUPFD_CLOEXEC == F_DUPFD) /* if old libc (w/o F_DUPFD_CLOEXEC) */ |
| fcntl(newfd, F_SETFD, FD_CLOEXEC); |
| close(fd); |
| return newfd; |
| } |
| |
| |
| /* Manipulating HFILEs */ |
| static HFILE *hfopen(const char *name) |
| { |
| HFILE *fp; |
| int fd; |
| |
| fd = STDIN_FILENO; |
| if (name) { |
| fd = open(name, O_RDONLY | O_CLOEXEC); |
| if (fd < 0) |
| return NULL; |
| if (O_CLOEXEC == 0) /* ancient libc */ |
| close_on_exec_on(fd); |
| } |
| |
| fp = xmalloc(sizeof(*fp)); |
| if (name == NULL) |
| G.HFILE_stdin = fp; |
| fp->fd = fd; |
| fp->cur = fp->end = fp->buf; |
| fp->next_hfile = G.HFILE_list; |
| G.HFILE_list = fp; |
| return fp; |
| } |
| static void hfclose(HFILE *fp) |
| { |
| HFILE **pp = &G.HFILE_list; |
| while (*pp) { |
| HFILE *cur = *pp; |
| if (cur == fp) { |
| *pp = cur->next_hfile; |
| break; |
| } |
| pp = &cur->next_hfile; |
| } |
| if (fp->fd >= 0) |
| close(fp->fd); |
| free(fp); |
| } |
| static int refill_HFILE_and_getc(HFILE *fp) |
| { |
| int n; |
| |
| if (fp->fd < 0) { |
| /* Already saw EOF */ |
| return EOF; |
| } |
| /* Try to buffer more input */ |
| fp->cur = fp->buf; |
| n = safe_read(fp->fd, fp->buf, sizeof(fp->buf)); |
| if (n < 0) { |
| bb_simple_perror_msg("read error"); |
| n = 0; |
| } |
| fp->end = fp->buf + n; |
| if (n == 0) { |
| /* EOF/error */ |
| close(fp->fd); |
| fp->fd = -1; |
| return EOF; |
| } |
| return (unsigned char)(*fp->cur++); |
| } |
| /* Inlined for common case of non-empty buffer. |
| */ |
| static ALWAYS_INLINE int hfgetc(HFILE *fp) |
| { |
| if (fp->cur < fp->end) |
| return (unsigned char)(*fp->cur++); |
| /* Buffer empty */ |
| return refill_HFILE_and_getc(fp); |
| } |
| static int move_HFILEs_on_redirect(int fd, int avoid_fd) |
| { |
| HFILE *fl = G.HFILE_list; |
| while (fl) { |
| if (fd == fl->fd) { |
| /* We use it only on script files, they are all CLOEXEC */ |
| fl->fd = xdup_CLOEXEC_and_close(fd, avoid_fd); |
| debug_printf_redir("redirect_fd %d: matches a script fd, moving it to %d\n", fd, fl->fd); |
| return 1; /* "found and moved" */ |
| } |
| fl = fl->next_hfile; |
| } |
| #if ENABLE_HUSH_MODE_X |
| if (G.x_mode_fd > 0 && fd == G.x_mode_fd) { |
| G.x_mode_fd = xdup_CLOEXEC_and_close(fd, avoid_fd); |
| return 1; /* "found and moved" */ |
| } |
| #endif |
| return 0; /* "not in the list" */ |
| } |
| #if ENABLE_FEATURE_SH_STANDALONE && BB_MMU |
| static void close_all_HFILE_list(void) |
| { |
| HFILE *fl = G.HFILE_list; |
| while (fl) { |
| /* hfclose would also free HFILE object. |
| * It is disastrous if we share memory with a vforked parent. |
| * I'm not sure we never come here after vfork. |
| * Therefore just close fd, nothing more. |
| * |
| * ">" instead of ">=": we don't close fd#0, |
| * interactive shell uses hfopen(NULL) as stdin input |
| * which has fl->fd == 0, but fd#0 gets redirected in pipes. |
| * If we'd close it here, then e.g. interactive "set | sort" |
| * with NOFORKed sort, would have sort's input fd closed. |
| */ |
| if (fl->fd > 0) |
| /*hfclose(fl); - unsafe */ |
| close(fl->fd); |
| fl = fl->next_hfile; |
| } |
| } |
| #endif |
| static int fd_in_HFILEs(int fd) |
| { |
| HFILE *fl = G.HFILE_list; |
| while (fl) { |
| if (fl->fd == fd) |
| return 1; |
| fl = fl->next_hfile; |
| } |
| return 0; |
| } |
| |
| |
| /* Helpers for setting new $n and restoring them back |
| */ |
| typedef struct save_arg_t { |
| char *sv_argv0; |
| char **sv_g_argv; |
| int sv_g_argc; |
| IF_HUSH_SET(smallint sv_g_malloced;) |
| } save_arg_t; |
| |
| static void save_and_replace_G_args(save_arg_t *sv, char **argv) |
| { |
| sv->sv_argv0 = argv[0]; |
| sv->sv_g_argv = G.global_argv; |
| sv->sv_g_argc = G.global_argc; |
| IF_HUSH_SET(sv->sv_g_malloced = G.global_args_malloced;) |
| |
| argv[0] = G.global_argv[0]; /* retain $0 */ |
| G.global_argv = argv; |
| IF_HUSH_SET(G.global_args_malloced = 0;) |
| |
| G.global_argc = 1 + string_array_len(argv + 1); |
| } |
| |
| static void restore_G_args(save_arg_t *sv, char **argv) |
| { |
| #if ENABLE_HUSH_SET |
| if (G.global_args_malloced) { |
| /* someone ran "set -- arg1 arg2 ...", undo */ |
| char **pp = G.global_argv; |
| while (*++pp) /* note: does not free $0 */ |
| free(*pp); |
| free(G.global_argv); |
| } |
| #endif |
| argv[0] = sv->sv_argv0; |
| G.global_argv = sv->sv_g_argv; |
| G.global_argc = sv->sv_g_argc; |
| IF_HUSH_SET(G.global_args_malloced = sv->sv_g_malloced;) |
| } |
| |
| |
| /* Basic theory of signal handling in shell |
| * ======================================== |
| * This does not describe what hush does, rather, it is current understanding |
| * what it _should_ do. If it doesn't, it's a bug. |
| * http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap |
| * |
| * Signals are handled only after each pipe ("cmd | cmd | cmd" thing) |
| * is finished or backgrounded. It is the same in interactive and |
| * non-interactive shells, and is the same regardless of whether |
| * a user trap handler is installed or a shell special one is in effect. |
| * ^C or ^Z from keyboard seems to execute "at once" because it usually |
| * backgrounds (i.e. stops) or kills all members of currently running |
| * pipe. |
| * |
| * Wait builtin is interruptible by signals for which user trap is set |
| * or by SIGINT in interactive shell. |
| * |
| * Trap handlers will execute even within trap handlers. (right?) |
| * |
| * User trap handlers are forgotten when subshell ("(cmd)") is entered, |
| * except for handlers set to '' (empty string). |
| * |
| * If job control is off, backgrounded commands ("cmd &") |
| * have SIGINT, SIGQUIT set to SIG_IGN. |
| * |
| * Commands which are run in command substitution ("`cmd`") |
| * have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN. |
| * |
| * Ordinary commands have signals set to SIG_IGN/DFL as inherited |
| * by the shell from its parent. |
| * |
| * Signals which differ from SIG_DFL action |
| * (note: child (i.e., [v]forked) shell is not an interactive shell): |
| * |
| * SIGQUIT: ignore |
| * SIGTERM (interactive): ignore |
| * SIGHUP (interactive): |
| * send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit |
| * SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore |
| * Note that ^Z is handled not by trapping SIGTSTP, but by seeing |
| * that all pipe members are stopped. Try this in bash: |
| * while :; do :; done - ^Z does not background it |
| * (while :; do :; done) - ^Z backgrounds it |
| * SIGINT (interactive): wait for last pipe, ignore the rest |
| * of the command line, show prompt. NB: ^C does not send SIGINT |
| * to interactive shell while shell is waiting for a pipe, |
| * since shell is bg'ed (is not in foreground process group). |
| * Example 1: this waits 5 sec, but does not execute ls: |
| * "echo $$; sleep 5; ls -l" + "kill -INT <pid>" |
| * Example 2: this does not wait and does not execute ls: |
| * "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>" |
| * Example 3: this does not wait 5 sec, but executes ls: |
| * "sleep 5; ls -l" + press ^C |
| * Example 4: this does not wait and does not execute ls: |
| * "sleep 5 & wait; ls -l" + press ^C |
| * |
| * (What happens to signals which are IGN on shell start?) |
| * (What happens with signal mask on shell start?) |
| * |
| * Old implementation |
| * ================== |
| * We use in-kernel pending signal mask to determine which signals were sent. |
| * We block all signals which we don't want to take action immediately, |
| * i.e. we block all signals which need to have special handling as described |
| * above, and all signals which have traps set. |
| * After each pipe execution, we extract any pending signals via sigtimedwait() |
| * and act on them. |
| * |
| * unsigned special_sig_mask: a mask of such "special" signals |
| * sigset_t blocked_set: current blocked signal set |
| * |
| * "trap - SIGxxx": |
| * clear bit in blocked_set unless it is also in special_sig_mask |
| * "trap 'cmd' SIGxxx": |
| * set bit in blocked_set (even if 'cmd' is '') |
| * after [v]fork, if we plan to be a shell: |
| * unblock signals with special interactive handling |
| * (child shell is not interactive), |
| * unset all traps except '' (note: regardless of child shell's type - {}, (), etc) |
| * after [v]fork, if we plan to exec: |
| * POSIX says fork clears pending signal mask in child - no need to clear it. |
| * Restore blocked signal set to one inherited by shell just prior to exec. |
| * |
| * Note: as a result, we do not use signal handlers much. The only uses |
| * are to count SIGCHLDs |
| * and to restore tty pgrp on signal-induced exit. |
| * |
| * Note 2 (compat): |
| * Standard says "When a subshell is entered, traps that are not being ignored |
| * are set to the default actions". bash interprets it so that traps which |
| * are set to '' (ignore) are NOT reset to defaults. We do the same. |
| * |
| * Problem: the above approach makes it unwieldy to catch signals while |
| * we are in read builtin, or while we read commands from stdin: |
| * masked signals are not visible! |
| * |
| * New implementation |
| * ================== |
| * We record each signal we are interested in by installing signal handler |
| * for them - a bit like emulating kernel pending signal mask in userspace. |
| * We are interested in: signals which need to have special handling |
| * as described above, and all signals which have traps set. |
| * Signals are recorded in pending_set. |
| * After each pipe execution, we extract any pending signals |
| * and act on them. |
| * |
| * unsigned special_sig_mask: a mask of shell-special signals. |
| * unsigned fatal_sig_mask: a mask of signals on which we restore tty pgrp. |
| * char *traps[sig] if trap for sig is set (even if it's ''). |
| * sigset_t pending_set: set of sigs we received. |
| * |
| * "trap - SIGxxx": |
| * if sig is in special_sig_mask, set handler back to: |
| * record_pending_signo, or to IGN if it's a tty stop signal |
| * if sig is in fatal_sig_mask, set handler back to sigexit. |
| * else: set handler back to SIG_DFL |
| * "trap 'cmd' SIGxxx": |
| * set handler to record_pending_signo. |
| * "trap '' SIGxxx": |
| * set handler to SIG_IGN. |
| * after [v]fork, if we plan to be a shell: |
| * set signals with special interactive handling to SIG_DFL |
| * (because child shell is not interactive), |
| * unset all traps except '' (note: regardless of child shell's type - {}, (), etc) |
| * after [v]fork, if we plan to exec: |
| * POSIX says fork clears pending signal mask in child - no need to clear it. |
| * |
| * To make wait builtin interruptible, we handle SIGCHLD as special signal, |
| * otherwise (if we leave it SIG_DFL) sigsuspend in wait builtin will not wake up on it. |
| * |
| * Note (compat): |
| * Standard says "When a subshell is entered, traps that are not being ignored |
| * are set to the default actions". bash interprets it so that traps which |
| * are set to '' (ignore) are NOT reset to defaults. We do the same. |
| */ |
| enum { |
| SPECIAL_INTERACTIVE_SIGS = 0 |
| | (1 << SIGTERM) |
| | (1 << SIGINT) |
| | (1 << SIGHUP) |
| , |
| SPECIAL_JOBSTOP_SIGS = 0 |
| #if ENABLE_HUSH_JOB |
| | (1 << SIGTTIN) |
| | (1 << SIGTTOU) |
| | (1 << SIGTSTP) |
| #endif |
| , |
| }; |
| |
| static void record_pending_signo(int sig) |
| { |
| sigaddset(&G.pending_set, sig); |
| #if ENABLE_HUSH_FAST |
| if (sig == SIGCHLD) { |
| G.count_SIGCHLD++; |
| //bb_error_msg("[%d] SIGCHLD_handler: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD); |
| } |
| #endif |
| } |
| |
| static sighandler_t install_sighandler(int sig, sighandler_t handler) |
| { |
| struct sigaction old_sa; |
| |
| /* We could use signal() to install handlers... almost: |
| * except that we need to mask ALL signals while handlers run. |
| * I saw signal nesting in strace, race window isn't small. |
| * SA_RESTART is also needed, but in Linux, signal() |
| * sets SA_RESTART too. |
| */ |
| /* memset(&G.sa, 0, sizeof(G.sa)); - already done */ |
| /* sigfillset(&G.sa.sa_mask); - already done */ |
| /* G.sa.sa_flags = SA_RESTART; - already done */ |
| G.sa.sa_handler = handler; |
| sigaction(sig, &G.sa, &old_sa); |
| return old_sa.sa_handler; |
| } |
| |
| static void hush_exit(int exitcode) NORETURN; |
| |
| static void restore_ttypgrp_and__exit(void) NORETURN; |
| static void restore_ttypgrp_and__exit(void) |
| { |
| /* xfunc has failed! die die die */ |
| /* no EXIT traps, this is an escape hatch! */ |
| G.exiting = 1; |
| hush_exit(xfunc_error_retval); |
| } |
| |
| #if ENABLE_HUSH_JOB |
| |
| /* Needed only on some libc: |
| * It was observed that on exit(), fgetc'ed buffered data |
| * gets "unwound" via lseek(fd, -NUM, SEEK_CUR). |
| * With the net effect that even after fork(), not vfork(), |
| * exit() in NOEXECed applet in "sh SCRIPT": |
| * noexec_applet_here |
| * echo END_OF_SCRIPT |
| * lseeks fd in input FILE object from EOF to "e" in "echo END_OF_SCRIPT". |
| * This makes "echo END_OF_SCRIPT" executed twice. |
| * Similar problems can be seen with msg_and_die_if_script() -> xfunc_die() |
| * and in `cmd` handling. |
| * If set as die_func(), this makes xfunc_die() exit via _exit(), not exit(): |
| */ |
| static void fflush_and__exit(void) NORETURN; |
| static void fflush_and__exit(void) |
| { |
| fflush_all(); |
| _exit(xfunc_error_retval); |
| } |
| |
| /* After [v]fork, in child: do not restore tty pgrp on xfunc death */ |
| # define disable_restore_tty_pgrp_on_exit() (die_func = fflush_and__exit) |
| /* After [v]fork, in parent: restore tty pgrp on xfunc death */ |
| # define enable_restore_tty_pgrp_on_exit() (die_func = restore_ttypgrp_and__exit) |
| |
| /* Restores tty foreground process group, and exits. |
| * May be called as signal handler for fatal signal |
| * (will resend signal to itself, producing correct exit state) |
| * or called directly with -EXITCODE. |
| * We also call it if xfunc is exiting. |
| */ |
| static void sigexit(int sig) NORETURN; |
| static void sigexit(int sig) |
| { |
| /* Careful: we can end up here after [v]fork. Do not restore |
| * tty pgrp then, only top-level shell process does that */ |
| if (G_saved_tty_pgrp && getpid() == G.root_pid) { |
| /* Disable all signals: job control, SIGPIPE, etc. |
| * Mostly paranoid measure, to prevent infinite SIGTTOU. |
| */ |
| sigprocmask_allsigs(SIG_BLOCK); |
| tcsetpgrp(G_interactive_fd, G_saved_tty_pgrp); |
| } |
| |
| /* Not a signal, just exit */ |
| if (sig <= 0) |
| _exit(- sig); |
| |
| kill_myself_with_sig(sig); /* does not return */ |
| } |
| #else |
| |
| # define disable_restore_tty_pgrp_on_exit() ((void)0) |
| # define enable_restore_tty_pgrp_on_exit() ((void)0) |
| |
| #endif |
| |
| static sighandler_t pick_sighandler(unsigned sig) |
| { |
| sighandler_t handler = SIG_DFL; |
| if (sig < sizeof(unsigned)*8) { |
| unsigned sigmask = (1 << sig); |
| |
| #if ENABLE_HUSH_JOB |
| /* is sig fatal? */ |
| if (G_fatal_sig_mask & sigmask) |
| handler = sigexit; |
| else |
| #endif |
| /* sig has special handling? */ |
| if (G.special_sig_mask & sigmask) { |
| handler = record_pending_signo; |
| /* TTIN/TTOU/TSTP can't be set to record_pending_signo |
| * in order to ignore them: they will be raised |
| * in an endless loop when we try to do some |
| * terminal ioctls! We do have to _ignore_ these. |
| */ |
| if (SPECIAL_JOBSTOP_SIGS & sigmask) |
| handler = SIG_IGN; |
| } |
| } |
| return handler; |
| } |
| |
| /* Restores tty foreground process group, and exits. */ |
| static void hush_exit(int exitcode) |
| { |
| #if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT |
| if (G.line_input_state) |
| save_history(G.line_input_state); |
| #endif |
| |
| fflush_all(); |
| if (G.exiting <= 0 && G_traps && G_traps[0] && G_traps[0][0]) { |
| char *argv[3]; |
| /* argv[0] is unused */ |
| argv[1] = xstrdup(G_traps[0]); /* copy, since EXIT trap handler may modify G_traps[0] */ |
| argv[2] = NULL; |
| G.exiting = 1; /* prevent EXIT trap recursion */ |
| /* Note: G_traps[0] is not cleared! |
| * "trap" will still show it, if executed |
| * in the handler */ |
| builtin_eval(argv); |
| } |
| |
| #if ENABLE_FEATURE_CLEAN_UP |
| { |
| struct variable *cur_var; |
| if (G.cwd != bb_msg_unknown) |
| free((char*)G.cwd); |
| cur_var = G.top_var; |
| while (cur_var) { |
| struct variable *tmp = cur_var; |
| if (!cur_var->max_len) |
| free(cur_var->varstr); |
| cur_var = cur_var->next; |
| free(tmp); |
| } |
| } |
| #endif |
| |
| fflush_all(); |
| #if ENABLE_HUSH_JOB |
| sigexit(- (exitcode & 0xff)); |
| #else |
| _exit(exitcode); |
| #endif |
| } |
| |
| |
| //TODO: return a mask of ALL handled sigs? |
| static int check_and_run_traps(void) |
| { |
| int last_sig = 0; |
| |
| while (1) { |
| int sig; |
| |
| if (sigisemptyset(&G.pending_set)) |
| break; |
| sig = 0; |
| do { |
| sig++; |
| if (sigismember(&G.pending_set, sig)) { |
| sigdelset(&G.pending_set, sig); |
| goto got_sig; |
| } |
| } while (sig < NSIG); |
| break; |
| got_sig: |
| #if ENABLE_HUSH_TRAP |
| if (G_traps && G_traps[sig]) { |
| debug_printf_exec("%s: sig:%d handler:'%s'\n", __func__, sig, G.traps[sig]); |
| if (G_traps[sig][0]) { |
| /* We have user-defined handler */ |
| smalluint save_rcode; |
| int save_pre; |
| char *argv[3]; |
| /* argv[0] is unused */ |
| argv[1] = xstrdup(G_traps[sig]); |
| /* why strdup? trap can modify itself: trap 'trap "echo oops" INT' INT */ |
| argv[2] = NULL; |
| save_pre = G.pre_trap_exitcode; |
| G.pre_trap_exitcode = save_rcode = G.last_exitcode; |
| builtin_eval(argv); |
| free(argv[1]); |
| G.pre_trap_exitcode = save_pre; |
| G.last_exitcode = save_rcode; |
| # if ENABLE_HUSH_FUNCTIONS |
| if (G.return_exitcode >= 0) { |
| debug_printf_exec("trap exitcode:%d\n", G.return_exitcode); |
| G.last_exitcode = G.return_exitcode; |
| } |
| # endif |
| last_sig = sig; |
| } /* else: "" trap, ignoring signal */ |
| continue; |
| } |
| #endif |
| /* not a trap: special action */ |
| switch (sig) { |
| case SIGINT: |
| debug_printf_exec("%s: sig:%d default SIGINT handler\n", __func__, sig); |
| G.flag_SIGINT = 1; |
| last_sig = sig; |
| break; |
| #if ENABLE_HUSH_JOB |
| case SIGHUP: { |
| //TODO: why are we doing this? ash and dash don't do this, |
| //they have no handler for SIGHUP at all, |
| //they rely on kernel to send SIGHUP+SIGCONT to orphaned process groups |
| struct pipe *job; |
| debug_printf_exec("%s: sig:%d default SIGHUP handler\n", __func__, sig); |
| /* bash is observed to signal whole process groups, |
| * not individual processes */ |
| for (job = G.job_list; job; job = job->next) { |
| if (job->pgrp <= 0) |
| continue; |
| debug_printf_exec("HUPing pgrp %d\n", job->pgrp); |
| if (kill(- job->pgrp, SIGHUP) == 0) |
| kill(- job->pgrp, SIGCONT); |
| } |
| sigexit(SIGHUP); |
| } |
| #endif |
| #if ENABLE_HUSH_FAST |
| case SIGCHLD: |
| debug_printf_exec("%s: sig:%d default SIGCHLD handler\n", __func__, sig); |
| G.count_SIGCHLD++; |
| //bb_error_msg("[%d] check_and_run_traps: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD); |
| /* Note: |
| * We don't do 'last_sig = sig' here -> NOT returning this sig. |
| * This simplifies wait builtin a bit. |
| */ |
| break; |
| #endif |
| default: /* ignored: */ |
| debug_printf_exec("%s: sig:%d default handling is to ignore\n", __func__, sig); |
| /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */ |
| /* Note: |
| * We don't do 'last_sig = sig' here -> NOT returning this sig. |
| * Example: wait is not interrupted by TERM |
| * in interactive shell, because TERM is ignored. |
| */ |
| break; |
| } |
| } |
| return last_sig; |
| } |
| |
| |
| static const char *get_cwd(int force) |
| { |
| if (force || G.cwd == NULL) { |
| /* xrealloc_getcwd_or_warn(arg) calls free(arg), |
| * we must not try to free(bb_msg_unknown) */ |
| if (G.cwd == bb_msg_unknown) |
| G.cwd = NULL; |
| G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd); |
| if (!G.cwd) |
| G.cwd = bb_msg_unknown; |
| } |
| return G.cwd; |
| } |
| |
| |
| /* |
| * Shell and environment variable support |
| */ |
| static struct variable **get_ptr_to_local_var(const char *name, unsigned len) |
| { |
| struct variable **pp; |
| struct variable *cur; |
| |
| pp = &G.top_var; |
| while ((cur = *pp) != NULL) { |
| if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=') |
| return pp; |
| pp = &cur->next; |
| } |
| return NULL; |
| } |
| |
| static const char* FAST_FUNC get_local_var_value(const char *name) |
| { |
| struct variable **vpp; |
| unsigned len = strlen(name); |
| |
| if (G.expanded_assignments) { |
| char **cpp = G.expanded_assignments; |
| while (*cpp) { |
| char *cp = *cpp; |
| if (strncmp(cp, name, len) == 0 && cp[len] == '=') |
| return cp + len + 1; |
| cpp++; |
| } |
| } |
| |
| vpp = get_ptr_to_local_var(name, len); |
| if (vpp) |
| return (*vpp)->varstr + len + 1; |
| |
| if (strcmp(name, "PPID") == 0) |
| return utoa(G.root_ppid); |
| // bash compat: UID? EUID? |
| #if ENABLE_HUSH_RANDOM_SUPPORT |
| if (strcmp(name, "RANDOM") == 0) |
| return utoa(next_random(&G.random_gen)); |
| #endif |
| #if ENABLE_HUSH_LINENO_VAR |
| if (strcmp(name, "LINENO") == 0) |
| return utoa(G.execute_lineno); |
| #endif |
| #if BASH_EPOCH_VARS |
| { |
| const char *fmt = NULL; |
| if (strcmp(name, "EPOCHSECONDS") == 0) |
| fmt = "%lu"; |
| else if (strcmp(name, "EPOCHREALTIME") == 0) |
| fmt = "%lu.%06u"; |
| if (fmt) { |
| struct timeval tv; |
| gettimeofday(&tv, NULL); |
| sprintf(G.epoch_buf, fmt, (unsigned long)tv.tv_sec, |
| (unsigned)tv.tv_usec); |
| return G.epoch_buf; |
| } |
| } |
| #endif |
| return NULL; |
| } |
| |
| #if ENABLE_HUSH_GETOPTS |
| static void handle_changed_special_names(const char *name, unsigned name_len) |
| { |
| if (name_len == 6) { |
| if (strncmp(name, "OPTIND", 6) == 0) { |
| G.getopt_count = 0; |
| return; |
| } |
| } |
| } |
| #else |
| /* Do not even bother evaluating arguments */ |
| # define handle_changed_special_names(...) ((void)0) |
| #endif |
| |
| /* str holds "NAME=VAL" and is expected to be malloced. |
| * We take ownership of it. |
| */ |
| #define SETFLAG_EXPORT (1 << 0) |
| #define SETFLAG_UNEXPORT (1 << 1) |
| #define SETFLAG_MAKE_RO (1 << 2) |
| #define SETFLAG_VARLVL_SHIFT 3 |
| static int set_local_var(char *str, unsigned flags) |
| { |
| struct variable **cur_pp; |
| struct variable *cur; |
| char *free_me = NULL; |
| char *eq_sign; |
| int name_len; |
| int retval; |
| unsigned local_lvl = (flags >> SETFLAG_VARLVL_SHIFT); |
| |
| eq_sign = strchr(str, '='); |
| if (HUSH_DEBUG && !eq_sign) |
| bb_simple_error_msg_and_die("BUG in setvar"); |
| |
| name_len = eq_sign - str + 1; /* including '=' */ |
| cur_pp = &G.top_var; |
| while ((cur = *cur_pp) != NULL) { |
| if (strncmp(cur->varstr, str, name_len) != 0) { |
| cur_pp = &cur->next; |
| continue; |
| } |
| |
| /* We found an existing var with this name */ |
| if (cur->flg_read_only) { |
| bb_error_msg("%s: readonly variable", str); |
| free(str); |
| //NOTE: in bash, assignment in "export READONLY_VAR=Z" fails, and sets $?=1, |
| //but export per se succeeds (does put the var in env). We don't mimic that. |
| return -1; |
| } |
| if (flags & SETFLAG_UNEXPORT) { // && cur->flg_export ? |
| debug_printf_env("%s: unsetenv '%s'\n", __func__, str); |
| *eq_sign = '\0'; |
| unsetenv(str); |
| *eq_sign = '='; |
| } |
| if (cur->var_nest_level < local_lvl) { |
| /* bash 3.2.33(1) and exported vars: |
| * # export z=z |
| * # f() { local z=a; env | grep ^z; } |
| * # f |
| * z=a |
| * # env | grep ^z |
| * z=z |
| */ |
| if (cur->flg_export) |
| flags |= SETFLAG_EXPORT; |
| /* New variable is local ("local VAR=VAL" or |
| * "VAR=VAL cmd") |
| * and existing one is global, or local |
| * on a lower level that new one. |
| * Remove it from global variable list: |
| */ |
| *cur_pp = cur->next; |
| if (G.shadowed_vars_pp) { |
| /* Save in "shadowed" list */ |
| debug_printf_env("shadowing %s'%s'/%u by '%s'/%u\n", |
| cur->flg_export ? "exported " : "", |
| cur->varstr, cur->var_nest_level, str, local_lvl |
| ); |
| cur->next = *G.shadowed_vars_pp; |
| *G.shadowed_vars_pp = cur; |
| } else { |
| /* Came from pseudo_exec_argv(), no need to save: delete it */ |
| debug_printf_env("shadow-deleting %s'%s'/%u by '%s'/%u\n", |
| cur->flg_export ? "exported " : "", |
| cur->varstr, cur->var_nest_level, str, local_lvl |
| ); |
| if (cur->max_len == 0) /* allocated "VAR=VAL"? */ |
| free_me = cur->varstr; /* then free it later */ |
| free(cur); |
| } |
| break; |
| } |
| |
| if (strcmp(cur->varstr + name_len, eq_sign + 1) == 0) { |
| debug_printf_env("assignement '%s' does not change anything\n", str); |
| free_and_exp: |
| free(str); |
| goto exp; |
| } |
| |
| /* Replace the value in the found "struct variable" */ |
| if (cur->max_len != 0) { |
| if (cur->max_len >= strnlen(str, cur->max_len + 1)) { |
| /* This one is from startup env, reuse space */ |
| debug_printf_env("reusing startup env for '%s'\n", str); |
| strcpy(cur->varstr, str); |
| goto free_and_exp; |
| } |
| /* Can't reuse */ |
| cur->max_len = 0; |
| goto set_str_and_exp; |
| } |
| /* max_len == 0 signifies "malloced" var, which we can |
| * (and have to) free. But we can't free(cur->varstr) here: |
| * if cur->flg_export is 1, it is in the environment. |
| * We should either unsetenv+free, or wait until putenv, |
| * then putenv(new)+free(old). |
| */ |
| free_me = cur->varstr; |
| goto set_str_and_exp; |
| } |
| |
| /* Not found or shadowed - create new variable struct */ |
| debug_printf_env("%s: alloc new var '%s'/%u\n", __func__, str, local_lvl); |
| cur = xzalloc(sizeof(*cur)); |
| cur->var_nest_level = local_lvl; |
| cur->next = *cur_pp; |
| *cur_pp = cur; |
| |
| set_str_and_exp: |
| cur->varstr = str; |
| exp: |
| #if !BB_MMU || ENABLE_HUSH_READONLY |
| if (flags & SETFLAG_MAKE_RO) { |
| cur->flg_read_only = 1; |
| } |
| #endif |
| if (flags & SETFLAG_EXPORT) |
| cur->flg_export = 1; |
| retval = 0; |
| if (cur->flg_export) { |
| if (flags & SETFLAG_UNEXPORT) { |
| cur->flg_export = 0; |
| /* unsetenv was already done */ |
| } else { |
| debug_printf_env("%s: putenv '%s'/%u\n", __func__, cur->varstr, cur->var_nest_level); |
| retval = putenv(cur->varstr); |
| /* fall through to "free(free_me)" - |
| * only now we can free old exported malloced string |
| */ |
| } |
| } |
| free(free_me); |
| |
| handle_changed_special_names(cur->varstr, name_len - 1); |
| |
| return retval; |
| } |
| |
| static void FAST_FUNC set_local_var_from_halves(const char *name, const char *val) |
| { |
| char *var = xasprintf("%s=%s", name, val); |
| set_local_var(var, /*flag:*/ 0); |
| } |
| |
| /* Used at startup and after each cd */ |
| static void set_pwd_var(unsigned flag) |
| { |
| set_local_var(xasprintf("PWD=%s", get_cwd(/*force:*/ 1)), flag); |
| } |
| |
| #if ENABLE_HUSH_UNSET || ENABLE_HUSH_GETOPTS |
| static int unset_local_var_len(const char *name, int name_len) |
| { |
| struct variable *cur; |
| struct variable **cur_pp; |
| |
| cur_pp = &G.top_var; |
| while ((cur = *cur_pp) != NULL) { |
| if (strncmp(cur->varstr, name, name_len) == 0 |
| && cur->varstr[name_len] == '=' |
| ) { |
| if (cur->flg_read_only) { |
| bb_error_msg("%s: readonly variable", name); |
| return EXIT_FAILURE; |
| } |
| |
| *cur_pp = cur->next; |
| debug_printf_env("%s: unsetenv '%s'\n", __func__, cur->varstr); |
| bb_unsetenv(cur->varstr); |
| if (!cur->max_len) |
| free(cur->varstr); |
| free(cur); |
| |
| break; |
| } |
| cur_pp = &cur->next; |
| } |
| |
| /* Handle "unset LINENO" et al even if did not find the variable to unset */ |
| handle_changed_special_names(name, name_len); |
| |
| return EXIT_SUCCESS; |
| } |
| |
| static int unset_local_var(const char *name) |
| { |
| return unset_local_var_len(name, strlen(name)); |
| } |
| #endif |
| |
| |
| /* |
| * Helpers for "var1=val1 var2=val2 cmd" feature |
| */ |
| static void add_vars(struct variable *var) |
| { |
| struct variable *next; |
| |
| while (var) { |
| next = var->next; |
| var->next = G.top_var; |
| G.top_var = var; |
| if (var->flg_export) { |
| debug_printf_env("%s: restoring exported '%s'/%u\n", __func__, var->varstr, var->var_nest_level); |
| putenv(var->varstr); |
| } else { |
| debug_printf_env("%s: restoring variable '%s'/%u\n", __func__, var->varstr, var->var_nest_level); |
| } |
| var = next; |
| } |
| } |
| |
| /* We put strings[i] into variable table and possibly putenv them. |
| * If variable is read only, we can free the strings[i] |
| * which attempts to overwrite it. |
| * The strings[] vector itself is freed. |
| */ |
| static void set_vars_and_save_old(char **strings) |
| { |
| char **s; |
| |
| if (!strings) |
| return; |
| |
| s = strings; |
| while (*s) { |
| struct variable *var_p; |
| struct variable **var_pp; |
| char *eq; |
| |
| eq = strchr(*s, '='); |
| if (HUSH_DEBUG && !eq) |
| bb_simple_error_msg_and_die("BUG in varexp4"); |
| var_pp = get_ptr_to_local_var(*s, eq - *s); |
| if (var_pp) { |
| var_p = *var_pp; |
| if (var_p->flg_read_only) { |
| char **p; |
| bb_error_msg("%s: readonly variable", *s); |
| /* |
| * "VAR=V BLTIN" unsets VARs after BLTIN completes. |
| * If VAR is readonly, leaving it in the list |
| * after asssignment error (msg above) |
| * causes doubled error message later, on unset. |
| */ |
| debug_printf_env("removing/freeing '%s' element\n", *s); |
| free(*s); |
| p = s; |
| do { *p = p[1]; p++; } while (*p); |
| goto next; |
| } |
| /* below, set_local_var() with nest level will |
| * "shadow" (remove) this variable from |
| * global linked list. |
| */ |
| } |
| debug_printf_env("%s: env override '%s'/%u\n", __func__, *s, G.var_nest_level); |
| set_local_var(*s, (G.var_nest_level << SETFLAG_VARLVL_SHIFT) | SETFLAG_EXPORT); |
| s++; |
| next: ; |
| } |
| free(strings); |
| } |
| |
| |
| /* |
| * Unicode helper |
| */ |
| static void reinit_unicode_for_hush(void) |
| { |
| /* Unicode support should be activated even if LANG is set |
| * _during_ shell execution, not only if it was set when |
| * shell was started. Therefore, re-check LANG every time: |
| */ |
| if (ENABLE_FEATURE_CHECK_UNICODE_IN_ENV |
| || ENABLE_UNICODE_USING_LOCALE |
| ) { |
| const char *s = get_local_var_value("LC_ALL"); |
| if (!s) s = get_local_var_value("LC_CTYPE"); |
| if (!s) s = get_local_var_value("LANG"); |
| reinit_unicode(s); |
| } |
| } |
| |
| /* |
| * in_str support (strings, and "strings" read from files). |
| */ |
| |
| #if ENABLE_HUSH_INTERACTIVE |
| /* To test correct lineedit/interactive behavior, type from command line: |
| * echo $P\ |
| * \ |
| * AT\ |
| * H\ |
| * \ |
| * It exercises a lot of corner cases. |
| */ |
| static const char *setup_prompt_string(void) |
| { |
| const char *prompt_str; |
| |
| debug_printf_prompt("%s promptmode:%d\n", __func__, G.promptmode); |
| |
| # if ENABLE_FEATURE_EDITING_FANCY_PROMPT |
| prompt_str = get_local_var_value(G.promptmode == 0 ? "PS1" : "PS2"); |
| if (!prompt_str) |
| prompt_str = ""; |
| # else |
| prompt_str = "> "; /* if PS2, else... */ |
| if (G.promptmode == 0) { /* PS1 */ |
| /* No fancy prompts supported, (re)generate "CURDIR $ " by hand */ |
| free(G.PS1); |
| /* bash uses $PWD value, even if it is set by user. |
| * It uses current dir only if PWD is unset. |
| * We always use current dir. */ |
| G.PS1 = xasprintf("%s %c ", get_cwd(0), (geteuid() != 0) ? '$' : '#'); |
| } |
| # endif |
| debug_printf("prompt_str '%s'\n", prompt_str); |
| return prompt_str; |
| } |
| static int get_user_input(struct in_str *i) |
| { |
| int r; |
| const char *prompt_str; |
| |
| prompt_str = setup_prompt_string(); |
| # if ENABLE_FEATURE_EDITING |
| for (;;) { |
| reinit_unicode_for_hush(); |
| if (G.flag_SIGINT) { |
| /* There was ^C'ed, make it look prettier: */ |
| bb_putchar('\n'); |
| G.flag_SIGINT = 0; |
| } |
| /* buglet: SIGINT will not make new prompt to appear _at once_, |
| * only after <Enter>. (^C works immediately) */ |
| r = read_line_input(G.line_input_state, prompt_str, |
| G.user_input_buf, CONFIG_FEATURE_EDITING_MAX_LEN-1 |
| ); |
| /* read_line_input intercepts ^C, "convert" it to SIGINT */ |
| if (r == 0) |
| raise(SIGINT); |
| check_and_run_traps(); |
| if (r != 0 && !G.flag_SIGINT) |
| break; |
| /* ^C or SIGINT: repeat */ |
| /* bash prints ^C even on real SIGINT (non-kbd generated) */ |
| write(STDOUT_FILENO, "^C", 2); |
| G.last_exitcode = 128 + SIGINT; |
| } |
| if (r < 0) { |
| /* EOF/error detected */ |
| i->p = NULL; |
| i->peek_buf[0] = r = EOF; |
| return r; |
| } |
| i->p = G.user_input_buf; |
| return (unsigned char)*i->p++; |
| # else |
| for (;;) { |
| G.flag_SIGINT = 0; |
| if (i->last_char == '\0' || i->last_char == '\n') { |
| /* Why check_and_run_traps here? Try this interactively: |
| * $ trap 'echo INT' INT; (sleep 2; kill -INT $$) & |
| * $ <[enter], repeatedly...> |
| * Without check_and_run_traps, handler never runs. |
| */ |
| check_and_run_traps(); |
| fputs(prompt_str, stdout); |
| } |
| fflush_all(); |
| //FIXME: here ^C or SIGINT will have effect only after <Enter> |
| r = hfgetc(i->file); |
| /* In !ENABLE_FEATURE_EDITING we don't use read_line_input, |
| * no ^C masking happens during fgetc, no special code for ^C: |
| * it generates SIGINT as usual. |
| */ |
| check_and_run_traps(); |
| if (G.flag_SIGINT) |
| G.last_exitcode = 128 + SIGINT; |
| if (r != '\0') |
| break; |
| } |
| return r; |
| # endif |
| } |
| /* This is the magic location that prints prompts |
| * and gets data back from the user */ |
| static int fgetc_interactive(struct in_str *i) |
| { |
| int ch; |
| /* If it's interactive stdin, get new line. */ |
| if (G_interactive_fd && i->file == G.HFILE_stdin) { |
| /* Returns first char (or EOF), the rest is in i->p[] */ |
| ch = get_user_input(i); |
| G.promptmode = 1; /* PS2 */ |
| debug_printf_prompt("%s promptmode=%d\n", __func__, G.promptmode); |
| } else { |
| /* Not stdin: script file, sourced file, etc */ |
| do ch = hfgetc(i->file); while (ch == '\0'); |
| } |
| return ch; |
| } |
| #else |
| static ALWAYS_INLINE int fgetc_interactive(struct in_str *i) |
| { |
| int ch; |
| do ch = hfgetc(i->file); while (ch == '\0'); |
| return ch; |
| } |
| #endif /* INTERACTIVE */ |
| |
| static int i_getch(struct in_str *i) |
| { |
| int ch; |
| |
| if (!i->file) { |
| /* string-based in_str */ |
| ch = (unsigned char)*i->p; |
| if (ch != '\0') { |
| i->p++; |
| i->last_char = ch; |
| return ch; |
| } |
| return EOF; |
| } |
| |
| /* FILE-based in_str */ |
| |
| #if ENABLE_FEATURE_EDITING |
| /* This can be stdin, check line editing char[] buffer */ |
| if (i->p && *i->p != '\0') { |
| ch = (unsigned char)*i->p++; |
| goto out; |
| } |
| #endif |
| /* peek_buf[] is an int array, not char. Can contain EOF. */ |
| ch = i->peek_buf[0]; |
| if (ch != 0) { |
| int ch2 = i->peek_buf[1]; |
| i->peek_buf[0] = ch2; |
| if (ch2 == 0) /* very likely, avoid redundant write */ |
| goto out; |
| i->peek_buf[1] = 0; |
| goto out; |
| } |
| |
| ch = fgetc_interactive(i); |
| out: |
| debug_printf("file_get: got '%c' %d\n", ch, ch); |
| i->last_char = ch; |
| #if ENABLE_HUSH_LINENO_VAR |
| if (ch == '\n') { |
| G.parse_lineno++; |
| debug_printf_parse("G.parse_lineno++ = %u\n", G.parse_lineno); |
| } |
| #endif |
| return ch; |
| } |
| |
| static int i_peek(struct in_str *i) |
| { |
| int ch; |
| |
| if (!i->file) { |
| /* string-based in_str */ |
| /* Doesn't report EOF on NUL. None of the callers care. */ |
| return (unsigned char)*i->p; |
| } |
| |
| /* FILE-based in_str */ |
| |
| #if ENABLE_FEATURE_EDITING && ENABLE_HUSH_INTERACTIVE |
| /* This can be stdin, check line editing char[] buffer */ |
| if (i->p && *i->p != '\0') |
| return (unsigned char)*i->p; |
| #endif |
| /* peek_buf[] is an int array, not char. Can contain EOF. */ |
| ch = i->peek_buf[0]; |
| if (ch != 0) |
| return ch; |
| |
| /* Need to get a new char */ |
| ch = fgetc_interactive(i); |
| debug_printf("file_peek: got '%c' %d\n", ch, ch); |
| |
| /* Save it by either rolling back line editing buffer, or in i->peek_buf[0] */ |
| #if ENABLE_FEATURE_EDITING && ENABLE_HUSH_INTERACTIVE |
| if (i->p) { |
| i->p -= 1; |
| return ch; |
| } |
| #endif |
| i->peek_buf[0] = ch; |
| /*i->peek_buf[1] = 0; - already is */ |
| return ch; |
| } |
| |
| /* Only ever called if i_peek() was called, and did not return EOF. |
| * IOW: we know the previous peek saw an ordinary char, not EOF, not NUL, |
| * not end-of-line. Therefore we never need to read a new editing line here. |
| */ |
| static int i_peek2(struct in_str *i) |
| { |
| int ch; |
| |
| /* There are two cases when i->p[] buffer exists. |
| * (1) it's a string in_str. |
| * (2) It's a file, and we have a saved line editing buffer. |
| * In both cases, we know that i->p[0] exists and not NUL, and |
| * the peek2 result is in i->p[1]. |
| */ |
| if (i->p) |
| return (unsigned char)i->p[1]; |
| |
| /* Now we know it is a file-based in_str. */ |
| |
| /* peek_buf[] is an int array, not char. Can contain EOF. */ |
| /* Is there 2nd char? */ |
| ch = i->peek_buf[1]; |
| if (ch == 0) { |
| /* We did not read it yet, get it now */ |
| do ch = hfgetc(i->file); while (ch == '\0'); |
| i->peek_buf[1] = ch; |
| } |
| |
| debug_printf("file_peek2: got '%c' %d\n", ch, ch); |
| return ch; |
| } |
| |
| static int i_getch_and_eat_bkslash_nl(struct in_str *input) |
| { |
| for (;;) { |
| int ch, ch2; |
| |
| ch = i_getch(input); |
| if (ch != '\\') |
| return ch; |
| ch2 = i_peek(input); |
| if (ch2 != '\n') |
| return ch; |
| /* backslash+newline, skip it */ |
| i_getch(input); |
| } |
| } |
| |
| /* Note: this function _eats_ \<newline> pairs, safe to use plain |
| * i_getch() after it instead of i_getch_and_eat_bkslash_nl(). |
| */ |
| static int i_peek_and_eat_bkslash_nl(struct in_str *input) |
| { |
| for (;;) { |
| int ch, ch2; |
| |
| ch = i_peek(input); |
| if (ch != '\\') |
| return ch; |
| ch2 = i_peek2(input); |
| if (ch2 != '\n') |
| return ch; |
| /* backslash+newline, skip it */ |
| i_getch(input); |
| i_getch(input); |
| } |
| } |
| |
| static void setup_file_in_str(struct in_str *i, HFILE *fp) |
| { |
| memset(i, 0, sizeof(*i)); |
| i->file = fp; |
| /* i->p = NULL; */ |
| } |
| |
| static void setup_string_in_str(struct in_str *i, const char *s) |
| { |
| memset(i, 0, sizeof(*i)); |
| /*i->file = NULL */; |
| i->p = s; |
| } |
| |
| |
| /* |
| * o_string support |
| */ |
| #define B_CHUNK (32 * sizeof(char*)) |
| |
| static void o_reset_to_empty_unquoted(o_string *o) |
| { |
| o->length = 0; |
| o->has_quoted_part = 0; |
| if (o->data) |
| o->data[0] = '\0'; |
| } |
| |
| static void o_free_and_set_NULL(o_string *o) |
| { |
| free(o->data); |
| memset(o, 0, sizeof(*o)); |
| } |
| |
| static ALWAYS_INLINE void o_free(o_string *o) |
| { |
| free(o->data); |
| } |
| |
| static void o_grow_by(o_string *o, int len) |
| { |
| if (o->length + len > o->maxlen) { |
| o->maxlen += (2 * len) | (B_CHUNK-1); |
| o->data = xrealloc(o->data, 1 + o->maxlen); |
| } |
| } |
| |
| static void o_addchr(o_string *o, int ch) |
| { |
| debug_printf("o_addchr: '%c' o->length=%d o=%p\n", ch, o->length, o); |
| if (o->length < o->maxlen) { |
| /* likely. avoid o_grow_by() call */ |
| add: |
| o->data[o->length] = ch; |
| o->length++; |
| o->data[o->length] = '\0'; |
| return; |
| } |
| o_grow_by(o, 1); |
| goto add; |
| } |
| |
| #if 0 |
| /* Valid only if we know o_string is not empty */ |
| static void o_delchr(o_string *o) |
| { |
| o->length--; |
| o->data[o->length] = '\0'; |
| } |
| #endif |
| |
| static void o_addblock(o_string *o, const char *str, int len) |
| { |
| o_grow_by(o, len); |
| ((char*)mempcpy(&o->data[o->length], str, len))[0] = '\0'; |
| o->length += len; |
| } |
| |
| static void o_addstr(o_string *o, const char *str) |
| { |
| o_addblock(o, str, strlen(str)); |
| } |
| |
| static void o_addstr_with_NUL(o_string *o, const char *str) |
| { |
| o_addblock(o, str, strlen(str) + 1); |
| } |
| |
| #if !BB_MMU |
| static void nommu_addchr(o_string *o, int ch) |
| { |
| if (o) |
| o_addchr(o, ch); |
| } |
| #else |
| # define nommu_addchr(o, str) ((void)0) |
| #endif |
| |
| #if ENABLE_HUSH_MODE_X |
| static void x_mode_addchr(int ch) |
| { |
| o_addchr(&G.x_mode_buf, ch); |
| } |
| static void x_mode_addstr(const char *str) |
| { |
| o_addstr(&G.x_mode_buf, str); |
| } |
| static void x_mode_addblock(const char *str, int len) |
| { |
| o_addblock(&G.x_mode_buf, str, len); |
| } |
| static void x_mode_prefix(void) |
| { |
| int n = G.x_mode_depth; |
| do x_mode_addchr('+'); while (--n >= 0); |
| } |
| static void x_mode_flush(void) |
| { |
| int len = G.x_mode_buf.length; |
| if (len <= 0) |
| return; |
| if (G.x_mode_fd > 0) { |
| G.x_mode_buf.data[len] = '\n'; |
| full_write(G.x_mode_fd, G.x_mode_buf.data, len + 1); |
| } |
| G.x_mode_buf.length = 0; |
| } |
| #endif |
| |
| /* |
| * HUSH_BRACE_EXPANSION code needs corresponding quoting on variable expansion side. |
| * Currently, "v='{q,w}'; echo $v" erroneously expands braces in $v. |
| * Apparently, on unquoted $v bash still does globbing |
| * ("v='*.txt'; echo $v" prints all .txt files), |
| * but NOT brace expansion! Thus, there should be TWO independent |
| * quoting mechanisms on $v expansion side: one protects |
| * $v from brace expansion, and other additionally protects "$v" against globbing. |
| * We have only second one. |
| */ |
| |
| #if ENABLE_HUSH_BRACE_EXPANSION |
| # define MAYBE_BRACES "{}" |
| #else |
| # define MAYBE_BRACES "" |
| #endif |
| |
| /* My analysis of quoting semantics tells me that state information |
| * is associated with a destination, not a source. |
| */ |
| static void o_addqchr(o_string *o, int ch) |
| { |
| int sz = 1; |
| char *found = strchr("*?[\\" MAYBE_BRACES, ch); |
| if (found) |
| sz++; |
| o_grow_by(o, sz); |
| if (found) { |
| o->data[o->length] = '\\'; |
| o->length++; |
| } |
| o->data[o->length] = ch; |
| o->length++; |
| o->data[o->length] = '\0'; |
| } |
| |
| static void o_addQchr(o_string *o, int ch) |
| { |
| int sz = 1; |
| if ((o->o_expflags & EXP_FLAG_ESC_GLOB_CHARS) |
| && strchr("*?[\\" MAYBE_BRACES, ch) |
| ) { |
| sz++; |
| o->data[o->length] = '\\'; |
| o->length++; |
| } |
| o_grow_by(o, sz); |
| o->data[o->length] = ch; |
| o->length++; |
| o->data[o->length] = '\0'; |
| } |
| |
| static void o_addqblock(o_string *o, const char *str, int len) |
| { |
| while (len) { |
| char ch; |
| int sz; |
| int ordinary_cnt = strcspn(str, "*?[\\" MAYBE_BRACES); |
| if (ordinary_cnt > len) /* paranoia */ |
| ordinary_cnt = len; |
| o_addblock(o, str, ordinary_cnt); |
| if (ordinary_cnt == len) |
| return; /* NUL is already added by o_addblock */ |
| str += ordinary_cnt; |
| len -= ordinary_cnt + 1; /* we are processing + 1 char below */ |
| |
| ch = *str++; |
| sz = 1; |
| if (ch) { /* it is necessarily one of "*?[\\" MAYBE_BRACES */ |
| sz++; |
| o->data[o->length] = '\\'; |
| o->length++; |
| } |
| o_grow_by(o, sz); |
| o->data[o->length] = ch; |
| o->length++; |
| } |
| o->data[o->length] = '\0'; |
| } |
| |
| static void o_addQblock(o_string *o, const char *str, int len) |
| { |
| if (!(o->o_expflags & EXP_FLAG_ESC_GLOB_CHARS)) { |
| o_addblock(o, str, len); |
| return; |
| } |
| o_addqblock(o, str, len); |
| } |
| |
| static void o_addQstr(o_string *o, const char *str) |
| { |
| o_addQblock(o, str, strlen(str)); |
| } |
| |
| /* A special kind of o_string for $VAR and `cmd` expansion. |
| * It contains char* list[] at the beginning, which is grown in 16 element |
| * increments. Actual string data starts at the next multiple of 16 * (char*). |
| * list[i] contains an INDEX (int!) into this string data. |
| * It means that if list[] needs to grow, data needs to be moved higher up |
| * but list[i]'s need not be modified. |
| * NB: remembering how many list[i]'s you have there is crucial. |
| * o_finalize_list() operation post-processes this structure - calculates |
| * and stores actual char* ptrs in list[]. Oh, it NULL terminates it as well. |
| */ |
| #if DEBUG_EXPAND || DEBUG_GLOB |
| static void debug_print_list(const char *prefix, o_string *o, int n) |
| { |
| char **list = (char**)o->data; |
| int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]); |
| int i = 0; |
| |
| indent(); |
| fdprintf(2, "%s: list:%p n:%d string_start:%d length:%d maxlen:%d glob:%d quoted:%d escape:%d\n", |
| prefix, list, n, string_start, o->length, o->maxlen, |
| !!(o->o_expflags & EXP_FLAG_GLOB), |
| o->has_quoted_part, |
| !!(o->o_expflags & EXP_FLAG_ESC_GLOB_CHARS)); |
| while (i < n) { |
| indent(); |
| fdprintf(2, " list[%d]=%d '%s' %p\n", i, (int)(uintptr_t)list[i], |
| o->data + (int)(uintptr_t)list[i] + string_start, |
| o->data + (int)(uintptr_t)list[i] + string_start); |
| i++; |
| } |
| if (n) { |
| const char *p = o->data + (int)(uintptr_t)list[n - 1] + string_start; |
| indent(); |
| fdprintf(2, " total_sz:%ld\n", (long)((p + strlen(p) + 1) - o->data)); |
| } |
| } |
| #else |
| # define debug_print_list(prefix, o, n) ((void)0) |
| #endif |
| |
| /* n = o_save_ptr_helper(str, n) "starts new string" by storing an index value |
| * in list[n] so that it points past last stored byte so far. |
| * It returns n+1. */ |
| static int o_save_ptr_helper(o_string *o, int n) |
| { |
| char **list = (char**)o->data; |
| int string_start; |
| int string_len; |
| |
| if (!o->has_empty_slot) { |
| string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]); |
| string_len = o->length - string_start; |
| if (!(n & 0xf)) { /* 0, 0x10, 0x20...? */ |
| debug_printf_list("list[%d]=%d string_start=%d (growing)\n", n, string_len, string_start); |
| /* list[n] points to string_start, make space for 16 more pointers */ |
| o->maxlen += 0x10 * sizeof(list[0]); |
| o->data = xrealloc(o->data, o->maxlen + 1); |
| list = (char**)o->data; |
| memmove(list + n + 0x10, list + n, string_len); |
| /* |
| * expand_on_ifs() has a "previous argv[] ends in IFS?" |
| * check. (grep for -prev-ifs-check-). |
| * Ensure that argv[-1][last] is not garbage |
| * but zero bytes, to save index check there. |
| */ |
| list[n + 0x10 - 1] = 0; |
| o->length += 0x10 * sizeof(list[0]); |
| } else { |
| debug_printf_list("list[%d]=%d string_start=%d\n", |
| n, string_len, string_start); |
| } |
| } else { |
| /* We have empty slot at list[n], reuse without growth */ |
| string_start = ((n+1 + 0xf) & ~0xf) * sizeof(list[0]); /* NB: n+1! */ |
| string_len = o->length - string_start; |
| debug_printf_list("list[%d]=%d string_start=%d (empty slot)\n", |
| n, string_len, string_start); |
| o->has_empty_slot = 0; |
| } |
| o->has_quoted_part = 0; |
| list[n] = (char*)(uintptr_t)string_len; |
| return n + 1; |
| } |
| |
| /* "What was our last o_save_ptr'ed position (byte offset relative o->data)?" */ |
| static int o_get_last_ptr(o_string *o, int n) |
| { |
| char **list = (char**)o->data; |
| int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]); |
| |
| return ((int)(uintptr_t)list[n-1]) + string_start; |
| } |
| |
| /* |
| * Globbing routines. |
| * |
| * Most words in commands need to be globbed, even ones which are |
| * (single or double) quoted. This stems from the possiblity of |
| * constructs like "abc"* and 'abc'* - these should be globbed. |
| * Having a different code path for fully-quoted strings ("abc", |
| * 'abc') would only help performance-wise, but we still need |
| * code for partially-quoted strings. |
| * |
| * Unfortunately, if we want to match bash and ash behavior in all cases, |
| * the logic can't be "shell-syntax argument is first transformed |
| * to a string, then globbed, and if globbing does not match anything, |
| * it is used verbatim". Here are two examples where it fails: |
| * |
| * echo 'b\*'? |
| * |
| * The globbing can't be avoided (because of '?' at the end). |
| * The glob pattern is: b\\\*? - IOW, both \ and * are literals |
| * and are glob-escaped. If this does not match, bash/ash print b\*? |
| * - IOW: they "unbackslash" the glob pattern. |
| * Now, look at this: |
| * |
| * v='\\\*'; echo b$v? |
| * |
| * The glob pattern is the same here: b\\\*? - the unquoted $v expansion |
| * should be used as glob pattern with no changes. However, if glob |
| * does not match, bash/ash print b\\\*? - NOT THE SAME as first example! |
| * |
| * ash implements this by having an encoded representation of the word |
| * to glob, which IS NOT THE SAME as the glob pattern - it has more data. |
| * Glob pattern is derived from it. If glob fails, the decision what result |
| * should be is made using that encoded representation. Not glob pattern. |
| */ |
| |
| #if ENABLE_HUSH_BRACE_EXPANSION |
| /* There in a GNU extension, GLOB_BRACE, but it is not usable: |
| * first, it processes even {a} (no commas), second, |
| * I didn't manage to make it return strings when they don't match |
| * existing files. Need to re-implement it. |
| */ |
| |
| /* Helper */ |
| static int glob_needed(const char *s) |
| { |
| while (*s) { |
| if (*s == '\\') { |
| if (!s[1]) |
| return 0; |
| s += 2; |
| continue; |
| } |
| if (*s == '*' || *s == '[' || *s == '?' || *s == '{') |
| return 1; |
| s++; |
| } |
| return 0; |
| } |
| /* Return pointer to next closing brace or to comma */ |
| static const char *next_brace_sub(const char *cp) |
| { |
| unsigned depth = 0; |
| cp++; |
| while (*cp != '\0') { |
| if (*cp == '\\') { |
| if (*++cp == '\0') |
| break; |
| cp++; |
| continue; |
| } |
| if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0)) |
| break; |
| if (*cp++ == '{') |
| depth++; |
| } |
| |
| return *cp != '\0' ? cp : NULL; |
| } |
| /* Recursive brace globber. Note: may garble pattern[]. */ |
| static int glob_brace(char *pattern, o_string *o, int n) |
| { |
| char *new_pattern_buf; |
| const char *begin; |
| const char *next; |
| const char *rest; |
| const char *p; |
| size_t rest_len; |
| |
| debug_printf_glob("glob_brace('%s')\n", pattern); |
| |
| begin = pattern; |
| while (1) { |
| if (*begin == '\0') |
| goto simple_glob; |
| if (*begin == '{') { |
| /* Find the first sub-pattern and at the same time |
| * find the rest after the closing brace */ |
| next = next_brace_sub(begin); |
| if (next == NULL) { |
| /* An illegal expression */ |
| goto simple_glob; |
| } |
| if (*next == '}') { |
| /* "{abc}" with no commas - illegal |
| * brace expr, disregard and skip it */ |
| begin = next + 1; |
| continue; |
| } |
| break; |
| } |
| if (*begin == '\\' && begin[1] != '\0') |
| begin++; |
| begin++; |
| } |
| debug_printf_glob("begin:%s\n", begin); |
| debug_printf_glob("next:%s\n", next); |
| |
| /* Now find the end of the whole brace expression */ |
| rest = next; |
| while (*rest != '}') { |
| rest = next_brace_sub(rest); |
| if (rest == NULL) { |
| /* An illegal expression */ |
| goto simple_glob; |
| } |
| debug_printf_glob("rest:%s\n", rest); |
| } |
| rest_len = strlen(++rest) + 1; |
| |
| /* We are sure the brace expression is well-formed */ |
| |
| /* Allocate working buffer large enough for our work */ |
| new_pattern_buf = xmalloc(strlen(pattern)); |
| |
| /* We have a brace expression. BEGIN points to the opening {, |
| * NEXT points past the terminator of the first element, and REST |
| * points past the final }. We will accumulate result names from |
| * recursive runs for each brace alternative in the buffer using |
| * GLOB_APPEND. */ |
| |
| p = begin + 1; |
| while (1) { |
| /* Construct the new glob expression */ |
| memcpy( |
| mempcpy( |
| mempcpy(new_pattern_buf, |
| /* We know the prefix for all sub-patterns */ |
| pattern, begin - pattern), |
| p, next - p), |
| rest, rest_len); |
| |
| /* Note: glob_brace() may garble new_pattern_buf[]. |
| * That's why we re-copy prefix every time (1st memcpy above). |
| */ |
| n = glob_brace(new_pattern_buf, o, n); |
| if (*next == '}') { |
| /* We saw the last entry */ |
| break; |
| } |
| p = next + 1; |
| next = next_brace_sub(next); |
| } |
| free(new_pattern_buf); |
| return n; |
| |
| simple_glob: |
| { |
| int gr; |
| glob_t globdata; |
| |
| memset(&globdata, 0, sizeof(globdata)); |
| gr = glob(pattern, 0, NULL, &globdata); |
| debug_printf_glob("glob('%s'):%d\n", pattern, gr); |
| if (gr != 0) { |
| if (gr == GLOB_NOMATCH) { |
| globfree(&globdata); |
| /* NB: garbles parameter */ |
| unbackslash(pattern); |
| o_addstr_with_NUL(o, pattern); |
| debug_printf_glob("glob pattern '%s' is literal\n", pattern); |
| return o_save_ptr_helper(o, n); |
| } |
| if (gr == GLOB_NOSPACE) |
| bb_die_memory_exhausted(); |
| |