stdlib/setenv.c

   1 /* Copyright (C) 1992-2015 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library 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 GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #if HAVE_CONFIG_H
  19 # include <config.h>
  20 #endif
  21
  22 /* Pacify GCC; see the commentary about VALLEN below.  This is needed
  23    at least through GCC 4.9.2.  Pacify GCC for the entire file, as
  24    there seems to be no way to pacify GCC selectively, only for the
  25    place where it's needed.  Do not use DIAG_IGNORE_NEEDS_COMMENT
  26    here, as it's not defined yet.  */
  27 #if ((__GNUC__ << 16) + __GNUC_MINOR__) >= ((4 << 16) + 7)
  28 # pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  29 #else
  30 # pragma GCC diagnostic ignored "-Wuninitialized"
  31 #endif
  32
  33 #include <errno.h>
  34 #if !_LIBC
  35 # if !defined errno && !defined HAVE_ERRNO_DECL
  36 extern int errno;
  37 # endif
  38 # define __set_errno(ev) ((errno) = (ev))
  39 #endif
  40
  41 #if _LIBC || HAVE_STDLIB_H
  42 # include <stdlib.h>
  43 #endif
  44 #if _LIBC || HAVE_STRING_H
  45 # include <string.h>
  46 #endif
  47 #if _LIBC || HAVE_UNISTD_H
  48 # include <unistd.h>
  49 #endif
  50
  51 #if !_LIBC
  52 # define __environ      environ
  53 # ifndef HAVE_ENVIRON_DECL
  54 extern char **environ;
  55 # endif
  56 #endif
  57
  58 #if _LIBC
  59 /* This lock protects against simultaneous modifications of `environ'.  */
  60 # include <libc-lock.h>
  61 __libc_lock_define_initialized (static, envlock)
  62 # define LOCK   __libc_lock_lock (envlock)
  63 # define UNLOCK __libc_lock_unlock (envlock)
  64 #else
  65 # define LOCK
  66 # define UNLOCK
  67 #endif
  68
  69 /* In the GNU C library we must keep the namespace clean.  */
  70 #ifdef _LIBC
  71 # define setenv __setenv
  72 # define unsetenv __unsetenv
  73 # define clearenv __clearenv
  74 # define tfind __tfind
  75 # define tsearch __tsearch
  76 #endif
  77
  78 /* In the GNU C library implementation we try to be more clever and
  79    allow arbitrarily many changes of the environment given that the used
  80    values are from a small set.  Outside glibc this will eat up all
  81    memory after a while.  */
  82 #if defined _LIBC || (defined HAVE_SEARCH_H && defined HAVE_TSEARCH \
  83                       && defined __GNUC__)
  84 # define USE_TSEARCH    1
  85 # include <search.h>
  86
  87 /* This is a pointer to the root of the search tree with the known
  88    values.  */
  89 static void *known_values;
  90
  91 # define KNOWN_VALUE(Str) \
  92   ({                                                                          \
  93     void *value = tfind (Str, &known_values, (__compar_fn_t) strcmp);         \
  94     value != NULL ? *(char **) value : NULL;                                  \
  95   })
  96 # define STORE_VALUE(Str) \
  97   tsearch (Str, &known_values, (__compar_fn_t) strcmp)
  98
  99 #else
 100 # undef USE_TSEARCH
 101
 102 # define KNOWN_VALUE(Str) NULL
 103 # define STORE_VALUE(Str) do { } while (0)
 104
 105 #endif
 106
 107
 108 /* If this variable is not a null pointer we allocated the current
 109    environment.  */
 110 static char **last_environ;
 111
 112
 113 /* This function is used by `setenv' and `putenv'.  The difference between
 114    the two functions is that for the former must create a new string which
 115    is then placed in the environment, while the argument of `putenv'
 116    must be used directly.  This is all complicated by the fact that we try
 117    to reuse values once generated for a `setenv' call since we can never
 118    free the strings.  */
 119 int
 120 __add_to_environ (const char *name, const char *value, const char *combined,
 121                   int replace)
 122 {
 123   char **ep;
 124   size_t size;
 125
 126   /* Compute lengths before locking, so that the critical section is
 127      less of a performance bottleneck.  VALLEN is needed only if
 128      COMBINED is null (unfortunately GCC is not smart enough to deduce
 129      this; see the #pragma at the start of this file).  Testing
 130      COMBINED instead of VALUE causes setenv (..., NULL, ...)  to dump
 131      core now instead of corrupting memory later.  */
 132   const size_t namelen = strlen (name);
 133   size_t vallen;
 134   if (combined == NULL)
 135     vallen = strlen (value) + 1;
 136
 137   LOCK;
 138
 139   /* We have to get the pointer now that we have the lock and not earlier
 140      since another thread might have created a new environment.  */
 141   ep = __environ;
 142
 143   size = 0;
 144   if (ep != NULL)
 145     {
 146       for (; *ep != NULL; ++ep)
 147         if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=')
 148           break;
 149         else
 150           ++size;
 151     }
 152
 153   if (ep == NULL || __builtin_expect (*ep == NULL, 1))
 154     {
 155       char **new_environ;
 156
 157       /* We allocated this space; we can extend it.  */
 158       new_environ = (char **) realloc (last_environ,
 159                                        (size + 2) * sizeof (char *));
 160       if (new_environ == NULL)
 161         {
 162           UNLOCK;
 163           return -1;
 164         }
 165
 166       if (__environ != last_environ)
 167         memcpy ((char *) new_environ, (char *) __environ,
 168                 size * sizeof (char *));
 169
 170       new_environ[size] = NULL;
 171       new_environ[size + 1] = NULL;
 172       ep = new_environ + size;
 173
 174       last_environ = __environ = new_environ;
 175     }
 176   if (*ep == NULL || replace)
 177     {
 178       char *np;
 179
 180       /* Use the user string if given.  */
 181       if (combined != NULL)
 182         np = (char *) combined;
 183       else
 184         {
 185           const size_t varlen = namelen + 1 + vallen;
 186 #ifdef USE_TSEARCH
 187           char *new_value;
 188           int use_alloca = __libc_use_alloca (varlen);
 189           if (__builtin_expect (use_alloca, 1))
 190             new_value = (char *) alloca (varlen);
 191           else
 192             {
 193               new_value = malloc (varlen);
 194               if (new_value == NULL)
 195                 {
 196                   UNLOCK;
 197                   return -1;
 198                 }
 199             }
 200 # ifdef _LIBC
 201           __mempcpy (__mempcpy (__mempcpy (new_value, name, namelen), "=", 1),
 202                      value, vallen);
 203 # else
 204           memcpy (new_value, name, namelen);
 205           new_value[namelen] = '=';
 206           memcpy (&new_value[namelen + 1], value, vallen);
 207 # endif
 208
 209           np = KNOWN_VALUE (new_value);
 210           if (__glibc_likely (np == NULL))
 211 #endif
 212             {
 213 #ifdef USE_TSEARCH
 214               if (__glibc_unlikely (! use_alloca))
 215                 np = new_value;
 216               else
 217 #endif
 218                 {
 219                   np = malloc (varlen);
 220                   if (__glibc_unlikely (np == NULL))
 221                     {
 222                       UNLOCK;
 223                       return -1;
 224                     }
 225
 226 #ifdef USE_TSEARCH
 227                   memcpy (np, new_value, varlen);
 228 #else
 229                   memcpy (np, name, namelen);
 230                   np[namelen] = '=';
 231                   memcpy (&np[namelen + 1], value, vallen);
 232 #endif
 233                 }
 234               /* And remember the value.  */
 235               STORE_VALUE (np);
 236             }
 237 #ifdef USE_TSEARCH
 238           else
 239             {
 240               if (__glibc_unlikely (! use_alloca))
 241                 free (new_value);
 242             }
 243 #endif
 244         }
 245
 246       *ep = np;
 247     }
 248
 249   UNLOCK;
 250
 251   return 0;
 252 }
 253
 254 int
 255 setenv (const char *name, const char *value, int replace)
 256 {
 257   if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
 258     {
 259       __set_errno (EINVAL);
 260       return -1;
 261     }
 262
 263   return __add_to_environ (name, value, NULL, replace);
 264 }
 265
 266 int
 267 unsetenv (const char *name)
 268 {
 269   size_t len;
 270   char **ep;
 271
 272   if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
 273     {
 274       __set_errno (EINVAL);
 275       return -1;
 276     }
 277
 278   len = strlen (name);
 279
 280   LOCK;
 281
 282   ep = __environ;
 283   if (ep != NULL)
 284     while (*ep != NULL)
 285       if (!strncmp (*ep, name, len) && (*ep)[len] == '=')
 286         {
 287           /* Found it.  Remove this pointer by moving later ones back.  */
 288           char **dp = ep;
 289
 290           do
 291             dp[0] = dp[1];
 292           while (*dp++);
 293           /* Continue the loop in case NAME appears again.  */
 294         }
 295       else
 296         ++ep;
 297
 298   UNLOCK;
 299
 300   return 0;
 301 }
 302
 303 /* The `clearenv' was planned to be added to POSIX.1 but probably
 304    never made it.  Nevertheless the POSIX.9 standard (POSIX bindings
 305    for Fortran 77) requires this function.  */
 306 int
 307 clearenv (void)
 308 {
 309   LOCK;
 310
 311   if (__environ == last_environ && __environ != NULL)
 312     {
 313       /* We allocated this environment so we can free it.  */
 314       free (__environ);
 315       last_environ = NULL;
 316     }
 317
 318   /* Clear the environment pointer removes the whole environment.  */
 319   __environ = NULL;
 320
 321   UNLOCK;
 322
 323   return 0;
 324 }
 325 #ifdef _LIBC
 326 libc_freeres_fn (free_mem)
 327 {
 328   /* Remove all traces.  */
 329   clearenv ();
 330
 331   /* Now remove the search tree.  */
 332   __tdestroy (known_values, free);
 333   known_values = NULL;
 334 }
 335
 336 # undef setenv
 337 # undef unsetenv
 338 # undef clearenv
 339 weak_alias (__setenv, setenv)
 340 weak_alias (__unsetenv, unsetenv)
 341 weak_alias (__clearenv, clearenv)
 342 #endif