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