You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1852 lines
54 KiB
1852 lines
54 KiB
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
fileops.c
|
|
|
|
Abstract:
|
|
|
|
Miscellaneous file operations.
|
|
|
|
Entry points:
|
|
|
|
Delnode
|
|
|
|
Author:
|
|
|
|
Ted Miller (tedm) 5-Apr-1995
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "setupp.h"
|
|
|
|
//
|
|
// This include is needed for ValidateAndChecksumFile()
|
|
//
|
|
#include <imagehlp.h>
|
|
#include <shlwapi.h>
|
|
|
|
#pragma hdrstop
|
|
|
|
|
|
|
|
VOID
|
|
pSetInstallAttributes(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set default attributes on a huge list of files. The shell
|
|
had been doing this, but it's probably better to do it here
|
|
so that the the user doesn't have his attributes reset everytime
|
|
he logs in.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
#define _R (FILE_ATTRIBUTE_READONLY)
|
|
#define _S (FILE_ATTRIBUTE_SYSTEM)
|
|
#define _H (FILE_ATTRIBUTE_HIDDEN)
|
|
#define _SH (_S | _H)
|
|
#define _SHR (_S | _H | _R)
|
|
|
|
struct {
|
|
WCHAR FileName[20];
|
|
BOOL DeleteIfEmpty;
|
|
DWORD Attributes;
|
|
} FilesToFix[] = {
|
|
// { L"X:\\autoexec.bat", TRUE, _H }, 16bit apps break if hidden: jarbats bug148787
|
|
{ L"X:\\autoexec.000", TRUE, _SH },
|
|
{ L"X:\\autoexec.old", TRUE, _SH },
|
|
{ L"X:\\autoexec.bak", TRUE, _SH },
|
|
{ L"X:\\autoexec.dos", TRUE, _SH },
|
|
{ L"X:\\autoexec.win", TRUE, _SH },
|
|
// { L"X:\\config.sys", TRUE, _H }, 16bit apps break if hidden: jarbats bug 148787
|
|
{ L"X:\\config.dos", TRUE, _SH },
|
|
{ L"X:\\config.win", TRUE, _SH },
|
|
{ L"X:\\command.com", FALSE, _SH },
|
|
{ L"X:\\command.dos", FALSE, _SH },
|
|
{ L"X:\\logo.sys", FALSE, _SH },
|
|
{ L"X:\\msdos.---", FALSE, _SH }, // Win9x backup of msdos.*
|
|
{ L"X:\\boot.ini", FALSE, _SH },
|
|
{ L"X:\\boot.bak", FALSE, _SH },
|
|
{ L"X:\\boot.---", FALSE, _SH },
|
|
{ L"X:\\bootsect.dos", FALSE, _SH },
|
|
{ L"X:\\bootlog.txt", FALSE, _SH }, // Win9x first boot log
|
|
{ L"X:\\bootlog.prv", FALSE, _SH },
|
|
{ L"X:\\ffastun.ffa", FALSE, _SH }, // Office 97 only used hidden, O2K uses SH
|
|
{ L"X:\\ffastun.ffl", FALSE, _SH },
|
|
{ L"X:\\ffastun.ffx", FALSE, _SH },
|
|
{ L"X:\\ffastun0.ffx", FALSE, _SH },
|
|
{ L"X:\\ffstunt.ffl", FALSE, _SH },
|
|
{ L"X:\\sms.ini", FALSE, _SH }, // SMS
|
|
{ L"X:\\sms.new", FALSE, _SH },
|
|
{ L"X:\\sms_time.dat", FALSE, _SH },
|
|
{ L"X:\\smsdel.dat", FALSE, _SH },
|
|
{ L"X:\\mpcsetup.log", FALSE, _H }, // Microsoft Proxy Server
|
|
{ L"X:\\detlog.txt", FALSE, _SH }, // Win9x PNP detection log
|
|
{ L"X:\\detlog.old", FALSE, _SH }, // Win9x PNP detection log
|
|
{ L"X:\\setuplog.txt", FALSE, _SH }, // Win9x setup log
|
|
{ L"X:\\setuplog.old", FALSE, _SH }, // Win9x setup log
|
|
{ L"X:\\suhdlog.dat", FALSE, _SH }, // Win9x setup log
|
|
{ L"X:\\suhdlog.---", FALSE, _SH }, // Win9x setup log
|
|
{ L"X:\\suhdlog.bak", FALSE, _SH }, // Win9x setup log
|
|
{ L"X:\\system.1st", FALSE, _SH }, // Win95 system.dat backup
|
|
{ L"X:\\netlog.txt", FALSE, _SH }, // Win9x network setup log file
|
|
{ L"X:\\setup.aif", FALSE, _SH }, // NT4 unattended setup script
|
|
{ L"X:\\catlog.wci", FALSE, _H }, // index server folder
|
|
{ L"X:\\cmsstorage.lst", FALSE, _SH }, // Microsoft Media Manager
|
|
};
|
|
|
|
WCHAR szWinDir[MAX_PATH];
|
|
DWORD i, j;
|
|
DWORD Result;
|
|
|
|
//
|
|
// Get the drive letter that we installed on.
|
|
//
|
|
Result = GetWindowsDirectory(szWinDir, MAX_PATH);
|
|
if( Result == 0) {
|
|
MYASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
for( i = 0; i < (sizeof(FilesToFix)/sizeof(FilesToFix[0])); i++ ) {
|
|
//
|
|
// First we need to fixup the path. This is really gross, but lots
|
|
// of these files will be on the system partition and lots will be
|
|
// on the partition where we installed, which may not be the same.
|
|
// Rather than figuring out which of these live on which partition
|
|
// and ensuring that this is true for all flavors of NT, just
|
|
// process both locations.
|
|
//
|
|
for( j = 0; j < 2; j++ ) {
|
|
if( j & 1 ) {
|
|
FilesToFix[i].FileName[0] = szWinDir[0];
|
|
} else {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
FilesToFix[i].FileName[0] = x86SystemPartitionDrive;
|
|
#else
|
|
FilesToFix[i].FileName[0] = L'C';
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// Now set the attributes.
|
|
//
|
|
SetFileAttributes( FilesToFix[i].FileName, FilesToFix[i].Attributes );
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
TreeCopy(
|
|
IN PCWSTR SourceDir,
|
|
IN PCWSTR TargetDir
|
|
)
|
|
{
|
|
DWORD d;
|
|
WCHAR Pattern[MAX_PATH];
|
|
WCHAR NewTarget[MAX_PATH];
|
|
WIN32_FIND_DATA FindData;
|
|
HANDLE FindHandle;
|
|
|
|
//
|
|
// First create the target directory if it doesn't already exist.
|
|
//
|
|
if(!CreateDirectory(TargetDir,NULL)) {
|
|
d = GetLastError();
|
|
if(d != ERROR_ALREADY_EXISTS) {
|
|
return(d);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy each file in the source directory to the target directory.
|
|
// If any directories are encountered along the way recurse to copy them
|
|
// as they are encountered.
|
|
//
|
|
// Start by forming the search pattern, which is <sourcedir>\*.
|
|
//
|
|
lstrcpyn(Pattern,SourceDir,MAX_PATH);
|
|
pSetupConcatenatePaths(Pattern,L"*",MAX_PATH,NULL);
|
|
|
|
//
|
|
// Start the search.
|
|
//
|
|
FindHandle = FindFirstFile(Pattern,&FindData);
|
|
if(FindHandle == INVALID_HANDLE_VALUE) {
|
|
|
|
d = NO_ERROR;
|
|
|
|
} else {
|
|
|
|
do {
|
|
|
|
//
|
|
// Form the full name of the file or directory we just found
|
|
// as well as its name in the target.
|
|
//
|
|
lstrcpyn(Pattern,SourceDir,MAX_PATH);
|
|
pSetupConcatenatePaths(Pattern,FindData.cFileName,MAX_PATH,NULL);
|
|
|
|
lstrcpyn(NewTarget,TargetDir,MAX_PATH);
|
|
pSetupConcatenatePaths(NewTarget,FindData.cFileName,MAX_PATH,NULL);
|
|
|
|
if(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
|
|
//
|
|
// The current match is a directory. Recurse into it unless
|
|
// it's . or ...
|
|
//
|
|
if(lstrcmp(FindData.cFileName,TEXT("." )) && lstrcmp(FindData.cFileName,TEXT(".."))) {
|
|
d = TreeCopy(Pattern,NewTarget);
|
|
} else {
|
|
d = NO_ERROR;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// The current match is not a directory -- so copy it.
|
|
//
|
|
SetFileAttributes(NewTarget,FILE_ATTRIBUTE_NORMAL);
|
|
d = CopyFile(Pattern,NewTarget,FALSE) ? NO_ERROR : GetLastError();
|
|
}
|
|
} while((d==NO_ERROR) && FindNextFile(FindHandle,&FindData));
|
|
|
|
FindClose(FindHandle);
|
|
}
|
|
|
|
return(d);
|
|
}
|
|
|
|
|
|
VOID
|
|
DelSubNodes(
|
|
IN PCWSTR Directory
|
|
)
|
|
{
|
|
WCHAR Pattern[MAX_PATH];
|
|
WIN32_FIND_DATA FindData;
|
|
HANDLE FindHandle;
|
|
|
|
//
|
|
// Delete each file in the given directory, but DO NOT remove the directory itself.
|
|
// If any directories are encountered along the way recurse to delete them
|
|
// as they are encountered.
|
|
//
|
|
// Start by forming the search pattern, which is <currentdir>\*.
|
|
//
|
|
lstrcpyn(Pattern,Directory,MAX_PATH);
|
|
pSetupConcatenatePaths(Pattern,L"*",MAX_PATH,NULL);
|
|
|
|
//
|
|
// Start the search.
|
|
//
|
|
FindHandle = FindFirstFile(Pattern,&FindData);
|
|
if(FindHandle != INVALID_HANDLE_VALUE) {
|
|
|
|
do {
|
|
|
|
//
|
|
// Form the full name of the file or directory we just found.
|
|
//
|
|
lstrcpyn(Pattern,Directory,MAX_PATH);
|
|
pSetupConcatenatePaths(Pattern,FindData.cFileName,MAX_PATH,NULL);
|
|
|
|
//
|
|
// Remove read-only atttribute if it's there.
|
|
//
|
|
if(FindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
|
|
SetFileAttributes(Pattern,FILE_ATTRIBUTE_NORMAL);
|
|
}
|
|
|
|
if(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
|
|
//
|
|
// The current match is a directory. Recurse into it unless
|
|
// it's . or ...
|
|
//
|
|
if(lstrcmp(FindData.cFileName,TEXT("." )) && lstrcmp(FindData.cFileName,TEXT(".."))) {
|
|
Delnode(Pattern);
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// The current match is not a directory -- so delete it.
|
|
//
|
|
if(!DeleteFile(Pattern)) {
|
|
SetuplogError(
|
|
LogSevWarning,
|
|
SETUPLOG_USE_MESSAGEID,
|
|
MSG_LOG_DELNODE_FAIL,
|
|
Pattern, NULL,
|
|
SETUPLOG_USE_MESSAGEID,
|
|
MSG_LOG_X_PARAM_RETURNED_WINERR,
|
|
szDeleteFile,
|
|
GetLastError(),
|
|
Pattern,
|
|
NULL,NULL);
|
|
}
|
|
}
|
|
} while(FindNextFile(FindHandle,&FindData));
|
|
|
|
FindClose(FindHandle);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
Delnode(
|
|
IN PCWSTR Directory
|
|
)
|
|
{
|
|
WCHAR Pattern[MAX_PATH];
|
|
WIN32_FIND_DATA FindData;
|
|
HANDLE FindHandle;
|
|
|
|
//
|
|
// Delete each file in the given directory, then remove the directory itself.
|
|
// If any directories are encountered along the way recurse to delete them
|
|
// as they are encountered.
|
|
//
|
|
// Start by forming the search pattern, which is <currentdir>\*.
|
|
//
|
|
lstrcpyn(Pattern,Directory,MAX_PATH);
|
|
pSetupConcatenatePaths(Pattern,L"*",MAX_PATH,NULL);
|
|
|
|
//
|
|
// Start the search.
|
|
//
|
|
FindHandle = FindFirstFile(Pattern,&FindData);
|
|
if(FindHandle != INVALID_HANDLE_VALUE) {
|
|
|
|
do {
|
|
|
|
//
|
|
// Form the full name of the file or directory we just found.
|
|
//
|
|
lstrcpyn(Pattern,Directory,MAX_PATH);
|
|
pSetupConcatenatePaths(Pattern,FindData.cFileName,MAX_PATH,NULL);
|
|
|
|
//
|
|
// Remove read-only atttribute if it's there.
|
|
//
|
|
if(FindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
|
|
SetFileAttributes(Pattern,FILE_ATTRIBUTE_NORMAL);
|
|
}
|
|
|
|
if(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
if( (FindData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
|
|
if( !RemoveDirectory(Pattern)) {
|
|
SetuplogError(
|
|
LogSevWarning,
|
|
SETUPLOG_USE_MESSAGEID,
|
|
MSG_LOG_DELNODE_FAIL,
|
|
Pattern, NULL,
|
|
SETUPLOG_USE_MESSAGEID,
|
|
MSG_LOG_X_PARAM_RETURNED_WINERR,
|
|
szRemoveDirectory,
|
|
GetLastError(),
|
|
Pattern,
|
|
NULL,NULL);
|
|
}
|
|
} else {
|
|
//
|
|
// The current match is a directory. Recurse into it unless
|
|
// it's . or ...
|
|
//
|
|
if(lstrcmp(FindData.cFileName,TEXT("." )) && lstrcmp(FindData.cFileName,TEXT(".."))) {
|
|
Delnode(Pattern);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// The current match is not a directory -- so delete it.
|
|
//
|
|
if(!DeleteFile(Pattern)) {
|
|
SetuplogError(
|
|
LogSevWarning,
|
|
SETUPLOG_USE_MESSAGEID,
|
|
MSG_LOG_DELNODE_FAIL,
|
|
Pattern, NULL,
|
|
SETUPLOG_USE_MESSAGEID,
|
|
MSG_LOG_X_PARAM_RETURNED_WINERR,
|
|
szDeleteFile,
|
|
GetLastError(),
|
|
Pattern,
|
|
NULL,NULL);
|
|
}
|
|
}
|
|
} while(FindNextFile(FindHandle,&FindData));
|
|
|
|
FindClose(FindHandle);
|
|
}
|
|
|
|
//
|
|
// Remove the directory we just emptied out. Ignore errors.
|
|
//
|
|
SetFileAttributes(Directory,FILE_ATTRIBUTE_NORMAL);
|
|
RemoveDirectory(Directory);
|
|
}
|
|
|
|
|
|
VOID
|
|
RemoveServicePackEntries(
|
|
HKEY hKey
|
|
)
|
|
/*
|
|
This routine takes in the Handle to the Software\Microsoft\Windows NT\CurrentVersion\Hotfix\ServicePackUninstall
|
|
key and then enumerates each value entry under it.
|
|
|
|
It then takes the value data and appends that to the
|
|
|
|
"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\" and delnodes that key. This
|
|
way we have an extensible mechanism to always cleanup the Uninstall keys for ServicePacks.
|
|
|
|
|
|
*/
|
|
{
|
|
|
|
#define UNINSTALLKEY L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
|
|
#define UNINSTALLKEYLEN (sizeof(UNINSTALLKEY) / sizeof(WCHAR) - 1)
|
|
|
|
DWORD Status,MaxValueName=0,MaxValue=0,Values=0,i;
|
|
DWORD TempMaxNameSize, TempMaxDataSize;
|
|
PWSTR ValueName, ValueData;
|
|
|
|
|
|
Status = RegQueryInfoKey( hKey,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&Values,
|
|
&MaxValueName,
|
|
&MaxValue,
|
|
NULL,
|
|
NULL );
|
|
|
|
//Account forterminating null
|
|
|
|
if( Status == ERROR_SUCCESS ){
|
|
|
|
MaxValueName += 2;
|
|
MaxValue = MaxValue + 2 + lstrlen(UNINSTALLKEY);
|
|
|
|
ValueName = MyMalloc( MaxValueName * sizeof(WCHAR) );
|
|
ValueData = MyMalloc( MaxValue * sizeof(WCHAR) );
|
|
|
|
if( !ValueName || !ValueData )
|
|
return;
|
|
|
|
lstrcpy( ValueData, UNINSTALLKEY );
|
|
|
|
|
|
for (i=0; i < Values; i++){
|
|
|
|
TempMaxNameSize = MaxValueName;
|
|
TempMaxDataSize = MaxValue;
|
|
|
|
Status = RegEnumValue( hKey,
|
|
i,
|
|
ValueName,
|
|
&TempMaxNameSize,
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)(ValueData+lstrlen(UNINSTALLKEY)),
|
|
&TempMaxDataSize
|
|
);
|
|
|
|
// Don't do delnode if valuedata is null
|
|
if( Status == ERROR_SUCCESS && ValueData[lstrlen(UNINSTALLKEY)] ){
|
|
|
|
pSetupRegistryDelnode( HKEY_LOCAL_MACHINE, ValueData );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
MyFree( ValueName );
|
|
MyFree( ValueData );
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
VOID
|
|
RemoveHotfixData(
|
|
VOID
|
|
)
|
|
{
|
|
WCHAR Path[MAX_PATH];
|
|
WCHAR KBNumber[64];
|
|
WCHAR UninstallKey[MAX_PATH];
|
|
DWORD i = 0;
|
|
DWORD prefixSize = 0;
|
|
DWORD Status, SubKeys;
|
|
HKEY hKey, SvcPckKey;
|
|
REGVALITEM SoftwareKeyItems[1];
|
|
|
|
//
|
|
//For each hotfix, the registry info is stored under
|
|
// HKLM\Software\Microsoft\Windows NT\CurrentVersion\Hotfix\<KB#>
|
|
// and the files are stored under
|
|
// %windir%\$NtUninstall<KB#>$
|
|
|
|
//
|
|
//Enumerate the hotfix key and remove the files and registry entries for each hotfix.
|
|
//
|
|
#define HOTFIXAPPKEY L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix"
|
|
|
|
Status = RegOpenKey(HKEY_LOCAL_MACHINE, HOTFIXAPPKEY, &hKey);
|
|
if( Status != ERROR_SUCCESS ) {
|
|
return;
|
|
}
|
|
|
|
Status = RegQueryInfoKey( hKey,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&SubKeys,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL );
|
|
|
|
if(Status == ERROR_SUCCESS) {
|
|
|
|
Status = GetWindowsDirectory(Path, MAX_PATH);
|
|
if(Status == 0) {
|
|
MYASSERT(FALSE);
|
|
return;
|
|
}
|
|
pSetupConcatenatePaths(Path,L"$NtUninstall",MAX_PATH,&prefixSize);
|
|
lstrcpy(UninstallKey, UNINSTALLKEY);
|
|
|
|
for( i = 0; i < SubKeys; i++ ) {
|
|
|
|
Status = RegEnumKey(hKey, i, KBNumber, sizeof(KBNumber) / sizeof(KBNumber[0]));
|
|
|
|
if (Status == ERROR_SUCCESS) {
|
|
|
|
if( !lstrcmpi( KBNumber, TEXT("ServicePackUninstall") ) ){
|
|
Status = RegOpenKey(hKey,KBNumber,&SvcPckKey);
|
|
if( Status == ERROR_SUCCESS ){
|
|
RemoveServicePackEntries(SvcPckKey);
|
|
RegCloseKey(SvcPckKey);
|
|
}
|
|
|
|
}else{
|
|
lstrcpyn(Path + prefixSize - 1, KBNumber, MAX_PATH - prefixSize);
|
|
lstrcat(Path, L"$");
|
|
Delnode(Path);
|
|
//
|
|
// Remove the entry from the Add/Remove Programs key.
|
|
// UNINSTALLKEY ends with '\\'
|
|
//
|
|
lstrcpy(UninstallKey + UNINSTALLKEYLEN, KBNumber);
|
|
pSetupRegistryDelnode(HKEY_LOCAL_MACHINE, UninstallKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
pSetupRegistryDelnode(HKEY_LOCAL_MACHINE, HOTFIXAPPKEY);
|
|
|
|
//
|
|
// delete HKLM\SOFTWARE\Microsoft\Updates\Windows 2000 key since it contains entries for SPs/QFEs for win2k
|
|
//
|
|
pSetupRegistryDelnode(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Updates\\Windows 2000");
|
|
|
|
//
|
|
// We need to hack something for Exchange because they check for
|
|
// a hotfix (irregardless of the OS version...
|
|
//
|
|
i = 1;
|
|
SoftwareKeyItems[0].Name = L"Installed";
|
|
SoftwareKeyItems[0].Data = &i;
|
|
SoftwareKeyItems[0].Size = sizeof(DWORD);
|
|
SoftwareKeyItems[0].Type = REG_DWORD;
|
|
SetGroupOfValues(HKEY_LOCAL_MACHINE,L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q147222",SoftwareKeyItems,1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
VOID
|
|
DeleteLocalSource(
|
|
VOID
|
|
)
|
|
{
|
|
WCHAR str[4];
|
|
|
|
if(WinntBased && !AllowRollback) {
|
|
if(SourcePath[0] && (SourcePath[1] == L':') && (SourcePath[2] == L'\\')) {
|
|
|
|
lstrcpyn(str,SourcePath,4);
|
|
if(GetDriveType(str) != DRIVE_CDROM) {
|
|
Delnode(SourcePath);
|
|
#ifdef _X86_
|
|
if (IsNEC_98 && !lstrcmpi(&SourcePath[2], pwLocalSource)) {
|
|
HKEY hkey;
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,L"System\\Setup",0,MAXIMUM_ALLOWED,&hkey) == NO_ERROR) {
|
|
RegDeleteValue(hkey, L"ForcePlatform");
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remove %systemroot%\winsxs\setuppolicies before rebooting
|
|
//
|
|
{
|
|
WCHAR SetupPoliciesPath[MAX_PATH];
|
|
GetSystemWindowsDirectoryW(SetupPoliciesPath, MAX_PATH);
|
|
pSetupConcatenatePaths(SetupPoliciesPath, L"WinSxS\\SetupPolicies", MAX_PATH, NULL);
|
|
Delnode(SetupPoliciesPath);
|
|
}
|
|
|
|
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
//
|
|
// Get rid of floppyless boot stuff.
|
|
//
|
|
if(FloppylessBootPath[0]) {
|
|
|
|
WCHAR Path[MAX_PATH];
|
|
|
|
//
|
|
// NEC98 should back boot related files in \$WIN_NT$.~BU,
|
|
// to restore boot files for keep original OS in each partition.
|
|
//
|
|
if (IsNEC_98) { //NEC98
|
|
lstrcpy(Path,FloppylessBootPath);
|
|
pSetupConcatenatePaths(Path,L"$WIN_NT$.~BU",MAX_PATH,NULL);
|
|
Delnode(Path);
|
|
} //NEC98
|
|
|
|
lstrcpy(Path,FloppylessBootPath);
|
|
pSetupConcatenatePaths(Path,L"$WIN_NT$.~BT",MAX_PATH,NULL);
|
|
Delnode(Path);
|
|
|
|
lstrcpy(Path,FloppylessBootPath);
|
|
pSetupConcatenatePaths(Path,L"$LDR$",MAX_PATH,NULL);
|
|
SetFileAttributes(Path,FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(Path);
|
|
|
|
lstrcpy(Path,FloppylessBootPath);
|
|
pSetupConcatenatePaths(Path,L"TXTSETUP.SIF",MAX_PATH,NULL);
|
|
SetFileAttributes(Path,FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(Path);
|
|
|
|
//
|
|
// Get rid of arc loader files.
|
|
//
|
|
if( !IsArc() ) {
|
|
|
|
lstrcpy(Path,FloppylessBootPath);
|
|
pSetupConcatenatePaths(Path,L"ARCLDR.EXE",MAX_PATH,NULL);
|
|
SetFileAttributes(Path,FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(Path);
|
|
|
|
lstrcpy(Path,FloppylessBootPath);
|
|
pSetupConcatenatePaths(Path,L"ARCSETUP.EXE",MAX_PATH,NULL);
|
|
SetFileAttributes(Path,FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(Path);
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// get rid of the boot.bak file
|
|
//
|
|
{
|
|
WCHAR szBootBak[] = L"?:\\BOOT.BAK";
|
|
|
|
szBootBak[0] = x86SystemPartitionDrive;
|
|
SetFileAttributes(szBootBak,FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(szBootBak);
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
|
|
#if defined(_IA64_)
|
|
//
|
|
// Get rid of SETUPLDR
|
|
//
|
|
{
|
|
WCHAR Path[MAX_PATH];
|
|
UNICODE_STRING UnicodeString;
|
|
WCHAR Buffer[MAX_PATH];
|
|
PWCHAR pwChar;
|
|
PWSTR NtPath;
|
|
BOOLEAN OldPriv, DontCare;
|
|
OBJECT_ATTRIBUTES ObjAttrib;
|
|
|
|
|
|
Buffer[0] = UNICODE_NULL;
|
|
|
|
//
|
|
// Make sure we have privilege to get/set nvram vars.
|
|
//
|
|
RtlAdjustPrivilege(
|
|
SE_SYSTEM_ENVIRONMENT_PRIVILEGE,
|
|
TRUE,
|
|
FALSE,
|
|
&OldPriv
|
|
);
|
|
|
|
RtlInitUnicodeString(&UnicodeString,L"SYSTEMPARTITION");
|
|
NtQuerySystemEnvironmentValue(
|
|
&UnicodeString,
|
|
Buffer,
|
|
sizeof(Buffer)/sizeof(WCHAR),
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Restore previous privilege.
|
|
//
|
|
RtlAdjustPrivilege(
|
|
SE_SYSTEM_ENVIRONMENT_PRIVILEGE,
|
|
OldPriv,
|
|
FALSE,
|
|
&DontCare
|
|
);
|
|
|
|
//
|
|
// Strip everything from ';' to end of string since previous strings
|
|
// are appended to the current string and are separated by ';'.
|
|
//
|
|
pwChar = Buffer;
|
|
while ((*pwChar != L'\0') && (*pwChar != L';')) {
|
|
pwChar++;
|
|
}
|
|
*pwChar = L'\0';
|
|
|
|
NtPath = ArcDevicePathToNtPath(Buffer);
|
|
if (NtPath) {
|
|
|
|
lstrcpy(Path,NtPath);
|
|
pSetupConcatenatePaths(Path,SETUPLDR,MAX_PATH,NULL);
|
|
RtlInitUnicodeString(&UnicodeString,Path);
|
|
InitializeObjectAttributes(
|
|
&ObjAttrib,
|
|
&UnicodeString,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL
|
|
);
|
|
NtDeleteFile(&ObjAttrib);
|
|
|
|
MyFree( NtPath );
|
|
|
|
}
|
|
}
|
|
#endif // defined(_IA64_)
|
|
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
ValidateAndChecksumFile(
|
|
IN PCTSTR Filename,
|
|
OUT PBOOLEAN IsNtImage,
|
|
OUT PULONG Checksum,
|
|
OUT PBOOLEAN Valid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Calculate a checksum value for a file using the standard
|
|
nt image checksum method. If the file is an nt image, validate
|
|
the image using the partial checksum in the image header. If the
|
|
file is not an nt image, it is simply defined as valid.
|
|
|
|
If we encounter an i/o error while checksumming, then the file
|
|
is declared invalid.
|
|
|
|
Arguments:
|
|
|
|
Filename - supplies full NT path of file to check.
|
|
|
|
IsNtImage - Receives flag indicating whether the file is an
|
|
NT image file.
|
|
|
|
Checksum - receives 32-bit checksum value.
|
|
|
|
Valid - receives flag indicating whether the file is a valid
|
|
image (for nt images) and that we can read the image.
|
|
|
|
Return Value:
|
|
|
|
BOOL - Returns TRUE if the flie was validated, and in this case,
|
|
IsNtImage, Checksum, and Valid will contain the result of
|
|
the validation.
|
|
This function will return FALSE, if the file could not be
|
|
validated, and in this case, the caller should call GetLastError()
|
|
to find out why this function failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Error;
|
|
PVOID BaseAddress;
|
|
ULONG FileSize;
|
|
HANDLE hFile,hSection;
|
|
PIMAGE_NT_HEADERS NtHeaders;
|
|
ULONG HeaderSum;
|
|
|
|
//
|
|
// Assume not an image and failure.
|
|
//
|
|
*IsNtImage = FALSE;
|
|
*Checksum = 0;
|
|
*Valid = FALSE;
|
|
|
|
//
|
|
// Open and map the file for read access.
|
|
//
|
|
|
|
Error = pSetupOpenAndMapFileForRead( Filename,
|
|
&FileSize,
|
|
&hFile,
|
|
&hSection,
|
|
&BaseAddress );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
SetLastError( Error );
|
|
return(FALSE);
|
|
}
|
|
|
|
if( FileSize == 0 ) {
|
|
*IsNtImage = FALSE;
|
|
*Checksum = 0;
|
|
*Valid = TRUE;
|
|
CloseHandle( hFile );
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
try {
|
|
NtHeaders = CheckSumMappedFile(BaseAddress,FileSize,&HeaderSum,Checksum);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
*Checksum = 0;
|
|
NtHeaders = NULL;
|
|
}
|
|
|
|
//
|
|
// If the file is not an image and we got this far (as opposed to encountering
|
|
// an i/o error) then the checksum is declared valid. If the file is an image,
|
|
// then its checksum may or may not be valid.
|
|
//
|
|
|
|
if(NtHeaders) {
|
|
*IsNtImage = TRUE;
|
|
*Valid = HeaderSum ? (*Checksum == HeaderSum) : TRUE;
|
|
} else {
|
|
*Valid = TRUE;
|
|
}
|
|
|
|
pSetupUnmapAndCloseFile( hFile, hSection, BaseAddress );
|
|
return( TRUE );
|
|
}
|
|
|
|
|
|
DWORD
|
|
QueryHardDiskNumber(
|
|
IN UCHAR DriveLetter
|
|
)
|
|
|
|
{
|
|
WCHAR driveName[10];
|
|
HANDLE h;
|
|
BOOL b;
|
|
STORAGE_DEVICE_NUMBER number;
|
|
DWORD bytes;
|
|
|
|
driveName[0] = '\\';
|
|
driveName[1] = '\\';
|
|
driveName[2] = '.';
|
|
driveName[3] = '\\';
|
|
driveName[4] = DriveLetter;
|
|
driveName[5] = ':';
|
|
driveName[6] = 0;
|
|
|
|
h = CreateFile(driveName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
|
|
INVALID_HANDLE_VALUE);
|
|
if (h == INVALID_HANDLE_VALUE) {
|
|
return (DWORD) -1;
|
|
}
|
|
|
|
b = DeviceIoControl(h, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
|
|
&number, sizeof(number), &bytes, NULL);
|
|
CloseHandle(h);
|
|
|
|
if (!b) {
|
|
return (DWORD) -1;
|
|
}
|
|
|
|
return number.DeviceNumber;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ExtendPartition(
|
|
IN WCHAR DriveLetter,
|
|
IN ULONG SizeMB OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function will extend a partition.
|
|
|
|
We'll do this in the following way:
|
|
1. Figure out if the partition is NTFS.
|
|
2. Figure out if there's any unpartitioned space behind
|
|
the partition the user is asking us to extend.
|
|
3. How much space is available?
|
|
4. Extend the partition
|
|
5. Extend the filesystem (inform him the partition is bigger).
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
DriveLetter - Supplies the driveletter for the partition
|
|
that we'll be extending.
|
|
|
|
SizeMB - if specified, indicates the size in MB by which
|
|
the partition will grow. If not specified, the
|
|
partition grows to encompass all the free space
|
|
in the adjacent free space.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether anything actually changed.
|
|
|
|
--*/
|
|
|
|
{
|
|
#define LEAVE_FREE_BUFFER (5 * (1024*1024))
|
|
HANDLE h;
|
|
PARTITION_INFORMATION_EX PartitionInfo;
|
|
BOOL b;
|
|
DWORD Bytes;
|
|
DISK_GEOMETRY Geometry;
|
|
DISK_GROW_PARTITION GrowInfo;
|
|
TCHAR PhysicalName[MAX_PATH];
|
|
TCHAR DosName[10];
|
|
LARGE_INTEGER BytesAvailable;
|
|
LARGE_INTEGER OurPartitionEndingLocation;
|
|
DWORD i;
|
|
PDRIVE_LAYOUT_INFORMATION_EX DriveLayout;
|
|
|
|
//
|
|
// =====================================
|
|
// 1. Figure out if the partition is NTFS.
|
|
// =====================================
|
|
//
|
|
DosName[0] = DriveLetter;
|
|
DosName[1] = TEXT(':');
|
|
DosName[2] = TEXT('\\');
|
|
DosName[3] = TEXT('\0');
|
|
b = GetVolumeInformation(
|
|
DosName,
|
|
NULL,0, // don't care about volume name
|
|
NULL, // ...or serial #
|
|
&i, // ...or max component length
|
|
&i, // ... or flags
|
|
PhysicalName,
|
|
sizeof(PhysicalName)/sizeof(TCHAR)
|
|
);
|
|
if( !b ) {
|
|
return FALSE;
|
|
}
|
|
|
|
if(lstrcmpi(PhysicalName,TEXT("NTFS"))) {
|
|
//
|
|
// Our partition isn't NTFS. Bail.
|
|
//
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %ws is not NTFS volume\n",
|
|
DosName);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Now initialize the name for this partition and
|
|
// the name for this drive.
|
|
//
|
|
wsprintf( DosName, TEXT("\\\\.\\%c:"), DriveLetter );
|
|
wsprintf( PhysicalName, TEXT("\\\\.\\PhysicalDrive%u"), QueryHardDiskNumber( (UCHAR)DriveLetter) );
|
|
|
|
|
|
//
|
|
// =====================================
|
|
// 2. Figure out if there's any unpartitioned space behind
|
|
// the partition the user is asking us to extend.
|
|
// =====================================
|
|
//
|
|
|
|
//
|
|
// Get a handle to the disk so we can start examination.
|
|
//
|
|
h = CreateFile( PhysicalName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if( h == INVALID_HANDLE_VALUE ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while opening %ws\n",
|
|
GetLastError(),
|
|
PhysicalName);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Get the disk's layout information. We aren't
|
|
// sure how big of a buffer we need, so brute-force it.
|
|
//
|
|
{
|
|
DWORD DriveLayoutSize = 1024;
|
|
PVOID p;
|
|
|
|
DriveLayout = MyMalloc(DriveLayoutSize);
|
|
if( !DriveLayout ) {
|
|
CloseHandle( h );
|
|
return FALSE;
|
|
}
|
|
|
|
retry:
|
|
|
|
b = DeviceIoControl( h,
|
|
IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
|
|
NULL,
|
|
0,
|
|
(PVOID)DriveLayout,
|
|
DriveLayoutSize,
|
|
&Bytes,
|
|
NULL );
|
|
|
|
if( !b ) {
|
|
DWORD LastError = GetLastError();
|
|
|
|
if (LastError == ERROR_INSUFFICIENT_BUFFER) {
|
|
DriveLayoutSize += 1024;
|
|
|
|
if(p = MyRealloc((PVOID)DriveLayout,DriveLayoutSize)) {
|
|
(PVOID)DriveLayout = p;
|
|
} else {
|
|
goto cleanexit0;
|
|
}
|
|
goto retry;
|
|
} else {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while getting drive layout for %ws\n",
|
|
LastError,
|
|
PhysicalName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseHandle( h );
|
|
h = INVALID_HANDLE_VALUE;
|
|
|
|
|
|
|
|
//
|
|
// DriveLayout now is full of most of the information we
|
|
// need, including an array of partition information. But
|
|
// we aren't sure which partition is ours. We need to
|
|
// get info on our specific partition, then match it
|
|
// against the entry inside DriveLayout.
|
|
//
|
|
|
|
|
|
//
|
|
// Open a handle to the partition.
|
|
//
|
|
h = CreateFile( DosName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
INVALID_HANDLE_VALUE );
|
|
|
|
if( h == INVALID_HANDLE_VALUE ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while opening %ws\n",
|
|
GetLastError(),
|
|
DosName);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Load info about our partition.
|
|
//
|
|
b = DeviceIoControl( h,
|
|
IOCTL_DISK_GET_PARTITION_INFO_EX,
|
|
NULL,
|
|
0,
|
|
&PartitionInfo,
|
|
sizeof(PartitionInfo),
|
|
&Bytes,
|
|
NULL );
|
|
|
|
if( !b ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while getting %ws's partition information\n",
|
|
GetLastError(),
|
|
DosName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
|
|
|
|
//
|
|
// Might as well get the geometry info on the disk too.
|
|
//
|
|
b = DeviceIoControl( h,
|
|
IOCTL_DISK_GET_DRIVE_GEOMETRY,
|
|
NULL,
|
|
0,
|
|
&Geometry,
|
|
sizeof(Geometry),
|
|
&Bytes,
|
|
NULL );
|
|
|
|
if( !b ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while getting %ws's drive geometry\n",
|
|
GetLastError(),
|
|
DosName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
|
|
CloseHandle( h );
|
|
h = INVALID_HANDLE_VALUE;
|
|
|
|
|
|
|
|
//
|
|
// =====================================
|
|
// 3. How much space is available?
|
|
// =====================================
|
|
//
|
|
|
|
//
|
|
// We're ready to actually verify that there's rooom for us to grow.
|
|
// If we're the last partition on the disk, we need to see if there's
|
|
// any room behind us (i.e. any unpartitioned space). If we're not
|
|
// the last partition, we need to see if there's any space between where
|
|
// our partition ends and the next partition begins.
|
|
//
|
|
// This is really gross, but DriveLayout->PartitionCount will likely be 4
|
|
// even if there's really only 1 formatted partition on the disk. We also
|
|
// don't want to take the chance that the partitions aren't ordered by their
|
|
// location on the disk. So we need to go cycle through the partitions
|
|
// again and manually find the one that starts right after ours.
|
|
//
|
|
OurPartitionEndingLocation.QuadPart = PartitionInfo.StartingOffset.QuadPart + PartitionInfo.PartitionLength.QuadPart;
|
|
|
|
//
|
|
// Initialize BytesAvailable based on the space from where our partition ends to where
|
|
// the disk ends. This is the best case and we can only get smaller sizes, so this
|
|
// is safe.
|
|
//
|
|
BytesAvailable.QuadPart = UInt32x32To64( Geometry.BytesPerSector, Geometry.SectorsPerTrack );
|
|
BytesAvailable.QuadPart = BytesAvailable.QuadPart * (ULONGLONG)(Geometry.TracksPerCylinder);
|
|
BytesAvailable.QuadPart = BytesAvailable.QuadPart * Geometry.Cylinders.QuadPart;
|
|
|
|
//
|
|
// Check if the value of End of Partition is beyond the Disk size.
|
|
// If we do not have this check we find that the partition gets corrupted as
|
|
// IOCTL_DISK_GROW_PARTITION does not check the validity of the value
|
|
// passed to it. This condition (of a negative grow) would arise because of a
|
|
// rounding off(to the lower value) up to a cylinder by
|
|
// IOCTL_DISK_GET_DRIVE_GEOMETRY.
|
|
//
|
|
if (BytesAvailable.QuadPart <= OurPartitionEndingLocation.QuadPart) {
|
|
b = FALSE;
|
|
goto cleanexit0;
|
|
}
|
|
|
|
BytesAvailable.QuadPart = BytesAvailable.QuadPart - OurPartitionEndingLocation.QuadPart;
|
|
|
|
for( i = 0; i < DriveLayout->PartitionCount; i++ ) {
|
|
if( (DriveLayout->PartitionEntry[i].StartingOffset.QuadPart > OurPartitionEndingLocation.QuadPart) &&
|
|
((DriveLayout->PartitionEntry[i].StartingOffset.QuadPart - OurPartitionEndingLocation.QuadPart) < BytesAvailable.QuadPart) ) {
|
|
|
|
//
|
|
// This partition is starting after ours and it's also the closest one we've found
|
|
// to our ending location.
|
|
//
|
|
BytesAvailable.QuadPart = DriveLayout->PartitionEntry[i].StartingOffset.QuadPart - OurPartitionEndingLocation.QuadPart;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Reserve the space at the disk end only for MBR disks
|
|
//
|
|
if (DriveLayout->PartitionStyle == PARTITION_STYLE_MBR) {
|
|
//
|
|
// If we don't have at least 5MB available, don't even bother. If we do, leave the last
|
|
// 5MB free for later use as a dynamic volume.
|
|
//
|
|
if( BytesAvailable.QuadPart < (ULONGLONG)(LEAVE_FREE_BUFFER) ) {
|
|
goto cleanexit0;
|
|
} else {
|
|
BytesAvailable.QuadPart = BytesAvailable.QuadPart - (ULONGLONG)(LEAVE_FREE_BUFFER);
|
|
}
|
|
}
|
|
|
|
//
|
|
// See if the user has asked us to extend by some known value...
|
|
//
|
|
if( SizeMB ) {
|
|
//
|
|
// Yes. Make sure we have atleast this much space to extend.
|
|
//
|
|
if( (LONGLONG)(SizeMB * (1024*1024)) < BytesAvailable.QuadPart ) {
|
|
BytesAvailable.QuadPart = UInt32x32To64( SizeMB, (1024*1024) );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// =====================================
|
|
// 4. Extend the partition
|
|
// =====================================
|
|
//
|
|
|
|
//
|
|
// Get a handle to the disk.
|
|
//
|
|
h = CreateFile( PhysicalName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if( h == INVALID_HANDLE_VALUE ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while opening %ws\n",
|
|
GetLastError(),
|
|
PhysicalName);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Fill in the datastructure we'll be sending to the IOCTL.
|
|
//
|
|
GrowInfo.PartitionNumber = PartitionInfo.PartitionNumber;
|
|
GrowInfo.BytesToGrow = BytesAvailable;
|
|
|
|
|
|
//
|
|
// Do it.
|
|
//
|
|
b = DeviceIoControl( h,
|
|
IOCTL_DISK_GROW_PARTITION,
|
|
&GrowInfo,
|
|
sizeof(GrowInfo),
|
|
NULL,
|
|
0,
|
|
&Bytes,
|
|
NULL );
|
|
|
|
if( !b ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while growing %ws partition\n",
|
|
GetLastError(),
|
|
PhysicalName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
|
|
CloseHandle( h );
|
|
h = INVALID_HANDLE_VALUE;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// =====================================
|
|
// 5. Extend the filesystem (inform him the partition is bigger).
|
|
// =====================================
|
|
//
|
|
|
|
|
|
|
|
//
|
|
// Get a handle to the partition.
|
|
//
|
|
h = CreateFile( DosName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
INVALID_HANDLE_VALUE );
|
|
|
|
if( h == INVALID_HANDLE_VALUE ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while opening %ws\n",
|
|
GetLastError(),
|
|
DosName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Gather some info on the partition.
|
|
//
|
|
b = DeviceIoControl( h,
|
|
IOCTL_DISK_GET_PARTITION_INFO_EX,
|
|
NULL,
|
|
0,
|
|
&PartitionInfo,
|
|
sizeof(PartitionInfo),
|
|
&Bytes,
|
|
NULL );
|
|
|
|
if( !b ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while getting %ws's partition information\n",
|
|
GetLastError(),
|
|
DosName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
|
|
|
|
//
|
|
// Grow the volume.
|
|
//
|
|
BytesAvailable.QuadPart = PartitionInfo.PartitionLength.QuadPart / Geometry.BytesPerSector;
|
|
|
|
b = DeviceIoControl( h,
|
|
FSCTL_EXTEND_VOLUME,
|
|
&BytesAvailable,
|
|
sizeof(BytesAvailable),
|
|
NULL,
|
|
0,
|
|
&Bytes,
|
|
NULL );
|
|
|
|
if( !b ) {
|
|
DbgPrintEx( DPFLTR_SETUP_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"ExtendPartition: %X Error while extending volume %ws\n",
|
|
GetLastError(),
|
|
DosName);
|
|
|
|
goto cleanexit0;
|
|
}
|
|
|
|
cleanexit0:
|
|
if( h != INVALID_HANDLE_VALUE ) {
|
|
CloseHandle( h );
|
|
}
|
|
|
|
|
|
//
|
|
// If we successfully extended the partition
|
|
// then mark the global flag to remove any
|
|
// stale volume information, at the end of setup.
|
|
//
|
|
if (b) {
|
|
PartitionExtended = TRUE;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
SetupExtendPartition(
|
|
IN WCHAR DriveLetter,
|
|
IN ULONG SizeMB OPTIONAL
|
|
)
|
|
{
|
|
BOOL b;
|
|
|
|
if ( b = ExtendPartition(DriveLetter, SizeMB) )
|
|
{
|
|
RemoveStaleVolumes();
|
|
PartitionExtended = FALSE;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DoFilesMatch(
|
|
IN PCWSTR File1,
|
|
IN PCWSTR File2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Compares two files to each other to see if they are identical.
|
|
|
|
Arguments:
|
|
|
|
File1 - First file to compare
|
|
File2 - Second file to compare
|
|
|
|
|
|
Return Value:
|
|
|
|
BOOL - Returns TRUE if the files match. If the both of the files are zero
|
|
length, then we still return TRUE.
|
|
|
|
--*/
|
|
{
|
|
DWORD FirstFileSize, SecondFileSize;
|
|
HANDLE FirstFileHandle, FirstMappingHandle;
|
|
HANDLE SecondFileHandle, SecondMappingHandle;
|
|
PVOID FirstBaseAddress, SecondBaseAddress;
|
|
|
|
BOOL RetVal = FALSE;
|
|
|
|
if( (pSetupOpenAndMapFileForRead(
|
|
File1,
|
|
&FirstFileSize,
|
|
&FirstFileHandle,
|
|
&FirstMappingHandle,
|
|
&FirstBaseAddress) == NO_ERROR)
|
|
&& (pSetupOpenAndMapFileForRead(
|
|
File1,
|
|
&SecondFileSize,
|
|
&SecondFileHandle,
|
|
&SecondMappingHandle,
|
|
&SecondBaseAddress) == NO_ERROR) ) {
|
|
|
|
if (FirstFileSize == SecondFileSize ) {
|
|
if (FirstFileSize != 0) {
|
|
//
|
|
// protect against inpage IO error
|
|
//
|
|
try {
|
|
RetVal = !memcmp(
|
|
FirstBaseAddress,
|
|
SecondBaseAddress,
|
|
FirstFileSize
|
|
);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
RetVal = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
pSetupUnmapAndCloseFile(
|
|
FirstFileHandle,
|
|
FirstMappingHandle,
|
|
FirstBaseAddress
|
|
);
|
|
|
|
pSetupUnmapAndCloseFile(
|
|
SecondFileHandle,
|
|
SecondMappingHandle,
|
|
SecondBaseAddress
|
|
);
|
|
|
|
}
|
|
|
|
return (RetVal);
|
|
}
|
|
|
|
DWORD
|
|
RemoveStaleVolumes(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine walks through all the volumes and deletes the one
|
|
which are marked for reinstall.
|
|
|
|
NOTE : Use the function carefully because it will nuke all
|
|
the entries related to the volume from the registry, iff the volume
|
|
says it needs to be reinstalled.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Appropriate Win32 error code.
|
|
|
|
--*/
|
|
{
|
|
const TCHAR *VolumeKeyName = TEXT("System\\CurrentControlSet\\Enum\\Storage\\Volume");
|
|
const TCHAR *ClassKeyName = TEXT("System\\CurrentControlSet\\Control\\Class");
|
|
|
|
DWORD ErrorCode;
|
|
HKEY VolumeKey = NULL;
|
|
HKEY ClassKey = NULL;
|
|
ULONG Index = 0;
|
|
ULONG VolumesFixedCount = 0;
|
|
TCHAR SubKeyName[MAX_PATH*2];
|
|
DWORD SubKeyLength;
|
|
FILETIME SubKeyTime;
|
|
|
|
//
|
|
// Open the Volume key
|
|
//
|
|
ErrorCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
VolumeKeyName,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&VolumeKey);
|
|
|
|
if (VolumeKey == NULL) {
|
|
ErrorCode = ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
if (ErrorCode != ERROR_SUCCESS) {
|
|
return ErrorCode;
|
|
}
|
|
|
|
//
|
|
// Open the Class key
|
|
//
|
|
ErrorCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
ClassKeyName,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&ClassKey);
|
|
|
|
if (ClassKey == NULL) {
|
|
ErrorCode = ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
if (ErrorCode != ERROR_SUCCESS) {
|
|
RegCloseKey(VolumeKey);
|
|
|
|
return ErrorCode;
|
|
}
|
|
|
|
//
|
|
// Enumerate each subkey of the opened key
|
|
//
|
|
while (TRUE) {
|
|
SubKeyName[0] = 0;
|
|
SubKeyLength = sizeof(SubKeyName) / sizeof(SubKeyName[0]);
|
|
|
|
ErrorCode = RegEnumKeyEx(VolumeKey,
|
|
Index,
|
|
SubKeyName,
|
|
&SubKeyLength,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&SubKeyTime);
|
|
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
TCHAR FullSubKeyName[MAX_PATH*4];
|
|
DWORD SubErrorCode;
|
|
HKEY CurrentSubKey = NULL;
|
|
GUID VolumeGuid = {0};
|
|
TCHAR VolumeGuidStr[MAX_PATH] = {0};
|
|
DWORD DrvInstance = -1;
|
|
BOOL DeleteKey = FALSE;
|
|
BOOL DeleteClassInstance = FALSE;
|
|
BOOL IncrementKeyIndex = TRUE;
|
|
|
|
_tcscpy(FullSubKeyName, VolumeKeyName);
|
|
_tcscat(FullSubKeyName, TEXT("\\"));
|
|
_tcscat(FullSubKeyName, SubKeyName);
|
|
|
|
SubErrorCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
FullSubKeyName,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&CurrentSubKey);
|
|
|
|
if (SubErrorCode == ERROR_SUCCESS) {
|
|
//
|
|
// Read the ConfigFlags value
|
|
//
|
|
DWORD ConfigFlags = 0;
|
|
DWORD Type = REG_DWORD;
|
|
DWORD BufferSize = sizeof(DWORD);
|
|
|
|
SubErrorCode = RegQueryValueEx(CurrentSubKey,
|
|
TEXT("ConfigFlags"),
|
|
NULL,
|
|
&Type,
|
|
(PBYTE)&ConfigFlags,
|
|
&BufferSize);
|
|
|
|
if (SubErrorCode == ERROR_SUCCESS) {
|
|
|
|
DeleteKey = (ConfigFlags & (CONFIGFLAG_REINSTALL | CONFIGFLAG_FINISH_INSTALL));
|
|
|
|
if (DeleteKey) {
|
|
Type = REG_BINARY;
|
|
BufferSize = sizeof(VolumeGuid);
|
|
|
|
//
|
|
// Read the GUID & DrvInst values
|
|
//
|
|
SubErrorCode = RegQueryValueEx(CurrentSubKey,
|
|
TEXT("GUID"),
|
|
NULL,
|
|
&Type,
|
|
(PBYTE)&VolumeGuid,
|
|
&BufferSize);
|
|
|
|
if (SubErrorCode == ERROR_SUCCESS) {
|
|
Type = REG_DWORD;
|
|
BufferSize = sizeof(DWORD);
|
|
|
|
SubErrorCode = RegQueryValueEx(CurrentSubKey,
|
|
TEXT("DrvInst"),
|
|
NULL,
|
|
&Type,
|
|
(PBYTE)&DrvInstance,
|
|
&BufferSize);
|
|
|
|
DeleteClassInstance =
|
|
(SubErrorCode == ERROR_SUCCESS) &&
|
|
(DrvInstance != -1);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Close the current subkey since we don't need it anymore
|
|
//
|
|
RegCloseKey(CurrentSubKey);
|
|
|
|
//
|
|
// Delete after we close the current key
|
|
//
|
|
if (DeleteKey) {
|
|
SubErrorCode = SHDeleteKey(HKEY_LOCAL_MACHINE,
|
|
FullSubKeyName);
|
|
|
|
if (SubErrorCode == ERROR_SUCCESS) {
|
|
VolumesFixedCount++;
|
|
IncrementKeyIndex = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Delete the instance key under class also if needed
|
|
//
|
|
if (DeleteClassInstance &&
|
|
(pSetupStringFromGuid(&VolumeGuid,
|
|
VolumeGuidStr,
|
|
sizeof(VolumeGuidStr)/sizeof(VolumeGuidStr[0])) == ERROR_SUCCESS)) {
|
|
_stprintf(FullSubKeyName,
|
|
TEXT("System\\CurrentControlSet\\Control\\Class\\%ws\\%04d"),
|
|
VolumeGuidStr,
|
|
DrvInstance);
|
|
|
|
SubErrorCode = SHDeleteKey(HKEY_LOCAL_MACHINE,
|
|
FullSubKeyName);
|
|
}
|
|
}
|
|
|
|
if (IncrementKeyIndex) {
|
|
Index++;
|
|
}
|
|
} else {
|
|
break; // we couldn't enumerate further sub keys
|
|
}
|
|
}
|
|
|
|
RegCloseKey(ClassKey);
|
|
RegCloseKey(VolumeKey);
|
|
|
|
//
|
|
// If we fixed at least a single volume then assume things
|
|
// went fine
|
|
//
|
|
if (VolumesFixedCount > 0) {
|
|
ErrorCode = ERROR_SUCCESS;
|
|
}
|
|
|
|
return ErrorCode;
|
|
}
|
|
|
|
#define MAX_NT_PATH (MAX_PATH + 4)//"\\??\\"
|
|
#define UNDO_FILE_NAME L"UNDO_GUIMODE.TXT"
|
|
|
|
VOID
|
|
RemoveAllPendingOperationsOnRestartOfGUIMode(
|
|
VOID
|
|
)
|
|
{
|
|
WCHAR undoFilePath[MAX_PATH];
|
|
|
|
if(!GetWindowsDirectoryW(undoFilePath, ARRAYSIZE(undoFilePath))){
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
wcscat(undoFilePath, L"\\system32\\");
|
|
wcscat(undoFilePath, UNDO_FILE_NAME);
|
|
|
|
SetFileAttributes(undoFilePath, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(undoFilePath);
|
|
}
|
|
|
|
BOOL
|
|
RenameOnRestartOfGUIMode(
|
|
IN PCWSTR pPathName,
|
|
IN PCWSTR pPathNameNew
|
|
)
|
|
{
|
|
DWORD Size;
|
|
BOOL result;
|
|
WCHAR undoFilePath[MAX_PATH];
|
|
WCHAR RenameOperationBuffer[2 * (MAX_NT_PATH + 2/*'\r\n'*/)];
|
|
HANDLE fileUndo;
|
|
BYTE signUnicode[] = {0xff, 0xfe};
|
|
|
|
if(!pPathName){
|
|
return FALSE;
|
|
}
|
|
|
|
if(!GetWindowsDirectoryW(undoFilePath, ARRAYSIZE(undoFilePath))){
|
|
return FALSE;
|
|
}
|
|
wcscat(undoFilePath, L"\\system32\\" UNDO_FILE_NAME);
|
|
|
|
wsprintfW(RenameOperationBuffer, L"\\??\\%s\r\n", pPathName);
|
|
if(pPathNameNew){
|
|
wsprintfW(RenameOperationBuffer + wcslen(RenameOperationBuffer),
|
|
L"\\??\\%s",
|
|
pPathNameNew);
|
|
}
|
|
wcscat(RenameOperationBuffer, L"\r\n");
|
|
|
|
fileUndo = CreateFileW(undoFilePath,
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
if(INVALID_HANDLE_VALUE == fileUndo){
|
|
return FALSE;
|
|
}
|
|
|
|
if(!SetFilePointer(fileUndo, 0, NULL, FILE_END)){
|
|
result = WriteFile(fileUndo, signUnicode, sizeof(signUnicode), &Size, NULL);
|
|
}
|
|
else {
|
|
result = TRUE;
|
|
}
|
|
|
|
if(result){
|
|
result = WriteFile(fileUndo,
|
|
RenameOperationBuffer,
|
|
wcslen(RenameOperationBuffer) * sizeof(WCHAR),
|
|
&Size,
|
|
NULL);
|
|
}
|
|
|
|
CloseHandle(fileUndo);
|
|
|
|
return result;
|
|
}
|
|
|
|
BOOL
|
|
DeleteOnRestartOfGUIMode(
|
|
IN PCWSTR pPathName
|
|
)
|
|
{
|
|
return RenameOnRestartOfGUIMode(pPathName, NULL);
|
|
}
|