/****************************************************************************** * * Copyright (c) 2000 Microsoft Corporation * * Module Name: * utils.cpp * * Abstract: * Definitions of commonly used util functions. * * Revision History: * Brijesh Krishnaswami (brijeshk) 03/17/2000 * created * *****************************************************************************/ #include #include #include #include #include #include "srdefs.h" #include "utils.h" #include #include #include #include #include #include #include #include #include "srapi.h" #ifdef THIS_FILE #undef THIS_FILE #endif static char __szTraceSourceFile[] = __FILE__; #define THIS_FILE __szTraceSourceFile #define WBEM_DIRECTORY L"wbem" #define FRAMEDYN_DLL L"framedyn.dll" // forward declaration for Delnode_Recurse BOOL SRGetAltFileName( LPCWSTR cszPath, LPWSTR szAltName ); #define TRACEID 1893 // this function converts an ANSI string to UNICODE. // this also allocates the memory for the new string WCHAR * ConvertToUnicode(CHAR * pszString) { WCHAR * pwszUnicodeString = NULL; DWORD dwBytesNeeded = 0; TENTER("ConvertToUnicode"); dwBytesNeeded = (lstrlenA(pszString) + 1) * sizeof(WCHAR); pwszUnicodeString = (PWCHAR) SRMemAlloc(dwBytesNeeded); if(NULL == pwszUnicodeString) { TRACE(0, "Not enough memory"); goto cleanup; } // Convert filename to Unicode if (!MultiByteToWideChar(CP_ACP, // code page 0, // no options pszString, // ANSI string -1, // NULL terminated string pwszUnicodeString, // output buffer dwBytesNeeded/sizeof(WCHAR))) // size in wide chars { DWORD dwReturnCode; dwReturnCode=GetLastError(); TRACE(0, "Failed to do conversion ec=%d", dwReturnCode); SRMemFree(pwszUnicodeString); goto cleanup; } cleanup: TLEAVE(); return pwszUnicodeString; } // this function converts a UNICODE string to ANSI. // this also allocates the memory for the new string CHAR * ConvertToANSI(WCHAR * pwszString) { CHAR * pszANSIString = NULL; DWORD dwBytesNeeded = lstrlenW(pwszString) + sizeof(char); TENTER("ConvertToANSI"); // note that the string may already be NULL terminated - however // we cannot assume this and will still allocate space to put a // NULL character in the end. pszANSIString = (PCHAR) SRMemAlloc(dwBytesNeeded); if(NULL == pszANSIString) { TRACE(0, "Not enough memory"); goto cleanup; } // Convert filename to Unicode if (!WideCharToMultiByte(CP_ACP, // code page 0, // no options pwszString, // Wide char string dwBytesNeeded, // no of wchars pszANSIString, // output buffer dwBytesNeeded, // size of buffer NULL, // address of default for unmappable // characters NULL)) // address of flag set when default // char. used { DWORD dwReturnCode; dwReturnCode=GetLastError(); TRACE(0, "Failed to do conversion ec=%d", dwReturnCode); SRMemFree(pszANSIString); //this sets pwszUnicodeString to NULL goto cleanup; } // set last char to NULL pszANSIString[dwBytesNeeded-1] = '\0'; cleanup: TraceFunctLeave(); return pszANSIString; } ///////////////////////////////////////////////////////////////////////////// // // TakeOwnership // ///////////////////////////////////////////////////////////////////////////// DWORD TakeOwnership( LPCWSTR cszPath, BOOL fAllowDelete ) { TraceFunctEnter("TakeOwnership"); DWORD dwRet = ERROR_SUCCESS; LPCWSTR cszErr; HANDLE hTokenProcess = NULL; TOKEN_USER *pUser = NULL; PSECURITY_DESCRIPTOR pSD = NULL; PACL pACL = NULL; EXPLICIT_ACCESS ea; DWORD dwSize; if (!::OpenProcessToken(::GetCurrentProcess(), TOKEN_QUERY, &hTokenProcess)) { dwRet = ::GetLastError(); cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::OpenProcessToken failed - %ls", cszErr); goto Exit; } if (!::GetTokenInformation( hTokenProcess, TokenUser, NULL, 0, &dwSize )) { dwRet = ::GetLastError(); if ( dwRet != ERROR_INSUFFICIENT_BUFFER ) { cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::GetTokenInformation(query) failed - %ls", cszErr); goto Exit; } else dwRet = ERROR_SUCCESS; } pUser = (TOKEN_USER*) new BYTE[dwSize]; if ( pUser == NULL ) { FatalTrace(0, "Insufficient memory..."); dwRet = ERROR_NOT_ENOUGH_MEMORY; goto Exit; } if (!::GetTokenInformation( hTokenProcess, TokenUser, pUser, dwSize, &dwSize )) { dwRet = ::GetLastError(); cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::GetTokenInformation(get) failed - %ls", cszErr); goto Exit; } dwRet = ::SetNamedSecurityInfo( (LPWSTR)cszPath, SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, pUser->User.Sid, NULL, NULL, NULL ); if ( dwRet != ERROR_SUCCESS ) { dwRet = ::GetLastError(); cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::SetNamedSecurityInfo failed - %ls", cszErr); goto Exit; } if (fAllowDelete) { pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH); if (pSD == NULL) { cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::LocalAlloc failed - %ls", cszErr); goto Exit; } InitializeSecurityDescriptor( pSD, SECURITY_DESCRIPTOR_REVISION ); ZeroMemory (&ea, sizeof(ea)); ea.grfAccessPermissions = DELETE; ea.grfAccessMode = SET_ACCESS; ea.grfInheritance= NO_INHERITANCE; ea.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE; ea.Trustee.TrusteeForm = TRUSTEE_IS_SID; ea.Trustee.TrusteeType = TRUSTEE_IS_USER; ea.Trustee.ptstrName = (LPTSTR) pUser->User.Sid; dwRet = SetEntriesInAcl(1, &ea, NULL, &pACL); if (ERROR_SUCCESS != dwRet) { dwRet = ::GetLastError(); cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::SetEntriesInAcl failed - %ls", cszErr); goto Exit; } if (FALSE == SetSecurityDescriptorDacl (pSD, TRUE, pACL, FALSE )) { dwRet = ::GetLastError(); cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::SetEntriesInAcl failed - %ls", cszErr); goto Exit; } if (FALSE == SetFileSecurity (cszPath, DACL_SECURITY_INFORMATION, pSD)) { cszErr = ::GetSysErrStr(dwRet); ErrorTrace(0, "::SetEntriesInAcl failed - %ls", cszErr); goto Exit; } } Exit: if ( pUser != NULL ) delete [] (BYTE*)pUser; if ( hTokenProcess != NULL ) ::CloseHandle( hTokenProcess ); if (pACL != NULL) LocalFree (pACL); if (pSD != NULL) LocalFree (pSD); TraceFunctLeave(); return( dwRet ); } //+--------------------------------------------------------------------------- // // Function: CopyFile_Recurse // // Synopsis: attempt to copy disk space used by a file tree // // Arguments: [pwszSource] -- directory name // [pwszDest] -- destination directory name // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD CopyFile_Recurse (const WCHAR *pwszSource, const WCHAR *pwszDest) { DWORD dwErr = ERROR_SUCCESS; WIN32_FIND_DATA fd; HANDLE hFile; WCHAR wcsPath[MAX_PATH]; WCHAR wcsDest2[MAX_PATH]; lstrcpy (wcsPath, pwszSource); lstrcat (wcsPath, TEXT("\\*.*")); hFile = FindFirstFile(wcsPath, &fd); if (hFile == INVALID_HANDLE_VALUE) { dwErr = GetLastError(); return dwErr; } do { if (!lstrcmp(fd.cFileName, L".") || !lstrcmp(fd.cFileName, L"..")) { continue; } lstrcpy (wcsPath, pwszSource); // construct the full path name lstrcat (wcsPath, TEXT("\\")); lstrcat (wcsPath, fd.cFileName); lstrcpy (wcsDest2, pwszDest); // construct the full path name lstrcat (wcsDest2, TEXT("\\")); lstrcat (wcsDest2, fd.cFileName); if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (FALSE == CreateDirectoryW (wcsDest2, NULL)) { dwErr = GetLastError(); if (dwErr != ERROR_ALREADY_EXISTS) { FindClose (hFile); return dwErr; } else dwErr = ERROR_SUCCESS; } dwErr = CopyFile_Recurse (wcsPath, wcsDest2); if (dwErr != ERROR_SUCCESS) { FindClose (hFile); return dwErr; } } else { // // We found a file. Copy it. // if (FALSE == CopyFileW (wcsPath, wcsDest2, FALSE)) { dwErr = GetLastError(); FindClose (hFile); return dwErr; } } } while (FindNextFile(hFile, &fd)); // Find the next entry FindClose(hFile); // Close the search handle return ERROR_SUCCESS; } //+--------------------------------------------------------------------------- // // Function: GetFileSize_Recurse // // Synopsis: attempt to count disk space used by a file tree // // Arguments: [pwszDir] -- directory name // [pllTotalBytes] -- output counter // [pfStop] -- TRUE if stop signalled // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD GetFileSize_Recurse (const WCHAR *pwszDir, INT64 *pllTotalBytes, BOOL *pfStop) { DWORD dwErr = ERROR_SUCCESS; WIN32_FIND_DATA fd; HANDLE hFile; WCHAR wcsPath[MAX_PATH]; lstrcpy (wcsPath, pwszDir); lstrcat (wcsPath, TEXT("\\*.*")); hFile = FindFirstFile(wcsPath, &fd); if (hFile == INVALID_HANDLE_VALUE) { dwErr = GetLastError(); return dwErr; } do { if (pfStop != NULL && TRUE == *pfStop) { FindClose (hFile); return ERROR_OPERATION_ABORTED; } if (!lstrcmp(fd.cFileName, L".") || !lstrcmp(fd.cFileName, L"..")) { continue; } lstrcpy (wcsPath, pwszDir); // construct the full path name lstrcat (wcsPath, TEXT("\\")); lstrcat (wcsPath, fd.cFileName); if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // // Found a directory. Skip mount points // if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { continue; } dwErr = GetFileSize_Recurse(wcsPath, pllTotalBytes, pfStop); if (dwErr != ERROR_SUCCESS) { FindClose(hFile); return dwErr; } } else { // // We found a file. Update the counter // ULARGE_INTEGER ulTemp; ulTemp.LowPart = fd.nFileSizeLow; ulTemp.HighPart = fd.nFileSizeHigh; #if 0 ulTemp.LowPart = GetCompressedFileSize (wcsPath, &ulTemp.HighPart); dwErr = (ulTemp.LowPart == 0xFFFFFFFF) ? GetLastError() : ERROR_SUCCESS; if (dwErr != ERROR_SUCCESS) { FindClose (hFile); return dwErr; } #endif *pllTotalBytes += ulTemp.QuadPart; // The file size does not contain the size of the // NTFS alternate data streams } } while (FindNextFile(hFile, &fd)); // Find the next entry FindClose(hFile); // Close the search handle return ERROR_SUCCESS; } //+--------------------------------------------------------------------------- // // Function: CompressFile // // Synopsis: attempt to compress to decompress an NTFS file // // Arguments: [pwszPath] -- directory or file name // [fCompress] -- TRUE compress, FALSE decompress // [fDirectory] -- TRUE if directory, FALSE if file // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD CompressFile (const WCHAR *pwszPath, BOOL fCompress, BOOL fDirectory) { DWORD dwErr = ERROR_SUCCESS; DWORD dwReturned = 0; TENTER("CompressFile"); if (pwszPath == NULL) return ERROR_INVALID_PARAMETER; DWORD dwFileAttr = GetFileAttributes(pwszPath); if (dwFileAttr != 0xFFFFFFFF && (dwFileAttr & FILE_ATTRIBUTE_READONLY)) { dwFileAttr &= ~FILE_ATTRIBUTE_READONLY; if (FALSE == SetFileAttributes (pwszPath, dwFileAttr)) { TRACE(0, "SetFileAttributes ignoring %ld", GetLastError()); } else dwFileAttr |= FILE_ATTRIBUTE_READONLY; } USHORT usFormat = fCompress ? COMPRESSION_FORMAT_DEFAULT : COMPRESSION_FORMAT_NONE; HANDLE hFile = CreateFile( pwszPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, fDirectory ? FILE_FLAG_BACKUP_SEMANTICS : 0, NULL ); if (hFile == INVALID_HANDLE_VALUE) { dwErr = GetLastError(); TRACE(0, "CompressFile: cannot open %ld %ws", dwErr, pwszPath); return dwErr; } if (FALSE == DeviceIoControl (hFile, FSCTL_SET_COMPRESSION, &usFormat, sizeof(usFormat), NULL, 0, &dwReturned, NULL)) { dwErr = GetLastError(); TRACE(0, "CompressFile: cannot compress/uncompress %ld %ws", dwErr, pwszPath); } CloseHandle (hFile); if (dwFileAttr != 0xFFFFFFFF && (dwFileAttr & FILE_ATTRIBUTE_READONLY)) { if (FALSE == SetFileAttributes (pwszPath, dwFileAttr)) { TRACE(0, "SetFileAttributes failed ignoring %ld", GetLastError()); } } TLEAVE(); return dwErr; } // returns system drive - as L"C:\\" if C: is the system drive BOOL GetSystemDrive(LPWSTR pszDrive) { if (pszDrive) return ExpandEnvironmentStrings(L"%SystemDrive%\\", pszDrive, MAX_SYS_DRIVE); else return FALSE; } // BUGBUG - pszDrive should have driveletter in caps, // and needs to be of format L"C:\\" if C: is the system drive BOOL IsSystemDrive(LPWSTR pszDriveOrGuid) { WCHAR szSystemDrive[MAX_PATH]; WCHAR szSystemGuid[MAX_PATH]; if (pszDriveOrGuid) { if (0 == ExpandEnvironmentStrings(L"%SystemDrive%\\", szSystemDrive, sizeof(szSystemDrive)/sizeof(WCHAR))) { return FALSE; } if (0 == wcsncmp(pszDriveOrGuid, L"\\\\?\\Volume", 10)) // guid { if (! GetVolumeNameForVolumeMountPoint(szSystemDrive, szSystemGuid, MAX_PATH)) { return FALSE; } return lstrcmpi(pszDriveOrGuid, szSystemGuid) ? FALSE : TRUE; } else // drive { return lstrcmpi(pszDriveOrGuid, szSystemDrive) ? FALSE : TRUE; } } else { return FALSE; } } DWORD RegReadDWORD(HKEY hKey, LPCWSTR pszName, PDWORD pdwValue) { DWORD dwType = REG_DWORD; DWORD dwSize = sizeof(DWORD); DWORD dwRc = RegQueryValueEx(hKey, pszName, 0, &dwType, (LPBYTE) pdwValue, &dwSize); return dwRc; } DWORD RegWriteDWORD(HKEY hKey, LPCWSTR pszName, PDWORD pdwValue) { DWORD dwType = REG_DWORD; DWORD dwSize = sizeof(DWORD); DWORD dwRc = RegSetValueEx(hKey, pszName, 0, dwType, (LPBYTE) pdwValue, dwSize); return dwRc; } // function that returns n where pszStr is of form n ULONG GetID( LPCWSTR pszStr) { ULONG ulID = 0; while (*pszStr && (*pszStr < L'0' || *pszStr > L'9')) pszStr++; ulID = (ULONG) _wtol(pszStr); return ulID; } LPWSTR GetMachineGuid() { HKEY hKey = NULL; static WCHAR s_szGuid[GUID_STRLEN] = L""; static LPWSTR s_pszGuid = NULL; if (! s_pszGuid) // first time { ULONG ulType, ulSize = sizeof(s_szGuid); DWORD dwErr; dwErr = RegOpenKeyEx (HKEY_LOCAL_MACHINE, s_cszSRCfgRegKey, 0, KEY_READ, &hKey); if (dwErr != ERROR_SUCCESS) goto Err; dwErr = RegQueryValueEx (hKey, s_cszSRMachineGuid, 0, &ulType, (BYTE *) &s_szGuid, &ulSize); if (dwErr != ERROR_SUCCESS) goto Err; s_pszGuid = (LPWSTR) s_szGuid; } Err: if (hKey) RegCloseKey(hKey); return s_pszGuid; } // util function to construct _Restore.{MachineGuid}\\pszSuffix LPWSTR MakeRestorePath(LPWSTR pszDest, LPCWSTR pszDrive, LPCWSTR pszSuffix) { LPWSTR pszGuid = GetMachineGuid(); wsprintf(pszDest, L"%s%s\\%s", pszDrive, s_cszSysVolInfo, s_cszRestoreDir); if (pszGuid) { // lstrcat(pszDest, L"."); lstrcat(pszDest, pszGuid); } if (pszSuffix && lstrlen(pszSuffix) > 0) { lstrcat(pszDest, L"\\"); lstrcat(pszDest, pszSuffix); } return pszDest; } // set start type of specified service directly in the registry DWORD SetServiceStartupRegistry(LPCWSTR pszName, DWORD dwStartType) { DWORD dwRc; HKEY hKey = NULL; WCHAR szKey[MAX_PATH]; lstrcpy(szKey, L"System\\CurrentControlSet\\Services\\"); lstrcat(szKey, pszName); dwRc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, KEY_WRITE, NULL, &hKey); if (ERROR_SUCCESS != dwRc) goto done; dwRc = RegWriteDWORD(hKey, L"Start", &dwStartType); done: if (hKey) RegCloseKey(hKey); return dwRc; } // get start type of specified service directly from the registry DWORD GetServiceStartupRegistry(LPCWSTR pszName, PDWORD pdwStartType) { DWORD dwRc; HKEY hKey = NULL; WCHAR szKey[MAX_PATH]; lstrcpy(szKey, L"System\\CurrentControlSet\\Services\\"); lstrcat(szKey, pszName); dwRc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, KEY_QUERY_VALUE, NULL, &hKey); if (ERROR_SUCCESS != dwRc) goto done; dwRc = RegReadDWORD(hKey, L"Start", pdwStartType); done: if (hKey) RegCloseKey(hKey); return dwRc; } DWORD SetServiceStartup(LPCWSTR pszName, DWORD dwStartType) { TraceFunctEnter("SetServiceStartup"); DWORD dwError=ERROR_INTERNAL_ERROR; SC_HANDLE hService=NULL; SC_HANDLE hSCManager=NULL; hSCManager = OpenSCManager(NULL, // computer name - local machine NULL,//SCM DB name - SERVICES_ACTIVE_DATABASE SC_MANAGER_ALL_ACCESS); // access type if( NULL == hSCManager) { dwError = GetLastError(); // file not found DebugTrace(TRACEID,"OpenSCManager failed 0x%x", dwError); goto done; } hService = OpenService(hSCManager, // handle to SCM database pszName, // service name SERVICE_CHANGE_CONFIG); // access if( NULL == hService) { dwError = GetLastError(); // file not found DebugTrace(TRACEID,"OpenService failed 0x%x", dwError); goto done; } if (FALSE==ChangeServiceConfig( hService, // handle to service SERVICE_NO_CHANGE, // type of service dwStartType, // when to start service SERVICE_NO_CHANGE, // severity of start failure NULL, // service binary file name NULL, // load ordering group name NULL, // tag identifier NULL, // array of dependency names NULL, // account name NULL, // account password NULL)) // display name { dwError = GetLastError(); // file not found DebugTrace(TRACEID,"ChangeServiceConfig failed 0x%x", dwError); goto done; } dwError = ERROR_SUCCESS; done: if (NULL != hService) { _VERIFY(CloseServiceHandle(hService)); // handle to service or // SCM object } if (NULL != hSCManager) { _VERIFY(CloseServiceHandle(hSCManager)); // handle to service or // SCM object } if ((dwError != ERROR_SUCCESS) && (dwError != ERROR_ACCESS_DENIED)) { // service control methods failed. Just update the registry // directly dwError = SetServiceStartupRegistry(pszName, dwStartType); } TraceFunctLeave(); return dwError; } DWORD GetServiceStartup(LPCWSTR pszName, PDWORD pdwStartType) { TraceFunctEnter("SetServiceStartup"); DWORD dwError=ERROR_INTERNAL_ERROR; SC_HANDLE hService=NULL; SC_HANDLE hSCManager=NULL; QUERY_SERVICE_CONFIG *pconfig = NULL; DWORD cbBytes = 0, cbBytes2 = 0; hSCManager = OpenSCManager(NULL, // computer name - local machine NULL,//SCM DB name - SERVICES_ACTIVE_DATABASE SC_MANAGER_ALL_ACCESS); // access type if( NULL == hSCManager) { dwError = GetLastError(); // file not found DebugTrace(TRACEID,"OpenSCManager failed 0x%x", dwError); goto done; } hService = OpenService(hSCManager, // handle to SCM database pszName, // service name SERVICE_QUERY_CONFIG); // access if( NULL == hService) { dwError = GetLastError(); // file not found DebugTrace(TRACEID,"OpenService failed 0x%x", dwError); goto done; } if (FALSE==QueryServiceConfig( hService, // handle to service NULL, 0, &cbBytes )) { dwError = GetLastError(); if (ERROR_INSUFFICIENT_BUFFER == dwError) { pconfig = (QUERY_SERVICE_CONFIG *) SRMemAlloc(cbBytes); if (!pconfig) { trace(TRACEID, "! SRMemAlloc"); goto done; } if (FALSE==QueryServiceConfig( hService, // handle to service pconfig, cbBytes, &cbBytes2 )) { dwError = GetLastError(); DebugTrace(TRACEID,"! QueryServiceConfig (second) : %ld", dwError); goto done; } if (pdwStartType) { *pdwStartType = pconfig->dwStartType; } dwError = ERROR_SUCCESS; } else { trace(TRACEID, "! QueryServiceConfig (first) : %ld", dwError); } } done: SRMemFree(pconfig); if (NULL != hService) { _VERIFY(CloseServiceHandle(hService)); // handle to service or // SCM object } if (NULL != hSCManager) { _VERIFY(CloseServiceHandle(hSCManager)); // handle to service or // SCM object } TraceFunctLeave(); return dwError; } // this function returns whether the SR service is running BOOL IsSRServiceRunning() { TraceFunctEnter("IsSRServiceRunning"); BOOL fReturn; DWORD dwError=ERROR_INTERNAL_ERROR; SC_HANDLE hService=NULL; SC_HANDLE hSCManager=NULL; SERVICE_STATUS ServiceStatus; // assume FALSE by default fReturn = FALSE; hSCManager = OpenSCManager(NULL, // computer name - local machine NULL,//SCM DB name - SERVICES_ACTIVE_DATABASE SC_MANAGER_ALL_ACCESS); // access type if( NULL == hSCManager) { dwError = GetLastError(); DebugTrace(TRACEID,"OpenSCManager failed 0x%x", dwError); goto done; } hService = OpenService(hSCManager, // handle to SCM database s_cszServiceName, // service name SERVICE_QUERY_STATUS); // access if( NULL == hService) { dwError = GetLastError(); DebugTrace(TRACEID,"OpenService failed 0x%x", dwError); goto done; } if (FALSE == QueryServiceStatus(hService, // handle to service &ServiceStatus)) // service status { dwError = GetLastError(); DebugTrace(TRACEID,"QueryServiceStatus failed 0x%x", dwError); goto done; } if (ServiceStatus.dwCurrentState == SERVICE_RUNNING) { fReturn = TRUE; } else { DebugTrace(TRACEID,"SR Service is not running"); fReturn = FALSE; } done: if (NULL != hService) { _VERIFY(CloseServiceHandle(hService)); // handle to service or // SCM object } if (NULL != hSCManager) { _VERIFY(CloseServiceHandle(hSCManager)); // handle to service or // SCM object } TraceFunctLeave(); return fReturn; } // this function returns whether the SR service is running BOOL IsSRServiceStopped(SC_HANDLE hService) { TraceFunctEnter("IsSRServiceStopped"); SERVICE_STATUS ServiceStatus; BOOL fReturn; DWORD dwError; // assume FALSE by default fReturn = FALSE; if (FALSE == QueryServiceStatus(hService, // handle to service &ServiceStatus)) // service status { dwError = GetLastError(); DebugTrace(TRACEID,"QueryServiceStatus failed 0x%x", dwError); goto done; } if (ServiceStatus.dwCurrentState == SERVICE_STOPPED) { DebugTrace(TRACEID,"SR Service is not running"); fReturn = TRUE; } else { DebugTrace(TRACEID,"SR Service is running"); fReturn = FALSE; } done: TraceFunctLeave(); return fReturn; } // private function to stop the SR service // fWait - if TRUE : function is synchronous - waits till service is stopped completely // if FALSE : function is asynchronous - does not wait for service to complete stopping BOOL StopSRService(BOOL fWait) { TraceFunctEnter("StopSRService"); BOOL fReturn=FALSE; SC_HANDLE hSCManager; SERVICE_STATUS ServiceStatus; SC_HANDLE hService=NULL; DWORD dwError; hSCManager = OpenSCManager(NULL, // computer name - local machine NULL,//SCM DB name - SERVICES_ACTIVE_DATABASE SC_MANAGER_ALL_ACCESS); // access type if (NULL == hSCManager) { dwError = GetLastError(); DebugTrace(TRACEID,"OpenSCManager failed 0x%x", dwError); goto done; } hService = OpenService(hSCManager, // handle to SCM database s_cszServiceName, // service name SERVICE_ALL_ACCESS); // access if( NULL == hService) { dwError = GetLastError(); DebugTrace(TRACEID,"OpenService failed 0x%x", dwError); goto done; } fReturn = ControlService(hService, // handle to service SERVICE_CONTROL_STOP, // control code &ServiceStatus); // status information if (FALSE == fReturn) { dwError = GetLastError(); DebugTrace(TRACEID,"ControlService failed 0x%x", dwError); goto done; } if (fWait) { DWORD dwCount; // // query the service until it stops // try thrice // Sleep(500); for (dwCount=0; dwCount < 3; dwCount++) { if (TRUE == IsSRServiceStopped(hService)) { break; } Sleep(2000); } if (dwCount == 3) { fReturn=IsSRServiceStopped(hService); } else { fReturn=TRUE; } } done: if (NULL != hService) { _VERIFY(CloseServiceHandle(hService)); // handle to service or // SCM object } if (NULL != hSCManager) { _VERIFY(CloseServiceHandle(hSCManager)); // handle to service or // SCM object } TraceFunctLeave(); return fReturn; } //+--------------------------------------------------------------------------- // // Function: GetLsaSecret // // Synopsis: obtains the LSA secret info as Unicode strings // // Arguments: [hPolicy] -- LSA policy object handle // [wszSecret] -- secret name // [ppusSecretValue] -- dynamically allocated value // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD GetLsaSecret (LSA_HANDLE hPolicy, const WCHAR *wszSecret, UNICODE_STRING ** ppusSecretValue) { TENTER ("GetLsaSecret"); LSA_HANDLE hSecret; UNICODE_STRING usSecretName; DWORD dwErr = ERROR_SUCCESS; RtlInitUnicodeString (&usSecretName, wszSecret); if (LSA_SUCCESS (LsaOpenSecret (hPolicy, &usSecretName, SECRET_QUERY_VALUE, &hSecret))) { if (!LSA_SUCCESS (LsaQuerySecret (hSecret, ppusSecretValue, NULL, NULL, NULL))) { *ppusSecretValue = NULL; TRACE(0, "Cannot query secret %ws", wszSecret); } LsaClose (hSecret); } TLEAVE(); return dwErr; } //+--------------------------------------------------------------------------- // // Function: SetLsaSecret // // Synopsis: sets the LSA secret info // // Arguments: [hPolicy] -- LSA policy object handle // [wszSecret] -- secret name // [wszSecretValue] -- secret value // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD SetLsaSecret (PVOID hPolicy, const WCHAR *wszSecret, WCHAR * wszSecretValue) { TENTER ("SetLsaSecret"); LSA_HANDLE hSecret; UNICODE_STRING usSecretName; UNICODE_STRING usSecretValue; DWORD dwErr = ERROR_SUCCESS; hPolicy = (LSA_HANDLE) hPolicy; RtlInitUnicodeString (&usSecretName, wszSecret); RtlInitUnicodeString (&usSecretValue, wszSecretValue); if (LSA_SUCCESS (LsaOpenSecret (hPolicy, &usSecretName, SECRET_SET_VALUE, &hSecret))) { if (!LSA_SUCCESS (LsaSetSecret (hSecret, &usSecretValue, NULL))) { TRACE(0, "Cannot set secret %ws", wszSecret); } LsaClose (hSecret); } TLEAVE(); return dwErr; } //+--------------------------------------------------------------------------- // // Function: WriteNtUnicodeString // // Synopsis: writes a NT unicode string to disk // // Arguments: [hFile] -- file handle // [pus] -- NT unicode string // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD WriteNtUnicodeString (HANDLE hFile, UNICODE_STRING *pus) { DWORD dwErr = ERROR_SUCCESS; DWORD cb = 0; if (pus != NULL && FALSE == WriteFile (hFile, (BYTE *)pus->Buffer, pus->Length, &cb, NULL)) { dwErr = GetLastError(); } else if (FALSE == WriteFile (hFile, (BYTE *) L"", sizeof(WCHAR), &cb, NULL)) { dwErr = GetLastError(); } return dwErr; } //+--------------------------------------------------------------------------- // // Function: GetLsaRestoreState // // Synopsis: gets the LSA machine and autologon password // // Arguments: [hKeySoftware] -- Software registry key // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD GetLsaRestoreState (HKEY hKeySoftware) { TENTER ("GetLsaRestoreState"); HKEY hKey = NULL; LSA_OBJECT_ATTRIBUTES loa; LSA_HANDLE hLsa = NULL; DWORD dwErr = ERROR_SUCCESS; loa.Length = sizeof(LSA_OBJECT_ATTRIBUTES); loa.RootDirectory = NULL; loa.ObjectName = NULL; loa.Attributes = 0; loa.SecurityDescriptor = NULL; loa.SecurityQualityOfService = NULL; if (LSA_SUCCESS (LsaOpenPolicy(NULL, &loa, POLICY_VIEW_LOCAL_INFORMATION, &hLsa))) { UNICODE_STRING * pusSecret = NULL; dwErr = RegOpenKeyEx (hKeySoftware, hKeySoftware == HKEY_LOCAL_MACHINE ? s_cszSRRegKey : L"Microsoft\\Windows NT\\CurrentVersion\\SystemRestore", 0, KEY_READ | KEY_WRITE, &hKey); if (dwErr != ERROR_SUCCESS) goto Err; if (ERROR_SUCCESS==GetLsaSecret (hLsa, s_cszMachineSecret, &pusSecret)) { if (pusSecret != NULL && pusSecret->Length > 0) dwErr = RegSetValueEx (hKey, s_cszMachineSecret, 0, REG_BINARY, (BYTE *) pusSecret->Buffer, pusSecret->Length); LsaFreeMemory (pusSecret); pusSecret = NULL; } if (ERROR_SUCCESS==GetLsaSecret(hLsa, s_cszAutologonSecret, &pusSecret)) { if (pusSecret != NULL && pusSecret->Length > 0) dwErr = RegSetValueEx (hKey, s_cszAutologonSecret, 0, REG_BINARY, (BYTE *) pusSecret->Buffer, pusSecret->Length); LsaFreeMemory (pusSecret); pusSecret = NULL; } } Err: if (hLsa != NULL) LsaClose (hLsa); if (hKey != NULL) RegCloseKey (hKey); TLEAVE(); return dwErr; } //+--------------------------------------------------------------------------- // // Function: GetDomainMembershipInfo // // Synopsis: writes current domain and computer name into a file // // Arguments: [pwszPath] -- file name // [pwszzBuffer] -- output multistring buffer // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD GetDomainMembershipInfo (WCHAR *pwszPath, WCHAR *pwszzBuffer) { TENTER("GetDomainMembershipInfo"); POLICY_PRIMARY_DOMAIN_INFO* ppdi = NULL; LSA_OBJECT_ATTRIBUTES loa; LSA_HANDLE hLsa = NULL; HANDLE hFile = INVALID_HANDLE_VALUE; DWORD dwComputerLength = MAX_COMPUTERNAME_LENGTH + 1; DWORD dwRc = ERROR_SUCCESS; ULONG cbWritten; WCHAR wszComputer[MAX_COMPUTERNAME_LENGTH+1]; loa.Length = sizeof(LSA_OBJECT_ATTRIBUTES); loa.RootDirectory = NULL; loa.ObjectName = NULL; loa.Attributes = 0; loa.SecurityDescriptor = NULL; loa.SecurityQualityOfService = NULL; if (FALSE == GetComputerNameW (wszComputer, &dwComputerLength)) { dwRc = GetLastError(); trace(0, "! GetComputerNameW : %ld", dwRc); return dwRc; } if (LSA_SUCCESS (LsaOpenPolicy(NULL, &loa, POLICY_VIEW_LOCAL_INFORMATION, &hLsa))) { if (pwszPath != NULL) { hFile = CreateFileW ( pwszPath, // file name GENERIC_WRITE, // file access 0, // share mode NULL, // SD CREATE_ALWAYS, // how to create 0, // file attributes NULL); // handle to template file if (INVALID_HANDLE_VALUE == hFile) { dwRc = GetLastError(); trace(0, "! CreateFileW : %ld", dwRc); goto Err; } if (FALSE == WriteFile (hFile, (BYTE *) wszComputer, (dwComputerLength+1)*sizeof(WCHAR), &cbWritten, NULL)) { dwRc = GetLastError(); trace(0, "! WriteFile : %ld", dwRc); goto Err; } } if (pwszzBuffer != NULL) { lstrcpy (pwszzBuffer, wszComputer); pwszzBuffer += dwComputerLength + 1; } if (LSA_SUCCESS (LsaQueryInformationPolicy( hLsa, PolicyPrimaryDomainInformation, (VOID **) &ppdi ))) { const WCHAR *pwszFlag = (ppdi->Sid > 0) ? L"1" : L"0"; if (pwszPath != NULL) { dwRc = WriteNtUnicodeString (hFile, &ppdi->Name); if (dwRc != ERROR_SUCCESS) { trace(0, "! WriteNtUnicodeString : %ld", dwRc); } if (FALSE == WriteFile (hFile, (BYTE *) pwszFlag, (lstrlenW(pwszFlag)+1)*sizeof(WCHAR), &cbWritten, NULL)) { dwRc = GetLastError(); trace(0, "! WriteFile : %ld", dwRc); goto Err; } } if (pwszzBuffer != NULL) { ULONG ul = ppdi->Name.Length / sizeof(WCHAR); memcpy (pwszzBuffer, ppdi->Name.Buffer, ppdi->Name.Length); pwszzBuffer [ul] = L'\0'; lstrcpy (&pwszzBuffer[ul+1], pwszFlag); } } } Err: if (hLsa != NULL) LsaClose (hLsa); if (hFile != INVALID_HANDLE_VALUE) CloseHandle (hFile); TLEAVE(); return dwRc; } //++ // // Method: DoesFileExist // // Synopsis: Checks if a file by the specified exists // // Arguments:[pszFileName] File name // // Returns: TRUE if the specified string is a file // False otherwise // // History: AshishS Created 7/30/96 // //-- BOOL DoesFileExist(const TCHAR * pszFileName) { DWORD dwFileAttr, dwError; TraceFunctEnter("DoesFileExist"); DebugTrace(TRACEID, "Checking for %S", pszFileName); dwFileAttr = GetFileAttributes(pszFileName); if (dwFileAttr == 0xFFFFFFFF ) { dwError = GetLastError(); // file not found DebugTrace(TRACEID,"GetFileAttributes failed 0x%x", dwError); TraceFunctLeave(); return FALSE ; } if (dwFileAttr & FILE_ATTRIBUTE_DIRECTORY) { DebugTrace(TRACEID, "It is a Directory "); TraceFunctLeave(); return FALSE; } DebugTrace(TRACEID, "File exists"); TraceFunctLeave(); return TRUE; } //++ // // Method: DoesDirExist // // Synopsis: Checks if the specified string is a directory // // Arguments: [pszFileName] Directory name // // Returns: TRUE if the specified string is a directory, // False otherwise // // History: AshishS Created 7/30/96 // //-- BOOL DoesDirExist(const TCHAR * pszFileName ) { DWORD dwFileAttr; TraceFunctEnter("DoesDirExist"); //DebugTrace(TRACEID, " Checking for %S", pszFileName); dwFileAttr = GetFileAttributes(pszFileName); if (dwFileAttr == 0xFFFFFFFF ) { // file not found //DebugTrace(TRACEID,"GetFileAttributes failed 0x%x", //GetLastError()); TraceFunctLeave(); return FALSE ; } if (dwFileAttr & FILE_ATTRIBUTE_DIRECTORY) { //DebugTrace(TRACEID, "Directory exists "); TraceFunctLeave(); return TRUE ; } //DebugTrace(TRACEID, "Directory does not exist"); TraceFunctLeave(); return FALSE; } // sets acl allowing specific access to LocalSystem/Admin // and to everyone DWORD SetAclInObject(HANDLE hObject, DWORD dwObjectType, DWORD dwSystemMask, DWORD dwEveryoneMask, BOOL fInherit) { tenter("SetAclInObject"); DWORD dwRes, dwDisposition; PSID pEveryoneSID = NULL, pAdminSID = NULL, pSystemSID = NULL; PACL pACL = NULL; PSECURITY_DESCRIPTOR pSD = NULL; EXPLICIT_ACCESS ea[3]; SID_IDENTIFIER_AUTHORITY SIDAuthWorld = SECURITY_WORLD_SID_AUTHORITY; SID_IDENTIFIER_AUTHORITY SIDAuthNT = SECURITY_NT_AUTHORITY; LONG lRes; // Create a well-known SID for the Everyone group. if(! AllocateAndInitializeSid( &SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryoneSID) ) { dwRes = GetLastError(); trace(0, "AllocateAndInitializeSid Error %u\n", dwRes); goto Cleanup; } // Initialize an EXPLICIT_ACCESS structure for an ACE. // The ACE will allow Everyone read access to the key. ZeroMemory(&ea, 3 * sizeof(EXPLICIT_ACCESS)); ea[0].grfAccessPermissions = dwEveryoneMask; ea[0].grfAccessMode = SET_ACCESS; ea[0].grfInheritance = fInherit ? SUB_CONTAINERS_AND_OBJECTS_INHERIT : NO_INHERITANCE; ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[0].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP; ea[0].Trustee.ptstrName = (LPTSTR) pEveryoneSID; // Create a SID for the BUILTIN\Administrators group. if(! AllocateAndInitializeSid( &SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &pAdminSID) ) { dwRes = GetLastError(); trace(0, "AllocateAndInitializeSid Error %u\n", dwRes); goto Cleanup; } // Initialize an EXPLICIT_ACCESS structure for an ACE. // The ACE will allow the Administrators group full access to the key. ea[1].grfAccessPermissions = dwSystemMask; ea[1].grfAccessMode = SET_ACCESS; ea[1].grfInheritance= fInherit ? SUB_CONTAINERS_AND_OBJECTS_INHERIT : NO_INHERITANCE; ea[1].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[1].Trustee.TrusteeType = TRUSTEE_IS_GROUP; ea[1].Trustee.ptstrName = (LPTSTR) pAdminSID; // Create a SID for the LocalSystem account if(! AllocateAndInitializeSid( &SIDAuthNT, 1, SECURITY_LOCAL_SYSTEM_RID, 0, 0, 0, 0, 0, 0, 0, &pSystemSID) ) { dwRes = GetLastError(); trace(0, "AllocateAndInitializeSid Error %u\n", dwRes ); goto Cleanup; } // Initialize an EXPLICIT_ACCESS structure for an ACE. // The ACE will allow the LocalSystem full access to the key. ea[2].grfAccessPermissions = dwSystemMask; ea[2].grfAccessMode = SET_ACCESS; ea[2].grfInheritance= fInherit ? SUB_CONTAINERS_AND_OBJECTS_INHERIT : NO_INHERITANCE; ea[2].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[2].Trustee.TrusteeType = TRUSTEE_IS_GROUP; ea[2].Trustee.ptstrName = (LPTSTR) pSystemSID; // Create a new ACL that contains the new ACEs. dwRes = SetEntriesInAcl(3, ea, NULL, &pACL); if (ERROR_SUCCESS != dwRes) { dwRes = GetLastError(); trace(0, "SetEntriesInAcl Error %u\n", dwRes ); goto Cleanup; } // Initialize a security descriptor. pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH); if (pSD == NULL) { trace(0, "LocalAlloc Error %u\n", GetLastError() ); goto Cleanup; } if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)) { dwRes = GetLastError(); trace(0, "InitializeSecurityDescriptor Error %u\n", dwRes ); goto Cleanup; } // Add the ACL to the security descriptor. if (!SetSecurityDescriptorDacl(pSD, TRUE, // fDaclPresent flag pACL, FALSE)) // not a default DACL { dwRes = GetLastError(); trace(0, "SetSecurityDescriptorDacl Error %u\n", dwRes ); goto Cleanup; } dwRes = SetSecurityInfo(hObject, (SE_OBJECT_TYPE) dwObjectType, DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION, NULL, NULL, pACL, NULL); if (ERROR_SUCCESS != dwRes) { trace(0, "SetSecurityInfo Error %u\n", dwRes ); goto Cleanup; } Cleanup: if (pEveryoneSID) FreeSid(pEveryoneSID); if (pAdminSID) FreeSid(pAdminSID); if (pSystemSID) FreeSid(pSystemSID); if (pACL) LocalFree(pACL); if (pSD) LocalFree(pSD); tleave(); return dwRes; } //+--------------------------------------------------------------------------- // // Function: Delnode_Recurse // // Synopsis: attempt to delete a directory tree // // Arguments: [pwszDir] -- directory name // [fIncludeRoot] -- delete top level directory and files // [pfStop] -- TRUE if stop signaled // // Returns: Win32 error code // // History: 12-Apr-2000 HenryLee Created // //---------------------------------------------------------------------------- DWORD Delnode_Recurse (const WCHAR *pwszDir, BOOL fDeleteRoot, BOOL *pfStop) { tenter("Delnode_Recurse"); DWORD dwErr = ERROR_SUCCESS; WIN32_FIND_DATA *pfd = NULL; HANDLE hFile = INVALID_HANDLE_VALUE; WCHAR * pwcsPath = NULL; if (lstrlenW (pwszDir) > MAX_PATH-5) { dwErr = ERROR_INVALID_PARAMETER; trace (0, "Delnode_Recurse failed with %d", dwErr); goto cleanup; } if (NULL == (pfd = new WIN32_FIND_DATA)) { dwErr = ERROR_NOT_ENOUGH_MEMORY; trace (0, "Delnode_Recurse failed with %d", dwErr); goto cleanup; } if (NULL == (pwcsPath = new WCHAR[MAX_PATH])) { dwErr = ERROR_NOT_ENOUGH_MEMORY; trace (0, "Delnode_Recurse failed with %d", dwErr); goto cleanup; } lstrcpy (pwcsPath, pwszDir); lstrcat (pwcsPath, TEXT("\\*.*")); hFile = FindFirstFileW (pwcsPath, pfd); if (hFile == INVALID_HANDLE_VALUE) { // if the directory does not exist, then return success dwErr = ERROR_SUCCESS; goto cleanup; } do { if (pfStop != NULL && TRUE == *pfStop) { dwErr = ERROR_OPERATION_ABORTED; trace (0, "Delnode_Recurse failed with %d", dwErr); goto cleanup; } if (!lstrcmp(pfd->cFileName, L".") || !lstrcmp(pfd->cFileName, L"..")) { continue; } lstrcpy (pwcsPath, pwszDir); // construct the full path name lstrcat (pwcsPath, TEXT("\\")); lstrcat (pwcsPath, pfd->cFileName); if (pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // // Found a directory. Skip mount points // if (pfd->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { continue; } dwErr = Delnode_Recurse (pwcsPath, TRUE, pfStop); if (dwErr != ERROR_SUCCESS) { trace (0, "Delnode_Recurse failed with %d, ignoring", dwErr); dwErr = ERROR_SUCCESS; // try to delete more directories } } else if (fDeleteRoot) { // // We found a file. Set the file attributes, // and try to delete it. // if ((pfd->dwFileAttributes & FILE_ATTRIBUTE_READONLY) || (pfd->dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)) { SetFileAttributesW (pwcsPath, FILE_ATTRIBUTE_NORMAL); } if (FALSE == DeleteFileW (pwcsPath)) { if (ERROR_SUCCESS == (dwErr = TakeOwnership (pwcsPath, TRUE))) { if (FALSE == DeleteFileW (pwcsPath)) { dwErr = GetLastError(); } } if (dwErr != ERROR_SUCCESS) { trace (0, "DeleteFile or TakeOwn failed with %d", dwErr); goto cleanup; } } } } while (FindNextFile(hFile, pfd)); // Find the next entry FindClose(hFile); // Close the search handle hFile = INVALID_HANDLE_VALUE; if (fDeleteRoot) { DWORD dwAttr = GetFileAttributes(pwszDir); if (dwAttr != 0xFFFFFFFF && (dwAttr & FILE_ATTRIBUTE_READONLY)) { dwAttr &= ~FILE_ATTRIBUTE_READONLY; if (FALSE == SetFileAttributes (pwszDir, dwAttr)) { TRACE(0, "SetFileAttributes ignoring %ld", GetLastError()); } } if (FALSE == RemoveDirectoryW (pwszDir)) { if (ERROR_SUCCESS == (dwErr = TakeOwnership (pwszDir, TRUE))) { if (FALSE == RemoveDirectoryW (pwszDir)) { LONG lLast = lstrlenW (pwszDir) - 1; if (lLast < 0) lLast = 0; dwErr = GetLastError(); if (pwszDir[lLast] != L')' && // already renamed TRUE == SRGetAltFileName (pwszDir, pwcsPath) && TRUE == MoveFile (pwszDir, pwcsPath)) dwErr = ERROR_SUCCESS; else trace (0, "RemoveDirectory failed with %d", dwErr); } } } } cleanup: if (hFile != INVALID_HANDLE_VALUE) FindClose (hFile); if (NULL != pfd) delete pfd; if (NULL != pwcsPath) delete [] pwcsPath; tleave(); return dwErr; } // // util function that checks the SR Stop event // to see if it has been signalled or not // will return TRUE if the event does not exist // BOOL IsStopSignalled(HANDLE hEvent) { TENTER("IsStopSignalled"); BOOL fRet, fOpened = FALSE; DWORD dwRc; if (! hEvent) { hEvent = OpenEvent(SYNCHRONIZE, FALSE, s_cszSRStopEvent); if (! hEvent) { // if cannot open, then assume that service is not stopped // if client is running on different desktop than service (multiple user magic) // then it cannot open the event, though service might be running dwRc = GetLastError(); TRACE(0, "! OpenEvent : %ld", dwRc); TLEAVE(); return FALSE; } fOpened = TRUE; } fRet = (WAIT_OBJECT_0 == WaitForSingleObject(hEvent, 0)); if (fOpened) CloseHandle(hEvent); TLEAVE(); return fRet; } void PostTestMessage(UINT msg, WPARAM wp, LPARAM lp) { HWINSTA hwinstaUser; HDESK hdeskUser = NULL; DWORD dwThreadId; HWINSTA hwinstaSave; HDESK hdeskSave; DWORD dwRc; TENTER("PostTestMessage"); // // save current values // GetDesktopWindow(); hwinstaSave = GetProcessWindowStation(); dwThreadId = GetCurrentThreadId(); hdeskSave = GetThreadDesktop(dwThreadId); // // change desktop and winstation to interactive user // hwinstaUser = OpenWindowStation(L"WinSta0", FALSE, MAXIMUM_ALLOWED); if (hwinstaUser == NULL) { dwRc = GetLastError(); trace(0, "! OpenWindowStation : %ld", dwRc); goto done; } SetProcessWindowStation(hwinstaUser); hdeskUser = OpenDesktop(L"Default", 0, FALSE, MAXIMUM_ALLOWED); if (hdeskUser == NULL) { dwRc = GetLastError(); trace(0, "! OpenDesktop : %ld", dwRc); goto done; } SetThreadDesktop(hdeskUser); if (FALSE == PostMessage(HWND_BROADCAST, msg, wp, lp)) { trace(0, "! PostMessage"); } done: // // restore old values // if (hdeskSave) SetThreadDesktop(hdeskSave); if (hwinstaSave) SetProcessWindowStation(hwinstaSave); // // close opened handles // if (hdeskUser) CloseDesktop(hdeskUser); if (hwinstaUser) CloseWindowStation(hwinstaUser); TLEAVE(); } //+------------------------------------------------------------------------- // // Function: RemoveTrailingFilename // // Synopsis: This function takes as input parameter a string which // contains a filename. It removes the last filename (or // directory ) from the string including the '\' or '/' // before the last filename. // // Arguments: IN/OUT pszString - string to be modified. // IN tchSlash - file name separator - must be '/' or'\' // // // Returns: nothing // // History: AshishS Created 5/22/96 // //------------------------------------------------------------------------ void RemoveTrailingFilename(WCHAR * pszString, WCHAR wchSlash) { WCHAR * pszStringStart; DWORD dwStrlen; pszStringStart = pszString; dwStrlen = lstrlen ( pszString); // first go the end of the string pszString += dwStrlen ; // now walk backwards till we see the first '\' // also maintain a count of how many characters we have // gone back. while ( (*pszString != wchSlash) && ( dwStrlen) ) { pszString--; dwStrlen --; } *pszString = TEXT('\0'); } // this function create the parent directory under the specified file // name if it already does not exist BOOL CreateParentDirectory(WCHAR * pszFileName) { TraceFunctEnter("CreateParentDirectory"); BOOL fReturn = FALSE; DWORD dwError; // get the parent directory RemoveTrailingFilename(pszFileName, L'\\'); if (FALSE == DoesDirExist(pszFileName)) { if (FALSE == CreateDirectory(pszFileName, // directory name NULL)) // SD { dwError = GetLastError(); ErrorTrace(TRACEID, "Could not create directory %S ec=%d", pszFileName, dwError); goto cleanup; } } fReturn = TRUE; cleanup: TraceFunctLeave(); return fReturn; } // this function creates all sub directories under the specified file // name. BOOL CreateBaseDirectory(const WCHAR * pszFileName) { BOOL fRetVal = FALSE; DWORD dwCurIndex,dwBufReqd; DWORD dwStrlen; TraceFunctEnter("CreateBaseDirectory"); DWORD dwError; WCHAR * pszFileNameCopy; dwBufReqd = (lstrlen(pszFileName) + 1) * sizeof(WCHAR); pszFileNameCopy = (WCHAR *) _alloca(dwBufReqd); if (NULL == pszFileNameCopy) { ErrorTrace(0, "alloca for size %d failed", dwBufReqd); goto cleanup; } lstrcpy(pszFileNameCopy, pszFileName); // do a fast check to see if the parent directory exists if (TRUE == CreateParentDirectory(pszFileNameCopy)) { fRetVal = TRUE; goto cleanup; } lstrcpy(pszFileNameCopy, pszFileName); dwStrlen = lstrlen(pszFileNameCopy); // check to see if this is a filename starting with the GUID if (0==wcsncmp( pszFileNameCopy, VOLUMENAME_FORMAT, lstrlen(VOLUMENAME_FORMAT))) { // this is of the format \\?\Volume // skip over the initial part dwCurIndex = lstrlen(VOLUMENAME_FORMAT)+1; // skip over the GUID part also while (dwCurIndex < dwStrlen) { dwCurIndex++; if (TEXT('\\') == pszFileNameCopy[dwCurIndex-1] ) { break; } } } else { // the filename is of the regular format // we start at index 1 and not at 0 because we want to handle // path name like \foo\abc.txt dwCurIndex = 1; } while (dwCurIndex < dwStrlen) { if (TEXT('\\') == pszFileNameCopy[dwCurIndex] ) { // NULL terminate at the '\' to get the sub directory // name. pszFileNameCopy[dwCurIndex] = TEXT('\0'); if (FALSE == DoesDirExist(pszFileNameCopy)) { if (FALSE == CreateDirectory(pszFileNameCopy, // directory name NULL)) // SD { dwError = GetLastError(); ErrorTrace(TRACEID, "Could not create directory %S ec=%d", pszFileNameCopy, dwError); pszFileNameCopy[dwCurIndex] = TEXT('\\'); goto cleanup; } DebugTrace(TRACEID, "Created directory %S", pszFileNameCopy); } // restore the \ to get the file name again. pszFileNameCopy[dwCurIndex] = TEXT('\\'); } dwCurIndex ++; } fRetVal = TRUE; cleanup: TraceFunctLeave(); return fRetVal; } // The following function logs the name of a file in the DS. The // problem right now is that the path of the DS is so long that the // relevant information is thrown away from the trace buffer. void LogDSFileTrace(DWORD dwTraceID, const WCHAR * pszPrefix, // Initial message to be traced const WCHAR * pszDSFile) { WCHAR * pszBeginName; TraceQuietEnter("LogDSFileTrace"); // first see if the file is in the DS pszBeginName = wcschr(pszDSFile, L'\\'); if (NULL == pszBeginName) { goto cleanup; } // skip over the first \ . pszBeginName++; // comapare if the first part is "system volume information" if (0!=_wcsnicmp(s_cszSysVolInfo, pszBeginName, lstrlen(s_cszSysVolInfo))) { goto cleanup; } // skip over the next \ . pszBeginName = wcschr(pszBeginName, L'\\'); if (NULL == pszBeginName) { goto cleanup; } pszBeginName++; // now skip over the _restore directory // first see if the file is in the DS pszBeginName = wcschr(pszBeginName, L'\\'); if (NULL == pszBeginName) { goto cleanup; } DebugTrace(dwTraceID, "%S %S", pszPrefix, pszBeginName); cleanup: // the file is not in the DS - or we are printing out the initial // part for debugging purposes. DebugTrace(dwTraceID, "%S%S", pszPrefix, pszDSFile); return; } // the following function calls pfnMethod on all the files specified // by the pszFindFileData filter. DWORD ProcessGivenFiles(WCHAR * pszBaseDir, PPROCESSFILEMETHOD pfnMethod, WCHAR * pszFindFileData) { TraceFunctEnter("ProcessGivenFiles"); WIN32_FIND_DATA FindFileData; HANDLE hFindFirstFile = INVALID_HANDLE_VALUE; DWORD dwErr, dwReturn = ERROR_INTERNAL_ERROR; BOOL fContinue; LogDSFileTrace(0, L"FileData is ", pszFindFileData); hFindFirstFile = FindFirstFile(pszFindFileData, &FindFileData); DebugTrace(0, "FindFirstFile returned %d", hFindFirstFile); if (INVALID_HANDLE_VALUE == hFindFirstFile) { dwErr = GetLastError(); DebugTrace(0, "FindFirstFile failed ec=%d. Filename is %S", dwErr, pszFindFileData); // what if even one file does not exist if ( (ERROR_FILE_NOT_FOUND == dwErr) || (ERROR_PATH_NOT_FOUND == dwErr) || (ERROR_NO_MORE_FILES == dwErr)) { // this is a success condition dwReturn = ERROR_SUCCESS; goto cleanup; } if (ERROR_SUCCESS != dwErr) { dwReturn = dwErr; } goto cleanup; } fContinue = TRUE; while (TRUE==fContinue) { LogDSFileTrace(0, L"FileName is ", FindFileData.cFileName); dwErr = pfnMethod(pszBaseDir, FindFileData.cFileName); if (ERROR_SUCCESS != dwErr) { ErrorTrace(0, "pfnMethod failed. ec=%d.file=%S ", dwErr, FindFileData.cFileName); goto cleanup; } fContinue = FindNextFile(hFindFirstFile, &FindFileData); } dwErr=GetLastError(); if (ERROR_NO_MORE_FILES != dwErr) { _ASSERT(0); ErrorTrace(0, "dwErr != ERROR_NO_MORE_FILES. It is %d", dwErr); goto cleanup; } dwReturn = ERROR_SUCCESS; cleanup: if (INVALID_HANDLE_VALUE != hFindFirstFile) { _VERIFY(TRUE == FindClose(hFindFirstFile)); } TraceFunctLeave(); return dwReturn; } DWORD DeleteGivenFile(WCHAR * pszBaseDir, // Base Directory const WCHAR * pszFile) // file to delete { TraceFunctEnter("DeleteGivenFile"); DWORD dwErr, dwReturn = ERROR_INTERNAL_ERROR; WCHAR szDataFile[MAX_PATH]; // construct the path name of the file wsprintf(szDataFile, L"%s\\%s", pszBaseDir, pszFile); if (TRUE != DeleteFile(szDataFile)) { dwErr = GetLastError(); if (ERROR_SUCCESS != dwErr) { dwReturn = dwErr; } ErrorTrace(0, "DeleteFile failed ec=%d", dwErr); LogDSFileTrace(0,L"File was ", szDataFile); goto cleanup; } dwReturn = ERROR_SUCCESS; cleanup: TraceFunctLeave(); return dwReturn; } //++----------------------------------------------------------------------- // // Function: WriteRegKey // // Synopsis: This function writes into a registry key. It also creates it // if it does not exist. // // Arguments: // // Returns: TRUE no error // FALSE a fatal error happened // // History: AshishS Created 5/22/96 //------------------------------------------------------------------------ BOOL WriteRegKey(BYTE * pbRegValue, DWORD dwNumBytes, const TCHAR * pszRegKey, const TCHAR * pszRegValueName, DWORD dwRegType) { HKEY hRegKey; LONG lResult; DWORD dwDisposition; TraceFunctEnter("WriteRegKey"); //read registry to find out name of the file if ( (lResult = RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszRegKey, // address of subkey name 0, // reserved NULL, // address of class string 0, // special options flag KEY_WRITE, // samDesired NULL, // address of key security structure &hRegKey, // address of handle of open key &dwDisposition // address of disposition value buffer )) != ERROR_SUCCESS ) { ErrorTrace(TRACEID, "RegCreateKeyEx error 0x%x", lResult); _ASSERT(0); goto cleanup; } if ( (lResult =RegSetValueEx( hRegKey, pszRegValueName, 0, // reserved dwRegType,// flag for value type pbRegValue, // address of value data dwNumBytes // size of value data )) != ERROR_SUCCESS ) { ErrorTrace(TRACEID, "RegSetValueEx error 0x%x", lResult); _ASSERT(0); _VERIFY(RegCloseKey(hRegKey)==ERROR_SUCCESS); goto cleanup; } _VERIFY(RegCloseKey(hRegKey)==ERROR_SUCCESS); TraceFunctLeave(); return TRUE; cleanup: TraceFunctLeave(); return FALSE; } //++------------------------------------------------------------------------ // // Function: ReadRegKey // // Synopsis: This function reads a registry key and creates it // if it does not exist with the default value. // // Arguments: // // Returns: TRUE no error // FALSE a fatal error happened // // History: AshishS Created 5/22/96 //------------------------------------------------------------------------ BOOL ReadRegKeyOrCreate(BYTE * pbRegValue, // The value of the reg key will be // stored here DWORD * pdwNumBytes, // Pointer to DWORD conataining // the number of bytes in the above buffer - will be // set to actual bytes stored. const TCHAR * pszRegKey, // Reg Key to be opened const TCHAR * pszRegValueName, // Reg Value to query DWORD dwRegTypeExpected, BYTE * pbDefaultValue, // default value DWORD dwDefaultValueSize) // size of default value { if (!ReadRegKey(pbRegValue,//Buffer to store value pdwNumBytes, // Length of above buffer pszRegKey, // Reg Key name pszRegValueName, // Value name dwRegTypeExpected) ) // Type expected { // read reg key failed - use default value and create this // key return WriteRegKey(pbDefaultValue, dwDefaultValueSize, pszRegKey, pszRegValueName, dwRegTypeExpected); } return TRUE; } //++------------------------------------------------------------------------ // // Function: ReadRegKey // // Synopsis: This function reads a registry key. // // Arguments: // // Returns: TRUE no error // FALSE a fatal error happened // // History: AshishS Created 5/22/96 //------------------------------------------------------------------------ BOOL ReadRegKey(BYTE * pbRegValue, // The value of the reg key will be // stored here DWORD * pdwNumBytes, // Pointer to DWORD conataining // the number of bytes in the above buffer - will be // set to actual bytes stored. const TCHAR * pszRegKey, // Reg Key to be opened const TCHAR * pszRegValueName, // Reg Value to query DWORD dwRegTypeExpected) // Expected type of Value { HKEY hRegKey; DWORD dwRegType; LONG lResult; TraceFunctEnter("ReadRegKey"); DebugTrace(TRACEID, "Trying to open %S %S", pszRegKey, pszRegValueName); //read registry to find out name of the file if ( (lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszRegKey, // address of subkey name 0, // reserved KEY_READ, // samDesired &hRegKey // address of handle of open key )) != ERROR_SUCCESS ) { ErrorTrace(TRACEID, "RegOpenKeyEx open error 0x%x", lResult); goto cleanup; } if ( (lResult =RegQueryValueEx( hRegKey, pszRegValueName, 0, // reserved &dwRegType,// address of buffer // for value type pbRegValue, pdwNumBytes)) != ERROR_SUCCESS ) { _VERIFY(RegCloseKey(hRegKey)==ERROR_SUCCESS); ErrorTrace(TRACEID, "RegQueryValueEx failed error 0x%x", lResult); goto cleanup; } _VERIFY(RegCloseKey(hRegKey)==ERROR_SUCCESS); if ( dwRegType != dwRegTypeExpected ) { ErrorTrace(TRACEID, "RegType is %d, not %d", dwRegType, dwRegTypeExpected); goto cleanup; } TraceFunctLeave(); return TRUE; cleanup: TraceFunctLeave(); return FALSE; } // this function sets the error hit by restore in the registry BOOL SetRestoreError(DWORD dwRestoreError) { TraceFunctEnter("SetDiskSpaceError"); DWORD dwNumBytes=sizeof(DWORD); BOOL fResult=FALSE; // assume FALSE by default DebugTrace(TRACEID, "Setting disk space error to %d", dwRestoreError); if (FALSE== WriteRegKey((BYTE*)&dwRestoreError, // The value of the // reg key will be set to this value dwNumBytes, // Pointer to DWORD containing // the number of bytes in the above buffer s_cszSRRegKey, // Reg Key to be opened s_cszRestoreDiskSpaceError, // Reg Value to query REG_DWORD)) // Expected type of Value { fResult = FALSE; goto cleanup; } fResult= TRUE; cleanup: TraceFunctLeave(); return fResult; } // this function checks to see of the restore failed because of disk space BOOL CheckForDiskSpaceError() { TraceFunctEnter("CheckForDiskSpaceError"); DWORD dwRestoreError; DWORD dwNumBytes=sizeof(DWORD); BOOL fResult=FALSE; // assume FALSE by default if (FALSE==ReadRegKey((BYTE*)&dwRestoreError, // The value of the // reg key will be stored here &dwNumBytes, // Pointer to DWORD containing // the number of bytes in the above buffer - will be // set to actual bytes stored. s_cszSRRegKey, // Reg Key to be opened s_cszRestoreDiskSpaceError, // Reg Value to query REG_DWORD)) // Expected type of Value { fResult = FALSE; } if (dwRestoreError == ERROR_DISK_FULL) { DebugTrace(TRACEID,"Restore failed because of disk space"); fResult= TRUE; } TraceFunctLeave(); return fResult; } // this function sets the status whether restore was done in safe mode BOOL SetRestoreSafeModeStatus(DWORD dwSafeModeStatus) { TraceFunctEnter("SetRestoreSafeModeStatus"); DWORD dwNumBytes=sizeof(DWORD); BOOL fResult=FALSE; // assume FALSE by default DebugTrace(TRACEID, "Setting restore safe mode status to %d", dwSafeModeStatus); if (FALSE== WriteRegKey((BYTE*)&dwSafeModeStatus, // The value of the // reg key will be set to this value dwNumBytes, // Pointer to DWORD containing // the number of bytes in the above buffer s_cszSRRegKey, // Reg Key to be opened s_cszRestoreSafeModeStatus, // Reg Value to query REG_DWORD)) // Expected type of Value { fResult = FALSE; goto cleanup; } fResult= TRUE; cleanup: TraceFunctLeave(); return fResult; } // this function checks to see is the last restore was done in safe mode BOOL WasLastRestoreInSafeMode() { TraceFunctEnter("WasLastRestoreInSafeMode"); DWORD dwRestoreSafeModeStatus; DWORD dwNumBytes=sizeof(DWORD); BOOL fResult=FALSE; // assume FALSE by default if (FALSE==ReadRegKey((BYTE*)&dwRestoreSafeModeStatus, // The value of the // reg key will be stored here &dwNumBytes, // Pointer to DWORD containing // the number of bytes in the above buffer - will be // set to actual bytes stored. s_cszSRRegKey, // Reg Key to be opened s_cszRestoreSafeModeStatus, // Reg Value to query REG_DWORD)) // Expected type of Value { fResult = FALSE; } if (dwRestoreSafeModeStatus != 0 ) { DebugTrace(TRACEID,"Last restore was done in safe mode"); fResult= TRUE; } else { DebugTrace(TRACEID,"Last restore was not done in safe mode"); } TraceFunctLeave(); return fResult; } #define MAX_LEN_SYSERR 1024 LPCWSTR GetSysErrStr() { LPCWSTR cszStr = GetSysErrStr( ::GetLastError() ); return( cszStr ); } LPCWSTR GetSysErrStr( DWORD dwErr ) { static WCHAR szErr[MAX_LEN_SYSERR+1]; ::FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwErr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), szErr, MAX_LEN_SYSERR, NULL ); return( szErr ); } /****************************************************************************/ LPWSTR SRGetRegMultiSz( HKEY hkRoot, LPCWSTR cszSubKey, LPCWSTR cszValue, LPDWORD pdwData ) { TraceFunctEnter("SRGetRegMultiSz"); LPCWSTR cszErr; DWORD dwRes; HKEY hKey = NULL; DWORD dwType; DWORD cbData = 0; LPWSTR szBuf = NULL; dwRes = ::RegOpenKeyEx( hkRoot, cszSubKey, 0, KEY_ALL_ACCESS, &hKey ); if ( dwRes != ERROR_SUCCESS ) { cszErr = ::GetSysErrStr( dwRes ); ErrorTrace(0, "::RegOpenKey() failed - %ls", cszErr); goto Exit; } dwRes = ::RegQueryValueEx( hKey, cszValue, 0, &dwType, NULL, &cbData ); if ( dwRes != ERROR_SUCCESS ) { cszErr = ::GetSysErrStr( dwRes ); ErrorTrace(0, "::RegQueryValueEx(len) failed - %ls", cszErr); goto Exit; } if ( dwType != REG_MULTI_SZ ) { ErrorTrace(0, "Type of '%ls' is %u (not REG_MULTI_SZ)...", cszValue, dwType); goto Exit; } if ( cbData == 0 ) { ErrorTrace(0, "Value '%ls' is empty...", cszValue); goto Exit; } szBuf = new WCHAR[cbData+2]; if (! szBuf) { ErrorTrace(0, "Cannot allocate memory"); goto Exit; } dwRes = ::RegQueryValueEx( hKey, cszValue, 0, &dwType, (LPBYTE)szBuf, &cbData ); if ( dwRes != ERROR_SUCCESS ) { cszErr = ::GetSysErrStr( dwRes ); ErrorTrace(0, "::RegQueryValueEx(data) failed - %ls", cszErr); delete [] szBuf; szBuf = NULL; } if ( pdwData != NULL ) *pdwData = cbData; Exit: if ( hKey != NULL ) ::RegCloseKey( hKey ); TraceFunctLeave(); return( szBuf ); } /****************************************************************************/ BOOL SRSetRegMultiSz( HKEY hkRoot, LPCWSTR cszSubKey, LPCWSTR cszValue, LPCWSTR cszData, DWORD cbData ) { TraceFunctEnter("SRSetRegMultiSz"); BOOL fRet = FALSE; LPCWSTR cszErr; DWORD dwRes; HKEY hKey = NULL; dwRes = ::RegOpenKeyEx( hkRoot, cszSubKey, 0, KEY_ALL_ACCESS, &hKey ); if ( dwRes != ERROR_SUCCESS ) { cszErr = ::GetSysErrStr( dwRes ); ErrorTrace(0, "::RegOpenKey() failed - %ls", cszErr); goto Exit; } dwRes = ::RegSetValueEx( hKey, cszValue, 0, REG_MULTI_SZ, (LPBYTE)cszData, cbData ); if ( dwRes != ERROR_SUCCESS ) { cszErr = ::GetSysErrStr( dwRes ); ErrorTrace(0, "::RegSetValueEx() failed - %ls", cszErr); goto Exit; } fRet = TRUE; Exit: if ( hKey != NULL ) ::RegCloseKey( hKey ); TraceFunctLeave(); return( fRet ); } // this returns the name after the volume name // For example input: c:\file output: file // input \\?\Volume{GUID}\file1 output: file1 WCHAR * ReturnPastVolumeName(const WCHAR * pszFileName) { DWORD dwStrlen, dwCurIndex; dwStrlen = lstrlen(pszFileName); // check to see if this is a filename starting with the GUID if (0==wcsncmp( pszFileName, VOLUMENAME_FORMAT, lstrlen(VOLUMENAME_FORMAT))) { // this is of the format \\?\Volume // skip over the initial part dwCurIndex = lstrlen(VOLUMENAME_FORMAT)+1; // skip over the GUID part also while (dwCurIndex < dwStrlen) { dwCurIndex++; if (TEXT('\\') == pszFileName[dwCurIndex-1] ) { break; } } } else { // the filename is of the regular format dwCurIndex = 3; } return (WCHAR *)pszFileName + dwCurIndex; } void SRLogEvent (HANDLE hEventSource, WORD wType, DWORD dwID, void * pRawData, DWORD dwDataSize, const WCHAR * pszS1, const WCHAR * pszS2, const WCHAR * pszS3) { const WCHAR* ps[3]; ps[0] = pszS1; ps[1] = pszS2; ps[2] = pszS3; WORD iStr = 0; for (int i = 0; i < 3; i++) { if (ps[i] != NULL) iStr++; } if (hEventSource) { ::ReportEvent( hEventSource, wType, 0, dwID, NULL, // sid iStr, dwDataSize, ps, pRawData); } } BOOL IsPowerUsers() { BOOL fReturn = FALSE; PSID psidPowerUsers; DWORD dwErr; SID_IDENTIFIER_AUTHORITY SystemSidAuthority = SECURITY_NT_AUTHORITY; TENTER("IsPowerUsers"); if ( AllocateAndInitializeSid ( &SystemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_POWER_USERS, 0, 0, 0, 0, 0, 0, &psidPowerUsers)) { if (! CheckTokenMembership(NULL, psidPowerUsers, &fReturn)) { dwErr = GetLastError(); TRACE(0, "! CheckTokenMembership : %ld", dwErr); } FreeSid (psidPowerUsers); } else { dwErr = GetLastError(); TRACE(0, "! AllocateAndInitializeSid : %ld", dwErr); } TLEAVE(); return fReturn; } // function to check if caller is running in admin context BOOL IsAdminOrSystem() { BOOL fReturn = FALSE; PSID psidAdmin, psidSystem; DWORD dwErr; SID_IDENTIFIER_AUTHORITY SystemSidAuthority = SECURITY_NT_AUTHORITY; TENTER("IsAdminOrSystem"); // // check if caller is Admin // if ( AllocateAndInitializeSid ( &SystemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &psidAdmin) ) { if (! CheckTokenMembership(NULL, psidAdmin, &fReturn)) { dwErr = GetLastError(); TRACE(0, "! CheckTokenMembership : %ld", dwErr); } FreeSid (psidAdmin); // // if so, scoot // if (fReturn) { goto done; } // // check if caller is localsystem // if ( AllocateAndInitializeSid ( &SystemSidAuthority, 1, SECURITY_LOCAL_SYSTEM_RID, 0, 0, 0, 0, 0, 0, 0, &psidSystem) ) { if (! CheckTokenMembership(NULL, psidSystem, &fReturn)) { dwErr = GetLastError(); TRACE(0, "! CheckTokenMembership : %ld", dwErr); } FreeSid(psidSystem); } else { dwErr = GetLastError(); TRACE(0, "! AllocateAndInitializeSid : %ld", dwErr); } } else { dwErr = GetLastError(); TRACE(0, "! AllocateAndInitializeSid : %ld", dwErr); } done: TLEAVE(); return (fReturn); } DWORD SRLoadString(LPCWSTR pszModule, DWORD dwStringId, LPWSTR pszString, DWORD cbBytes) { DWORD dwErr = ERROR_SUCCESS; HINSTANCE hModule = NULL; if (hModule = LoadLibraryEx(pszModule, NULL, DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE)) { if (! LoadString(hModule, dwStringId, pszString, cbBytes)) { dwErr = GetLastError(); } FreeLibrary(hModule); } else dwErr = GetLastError(); return dwErr; } // // replace CurrentControlSet in pszString with ControlSetxxx // void ChangeCCS(HKEY hkMount, LPWSTR pszString) { tenter("ChangeCCS"); int nCS = lstrlen(L"CurrentControlSet"); if (_wcsnicmp(pszString, L"CurrentControlSet", nCS) == 0) { WCHAR szCS[20] = L"ControlSet001"; DWORD dwCurrent = 0; HKEY hKey = NULL; if (ERROR_SUCCESS == RegOpenKeyEx(hkMount, L"Select", 0, KEY_READ, &hKey)) { if (ERROR_SUCCESS == RegReadDWORD(hKey, L"Current", &dwCurrent)) { wsprintf(szCS, L"ControlSet%03d", (int) dwCurrent); } RegCloseKey(hKey); } else { trace(0, "! RegOpenKeyEx : %ld", GetLastError()); } WCHAR szTemp[MAX_PATH]; lstrcpy(szTemp, &(pszString[nCS])); wsprintf(pszString, L"%s%s", szCS, szTemp); trace(0, "ChangeCCS: pszString = %S", pszString); } tleave(); } WCHAR * SRPathFindExtension (WCHAR * pwszPath) { WCHAR *pwszDot = NULL; if (pwszPath != NULL) for (; *pwszPath; pwszPath++) { switch (*pwszPath) { case L'.': pwszDot = pwszPath; // remember the last dot break; case L'\\': case L' ': pwszDot = NULL; // extensions can't have spaces break; // forget last dot, it was in a directory } } return pwszDot; } // In order to prevent endless loop in case of disk failure, try only up to // a predefined number. #define MAX_ALT_INDEX 1000 // // This function makes an unique alternative name of given file name, keeping // path and extension. // BOOL SRGetAltFileName( LPCWSTR cszPath, LPWSTR szAltName ) { TraceFunctEnter("SRGetAltFileName"); BOOL fRet = FALSE; WCHAR szNewPath[SR_MAX_FILENAME_LENGTH]; LPWSTR szExtPos; WCHAR szExtBuf[SR_MAX_FILENAME_LENGTH]; int nAltIdx; ::lstrcpy( szNewPath, cszPath ); szExtPos = SRPathFindExtension( szNewPath ); if ( szExtPos != NULL ) { ::lstrcpy( szExtBuf, szExtPos ); } else { szExtBuf[0] = L'\0'; szExtPos = &szNewPath[ lstrlen(szNewPath) ]; // end of string } for ( nAltIdx = 2; nAltIdx < MAX_ALT_INDEX; nAltIdx++ ) { ::wsprintf( szExtPos, L"(%d)%s", nAltIdx, szExtBuf ); if ( ::GetFileAttributes( szNewPath ) == 0xFFFFFFFF ) break; } if ( nAltIdx == MAX_ALT_INDEX ) { ErrorTrace(0, "Couldn't get alternative name."); goto Exit; } ::lstrcpy( szAltName, szNewPath ); fRet = TRUE; Exit: TraceFunctLeave(); return( fRet ); } CSRClientLoader::CSRClientLoader() { m_hSRClient=NULL; m_hFrameDyn=NULL; } CSRClientLoader::~CSRClientLoader() { // unload library here if (m_hFrameDyn != NULL) { _VERIFY(FreeLibrary(m_hFrameDyn)); } if (m_hSRClient != NULL) { _VERIFY(FreeLibrary(m_hSRClient)); } } BOOL CSRClientLoader::LoadFrameDyn() { TraceFunctEnter("LoadFrameDyn"); WCHAR szFrameDynPath[MAX_PATH+100]; DWORD dwCharsCopied, dwBufSize,dwError; BOOL fReturn=FALSE; m_hFrameDyn=LoadLibrary(FRAMEDYN_DLL); // file name of module if (m_hFrameDyn != NULL) { // we are done. fReturn = TRUE; goto cleanup; } // framedyn.dll could not be loaded. Try to load framedyn.dll // from the explicit path. (system32\wbem\framedyn.dll) dwError = GetLastError(); ErrorTrace(0,"Failed to load framedyn.dll on first attempt. ec=%d", dwError); // get the windows system32 directory // add wbem\framedyn.dll // Call LoadLibrary on this path dwBufSize = sizeof(szFrameDynPath)/sizeof(WCHAR); dwCharsCopied=GetSystemDirectory( szFrameDynPath, //buffer for system directory dwBufSize); // size of directory buffer if (dwCharsCopied == 0) { dwError = GetLastError(); ErrorTrace(0,"Failed to load system directory. ec=%d", dwError); goto cleanup; } // check if buffer is big enough. if (dwBufSize < dwCharsCopied + sizeof(FRAMEDYN_DLL)/sizeof(WCHAR) + sizeof(WBEM_DIRECTORY)/sizeof(WCHAR)+ 3 ) { ErrorTrace(0,"Buffer not big enough. WinSys is %d chars long", dwCharsCopied); goto cleanup; } lstrcat(szFrameDynPath, L"\\" WBEM_DIRECTORY L"\\" FRAMEDYN_DLL); m_hFrameDyn=LoadLibrary(szFrameDynPath); // file name of module if (m_hFrameDyn == NULL) { // we are done. fReturn = FALSE; dwError = GetLastError(); ErrorTrace(0,"Failed to load framedyn.dll on second attempt. ec=%d", dwError); goto cleanup; } fReturn=TRUE; cleanup: TraceFunctLeave(); return fReturn; } BOOL CSRClientLoader::LoadSrClient() { TraceFunctEnter("LoadSrClient"); DWORD dwError; BOOL fReturn=FALSE; if (m_hSRClient != NULL) { fReturn=TRUE; goto cleanup; } // sometimes srclient.dll cannot be loaded because framedyn.dll // cannot be loaded because of the PATH variable being messed up. // Explicitly load framedyn.dll from %windir%\system32\wbem // and then try again. if (FALSE == LoadFrameDyn()) { ErrorTrace(0,"Failed to load framedyn.dll"); // we can still try to load srclient.dll } m_hSRClient=LoadLibrary(L"srclient.dll"); // file name of module if (m_hSRClient == NULL) { dwError = GetLastError(); ErrorTrace(0,"Failed to load srclient.dll. ec=%d", dwError); goto cleanup; } fReturn=TRUE; cleanup: TraceFunctLeave(); return fReturn; }