1 /*
2 * msvcrt.dll environment functions
3 *
4 * Copyright 1996,1998 Marcus Meissner
5 * Copyright 1996 Jukka Iivonen
6 * Copyright 1997,2000 Uwe Bonnes
7 * Copyright 2000 Jon Griffiths
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23 #include "wine/unicode.h"
24 #include "msvcrt.h"
25 #include "wine/debug.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
28
29 /*********************************************************************
30 * getenv (MSVCRT.@)
31 */
32 char * CDECL MSVCRT_getenv(const char *name)
33 {
34 char **environ;
35 unsigned int length=strlen(name);
36
37 for (environ = MSVCRT__environ; *environ; environ++)
38 {
39 char *str = *environ;
40 char *pos = strchr(str,'=');
41 if (pos && ((pos - str) == length) && !strncasecmp(str,name,length))
42 {
43 TRACE("(%s): got %s\n", debugstr_a(name), debugstr_a(pos + 1));
44 return pos + 1;
45 }
46 }
47 return NULL;
48 }
49
50 /*********************************************************************
51 * _wgetenv (MSVCRT.@)
52 */
53 MSVCRT_wchar_t * CDECL MSVCRT__wgetenv(const MSVCRT_wchar_t *name)
54 {
55 MSVCRT_wchar_t **environ;
56 unsigned int length=strlenW(name);
57
58 /* Initialize the _wenviron array if it's not already created. */
59 if (!MSVCRT__wenviron)
60 MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(NULL);
61
62 for (environ = MSVCRT__wenviron; *environ; environ++)
63 {
64 MSVCRT_wchar_t *str = *environ;
65 MSVCRT_wchar_t *pos = strchrW(str,'=');
66 if (pos && ((pos - str) == length) && !strncmpiW(str,name,length))
67 {
68 TRACE("(%s): got %s\n", debugstr_w(name), debugstr_w(pos + 1));
69 return pos + 1;
70 }
71 }
72 return NULL;
73 }
74
75 /*********************************************************************
76 * _putenv (MSVCRT.@)
77 */
78 int CDECL _putenv(const char *str)
79 {
80 char *name, *value;
81 char *dst;
82 int ret;
83
84 TRACE("%s\n", debugstr_a(str));
85
86 if (!str)
87 return -1;
88
89 name = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
90 if (!name)
91 return -1;
92 dst = name;
93 while (*str && *str != '=')
94 *dst++ = *str++;
95 if (!*str++)
96 {
97 ret = -1;
98 goto finish;
99 }
100 *dst++ = '\0';
101 value = dst;
102 while (*str)
103 *dst++ = *str++;
104 *dst = '\0';
105
106 ret = SetEnvironmentVariableA(name, value[0] ? value : NULL) ? 0 : -1;
107
108 /* _putenv returns success on deletion of nonexistent variable, unlike [Rtl]SetEnvironmentVariable */
109 if ((ret == -1) && (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) ret = 0;
110
111 MSVCRT__environ = msvcrt_SnapshotOfEnvironmentA(MSVCRT__environ);
112 /* Update the __p__wenviron array only when already initialized */
113 if (MSVCRT__wenviron)
114 MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(MSVCRT__wenviron);
115
116 finish:
117 HeapFree(GetProcessHeap(), 0, name);
118 return ret;
119 }
120
121 /*********************************************************************
122 * _wputenv (MSVCRT.@)
123 */
124 int CDECL _wputenv(const MSVCRT_wchar_t *str)
125 {
126 MSVCRT_wchar_t *name, *value;
127 MSVCRT_wchar_t *dst;
128 int ret;
129
130 TRACE("%s\n", debugstr_w(str));
131
132 if (!str)
133 return -1;
134 name = HeapAlloc(GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(MSVCRT_wchar_t));
135 if (!name)
136 return -1;
137 dst = name;
138 while (*str && *str != '=')
139 *dst++ = *str++;
140 if (!*str++)
141 {
142 ret = -1;
143 goto finish;
144 }
145 *dst++ = 0;
146 value = dst;
147 while (*str)
148 *dst++ = *str++;
149 *dst = 0;
150
151 ret = SetEnvironmentVariableW(name, value[0] ? value : NULL) ? 0 : -1;
152
153 /* _putenv returns success on deletion of nonexistent variable, unlike [Rtl]SetEnvironmentVariable */
154 if ((ret == -1) && (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) ret = 0;
155
156 MSVCRT__environ = msvcrt_SnapshotOfEnvironmentA(MSVCRT__environ);
157 MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(MSVCRT__wenviron);
158
159 finish:
160 HeapFree(GetProcessHeap(), 0, name);
161 return ret;
162 }
163
164 /*********************************************************************
165 * _putenv_s (MSVCRT.@)
166 */
167 int CDECL _putenv_s(const char *name, const char *value)
168 {
169 int ret;
170
171 TRACE("%s %s\n", debugstr_a(name), debugstr_a(value));
172
173 if (!MSVCRT_CHECK_PMT(name != NULL) || !MSVCRT_CHECK_PMT(value != NULL))
174 {
175 *MSVCRT__errno() = MSVCRT_EINVAL;
176 return -1;
177 }
178
179 ret = SetEnvironmentVariableA(name, value[0] ? value : NULL) ? 0 : -1;
180
181 /* _putenv returns success on deletion of nonexistent variable, unlike [Rtl]SetEnvironmentVariable */
182 if ((ret == -1) && (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) ret = 0;
183
184 MSVCRT__environ = msvcrt_SnapshotOfEnvironmentA(MSVCRT__environ);
185 MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(MSVCRT__wenviron);
186
187 return ret;
188 }
189
190 /*********************************************************************
191 * _wputenv_s (MSVCRT.@)
192 */
193 int CDECL _wputenv_s(const MSVCRT_wchar_t *name, const MSVCRT_wchar_t *value)
194 {
195 int ret;
196
197 TRACE("%s %s\n", debugstr_w(name), debugstr_w(value));
198
199 if (!MSVCRT_CHECK_PMT(name != NULL) || !MSVCRT_CHECK_PMT(value != NULL))
200 {
201 *MSVCRT__errno() = MSVCRT_EINVAL;
202 return -1;
203 }
204
205 ret = SetEnvironmentVariableW(name, value[0] ? value : NULL) ? 0 : -1;
206
207 /* _putenv returns success on deletion of nonexistent variable, unlike [Rtl]SetEnvironmentVariable */
208 if ((ret == -1) && (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) ret = 0;
209
210 MSVCRT__environ = msvcrt_SnapshotOfEnvironmentA(MSVCRT__environ);
211 MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(MSVCRT__wenviron);
212
213 return ret;
214 }
215
216 /******************************************************************
217 * _dupenv_s (MSVCRT.@)
218 */
219 int CDECL _dupenv_s(char **buffer, MSVCRT_size_t *numberOfElements, const char *varname)
220 {
221 char* e;
222 MSVCRT_size_t sz;
223
224 if (!MSVCRT_CHECK_PMT(buffer != NULL) || !MSVCRT_CHECK_PMT(varname) ||
225 !(e = MSVCRT_getenv(varname)))
226 {
227 return *MSVCRT__errno() = MSVCRT_EINVAL;
228 }
229 sz = strlen(e) + 1;
230 if (!(*buffer = MSVCRT_malloc(sz)))
231 {
232 if (numberOfElements) *numberOfElements = 0;
233 return *MSVCRT__errno() = MSVCRT_ENOMEM;
234 }
235 strcpy(*buffer, e);
236 if (numberOfElements) *numberOfElements = sz;
237 return 0;
238 }
239
240 /******************************************************************
241 * _wdupenv_s (MSVCRT.@)
242 */
243 int CDECL _wdupenv_s(MSVCRT_wchar_t **buffer, MSVCRT_size_t *numberOfElements,
244 const MSVCRT_wchar_t *varname)
245 {
246 MSVCRT_wchar_t* e;
247 MSVCRT_size_t sz;
248
249 if (!MSVCRT_CHECK_PMT(buffer != NULL) || !MSVCRT_CHECK_PMT(varname) ||
250 !(e = MSVCRT__wgetenv(varname)))
251 {
252 return *MSVCRT__errno() = MSVCRT_EINVAL;
253 }
254 sz = strlenW(e) + 1;
255 if (!(*buffer = MSVCRT_malloc(sz * sizeof(MSVCRT_wchar_t))))
256 {
257 if (numberOfElements) *numberOfElements = 0;
258 return *MSVCRT__errno() = MSVCRT_ENOMEM;
259 }
260 strcpyW(*buffer, e);
261 if (numberOfElements) *numberOfElements = sz;
262 return 0;
263 }
264
265 /******************************************************************
266 * getenv_s (MSVCRT.@)
267 */
268 int CDECL getenv_s(MSVCRT_size_t *pReturnValue, char* buffer, MSVCRT_size_t numberOfElements, const char *varname)
269 {
270 char* e;
271
272 if (!MSVCRT_CHECK_PMT(pReturnValue != NULL) ||
273 !MSVCRT_CHECK_PMT(!(buffer == NULL && numberOfElements > 0)) ||
274 !MSVCRT_CHECK_PMT(varname != NULL))
275 {
276 return *MSVCRT__errno() = MSVCRT_EINVAL;
277 }
278 if (!(e = MSVCRT_getenv(varname)))
279 {
280 *pReturnValue = 0;
281 return *MSVCRT__errno() = MSVCRT_EINVAL;
282 }
283 *pReturnValue = strlen(e) + 1;
284 if (numberOfElements < *pReturnValue)
285 {
286 return *MSVCRT__errno() = MSVCRT_ERANGE;
287 }
288 strcpy(buffer, e);
289 return 0;
290 }
291
292 /******************************************************************
293 * _wgetenv_s (MSVCRT.@)
294 */
295 int CDECL _wgetenv_s(MSVCRT_size_t *pReturnValue, MSVCRT_wchar_t *buffer, MSVCRT_size_t numberOfElements,
296 const MSVCRT_wchar_t *varname)
297 {
298 MSVCRT_wchar_t* e;
299
300 if (!MSVCRT_CHECK_PMT(pReturnValue != NULL) ||
301 !MSVCRT_CHECK_PMT(!(buffer == NULL && numberOfElements > 0)) ||
302 !MSVCRT_CHECK_PMT(varname != NULL))
303 {
304 return *MSVCRT__errno() = MSVCRT_EINVAL;
305 }
306 if (!(e = MSVCRT__wgetenv(varname)))
307 {
308 *pReturnValue = 0;
309 return *MSVCRT__errno() = MSVCRT_EINVAL;
310 }
311 *pReturnValue = strlenW(e) + 1;
312 if (numberOfElements < *pReturnValue)
313 {
314 return *MSVCRT__errno() = MSVCRT_ERANGE;
315 }
316 strcpyW(buffer, e);
317 return 0;
318 }
319
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.