//************************************************************* // File name: envvar.c // // Description: Contains the environment variable functions // // // Microsoft Confidential // Copyright (c) Microsoft Corporation 1996 // All rights reserved // //************************************************************* #include "uenv.h" // // Max environment variable length // #define MAX_VALUE_LEN 1024 // // Environment variables // #define COMPUTERNAME_VARIABLE TEXT("COMPUTERNAME") #define HOMEDRIVE_VARIABLE TEXT("HOMEDRIVE") #define HOMESHARE_VARIABLE TEXT("HOMESHARE") #define HOMEPATH_VARIABLE TEXT("HOMEPATH") #define SYSTEMDRIVE_VARIABLE TEXT("SystemDrive") #define SYSTEMROOT_VARIABLE TEXT("SystemRoot") #define USERNAME_VARIABLE TEXT("USERNAME") #define USERDOMAIN_VARIABLE TEXT("USERDOMAIN") #define USERDNSDOMAIN_VARIABLE TEXT("USERDNSDOMAIN") #define USERPROFILE_VARIABLE TEXT("USERPROFILE") #define ALLUSERSPROFILE_VARIABLE TEXT("ALLUSERSPROFILE") #define PATH_VARIABLE TEXT("Path") #define LIBPATH_VARIABLE TEXT("LibPath") #define OS2LIBPATH_VARIABLE TEXT("Os2LibPath") #define PROGRAMFILES_VARIABLE TEXT("ProgramFiles") #define COMMONPROGRAMFILES_VARIABLE TEXT("CommonProgramFiles") #if defined(WX86) || defined(_WIN64) #define PROGRAMFILESX86_VARIABLE TEXT("ProgramFiles(x86)") #define COMMONPROGRAMFILESX86_VARIABLE TEXT("CommonProgramFiles(x86)") #endif #define USER_ENV_SUBKEY TEXT("Environment") #define USER_VOLATILE_ENV_SUBKEY TEXT("Volatile Environment") // // Parsing information for autoexec.bat // #define AUTOEXECPATH_VARIABLE TEXT("AutoexecPath") #define PARSE_AUTOEXEC_KEY TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon") #define PARSE_AUTOEXEC_ENTRY TEXT("ParseAutoexec") #define PARSE_AUTOEXEC_DEFAULT TEXT("1") #define MAX_PARSE_AUTOEXEC_BUFFER 2 #define SYS_ENVVARS TEXT("System\\CurrentControlSet\\Control\\Session Manager\\Environment") BOOL UpdateSystemEnvironment(PVOID *pEnv); BOOL GetUserNameAndDomain(HANDLE hToken, LPTSTR *UserName, LPTSTR *UserDomain); BOOL GetUserNameAndDomainSlowly(HANDLE hToken, LPTSTR *UserName, LPTSTR *UserDomain); LPTSTR GetUserDNSDomainName(LPTSTR lpDomain, HANDLE hUserToken); LONG GetHKeyCU(HANDLE hToken, HKEY *hKeyCU); BOOL ProcessAutoexec(PVOID *pEnv); BOOL AppendNTPathWithAutoexecPath(PVOID *pEnv, LPTSTR lpPathVariable, LPTSTR lpAutoexecPath); BOOL SetEnvironmentVariables(PVOID *pEnv, LPTSTR lpRegSubKey, HKEY hKeyCU); #ifdef _X86_ BOOL IsPathIncludeRemovable(LPTSTR lpValue); #endif //************************************************************* // // CreateEnvironmentBlock() // // Purpose: Creates the environment variables for the // specificed hToken. If hToken is NULL, the // environment block will only contain system // variables. // // Parameters: pEnv - Receives the environment block // hToken - User's token or NULL // bInherit - Inherit the current process environment // // Return: TRUE if successful // FALSE if not // // Comments: The pEnv value must be destroyed by // calling DestroyEnvironmentBlock // // History: Date Author Comment // 6/19/96 ericflo Created // //************************************************************* BOOL WINAPI CreateEnvironmentBlock (LPVOID *pEnv, HANDLE hToken, BOOL bInherit) { LPTSTR szBuffer = NULL; LPTSTR szValue = NULL; LPTSTR szExpValue = NULL; DWORD dwBufferSize = MAX_PATH+1; NTSTATUS Status; LPTSTR UserName = NULL; LPTSTR UserDomain = NULL; LPTSTR UserDNSDomain = NULL; HKEY hKey, hKeyCU; DWORD dwDisp, dwType, dwSize; TCHAR szParseAutoexec[MAX_PARSE_AUTOEXEC_BUFFER]; LONG dwError; BOOL bRetVal = FALSE; // // Arg check // if (!pEnv) { SetLastError (ERROR_INVALID_PARAMETER); goto Exit; } Status = RtlCreateEnvironment((BOOLEAN)bInherit, pEnv); if (!NT_SUCCESS(Status)) { goto Exit; } // // Allocate memory for Local variables to avoid stack overflow // szBuffer = (LPTSTR)LocalAlloc(LPTR, (MAX_PATH+1)*sizeof(TCHAR)); if (!szBuffer) { DebugMsg((DM_WARNING, TEXT("CreateEnvironmentBlock: Out of memory"))); goto Exit; } szValue = (LPTSTR)LocalAlloc(LPTR, (MAX_VALUE_LEN+1)*sizeof(TCHAR)); if (!szValue) { DebugMsg((DM_WARNING, TEXT("CreateEnvironmentBlock: Out of memory"))); goto Exit; } szExpValue = (LPTSTR)LocalAlloc(LPTR, (MAX_VALUE_LEN+1)*sizeof(TCHAR)); if (!szExpValue) { DebugMsg((DM_WARNING, TEXT("CreateEnvironmentBlock: Out of memory"))); goto Exit; } // // First start by getting the systemroot and systemdrive values and // setting it in the new environment. // if ( GetEnvironmentVariable(SYSTEMROOT_VARIABLE, szBuffer, dwBufferSize) ) { SetEnvironmentVariableInBlock(pEnv, SYSTEMROOT_VARIABLE, szBuffer, TRUE); } if ( GetEnvironmentVariable(SYSTEMDRIVE_VARIABLE, szBuffer, dwBufferSize) ) { SetEnvironmentVariableInBlock(pEnv, SYSTEMDRIVE_VARIABLE, szBuffer, TRUE); } // // Set the all users profile location. // dwBufferSize = MAX_PATH+1; if (GetAllUsersProfileDirectory(szBuffer, &dwBufferSize)) { SetEnvironmentVariableInBlock(pEnv, ALLUSERSPROFILE_VARIABLE, szBuffer, TRUE); } // // We must examine the registry directly to pull out // the system environment variables, because they // may have changed since the system was booted. // if (!UpdateSystemEnvironment(pEnv)) { RtlDestroyEnvironment(*pEnv); goto Exit; } // // Set the computername // dwBufferSize = MAX_PATH+1; if (GetComputerName (szBuffer, &dwBufferSize)) { SetEnvironmentVariableInBlock(pEnv, COMPUTERNAME_VARIABLE, szBuffer, TRUE); } // // Set the default user profile location // dwBufferSize = MAX_PATH+1; if (GetDefaultUserProfileDirectory(szBuffer, &dwBufferSize)) { SetEnvironmentVariableInBlock(pEnv, USERPROFILE_VARIABLE, szBuffer, TRUE); } // // Set the Program Files environment variable // if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion"), 0, KEY_READ, &hKey) == ERROR_SUCCESS) { dwSize = (MAX_VALUE_LEN+1)*sizeof(TCHAR); if (RegQueryValueEx (hKey, TEXT("ProgramFilesDir"), NULL, &dwType, (LPBYTE) szValue, &dwSize) == ERROR_SUCCESS) { ExpandEnvironmentStrings (szValue, szExpValue, (MAX_VALUE_LEN+1)); SetEnvironmentVariableInBlock(pEnv, PROGRAMFILES_VARIABLE, szExpValue, TRUE); } dwSize = (MAX_VALUE_LEN+1)*sizeof(TCHAR); if (RegQueryValueEx (hKey, TEXT("CommonFilesDir"), NULL, &dwType, (LPBYTE) szValue, &dwSize) == ERROR_SUCCESS) { ExpandEnvironmentStrings (szValue, szExpValue, (MAX_VALUE_LEN+1)); SetEnvironmentVariableInBlock(pEnv, COMMONPROGRAMFILES_VARIABLE, szExpValue, TRUE); } #if defined(WX86) || defined(_WIN64) dwSize = (MAX_VALUE_LEN+1)*sizeof(TCHAR); if (RegQueryValueEx (hKey, TEXT("ProgramFilesDir (x86)"), NULL, &dwType, (LPBYTE) szValue, &dwSize) == ERROR_SUCCESS) { ExpandEnvironmentStrings (szValue, szExpValue, (MAX_VALUE_LEN+1)); SetEnvironmentVariableInBlock(pEnv, PROGRAMFILESX86_VARIABLE, szExpValue, TRUE); } dwSize = (MAX_VALUE_LEN+1)*sizeof(TCHAR); if (RegQueryValueEx (hKey, TEXT("CommonFilesDir (x86)"), NULL, &dwType, (LPBYTE) szValue, &dwSize) == ERROR_SUCCESS) { ExpandEnvironmentStrings (szValue, szExpValue, (MAX_VALUE_LEN+1)); SetEnvironmentVariableInBlock(pEnv, COMMONPROGRAMFILESX86_VARIABLE, szExpValue, TRUE); } #endif RegCloseKey (hKey); } // // If hToken is NULL, we can exit now since the caller only wants // system environment variables. // if (!hToken) { bRetVal = TRUE; goto Exit; } // // Open the HKEY_CURRENT_USER for this token. // dwError = GetHKeyCU(hToken, &hKeyCU); // // if the hive is not found assume that the caller just needs the system attribute. // if ((!hKeyCU) && (dwError == ERROR_FILE_NOT_FOUND)) { bRetVal = TRUE; goto Exit; } if (!hKeyCU) { RtlDestroyEnvironment(*pEnv); DebugMsg((DM_WARNING, TEXT("CreateEnvironmentBlock: Failed to open HKEY_CURRENT_USER, error = %d"), dwError)); goto Exit; } // // Set the user's name and domain. // if (!GetUserNameAndDomain(hToken, &UserName, &UserDomain)) { GetUserNameAndDomainSlowly(hToken, &UserName, &UserDomain); } UserDNSDomain = GetUserDNSDomainName(UserDomain, hToken); SetEnvironmentVariableInBlock( pEnv, USERNAME_VARIABLE, UserName, TRUE); SetEnvironmentVariableInBlock( pEnv, USERDOMAIN_VARIABLE, UserDomain, TRUE); SetEnvironmentVariableInBlock( pEnv, USERDNSDOMAIN_VARIABLE, UserDNSDomain, TRUE); LocalFree(UserName); LocalFree(UserDomain); LocalFree(UserDNSDomain); // // Set the user's profile location. // dwBufferSize = MAX_PATH+1; if (GetUserProfileDirectory(hToken, szBuffer, &dwBufferSize)) { SetEnvironmentVariableInBlock(pEnv, USERPROFILE_VARIABLE, szBuffer, TRUE); } // // Process autoexec.bat // lstrcpy (szParseAutoexec, PARSE_AUTOEXEC_DEFAULT); if (RegCreateKeyEx (hKeyCU, PARSE_AUTOEXEC_KEY, 0, 0, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey, &dwDisp) == ERROR_SUCCESS) { // // Query the current value. If it doesn't exist, then add // the entry for next time. // dwBufferSize = sizeof (TCHAR) * MAX_PARSE_AUTOEXEC_BUFFER; if (RegQueryValueEx (hKey, PARSE_AUTOEXEC_ENTRY, NULL, &dwType, (LPBYTE) szParseAutoexec, &dwBufferSize) != ERROR_SUCCESS) { // // Set the default value // RegSetValueEx (hKey, PARSE_AUTOEXEC_ENTRY, 0, REG_SZ, (LPBYTE) szParseAutoexec, sizeof (TCHAR) * lstrlen (szParseAutoexec) + 1); } // // Close key // RegCloseKey (hKey); } // // Process autoexec if appropriate // if (szParseAutoexec[0] == TEXT('1')) { ProcessAutoexec(pEnv); } // // Set User environment variables. // SetEnvironmentVariables(pEnv, USER_ENV_SUBKEY, hKeyCU); // // Set User volatile environment variables. // SetEnvironmentVariables(pEnv, USER_VOLATILE_ENV_SUBKEY, hKeyCU); // // Merge the paths // AppendNTPathWithAutoexecPath(pEnv, PATH_VARIABLE, AUTOEXECPATH_VARIABLE); RegCloseKey (hKeyCU); bRetVal = TRUE; Exit: if (szBuffer) { LocalFree(szBuffer); } if (szValue) { LocalFree(szValue); } if (szExpValue) { LocalFree(szExpValue); } return bRetVal; } //************************************************************* // // DestroyEnvironmentBlock() // // Purpose: Frees the environment block created by // CreateEnvironmentBlock // // Parameters: lpEnvironment - Pointer to variables // // Return: TRUE if successful // FALSE if an error occurs // // Comments: // // History: Date Author Comment // 6/19/96 ericflo Created // //************************************************************* BOOL WINAPI DestroyEnvironmentBlock (LPVOID lpEnvironment) { if (!lpEnvironment) { SetLastError (ERROR_INVALID_PARAMETER); return FALSE; } RtlDestroyEnvironment(lpEnvironment); return TRUE; } //************************************************************* // // UpdateSystemEnvironment() // // Purpose: Reads the system environment variables from the // registry. // // Parameters: pEnv - Environment block pointer // // Return: TRUE if successful // FALSE if an error occurs // // Comments: // // History: Date Author Comment // 6/21/96 ericflo Ported // //************************************************************* BOOL UpdateSystemEnvironment(PVOID *pEnv) { HKEY KeyHandle; DWORD Result; DWORD ValueNameLength; DWORD Type; DWORD DataLength; DWORD cValues; /* address of buffer for number of value identifiers */ DWORD chMaxValueName; /* address of buffer for longest value name length */ DWORD cbMaxValueData; /* address of buffer for longest value data length */ DWORD junk; FILETIME FileTime; PTCHAR ValueName; PTCHAR ValueData; DWORD i; BOOL Bool; PTCHAR ExpandedValue; BOOL rc = TRUE; DWORD ClassStringSize = MAX_PATH + 1; TCHAR Class[MAX_PATH + 1]; Result = RegOpenKeyEx ( HKEY_LOCAL_MACHINE, SYS_ENVVARS, 0, KEY_QUERY_VALUE, &KeyHandle ); if ( Result != ERROR_SUCCESS ) { DebugMsg((DM_WARNING, TEXT("UpdateSystemEnvironment: RegOpenKeyEx failed, error = %d"),Result)); return( TRUE ); } Result = RegQueryInfoKey( KeyHandle, Class, /* address of buffer for class string */ &ClassStringSize, /* address of size of class string buffer */ NULL, /* reserved */ &junk, /* address of buffer for number of subkeys */ &junk, /* address of buffer for longest subkey */ &junk, /* address of buffer for longest class string length */ &cValues, /* address of buffer for number of value identifiers */ &chMaxValueName, /* address of buffer for longest value name length */ &cbMaxValueData, /* address of buffer for longest value data length */ &junk, /* address of buffer for descriptor length */ &FileTime /* address of buffer for last write time */ ); if ( Result != NO_ERROR && Result != ERROR_MORE_DATA ) { DebugMsg((DM_WARNING, TEXT("UpdateSystemEnvironment: RegQueryInfoKey failed, error = %d"),Result)); RegCloseKey(KeyHandle); return( TRUE ); } // // No need to adjust the datalength for TCHAR issues // ValueData = LocalAlloc(LPTR, cbMaxValueData); if ( ValueData == NULL ) { RegCloseKey(KeyHandle); return( FALSE ); } // // The maximum value name length comes back in characters, convert to bytes // before allocating storage. Allow for trailing NULL also. // ValueName = LocalAlloc(LPTR, (++chMaxValueName) * sizeof( TCHAR ) ); if ( ValueName == NULL ) { RegCloseKey(KeyHandle); LocalFree( ValueData ); return( FALSE ); } // // To exit from here on, set rc and jump to Cleanup // for (i=0; i= (MAX_VALUE_LEN * sizeof(TCHAR))) { ValueData[MAX_VALUE_LEN-1] = TEXT('\0'); } switch ( Type ) { case REG_SZ: { Bool = SetEnvironmentVariableInBlock( pEnv, ValueName, ValueData, TRUE ); if ( !Bool ) { DebugMsg((DM_WARNING, TEXT("UpdateSystemEnvironment: Failed to set environment variable <%s> to <%s> with %d."), ValueName, ValueData, GetLastError())); } break; } default: { continue; } } } // // To exit from here on, set rc and jump to Cleanup // for (i=0; i= (MAX_VALUE_LEN * sizeof(TCHAR))) { ValueData[MAX_VALUE_LEN-1] = TEXT('\0'); } switch ( Type ) { case REG_EXPAND_SZ: { ExpandedValue = AllocAndExpandEnvironmentStrings( ValueData ); Bool = SetEnvironmentVariableInBlock( pEnv, ValueName, ExpandedValue, TRUE ); LocalFree( ExpandedValue ); if ( !Bool ) { DebugMsg((DM_WARNING, TEXT("UpdateSystemEnvironment: Failed to set environment variable <%s> to <%s> with %d."), ValueName, ValueData, GetLastError())); } break; } default: { continue; } } } Cleanup: RegCloseKey(KeyHandle); LocalFree( ValueName ); LocalFree( ValueData ); return( rc ); } //************************************************************* // // GetUserNameAndDomain() // // Purpose: Gets the user's name and domain // // Parameters: hToken - User's token // UserName - Receives pointer to user's name // UserDomain - Receives pointer to user's domain // // Return: TRUE if successful // FALSE if an error occurs // // Comments: // // History: Date Author Comment // 6/21/96 ericflo Ported // //************************************************************* BOOL GetUserNameAndDomain(HANDLE hToken, LPTSTR *UserName, LPTSTR *UserDomain) { BOOL bResult = FALSE; LPTSTR lpTemp, lpDomain = NULL; LPTSTR lpUserName, lpUserDomain; HANDLE hOldToken; // // Impersonate the user // if (!ImpersonateUser(hToken, &hOldToken)) { DebugMsg((DM_VERBOSE, TEXT("GetUserNameAndDomain Failed to impersonate user"))); goto Exit; } // // Get the username in NT4 format // lpDomain = MyGetUserNameEx (NameSamCompatible); RevertToUser(&hOldToken); if (!lpDomain) { DebugMsg((DM_WARNING, TEXT("GetUserNameAndDomain: MyGetUserNameEx failed for NT4 style name with %d"), GetLastError())); goto Exit; } // // Look for the \ between the domain and username and replace // it with a NULL // lpTemp = lpDomain; while (*lpTemp && ((*lpTemp) != TEXT('\\'))) lpTemp++; if (*lpTemp != TEXT('\\')) { DebugMsg((DM_WARNING, TEXT("GetUserNameAndDomain Failed to find slash in NT4 style name: <%s>"), lpDomain)); goto Exit; } *lpTemp = TEXT('\0'); lpTemp++; // // Allocate space for the results // lpUserName = LocalAlloc (LPTR, (lstrlen(lpTemp) + 1) * sizeof(TCHAR)); if (!lpUserName) { DebugMsg((DM_WARNING, TEXT("GetUserNameAndDomain Failed to allocate memory with %d"), GetLastError())); goto Exit; } lstrcpy (lpUserName, lpTemp); lpUserDomain = LocalAlloc (LPTR, (lstrlen(lpDomain) + 1) * sizeof(TCHAR)); if (!lpUserDomain) { DebugMsg((DM_WARNING, TEXT("GetUserNameAndDomain Failed to allocate memory with %d"), GetLastError())); LocalFree (lpUserName); goto Exit; } lstrcpy (lpUserDomain, lpDomain); // // Save the results in the outbound arguments // *UserName = lpUserName; *UserDomain = lpUserDomain; // // Success // bResult = TRUE; Exit: if (lpDomain) { LocalFree (lpDomain); } return(bResult); } //************************************************************* // // GetUserNameAndDomainSlowly() // // Purpose: Gets the user's name and domain from a DC // // Parameters: hToken - User's token // UserName - Receives pointer to user's name // UserDomain - Receives pointer to user's domain // // Return: TRUE if successful // FALSE if an error occurs // // Comments: // // History: Date Author Comment // 6/21/96 ericflo Ported // //************************************************************* BOOL GetUserNameAndDomainSlowly(HANDLE hToken, LPTSTR *UserName, LPTSTR *UserDomain) { LPTSTR lpUserName = NULL; LPTSTR lpUserDomain = NULL; DWORD cbAccountName = 0; DWORD cbUserDomain = 0; SID_NAME_USE SidNameUse; BOOL bRet = FALSE; PSID pSid; // // Get the user's sid // pSid = GetUserSid (hToken); if (!pSid) { return FALSE; } // // Get the space needed for the User name and the Domain name // if (!LookupAccountSid(NULL, pSid, NULL, &cbAccountName, NULL, &cbUserDomain, &SidNameUse ) ) { if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) { goto Error; } } lpUserName = (LPTSTR)LocalAlloc(LPTR, cbAccountName*sizeof(TCHAR)); if (!lpUserName) { goto Error; } lpUserDomain = (LPTSTR)LocalAlloc(LPTR, cbUserDomain*sizeof(WCHAR)); if (!lpUserDomain) { LocalFree(lpUserName); goto Error; } // // Now get the user name and domain name // if (!LookupAccountSid(NULL, pSid, lpUserName, &cbAccountName, lpUserDomain, &cbUserDomain, &SidNameUse ) ) { LocalFree(lpUserName); LocalFree(lpUserDomain); goto Error; } *UserName = lpUserName; *UserDomain = lpUserDomain; bRet = TRUE; Error: DeleteUserSid (pSid); return(bRet); } //************************************************************* // // GetUserDNSDomainName() // // Purpose: Gets the DNS domain name for the user // // Parameters: lpDomain - User's flat domain name // hUserToken - User's token // // // Return: DNS domain name if successful // NULL if an error occurs // //************************************************************* LPTSTR GetUserDNSDomainName(LPTSTR lpDomain, HANDLE hUserToken) { LPTSTR lpDnsDomain = NULL, lpTemp = NULL; DWORD dwBufferSize; TCHAR szBuffer[MAX_PATH]; INT iRole; HANDLE hOldToken; BOOL bResult = FALSE; // // Check if this machine is running standalone, if so, there won't be // a DNS domain name // if (!GetMachineRole (&iRole)) { DebugMsg((DM_WARNING, TEXT("GetUserDNSDomainName: Failed to get the role of the computer."))); return NULL; } if (iRole == 0) { DebugMsg((DM_VERBOSE, TEXT("GetUserDNSDomainName: Computer is running standalone. No DNS domain name available."))); return NULL; } // // Get the computer name to see if the user logged on locally // dwBufferSize = ARRAYSIZE(szBuffer); if (GetComputerName (szBuffer, &dwBufferSize)) { if (!lstrcmpi(lpDomain, szBuffer)) { DebugMsg((DM_VERBOSE, TEXT("GetUserDNSDomainName: Local user account. No DNS domain name available."))); return NULL; } } if (LoadString (g_hDllInstance, IDS_NT_AUTHORITY, szBuffer, ARRAYSIZE(szBuffer))) { if (!lstrcmpi(lpDomain, szBuffer)) { DebugMsg((DM_VERBOSE, TEXT("GetUserDNSDomainName: Domain name is NT Authority. No DNS domain name available."))); return NULL; } } if (LoadString (g_hDllInstance, IDS_BUILTIN, szBuffer, ARRAYSIZE(szBuffer))) { if (!lstrcmpi(lpDomain, szBuffer)) { DebugMsg((DM_VERBOSE, TEXT("GetUserDNSDomainName: Domain name is BuiltIn. No DNS domain name available."))); return NULL; } } // // Impersonate the user // if (!ImpersonateUser(hUserToken, &hOldToken)) { DebugMsg((DM_VERBOSE, TEXT("GetUserDNSDomainName: Failed to impersonate user"))); goto Exit; } // // Get the username in DnsDomainName format // lpDnsDomain = MyGetUserNameEx (NameDnsDomain); RevertToUser(&hOldToken); if (!lpDnsDomain) { DebugMsg((DM_WARNING, TEXT("GetUserDNSDomainName: MyGetUserNameEx failed for NameDnsDomain style name with %d"), GetLastError())); goto Exit; } // // Look for the \ between the domain and username and replace // it with a NULL // lpTemp = lpDnsDomain; while (*lpTemp && (*lpTemp != TEXT('\\'))) lpTemp++; if (*lpTemp != TEXT('\\')) { DebugMsg((DM_WARNING, TEXT("GetUserDNSDomainName: Failed to find slash in NameDnsDomain style name: <%s>"), lpDnsDomain)); goto Exit; } *lpTemp = TEXT('\0'); bResult = TRUE; Exit: if (!bResult && lpDnsDomain) { LocalFree(lpDnsDomain); lpDnsDomain = NULL; } return lpDnsDomain; } //************************************************************* // // GetHKeyCU() // // Purpose: Get HKEY_CURRENT_USER for the given hToken // // Parameters: hToken - token handle // // Return: hKey if successful // NULL if an error occurs // // Comments: // // History: Date Author Comment // 6/21/96 ericflo Created // //************************************************************* LONG GetHKeyCU(HANDLE hToken, HKEY *hKeyCU) { LPTSTR lpSidString; LONG dwError; *hKeyCU = NULL; lpSidString = GetSidString (hToken); if (!lpSidString) { return GetLastError(); } dwError = RegOpenKeyEx (HKEY_USERS, lpSidString, 0, KEY_READ, hKeyCU); if (!(*hKeyCU)) DebugMsg((DM_VERBOSE, TEXT("GetHkeyCU: RegOpenKey failed with error %d"), dwError)); DeleteSidString(lpSidString); return dwError; } /***************************************************************************\ * ProcessAutoexecPath * * Creates AutoexecPath environment variable using autoexec.bat * LpValue may be freed by this routine. * * History: * 06-02-92 Johannec Created. * \***************************************************************************/ LPTSTR ProcessAutoexecPath(PVOID pEnv, LPTSTR lpValue, DWORD cb) { LPTSTR lpt; LPTSTR lpStart; LPTSTR lpPath; DWORD cbt; UNICODE_STRING Name; UNICODE_STRING Value; BOOL bPrevAutoexecPath; WCHAR ch; DWORD dwTemp, dwCount = 0; cbt = 1024; lpt = (LPTSTR)LocalAlloc(LPTR, cbt*sizeof(WCHAR)); if (!lpt) { return(lpValue); } *lpt = 0; lpStart = lpValue; RtlInitUnicodeString(&Name, AUTOEXECPATH_VARIABLE); Value.Buffer = (PWCHAR)LocalAlloc(LPTR, cbt*sizeof(WCHAR)); if (!Value.Buffer) { goto Fail; } while (NULL != (lpPath = wcsstr (lpValue, TEXT("%")))) { if (!_wcsnicmp(lpPath+1, TEXT("PATH%"), 5)) { // // check if we have an autoexecpath already set, if not just remove // the %path% // Value.Length = (USHORT)cbt; Value.MaximumLength = (USHORT)cbt; bPrevAutoexecPath = (BOOL)!RtlQueryEnvironmentVariable_U(pEnv, &Name, &Value); *lpPath = 0; dwTemp = dwCount + lstrlen (lpValue); if (dwTemp < cbt) { lstrcat(lpt, lpValue); dwCount = dwTemp; } if (bPrevAutoexecPath) { dwTemp = dwCount + lstrlen (Value.Buffer); if (dwTemp < cbt) { lstrcat(lpt, Value.Buffer); dwCount = dwTemp; } } *lpPath++ = TEXT('%'); lpPath += 5; // go passed %path% lpValue = lpPath; } else { lpPath = wcsstr(lpPath+1, TEXT("%")); if (!lpPath) { lpStart = NULL; goto Fail; } lpPath++; ch = *lpPath; *lpPath = 0; dwTemp = dwCount + lstrlen (lpValue); if (dwTemp < cbt) { lstrcat(lpt, lpValue); dwCount = dwTemp; } *lpPath = ch; lpValue = lpPath; } } if (*lpValue) { dwTemp = dwCount + lstrlen (lpValue); if (dwTemp < cbt) { lstrcat(lpt, lpValue); dwCount = dwTemp; } } LocalFree(Value.Buffer); LocalFree(lpStart); return(lpt); Fail: LocalFree(lpt); return(lpStart); } /***************************************************************************\ * ProcessCommand * * History: * 01-24-92 Johannec Created. * \***************************************************************************/ BOOL ProcessCommand(LPSTR lpStart, PVOID *pEnv) { LPTSTR lpt, lptt; LPTSTR lpVariable; LPTSTR lpValue; LPTSTR lpExpandedValue = NULL; WCHAR c; DWORD cb, cbNeeded; LPTSTR lpu; // // convert to Unicode // lpu = (LPTSTR)LocalAlloc(LPTR, (cb=lstrlenA(lpStart)+1)*sizeof(WCHAR)); if (!lpu) { return FALSE; } MultiByteToWideChar(CP_OEMCP, 0, lpStart, -1, lpu, cb); // // Find environment variable. // for (lpt = lpu; *lpt && *lpt == TEXT(' '); lpt++) //skip spaces ; if (!*lpt) { LocalFree (lpu); return(FALSE); } lptt = lpt; for (; *lpt && *lpt != TEXT(' ') && *lpt != TEXT('='); lpt++) //find end of variable name ; c = *lpt; *lpt = 0; lpVariable = (LPTSTR)LocalAlloc(LPTR, (lstrlen(lptt) + 1)*sizeof(WCHAR)); if (!lpVariable) { LocalFree (lpu); return(FALSE); } lstrcpy(lpVariable, lptt); *lpt = c; // // Find environment variable value. // for (; *lpt && (*lpt == TEXT(' ') || *lpt == TEXT('=')); lpt++) ; if (!*lpt) { // if we have a blank path statement in the autoexec file, // then we don't want to pass "PATH" as the environment // variable because it trashes the system's PATH. Instead // we want to change the variable AutoexecPath. This would have // be handled below if a value had been assigned to the // environment variable. if (lstrcmpi(lpVariable, PATH_VARIABLE) == 0) { SetEnvironmentVariableInBlock(pEnv, AUTOEXECPATH_VARIABLE, TEXT(""), TRUE); } else { SetEnvironmentVariableInBlock(pEnv, lpVariable, TEXT(""), TRUE); } LocalFree (lpVariable); LocalFree (lpu); return(FALSE); } lptt = lpt; for (; *lpt; lpt++) //find end of varaible value ; c = *lpt; *lpt = 0; lpValue = (LPTSTR)LocalAlloc(LPTR, (lstrlen(lptt) + 1)*sizeof(WCHAR)); if (!lpValue) { LocalFree (lpu); LocalFree(lpVariable); return(FALSE); } lstrcpy(lpValue, lptt); *lpt = c; #ifdef _X86_ // NEC98 // // If the path includes removable drive, // it is assumed that the drive assignment has changed from DOS. // if (IsNEC_98 && (lstrcmpi(lpVariable, PATH_VARIABLE) == 0) && IsPathIncludeRemovable(lpValue)) { LocalFree (lpu); LocalFree(lpVariable); LocalFree(lpValue); return(FALSE); } #endif cb = 1024; lpExpandedValue = (LPTSTR)LocalAlloc(LPTR, cb*sizeof(WCHAR)); if (lpExpandedValue) { if (!lstrcmpi(lpVariable, PATH_VARIABLE)) { lpValue = ProcessAutoexecPath(*pEnv, lpValue, (lstrlen(lpValue)+1)*sizeof(WCHAR)); } cbNeeded = ExpandUserEnvironmentStrings(*pEnv, lpValue, lpExpandedValue, cb); if (cbNeeded > cb) { LocalFree(lpExpandedValue); cb = cbNeeded; lpExpandedValue = (LPTSTR)LocalAlloc(LPTR, cb*sizeof(WCHAR)); if (lpExpandedValue) { ExpandUserEnvironmentStrings(*pEnv, lpValue, lpExpandedValue, cb); } } } if (!lpExpandedValue) { lpExpandedValue = lpValue; } if (lstrcmpi(lpVariable, PATH_VARIABLE)) { SetEnvironmentVariableInBlock(pEnv, lpVariable, lpExpandedValue, FALSE); } else { SetEnvironmentVariableInBlock(pEnv, AUTOEXECPATH_VARIABLE, lpExpandedValue, TRUE); } if (lpExpandedValue != lpValue) { LocalFree(lpExpandedValue); } LocalFree(lpVariable); LocalFree(lpValue); LocalFree (lpu); return(TRUE); } /***************************************************************************\ * ProcessSetCommand * * History: * 01-24-92 Johannec Created. * \***************************************************************************/ BOOL ProcessSetCommand(LPSTR lpStart, PVOID *pEnv) { LPSTR lpt; // // Find environment variable. // for (lpt = lpStart; *lpt && *lpt != TEXT(' '); lpt++) ; if (!*lpt) return(FALSE); return (ProcessCommand(lpt, pEnv)); } /***************************************************************************\ * ProcessAutoexec * * History: * 01-24-92 Johannec Created. * \***************************************************************************/ BOOL ProcessAutoexec( PVOID *pEnv ) { HANDLE fh = NULL; DWORD dwFileSize; DWORD dwBytesRead; CHAR *lpBuffer = NULL; CHAR *token; CHAR Seps[] = "&\n\r"; // Seperators for tokenizing autoexec.bat BOOL Status = FALSE; TCHAR szAutoExecBat [] = TEXT("c:\\autoexec.bat"); #ifdef _X86_ TCHAR szTemp[3]; #endif UINT uiErrMode; // There is a case where the OS might not be booting from drive // C, so we can not assume that the autoexec.bat file is on c:\. // Set the error mode so the user doesn't see the critical error // popup and attempt to open the file on c:\. uiErrMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX); #ifdef _X86_ if (IsNEC_98) { if (GetEnvironmentVariable (TEXT("SystemDrive"), szTemp, 3)) { szAutoExecBat[0] = szTemp[0]; } } #endif // if autoexec.bat is encrypted then ignore it as it creates cyclic-dependency // and don't allow any user to logon if (GetFileAttributes(szAutoExecBat) & FILE_ATTRIBUTE_ENCRYPTED) { goto Exit; } fh = CreateFile (szAutoExecBat, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); SetErrorMode (uiErrMode); if (fh == INVALID_HANDLE_VALUE) { return(FALSE); //could not open autoexec.bat file, we're done. } dwFileSize = GetFileSize(fh, NULL); if (dwFileSize == -1) { goto Exit; // can't read the file size } lpBuffer = (PCHAR)LocalAlloc(LPTR, dwFileSize+1); if (!lpBuffer) { goto Exit; } Status = ReadFile(fh, lpBuffer, dwFileSize, &dwBytesRead, NULL); if (!Status) { goto Exit; // error reading file } // // Zero terminate the buffer so we don't walk off the end // ASSERT(dwBytesRead <= dwFileSize); lpBuffer[dwBytesRead] = 0; // // Search for SET and PATH commands // token = strtok(lpBuffer, Seps); while (token != NULL) { for (;*token && *token == ' ';token++) //skip spaces ; if (*token == TEXT('@')) token++; for (;*token && *token == ' ';token++) //skip spaces ; if (!_strnicmp(token, "Path", 4)) { ProcessCommand(token, pEnv); } if (!_strnicmp(token, "SET", 3)) { ProcessSetCommand(token, pEnv); } token = strtok(NULL, Seps); } Exit: if (fh) { CloseHandle(fh); } if (lpBuffer) { LocalFree(lpBuffer); } if (!Status) { DebugMsg((DM_WARNING, TEXT("ProcessAutoexec: Cannot process autoexec.bat."))); } return(Status); } /***************************************************************************\ * BuildEnvironmentPath * * * History: * 2-28-92 Johannec Created * \***************************************************************************/ BOOL BuildEnvironmentPath(PVOID *pEnv, LPTSTR lpPathVariable, LPTSTR lpPathValue) { NTSTATUS Status; UNICODE_STRING Name; UNICODE_STRING Value; WCHAR lpTemp[1025]; DWORD cb; if (!*pEnv) { return(FALSE); } RtlInitUnicodeString(&Name, lpPathVariable); cb = 1024; Value.Buffer = (PWCHAR)LocalAlloc(LPTR, cb*sizeof(WCHAR)); if (!Value.Buffer) { return(FALSE); } Value.Length = (USHORT)(sizeof(WCHAR) * cb); Value.MaximumLength = (USHORT)(sizeof(WCHAR) * cb); Status = RtlQueryEnvironmentVariable_U(*pEnv, &Name, &Value); if (!NT_SUCCESS(Status)) { LocalFree(Value.Buffer); Value.Length = 0; *lpTemp = 0; } if (Value.Length) { lstrcpy(lpTemp, Value.Buffer); if ( *( lpTemp + lstrlen(lpTemp) - 1) != TEXT(';') ) { lstrcat(lpTemp, TEXT(";")); } LocalFree(Value.Buffer); } if (lpPathValue && ((lstrlen(lpTemp) + lstrlen(lpPathValue) + 1) < (INT)cb)) { lstrcat(lpTemp, lpPathValue); RtlInitUnicodeString(&Value, lpTemp); Status = RtlSetEnvironmentVariable(pEnv, &Name, &Value); } if (NT_SUCCESS(Status)) { return(TRUE); } return(FALSE); } /***************************************************************************\ * AppendNTPathWithAutoexecPath * * Gets the AutoexecPath created in ProcessAutoexec, and appends it to * the NT path. * * History: * 05-28-92 Johannec Created. * \***************************************************************************/ BOOL AppendNTPathWithAutoexecPath( PVOID *pEnv, LPTSTR lpPathVariable, LPTSTR lpAutoexecPath ) { NTSTATUS Status; UNICODE_STRING Name; UNICODE_STRING Value; WCHAR AutoexecPathValue[1024]; DWORD cb; BOOL Success; if (!*pEnv) { return(FALSE); } RtlInitUnicodeString(&Name, lpAutoexecPath); cb = 1024; Value.Buffer = (PWCHAR)LocalAlloc(LPTR, cb*sizeof(WCHAR)); if (!Value.Buffer) { return(FALSE); } Value.Length = (USHORT)cb; Value.MaximumLength = (USHORT)cb; Status = RtlQueryEnvironmentVariable_U(*pEnv, &Name, &Value); if (!NT_SUCCESS(Status)) { LocalFree(Value.Buffer); return(FALSE); } if (Value.Length) { lstrcpy(AutoexecPathValue, Value.Buffer); } LocalFree(Value.Buffer); Success = BuildEnvironmentPath(pEnv, lpPathVariable, AutoexecPathValue); RtlSetEnvironmentVariable( pEnv, &Name, NULL); return(Success); } /***************************************************************************\ * SetEnvironmentVariables * * Reads the user-defined environment variables from the user registry * and adds them to the environment block at pEnv. * * History: * 2-28-92 Johannec Created * \***************************************************************************/ BOOL SetEnvironmentVariables( PVOID *pEnv, LPTSTR lpRegSubKey, HKEY hKeyCU ) { WCHAR lpValueName[MAX_PATH]; LPBYTE lpDataBuffer; DWORD cbDataBuffer; LPBYTE lpData; LPTSTR lpExpandedValue = NULL; DWORD cbValueName = MAX_PATH; DWORD cbData; DWORD dwType; DWORD dwIndex = 0; HKEY hkey; BOOL bResult; if (RegOpenKeyExW(hKeyCU, lpRegSubKey, 0, KEY_READ, &hkey)) { return(FALSE); } cbDataBuffer = 4096; lpDataBuffer = (LPBYTE)LocalAlloc(LPTR, cbDataBuffer*sizeof(WCHAR)); if (lpDataBuffer == NULL) { RegCloseKey(hkey); return(FALSE); } lpData = lpDataBuffer; cbData = cbDataBuffer; bResult = TRUE; while (!RegEnumValue(hkey, dwIndex, lpValueName, &cbValueName, 0, &dwType, lpData, &cbData)) { if (cbValueName) { // // Limit environment variable length // lpData[MAX_VALUE_LEN-1] = TEXT('\0'); if (dwType == REG_SZ) { // // The path variables PATH, LIBPATH and OS2LIBPATH must have // their values apppended to the system path. // if ( !lstrcmpi(lpValueName, PATH_VARIABLE) || !lstrcmpi(lpValueName, LIBPATH_VARIABLE) || !lstrcmpi(lpValueName, OS2LIBPATH_VARIABLE) ) { BuildEnvironmentPath(pEnv, lpValueName, (LPTSTR)lpData); } else { // // the other environment variables are just set. // SetEnvironmentVariableInBlock(pEnv, lpValueName, (LPTSTR)lpData, TRUE); } } } dwIndex++; cbData = cbDataBuffer; cbValueName = MAX_PATH; } dwIndex = 0; cbData = cbDataBuffer; cbValueName = MAX_PATH; while (!RegEnumValue(hkey, dwIndex, lpValueName, &cbValueName, 0, &dwType, lpData, &cbData)) { if (cbValueName) { // // Limit environment variable length // lpData[MAX_VALUE_LEN-1] = TEXT('\0'); if (dwType == REG_EXPAND_SZ) { DWORD cb, cbNeeded; cb = 1024; lpExpandedValue = (LPTSTR)LocalAlloc(LPTR, cb*sizeof(WCHAR)); if (lpExpandedValue) { cbNeeded = ExpandUserEnvironmentStrings(*pEnv, (LPTSTR)lpData, lpExpandedValue, cb); if (cbNeeded > cb) { LocalFree(lpExpandedValue); cb = cbNeeded; lpExpandedValue = (LPTSTR)LocalAlloc(LPTR, cb*sizeof(WCHAR)); if (lpExpandedValue) { ExpandUserEnvironmentStrings(*pEnv, (LPTSTR)lpData, lpExpandedValue, cb); } } } if (lpExpandedValue == NULL) { bResult = FALSE; break; } // // The path variables PATH, LIBPATH and OS2LIBPATH must have // their values apppended to the system path. // if ( !lstrcmpi(lpValueName, PATH_VARIABLE) || !lstrcmpi(lpValueName, LIBPATH_VARIABLE) || !lstrcmpi(lpValueName, OS2LIBPATH_VARIABLE) ) { BuildEnvironmentPath(pEnv, lpValueName, (LPTSTR)lpExpandedValue); } else { // // the other environment variables are just set. // SetEnvironmentVariableInBlock(pEnv, lpValueName, (LPTSTR)lpExpandedValue, TRUE); } LocalFree(lpExpandedValue); } } dwIndex++; cbData = cbDataBuffer; cbValueName = MAX_PATH; } LocalFree(lpDataBuffer); RegCloseKey(hkey); return(bResult); } //************************************************************* // // ExpandEnvironmentStringsForUser() // // Purpose: Expands the source string using the environment block for the // specified user. If hToken is null, the system environment block // will be used (no user environment variables). // // Parameters: hToken - User's token (or null for system env vars) // lpSrc - String to be expanded // lpDest - Buffer to receive string // dwSize - Size of dest buffer // // Return: TRUE if successful // FALSE if an error occurs // //************************************************************* BOOL WINAPI ExpandEnvironmentStringsForUser(HANDLE hToken, LPCTSTR lpSrc, LPTSTR lpDest, DWORD dwSize) { LPVOID pEnv; DWORD dwNeeded; BOOL bResult = FALSE; // // Arg check // if ( !lpDest || !lpSrc ) { SetLastError (ERROR_INVALID_PARAMETER); return FALSE; } // // Get the user's environment block // if (!CreateEnvironmentBlock (&pEnv, hToken, FALSE)) { DebugMsg((DM_WARNING, TEXT("ExpandEnvironmentStringsForUser: CreateEnvironmentBlock failed with = %d"), GetLastError())); return FALSE; } // // Expand the string // dwNeeded = ExpandUserEnvironmentStrings(pEnv, lpSrc, lpDest, dwSize); if (dwNeeded && (dwNeeded < dwSize)) { bResult = TRUE; } else { SetLastError(ERROR_INSUFFICIENT_BUFFER ); } // // Free the environment block // DestroyEnvironmentBlock (pEnv); return bResult; } //************************************************************* // // GetSystemTempDirectory() // // Purpose: Gets the system temp directory in short form // // Parameters: lpDir - Receives the directory // lpcchSize - Size of the lpDir buffer // // // Return: TRUE if successful // FALSE if an error occurs // //************************************************************* BOOL WINAPI GetSystemTempDirectory(LPTSTR lpDir, LPDWORD lpcchSize) { TCHAR szTemp[MAX_PATH]; TCHAR szDirectory[MAX_PATH]; DWORD dwLength; HKEY hKey; LONG lResult; DWORD dwSize, dwType; BOOL bRetVal = FALSE; WIN32_FILE_ATTRIBUTE_DATA fad; szTemp[0] = TEXT('\0'); szDirectory[0] = TEXT('\0'); // // Look in the system environment variables // if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, SYS_ENVVARS, 0, KEY_READ, &hKey) == ERROR_SUCCESS) { // // Check for TEMP // dwSize = sizeof(szTemp); if (RegQueryValueEx (hKey, TEXT("TEMP"), NULL, &dwType, (LPBYTE) szTemp, &dwSize) == ERROR_SUCCESS) { RegCloseKey (hKey); goto FoundTemp; } // // Check for TMP // dwSize = sizeof(szTemp); if (RegQueryValueEx (hKey, TEXT("TMP"), NULL, &dwType, (LPBYTE) szTemp, &dwSize) == ERROR_SUCCESS) { RegCloseKey (hKey); goto FoundTemp; } RegCloseKey (hKey); } // // Check if %SystemRoot%\Temp exists // lstrcpy (szDirectory, TEXT("%SystemRoot%\\Temp")); ExpandEnvironmentStrings (szDirectory, szTemp, ARRAYSIZE (szTemp)); if (GetFileAttributesEx (szTemp, GetFileExInfoStandard, &fad) && fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { goto FoundTemp; } // // Check if %SystemDrive%\Temp exists // lstrcpy (szDirectory, TEXT("%SystemDrive%\\Temp")); ExpandEnvironmentStrings (szDirectory, szTemp, ARRAYSIZE (szTemp)); if (GetFileAttributesEx (szTemp, GetFileExInfoStandard, &fad) && fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { goto FoundTemp; } // // Last resort is %SystemRoot% // lstrcpy (szTemp, TEXT("%SystemRoot%")); FoundTemp: ExpandEnvironmentStrings (szTemp, szDirectory, ARRAYSIZE (szDirectory)); GetShortPathName (szDirectory, szTemp, ARRAYSIZE(szTemp)); dwLength = lstrlen(szTemp) + 1; if (lpDir) { if (*lpcchSize >= dwLength) { lstrcpy (lpDir, szTemp); bRetVal = TRUE; } else { SetLastError(ERROR_INSUFFICIENT_BUFFER); } } else { SetLastError(ERROR_INSUFFICIENT_BUFFER); } *lpcchSize = dwLength; return bRetVal; } #ifdef _X86_ BOOL IsPathIncludeRemovable(LPTSTR lpValue) { LPTSTR lpt, tmp; BOOL ret = FALSE; WCHAR c; tmp = LocalAlloc(LPTR, (lstrlen(lpValue) + 1) * sizeof(WCHAR)); if (!tmp) { DebugMsg((DM_WARNING, TEXT("IsPathIncludeRemovable : Failed to LocalAlloc (%d)"), GetLastError())); } else { lstrcpy(tmp, lpValue); lpt = tmp; while (*lpt) { // skip spaces for ( ; *lpt && *lpt == TEXT(' '); lpt++) ; // check if the drive is removable if (lpt[0] && lpt[1] && lpt[1] == TEXT(':') && lpt[2]) { // ex) "A:\" c = lpt[3]; lpt[3] = 0; if (GetDriveType(lpt) == DRIVE_REMOVABLE) { lpt[3] = c; ret = TRUE; break; } lpt[3] = c; } // skip to the next path for ( ; *lpt && *lpt != TEXT(';'); lpt++) ; if (*lpt) lpt++; } LocalFree(tmp); } return(ret); } #endif