dlls/msvcrt/environ.c

   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 "msvcrt.h"
  24 #include "mtdll.h"
  25 #include <winnls.h>
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  29
  30 int env_init(BOOL unicode, BOOL modif)
  31 {
  32     if (!unicode && !MSVCRT___initenv)
  33     {
  34         char *environ_strings = GetEnvironmentStringsA();
  35         int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
  36         char *ptr;
  37
  38         for (ptr = environ_strings; *ptr; ptr += strlen(ptr) + 1)
  39         {
  40             /* Don't count environment variables starting with '=' which are command shell specific */
  41             if (*ptr != '=') count++;
  42             len += strlen(ptr) + 1;
  43         }
  44         MSVCRT___initenv = malloc(count * sizeof(*MSVCRT___initenv) + len);
  45         if (!MSVCRT___initenv)
  46         {
  47             FreeEnvironmentStringsA(environ_strings);
  48             return -1;
  49         }
  50
  51         memcpy(&MSVCRT___initenv[count], environ_strings, len);
  52         for (ptr = (char *)&MSVCRT___initenv[count]; *ptr; ptr += strlen(ptr) + 1)
  53         {
  54             /* Skip special environment strings set by the command shell */
  55             if (*ptr != '=') MSVCRT___initenv[i++] = ptr;
  56         }
  57         MSVCRT___initenv[i] = NULL;
  58         FreeEnvironmentStringsA(environ_strings);
  59
  60         MSVCRT__environ = MSVCRT___initenv;
  61     }
  62
  63     if (!unicode && modif && MSVCRT__environ == MSVCRT___initenv)
  64     {
  65         int i = 0;
  66
  67         while(MSVCRT___initenv[i]) i++;
  68         MSVCRT__environ = malloc((i + 1) * sizeof(char *));
  69         if (!MSVCRT__environ) return -1;
  70         for (i = 0; MSVCRT___initenv[i]; i++)
  71             MSVCRT__environ[i] = strdup(MSVCRT___initenv[i]);
  72         MSVCRT__environ[i] = NULL;
  73     }
  74
  75     if (unicode && !MSVCRT___winitenv)
  76     {
  77         wchar_t *wenviron_strings = GetEnvironmentStringsW();
  78         int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
  79         wchar_t *wptr;
  80
  81         for (wptr = wenviron_strings; *wptr; wptr += wcslen(wptr) + 1)
  82         {
  83             /* Don't count environment variables starting with '=' which are command shell specific */
  84             if (*wptr != '=') count++;
  85             len += wcslen(wptr) + 1;
  86         }
  87         MSVCRT___winitenv = malloc(count * sizeof(*MSVCRT___winitenv) + len * sizeof(wchar_t));
  88         if (!MSVCRT___winitenv)
  89         {
  90             FreeEnvironmentStringsW(wenviron_strings);
  91             return -1;
  92         }
  93
  94         memcpy(&MSVCRT___winitenv[count], wenviron_strings, len * sizeof(wchar_t));
  95         for (wptr = (wchar_t *)&MSVCRT___winitenv[count]; *wptr; wptr += wcslen(wptr) + 1)
  96         {
  97             /* Skip special environment strings set by the command shell */
  98             if (*wptr != '=') MSVCRT___winitenv[i++] = wptr;
  99         }
 100         MSVCRT___winitenv[i] = NULL;
 101         FreeEnvironmentStringsW(wenviron_strings);
 102
 103         MSVCRT__wenviron = MSVCRT___winitenv;
 104     }
 105
 106     if (unicode && modif && MSVCRT__wenviron == MSVCRT___winitenv)
 107     {
 108         int i = 0;
 109
 110         while(MSVCRT___winitenv[i]) i++;
 111         MSVCRT__wenviron = malloc((i + 1) * sizeof(wchar_t *));
 112         if (!MSVCRT__wenviron) return -1;
 113         for (i = 0; MSVCRT___winitenv[i]; i++)
 114             MSVCRT__wenviron[i] = wcsdup(MSVCRT___winitenv[i]);
 115         MSVCRT__wenviron[i] = NULL;
 116     }
 117
 118     return 0;
 119 }
 120
 121 static int env_get_index(const char *name)
 122 {
 123     int i, len;
 124
 125     len = strlen(name);
 126     for (i = 0; MSVCRT__environ[i]; i++)
 127     {
 128         if (!strncmp(name, MSVCRT__environ[i], len) && MSVCRT__environ[i][len] == '=')
 129             return i;
 130     }
 131     return i;
 132 }
 133
 134 static int wenv_get_index(const wchar_t *name)
 135 {
 136     int i, len;
 137
 138     len = wcslen(name);
 139     for (i = 0; MSVCRT__wenviron[i]; i++)
 140     {
 141         if (!wcsncmp(name, MSVCRT__wenviron[i], len) && MSVCRT__wenviron[i][len] == '=')
 142             return i;
 143     }
 144     return i;
 145 }
 146
 147 static int env_set(char **env, wchar_t **wenv)
 148 {
 149     wchar_t *weq = wcschr(*wenv, '=');
 150     char *eq = strchr(*env, '=');
 151     int idx;
 152
 153     *weq = 0;
 154     if (!SetEnvironmentVariableW(*wenv, weq[1] ? weq + 1 : NULL) &&
 155             GetLastError() != ERROR_ENVVAR_NOT_FOUND)
 156         return -1;
 157
 158     *eq = 0;
 159     idx = env_get_index(*env);
 160     *eq = '=';
 161     if (!eq[1])
 162     {
 163         for(; MSVCRT__environ[idx]; idx++)
 164             MSVCRT__environ[idx] = MSVCRT__environ[idx + 1];
 165     }
 166     else if (MSVCRT__environ[idx])
 167     {
 168         free(MSVCRT__environ[idx]);
 169         MSVCRT__environ[idx] = *env;
 170         *env = NULL;
 171     }
 172     else
 173     {
 174         char **new_env = realloc(MSVCRT__environ, (idx + 2) * sizeof(*MSVCRT__environ));
 175         if (!new_env) return -1;
 176         MSVCRT__environ = new_env;
 177         MSVCRT__environ[idx] = *env;
 178         MSVCRT__environ[idx + 1] = NULL;
 179         *env = NULL;
 180     }
 181
 182     if (!MSVCRT__wenviron) return 0;
 183     idx = wenv_get_index(*wenv);
 184     *weq = '=';
 185     if (!weq[1])
 186     {
 187         for(; MSVCRT__wenviron[idx]; idx++)
 188             MSVCRT__wenviron[idx] = MSVCRT__wenviron[idx + 1];
 189     }
 190     else if (MSVCRT__wenviron[idx])
 191     {
 192         free(MSVCRT__wenviron[idx]);
 193         MSVCRT__wenviron[idx] = *wenv;
 194         *wenv = NULL;
 195     }
 196     else
 197     {
 198         wchar_t **new_env = realloc(MSVCRT__wenviron, (idx + 2) * sizeof(*MSVCRT__wenviron));
 199         if (!new_env) return -1;
 200         MSVCRT__wenviron = new_env;
 201         MSVCRT__wenviron[idx] = *wenv;
 202         MSVCRT__wenviron[idx + 1] = NULL;
 203         *wenv = NULL;
 204     }
 205     return 0;
 206 }
 207
 208 static char * getenv_helper(const char *name)
 209 {
 210     int idx;
 211
 212     if (!name) return NULL;
 213
 214     idx = env_get_index(name);
 215     if (!MSVCRT__environ[idx]) return NULL;
 216     return strchr(MSVCRT__environ[idx], '=') + 1;
 217 }
 218
 219 /*********************************************************************
 220  *              getenv (MSVCRT.@)
 221  */
 222 char * CDECL getenv(const char *name)
 223 {
 224     char *ret;
 225
 226     if (!MSVCRT_CHECK_PMT(name != NULL)) return NULL;
 227
 228     _lock(_ENV_LOCK);
 229     ret = getenv_helper(name);
 230     _unlock(_ENV_LOCK);
 231     return ret;
 232 }
 233
 234 static wchar_t * wgetenv_helper(const wchar_t *name)
 235 {
 236     int idx;
 237
 238     if (!name) return NULL;
 239     if (env_init(TRUE, FALSE)) return NULL;
 240
 241     idx = wenv_get_index(name);
 242     if (!MSVCRT__wenviron[idx]) return NULL;
 243     return wcschr(MSVCRT__wenviron[idx], '=') + 1;
 244 }
 245
 246 /*********************************************************************
 247  *              _wgetenv (MSVCRT.@)
 248  */
 249 wchar_t * CDECL _wgetenv(const wchar_t *name)
 250 {
 251     wchar_t *ret;
 252
 253     if (!MSVCRT_CHECK_PMT(name != NULL)) return NULL;
 254
 255     _lock(_ENV_LOCK);
 256     ret = wgetenv_helper(name);
 257     _unlock(_ENV_LOCK);
 258     return ret;
 259 }
 260
 261 static int putenv_helper(const char *name, const char *val, const char *eq)
 262 {
 263     wchar_t *wenv;
 264     char *env;
 265     int r;
 266
 267     _lock(_ENV_LOCK);
 268     r = env_init(FALSE, TRUE);
 269     _unlock(_ENV_LOCK);
 270     if (r) return -1;
 271
 272     if (eq)
 273     {
 274         env = strdup(name);
 275         if (!env) return -1;
 276     }
 277     else
 278     {
 279         int name_len = strlen(name);
 280
 281         r = strlen(val);
 282         env = malloc(name_len + r + 2);
 283         if (!env) return -1;
 284         memcpy(env, name, name_len);
 285         env[name_len] = '=';
 286         strcpy(env + name_len + 1, val);
 287     }
 288
 289     wenv = msvcrt_wstrdupa(env);
 290     if (!wenv)
 291     {
 292         free(env);
 293         return -1;
 294     }
 295
 296     _lock(_ENV_LOCK);
 297     r = env_set(&env, &wenv);
 298     _unlock(_ENV_LOCK);
 299     free(env);
 300     free(wenv);
 301     return r;
 302 }
 303
 304 static char *msvcrt_astrdupw(const wchar_t *wstr)
 305 {
 306     const unsigned int len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
 307     char *str = malloc(len * sizeof(char));
 308
 309     if (!str)
 310         return NULL;
 311     WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
 312     return str;
 313 }
 314
 315
 316 static int wputenv_helper(const wchar_t *name, const wchar_t *val, const wchar_t *eq)
 317 {
 318     wchar_t *wenv;
 319     char *env;
 320     int r;
 321
 322     _lock(_ENV_LOCK);
 323     r = env_init(TRUE, TRUE);
 324     _unlock(_ENV_LOCK);
 325     if (r) return -1;
 326
 327     if (eq)
 328     {
 329         wenv = wcsdup(name);
 330         if (!wenv) return -1;
 331     }
 332     else
 333     {
 334         int name_len = wcslen(name);
 335
 336         r = wcslen(val);
 337         wenv = malloc((name_len + r + 2) * sizeof(wchar_t));
 338         if (!wenv) return -1;
 339         memcpy(wenv, name, name_len * sizeof(wchar_t));
 340         wenv[name_len] = '=';
 341         wcscpy(wenv + name_len + 1, val);
 342     }
 343
 344     env = msvcrt_astrdupw(wenv);
 345     if (!env)
 346     {
 347         free(wenv);
 348         return -1;
 349     }
 350
 351     _lock(_ENV_LOCK);
 352     r = env_set(&env, &wenv);
 353     _unlock(_ENV_LOCK);
 354     free(env);
 355     free(wenv);
 356     return r;
 357 }
 358
 359 /*********************************************************************
 360  *              _putenv (MSVCRT.@)
 361  */
 362 int CDECL _putenv(const char *str)
 363 {
 364     const char *eq;
 365
 366     TRACE("%s\n", debugstr_a(str));
 367
 368     if (!str || !(eq = strchr(str, '=')))
 369         return -1;
 370
 371     return putenv_helper(str, NULL, eq);
 372 }
 373
 374 /*********************************************************************
 375  *              _wputenv (MSVCRT.@)
 376  */
 377 int CDECL _wputenv(const wchar_t *str)
 378 {
 379     const wchar_t *eq;
 380
 381     TRACE("%s\n", debugstr_w(str));
 382
 383     if (!str || !(eq = wcschr(str, '=')))
 384         return -1;
 385
 386     return wputenv_helper(str, NULL, eq);
 387 }
 388
 389 /*********************************************************************
 390  *              _putenv_s (MSVCRT.@)
 391  */
 392 errno_t CDECL _putenv_s(const char *name, const char *value)
 393 {
 394     errno_t ret = 0;
 395
 396     TRACE("%s %s\n", debugstr_a(name), debugstr_a(value));
 397
 398     if (!MSVCRT_CHECK_PMT(name != NULL)) return EINVAL;
 399     if (!MSVCRT_CHECK_PMT(value != NULL)) return EINVAL;
 400
 401     if (putenv_helper(name, value, NULL) < 0)
 402     {
 403         msvcrt_set_errno(GetLastError());
 404         ret = *_errno();
 405     }
 406
 407     return ret;
 408 }
 409
 410 /*********************************************************************
 411  *              _wputenv_s (MSVCRT.@)
 412  */
 413 errno_t CDECL _wputenv_s(const wchar_t *name, const wchar_t *value)
 414 {
 415     errno_t ret = 0;
 416
 417     TRACE("%s %s\n", debugstr_w(name), debugstr_w(value));
 418
 419     if (!MSVCRT_CHECK_PMT(name != NULL)) return EINVAL;
 420     if (!MSVCRT_CHECK_PMT(value != NULL)) return EINVAL;
 421
 422     if (wputenv_helper(name, value, NULL) < 0)
 423     {
 424         msvcrt_set_errno(GetLastError());
 425         ret = *_errno();
 426     }
 427
 428     return ret;
 429 }
 430
 431 #if _MSVCR_VER>=80
 432
 433 /******************************************************************
 434  *              _dupenv_s (MSVCR80.@)
 435  */
 436 int CDECL _dupenv_s(char **buffer, size_t *numberOfElements, const char *varname)
 437 {
 438     char *e;
 439     size_t sz;
 440
 441     if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
 442     if (!MSVCRT_CHECK_PMT(varname != NULL)) return EINVAL;
 443
 444     _lock(_ENV_LOCK);
 445     if (!(e = getenv(varname)))
 446     {
 447         _unlock(_ENV_LOCK);
 448         *buffer = NULL;
 449         if (numberOfElements) *numberOfElements = 0;
 450         return 0;
 451     }
 452
 453     sz = strlen(e) + 1;
 454     *buffer = malloc(sz);
 455     if (*buffer) strcpy(*buffer, e);
 456     _unlock(_ENV_LOCK);
 457
 458     if (!*buffer)
 459     {
 460         if (numberOfElements) *numberOfElements = 0;
 461         return *_errno() = ENOMEM;
 462     }
 463     if (numberOfElements) *numberOfElements = sz;
 464     return 0;
 465 }
 466
 467 /******************************************************************
 468  *              _wdupenv_s (MSVCR80.@)
 469  */
 470 int CDECL _wdupenv_s(wchar_t **buffer, size_t *numberOfElements,
 471                      const wchar_t *varname)
 472 {
 473     wchar_t *e;
 474     size_t sz;
 475
 476     if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
 477     if (!MSVCRT_CHECK_PMT(varname != NULL)) return EINVAL;
 478
 479     _lock(_ENV_LOCK);
 480     if (!(e = _wgetenv(varname)))
 481     {
 482         _unlock(_ENV_LOCK);
 483         *buffer = NULL;
 484         if (numberOfElements) *numberOfElements = 0;
 485         return 0;
 486     }
 487
 488     sz = wcslen(e) + 1;
 489     *buffer = malloc(sz * sizeof(wchar_t));
 490     if (*buffer) wcscpy(*buffer, e);
 491     _unlock(_ENV_LOCK);
 492
 493     if (!*buffer)
 494     {
 495         if (numberOfElements) *numberOfElements = 0;
 496         return *_errno() = ENOMEM;
 497     }
 498     if (numberOfElements) *numberOfElements = sz;
 499     return 0;
 500 }
 501
 502 #endif /* _MSVCR_VER>=80 */
 503
 504 /******************************************************************
 505  *              getenv_s (MSVCRT.@)
 506  */
 507 int CDECL getenv_s(size_t *ret_len, char* buffer, size_t len, const char *varname)
 508 {
 509     char *e;
 510
 511     if (!MSVCRT_CHECK_PMT(ret_len != NULL)) return EINVAL;
 512     *ret_len = 0;
 513     if (!MSVCRT_CHECK_PMT((buffer && len > 0) || (!buffer && !len))) return EINVAL;
 514     if (buffer) buffer[0] = 0;
 515
 516     _lock(_ENV_LOCK);
 517     e = getenv_helper(varname);
 518     if (e)
 519     {
 520         *ret_len = strlen(e) + 1;
 521         if (len >= *ret_len) strcpy(buffer, e);
 522     }
 523     _unlock(_ENV_LOCK);
 524
 525     if (!e || !len) return 0;
 526     if (len < *ret_len) return ERANGE;
 527     return 0;
 528 }
 529
 530 /******************************************************************
 531  *              _wgetenv_s (MSVCRT.@)
 532  */
 533 int CDECL _wgetenv_s(size_t *ret_len, wchar_t *buffer, size_t len,
 534                      const wchar_t *varname)
 535 {
 536     wchar_t *e;
 537
 538     if (!MSVCRT_CHECK_PMT(ret_len != NULL)) return EINVAL;
 539     *ret_len = 0;
 540     if (!MSVCRT_CHECK_PMT((buffer && len > 0) || (!buffer && !len))) return EINVAL;
 541     if (buffer) buffer[0] = 0;
 542
 543     _lock(_ENV_LOCK);
 544     e = wgetenv_helper(varname);
 545     if (e)
 546     {
 547         *ret_len = wcslen(e) + 1;
 548         if (len >= *ret_len) wcscpy(buffer, e);
 549     }
 550     _unlock(_ENV_LOCK);
 551
 552     if (!e || !len) return 0;
 553     if (len < *ret_len) return ERANGE;
 554     return 0;
 555 }
 556
 557 /*********************************************************************
 558  *              _get_environ (MSVCRT.@)
 559  */
 560 void CDECL _get_environ(char ***ptr)
 561 {
 562     *ptr = MSVCRT__environ;
 563 }
 564
 565 /*********************************************************************
 566  *              _get_wenviron (MSVCRT.@)
 567  */
 568 void CDECL _get_wenviron(wchar_t ***ptr)
 569 {
 570     *ptr = MSVCRT__wenviron;
 571 }