//-----------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1996 - 1996.
//
// File: utils.c
//
// Contents: Cross Language Migration Tools utility function
//
// History: 09/17/2001 Xiaofeng Zang (xiaoz) Created
//
// Notes:
//
//-----------------------------------------------------------------------
#include "StdAfx.h"
#include "clmt.h"
#include <esent97.h>
#include <dsrole.h>
#include <Ntdsapi.h>
HRESULT MakeDOInfCopy();
//-----------------------------------------------------------------------
//
// Function: ConcatenatePaths
//
// Descrip: Concat the 2 paths into 1 into Target
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: if buffer is small to hold the concated string, return value
// will be false,however, the truncated string still got copied
//
//-----------------------------------------------------------------------
BOOL
ConcatenatePaths(
LPTSTR Target,
LPCTSTR Path,
UINT TargetBufferSize )
{
UINT TargetLength,PathLength;
BOOL TrailingBackslash,LeadingBackslash;
UINT EndingLength;
TargetLength = lstrlen(Target);
PathLength = lstrlen(Path);
//
// See whether the target has a trailing backslash.
//
if(TargetLength && (Target[TargetLength-1] == TEXT('\\')))
{
TrailingBackslash = TRUE;
TargetLength--;
}
else
{
TrailingBackslash = FALSE;
}
//
// See whether the path has a leading backshash.
//
if(Path[0] == TEXT('\\'))
{
LeadingBackslash = TRUE;
PathLength--;
}
else
{
LeadingBackslash = FALSE;
}
//
// Calculate the ending length, which is equal to the sum of
// the length of the two strings modulo leading/trailing
// backslashes, plus one path separator, plus a nul.
//
EndingLength = TargetLength + PathLength + 2;
if(!LeadingBackslash && (TargetLength < TargetBufferSize))
{
Target[TargetLength++] = TEXT('\\');
}
if(TargetBufferSize > TargetLength)
{
lstrcpyn(Target+TargetLength,Path,TargetBufferSize-TargetLength);
}
//
// Make sure the buffer is nul terminated in all cases.
//
if (TargetBufferSize)
{
Target[TargetBufferSize-1] = 0;
}
return(EndingLength <= TargetBufferSize);
}
//-----------------------------------------------------------------------
//
// Function: StrToUInt
//
// Descrip:
//
// Returns: UINT
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
UINT StrToUInt(
LPTSTR lpszNum)
{
LPTSTR lpszStop;
#ifdef UNICODE
return (wcstoul(lpszNum, &lpszStop, 16));
#else
return (strtoul(lpszNum, &lpszStop, 16));
#endif
}
//-----------------------------------------------------------------------
//
// Function: INIFile_ChangeSectionName
//
// Descrip: change a section name in the INF file
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
BOOL INIFile_ChangeSectionName(
LPCTSTR szIniFileName,
LPCTSTR szIniOldSectionName,
LPCTSTR szIniNewSectionName)
{
LPTSTR pBuf = NULL;
BOOL bRetVal = FALSE;
DWORD ccbBufsize = 0x7FFFF;
DWORD copied_chars;
DPF (INFmsg ,TEXT("[INIFile_ChangeSectionName] Calling ,%s,%s,%s !"),
szIniFileName,szIniOldSectionName,szIniNewSectionName);
//
// allocate max size of buffer
//
do
{
if (pBuf)
{
free(pBuf);
ccbBufsize *= 2;
}
pBuf = (LPTSTR) malloc(ccbBufsize * sizeof(TCHAR));
if (!pBuf)
{
DPF (INFerr,TEXT("[INIFile_ChangeSectionName] memory allocate error !"));
goto Exit1;
}
copied_chars = GetPrivateProfileSection(szIniOldSectionName,
pBuf,
ccbBufsize,
szIniFileName);
} while (copied_chars == ccbBufsize -2);
if (! copied_chars)
{
//
// this section is not in INI file
//
// do nothing
//
DPF (INFerr,TEXT("[INIFile_ChangeSectionName] No %s section in %s !"),szIniOldSectionName);
goto Exit2;
}
bRetVal = WritePrivateProfileSection(
szIniNewSectionName,
pBuf,
szIniFileName);
if (! bRetVal)
{
//
// write failure
//
DPF (dlError,TEXT("[INIFile_ChangeSectionName] WritePrivateProfileSection fail!"));
goto Exit2;
}
//Delete the old section
WritePrivateProfileSection(
szIniOldSectionName,
NULL,
szIniFileName);
//
// at this step, even old section is not deleted, it's still OK
//
bRetVal = TRUE;
Exit2:
if (pBuf)
{
free(pBuf);
}
Exit1:
return bRetVal;
}
//-----------------------------------------------------------------------
//
// Function: INIFile_ChangeSectionName
//
// Descrip: change a section name in the INF file
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
BOOL INIFile_Merge2Section(
LPCTSTR szIniFileName,
LPCTSTR szSourceSection,
LPCTSTR szDestSection)
{
LPTSTR pBufSource = NULL, pBufDest = NULL, pBufMerged = NULL;
BOOL bRetVal = FALSE;
DWORD cchBufsize;
DWORD srccopied_chars, dstcopied_chars;
DPF (INFmsg ,TEXT("[INIFile_Merger2Section] Calling ,%s,%s,%s !"),
szIniFileName,szSourceSection,szDestSection);
//
// allocate max size of buffer
//
cchBufsize = 0x7FFFF;
do
{
if (pBufDest)
{
free(pBufDest);
cchBufsize *= 2;
}
pBufDest = (LPTSTR) malloc(cchBufsize * sizeof(TCHAR));
if (!pBufDest)
{
DPF (INFerr,TEXT("[INIFile_ChangeSectionName] memory allocate error !"));
goto Exit;
}
dstcopied_chars = GetPrivateProfileSection(szDestSection,
pBufDest,
cchBufsize,
szIniFileName);
} while (dstcopied_chars == cchBufsize -2);
if (! dstcopied_chars)
{
//
// this section is not in INI file
//
// do nothing
//
DPF (INFerr,TEXT("[INIFile_Merger2Section] No %s section in %s !"),szDestSection);
goto Exit;
}
cchBufsize = 0x7FFFF;
do
{
if (pBufSource)
{
free(pBufSource);
cchBufsize *= 2;
}
pBufSource = (LPTSTR) malloc(cchBufsize * sizeof(TCHAR));
if (!pBufSource)
{
DPF (INFerr,TEXT("[INIFile_ChangeSectionName] memory allocate error !"));
goto Exit;
}
srccopied_chars = GetPrivateProfileSection(szSourceSection,
pBufSource,
cchBufsize,
szIniFileName);
} while (srccopied_chars == cchBufsize -2);
if (! srccopied_chars)
{
//
// this section is not in INI file
//
// do nothing
//
DPF (INFerr,TEXT("[INIFile_Merger2Section] No %s section in %s !"),szSourceSection);
goto Exit;
}
pBufMerged = (LPTSTR) malloc((srccopied_chars + dstcopied_chars + 1) * sizeof(TCHAR));
if (!pBufMerged)
{
DPF (INFerr,TEXT("[INIFile_ChangeSectionName] memory allocate error !"));
goto Exit;
}
memmove((LPBYTE)pBufMerged,(LPBYTE)pBufDest,dstcopied_chars * sizeof(TCHAR));
memmove((LPBYTE)(pBufMerged + dstcopied_chars),(LPBYTE)pBufSource,srccopied_chars * sizeof(TCHAR));
pBufMerged[srccopied_chars + dstcopied_chars] = TEXT('\0');
bRetVal = WritePrivateProfileSection(
szDestSection,
pBufMerged,
szIniFileName);
if (! bRetVal)
{
//
// write failure
//
DPF (dlError,TEXT("[INIFile_ChangeSectionName] WritePrivateProfileSection fail!"));
goto Exit;
}
bRetVal = TRUE;
Exit:
FreePointer(pBufSource);
FreePointer(pBufDest);
FreePointer(pBufMerged);
return bRetVal;
}
//-----------------------------------------------------------------------------
//
// Function: INIFile_IsSectionExist
//
// Synopsis: Find out whether the section name is existed in INF file or not
//
// Returns: TRUE if found, FALSE otherwise
//
// History: 02/07/2002 Rerkboos Created
//
// Notes: None.
//
//-----------------------------------------------------------------------------
BOOL INIFile_IsSectionExist(
LPCTSTR lpSection, // Section name to be searched
LPCTSTR lpINFFile // INF file name
)
{
HINF hInf;
BOOL fRet = FALSE;
if (NULL == lpSection || NULL == lpINFFile)
{
return FALSE;
}
hInf = SetupOpenInfFile(lpINFFile, NULL, INF_STYLE_WIN4, NULL);
if (INVALID_HANDLE_VALUE != hInf)
{
if (SetupGetLineCount(hInf, lpSection) > 0)
{
fRet = TRUE;
}
SetupCloseInfFile(hInf);
}
return fRet;
}
//-----------------------------------------------------------------------
//
// Function: IntToString
//
// Descrip:
//
// Returns: void
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
void IntToString(
DWORD i,
LPTSTR sz)
{
#define CCH_MAX_DEC 12 // Number of chars needed to hold 2^32
TCHAR szTemp[CCH_MAX_DEC];
int iChr;
iChr = 0;
do {
szTemp[iChr++] = TEXT('0') + (TCHAR)(i % 10);
i = i / 10;
} while (i != 0);
do {
iChr--;
*sz++ = szTemp[iChr];
} while (iChr != 0);
*sz++ = TEXT('\0');
}
//-----------------------------------------------------------------------
//
// Function: IsDirExisting
//
// Descrip: Check whether the Dir exists or not
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
BOOL IsDirExisting(LPTSTR Dir)
{
LONG lResult = GetFileAttributes(Dir);
DPF (dlInfo,TEXT("[IsDirExisting] %s lResult:%X"),Dir,lResult);
if ((lResult == 0xFFFFFFFF) ||
(!(lResult & FILE_ATTRIBUTE_DIRECTORY)))
{
return FALSE;
}
else
{
return TRUE;
}
}
LONG IsDirExisting2(LPTSTR Dir, PBOOL pbExit)
{
LONG lResult = GetFileAttributes(Dir);
DPF (dlInfo,TEXT("[IsDirExisting] %s lResult:%X"),Dir,lResult);
if (lResult == INVALID_FILE_ATTRIBUTES)
{
DWORD dwErr = GetLastError();
if ( (dwErr == ERROR_FILE_NOT_FOUND)
|| (dwErr == ERROR_PATH_NOT_FOUND) )
{
*pbExit = FALSE;
return ERROR_SUCCESS;
}
else
{
return dwErr;
}
}
else
{
*pbExit = TRUE;
return ERROR_SUCCESS;
}
}
//-----------------------------------------------------------------------
//
// Function: IsFileFolderExisting
//
// Descrip: Check whether the File exists or not
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
BOOL IsFileFolderExisting( LPTSTR File)
{
LONG lResult = GetFileAttributes(File);
DPF (dlInfo,TEXT("[IsFileFolderExisting] %s lResult:%X"),File,lResult);
if (lResult == 0xFFFFFFFF)
{
return FALSE;
}
else
{
return TRUE;
}
}
//-----------------------------------------------------------------------
//
// Function: MyMoveFile
//
// Descrip: Rename a file or direcory
//
// Returns: HRESULT
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
HRESULT MyMoveFile(
LPCTSTR lpExistingFileName, // file name
LPCTSTR lpNewFileName, // new file name
BOOL bAnalyze, // if it's analyze mode, it will add an entry in INF file
// for future renaming
BOOL bIsFileProtected)
{
LPCTSTR lpMyNewFileName = lpNewFileName;
if (!lpExistingFileName)
{
return E_INVALIDARG;
}
if (!IsFileFolderExisting((LPTSTR)lpExistingFileName))
{
return S_FALSE;
}
if (!MyStrCmpI(lpExistingFileName,lpNewFileName))
{
return S_FALSE;
}
if (!lpNewFileName || !lpNewFileName[0])
{
lpMyNewFileName = NULL;
}
if (bAnalyze)
{
HRESULT hr;
DWORD dwType;
if (bIsFileProtected)
{
dwType = TYPE_SFPFILE_MOVE;
}
else
{
dwType = TYPE_FILE_MOVE;
}
return (AddFolderRename((LPTSTR)lpExistingFileName,(LPTSTR)lpMyNewFileName,dwType,NULL));
}
else
{
if (MoveFileEx(lpExistingFileName,lpMyNewFileName,MOVEFILE_DELAY_UNTIL_REBOOT))
{
return S_OK;
}
else
{
return HRESULT_FROM_WIN32(GetLastError());
}
}
}
//-----------------------------------------------------------------------
//
// Function: AddHardLinkEntry
//
// Descrip: add an entry in hardlink section
//
// Returns: HRESULT
//
// Notes:
//
// History: 04/10/2002 xiaoz created
//
// Notes: none
//
//-----------------------------------------------------------------------
HRESULT AddHardLinkEntry(
LPTSTR szLinkName, //Link Name to created
LPTSTR szLinkValue, //the name you want to link to
LPTSTR szType,
LPTSTR lpUser,
LPTSTR lpHiddenType,
LPTSTR lpKeyname
)
{
LPTSTR lpszSectionName;
LPTSTR szOneLine = NULL;
size_t CchOneLine = MAX_PATH;
TCHAR szIndex[MAX_PATH];
LPTSTR lpCurrIndex = szIndex;
HRESULT hr;
if (!szLinkName ||!szLinkValue || !szType || !szLinkName[0] || !szLinkValue[0] || !szType[0])
{
hr = E_INVALIDARG;
goto Cleanup;
}
CchOneLine += lstrlen(szLinkName)+lstrlen(szLinkValue) +lstrlen(szType);
szOneLine = malloc(CchOneLine * sizeof(TCHAR));
if (!szOneLine)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (!lpHiddenType)
{
hr = StringCchPrintf(szOneLine,CchOneLine,TEXT("%s,\"%s\",\"%s\""),
szType,szLinkName,szLinkValue);
}
else
{
hr = StringCchPrintf(szOneLine,CchOneLine,TEXT("%s,\"%s\",\"%s\",\"%s\""),
szType,szLinkName,szLinkValue,lpHiddenType);
}
if (FAILED(hr))
{
goto Cleanup;
}
if (lpKeyname && (g_dwKeyIndex < 0xFFFF))
{
g_dwKeyIndex = 0xFFFF;
_itot(g_dwKeyIndex,szIndex,16);
}
else
{
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
}
if (lpUser && !MyStrCmpI(lpUser,DEFAULT_USER))
{
lpszSectionName = TEXT("Folder.HardLink.Peruser");
}
else
{
lpszSectionName = TEXT("Folder.HardLink");
}
if (!WritePrivateProfileString(lpszSectionName,lpCurrIndex,szOneLine,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
hr = S_OK;
Cleanup:
if (szOneLine)
{
free(szOneLine);
}
return hr;
}
//-----------------------------------------------------------------------
//
// Function: MyMoveDirectory
//
// Descrip: Rename SourceDir to DestDir
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: if the directory is in use, a deferred move will be
// performed and we set the system reboot statue
// MoveFileEx will fail for directory when DestDir is
// already exitsing
// if bTakeCareBackupDir is TRUE, this function will make
// a backup for DestDir if it exists.
//-----------------------------------------------------------------------
HRESULT MyMoveDirectory(
LPTSTR SourceDir,
LPTSTR DestDir,
BOOL bTakeCareBackupDir,
BOOL bAnalyze,
BOOL bCreateHardLink,
DWORD dwShellID)
{
HRESULT hr;
size_t cChSourceDir, cChDestDir ;
LPTSTR lpSourceBackupDir, lpDestBackupDir;
BOOL bDirExist;
DWORD dwStatus;
lpSourceBackupDir = lpDestBackupDir = NULL;
dwStatus = IsDirExisting2(SourceDir,&bDirExist);
if (ERROR_SUCCESS == dwStatus)
{
if (!bDirExist)
{
hr = S_FALSE;
goto Cleanup;
}
}
else
{
hr = HRESULT_FROM_WIN32(dwStatus);
DPF(APPerr, TEXT("Error: current user maybe can not access folder %s "),SourceDir);
goto Cleanup;
}
if (!MyStrCmpI(SourceDir,DestDir))
{
hr = S_FALSE;
goto Cleanup;
}
if (bAnalyze)
{
BOOL bAccess;
LPTSTR lp = StrRChrI(SourceDir,NULL,TEXT('\\'));
TCHAR cCh;
if (!lp)
{
hr = S_FALSE;
goto Cleanup;
}
//Try self first
hr = IsObjectAccessiablebyLocalSys(SourceDir,SE_FILE_OBJECT,&bAccess);
if (hr != S_OK)
{
hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
DPF(APPerr, TEXT("Error: LocalSystem or Local Administartors Group or Anyone can not access folder %s "),SourceDir);
goto Cleanup;
}
//try parent
if (*(lp-1) == TEXT(':'))
{
lp++;
}
cCh = *lp;
*lp = TEXT('\0');
hr = IsObjectAccessiablebyLocalSys(SourceDir,SE_FILE_OBJECT,&bAccess);
if (hr != S_OK)
{
hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
DPF(APPerr, TEXT("Error: LocalSystem or Local Administartors Group or Anyone can not access folder %s "),SourceDir);
goto Cleanup;
}
if (!bAccess)
{
DPF(APPerr, TEXT("Error: LocalSystem or Local Administartors Group or Anyone can not access folder %s "),SourceDir);
hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
goto Cleanup;
}
*lp = cCh;
if (bTakeCareBackupDir && IsDirExisting(DestDir))
{
LPTSTR lpOld,lpNew,lpLastSlash;
//
// RERKBOOS: Add more code here...
// We merge the content from Backup English folder to localized folder
// then we will rename localized folder to English folder
//
#ifdef NEVER
//Testing team decides to change mind and better not to add this code
//we will just follow here
hr = MergeDirectory(DestDir, SourceDir);
if (FAILED(hr))
{
goto Cleanup;
}
#endif
//We need to make sure DestDir does not exist
cChDestDir = lstrlen(DestDir)+ MAX_PATH;
lpDestBackupDir = malloc(cChDestDir * sizeof(TCHAR));
if (!lpDestBackupDir)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (!GetBackupDir( DestDir,lpDestBackupDir,cChDestDir,FALSE))
{
hr = E_FAIL;
goto Cleanup;
}
if (FAILED(hr = AddFolderRename(DestDir,lpDestBackupDir,TYPE_DIR_MOVE,NULL)))
{
goto Cleanup;
}
lpOld = StrRChrI(DestDir,NULL,TEXT('\\'));
lpNew = StrRChrI(lpDestBackupDir,NULL,TEXT('\\'));
lpLastSlash = lpOld;
if (lpOld && lpNew)
{
lpOld++;
lpNew++;
//*lpLastSlash = TEXT('\0');
if (!AddItemToStrRepaceTable(TEXT("SYSTEM"),lpOld,lpNew,DestDir,
dwShellID,&g_StrReplaceTable))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
//*lpLastSlash = TEXT('\\');
}
}
else
{
//We need to make sure DestDir does not exist
cChDestDir = lstrlen(DestDir)+ MAX_PATH;
lpDestBackupDir = malloc(cChDestDir * sizeof(TCHAR));
if (lpDestBackupDir)
{
if (GetBackupDir( DestDir,lpDestBackupDir,cChDestDir,FALSE))
{
AddFolderRename(DestDir,lpDestBackupDir,TYPE_DIR_MOVE,NULL);
}
}
}
}
//if we are here we are safe to move source dir to destination
if (bAnalyze)
{
if (FAILED(hr = AddFolderRename(SourceDir,DestDir,TYPE_DIR_MOVE,NULL)))
{
goto Cleanup;
}
/*if (bCreateHardLink)
{
if (FAILED(hr = AddHardLinkEntry(SourceDir,DestDir)))
{
goto Cleanup;
}
}*/
}
else
{
if (!MoveFileEx(SourceDir,DestDir,MOVEFILE_DELAY_UNTIL_REBOOT))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
}
if (bAnalyze && bTakeCareBackupDir)
{
cChSourceDir = lstrlen(SourceDir)+ MAX_PATH;
lpSourceBackupDir = malloc(cChSourceDir * sizeof(TCHAR));
if (!lpSourceBackupDir)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (GetBackupDir( SourceDir,lpSourceBackupDir,cChSourceDir,TRUE))
{
LPTSTR lpOld,lpNew,lpLastSlash;
if (FAILED(hr = AddFolderRename(lpSourceBackupDir,SourceDir,TYPE_DIR_MOVE,NULL)))
{
goto Cleanup;
}
lpOld = StrRChrI(lpSourceBackupDir,NULL,TEXT('\\'));
lpNew = StrRChrI(SourceDir,NULL,TEXT('\\'));
lpLastSlash = lpOld;
if (lpOld && lpNew)
{
lpOld++;
lpNew++;
//*lpLastSlash = TEXT('\0');
if (!AddItemToStrRepaceTable(TEXT("SYSTEM"),lpOld,lpNew,lpSourceBackupDir,
dwShellID,&g_StrReplaceTable))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
//*lpLastSlash = TEXT('\\');
}
}
}
hr = S_OK;
Cleanup:
FreePointer(lpSourceBackupDir);
FreePointer(lpDestBackupDir);
return hr;
}
//-----------------------------------------------------------------------
//
// Function: UpdateINFFileSys
//
// Descrip: adding ALLUSERSPROFILE/HOMEDRIVE/WINDIR Key in [String] section
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
// 03/05/2002 rerkboos modified
//
// Notes:
//
//-----------------------------------------------------------------------
HRESULT UpdateINFFileSys(
LPTSTR lpInfFile
)
{
HRESULT hr = E_FAIL;
DWORD dwSize;
TCHAR szStringSection[32];
TCHAR szProfileDir[MAX_PATH];
TCHAR szWindir[MAX_PATH+1];
TCHAR szHomeDrive[MAX_PATH];
TCHAR szSystemDrive[MAX_PATH];
TCHAR szStr[MAX_PATH];
TCHAR szComputerName[16];
TCHAR szBackupDir[MAX_PATH];
TCHAR szFirstNTFSDrive[4];
INT i;
struct _EnvPair
{
LPCTSTR lpEnvVarName;
LPCTSTR lpValue;
};
struct _EnvPair epCLMT[] = {
TEXT("ALLUSERSPROFILE"), szProfileDir,
TEXT("HOMEDRIVE"), szHomeDrive,
TEXT("WINDIR"), szWindir,
TEXT("SYSTEMDRIVE"), szSystemDrive,
TEXT("COMPUTERNAME"), szComputerName,
TEXT("MUIBACKUPDIR"), szBackupDir,
TEXT("FIRSTNTFSDRIVE"), szFirstNTFSDrive,
NULL, NULL
};
if (lpInfFile == NULL)
{
return E_INVALIDARG;
}
DPF(APPmsg, TEXT("Enter UpdateINFFileSys:"));
//
// Get neccessary environment variables from system
//
dwSize = ARRAYSIZE(szProfileDir);
if (!GetAllUsersProfileDirectory(szProfileDir, &dwSize))
{
DPF(APPerr, TEXT("Failed to get ALLUSERPROFILE"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto EXIT;
}
dwSize = ARRAYSIZE(szComputerName);
if (!GetComputerName(szComputerName, &dwSize))
{
DPF(APPerr, TEXT("Failed to get computer name"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto EXIT;
}
if (!GetSystemWindowsDirectory(szWindir, ARRAYSIZE(szWindir)))
{
DPF(APPerr, TEXT("Failed to get WINDIR"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto EXIT;
}
if (!GetEnvironmentVariable(TEXT("HOMEDRIVE"), szHomeDrive, ARRAYSIZE(szHomeDrive)))
{
DWORD dw = GetLastError();
DPF(APPerr, TEXT("Failed to get HOMEDRIVE"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto EXIT;
}
if (!GetEnvironmentVariable(TEXT("SystemDrive"), szSystemDrive, ARRAYSIZE(szSystemDrive)))
{
DPF(APPerr, TEXT("Failed to get SystemDrive"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto EXIT;
}
hr = StringCchCopy(szBackupDir, ARRAYSIZE(szBackupDir), szWindir);
if (SUCCEEDED(hr))
{
ConcatenatePaths(szBackupDir, CLMT_BACKUP_DIR, ARRAYSIZE(szBackupDir));
if (!CreateDirectory(szBackupDir, NULL))
{
hr = HRESULT_FROM_WIN32(GetLastError());
if (HRESULT_CODE(hr) != ERROR_ALREADY_EXISTS)
{
goto EXIT;
}
}
}
else
{
goto EXIT;
}
hr = GetFirstNTFSDrive(szFirstNTFSDrive, ARRAYSIZE(szFirstNTFSDrive));
if (FAILED(hr))
{
DPF(APPerr, TEXT("Failed to get first NTFS drive in system"));
goto EXIT;
}
//
// Generate strings section depend on operation mode
//
hr = InfGenerateStringsSection(lpInfFile,
szStringSection,
ARRAYSIZE(szStringSection));
if (FAILED(hr))
{
DPF(APPerr, TEXT("InfGenerateStringsSection failed"));
goto EXIT;
}
//
// Update private environment variables to INF file
//
for (i = 0 ; epCLMT[i].lpEnvVarName != NULL ; i++)
{
hr = StringCchPrintf(szStr,
ARRAYSIZE(szStr),
TEXT("\"%s\""),
epCLMT[i].lpValue);
if (SUCCEEDED(hr))
{
BOOL bRet;
bRet = WritePrivateProfileString(szStringSection,
epCLMT[i].lpEnvVarName,
szStr,
lpInfFile);
if (!bRet)
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(APPerr, TEXT("Failed to append private variable to INF file"));
break;
}
}
else
{
DPF(APPerr, TEXT("StringCchPrintf failed"));
break;
}
}
EXIT:
DPF(APPmsg, TEXT("Exit UpdateINFFileSys:"));
return hr;
}
//-----------------------------------------------------------------------
//
// Function: InfGenerateStringsSection
//
// Descrip: Generate [Strings] section from localized and English
// sections. If the operation is normal source strings are
// from localized section and destination strings are from
// English section. vice versa if the operation is Undo.
//
// Returns: HRESULT
//
// Notes:
//
// History: 03/05/2002 rerkboos Created
//
// Notes: none.
//
//-----------------------------------------------------------------------
HRESULT InfGenerateStringsSection(
LPCTSTR lpInfFile, // INF file name
LPTSTR lpFinalSection, // Output section name that stores required strings
SIZE_T cchFinalSection // Size of lpFinalSection in TCHAR
)
{
LPVOID lpBuffer;
LPVOID lpOldBuffer;
LPCTSTR lpSection;
LPCTSTR lpSrcSection;
LPCTSTR lpDstSection;
DWORD cbBuffer;
DWORD cchRead;
TCHAR szLocSection[16];
BOOL bRet = TRUE;
HRESULT hr = S_OK;
LCID lcidOriginal;
const TCHAR szFinalSection[] = TEXT("Strings");
const TCHAR szEngSection[] = TEXT("Strings.0409");
const TCHAR szPrefixSRC[] = TEXT("SRC_");
const TCHAR szPrefixDST[] = TEXT("DST_");
if (lpInfFile == NULL || lpFinalSection == NULL)
{
return E_INVALIDARG;
}
hr = GetSavedInstallLocale(&lcidOriginal);
if (SUCCEEDED(hr))
{
hr = StringCchPrintf(szLocSection,
ARRAYSIZE(szLocSection),
TEXT("Strings.%04X"),
lcidOriginal);
}
if (FAILED(hr))
{
return hr;
}
if (MyStrCmpI(szLocSection,szEngSection) == LSTR_EQUAL)
{
return E_NOTIMPL;
}
cbBuffer = 8192;
lpBuffer = MEMALLOC(cbBuffer);
if (lpBuffer == NULL)
{
return E_OUTOFMEMORY;
}
cchRead = GetPrivateProfileSectionNames(lpBuffer,
cbBuffer / sizeof(TCHAR),
lpInfFile);
while (cchRead == (cbBuffer / sizeof(TCHAR)) - 2)
{
// Buffer is too small, reallocate until we have enough
lpOldBuffer = lpBuffer;
cbBuffer += 8192;
lpBuffer = MEMREALLOC(lpOldBuffer, cbBuffer);
if (lpBuffer == NULL)
{
MEMFREE(lpOldBuffer);
return E_OUTOFMEMORY;
}
// Read the data from section again
cchRead = GetPrivateProfileSectionNames(lpBuffer,
cbBuffer / sizeof(TCHAR),
lpInfFile);
}
// At this point we have big enough buffer and data in it
if (cchRead > 0)
{
lpSection = MultiSzTok(lpBuffer);
while (lpSection != NULL)
{
if (StrStrI(lpSection, TEXT("Strings.")) != NULL)
{
// This is one of Strings sections,
// Delete all sections that do not match current locale and English
if (MyStrCmpI(lpSection, szLocSection) != LSTR_EQUAL &&
MyStrCmpI(lpSection, szEngSection) != LSTR_EQUAL)
{
bRet = WritePrivateProfileSection(lpSection, NULL, lpInfFile);
if (!bRet)
{
break;
}
}
}
// Get next section name
lpSection = MultiSzTok(NULL);
}
// no error occured
bRet = TRUE;
}
else
{
SetLastError(ERROR_NOT_FOUND);
bRet = FALSE;
}
MEMFREE(lpBuffer);
if (!bRet)
{
return HRESULT_FROM_WIN32(GetLastError());
}
//
// Merge strings from Loc and Eng section to [Strings] section
//
if (g_dwRunningStatus != CLMT_UNDO_PROGRAM_FILES
&& g_dwRunningStatus != CLMT_UNDO_APPLICATION_DATA
&& g_dwRunningStatus != CLMT_UNDO_ALL)
{
lpSrcSection = szLocSection;
lpDstSection = szEngSection;
}
else
{
lpSrcSection = szEngSection;
lpDstSection = szLocSection;
}
// Copy source strings to [Strings] section with SRC_ prefix
hr = InfCopySectionWithPrefix(lpSrcSection,
szFinalSection,
szPrefixSRC,
lpInfFile);
if (SUCCEEDED(hr))
{
// Copy destination strings to [Strings] section with DSTs_ prefix
hr = InfCopySectionWithPrefix(lpDstSection,
szFinalSection,
szPrefixDST,
lpInfFile);
if (SUCCEEDED(hr))
{
WritePrivateProfileSection(lpSrcSection, NULL, lpInfFile);
WritePrivateProfileSection(lpDstSection, NULL, lpInfFile);
hr = StringCchCopy(lpFinalSection, cchFinalSection, szFinalSection);
}
}
return hr;
}
//-----------------------------------------------------------------------
//
// Function: InfCopySectionWithPrefix
//
// Descrip: Copy keys from source section to destination and append
// prefix to key name in destination section
//
// Returns: HRESULT
//
// Notes:
//
// History: 03/05/2002 rerkboos Created
//
// Notes: none.
//
//-----------------------------------------------------------------------
HRESULT InfCopySectionWithPrefix(
LPCTSTR lpSrcSection, // Source section name
LPCTSTR lpDstSection, // Destination section name
LPCTSTR lpPrefix, // Prefix to add to key name
LPCTSTR lpInfFile // Inf file name
)
{
HRESULT hr = E_NOTIMPL;
BOOL bRet;
LPVOID lpBuffer;
LPVOID lpOldBuffer;
DWORD cbBuffer;
DWORD cchRead;
LPTSTR lpSz;
LPTSTR lpKey;
LPTSTR lpValue;
TCHAR szPrefixedKey[MAX_PATH];
if (lpSrcSection == NULL || lpDstSection == NULL || lpInfFile == NULL)
{
return E_INVALIDARG;
}
//
// Read data from source section into memory
//
cbBuffer = 65536;
lpBuffer = MEMALLOC(cbBuffer);
if (lpBuffer == NULL)
{
return E_OUTOFMEMORY;
}
cchRead = GetPrivateProfileSection(lpSrcSection,
lpBuffer,
cbBuffer / sizeof(TCHAR),
lpInfFile);
while (cchRead == (cbBuffer / sizeof(TCHAR)) - 2)
{
// Buffer is too small, reallocate until we have enough
lpOldBuffer = lpBuffer;
cbBuffer += 65536;
lpBuffer = MEMREALLOC(lpOldBuffer, cbBuffer);
if (lpBuffer == NULL)
{
MEMFREE(lpOldBuffer);
return E_OUTOFMEMORY;
}
// Read the data from section again
cchRead = GetPrivateProfileSection(lpSrcSection,
lpBuffer,
cbBuffer / sizeof(TCHAR),
lpInfFile);
}
//
// Write key with prefix to destination section
//
lpKey = (LPTSTR) MultiSzTok((LPCTSTR) lpBuffer);
while (lpKey != NULL)
{
lpValue = StrStr(lpKey, TEXT("="));
*lpValue = TEXT('\0');
hr = StringCchPrintf(szPrefixedKey,
ARRAYSIZE(szPrefixedKey),
TEXT("%s%s"),
lpPrefix,
lpKey);
if (FAILED(hr))
{
break;
}
*lpValue = TEXT('=');
lpValue++;
bRet = WritePrivateProfileString(lpDstSection,
szPrefixedKey,
lpValue,
lpInfFile);
if (!bRet)
{
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
// Get next Sz value
lpKey = (LPTSTR) MultiSzTok(NULL);
}
MEMFREE(lpBuffer);
return hr;
}
//-----------------------------------------------------------------------
//
// Function: UpdateINFFilePerUser
//
// Descrip: adding user specific key name in [Strings] section
//
// Returns: HRESULT
//
// Notes:
//
// History: 09/17/2001 xiaoz created
// 03/08/2002 rerkboos modified to work with SRC/DST format
//
// Notes:
//
//-----------------------------------------------------------------------
HRESULT UpdateINFFilePerUser(
LPCTSTR lpInfFile,
LPCTSTR lpUserName,
LPCTSTR lpUserSid,
BOOL bCureMode
)
{
HRESULT hr = S_OK;
BOOL bRet = FALSE;
DWORD dwSize;
TCHAR szExpandedUserProfilePath[MAX_PATH];
TCHAR szStr[MAX_PATH + 2];
UINT uInstLocale;
TCHAR szRegKey[MAX_PATH];
HRESULT hRes;
LONG lRet;
DWORD cbStr;
const TCHAR szStringsSection[] = TEXT("Strings");
if (lpInfFile == NULL || lpUserName == NULL)
{
hr = E_INVALIDARG;
goto Cleanup;
}
DPF(APPmsg, TEXT("Enter UpdateINFFilePerUser"));
dwSize = MAX_PATH;
if (GetDefaultUserProfileDirectory(szExpandedUserProfilePath, &dwSize))
{
if (MyStrCmpI(DEFAULT_USER, lpUserName))
{
hr = StringCchCopy(szRegKey, ARRAYSIZE(szRegKey), g_cszProfileList);
if (SUCCEEDED(hr))
{
hr = StringCchCat(szRegKey, ARRAYSIZE(szRegKey), TEXT("\\"));
hr = StringCchCat(szRegKey, ARRAYSIZE(szRegKey), lpUserSid);
if (SUCCEEDED(hr))
{
cbStr = sizeof(szStr);
lRet = GetRegistryValue(HKEY_LOCAL_MACHINE,
szRegKey,
g_cszProfileImagePath,
(LPBYTE) szStr,
&cbStr);
if (lRet == ERROR_SUCCESS)
{
ExpandEnvironmentStrings(szStr,
szExpandedUserProfilePath,
ARRAYSIZE(szExpandedUserProfilePath));
}
else
{
hr = E_FAIL;
}
}
}
if (FAILED(hr))
{
DPF(APPerr, TEXT("Failed to get profile directory for user"));
}
}
if (SUCCEEDED(hr))
{
hr = StringCchPrintf(szStr,
ARRAYSIZE(szStr),
TEXT("\"%s\""),
szExpandedUserProfilePath);
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(APPerr, TEXT("Failed to get default user profile directory"));
goto Cleanup;
}
if (SUCCEEDED(hr))
{
if (bCureMode)
{
if (!WritePrivateProfileString(szStringsSection,
lpUserSid,
szStr,
lpInfFile))
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(APPerr, TEXT("Failed to write environment variable"));
}
}
else
{
if (!WritePrivateProfileString(szStringsSection,
TEXT("USERPROFILE"),
szStr,
lpInfFile))
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(APPerr, TEXT("Failed to write environment variable"));
}
}
}
if (!bCureMode)
{
if (!WritePrivateProfileString(szStringsSection,
TEXT("USER_SID"),
lpUserSid,
lpInfFile))
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(APPerr, TEXT("Failed to write environment variable"));
goto Cleanup;
}
}
hr = S_OK;
DPF(APPmsg, TEXT("Exit UpdateINFFilePerUser"));
Cleanup:
return hr;
}
//-----------------------------------------------------------------------
//
// Function: GetInfFilePath
//
// Descrip: Get a file name for temp INF file
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
// 03/06/2002 rerkboos Read INF from resource
//
// Notes:
//
//-----------------------------------------------------------------------
HRESULT GetInfFilePath(
LPTSTR lpInfFile, // Output buffer store INF file name
SIZE_T cchInfFile // Len of buffer in TCHAR
)
{
HRESULT hr = S_OK;
BOOL bRet = FALSE;
TCHAR *p;
TCHAR szSysDir[MAX_PATH];
TCHAR szInfSource[MAX_PATH];
TCHAR szTempName[MAX_PATH];
LPTSTR lpFileName;
if (!lpInfFile)
{
return E_INVALIDARG;
}
DPF(dlPrint, TEXT("Enter GetInfFilePath:"));
// Contruct a tmp file name for our INF in szSysDir
// The temp INF file is in %windir%\system32\clmt*.tmp
if (GetSystemDirectory(szSysDir, ARRAYSIZE(szSysDir)))
{
if (GetTempFileName(szSysDir, TEXT("clmt"), 0, szTempName))
{
hr = S_OK;
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(dlError, TEXT("Failed to get temp file name"));
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(dlError, TEXT("Failed to get system directory"));
}
if (SUCCEEDED(hr))
{
// We will use template from inf file if user supply /INF switch
// otherwise we will grab it from resource section
if (g_fUseInf)
{
//
// Use user-supply INF as template
//
if (GetFullPathName(g_szInfFile,
ARRAYSIZE(szInfSource),
szInfSource,
&lpFileName))
{
// Copy the source INF file to %windir%\system32\clmt*.tmp
if (CopyFile(szInfSource, szTempName, FALSE))
{
DPF(dlPrint, TEXT("Use inf from %s"), g_szInfFile);
hr = StringCchCopy(lpInfFile, cchInfFile, szTempName);
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(dlError, TEXT("Failed to copy temporary INF file"));
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
DPF(dlError, TEXT("%s not found."), g_szInfFile);
}
}
else
{
//
// Use template from resource
//
DPF(dlPrint, TEXT("Use INF from resource"));
hr = GetInfFromResource(szTempName);
if (SUCCEEDED(hr))
{
hr = StringCchCopy(g_szInfFile, ARRAYSIZE(g_szInfFile), szTempName);
hr = StringCchCopy(lpInfFile, cchInfFile, szTempName);
}
else
{
DPF(dlError, TEXT("Failed to read INF file from resource"));
}
}
}
DPF(dlPrint, TEXT("Exit GetInfFilePath:"));
return hr;
}
//-----------------------------------------------------------------------
//
// Function: GetInfFromResource
//
// Descrip: Read INF file from resource section and write it to output
// file.
//
// Returns: HRESULT
//
// Notes:
//
// History: 03/08/2002 rerkboos Created
//
// Notes:
//
//-----------------------------------------------------------------------
HRESULT GetInfFromResource(
LPCTSTR lpDstFile // Output file name
)
{
HRESULT hr = E_FAIL;
HMODULE hExe;
BOOL bRet = FALSE;
if (lpDstFile == NULL)
{
return E_INVALIDARG;
}
// Get the handle to our executable
hExe = GetModuleHandle(NULL);
if (hExe)
{
// Inf is stored in RCDATA type with the name "CLMTINF"
HRSRC hRsrc = FindResource(hExe, TEXT("CLMTINF"), RT_RCDATA);
if (hRsrc)
{
DWORD cbBuffer;
LPVOID lpBuffer;
cbBuffer = SizeofResource(hExe, hRsrc);
if (cbBuffer > 0)
{
lpBuffer = MEMALLOC(cbBuffer);
if (lpBuffer)
{
HGLOBAL hGlobal = LoadResource(hExe, hRsrc);
if (hGlobal)
{
LPVOID lpLockGlobal = LockResource(hGlobal);
if (lpLockGlobal)
{
HANDLE hFile;
CopyMemory(lpBuffer, lpLockGlobal, cbBuffer);
hFile = CreateFile(lpDstFile,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_TEMPORARY,
NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
DWORD cbWritten;
bRet = WriteFile(hFile,
lpBuffer,
cbBuffer,
&cbWritten,
NULL);
CloseHandle(hFile);
}
}
}
MEMFREE(lpBuffer);
}
else
{
SetLastError(ERROR_OUTOFMEMORY);
}
}
}
}
if (!bRet)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
hr = S_OK;
}
return hr;
}
//*************************************************************
// ReplaceString
//
// Purpose: Replace a string
//
// Parameter: lpszOldStr: Orignal string
// lpszReplaceStr: Search string
// lpszReplacedWithStr: String to be replaced with
// lpszOutputStr: Output buffer
// cbszOutputStr: size of output buffer
// lpszTailCheck: point to predefined tail character
// lpSysPath: point to standard system path
// lpAttrib: point to string attribute
// bStrCheck: True -- do it, or False -- skip it
//
// History: 12/10/2001 geoffguo created
//
// Note: Tail check is right side check.
// For example, "Documents" and "Documents and Settings". if you search
// "Documents", to avoid mismatch, we check the next character of "Documents".
//*************************************************************
BOOL ReplaceString(
LPCTSTR lpszOldStr,
LPCTSTR lpszReplaceStr,
LPCTSTR lpszReplacedWithStr,
LPTSTR lpszOutputStr,
size_t cbszOutputStr,
LPCTSTR lpszTailCheck,
LPCTSTR lpSysPath,
LPDWORD lpAttrib,
BOOL bStrCheck)
{
BOOL bRet = FALSE;
DWORD dwLen, dwStrNum;
LPTSTR pszAnchor = NULL;
TCHAR cTemp;
TCHAR *p;
if (!lpszOldStr || !lpszReplaceStr || !lpszReplacedWithStr || !lpszOutputStr)
{
return bRet;
}
dwStrNum = 0;
dwLen = lstrlen(lpszReplaceStr);
p = (LPTSTR)lpszOldStr;
lpszOutputStr[0] = TEXT('\0');
while (*p)
{
//get the first occurance of the string needs to be replaced
pszAnchor = StrStrI(p,lpszReplaceStr);
if (pszAnchor)
{
dwStrNum++;
if (!bStrCheck || StringValidationCheck(lpszOldStr, lpszReplaceStr, lpSysPath, lpszTailCheck, lpAttrib, dwStrNum))
{
cTemp = *pszAnchor;
*pszAnchor = L'\0';
if (FAILED(StringCchCat(lpszOutputStr,cbszOutputStr,p)))
{
bRet = FALSE;
goto Exit;
}
if (FAILED(StringCchCat(lpszOutputStr,cbszOutputStr,lpszReplacedWithStr)))
{
bRet = FALSE;
goto Exit;
}
*pszAnchor = cTemp;
bRet = TRUE;
} else //Copy invalid matching string
{
cTemp = *(pszAnchor+dwLen);
*(pszAnchor+dwLen) = L'\0';
if (FAILED(StringCchCat(lpszOutputStr,cbszOutputStr,p)))
{
bRet = FALSE;
goto Exit;
}
*(pszAnchor+dwLen) = cTemp;
}
p = pszAnchor+dwLen;
}
else //Copy string
{
if (FAILED(StringCchCat(lpszOutputStr,cbszOutputStr,p)))
{
bRet = FALSE;
goto Exit;
}
break;
}
}
Exit:
return bRet;
}
//-----------------------------------------------------------------------
//
// Function: StringMultipleReplacement
//
// Descrip: string replacement with multiple replace pair
//
// Returns: HRESULT
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
// lpszOldStr : The source string
// lpszReplaceMSzStr : multi string instance that needs to be replaced
// lpszReplacedWithMSzStr : multi string instance that will replace to
// lpszOutputStr: output buffer
// cbszOutputStr:buffer size for lpszOutputStr
//
//-----------------------------------------------------------------------
HRESULT StringMultipleReplacement(
LPCTSTR lpszOldStr,
LPCTSTR lpszReplaceMSzStr,
LPCTSTR lpszReplacedWithMSzStr,
LPTSTR lpszOutputStr,
size_t cchOutputStr)
{
HRESULT hr;
DWORD dwLen;
LPTSTR pszAnchor = NULL;
TCHAR cTemp;
LPTSTR pOld,pNew;
LPTSTR pTmp = NULL;
TCHAR cNonChar = TEXT('\xFFFF');
if (!lpszOldStr || !lpszReplaceMSzStr || !lpszReplacedWithMSzStr || !lpszOutputStr)
{
hr = E_INVALIDARG;
goto Cleanup;
}
pOld = (LPTSTR)lpszReplaceMSzStr;
pNew = (LPTSTR)lpszReplacedWithMSzStr;
//alloc temp buffer for intermediate string
pTmp = malloc(cchOutputStr*sizeof(TCHAR));
if (!pTmp)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (FAILED(hr = StringCchCopy(pTmp,cchOutputStr,lpszOldStr)))
{
goto Cleanup;
}
while (*pOld && *pNew)
{
if (!ReplaceString(pTmp,pOld,pNew,lpszOutputStr, cchOutputStr,&cNonChar, NULL, NULL, TRUE))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
pOld += (lstrlen(pOld) + 1);
pNew += (lstrlen(pNew) + 1);
if (FAILED(hr = StringCchCopy(pTmp,cchOutputStr,lpszOutputStr)))
{
goto Cleanup;
}
}
hr = S_OK;
Cleanup:
FreePointer(pTmp);
return hr;
}
//-----------------------------------------------------------------------
//
// Function: MultiSzSubStr
//
// Descrip: multiSZ version of substr
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: return TRUE is szString is a sub string of a string in szMultiSz
//
//-----------------------------------------------------------------------
BOOL
MultiSzSubStr (
LPTSTR szString,
LPTSTR szMultiSz)
{
TCHAR *p = szMultiSz;
while (*p)
{
if (StrStrI(p,szString))
{
return TRUE;
}
p += (lstrlen(p) + 1);
}
return FALSE;
}
//-----------------------------------------------------------------------
//
// Function: IsStrInMultiSz
//
// Descrip: check whether is string is in MultiSz
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
//
//-----------------------------------------------------------------------
BOOL
IsStrInMultiSz (
LPCTSTR szString,
LPCTSTR szMultiSz)
{
LPCTSTR p = szMultiSz;
while (*p)
{
if (!MyStrCmpI(p,szString))
{
return TRUE;
}
p += (lstrlen(p) + 1);
}
return FALSE;
}
//-----------------------------------------------------------------------
//
// Function: MultiSzLen
//
// Descrip: Returns the length (in characters) of the buffer required to hold a multisz,
// INCLUDING the trailing null.
//
// Returns: DWORD
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
// Example: MultiSzLen("foo\0bar\0") returns 9
//
//-----------------------------------------------------------------------
DWORD MultiSzLen(LPCTSTR szMultiSz)
{
TCHAR *p = (LPTSTR) szMultiSz;
DWORD dwLen = 0;
if (!p)
{
return 0;
}
if (!*p)
{
return 2;
}
while (*p)
{
dwLen += (lstrlen(p) +1);
p += (lstrlen(p) + 1);
}
// add one for the trailing null character
return (dwLen+1);
}
//-----------------------------------------------------------------------
//
// Function: MultiSzTok
//
// Descrip: Extract an sz string from multisz string
// (work similar to strtok, but use '\0' as seperator)
//
// Returns: Pointer to next Sz string
// NULL if no string left
//
// Notes:
//
// History: 03/05/2002 rerkboos Created
//
// Notes: Supply the pointer to multisz string the first time calling
// this function. Supply NULL for subsequent call to get
// next sz string in multisz.
//
//-----------------------------------------------------------------------
LPCTSTR MultiSzTok(
LPCTSTR lpMultiSz // Pointer to multisz string
)
{
LPCTSTR lpCurrentSz;
static LPCTSTR lpNextSz;
if (lpMultiSz != NULL)
{
lpNextSz = lpMultiSz;
}
lpCurrentSz = lpNextSz;
// Advance pointer to next Sz
while (*lpNextSz != TEXT('\0'))
{
lpNextSz++;
}
lpNextSz++;
return (*lpCurrentSz == TEXT('\0') ? NULL : lpCurrentSz);
}
//-----------------------------------------------------------------------
//
// Function: CmpMultiSzi
//
// Descrip: check whether 2 multisz is equal(case insensitive)
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: here if stra ="foo1\0foo2\0" and strb = "foo2\0foo1\0"
// it will return equal , in other words, the string order
// in multi-sz is not playing role in comparing
//
//-----------------------------------------------------------------------
BOOL CmpMultiSzi(
LPCTSTR szMultiSz1,
LPCTSTR szMultiSz2)
{
LPCTSTR p;
if (MultiSzLen(szMultiSz1) != MultiSzLen(szMultiSz2))
{
return FALSE;
}
p = szMultiSz1;
while (*p)
{
if (!IsStrInMultiSz(p,szMultiSz2))
{
return FALSE;
}
p += (lstrlen(p) + 1);
}
return TRUE;
}
//-----------------------------------------------------------------------
//
// Function: AppendSzToMultiSz
//
// Descrip: appending a string to multiSZ
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: return true if succeed, since it will do malloc and the current multiSZ
// string buffer is too small to append a string, so the API will possible
// return false, call GetLastError to get error code
//
//-----------------------------------------------------------------------
BOOL
AppendSzToMultiSz(
IN LPCTSTR SzToAppend,
IN OUT LPTSTR *MultiSz,
IN OUT PDWORD pcchMultiSzLen //MultiSz buffer size in char
)
{
DWORD cchszLen;
DWORD cchmultiSzLen;
LPTSTR newMultiSz = NULL;
LPTSTR lpStartPoint = NULL;
LPTSTR lpSpTChar = NULL;
BOOL bMemEnlarged = FALSE;
DWORD cchLen;
BOOL bRet = FALSE;
HRESULT hr;
//SzToAppend can not be null or empty
if (!SzToAppend || !SzToAppend[0])
{
SetLastError(ERROR_INVALID_PARAMETER);
goto Exit;
}
//Multi-SZ must be initialzed , not NULL pointer, at least 2 '\0'
if (!MultiSz || *pcchMultiSzLen < 2)
{
SetLastError(ERROR_INVALID_PARAMETER);
goto Exit;
}
// get the size, of the two buffers in TCHAR
cchszLen = lstrlen(SzToAppend)+1;
cchmultiSzLen = MultiSzLen(*MultiSz);
if (cchszLen + cchmultiSzLen > *pcchMultiSzLen)
{
newMultiSz = (LPTSTR)malloc( (cchszLen+cchmultiSzLen+MULTI_SZ_BUF_DELTA) * sizeof(TCHAR) );
if( newMultiSz == NULL )
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto Exit;
}
// recopy the old MultiSz into proper position into the new buffer.
// the (char*) cast is necessary, because newMultiSz may be a wchar*, and
// szLen is in bytes.
memcpy( ((char*)newMultiSz), *MultiSz, cchmultiSzLen * sizeof(TCHAR));
bMemEnlarged = TRUE;
cchLen = cchszLen + cchmultiSzLen + MULTI_SZ_BUF_DELTA;
}
else
{
newMultiSz = *MultiSz;
cchLen = *pcchMultiSzLen;
}
//the existing sz ended with 2 NULL, we need to start to copy the string
// from second null char
//lpStartPoint = (char*)newMultiSz + (multiSzLen - 1) * sizeof(TCHAR);
if (cchmultiSzLen == 2)
{
//if it's empty MultiSz, we do not need to keep the 1st NULL
cchmultiSzLen = 0;
lpStartPoint = newMultiSz;
}
else
{
lpStartPoint = newMultiSz + (cchmultiSzLen - 1);
}
// copy in the new string
lpSpTChar = (TCHAR*) lpStartPoint;
if (FAILED(hr = StringCchCopy(lpSpTChar,cchLen - (cchmultiSzLen - 1) , SzToAppend )))
{
SetLastError(HRESULT_CODE(hr));
goto Exit;
}
//Add the ending NULL
*(lpSpTChar+lstrlen(SzToAppend)+1) = 0;
if (bMemEnlarged)
{
free( *MultiSz );
*MultiSz = newMultiSz;
*pcchMultiSzLen = cchszLen + cchmultiSzLen + MULTI_SZ_BUF_DELTA;
}
SetLastError(ERROR_SUCCESS);
bRet = TRUE;
Exit:
if (!bRet)
{
if (newMultiSz)
{
free(newMultiSz);
}
}
return bRet;
}
//-----------------------------------------------------------------------
//
// Function: PrintMultiSz
//
// Descrip:
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes: internal used for debug perpose
//
//-----------------------------------------------------------------------
void PrintMultiSz(LPTSTR MultiSz)
{
TCHAR *p = MultiSz;
while (*p)
{
_tprintf(TEXT(" %s"),p);
_tprintf(TEXT("\n"));
p += (lstrlen(p) + 1);
}
}
//-----------------------------------------------------------------------
//
// Function: GetSetUserProfilePath
//
// Descrip: Get or Set User Profile path from registry
//
// Returns: BOOL
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
// szUserName: User name
// szPath : Profile path for set and buffer to get profile path for read
// nOperation: PROFILE_PATH_READ for get path and PROFILE_PATH_WRITE for
// set path
// nType : Specifes string type, only used to read though
// REG_SZ : for unicode string
// REG_EXPAND_SZ : for unicode string conatins enviroment variable
//
//-----------------------------------------------------------------------
HRESULT GetSetUserProfilePath(
LPCTSTR szUserName,
LPTSTR szPath,
size_t cchPath,
UINT nOperation,
UINT nType)
{
PSID pSID =NULL;
DWORD cbSID = 1024;
TCHAR lpszDomain[MAXDOMAINLENGTH];
DWORD cchDomainName = MAXDOMAINLENGTH;
SID_NAME_USE snuType;
LPTSTR szStrSid = NULL;
LPTSTR lpszRegRegProfilePath = NULL;
HKEY hKeyProfileList = NULL;
DWORD dwErr, dwType, cbUserProfilePath;
DWORD dwSize;
size_t cchLen;
TCHAR szUserProfilePath[MAX_PATH],szExpandedUserProfilePath[MAX_PATH];
LPTSTR lpszUserProfilePath = szUserProfilePath;
LPTSTR lpszExpandedUserProfilePath = szExpandedUserProfilePath;
HRESULT hr;
pSID = (PSID) LocalAlloc(LPTR, cbSID);
if (!pSID)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (!LookupAccountName(NULL,szUserName,pSID,&cbSID,lpszDomain,
&cchDomainName,&snuType))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
if (!IsValidSid(pSID))
{
hr = E_FAIL;
goto Cleanup;
}
if (!ConvertSidToStringSid(pSID,&szStrSid))
{
hr = E_FAIL;
goto Cleanup;
}
cchLen = lstrlen(g_cszProfileList)+ lstrlen(szStrSid) + 3;
if (!(lpszRegRegProfilePath = malloc(cchLen * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (FAILED(hr = StringCchPrintf(lpszRegRegProfilePath,cchLen,_T("%s\\%s"),g_cszProfileList,szStrSid)))
{
goto Cleanup;
}
if ( (dwErr = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
lpszRegRegProfilePath,
0,
KEY_ALL_ACCESS,
&hKeyProfileList )) != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Cleanup;
}
if (nOperation == PROFILE_PATH_READ)
{
cbUserProfilePath = MAX_PATH;
dwErr = RegQueryValueEx( hKeyProfileList,
g_cszProfileImagePath,
NULL,
&dwType,
(PBYTE)lpszUserProfilePath,
&cbUserProfilePath );
if (dwErr == ERROR_MORE_DATA)
{
lpszUserProfilePath = malloc(cbUserProfilePath * sizeof(TCHAR));
if (!lpszUserProfilePath)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
dwErr = RegQueryValueEx(hKeyProfileList,
g_cszProfileImagePath,
NULL,
&dwType,
(PBYTE)lpszUserProfilePath,
&cbUserProfilePath );
}
}
else
{ // for witre operation
dwErr = RegSetValueEx(hKeyProfileList,
g_cszProfileImagePath,
0,
REG_EXPAND_SZ,
(const BYTE *)szPath,
(lstrlen(szPath)+1)*sizeof(TCHAR));
}
if ( dwErr != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
//The string saved in registry contains enviroment variable, so
//if user want expanded version, we will do it here
if (nOperation == PROFILE_PATH_READ)
{
if (nType == REG_SZ)
{
size_t cchLenForExpandedStr;
cchLenForExpandedStr = ExpandEnvironmentStrings(
lpszUserProfilePath,
lpszExpandedUserProfilePath,
MAX_PATH);
if (!cchLenForExpandedStr)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
else if (cchLenForExpandedStr >= MAX_PATH)
{
lpszExpandedUserProfilePath = malloc(cchLenForExpandedStr * sizeof(TCHAR));
if (!lpszExpandedUserProfilePath)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (!ExpandEnvironmentStrings(lpszUserProfilePath,
lpszExpandedUserProfilePath,
cchLenForExpandedStr))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
}
if (FAILED(hr = StringCchCopy(szPath,cchPath,lpszExpandedUserProfilePath)))
{
goto Cleanup;
}
}
else
{
if (FAILED(StringCchCopy(szPath,cchPath,lpszUserProfilePath)))
{
goto Cleanup;
}
}
}
hr = S_OK;
Cleanup:
if (hKeyProfileList)
{
RegCloseKey( hKeyProfileList );
}
if (pSID)
{
FreeSid(pSID);
}
if (szStrSid)
{
LocalFree(szStrSid);
}
FreePointer(lpszRegRegProfilePath);
if (!lpszUserProfilePath && (lpszUserProfilePath != szUserProfilePath))
{
free(lpszUserProfilePath);
}
if (!lpszExpandedUserProfilePath && (lpszExpandedUserProfilePath != szUserProfilePath))
{
free(lpszExpandedUserProfilePath);
}
return (hr);
}
//-----------------------------------------------------------------------
//
// Function: ReStartSystem
//
// Descrip: logoff or reboot the system
//
// Returns: none
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
//
//-----------------------------------------------------------------------
void ReStartSystem(UINT uFlags)
{
HANDLE Token = NULL;
ULONG ReturnLength, Index;
PTOKEN_PRIVILEGES NewState = NULL;
PTOKEN_PRIVILEGES OldState = NULL;
BOOL Result;
Result = OpenProcessToken( GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&Token );
if (Result)
{
ReturnLength = 4096;
NewState = (PTOKEN_PRIVILEGES)LocalAlloc(LPTR, ReturnLength);
OldState = (PTOKEN_PRIVILEGES)LocalAlloc(LPTR, ReturnLength);
Result = (BOOL)((NewState != NULL) && (OldState != NULL));
if (Result)
{
Result = GetTokenInformation( Token, // TokenHandle
TokenPrivileges, // TokenInformationClass
NewState, // TokenInformation
ReturnLength, // TokenInformationLength
&ReturnLength ); // ReturnLength
if (Result)
{
//
// Set the state settings so that all privileges are enabled...
//
if (NewState->PrivilegeCount > 0)
{
for (Index = 0; Index < NewState->PrivilegeCount; Index++)
{
NewState->Privileges[Index].Attributes = SE_PRIVILEGE_ENABLED;
}
}
Result = AdjustTokenPrivileges( Token, // TokenHandle
FALSE, // DisableAllPrivileges
NewState, // NewState
ReturnLength, // BufferLength
OldState, // PreviousState
&ReturnLength ); // ReturnLength
if (Result)
{
//ExitWindowsEx(uFlags, 0);
InitiateSystemShutdownEx(NULL,NULL,0,TRUE,TRUE,
SHTDN_REASON_MAJOR_OPERATINGSYSTEM|SHTDN_REASON_MINOR_UPGRADE);
AdjustTokenPrivileges( Token,
FALSE,
OldState,
0,
NULL,
NULL );
}
}
}
}
if (NewState != NULL)
{
LocalFree(NewState);
}
if (OldState != NULL)
{
LocalFree(OldState);
}
if (Token != NULL)
{
CloseHandle(Token);
}
}
//-----------------------------------------------------------------------
//
// Function: DoMessageBox
//
// Descrip: Wrapper for MessageBox
//
// Returns: UINT
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
//
//-----------------------------------------------------------------------
int DoMessageBox(HWND hwndParent, UINT uIdString, UINT uIdCaption, UINT uType)
{
TCHAR szString[MAX_PATH+MAX_PATH];
TCHAR szCaption[MAX_PATH];
szString[0] = szCaption[0] = TEXT('\0');
if (uIdString)
LoadString(g_hInstDll, uIdString, szString, MAX_PATH+MAX_PATH-1);
if (uIdCaption)
LoadString(g_hInstDll, uIdCaption, szCaption, MAX_PATH-1);
return MessageBox(hwndParent, szString, szCaption, uType);
}
//-----------------------------------------------------------------------
//
// Function: DoMessageBox
//
// Descrip: Wrapper for MessageBox
//
// Returns: UINT
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
// Notes:
//
//-----------------------------------------------------------------------
BOOL
Str2KeyPath(
IN LPTSTR String,
OUT PHKEY Data,
OUT LPTSTR *pSubKeyPath
)
{
UINT i;
TCHAR *p,ch;
DWORD cchStrlen;
STRING_TO_DATA InfRegSpecTohKey[] = {
TEXT("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE,
TEXT("HKLM") , HKEY_LOCAL_MACHINE,
TEXT("HKEY_CLASSES_ROOT") , HKEY_CLASSES_ROOT,
TEXT("HKCR") , HKEY_CLASSES_ROOT,
TEXT("HKR") , NULL,
TEXT("HKEY_CURRENT_USER") , HKEY_CURRENT_USER,
TEXT("HKCU") , HKEY_CURRENT_USER,
TEXT("HKEY_USERS") , HKEY_USERS,
TEXT("HKU") , HKEY_USERS,
TEXT("") , NULL
};
PSTRING_TO_DATA Table = InfRegSpecTohKey;
if ( !String || !String[0])
{
*pSubKeyPath = NULL;
*Data = NULL;
return TRUE;
}
for(i=0; Table[i].String[0]; i++)
{
cchStrlen = _tcslen(Table[i].String);
if (_tcslen(String) < cchStrlen)
{
continue;
}
ch = String[cchStrlen];
String[cchStrlen] = 0;
if(!MyStrCmpI(Table[i].String,String))
{
*Data = Table[i].Data;
String[cchStrlen] = ch;
*pSubKeyPath = &(String[cchStrlen+1]);
return(TRUE);
}
String[cchStrlen] = ch;
}
//if we can not find the prefix defined
//we think it's for user registery
//In this case ,we return PHKEY as NULL, and pSubKeyPath = String
*pSubKeyPath = String;
*Data = NULL;
return TRUE;
}
BOOL
HKey2Str(
IN HKEY hKey,
IN LPTSTR pKeyPath,
IN size_t cbKeyPath
)
{
UINT i;
TCHAR *p,ch;
size_t nStrlen;
STRING_TO_DATA InfRegSpecTohKey[] = {
TEXT("HKLM") , HKEY_LOCAL_MACHINE,
TEXT("HKCR") , HKEY_CLASSES_ROOT,
TEXT("HKCU") , HKEY_CURRENT_USER,
TEXT("HKU") , HKEY_USERS,
TEXT("") , NULL
};
PSTRING_TO_DATA Table = InfRegSpecTohKey;
for(i=0; Table[i].Data; i++)
{
if (hKey == Table[i].Data)
{
if (SUCCEEDED(StringCchCopy(pKeyPath,cbKeyPath,Table[i].String)))
{
return TRUE;
}
else
{
return FALSE;
}
}
}
return(FALSE);
}
//-----------------------------------------------------------------------------
//
// Function: Str2KeyPath2
//
// Synopsis: Return the HKEY_xxx value associcated with string value
//
// Returns: REG_xxx value
//
// History: 02/07/2002 Rerkboos Created
//
// Notes: none
//
//-----------------------------------------------------------------------------
BOOL Str2KeyPath2(
LPCTSTR lpHKeyStr,
PHKEY pHKey,
LPCTSTR* pSubKeyPath
)
{
int i;
LPCTSTR lpStart;
STRING_TO_DATA InfRegSpecTohKey[] = {
TEXT("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE,
TEXT("HKLM") , HKEY_LOCAL_MACHINE,
TEXT("HKEY_CLASSES_ROOT") , HKEY_CLASSES_ROOT,
TEXT("HKCR") , HKEY_CLASSES_ROOT,
TEXT("HKR") , NULL,
TEXT("HKEY_CURRENT_USER") , HKEY_CURRENT_USER,
TEXT("HKCU") , HKEY_CURRENT_USER,
TEXT("HKEY_USERS") , HKEY_USERS,
TEXT("HKU") , HKEY_USERS,
TEXT("") , NULL
};
PSTRING_TO_DATA Table = InfRegSpecTohKey;
if (NULL == lpHKeyStr)
{
return FALSE;
}
for(i = 0 ; Table[i].String[0] != TEXT('\0') ; i++)
{
lpStart = _tcsstr(lpHKeyStr, Table[i].String);
if (lpStart == lpHKeyStr)
{
//
// Assign the values back to caller, if caller supply the pointers
//
if (NULL != pHKey)
{
*pHKey = Table[i].Data;
}
if (NULL != pSubKeyPath)
{
lpStart += lstrlen(Table[i].String);
if (*lpStart == TEXT('\0'))
{
*pSubKeyPath = lpStart;
}
else
{
*pSubKeyPath = lpStart + 1;
}
}
return TRUE;
}
}
return FALSE;
}
//-----------------------------------------------------------------------------
//
// Function: Str2REG
//
// Synopsis: Convert the registry type string to REG_xxx value
//
// Returns: REG_xxx value
//
// History: 02/07/2002 Rerkboos Created
//
// Notes: none
//
//-----------------------------------------------------------------------------
DWORD Str2REG(
LPCTSTR lpStrType // String of registry type
)
{
INT nIndex;
struct _STRING_TO_REG
{
TCHAR szStrType[32];
DWORD dwType;
};
// Mapping table from string to REG_xxx value
struct _STRING_TO_REG arrRegEntries[] = {
TEXT("REG_BINARY"), REG_BINARY,
TEXT("REG_DWORD"), REG_DWORD,
TEXT("REG_DWORD_LITTLE_ENDIAN"), REG_DWORD_LITTLE_ENDIAN,
TEXT("REG_DWORD_BIG_ENDIAN"), REG_DWORD_BIG_ENDIAN,
TEXT("REG_EXPAND_SZ"), REG_EXPAND_SZ,
TEXT("REG_LINK"), REG_LINK,
TEXT("REG_MULTI_SZ"), REG_MULTI_SZ,
TEXT("REG_NONE"), REG_NONE,
TEXT("REG_QWORD"), REG_QWORD,
TEXT("REG_QWORD_LITTLE_ENDIAN"), REG_QWORD_LITTLE_ENDIAN,
TEXT("REG_RESOUCE_LIST"), REG_RESOURCE_LIST,
TEXT("REG_SZ"), REG_SZ,
TEXT(""), 0
};
if (lpStrType == NULL)
{
return REG_NONE;
}
for (nIndex = 0 ; arrRegEntries[nIndex].szStrType[0] != TEXT('\0') ; nIndex++)
{
if (MyStrCmpI(lpStrType, arrRegEntries[nIndex].szStrType) == 0)
{
return arrRegEntries[nIndex].dwType;
}
}
return REG_NONE;
}
//*************************************************************
// GetFirstEnvStrLen
//
// Purpose: Get the environment string length if it is at the beginning.
//
// Parameter: lpStr: Input string
//
// Notes: none
//
// History: 3/25/2001 geoffguo created
//*************************************************************
DWORD GetFirstEnvStrLen (LPTSTR lpStr)
{
DWORD dwLen = 0;
DWORD dwSize, i;
TCHAR cTemp;
if (lpStr[0] == L'%')
{
dwSize = lstrlen(lpStr);
for (i = 1; i < dwSize; i++)
if (lpStr[i] == L'%')
break;
if (i < dwSize)
{
cTemp = lpStr[i+1];
lpStr[i+1] = (TCHAR)'\0';
dwLen = ExpandEnvironmentStrings (lpStr, NULL, 0);
lpStr[i+1] = cTemp;
}
}
return dwLen;
}
//*************************************************************
// StringValidationCheck
//
// Purpose: Check the string to see if it is a valid system path
//
// Parameter: lpOriginalStr: Data string to be checked
// lpSearchStr: Search string
// lpSysPath: Point to standard system path
// lpszTailCheck: Point to predefined tail character
// lpAttrib: Folder attribute
// dwStrNum: The number of matching string
//
// Notes: none
//
// History: 3/18/2001 geoffguo created
//*************************************************************
BOOL StringValidationCheck (
LPCTSTR lpOriginalStr,
LPCTSTR lpSearchStr,
LPCTSTR lpSysPath,
LPCTSTR lpTailCheck,
LPDWORD lpAttrib,
DWORD dwStrNum)
{
BOOL bRet = TRUE;
DWORD i, dwLen;
LPTSTR lpOrgStr, lpTemp1, lpTemp2;
if (lpAttrib == NULL || lpSysPath == NULL)
goto Exit;
dwLen = ExpandEnvironmentStrings (lpOriginalStr, NULL, 0);
if (dwLen == 0)
{
bRet = FALSE;
goto Exit;
}
lpOrgStr = calloc (dwLen+1, sizeof(TCHAR));
if (!lpOrgStr)
{
bRet = FALSE;
goto Exit;
}
ExpandEnvironmentStrings (lpOriginalStr, lpOrgStr, dwLen+1);
dwLen = lstrlen(lpSearchStr);
//To avoid hit Documents and Settings wrongly,
//skip the environment variable at the beginning of the string.
lpTemp1 = lpOrgStr + GetFirstEnvStrLen((LPTSTR)lpOriginalStr);
for (i = 0; i < dwStrNum; i++)
{
lpTemp2 = StrStrI(lpTemp1, lpSearchStr);
if (!lpTemp2)
{
bRet = FALSE;
goto Exit1;
}
lpTemp1 = lpTemp2+dwLen;
}
if (*(lpTemp2+dwLen) == *lpTailCheck)
{
bRet = FALSE;
goto Exit1;
}
if (StrStrI(lpOriginalStr, L"\\Device\\HarddiskVolume"))
{
bRet = TRUE;
goto Exit1;
}
switch (*lpAttrib & 0xffff)
{
/*
CSIDL_DESKTOP // <desktop>
CSIDL_INTERNET // Internet Explorer (icon on desktop)
CSIDL_CONTROLS // My Computer\Control Panel
CSIDL_PRINTERS // My Computer\Printers
CSIDL_BITBUCKET // <desktop>\Recycle Bin
CSIDL_MYDOCUMENTS // logical "My Documents" desktop icon
CSIDL_DRIVES // My Computer
CSIDL_NETWORK // Network Neighborhood (My Network Places)
CSIDL_FONTS // windows\fonts
CSIDL_ALTSTARTUP // non localized startup
CSIDL_COMMON_ALTSTARTUP // non localized common startup
CSIDL_WINDOWS // GetWindowsDirectory()
CSIDL_SYSTEM // GetSystemDirectory()
CSIDL_CONNECTIONS // Network and Dial-up Connections
CSIDL_PROFILE // USERPROFILE
CSIDL_SYSTEMX86 // x86 system directory on RISC
CSIDL_PROGRAM_FILESX86 // x86 C:\Program Files on RISC
CSIDL_PROGRAM_FILES_COMMONX86 // x86 Program Files\Common on RISC
CSIDL_RESOURCES // Resource Direcotry
CSIDL_RESOURCES_LOCALIZED // Localized Resource Direcotry
CSIDL_COMMON_OEM_LINKS // Links to All Users OEM specific apps
CSIDL_COMPUTERSNEARME // Computers Near Me (computered from Workgroup membership)
*/
case CSIDL_COMMON_APPDATA: // All Users\Application Data
case CSIDL_COMMON_DESKTOPDIRECTORY: // All Users\Desktop
case CSIDL_COMMON_STARTMENU: // All Users\Start Menu
case CSIDL_COMMON_TEMPLATES: // All Users\Templates
case CSIDL_COMMON_FAVORITES:
case CSIDL_COMMON_STARTUP: // All Users\Start Menu\Startup
case CSIDL_COMMON_MUSIC: // All Users\My Music
case CSIDL_COMMON_PICTURES: // All Users\My Pictures
case CSIDL_COMMON_VIDEO: // All Users\My Video
case CSIDL_COMMON_ADMINTOOLS: // All Users\Start Menu\Programs\Administrative Tools
case CSIDL_COMMON_PROGRAMS: // All Users\Start Menu\Programs
case CSIDL_COMMON_ACCESSORIES: // All Users\Start Menu\Programs\Accessaries
case CSIDL_COMMON_DOCUMENTS: // All Users\Documents
case CSIDL_STARTMENU: // <user name>\Start Menu
case CSIDL_DESKTOPDIRECTORY: // <user name>\Desktop
case CSIDL_NETHOOD: // <user name>\nethood
case CSIDL_TEMPLATES: // <user name>\Templates
case CSIDL_APPDATA: // <user name>\Application Data
case CSIDL_LOCAL_SETTINGS: // <user name>\Local Settings
case CSIDL_PRINTHOOD: // <user name>\PrintHood
case CSIDL_FAVORITES: // <user name>\Favorites
case CSIDL_RECENT: // <user name>\Recent
case CSIDL_SENDTO: // <user name>\SendTo
case CSIDL_COOKIES: // <user name>\Cookies
case CSIDL_HISTORY: // <user name>\History
case CSIDL_PERSONAL: // <user name>\My Documents
case CSIDL_MYMUSIC: // <user name>\My Document\My Music
case CSIDL_MYPICTURES: // <user name>\My Document\My Pictures
case CSIDL_ADMINTOOLS: // <user name>\Start Menu\Programs\Administrative Tools
case CSIDL_PROGRAMS: // <user name>\Start Menu\Programs
case CSIDL_STARTUP: // <user name>\Start Menu\Programs\Startup
case CSIDL_ACCESSORIES: // <user name>\Start Menu\Programs\Accessaries
case CSIDL_LOCAL_APPDATA: // <user name>\Local Settings\Applicaiton Data (non roaming)
case CSIDL_INTERNET_CACHE: // <user name>\Local Settings\Temporary Internet Files
case CSIDL_PROGRAM_FILES_COMMON: // C:\Program Files\Common
case CSIDL_PF_ACCESSORIES: // C:\Program Files\Accessaries
case CSIDL_PROGRAM_FILES: // C:\Program Files
case CSIDL_COMMON_COMMONPROGRAMFILES_SERVICES: //for %CommonProgramFiles%\services
case CSIDL_COMMON_PROGRAMFILES_ACCESSARIES: //for %ProgramFiles%\accessaries
case CSIDL_COMMON_PROGRAMFILES_WINNT_ACCESSARIES: //for %ProgramFiles%\Windows NT\accessaries
case CSIDL_MYVIDEO: // "My Videos" folder
case CSIDL_CDBURN_AREA: // USERPROFILE\Local Settings\Application Data\Microsoft\CD Burning
case CSIDL_COMMON_ACCESSORIES_ACCESSIBILITY:
case CSIDL_COMMON_ACCESSORIES_ENTERTAINMENT:
case CSIDL_COMMON_ACCESSORIES_SYSTEM_TOOLS:
case CSIDL_COMMON_ACCESSORIES_COMMUNICATIONS:
case CSIDL_COMMON_ACCESSORIES_MS_SCRIPT_DEBUGGER:
case CSIDL_COMMON_ACCESSORIES_GAMES:
case CSIDL_COMMON_WINDOWSMEDIA:
case CSIDL_COMMON_COVERPAGES:
case CSIDL_COMMON_RECEIVED_FAX:
case CSIDL_COMMON_SENT_FAX:
case CSIDL_COMMON_FAX:
case CSIDL_FAVORITES_LINKS:
case CSIDL_FAVORITES_MEDIA:
case CSIDL_ACCESSORIES_ACCESSIBILITY:
case CSIDL_ACCESSORIES_SYSTEM_TOOLS:
case CSIDL_ACCESSORIES_ENTERTAINMENT:
case CSIDL_ACCESSORIES_COMMUNICATIONS:
case CSIDL_ACCESSORIES_COMMUNICATIONS_HYPERTERMINAL:
case CSIDL_PROFILES_DIRECTORY:
case CSIDL_USERNAME_IN_USERPROFILE:
case CSIDL_UAM_VOLUME:
case CSIDL_COMMON_SHAREDTOOLS_STATIONERY:
case CSIDL_NETMEETING_RECEIVED_FILES:
case CSIDL_COMMON_NETMEETING_RECEIVED_FILES:
case CSIDL_COMMON_ACCESSORIES_COMMUNICATIONS_FAX:
case CSIDL_FAX_PERSONAL_COVER_PAGES:
case CSIDL_FAX:
bRet = ReverseStrCmp(lpTemp2, lpSysPath);
break;
default:
break;
}
Exit1:
free (lpOrgStr);
Exit:
return bRet;
}
//*************************************************************
// ReplaceMultiMatchInString
//
// Purpose: Replace the string at multiple place in data string
//
// Parameter: lpOldStr: Data string to be checked
// lpNewStr: Output string buffer
// cbNewStr: Size of output string buffer
// dwMaxMatchNum: Max posible match number
// lpRegStr: String and attribute table
// bStrCheck: True -- do it, or False -- skip it
//
// Notes: none
//
// History: 12/10/2001 geoffguo created
//*************************************************************
BOOL ReplaceMultiMatchInString(
LPTSTR lpOldStr,
LPTSTR lpNewStr,
size_t cbNewStr,
DWORD dwMaxMatchNum,
PREG_STRING_REPLACE lpRegStr,
LPDWORD pAttrib,
BOOL bStrCheck)
{
BOOL bRet = FALSE;
LPCTSTR lpSearchStr;
LPCTSTR lpReplaceStr;
LPTSTR lpMiddleStr;
LPCTSTR lpPath;
LPDWORD lpAttrib;
TCHAR cNonChar = L'\xFFFF';
TCHAR cSpaceChar = L' ';
TCHAR cDotChar = L'.';
TCHAR cRightChar;
DWORD cchMiddleStr;
cchMiddleStr = lstrlen(lpOldStr) + lpRegStr->cchMaxStrLen * dwMaxMatchNum;
lpMiddleStr = (LPTSTR) calloc(cchMiddleStr, sizeof(TCHAR));
if (!lpMiddleStr)
{
goto Exit;
}
if (FAILED(StringCchCopy(lpMiddleStr, cchMiddleStr,lpOldStr)))
{
goto Exit;
}
lpSearchStr = lpRegStr->lpSearchString;
lpReplaceStr = lpRegStr->lpReplaceString;
lpAttrib = lpRegStr->lpAttrib;
if (lpRegStr->lpFullStringList)
{
lpPath = lpRegStr->lpFullStringList;
}
else
{
lpPath = NULL;
}
while (*lpSearchStr && *lpReplaceStr)
{
if (bStrCheck)
{
if (*lpAttrib == CSIDL_COMMON_DOCUMENTS)
{
cRightChar = cSpaceChar;
} else if (*lpAttrib == CSIDL_USERNAME_IN_USERPROFILE)
{
cRightChar = cDotChar;
}
else
{
cRightChar = cNonChar;
}
}
if(ReplaceString(lpMiddleStr, lpSearchStr, lpReplaceStr, lpNewStr, cchMiddleStr, &cRightChar, lpPath, lpAttrib, bStrCheck))
{
if (bStrCheck)
{
*pAttrib |= *lpAttrib;
}
bRet = TRUE;
}
if (FAILED(StringCchCopy(lpMiddleStr, cchMiddleStr,lpNewStr)))
goto Exit;
lpSearchStr += lstrlen(lpSearchStr) + 1;
lpReplaceStr += lstrlen(lpReplaceStr) + 1;
if (lpPath)
{
lpPath += lstrlen(lpPath) + 1;
}
if (lpAttrib)
{
lpAttrib++;
}
}
Exit:
if(lpMiddleStr)
{
free(lpMiddleStr);
}
return bRet;
}
//-----------------------------------------------------------------------------
//
// Function: ComputeLocalProfileName
//
// Synopsis: Constructs the pathname of the local profile for user.
// It will attempt to create user profile directory using
// username. If the directory exists, it will append a counter
// after users name e.g. %documentsettings%\username.001
//
// Returns: TRUE if succeeded, FALSE otherwise
//
// History: 02/07/2002 Rerkboos Created
//
// Notes: none
//
//-----------------------------------------------------------------------------
BOOL ComputeLocalProfileName(
LPCTSTR lpOldUserName, // Old user name
LPCTSTR lpNewUserName, // New user name
LPTSTR lpNewProfilePath, // Output buffer store new profile path
size_t cchNewProfilePath, // Size of profile path buffer (in WCHAR)
UINT nRegType // Read the output in REG_SZ or REG_EXPAND_SZ
)
{
HANDLE hFile;
TCHAR szProfilePath[MAX_PATH];
TCHAR szUserProfilePath[MAX_PATH];
TCHAR szExpUserProfilePath[MAX_PATH];
TCHAR szComputerName[16];
DWORD cbSize;
DWORD dwType;
LONG lRet;
DWORD cchSize;
size_t nCounter;
HKEY hKey;
HRESULT hr;
WIN32_FIND_DATA fd;
if (lpOldUserName == NULL || lpOldUserName[0] == TEXT('\0') ||
lpNewUserName == NULL || lpNewUserName[0] == TEXT('\0') ||
lpNewProfilePath == NULL)
{
return FALSE;
}
//
// If user name does not change, return the current user's profile path
//
if (MyStrCmpI(lpOldUserName, lpNewUserName) == 0)
{
hr = GetSetUserProfilePath(lpOldUserName,
lpNewProfilePath,
cchNewProfilePath,
PROFILE_PATH_READ,
nRegType);
if (SUCCEEDED(hr))
{
return TRUE;
}
else
{
return FALSE;
}
}
//
// Get ProfilesDirectory from registry
//
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
g_cszProfileList,
0,
KEY_READ,
&hKey)
== ERROR_SUCCESS)
{
cbSize = sizeof(szProfilePath);
lRet = RegQueryValueEx(hKey,
PROFILES_DIRECTORY,
NULL,
&dwType,
(LPBYTE) szProfilePath,
&cbSize);
RegCloseKey(hKey);
if (lRet != ERROR_SUCCESS)
{
DPF(dlError,
TEXT("ComputeLocalProfileName: Unable to query reg value <%s>"),
PROFILES_DIRECTORY);
return FALSE;
}
}
else
{
DPF(dlError,
TEXT("ComputeLocalProfileName: Unable to open reg key <%s>"),
g_cszProfileList);
return FALSE;
}
// Compose a new user profile directory
hr = StringCchPrintf(szUserProfilePath,
ARRAYSIZE(szUserProfilePath),
TEXT("%s\\%s"),
szProfilePath,
lpNewUserName);
if ( FAILED(hr) )
{
return FALSE;
}
// Profile path still contains environment strings, need to expand it
ExpandEnvironmentStrings(szUserProfilePath,
szExpUserProfilePath,
ARRAYSIZE(szExpUserProfilePath));
// Does this directory exist?
hFile = FindFirstFile(szExpUserProfilePath, &fd);
if (INVALID_HANDLE_VALUE == hFile)
{
//
// Directory does not exist, use this name
//
hr = StringCchCopy(lpNewProfilePath, cchNewProfilePath, szUserProfilePath);
if ( FAILED(hr) )
{
return FALSE;
}
return TRUE;
}
else
{
//
// Directory exists, try different name
//
FindClose(hFile);
// Try appending username with computer Name
cchSize = ARRAYSIZE(szComputerName);
GetComputerName(szComputerName, &cchSize);
hr = StringCchPrintf(szUserProfilePath,
ARRAYSIZE(szUserProfilePath),
TEXT("%s\\%s.%s"),
szProfilePath,
lpNewUserName,
szComputerName);
if ( FAILED(hr) )
{
return FALSE;
}
// Profile path still contains environment strings, need to expand it
ExpandEnvironmentStrings(szUserProfilePath,
szExpUserProfilePath,
ARRAYSIZE(szExpUserProfilePath));
// Does the new directory name exist?
hFile = FindFirstFile(szExpUserProfilePath, &fd);
if (INVALID_HANDLE_VALUE == hFile)
{
// Directory does not exist, use this one
hr = StringCchCopy(lpNewProfilePath, cchNewProfilePath, szUserProfilePath);
if ( FAILED(hr) )
{
return FALSE;
}
return TRUE;
}
else
{
//
// This directory also exists
//
FindClose(hFile);
for (nCounter = 0 ; nCounter < 1000 ; nCounter++)
{
// Try appending counter after user name
hr = StringCchPrintf(szUserProfilePath,
ARRAYSIZE(szUserProfilePath),
TEXT("%s\\%s.%.3d"),
szProfilePath,
lpNewUserName,
nCounter);
if ( FAILED(hr) )
{
return FALSE;
}
// Profile path still contains environment strings, need to expand it
ExpandEnvironmentStrings(szUserProfilePath,
szExpUserProfilePath,
ARRAYSIZE(szExpUserProfilePath));
// Does this directory name exist?
hFile = FindFirstFile(szExpUserProfilePath, &fd);
if (INVALID_HANDLE_VALUE == hFile)
{
// Directory does not exist, use this one
hr = StringCchCopy(lpNewProfilePath,
cchNewProfilePath,
szUserProfilePath);
if ( FAILED(hr) )
{
return FALSE;
}
return TRUE;
}
else
{
// Directory exists, keep finding...
FindClose(hFile);
}
}
}
}
// If we reach here, we could not find a new profile directory for this user
return FALSE;
}
//-----------------------------------------------------------------------------
//
// Function: UpdateProgress
//
// Synopsis: Simple progress clock, display the progress during
// long operation.
//
// Returns: none.
//
// History: 02/07/2002 Rerkboos Created
//
// Notes: none
//
//-----------------------------------------------------------------------------
void UpdateProgress()
{
static unsigned short n;
const TCHAR clock[] = TEXT("-\\|/");
wprintf(TEXT("%lc\r"), clock[n]);
n++;
n %= 4;
}
//-----------------------------------------------------------------------//
//
// GetMaxStrLen()
//
// Get Maximum searching strings and replace strings length for string
// buffer memery allocation.
//
// lpRegStr: Input parameter structure
//
// Notes: none
//
// History: 12/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
DWORD GetMaxStrLen (
PREG_STRING_REPLACE lpRegStr)
{
DWORD dwLen = 0;
DWORD dwMaxLen;
LPTSTR lpStr;
lpStr = lpRegStr->lpReplaceString;
dwMaxLen = 0;
while (*lpStr)
{
dwLen = lstrlen(lpStr);
//dwMaxLen is the max-length in replacement multi-strings
if (dwLen > dwMaxLen)
dwMaxLen = dwLen;
lpStr += dwLen + 1;
}
lpStr = lpRegStr->lpSearchString;
while (*lpStr)
{
dwLen = lstrlen(lpStr);
//dwMaxLen is the max-length in search and replacement multi-strings
if (dwLen > dwMaxLen)
dwMaxLen = dwLen;
lpStr += dwLen + 1;
}
return dwMaxLen;
}
//-----------------------------------------------------------------------//
//
// AddNodeToList()
//
// lpVal: The node needed to add.
// lpValList: The head of the list.
//
// Notes: none
//
// History: 12/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
DWORD AddNodeToList (
PVALLIST lpVal,
PVALLIST *lpValList)
{
DWORD nResult = ERROR_SUCCESS;
PVALLIST lpTemp;
if (!*lpValList)
{
*lpValList = lpVal;
} else
{
lpTemp = *lpValList;
while (lpTemp->pvl_next)
lpTemp = lpTemp->pvl_next;
lpTemp->pvl_next = lpVal;
}
return nResult;
}
//-----------------------------------------------------------------------//
//
// RemoveValueList()
//
// lpValList: The head of the list.
//
// Notes: none
//
// History: 12/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
DWORD RemoveValueList (
PVALLIST *lpValList)
{
DWORD nResult = ERROR_SUCCESS;
PVALLIST lpTemp, lpDel;
if (*lpValList)
{
lpTemp = *lpValList;
while (lpTemp)
{
lpDel = lpTemp;
lpTemp = lpTemp->pvl_next;
if (lpDel->ve.ve_valuename)
free (lpDel->ve.ve_valuename);
if (lpDel->ve.ve_valueptr)
free ((LPBYTE)(lpDel->ve.ve_valueptr));
if (lpDel->lpPre_valuename)
free (lpDel->lpPre_valuename);
free (lpDel);
}
}
return nResult;
}
//-----------------------------------------------------------------------//
//
// FreeStrList()
//
// lpStrList: The head of the list.
//
//
// Notes: none
//
// History: 12/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
void FreeStrList (
PSTRLIST lpStrList)
{
if (lpStrList->pst_next)
FreeStrList (lpStrList->pst_next);
if (lpStrList->lpstr)
free (lpStrList->lpstr);
free (lpStrList);
}
//-----------------------------------------------------------------------//
//
// GetMaxMatchNum()
//
// Get maximum string match number.
//
// lpDataStr: Search string
// lpRegStr: Input parameter structure
//
// Notes: none
//
// History: 12/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
DWORD
GetMaxMatchNum (
LPTSTR lpDataStr,
PREG_STRING_REPLACE lpRegStr)
{
DWORD dwMatchNum, dwLen;
LPTSTR lpTemp;
LPTSTR lpSearchStr;
LPTSTR lpFound;
lpSearchStr = lpRegStr->lpSearchString;
dwMatchNum = 0;
while (*lpSearchStr)
{
lpTemp = lpDataStr;
while (lpFound = StrStrI(lpTemp, lpSearchStr))
{
dwMatchNum++;
lpTemp = lpFound + 1;
}
dwLen = lstrlen(lpSearchStr);
lpSearchStr += dwLen + 1;
}
return dwMatchNum;
}
//-----------------------------------------------------------------------//
//
// ReplaceSingleString()
//
// DESCRIPTION:
// Analize a single string and replace localized string to English.
//
// lpOldDataStr: String data
// dwType: Type of string
// lpRegStr: Input parameter structure
// lpFullKey: Full sub-key path
//
// Notes: none
//
// History: 11/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
LPTSTR ReplaceSingleString (
LPTSTR lpOldDataStr,
DWORD dwType,
PREG_STRING_REPLACE lpRegStr,
LPTSTR lpFullKey,
LPDWORD pAttrib,
BOOL bStrChk)
{
DWORD dwMatchNum;
LPTSTR lpNewDataStr = NULL;
size_t cbNewDataStr;
if (!lpOldDataStr)
goto Exit;
dwMatchNum = GetMaxMatchNum (lpOldDataStr, lpRegStr);
if (dwMatchNum > 0)
{
if (dwType != REG_DWORD && *lpOldDataStr)
{
cbNewDataStr = lstrlen(lpOldDataStr) + lpRegStr->cchMaxStrLen * dwMatchNum;
lpNewDataStr = (LPTSTR) calloc(cbNewDataStr, sizeof(TCHAR));
if (!lpNewDataStr)
{
DPF (dlError, L"ReplaceSingleString: No enough memory");
goto Exit;
}
if (!ReplaceMultiMatchInString(lpOldDataStr, lpNewDataStr, cbNewDataStr, dwMatchNum, lpRegStr, pAttrib, bStrChk))
{
free (lpNewDataStr);
lpNewDataStr = NULL;
}
}
}
Exit:
return lpNewDataStr;
}
//-----------------------------------------------------------------------//
//
// ReplaceValueSettings()
//
// Rename value setting based on input parameter
//
// szUserName: User name
// lpOldDataStr: String value data
// dwSize: Size of string data
// lpOldValueName:Value name
// dwType: Type of string
// lpRegStr: Input parameter structure
// lpValList: Updated value list
// lpFullKey: Full sub-key path
//
// Notes: none
//
// History: 11/10/2001 geoffguo created
//
//-----------------------------------------------------------------------//
HRESULT ReplaceValueSettings (
LPTSTR szUserName,
LPTSTR lpOldDataStr,
DWORD dwSize,
LPTSTR lpOldValueName,
DWORD dwType,
PREG_STRING_REPLACE lpRegStr,
PVALLIST *lpValList,
LPTSTR lpFullKey,
BOOL bStrChk)
{
BOOL bValueName = FALSE;
BOOL bValueData = FALSE;
HRESULT hResult = S_OK;
DWORD dwOutputSize = 0, dwMatchNum = 0;
LPTSTR lpNewDataStr = NULL;
LPTSTR lpNewValueName = NULL;
LPTSTR lpOutputValueName;
LPTSTR lpEnd;
LPBYTE lpOutputData;
PVALLIST lpVal = NULL;
PSTRLIST lpStrList = NULL;
PSTRLIST lpLastList = NULL;
PSTRLIST lpTempList = NULL;
size_t cbPre_valuename;
DWORD dwAttrib = 0;
lpStrList = (PSTRLIST) calloc(sizeof(STRLIST), 1);
lpLastList = lpStrList;
if (!lpLastList)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings1: No enough memory");
goto Exit;
}
if ( (dwType & 0xffff)== REG_MULTI_SZ)
{
lpEnd = lpOldDataStr;
while(lpEnd < (lpOldDataStr + dwSize/sizeof(TCHAR)))
{
if(*lpEnd == (TCHAR)'\0')
{
//empty string
dwOutputSize += sizeof(TCHAR);
lpEnd++;
}
else
{
lpNewDataStr = ReplaceSingleString (
lpEnd,
dwType,
lpRegStr,
lpFullKey,
&dwAttrib,
bStrChk);
if (lpNewDataStr)
{
lpLastList->lpstr = lpNewDataStr;
bValueData = TRUE;
}
else
{
size_t cbBufLen = lstrlen(lpEnd)+1;
lpLastList->lpstr = calloc(cbBufLen, sizeof(TCHAR));
if (!lpLastList->lpstr)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings2: No enough memory");
goto Exit;
}
hResult = StringCchCopy(lpLastList->lpstr, cbBufLen,lpEnd);
if (FAILED(hResult))
{
DPF (dlError, L"ReplaceValueSettings: buffer too small for %s",lpEnd);
goto Exit;
}
}
dwOutputSize += (lstrlen(lpLastList->lpstr)+1)*sizeof(TCHAR);
lpEnd += lstrlen(lpEnd)+1;
}
lpLastList->pst_next = (PSTRLIST) calloc(sizeof(STRLIST), 1);
if (!lpLastList->pst_next)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings3: No enough memory");
goto Exit;
}
lpLastList->pst_next->pst_prev = lpLastList;
lpLastList = lpLastList->pst_next;
lpLastList->pst_next = NULL;
lpLastList->lpstr = NULL;
}
if (lpLastList != lpStrList)
{
lpLastList = lpLastList->pst_prev;
free (lpLastList->pst_next);
lpLastList->pst_next = NULL;
}
}
else
{
lpNewDataStr = ReplaceSingleString (
lpOldDataStr,
dwType,
lpRegStr,
lpFullKey,
&dwAttrib,
bStrChk);
if (lpNewDataStr)
{
lpLastList->lpstr = lpNewDataStr;
bValueData = TRUE;
}
else
{
lpLastList->lpstr = calloc(dwSize+sizeof(TCHAR), 1);
if (!lpLastList->lpstr)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings4: No enough memory");
goto Exit;
}
hResult = StringCbCopy(lpLastList->lpstr, dwSize+sizeof(TCHAR), lpOldDataStr);
if (FAILED(hResult))
{
goto Exit;
}
}
lpLastList->pst_next = NULL;
dwOutputSize = (lstrlen(lpLastList->lpstr)+1)*sizeof(TCHAR);
}
if (lpOldValueName)
dwMatchNum = GetMaxMatchNum (lpOldValueName, lpRegStr);
else
dwMatchNum = 0;
if (dwMatchNum > 0)
{
if (*lpOldValueName)
{
size_t cbNewValueName = lstrlen(lpOldValueName) + lpRegStr->cchMaxStrLen * dwMatchNum;
lpNewValueName = (LPTSTR) calloc(cbNewValueName, sizeof(TCHAR));
if (!lpNewValueName)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings5: No enough memory");
goto Exit;
}
bValueName = ReplaceMultiMatchInString(lpOldValueName, lpNewValueName,cbNewValueName, dwMatchNum, lpRegStr, &dwAttrib, bStrChk);
}
}
if (bValueData || bValueName)
{
lpVal = (PVALLIST) calloc(sizeof(VALLIST), 1);
if (!lpVal)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings6: No enough memory");
goto Exit;
}
if (bValueData)
{
lpVal->val_type |= REG_CHANGE_VALUEDATA;
}
if (bValueName)
{
lpOutputValueName = lpNewValueName;
lpVal->val_type |= REG_CHANGE_VALUENAME;
} else
lpOutputValueName = lpOldValueName;
if (lpOutputValueName)
{
HRESULT hr;
size_t cbValname = lstrlen(lpOutputValueName) + 1;
lpVal->ve.ve_valuename = (LPTSTR) calloc(cbValname, sizeof(TCHAR));
if (!lpVal->ve.ve_valuename)
{
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings7: No enough memory");
goto Exit;
}
//We calculte the buffer for lpVal->lpPre_valuename, so here StringCchCopy should be
//always success, assinging return value just make prefast happy
hr = StringCchCopy (lpVal->ve.ve_valuename, cbValname, lpOutputValueName);
} else
lpVal->ve.ve_valuename = NULL;
lpVal->ve.ve_valueptr = (DWORD_PTR) calloc(dwOutputSize, 1);
if (!lpVal->ve.ve_valueptr)
{
free (lpVal->ve.ve_valuename);
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings8: No enough memory");
goto Exit;
}
if (lpOldValueName)
{
cbPre_valuename = lstrlen(lpOldValueName)+1;
lpVal->lpPre_valuename = (LPTSTR)calloc(cbPre_valuename, sizeof(TCHAR));
if (!lpVal->lpPre_valuename)
{
free (lpVal->ve.ve_valuename);
free ((LPBYTE)(lpVal->ve.ve_valueptr));
hResult = E_OUTOFMEMORY;
DPF (dlError, L"ReplaceValueSettings9: No enough memory");
goto Exit;
}
} else
lpVal->lpPre_valuename = NULL;
lpVal->val_attrib = dwAttrib;
lpOutputData = (LPBYTE)(lpVal->ve.ve_valueptr);
lpTempList = lpStrList;
do {
if (lpTempList->lpstr)
memcpy (lpOutputData, (LPBYTE)lpTempList->lpstr, (lstrlen(lpTempList->lpstr)+1)*sizeof(TCHAR));
else
{
lpOutputData[0] = (BYTE)0;
lpOutputData[1] = (BYTE)0;
}
lpOutputData += (lstrlen((LPTSTR)lpOutputData)+1)*sizeof(TCHAR);
lpTempList = lpTempList->pst_next;
} while (lpTempList != NULL);
if (lpOldValueName)
{
HRESULT hr;
//We calculte the buffer for lpVal->lpPre_valuename, so here StringCchCopy should be
//always success, assinging return value just make prefast happy
hr = StringCchCopy(lpVal->lpPre_valuename, cbPre_valuename, lpOldValueName);
}
lpVal->ve.ve_valuelen = dwOutputSize;
lpVal->ve.ve_type = dwType;
lpVal->pvl_next = NULL;
lpVal->md.dwMDIdentifier = 0x00FFFFFF;
AddNodeToList(lpVal, lpValList);
}
else
hResult = S_OK;
Exit:
if (lpStrList)
{
FreeStrList (lpStrList);
}
if(lpNewValueName)
{
free(lpNewValueName);
}
return hResult;
}
//-----------------------------------------------------------------------
//
// Function: IsAdmin
//
// Descrip: Check whether current user is in administrators group
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes:
//
//-----------------------------------------------------------------------
BOOL IsAdmin()
{
// get the administrator sid
PSID psidAdministrators;
SID_IDENTIFIER_AUTHORITY siaNtAuthority = SECURITY_NT_AUTHORITY;
BOOL bIsAdmin = FALSE;
if(!AllocateAndInitializeSid(&siaNtAuthority, 2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&psidAdministrators))
{
return FALSE;
}
// on NT5, we should use the CheckTokenMembershipAPI to correctly handle cases where
// the Adiminstrators group might be disabled. bIsAdmin is BOOL for
// CheckTokenMembership checks if the SID is enabled in the token. NULL for
// the token means the token of the current thread. Disabled groups, restricted
// SIDS, and SE_GROUP_USE_FOR_DENY_ONLY are all considered. If the function
// returns false, ignore the result.
if (!CheckTokenMembership(NULL, psidAdministrators, &bIsAdmin))
{
bIsAdmin = FALSE;
}
FreeSid(psidAdministrators);
return bIsAdmin;
}
//-----------------------------------------------------------------------
//
// Function: DoesUserHavePrivilege
//
// Descrip:
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz copied from NTSETUP
//
// Routine Description:
// This routine returns TRUE if the caller's process has
// the specified privilege. The privilege does not have
// to be currently enabled. This routine is used to indicate
// whether the caller has the potential to enable the privilege.
// Caller is NOT expected to be impersonating anyone and IS
// expected to be able to open their own process and process
// token.
// Arguments:
// Privilege - the name form of privilege ID (such as
// SE_SECURITY_NAME).
//Return Value:
// TRUE - Caller has the specified privilege.
// FALSE - Caller does not have the specified privilege.
BOOL
DoesUserHavePrivilege(
PTSTR PrivilegeName
)
{
HANDLE Token;
ULONG BytesRequired;
PTOKEN_PRIVILEGES Privileges;
BOOL b;
DWORD i;
LUID Luid;
//
// Open the process token.
//
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&Token)) {
return(FALSE);
}
b = FALSE;
Privileges = NULL;
//
// Get privilege information.
//
if(!GetTokenInformation(Token,TokenPrivileges,NULL,0,&BytesRequired)
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
&& (Privileges = (PTOKEN_PRIVILEGES)LocalAlloc(LPTR,BytesRequired))
&& GetTokenInformation(Token,TokenPrivileges,Privileges,BytesRequired,&BytesRequired)
&& LookupPrivilegeValue(NULL,PrivilegeName,&Luid)) {
//
// See if we have the requested privilege
//
for(i=0; i<Privileges->PrivilegeCount; i++) {
if(!memcmp(&Luid,&Privileges->Privileges[i].Luid,sizeof(LUID))) {
b = TRUE;
break;
}
}
}
//
// Clean up and return.
//
if(Privileges) {
LocalFree((HLOCAL)Privileges);
}
CloseHandle(Token);
return(b);
}
//-----------------------------------------------------------------------
//
// Function: EnablePrivilege
//
// Descrip:
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz copied from NTSETUP
//
// Notes:
//
//-----------------------------------------------------------------------
BOOL
EnablePrivilege(
IN PTSTR PrivilegeName,
IN BOOL Enable
)
{
HANDLE Token;
BOOL b;
TOKEN_PRIVILEGES NewPrivileges;
LUID Luid;
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&Token)) {
return(FALSE);
}
if(!LookupPrivilegeValue(NULL,PrivilegeName,&Luid)) {
CloseHandle(Token);
return(FALSE);
}
NewPrivileges.PrivilegeCount = 1;
NewPrivileges.Privileges[0].Luid = Luid;
NewPrivileges.Privileges[0].Attributes = Enable ? SE_PRIVILEGE_ENABLED : 0;
b = AdjustTokenPrivileges(
Token,
FALSE,
&NewPrivileges,
0,
NULL,
NULL
);
CloseHandle(Token);
return(b);
}
//-----------------------------------------------------------------------
//
// Function: GetCurrentControlSet
//
// Descrip:
//
// Returns: INT
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: the HKLM\SYSTEM\CurrentControlSet is actually is copy of
// HKLM\SYSTEM\ControlSetXXX, the XXX is specified in
// HKLM\SYSTEM\Select\Current . This API returns this XXX,
// if it failed , it returns -1
//
//-----------------------------------------------------------------------
INT GetCurrentControlSet()
{
DWORD dwErr;
DWORD dwCurrrent,dwSize;
HKEY hKey = NULL;
dwErr = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\Select"),
0,
KEY_READ,
&hKey );
// if failed to open registry key , return -1
if( dwErr != ERROR_SUCCESS )
{
dwCurrrent = -1;
hKey = NULL;
goto Cleanup;
}
dwSize = sizeof(DWORD);
dwErr = RegQueryValueEx(hKey,
TEXT("Current"),
NULL, //reserved
NULL, //type
(LPBYTE) &dwCurrrent,
&dwSize );
if(dwErr != ERROR_SUCCESS)
{
dwCurrrent = -1;
goto Cleanup;
}
//Notes:here we succeeded in geting the value, do we need to do
//a registry open to make sure the actual HKLM\SYSTEM\ControlSetXXX
//is there
Cleanup:
if (hKey)
{
RegCloseKey(hKey);
}
return dwCurrrent;
}
//-----------------------------------------------------------------------
//
// Function: ReplaceCurrentControlSet
//
// Descrip:
//
// Returns: BOOL
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: replace CurrentControlSet with ControlSetXXX
//
//-----------------------------------------------------------------------
HRESULT ReplaceCurrentControlSet(LPTSTR strList)
{
INT nCurrent;
TCHAR szCurrCrtlSet[MAX_PATH];
DWORD dwStrLen;
TCHAR *lpTmpBuf;
HRESULT hr;
//If the string list is empty .we just return
dwStrLen = MultiSzLen(strList);
if (dwStrLen < 3)
{
return S_OK;
}
//If there is no CurrentControlSet in the String list, just return
if (!MultiSzSubStr (TEXT("CurrentControlSet"),strList))
{
return S_FALSE;
}
//Get the CurrentControlSet #, this is specified in registry , detail see GetCurrentControlSet
nCurrent = GetCurrentControlSet();
// if we can not get, just bail out
if (nCurrent < 0)
{
return HRESULT_FROM_WIN32(GetLastError());
}
//This indeed will never fail, unless this registry value has been tamnpered,
// we will bail out then
if (FAILED(hr = StringCchPrintf(szCurrCrtlSet,MAX_PATH,TEXT("ControlSet%03d\0"),nCurrent)))
{
return hr;
}
//Get a Temp buffer for saving replaced string, dwStrLen already includes the last NULL
// in this multi-sz string
lpTmpBuf = malloc( dwStrLen * sizeof(TCHAR) );
if (!lpTmpBuf)
{
return E_OUTOFMEMORY;
}
memmove((BYTE*)lpTmpBuf,(BYTE*)strList,dwStrLen * sizeof(TCHAR));
hr = StringMultipleReplacement(lpTmpBuf,TEXT("CurrentControlSet\0"),szCurrCrtlSet,strList,dwStrLen);
if (FAILED(hr))
{
memmove(strList,lpTmpBuf,dwStrLen * sizeof(TCHAR));
}
free(lpTmpBuf);
return hr;
}
//-----------------------------------------------------------------------
//
// Function: UnProtectSFPFiles
//
// Descrip:
//
// Returns: DWORD
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes: Unprotect a list of files specified by multiSzFileList which
// is multi-sz string. pdwResult is an array of DWORD which will
// be specifed whether success or failure of each unprotect action
// if can be NULL if called does not care this information.
// the retuan value is BOOL,if is FALSE, it means starting SFP
// service failed.
//
//-----------------------------------------------------------------------
BOOL UnProtectSFPFiles(
IN LPTSTR multiSzFileList,
IN OUT LPDWORD pdwResult)
{
HANDLE hSfp = INVALID_HANDLE_VALUE;
DWORD bResult = TRUE;
LPTSTR lp;
LPDWORD lpdw;
DWORD dw;
//If the no string there, we just return success
if (!multiSzFileList)
{
goto Cleanup;
}
//Connect to SFP service
hSfp = SfcConnectToServer( NULL );
if (INVALID_HANDLE_VALUE == hSfp)
{
bResult = FALSE;
goto Cleanup;
}
//lp points to Path while lpdw points to the result array
lp = multiSzFileList;
lpdw = pdwResult;
while (*lp)
{
DWORD dwResult = NO_ERROR;
//if the file pointed by lp is in the file protection list
// unprotect it and put the return value to array
if (SfcIsFileProtected(hSfp,lp))
{
dwResult = SfcFileException(hSfp,lp, SFC_ACTION_ADDED | SFC_ACTION_REMOVED | SFC_ACTION_MODIFIED
| SFC_ACTION_RENAMED_OLD_NAME |SFC_ACTION_RENAMED_NEW_NAME);
}
else
{
dw = GetLastError();
}
if (lpdw)
{
*lpdw = dwResult;
lpdw++;
}
lp = lp + lstrlen(lp) + 1;
}
Cleanup:
if (hSfp)
{
SfcClose(hSfp);
}
return bResult;
}
/*++
Routine Description:
This routine returns TRUE if the caller's process has
the specified privilege. The privilege does not have
to be currently enabled. This routine is used to indicate
whether the caller has the potential to enable the privilege.
Caller is NOT expected to be impersonating anyone and IS
expected to be able to open their own process and process
token.
Arguments:
lpDir - the direcory which is to be backuped
lpBackupDir - the backup directory name we got , it should be %lpDir%.CLMTxxx
- where xxx is 000,001,...
cChBackupDir is the lpBackupDir's size in TCHAR
bFindExist - if this is TRUE , it means the lpDir has already been backuiped
- and caller wants to get that dir name
- if this is FALSE , it means the caller want to find an appriate backup
- dir name for lpDir
Return Value:
TRUE - The directory name found.
FALSE - The directory can not be found
--*/
BOOL GetBackupDir(
LPCTSTR lpDir,
LPTSTR lpBackupDir,
size_t cChBackupDir,
BOOL bFindExist)
{
BOOL bResult = FALSE;
HRESULT hr;
int nCounter;
HANDLE hFile;
WIN32_FIND_DATA fd;
if (!lpDir && !lpDir[0])
{
goto Exit;
}
if (!lpBackupDir)
{
goto Exit;
}
for (nCounter = 0 ; nCounter < 1000 ; nCounter++)
{
// Try appending counter after
TCHAR szCounter[10];
_itot(nCounter,szCounter,10);
hr = StringCchPrintf(lpBackupDir,cChBackupDir,
TEXT("%s.%s%03s"),lpDir,TEXT("clmt"),szCounter);
if ( FAILED(hr) )
{
goto Exit;
}
// Does this directory name exist?
hFile = FindFirstFile(lpBackupDir, &fd);
if (INVALID_HANDLE_VALUE == hFile)
{
// Directory does not exist, use this one
FindClose(hFile);
break;
}
else
{ // Directory exists, keep finding...
FindClose(hFile);
}
}//end of for nCounter
if (nCounter < 1000)
{
//we found a dir name that does not exist
if (bFindExist)
{
if (nCounter > 0)
{
TCHAR szCounter[10];
nCounter--;
_itot(nCounter,szCounter,10);
hr = StringCchPrintf(lpBackupDir,cChBackupDir,
TEXT("%s.%s%03s"),lpDir,TEXT("clmt"),szCounter);
if ( FAILED(hr) )
{
goto Exit;
}
}
else
{
goto Exit;
}
}
bResult = TRUE;
}
Exit:
return (bResult);
}
//Add an entry in INF file for key rename
//szOldKeyPath --- the key needs to be renamed
//szNewKeyPath --- to name to be renamed to
//szUsername --- if it's HKLM, HKCR, this needs to be NULL
// ---- otherwise it's the username for registry
HRESULT AddRegKeyRename(
LPTSTR lpszKeyRoot,
LPTSTR lpszOldKeyname,
LPTSTR lpszNewKeyname,
LPTSTR szUsername)
{
TCHAR *lpszOneLine =NULL;
TCHAR *lpszSectionName = NULL;
DWORD cchOneLine;
DWORD cchSectionNameLen;
HRESULT hr;
TCHAR szIndex[MAX_PATH];
LPTSTR lpUserStringSid = NULL;
PSID pSid = NULL;
LPTSTR lpszKeyRootWithoutBackSlash = lpszKeyRoot;
LPTSTR lpszKeyRootWithoutBackSlash1 = NULL,lpszOldKeyname1 = NULL,lpszNewKeyname1 = NULL;
if ( !lpszKeyRoot || !lpszOldKeyname || !lpszNewKeyname)
{
hr = E_INVALIDARG;
goto Cleanup;
}
cchOneLine = lstrlen(lpszKeyRoot)+lstrlen(lpszOldKeyname)+lstrlen(lpszNewKeyname)+MAX_PATH;
if (szUsername)
{
cchSectionNameLen = lstrlen(szUsername)+lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
}
else
{
cchSectionNameLen = lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
}
lpszOneLine = malloc(cchOneLine*sizeof(TCHAR));
lpszSectionName = malloc(cchSectionNameLen*sizeof(TCHAR));
if (!lpszOneLine || !lpszSectionName)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (lpszKeyRoot[0]==TEXT('\\'))
{
lpszKeyRootWithoutBackSlash = lpszKeyRoot + 1;
}
if (!szUsername ||!MyStrCmpI(szUsername,TEXT("System")))
{
hr = StringCchCopy(lpszSectionName,cchSectionNameLen,REG_PERSYS_UPDATE);
if (FAILED(hr))
{
goto Cleanup;
}
}
else
{
if (!MyStrCmpI(szUsername,DEFAULT_USER)
||!MyStrCmpI(szUsername,APPLICATION_DATA_METABASE))
{
hr = StringCchPrintf(lpszSectionName,cchSectionNameLen,TEXT("%s%s"),
REG_PERUSER_UPDATE_PREFIX,szUsername);
if (FAILED(hr))
{
goto Cleanup;
}
}
else
{
hr = GetSIDFromName(szUsername,&pSid);
if (FAILED(hr))
{
goto Cleanup;
}
if (!ConvertSidToStringSid(pSid,&lpUserStringSid))
{
lpUserStringSid = NULL;
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
if (cchSectionNameLen < (DWORD)(lstrlen(lpUserStringSid)+lstrlen(REG_PERUSER_UPDATE_PREFIX)
+ lstrlen(REG_PERSYS_UPDATE)))
{
LPTSTR pTmp;
cchSectionNameLen = lstrlen(lpUserStringSid)+lstrlen(REG_PERUSER_UPDATE_PREFIX)
+ lstrlen(REG_PERSYS_UPDATE);
pTmp = realloc(lpszSectionName,cchSectionNameLen*sizeof(TCHAR));
if (!pTmp)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
else
{
lpszSectionName = pTmp;
}
}
hr = StringCchPrintf(lpszSectionName,cchSectionNameLen,TEXT("%s%s"),
REG_PERUSER_UPDATE_PREFIX,lpUserStringSid);
if (FAILED(hr))
{
goto Cleanup;
}
}
}
AddExtraQuoteEtc(lpszKeyRootWithoutBackSlash,&lpszKeyRootWithoutBackSlash1);
AddExtraQuoteEtc(lpszOldKeyname,&lpszOldKeyname1);
AddExtraQuoteEtc(lpszNewKeyname,&lpszNewKeyname1);
hr = StringCchPrintf(lpszOneLine,cchOneLine,TEXT("%d,\"%s\",\"%s\",\"%s\""),
CONSTANT_REG_KEY_RENAME,lpszKeyRootWithoutBackSlash1,
lpszOldKeyname1,lpszNewKeyname1);
if (FAILED(hr))
{
goto Cleanup;
}
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
if (!WritePrivateProfileString(lpszSectionName,szIndex,lpszOneLine,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
hr = S_OK;
}
Cleanup:
FreePointer(lpszOneLine);
FreePointer(lpszSectionName);
FreePointer(lpszKeyRootWithoutBackSlash1);
FreePointer(lpszOldKeyname1);
FreePointer(lpszNewKeyname1);
if (lpUserStringSid)
{
LocalFree(lpUserStringSid);
}
FreePointer(pSid);
return (hr);
}
HRESULT SetSectionName (
LPTSTR szUsername,
LPTSTR *lpszSectionName)
{
HRESULT hr;
PSID pSid = NULL;
LPTSTR lpUserStringSid = NULL;
DWORD dwCchSectionNameLen;
if (szUsername)
{
dwCchSectionNameLen = lstrlen(szUsername)+lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
}
else
{
dwCchSectionNameLen = lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
}
*lpszSectionName = malloc(dwCchSectionNameLen*sizeof(TCHAR));
if (!*lpszSectionName)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (!szUsername
||!MyStrCmpI(szUsername,TEXT("System")))
{
//We calculte the buffer for lpszSectionName, so here StringCchCopy should be
//always success, assinging return value just make prefast happy
hr = StringCchCopy(*lpszSectionName,dwCchSectionNameLen,REG_PERSYS_UPDATE);
}
else
{
if (!MyStrCmpI(szUsername,DEFAULT_USER)
||!MyStrCmpI(szUsername,APPLICATION_DATA_METABASE))
{
hr = StringCchPrintf(*lpszSectionName,dwCchSectionNameLen,TEXT("%s%s"),
REG_PERUSER_UPDATE_PREFIX,szUsername);
if (FAILED(hr))
{
goto Cleanup;
}
}
else
{
LPTSTR pTmp;
hr = GetSIDFromName(szUsername,&pSid);
if (FAILED(hr))
{
goto Cleanup;
}
if (!ConvertSidToStringSid(pSid,&lpUserStringSid))
{
lpUserStringSid = NULL;
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
dwCchSectionNameLen = lstrlen(lpUserStringSid)+lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
pTmp = realloc(*lpszSectionName,dwCchSectionNameLen*sizeof(TCHAR));
if (!pTmp)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
else
{
*lpszSectionName = pTmp;
}
hr = StringCchPrintf(*lpszSectionName,dwCchSectionNameLen,TEXT("%s%s"),
REG_PERUSER_UPDATE_PREFIX,lpUserStringSid);
if (FAILED(hr))
{
goto Cleanup;
}
}
}
Cleanup:
if (lpUserStringSid)
{
LocalFree(lpUserStringSid);
}
if (FAILED(hr))
FreePointer(*lpszSectionName);
FreePointer(pSid);
return hr;
}
//Add an entry in INF file for Value rename
//szKeyPath: Key path
//szOldValueName: Old value name
//szNewValueName: New value name. Set to NULL if value name is not changed.
//szOldValueData: Old value data. Set to NULL if value data is not changed.
//szNewValueData: New value data. Set to NULL if value data is not changed.
//dwType: Date type REG_SZ,REG_EXPAND_SZ,REG_MULTI_SZ
//dwAttrib: Value string attribute
//szUsername: If it's HKLM, HKCR, this needs to be NULL
// otherwise it's the username for registry
HRESULT AddRegValueRename(
LPTSTR szKeyPath,
LPTSTR szOldValueName,
LPTSTR szNewValueName,
LPTSTR szOldValueData,
LPTSTR szNewValueData,
DWORD dwType,
DWORD dwAttrib,
LPTSTR szUsername)
{
HRESULT hr;
TCHAR *szRenameValueDataLine = NULL;
TCHAR *szRenameValueNameLine = NULL;
DWORD dwCchsizeforRenameValueData;
DWORD dwCchsizeforRenameValueName = MAX_PATH ;
TCHAR *lpszSectionName = NULL;
DWORD dwCchSectionNameLen;
TCHAR szIndex[MAX_PATH];
LPTSTR lpUserStringSid = NULL;
PSID pSid = NULL;
LPTSTR lpszKeyPathWithoutBackSlash = NULL,lpszKeyPathWithoutBackSlash1 = NULL;
LPTSTR lpszOldNameWithExtraQuote = NULL, lpszNewNameWithExtraQuote = NULL;
LPTSTR lpszValueDataExtraQuote = NULL;
if (szUsername)
{
dwCchSectionNameLen = lstrlen(szUsername)+lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
}
else
{
dwCchSectionNameLen = lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
}
lpszSectionName = malloc(dwCchSectionNameLen*sizeof(TCHAR));
if (!lpszSectionName)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (!szUsername
||!MyStrCmpI(szUsername,TEXT("System")))
{
lpszKeyPathWithoutBackSlash = szKeyPath;
//We calculte the buffer for lpszSectionName, so here StringCchCopy should be
//always success, assinging return value just make prefast happy
hr = StringCchCopy(lpszSectionName,dwCchSectionNameLen,REG_PERSYS_UPDATE);
}
else
{
if (szKeyPath[0]==TEXT('\\'))
{
lpszKeyPathWithoutBackSlash = szKeyPath + 1;
}
else
{
lpszKeyPathWithoutBackSlash = szKeyPath;
}
if (!MyStrCmpI(szUsername,DEFAULT_USER)
||!MyStrCmpI(szUsername,APPLICATION_DATA_METABASE))
{
hr = StringCchPrintf(lpszSectionName,dwCchSectionNameLen,TEXT("%s%s"),
REG_PERUSER_UPDATE_PREFIX,szUsername);
if (FAILED(hr))
{
goto Cleanup;
}
}
else
{
LPTSTR pTmp;
hr = GetSIDFromName(szUsername,&pSid);
if (FAILED(hr))
{
goto Cleanup;
}
if (!ConvertSidToStringSid(pSid,&lpUserStringSid))
{
lpUserStringSid = NULL;
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
dwCchSectionNameLen = lstrlen(lpUserStringSid)+lstrlen(REG_PERUSER_UPDATE_PREFIX)+ lstrlen(REG_PERSYS_UPDATE);
pTmp = realloc(lpszSectionName,dwCchSectionNameLen*sizeof(TCHAR));
if (!pTmp)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
else
{
lpszSectionName = pTmp;
}
hr = StringCchPrintf(lpszSectionName,dwCchSectionNameLen,TEXT("%s%s"),
REG_PERUSER_UPDATE_PREFIX,lpUserStringSid);
if (FAILED(hr))
{
goto Cleanup;
}
}
}
hr = AddExtraQuoteEtc(lpszKeyPathWithoutBackSlash,&lpszKeyPathWithoutBackSlash1);
if (FAILED(hr))
{
goto Cleanup;
}
hr = AddExtraQuoteEtc(szOldValueName,&lpszOldNameWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
if (szNewValueData)
{
if ((dwType & 0xffff) == REG_MULTI_SZ)
{
LPTSTR lpString = NULL;
hr = MultiSZ2String(szNewValueData,TEXT(','),&lpString);
if (FAILED(hr))
{
goto Cleanup;
}
dwCchsizeforRenameValueData = lstrlen(lpszKeyPathWithoutBackSlash1) +
lstrlen(szOldValueName) +
lstrlen(lpString) + MAX_PATH;
szRenameValueDataLine = malloc(dwCchsizeforRenameValueData*sizeof(TCHAR));
if (!szRenameValueDataLine)
{
hr = E_OUTOFMEMORY;
FreePointer(lpString);
goto Cleanup;
}
hr = StringCchPrintf(szRenameValueDataLine,dwCchsizeforRenameValueData,
TEXT("%d,%d,\"%s\",\"%s\",%s"),CONSTANT_REG_VALUE_DATA_RENAME,
dwType,lpszKeyPathWithoutBackSlash1,szOldValueName,lpString);
FreePointer(lpString);
if (FAILED(hr))
{
goto Cleanup;
}
}
else
{
hr = AddExtraQuoteEtc(szNewValueData,&lpszValueDataExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
dwCchsizeforRenameValueData = lstrlen(lpszKeyPathWithoutBackSlash1) +
lstrlen(szOldValueName) +
lstrlen(lpszValueDataExtraQuote) + MAX_PATH;
szRenameValueDataLine = malloc(dwCchsizeforRenameValueData*sizeof(TCHAR));
if (!szRenameValueDataLine)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = StringCchPrintf(szRenameValueDataLine,dwCchsizeforRenameValueData,
TEXT("%d,%u,\"%s\",\"%s\",\"%s\""), CONSTANT_REG_VALUE_DATA_RENAME,
dwType,lpszKeyPathWithoutBackSlash1,lpszOldNameWithExtraQuote, lpszValueDataExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
}
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
if (!WritePrivateProfileString(lpszSectionName,szIndex,szRenameValueDataLine,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
}
if (szNewValueName)
{
hr = AddExtraQuoteEtc(szNewValueName,&lpszNewNameWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
dwCchsizeforRenameValueName = lstrlen(lpszKeyPathWithoutBackSlash1) +
lstrlen(lpszOldNameWithExtraQuote) +
lstrlen(lpszNewNameWithExtraQuote) + MAX_PATH;
szRenameValueNameLine = malloc(dwCchsizeforRenameValueName*sizeof(TCHAR));
if (!szRenameValueNameLine)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = StringCchPrintf(szRenameValueNameLine,dwCchsizeforRenameValueName,TEXT("%d,\"%s\",\"%s\",\"%s\""),
CONSTANT_REG_VALUE_NAME_RENAME,lpszKeyPathWithoutBackSlash1,
lpszOldNameWithExtraQuote,lpszNewNameWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
if (!WritePrivateProfileString(lpszSectionName,szIndex,szRenameValueNameLine,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
}
hr = S_OK;
Cleanup:
if (lpUserStringSid)
{
LocalFree(lpUserStringSid);
}
FreePointer(lpszOldNameWithExtraQuote);
FreePointer(lpszNewNameWithExtraQuote);
FreePointer(lpszValueDataExtraQuote);
FreePointer(szRenameValueDataLine);
FreePointer(szRenameValueNameLine);
FreePointer(lpszSectionName);
FreePointer(pSid);
FreePointer(lpszKeyPathWithoutBackSlash1);
return (hr);
}
HRESULT AddFolderRename(
LPTSTR szOldName,
LPTSTR szNewName,
DWORD dwType,
LPTSTR lpExcludeList)
{
LPTSTR szSectionName = TEXT("Folder.ObjectRename");
LPTSTR szOneLine = NULL;
size_t CchOneLine = MAX_PATH;
TCHAR szIndex[MAX_PATH];
HRESULT hr;
LPTSTR lpString = NULL;
switch (dwType)
{
case TYPE_DIR_MOVE:
if (lpExcludeList)
{
hr = MultiSZ2String(lpExcludeList,TEXT(','),&lpString);
if (FAILED(hr))
{
goto Cleanup;
}
CchOneLine +=lstrlen(lpString)+lstrlen(szOldName)+lstrlen(szNewName);
szOneLine = malloc(CchOneLine * sizeof(TCHAR));
if (!szOneLine)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = StringCchPrintf(szOneLine,CchOneLine,TEXT("%d,\"%s\",\"%s\",%s"),
dwType,szOldName,szNewName,lpString);
free(lpString);
if (FAILED(hr))
{
goto Cleanup;
}
break;
}
else
{
}
case TYPE_SFPFILE_MOVE:
case TYPE_FILE_MOVE:
CchOneLine += lstrlen(szOldName)+lstrlen(szNewName);
szOneLine = malloc(CchOneLine * sizeof(TCHAR));
if (!szOneLine)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = StringCchPrintf(szOneLine,CchOneLine,TEXT("%d,\"%s\",\"%s\""),dwType,szOldName,szNewName);
if (FAILED(hr))
{
goto Cleanup;
}
break;
}
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
if (!WritePrivateProfileString(szSectionName,szIndex,szOneLine,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
// Add the file/folder rename to Change log
// Does not care about return value
hr = AddFileChangeLog(dwType, szOldName, szNewName);
hr = S_OK;
Cleanup:
if (szOneLine)
{
free(szOneLine);
}
if (lpString)
{
free(lpString);
}
return hr;
}
LONG EnsureCLMTReg()
{
HKEY hkey = NULL;
LONG lStatus;
lStatus = RegCreateKey(HKEY_LOCAL_MACHINE,CLMT_REGROOT,&hkey);
if (lStatus == ERROR_SUCCESS)
{
RegCloseKey(hkey);
}
return lStatus;
}
HRESULT SaveInstallLocale(void)
{
HKEY hkey = NULL;
LONG lStatus;
HRESULT hr;
LCID lcid;
TCHAR szLocale[MAX_PATH];
TCHAR szStr[16];
lcid = GetInstallLocale();
if (!lcid)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (!IsValidLocale(lcid,LCID_INSTALLED))
{
hr = E_FAIL;
goto Exit;
}
_itot(lcid,szStr,16);
//StringCchCopy should be always success, since we called IsValidLocale to make sure
//it is a valid locale which should be less than MAX_PATH chars
hr = StringCchPrintf(szLocale,ARRAYSIZE(szLocale),TEXT("%08s"),szStr);
lStatus = RegCreateKey(HKEY_LOCAL_MACHINE,CLMT_REGROOT,&hkey);
if (lStatus != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
lStatus = RegSetValueEx(hkey,
CLMT_OriginalInstallLocale,
0, //reserved
REG_SZ,//type
(LPBYTE) szLocale,
(lstrlen(szLocale)+1)*sizeof(TCHAR));
if( lStatus != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
hr = S_OK;
Exit:
if (hkey)
{
RegCloseKey(hkey);
}
return hr;
}
HRESULT GetSavedInstallLocale(LCID *plcid)
{
HKEY hkey = NULL;
LONG lStatus;
HRESULT hr;
LCID lcid;
TCHAR szLocale[MAX_PATH];
TCHAR *pStop;
DWORD dwSize;
if ( !plcid )
{
hr = E_INVALIDARG;
goto Exit;
}
lStatus = RegOpenKey(HKEY_LOCAL_MACHINE,CLMT_REGROOT,&hkey);
if (lStatus != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
dwSize = MAX_PATH *sizeof(TCHAR);
lStatus = RegQueryValueEx(hkey,
CLMT_OriginalInstallLocale,
NULL, //reserved
NULL,//type
(LPBYTE) szLocale,
&dwSize);
if( lStatus != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
*plcid = _tcstol(szLocale, &pStop, 16);
if (!IsValidLocale(*plcid,LCID_INSTALLED))
{
hr = E_FAIL;
goto Exit;
}
hr = S_OK;
Exit:
if (hkey)
{
RegCloseKey(hkey);
}
return hr;
}
HRESULT SetCLMTStatus(DWORD dwRunStatus)
{
HKEY hkey = NULL;
LONG lStatus;
HRESULT hr;
if ( (dwRunStatus != CLMT_DOMIG)
&& (dwRunStatus != CLMT_UNDO_PROGRAM_FILES)
&& (dwRunStatus != CLMT_UNDO_APPLICATION_DATA)
&& (dwRunStatus != CLMT_UNDO_ALL)
&& (dwRunStatus != CLMT_DOMIG_DONE)
&& (dwRunStatus != CLMT_UNDO_PROGRAM_FILES_DONE)
&& (dwRunStatus != CLMT_UNDO_APPLICATION_DATA_DONE)
&& (dwRunStatus != CLMT_UNDO_ALL_DONE)
&& (dwRunStatus != CLMT_CURE_PROGRAM_FILES)
&& (dwRunStatus != CLMT_CLEANUP_AFTER_UPGRADE) )
{
hr = E_INVALIDARG;
goto Exit;
}
lStatus = RegCreateKey(HKEY_LOCAL_MACHINE,CLMT_REGROOT,&hkey);
if (lStatus != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
lStatus = RegSetValueEx(hkey,
CLMT_RUNNING_STATUS,
0, //reserved
REG_DWORD,//type
(LPBYTE) &dwRunStatus,
sizeof(DWORD));
if( lStatus != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
hr = S_OK;
Exit:
if (hkey)
{
RegCloseKey(hkey);
}
return hr;
}
HRESULT GetCLMTStatus(PDWORD pdwRunStatus)
{
HKEY hkey = NULL;
LONG lStatus;
HRESULT hr;
DWORD dwSize;
if ( !pdwRunStatus )
{
hr = E_INVALIDARG;
goto Exit;
}
lStatus = RegOpenKey(HKEY_LOCAL_MACHINE,CLMT_REGROOT,&hkey);
if (lStatus != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
dwSize = sizeof(DWORD);
lStatus = RegQueryValueEx(hkey,
CLMT_RUNNING_STATUS,
NULL,
NULL,
(LPBYTE)pdwRunStatus,
&dwSize);
if( lStatus != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(lStatus);
goto Exit;
}
hr = S_OK;
Exit:
if (hkey)
{
RegCloseKey(hkey);
}
return hr;
}
//-----------------------------------------------------------------------
//
// Function: GetInstallLocale
//
// Descrip: Get the OS installed locale
//
// Returns: LCID
//
// Notes: if fails, the return value is 0, otherwize is the os 's lcid
//
// History: 09/17/2001 xiaoz created
//
// Notes: If it returns 0, it means failure, and call GetLastError() to get the detail
// error code
//
//-----------------------------------------------------------------------
UINT GetInstallLocale(VOID)
{
LONG dwErr;
HKEY hkey;
DWORD dwSize;
TCHAR buffer[512];
LANGID rcLang;
UINT lcid;
lcid = 0;
dwErr = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Control\\Nls\\Language"),
0,
KEY_READ,
&hkey );
if( dwErr == ERROR_SUCCESS )
{
dwSize = sizeof(buffer);
dwErr = RegQueryValueEx(hkey,
TEXT("InstallLanguage"),
NULL, //reserved
NULL, //type
(LPBYTE) buffer,
&dwSize );
if(dwErr == ERROR_SUCCESS)
{
lcid = StrToUInt(buffer);
}
RegCloseKey(hkey);
}
return( lcid );
}
//-----------------------------------------------------------------------
//
// Function: SetInstallLocale
//
// Descrip: Set the OS installed locale
//
// Returns: HRESULT
//
// Notes:
//
// History: 09/17/2001 xiaoz created
//
//
//-----------------------------------------------------------------------
HRESULT SetInstallLocale(LCID lcid)
{
LONG dwErr;
HKEY hkey = NULL;
TCHAR szLocale[32],szTmpLocale[32];
HRESULT hr;
if (!IsValidLocale(lcid,LCID_INSTALLED))
{
hr = E_INVALIDARG;
goto Exit;
}
dwErr = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Control\\Nls\\Language"),
0,
KEY_WRITE,
&hkey );
if( dwErr != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Exit;
}
//following 2 sentences should never fail since we already validated by IsValidLocale
_itot(lcid,szTmpLocale,16);
//StringCchCopy should be always success, since we called IsValidLocale to make sure
//it is a valid locale which should be less than 32 chars
hr = StringCchPrintf(szLocale,ARRAYSIZE(szLocale),TEXT("%04s"),szTmpLocale);
dwErr = RegSetValueEx(hkey,
TEXT("InstallLanguage"),
0, //reserved
REG_SZ,//type
(LPBYTE) szLocale,
(lstrlen(szLocale)+1)*sizeof(TCHAR));
if( dwErr != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Exit;
}
hr = S_OK;
Exit:
if (hkey)
{
RegCloseKey(hkey);
}
return hr;
}
//
// Function: ReverseStrCmp
//
// Description: Reverse compare strings
//
// Returns: TRUE if two strings are equal.
// FALSE if different.
// Notes:
//
// History: 3/14/2002 geoffguo created
//
BOOL ReverseStrCmp(
LPCTSTR lpCurrentChar,
LPCTSTR lpStrBuf)
{
BOOL bRet = FALSE;
DWORD i, dwLen;
LPCTSTR lpStr1, lpStr2;
if (!lpCurrentChar || !lpStrBuf)
goto Exit;
dwLen = lstrlen(lpStrBuf);
do
{
bRet = TRUE;
lpStr1 = lpCurrentChar;
lpStr2 = &lpStrBuf[dwLen-1];
for (i = 0; i < dwLen; i++)
{
if (IsBadStringPtr(lpStr1, 1) || *lpStr1 == (TCHAR)'\0' ||
towupper(*lpStr1) != towupper(*lpStr2) &&
*lpStr2 != L':' && //solve MS Installer path issue: G?\Program Files
*lpStr2 != L'\\') //solve MS FrontPage URL format issue: D:/Document and Settings
{
bRet = FALSE;
break;
}
lpStr1--;
lpStr2--;
}
if (bRet)
break;
dwLen--;
} while (lpStrBuf[dwLen-1] != (TCHAR)'\\' && dwLen > 0);
Exit:
return bRet;
}
DWORD MultiSZNumOfString(IN LPTSTR lpMultiSZ)
{
DWORD dwNum = 0;
LPTSTR lpStr = lpMultiSZ;
if (!lpMultiSZ)
{
return 0;
}
while (*lpStr)
{
dwNum++;
lpStr = lpStr + lstrlen(lpStr)+1;
}
return dwNum;
}
//
// Function: StrNumInMultiSZ
//
// Description: Get string number in multi-string
//
// Returns: String number or 0xFFFFFFFF if not find.
//
// Notes:
//
// History: 3/21/2002 geoffguo created
//
DWORD StrNumInMultiSZ(
LPCTSTR lpStr,
LPCTSTR lpMultiSZ)
{
DWORD dwNum = 0xFFFFFFFF;
LPTSTR lpTemp;
if (!lpMultiSZ || !lpStr)
{
goto Exit;
}
lpTemp = (LPTSTR)lpMultiSZ;
dwNum = 0;
while (*lpTemp)
{
if(MyStrCmpI(lpStr, lpTemp) == 0)
break;
dwNum++;
lpTemp = lpTemp + lstrlen(lpTemp)+1;
}
if (*lpTemp == (TCHAR)NULL)
dwNum = 0xFFFFFFFF;
Exit:
return dwNum;
}
//
// Function: GetStrInMultiSZ
//
// Description: Get string in multi-string based on string number.
//
// Returns: Point to the string or NULL.
//
// Notes:
//
// History: 3/21/2002 geoffguo created
//
LPTSTR GetStrInMultiSZ(
DWORD dwNum,
LPCTSTR lpMultiSZ)
{
DWORD i;
LPTSTR lpTemp = NULL;
if (!lpMultiSZ)
{
goto Exit;
}
lpTemp = (LPTSTR)lpMultiSZ;
i = 0;
while (*lpTemp)
{
if(i == dwNum)
break;
i++;
lpTemp = lpTemp + lstrlen(lpTemp)+1;
}
if (*lpTemp == (TCHAR)NULL)
lpTemp = NULL;
Exit:
return lpTemp;
}
HRESULT MultiSZ2String(
IN LPTSTR lpMultiSZ,
IN TCHAR chSeperator,
OUT LPTSTR *lpString)
{
LPTSTR lpSource = NULL,lpDest = NULL,lpDestStart = NULL,lpTmpBuf = NULL;
DWORD cchLen ;
HRESULT hr;
DWORD dwNumofStringInMSZ;
if (!lpMultiSZ || !lpString )
{
hr = E_INVALIDARG;
goto Cleanup;
}
cchLen = MultiSzLen(lpMultiSZ);
if (cchLen < 3)
{
hr = E_INVALIDARG;
*lpString = NULL;
goto Cleanup;
}
dwNumofStringInMSZ = MultiSZNumOfString(lpMultiSZ);
lpDest = malloc( (cchLen + dwNumofStringInMSZ * 2) * sizeof(TCHAR));
lpDestStart = lpDest;
lpTmpBuf = malloc( (cchLen + dwNumofStringInMSZ * 2) * sizeof(TCHAR));
if (!lpDest || !lpTmpBuf)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
lpSource = lpMultiSZ;
while (*lpSource)
{
//We calculte the buffer for lpTmpBuf, so here StringCchCopy should be
//always success, assinging return value just make prefast happy
hr = StringCchPrintf(lpTmpBuf,cchLen + dwNumofStringInMSZ * 2,TEXT("\"%s\""),lpSource);
memcpy((BYTE*)lpDest,(BYTE*)lpTmpBuf,lstrlen(lpTmpBuf) * sizeof(TCHAR));
lpSource = lpSource + lstrlen(lpSource)+1;
lpDest = lpDest + lstrlen(lpTmpBuf);
*lpDest = chSeperator;
lpDest++;
}
lpDest--;
*lpDest = TEXT('\0');
hr = S_OK;
Cleanup:
if (lpTmpBuf)
{
free(lpTmpBuf);
}
if FAILED(hr)
{
if (lpDestStart)
{
free(lpDestStart);
}
lpDestStart = NULL;
}
*lpString = lpDestStart;
return hr;
}
void FreePointer(void *lp)
{
if (lp)
{
free(lp);
}
}
HRESULT GetSIDFromName(
IN LPTSTR lpszUserName,
OUT PSID *ppSid)
{
PSID pSid = NULL;
DWORD cbSid = 1024;
SID_NAME_USE Use ;
HRESULT hr;
DWORD dwDomainNameLen = MAX_PATH;
TCHAR szDomain[MAX_PATH];
if (!lpszUserName)
{
hr = E_INVALIDARG;
goto Cleanup;
}
pSid = (PSID)malloc( cbSid);
if(!pSid)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
if (LookupAccountName(NULL,lpszUserName,pSid,&cbSid,szDomain,&dwDomainNameLen,&Use)== FALSE)
{
DWORD dwErr = GetLastError();
if(dwErr != ERROR_INSUFFICIENT_BUFFER)
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Cleanup;
}
else
{
free(pSid);
pSid = (PSID)malloc( cbSid);
if(!pSid)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
dwDomainNameLen = MAX_PATH;
if (LookupAccountName(NULL,lpszUserName,pSid,&cbSid,szDomain,&dwDomainNameLen,&Use)== FALSE)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
}
}
//Check the SID
if(!IsValidSid(pSid))
{
hr = E_FAIL;
goto Cleanup;
}
hr = S_OK;
Cleanup:
if FAILED(hr)
{
if (pSid)
{
free(pSid);
}
*ppSid = NULL;
}
else
{
*ppSid = pSid;
}
return hr;
}
void BoostMyPriority()
{
HANDLE hProcess;
hProcess = GetCurrentProcess();
SetPriorityClass(hProcess,HIGH_PRIORITY_CLASS);
}
//***************************************************************************
//
// BOOL StopService
//
// DESCRIPTION:
//
// Stops and then removes the service.
//
// PARAMETERS:
//
// pServiceName short service name
// dwMaxWait max time in seconds to wait
//
// RETURN VALUE:
//
// TRUE if it worked
//
//***************************************************************************
BOOL StopService(
IN LPCTSTR pServiceName,
IN DWORD dwMaxWait)
{
BOOL bRet = FALSE;
SC_HANDLE schService;
SC_HANDLE schSCManager;
DWORD dwCnt;
SERVICE_STATUS ssStatus; // current status of the service
schSCManager = OpenSCManager(
NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_ALL_ACCESS // access required
);
if ( schSCManager )
{
schService = OpenService(schSCManager, pServiceName, SERVICE_ALL_ACCESS);
if (schService)
{
// try to stop the service
if ( bRet = ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) )
{
for(dwCnt=0; dwCnt < dwMaxWait &&
QueryServiceStatus( schService, &ssStatus ); dwCnt++)
{
if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING )
Sleep( 1000 );
else
break;
}
}
CloseServiceHandle(schService);
}
CloseServiceHandle(schSCManager);
}
return bRet;
}
//***************************************************************************
//
// HRESULT ReconfigureServiceStartType
//
// DESCRIPTION:
//
// Change the Service Start Type, there are following type availabe now
// SERVICE_AUTO_START
// SERVICE_BOOT_START
// SERVICE_DEMAND_START
// SERVICE_DISABLED
// SERVICE_SYSTEM_START
//
// PARAMETERS:
//
// pServiceName short service name
// dwOldType service current start type
// dwNewType start type you want to change to
// dwMaxWait max time in seconds to wait
//
// RETURN VALUE: S_OK if change successfully
//
// Note: if current start type is dwOldType, the function will try to
// change start type to dwNewType.
// if current start type is NOT dwOldType, it will not do any
// change, in this S_FALSE is returned.
// If you want change service start type to dwNewType, no mater
// current start type, specify dwOldType >=0xFFFF
//
//***************************************************************************
HRESULT ReconfigureServiceStartType(
IN LPCTSTR pServiceName,
IN DWORD dwOldType,
IN DWORD dwNewType,
IN DWORD dwMaxWait)
{
SC_LOCK sclLock = NULL;
SERVICE_DESCRIPTION sdBuf;
DWORD dwBytesNeeded, dwStartType;
SC_HANDLE schSCManager = NULL;
SC_HANDLE schService = NULL;
DWORD dwErr = ERROR_SUCCESS;
LPQUERY_SERVICE_CONFIG lpqscBuf = NULL;
HRESULT hr = S_OK;
DWORD dwCnt;
schSCManager = OpenSCManager(
NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_ALL_ACCESS // access required
);
if (!schSCManager)
{
dwErr = GetLastError();
goto cleanup;
}
// Need to acquire database lock before reconfiguring.
for(dwCnt=0; dwCnt < dwMaxWait ; dwCnt++)
{
sclLock = LockServiceDatabase(schSCManager);
if (sclLock == NULL)
{
// Exit if the database is not locked by another process.
dwErr = GetLastError();
if (dwErr != ERROR_SERVICE_DATABASE_LOCKED)
{
goto cleanup;
}
else
{
Sleep(1000);
}
}
else
{
break;
}
}
if (!sclLock)
{
goto cleanup;
}
// The database is locked, so it is safe to make changes.
// Open a handle to the service.
schService = OpenService(
schSCManager, // SCManager database
pServiceName, // name of service
SERVICE_CHANGE_CONFIG | SERVICE_QUERY_CONFIG ); // need CHANGE access
if (schService == NULL)
{
dwErr = GetLastError();
goto cleanup;
}
lpqscBuf = (LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, 4096);
if (lpqscBuf == NULL)
{
dwErr = ERROR_OUTOFMEMORY;
goto cleanup;
}
if (!QueryServiceConfig(schService, // handle to service
lpqscBuf, // buffer
4096, // size of buffer
&dwBytesNeeded))
{
dwErr = GetLastError();
goto cleanup;
}
if (dwOldType < 0xFFFF)
{
if (lpqscBuf->dwStartType != dwOldType)
{
hr = S_FALSE;
goto cleanup;
}
}
// Make the changes.
if (! ChangeServiceConfig(schService, // handle of service
SERVICE_NO_CHANGE, // service type: no change
dwNewType, // change service start type
SERVICE_NO_CHANGE, // error control: no change
NULL, // binary path: no change
NULL, // load order group: no change
NULL, // tag ID: no change
NULL, // dependencies: no change
NULL, // account name: no change
NULL, // password: no change
NULL) ) // display name: no change
{
dwErr = GetLastError();
goto cleanup;
}
hr = S_OK;
cleanup:
if (dwErr != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(dwErr);
}
if (sclLock)
{
UnlockServiceDatabase(sclLock);
}
if (schService)
{ // Close the handle to the service.
CloseServiceHandle(schService);
}
if (schSCManager)
{
CloseServiceHandle(schSCManager);
}
if (lpqscBuf)
{
LocalFree(lpqscBuf);
}
return hr;
}
//-----------------------------------------------------------------------
//
// Function: MyGetShortPathName
//
// Descrip:
//
// Returns: DWORD
//
// Notes: none
//
// History: 09/17/2001 xiaoz created
//
// Notes:
// lpszLongPath is the long path name
// lpszOriginalPath (optional)is the the original name of lpszLongPath(before we renamed it)
// lpszShortPath is the buffer to receive the short path name
// cchBuffer is the buffer size for lpszShortPath
//
//-----------------------------------------------------------------------
#define BYTE_COUNT_8_DOT_3 (24)
HRESULT MyGetShortPathName(
IN LPCTSTR lpszPathRoot,
IN LPCTSTR lpszOldName,
IN LPCTSTR lpszNewName,
OUT LPTSTR lpszShortName,
IN DWORD cchBuffer)
{
HRESULT hr = S_OK;
GENERATE_NAME_CONTEXT NameContext;
WCHAR ShortNameBuffer[BYTE_COUNT_8_DOT_3 / sizeof( WCHAR ) + 1];
UNICODE_STRING FileName,ShortName;
DWORD StringLength;
LPTSTR lpName;
TCHAR szPath[MAX_PATH],szLongPath[MAX_PATH];
TCHAR DriveRoot[_MAX_DRIVE + 2];
#define FILESYSNAMEBUFSIZE 1024 // probably more than we need
TCHAR szFileSystemType[FILESYSNAMEBUFSIZE];
BOOL bIsNTFS = FALSE;
BOOL bTmpDirCreated = FALSE;
DWORD dwAllowExtendedChar;
BOOLEAN bAllowExtendedChar;
DWORD dwsizeofdw;
if (lstrlen(lpszNewName) <= 8)
{
hr = StringCchCopy(lpszShortName,cchBuffer,lpszNewName);
goto Exit;
}
//
// Initialize the short string to use the input buffer.
//
ShortName.Buffer = ShortNameBuffer;
ShortName.MaximumLength = BYTE_COUNT_8_DOT_3;
FileName.Buffer = (LPTSTR)lpszNewName;
StringLength = lstrlen(lpszNewName);
FileName.Length = (USHORT)StringLength * sizeof(TCHAR);
FileName.MaximumLength = (USHORT)(StringLength + 1)*sizeof(TCHAR);
// Initialize the name context.
//
RtlZeroMemory( &NameContext, sizeof( GENERATE_NAME_CONTEXT ));
#define EXTENDED_CHAR_MODE_VALUE_NAME TEXT("NtfsAllowExtendedCharacterIn8dot3Name")
#define COMPATIBILITY_MODE_KEY_NAME TEXT("System\\CurrentControlSet\\Control\\FileSystem")
dwsizeofdw = sizeof(DWORD);
if (ERROR_SUCCESS == GetRegistryValue(HKEY_LOCAL_MACHINE,
COMPATIBILITY_MODE_KEY_NAME,
EXTENDED_CHAR_MODE_VALUE_NAME,
(LPBYTE)&dwAllowExtendedChar,
&dwsizeofdw))
{
if (dwAllowExtendedChar)
{
bAllowExtendedChar = TRUE;
}
else
{
bAllowExtendedChar = FALSE;
}
}
else
{
bAllowExtendedChar = FALSE;
}
RtlGenerate8dot3Name( &FileName, bAllowExtendedChar, &NameContext, &ShortName );
//now ShortName.Buffer contains the shortpath and is NULL ended
ShortName.Buffer[ShortName.Length /sizeof(TCHAR)] = TEXT('\0');
//check whether the short name is exitsted or now
hr = StringCchCopy(szPath,ARRAYSIZE(szPath),lpszPathRoot);
if (FAILED(hr))
{
goto Exit;
}
if (!ConcatenatePaths(szPath,ShortName.Buffer,ARRAYSIZE(szPath)))
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
goto Exit;
}
if (!IsFileFolderExisting(szPath))
{
hr = StringCchCopy(lpszShortName,cchBuffer,ShortName.Buffer);
goto Exit;
}
_tsplitpath(lpszPathRoot, DriveRoot, NULL, NULL, NULL);
hr = StringCchCat(DriveRoot, ARRAYSIZE(DriveRoot), TEXT("\\"));
if (FAILED(hr))
{
hr = E_INVALIDARG;
goto Exit;
}
if (! GetVolumeInformation(DriveRoot, NULL, 0,
NULL, NULL, NULL, szFileSystemType, ARRAYSIZE(szFileSystemType)) )
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (!MyStrCmpI(szFileSystemType,TEXT("NTFS")))
{
bIsNTFS = TRUE;
}
//Follwing we process the short name path is existing.
if (!GetLongPathName(szPath,szLongPath,ARRAYSIZE(szLongPath)))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
lpName = StrRChrI(szLongPath,NULL,TEXT('\\'));
if (!lpName)
{
hr = E_FAIL;
goto Exit;
}
if (!MyStrCmpI(lpName+1,lpszOldName))
{
if (bIsNTFS)
{
hr = StringCchCopy(lpszShortName,cchBuffer,ShortName.Buffer);
goto Exit;
}
}
else
if (!MyStrCmpI(lpName,lpszNewName))
{
hr = StringCchCopy(lpszShortName,cchBuffer,ShortName.Buffer);
goto Exit;
}
//here we need to get the shortpath name by creating it
hr = StringCchCopy(szLongPath,ARRAYSIZE(szLongPath),lpszPathRoot);
if (FAILED(hr))
{
goto Exit;
}
if (!ConcatenatePaths(szLongPath,lpszNewName,ARRAYSIZE(szLongPath)))
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
goto Exit;
}
if (!CreateDirectory(szLongPath,NULL))
{
DWORD dwErr = GetLastError();
if (dwErr != ERROR_ALREADY_EXISTS)
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Exit;
}
}
else
{
bTmpDirCreated = TRUE;
}
if (!GetShortPathName(szLongPath,szPath,cchBuffer))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (bTmpDirCreated)
{
RemoveDirectory(szLongPath);
}
if (!(lpName = StrRChrI(szPath,NULL,TEXT('\\'))))
{
hr = E_FAIL;
goto Exit;
}
hr = StringCchCopy(lpszShortName,cchBuffer,lpName+1);
Exit:
return hr;
}
BOOL
MassageLinkValue(
IN LPCWSTR lpLinkName,
IN LPCWSTR lpLinkValue,
OUT PUNICODE_STRING NtLinkName,
OUT PUNICODE_STRING NtLinkValue,
OUT PUNICODE_STRING DosLinkValue
)
{
PWSTR FilePart;
PWSTR s, sBegin, sBackupLimit, sLinkName;
NTSTATUS Status;
USHORT nSaveNtNameLength;
ULONG nLevels;
//
// Initialize output variables to NULL
//
RtlInitUnicodeString( NtLinkName, NULL );
RtlInitUnicodeString( NtLinkValue, NULL );
//
// Translate link name into full NT path.
//
if (!RtlDosPathNameToNtPathName_U( lpLinkName,
NtLinkName,
&sLinkName,
NULL
)
)
{
return FALSE;
}
//
// All done if no link value.
//
if (!ARGUMENT_PRESENT( lpLinkValue )) {
return TRUE;
}
//
// If the target is a device, do not allow the link.
//
if (RtlIsDosDeviceName_U( (PWSTR)lpLinkValue )) {
return FALSE;
}
//
// Convert to DOS path to full path, and get Nt representation
// of DOS path.
//
if (!RtlGetFullPathName_U( lpLinkValue,
DosLinkValue->MaximumLength,
DosLinkValue->Buffer,
NULL
)
) {
return FALSE;
}
DosLinkValue->Length = wcslen( DosLinkValue->Buffer ) * sizeof( WCHAR );
//
// Verify that the link value is a valid NT name.
//
if (!RtlDosPathNameToNtPathName_U( DosLinkValue->Buffer,
NtLinkValue,
NULL,
NULL
)
) {
return FALSE;
}
return TRUE;
} // MassageLinkValue
BOOL CreateSymbolicLink(
LPTSTR szLinkName,
LPTSTR szLinkValue,
BOOL bMakeLinkHidden
)
{
NTSTATUS Status = STATUS_SUCCESS;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE Handle;
UNICODE_STRING UnicodeName;
UNICODE_STRING NtLinkName;
UNICODE_STRING NtLinkValue;
UNICODE_STRING DosLinkValue;
WCHAR FullPathLinkValue[ DOS_MAX_PATH_LENGTH+1 ];
IO_STATUS_BLOCK IoStatusBlock;
BOOL TranslationStatus;
PVOID FreeBuffer;
PVOID FreeBuffer2;
FILE_DISPOSITION_INFORMATION Disposition;
PREPARSE_DATA_BUFFER ReparseBufferHeader = NULL;
PCHAR ReparseBuffer = NULL;
ULONG ReparsePointTag = IO_REPARSE_TAG_RESERVED_ZERO;
USHORT ReparseDataLength = 0;
ULONG FsControlCode = 0;
ULONG CreateOptions = 0;
ULONG CreateDisposition = 0;
ULONG DesiredAccess = SYNCHRONIZE;
DWORD dwAttrib;
BOOL bRet = FALSE;
// change the name to NT path, eg d:\programme to ??\d:\programme
TranslationStatus = RtlDosPathNameToNtPathName_U(
szLinkName,
&UnicodeName,
NULL,
NULL
);
if (!TranslationStatus)
{
goto exit;
}
FreeBuffer = UnicodeName.Buffer;
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
//
// Set the code of the FSCTL operation.
//
FsControlCode = FSCTL_SET_REPARSE_POINT;
//
// Set the open/create options for a directory.
//
CreateOptions = FILE_OPEN_REPARSE_POINT;
//
// Set the tag to mount point.
//
ReparsePointTag = IO_REPARSE_TAG_MOUNT_POINT;
//
// Open to set the reparse point.
//
DesiredAccess |= FILE_WRITE_DATA;
CreateDisposition = FILE_OPEN; // the file must be present
Status = NtCreateFile(&Handle,
DesiredAccess,
&ObjectAttributes,
&IoStatusBlock,
NULL, // pallocationsize (none!)
FILE_ATTRIBUTE_NORMAL,// attributes to be set if created
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
CreateDisposition,
CreateOptions,
NULL, // EA buffer (none!)
0);
//
// Create a directory if you do not find it.
//
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
DesiredAccess = SYNCHRONIZE;
CreateDisposition = FILE_CREATE;
CreateOptions = FILE_DIRECTORY_FILE;
Status = NtCreateFile(&Handle,
DesiredAccess,
&ObjectAttributes,
&IoStatusBlock,
NULL, // pallocationsize (none!)
FILE_ATTRIBUTE_NORMAL, // attributes to be set if created
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
CreateDisposition,
CreateOptions,
NULL, // EA buffer (none!)
0);
if (!NT_SUCCESS(Status))
{
goto exit;
}
//
// Close the handle and re-open.
//
NtClose( Handle );
CreateOptions = FILE_OPEN_REPARSE_POINT;
DesiredAccess |= FILE_WRITE_DATA;
CreateDisposition = FILE_OPEN; // the file must be present
Status = NtCreateFile(&Handle,
DesiredAccess,
&ObjectAttributes,
&IoStatusBlock,
NULL, // pallocationsize (none!)
FILE_ATTRIBUTE_NORMAL, // attributes to be set if created
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
CreateDisposition,
CreateOptions,
NULL, // EA buffer (none!)
0);
}
RtlFreeHeap( RtlProcessHeap(), 0, FreeBuffer );
if (!NT_SUCCESS(Status))
{
goto exit;
}
//
// Innitialize the DosName buffer.
//
DosLinkValue.Buffer = FullPathLinkValue;
DosLinkValue.MaximumLength = sizeof( FullPathLinkValue );
DosLinkValue.Length = 0;
//
// Massage all the names.
//
if (!MassageLinkValue( szLinkName,
szLinkValue,
&NtLinkName,
&NtLinkValue,
&DosLinkValue ))
{
RtlFreeUnicodeString( &NtLinkName );
RtlFreeUnicodeString( &NtLinkValue );
goto exit;
}
RtlFreeUnicodeString( &NtLinkName );
//
// Set the reparse point with mount point or symbolic link tag and determine
// the appropriate length of the buffer.
//
ReparseDataLength = (USHORT)((FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer) -
REPARSE_DATA_BUFFER_HEADER_SIZE) +
NtLinkValue.Length + sizeof(UNICODE_NULL) +
DosLinkValue.Length + sizeof(UNICODE_NULL));
//
// Allocate a buffer to set the reparse point.
//
ReparseBufferHeader
= (PREPARSE_DATA_BUFFER)RtlAllocateHeap(RtlProcessHeap(),
HEAP_ZERO_MEMORY,
REPARSE_DATA_BUFFER_HEADER_SIZE + ReparseDataLength);
if (ReparseBufferHeader == NULL)
{
NtClose( Handle );
RtlFreeUnicodeString( &NtLinkValue );
goto exit;
}
//
// Setting the buffer is common for both tags as their buffers have identical fields.
//
ReparseBufferHeader->ReparseDataLength = (USHORT)ReparseDataLength;
ReparseBufferHeader->Reserved = 0;
ReparseBufferHeader->SymbolicLinkReparseBuffer.SubstituteNameOffset = 0;
ReparseBufferHeader->SymbolicLinkReparseBuffer.SubstituteNameLength = NtLinkValue.Length;
ReparseBufferHeader->SymbolicLinkReparseBuffer.PrintNameOffset = NtLinkValue.Length + sizeof( UNICODE_NULL );
ReparseBufferHeader->SymbolicLinkReparseBuffer.PrintNameLength = DosLinkValue.Length;
RtlCopyMemory(ReparseBufferHeader->SymbolicLinkReparseBuffer.PathBuffer,
NtLinkValue.Buffer,
NtLinkValue.Length);
RtlCopyMemory((PCHAR)(ReparseBufferHeader->SymbolicLinkReparseBuffer.PathBuffer)+
NtLinkValue.Length + sizeof(UNICODE_NULL),
DosLinkValue.Buffer,
DosLinkValue.Length);
RtlFreeUnicodeString( &NtLinkValue );
//
// Set the tag
//
ReparseBufferHeader->ReparseTag = ReparsePointTag;
//
// Set the reparse point.
//
Status = NtFsControlFile(Handle,
NULL,
NULL,
NULL,
&IoStatusBlock,
FsControlCode,
ReparseBufferHeader,
REPARSE_DATA_BUFFER_HEADER_SIZE + ReparseBufferHeader->ReparseDataLength,
NULL, // no output buffer
0); // output buffer length\
//
// Close the file.
//
NtClose( Handle );
if (!NT_SUCCESS(Status))
{
goto exit;
}
bRet = TRUE;
if (bMakeLinkHidden)
{
dwAttrib = GetFileAttributes(szLinkName);
if (INVALID_FILE_ATTRIBUTES == dwAttrib)
{
goto exit;
}
if (!SetFileAttributes(szLinkName,dwAttrib|FILE_ATTRIBUTE_HIDDEN))
{
DPF (APPmsg, L"SetFileAttributes! Error: %d \n", GetLastError());
goto exit;
}
}
exit:
return bRet;
}
BOOL GetSymbolicLink(
LPTSTR szLinkName,
LPTSTR szLinkValue,
DWORD cchSize
)
{
NTSTATUS Status = STATUS_SUCCESS;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE Handle;
UNICODE_STRING UnicodeName;
UNICODE_STRING NtLinkName;
UNICODE_STRING NtLinkValue;
UNICODE_STRING DosLinkValue;
WCHAR FullPathLinkValue[ DOS_MAX_PATH_LENGTH+1 ];
IO_STATUS_BLOCK IoStatusBlock;
BOOL TranslationStatus;
PVOID FreeBuffer;
PVOID FreeBuffer2;
FILE_DISPOSITION_INFORMATION Disposition;
PREPARSE_DATA_BUFFER ReparseBufferHeader = NULL;
PCHAR ReparseBuffer = NULL;
ULONG ReparsePointTag = IO_REPARSE_TAG_RESERVED_ZERO;
USHORT ReparseDataLength = 0;
ULONG FsControlCode = 0;
ULONG CreateOptions = 0;
ULONG CreateDisposition = 0;
ULONG DesiredAccess = SYNCHRONIZE;
DWORD dwAttrib;
BOOL bRet = FALSE;
// change the name to NT path, eg d:\programme to ??\d:\programme
TranslationStatus = RtlDosPathNameToNtPathName_U(
szLinkName,
&UnicodeName,
NULL,
NULL
);
if (!TranslationStatus)
{
goto exit;
}
FreeBuffer = UnicodeName.Buffer;
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
FsControlCode = FSCTL_GET_REPARSE_POINT;
DesiredAccess = FILE_READ_DATA | SYNCHRONIZE;
CreateOptions = FILE_OPEN_REPARSE_POINT | FILE_SYNCHRONOUS_IO_NONALERT;
//
// Set the tag to mount point.
//
ReparsePointTag = IO_REPARSE_TAG_MOUNT_POINT;
Status = NtOpenFile(
&Handle,
DesiredAccess,
&ObjectAttributes,
&IoStatusBlock,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
CreateOptions
);
RtlFreeHeap( RtlProcessHeap(), 0, FreeBuffer );
if (!NT_SUCCESS(Status))
{
goto exit;
}
ReparseDataLength = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
ReparseBuffer = RtlAllocateHeap(
RtlProcessHeap(),
HEAP_ZERO_MEMORY,
ReparseDataLength
);
if (ReparseBuffer == NULL)
{
goto exit;
}
Status = NtFsControlFile(
Handle,
NULL,
NULL,
NULL,
&IoStatusBlock,
FsControlCode, // no input buffer
NULL, // input buffer length
0,
(PVOID)ReparseBuffer,
ReparseDataLength
);
if (!NT_SUCCESS(Status))
{
NtClose( Handle );
RtlFreeHeap( RtlProcessHeap(), 0, ReparseBufferHeader );
goto exit;
}
NtClose( Handle );
ReparseBufferHeader = (PREPARSE_DATA_BUFFER)ReparseBuffer;
if ((ReparseBufferHeader->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) ||
(ReparseBufferHeader->ReparseTag == IO_REPARSE_TAG_SYMBOLIC_LINK))
{
USHORT Offset = 0;
NtLinkValue.Buffer = &ReparseBufferHeader->SymbolicLinkReparseBuffer.PathBuffer[Offset];
NtLinkValue.Length = ReparseBufferHeader->SymbolicLinkReparseBuffer.SubstituteNameLength;
Offset = NtLinkValue.Length + sizeof(UNICODE_NULL);
DosLinkValue.Buffer = &ReparseBufferHeader->SymbolicLinkReparseBuffer.PathBuffer[Offset/sizeof(WCHAR)];
DosLinkValue.Length = ReparseBufferHeader->SymbolicLinkReparseBuffer.PrintNameLength;
if (cchSize < DosLinkValue.Length / sizeof(TCHAR) +1)
{
RtlFreeHeap( RtlProcessHeap(), 0, ReparseBufferHeader );
goto exit;
}
else
{
int cbLen = DosLinkValue.Length;
LPTSTR lpStart = DosLinkValue.Buffer;
if (DosLinkValue.Length > 4 * sizeof(TCHAR))
{
if ( (DosLinkValue.Buffer[0] == TEXT('\\'))
&& (DosLinkValue.Buffer[1] == TEXT('\\'))
&& (DosLinkValue.Buffer[2] == TEXT('?'))
&& (DosLinkValue.Buffer[3] == TEXT('\\')) )
{
cbLen -= 4 * sizeof(TCHAR);
lpStart += 4;
}
}
//memmove((PBYTE)szLinkValue,(PBYTE)DosLinkValue.Buffer,DosLinkValue.Length);
//szLinkValue[DosLinkValue.Length / sizeof(TCHAR)] = TEXT('\0');
memmove((PBYTE)szLinkValue,(PBYTE)lpStart,cbLen);
szLinkValue[cbLen / sizeof(TCHAR)] = TEXT('\0');
}
}
else
{
RtlFreeHeap( RtlProcessHeap(), 0, ReparseBufferHeader );
goto exit;
}
bRet = TRUE;
RtlFreeHeap( RtlProcessHeap(), 0, ReparseBufferHeader );
exit:
return bRet;
}
typedef struct {
WORD wSuiteMask;
LPTSTR szSuiteName;
} SUITE_INFO;
HRESULT LogMachineInfo()
{
SYSTEMTIME systime;
OSVERSIONINFOEX ov;
TCHAR lpTimeStr[MAX_PATH];
TCHAR lpComputerName[MAX_COMPUTERNAME_LENGTH + 1];
SUITE_INFO c_rgSuite_Info[] = {
{VER_SUITE_BACKOFFICE, TEXT("Microsoft BackOffice")},
{VER_SUITE_BLADE, TEXT("Windows Server 2003, Web Edition")},
{VER_SUITE_DATACENTER, TEXT("Datacenter Server")},
{VER_SUITE_ENTERPRISE, TEXT("Advanced/Enterprise Server")},
{VER_SUITE_PERSONAL, TEXT("Windows XP Home Edition")},
{VER_SUITE_SMALLBUSINESS, TEXT("Small Business Server")},
{VER_SUITE_SMALLBUSINESS_RESTRICTED, TEXT("Restricted Small Business Server")},
{VER_SUITE_TERMINAL, TEXT("Terminal Services")},
{0,NULL}
};
SUITE_INFO *psi;
LCID lcidSys,lcidUser,lcidInstall;
TCHAR szLocalename[MAX_PATH];
TCHAR szSystemDir[MAX_PATH+1];
#define FILESYSNAMEBUFSIZE 1024 // probably more than we need
TCHAR szFileSystemType[FILESYSNAMEBUFSIZE];
DWORD cchSize;
TCHAR szModule[MAX_PATH+1];
TCHAR szCurrRoot[MAX_PATH+1],szExpRoot[MAX_PATH+1];
DWORD cchCurrRoot,cchExpRoot;
HRESULT hr = S_OK;
if (GetModuleFileName(GetModuleHandle(NULL),szModule,ARRAYSIZE(szModule)-1))
{
szModule[ARRAYSIZE(szModule)-1] = TEXT('\0');
DPF(APPmsg, TEXT("CLMT Version: %s started from %s"),TEXT(VER_FILEVERSION_STR),szModule);
}
else
{
DPF(APPmsg, TEXT("CLMT Version: %s"),TEXT(VER_FILEVERSION_STR));
}
GetSystemTime(&systime);
if (GetTimeFormat(LOCALE_USER_DEFAULT,0,&systime,NULL,lpTimeStr,ARRAYSIZE(lpTimeStr)))
{
DPF(APPmsg, TEXT("CLMT started at %s,%d/%d/%d"),lpTimeStr,systime.wMonth,systime.wDay ,systime.wYear );
}
cchSize = ARRAYSIZE(lpComputerName);
if (GetComputerName(lpComputerName,&cchSize))
{
DPF(APPmsg, TEXT("Computer name : %s"),lpComputerName);
}
ov.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if (GetVersionEx((LPOSVERSIONINFO)&ov))
{
TCHAR szProductType[MAX_PATH];
TCHAR szSuiteList[MAX_PATH];
DPF(APPmsg, TEXT("OS Version: %d.%d"),ov.dwMajorVersion,ov.dwMinorVersion);
if (ov.szCSDVersion[0])
{
DPF(APPmsg, TEXT("Service Pack: %s"),ov.szCSDVersion);
}
switch (ov.wProductType )
{
case VER_NT_WORKSTATION:
hr = StringCchCopy(szProductType,ARRAYSIZE(szProductType),TEXT("NT_WORKSTATION"));
break;
case VER_NT_DOMAIN_CONTROLLER:
hr = StringCchCopy(szProductType,ARRAYSIZE(szProductType),TEXT("DOMAIN_CONTROLLER"));
break;
case VER_NT_SERVER :
hr = StringCchCopy(szProductType,ARRAYSIZE(szProductType),TEXT("NT_SERVER"));
break;
default:
hr = StringCchCopy(szProductType,ARRAYSIZE(szProductType),TEXT("Unknow Type"));
}
if (FAILED(hr))
{
return hr;
}
DPF(APPmsg, TEXT("Product Type: %s"),szProductType);
szSuiteList[0] = TEXT('\0');
for (psi = c_rgSuite_Info; psi->szSuiteName; psi++)
{
if (psi->wSuiteMask & ov.wSuiteMask)
{
hr = StringCchCat(szSuiteList,ARRAYSIZE(szSuiteList),psi->szSuiteName);
if (FAILED(hr))
{
break;
}
}
}
if (FAILED(hr))
{
return hr;
}
if (szSuiteList[0])
{
DPF(APPmsg, TEXT("Suite List: %s"),szSuiteList);
}
}
lcidSys = GetSystemDefaultLCID();
lcidUser = GetUserDefaultLCID();
lcidInstall = GetInstallLocale();
if (GetLocaleInfo(lcidInstall,LOCALE_SENGLANGUAGE,szLocalename,ARRAYSIZE(szLocalename)))
{
DPF(APPmsg, TEXT("OS LanguageID/Name: %x,%s"),lcidInstall,szLocalename);
}
else
{
DPF(APPmsg, TEXT("OS LanguageID/Name: %x"),lcidInstall);
}
if (GetLocaleInfo(lcidSys,LOCALE_SENGLANGUAGE,szLocalename,ARRAYSIZE(szLocalename)))
{
DPF(APPmsg, TEXT("System locale ID/Name: %x,%s"),lcidSys,szLocalename);
}
else
{
DPF(APPmsg, TEXT("System locale ID: %x"),lcidSys);
}
if (GetLocaleInfo(lcidUser,LOCALE_SENGLANGUAGE,szLocalename,ARRAYSIZE(szLocalename)))
{
DPF(APPmsg, TEXT("User Locale ID/Name: %x,%s"),lcidUser,szLocalename);
}
else
{
DPF(APPmsg, TEXT("User Locale ID: %x"),lcidUser);
}
if (GetSystemDirectory(szSystemDir, ARRAYSIZE(szSystemDir)))
{
TCHAR DriveRoot[_MAX_DRIVE + 2];
ULARGE_INTEGER FreeBytesAvailable; // bytes available to caller
ULARGE_INTEGER TotalNumberOfBytes; // bytes on disk
ULARGE_INTEGER TotalNumberOfFreeBytes;
DPF(APPmsg, TEXT("System Dir is : %s"),szSystemDir);
_tsplitpath(szSystemDir, DriveRoot, NULL, NULL, NULL);
if (FAILED(hr = StringCchCat(DriveRoot, ARRAYSIZE(DriveRoot), TEXT("\\"))))
{
return hr;
}
if ( GetVolumeInformation(DriveRoot, NULL, 0,
NULL, NULL, NULL, szFileSystemType, ARRAYSIZE(szFileSystemType)) )
{
DPF(APPmsg, TEXT("System Drive File System is : %s"),szFileSystemType);
}
if (GetDiskFreeSpaceEx(szSystemDir,&FreeBytesAvailable,&TotalNumberOfBytes,&TotalNumberOfFreeBytes))
{
TCHAR szFreeBytesAvailable[64],szTotalNumberOfBytes[64],szTotalNumberOfFreeBytes[64];
_ui64tot(FreeBytesAvailable.QuadPart,szFreeBytesAvailable,10);
_ui64tot(TotalNumberOfBytes.QuadPart,szTotalNumberOfBytes,10);
_ui64tot(TotalNumberOfFreeBytes.QuadPart,szTotalNumberOfFreeBytes,10);
DPF(APPmsg, TEXT("Free Space Available for system drive : %s"),szFreeBytesAvailable);
DPF(APPmsg, TEXT("Total Space Available for system drive : %s"),szTotalNumberOfBytes);
DPF(APPmsg, TEXT("Total Free Space Available for system drive : %s"),szTotalNumberOfFreeBytes);
}
}
cchCurrRoot = ARRAYSIZE(szCurrRoot);
cchExpRoot = ARRAYSIZE(szExpRoot);
if ( (GetRegistryValue(HKEY_LOCAL_MACHINE,TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion"),
TEXT("PathName"),(LPBYTE)szExpRoot,&cchExpRoot)==ERROR_SUCCESS)
&& (GetRegistryValue(HKEY_LOCAL_MACHINE,TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion"),
TEXT("SystemRoot"),(LPBYTE)szCurrRoot,&cchCurrRoot)==ERROR_SUCCESS) )
{
szExpRoot[1] = TEXT('\0');
szCurrRoot[1] = TEXT('\0');
if (MyStrCmpI(szExpRoot,szCurrRoot))
{
DPF(APPmsg, TEXT("Warning : System Drive is not correct, supposed to be ---%s Drive---, right now is --- %s Drive ---"),szExpRoot,szCurrRoot);
DPF(APPmsg, TEXT("Warning : This is usually caused by you ghost the image from one partition, and recover to another"));
}
}
return S_OK;
}
HRESULT AddExtraQuoteEtc(
LPTSTR lpszStrIn,
LPTSTR *lplpszStrOut)
{
LPTSTR lpStart,lpAtSpecialChar,lpDest;
DWORD cchSpechialCharCount = 0,cchStrLen;
HRESULT hr;
LPTSTR szSpecialStrList[] = {TEXT("\""),TEXT("%%"),NULL};
int i , nCurrSpecialStr;
TCHAR szTemplate[MAX_PATH];
if (!lpszStrIn || !lplpszStrOut)
{
return E_INVALIDARG;
}
i = 0;
while (szSpecialStrList[i])
{
lpStart = lpszStrIn;
while (lpAtSpecialChar = StrStrI(lpStart,szSpecialStrList[i]))
{
cchSpechialCharCount += lstrlen(szSpecialStrList[i]);
lpStart = lpAtSpecialChar + lstrlen(szSpecialStrList[i]);
}
i++;
}
if (!cchSpechialCharCount)
{
*lplpszStrOut = malloc ( (lstrlen(lpszStrIn) +1) * sizeof(TCHAR));
if (!*lplpszStrOut)
{
return E_OUTOFMEMORY;
}
hr = StringCchCopy(*lplpszStrOut,lstrlen(lpszStrIn) +1,lpszStrIn);
return S_FALSE;
}
cchStrLen = lstrlen(lpszStrIn) + cchSpechialCharCount + 1;
*lplpszStrOut = malloc (cchStrLen * sizeof(TCHAR));
if (!*lplpszStrOut)
{
return E_OUTOFMEMORY;
}
hr = StringCchCopy(*lplpszStrOut,cchStrLen,TEXT(""));
lpStart = lpszStrIn;
lpAtSpecialChar = lpszStrIn;
while (*lpStart)
{
LPTSTR lp1stSpecialChar = NULL;
nCurrSpecialStr = 0;
for (i = 0; szSpecialStrList[i]; i++)
{
lpAtSpecialChar = StrStrI(lpStart,szSpecialStrList[i]);
if (lpAtSpecialChar && !lp1stSpecialChar)
{
lp1stSpecialChar = lpAtSpecialChar;
nCurrSpecialStr = i;
}
else if (lpAtSpecialChar && lp1stSpecialChar)
{
if (lpAtSpecialChar < lp1stSpecialChar)
{
lp1stSpecialChar = lpAtSpecialChar;
nCurrSpecialStr = i;
}
}
}
if (lp1stSpecialChar)
{
TCHAR chTmp = *lp1stSpecialChar;
*lp1stSpecialChar = TEXT('\0');
hr = StringCchCat(*lplpszStrOut,cchStrLen,lpStart);
*lp1stSpecialChar = chTmp;
for (i = 0; i< lstrlen(szSpecialStrList[nCurrSpecialStr])* 2; i++)
{
szTemplate[i] = chTmp;
}
szTemplate[i] = TEXT('\0');
hr = StringCchCat(*lplpszStrOut,cchStrLen,szTemplate);
lpStart = lp1stSpecialChar + lstrlen(szSpecialStrList[nCurrSpecialStr]);
}
else
{
hr = StringCchCat(*lplpszStrOut,cchStrLen,lpStart);
lpStart = lpStart + lstrlen(lpStart);
}
}
return S_OK;
}
HRESULT CopyMyselfTo(LPTSTR lpszDestDir)
{
TCHAR szModule[2*MAX_PATH+1];
LPTSTR lpszNewFile,lpFileName;
DWORD cchLen;
BOOL bCopied;
HRESULT hr;
if (!lpszDestDir || !lpszDestDir[0])
{
return E_INVALIDARG;
}
if (!GetModuleFileName(GetModuleHandle(NULL),szModule,ARRAYSIZE(szModule)-1))
{
szModule[ARRAYSIZE(szModule)-1] = TEXT('\0');
return HRESULT_FROM_WIN32(GetLastError());
}
lpFileName = StrRChrIW(szModule,NULL,TEXT('\\'));
if (!lpFileName)
{
return E_FAIL;
}
lpFileName++;
if (! *lpFileName)
{
return E_FAIL;
}
cchLen = lstrlen(lpszDestDir)+ lstrlen(lpFileName) + 2; // one for "\\", one for ending NULL
if (!(lpszNewFile = malloc(cchLen * sizeof(TCHAR))))
{
return E_OUTOFMEMORY;
}
//We calculte the buffer for lpszNewFile, so here StringCchCopy should be
//always success, assinging return value just make prefast happy
hr = StringCchCopy(lpszNewFile,cchLen,lpszDestDir);
ConcatenatePaths(lpszNewFile,lpFileName,cchLen);
bCopied = CopyFile(szModule,lpszNewFile,FALSE);
if (bCopied)
{
free(lpszNewFile);
return S_OK;
}
else
{
DWORD dw = GetLastError();
DWORD dwAttrib = GetFileAttributes(lpszNewFile);
if ( (dwAttrib & FILE_ATTRIBUTE_READONLY)
||(dwAttrib & FILE_ATTRIBUTE_SYSTEM) )
{
if (SetFileAttributes(lpszNewFile,FILE_ATTRIBUTE_NORMAL))
{
bCopied = CopyFile(szModule,lpszNewFile,FALSE);
if (bCopied)
{
dw = ERROR_SUCCESS;
}
else
{
dw = GetLastError();
}
}
}
free(lpszNewFile);
return HRESULT_FROM_WIN32(dw);
}
}
// local functions
HRESULT SetRunOnceValue (
IN LPCTSTR szValueName,
IN LPCTSTR szValue)
{
HKEY hRunOnceKey = NULL;
DWORD dwStatus = ERROR_SUCCESS;
DWORD cbData;
const TCHAR* szRunOnceKeyPath = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce");
if (NULL == szValueName || TEXT('\0') == szValueName[0])
{
dwStatus = ERROR_INVALID_PARAMETER;
goto SetRunOnceValueEnd;
}
if (NULL == szValue || TEXT('\0') == szValue[0])
{
dwStatus = ERROR_INVALID_PARAMETER;
goto SetRunOnceValueEnd;
}
dwStatus = RegOpenKey (HKEY_LOCAL_MACHINE, szRunOnceKeyPath, &hRunOnceKey);
if (ERROR_SUCCESS != dwStatus)
{
goto SetRunOnceValueEnd;
}
cbData = ( lstrlen(szValue) + 1) * sizeof(TCHAR);
dwStatus = RegSetValueEx (hRunOnceKey,
szValueName,
0, // Reserved
REG_SZ,
(CONST BYTE *) szValue,
cbData);
SetRunOnceValueEnd:
if (hRunOnceKey)
{
RegCloseKey(hRunOnceKey);
}
return HRESULT_FROM_WIN32(dwStatus);
}
//-----------------------------------------------------------------------
//
// Function: SetRunValue
//
// Descrip:
//
// Returns: BOOL
//
// Notes: none
//
// History:
//
// Notes:
//
//-----------------------------------------------------------------------
HRESULT SetRunValue(
LPCTSTR szValueName,
LPCTSTR szValue
)
{
HKEY hRunKey = NULL;
DWORD dwStatus = ERROR_SUCCESS;
DWORD cbData;
if (NULL == szValueName || TEXT('\0') == szValueName[0] ||
NULL == szValue || TEXT('\0') == szValue[0])
{
return E_INVALIDARG;
}
dwStatus = RegOpenKey(HKEY_LOCAL_MACHINE, TEXT_RUN_KEY, &hRunKey);
if (ERROR_SUCCESS == dwStatus)
{
cbData = (lstrlen(szValue) + 1) * sizeof(TCHAR);
dwStatus = RegSetValueEx(hRunKey,
szValueName,
0,
REG_SZ,
(CONST BYTE *) szValue,
cbData);
RegCloseKey(hRunKey);
}
return (HRESULT_FROM_WIN32(dwStatus));
}
/*************************************************************
*
* CreateSd(void)
* Creates a SECURITY_DESCRIPTOR for administrators group.
*
* NOTES:
* Caller must free the returned buffer if not NULL.
*
* RETURN CODES:
*
*************************************************************/
HRESULT CreateAdminsSd( PSECURITY_DESCRIPTOR *ppSD)
{
SID_IDENTIFIER_AUTHORITY sia = SECURITY_NT_AUTHORITY;
PSID BuiltInAdministrators = NULL;
PSECURITY_DESCRIPTOR Sd = NULL;
ULONG AclSize;
ACL *Acl;
HRESULT hr;
if( ! AllocateAndInitializeSid(
&sia,
2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&BuiltInAdministrators
))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
//
// Calculate the size of and allocate a buffer for the DACL, we need
// this value independently of the total alloc size for ACL init.
//
//
// "- sizeof (ULONG)" represents the SidStart field of the
// ACCESS_ALLOWED_ACE. Since we're adding the entire length of the
// SID, this field is counted twice.
// See detail in InitializeAcl in MSDN
AclSize = sizeof (ACL) +
(sizeof (ACCESS_ALLOWED_ACE) - sizeof (ULONG)) +
GetLengthSid(BuiltInAdministrators) ;
Sd = LocalAlloc(LMEM_FIXED + LMEM_ZEROINIT,
SECURITY_DESCRIPTOR_MIN_LENGTH + AclSize);
if (!Sd)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
Acl = (ACL *)((BYTE *)Sd + SECURITY_DESCRIPTOR_MIN_LENGTH);
if (!InitializeAcl(Acl,
AclSize,
ACL_REVISION))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
//#define ACCESS_ALL GENERIC_ALL | STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL
if (!AddAccessAllowedAce(Acl,
ACL_REVISION,
//GENERIC_READ | GENERIC_WRITE,
GENERIC_ALL,
BuiltInAdministrators))
{
// Failed to build the ACE granting "Built-in Administrators"
// STANDARD_RIGHTS_ALL access.
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (!InitializeSecurityDescriptor(Sd,SECURITY_DESCRIPTOR_REVISION))
{
// error
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (!SetSecurityDescriptorDacl(Sd,
TRUE,
Acl,
FALSE))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
*ppSD = Sd;
hr = S_OK;
Exit:
/* A jump of last resort */
if (hr != S_OK)
{
*ppSD = NULL;
if (Sd)
{
LocalFree(Sd);
} // error
}
if (BuiltInAdministrators)
{
FreeSid(BuiltInAdministrators);
}
return hr;
}
/*************************************************************
*
* MyStrCmpIA/W
* Do locale independent string comparison(case-insensive)
*
* NOTES:
* It's just a wrapper for CompareString with LOCALE_INVARIANT
* we can not use LOCALE_INVARIANT since this is XP+ only
*
* RETURN CODES: see lstrcmpi in MSDN
*
*************************************************************/
int MyStrCmpIW(
LPCWSTR lpString1,
LPCWSTR lpString2)
{
return ( CompareStringW(LOCALE_ENGLISH, NORM_IGNORECASE,
lpString1, -1, lpString2, -1) - 2);
}
int MyStrCmpIA(
LPCSTR lpString1,
LPCSTR lpString2)
{
return ( CompareStringA(LOCALE_ENGLISH, NORM_IGNORECASE,
lpString1, -1, lpString2, -1) - 2);
}
//-----------------------------------------------------------------------
//
// Function: MergeDirectory
//
// Descrip: Merge the contents inside source directory to destination
// directory. If file/folder in source dir does not exist in
// destination dir, we will add it to CLMTDO.inf. These files
// or folders will be moved in DoCriticalWork().
//
// Returns: S_OK if function succeeded.
// S_FALSE if source directory does not exist
// else if error occured
//
// Notes: none
//
// History: 04/30/2002 rerkboos created
//
// Notes: none
//
//-----------------------------------------------------------------------
HRESULT MergeDirectory(
LPCTSTR lpSrcDir,
LPCTSTR lpDstDir
)
{
HRESULT hr = S_OK;
BOOL bRet;
WIN32_FIND_DATA FindFileData;
HANDLE hFile;
TCHAR szDstFile[MAX_PATH];
TCHAR szSrcFile[MAX_PATH];
TCHAR szSearchPath[MAX_PATH];
if (!IsDirExisting((LPTSTR) lpSrcDir))
{
return S_FALSE;
}
// Destination directory does not exist, no need to do a merge
if (!IsDirExisting((LPTSTR) lpDstDir))
{
hr = AddFolderRename((LPTSTR)lpSrcDir, (LPTSTR)lpDstDir, TYPE_DIR_MOVE, NULL);
return hr;
}
hr = StringCchCopy(szSearchPath, ARRAYSIZE(szSearchPath), lpSrcDir);
if (SUCCEEDED(hr))
{
bRet = ConcatenatePaths(szSearchPath, TEXT("*"), ARRAYSIZE(szSearchPath));
if (!bRet)
{
hr = E_UNEXPECTED;
return hr;
}
}
else
{
return hr;
}
//
// Check all files and subdirectores under Source directory
// Merge contents to destination directory as appropriate
//
hFile = FindFirstFileEx(szSearchPath,
FindExInfoStandard,
&FindFileData,
FindExSearchLimitToDirectories,
NULL,
0);
if (hFile != INVALID_HANDLE_VALUE)
{
while (SUCCEEDED(hr))
{
// Ignore "." and ".." folders
if (lstrcmp(FindFileData.cFileName, TEXT(".")) != LSTR_EQUAL
&& lstrcmp(FindFileData.cFileName, TEXT("..")) != LSTR_EQUAL)
{
hr = StringCchCopy(szDstFile, ARRAYSIZE(szDstFile), lpDstDir)
|| StringCchCopy(szSrcFile, ARRAYSIZE(szSrcFile), lpSrcDir);
if (FAILED(hr))
{
break;
}
bRet = ConcatenatePaths(szDstFile,
FindFileData.cFileName,
ARRAYSIZE(szDstFile))
&& ConcatenatePaths(szSrcFile,
FindFileData.cFileName,
ARRAYSIZE(szSrcFile));
if (!bRet)
{
hr = E_UNEXPECTED;
break;
}
//
// Check if the file is a directory or not
//
if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
// The file is a directory, do a recursive call
// to merge contents inside it
hr = MergeDirectory(szSrcFile, szDstFile);
if (FAILED(hr))
{
break;
}
}
else
{
// This is just a file, move the file to destination folder
// if file does not exist in destination folder
if (!IsFileFolderExisting(szDstFile))
{
hr = AddFolderRename(szSrcFile, szDstFile, TYPE_FILE_MOVE, NULL);
if (FAILED(hr))
{
break;
}
}
}
}
// Get the next file in source directory
bRet = FindNextFile(hFile, &FindFileData);
if (!bRet)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
FindClose(hFile);
if (HRESULT_CODE(hr) == ERROR_NO_MORE_FILES)
{
// No more files in source directory, function succeeded
hr = S_OK;
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
return hr;
}
HRESULT IsNTFS(
IN LPTSTR lpszPathRoot,
OUT BOOL *pbIsNTFS)
{
TCHAR DriveRoot[_MAX_DRIVE + 2];
BOOL bIsNTFS = FALSE;
TCHAR szFileSystemType[FILESYSNAMEBUFSIZE];
HRESULT hr = S_OK;
_tsplitpath(lpszPathRoot, DriveRoot, NULL, NULL, NULL);
if (!pbIsNTFS || !lpszPathRoot || !lpszPathRoot[0])
{
hr = E_INVALIDARG;
goto Exit;
}
hr = StringCchCat(DriveRoot, ARRAYSIZE(DriveRoot), TEXT("\\"));
if (FAILED(hr))
{
hr = E_INVALIDARG;
goto Exit;
}
if (! GetVolumeInformation(DriveRoot, NULL, 0,
NULL, NULL, NULL, szFileSystemType, ARRAYSIZE(szFileSystemType)) )
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (!MyStrCmpI(szFileSystemType,TEXT("NTFS")))
{
bIsNTFS = TRUE;
}
*pbIsNTFS = bIsNTFS;
Exit:
return hr;
}
HRESULT IsSysVolNTFS(OUT BOOL *pbIsNTFS)
{
TCHAR szWindir[MAX_PATH+1];
if (!GetSystemWindowsDirectory(szWindir, ARRAYSIZE(szWindir)))
{
return (HRESULT_FROM_WIN32(GetLastError()));
}
return IsNTFS(szWindir,pbIsNTFS);
}
BOOL
CALLBACK
DoCriticalDlgProc(
HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
static HWND hButton1, hButton2, hProgress, hText,hOK, hAdminText;
static TCHAR szOK[64], szSTART[64],szCANCEL[64],szCRITICALUPDATING[MAX_PATH],
szREMIND_DO_CRITICAL[1024],szREBOOTING[MAX_PATH],
szAdminChange[512];
static DWORD dwTimerProgressDone = 10000, dwTimerTickIncrement = 500 , dwTimerTicks;
static UINT_PTR dwTimer;
TCHAR szOldAdminName[MAX_PATH];
int nRet;
BOOL bRet;
HRESULT hr;
static BOOL bSysUpdated;
#define ID_TIMER 1
switch (uMsg)
{
case WM_INITDIALOG:
// Init the dialog
ShowWindow(hwndDlg, SW_SHOWNORMAL);
dwTimerTicks = 0;
bSysUpdated = FALSE;
LoadString(g_hInstDll,IDS_OK,szOK,ARRAYSIZE(szOK));
LoadString(g_hInstDll,IDS_START,szSTART,ARRAYSIZE(szSTART));
LoadString(g_hInstDll,IDS_CANCEL,szCANCEL,ARRAYSIZE(szCANCEL));
LoadString(g_hInstDll,IDS_REMIND_DO_CRITICAL,szREMIND_DO_CRITICAL,
ARRAYSIZE(szREMIND_DO_CRITICAL));
LoadString(g_hInstDll,IDS_CRITICALUPDATING,szCRITICALUPDATING,
ARRAYSIZE(szCRITICALUPDATING));
LoadString(g_hInstDll,IDS_REBOOTING,szREBOOTING,ARRAYSIZE(szREBOOTING));
hButton1 = GetDlgItem(hwndDlg, ID_BUTTON_1);
hButton2 = GetDlgItem(hwndDlg, ID_BUTTON_2);
hProgress = GetDlgItem(hwndDlg, IDC_PROGRESS);
hText = GetDlgItem(hwndDlg, IDC_STATIC);
hOK = GetDlgItem(hwndDlg, IDOK);
ShowWindow(hProgress,SW_HIDE);
ShowWindow(hOK,SW_HIDE);
SetWindowText(hButton1,szSTART);
SetWindowText(hButton2,szCANCEL);
SetWindowText(hText,szREMIND_DO_CRITICAL);
SendMessage(hProgress, PBM_SETRANGE, 0, MAKELPARAM(0, dwTimerProgressDone ));
SetForegroundWindow(hwndDlg);
break;
case WM_COMMAND:
// Handle command buttons
switch (wParam)
{
case ID_BUTTON_1:
if (bSysUpdated)
{
break;
}
bSysUpdated = TRUE;
SetWindowText(hText,szCRITICALUPDATING);
ShowWindow(hButton1,SW_HIDE);
ShowWindow(hButton2,SW_HIDE);
hr = DoCriticalWork();
if (SUCCEEDED(hr))
{
bSysUpdated = TRUE;
ShowWindow(hOK,SW_SHOW);
SetFocus(hOK);
DefDlgProc(hwndDlg,DM_SETDEFID, IDOK, 0);
dwTimer = SetTimer(hwndDlg,ID_TIMER,dwTimerTickIncrement,NULL);
if (dwTimer)
{
ShowWindow(hProgress,SW_SHOW);
SetWindowText(hText,szREBOOTING);
}
}
break;
case ID_BUTTON_2:
nRet = DoMessageBox(GetConsoleWindow(), IDS_CONFIRM,
IDS_MAIN_TITLE, MB_YESNO|MB_SYSTEMMODAL);
if (IDYES == nRet)
{
EndDialog(hwndDlg, ID_BUTTON_2);
}
break;
case IDOK:
if (bSysUpdated)
{
EndDialog(hwndDlg, ID_UPDATE_DONE);
}
else
{
EndDialog(hwndDlg, IDOK);
}
break;
case ID_UPDATE_DONE:
EndDialog(hwndDlg, ID_UPDATE_DONE);
break;
}
break;
case WM_TIMER:
dwTimerTicks += dwTimerTickIncrement;
if (dwTimerTicks > dwTimerProgressDone)
{
KillTimer(hwndDlg, dwTimer);
PostMessage(hwndDlg, WM_COMMAND, ID_UPDATE_DONE, 0);
}
SendMessage(hProgress, PBM_SETPOS,dwTimerTicks,0);
break;
case WM_CLOSE:
EndDialog(hwndDlg, IDCANCEL);
break;
default:
break;
}
return FALSE;
}
HRESULT DoCriticalWork ()
{
#ifdef CONSOLE_UI
wprintf(TEXT("updating system settings, !!! Do not Interrupt......\n"));
#endif
DPF(APPmsg, TEXT("Enter DoCriticalWork:"));
BoostMyPriority();
MakeDOInfCopy();
g_hInfDoItem = SetupOpenInfFile(g_szToDoINFFileName,
NULL,
INF_STYLE_WIN4,
NULL);
if (g_hInfDoItem != INVALID_HANDLE_VALUE)
{
Remove16bitFEDrivers();
ResetServicesStatus(g_hInfDoItem, TEXT_SERVICE_STATUS_SECTION);
ResetServicesStartUp(g_hInfDoItem, TEXT_SERVICE_STARTUP_SECTION);
// ReconfigureServices(g_hInf);
BatchUpateIISMetabase(g_hInfDoItem,TEXT("Reg.Update.$MetaBase"));
BatchFixPathInLink(g_hInfDoItem,TEXT("LNK"));
BatchINFUpdate(g_hInfDoItem);
FolderMove(g_hInfDoItem,TEXT("Folder.ObjectRename"),FALSE);
LoopUser(FinalUpdateRegForUser);
// The EnumUserProfile() will be enable after RC 1
// EnumUserProfile(ResetMiscProfilePathPerUser);
UsrGrpAndDoc_and_SettingsRename(g_hInfDoItem,FALSE);
UpdateDSObjProp(g_hInfDoItem,DS_OBJ_PROPERTY_UPDATE);
INFCreateHardLink(g_hInfDoItem,FOLDER_UPDATE_HARDLINK,FALSE);
SetInstallLocale(0x0409);
SetProtectedRenamesFlag(TRUE);
RegUpdate(g_hInfDoItem, NULL , TEXT(""));
SetupCloseInfFile(g_hInfDoItem);
DPF(APPmsg, TEXT("Leaving DoCriticalWork:"));
return S_OK;
}
DPF(APPmsg, TEXT("Leaving DoCriticalWork:"));
return HRESULT_FROM_WIN32( GetLastError() );
}
HRESULT RenameRegRoot (
LPCTSTR lpSrcStr,
LPTSTR lpDstStr,
DWORD dwSize,
LPCTSTR lpUserSid,
LPCTSTR lpKeyName)
{
HRESULT hResult;
TCHAR szKeyBuf[2*MAX_PATH];
TCHAR cNonChar = TEXT('\xFFFF');
if (StrStrI(lpSrcStr, TEXT("HKLM")))
ReplaceString(lpSrcStr,TEXT("HKLM"),TEXT("MACHINE"),szKeyBuf, MAX_PATH*2,&cNonChar, NULL, NULL, TRUE);
else if (StrStrI(lpSrcStr, TEXT("HKCR")))
ReplaceString(lpSrcStr,TEXT("HKCR"),TEXT("CLASSES_ROOT"),szKeyBuf, MAX_PATH*2,&cNonChar, NULL, NULL, TRUE);
else if (StrStrI(lpSrcStr, TEXT("HKCU")))
ReplaceString(lpSrcStr,TEXT("HKCU"),TEXT("CURRENT_USER"),szKeyBuf, MAX_PATH*2,&cNonChar, NULL, NULL, TRUE);
else
hResult = StringCchPrintf(szKeyBuf, 2*MAX_PATH, TEXT("USERS\\%s%s"), lpUserSid, lpSrcStr);
if (lpKeyName)
hResult = StringCchPrintf(lpDstStr, dwSize, TEXT("%s\\%s"), szKeyBuf, lpKeyName);
else
hResult = StringCchCopy(lpDstStr, dwSize, szKeyBuf);
return hResult;
}
DWORD AdjustRegSecurity (
HKEY hRootKey,
LPCTSTR lpSubKeyName, // Registry sub key path
LPCTSTR lpszUsersid, // User Sid
BOOL bSetOrRestore // set or restore the security setting
)
{
DWORD dwRet;
HRESULT hr;
TCHAR szKeyName[MAX_PATH*2];
TCHAR szKeyBuf[MAX_PATH*2];
if (lpszUsersid && *lpszUsersid)
{
if (FAILED(hr = StringCchPrintf(szKeyName, MAX_PATH*2-1, TEXT("\\%s"), lpSubKeyName)))
goto Exit1;
}
else if (hRootKey == HKEY_LOCAL_MACHINE)
{
if (FAILED(hr = StringCchPrintf(szKeyName, MAX_PATH*2-1, TEXT("HKLM\\%s"), lpSubKeyName)))
goto Exit1;
}
else if (hRootKey == HKEY_CLASSES_ROOT)
{
if (FAILED(hr = StringCchPrintf(szKeyName, MAX_PATH*2-1, TEXT("HKCR\\%s"), lpSubKeyName)))
goto Exit1;
}
RenameRegRoot(szKeyName, szKeyBuf, 2*MAX_PATH-1, lpszUsersid, NULL);
dwRet = AdjustObjectSecurity(szKeyBuf, SE_REGISTRY_KEY, bSetOrRestore);
goto Exit;
Exit1:
dwRet = HRESULT_CODE(hr);
Exit:
return dwRet;
}
//-----------------------------------------------------------------------------
//
// Function: GetFirstNTFSDrive
//
// Descrip: Get the first NTFS drive in the system.
//
// Returns: S_OK - Found NTFS partition
// S_FALSE - NTFS partition not found, return system drive instead
// Else - Error occured
//
// Notes: none
//
// History: 04/25/2002 Rerkboos Created
//
// Notes: none
//
//-----------------------------------------------------------------------------
HRESULT GetFirstNTFSDrive(
LPTSTR lpBuffer, // Buffer to store first NTFS drive
DWORD cchBuffer // Size of buffer in TCHAR
)
{
HRESULT hr = S_OK;
DWORD dwRet;
TCHAR szDrives[MAX_PATH];
LPCTSTR lpDrive;
BOOL bIsNTFS = FALSE;
dwRet = GetLogicalDriveStrings(ARRAYSIZE(szDrives), szDrives);
if (dwRet > 0)
{
lpDrive = MultiSzTok(szDrives);
while (lpDrive != NULL)
{
hr = IsNTFS((LPTSTR) lpDrive, &bIsNTFS);
if (SUCCEEDED(hr))
{
if (bIsNTFS)
{
lstrcpyn(lpBuffer, lpDrive, 3);
return S_OK;
}
}
lpDrive = MultiSzTok(NULL);
}
}
// If we reach here, no NTFS partition is found
// return System drive to caller instead
hr = S_FALSE;
if (!GetEnvironmentVariable(TEXT("HOMEDRIVE"), lpBuffer, cchBuffer))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
return hr;
}
//-----------------------------------------------------------------------------
//
// Function: DuplicateString
//
// Synopsis: Duplicate the orinal string to a newly allocated buffer.
//
// Returns: S_OK if succeeded
//
// History: 06/03/2002 rerkboos created
//
// Notes: Caller need to free the allocated buffer using MEMFREE() macro
// or HeapFree() API.
//
//-----------------------------------------------------------------------------
HRESULT DuplicateString(
LPTSTR *plpDstString, // Pointer to the newly allocated buffer
LPDWORD lpcchDstString, // Pointer to store size of buffer (in TCHAR)
LPCTSTR lpOrgString // Original string to duplicate
)
{
HRESULT hr;
if (plpDstString == NULL || lpcchDstString == NULL)
{
return E_INVALIDARG;
}
*lpcchDstString = lstrlen(lpOrgString) + 1;
*plpDstString = MEMALLOC(*lpcchDstString * sizeof(TCHAR));
if (*plpDstString != NULL)
{
hr = StringCchCopy(*plpDstString,
*lpcchDstString,
lpOrgString);
if (FAILED(hr))
{
// Free the memory if failed to copy the string
MEMFREE(*plpDstString);
}
}
else
{
*lpcchDstString = 0;
hr = E_OUTOFMEMORY;
}
return hr;
}
HRESULT
SetProtectedRenamesFlag(
BOOL bSet
)
{
HKEY hKey;
long rslt = ERROR_SUCCESS;
HRESULT hr = S_OK;
rslt = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("System\\CurrentControlSet\\Control\\Session Manager"),
0,
KEY_SET_VALUE,
&hKey);
if (rslt == ERROR_SUCCESS)
{
DWORD Value = bSet ? 1 : 0;
rslt = RegSetValueEx(hKey,
TEXT("AllowProtectedRenames"),
0,
REG_DWORD,
(LPBYTE)&Value,
sizeof(DWORD));
RegCloseKey(hKey);
if (rslt != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(rslt);
}
}
else
{
hr = HRESULT_FROM_WIN32(rslt);
}
return hr;
}
LONG SDBCleanup(
OUT LPTSTR lpSecDatabase,
IN DWORD cchLen,
OUT LPBOOL lpCleanupFailed
)
{
char aszSdbFile[MAX_PATH+1+MAX_PATH];
TCHAR wszSdbFile[MAX_PATH+1+MAX_PATH];
TCHAR wszWindir[MAX_PATH+1];
TCHAR szSdbLogFiles[MAX_PATH+1+MAX_PATH];
TCHAR szSdbLogFileRoot[MAX_PATH+1+MAX_PATH],szBackupLogFileRoot[MAX_PATH+1+MAX_PATH];
JET_DBINFOMISC jetdbinfo;
JET_ERR jetError;
long lerr = ERROR_SUCCESS;
HRESULT hr;
if (!GetSystemWindowsDirectory(wszSdbFile, ARRAYSIZE(wszSdbFile)-MAX_PATH))
{
DPF(APPerr, TEXT("Failed to get WINDIR"));
lerr = GetLastError();
goto EXIT;
}
if (!GetSystemWindowsDirectory(wszWindir, ARRAYSIZE(wszWindir)))
{
DPF(APPerr, TEXT("Failed to get WINDIR"));
lerr = GetLastError();
goto EXIT;
}
hr = StringCchCopy(szSdbLogFiles,ARRAYSIZE(szSdbLogFiles),wszWindir);
hr = StringCchCopy(szSdbLogFileRoot,ARRAYSIZE(szSdbLogFileRoot),wszWindir);
hr = StringCchCopy(szBackupLogFileRoot,ARRAYSIZE(szBackupLogFileRoot),wszWindir);
ConcatenatePaths(szSdbLogFileRoot,TEXT("\\Security"),ARRAYSIZE(szSdbLogFileRoot));
ConcatenatePaths(szBackupLogFileRoot,TEXT("\\$CLMT_BACKUP$"),ARRAYSIZE(szBackupLogFileRoot));
ConcatenatePaths(szSdbLogFiles,TEXT("\\Security\\edb?????.log"),ARRAYSIZE(szSdbLogFiles));
hr = StringCbCat(wszSdbFile, ARRAYSIZE(wszSdbFile), TEXT("\\Security\\Database\\secedit.sdb"));
if (lpSecDatabase)
{
hr = StringCchCopy(lpSecDatabase,cchLen,wszSdbFile);
}
WideCharToMultiByte( CP_ACP, 0, wszSdbFile, -1,aszSdbFile,ARRAYSIZE(aszSdbFile),NULL,NULL);
jetError = JetGetDatabaseFileInfo(aszSdbFile,&jetdbinfo,sizeof(JET_DBINFOMISC),JET_DbInfoMisc);
if (jetError != JET_errSuccess)
{
if (JET_errFileNotFound == jetError)
{
lerr = ERROR_SUCCESS;
}
else
{
lerr = jetError;
}
goto EXIT;
}
EXIT:
if (lerr == ERROR_SUCCESS)
{
if (jetdbinfo.dbstate == 2)
{
if (lpCleanupFailed)
{
*lpCleanupFailed = TRUE;
}
}
else
{
WIN32_FIND_DATA FindFileData;
HANDLE hFile = FindFirstFile(szSdbLogFiles,&FindFileData);
if (hFile != INVALID_HANDLE_VALUE)
{
do
{
TCHAR szOld[MAX_PATH+1+MAX_PATH],szNew[MAX_PATH+1+MAX_PATH];
hr = StringCchCopy(szOld,ARRAYSIZE(szOld),szSdbLogFileRoot);
hr = StringCchCopy(szNew,ARRAYSIZE(szNew),szBackupLogFileRoot);
ConcatenatePaths(szOld,FindFileData.cFileName ,ARRAYSIZE(szOld));
ConcatenatePaths(szNew,FindFileData.cFileName ,ARRAYSIZE(szNew));
AddFolderRename(szOld,szNew,TYPE_FILE_MOVE,NULL);
}while (FindNextFile(hFile,&FindFileData));
FindClose(hFile);
}
if (lpCleanupFailed)
{
*lpCleanupFailed = FALSE;
}
}
}
return lerr;
}
//-----------------------------------------------------------------------
//
// Function: DeleteDirectory
//
// Descrip: Delete the directory and files inside.
//
// Returns: S_OK if function succeeded.
// S_FALSE if source directory does not exist
// else if error occured
//
// Notes: none
//
// History: 07/13/2002 rerkboos created
//
// Notes: none
//
//-----------------------------------------------------------------------
HRESULT DeleteDirectory(
LPCTSTR lpDir
)
{
HRESULT hr = S_OK;
BOOL bRet;
WIN32_FIND_DATA FindFileData;
HANDLE hFile;
TCHAR szFile[2 * MAX_PATH];
TCHAR szSearchPath[2 * MAX_PATH];
if (!IsDirExisting((LPTSTR) lpDir))
{
return S_FALSE;
}
// Compose the file path inside specified directory
hr = StringCchCopy(szSearchPath, ARRAYSIZE(szSearchPath), lpDir);
if (SUCCEEDED(hr))
{
bRet = ConcatenatePaths(szSearchPath, TEXT("*"), ARRAYSIZE(szSearchPath));
if (!bRet)
{
hr = E_UNEXPECTED;
return hr;
}
}
else
{
return hr;
}
//
// Delete all files and subdirectores under specified directory
//
hFile = FindFirstFileEx(szSearchPath,
FindExInfoStandard,
&FindFileData,
FindExSearchLimitToDirectories,
NULL,
0);
if (hFile != INVALID_HANDLE_VALUE)
{
while (SUCCEEDED(hr))
{
// Ignore "." and ".." folders
if (MyStrCmpI(FindFileData.cFileName, TEXT(".")) != LSTR_EQUAL
&& MyStrCmpI(FindFileData.cFileName, TEXT("..")) != LSTR_EQUAL)
{
hr = StringCchCopy(szFile, ARRAYSIZE(szFile), lpDir);
if (FAILED(hr))
{
break;
}
bRet = ConcatenatePaths(szFile,
FindFileData.cFileName,
ARRAYSIZE(szFile));
if (!bRet)
{
hr = E_UNEXPECTED;
break;
}
//
// Check if the file is a directory or not
//
if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
// The file is a directory, do a recursive call
// to delete contents inside it
hr = DeleteDirectory(szFile);
if (FAILED(hr))
{
break;
}
}
else
{
// This is just a file, delete it
bRet = DeleteFile(szFile);
if (!bRet)
{
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
}
}
// Get the next file in source directory
bRet = FindNextFile(hFile, &FindFileData);
if (!bRet)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
FindClose(hFile);
if (HRESULT_CODE(hr) == ERROR_NO_MORE_FILES)
{
// Delete itself
bRet = RemoveDirectory(lpDir);
if (bRet)
{
// function succeeded
hr = S_OK;
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
return hr;
}
//-----------------------------------------------------------------------
//
// Function: MyDeleteFile
//
// Descrip: Delete the specified file. The function will set the file
// attribute to Normal before deletion
//
// Returns: S_OK if function succeeded.
// S_FALSE if source directory does not exist
// else if error occured
//
// Notes: none
//
// History: 07/13/2002 rerkboos created
//
// Notes: none
//
//-----------------------------------------------------------------------
HRESULT MyDeleteFile(
LPCTSTR lpFile
)
{
HRESULT hr;
BOOL bRet;
bRet = SetFileAttributes(lpFile, FILE_ATTRIBUTE_NORMAL);
if (bRet)
{
bRet = DeleteFile(lpFile);
}
hr = (bRet ? S_OK : HRESULT_FROM_WIN32(GetLastError()));
return hr;
}
HRESULT GetDCInfo(
PBOOL pbIsDC,//whether is a DC
LPTSTR lpszDCName,//if is DC, the DC name
PDWORD pcchLen)//buffer size for lpszDCName
{
PBYTE pdsInfo = NULL;
DWORD dwErr = ERROR_SUCCESS;
HRESULT hr = S_OK;
if (!pbIsDC)
{
hr = E_INVALIDARG;
goto Exit;
}
//
// Check if the machine is Domain Controller or not
//
dwErr = DsRoleGetPrimaryDomainInformation(NULL,
DsRolePrimaryDomainInfoBasic,
&pdsInfo);
if (dwErr == ERROR_SUCCESS)
{
DSROLE_MACHINE_ROLE dsMachineRole;
dsMachineRole = ((DSROLE_PRIMARY_DOMAIN_INFO_BASIC *) pdsInfo)->MachineRole;
if (dsMachineRole == DsRole_RoleBackupDomainController ||
dsMachineRole == DsRole_RolePrimaryDomainController)
{
*pbIsDC = TRUE;
if (pcchLen)
{
if (lpszDCName)
{
hr = StringCchCopy(lpszDCName,*pcchLen,
((DSROLE_PRIMARY_DOMAIN_INFO_BASIC *) pdsInfo)->DomainNameFlat);
}
//
*pcchLen = lstrlen(((DSROLE_PRIMARY_DOMAIN_INFO_BASIC *) pdsInfo)->DomainNameFlat)+ 1;
}
}
else
{
*pbIsDC = FALSE;
}
}
else
{
hr = HRESULT_FROM_WIN32(dwErr);
pdsInfo = NULL;
goto Exit;
}
Exit:
if (pdsInfo)
{
DsRoleFreeMemory(pdsInfo);
}
return hr;
}
HRESULT GetFQDNForExchange2k(LPTSTR *lplpFQDN)
{
LPTSTR lpExchangeFormat = TEXT("LDAP://CN=1,CN=SMTP,CN=Protocols,CN=%s,CN=Servers,CN=%s,CN=Administrative Groups,CN=%s,CN=Microsoft Exchange,CN=Services,CN=Configuration,%s");
BOOL bIsDC;
TCHAR szDcName[MAX_PATH+1],szCompname[MAX_PATH+1];
DWORD cchSize;
TCHAR szCurrUsrname[MAX_PATH+1];
LPTSTR lpFQDNCurrUsr = NULL,lpFQDNSuffix,lpFQDNWithldap = NULL;
DWORD cchPathWithLDAP;
TCHAR szExchgeReg[2*MAX_PATH];
LPTSTR lpszAdminGroupName = NULL,lpszOrgName = NULL,lpStart,lpEnd;
TCHAR cTmp;
HRESULT hr;
LONG lstatus;
cchSize = ARRAYSIZE(szCurrUsrname);
if (!GetUserName(szCurrUsrname, &cchSize))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
cchSize = ARRAYSIZE(szDcName);
hr = GetDCInfo(&bIsDC,szDcName,&cchSize);
if (FAILED(hr) || !bIsDC)
{
if (!bIsDC)
{
hr =S_FALSE;
}
goto Exit;
}
cchSize = ARRAYSIZE(szCompname);
if (!GetComputerName(szCompname,&cchSize))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (S_OK !=GetFQDN(szCurrUsrname,szDcName,&lpFQDNCurrUsr))
{
lpFQDNCurrUsr = NULL;
goto Exit;
}
lpFQDNSuffix = StrStrI(lpFQDNCurrUsr, TEXT("=Users,"));
if (!lpFQDNSuffix)
{
hr = S_FALSE;
goto Exit;
}
lpFQDNSuffix += lstrlen(TEXT("=Users,"));
cchSize = ARRAYSIZE(szExchgeReg);
lstatus= RegGetValue(HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Services\\SMTPSVC\\Parameters"),
TEXT("SiteDN"), NULL, (LPBYTE)szExchgeReg, &cchSize);
if (ERROR_SUCCESS != lstatus)
{
hr = HRESULT_FROM_WIN32(lstatus);
goto Exit;
}
lpszAdminGroupName = malloc(ARRAYSIZE(szExchgeReg) * sizeof(TCHAR));
lpszOrgName = malloc(ARRAYSIZE(szExchgeReg) * sizeof(TCHAR));
if (!lpszAdminGroupName || !lpszOrgName)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
//try to get exchnage admin group group name
//by default it is First Administrative Group
lpStart = StrStrI(szExchgeReg, TEXT("/ou="));
if (lpStart)
{
lpStart = lpStart + lstrlen(TEXT("/ou="));
if (!*lpStart)
{
hr = S_FALSE;
goto Exit;
}
}
else
{
hr = S_FALSE;
goto Exit;
}
lpEnd = StrStrI(lpStart, TEXT("/"));
if (lpEnd)
{
cTmp = *lpEnd;
*lpEnd = TEXT('\0');
}
hr = StringCchCopy(lpszAdminGroupName,ARRAYSIZE(szExchgeReg),lpStart);
if (lpEnd)
{
*lpEnd = cTmp;
}
//try to get ornization name
lpStart = StrStrI(szExchgeReg, TEXT("/o="));
if (lpStart)
{
lpStart = lpStart + lstrlen(TEXT("/o="));
if (!*lpStart)
{
hr = S_FALSE;
goto Exit;
}
}
else
{
hr = S_FALSE;
goto Exit;
}
lpEnd = StrStrI(lpStart, TEXT("/"));
if (lpEnd)
{
cTmp = *lpEnd;
*lpEnd = TEXT('\0');
}
hr = StringCchCopy(lpszOrgName,ARRAYSIZE(szExchgeReg),lpStart);
if (lpEnd)
{
*lpEnd = cTmp;
}
cchPathWithLDAP = lstrlen(lpFQDNSuffix) + lstrlen(szDcName) + lstrlen(szCompname)
+ lstrlen(lpExchangeFormat) + lstrlen(lpszOrgName)
+ lstrlen(lpszAdminGroupName)+ MAX_PATH;
if (! (lpFQDNWithldap = (LPTSTR) malloc(cchPathWithLDAP * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = StringCchPrintf(lpFQDNWithldap,
cchPathWithLDAP,
lpExchangeFormat,
szCompname,
lpszAdminGroupName,
lpszOrgName,
lpFQDNSuffix);
Exit:
if (hr == S_OK)
{
*lplpFQDN = lpFQDNWithldap;
}
else
{
FreePointer(lpFQDNWithldap);
*lplpFQDN = NULL;
}
FreePointer(lpFQDNCurrUsr);
FreePointer(lpszAdminGroupName);
FreePointer(lpszOrgName);
return hr;
}
HRESULT GetFQDNForFrs(LPTSTR *lplpFQDN)
{
BOOL bIsDC;
TCHAR szDcName[MAX_PATH+1],szCompname[MAX_PATH+1];
DWORD cchSize;
TCHAR szCurrUsrname[MAX_PATH+1];
LPTSTR lpFQDNCurrUsr = NULL,lpFQDNSuffix,lpFQDNWithldap = NULL;
LPTSTR lpFrsFormat = TEXT("LDAP://CN=Domain System Volume (SYSVOL share),CN=NTFRS Subscriptions,CN=%s,OU=Domain Controllers,%s");
DWORD cchPathWithLDAP;
HRESULT hr;
cchSize = ARRAYSIZE(szCurrUsrname);
if (!GetUserName(szCurrUsrname, &cchSize))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
cchSize = ARRAYSIZE(szDcName);
hr = GetDCInfo(&bIsDC,szDcName,&cchSize);
if (FAILED(hr) || !bIsDC)
{
if (!bIsDC)
{
hr =S_FALSE;
}
goto Exit;
}
cchSize = ARRAYSIZE(szCompname);
if (!GetComputerName(szCompname,&cchSize))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (S_OK !=GetFQDN(szCurrUsrname,szDcName,&lpFQDNCurrUsr))
{
lpFQDNCurrUsr = NULL;
goto Exit;
}
lpFQDNSuffix = StrStrI(lpFQDNCurrUsr, TEXT("=Users,"));
if (!lpFQDNSuffix)
{
hr =S_FALSE;
goto Exit;
}
lpFQDNSuffix += lstrlen(TEXT("=Users,"));
cchPathWithLDAP = lstrlen(lpFQDNSuffix) + lstrlen(szDcName)
+ lstrlen(lpFrsFormat) + MAX_PATH;
if (! (lpFQDNWithldap = (LPTSTR) malloc(cchPathWithLDAP * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = StringCchPrintf(lpFQDNWithldap,
cchPathWithLDAP,
lpFrsFormat,
szCompname,
lpFQDNSuffix);
Exit:
if (hr == S_OK)
{
*lplpFQDN = lpFQDNWithldap;
}
else
{
FreePointer(lpFQDNWithldap);
*lplpFQDN = NULL;
}
FreePointer(lpFQDNCurrUsr);
return hr;}
HRESULT AddDSObjPropUpdate2Inf(
LPTSTR lpLdpPath,
LPTSTR lpPropName,
LPTSTR lpValue)
{
LPTSTR lpszOneline = NULL;
DWORD cchSize ;
HRESULT hr = S_OK;
TCHAR szIndex[MAX_PATH];
if (!lpLdpPath || !lpPropName || !lpValue)
{
hr = E_INVALIDARG;
goto cleanup;
}
cchSize = lstrlen(lpLdpPath) + lstrlen(lpPropName) + lstrlen(lpValue) + MAX_PATH;
if ( ! (lpszOneline = malloc(cchSize * sizeof(TCHAR)) ))
{
hr = E_OUTOFMEMORY;
goto cleanup;
}
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
hr = StringCchPrintf(lpszOneline, cchSize, TEXT("\"%s\",\"%s\",\"%s\""),lpLdpPath,lpPropName,lpValue);
if (!WritePrivateProfileString(DS_OBJ_PROPERTY_UPDATE,szIndex,lpszOneline,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
hr = S_OK;
cleanup:
FreePointer(lpszOneline);
return hr;
}
HRESULT Ex2000Update()
{
LPTSTR lpObjPath = NULL;
LPTSTR lpBadMailDirectory = NULL, lpPickupDirectory = NULL, lpQueueDirectory = NULL;
LPTSTR lpNewBadMailDirectory = NULL, lpNewPickupDirectory = NULL, lpNewQueueDirectory = NULL;
HRESULT hr;
hr = GetFQDNForExchange2k(&lpObjPath);
if (hr != S_OK)
{
goto exit;
}
hr = PropertyValueHelper(lpObjPath,TEXT("msExchSmtpBadMailDirectory"),&lpBadMailDirectory,NULL);
if (hr == S_OK)
{
if (lpNewBadMailDirectory = ReplaceLocStringInPath(lpBadMailDirectory,TRUE))
{
AddDSObjPropUpdate2Inf(lpObjPath,TEXT("msExchSmtpBadMailDirectory"),lpNewBadMailDirectory);
}
}
hr = PropertyValueHelper(lpObjPath,TEXT("msExchSmtpPickupDirectory"),&lpPickupDirectory,NULL);
if (hr == S_OK)
{
if (lpNewPickupDirectory = ReplaceLocStringInPath(lpPickupDirectory,TRUE))
{
AddDSObjPropUpdate2Inf(lpObjPath,TEXT("msExchSmtpPickupDirectory"),lpNewPickupDirectory);
}
}
hr = PropertyValueHelper(lpObjPath,TEXT("msExchSmtpQueueDirectory"),&lpQueueDirectory,NULL);
if (hr == S_OK)
{
if (lpNewQueueDirectory = ReplaceLocStringInPath(lpQueueDirectory,TRUE))
{
AddDSObjPropUpdate2Inf(lpObjPath,TEXT("msExchSmtpQueueDirectory"),lpNewQueueDirectory);
}
}
exit:
FreePointer(lpObjPath);
FreePointer(lpBadMailDirectory);
FreePointer(lpPickupDirectory);
FreePointer(lpQueueDirectory);
if (lpNewBadMailDirectory)
{
MEMFREE(lpNewBadMailDirectory);
}
if (lpNewPickupDirectory)
{
MEMFREE(lpNewPickupDirectory);
}
if (lpNewQueueDirectory)
{
MEMFREE(lpNewQueueDirectory);
}
return hr;
}
HRESULT FRSUpdate()
{
LPTSTR lpObjPath = NULL;
LPTSTR lpfRSRootPath = NULL, lpfRSStagingPath = NULL;
LPTSTR lpNewfRSRootPath = NULL, lpNewfRSStagingPath = NULL;
BOOL bChanged = FALSE;
HRESULT hr;
TCHAR szSysVolPath[2*MAX_PATH],szSysVolPath2[2*MAX_PATH];
DWORD cchSize = ARRAYSIZE(szSysVolPath);
WIN32_FIND_DATA FindFileData;
HANDLE hFile ;
hr = GetFQDNForFrs(&lpObjPath);
if (hr != S_OK)
{
goto exit;
}
hr = PropertyValueHelper(lpObjPath,TEXT("fRSRootPath"),&lpfRSRootPath,NULL);
if (hr == S_OK)
{
if (lpNewfRSRootPath = ReplaceLocStringInPath(lpfRSRootPath,TRUE))
{
AddDSObjPropUpdate2Inf(lpObjPath,TEXT("fRSRootPath"),lpNewfRSRootPath);
bChanged = TRUE;
}
}
hr = PropertyValueHelper(lpObjPath,TEXT("fRSStagingPath"),&lpfRSStagingPath,NULL);
if (hr == S_OK)
{
if (lpNewfRSStagingPath = ReplaceLocStringInPath(lpfRSStagingPath,TRUE))
{
AddDSObjPropUpdate2Inf(lpObjPath,TEXT("fRSStagingPath"),lpNewfRSStagingPath);
bChanged = TRUE;
}
}
if (bChanged)
{
TCHAR szVal[MAX_PATH];
_itot(210,szVal,10);
hr = AddRegValueRename(TEXT("HKLM\\SYSTEM\\CurrentControlSet\\Services\\NtFrs\\Parameters\\Backup/Restore\\Process at Startup"),
TEXT("BurFlags"),
NULL,
NULL,
szVal,
REG_DWORD,
0,
NULL);
}
if (S_OK != GetSharePath(TEXT("SYSVOL"),szSysVolPath,&cchSize))
{
goto exit;
}
hr = StringCchCopy(szSysVolPath2,ARRAYSIZE(szSysVolPath2),szSysVolPath);
ConcatenatePaths(szSysVolPath2,TEXT("*.*"),ARRAYSIZE(szSysVolPath2));
hFile = FindFirstFile(szSysVolPath2,&FindFileData);
if (hFile != INVALID_HANDLE_VALUE)
{
do
{
TCHAR szEnrty[MAX_PATH+1+MAX_PATH];
LPTSTR lpNewLinkPath = NULL, lpNewLinkData = NULL;
TCHAR szLinkValue[MAX_PATH+1+MAX_PATH];
if(0 == MyStrCmpI(FindFileData.cFileName , TEXT(".")))
{
continue;
}
if(0 == MyStrCmpI(FindFileData.cFileName , TEXT("..")))
{
continue;
}
hr = StringCchCopy(szEnrty,ARRAYSIZE(szEnrty),szSysVolPath);
ConcatenatePaths(szEnrty,FindFileData.cFileName ,ARRAYSIZE(szEnrty));
if (!(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
{
continue;
}
if (!GetSymbolicLink(szEnrty,szLinkValue,ARRAYSIZE(szLinkValue)))
{
continue;
}
if (!(lpNewLinkPath = ReplaceLocStringInPath(szLinkValue,TRUE)))
{
continue;
}
if (!(lpNewLinkData = ReplaceLocStringInPath(szEnrty,TRUE)))
{
lpNewLinkData = szEnrty;
}
AddHardLinkEntry(lpNewLinkData,lpNewLinkPath,TEXT("1"),NULL,TEXT("0"),NULL);
if (lpNewLinkPath && lpNewLinkData != szEnrty)
{
MEMFREE(lpNewLinkPath);
}
if (lpNewLinkData)
{
MEMFREE(lpNewLinkData);
}
}while (FindNextFile(hFile,&FindFileData));
FindClose(hFile);
}
exit:
FreePointer(lpObjPath);
FreePointer(lpfRSRootPath);
FreePointer(lpfRSStagingPath);
if (lpNewfRSRootPath)
{
MEMFREE(lpNewfRSRootPath);
}
if (lpNewfRSStagingPath)
{
MEMFREE(lpNewfRSStagingPath);
}
return hr;
}
HRESULT GetSharePath(
LPTSTR lpShareName,
LPTSTR lpSharePath,
PDWORD pcchSize)
{
HKEY hkey = NULL;
LONG lstatus;
HRESULT hr;
UINT i = 0;
LPTSTR lpValueName = NULL, lpValueData = NULL;
DWORD cchValueName, cchValueData, numofentry;
BOOL bNameMatchFound = FALSE;
LPTSTR lpPath;
if (!lpShareName || !pcchSize)
{
hr = E_INVALIDARG;
}
lstatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\Shares"),
0,
KEY_READ,
&hkey);
if (ERROR_SUCCESS != lstatus)
{
hr = HRESULT_FROM_WIN32(lstatus);
goto exit;
}
lstatus = RegQueryInfoKey(hkey,
NULL,
NULL,
0,
NULL,
NULL,
NULL,
&numofentry,
&cchValueName,
&cchValueData,
NULL,
NULL);
if ( lstatus != ERROR_SUCCESS )
{
hr = HRESULT_FROM_WIN32(lstatus);
goto exit;
}
if (!numofentry)
{
hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
goto exit;
}
cchValueName++;
cchValueData++;
lpValueName = malloc(cchValueName * sizeof(TCHAR));
lpValueData = malloc(cchValueData * sizeof(TCHAR));
if (!lpValueName || !lpValueData)
{
hr = E_OUTOFMEMORY;
goto exit;
}
for (i =0; i< numofentry; i++)
{
DWORD cchCurrValueName, cchCurrValueData;
DWORD dwType;
cchCurrValueName = cchValueName;
cchCurrValueData = cchValueData;
lstatus = RegEnumValue(hkey, i, lpValueName, &cchCurrValueName,
NULL, &dwType, (LPBYTE)lpValueData,&cchCurrValueData);
if ( (lstatus != ERROR_SUCCESS)
|| (dwType != REG_MULTI_SZ)
|| MyStrCmpI(lpShareName,lpValueName) )
{
continue;
}
lpPath = lpValueData;
while (*lpPath)
{
if (StrStrI(lpPath, TEXT("Path=")))
{
lpPath += lstrlen(TEXT("Path="));
bNameMatchFound = TRUE;
break;
}
lpPath = lpPath + lstrlen(lpPath) + 1;
}
if (bNameMatchFound)
{
break;
}
}
if (bNameMatchFound)
{
if (*pcchSize < (UINT)lstrlen(lpPath) +1)
{
*pcchSize = lstrlen(lpPath) +1;
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
goto exit;
}
*pcchSize = lstrlen(lpPath) +1;
if (lpSharePath)
{
hr = StringCchCopy(lpSharePath,*pcchSize,lpPath);
}
else
{
hr = S_OK;
}
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
goto exit;
}
exit:
FreePointer(lpValueName);
FreePointer(lpValueData);
if (hkey)
{
RegCloseKey(hkey);
}
return hr;
}
HRESULT Sz2MultiSZ(
IN OUT LPTSTR lpsz,
IN TCHAR chSeperator)
{
HRESULT hr;
LPTSTR lp, lpSep;
if (!lpsz)
{
hr = E_INVALIDARG;
goto Cleanup;
}
lp = lpsz;
while (*lp && (lpSep = StrChr(lp,chSeperator)))
{
*lpSep = TEXT('\0');
lp = lpSep + 1;
}
if (*lp)
{
lp = lp + lstrlen(lp) + 1;
*lp = TEXT('\0');
}
hr = S_OK;
Cleanup:
return hr;
}
HRESULT ConstructUIReplaceStringTable(
LPTSTR lpszOld,
LPTSTR lpszNew,
PREG_STRING_REPLACE pTable)
{
DWORD dwNumOld, dwNumNew;
if (!lpszOld || !lpszNew)
{
return E_INVALIDARG;
}
dwNumOld = MultiSZNumOfString(lpszOld);
dwNumNew = MultiSZNumOfString(lpszNew);
if (!dwNumOld || !dwNumNew || (dwNumOld != dwNumNew))
{
return E_INVALIDARG;
}
pTable->nNumOfElem = dwNumNew;
pTable->cchUserName = 0;
pTable->szUserNameLst = NULL;
pTable->cchSearchString = MultiSzLen(lpszOld);
pTable->lpSearchString = lpszOld;
pTable->cchReplaceString = MultiSzLen(lpszNew);
pTable->lpReplaceString = lpszNew;
pTable->cchAttribList = 0;
pTable->lpAttrib = NULL;
pTable->cchFullStringList = 0;
pTable->lpFullStringList = NULL;
pTable->cchMaxStrLen = 0;
return S_OK;
}
HRESULT MakeDOInfCopy()
{
TCHAR szBackupDir[MAX_PATH];
HRESULT hr;
TCHAR szDoInf[2*MAX_PATH],szDoInfBackup[2*MAX_PATH];
if (!GetSystemWindowsDirectory(szBackupDir, ARRAYSIZE(szBackupDir)))
{
//BUGBUG:Xiaoz:Add DLG pop up for failure
DPF(APPerr, TEXT("MakeDOInfCopy:Failed to get WINDIR"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
ConcatenatePaths(szBackupDir,CLMT_BACKUP_DIR,ARRAYSIZE(szBackupDir));
hr = StringCchCopy(szDoInf,ARRAYSIZE(szDoInf),szBackupDir);
hr = StringCchCopy(szDoInfBackup,ARRAYSIZE(szDoInfBackup),szBackupDir);
ConcatenatePaths(szDoInf,TEXT("clmtdo.inf"),ARRAYSIZE(szDoInf));
ConcatenatePaths(szDoInfBackup,TEXT("clmtdo.bak"),ARRAYSIZE(szDoInfBackup));
if (!CopyFile(szDoInf,szDoInfBackup,FALSE))
{
DPF(APPerr, TEXT("MakeDOInfCopy:CopyFile failed"));
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
hr = S_OK;
Exit:
return hr;
}
VOID RemoveSubString(
LPTSTR lpSrcString,
LPCTSTR lpSubString
)
{
LPTSTR lpMatchedStr;
DWORD dwSubStrLen;
lpMatchedStr = StrStr(lpSrcString, lpSubString);
if (lpMatchedStr != NULL)
{
dwSubStrLen = lstrlen(lpSubString);
while (*(lpMatchedStr + dwSubStrLen) != TEXT('\0'))
{
*(lpMatchedStr) = *(lpMatchedStr + dwSubStrLen);
lpMatchedStr++;
}
*lpMatchedStr = TEXT('\0');
}
}