environ.c File Reference

#include <precomp.h>
#include <internal/wine/msvcrt.h>

Include dependency graph for environ.c:

Go to the source code of this file.

Functions
int	BlockEnvToEnvironA (void)
int	BlockEnvToEnvironW (void)
char **	DuplicateEnvironment (char **original_environment, int wide)
void	FreeEnvironment (char **environment)
int	SetEnv (const wchar_t *option)
int *	__p__commode (void)
void	__set_app_type (int app_type)
char **	__p__acmdln (void)
wchar_t **	__p__wcmdln (void)
char ***	__p__environ (void)
wchar_t ***	__p__wenviron (void)
char ***	__p___initenv (void)
wchar_t ***	__p___winitenv (void)
errno_t	_get_osplatform (unsigned int *pValue)
int *	__p___mb_cur_max (void)
int CDECL	___mb_cur_max_func (void)
unsigned int *	__p__osver (void)
char **	__p__pgmptr (void)
int	_get_pgmptr (char **p)
wchar_t **	__p__wpgmptr (void)
int	_get_wpgmptr (WCHAR **p)
unsigned int *	__p__winmajor (void)
unsigned int *	__p__winminor (void)
unsigned int *	__p__winver (void)

Variables
unsigned int	_osplatform = 0
unsigned int	_osver = 0
unsigned int	_winminor = 0
unsigned int	_winmajor = 0
unsigned int	_winver = 0
unsigned int	__setlc_active = 0
unsigned int	__unguarded_readlc_active = 0
char *	_acmdln = NULL
wchar_t *	_wcmdln = NULL
char **	_environ = NULL
wchar_t **	_wenviron = NULL
char **	__initenv = NULL
wchar_t **	__winitenv = NULL
char *	_pgmptr = NULL
wchar_t *	_wpgmptr = NULL
int	__app_type = _UNKNOWN_APP
int	_commode

Function Documentation

___mb_cur_max_func()

int CDECL ___mb_cur_max_func

(

void

)

Definition at line 438 of file environ.c.

{
  return get_locinfo()->mb_cur_max;
}

__p___initenv()

char *** __p___initenv

(

void

)

Definition at line 400 of file environ.c.

{
    return &__initenv;
}

Referenced by Test___initenv().

__p___mb_cur_max()

int * __p___mb_cur_max

(

void

)

Definition at line 430 of file environ.c.

{
    return &get_locinfo()->mb_cur_max;
}

__p___winitenv()

wchar_t *** __p___winitenv

(

void

)

Definition at line 408 of file environ.c.

{
    return &__winitenv;
}

Referenced by Test___winitenv().

__p__acmdln()

char ** __p__acmdln

(

void

)

Definition at line 368 of file environ.c.

{
    return &_acmdln;
}

__p__commode()

int * __p__commode

(

void

)

Definition at line 352 of file environ.c.

{
   return &_commode;
}

Referenced by Test__commode().

__p__environ()

char *** __p__environ

(

void

)

Definition at line 384 of file environ.c.

{
    return &_environ;
}

__p__osver()

unsigned int * __p__osver

(

void

)

Definition at line 446 of file environ.c.

{
    return &_osver;
}

Referenced by Test__osver().

__p__pgmptr()

char ** __p__pgmptr

(

void

)

Definition at line 454 of file environ.c.

{
    return &_pgmptr;
}

__p__wcmdln()

wchar_t ** __p__wcmdln

(

void

)

Definition at line 376 of file environ.c.

{
    return &_wcmdln;
}

__p__wenviron()

wchar_t *** __p__wenviron

(

void

)

Definition at line 392 of file environ.c.

{
    return &_wenviron;
}

__p__winmajor()

unsigned int * __p__winmajor

(

void

)

Definition at line 500 of file environ.c.

{
    return &_winmajor;
}

Referenced by Test__winmajor().

__p__winminor()

unsigned int * __p__winminor

(

void

)

Definition at line 508 of file environ.c.

{
    return &_winminor;
}

Referenced by Test__winminor().

__p__winver()

unsigned int * __p__winver

(

void

)

Definition at line 516 of file environ.c.

{
    return &_winver;
}

Referenced by Test__winver().

__p__wpgmptr()

wchar_t ** __p__wpgmptr

(

void

)

Definition at line 477 of file environ.c.

{
    return &_wpgmptr;
}

__set_app_type()

void __set_app_type

(

int

app_type

)

Definition at line 360 of file environ.c.

{
    __app_type = app_type;
}

_get_osplatform()

errno_t _get_osplatform

(

unsigned int *

pValue

)

Definition at line 416 of file environ.c.

{
    if (!MSVCRT_CHECK_PMT(pValue != NULL)) {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    *pValue = _osplatform;
    return 0;
}

_get_pgmptr()

int _get_pgmptr

(

char **

p

)

Definition at line 462 of file environ.c.

{
  if (!MSVCRT_CHECK_PMT(p))
  {
    *_errno() = EINVAL;
    return EINVAL;
  }
 
  *p = _pgmptr;
  return 0;
}

_get_wpgmptr()

int _get_wpgmptr

(

WCHAR **

p

)

Definition at line 485 of file environ.c.

{
  if (!MSVCRT_CHECK_PMT(p))
  {
    *_errno() = EINVAL;
    return EINVAL;
  }
 
  *p = _wpgmptr;
  return 0;
}

BlockEnvToEnvironA()

int BlockEnvToEnvironA

(

void

)

Definition at line 34 of file environ.c.

{
   char *ptr, *environment_strings;
   char **envptr;
   int count = 1;
   size_t len;
 
   TRACE("BlockEnvToEnvironA()\n");
 
   environment_strings = GetEnvironmentStringsA();
   if (environment_strings == NULL) {
      return -1;
   }
 
   for (ptr = environment_strings; *ptr; ptr += len)
   {
      len = strlen(ptr) + 1;
      /* Skip drive letter settings. */
      if (*ptr != '=')
         count++;
   }
 
   __initenv = _environ = malloc(count * sizeof(char*));
   if (_environ)
   {
      for (ptr = environment_strings, envptr = _environ; count > 1; ptr += len)
      {
         len = strlen(ptr) + 1;
         /* Skip drive letter settings. */
         if (*ptr != '=')
         {
            if ((*envptr = malloc(len)) == NULL)
            {
               for (envptr--; envptr >= _environ; envptr--)
                  free(*envptr);
               FreeEnvironmentStringsA(environment_strings);
               free(_environ);
               __initenv = _environ = NULL;
               return -1;
            }
            memcpy(*envptr++, ptr, len);
            count--;
         }
      }
      /* Add terminating NULL entry. */
      *envptr = NULL;
   }
 
   FreeEnvironmentStringsA(environment_strings);
   return _environ ? 0 : -1;
}

Referenced by crt_process_init(), and DllMain().

BlockEnvToEnvironW()

int BlockEnvToEnvironW

(

void

)

Definition at line 86 of file environ.c.

{
   wchar_t *ptr, *environment_strings;
   wchar_t **envptr;
   int count = 1;
   size_t len;
 
   TRACE("BlockEnvToEnvironW()\n");
 
   environment_strings = GetEnvironmentStringsW();
   if (environment_strings == NULL) {
      return -1;
   }
 
   for (ptr = environment_strings; *ptr; ptr += len)
   {
      len = wcslen(ptr) + 1;
      /* Skip drive letter settings. */
      if (*ptr != '=')
         count++;
   }
 
   __winitenv = _wenviron = malloc(count * sizeof(wchar_t*));
   if (_wenviron)
   {
      for (ptr = environment_strings, envptr = _wenviron; count > 1; ptr += len)
      {
         len = wcslen(ptr) + 1;
         /* Skip drive letter settings. */
         if (*ptr != '=')
         {
            if ((*envptr = malloc(len * sizeof(wchar_t))) == NULL)
            {
               for (envptr--; envptr >= _wenviron; envptr--)
                  free(*envptr);
               FreeEnvironmentStringsW(environment_strings);
               free(_wenviron);
               __winitenv = _wenviron = NULL;
               return -1;
            }
            memcpy(*envptr++, ptr, len * sizeof(wchar_t));
            count--;
         }
      }
      /* Add terminating NULL entry. */
      *envptr = NULL;
   }
 
   FreeEnvironmentStringsW(environment_strings);
   return _wenviron ? 0 : -1;
}

Referenced by crt_process_init(), and DllMain().

DuplicateEnvironment()

char ** DuplicateEnvironment	(	char **	original_environment,
		int	wide
	)

Internal function to duplicate environment block. Although it's parameter are defined as char**, it's able to work also with wide character environment block which are of type wchar_t**.

Parameters

original_environment	Environment to duplicate.
wide	Set to zero for multibyte environments, non-zero otherwise.

Returns

Original environment in case of failure, otherwise pointer to new environment block.

Definition at line 151 of file environ.c.

{
   int count = 1;
   char **envptr, **newenvptr, **newenv;
 
   for (envptr = original_environment; *envptr != NULL; envptr++, count++)
      ;
 
   newenvptr = newenv = malloc(count * sizeof(char*));
   if (newenv == NULL)
      return original_environment;
 
   for (envptr = original_environment; count > 1; newenvptr++, count--)
   {
      if (wide)
         *newenvptr = (char*)_wcsdup((wchar_t*)*envptr++);
      else
         *newenvptr = _strdup(*envptr++);
      if (*newenvptr == NULL)
      {
         for (newenvptr--; newenvptr >= newenv; newenvptr--)
            free(*newenvptr);
         free(newenv);
         return original_environment;
      }
   }
   *newenvptr = NULL;
 
   return newenv;
}

Referenced by SetEnv().

FreeEnvironment()

void FreeEnvironment

(

char **

environment

)

Internal function to deallocate environment block. Although it's parameter are defined as char**, it's able to work also with wide character environment block which are of type wchar_t**.

Parameters

environment

Environment to free.

Definition at line 190 of file environ.c.

{
   char **envptr;
   for (envptr = environment; *envptr != NULL; envptr++)
      free(*envptr);
   free(environment);
}

Referenced by crt_process_init(), DllMain(), and msvcrt_init_exception().

SetEnv()

int SetEnv

(

const wchar_t *

option

)

Internal version of _wputenv and _putenv. It works duplicates the original envirnments created during initilization if needed to prevent having spurious pointers floating around. Then it updates the internal environment tables (_environ and _wenviron) and at last updates the OS environemnt.

Note that there can happen situation when the internal [_w]environ arrays will be updated, but the OS environment update will fail. In this case we don't undo the changes to the [_w]environ tables to comply with the Microsoft behaviour (and it's also much easier :-).

Definition at line 210 of file environ.c.

{
   wchar_t *epos, *name;
   wchar_t **wenvptr;
   wchar_t *woption;
   char *mboption;
   int remove, index, count, size, result = 0, found = 0;
   wchar_t **wnewenv;
   char **mbnewenv;
 
   if (option == NULL || (epos = wcschr(option, L'=')) == NULL)
      return -1;
   remove = (epos[1] == 0);
 
   /* Duplicate environment if needed. */
   if (_environ == __initenv)
   {
      if ((_environ = DuplicateEnvironment(_environ, 0)) == __initenv)
         return -1;
   }
   if (_wenviron == __winitenv)
   {
      if ((_wenviron = (wchar_t**)DuplicateEnvironment((char**)_wenviron, 1)) ==
          __winitenv)
         return -1;
   }
 
   /* Create a copy of the option name. */
   name = malloc((epos - option + 1) * sizeof(wchar_t));
   if (name == NULL)
      return -1;
   memcpy(name, option, (epos - option) * sizeof(wchar_t));
   name[epos - option] = 0;
 
   /* Find the option we're trying to modify. */
   for (index = 0, wenvptr = _wenviron; *wenvptr != NULL; wenvptr++, index++)
   {
      if (!_wcsnicmp(*wenvptr, option, epos - option))
      {
         found = 1;
         break;
      }
   }
 
   if (remove)
   {
      if (!found)
      {
         free(name);
         return 0;
      }
 
      /* Remove the option from wide character environment. */
      free(*wenvptr);
      for (count = index; *wenvptr != NULL; wenvptr++, count++)
         *wenvptr = *(wenvptr + 1);
      wnewenv = realloc(_wenviron, count * sizeof(wchar_t*));
      if (wnewenv != NULL)
         _wenviron = wnewenv;
 
      /* Remove the option from multibyte environment. We assume
       * the environments are in sync and the option is at the
       * same position. */
      free(_environ[index]);
      memmove(&_environ[index], &_environ[index+1], (count - index) * sizeof(char*));
      mbnewenv = realloc(_environ, count * sizeof(char*));
      if (mbnewenv != NULL)
         _environ = mbnewenv;
 
      result = SetEnvironmentVariableW(name, NULL) ? 0 : -1;
   }
   else
   {
      /* Make a copy of the option that we will store in the environment block. */
      woption = _wcsdup((wchar_t*)option);
      if (woption == NULL)
      {
         free(name);
         return -1;
      }
 
      /* Create a multibyte copy of the option. */
      size = WideCharToMultiByte(CP_ACP, 0, option, -1, NULL, 0, NULL, NULL);
      mboption = malloc(size);
      if (mboption == NULL)
      {
         free(name);
         free(woption);
         return -1;
      }
      WideCharToMultiByte(CP_ACP, 0, option, -1, mboption, size, NULL, NULL);
 
      if (found)
      {
         /* Replace the current entry. */
         free(*wenvptr);
         *wenvptr = woption;
         free(_environ[index]);
         _environ[index] = mboption;
      }
      else
      {
         /* Get the size of the original environment. */
         for (count = index; *wenvptr != NULL; wenvptr++, count++)
            ;
 
         /* Create a new entry. */
         if ((wnewenv = realloc(_wenviron, (count + 2) * sizeof(wchar_t*))) == NULL)
         {
            free(name);
            free(mboption);
            free(woption);
            return -1;
         }
         _wenviron = wnewenv;
         if ((mbnewenv = realloc(_environ, (count + 2) * sizeof(char*))) == NULL)
         {
            free(name);
            free(mboption);
            free(woption);
            return -1;
         }
         _environ = mbnewenv;
 
         /* Set the last entry to our option. */
         _wenviron[count] = woption;
         _environ[count] = mboption;
         _wenviron[count + 1] = NULL;
         _environ[count + 1] = NULL;
      }
 
      /* And finally update the OS environment. */
      result = SetEnvironmentVariableW(name, epos + 1) ? 0 : -1;
   }
   free(name);
 
   return result;
}

Referenced by _putenv(), and _wputenv().

Variable Documentation

__app_type

int __app_type = _UNKNOWN_APP

Definition at line 30 of file environ.c.

Referenced by __set_app_type(), _assert(), and abort().

__initenv

char** __initenv = NULL

Definition at line 24 of file environ.c.

Referenced by __p___initenv(), BlockEnvToEnvironA(), DllMain(), msvcrt_init_exception(), SetEnv(), and Test___initenv().

__setlc_active

unsigned int __setlc_active = 0

Definition at line 16 of file environ.c.

Referenced by ___setlc_active_func(), and Test___setlc_active().

__unguarded_readlc_active

unsigned int __unguarded_readlc_active = 0

Definition at line 17 of file environ.c.

Referenced by ___unguarded_readlc_active_add_func(), and Test___unguarded_readlc_active().

__winitenv

wchar_t** __winitenv = NULL

Definition at line 25 of file environ.c.

Referenced by __p___winitenv(), __wgetmainargs(), BlockEnvToEnvironW(), DllMain(), msvcrt_init_exception(), SetEnv(), and Test___winitenv().

_acmdln

char* _acmdln = NULL

Definition at line 18 of file environ.c.

Referenced by __p__acmdln().

_commode

int _commode

Definition at line 31 of file environ.c.

Referenced by __p__commode().

_environ

char** _environ = NULL

Definition at line 22 of file environ.c.

Referenced by __getmainargs(), __p__environ(), BlockEnvToEnvironA(), crt_process_init(), DllMain(), msvcrt_init_exception(), and SetEnv().

_osplatform

unsigned int _osplatform = 0

Definition at line 10 of file environ.c.

Referenced by _get_osplatform(), crt_process_init(), DllMain(), and Test__osplatform().

_osver

unsigned int _osver = 0

Definition at line 11 of file environ.c.

Referenced by __p__osver(), crt_process_init(), DllMain(), and Test__osver().

_pgmptr

char* _pgmptr = NULL

Definition at line 27 of file environ.c.

Referenced by __p__pgmptr(), and _get_pgmptr().

_wcmdln

wchar_t* _wcmdln = NULL

Definition at line 19 of file environ.c.

Referenced by __p__wcmdln().

_wenviron

wchar_t** _wenviron = NULL

Definition at line 23 of file environ.c.

Referenced by __p__wenviron(), BlockEnvToEnvironW(), DllMain(), msvcrt_init_exception(), and SetEnv().

_winmajor

unsigned int _winmajor = 0

Definition at line 13 of file environ.c.

Referenced by __p__winmajor(), crt_process_init(), DllMain(), and Test__winmajor().

_winminor

unsigned int _winminor = 0

Definition at line 12 of file environ.c.

Referenced by __p__winminor(), crt_process_init(), DllMain(), and Test__winminor().

_winver

unsigned int _winver = 0

Definition at line 14 of file environ.c.

Referenced by __p__winver(), crt_process_init(), DllMain(), test__wcstoi64(), Test__winver(), test_demangle(), and test_xcvt().

_wpgmptr

wchar_t* _wpgmptr = NULL

Definition at line 29 of file environ.c.

Referenced by __p__wpgmptr(), and _get_wpgmptr().