]>
Commit | Line | Data |
---|---|---|
568035b7 | 1 | /* Copyright (C) 1992-2013 Free Software Foundation, Inc. |
f0e44959 | 2 | This file is part of the GNU C Library. |
28f540f4 | 3 | |
f0e44959 | 4 | The GNU C Library is free software; you can redistribute it and/or |
41bdb6e2 AJ |
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. | |
28f540f4 | 8 | |
f0e44959 UD |
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 | |
41bdb6e2 | 12 | Lesser General Public License for more details. |
28f540f4 | 13 | |
41bdb6e2 | 14 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 PE |
15 | License along with the GNU C Library; if not, see |
16 | <http://www.gnu.org/licenses/>. */ | |
28f540f4 | 17 | |
f0e44959 UD |
18 | #if HAVE_CONFIG_H |
19 | # include <config.h> | |
196980f5 RM |
20 | #endif |
21 | ||
22 | #include <errno.h> | |
61c162b5 | 23 | #if !_LIBC |
ff152e3f | 24 | # if !defined errno && !defined HAVE_ERRNO_DECL |
61c162b5 UD |
25 | extern int errno; |
26 | # endif | |
27 | # define __set_errno(ev) ((errno) = (ev)) | |
28 | #endif | |
196980f5 RM |
29 | |
30 | #if _LIBC || HAVE_STDLIB_H | |
f0e44959 | 31 | # include <stdlib.h> |
196980f5 RM |
32 | #endif |
33 | #if _LIBC || HAVE_STRING_H | |
f0e44959 | 34 | # include <string.h> |
196980f5 RM |
35 | #endif |
36 | #if _LIBC || HAVE_UNISTD_H | |
f0e44959 | 37 | # include <unistd.h> |
196980f5 | 38 | #endif |
28f540f4 | 39 | |
61c162b5 | 40 | #if !_LIBC |
f0e44959 | 41 | # define __environ environ |
61c162b5 UD |
42 | # ifndef HAVE_ENVIRON_DECL |
43 | extern char **environ; | |
44 | # endif | |
28f540f4 RM |
45 | #endif |
46 | ||
61c162b5 | 47 | #if _LIBC |
9e0f4072 | 48 | /* This lock protects against simultaneous modifications of `environ'. */ |
5107cf1d | 49 | # include <bits/libc-lock.h> |
9e0f4072 | 50 | __libc_lock_define_initialized (static, envlock) |
f0e44959 UD |
51 | # define LOCK __libc_lock_lock (envlock) |
52 | # define UNLOCK __libc_lock_unlock (envlock) | |
9e0f4072 | 53 | #else |
f0e44959 UD |
54 | # define LOCK |
55 | # define UNLOCK | |
9e0f4072 RM |
56 | #endif |
57 | ||
3e5f5557 UD |
58 | /* In the GNU C library we must keep the namespace clean. */ |
59 | #ifdef _LIBC | |
ff152e3f UD |
60 | # define setenv __setenv |
61 | # define unsetenv __unsetenv | |
3e5f5557 | 62 | # define clearenv __clearenv |
b17277cf UD |
63 | # define tfind __tfind |
64 | # define tsearch __tsearch | |
3e5f5557 UD |
65 | #endif |
66 | ||
ff152e3f | 67 | /* In the GNU C library implementation we try to be more clever and |
49c091e5 | 68 | allow arbitrarily many changes of the environment given that the used |
ff152e3f UD |
69 | values are from a small set. Outside glibc this will eat up all |
70 | memory after a while. */ | |
a709dd43 UD |
71 | #if defined _LIBC || (defined HAVE_SEARCH_H && defined HAVE_TSEARCH \ |
72 | && defined __GNUC__) | |
ff152e3f UD |
73 | # define USE_TSEARCH 1 |
74 | # include <search.h> | |
75 | ||
76 | /* This is a pointer to the root of the search tree with the known | |
77 | values. */ | |
78 | static void *known_values; | |
79 | ||
b17277cf UD |
80 | # define KNOWN_VALUE(Str) \ |
81 | ({ \ | |
a709dd43 UD |
82 | void *value = tfind (Str, &known_values, (__compar_fn_t) strcmp); \ |
83 | value != NULL ? *(char **) value : NULL; \ | |
b17277cf UD |
84 | }) |
85 | # define STORE_VALUE(Str) \ | |
a709dd43 | 86 | tsearch (Str, &known_values, (__compar_fn_t) strcmp) |
ff152e3f UD |
87 | |
88 | #else | |
89 | # undef USE_TSEARCH | |
90 | ||
91 | # define KNOWN_VALUE(Str) NULL | |
92 | # define STORE_VALUE(Str) do { } while (0) | |
93 | ||
94 | #endif | |
95 | ||
3e5f5557 | 96 | |
f0e44959 UD |
97 | /* If this variable is not a null pointer we allocated the current |
98 | environment. */ | |
99 | static char **last_environ; | |
100 | ||
101 | ||
de4a40d0 UD |
102 | /* This function is used by `setenv' and `putenv'. The difference between |
103 | the two functions is that for the former must create a new string which | |
104 | is then placed in the environment, while the argument of `putenv' | |
105 | must be used directly. This is all complicated by the fact that we try | |
106 | to reuse values once generated for a `setenv' call since we can never | |
107 | free the strings. */ | |
28f540f4 | 108 | int |
de4a40d0 | 109 | __add_to_environ (name, value, combined, replace) |
196980f5 RM |
110 | const char *name; |
111 | const char *value; | |
de4a40d0 | 112 | const char *combined; |
196980f5 | 113 | int replace; |
28f540f4 | 114 | { |
2e09a79a JM |
115 | char **ep; |
116 | size_t size; | |
196980f5 | 117 | const size_t namelen = strlen (name); |
de4a40d0 | 118 | const size_t vallen = value != NULL ? strlen (value) + 1 : 0; |
28f540f4 | 119 | |
9e0f4072 RM |
120 | LOCK; |
121 | ||
7195db12 UD |
122 | /* We have to get the pointer now that we have the lock and not earlier |
123 | since another thread might have created a new environment. */ | |
124 | ep = __environ; | |
125 | ||
28f540f4 | 126 | size = 0; |
96ff4937 | 127 | if (ep != NULL) |
b0772d3b | 128 | { |
96ff4937 | 129 | for (; *ep != NULL; ++ep) |
b0772d3b UD |
130 | if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=') |
131 | break; | |
132 | else | |
133 | ++size; | |
134 | } | |
196980f5 | 135 | |
3504e5a6 | 136 | if (ep == NULL || __builtin_expect (*ep == NULL, 1)) |
28f540f4 | 137 | { |
c63bfa79 | 138 | const size_t varlen = namelen + 1 + vallen; |
196980f5 | 139 | char **new_environ; |
86187531 | 140 | |
ff152e3f UD |
141 | /* We allocated this space; we can extend it. */ |
142 | new_environ = (char **) realloc (last_environ, | |
143 | (size + 2) * sizeof (char *)); | |
28f540f4 | 144 | if (new_environ == NULL) |
9e0f4072 RM |
145 | { |
146 | UNLOCK; | |
147 | return -1; | |
148 | } | |
28f540f4 | 149 | |
de4a40d0 UD |
150 | /* If the whole entry is given add it. */ |
151 | if (combined != NULL) | |
152 | /* We must not add the string to the search tree since it belongs | |
153 | to the user. */ | |
154 | new_environ[size] = (char *) combined; | |
155 | else | |
156 | { | |
157 | /* See whether the value is already known. */ | |
ff152e3f | 158 | #ifdef USE_TSEARCH |
c63bfa79 UD |
159 | char *new_value; |
160 | int use_alloca = __libc_use_alloca (varlen); | |
161 | if (__builtin_expect (use_alloca, 1)) | |
162 | new_value = (char *) alloca (varlen); | |
163 | else | |
164 | { | |
165 | new_value = malloc (varlen); | |
166 | if (new_value == NULL) | |
167 | { | |
168 | UNLOCK; | |
169 | if (last_environ == NULL) | |
170 | free (new_environ); | |
171 | return -1; | |
172 | } | |
173 | } | |
ff152e3f | 174 | # ifdef _LIBC |
de4a40d0 UD |
175 | __mempcpy (__mempcpy (__mempcpy (new_value, name, namelen), "=", 1), |
176 | value, vallen); | |
ff152e3f | 177 | # else |
de4a40d0 UD |
178 | memcpy (new_value, name, namelen); |
179 | new_value[namelen] = '='; | |
180 | memcpy (&new_value[namelen + 1], value, vallen); | |
ff152e3f UD |
181 | # endif |
182 | ||
de4a40d0 | 183 | new_environ[size] = KNOWN_VALUE (new_value); |
3504e5a6 | 184 | if (__builtin_expect (new_environ[size] == NULL, 1)) |
de4a40d0 | 185 | #endif |
ff152e3f | 186 | { |
c63bfa79 UD |
187 | #ifdef USE_TSEARCH |
188 | if (__builtin_expect (! use_alloca, 0)) | |
189 | new_environ[size] = new_value; | |
190 | else | |
191 | #endif | |
de4a40d0 | 192 | { |
c63bfa79 UD |
193 | new_environ[size] = (char *) malloc (varlen); |
194 | if (__builtin_expect (new_environ[size] == NULL, 0)) | |
195 | { | |
196 | UNLOCK; | |
197 | return -1; | |
198 | } | |
ff152e3f UD |
199 | |
200 | #ifdef USE_TSEARCH | |
c63bfa79 | 201 | memcpy (new_environ[size], new_value, varlen); |
ff152e3f | 202 | #else |
c63bfa79 UD |
203 | memcpy (new_environ[size], name, namelen); |
204 | new_environ[size][namelen] = '='; | |
205 | memcpy (&new_environ[size][namelen + 1], value, vallen); | |
ff152e3f | 206 | #endif |
c63bfa79 UD |
207 | } |
208 | ||
de4a40d0 UD |
209 | /* And save the value now. We cannot do this when we remove |
210 | the string since then we cannot decide whether it is a | |
211 | user string or not. */ | |
212 | STORE_VALUE (new_environ[size]); | |
213 | } | |
28f540f4 | 214 | } |
196980f5 RM |
215 | |
216 | if (__environ != last_environ) | |
217 | memcpy ((char *) new_environ, (char *) __environ, | |
218 | size * sizeof (char *)); | |
219 | ||
28f540f4 RM |
220 | new_environ[size + 1] = NULL; |
221 | ||
196980f5 | 222 | last_environ = __environ = new_environ; |
28f540f4 RM |
223 | } |
224 | else if (replace) | |
225 | { | |
cb37d842 | 226 | char *np; |
ff152e3f | 227 | |
de4a40d0 UD |
228 | /* Use the user string if given. */ |
229 | if (combined != NULL) | |
230 | np = (char *) combined; | |
231 | else | |
232 | { | |
c63bfa79 | 233 | const size_t varlen = namelen + 1 + vallen; |
ff152e3f | 234 | #ifdef USE_TSEARCH |
c63bfa79 UD |
235 | char *new_value; |
236 | int use_alloca = __libc_use_alloca (varlen); | |
237 | if (__builtin_expect (use_alloca, 1)) | |
238 | new_value = (char *) alloca (varlen); | |
239 | else | |
240 | { | |
241 | new_value = malloc (varlen); | |
242 | if (new_value == NULL) | |
243 | { | |
244 | UNLOCK; | |
245 | return -1; | |
246 | } | |
247 | } | |
ff152e3f | 248 | # ifdef _LIBC |
de4a40d0 UD |
249 | __mempcpy (__mempcpy (__mempcpy (new_value, name, namelen), "=", 1), |
250 | value, vallen); | |
ff152e3f | 251 | # else |
de4a40d0 UD |
252 | memcpy (new_value, name, namelen); |
253 | new_value[namelen] = '='; | |
254 | memcpy (&new_value[namelen + 1], value, vallen); | |
ff152e3f UD |
255 | # endif |
256 | ||
de4a40d0 | 257 | np = KNOWN_VALUE (new_value); |
3504e5a6 | 258 | if (__builtin_expect (np == NULL, 1)) |
de4a40d0 | 259 | #endif |
9e0f4072 | 260 | { |
c63bfa79 UD |
261 | #ifdef USE_TSEARCH |
262 | if (__builtin_expect (! use_alloca, 0)) | |
263 | np = new_value; | |
264 | else | |
265 | #endif | |
de4a40d0 | 266 | { |
c63bfa79 UD |
267 | np = malloc (varlen); |
268 | if (__builtin_expect (np == NULL, 0)) | |
269 | { | |
270 | UNLOCK; | |
271 | return -1; | |
272 | } | |
ff152e3f UD |
273 | |
274 | #ifdef USE_TSEARCH | |
c63bfa79 | 275 | memcpy (np, new_value, varlen); |
86187531 | 276 | #else |
c63bfa79 UD |
277 | memcpy (np, name, namelen); |
278 | np[namelen] = '='; | |
279 | memcpy (&np[namelen + 1], value, vallen); | |
86187531 | 280 | #endif |
c63bfa79 | 281 | } |
de4a40d0 UD |
282 | /* And remember the value. */ |
283 | STORE_VALUE (np); | |
284 | } | |
28f540f4 | 285 | } |
cb37d842 | 286 | |
cb37d842 | 287 | *ep = np; |
28f540f4 RM |
288 | } |
289 | ||
9e0f4072 RM |
290 | UNLOCK; |
291 | ||
28f540f4 RM |
292 | return 0; |
293 | } | |
196980f5 | 294 | |
de4a40d0 UD |
295 | int |
296 | setenv (name, value, replace) | |
297 | const char *name; | |
298 | const char *value; | |
299 | int replace; | |
300 | { | |
e17f8b61 RM |
301 | if (name == NULL || *name == '\0' || strchr (name, '=') != NULL) |
302 | { | |
303 | __set_errno (EINVAL); | |
304 | return -1; | |
305 | } | |
306 | ||
de4a40d0 UD |
307 | return __add_to_environ (name, value, NULL, replace); |
308 | } | |
309 | ||
61f9d0a3 | 310 | int |
299a95b9 RM |
311 | unsetenv (name) |
312 | const char *name; | |
196980f5 | 313 | { |
7c5bb945 | 314 | size_t len; |
196980f5 RM |
315 | char **ep; |
316 | ||
61f9d0a3 UD |
317 | if (name == NULL || *name == '\0' || strchr (name, '=') != NULL) |
318 | { | |
319 | __set_errno (EINVAL); | |
320 | return -1; | |
321 | } | |
322 | ||
323 | len = strlen (name); | |
324 | ||
9e0f4072 RM |
325 | LOCK; |
326 | ||
de4a40d0 | 327 | ep = __environ; |
1fa7ae05 UD |
328 | if (ep != NULL) |
329 | while (*ep != NULL) | |
330 | if (!strncmp (*ep, name, len) && (*ep)[len] == '=') | |
331 | { | |
332 | /* Found it. Remove this pointer by moving later ones back. */ | |
333 | char **dp = ep; | |
334 | ||
335 | do | |
336 | dp[0] = dp[1]; | |
337 | while (*dp++); | |
338 | /* Continue the loop in case NAME appears again. */ | |
339 | } | |
340 | else | |
341 | ++ep; | |
9e0f4072 RM |
342 | |
343 | UNLOCK; | |
61f9d0a3 UD |
344 | |
345 | return 0; | |
196980f5 | 346 | } |
f0e44959 UD |
347 | |
348 | /* The `clearenv' was planned to be added to POSIX.1 but probably | |
349 | never made it. Nevertheless the POSIX.9 standard (POSIX bindings | |
350 | for Fortran 77) requires this function. */ | |
351 | int | |
352 | clearenv () | |
353 | { | |
354 | LOCK; | |
355 | ||
356 | if (__environ == last_environ && __environ != NULL) | |
357 | { | |
de4a40d0 | 358 | /* We allocated this environment so we can free it. */ |
f0e44959 UD |
359 | free (__environ); |
360 | last_environ = NULL; | |
361 | } | |
362 | ||
363 | /* Clear the environment pointer removes the whole environment. */ | |
364 | __environ = NULL; | |
365 | ||
366 | UNLOCK; | |
367 | ||
368 | return 0; | |
369 | } | |
3e5f5557 | 370 | #ifdef _LIBC |
c877418f | 371 | libc_freeres_fn (free_mem) |
69071b2a UD |
372 | { |
373 | /* Remove all traces. */ | |
374 | clearenv (); | |
375 | ||
376 | /* Now remove the search tree. */ | |
377 | __tdestroy (known_values, free); | |
378 | known_values = NULL; | |
379 | } | |
69071b2a | 380 | |
ff152e3f UD |
381 | # undef setenv |
382 | # undef unsetenv | |
3e5f5557 | 383 | # undef clearenv |
ff152e3f UD |
384 | weak_alias (__setenv, setenv) |
385 | weak_alias (__unsetenv, unsetenv) | |
3e5f5557 UD |
386 | weak_alias (__clearenv, clearenv) |
387 | #endif |