X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=builtins%2Fenable.def;h=b6ac48338674f8e5cffa34588e88e1bb26850d3a;hb=28ef6c316f1aff914bb95ac09787a3c83c1815fd;hp=2aeae39db1a7cda354e502962c296f6e51f65593;hpb=726f63884db0132f01745f1fb4465e6621088ccf;p=thirdparty%2Fbash.git diff --git a/builtins/enable.def b/builtins/enable.def index 2aeae39db..b6ac48338 100644 --- a/builtins/enable.def +++ b/builtins/enable.def @@ -7,7 +7,7 @@ This file is part of GNU Bash, the Bourne Again SHell. Bash is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free -Software Foundation; either version 1, or (at your option) any later +Software Foundation; either version 2, or (at your option) any later version. Bash is distributed in the hope that it will be useful, but WITHOUT ANY @@ -17,26 +17,67 @@ for more details. You should have received a copy of the GNU General Public License along with Bash; see the file COPYING. If not, write to the Free Software -Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. +Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. $PRODUCES enable.c $BUILTIN enable $FUNCTION enable_builtin -$SHORT_DOC enable [-n] [name ...] +$SHORT_DOC enable [-pnds] [-a] [-f filename] [name ...] Enable and disable builtin shell commands. This allows you to use a disk command which has the same name as a shell -builtin. If -n is used, the NAMEs become disabled. Otherwise -NAMEs are enabled. For example, to use the `test' found on your -path instead of the shell builtin version, you type `enable -n test'. +builtin without specifying a full pathname. If -n is used, the +NAMEs become disabled; otherwise NAMEs are enabled. For example, +to use the `test' found in $PATH instead of the shell builtin +version, type `enable -n test'. On systems supporting dynamic +loading, the -f option may be used to load new builtins from the +shared object FILENAME. The -d option will delete a builtin +previously loaded with -f. If no non-option names are given, or +the -p option is supplied, a list of builtins is printed. The +-a option means to print every builtin with an indication of whether +or not it is enabled. The -s option restricts the output to the POSIX.2 +`special' builtins. The -n option displays a list of all disabled builtins. $END +#include + +#if defined (HAVE_UNISTD_H) +# ifdef _MINIX +# include +# endif +# include +#endif + +#include +#include "../bashansi.h" #include "../shell.h" #include "../builtins.h" +#include "../flags.h" #include "common.h" +#include "bashgetopt.h" + +#if defined (PROGRAMMABLE_COMPLETION) +# include "../pcomplete.h" +#endif + +#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM) +static int dyn_load_builtin (); +#endif + +#if defined (HAVE_DLCLOSE) +static int dyn_unload_builtin (); +#endif #define ENABLED 1 #define DISABLED 2 +#define SPECIAL 4 + +#define AFLAG 0x01 +#define DFLAG 0x02 +#define FFLAG 0x04 +#define NFLAG 0x08 +#define PFLAG 0x10 +#define SFLAG 0x20 static int enable_shell_command (); static void list_some_builtins (); @@ -44,61 +85,123 @@ static void list_some_builtins (); /* Enable/disable shell commands present in LIST. If list is not specified, then print out a list of shell commands showing which are enabled and which are disabled. */ +int enable_builtin (list) WORD_LIST *list; { - int result = 0, any_failed = 0; - int disable_p, all_p; + int result, flags; + int opt, filter; +#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM) + char *filename; +#endif - disable_p = all_p = 0; + result = EXECUTION_SUCCESS; + flags = 0; - while (list && list->word->word && list->word->word[0] == '-') + reset_internal_getopt (); + while ((opt = internal_getopt (list, "adnpsf:")) != -1) { - char *arg = list->word->word; - - list = list->next; - - if (ISOPTION (arg, 'n')) - disable_p = 1; - else if (arg[1] == 'a' && (arg[2] == 0 || strcmp (arg + 2, "ll") == 0)) - all_p = 1; - else if (ISOPTION (arg, '-')) - break; - else + switch (opt) { - bad_option (arg); - return (EXECUTION_FAILURE); + case 'a': + flags |= AFLAG; + break; + case 'n': + flags |= NFLAG; + break; + case 'p': + flags |= PFLAG; + break; + case 's': + flags |= SFLAG; + break; + case 'f': +#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM) + flags |= FFLAG; + filename = list_optarg; + break; +#else + builtin_error ("dynamic loading not available"); + return (EX_USAGE); +#endif +#if defined (HAVE_DLCLOSE) + case 'd': + flags |= DFLAG; + break; +#else + builtin_error ("dynamic loading not available"); + return (EX_USAGE); +#endif /* HAVE_DLCLOSE */ + default: + builtin_usage (); + return (EX_USAGE); } } - if (!list) + list = loptend; + +#if defined (RESTRICTED_SHELL) + /* Restricted shells cannot load new builtins. */ + if (restricted && (flags & (FFLAG|DFLAG))) { - int filter; + builtin_error ("restricted"); + return (EXECUTION_FAILURE); + } +#endif - if (all_p) - filter = ENABLED | DISABLED; - else if (disable_p) - filter = DISABLED; - else - filter = ENABLED; + if (list == 0 || (flags & PFLAG)) + { + filter = (flags & AFLAG) ? (ENABLED | DISABLED) + : (flags & NFLAG) ? DISABLED : ENABLED; + + if (flags & SFLAG) + filter |= SPECIAL; list_some_builtins (filter); } +#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM) + else if (flags & FFLAG) + { + filter = (flags & NFLAG) ? DISABLED : ENABLED; + if (flags & SFLAG) + filter |= SPECIAL; + + result = dyn_load_builtin (list, filter, filename); +#if defined (PROGRAMMABLE_COMPLETION) + set_itemlist_dirty (&it_builtins); +#endif + } +#endif +#if defined (HAVE_DLCLOSE) + else if (flags & DFLAG) + { + while (list) + { + opt = dyn_unload_builtin (list->word->word); + if (opt == EXECUTION_FAILURE) + result = EXECUTION_FAILURE; + list = list->next; + } +#if defined (PROGRAMMABLE_COMPLETION) + set_itemlist_dirty (&it_builtins); +#endif + } +#endif else { while (list) { - result = enable_shell_command (list->word->word, disable_p); + opt = enable_shell_command (list->word->word, flags & NFLAG); - if (!result) + if (opt == EXECUTION_FAILURE) { builtin_error ("%s: not a shell builtin", list->word->word); - any_failed++; + result = EXECUTION_FAILURE; } list = list->next; } } - return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS); + return (result); } /* List some builtins. @@ -111,19 +214,18 @@ list_some_builtins (filter) for (i = 0; i < num_shell_builtins; i++) { - if (!shell_builtins[i].function) + if (shell_builtins[i].function == 0 || (shell_builtins[i].flags & BUILTIN_DELETED)) continue; - if ((filter & ENABLED) && - (shell_builtins[i].flags & BUILTIN_ENABLED)) - { - printf ("enable %s\n", shell_builtins[i].name); - } + if ((filter & SPECIAL) && + (shell_builtins[i].flags & SPECIAL_BUILTIN) == 0) + continue; + + if ((filter & ENABLED) && (shell_builtins[i].flags & BUILTIN_ENABLED)) + printf ("enable %s\n", shell_builtins[i].name); else if ((filter & DISABLED) && ((shell_builtins[i].flags & BUILTIN_ENABLED) == 0)) - { - printf ("enable -n %s\n", shell_builtins[i].name); - } + printf ("enable -n %s\n", shell_builtins[i].name); } } @@ -134,23 +236,229 @@ enable_shell_command (name, disable_p) char *name; int disable_p; { - register int i; - int found = 0; + struct builtin *b; - for (i = 0; i < num_shell_builtins; i++) + b = builtin_address_internal (name, 1); + if (b == 0) + return (EXECUTION_FAILURE); + + if (disable_p) + b->flags &= ~BUILTIN_ENABLED; + else + b->flags |= BUILTIN_ENABLED; + +#if defined (PROGRAMMABLE_COMPLETION) + set_itemlist_dirty (&it_enabled); + set_itemlist_dirty (&it_disabled); +#endif + + return (EXECUTION_SUCCESS); +} + +#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM) + +#if defined (HAVE_DLFCN_H) +# include +#endif + +static int +dyn_load_builtin (list, flags, filename) + WORD_LIST *list; + int flags; + char *filename; +{ + WORD_LIST *l; + void *handle; + + int total, size, new, replaced; + char *struct_name, *name; + struct builtin **new_builtins, *b, *new_shell_builtins, *old_builtin; + + if (list == 0) + return (EXECUTION_FAILURE); + +#ifndef RTLD_LAZY +#define RTLD_LAZY 1 +#endif + +#if defined (_AIX) + handle = dlopen (filename, RTLD_NOW|RTLD_GLOBAL); +#else + handle = dlopen (filename, RTLD_LAZY); +#endif /* !_AIX */ + + if (handle == 0) { - if (!shell_builtins[i].function) - continue; + builtin_error ("cannot open shared object %s: %s", filename, dlerror ()); + return (EXECUTION_FAILURE); + } + + for (new = 0, l = list; l; l = l->next, new++) + ; + new_builtins = (struct builtin **)xmalloc (new * sizeof (struct builtin *)); - if (STREQ (name, shell_builtins[i].name)) + /* For each new builtin in the shared object, find it and its describing + structure. If this is overwriting an existing builtin, do so, otherwise + save the loaded struct for creating the new list of builtins. */ + for (replaced = new = 0; list; list = list->next) + { + name = list->word->word; + + size = strlen (name); + struct_name = xmalloc (size + 8); + strcpy (struct_name, name); + strcpy (struct_name + size, "_struct"); + + b = (struct builtin *)dlsym (handle, struct_name); + if (b == 0) { - found++; + builtin_error ("cannot find %s in shared object %s: %s", struct_name, + filename, dlerror ()); + free (struct_name); + continue; + } - if (disable_p) - shell_builtins[i].flags &= ~BUILTIN_ENABLED; - else - shell_builtins[i].flags |= BUILTIN_ENABLED; + free (struct_name); + + b->flags &= ~STATIC_BUILTIN; + if (flags & SPECIAL) + b->flags |= SPECIAL_BUILTIN; + b->handle = handle; + + if (old_builtin = builtin_address_internal (name, 1)) + { + replaced++; + FASTCOPY ((char *)b, (char *)old_builtin, sizeof (struct builtin)); } + else + new_builtins[new++] = b; + } + + if (replaced == 0 && new == 0) + { + free (new_builtins); + dlclose (handle); + return (EXECUTION_FAILURE); } - return (found); + + if (new) + { + total = num_shell_builtins + new; + size = (total + 1) * sizeof (struct builtin); + + new_shell_builtins = (struct builtin *)xmalloc (size); + FASTCOPY ((char *)shell_builtins, (char *)new_shell_builtins, + num_shell_builtins * sizeof (struct builtin)); + for (replaced = 0; replaced < new; replaced++) + FASTCOPY ((char *)new_builtins[replaced], + (char *)&new_shell_builtins[num_shell_builtins + replaced], + sizeof (struct builtin)); + + new_shell_builtins[total].name = (char *)0; + new_shell_builtins[total].function = (Function *)0; + new_shell_builtins[total].flags = 0; + + if (shell_builtins != static_shell_builtins) + free (shell_builtins); + + shell_builtins = new_shell_builtins; + num_shell_builtins = total; + initialize_shell_builtins (); + } + + free (new_builtins); + return (EXECUTION_SUCCESS); +} +#endif + +#if defined (HAVE_DLCLOSE) +static void +delete_builtin (b) + struct builtin *b; +{ + int ind, size; + struct builtin *new_shell_builtins; + + /* XXX - funky pointer arithmetic - XXX */ +#ifdef __STDC__ + ind = b - shell_builtins; +#else + ind = ((int)b - (int)shell_builtins) / sizeof (struct builtin); +#endif + size = num_shell_builtins * sizeof (struct builtin); + new_shell_builtins = (struct builtin *)xmalloc (size); + + /* Copy shell_builtins[0]...shell_builtins[ind - 1] to new_shell_builtins */ + if (ind) + FASTCOPY ((char *)shell_builtins, (char *)new_shell_builtins, + ind * sizeof (struct builtin)); + /* Copy shell_builtins[ind+1]...shell_builtins[num_shell_builtins to + new_shell_builtins, starting at ind. */ + FASTCOPY ((char *)(&shell_builtins[ind+1]), + (char *)(&new_shell_builtins[ind]), + (num_shell_builtins - ind) * sizeof (struct builtin)); + + if (shell_builtins != static_shell_builtins) + free (shell_builtins); + + /* The result is still sorted. */ + num_shell_builtins--; + shell_builtins = new_shell_builtins; +} + +/* Tenon's MachTen has a dlclose that doesn't return a value, so we + finesse it with a local wrapper. */ +static int +local_dlclose (handle) + void *handle; +{ +#if !defined (__MACHTEN__) + return (dlclose (handle)); +#else /* __MACHTEN__ */ + dlclose (handle); + return ((dlerror () != NULL) ? -1 : 0); +#endif /* __MACHTEN__ */ +} + +static int +dyn_unload_builtin (name) + char *name; +{ + struct builtin *b; + void *handle; + int ref, i; + char *uerror; + + b = builtin_address_internal (name, 1); + if (b == 0) + { + builtin_error ("%s: not a shell builtin", name); + return (EXECUTION_FAILURE); + } + if (b->flags & STATIC_BUILTIN) + { + builtin_error ("%s: not dynamically loaded", name); + return (EXECUTION_FAILURE); + } + + handle = (void *)b->handle; + for (ref = i = 0; i < num_shell_builtins; i++) + { + if (shell_builtins[i].handle == b->handle) + ref++; + } + + /* Don't remove the shared object unless the reference count of builtins + using it drops to zero. */ + if (ref == 1 && local_dlclose (handle) != 0) + { + builtin_error ("cannot delete %s: %s", name, dlerror ()); + return (EXECUTION_FAILURE); + } + + /* Now remove this entry from the builtin table and reinitialize. */ + delete_builtin (b); + + return (EXECUTION_SUCCESS); } +#endif