gl/setenv.c

   1 /* Copyright (C) 1992,1995-1999,2000-2003,2005,2006 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   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 3, 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 along
  15    with this program; if not, see <http://www.gnu.org/licenses/>.  */
  16
  17 #if !_LIBC
  18 # include <config.h>
  19 #endif
  20 #include <alloca.h>
  21
  22 #include <errno.h>
  23 #ifndef __set_errno
  24 # define __set_errno(ev) ((errno) = (ev))
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #if _LIBC || HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32
  33 #if !_LIBC
  34 # include "allocsa.h"
  35 #endif
  36
  37 #if !_LIBC
  38 # define __environ      environ
  39 # ifndef HAVE_ENVIRON_DECL
  40 extern char **environ;
  41 # endif
  42 #endif
  43
  44 #if _LIBC
  45 /* This lock protects against simultaneous modifications of `environ'.  */
  46 # include <bits/libc-lock.h>
  47 __libc_lock_define_initialized (static, envlock)
  48 # define LOCK   __libc_lock_lock (envlock)
  49 # define UNLOCK __libc_lock_unlock (envlock)
  50 #else
  51 # define LOCK
  52 # define UNLOCK
  53 #endif
  54
  55 /* In the GNU C library we must keep the namespace clean.  */
  56 #ifdef _LIBC
  57 # define setenv __setenv
  58 # define clearenv __clearenv
  59 # define tfind __tfind
  60 # define tsearch __tsearch
  61 #endif
  62
  63 /* In the GNU C library implementation we try to be more clever and
  64    allow arbitrarily many changes of the environment given that the used
  65    values are from a small set.  Outside glibc this will eat up all
  66    memory after a while.  */
  67 #if defined _LIBC || (defined HAVE_SEARCH_H && defined HAVE_TSEARCH \
  68                       && defined __GNUC__)
  69 # define USE_TSEARCH    1
  70 # include <search.h>
  71 typedef int (*compar_fn_t) (const void *, const void *);
  72
  73 /* This is a pointer to the root of the search tree with the known
  74    values.  */
  75 static void *known_values;
  76
  77 # define KNOWN_VALUE(Str) \
  78   ({                                                                          \
  79     void *value = tfind (Str, &known_values, (compar_fn_t) strcmp);           \
  80     value != NULL ? *(char **) value : NULL;                                  \
  81   })
  82 # define STORE_VALUE(Str) \
  83   tsearch (Str, &known_values, (compar_fn_t) strcmp)
  84
  85 #else
  86 # undef USE_TSEARCH
  87
  88 # define KNOWN_VALUE(Str) NULL
  89 # define STORE_VALUE(Str) do { } while (0)
  90
  91 #endif
  92
  93
  94 /* If this variable is not a null pointer we allocated the current
  95    environment.  */
  96 static char **last_environ;
  97
  98
  99 /* This function is used by `setenv' and `putenv'.  The difference between
 100    the two functions is that for the former must create a new string which
 101    is then placed in the environment, while the argument of `putenv'
 102    must be used directly.  This is all complicated by the fact that we try
 103    to reuse values once generated for a `setenv' call since we can never
 104    free the strings.  */
 105 int
 106 __add_to_environ (const char *name, const char *value, const char *combined,
 107                   int replace)
 108 {
 109   register char **ep;
 110   register size_t size;
 111   const size_t namelen = strlen (name);
 112   const size_t vallen = value != NULL ? strlen (value) + 1 : 0;
 113
 114   LOCK;
 115
 116   /* We have to get the pointer now that we have the lock and not earlier
 117      since another thread might have created a new environment.  */
 118   ep = __environ;
 119
 120   size = 0;
 121   if (ep != NULL)
 122     {
 123       for (; *ep != NULL; ++ep)
 124         if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=')
 125           break;
 126         else
 127           ++size;
 128     }
 129
 130   if (ep == NULL || *ep == NULL)
 131     {
 132       char **new_environ;
 133 #ifdef USE_TSEARCH
 134       char *new_value;
 135 #endif
 136
 137       /* We allocated this space; we can extend it.  */
 138       new_environ =
 139         (char **) (last_environ == NULL
 140                    ? malloc ((size + 2) * sizeof (char *))
 141                    : realloc (last_environ, (size + 2) * sizeof (char *)));
 142       if (new_environ == NULL)
 143         {
 144           UNLOCK;
 145           return -1;
 146         }
 147
 148       /* If the whole entry is given add it.  */
 149       if (combined != NULL)
 150         /* We must not add the string to the search tree since it belongs
 151            to the user.  */
 152         new_environ[size] = (char *) combined;
 153       else
 154         {
 155           /* See whether the value is already known.  */
 156 #ifdef USE_TSEARCH
 157 # ifdef _LIBC
 158           new_value = (char *) alloca (namelen + 1 + vallen);
 159           __mempcpy (__mempcpy (__mempcpy (new_value, name, namelen), "=", 1),
 160                      value, vallen);
 161 # else
 162           new_value = (char *) allocsa (namelen + 1 + vallen);
 163           if (new_value == NULL)
 164             {
 165               __set_errno (ENOMEM);
 166               UNLOCK;
 167               return -1;
 168             }
 169           memcpy (new_value, name, namelen);
 170           new_value[namelen] = '=';
 171           memcpy (&new_value[namelen + 1], value, vallen);
 172 # endif
 173
 174           new_environ[size] = KNOWN_VALUE (new_value);
 175           if (new_environ[size] == NULL)
 176 #endif
 177             {
 178               new_environ[size] = (char *) malloc (namelen + 1 + vallen);
 179               if (new_environ[size] == NULL)
 180                 {
 181 #if defined USE_TSEARCH && !defined _LIBC
 182                   freesa (new_value);
 183 #endif
 184                   __set_errno (ENOMEM);
 185                   UNLOCK;
 186                   return -1;
 187                 }
 188
 189 #ifdef USE_TSEARCH
 190               memcpy (new_environ[size], new_value, namelen + 1 + vallen);
 191 #else
 192               memcpy (new_environ[size], name, namelen);
 193               new_environ[size][namelen] = '=';
 194               memcpy (&new_environ[size][namelen + 1], value, vallen);
 195 #endif
 196               /* And save the value now.  We cannot do this when we remove
 197                  the string since then we cannot decide whether it is a
 198                  user string or not.  */
 199               STORE_VALUE (new_environ[size]);
 200             }
 201 #if defined USE_TSEARCH && !defined _LIBC
 202           freesa (new_value);
 203 #endif
 204         }
 205
 206       if (__environ != last_environ)
 207         memcpy ((char *) new_environ, (char *) __environ,
 208                 size * sizeof (char *));
 209
 210       new_environ[size + 1] = NULL;
 211
 212       last_environ = __environ = new_environ;
 213     }
 214   else if (replace)
 215     {
 216       char *np;
 217
 218       /* Use the user string if given.  */
 219       if (combined != NULL)
 220         np = (char *) combined;
 221       else
 222         {
 223 #ifdef USE_TSEARCH
 224           char *new_value;
 225 # ifdef _LIBC
 226           new_value = alloca (namelen + 1 + vallen);
 227           __mempcpy (__mempcpy (__mempcpy (new_value, name, namelen), "=", 1),
 228                      value, vallen);
 229 # else
 230           new_value = allocsa (namelen + 1 + vallen);
 231           if (new_value == NULL)
 232             {
 233               __set_errno (ENOMEM);
 234               UNLOCK;
 235               return -1;
 236             }
 237           memcpy (new_value, name, namelen);
 238           new_value[namelen] = '=';
 239           memcpy (&new_value[namelen + 1], value, vallen);
 240 # endif
 241
 242           np = KNOWN_VALUE (new_value);
 243           if (np == NULL)
 244 #endif
 245             {
 246               np = malloc (namelen + 1 + vallen);
 247               if (np == NULL)
 248                 {
 249 #if defined USE_TSEARCH && !defined _LIBC
 250                   freesa (new_value);
 251 #endif
 252                   __set_errno (ENOMEM);
 253                   UNLOCK;
 254                   return -1;
 255                 }
 256
 257 #ifdef USE_TSEARCH
 258               memcpy (np, new_value, namelen + 1 + vallen);
 259 #else
 260               memcpy (np, name, namelen);
 261               np[namelen] = '=';
 262               memcpy (&np[namelen + 1], value, vallen);
 263 #endif
 264               /* And remember the value.  */
 265               STORE_VALUE (np);
 266             }
 267 #if defined USE_TSEARCH && !defined _LIBC
 268           freesa (new_value);
 269 #endif
 270         }
 271
 272       *ep = np;
 273     }
 274
 275   UNLOCK;
 276
 277   return 0;
 278 }
 279
 280 int
 281 setenv (const char *name, const char *value, int replace)
 282 {
 283   return __add_to_environ (name, value, NULL, replace);
 284 }
 285
 286 /* The `clearenv' was planned to be added to POSIX.1 but probably
 287    never made it.  Nevertheless the POSIX.9 standard (POSIX bindings
 288    for Fortran 77) requires this function.  */
 289 int
 290 clearenv (void)
 291 {
 292   LOCK;
 293
 294   if (__environ == last_environ && __environ != NULL)
 295     {
 296       /* We allocated this environment so we can free it.  */
 297       free (__environ);
 298       last_environ = NULL;
 299     }
 300
 301   /* Clear the environment pointer removes the whole environment.  */
 302   __environ = NULL;
 303
 304   UNLOCK;
 305
 306   return 0;
 307 }
 308
 309 #ifdef _LIBC
 310 static void
 311 free_mem (void)
 312 {
 313   /* Remove all traces.  */
 314   clearenv ();
 315
 316   /* Now remove the search tree.  */
 317   __tdestroy (known_values, free);
 318   known_values = NULL;
 319 }
 320 text_set_element (__libc_subfreeres, free_mem);
 321
 322
 323 # undef setenv
 324 # undef clearenv
 325 weak_alias (__setenv, setenv)
 326 weak_alias (__clearenv, clearenv)
 327 #endif