|
|
/***
*setenv.c -set an environment variable in the environment** Copyright (c) 1993-2001, Microsoft Corporation. All rights reserved.**Purpose:* defines __crtsetenv() - adds a new variable to environment.* Internal use only.**Revision History:* 11-30-93 CFW Module created, most of it grabbed from putenv.c.* 12-07-93 CFW Change _TCHAR to _TSCHAR.* 01-15-94 CFW Use _tcsnicoll for global match.* 01-28-94 CFW Copy environment when re-alloc.* 03-25-94 GJF Declaration of __[w]initenv moved to internal.h.* 01-10-95 CFW Debug CRT allocs.* 01-18-95 GJF Must replace _tcsdup with _malloc_crt/_tcscpy for* _DEBUG build.* 06-01-95 CFW Free strings for removed environemnt variables.* 03-03-98 RKP Add support for 64 bit* 05-28-99 GJF When appropriate, free up the option string.* 08-03-99 PML Fix use-after-free bug in __crtsetenv()* 02-23-00 GB Fix __crtwsetenv() so as to work on Win9x.* 05-17-00 GB Use ERROR_CALL_NOT_IMPLEMENTED for existance of W API* 05-23-00 GB return error (-1) for API returning error********************************************************************************/
#ifndef _POSIX_
#include <windows.h>
#include <cruntime.h>
#include <internal.h>
#include <stdlib.h>
#include <tchar.h>
#include <rterr.h>
#include <dbgint.h>
static _TSCHAR **copy_environ(_TSCHAR **);
#ifdef WPRFLAG
static int __cdecl wfindenv(const wchar_t *name, int len);#define USE_W 1
#define USE_A 0
#else
static int __cdecl findenv(const char *name, int len);#endif
/***
*int __crtsetenv(option) - add/replace/remove variable in environment**Purpose:* option should be of the form "option=value". If a string with the* given option part already exists, it is replaced with the given* string; otherwise the given string is added to the environment.* If the string is of the form "option=", then the string is* removed from the environment, if it exists. If the string has* no equals sign, error is returned.**Entry:* char *option - option string to set in the environment list.* should be of the form "option=value".* int primary - Only the primary call to _crt[w]setenv needs to* create new copies or set the OS environment.* 1 indicates that this is the primary call.**Exit:* returns 0 if OK, -1 if fails.**Exceptions:**Warnings:* This code will not work if variables are removed from the environment* by deleting them from environ[]. Use _putenv("option=") to remove a * variable.** The option argument may be freed!********************************************************************************/
#ifdef WPRFLAG
int __cdecl __crtwsetenv (#else
int __cdecl __crtsetenv (#endif
_TSCHAR *option, const int primary ){#ifdef WPRFLAG
static int f_use = USE_W;#endif
int ix; int retval = 0; int remove; /* 1 if variable is to be removed */ _TSCHAR **env; _TSCHAR *name, *value; const _TSCHAR *equal;
/*
* check that the option string is valid, find the equal sign * and verify '=' is not the first character in string. */ if ( (option == NULL) || ((equal = _tcschr(option, _T('='))) == NULL) || option == equal) return(-1);
/* if the character following '=' is null, we are removing the
* the environment variable. Otherwise, we are adding or updating * an environment variable. */ remove = (*(equal + 1) == _T('\0'));
/*
* the first time _[w]putenv() is called, copy the environment * block that was passed to [w]main to avoid making a * dangling pointer if the block is re-alloced. */#ifdef WPRFLAG
if (_wenviron == __winitenv) _wenviron = copy_environ(_wenviron);#else
if (_environ == __initenv) _environ = copy_environ(_environ);#endif
/* see if requested environment array exists */ if (_tenviron == NULL) {
/*
* The requested type of environment does not exist. * See if other type exists, if so convert it to requested type. * The functions that convert the enviroment (__mbtow_environ and * __wtomb_environ) will call this function (__crt[w]setenv) once * for each of the pre-existing environment variables. To avoid * an infinite loop, test the primary flag. */
#ifdef WPRFLAG
if (primary && _environ) { if (__mbtow_environ() != 0) return -1; }#else
if (primary && _wenviron) { if (__wtomb_environ() != 0) return -1; }#endif
else { /* nothing to remove, return */ if ( remove ) return 0; else { /* create ones that do not exist */
if (_environ == NULL) { _environ = _malloc_crt(sizeof(char *)); if (!_environ) return -1; *_environ = NULL; }
if (_wenviron == NULL) { _wenviron = _malloc_crt(sizeof(wchar_t *)); if (!_wenviron) return -1; *_wenviron = NULL; } } } }
/*
* At this point, the two types of environments are in sync (as much * as they can be anyway). The only way they can get out of sync * (besides users directly modifiying the environment) is if there * are conversion problems: If the user sets two Unicode EVs, * "foo1" and "foo2" and converting then to multibyte yields "foo?" * and "foo?", then the environment blocks will differ. */
/* init env pointers */ env = _tenviron;
/* See if the string is already in the environment */#ifdef WPRFLAG
ix = wfindenv(option, (int)(equal - option));#else
ix = findenv(option, (int)(equal - option));#endif
if ((ix >= 0) && (*env != NULL)) { /*
* String is already in the environment. Free up the original * string. Then, install the new string or shrink the environment, * whichever is warranted. */ _free_crt(env[ix]);
if (remove) { void *pv;
/* removing -- move all the later strings up */ for ( ; env[ix] != NULL; ++ix) { env[ix] = env[ix+1]; }
/* shrink the environment memory block
(ix now has number of strings, including NULL) -- this realloc probably can't fail, since we're shrinking a mem block, but we're careful anyway. */ if (pv = (_TSCHAR **) _realloc_crt(env, ix * sizeof(_TSCHAR *))) _tenviron = pv; } else { /* replace the option */ env[ix] = (_TSCHAR *) option; } } else { /*
* String is NOT in the environment */ if ( !remove ) { void *pv; /*
* Append the string to the environ table. Note that * table must be grown to do this. */ if (ix < 0) ix = -ix; /* ix = length of environ table */
pv = _realloc_crt(env, sizeof(_TSCHAR *) * (ix + 2)); if (!pv) return -1; else env = (_TSCHAR **)pv;
env[ix] = (_TSCHAR *)option; env[ix + 1] = NULL;
_tenviron = env; } else { /*
* We are asked to remove an environment var that isn't there. * Free the option string and return success. */ _free_crt(option); return 0; } }
/*
* Update the OS environment. Don't give an error if this fails * since the failure will not affect the user unless he/she is making * direct API calls. Only need to do this for one type, OS converts * to other type automatically. */ if ( primary && (name = (_TSCHAR *)_malloc_crt((_tcslen(option) + 2) * sizeof(_TSCHAR))) != NULL ) { _tcscpy(name, option); value = name + (equal - option); *value++ = _T('\0');#ifdef WPRFLAG
if (f_use == USE_W) { if ( SetEnvironmentVariableW(name, remove ? NULL : value) == 0) { if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) f_use = USE_A; else retval = -1; } } if (f_use == USE_A) { int size; char *c_name = NULL, *c_value = NULL; if ((size = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL)) == 0) retval = -1; /* allocate space for variable */ else if ((c_name = (char *) _malloc_crt(size * sizeof(char))) == NULL) retval = -1; /* convert it */ else if (WideCharToMultiByte(CP_ACP, 0, name, -1, c_name, size, NULL, NULL) == 0) retval = -1; else if ( !remove ) { if ((size = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL)) == 0) retval = -1; /* allocate space for variable */ else if ((c_value = (char *) _malloc_crt(size * sizeof(char))) == NULL) retval = -1; /* convert it */ else if (WideCharToMultiByte(CP_ACP, 0, value, -1, c_value, size, NULL, NULL) == 0) retval = -1; }
if (retval != -1) if (SetEnvironmentVariableA(c_name, remove ? NULL : c_value) == 0) retval = -1;
_free_crt(c_value); _free_crt(c_name); }#else
if (SetEnvironmentVariable(name, remove ? NULL : value) == 0) retval = -1;#endif
_free_crt(name); }
if (remove) { /* free option string since it won't be used anymore */ _free_crt(option); }
return retval;}
/***
*int findenv(name, len) - [STATIC]**Purpose:* Scan for the given string within the environment**Entry:**Exit:* Returns the offset in "environ[]" of the given variable* Returns the negative of the length of environ[] if not found.* Returns 0 if the environment is empty.** [NOTE: That a 0 return can mean that the environment is empty* or that the string was found as the first entry in the array.]**Exceptions:********************************************************************************/
#ifdef WPRFLAG
static int __cdecl wfindenv (#else
static int __cdecl findenv (#endif
const _TSCHAR *name, int len ){ _TSCHAR **env;
for ( env = _tenviron ; *env != NULL ; env++ ) { /*
* See if first len characters match, up to case */ if ( _tcsnicoll(name, *env, len) == 0 ) /*
* the next character of the environment string must * be an '=' or a '\0' */ if ( (*env)[len] == _T('=') || (*env)[len] == _T('\0') ) return(int)(env - _tenviron);//
// We cannot break here since findenv must report the total number of strings.
// else
// break;
}
return(-(int)(env - _tenviron));}
/***
*copy_environ - copy an environment block**Purpose:* Create a copy of an environment block.**Entry:* _TSCHAR **oldenviron - pointer to enviroment to be copied.**Exit:* Returns a pointer to newly created environment.**Exceptions:********************************************************************************/
static _TSCHAR **copy_environ(_TSCHAR **oldenviron){ int cvars = 0; _TSCHAR **oldenvptr = oldenviron; _TSCHAR **newenviron, **newenvptr;
/* no environment */ if (oldenviron == NULL) return NULL;
/* count number of environment variables */ while (*oldenvptr++) cvars++;
/* need pointer for each string, plus one null ptr at end */ if ( (newenviron = newenvptr = (_TSCHAR **) _malloc_crt((cvars+1) * sizeof(_TSCHAR *))) == NULL ) _amsg_exit(_RT_SPACEENV);
/* duplicate the environment variable strings */ oldenvptr = oldenviron; while (*oldenvptr)#ifdef _DEBUG
{ if ( (*newenvptr = _malloc_crt((_tcslen(*oldenvptr)+1) * sizeof(_TSCHAR))) != NULL ) _tcscpy(*newenvptr, *oldenvptr); oldenvptr++; newenvptr++; }#else /* ndef _DEBUG */
*newenvptr++ = _tcsdup(*oldenvptr++);#endif /* _DEBUG */
*newenvptr = NULL;
return newenviron;}
#endif /* POSIX */
|
