lib-src/env.c

   1 /* env - manipulate environment and execute a program in that environment
   2    Copyright (C) 1986 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 /* Mly 861126 */
  19
  20 /* If first argument is "-", then a new environment is constructed
  21    from scratch; otherwise the environment is inherited from the parent
  22    process, except as modified by other options.
  23
  24    So, "env - foo" will invoke the "foo" program in a null environment,
  25    whereas "env foo" would invoke "foo" in the same environment as that
  26    passed to "env" itself.
  27
  28    Subsequent arguments are interpreted as follows:
  29
  30    * "variable=value" (i.e., an arg containing a "=" character)
  31      means to set the specified environment variable to that value.
  32      `value' may be of zero length ("variable=").  Note that setting
  33      a variable to a zero-length value is different from unsetting it.
  34
  35    * "-u variable" or "-unset variable"
  36      means to unset that variable.
  37      If that variable isn't set, does nothing.
  38
  39    * "-s variable value" or "-set variable value"
  40      same as "variable=value".
  41
  42    * "-" or "--"
  43      are used to indicate that the following argument is the program
  44      to invoke.  This is only necessary when the program's name
  45      begins with "-" or contains a "=".
  46
  47    * anything else
  48      The first remaining argument specifies a program to invoke
  49      (it is searched for according to the specification of the PATH
  50      environment variable) and any arguments following that are
  51      passed as arguments to that program.
  52
  53      If no program-name is specified following the environment
  54      specifications, the resulting environment is printed.
  55      This is like specifying a program-name of "printenv".
  56
  57    Examples:
  58      If the environment passed to "env" is
  59      { USER=rms EDITOR=emacs PATH=.:/gnubin:/hacks }
  60
  61      * "env DISPLAY=gnu:0 nemacs"
  62         calls "nemacs" in the envionment
  63         { USER=rms EDITOR=emacs PATH=.:/gnubin:/hacks DISPLAY=gnu:0 }
  64
  65      * "env - USER=foo /hacks/hack bar baz"
  66        calls the "hack" program on arguments "bar" and "baz"
  67        in an environment in which the only variable is "USER".
  68        Note that the "-" option clears out the PATH variable,
  69        so one should be careful to specify in which directory
  70        to find the program to call.
  71
  72      * "env -u EDITOR USER=foo PATH=/energy -- e=mc2 bar baz"
  73        The program "/energy/e=mc2" is called with environment
  74        { USER=foo PATH=/energy }
  75 */
  76
  77 #ifdef EMACS
  78 #define NO_SHORTNAMES
  79 #include "../src/config.h"
  80 #endif /* EMACS */
  81
  82 #include <stdio.h>
  83
  84 extern int execvp ();
  85
  86 char *xmalloc (), *xrealloc ();
  87 char *concat ();
  88
  89 extern char **environ;
  90
  91 char **nenv;
  92 int nenv_size;
  93
  94 char *progname;
  95 void setenv ();
  96 void fatal ();
  97 char *myindex ();
  98
  99 main (argc, argv, envp)
 100      register int argc;
 101      register char **argv;
 102      char **envp;
 103 {
 104   register char *tem;
 105
 106   progname = argv[0];
 107   argc--;
 108   argv++;
 109
 110   nenv_size = 100;
 111   nenv = (char **) xmalloc (nenv_size * sizeof (char *));
 112   *nenv = (char *) 0;
 113
 114   /* "-" flag means to not inherit parent's environment */
 115   if (argc && !strcmp (*argv, "-"))
 116     {
 117       argc--;
 118       argv++;
 119     }
 120   else
 121     /* Else pass on existing env vars. */
 122     for (; *envp; envp++)
 123       {
 124         tem = myindex (*envp, '=');
 125         if (tem)
 126           {
 127             *tem = '\000';
 128             setenv (*envp, tem + 1);
 129           }
 130       }
 131
 132   while (argc > 0)
 133     {
 134       tem = myindex (*argv, '=');
 135       if (tem)
 136         /* If arg contains a "=" it specifies to set a variable */
 137         {
 138           *tem = '\000';
 139           setenv (*argv, tem + 1);
 140           argc--;
 141           argv++;
 142           continue;
 143         }
 144
 145       if (**argv != '-')
 146         /* Remaining args are program name and args to pass it */
 147         break;
 148
 149       if (argc < 2)
 150         fatal ("no argument for `%s' option", *argv);
 151       if (!strcmp (*argv, "-u")
 152           || !strcmp (*argv, "-unset"))
 153         /* Unset a variable */
 154         {
 155           argc--;
 156           argv++;
 157           setenv (*argv, (char *) 0);
 158           argc--;
 159           argv++;
 160         }
 161       else if (!strcmp (*argv, "-s") ||
 162                !strcmp (*argv, "-set"))
 163         /* Set a variable */
 164         {
 165           argc--;
 166           argv++;
 167           tem = *argv;
 168           if (argc < 2)
 169             fatal ("no value specified for variable \"%s\"", tem);
 170           argc--;
 171           argv++;
 172           setenv (tem, *argv);
 173           argc--;
 174           argv++;
 175         }
 176       else if (!strcmp (*argv, "-") || !strcmp (*argv, "--"))
 177         {
 178           argc--;
 179           argv++;
 180           break;
 181         }
 182       else
 183         {
 184           fatal ("unrecognized option `%s'", *argv);
 185         }
 186     }
 187
 188   /* If no program specified print the environment and exit */
 189   if (argc <= 0)
 190     {
 191       while (*nenv)
 192         printf ("%s\n", *nenv++);
 193       exit (0);
 194     }
 195   else
 196     {
 197       extern int errno, sys_nerr;
 198       extern char *sys_errlist[];
 199
 200       environ = nenv;
 201       (void) execvp (*argv, argv);
 202
 203       fprintf (stderr, "%s: cannot execute `%s'", progname, *argv);
 204       if (errno < sys_nerr)
 205         fprintf (stderr, ": %s\n", sys_errlist[errno]);
 206       else
 207         putc ('\n', stderr);
 208       exit (errno != 0 ? errno : 1);
 209     }
 210 }
 211
 212 void
 213 setenv (var, val)
 214      register char *var, *val;
 215 {
 216   register char **e;
 217   int len = strlen (var);
 218
 219   {
 220     register char *tem = myindex (var, '=');
 221     if (tem)
 222       fatal ("environment variable names can not contain `=': %s", var);
 223     else if (*var == '\000')
 224       fatal ("zero-length environment variable name specified");
 225   }
 226
 227   for (e = nenv; *e; e++)
 228     if (!strncmp (var, *e, len) && (*e)[len] == '=')
 229       {
 230         if (val)
 231           goto set;
 232         else
 233           do
 234             {
 235               *e = *(e + 1);
 236           } while (*e++);
 237         return;
 238       }
 239
 240   if (!val)
 241     return;                     /* Nothing to unset */
 242
 243   len = e - nenv;
 244   if (len + 1 >= nenv_size)
 245     {
 246       nenv_size += 100;
 247       nenv = (char **) xrealloc (nenv, nenv_size * sizeof (char *));
 248       e = nenv + len;
 249     }
 250
 251 set:
 252   val = concat (var, "=", val);
 253   if (*e)
 254     free (*e);
 255   else
 256     *(e + 1) = (char *) 0;
 257   *e = val;
 258   return;
 259 }
 260
 261 void
 262 fatal (msg, arg1, arg2)
 263      char *msg, *arg1, *arg2;
 264 {
 265   fprintf (stderr, "%s: ", progname);
 266   fprintf (stderr, msg, arg1, arg2);
 267   putc ('\n', stderr);
 268   exit (1);
 269 }
 270 \f
 271
 272 extern char *malloc (), *realloc ();
 273
 274 void
 275 memory_fatal ()
 276 {
 277   fatal ("virtual memory exhausted");
 278 }
 279
 280 char *
 281 xmalloc (size)
 282      int size;
 283 {
 284   register char *value;
 285   value = (char *) malloc (size);
 286   if (!value)
 287     memory_fatal ();
 288   return (value);
 289 }
 290
 291 char *
 292 xrealloc (ptr, size)
 293      char *ptr;
 294      int size;
 295 {
 296   register char *value;
 297   value = (char *) realloc (ptr, size);
 298   if (!value)
 299     memory_fatal ();
 300   return (value);
 301 }
 302
 303 /* Return a newly-allocated string whose contents concatenate
 304    those of S1, S2, S3.  */
 305
 306 char *
 307 concat (s1, s2, s3)
 308      char *s1, *s2, *s3;
 309 {
 310   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 311   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 312
 313   strcpy (result, s1);
 314   strcpy (result + len1, s2);
 315   strcpy (result + len1 + len2, s3);
 316   result[len1 + len2 + len3] = 0;
 317
 318   return result;
 319 }
 320
 321 /* Return a pointer to the first occurrence in STR of C,
 322    or 0 if C does not occur.  */
 323
 324 char *
 325 myindex (str, c)
 326      char *str;
 327      char c;
 328 {
 329   char *s = str;
 330
 331   while (*s)
 332     {
 333       if (*s == c)
 334         return s;
 335       s++;
 336     }
 337   return 0;
 338 }