Fixed backport of libassuan-2 changes.
[gnupg.git] / 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