1 /* Copyright (C) 1992-2023 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 <https://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 <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 (const char *name, const char *value, const char *combined,
117 int replace)
118 {
119 char **ep;
120 size_t size;
121
122 /* Compute lengths before locking, so that the critical section is
123 less of a performance bottleneck. VALLEN is needed only if
124 COMBINED is null (unfortunately GCC is not smart enough to deduce
125 this; see the #pragma at the start of this file). Testing
126 COMBINED instead of VALUE causes setenv (..., NULL, ...) to dump
127 core now instead of corrupting memory later. */
128 const size_t namelen = strlen (name);
129 size_t vallen;
130 if (combined == NULL)
131 vallen = strlen (value) + 1;
132
133 LOCK;
134
135 /* We have to get the pointer now that we have the lock and not earlier
136 since another thread might have created a new environment. */
137 ep = __environ;
138
139 size = 0;
140 if (ep != NULL)
141 {
142 for (; *ep != NULL; ++ep)
143 if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=')
144 break;
145 else
146 ++size;
147 }
148
149 if (ep == NULL || __builtin_expect (*ep == NULL, 1))
150 {
151 char **new_environ;
152
153 /* We allocated this space; we can extend it. Avoid using the raw
154 reallocated pointer to avoid GCC -Wuse-after-free. */
155 uintptr_t ip_last_environ = (uintptr_t)last_environ;
156 new_environ = (char **) realloc (last_environ,
157 (size + 2) * sizeof (char *));
158 if (new_environ == NULL)
159 {
160 UNLOCK;
161 return -1;
162 }
163
164 if ((uintptr_t)__environ != ip_last_environ)
165 memcpy ((char *) new_environ, (char *) __environ,
166 size * sizeof (char *));
167
168 new_environ[size] = NULL;
169 new_environ[size + 1] = NULL;
170 ep = new_environ + size;
171
172 last_environ = __environ = new_environ;
173 }
174 if (*ep == NULL || replace)
175 {
176 char *np;
177
178 /* Use the user string if given. */
179 if (combined != NULL)
180 np = (char *) combined;
181 else
182 {
183 const size_t varlen = namelen + 1 + vallen;
184 #ifdef USE_TSEARCH
185 char *new_value = malloc (varlen);
186 if (new_value == NULL)
187 {
188 UNLOCK;
189 return -1;
190 }
191 # ifdef _LIBC
192 __mempcpy (__mempcpy (__mempcpy (new_value, name, namelen), "=", 1),
193 value, vallen);
194 # else
195 memcpy (new_value, name, namelen);
196 new_value[namelen] = '=';
197 memcpy (&new_value[namelen + 1], value, vallen);
198 # endif
199
200 np = KNOWN_VALUE (new_value);
201 if (__glibc_likely (np == NULL))
202 #endif
203 {
204 #ifdef USE_TSEARCH
205 np = new_value;
206 #endif
207 /* And remember the value. */
208 STORE_VALUE (np);
209 }
210 #ifdef USE_TSEARCH
211 else
212 free (new_value);
213 #endif
214 }
215
216 *ep = np;
217 }
218
219 UNLOCK;
220
221 return 0;
222 }
223
224 int
225 setenv (const char *name, const char *value, int replace)
226 {
227 if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
228 {
229 __set_errno (EINVAL);
230 return -1;
231 }
232
233 return __add_to_environ (name, value, NULL, replace);
234 }
235
236 int
237 unsetenv (const char *name)
238 {
239 size_t len;
240 char **ep;
241
242 if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
243 {
244 __set_errno (EINVAL);
245 return -1;
246 }
247
248 len = strlen (name);
249
250 LOCK;
251
252 ep = __environ;
253 if (ep != NULL)
254 while (*ep != NULL)
255 {
256 if (!strncmp (*ep, name, len) && (*ep)[len] == '=')
257 {
258 /* Found it. Remove this pointer by moving later ones back. */
259 char **dp = ep;
260
261 do
262 dp[0] = dp[1];
263 while (*dp++);
264 /* Continue the loop in case NAME appears again. */
265 }
266 else
267 ++ep;
268 }
269
270 UNLOCK;
271
272 return 0;
273 }
274
275 /* The `clearenv' was planned to be added to POSIX.1 but probably
276 never made it. Nevertheless the POSIX.9 standard (POSIX bindings
277 for Fortran 77) requires this function. */
278 int
279 clearenv (void)
280 {
281 LOCK;
282
283 if (__environ == last_environ && __environ != NULL)
284 {
285 /* We allocated this environment so we can free it. */
286 free (__environ);
287 last_environ = NULL;
288 }
289
290 /* Clear the environment pointer removes the whole environment. */
291 __environ = NULL;
292
293 UNLOCK;
294
295 return 0;
296 }
297 #ifdef _LIBC
298 void
299 __libc_setenv_freemem (void)
300 {
301 /* Remove all traces. */
302 clearenv ();
303
304 /* Now remove the search tree. */
305 __tdestroy (known_values, free);
306 known_values = NULL;
307 }
308
309 # undef setenv
310 # undef unsetenv
311 # undef clearenv
312 weak_alias (__setenv, setenv)
313 weak_alias (__unsetenv, unsetenv)
314 weak_alias (__clearenv, clearenv)
315 #endif