//#define BB_FEATURE_SH_BACKTICKS
//
//If, then, else, etc. support.. This should now behave basically
-//like any other Bourne shell...
+//like any other Bourne shell -- sortof...
#define BB_FEATURE_SH_IF_EXPRESSIONS
//
-/* This is currently a little broken... */
-//#define HANDLE_CONTINUATION_CHARS
+/* This is currently sortof broken, only for the brave... */
+#undef HANDLE_CONTINUATION_CHARS
+//
+/* This would be great -- if wordexp wouldn't strip all quoting
+ * out from the target strings... As is, a parser needs */
+#undef BB_FEATURE_SH_WORDEXP
//
//For debugging/development on the shell only...
//#define DEBUG_SHELL
#include <unistd.h>
#include <getopt.h>
-//#undef __GLIBC__
-//#undef __UCLIBC__
+#ifdef BB_LOCALE_SUPPORT
+#include <locale.h>
+#endif
+
+//#define BB_FEATURE_SH_WORDEXP
-#if ( (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) ) || defined (__UCLIBC__)
+#ifdef BB_FEATURE_SH_WORDEXP
#include <wordexp.h>
#define expand_t wordexp_t
#undef BB_FEATURE_SH_BACKTICKS
#include "cmdedit.h"
-static const int MAX_LINE = 256; /* size of input buffer for cwd data */
static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
/* function prototypes for builtins */
static int builtin_cd(struct child_prog *cmd);
-static int builtin_env(struct child_prog *dummy);
static int builtin_exec(struct child_prog *cmd);
static int builtin_exit(struct child_prog *cmd);
static int builtin_fg_bg(struct child_prog *cmd);
/* Table of forking built-in functions (things that fork cannot change global
* variables in the parent process, such as the current working directory) */
static struct built_in_command bltins_forking[] = {
- {"env", "Print all environment variables", builtin_env},
{"pwd", "Print current directory", builtin_pwd},
{"help", "List shell built-in commands", builtin_help},
{NULL, NULL, NULL}
static char syntax_err[]="syntax error near unexpected token";
#endif
+static char *PS1;
+static char *PS2 = "> ";
+
+
#ifdef DEBUG_SHELL
static inline void debug_printf(const char *format, ...)
{
builtin previous use notes
------ ----------------- ---------
cd cmd->progs[0]
-env 0
exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
exit cmd->progs[0]
fg_bg cmd->progs[0], job_list->head, job_list->fg
help 0
jobs job_list->head
pwd 0
-export cmd->progs[0] passes cmd, job_list to builtin_env(), which ignores them
+export cmd->progs[0]
source cmd->progs[0]
unset cmd->progs[0]
read cmd->progs[0]
else
newdir = child->argv[1];
if (chdir(newdir)) {
- printf("cd: %s: %s\n", newdir, strerror(errno));
+ printf("cd: %s: %m\n", newdir);
return EXIT_FAILURE;
}
- getcwd(cwd, sizeof(char)*MAX_LINE);
+ cwd = xgetcwd(cwd);
return EXIT_SUCCESS;
}
-/* built-in 'env' handler */
-static int builtin_env(struct child_prog *dummy)
-{
- char **e;
-
- for (e = environ; *e; e++) {
- printf( "%s\n", *e);
- }
- return (0);
-}
-
/* built-in 'exec' handler */
static int builtin_exec(struct child_prog *child)
{
/* built-in 'pwd' handler */
static int builtin_pwd(struct child_prog *dummy)
{
- getcwd(cwd, MAX_LINE);
printf( "%s\n", cwd);
return EXIT_SUCCESS;
}
static int builtin_export(struct child_prog *child)
{
int res;
+ char *v = child->argv[1];
- if (child->argv[1] == NULL) {
- return (builtin_env(child));
+ if (v == NULL) {
+ char **e;
+ for (e = environ; *e; e++) {
+ printf( "%s\n", *e);
+ }
+ return 0;
}
- res = putenv(child->argv[1]);
+ res = putenv(v);
if (res)
- fprintf(stderr, "export: %s\n", strerror(errno));
+ fprintf(stderr, "export: %m\n");
+#ifndef BB_FEATURE_SH_SIMPLE_PROMPT
+ if (strncmp(v, "PS1=", 4)==0)
+ PS1 = getenv("PS1");
+#endif
+
+#ifdef BB_LOCALE_SUPPORT
+ if(strncmp(v, "LC_ALL=", 7)==0)
+ setlocale(LC_ALL, getenv("LC_ALL"));
+ if(strncmp(v, "LC_CTYPE=", 9)==0)
+ setlocale(LC_CTYPE, getenv("LC_CTYPE"));
+#endif
+
return (res);
}
if((s = strdup(string)))
res = putenv(s);
if (res)
- fprintf(stderr, "read: %s\n", strerror(errno));
+ fprintf(stderr, "read: %m\n");
}
else
fgets(string, sizeof(string), stdin);
*/
static int run_command_predicate(char *cmd)
{
- int n=strlen(cmd);
- local_pending_command = xmalloc(n+1);
- strncpy(local_pending_command, cmd, n);
- local_pending_command[n]='\0';
+ local_pending_command = xstrdup(cmd);
return( busy_loop(NULL));
}
#endif
static void free_job(struct job *cmd)
{
int i;
+ struct jobset *keep;
for (i = 0; i < cmd->num_progs; i++) {
free(cmd->progs[i].argv);
if (cmd->progs[i].redirects)
free(cmd->progs[i].redirects);
}
- free(cmd->progs);
+ if (cmd->progs)
+ free(cmd->progs);
if (cmd->text)
free(cmd->text);
- free(cmd->cmdbuf);
+ if (cmd->cmdbuf)
+ free(cmd->cmdbuf);
+ keep = cmd->job_list;
memset(cmd, 0, sizeof(struct job));
+ cmd->job_list = keep;
}
-/* remove a job from the job_list */
-static void remove_job(struct jobset *job_list, struct job *job)
+/* remove a job from a jobset */
+static void remove_job(struct jobset *j_list, struct job *job)
{
struct job *prevjob;
free_job(job);
- if (job == job_list->head) {
- job_list->head = job->next;
+ if (job == j_list->head) {
+ j_list->head = job->next;
} else {
- prevjob = job_list->head;
+ prevjob = j_list->head;
while (prevjob->next != job)
prevjob = prevjob->next;
prevjob->next = job->next;
/* Checks to see if any background processes have exited -- if they
have, figure out why and see if a job has completed */
-static void checkjobs(struct jobset *job_list)
+static void checkjobs(struct jobset *j_list)
{
struct job *job;
pid_t childpid;
int prognum = 0;
while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
- for (job = job_list->head; job; job = job->next) {
+ for (job = j_list->head; job; job = job->next) {
prognum = 0;
while (prognum < job->num_progs &&
job->progs[prognum].pid != childpid) prognum++;
if (!job->running_progs) {
printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
- remove_job(job_list, job);
+ remove_job(j_list, job);
}
} else {
/* child stopped */
if (openfd < 0) {
/* this could get lost if stderr has been redirected, but
bash and ash both lose it as well (though zsh doesn't!) */
- error_msg("error opening %s: %s", redir->filename,
- strerror(errno));
+ perror_msg("error opening %s", redir->filename);
return 1;
}
}
}
-#if defined(BB_FEATURE_SH_SIMPLE_PROMPT)
-static char* setup_prompt_string(int state)
+static inline void cmdedit_set_initial_prompt(void)
{
- char prompt_str[BUFSIZ];
-
- /* Set up the prompt */
- if (state == 0) {
- /* simple prompt */
- sprintf(prompt_str, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
- } else {
- strcpy(prompt_str,"> ");
- }
-
- return(strdup(prompt_str)); /* Must free this memory */
-}
-
+#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
+ PS1 = NULL;
#else
+ PS1 = getenv("PS1");
+ if(PS1==0)
+ PS1 = "\\w \\$ ";
+#endif
+}
-static char* setup_prompt_string(int state)
+static inline void setup_prompt_string(char **prompt_str)
{
- char user[9],buf[255],*s;
- char prompt[3];
- char prompt_str[BUFSIZ];
-
+#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
/* Set up the prompt */
- if (state == 0) {
- /* get User Name and setup prompt */
- strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
- my_getpwuid(user, geteuid());
-
- /* get HostName */
- gethostname(buf, 255);
- s = strchr(buf, '.');
- if (s) {
- *s = 0;
- }
- } else {
- strcpy(prompt,"> ");
- }
-
- if (state == 0) {
- snprintf(prompt_str, BUFSIZ-1, "[%s@%s %s]%s", user, buf,
- get_last_path_component(cwd), prompt);
+ if (shell_context == 0) {
+ if (PS1)
+ free(PS1);
+ PS1=xmalloc(strlen(cwd)+4);
+ sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
+ *prompt_str = PS1;
} else {
- sprintf(prompt_str, "%s", prompt);
+ *prompt_str = PS2;
}
- return(strdup(prompt_str)); /* Must free this memory */
+#else
+ *prompt_str = (shell_context==0)? PS1 : PS2;
+#endif
}
-#endif
-
static int get_command(FILE * source, char *command)
{
char *prompt_str;
}
if (source == stdin) {
- prompt_str = setup_prompt_string(shell_context);
+ setup_prompt_string(&prompt_str);
-#ifdef BB_FEATURE_SH_COMMAND_EDITING
+#ifdef BB_FEATURE_COMMAND_EDITING
/*
** enable command line editing only while a command line
** is actually being read; otherwise, we'll end up bequeathing
*/
cmdedit_read_input(prompt_str, command);
cmdedit_terminate();
- free(prompt_str);
return 0;
#else
fputs(prompt_str, stdout);
- free(prompt_str);
#endif
}
return 1;
}
- /* remove trailing newline */
- chomp(command);
-
return 0;
}
}
#endif
+#if defined BB_FEATURE_SH_ENVIRONMENT && ! defined BB_FEATURE_SH_WORDEXP
+char * strsep_space( char *string, int * ix)
+{
+ char *token, *begin;
+
+ begin = string;
+
+ /* Short circuit the trivial case */
+ if ( !string || ! string[*ix])
+ return NULL;
+
+ /* Find the end of the token. */
+ while( string && string[*ix] && !isspace(string[*ix]) ) {
+ (*ix)++;
+ }
+
+ /* Find the end of any whitespace trailing behind
+ * the token and let that be part of the token */
+ while( string && string[*ix] && isspace(string[*ix]) ) {
+ (*ix)++;
+ }
+
+ if (! string && *ix==0) {
+ /* Nothing useful was found */
+ return NULL;
+ }
+
+ token = xmalloc(*ix+1);
+ token[*ix] = '\0';
+ strncpy(token, string, *ix);
+
+ return token;
+}
+#endif
+
+
static int expand_arguments(char *command)
{
#ifdef BB_FEATURE_SH_ENVIRONMENT
expand_t expand_result;
char *src, *dst, *var;
+ int ix = 0;
int i=0, length, total_length=0, retval;
const char *out_of_space = "out of space during expansion";
#endif
/* get rid of the terminating \n */
chomp(command);
+
+ /* Fix up escape sequences to be the Real Thing(tm) */
+ while( command && command[ix]) {
+ if (command[ix] == '\\') {
+ const char *tmp = command+ix+1;
+ command[ix] = process_escape_sequence( &tmp );
+ memmove(command+ix + 1, tmp, strlen(tmp)+1);
+ }
+ ix++;
+ }
#ifdef BB_FEATURE_SH_ENVIRONMENT
-#if ( (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) ) || defined (__UCLIBC__)
+#ifdef BB_FEATURE_SH_WORDEXP
/* This first part uses wordexp() which is a wonderful C lib
* function which expands nearly everything. */
- retval = wordexp (command, &expand_result, 0);
+ retval = wordexp (command, &expand_result, WRDE_SHOWERR);
if (retval == WRDE_NOSPACE) {
/* Mem may have been allocated... */
wordfree (&expand_result);
* (char*) into cmd (char**, one word per string) */
{
- int flags = GLOB_NOCHECK|GLOB_BRACE|GLOB_TILDE;
- char * tmpcmd;
+ int flags = GLOB_NOCHECK
+#ifdef GLOB_BRACE
+ | GLOB_BRACE
+#endif
+#ifdef GLOB_TILDE
+ | GLOB_TILDE
+#endif
+ ;
+ char *tmpcmd, *cmd, *cmd_copy;
/* We need a clean copy, so strsep can mess up the copy while
* we write stuff into the original (in a minute) */
- char * cmd = strdup(command);
+ cmd = cmd_copy = strdup(command);
*command = '\0';
- for (tmpcmd = cmd; (tmpcmd = strsep(&cmd, " \t")) != NULL;) {
+ for (ix = 0, tmpcmd = cmd;
+ (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
if (*tmpcmd == '\0')
break;
retval = glob(tmpcmd, flags, NULL, &expand_result);
+ free(tmpcmd); /* Free mem allocated by strsep_space */
if (retval == GLOB_NOSPACE) {
/* Mem may have been allocated... */
globfree (&expand_result);
/* Convert from char** (one word per string) to a simple char*,
* but don't overflow command which is BUFSIZ in length */
for (i=0; i < expand_result.gl_pathc; i++) {
- length=strlen(expand_result.gl_pathv[i])+1;
- if (BUFSIZ-total_length-length <= 0) {
+ length=strlen(expand_result.gl_pathv[i]);
+ if (total_length+length+1 >= BUFSIZ) {
error_msg(out_of_space);
return FALSE;
}
+ if (i>0) {
+ strcat(command+total_length, " ");
+ total_length+=1;
+ }
strcat(command+total_length, expand_result.gl_pathv[i]);
- strcat(command+total_length, " ");
total_length+=length;
}
globfree (&expand_result);
}
}
- free(cmd);
+ free(cmd_copy);
trim(command);
}
case '0':case '1':case '2':case '3':case '4':
case '5':case '6':case '7':case '8':case '9':
{
- int index=*(dst + 1)-48;
- if (index >= argc) {
+ int ixx=*(dst + 1)-48;
+ if (ixx >= argc) {
var='\0';
} else {
- var = argv[index];
+ var = argv[ixx];
}
}
break;
} else {
/* Looks like an environment variable */
char delim_hold;
- int num_skip_chars=1;
+ int num_skip_chars=0;
int dstlen = strlen(dst);
/* Is this a ${foo} type variable? */
if (dstlen >=2 && *(dst+1) == '{') {
src=strchr(dst+1, '}');
- num_skip_chars=2;
+ num_skip_chars=1;
} else {
- src=strpbrk(dst+1, " \t~`!$^&*()=|\\[];\"'<>?./");
+ src=dst+1;
+ while(isalnum(*src) || *src=='_') src++;
}
if (src == NULL) {
src = dst+dstlen;
}
delim_hold=*src;
*src='\0'; /* temporary */
- var = getenv(dst + num_skip_chars);
+ var = getenv(dst + 1 + num_skip_chars);
*src=delim_hold;
- if (num_skip_chars==2) {
- src++;
- }
+ src += num_skip_chars;
}
if (var == NULL) {
/* Seems we got an un-expandable variable. So delete it. */
}
/* Move stuff to the end of the string to accommodate
* filling the created gap with the new stuff */
- memmove(dst+subst_len, src, trail_len);
- *(dst+subst_len+trail_len)='\0';
+ memmove(dst+subst_len, src, trail_len+1);
/* Now copy in the new stuff */
memcpy(dst, var, subst_len);
src = dst+subst_len;
int argc_l = 0;
int done = 0;
int argv_alloced;
- int i;
+ int i, saw_quote = 0;
char quote = '\0';
int count;
struct child_prog *prog;
*src == ']') *buf++ = '\\';
*buf++ = *src;
} else if (isspace(*src)) {
- if (*prog->argv[argc_l]) {
+ if (*prog->argv[argc_l] || saw_quote) {
buf++, argc_l++;
/* +1 here leaves room for the NULL which ends argv */
if ((argc_l + 1) == argv_alloced) {
argv_alloced);
}
prog->argv[argc_l] = buf;
+ saw_quote = 0;
}
} else
switch (*src) {
case '"':
case '\'':
quote = *src;
+ saw_quote = 1;
break;
case '#': /* comment */
chptr++;
if (!*chptr) {
- error_msg("file name expected after %c", *src);
+ error_msg("file name expected after %c", *(src-1));
free_job(job);
job->num_progs=0;
return 1;
case '|': /* pipe */
/* finish this command */
- if (*prog->argv[argc_l])
+ if (*prog->argv[argc_l] || saw_quote)
argc_l++;
if (!argc_l) {
error_msg("empty command in pipe");
break;
#else
error_msg("character expected after \\");
- free(command);
free_job(job);
return 1;
#endif
src++;
}
- if (*prog->argv[argc_l]) {
+ if (*prog->argv[argc_l] || saw_quote) {
argc_l++;
}
if (!argc_l) {
#endif
{
- char** argv=child->argv;
+ char** argv_l=child->argv;
int argc_l;
- for(argc_l=0;*argv!=NULL; argv++, argc_l++);
+ for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
optind = 1;
run_applet_by_name(name, argc_l, child->argv);
}
static void insert_job(struct job *newjob, int inbg)
{
struct job *thejob;
- struct jobset *job_list=newjob->job_list;
+ struct jobset *j_list=newjob->job_list;
/* find the ID for thejob to use */
newjob->jobid = 1;
- for (thejob = job_list->head; thejob; thejob = thejob->next)
+ for (thejob = j_list->head; thejob; thejob = thejob->next)
if (thejob->jobid >= newjob->jobid)
newjob->jobid = thejob->jobid + 1;
/* add thejob to the list of running jobs */
- if (!job_list->head) {
- thejob = job_list->head = xmalloc(sizeof(*thejob));
+ if (!j_list->head) {
+ thejob = j_list->head = xmalloc(sizeof(*thejob));
} else {
- for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
+ for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
thejob->next = xmalloc(sizeof(*thejob));
thejob = thejob->next;
}
if (!parse_command(&next_command, &newjob, &inbg) &&
newjob.num_progs) {
int pipefds[2] = {-1,-1};
- debug_printf( "job=%p being fed to run_command by busy_loop()'\n", &newjob);
+ debug_printf( "job=%p fed to run_command by busy_loop()'\n",
+ &newjob);
run_command(&newjob, inbg, pipefds);
}
else {
#ifdef BB_FEATURE_CLEAN_UP
void free_memory(void)
{
- if (cwd)
+ if (cwd) {
free(cwd);
+ cwd = NULL;
+ }
if (local_pending_command)
free(local_pending_command);
/* These variables need re-initializing when recursing */
shell_context = 0;
- cwd=NULL;
local_pending_command = NULL;
close_me_head = NULL;
job_list.head = NULL;
if (interactive==TRUE) {
//printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
/* Looks like they want an interactive shell */
- printf( "\n\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
+ printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
printf( "Enter 'help' for a list of built-in commands.\n\n");
} else if (local_pending_command==NULL) {
//printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
}
/* initialize the cwd -- this is never freed...*/
- cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
- getcwd(cwd, sizeof(char)*MAX_LINE);
+ cwd = xgetcwd(0);
#ifdef BB_FEATURE_CLEAN_UP
atexit(free_memory);
#endif
+#ifdef BB_FEATURE_COMMAND_EDITING
+ cmdedit_set_initial_prompt();
+#else
+ PS1 = NULL;
+#endif
+
return (busy_loop(input));
}
+