environment.c File Reference

#include "precomp.h"
#include <debug.h>

Include dependency graph for environment.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static BOOL	SetUserEnvironmentVariable (PWSTR *Environment, LPWSTR lpName, LPWSTR lpValue, BOOL bExpand)
static BOOL	AppendUserEnvironmentVariable (PWSTR *Environment, LPWSTR lpName, LPWSTR lpValue)
static HKEY	GetCurrentUserKey (HANDLE hToken)
static BOOL	GetUserAndDomainName (IN HANDLE hToken, OUT LPWSTR *UserName, OUT LPWSTR *DomainName)
static BOOL	SetUserEnvironment (PWSTR *Environment, HKEY hKey, LPWSTR lpSubKeyName)
static BOOL	SetSystemEnvironment (PWSTR *Environment)
BOOL WINAPI	CreateEnvironmentBlock (OUT LPVOID *lpEnvironment, IN HANDLE hToken, IN BOOL bInherit)
BOOL WINAPI	DestroyEnvironmentBlock (IN LPVOID lpEnvironment)
BOOL WINAPI	ExpandEnvironmentStringsForUserW (IN HANDLE hToken, IN LPCWSTR lpSrc, OUT LPWSTR lpDest, IN DWORD dwSize)
BOOL WINAPI	ExpandEnvironmentStringsForUserA (IN HANDLE hToken, IN LPCSTR lpSrc, OUT LPSTR lpDest, IN DWORD dwSize)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 29 of file environment.c.

Function Documentation

AppendUserEnvironmentVariable()

static BOOL AppendUserEnvironmentVariable ( PWSTR *  Environment, LPWSTR  lpName, LPWSTR  lpValue  )

static

Definition at line 116 of file environment.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name, Value;
 
    RtlInitUnicodeString(&Name, lpName);
 
    Value.Length = 0;
    Value.MaximumLength = 1024 * sizeof(WCHAR);
    Value.Buffer = LocalAlloc(LPTR, Value.MaximumLength);
    if (Value.Buffer == NULL)
        return FALSE;
 
    Value.Buffer[0] = UNICODE_NULL;
 
    Status = RtlQueryEnvironmentVariable_U(*Environment,
                                           &Name,
                                           &Value);
    if (NT_SUCCESS(Status))
        RtlAppendUnicodeToString(&Value, L";");
 
    RtlAppendUnicodeToString(&Value, lpValue);
 
    Status = RtlSetEnvironmentVariable(Environment,
                                       &Name,
                                       &Value);
    LocalFree(Value.Buffer);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlSetEnvironmentVariable() failed (Status %lx)\n", Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by SetUserEnvironment().

CreateEnvironmentBlock()

BOOL WINAPI CreateEnvironmentBlock	(	OUT LPVOID *	lpEnvironment,
		IN HANDLE	hToken,
		IN BOOL	bInherit
	)

Definition at line 503 of file environment.c.

{
    NTSTATUS Status;
    LONG lError;
    PWSTR* Environment = (PWSTR*)lpEnvironment;
    DWORD Length;
    DWORD dwType;
    HKEY hKey;
    HKEY hKeyUser;
    LPWSTR lpUserName = NULL;
    LPWSTR lpDomainName = NULL;
    WCHAR Buffer[MAX_PATH];
    WCHAR PublicDirectory[MAX_PATH];
    WCHAR szValue[1024];
 
    DPRINT("CreateEnvironmentBlock() called\n");
 
    if (lpEnvironment == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    Status = RtlCreateEnvironment((BOOLEAN)bInherit, Environment);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlCreateEnvironment() failed (Status %lx)\n", Status);
        SetLastError(RtlNtStatusToDosError(Status));
        return FALSE;
    }
 
    /* Set 'SystemRoot' variable */
    Length = ARRAYSIZE(Buffer);
    if (GetEnvironmentVariableW(L"SystemRoot", Buffer, Length))
    {
        SetUserEnvironmentVariable(Environment,
                                   L"SystemRoot",
                                   Buffer,
                                   FALSE);
    }
 
    /* Set 'SystemDrive' variable */
    if (GetEnvironmentVariableW(L"SystemDrive", Buffer, Length))
    {
        SetUserEnvironmentVariable(Environment,
                                   L"SystemDrive",
                                   Buffer,
                                   FALSE);
    }
 
    /* Set variables from Session Manager */
    if (!SetSystemEnvironment(Environment))
    {
        RtlDestroyEnvironment(*Environment);
        return FALSE;
    }
 
    /* Set 'COMPUTERNAME' variable */
    Length = ARRAYSIZE(Buffer);
    if (GetComputerNameW(Buffer, &Length))
    {
        SetUserEnvironmentVariable(Environment,
                                   L"COMPUTERNAME",
                                   Buffer,
                                   FALSE);
    }
 
    /* Set 'ALLUSERSPROFILE' variable */
    Length = ARRAYSIZE(Buffer);
    if (GetAllUsersProfileDirectoryW(Buffer, &Length))
    {
        SetUserEnvironmentVariable(Environment,
                                   L"ALLUSERSPROFILE",
                                   Buffer,
                                   FALSE);
        SetUserEnvironmentVariable(Environment,
                            L"ProgramData",
                            Buffer,
                            FALSE);
    }
 
    /* Set 'USERPROFILE' variable to the default users profile */
    Length = ARRAYSIZE(Buffer);
    if (GetDefaultUserProfileDirectoryW(Buffer, &Length))
    {
        SetUserEnvironmentVariable(Environment,
                                   L"USERPROFILE",
                                   Buffer,
                                   TRUE);
    }
 
    lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                           L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion",
                           0,
                           KEY_READ,
                           &hKey);
    if (lError == ERROR_SUCCESS)
    {
        Length = sizeof(szValue);
        lError = RegQueryValueExW(hKey,
                                  L"ProgramFilesDir",
                                  NULL,
                                  &dwType,
                                  (LPBYTE)szValue,
                                  &Length);
        if (lError == ERROR_SUCCESS)
        {
            SetUserEnvironmentVariable(Environment,
                                       L"ProgramFiles",
                                       szValue,
                                       FALSE);
        }
 
        Length = sizeof(szValue);
        lError = RegQueryValueExW(hKey,
                                  L"CommonFilesDir",
                                  NULL,
                                  &dwType,
                                  (LPBYTE)szValue,
                                  &Length);
        if (lError == ERROR_SUCCESS)
        {
            SetUserEnvironmentVariable(Environment,
                                       L"CommonProgramFiles",
                                       szValue,
                                       FALSE);
        }
 
        RegCloseKey(hKey);
    }
 
    /* Set 'PUBLIC' variable to the public user directory */
    lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                        L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList",
                        0,
                        KEY_READ,
                        &hKey);
    if (lError == ERROR_SUCCESS)
    {
        Length = sizeof(szValue);
        lError = RegQueryValueExW(hKey,
                                  L"Public",
                                  NULL,
                                  &dwType,
                                  (LPBYTE)szValue,
                                  &Length);
        if (lError == ERROR_SUCCESS)
        {
            if (!ExpandEnvironmentStringsW(szValue,
                                            PublicDirectory,
                                            ARRAYSIZE(PublicDirectory)))
            {
                DPRINT1("Error: %lu\n", GetLastError());
                RegCloseKey(hKey);
                return FALSE;
            }
 
            SetUserEnvironmentVariable(Environment, L"PUBLIC", PublicDirectory, FALSE);
        }
        RegCloseKey(hKey);
    }
 
    /*
     * If no user token is specified, the system environment variables are set
     * and we stop here, otherwise continue setting the user-specific variables.
     */
    if (hToken == NULL)
        return TRUE;
 
    hKeyUser = GetCurrentUserKey(hToken);
    if (hKeyUser == NULL)
    {
        DPRINT1("GetCurrentUserKey() failed\n");
        RtlDestroyEnvironment(*Environment);
        return FALSE;
    }
 
    /* Set 'USERPROFILE' variable */
    Length = ARRAYSIZE(Buffer);
    if (GetUserProfileDirectoryW(hToken, Buffer, &Length))
    {
        DWORD MinLen = 2;
 
        SetUserEnvironmentVariable(Environment,
                                   L"USERPROFILE",
                                   Buffer,
                                   FALSE);
 
        // FIXME: Strangely enough the following two environment variables
        // are not set by userenv.dll in Windows... See r68284 / CORE-9875
        // FIXME2: This is done by msgina.dll !!
 
        /* At least <drive letter>:<path> */
        if (Length > MinLen)
        {
            /* Set 'HOMEDRIVE' variable */
            StringCchCopyNW(szValue, ARRAYSIZE(Buffer), Buffer, MinLen);
            SetUserEnvironmentVariable(Environment,
                                       L"HOMEDRIVE",
                                       szValue,
                                       FALSE);
 
            /* Set 'HOMEPATH' variable */
            StringCchCopyNW(szValue, ARRAYSIZE(Buffer), Buffer + MinLen, Length - MinLen);
            SetUserEnvironmentVariable(Environment,
                                       L"HOMEPATH",
                                       szValue,
                                       FALSE);
        }
    }
    else
    {
        DPRINT1("GetUserProfileDirectoryW failed with error %lu\n", GetLastError());
    }
 
    if (GetUserAndDomainName(hToken,
                             &lpUserName,
                             &lpDomainName))
    {
        /* Set 'USERNAME' variable */
        SetUserEnvironmentVariable(Environment,
                                   L"USERNAME",
                                   lpUserName,
                                   FALSE);
 
        /* Set 'USERDOMAIN' variable */
        SetUserEnvironmentVariable(Environment,
                                   L"USERDOMAIN",
                                   lpDomainName,
                                   FALSE);
 
        if (lpUserName != NULL)
            LocalFree(lpUserName);
 
        if (lpDomainName != NULL)
            LocalFree(lpDomainName);
    }
 
    /* Set user environment variables */
    SetUserEnvironment(Environment,
                       hKeyUser,
                       L"Environment");
 
    /* Set user volatile environment variables */
    SetUserEnvironment(Environment,
                       hKeyUser,
                       L"Volatile Environment");
 
    RegCloseKey(hKeyUser);
 
    return TRUE;
}

Referenced by ExpandEnvironmentStringsForUserW(), InstallDevice(), RegenerateUserEnvironment(), ScmStartUserModeService(), StartTaskManager(), StartUserShell(), Test_ApphelpCheckRunApp(), test_create_env(), and wWinMain().

DestroyEnvironmentBlock()

BOOL WINAPI DestroyEnvironmentBlock

(

IN LPVOID

lpEnvironment

)

Definition at line 761 of file environment.c.

{
    DPRINT("DestroyEnvironmentBlock() called\n");
 
    if (lpEnvironment == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    RtlDestroyEnvironment(lpEnvironment);
 
    return TRUE;
}

Referenced by ExpandEnvironmentStringsForUserW(), InstallDevice(), RegenerateUserEnvironment(), ScmStartUserModeService(), StartTaskManager(), StartUserShell(), Test_ApphelpCheckRunApp(), Test_BasicCall(), test_create_env(), Test_PreviousEnvironmentReturned(), and wWinMain().

ExpandEnvironmentStringsForUserA()

BOOL WINAPI ExpandEnvironmentStringsForUserA	(	IN HANDLE	hToken,
		IN LPCSTR	lpSrc,
		OUT LPSTR	lpDest,
		IN DWORD	dwSize
	)

Definition at line 830 of file environment.c.

{
    BOOL Ret = FALSE;
    DWORD dwSrcLen;
    LPWSTR lpSrcW = NULL, lpDestW = NULL;
 
    if (lpSrc == NULL || lpDest == NULL || dwSize == 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    dwSrcLen = strlen(lpSrc);
    lpSrcW = (LPWSTR)GlobalAlloc(GMEM_FIXED,
                                 (dwSrcLen + 1) * sizeof(WCHAR));
    if (lpSrcW == NULL ||
        MultiByteToWideChar(CP_ACP,
                            0,
                            lpSrc,
                            -1,
                            lpSrcW,
                            dwSrcLen + 1) == 0)
    {
        goto Cleanup;
    }
 
    lpDestW = (LPWSTR)GlobalAlloc(GMEM_FIXED,
                                  dwSize * sizeof(WCHAR));
    if (lpDestW == NULL)
        goto Cleanup;
 
    Ret = ExpandEnvironmentStringsForUserW(hToken,
                                           lpSrcW,
                                           lpDestW,
                                           dwSize);
    if (Ret)
    {
        if (WideCharToMultiByte(CP_ACP,
                                0,
                                lpDestW,
                                -1,
                                lpDest,
                                dwSize,
                                NULL,
                                NULL) == 0)
        {
            Ret = FALSE;
        }
    }
 
Cleanup:
    if (lpSrcW != NULL)
        GlobalFree((HGLOBAL)lpSrcW);
 
    if (lpDestW != NULL)
        GlobalFree((HGLOBAL)lpDestW);
 
    return Ret;
}

Referenced by UnExpandEnvironmentStringForUserA().

ExpandEnvironmentStringsForUserW()

BOOL WINAPI ExpandEnvironmentStringsForUserW	(	IN HANDLE	hToken,
		IN LPCWSTR	lpSrc,
		OUT LPWSTR	lpDest,
		IN DWORD	dwSize
	)

Definition at line 779 of file environment.c.

{
    BOOL Ret = FALSE;
    PVOID lpEnvironment;
 
    if (lpSrc == NULL || lpDest == NULL || dwSize == 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (CreateEnvironmentBlock(&lpEnvironment,
                               hToken,
                               FALSE))
    {
        UNICODE_STRING SrcU, DestU;
        NTSTATUS Status;
 
        /* Initialize the strings */
        RtlInitUnicodeString(&SrcU, lpSrc);
        DestU.Length = 0;
        DestU.MaximumLength = dwSize * sizeof(WCHAR);
        DestU.Buffer = lpDest;
 
        /* Expand the strings */
        Status = RtlExpandEnvironmentStrings_U((PWSTR)lpEnvironment,
                                               &SrcU,
                                               &DestU,
                                               NULL);
 
        DestroyEnvironmentBlock(lpEnvironment);
 
        if (NT_SUCCESS(Status))
        {
            Ret = TRUE;
        }
        else
        {
            SetLastError(RtlNtStatusToDosError(Status));
        }
    }
 
    return Ret;
}

Referenced by ExpandEnvironmentStringsForUserA(), PlaySound_ExpandEnvironmentStrings(), and UnExpandEnvironmentStringForUserW().

GetCurrentUserKey()

static HKEY GetCurrentUserKey ( HANDLE  hToken )

static

Definition at line 157 of file environment.c.

{
    LONG Error;
    UNICODE_STRING SidString;
    HKEY hKey;
 
    if (!GetUserSidStringFromToken(hToken, &SidString))
    {
        DPRINT1("GetUserSidFromToken() failed\n");
        return NULL;
    }
 
    Error = RegOpenKeyExW(HKEY_USERS,
                          SidString.Buffer,
                          0,
                          MAXIMUM_ALLOWED,
                          &hKey);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("RegOpenKeyExW() failed (Error %ld)\n", Error);
        RtlFreeUnicodeString(&SidString);
        SetLastError((DWORD)Error);
        return NULL;
    }
 
    RtlFreeUnicodeString(&SidString);
 
    return hKey;
}

Referenced by CreateEnvironmentBlock().

GetUserAndDomainName()

static BOOL GetUserAndDomainName ( IN HANDLE  hToken, OUT LPWSTR *  UserName, OUT LPWSTR *  DomainName  )

static

Definition at line 190 of file environment.c.

{
    BOOL bRet = TRUE;
    PSID Sid = NULL;
    LPWSTR lpUserName = NULL;
    LPWSTR lpDomainName = NULL;
    DWORD cbUserName = 0;
    DWORD cbDomainName = 0;
    SID_NAME_USE SidNameUse;
 
    Sid = GetUserSid(hToken);
    if (Sid == NULL)
    {
        DPRINT1("GetUserSid() failed\n");
        return FALSE;
    }
 
    if (!LookupAccountSidW(NULL,
                           Sid,
                           NULL,
                           &cbUserName,
                           NULL,
                           &cbDomainName,
                           &SidNameUse))
    {
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        {
            bRet = FALSE;
            goto done;
        }
    }
 
    lpUserName = LocalAlloc(LPTR, cbUserName * sizeof(WCHAR));
    if (lpUserName == NULL)
    {
        bRet = FALSE;
        goto done;
    }
 
    lpDomainName = LocalAlloc(LPTR, cbDomainName * sizeof(WCHAR));
    if (lpDomainName == NULL)
    {
        bRet = FALSE;
        goto done;
    }
 
    if (!LookupAccountSidW(NULL,
                           Sid,
                           lpUserName,
                           &cbUserName,
                           lpDomainName,
                           &cbDomainName,
                           &SidNameUse))
    {
        bRet = FALSE;
        goto done;
    }
 
    *UserName = lpUserName;
    *DomainName = lpDomainName;
 
done:
    if (bRet == FALSE)
    {
        if (lpUserName != NULL)
            LocalFree(lpUserName);
 
        if (lpDomainName != NULL)
            LocalFree(lpDomainName);
    }
 
    LocalFree(Sid);
 
    return bRet;
}

Referenced by CreateEnvironmentBlock().

SetSystemEnvironment()

static BOOL SetSystemEnvironment ( PWSTR *  Environment )

static

Definition at line 394 of file environment.c.

{
    LONG Error;
    HKEY hEnvKey;
    DWORD dwValues;
    DWORD dwMaxValueNameLength;
    DWORD dwMaxValueDataLength;
    DWORD dwValueNameLength;
    DWORD dwValueDataLength;
    DWORD dwType;
    DWORD i;
    LPWSTR lpValueName;
    LPWSTR lpValueData;
 
    Error = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                          L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment",
                          0,
                          KEY_QUERY_VALUE,
                          &hEnvKey);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("RegOpenKeyExW() failed (Error %ld)\n", Error);
        return FALSE;
    }
 
    Error = RegQueryInfoKey(hEnvKey,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            &dwValues,
                            &dwMaxValueNameLength,
                            &dwMaxValueDataLength,
                            NULL,
                            NULL);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("RegQueryInforKey() failed (Error %ld)\n", Error);
        RegCloseKey(hEnvKey);
        return FALSE;
    }
 
    if (dwValues == 0)
    {
        RegCloseKey(hEnvKey);
        return TRUE;
    }
 
    /* Allocate buffers */
    dwMaxValueNameLength++;
    lpValueName = LocalAlloc(LPTR, dwMaxValueNameLength * sizeof(WCHAR));
    if (lpValueName == NULL)
    {
        RegCloseKey(hEnvKey);
        return FALSE;
    }
 
    lpValueData = LocalAlloc(LPTR, dwMaxValueDataLength);
    if (lpValueData == NULL)
    {
        LocalFree(lpValueName);
        RegCloseKey(hEnvKey);
        return FALSE;
    }
 
    /* Enumerate values */
    for (i = 0; i < dwValues; i++)
    {
        dwValueNameLength = dwMaxValueNameLength;
        dwValueDataLength = dwMaxValueDataLength;
 
        Error = RegEnumValueW(hEnvKey,
                              i,
                              lpValueName,
                              &dwValueNameLength,
                              NULL,
                              &dwType,
                              (LPBYTE)lpValueData,
                              &dwValueDataLength);
        if (Error == ERROR_SUCCESS)
        {
            /* Set environment variable */
            SetUserEnvironmentVariable(Environment,
                                       lpValueName,
                                       lpValueData,
                                       (dwType == REG_EXPAND_SZ));
        }
        else
        {
            LocalFree(lpValueData);
            LocalFree(lpValueName);
            RegCloseKey(hEnvKey);
 
            return FALSE;
        }
    }
 
    LocalFree(lpValueData);
    LocalFree(lpValueName);
    RegCloseKey(hEnvKey);
 
    return TRUE;
}

Referenced by CreateEnvironmentBlock().

SetUserEnvironment()

static BOOL SetUserEnvironment ( PWSTR *  Environment, HKEY  hKey, LPWSTR  lpSubKeyName  )

static

Definition at line 271 of file environment.c.

{
    LONG Error;
    HKEY hEnvKey;
    DWORD dwValues;
    DWORD dwMaxValueNameLength;
    DWORD dwMaxValueDataLength;
    DWORD dwValueNameLength;
    DWORD dwValueDataLength;
    DWORD dwType;
    DWORD i;
    LPWSTR lpValueName;
    LPWSTR lpValueData;
 
    Error = RegOpenKeyExW(hKey,
                          lpSubKeyName,
                          0,
                          KEY_QUERY_VALUE,
                          &hEnvKey);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("RegOpenKeyExW() failed (Error %ld)\n", Error);
        SetLastError((DWORD)Error);
        return FALSE;
    }
 
    Error = RegQueryInfoKey(hEnvKey,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            &dwValues,
                            &dwMaxValueNameLength,
                            &dwMaxValueDataLength,
                            NULL,
                            NULL);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("RegQueryInforKey() failed (Error %ld)\n", Error);
        RegCloseKey(hEnvKey);
        SetLastError((DWORD)Error);
        return FALSE;
    }
 
    if (dwValues == 0)
    {
        RegCloseKey(hEnvKey);
        return TRUE;
    }
 
    /* Allocate buffers */
    dwMaxValueNameLength++;
    lpValueName = LocalAlloc(LPTR, dwMaxValueNameLength * sizeof(WCHAR));
    if (lpValueName == NULL)
    {
        RegCloseKey(hEnvKey);
        return FALSE;
    }
 
    lpValueData = LocalAlloc(LPTR, dwMaxValueDataLength);
    if (lpValueData == NULL)
    {
        LocalFree(lpValueName);
        RegCloseKey(hEnvKey);
        return FALSE;
    }
 
    /* Enumerate values */
    for (i = 0; i < dwValues; i++)
    {
        dwValueNameLength = dwMaxValueNameLength;
        dwValueDataLength = dwMaxValueDataLength;
 
        Error = RegEnumValueW(hEnvKey,
                              i,
                              lpValueName,
                              &dwValueNameLength,
                              NULL,
                              &dwType,
                              (LPBYTE)lpValueData,
                              &dwValueDataLength);
        if (Error == ERROR_SUCCESS)
        {
            if (!_wcsicmp(lpValueName, L"PATH"))
            {
                /* Append 'Path' environment variable */
                AppendUserEnvironmentVariable(Environment,
                                              lpValueName,
                                              lpValueData);
            }
            else
            {
                /* Set environment variable */
                SetUserEnvironmentVariable(Environment,
                                           lpValueName,
                                           lpValueData,
                                           (dwType == REG_EXPAND_SZ));
            }
        }
        else
        {
            LocalFree(lpValueData);
            LocalFree(lpValueName);
            RegCloseKey(hEnvKey);
 
            return FALSE;
        }
    }
 
    LocalFree(lpValueData);
    LocalFree(lpValueName);
    RegCloseKey(hEnvKey);
 
    return TRUE;
}

Referenced by CreateEnvironmentBlock().

SetUserEnvironmentVariable()

static BOOL SetUserEnvironmentVariable ( PWSTR *  Environment, LPWSTR  lpName, LPWSTR  lpValue, BOOL  bExpand  )

static

Definition at line 34 of file environment.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name;
    UNICODE_STRING SrcValue, DstValue;
    ULONG Length;
    PVOID Buffer = NULL;
    WCHAR ShortName[MAX_PATH];
 
    if (bExpand)
    {
        RtlInitUnicodeString(&SrcValue, lpValue);
 
        Length = 2 * MAX_PATH * sizeof(WCHAR);
 
        DstValue.Length = 0;
        DstValue.MaximumLength = Length;
        DstValue.Buffer = Buffer = LocalAlloc(LPTR, Length);
        if (DstValue.Buffer == NULL)
        {
            DPRINT1("LocalAlloc() failed\n");
            return FALSE;
        }
 
        Status = RtlExpandEnvironmentStrings_U(*Environment,
                                               &SrcValue,
                                               &DstValue,
                                               &Length);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("RtlExpandEnvironmentStrings_U() failed (Status %lx)\n", Status);
            DPRINT1("Length %lu\n", Length);
 
            if (Buffer)
                LocalFree(Buffer);
 
            return FALSE;
        }
    }
    else
    {
        RtlInitUnicodeString(&DstValue, lpValue);
    }
 
    if (!_wcsicmp(lpName, L"TEMP") || !_wcsicmp(lpName, L"TMP"))
    {
        if (GetShortPathNameW(DstValue.Buffer, ShortName, ARRAYSIZE(ShortName)))
        {
            RtlInitUnicodeString(&DstValue, ShortName);
        }
        else
        {
            DPRINT("GetShortPathNameW() failed for %S (Error %lu)\n", DstValue.Buffer, GetLastError());
        }
    }
 
    RtlInitUnicodeString(&Name, lpName);
 
    DPRINT("Value: %wZ\n", &DstValue);
 
    Status = RtlSetEnvironmentVariable(Environment,
                                       &Name,
                                       &DstValue);
 
    if (Buffer)
        LocalFree(Buffer);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlSetEnvironmentVariable() failed (Status %lx)\n", Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CreateEnvironmentBlock(), SetSystemEnvironment(), and SetUserEnvironment().