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.
5010 lines
160 KiB
5010 lines
160 KiB
/*++
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
backup.c
|
|
|
|
Abstract:
|
|
|
|
Routines to control backup during install process
|
|
And restore of an old install process
|
|
|
|
Author:
|
|
|
|
Jamie Hunter (jamiehun) 13-Jan-1997
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
VOID
|
|
pSetupExemptFileFromProtection(
|
|
IN PCTSTR FileName,
|
|
IN DWORD FileChangeFlags,
|
|
IN PSETUP_LOG_CONTEXT LogContext, OPTIONAL
|
|
OUT PDWORD QueueNodeFlags OPTIONAL
|
|
);
|
|
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupQueueBackupCopy(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN LONG TargetRootPath,
|
|
IN LONG TargetSubDir, OPTIONAL
|
|
IN LONG TargetFilename,
|
|
IN LONG BackupRootPath,
|
|
IN LONG BackupSubDir, OPTIONAL
|
|
IN LONG BackupFilename
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place a backup copy operation on a setup file queue.
|
|
Target is to be backed up at Backup location
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - supplies a handle to a setup file queue, as returned
|
|
by SetupOpenFileQueue.
|
|
|
|
TargetRootPath - Supplies the source directory, eg C:\WINNT\
|
|
|
|
TargetSubDir - Supplies the optional sub-directory (eg WINNT if RootPath = c:\ )
|
|
|
|
TargetFilename - supplies the filename part of the file to be copied.
|
|
|
|
BackupRootPath - supplies the directory where the file is to be copied.
|
|
|
|
BackupSubDir - supplies the optional sub-directory
|
|
|
|
BackupFilename - supplies the name of the target file.
|
|
|
|
Return Value:
|
|
|
|
same value as GetLastError() indicating error, or NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
PSP_FILE_QUEUE Queue;
|
|
PSP_FILE_QUEUE_NODE QueueNode,TempNode;
|
|
int Size;
|
|
DWORD Err;
|
|
PVOID StringTable;
|
|
PTSTR FullRootName;
|
|
|
|
Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
Err = NO_ERROR;
|
|
|
|
try {
|
|
StringTable = Queue->StringTable; // used for strings in source queue
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Allocate a queue structure.
|
|
//
|
|
QueueNode = MyMalloc(sizeof(SP_FILE_QUEUE_NODE));
|
|
if (!QueueNode) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Operation is backup.
|
|
//
|
|
QueueNode->Operation = FILEOP_BACKUP;
|
|
QueueNode->InternalFlags = 0;
|
|
|
|
QueueNode->SourceRootPath = BackupRootPath;
|
|
QueueNode->SourcePath = BackupSubDir;
|
|
QueueNode->SourceFilename = BackupFilename;
|
|
|
|
// if target has a sub-dir, we have to combine root and subdir into one string
|
|
if (TargetSubDir != -1) {
|
|
|
|
FullRootName = pSetupFormFullPath(
|
|
StringTable,
|
|
TargetRootPath,
|
|
TargetSubDir,
|
|
-1);
|
|
|
|
if (!FullRootName) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean1;
|
|
}
|
|
|
|
TargetRootPath = pSetupStringTableAddString(StringTable,
|
|
FullRootName,
|
|
STRTAB_CASE_SENSITIVE
|
|
);
|
|
MyFree(FullRootName);
|
|
|
|
if (TargetRootPath == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean1;
|
|
}
|
|
|
|
// now combined into TargetRootPath
|
|
TargetSubDir = -1;
|
|
|
|
}
|
|
QueueNode->TargetDirectory = TargetRootPath;
|
|
QueueNode->TargetFilename = TargetFilename;
|
|
|
|
QueueNode->Next = NULL;
|
|
|
|
//
|
|
// Link the node onto the end of the backup queue
|
|
//
|
|
|
|
if (Queue->BackupQueue) {
|
|
for (TempNode = Queue->BackupQueue; TempNode->Next; TempNode=TempNode->Next) /* blank */ ;
|
|
TempNode->Next = QueueNode;
|
|
} else {
|
|
Queue->BackupQueue = QueueNode;
|
|
}
|
|
|
|
Queue->BackupNodeCount++;
|
|
|
|
Err = NO_ERROR;
|
|
goto clean0;
|
|
|
|
clean1:
|
|
MyFree(QueueNode);
|
|
clean0:
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
BOOL
|
|
pSetupGetFullBackupPath(
|
|
OUT PTSTR FullPath,
|
|
IN PCTSTR Path, OPTIONAL
|
|
IN UINT TargetBufferSize,
|
|
OUT PUINT RequiredSize OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine takes a potentially relative path
|
|
and concatenates it to the base path
|
|
|
|
Arguments:
|
|
|
|
FullPath - Destination for full path
|
|
Path - Relative source path to backup directory if specified.
|
|
If NULL, generates a temporary path
|
|
TargetBufferSize - Size of buffer (characters)
|
|
RequiredSize - Filled in with size required to contain full path
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, return TRUE
|
|
If there was an error, return FALSE
|
|
|
|
--*/
|
|
{
|
|
UINT PathLen;
|
|
LPCTSTR Base = WindowsBackupDirectory;
|
|
|
|
if(!Path) {
|
|
//
|
|
// temporary location
|
|
//
|
|
Path = SP_BACKUP_OLDFILES;
|
|
Base = WindowsDirectory;
|
|
}
|
|
|
|
//
|
|
// Backup directory is stored in "WindowsBackupDirectory" for permanent backups
|
|
// and WindowsDirectory\SP_BACKUP_OLDFILES for temporary backups
|
|
//
|
|
|
|
PathLen = lstrlen(Base);
|
|
|
|
if ( FullPath == NULL || TargetBufferSize <= PathLen ) {
|
|
// just calculate required path len
|
|
FullPath = (PTSTR) Base;
|
|
TargetBufferSize = 0;
|
|
} else {
|
|
// calculate and copy
|
|
lstrcpy(FullPath, Base);
|
|
}
|
|
return pSetupConcatenatePaths(FullPath, Path, TargetBufferSize, RequiredSize);
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupCopyString(
|
|
IN PVOID DestStringTable,
|
|
OUT PLONG DestStringID,
|
|
IN PVOID SrcStringTable,
|
|
IN LONG SrcStringID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets a string from source string table, adds it to destination string table with new ID.
|
|
|
|
Arguments:
|
|
|
|
DestStringTable - Where string has to go
|
|
DestStringID - pointer, set to string ID in respect to DestStringTable
|
|
SrcStringTable - Where string is coming from
|
|
StringID - string ID in respect to SrcStringTable
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Err = NO_ERROR;
|
|
LONG DestID;
|
|
PTSTR String;
|
|
|
|
if (DestStringID == NULL) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
if (SrcStringID == -1) {
|
|
// "not supplied"
|
|
DestID = -1;
|
|
} else {
|
|
// actually need to copy
|
|
|
|
String = pSetupStringTableStringFromId( SrcStringTable, SrcStringID );
|
|
if (String == NULL) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
DestID = pSetupStringTableAddString( DestStringTable, String, STRTAB_CASE_SENSITIVE );
|
|
if (DestID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
*DestStringID = DestID;
|
|
}
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupGetTargetByPath(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN PVOID PathStringTable, OPTIONAL
|
|
IN PCTSTR TargetPath, OPTIONAL
|
|
IN LONG TargetRoot,
|
|
IN LONG TargetSubDir, OPTIONAL
|
|
IN LONG TargetFilename,
|
|
OUT PLONG TableID, OPTIONAL
|
|
OUT PSP_TARGET_ENT TargetInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given a pathname, obtains/creates target info
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - Queue we're looking at
|
|
PathStringTable - String table used for the Target Root/SubDir/Filename strings, NULL if same as QueueHandle's
|
|
TargetPath - if given, is the full path, previously generated
|
|
TargetRoot - root portion, eg c:\winnt
|
|
TargetSubDir - optional sub-directory portion, -1 if not provided
|
|
TargetFilename - filename , eg readme.txt
|
|
TableID - filled with ID for future use in pSetupBackupGetTargetByID or pSetupBackupSetTargetByID
|
|
TargetInfo - Filled with information about target
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG PathID;
|
|
TCHAR PathBuffer[MAX_PATH];
|
|
PTSTR TmpPtr;
|
|
PVOID LookupTable = NULL;
|
|
PVOID QueueStringTable = NULL;
|
|
PTSTR FullTargetPath = NULL;
|
|
DWORD Err = NO_ERROR;
|
|
PSP_FILE_QUEUE Queue;
|
|
DWORD RequiredSize;
|
|
|
|
Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
try {
|
|
LookupTable = Queue->TargetLookupTable; // used for path lookup in source queue
|
|
QueueStringTable = Queue->StringTable; // used for strings in source queue
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
if (PathStringTable == NULL) {
|
|
// default string table is that of queue's
|
|
PathStringTable = QueueStringTable;
|
|
}
|
|
|
|
if (TargetPath == NULL) {
|
|
// obtain the complete target path and filename (Duplicated String)
|
|
FullTargetPath = pSetupFormFullPath(
|
|
PathStringTable,
|
|
TargetRoot,
|
|
TargetSubDir,
|
|
TargetFilename);
|
|
|
|
if (!FullTargetPath) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
TargetPath = FullTargetPath;
|
|
}
|
|
|
|
//
|
|
// normalize path
|
|
//
|
|
RequiredSize = GetFullPathName(TargetPath,
|
|
SIZECHARS(PathBuffer),
|
|
PathBuffer,
|
|
&TmpPtr
|
|
);
|
|
//
|
|
// This call should always succeed.
|
|
//
|
|
MYASSERT((RequiredSize > 0) &&
|
|
(RequiredSize < SIZECHARS(PathBuffer)) // RequiredSize doesn't include terminating NULL char
|
|
);
|
|
|
|
//
|
|
// Even though we asserted that this should not be the case above,
|
|
// we should handle failure in case asserts are turned off.
|
|
//
|
|
if(!RequiredSize) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
} else if(RequiredSize >= SIZECHARS(PathBuffer)) {
|
|
Err = ERROR_BUFFER_OVERFLOW;
|
|
goto clean0;
|
|
}
|
|
|
|
PathID = pSetupStringTableLookUpStringEx(LookupTable, PathBuffer, 0, TargetInfo, sizeof(SP_TARGET_ENT));
|
|
if (PathID == -1) {
|
|
ZeroMemory(TargetInfo, sizeof(SP_TARGET_ENT));
|
|
if (PathStringTable != QueueStringTable) {
|
|
// need to add entries to Queue's string table if we're using another
|
|
|
|
Err = pSetupBackupCopyString(QueueStringTable, &TargetRoot, PathStringTable, TargetRoot);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
Err = pSetupBackupCopyString(QueueStringTable, &TargetSubDir, PathStringTable, TargetSubDir);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
Err = pSetupBackupCopyString(QueueStringTable, &TargetFilename, PathStringTable, TargetFilename);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
PathStringTable = QueueStringTable;
|
|
}
|
|
TargetInfo->TargetRoot = TargetRoot;
|
|
TargetInfo->TargetSubDir = TargetSubDir;
|
|
TargetInfo->TargetFilename = TargetFilename;
|
|
TargetInfo->BackupRoot = -1;
|
|
TargetInfo->BackupSubDir = -1;
|
|
TargetInfo->BackupFilename = -1;
|
|
TargetInfo->NewTargetFilename = -1;
|
|
TargetInfo->InternalFlags = 0;
|
|
|
|
PathID = pSetupStringTableAddStringEx(LookupTable, PathBuffer, 0, TargetInfo, sizeof(SP_TARGET_ENT));
|
|
if (PathID == -1)
|
|
{
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
if (TableID != NULL) {
|
|
*TableID = PathID;
|
|
}
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
if (FullTargetPath != NULL) {
|
|
MyFree(FullTargetPath);
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupGetTargetByID(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN LONG TableID,
|
|
OUT PSP_TARGET_ENT TargetInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given an entry in the LookupTable, gets info
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - Queue we're looking at
|
|
TableID - ID relating to string entry we've found (via pSetupBackupGetTargetByPath)
|
|
TargetInfo - Filled with information about target
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
PVOID LookupTable = NULL;
|
|
DWORD Err = NO_ERROR;
|
|
PSP_FILE_QUEUE Queue;
|
|
|
|
Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
|
|
try {
|
|
LookupTable = Queue->TargetLookupTable; // used for strings in source queue
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
if (pSetupStringTableGetExtraData(LookupTable, TableID, TargetInfo, sizeof(SP_TARGET_ENT)) == FALSE) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupSetTargetByID(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN LONG TableID,
|
|
IN PSP_TARGET_ENT TargetInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given an entry in the LookupTable, sets info
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - Queue we're looking at
|
|
TableID - ID relating to string entry we've found (via pSetupBackupGetTargetByPath)
|
|
TargetInfo - Filled with information about target
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
PVOID LookupTable = NULL;
|
|
DWORD Err = NO_ERROR;
|
|
PSP_FILE_QUEUE Queue;
|
|
|
|
Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
|
|
try {
|
|
LookupTable = Queue->TargetLookupTable; // used for strings in source queue
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
if ( pSetupStringTableSetExtraData(LookupTable, TableID, TargetInfo, sizeof(SP_TARGET_ENT)) == FALSE) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupGetReinstallKeyStrings(
|
|
IN PSP_FILE_QUEUE BackupFileQueue,
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData,
|
|
IN PCTSTR DeviceID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will save the values needed to create the Reinstall backup key
|
|
in the string table of the backup queue. We save these strings in the string
|
|
table before the new drivers are installed and then create the registry key
|
|
after the new device is installed. It is done this way because the Rollback
|
|
UI code will look for the Reinstall subkeys, so we want to make sure that
|
|
we have successfully backed-up all of the needed files before we create
|
|
this Reinstall subkey.
|
|
|
|
Arguments:
|
|
|
|
BackupFileQueue -
|
|
DeviceInfoSet -
|
|
DeviceInfoData -
|
|
DeviceID -
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
DWORD Err = NO_ERROR;
|
|
HKEY hKeyDevReg = INVALID_HANDLE_VALUE;
|
|
DWORD RegCreated, cbData;
|
|
TCHAR Buffer[MAX_PATH];
|
|
|
|
try {
|
|
|
|
//
|
|
// Get the DeviceDesc of the device and fill in the BackupDevDescID and
|
|
// BackupDisplayNameID values in the string table. This value is
|
|
// required since it is needed during a rollback for us to choose the
|
|
// exact driver that was installed from the specific INF.
|
|
//
|
|
if (!SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
SPDRP_DEVICEDESC,
|
|
NULL,
|
|
(PBYTE)Buffer,
|
|
sizeof(Buffer),
|
|
NULL)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
BackupFileQueue->BackupDeviceDescID =
|
|
pSetupStringTableAddString(BackupFileQueue->StringTable,
|
|
Buffer,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
if (BackupFileQueue->BackupDeviceDescID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// At this point we will also set the BackupDisplayNameID value just in
|
|
// case the device does not have a FriendlyName.
|
|
//
|
|
BackupFileQueue->BackupDisplayNameID =
|
|
pSetupStringTableAddString(BackupFileQueue->StringTable,
|
|
Buffer,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
if (BackupFileQueue->BackupDisplayNameID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// We will try and get the device's FriendlyName. If it has one then we
|
|
// will set the BackupDisplayNameID to this value, otherwise DisplayName
|
|
// will just be the DeviceDesc.
|
|
//
|
|
if (SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
SPDRP_FRIENDLYNAME,
|
|
NULL,
|
|
(PBYTE)Buffer,
|
|
sizeof(Buffer),
|
|
NULL)) {
|
|
|
|
BackupFileQueue->BackupDisplayNameID =
|
|
pSetupStringTableAddString(BackupFileQueue->StringTable,
|
|
Buffer,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
if (BackupFileQueue->BackupDisplayNameID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the BackupMfgID value.
|
|
//
|
|
if (!SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
SPDRP_MFG,
|
|
NULL,
|
|
(PBYTE)Buffer,
|
|
sizeof(Buffer),
|
|
NULL)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
BackupFileQueue->BackupMfgID =
|
|
pSetupStringTableAddString(BackupFileQueue->StringTable,
|
|
Buffer,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
if (BackupFileQueue->BackupMfgID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Set the BackupProviderNameID value.
|
|
//
|
|
hKeyDevReg = SetupDiOpenDevRegKey(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DRV,
|
|
KEY_READ
|
|
);
|
|
|
|
if (hKeyDevReg == INVALID_HANDLE_VALUE) {
|
|
goto clean0;
|
|
}
|
|
|
|
cbData = sizeof(Buffer);
|
|
Err = RegQueryValueEx(hKeyDevReg,
|
|
pszProviderName,
|
|
NULL,
|
|
NULL,
|
|
(PBYTE)Buffer,
|
|
&cbData
|
|
);
|
|
|
|
RegCloseKey(hKeyDevReg);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
BackupFileQueue->BackupProviderNameID =
|
|
pSetupStringTableAddString(BackupFileQueue->StringTable,
|
|
Buffer,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
if (BackupFileQueue->BackupProviderNameID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Set the DeviceInstanceIds value. This is a multi-sz value so make
|
|
// sure we put a double NULL on the end.
|
|
//
|
|
BackupFileQueue->BackupDeviceInstanceID =
|
|
pSetupStringTableAddString(BackupFileQueue->StringTable,
|
|
(PTSTR)DeviceID,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
if (BackupFileQueue->BackupDeviceInstanceID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
|
|
clean0: ; // Nothing to do.
|
|
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// if we except, assume it's due to invalid parameter
|
|
//
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupCreateReinstallKey(
|
|
IN PSP_FILE_QUEUE BackupFileQueue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will create the needed reinstall registry key so that these
|
|
drivers can be later rolled back. The reinstall registry key lives in the
|
|
following location:
|
|
|
|
HKLM\Software\Microsoft\Windows\CurrentVersion\Reinstall\xxxx
|
|
|
|
where xxxx is the BackupInstanceId.
|
|
|
|
Under this key we will store the following information
|
|
|
|
DisplayName - This is the name that is displayed in any UI of
|
|
drivers that can be reinstalled. This is normally
|
|
just the device description.
|
|
DeviceInstanceIds - Multi-sz string of the device instance Ids of
|
|
every device that is using this backup. Setupapi
|
|
only sets the first device instance Id. Newdev
|
|
can append other device instance Ids to this list
|
|
if it is doing multiple device installs (in the
|
|
case of UpdateDriverForPlugAndPlayDevices or
|
|
InstallWindowsUpdateDriver).
|
|
ReinstallString - The full backup path including the INF file
|
|
DeviceDesc - The DeviceDesc of the driver that was installed.
|
|
This is needed to make sure we pick the identical
|
|
driver during a roll back.
|
|
Mfg - The Mfg of the driver that was installed.
|
|
This is needed to make sure we pick the identical
|
|
driver during a roll back.
|
|
ProviderName - The ProviderName of the driver that was installed.
|
|
This is needed to make sure we pick the identical
|
|
driver during a roll back.
|
|
|
|
|
|
Arguments:
|
|
|
|
BackupFileQueue -
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
DWORD Err = NO_ERROR;
|
|
HKEY hKeyReinstall = INVALID_HANDLE_VALUE;
|
|
HKEY hKeyReinstallInstance = INVALID_HANDLE_VALUE;
|
|
DWORD RegCreated, cbData;
|
|
TCHAR Buffer[MAX_PATH];
|
|
BOOL b;
|
|
|
|
try {
|
|
|
|
//
|
|
// Make sure the BackupInfID is valid. If it is -1 then something went
|
|
// wrong during the backup and so we do not want to create the Reinstall
|
|
// instance subkey.
|
|
//
|
|
if (BackupFileQueue->BackupInfID == -1) {
|
|
|
|
Err = ERROR_NO_BACKUP;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Open/Create the Reinstall registry key. Call RegCreateKeyEx in case
|
|
// this is the first time a backup is being performed and this key
|
|
// does not yet exist.
|
|
//
|
|
Err = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
|
|
pszReinstallPath,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hKeyReinstall,
|
|
&RegCreated
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Create the Reinstall instance key under the Reinstall key.
|
|
//
|
|
cbData = MAX_PATH;
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupInstanceID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
Err = RegCreateKeyEx(hKeyReinstall,
|
|
Buffer,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hKeyReinstallInstance,
|
|
&RegCreated
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Add the DeviceDesc to the Reinstall instance subkey
|
|
//
|
|
cbData = MAX_PATH;
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupDeviceDescID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
Err = RegSetValueEx(hKeyReinstallInstance,
|
|
pszDeviceDesc,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE)Buffer,
|
|
(lstrlen(Buffer) + 1) * sizeof(TCHAR)
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Add the DisplayName to the Reinstall instance subkey
|
|
//
|
|
cbData = MAX_PATH;
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupDisplayNameID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
RegSetValueEx(hKeyReinstallInstance,
|
|
pszReinstallDisplayName,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE)Buffer,
|
|
(lstrlen(Buffer) + 1) * sizeof(TCHAR)
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Add the Mfg to the Reinstall instance subkey
|
|
//
|
|
cbData = MAX_PATH;
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupMfgID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
Err = RegSetValueEx(hKeyReinstallInstance,
|
|
pszMfg,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE)Buffer,
|
|
(lstrlen(Buffer) + 1) * sizeof(TCHAR)
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Add the ProviderName to the Reinstall instance subkey
|
|
//
|
|
cbData = MAX_PATH;
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupProviderNameID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
Err = RegSetValueEx(hKeyReinstallInstance,
|
|
pszProviderName,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE)Buffer,
|
|
(lstrlen(Buffer) + 1) * sizeof(TCHAR)
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Set the DeviceInstanceIds value. This is a multi-sz value so make
|
|
// sure we put a double NULL on the end.
|
|
//
|
|
//
|
|
// Add the Mfg to the Reinstall instance subkey
|
|
//
|
|
cbData = MAX_PATH;
|
|
ZeroMemory(Buffer, sizeof(Buffer));
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupDeviceInstanceID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
Err = RegSetValueEx(hKeyReinstallInstance,
|
|
pszReinstallDeviceInstanceIds,
|
|
0,
|
|
REG_MULTI_SZ,
|
|
(PBYTE)Buffer,
|
|
(lstrlen(Buffer) + 2) * sizeof(TCHAR)
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Add the ReinstallString to the Reinstall instance subkey
|
|
//
|
|
cbData = MAX_PATH;
|
|
b = pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupInfID,
|
|
Buffer,
|
|
&cbData);
|
|
if (b == FALSE) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
Err = RegSetValueEx(hKeyReinstallInstance,
|
|
pszReinstallString,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE)Buffer,
|
|
(lstrlen(Buffer) + 1) * sizeof(TCHAR)
|
|
);
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
goto clean0;
|
|
}
|
|
|
|
clean0: ; // Nothing to do.
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// if we except, assume it's due to invalid parameter
|
|
//
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (hKeyReinstallInstance != INVALID_HANDLE_VALUE) {
|
|
RegCloseKey(hKeyReinstallInstance);
|
|
}
|
|
|
|
if (hKeyReinstall != INVALID_HANDLE_VALUE) {
|
|
RegCloseKey(hKeyReinstall);
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupAppendFiles(
|
|
IN HSPFILEQ TargetQueueHandle,
|
|
IN PCTSTR BackupSubDir,
|
|
IN DWORD BackupFlags,
|
|
IN HSPFILEQ SourceQueueHandle OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will take a list of files from SourceQueueHandle Copy sub-queue's
|
|
These files will appear in the Target Queue's target cache
|
|
And may be placed into the Target Backup Queue
|
|
Typically the copy queue is entries of..
|
|
<oldsrc-root>\<oldsrc-sub>\<oldsrc-name> copied to
|
|
<olddest-path>\<olddest-name>
|
|
|
|
Arguments:
|
|
|
|
TargetQueueHandle - Where Backups are queued to
|
|
BackupSubDir - Directory to backup to, relative to backup root
|
|
BackupFlags - How backup should occur
|
|
SourceQueueHandle - Handle that has a series of copy operations (backup hint)
|
|
created, say, by pretending to do the re-install
|
|
If not specified, only flags are passed
|
|
|
|
Return Value:
|
|
|
|
Returns error code (LastError is also set)
|
|
If the function succeeds, returns NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
TCHAR BackupPath[MAX_PATH];
|
|
PSP_FILE_QUEUE SourceQueue = NULL;
|
|
PSP_FILE_QUEUE TargetQueue = NULL;
|
|
PSP_FILE_QUEUE_NODE QueueNode = NULL;
|
|
PSOURCE_MEDIA_INFO SourceMediaInfo = NULL;
|
|
BOOL b = TRUE;
|
|
PVOID SourceStringTable = NULL;
|
|
PVOID TargetStringTable = NULL;
|
|
LONG BackupRootID = -1;
|
|
DWORD Err = NO_ERROR;
|
|
LONG PathID = -1;
|
|
SP_TARGET_ENT TargetInfo;
|
|
|
|
SourceQueue = (PSP_FILE_QUEUE)SourceQueueHandle; // optional
|
|
TargetQueue = (PSP_FILE_QUEUE)TargetQueueHandle;
|
|
|
|
b=TRUE; // set if we can skip this routine
|
|
try {
|
|
|
|
TargetStringTable = TargetQueue->StringTable; // used for strings in target queue
|
|
|
|
if (SourceQueue == NULL) {
|
|
b = TRUE; // nothing to do
|
|
} else {
|
|
SourceStringTable = SourceQueue->StringTable; // used for strings in source queue
|
|
b = (!SourceQueue->CopyNodeCount);
|
|
}
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
// these are backup flags to be passed into the queue
|
|
if (BackupFlags & SP_BKFLG_CALLBACK) {
|
|
TargetQueue->Flags |= FQF_BACKUP_AWARE;
|
|
}
|
|
|
|
if (b) {
|
|
// nothing to do
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// get full directory path of backup - this appears as the "dest" for any backup entries
|
|
//
|
|
if ( BackupSubDir == NULL ) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
if ( pSetupGetFullBackupPath(BackupPath, BackupSubDir, MAX_PATH,NULL) == FALSE ) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Target will often use this, so we create the ID now instead of later
|
|
//
|
|
BackupRootID = pSetupStringTableAddString(TargetStringTable,
|
|
BackupPath,
|
|
STRTAB_CASE_SENSITIVE);
|
|
if (BackupRootID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// CopyQueue is split over a number of media's
|
|
// we're not (currently) bothered about media
|
|
// iterate through all the copy sub-queue's
|
|
// and (1) add them to the target lookup table
|
|
// (2) if wanted, add them into the backup queue
|
|
|
|
for (SourceMediaInfo=SourceQueue->SourceMediaList; SourceMediaInfo!=NULL ; SourceMediaInfo=SourceMediaInfo->Next) {
|
|
if (!SourceMediaInfo->CopyNodeCount) {
|
|
continue;
|
|
}
|
|
MYASSERT(SourceMediaInfo->CopyQueue);
|
|
|
|
for (QueueNode = SourceMediaInfo->CopyQueue; QueueNode!=NULL; QueueNode = QueueNode->Next) {
|
|
// for each "Copy"
|
|
// we want information about the destination path
|
|
//
|
|
|
|
Err = pSetupBackupGetTargetByPath(TargetQueueHandle,
|
|
SourceStringTable,
|
|
NULL, // precalculated string
|
|
QueueNode->TargetDirectory,
|
|
-1,
|
|
QueueNode->TargetFilename,
|
|
&PathID,
|
|
&TargetInfo);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
|
|
// we now have a created (or obtained) TargetInfo, and PathID
|
|
// provide a source name for backup
|
|
TargetInfo.BackupRoot = BackupRootID;
|
|
Err = pSetupBackupCopyString(TargetStringTable, &TargetInfo.BackupSubDir, SourceStringTable, QueueNode->SourcePath);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
Err = pSetupBackupCopyString(TargetStringTable, &TargetInfo.BackupFilename, SourceStringTable, QueueNode->SourceFilename);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
|
|
if ((BackupFlags & SP_BKFLG_LATEBACKUP) == FALSE) {
|
|
// we need to add this item to the backup queue
|
|
Err = pSetupQueueBackupCopy(TargetQueueHandle,
|
|
// source
|
|
TargetInfo.TargetRoot,
|
|
TargetInfo.TargetSubDir,
|
|
TargetInfo.TargetFilename,
|
|
TargetInfo.BackupRoot,
|
|
TargetInfo.BackupSubDir,
|
|
TargetInfo.BackupFilename);
|
|
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
// flag that we've added it to the pre-copy backup sub-queue
|
|
TargetInfo.InternalFlags |= SP_TEFLG_BACKUPQUEUE;
|
|
}
|
|
|
|
// any backups should go to this specified directory
|
|
TargetInfo.InternalFlags |= SP_TEFLG_ORIGNAME;
|
|
|
|
Err = pSetupBackupSetTargetByID(TargetQueueHandle, PathID, &TargetInfo);
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
|
|
SetLastError(Err);
|
|
return (Err);
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupBackupFile(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN PCTSTR TargetPath,
|
|
IN PCTSTR BackupPath,
|
|
IN LONG TargetID, OPTIONAL
|
|
IN LONG TargetRootPath,
|
|
IN LONG TargetSubDir,
|
|
IN LONG TargetFilename,
|
|
IN LONG BackupRootPath,
|
|
IN LONG BackupSubDir,
|
|
IN LONG BackupFilename,
|
|
OUT BOOL *InUseFlag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
If BackupFilename not supplied, it is obtained/created
|
|
Will either
|
|
1) copy a file to the backup directory, or
|
|
2) queue that a file is backed up on reboot
|
|
The latter occurs if the file was locked.
|
|
|
|
Arguments:
|
|
|
|
HSPFILEQ - QueueHandle - specifies Queue
|
|
LONG - TargetID - if specified (not -1), use for target
|
|
LONG - TargetRootPath - used if TargetID == -1
|
|
LONG - TargetSubDir - used if TargetID == -1
|
|
LONG - TargetFilename - used if TargetID == -1
|
|
LONG - BackupRootPath - alternate root (valid if BackupFilename != -1)
|
|
LONG - BackupSubDir - alternate directory (valid if BackupFilename != -1)
|
|
LONG - BackupFilename - alternate filename
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, return value is TRUE
|
|
If the function fails, return value is FALSE
|
|
|
|
--*/
|
|
{
|
|
PSP_FILE_QUEUE Queue = NULL;
|
|
PVOID StringTable = NULL;
|
|
PVOID LookupTable = NULL;
|
|
DWORD Err = NO_ERROR;
|
|
SP_TARGET_ENT TargetInfo;
|
|
PTSTR FullTargetPath = NULL;
|
|
PTSTR FullBackupPath = NULL;
|
|
BOOL InUse = FALSE;
|
|
PTSTR TempNamePtr = NULL, DirTruncPos;
|
|
TCHAR TempPath[MAX_PATH];
|
|
TCHAR TempFilename[MAX_PATH];
|
|
TCHAR ParsedPath[MAX_PATH];
|
|
UINT OldMode;
|
|
LONG NewTargetFilename;
|
|
BOOL DoRename = FALSE;
|
|
|
|
OldMode = SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
|
|
try {
|
|
StringTable = Queue->StringTable; // used for strings in source queue
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean1;
|
|
}
|
|
|
|
if(TargetPath == NULL && TargetID == -1) {
|
|
|
|
if (TargetRootPath == -1 || TargetFilename == -1) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
// complete target path
|
|
|
|
FullTargetPath = pSetupFormFullPath(
|
|
StringTable,
|
|
TargetRootPath,
|
|
TargetSubDir,
|
|
TargetFilename
|
|
);
|
|
|
|
if (!FullTargetPath) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
TargetPath = FullTargetPath;
|
|
|
|
}
|
|
|
|
if (TargetID == -1) {
|
|
Err = pSetupBackupGetTargetByPath(QueueHandle,
|
|
NULL, // string table
|
|
TargetPath, // precalculated string
|
|
TargetRootPath,
|
|
TargetSubDir,
|
|
TargetFilename,
|
|
&TargetID,
|
|
&TargetInfo);
|
|
} else {
|
|
Err = pSetupBackupGetTargetByID(QueueHandle,
|
|
TargetID,
|
|
&TargetInfo);
|
|
}
|
|
|
|
if(Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// if we're not interested in backing up (global flag) we can skip
|
|
// but it's only safe to do so if we'd copy & then later throw the copy away on success
|
|
// note that if FQF_DEVICE_BACKUP is set, we'll always backup
|
|
//
|
|
if (((TargetInfo.InternalFlags & SP_TEFLG_RENAMEEXISTING) == 0)
|
|
&& ((Queue->Flags & FQF_DEVICE_BACKUP)==0)
|
|
&& ((GlobalSetupFlags & PSPGF_NO_BACKUP)!=0)) {
|
|
|
|
Err = NO_ERROR;
|
|
goto clean0;
|
|
}
|
|
//
|
|
// Figure out whether we've been asked to rename the existing file to a
|
|
// temp name in the same directory, but haven't yet done so.
|
|
//
|
|
DoRename = ((TargetInfo.InternalFlags & (SP_TEFLG_RENAMEEXISTING | SP_TEFLG_MOVED)) == SP_TEFLG_RENAMEEXISTING);
|
|
|
|
if(BackupFilename == -1) {
|
|
//
|
|
// non-specific backup
|
|
//
|
|
if((TargetInfo.InternalFlags & SP_TEFLG_SAVED) && !DoRename) {
|
|
//
|
|
// Already backed up, and we don't need to rename the existing file.
|
|
// Nothing to do.
|
|
//
|
|
Err = NO_ERROR;
|
|
goto clean0;
|
|
}
|
|
|
|
if(TargetInfo.InternalFlags & SP_TEFLG_INUSE) {
|
|
//
|
|
// Previously marked as INUSE, not allowed to change it. If we
|
|
// were asked to rename the existing file, then we need to return
|
|
// failure, otherwise, we can report success.
|
|
//
|
|
//
|
|
InUse = TRUE;
|
|
|
|
Err = DoRename ? ERROR_SHARING_VIOLATION : NO_ERROR;
|
|
goto clean0;
|
|
}
|
|
|
|
if(TargetInfo.InternalFlags & SP_TEFLG_ORIGNAME) {
|
|
//
|
|
// original name given, use that
|
|
//
|
|
BackupRootPath = TargetInfo.BackupRoot;
|
|
BackupSubDir = TargetInfo.BackupSubDir;
|
|
BackupFilename = TargetInfo.BackupFilename;
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// We should never be called if the file has already been
|
|
// saved.
|
|
//
|
|
MYASSERT(!(TargetInfo.InternalFlags & SP_TEFLG_SAVED));
|
|
|
|
//
|
|
// Even if the above assert fires, we should still deal with
|
|
// the case where this occurs. Also, we should deal with the
|
|
// case where a backup was previously attempted but failed due
|
|
// to the file being in-use.
|
|
//
|
|
if(TargetInfo.InternalFlags & SP_TEFLG_SAVED) {
|
|
//
|
|
// nothing to do, we shouldn't treat this as an actual error
|
|
//
|
|
Err = NO_ERROR;
|
|
goto clean0;
|
|
} else if(TargetInfo.InternalFlags & SP_TEFLG_INUSE) {
|
|
//
|
|
// force the issue of InUse
|
|
//
|
|
InUse = TRUE;
|
|
|
|
Err = ERROR_SHARING_VIOLATION;
|
|
goto clean0;
|
|
}
|
|
|
|
TargetInfo.BackupRoot = BackupRootPath;
|
|
TargetInfo.BackupSubDir = BackupSubDir;
|
|
TargetInfo.BackupFilename = BackupFilename;
|
|
TargetInfo.InternalFlags |= SP_TEFLG_ORIGNAME;
|
|
TargetInfo.InternalFlags &= ~SP_TEFLG_TEMPNAME;
|
|
}
|
|
|
|
if(TargetPath == NULL) {
|
|
//
|
|
// must have looked up using TargetID, use TargetInfo to generate TargetPath
|
|
// complete target path
|
|
//
|
|
FullTargetPath = pSetupFormFullPath(StringTable,
|
|
TargetInfo.TargetRoot,
|
|
TargetInfo.TargetSubDir,
|
|
TargetInfo.TargetFilename
|
|
);
|
|
|
|
if(!FullTargetPath) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
TargetPath = FullTargetPath;
|
|
}
|
|
|
|
if(DoRename) {
|
|
//
|
|
// We'd better not already have a temp filename stored in our TargetInfo.
|
|
//
|
|
MYASSERT(TargetInfo.NewTargetFilename == -1);
|
|
|
|
//
|
|
// First, strip the filename off the path.
|
|
//
|
|
_tcscpy(TempPath, TargetPath);
|
|
TempNamePtr = (PTSTR)pSetupGetFileTitle(TempPath);
|
|
*TempNamePtr = TEXT('\0');
|
|
|
|
//
|
|
// Now get a temp filename within that directory...
|
|
//
|
|
if(GetTempFileName(TempPath, TEXT("OLD"), 0, TempFilename) == 0 ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// ...and store this path's string ID in our TargetInfo
|
|
//
|
|
NewTargetFilename = pSetupStringTableAddString(StringTable,
|
|
TempFilename,
|
|
STRTAB_CASE_SENSITIVE
|
|
);
|
|
|
|
if(NewTargetFilename == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
if(!(TargetInfo.InternalFlags & (SP_TEFLG_ORIGNAME | SP_TEFLG_TEMPNAME))) {
|
|
//
|
|
// If we don't yet have a name to use in backing up this file, then
|
|
// generate one now. If we are doing a rename, we can use that name.
|
|
//
|
|
if(DoRename) {
|
|
//
|
|
// Make sure that all flags agree on the fact that we need to back
|
|
// up this file.
|
|
//
|
|
MYASSERT(!(TargetInfo.InternalFlags & SP_TEFLG_SAVED));
|
|
|
|
//
|
|
// Temp filename was stored in TempFilename buffer above.
|
|
//
|
|
TempNamePtr = (PTSTR)pSetupGetFileTitle(TempFilename);
|
|
|
|
BackupFilename = pSetupStringTableAddString(StringTable, TempNamePtr, STRTAB_CASE_SENSITIVE);
|
|
if(BackupFilename == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
DirTruncPos = CharPrev(TempFilename, TempNamePtr);
|
|
|
|
//
|
|
// (We know pSetupGetFileTitle will never return a pointer to a path
|
|
// separator character, so the following check is valid.)
|
|
//
|
|
if(*DirTruncPos == TEXT('\\')) {
|
|
//
|
|
// If this is in a root directory (e.g., "A:\"), then we don't want to strip off
|
|
// the trailing backslash.
|
|
//
|
|
if(((DirTruncPos - TempFilename) != 2) || (*CharNext(TempFilename) != TEXT(':'))) {
|
|
TempNamePtr = DirTruncPos;
|
|
}
|
|
}
|
|
|
|
lstrcpyn(TempPath, TempFilename, (int)(TempNamePtr - TempFilename) + 1);
|
|
|
|
BackupRootPath = pSetupStringTableAddString(StringTable, TempPath, STRTAB_CASE_SENSITIVE);
|
|
if(BackupRootPath == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// specify "NULL" as the sub-directory, since all we want is a temporary location
|
|
//
|
|
if(pSetupGetFullBackupPath(TempPath, NULL, MAX_PATH,NULL) == FALSE ) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
_tcscpy(TempFilename,TempPath);
|
|
|
|
//
|
|
// Note: In the code below, we employ a "trick" to get the
|
|
// pSetupMakeSurePathExists API to make sure that a directory
|
|
// exists. Since we don't yet know the filename (we need to call
|
|
// GetTempFileName against an existing directory to find that out),
|
|
// we just use a dummy placeholder filename ("OLD") so that it can
|
|
// be discarded by the pSetupMakeSurePathExists API.
|
|
//
|
|
if(pSetupConcatenatePaths(TempFilename, TEXT("OLD"), MAX_PATH, NULL) == FALSE ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
pSetupMakeSurePathExists(TempFilename);
|
|
if(GetTempFileName(TempPath, TEXT("OLD"), 0, TempFilename) == 0 ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
TempNamePtr = TempFilename + _tcslen(TempPath) + 1 /* 1 to skip past \ */;
|
|
BackupRootPath = pSetupStringTableAddString( StringTable, TempPath, STRTAB_CASE_SENSITIVE );
|
|
if(BackupRootPath == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
BackupFilename = pSetupStringTableAddString( StringTable, TempNamePtr, STRTAB_CASE_SENSITIVE );
|
|
if(BackupFilename == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
BackupPath = TempFilename;
|
|
|
|
TargetInfo.BackupRoot = BackupRootPath;
|
|
TargetInfo.BackupSubDir = BackupSubDir = -1;
|
|
TargetInfo.BackupFilename = BackupFilename;
|
|
TargetInfo.InternalFlags |= SP_TEFLG_TEMPNAME;
|
|
|
|
}
|
|
|
|
|
|
if(BackupPath == NULL) {
|
|
//
|
|
// make a complete path from this source
|
|
//
|
|
FullBackupPath = pSetupFormFullPath(StringTable,
|
|
BackupRootPath,
|
|
BackupSubDir,
|
|
BackupFilename
|
|
);
|
|
|
|
if (!FullBackupPath) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
BackupPath = FullBackupPath;
|
|
}
|
|
|
|
//
|
|
// If we need to make a copy of the existing file, do so now.
|
|
//
|
|
if(!DoRename || (TargetInfo.InternalFlags & SP_TEFLG_ORIGNAME)) {
|
|
|
|
SetFileAttributes(BackupPath, FILE_ATTRIBUTE_NORMAL);
|
|
pSetupMakeSurePathExists(BackupPath);
|
|
Err = CopyFile(TargetPath, BackupPath, FALSE) ? NO_ERROR : GetLastError();
|
|
|
|
if(Err == NO_ERROR) {
|
|
TargetInfo.InternalFlags |= SP_TEFLG_SAVED;
|
|
} else {
|
|
//
|
|
// Delete placeholder file created by GetTempFileName.
|
|
//
|
|
SetFileAttributes(BackupPath, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(BackupPath);
|
|
|
|
if(Err == ERROR_SHARING_VIOLATION) {
|
|
//
|
|
// Unless we were also going to attempt a rename, don't
|
|
// consider sharing violations to be errors.
|
|
//
|
|
InUse = TRUE;
|
|
TargetInfo.InternalFlags |= SP_TEFLG_INUSE;
|
|
if(!DoRename) {
|
|
Err = NO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// OK, now rename the existing file, if necessary.
|
|
//
|
|
if(DoRename && (Err == NO_ERROR)) {
|
|
|
|
if(DoMove(TargetPath, TempFilename)) {
|
|
|
|
TargetInfo.InternalFlags |= SP_TEFLG_MOVED;
|
|
TargetInfo.NewTargetFilename = NewTargetFilename;
|
|
|
|
//
|
|
// Post a delayed deletion for this temp filename so it'll get
|
|
// cleaned up after reboot.
|
|
//
|
|
if(!PostDelayedMove(Queue, TempFilename, NULL, -1, FALSE)) {
|
|
//
|
|
// Don't abort just because we couldn't schedule a delayed
|
|
// delete. If this fails, the only bad thing that will happen
|
|
// is a turd will get left over after reboot.
|
|
//
|
|
// We should log an event about this, however.
|
|
//
|
|
Err = GetLastError();
|
|
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_WARNING | SETUP_LOG_BUFFER,
|
|
MSG_LOG_RENAME_EXISTING_DELAYED_DELETE_FAILED,
|
|
NULL,
|
|
TargetPath,
|
|
TempFilename
|
|
);
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_WARNING,
|
|
Err
|
|
);
|
|
|
|
Err = NO_ERROR;
|
|
}
|
|
|
|
} else {
|
|
Err = GetLastError();
|
|
SetFileAttributes(TempFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(TempFilename);
|
|
if(Err == ERROR_SHARING_VIOLATION) {
|
|
InUse = TRUE;
|
|
TargetInfo.InternalFlags |= SP_TEFLG_INUSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// update internal info (this call should never fail)
|
|
//
|
|
pSetupBackupSetTargetByID(QueueHandle,
|
|
TargetID,
|
|
&TargetInfo
|
|
);
|
|
|
|
clean0:
|
|
|
|
if (FullTargetPath != NULL) {
|
|
MyFree(FullTargetPath);
|
|
}
|
|
if (FullBackupPath != NULL) {
|
|
MyFree(FullBackupPath);
|
|
}
|
|
if (Err != NO_ERROR) {
|
|
//
|
|
// note the fact that at least one backup error has occurred
|
|
//
|
|
Queue->Flags |= FQF_BACKUP_INCOMPLETE;
|
|
}
|
|
|
|
clean1:
|
|
SetErrorMode(OldMode);
|
|
|
|
SetLastError(Err);
|
|
|
|
if(InUseFlag) {
|
|
*InUseFlag = InUse;
|
|
}
|
|
|
|
return Err;
|
|
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
VOID
|
|
pSetupDeleteBackup(
|
|
IN PCTSTR BackupInstance
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function will delete an entire backup instance. This entails deleting
|
|
the relative BackupInstance out of the registry Reinstall key as well
|
|
|
|
Arguments:
|
|
|
|
BackupInstance - Instance Id of the backup
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, return value is TRUE
|
|
If the function fails, return value is FALSE
|
|
|
|
--*/
|
|
{
|
|
TCHAR Buffer[MAX_PATH];
|
|
HKEY hKeyReinstall = INVALID_HANDLE_VALUE;
|
|
|
|
if (BackupInstance == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Delete this instance from the Reinstall key.
|
|
//
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
pszReinstallPath,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyReinstall
|
|
) == ERROR_SUCCESS) {
|
|
|
|
RegDeleteKey(hKeyReinstall, BackupInstance);
|
|
|
|
RegCloseKey(hKeyReinstall);
|
|
}
|
|
|
|
|
|
//
|
|
// Now delete the entire backup directory.
|
|
//
|
|
if (pSetupGetFullBackupPath(Buffer, BackupInstance, MAX_PATH, NULL)) {
|
|
pRemoveDirectory(Buffer);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupGetCurrentlyInstalledDriverNode(
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN OUT PSP_DEVINFO_DATA DeviceInfoData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get driver node that relates to current INF file of device
|
|
|
|
Arguments:
|
|
|
|
DeviceInfoSet
|
|
DeviceInfoData
|
|
|
|
Return Value:
|
|
|
|
Error Status
|
|
|
|
--*/
|
|
{
|
|
DWORD Err;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
|
|
ZeroMemory(&DeviceInstallParams, sizeof(DeviceInstallParams));
|
|
ZeroMemory(&DriverInfoData, sizeof(DriverInfoData));
|
|
|
|
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
|
|
if(!SetupDiGetDeviceInstallParams(DeviceInfoSet, DeviceInfoData, &DeviceInstallParams)) {
|
|
return GetLastError();
|
|
}
|
|
|
|
//
|
|
// Set the flags that tell SetupDiBuildDriverInfoList to just put the currently installed
|
|
// driver node in the list, and that it should allow excluded drivers.
|
|
//
|
|
DeviceInstallParams.FlagsEx |= (DI_FLAGSEX_INSTALLEDDRIVER | DI_FLAGSEX_ALLOWEXCLUDEDDRVS);
|
|
|
|
if(!SetupDiSetDeviceInstallParams(DeviceInfoSet, DeviceInfoData, &DeviceInstallParams)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Now build a class driver list that just contains the currently installed driver.
|
|
//
|
|
if(!SetupDiBuildDriverInfoList(DeviceInfoSet, DeviceInfoData, SPDIT_CLASSDRIVER)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// The only driver in the list should be the currently installed driver, if there
|
|
// is a currently installed driver.
|
|
//
|
|
if (!SetupDiEnumDriverInfo(DeviceInfoSet, DeviceInfoData, SPDIT_CLASSDRIVER,
|
|
0, &DriverInfoData)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Make the currently installed driver the selected driver.
|
|
//
|
|
if(!SetupDiSetSelectedDriver(DeviceInfoSet, DeviceInfoData, &DriverInfoData)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// At this point, we've successfully selected the currently installed driver for the specified
|
|
// device information element. We're done!
|
|
//
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupGetBackupQueue(
|
|
IN PCTSTR DeviceID,
|
|
IN OUT HSPFILEQ FileQueue,
|
|
IN DWORD BackupFlags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a backup Queue for current device (DeviceID)
|
|
Also makes sure that the INF file is backed up
|
|
|
|
Arguments:
|
|
|
|
DeviceID String ID of device
|
|
FileQueue Backup queue is filled with files that need copying
|
|
BackupFlags Various flags
|
|
|
|
Return Value:
|
|
|
|
Error Status
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
//
|
|
// we want to obtain a copy/move list of device associated with DeviceID
|
|
//
|
|
//
|
|
PSP_FILE_QUEUE FileQ = (PSP_FILE_QUEUE)FileQueue;
|
|
HDEVINFO TempInfoSet = (HDEVINFO)INVALID_HANDLE_VALUE;
|
|
HSPFILEQ TempQueueHandle = (HSPFILEQ)INVALID_HANDLE_VALUE;
|
|
SP_DEVINFO_DATA TempInfoData;
|
|
SP_DEVINSTALL_PARAMS TempParams;
|
|
TCHAR SubDir[MAX_PATH];
|
|
LONG Instance;
|
|
PDEVINFO_ELEM DevInfoElem = NULL;
|
|
PTSTR szInfFileName = NULL;
|
|
PTSTR szInfFileNameExt = NULL;
|
|
PTSTR BackupPathExt = NULL;
|
|
TCHAR BackupInstance[MAX_PATH];
|
|
TCHAR BackupPath[MAX_PATH];
|
|
TCHAR ReinstallString[MAX_PATH];
|
|
TCHAR OemOrigName[MAX_PATH];
|
|
TCHAR CatBackupPath[MAX_PATH];
|
|
TCHAR CatSourcePath[MAX_PATH];
|
|
DWORD Err;
|
|
PDEVICE_INFO_SET pDeviceInfoSet = NULL;
|
|
int InstanceId;
|
|
DWORD BackupInfID = -1;
|
|
DWORD BackupInstanceID = -1;
|
|
PSP_INF_INFORMATION pInfInformation = NULL;
|
|
DWORD InfInformationSize;
|
|
SP_ORIGINAL_FILE_INFO InfOriginalFileInformation;
|
|
BOOL success;
|
|
PSETUP_LOG_CONTEXT SavedLogContext = NULL;
|
|
PSETUP_LOG_CONTEXT LocalLogContext = NULL;
|
|
BOOL ChangedThreadLogContext = FALSE;
|
|
|
|
//
|
|
// if backup information exists, abort (no flags will be set)
|
|
//
|
|
if(FileQ->BackupInfID != -1) {
|
|
return ERROR_ALREADY_EXISTS;
|
|
}
|
|
|
|
//
|
|
// detach any backup related logging from current log section
|
|
// putting it into it's own section
|
|
// this stops confusion when debugging (v)verbose logs
|
|
// and we're going down this path
|
|
//
|
|
CreateLogContext(NULL,FALSE,&LocalLogContext);
|
|
if(LocalLogContext) {
|
|
DWORD LogTag = AllocLogInfoSlot(LocalLogContext,TRUE);
|
|
if(LogTag) {
|
|
WriteLogEntry(LocalLogContext,
|
|
LogTag,
|
|
MSG_LOG_DRIVERBACKUP,
|
|
NULL,
|
|
DeviceID
|
|
);
|
|
}
|
|
|
|
}
|
|
ChangedThreadLogContext = SetThreadLogContext(LocalLogContext,&SavedLogContext);
|
|
|
|
CatBackupPath[0] = 0; // by default, don't bother with a catalog
|
|
CatSourcePath[0] = 0;
|
|
|
|
// pretend we're installing old INF
|
|
// this gives us a list of files we need
|
|
|
|
TempInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL);
|
|
if ( TempInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
if(!(pDeviceInfoSet = AccessDeviceInfoSet(TempInfoSet))) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
//
|
|
// make sure info-set has our local context
|
|
//
|
|
InheritLogContext(LocalLogContext,&pDeviceInfoSet->InstallParamBlock.LogContext);
|
|
|
|
//
|
|
// Open the driver info, related to DeviceID I was given
|
|
//
|
|
|
|
TempInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
if ( SetupDiOpenDeviceInfo(TempInfoSet ,DeviceID, NULL, 0, &TempInfoData) == FALSE ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
//
|
|
// make sure the temporary element has our backup logging context
|
|
//
|
|
DevInfoElem = FindAssociatedDevInfoElem(TempInfoSet,
|
|
&TempInfoData,
|
|
NULL);
|
|
MYASSERT(DevInfoElem);
|
|
if(DevInfoElem) {
|
|
InheritLogContext(LocalLogContext,&DevInfoElem->InstallParamBlock.LogContext);
|
|
}
|
|
|
|
//
|
|
// Get the currently-installed driver node selected for this element.
|
|
//
|
|
if ( pSetupGetCurrentlyInstalledDriverNode(TempInfoSet, &TempInfoData) != NO_ERROR ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Now queue all files to be copied by this driver node into our own file queue.
|
|
// it'll inherit the backup logging context
|
|
//
|
|
TempQueueHandle = SetupOpenFileQueue();
|
|
|
|
if ( TempQueueHandle == (HSPFILEQ)INVALID_HANDLE_VALUE ) {
|
|
//
|
|
// SetupOpenFileQueue modified to return error
|
|
//
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
TempParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if ( !SetupDiGetDeviceInstallParams(TempInfoSet, &TempInfoData, &TempParams) ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
TempParams.FileQueue = TempQueueHandle;
|
|
TempParams.Flags |= DI_NOVCP;
|
|
|
|
if ( !SetupDiSetDeviceInstallParams(TempInfoSet, &TempInfoData, &TempParams) ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
if ( !SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES, TempInfoSet, &TempInfoData) ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// We want this backup to be in a unique directory. To do this we just do
|
|
// the standard instance number trick where we enumerate from 0000 to 9999
|
|
// and choose the first number where there isn't a backup directory with
|
|
// that name already created.
|
|
//
|
|
for (InstanceId=0; InstanceId<=9999; InstanceId++) {
|
|
|
|
wsprintf(SubDir, TEXT("\\%04d\\%s"), (LONG) InstanceId, (PCTSTR) SP_BACKUP_DRIVERFILES );
|
|
|
|
if ( pSetupGetFullBackupPath(BackupPath, SubDir, MAX_PATH, NULL) == FALSE ) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// If this backup path does not exist then we have a valid directory.
|
|
//
|
|
if (!FileExists(BackupPath, NULL)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (InstanceId <= 9999) {
|
|
//
|
|
// Add string indicating Backup InstanceID to file Queue
|
|
// for later retrieval
|
|
//
|
|
wsprintf(BackupInstance, TEXT("%04d"), (LONG) InstanceId);
|
|
BackupInstanceID = pSetupStringTableAddString(FileQ->StringTable,
|
|
BackupInstance,
|
|
STRTAB_CASE_SENSITIVE);
|
|
if (BackupInstanceID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
} else {
|
|
//
|
|
// If we don't have any free backup directories then we will fail. There
|
|
// should never be this many drivers backed up so this shouldn't be a
|
|
// problem.
|
|
//
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// get the path of the INF file, we will need to back it up
|
|
//
|
|
if(!(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet,
|
|
&TempInfoData,
|
|
NULL))) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
szInfFileName = pStringTableStringFromId(pDeviceInfoSet->StringTable,
|
|
DevInfoElem->SelectedDriver->InfFileName
|
|
);
|
|
if (szInfFileName == NULL) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// we want to get the "real" name of the INF - we may have a precompiled inf
|
|
//
|
|
|
|
ZeroMemory(&InfOriginalFileInformation, sizeof(InfOriginalFileInformation));
|
|
|
|
//
|
|
// if nothing else, use same name as is in the INF directory
|
|
//
|
|
lstrcpy(OemOrigName,pSetupGetFileTitle(szInfFileName));
|
|
|
|
//
|
|
// but use the original name if available
|
|
//
|
|
InfInformationSize = 8192; // I'd rather have this too big and succeed first time, than read the INF twice
|
|
pInfInformation = (PSP_INF_INFORMATION)MyMalloc(InfInformationSize);
|
|
|
|
if (pInfInformation != NULL) {
|
|
success = SetupGetInfInformation(szInfFileName,INFINFO_INF_NAME_IS_ABSOLUTE,pInfInformation,InfInformationSize,&InfInformationSize);
|
|
if (!success && GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
|
|
PVOID newbuff = MyRealloc(pInfInformation,InfInformationSize);
|
|
if (!newbuff) {
|
|
MyFree(pInfInformation);
|
|
pInfInformation = NULL;
|
|
} else {
|
|
pInfInformation = (PSP_INF_INFORMATION)newbuff;
|
|
success = SetupGetInfInformation(szInfFileName,INFINFO_INF_NAME_IS_ABSOLUTE,pInfInformation,InfInformationSize,&InfInformationSize);
|
|
}
|
|
}
|
|
if (success) {
|
|
InfOriginalFileInformation.cbSize = sizeof(InfOriginalFileInformation);
|
|
if (SetupQueryInfOriginalFileInformation(pInfInformation,0,NULL,&InfOriginalFileInformation)) {
|
|
if (InfOriginalFileInformation.OriginalInfName[0]) {
|
|
//
|
|
// we have a "real" inf name
|
|
//
|
|
lstrcpy(OemOrigName,pSetupGetFileTitle(InfOriginalFileInformation.OriginalInfName));
|
|
} else {
|
|
MYASSERT(InfOriginalFileInformation.OriginalInfName[0]);
|
|
}
|
|
|
|
//
|
|
// Don't bother finding out about the INF's catalog if we're in
|
|
// "minimal embedded" mode...
|
|
//
|
|
if(!(GlobalSetupFlags & PSPGF_MINIMAL_EMBEDDED)) {
|
|
|
|
if (InfOriginalFileInformation.OriginalCatalogName[0]) {
|
|
|
|
TCHAR CurrentCatName[MAX_PATH];
|
|
|
|
//
|
|
// given that the file is ....\OEMx.INF the catalog is "OEMx.CAT"
|
|
// we key off OemOrigName (eg mydisk.inf )
|
|
// and we won't bother copying the catalog if we can't verify the inf
|
|
//
|
|
lstrcpy(CurrentCatName,pSetupGetFileTitle(szInfFileName));
|
|
lstrcpy(_tcsrchr(CurrentCatName, TEXT('.')), pszCatSuffix);
|
|
|
|
//
|
|
// we have a catalog name
|
|
// now consider making a copy of the cached catalog
|
|
// into our backup we get out CatProblem and
|
|
// szCatFileName
|
|
//
|
|
// if all seems ok, copy file from szCatFileName to
|
|
// backupdir\OriginalCatalogName
|
|
//
|
|
|
|
Err = _VerifyFile(
|
|
FileQ->LogContext,
|
|
&(FileQ->VerifyContext),
|
|
CurrentCatName, // eg "OEMx.CAT"
|
|
NULL,0, // we're not verifying against another catalog image
|
|
OemOrigName, // eg "mydisk.inf"
|
|
szInfFileName, // eg "....\OEMx.INF"
|
|
NULL, // return: problem info
|
|
NULL, // return: problem file
|
|
FALSE, // has to be FALSE because we're getting full path
|
|
((PSP_FILE_QUEUE)TempQueueHandle)->ValidationPlatform, // alt platform info
|
|
VERIFY_FILE_IGNORE_SELFSIGNED | VERIFY_FILE_NO_DRIVERBLOCKED_CHECK,
|
|
CatSourcePath, // return: catalog file, full path
|
|
NULL, // return: number of catalogs considered
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
if(Err != NO_ERROR) {
|
|
//
|
|
// There may be an Authenticode-signed catalog, so
|
|
// we'll look for that, too.
|
|
//
|
|
Err = _VerifyFile(
|
|
FileQ->LogContext,
|
|
&(FileQ->VerifyContext),
|
|
CurrentCatName, // eg "OEMx.CAT"
|
|
NULL,0, // we're not verifying against another catalog image
|
|
OemOrigName, // eg "mydisk.inf"
|
|
szInfFileName, // eg "....\OEMx.INF"
|
|
NULL, // return: problem info
|
|
NULL, // return: problem file
|
|
FALSE, // has to be FALSE because we're getting full path
|
|
((PSP_FILE_QUEUE)TempQueueHandle)->ValidationPlatform, // alt platform info
|
|
(VERIFY_FILE_IGNORE_SELFSIGNED
|
|
| VERIFY_FILE_NO_DRIVERBLOCKED_CHECK
|
|
| VERIFY_FILE_USE_AUTHENTICODE_CATALOG),
|
|
CatSourcePath, // return: catalog file, full path
|
|
NULL, // return: number of catalogs considered
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// For the purposes of this routine, we don't care
|
|
// whether or not the publisher is in the
|
|
// TrustedPublisher store.
|
|
//
|
|
if((Err == ERROR_AUTHENTICODE_TRUSTED_PUBLISHER) ||
|
|
(Err == ERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHED)) {
|
|
|
|
Err = NO_ERROR;
|
|
}
|
|
}
|
|
|
|
if(Err == NO_ERROR && CatSourcePath[0]) {
|
|
//
|
|
// we have a catalog file of interest to copy
|
|
//
|
|
lstrcpy(CatBackupPath,BackupPath);
|
|
if (!pSetupConcatenatePaths(CatBackupPath, InfOriginalFileInformation.OriginalCatalogName, MAX_PATH, NULL)) {
|
|
//
|
|
// non-fatal
|
|
//
|
|
CatSourcePath[0]=0;
|
|
CatBackupPath[0]=0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pInfInformation != NULL) {
|
|
MyFree(pInfInformation);
|
|
pInfInformation = NULL;
|
|
}
|
|
}
|
|
if ( pSetupConcatenatePaths(BackupPath, OemOrigName, MAX_PATH, NULL) == FALSE ) {
|
|
Err = ERROR_INVALID_HANDLE;
|
|
goto clean0;
|
|
}
|
|
|
|
pSetupMakeSurePathExists(BackupPath);
|
|
SetFileAttributes(BackupPath,FILE_ATTRIBUTE_NORMAL);
|
|
Err = CopyFile(szInfFileName, BackupPath ,FALSE) ? NO_ERROR : GetLastError();
|
|
|
|
if (Err != NO_ERROR) {
|
|
goto clean0;
|
|
}
|
|
|
|
if(CatSourcePath[0] && CatBackupPath[0]) {
|
|
//
|
|
// if we copied Inf file, try to copy catalog file
|
|
// if we don't succeed, don't consider this a fatal error
|
|
//
|
|
SetFileAttributes(CatBackupPath,FILE_ATTRIBUTE_NORMAL);
|
|
CopyFile(CatSourcePath, CatBackupPath ,FALSE);
|
|
}
|
|
|
|
//
|
|
// Add string indicating Backup INF location to file Queue
|
|
// for later retrieval
|
|
//
|
|
|
|
BackupInfID = pSetupStringTableAddString(FileQ->StringTable,
|
|
BackupPath,
|
|
STRTAB_CASE_SENSITIVE);
|
|
if (BackupInfID == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Save the full inf backup path since we need to put it in the registry
|
|
// below.
|
|
//
|
|
lstrcpy(ReinstallString, BackupPath);
|
|
|
|
//
|
|
// Also backup the PNF file
|
|
//
|
|
// WARNING: We reuse the szInfFileName and BackupPath variables at this point
|
|
// so if you add code that needs them then add it above.
|
|
//
|
|
szInfFileNameExt = _tcsrchr(szInfFileName,TEXT('.'));
|
|
MYASSERT(szInfFileNameExt);
|
|
BackupPathExt = _tcsrchr(BackupPath,TEXT('.'));
|
|
MYASSERT(BackupPathExt);
|
|
|
|
if (szInfFileNameExt && BackupPathExt) {
|
|
lstrcpy(szInfFileNameExt,pszPnfSuffix);
|
|
lstrcpy(BackupPathExt,pszPnfSuffix);
|
|
SetFileAttributes(BackupPath,FILE_ATTRIBUTE_NORMAL);
|
|
CopyFile(szInfFileName, BackupPath, FALSE);
|
|
}
|
|
|
|
//
|
|
// add items we may need to backup
|
|
// (ie the copy queue of TempQueueHandle is converted to a backup queue of FileQueue)
|
|
//
|
|
|
|
if ( pSetupBackupAppendFiles(FileQueue, SubDir, BackupFlags, TempQueueHandle) != NO_ERROR ) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Create the Reinstall registry key that points to the backup directory we
|
|
// just made.
|
|
//
|
|
|
|
if (pSetupBackupGetReinstallKeyStrings(FileQ,
|
|
TempInfoSet,
|
|
&TempInfoData,
|
|
DeviceID
|
|
) != NO_ERROR) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
Err = NO_ERROR;
|
|
|
|
//
|
|
// update BackupInfID so that INF name can be queried later. We will set
|
|
// these values at the very end since the fact that FileQ->BackupInfID is
|
|
// not -1 means the backup initialization has been successful.
|
|
//
|
|
FileQ->BackupInfID = BackupInfID;
|
|
FileQ->BackupInstanceID = BackupInstanceID;
|
|
|
|
//
|
|
// Set the FQF_DEVICE_BACKUP flag so that we know this is a device install
|
|
// backup.
|
|
//
|
|
FileQ->Flags |= FQF_DEVICE_BACKUP;
|
|
|
|
clean0:
|
|
|
|
//
|
|
// If we encountered an error during our backup initialization then we want
|
|
// to clean out the backup directory and Reinstall subkey.
|
|
//
|
|
if ((Err != NO_ERROR) &&
|
|
(BackupInstanceID != -1)) {
|
|
if (pSetupStringTableStringFromIdEx(FileQ->StringTable,
|
|
BackupInstanceID,
|
|
BackupInstance,
|
|
NULL)) {
|
|
pSetupDeleteBackup(BackupInstance);
|
|
}
|
|
}
|
|
|
|
//
|
|
// delete temporary structures used
|
|
//
|
|
if (pDeviceInfoSet != NULL ) {
|
|
UnlockDeviceInfoSet(pDeviceInfoSet);
|
|
}
|
|
if ( TempInfoSet != (HDEVINFO)INVALID_HANDLE_VALUE ) {
|
|
SetupDiDestroyDeviceInfoList(TempInfoSet);
|
|
}
|
|
if ( TempQueueHandle != (HSPFILEQ)INVALID_HANDLE_VALUE ) {
|
|
SetupCloseFileQueue(TempQueueHandle);
|
|
}
|
|
|
|
if(ChangedThreadLogContext) {
|
|
//
|
|
// restore thread log context if we changed (cleared) it
|
|
//
|
|
SetThreadLogContext(SavedLogContext,NULL);
|
|
}
|
|
DeleteLogContext(LocalLogContext);
|
|
|
|
SetLastError(Err);
|
|
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
pSetupCompleteBackup(
|
|
IN OUT HSPFILEQ FileQueue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called after we have successfully finished installing a
|
|
device. At this point the new backup that we have created is valid and
|
|
so any old backups that this device was using need to be removed.
|
|
|
|
To do this the code will enumerate all of the backup instances under the
|
|
Reinstall key and scan their DeviceInstanceIds multi-sz value. If it finds
|
|
this DeviceInstanceId in the list then it will remove it. If the list is
|
|
empty after this removal then the entire backup instance and its
|
|
cooresponding backup directory will be deleted.
|
|
|
|
Arguments:
|
|
|
|
FileQueue Backup queue is filled with files that need copying
|
|
|
|
Return Value:
|
|
|
|
Error Status
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
PSP_FILE_QUEUE BackupFileQueue = (PSP_FILE_QUEUE)FileQueue;
|
|
HKEY hKeyReinstall;
|
|
HKEY hKeyReinstallInstance;
|
|
DWORD Index;
|
|
TCHAR DeviceInstanceId[MAX_DEVICE_ID_LEN];
|
|
TCHAR ReinstallInstance[MAX_PATH];
|
|
FILETIME ftLastWriteTime;
|
|
DWORD cbData, cbInstanceSize;
|
|
BOOL bDeleteBackupInstance;
|
|
DWORD Err = NO_ERROR;
|
|
PTSTR DeviceInstanceIdsList, p;
|
|
|
|
try {
|
|
|
|
//
|
|
// If we don't have a BackupInfID then the backup failed, so don't bother
|
|
// cleaning out the old backup information or creating the new Reinstall
|
|
// instance key.
|
|
//
|
|
if (BackupFileQueue->BackupInfID == -1) {
|
|
Err = ERROR_NO_BACKUP;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Get the Device Instance Id from the backup queue. This value must be
|
|
// cleaned out from all other Reinstall Instance keys.
|
|
//
|
|
cbData = MAX_PATH;
|
|
if (!pSetupStringTableStringFromIdEx(BackupFileQueue->StringTable,
|
|
BackupFileQueue->BackupDeviceInstanceID,
|
|
DeviceInstanceId,
|
|
&cbData)) {
|
|
if (cbData == 0) {
|
|
Err = ERROR_NO_BACKUP;
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Open the Reinstall key so we can enumerate all of the instance subkeys.
|
|
//
|
|
Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
pszReinstallPath,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyReinstall
|
|
);
|
|
|
|
if (Err == ERROR_SUCCESS) {
|
|
|
|
cbInstanceSize = sizeof(ReinstallInstance) / sizeof(TCHAR);
|
|
Index = 0;
|
|
while (RegEnumKeyEx(hKeyReinstall,
|
|
Index++,
|
|
ReinstallInstance,
|
|
&cbInstanceSize,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ftLastWriteTime
|
|
) == ERROR_SUCCESS) {
|
|
|
|
//
|
|
// Assume that we don't need to delete this backup instance
|
|
//
|
|
bDeleteBackupInstance = FALSE;
|
|
|
|
Err = RegOpenKeyEx(hKeyReinstall,
|
|
ReinstallInstance,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyReinstallInstance
|
|
);
|
|
|
|
if (Err == ERROR_SUCCESS) {
|
|
|
|
cbData = 0;
|
|
if ((RegQueryValueEx(hKeyReinstallInstance,
|
|
pszReinstallDeviceInstanceIds,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&cbData
|
|
) == ERROR_SUCCESS) &&
|
|
(cbData)) {
|
|
|
|
DeviceInstanceIdsList = MyMalloc(cbData + sizeof(TCHAR));
|
|
|
|
if (DeviceInstanceIdsList) {
|
|
|
|
if (RegQueryValueEx(hKeyReinstallInstance,
|
|
pszReinstallDeviceInstanceIds,
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)DeviceInstanceIdsList,
|
|
&cbData) == ERROR_SUCCESS) {
|
|
|
|
//
|
|
// Walk the list of DeviceInstanceIds and check for
|
|
// a match with our device.
|
|
//
|
|
for (p = DeviceInstanceIdsList;
|
|
*p;
|
|
p += (lstrlen(p) + 1)) {
|
|
|
|
if (lstrcmpi(p, DeviceInstanceId) == 0) {
|
|
|
|
//
|
|
// We have a match! First we will check to
|
|
// see if this is the only DeviceInstanceId
|
|
// in the list. To do this take the length of
|
|
// the string and add two for the two terminating
|
|
// NULLs of a multi-sz string and compare that
|
|
// to cbData. If it is the same as (or larger
|
|
// than) cbData then this is the only string
|
|
// in the multi-sz list.
|
|
//
|
|
if ((p == DeviceInstanceIdsList) &&
|
|
(((lstrlen(DeviceInstanceIdsList) + 2) * sizeof(TCHAR)) >= cbData)) {
|
|
|
|
//
|
|
// Since there is only this one DeviceInstanceId
|
|
// in the list set bDeleteBackupInstance to TRUE
|
|
// so we can delete this entire subkey along
|
|
// with the files that are backed up for it.
|
|
//
|
|
bDeleteBackupInstance = TRUE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Since there is more than this DeviceInstanceId
|
|
// in the list we need to remove just this
|
|
// one Id from the multi-sz string and
|
|
// put the new multi-sz string back
|
|
// into the registry.
|
|
//
|
|
DWORD pLength = lstrlen(p);
|
|
PTSTR p2 = p + (pLength + 1);
|
|
|
|
memcpy(p, p2, cbData - ((ULONG_PTR)p2 - (ULONG_PTR)DeviceInstanceIdsList));
|
|
|
|
RegSetValueEx(hKeyReinstallInstance,
|
|
pszReinstallDeviceInstanceIds,
|
|
0,
|
|
REG_MULTI_SZ,
|
|
(PBYTE)DeviceInstanceIdsList,
|
|
cbData - ((pLength + 1) * sizeof(TCHAR))
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
MyFree(DeviceInstanceIdsList);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKeyReinstallInstance);
|
|
|
|
//
|
|
// If this entire subkey and it's corresponding directory need
|
|
// to be deleted then do it now.
|
|
//
|
|
if (bDeleteBackupInstance) {
|
|
|
|
pSetupDeleteBackup(ReinstallInstance);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Need to update the cbInstanceSize variable before calling
|
|
// RegEnumKeyEx again.
|
|
//
|
|
cbInstanceSize = sizeof(ReinstallInstance) / sizeof(TCHAR);
|
|
}
|
|
|
|
RegCloseKey(hKeyReinstall);
|
|
}
|
|
|
|
//
|
|
// Create the new Reinstall instance backup subkey.
|
|
//
|
|
Err = pSetupBackupCreateReinstallKey(BackupFileQueue);
|
|
|
|
clean0: ; // Nothing to do.
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// if we except, assume it's due to invalid parameter
|
|
//
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
VOID
|
|
pSetupCleanupBackup(
|
|
IN PSP_FILE_QUEUE Queue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to delete any backup directories or registry entries
|
|
associated with this queue.
|
|
|
|
Arguments:
|
|
|
|
Queue file queue
|
|
|
|
Return Value:
|
|
|
|
VOID
|
|
|
|
--*/
|
|
{
|
|
TCHAR BackupInstance[MAX_PATH];
|
|
DWORD cbData;
|
|
|
|
//
|
|
// If we don't have a BackupInfID or a BackupInstanceID then the backup
|
|
// must have failed much earlier. If the backup failed then it would have
|
|
// cleaned itself up so there is no cleanup that needs to be done now.
|
|
//
|
|
if ((Queue->BackupInfID == -1) ||
|
|
(Queue->BackupInstanceID == -1)) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the Backup Instance from the backup queue.
|
|
//
|
|
cbData = MAX_PATH;
|
|
if (pSetupStringTableStringFromIdEx(Queue->StringTable,
|
|
Queue->BackupInstanceID,
|
|
BackupInstance,
|
|
&cbData)) {
|
|
|
|
pSetupDeleteBackup(BackupInstance);
|
|
}
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
BOOL
|
|
PostDelayedMove(
|
|
IN PSP_FILE_QUEUE Queue,
|
|
IN PCTSTR CurrentName,
|
|
IN PCTSTR NewName, OPTIONAL
|
|
IN DWORD SecurityDesc,
|
|
IN BOOL TargetIsProtected
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Helper for DelayedMove
|
|
We don't do any delayed Moves until we know all else succeeded
|
|
|
|
Arguments:
|
|
|
|
Queue Queue that the move is applied to
|
|
CurrentName Name of file we want to move
|
|
NewName Name we want to move to
|
|
SecurityDesc Index in string table of Security Descriptor string or -1 if not present
|
|
TargetIsProtected Indicates whether target file is a protected system file
|
|
|
|
Return Value:
|
|
|
|
FALSE if error
|
|
|
|
--*/
|
|
{
|
|
PSP_DELAYMOVE_NODE DelayMoveNode;
|
|
LONG SourceFilename;
|
|
LONG TargetFilename;
|
|
DWORD Err;
|
|
|
|
if (CurrentName == NULL) {
|
|
SourceFilename = -1;
|
|
} else {
|
|
SourceFilename = pSetupStringTableAddString(Queue->StringTable,
|
|
(PTSTR)CurrentName,
|
|
STRTAB_CASE_SENSITIVE
|
|
);
|
|
if (SourceFilename == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
}
|
|
if (NewName == NULL) {
|
|
TargetFilename = -1;
|
|
} else {
|
|
TargetFilename = pSetupStringTableAddString(Queue->StringTable,
|
|
(PTSTR)NewName,
|
|
STRTAB_CASE_SENSITIVE
|
|
);
|
|
if (TargetFilename == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
DelayMoveNode = MyMalloc(sizeof(SP_DELAYMOVE_NODE));
|
|
|
|
if (DelayMoveNode == NULL) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
DelayMoveNode->NextNode = NULL;
|
|
DelayMoveNode->SourceFilename = SourceFilename;
|
|
DelayMoveNode->TargetFilename = TargetFilename;
|
|
DelayMoveNode->SecurityDesc = SecurityDesc;
|
|
DelayMoveNode->TargetIsProtected = TargetIsProtected;
|
|
|
|
if (Queue->DelayMoveQueueTail == NULL) {
|
|
Queue->DelayMoveQueue = DelayMoveNode;
|
|
} else {
|
|
Queue->DelayMoveQueueTail->NextNode = DelayMoveNode;
|
|
}
|
|
Queue->DelayMoveQueueTail = DelayMoveNode;
|
|
|
|
Err = NO_ERROR;
|
|
|
|
clean0:
|
|
|
|
SetLastError(Err);
|
|
|
|
return (Err == NO_ERROR);
|
|
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD
|
|
DoAllDelayedMoves(
|
|
IN PSP_FILE_QUEUE Queue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Execute the Delayed Moves previously posted
|
|
|
|
Arguments:
|
|
|
|
Queue Queue that has the list in
|
|
|
|
Return Value:
|
|
|
|
Error Status
|
|
|
|
--*/
|
|
{
|
|
PSP_DELAYMOVE_NODE DelayMoveNode;
|
|
PTSTR CurrentName;
|
|
PTSTR TargetName;
|
|
BOOL b = TRUE;
|
|
PSP_DELAYMOVE_NODE DoneQueue = NULL;
|
|
PSP_DELAYMOVE_NODE NextNode = NULL;
|
|
DWORD Err = NO_ERROR;
|
|
BOOL EnableProtectedRenames = FALSE;
|
|
|
|
for (DelayMoveNode = Queue->DelayMoveQueue ; DelayMoveNode ; DelayMoveNode = NextNode ) {
|
|
NextNode = DelayMoveNode->NextNode;
|
|
|
|
MYASSERT(DelayMoveNode->SourceFilename != -1);
|
|
CurrentName = pSetupStringTableStringFromId(Queue->StringTable, DelayMoveNode->SourceFilename);
|
|
MYASSERT(CurrentName);
|
|
|
|
if (DelayMoveNode->TargetFilename == -1) {
|
|
TargetName = NULL;
|
|
} else {
|
|
TargetName = pSetupStringTableStringFromId( Queue->StringTable, DelayMoveNode->TargetFilename );
|
|
MYASSERT(TargetName);
|
|
}
|
|
|
|
//
|
|
// Keep track of whether we've encountered any protected system files.
|
|
//
|
|
EnableProtectedRenames |= DelayMoveNode->TargetIsProtected;
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// If this is a move (instead of a delete), then set security (letting
|
|
// SCE know what the file's final name will be.
|
|
//
|
|
if((DelayMoveNode->SecurityDesc != -1) && TargetName) {
|
|
|
|
Err = pSetupCallSCE(ST_SCE_RENAME,
|
|
CurrentName,
|
|
Queue,
|
|
TargetName,
|
|
DelayMoveNode->SecurityDesc,
|
|
NULL
|
|
);
|
|
|
|
if(Err != NO_ERROR ){
|
|
//
|
|
// If we're on the first delay-move node, then we can abort.
|
|
// However, if we've already processed one or more nodes, then
|
|
// we can't abort--we must simply log an error indicating what
|
|
// happened and keep on going.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
MSG_LOG_DELAYED_MOVE_SCE_FAILED,
|
|
NULL,
|
|
CurrentName,
|
|
TargetName
|
|
);
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
Err
|
|
);
|
|
|
|
if(DelayMoveNode == Queue->DelayMoveQueue) {
|
|
//
|
|
// Failure occurred on 1st node--we can abort.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_OPERATION_CANCELLED,
|
|
NULL
|
|
);
|
|
break;
|
|
} else {
|
|
//
|
|
// There's no turning back--log an error and keep on going.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_ERROR_IGNORED,
|
|
NULL
|
|
);
|
|
|
|
Err = NO_ERROR;
|
|
}
|
|
}
|
|
|
|
} else
|
|
#endif
|
|
{
|
|
Err = NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// finally delay the move
|
|
//
|
|
if(!DelayedMove(CurrentName, TargetName)) {
|
|
|
|
Err = GetLastError();
|
|
|
|
//
|
|
// Same deal as above with SCE call--if we've already processed one
|
|
// or more delay-move nodes, we can't abort.
|
|
//
|
|
if(TargetName) {
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
MSG_LOG_DELAYED_MOVE_FAILED,
|
|
NULL,
|
|
CurrentName,
|
|
TargetName
|
|
);
|
|
} else {
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
MSG_LOG_DELAYED_DELETE_FAILED,
|
|
NULL,
|
|
CurrentName
|
|
);
|
|
}
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
Err
|
|
);
|
|
|
|
if(DelayMoveNode == Queue->DelayMoveQueue) {
|
|
//
|
|
// Failure occurred on 1st node--we can abort.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_OPERATION_CANCELLED,
|
|
NULL
|
|
);
|
|
break;
|
|
} else {
|
|
//
|
|
// There's no turning back--log an error and keep on going.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_ERROR_IGNORED,
|
|
NULL
|
|
);
|
|
|
|
Err = NO_ERROR;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Move node to queue containing nodes that have already been processed
|
|
//
|
|
DelayMoveNode->NextNode = DoneQueue;
|
|
DoneQueue = DelayMoveNode;
|
|
}
|
|
|
|
//
|
|
// If we have any replacement of protected system files, then we need to
|
|
// inform session manager so that it allows the replacement to occur upon
|
|
// reboot.
|
|
//
|
|
// NOTE: We don't have to worry about enabling replacement of system files
|
|
// with unsigned (hence, untrusted) versions. We only queue up unsigned
|
|
// system files for replacement if the user was explicitly warned of (and
|
|
// agreed to) the consequences.
|
|
//
|
|
// NTRAID#55485-2000/02/03-jamiehun
|
|
// Protected renames only allows "rename all" or "rename none"
|
|
//
|
|
// the session manager only allows the granularity of "allow all
|
|
// renames" or "allow no renames". If Err != NO_ERROR, then we
|
|
// might want to clear out this flag, but that means we'd negate
|
|
// any renames that were previously allowed. Yuck. So we flip a
|
|
// coin, decide to do nothing, and hope for the best if an error
|
|
// occurred. We have similar situation above -- it's all or
|
|
// nothing.
|
|
//
|
|
if((Err == NO_ERROR) && EnableProtectedRenames) {
|
|
pSetupProtectedRenamesFlag(TRUE);
|
|
}
|
|
|
|
//
|
|
// any nodes that are left are dropped
|
|
//
|
|
for ( ; DelayMoveNode ; DelayMoveNode = NextNode ) {
|
|
NextNode = DelayMoveNode->NextNode;
|
|
|
|
MyFree(DelayMoveNode);
|
|
}
|
|
Queue->DelayMoveQueue = NULL;
|
|
Queue->DelayMoveQueueTail = NULL;
|
|
|
|
//
|
|
// delete all nodes we queue'd
|
|
//
|
|
for ( ; DoneQueue ; DoneQueue = NextNode ) {
|
|
NextNode = DoneQueue->NextNode;
|
|
//
|
|
// done with node
|
|
//
|
|
MyFree(DoneQueue);
|
|
}
|
|
|
|
return Err;
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
VOID
|
|
pSetupUnwindAll(
|
|
IN PSP_FILE_QUEUE Queue,
|
|
IN BOOL Succeeded
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes the Unwind Queue. If Succeeded is FALSE, restores any data that was backed up
|
|
|
|
Arguments:
|
|
|
|
Queue Queue to be unwound
|
|
Succeeded Indicates if we should treat the whole operation as succeeded or failed
|
|
|
|
Return Value:
|
|
|
|
None--this routine should always succeed. (Any file errors encountered
|
|
along the way are logged in the setupapi logfile.)
|
|
|
|
--*/
|
|
|
|
{
|
|
// if Succeeded, we need to delete Temp files
|
|
// if we didn't succeed, we need to restore backups
|
|
|
|
PSP_UNWIND_NODE UnwindNode;
|
|
PSP_UNWIND_NODE ThisNode;
|
|
SP_TARGET_ENT TargetInfo;
|
|
PTSTR BackupFilename;
|
|
PTSTR TargetFilename;
|
|
PTSTR RenamedFilename;
|
|
DWORD Err = NO_ERROR;
|
|
TCHAR TempPath[MAX_PATH];
|
|
PTSTR TempNamePtr;
|
|
TCHAR TempFilename[MAX_PATH];
|
|
BOOL RestoreByRenaming;
|
|
BOOL OkToDeleteBackup;
|
|
|
|
try {
|
|
if (Succeeded == FALSE) {
|
|
//
|
|
// we need to restore backups
|
|
//
|
|
|
|
WriteLogEntry(
|
|
Queue->LogContext,
|
|
SETUP_LOG_WARNING,
|
|
MSG_LOG_UNWIND,
|
|
NULL);
|
|
|
|
for ( UnwindNode = Queue->UnwindQueue; UnwindNode != NULL; ) {
|
|
ThisNode = UnwindNode;
|
|
UnwindNode = UnwindNode->NextNode;
|
|
|
|
if (pSetupBackupGetTargetByID((HSPFILEQ)Queue, ThisNode->TargetID, &TargetInfo) == NO_ERROR) {
|
|
|
|
|
|
BackupFilename = NULL;
|
|
TargetFilename = NULL;
|
|
RenamedFilename = NULL;
|
|
|
|
// restore backup
|
|
if(!(TargetInfo.InternalFlags & SP_TEFLG_RESTORED)) {
|
|
|
|
// get target name
|
|
TargetFilename = pSetupFormFullPath(
|
|
Queue->StringTable,
|
|
TargetInfo.TargetRoot,
|
|
TargetInfo.TargetSubDir,
|
|
TargetInfo.TargetFilename);
|
|
|
|
if(TargetInfo.InternalFlags & SP_TEFLG_MOVED) {
|
|
//
|
|
// Get renamed filename
|
|
//
|
|
RenamedFilename = pSetupStringTableStringFromId(Queue->StringTable,
|
|
TargetInfo.NewTargetFilename
|
|
);
|
|
}
|
|
|
|
if(TargetInfo.InternalFlags & SP_TEFLG_SAVED) {
|
|
//
|
|
// get backup name
|
|
//
|
|
BackupFilename = pSetupFormFullPath(
|
|
Queue->StringTable,
|
|
TargetInfo.BackupRoot,
|
|
TargetInfo.BackupSubDir,
|
|
TargetInfo.BackupFilename);
|
|
|
|
}
|
|
}
|
|
|
|
if(TargetFilename && (RenamedFilename || BackupFilename)) {
|
|
//
|
|
// We either renamed the original file or we backed it up.
|
|
// We need to put it back.
|
|
//
|
|
RestoreByRenaming = RenamedFilename ? TRUE : FALSE;
|
|
|
|
RestoreRenamedOrBackedUpFile(TargetFilename,
|
|
(RestoreByRenaming
|
|
? RenamedFilename
|
|
: BackupFilename),
|
|
RestoreByRenaming,
|
|
Queue->LogContext
|
|
);
|
|
|
|
//
|
|
// If we were doing a copy (i.e., from a backup) as opposed
|
|
// to a rename, then we need to reapply timestamp and
|
|
// security.
|
|
//
|
|
if(!RestoreByRenaming) {
|
|
|
|
Err = GetSetFileTimestamp(TargetFilename,
|
|
&(ThisNode->CreateTime),
|
|
&(ThisNode->AccessTime),
|
|
&(ThisNode->WriteTime),
|
|
TRUE
|
|
);
|
|
|
|
if(Err != NO_ERROR) {
|
|
//
|
|
// We just blew away the timestamp on the file--log
|
|
// an error entry to that effect.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
MSG_LOG_BACKUP_EXISTING_RESTORE_FILETIME_FAILED,
|
|
NULL,
|
|
TargetFilename
|
|
);
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
Err
|
|
);
|
|
}
|
|
|
|
if(ThisNode->SecurityDesc != NULL){
|
|
|
|
Err = StampFileSecurity(TargetFilename, ThisNode->SecurityDesc);
|
|
|
|
if(Err != NO_ERROR) {
|
|
//
|
|
// We just blew away the existing security on
|
|
// the file--log an error entry to that effect.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
MSG_LOG_BACKUP_EXISTING_RESTORE_SECURITY_FAILED,
|
|
NULL,
|
|
TargetFilename
|
|
);
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
Err
|
|
);
|
|
}
|
|
#ifdef UNICODE
|
|
Err = pSetupCallSCE(ST_SCE_UNWIND,
|
|
TargetFilename,
|
|
NULL,
|
|
NULL,
|
|
-1,
|
|
ThisNode->SecurityDesc
|
|
);
|
|
|
|
if(Err != NO_ERROR) {
|
|
//
|
|
// We just blew away the existing security on
|
|
// the file--log an error entry to that effect.
|
|
//
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
MSG_LOG_BACKUP_EXISTING_RESTORE_SCE_FAILED,
|
|
NULL,
|
|
TargetFilename
|
|
);
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_ERROR,
|
|
Err
|
|
);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now mark that we've restored this file. We'll delete
|
|
// tempfiles later
|
|
//
|
|
TargetInfo.InternalFlags |= SP_TEFLG_RESTORED;
|
|
pSetupBackupSetTargetByID((HSPFILEQ)Queue, ThisNode->TargetID, &TargetInfo);
|
|
}
|
|
|
|
if(BackupFilename) {
|
|
MyFree(BackupFilename);
|
|
}
|
|
if(TargetFilename) {
|
|
MyFree(TargetFilename);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// cleanup - remove temporary files
|
|
//
|
|
for ( UnwindNode = Queue->UnwindQueue; UnwindNode != NULL; ) {
|
|
ThisNode = UnwindNode;
|
|
UnwindNode = UnwindNode->NextNode;
|
|
|
|
if (pSetupBackupGetTargetByID((HSPFILEQ)Queue, ThisNode->TargetID, &TargetInfo) == NO_ERROR) {
|
|
// delete temporary file
|
|
if (TargetInfo.InternalFlags & SP_TEFLG_TEMPNAME) {
|
|
//
|
|
// get name of file that was used for backup
|
|
//
|
|
BackupFilename = pSetupFormFullPath(
|
|
Queue->StringTable,
|
|
TargetInfo.BackupRoot,
|
|
TargetInfo.BackupSubDir,
|
|
TargetInfo.BackupFilename);
|
|
|
|
if(BackupFilename) {
|
|
//
|
|
// If this operation was a bootfile replacement, then we
|
|
// don't want to delete the backup (if we used the renamed
|
|
// file for the backup as well). A delayed delete will
|
|
// have been queued to get rid of the file after a reboot.
|
|
//
|
|
OkToDeleteBackup = TRUE;
|
|
|
|
if(TargetInfo.InternalFlags & SP_TEFLG_MOVED) {
|
|
//
|
|
// Retrieve the renamed filename to see if it's the
|
|
// same as the backup filename.
|
|
//
|
|
RenamedFilename = pSetupStringTableStringFromId(Queue->StringTable,
|
|
TargetInfo.NewTargetFilename
|
|
);
|
|
|
|
if(!lstrcmpi(BackupFilename, RenamedFilename)) {
|
|
OkToDeleteBackup = FALSE;
|
|
}
|
|
}
|
|
|
|
if(OkToDeleteBackup) {
|
|
//
|
|
// since it was temporary, delete it
|
|
//
|
|
SetFileAttributes(BackupFilename, FILE_ATTRIBUTE_NORMAL);
|
|
if(!DeleteFile(BackupFilename)) {
|
|
//
|
|
// Alright, see if we can set it up for delayed delete
|
|
// instead.
|
|
//
|
|
if(!DelayedMove(BackupFilename, NULL)) {
|
|
//
|
|
// Oh well, just write a log entry indicating that
|
|
// this file turd was left on the user's disk.
|
|
//
|
|
Err = GetLastError();
|
|
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_WARNING | SETUP_LOG_BUFFER,
|
|
MSG_LOG_BACKUP_DELAYED_DELETE_FAILED,
|
|
NULL,
|
|
BackupFilename
|
|
);
|
|
|
|
WriteLogError(Queue->LogContext,
|
|
SETUP_LOG_WARNING,
|
|
Err
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
MyFree(BackupFilename);
|
|
}
|
|
}
|
|
|
|
pSetupResetTarget(Queue->TargetLookupTable,
|
|
ThisNode->TargetID,
|
|
NULL,
|
|
&TargetInfo,
|
|
sizeof(TargetInfo),
|
|
(LPARAM)0
|
|
);
|
|
}
|
|
|
|
// cleanup node
|
|
if (ThisNode->SecurityDesc != NULL) {
|
|
MyFree(ThisNode->SecurityDesc);
|
|
}
|
|
MyFree(ThisNode);
|
|
}
|
|
Queue->UnwindQueue = NULL;
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// should generally not get here
|
|
// unless Queue is invalid
|
|
//
|
|
}
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
DWORD _SetupGetBackupInformation(
|
|
IN PSP_FILE_QUEUE Queue,
|
|
OUT PSP_BACKUP_QUEUE_PARAMS_V2 BackupParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get Backup INF path - Internal version
|
|
|
|
Arguments:
|
|
|
|
Queue - pointer to queue structure (validated)
|
|
BackupParams OUT - filled with INF file path
|
|
|
|
Return Value:
|
|
|
|
TRUE if success, else FALSE
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Queue is assumed to have been validated
|
|
// BackupParams is in Native format
|
|
//
|
|
|
|
LONG BackupInfID;
|
|
ULONG BufSize = MAX_PATH;
|
|
BOOL b;
|
|
DWORD err = NO_ERROR;
|
|
LPCTSTR filename;
|
|
INT offset;
|
|
|
|
BackupInfID = Queue->BackupInfID;
|
|
|
|
if (BackupInfID != -1) {
|
|
//
|
|
// get inf from stringtable
|
|
//
|
|
b = pSetupStringTableStringFromIdEx(Queue->StringTable,
|
|
BackupInfID,
|
|
BackupParams->FullInfPath,
|
|
&BufSize);
|
|
if (b == FALSE) {
|
|
if (BufSize == 0) {
|
|
err = ERROR_NO_BACKUP;
|
|
} else {
|
|
err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// find index of filename
|
|
//
|
|
filename = pSetupGetFileTitle(BackupParams->FullInfPath);
|
|
offset = (INT)(filename - BackupParams->FullInfPath);
|
|
BackupParams->FilenameOffset = offset;
|
|
|
|
//
|
|
// If the caller passed in a SP_BACKUP_QUEUE_PARAMS_V2 structure then
|
|
// also fill in the ReinstallInstance string value.
|
|
//
|
|
if (BackupParams->cbSize >= sizeof(SP_BACKUP_QUEUE_PARAMS_V2)) {
|
|
BufSize = MAX_PATH;
|
|
if(Queue->BackupInstanceID != -1) {
|
|
b = pSetupStringTableStringFromIdEx(Queue->StringTable,
|
|
Queue->BackupInstanceID,
|
|
BackupParams->ReinstallInstance,
|
|
&BufSize);
|
|
} else {
|
|
//
|
|
// no instance ID
|
|
//
|
|
BackupParams->ReinstallInstance[0] = TEXT('\0');
|
|
}
|
|
if (b == FALSE) {
|
|
if (BufSize == 0) {
|
|
err = ERROR_NO_BACKUP;
|
|
} else {
|
|
err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
goto Clean0;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// no backup path
|
|
//
|
|
err = ERROR_NO_BACKUP;
|
|
}
|
|
|
|
Clean0:
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// ANSI version in UNICODE
|
|
//
|
|
BOOL
|
|
WINAPI
|
|
SetupGetBackupInformationA(
|
|
IN HSPFILEQ QueueHandle,
|
|
OUT PSP_BACKUP_QUEUE_PARAMS_V2_A BackupParams
|
|
)
|
|
{
|
|
BOOL b;
|
|
int i;
|
|
INT c;
|
|
LPCSTR p;
|
|
SP_BACKUP_QUEUE_PARAMS_W BackupParamsW;
|
|
|
|
//
|
|
// confirm structure size
|
|
//
|
|
|
|
try {
|
|
if((BackupParams->cbSize != sizeof(SP_BACKUP_QUEUE_PARAMS_V2_A)) &&
|
|
(BackupParams->cbSize != sizeof(SP_BACKUP_QUEUE_PARAMS_V1_A))) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
b = FALSE;
|
|
leave; // exit try block
|
|
}
|
|
//
|
|
// call Unicode version of API
|
|
//
|
|
ZeroMemory( &BackupParamsW, sizeof(BackupParamsW) );
|
|
BackupParamsW.cbSize = sizeof(BackupParamsW);
|
|
|
|
b = SetupGetBackupInformationW(QueueHandle,&BackupParamsW);
|
|
if (b) {
|
|
//
|
|
// success, convert structure from UNICODE to ANSI
|
|
//
|
|
i = WideCharToMultiByte(
|
|
CP_ACP,
|
|
0,
|
|
BackupParamsW.FullInfPath,
|
|
MAX_PATH,
|
|
BackupParams->FullInfPath,
|
|
MAX_PATH,
|
|
NULL,
|
|
NULL
|
|
);
|
|
if (i==0) {
|
|
//
|
|
// error occurred (LastError set to error)
|
|
//
|
|
b = FALSE;
|
|
leave; // exit try block
|
|
}
|
|
|
|
//
|
|
// we need to recalc the offset of INF filename
|
|
// taking care of internationalization
|
|
//
|
|
p = BackupParams->FullInfPath;
|
|
for(c = 0; c < BackupParamsW.FilenameOffset; c++) {
|
|
p = CharNextA(p);
|
|
}
|
|
BackupParams->FilenameOffset = (int)(p-(BackupParams->FullInfPath)); // new offset in ANSI
|
|
|
|
if (BackupParams->cbSize >= sizeof(SP_BACKUP_QUEUE_PARAMS_V2_A)) {
|
|
//
|
|
// instance
|
|
//
|
|
i = WideCharToMultiByte(
|
|
CP_ACP,
|
|
0,
|
|
BackupParamsW.ReinstallInstance,
|
|
MAX_PATH,
|
|
BackupParams->ReinstallInstance,
|
|
MAX_PATH,
|
|
NULL,
|
|
NULL
|
|
);
|
|
if (i==0) {
|
|
//
|
|
// error occurred (LastError set to error)
|
|
//
|
|
b = FALSE;
|
|
leave; // exit try block
|
|
}
|
|
}
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// if we except, assume it's due to invalid parameter
|
|
//
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
b = FALSE;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
#else
|
|
//
|
|
// Unicode version in ANSI
|
|
//
|
|
BOOL
|
|
WINAPI
|
|
SetupGetBackupInformationW(
|
|
IN HSPFILEQ QueueHandle,
|
|
OUT PSP_BACKUP_QUEUE_PARAMS_V2_W BackupParams
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(QueueHandle);
|
|
UNREFERENCED_PARAMETER(BackupParams);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(FALSE);
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Native version
|
|
//
|
|
BOOL
|
|
WINAPI
|
|
SetupGetBackupInformation(
|
|
IN HSPFILEQ QueueHandle,
|
|
OUT PSP_BACKUP_QUEUE_PARAMS_V2 BackupParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get Backup INF path
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - handle of queue to retrieve backup INF file from
|
|
BackupParams - IN - has cbSize set, OUT - filled with INF file path
|
|
|
|
Return Value:
|
|
|
|
TRUE if success, else FALSE
|
|
|
|
--*/
|
|
{
|
|
BOOL b = TRUE;
|
|
PSP_FILE_QUEUE Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
DWORD res;
|
|
|
|
//
|
|
// first validate QueueHandle
|
|
//
|
|
try {
|
|
if(Queue->Signature != SP_FILE_QUEUE_SIG) {
|
|
b = FALSE;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
b = FALSE;
|
|
}
|
|
if(!b) {
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// now fill in structure
|
|
// if we except, assume bad pointer
|
|
//
|
|
try {
|
|
if((BackupParams->cbSize != sizeof(SP_BACKUP_QUEUE_PARAMS_V2)) &&
|
|
(BackupParams->cbSize != sizeof(SP_BACKUP_QUEUE_PARAMS_V1))) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
b = FALSE;
|
|
leave; // exit try block
|
|
}
|
|
res = _SetupGetBackupInformation(Queue,BackupParams);
|
|
if (res == NO_ERROR) {
|
|
b = TRUE;
|
|
} else {
|
|
SetLastError(res);
|
|
b = FALSE;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// if we except, assume it's due to invalid parameter
|
|
//
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
b = FALSE;
|
|
}
|
|
|
|
Clean0:
|
|
return b;
|
|
}
|
|
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
VOID
|
|
RestoreRenamedOrBackedUpFile(
|
|
IN PCTSTR TargetFilename,
|
|
IN PCTSTR CurrentFilename,
|
|
IN BOOL RenameFile,
|
|
IN PSETUP_LOG_CONTEXT LogContext OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine does its best to restore a backed-up or renamed file back to
|
|
its original name.
|
|
|
|
Arguments:
|
|
|
|
TargetFilename - filename to be restored to
|
|
|
|
CurrentFilename - file to restore
|
|
|
|
RenameFile - if TRUE, CurrentFilename was previously renamed from
|
|
TargetFilename (hence should be renamed back). If FALSE,
|
|
CurrentFilename is merely a copy, and should be copied back.
|
|
|
|
LogContext - supplies a log context used if errors are encountered.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
DWORD Err;
|
|
TCHAR TempPath[MAX_PATH];
|
|
PTSTR TempNamePtr;
|
|
TCHAR TempFilename[MAX_PATH];
|
|
DWORD LogTag = AllocLogInfoSlotOrLevel(LogContext,SETUP_LOG_INFO,FALSE);
|
|
|
|
WriteLogEntry(
|
|
LogContext,
|
|
LogTag,
|
|
MSG_LOG_UNWIND_FILE,
|
|
NULL,
|
|
CurrentFilename,
|
|
TargetFilename
|
|
);
|
|
|
|
//
|
|
// First, clear target attributes...
|
|
//
|
|
SetFileAttributes(TargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
|
|
if(RenameFile) {
|
|
//
|
|
// simple case, move temporary file over existing file
|
|
//
|
|
pSetupExemptFileFromProtection(
|
|
TargetFilename,
|
|
SFC_ACTION_ADDED | SFC_ACTION_REMOVED | SFC_ACTION_MODIFIED
|
|
| SFC_ACTION_RENAMED_OLD_NAME |SFC_ACTION_RENAMED_NEW_NAME,
|
|
LogContext,
|
|
NULL
|
|
);
|
|
Err = DoMove(CurrentFilename, TargetFilename) ? NO_ERROR : GetLastError();
|
|
} else {
|
|
pSetupExemptFileFromProtection(
|
|
TargetFilename,
|
|
SFC_ACTION_ADDED | SFC_ACTION_REMOVED | SFC_ACTION_MODIFIED
|
|
| SFC_ACTION_RENAMED_OLD_NAME |SFC_ACTION_RENAMED_NEW_NAME,
|
|
LogContext,
|
|
NULL
|
|
);
|
|
Err = CopyFile(CurrentFilename, TargetFilename, FALSE) ? NO_ERROR : GetLastError();
|
|
}
|
|
|
|
if(Err != NO_ERROR) {
|
|
//
|
|
// Can't replace the file that got copied in place of
|
|
// the original one--try to move that one to a tempname
|
|
// and schedule it for delayed deletion.
|
|
//
|
|
WriteLogEntry(LogContext,
|
|
SETUP_LOG_ERROR|SETUP_LOG_BUFFER,
|
|
MSG_LOG_UNWIND_TRY1_FAILED,
|
|
NULL,
|
|
CurrentFilename,
|
|
TargetFilename
|
|
);
|
|
WriteLogError(LogContext,
|
|
SETUP_LOG_ERROR,
|
|
Err
|
|
);
|
|
|
|
//
|
|
// First, strip the filename off the path.
|
|
//
|
|
_tcscpy(TempPath, TargetFilename);
|
|
TempNamePtr = (PTSTR)pSetupGetFileTitle(TempPath);
|
|
*TempNamePtr = TEXT('\0');
|
|
|
|
//
|
|
// Now get a temp filename within that directory...
|
|
//
|
|
if(GetTempFileName(TempPath, TEXT("OLD"), 0, TempFilename) == 0 ) {
|
|
//
|
|
// Uh oh!
|
|
//
|
|
Err = GetLastError();
|
|
} else if(!DoMove(TargetFilename, TempFilename)) {
|
|
Err = GetLastError();
|
|
} else {
|
|
//
|
|
// OK, we were able to rename the current file to a
|
|
// temp filename--now attempt to copy or move the
|
|
// original file back to its original name.
|
|
//
|
|
if(RenameFile) {
|
|
Err = DoMove(CurrentFilename, TargetFilename) ? NO_ERROR : GetLastError();
|
|
} else {
|
|
Err = CopyFile(CurrentFilename, TargetFilename, FALSE) ? NO_ERROR : GetLastError();
|
|
}
|
|
|
|
if(Err != NO_ERROR) {
|
|
//
|
|
// This is very bad--put the current file back (it's probably
|
|
// better to have something than nothing at all).
|
|
//
|
|
DoMove(TempFilename, TargetFilename);
|
|
}
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
//
|
|
// We successfully moved the current file to a temp
|
|
// filename, and put the original file back. Now
|
|
// queue a delayed delete for the temp file.
|
|
//
|
|
if(!DelayedMove(TempFilename, NULL)) {
|
|
//
|
|
// All this means is that a file turd will get
|
|
// left on the disk--simply log an event about
|
|
// this.
|
|
//
|
|
Err = GetLastError();
|
|
|
|
WriteLogEntry(LogContext,
|
|
SETUP_LOG_WARNING | SETUP_LOG_BUFFER,
|
|
MSG_LOG_RENAME_EXISTING_DELAYED_DELETE_FAILED,
|
|
NULL,
|
|
TargetFilename,
|
|
TempFilename
|
|
);
|
|
|
|
WriteLogError(LogContext,
|
|
SETUP_LOG_WARNING,
|
|
Err
|
|
);
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// We were unable to put the original file back--we
|
|
// can't fail, so just log an error about this and
|
|
// keep on going.
|
|
//
|
|
// in the case of a backed-up file,
|
|
// we might get away with queueing the original file
|
|
// for a delayed rename and then prompting the user
|
|
// to reboot. However, that won't work for renamed
|
|
// files, because they're typically needed very
|
|
// early on in the boot (i.e., before session
|
|
// manager has had a chance to process the delayed
|
|
// rename operations).
|
|
//
|
|
WriteLogEntry(LogContext,
|
|
SETUP_LOG_ERROR | SETUP_LOG_BUFFER,
|
|
(RenameFile
|
|
? MSG_LOG_RENAME_EXISTING_RESTORE_FAILED
|
|
: MSG_LOG_BACKUP_EXISTING_RESTORE_FAILED),
|
|
NULL,
|
|
CurrentFilename,
|
|
TargetFilename
|
|
);
|
|
|
|
WriteLogError(LogContext,
|
|
SETUP_LOG_ERROR,
|
|
Err
|
|
);
|
|
}
|
|
}
|
|
|
|
if (LogTag) {
|
|
ReleaseLogInfoSlot(LogContext,LogTag);
|
|
}
|
|
}
|
|
|
|
//
|
|
// ==========================================================
|
|
//
|
|
|
|
BOOL
|
|
UnPostDelayedMove(
|
|
IN PSP_FILE_QUEUE Queue,
|
|
IN PCTSTR CurrentName,
|
|
IN PCTSTR NewName OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Locates a delay-move node (either for rename or delete), and removes it
|
|
from the delay-move queue.
|
|
|
|
Arguments:
|
|
|
|
Queue Queue that the move was applied to
|
|
CurrentName Name of file to be moved
|
|
NewName Name to move file to (NULL if delayed-delete)
|
|
|
|
Return Value:
|
|
|
|
If successful, the return value is TRUE, otherwise it is FALSE.
|
|
|
|
--*/
|
|
{
|
|
PSP_DELAYMOVE_NODE CurNode, PrevNode;
|
|
PCTSTR SourceFilename, TargetFilename;
|
|
|
|
//
|
|
// Since the path string IDs in the delay-move nodes are case-sensitive, we
|
|
// don't attempt to match on ID. We instead retrieve the strings, and do
|
|
// case-insensitive string compares. Since this routine is rarely used, the
|
|
// performance hit isn't a big deal.
|
|
//
|
|
for(CurNode = Queue->DelayMoveQueue, PrevNode = NULL;
|
|
CurNode;
|
|
PrevNode = CurNode, CurNode = CurNode->NextNode) {
|
|
|
|
if(NewName) {
|
|
//
|
|
// We're searching for a delayed rename, so we must pay attention
|
|
// to the target filename.
|
|
//
|
|
if(CurNode->TargetFilename == -1) {
|
|
continue;
|
|
} else {
|
|
TargetFilename = pSetupStringTableStringFromId(Queue->StringTable, CurNode->TargetFilename);
|
|
MYASSERT(TargetFilename);
|
|
if(lstrcmpi(NewName, TargetFilename)) {
|
|
//
|
|
// Target filenames differ--move on.
|
|
//
|
|
continue;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// We're searching for a delayed delete.
|
|
//
|
|
if(CurNode->TargetFilename != -1) {
|
|
//
|
|
// This is a rename, not a delete--move on.
|
|
//
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we get to here, then the target filenames match (if this is a
|
|
// rename), or they're both empty (if it's a delete). Now compare the
|
|
// source filenames.
|
|
//
|
|
MYASSERT(CurNode->SourceFilename != -1);
|
|
SourceFilename = pSetupStringTableStringFromId(Queue->StringTable, CurNode->SourceFilename);
|
|
MYASSERT(SourceFilename);
|
|
|
|
if(lstrcmpi(CurrentName, SourceFilename)) {
|
|
//
|
|
// Source filenames differ--move on.
|
|
//
|
|
continue;
|
|
} else {
|
|
//
|
|
// We have a match--remove the node from the delay-move queue.
|
|
//
|
|
if(PrevNode) {
|
|
PrevNode->NextNode = CurNode->NextNode;
|
|
} else {
|
|
Queue->DelayMoveQueue = CurNode->NextNode;
|
|
}
|
|
if(!CurNode->NextNode) {
|
|
MYASSERT(Queue->DelayMoveQueueTail == CurNode);
|
|
Queue->DelayMoveQueueTail = PrevNode;
|
|
}
|
|
MyFree(CurNode);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We didn't find a match.
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
DWORD
|
|
pSetupDoLastKnownGoodBackup(
|
|
IN struct _SP_FILE_QUEUE *Queue, OPTIONAL
|
|
IN PCTSTR TargetFilename,
|
|
IN DWORD Flags,
|
|
IN PSETUP_LOG_CONTEXT LogContext OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process LastKnownGood backups into <<LastGoodDirectory>>.
|
|
If files are to be deleted on restore, write apropriate flags to HKLM\System\LastGoodRecovery\LastGood\<path/file>
|
|
|
|
Caviats:
|
|
|
|
If file is not inside <<WindowsDirectory>> or sub-directory, exit no-error.
|
|
|
|
Backup will not occur if PSPGF_NO_BACKUP is set.
|
|
|
|
If !SP_LKG_FLAG_FORCECOPY
|
|
If file is inside <<LastGoodDirectory>>, exit with error.
|
|
If file is inside <<InfDirectory>> throw warnings
|
|
|
|
If an INF inside of <<InfDirectory>> is backed up, it's PNF is backed up too.
|
|
|
|
If backup fails, we don't abort copy.
|
|
|
|
Arguments:
|
|
|
|
Queue Queue (optional) if specified, flags will be checked
|
|
TargetFilename Name of file to backup
|
|
Flags
|
|
SP_LKG_FLAG_FORCECOPY - if set, turns copy safety-guards off
|
|
SP_LKG_FLAG_DELETEIFNEW - if set, writes a delete entry for new files
|
|
SP_LKG_FLAG_DELETEEXISTING - if set, writes a delete entry for existing files
|
|
SP_LKG_FLAG_DELETEOP - if set, primary operation is trying to delete/rename file
|
|
|
|
LogContext If specified, provides preferred logging context
|
|
|
|
Return Value:
|
|
|
|
error if operation should be aborted, NO_ERROR otherwise.
|
|
|
|
--*/
|
|
{
|
|
#ifdef UNICODE
|
|
int wd_len; // windows directory len
|
|
int tf_len; // target file len
|
|
int id_len; // inf directory len
|
|
int lkgd_len; // last known good directory len
|
|
int rf_len; // relative file len (including preceeding slash)
|
|
BOOL is_inf = FALSE;
|
|
BOOL is_infdir = FALSE;
|
|
BOOL write_delete = FALSE;
|
|
BOOL no_copy = FALSE;
|
|
BOOL source_exists = FALSE;
|
|
BOOL target_exists = FALSE;
|
|
TCHAR FullTargetFilename[MAX_PATH];
|
|
TCHAR BackupTargetFilename[MAX_PATH+14];
|
|
TCHAR TempFilename[MAX_PATH];
|
|
TCHAR RegName[MAX_PATH];
|
|
PCTSTR RelativeFilename;
|
|
PCTSTR CharPtr;
|
|
PTSTR DestPtr;
|
|
PTSTR NamePart = NULL;
|
|
PTSTR ExtPart = NULL;
|
|
DWORD attr;
|
|
HANDLE hFile;
|
|
HKEY hKeyLastGood;
|
|
DWORD disposition;
|
|
LONG regres;
|
|
DWORD LastGoodFlags = 0;
|
|
DWORD rval = NO_ERROR;
|
|
PSETUP_LOG_CONTEXT LocalLogContext = NULL;
|
|
|
|
if (!LogContext) {
|
|
//
|
|
// LogContext may be obmitted if there's a Queue parameter
|
|
//
|
|
if (Queue && Queue->LogContext) {
|
|
LogContext = Queue->LogContext;
|
|
} else {
|
|
if(CreateLogContext(NULL,TRUE,&LocalLogContext)==NO_ERROR) {
|
|
LogContext = LocalLogContext;
|
|
}
|
|
}
|
|
MYASSERT(LogContext);
|
|
}
|
|
|
|
if ((GlobalSetupFlags & PSPGF_NO_BACKUP)!=0) {
|
|
//
|
|
// in a scenario where (1) we trust what we're doing and
|
|
// (2) what we're doing modifies lots of files
|
|
// or (3) what we're doing is undoable (eg, upgrading OS)
|
|
//
|
|
no_copy = TRUE;
|
|
}
|
|
#if 0
|
|
else if (Queue && !(Queue->Flags & FQF_DEVICE_INSTALL)) {
|
|
//
|
|
// in this scenario, a queue was specified, but it's not marked
|
|
// for device install
|
|
// we're not interested in this case
|
|
//
|
|
no_copy = TRUE;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// cannonicalize the Target name so user doesn't do stuff like .../TEMP/../INF
|
|
//
|
|
tf_len = (int)GetFullPathName(TargetFilename,
|
|
MAX_PATH,
|
|
FullTargetFilename,
|
|
&NamePart);
|
|
if (tf_len <= 0 || tf_len > MAX_PATH) {
|
|
//
|
|
// we don't do large paths very well
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
}
|
|
wd_len = lstrlen(WindowsDirectory);
|
|
lkgd_len = lstrlen(LastGoodDirectory);
|
|
id_len = lstrlen(InfDirectory);
|
|
|
|
//
|
|
// see if this file is nested below <<WindowsDirectory>>
|
|
// note that such a file must be at least two characters longer
|
|
//
|
|
if((tf_len <= wd_len)
|
|
|| (FullTargetFilename[wd_len] != TEXT('\\'))
|
|
|| (_tcsnicmp(WindowsDirectory,FullTargetFilename,wd_len)!=0)) {
|
|
//
|
|
// this file is outside of %windir%, not handled by LKG
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
}
|
|
if (!(Flags&SP_LKG_FLAG_FORCECOPY)) {
|
|
//
|
|
// sanity check for files being copied into LKG dir
|
|
//
|
|
if((tf_len > lkgd_len)
|
|
&& (FullTargetFilename[lkgd_len] == TEXT('\\'))
|
|
&& (_tcsnicmp(LastGoodDirectory,FullTargetFilename,lkgd_len)==0)) {
|
|
//
|
|
// this file is prefixed by LastGoodDirectory
|
|
// not allowed - throw a log message and inform caller of this mistake
|
|
// return FALSE to abort the operation
|
|
//
|
|
WriteLogEntry(LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_FILE_BLOCK,
|
|
NULL,
|
|
FullTargetFilename,
|
|
LastGoodDirectory
|
|
);
|
|
rval = ERROR_ACCESS_DENIED;
|
|
goto final;
|
|
}
|
|
}
|
|
if((tf_len > id_len)
|
|
&& (FullTargetFilename[id_len] == TEXT('\\'))
|
|
&& (_tcsnicmp(InfDirectory,FullTargetFilename,id_len)==0)
|
|
&& ((NamePart-FullTargetFilename) == (id_len+1))) {
|
|
//
|
|
// the file sits in the primary INF directory
|
|
//
|
|
is_infdir = TRUE;
|
|
//
|
|
// check for name ending in ".INF" - if so, we need to backup ".PNF" too
|
|
//
|
|
ExtPart = FullTargetFilename+tf_len;
|
|
while ((ExtPart = CharPrev(NamePart,ExtPart)) != NamePart) {
|
|
if (ExtPart[0] == TEXT('.')) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(_tcsicmp(ExtPart,TEXT(".INF"))==0) {
|
|
//
|
|
// ends in .INF
|
|
//
|
|
is_inf = TRUE;
|
|
//
|
|
// we should only get here if Force is set (ie, we've already determined
|
|
// what is being copied and all is OK). If we don't, this implies someone
|
|
// is trying a back-door INF copy. we've already logged above that they're writing
|
|
// to this directory when they shouldn't. However, if we don't do anything
|
|
// about it, culprit could render machine in bad state
|
|
// change this behavior into a "Force" behavior
|
|
//
|
|
if (!(Flags&SP_LKG_FLAG_FORCECOPY)) {
|
|
no_copy = FALSE; // ensure we'll go through copy logic
|
|
WriteLogEntry(LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_INF_WARN,
|
|
NULL,
|
|
FullTargetFilename,
|
|
InfDirectory
|
|
);
|
|
if(!(Flags&SP_LKG_FLAG_DELETEOP)) {
|
|
//
|
|
// we're invalidly trying to overwrite an INF/create an INF
|
|
//
|
|
Flags|=SP_LKG_FLAG_DELETEIFNEW;
|
|
}
|
|
}
|
|
} else if (!(Flags&SP_LKG_FLAG_FORCECOPY)) {
|
|
//
|
|
// writing something else into this directory - huh?
|
|
// well, if it's not an INF, we won't pick it up via INF searching
|
|
// if it's a PNF or cache, we're regenerate it
|
|
// don't fret too much, but slap wrist.
|
|
//
|
|
WriteLogEntry(LogContext,
|
|
SETUP_LOG_ERROR,
|
|
MSG_LOG_FILE_WARN,
|
|
NULL,
|
|
FullTargetFilename,
|
|
InfDirectory
|
|
);
|
|
}
|
|
}
|
|
|
|
if (no_copy) {
|
|
//
|
|
// we determined that we're not going to backup, and we've now done logging items
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
}
|
|
|
|
//
|
|
// does source really exist?
|
|
//
|
|
if ((attr=GetFileAttributes(FullTargetFilename))!=(DWORD)(-1)) {
|
|
source_exists = TRUE;
|
|
if (Flags & SP_LKG_FLAG_DELETEEXISTING) {
|
|
write_delete = TRUE;
|
|
}
|
|
} else if (Flags & SP_LKG_FLAG_DELETEIFNEW) {
|
|
write_delete = TRUE;
|
|
} else {
|
|
//
|
|
// we're done
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
}
|
|
//
|
|
// remap to LKG directory
|
|
//
|
|
RelativeFilename = FullTargetFilename+wd_len; // includes preceeding backslash
|
|
rf_len = tf_len-wd_len;
|
|
MYASSERT((MAX_PATH+(lkgd_len-wd_len))<=SIZECHARS(BackupTargetFilename));
|
|
lstrcpy(BackupTargetFilename,LastGoodDirectory);
|
|
lstrcpy(BackupTargetFilename+lkgd_len,RelativeFilename);
|
|
|
|
//
|
|
// does backup already exist?
|
|
//
|
|
if ((attr=GetFileAttributes(BackupTargetFilename))!=(DWORD)(-1)) {
|
|
//
|
|
// if it does, nothing useful to do.
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
}
|
|
|
|
//
|
|
// create intermediate directories as needed
|
|
//
|
|
pSetupMakeSurePathExists(BackupTargetFilename);
|
|
|
|
//
|
|
// we need to use a temporary file first, and then move it into place
|
|
// so we don't get in the situation where we write a bad file, reboot
|
|
// and decide to use LKG.
|
|
//
|
|
if(GetTempFileName(LastGoodDirectory, TEXT("TMP"), 0, TempFilename) == 0 ) {
|
|
//
|
|
// if this fails, it could be because we haven't got right permissions
|
|
// non-fatal
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
}
|
|
//
|
|
// after this point, aborts require cleaning up of temporary file
|
|
//
|
|
|
|
if (write_delete) {
|
|
//
|
|
// GetTempFileName created an empty place holder
|
|
// ensure it has right attributes
|
|
// before moving into place
|
|
//
|
|
SetFileAttributes(TempFilename,FILE_ATTRIBUTE_HIDDEN);
|
|
} else {
|
|
//
|
|
// copy original to this temporary file
|
|
// apply apropriate permissions
|
|
//
|
|
if(!CopyFile(FullTargetFilename, TempFilename ,FALSE)) {
|
|
//
|
|
// copy failed - non fatal
|
|
//
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
//
|
|
// we have a temporary file ready to be moved into place
|
|
// move it to final name, ensuring that while we were doing above, a new file
|
|
// was not already written
|
|
//
|
|
if(!MoveFileEx(TempFilename,BackupTargetFilename,MOVEFILE_WRITE_THROUGH)) {
|
|
//
|
|
// could be that a file with that name now exists, but didn't earlier
|
|
// oh well, clean up the mess and leave gracefully
|
|
//
|
|
goto cleanup;
|
|
}
|
|
|
|
if (write_delete) {
|
|
//
|
|
// if we successfully wrote an empty placeholder for a file to be deleted, we need to shadow this file with
|
|
// an entry in registry
|
|
//
|
|
regres = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_LASTGOOD,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hKeyLastGood,
|
|
&disposition);
|
|
if (regres == NO_ERROR) {
|
|
//
|
|
// copy string, remapping slash's from '\\' to '/'
|
|
//
|
|
CharPtr = RelativeFilename+1; // after initial '\'
|
|
DestPtr = RegName;
|
|
while(*CharPtr) {
|
|
PCTSTR Next = _tcschr(CharPtr,TEXT('\\'));
|
|
if (!Next) {
|
|
Next = CharPtr + lstrlen(CharPtr);
|
|
}
|
|
if(Next-CharPtr) {
|
|
CopyMemory(DestPtr,CharPtr,(Next-CharPtr)*sizeof(TCHAR));
|
|
DestPtr+=(Next-CharPtr);
|
|
CharPtr = Next;
|
|
}
|
|
if (*CharPtr == TEXT('\\')) {
|
|
*DestPtr = TEXT('/');
|
|
DestPtr++;
|
|
CharPtr++;
|
|
}
|
|
}
|
|
*DestPtr = TEXT('\0');
|
|
|
|
//
|
|
// write key, name = modified relative path, value = flags
|
|
//
|
|
LastGoodFlags = LASTGOOD_OPERATION_DELETE;
|
|
regres = RegSetValueEx(hKeyLastGood,
|
|
RegName,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&LastGoodFlags,
|
|
sizeof(LastGoodFlags));
|
|
RegCloseKey(hKeyLastGood);
|
|
}
|
|
}
|
|
|
|
//
|
|
// ok, now we've populated the LKG directory with this file
|
|
//
|
|
if (is_inf) {
|
|
//
|
|
// if we backed up an INF that's in primary INF directory, we should also backup existing PNF
|
|
// if we're writing an entry to delete INF, we'll always write an entry to delete PNF
|
|
//
|
|
MYASSERT(ExtPart);
|
|
lstrcpy(ExtPart,TEXT(".PNF"));
|
|
if(pSetupDoLastKnownGoodBackup(NULL,
|
|
FullTargetFilename,
|
|
SP_LKG_FLAG_FORCECOPY|SP_LKG_FLAG_DELETEIFNEW|(write_delete?SP_LKG_FLAG_DELETEEXISTING:0),
|
|
LogContext) != NO_ERROR) {
|
|
//
|
|
// should never fail
|
|
//
|
|
MYASSERT(FALSE);
|
|
}
|
|
}
|
|
//
|
|
// done!
|
|
//
|
|
rval = NO_ERROR;
|
|
goto final;
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// cleanup in the case where we've already created temporary file
|
|
//
|
|
SetFileAttributes(TempFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(TempFilename);
|
|
|
|
rval = NO_ERROR;
|
|
|
|
final:
|
|
if(LocalLogContext) {
|
|
DeleteLogContext(LocalLogContext);
|
|
}
|
|
return rval;
|
|
|
|
#else
|
|
//
|
|
// ANSI - not supported
|
|
//
|
|
return NO_ERROR;
|
|
#endif
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
BOOL
|
|
pSetupRestoreLastKnownGoodFile(
|
|
IN PCTSTR TargetFilename,
|
|
IN DWORD Flags,
|
|
IN PSETUP_LOG_CONTEXT LogContext OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Restore a single LKG file
|
|
The assumption here is that if this API was called, we detected something
|
|
really bad that needs to be fixed immediately
|
|
|
|
Arguments:
|
|
|
|
TargetFilename Name of file to restore
|
|
Flags
|
|
|
|
LogContext If specified, provides preferred logging context
|
|
|
|
Return Value:
|
|
|
|
TRUE if file was successfully restored
|
|
|
|
--*/
|
|
{
|
|
int wd_len; // windows directory len
|
|
int tf_len; // target file len
|
|
int lkgd_len; // last known good directory len
|
|
int rf_len; // relative file len (including preceeding slash)
|
|
TCHAR FullTargetFilename[MAX_PATH];
|
|
TCHAR BackupTargetFilename[MAX_PATH+14];
|
|
TCHAR TempFilename[MAX_PATH];
|
|
TCHAR TempPathname[MAX_PATH];
|
|
TCHAR RegName[MAX_PATH];
|
|
PCTSTR RelativeFilename;
|
|
PTSTR NamePart = NULL;
|
|
BOOL rflag = FALSE;
|
|
PSETUP_LOG_CONTEXT LocalLogContext = NULL;
|
|
LONG regres;
|
|
HKEY hKeyLastGood;
|
|
PCTSTR CharPtr;
|
|
PTSTR DestPtr;
|
|
DWORD RegType;
|
|
DWORD RegSize;
|
|
DWORD LastGoodFlags = 0;
|
|
|
|
if (!LogContext) {
|
|
//
|
|
// LogContext may be obmitted if there's a Queue parameter
|
|
//
|
|
if(CreateLogContext(NULL,TRUE,&LocalLogContext)==NO_ERROR) {
|
|
LogContext = LocalLogContext;
|
|
}
|
|
MYASSERT(LogContext);
|
|
}
|
|
|
|
//
|
|
// cannonicalize the Target name so user doesn't do stuff like .../TEMP/../INF
|
|
//
|
|
tf_len = (int)GetFullPathName(TargetFilename,
|
|
MAX_PATH,
|
|
FullTargetFilename,
|
|
&NamePart);
|
|
if (tf_len <= 0 || tf_len > MAX_PATH) {
|
|
//
|
|
// we don't do large paths very well
|
|
//
|
|
goto final;
|
|
}
|
|
wd_len = lstrlen(WindowsDirectory);
|
|
lkgd_len = lstrlen(LastGoodDirectory);
|
|
|
|
//
|
|
// see if this file is nested below <<WindowsDirectory>>
|
|
// note that such a file must be at least two characters longer
|
|
//
|
|
if((tf_len <= wd_len)
|
|
|| (FullTargetFilename[wd_len] != TEXT('\\'))
|
|
|| (_tcsnicmp(WindowsDirectory,FullTargetFilename,wd_len)!=0)) {
|
|
//
|
|
// this file is outside of %windir%, not handled by LKG
|
|
//
|
|
goto final;
|
|
}
|
|
|
|
//
|
|
// remap to LKG directory
|
|
//
|
|
RelativeFilename = FullTargetFilename+wd_len; // includes preceeding backslash
|
|
rf_len = tf_len-wd_len;
|
|
MYASSERT((MAX_PATH+(lkgd_len-wd_len))<=SIZECHARS(BackupTargetFilename));
|
|
lstrcpy(BackupTargetFilename,LastGoodDirectory);
|
|
lstrcpy(BackupTargetFilename+lkgd_len,RelativeFilename);
|
|
|
|
//
|
|
// does backup already exist?
|
|
//
|
|
if (GetFileAttributes(BackupTargetFilename)==(DWORD)(-1)) {
|
|
//
|
|
// if not, nothing we can do
|
|
//
|
|
goto final;
|
|
}
|
|
//
|
|
// find LKG flags to see what we need to do
|
|
//
|
|
regres = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_LASTGOOD,
|
|
0,
|
|
KEY_READ,
|
|
&hKeyLastGood);
|
|
if (regres == NO_ERROR) {
|
|
//
|
|
// copy string, remapping slash's from '\\' to '/'
|
|
//
|
|
CharPtr = RelativeFilename+1; // after initial '\'
|
|
DestPtr = RegName;
|
|
while(*CharPtr) {
|
|
PCTSTR Next = _tcschr(CharPtr,TEXT('\\'));
|
|
if (!Next) {
|
|
Next = CharPtr + lstrlen(CharPtr);
|
|
}
|
|
if(Next-CharPtr) {
|
|
CopyMemory(DestPtr,CharPtr,(Next-CharPtr)*sizeof(TCHAR));
|
|
DestPtr+=(Next-CharPtr);
|
|
CharPtr = Next;
|
|
}
|
|
if (*CharPtr == TEXT('\\')) {
|
|
*DestPtr = TEXT('/');
|
|
DestPtr++;
|
|
CharPtr++;
|
|
}
|
|
}
|
|
*DestPtr = TEXT('\0');
|
|
|
|
RegSize = sizeof(LastGoodFlags);
|
|
regres = RegQueryValueEx(hKeyLastGood,
|
|
RegName,
|
|
NULL,
|
|
&RegType,
|
|
(PBYTE)&LastGoodFlags,
|
|
&RegSize);
|
|
if((regres != NO_ERROR)
|
|
|| (RegType != REG_DWORD)
|
|
|| (RegSize != sizeof(DWORD))) {
|
|
//
|
|
// default action is copy
|
|
//
|
|
LastGoodFlags = 0;
|
|
}
|
|
RegCloseKey(hKeyLastGood);
|
|
}
|
|
|
|
//
|
|
// base directory of target file
|
|
//
|
|
lstrcpyn(TempPathname, FullTargetFilename, MAX_PATH);
|
|
*((PTSTR)pSetupGetFileTitle(TempPathname)) = TEXT('\0');
|
|
|
|
if (LastGoodFlags & LASTGOOD_OPERATION_DELETE) {
|
|
//
|
|
// delete
|
|
//
|
|
if(GetFileAttributes(FullTargetFilename)==(DWORD)(-1)) {
|
|
//
|
|
// already deleted
|
|
//
|
|
rflag = TRUE;
|
|
goto final;
|
|
}
|
|
|
|
pSetupExemptFileFromProtection(
|
|
FullTargetFilename,
|
|
SFC_ACTION_ADDED | SFC_ACTION_REMOVED | SFC_ACTION_MODIFIED
|
|
| SFC_ACTION_RENAMED_OLD_NAME |SFC_ACTION_RENAMED_NEW_NAME,
|
|
LogContext,
|
|
NULL
|
|
);
|
|
//
|
|
// try the simple way first
|
|
//
|
|
SetFileAttributes(FullTargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
if(!DeleteFile(FullTargetFilename)) {
|
|
//
|
|
// can't delete target directly
|
|
//
|
|
if(!GetTempFileName(TempPathname, TEXT("SETP"), 0, BackupTargetFilename)) {
|
|
//
|
|
// can't create backup temp, nothing we can do
|
|
//
|
|
goto final;
|
|
}
|
|
//
|
|
// move existing file into a temp backup
|
|
//
|
|
if(!MoveFileEx(FullTargetFilename,BackupTargetFilename,MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH)) {
|
|
//
|
|
// this failed too for some reason
|
|
//
|
|
SetFileAttributes(BackupTargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(BackupTargetFilename);
|
|
goto final;
|
|
}
|
|
//
|
|
// now do something with the bad file
|
|
// we don't care if this fails
|
|
//
|
|
SetFileAttributes(BackupTargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
if(!DeleteFile(BackupTargetFilename)) {
|
|
MoveFileEx(BackupTargetFilename,NULL,MOVEFILE_DELAY_UNTIL_REBOOT);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// restore back to LKG file
|
|
//
|
|
|
|
//
|
|
// create intermediate directories as needed as part of the restore
|
|
//
|
|
pSetupMakeSurePathExists(FullTargetFilename);
|
|
|
|
//
|
|
// create a temporary filename to copy to
|
|
// before moving restored file into place
|
|
//
|
|
if(!GetTempFileName(TempPathname, TEXT("SETP"), 0, TempFilename)) {
|
|
//
|
|
// can't create temp, nothing we can do
|
|
//
|
|
goto final;
|
|
}
|
|
if(!CopyFile(BackupTargetFilename,TempFilename,FALSE)) {
|
|
//
|
|
// failed to copy to temporary file
|
|
//
|
|
DeleteFile(TempFilename);
|
|
goto final;
|
|
}
|
|
//
|
|
// simple case, move temporary file over existing file
|
|
//
|
|
pSetupExemptFileFromProtection(
|
|
FullTargetFilename,
|
|
SFC_ACTION_ADDED | SFC_ACTION_REMOVED | SFC_ACTION_MODIFIED
|
|
| SFC_ACTION_RENAMED_OLD_NAME |SFC_ACTION_RENAMED_NEW_NAME,
|
|
LogContext,
|
|
NULL
|
|
);
|
|
SetFileAttributes(FullTargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
if(!MoveFileEx(TempFilename,FullTargetFilename,MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH)) {
|
|
//
|
|
// we failed to overwrite file, need slightly different stratagy
|
|
//
|
|
if(!GetTempFileName(TempPathname, TEXT("SETP"), 0, BackupTargetFilename)) {
|
|
//
|
|
// can't create backup temp, nothing we can do
|
|
//
|
|
SetFileAttributes(TempFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(TempFilename);
|
|
goto final;
|
|
}
|
|
//
|
|
// move existing file into a temp backup
|
|
//
|
|
if(!MoveFileEx(FullTargetFilename,BackupTargetFilename,MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH)) {
|
|
//
|
|
// this failed too for some reason
|
|
//
|
|
SetFileAttributes(BackupTargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(BackupTargetFilename);
|
|
SetFileAttributes(TempFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(TempFilename);
|
|
goto final;
|
|
}
|
|
//
|
|
// we moved existing file out of place, now move new file into place
|
|
//
|
|
if(!MoveFileEx(TempFilename,FullTargetFilename,MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH)) {
|
|
//
|
|
// huh? Ok, that failed, try to recover
|
|
//
|
|
MoveFileEx(BackupTargetFilename,FullTargetFilename,MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH);
|
|
SetFileAttributes(TempFilename, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(TempFilename);
|
|
goto final;
|
|
}
|
|
//
|
|
// now do something with the bad file
|
|
// we don't care if this fails
|
|
//
|
|
SetFileAttributes(BackupTargetFilename, FILE_ATTRIBUTE_NORMAL);
|
|
if(!DeleteFile(BackupTargetFilename)) {
|
|
MoveFileEx(BackupTargetFilename,NULL,MOVEFILE_DELAY_UNTIL_REBOOT);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// done!
|
|
//
|
|
rflag = TRUE;
|
|
|
|
final:
|
|
if(LocalLogContext) {
|
|
DeleteLogContext(LocalLogContext);
|
|
}
|
|
return rflag;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef UNICODE
|
|
WINSETUPAPI
|
|
BOOL
|
|
WINAPI
|
|
SetupPrepareQueueForRestoreA(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN PCSTR BackupPath,
|
|
IN DWORD RestoreFlags
|
|
)
|
|
/*++
|
|
|
|
See SetupPrepareQueueForRestore
|
|
|
|
--*/
|
|
{
|
|
BOOL f;
|
|
DWORD rc;
|
|
PCWSTR UnicodeBackupPath;
|
|
|
|
if(BackupPath) {
|
|
rc = pSetupCaptureAndConvertAnsiArg(BackupPath, &UnicodeBackupPath);
|
|
if(rc != NO_ERROR) {
|
|
SetLastError(rc);
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
f = SetupPrepareQueueForRestore(QueueHandle,UnicodeBackupPath,RestoreFlags);
|
|
rc = GetLastError();
|
|
MyFree(UnicodeBackupPath);
|
|
SetLastError(rc);
|
|
return f;
|
|
}
|
|
|
|
#else
|
|
|
|
WINSETUPAPI
|
|
BOOL
|
|
WINAPI
|
|
SetupPrepareQueueForRestoreW(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN PCWSTR BackupPath,
|
|
IN DWORD RestoreFlags
|
|
)
|
|
/*++
|
|
|
|
ANSI stub
|
|
|
|
--*/
|
|
{
|
|
UNREFERENCED_PARAMETER(QueueHandle);
|
|
UNREFERENCED_PARAMETER(BackupPath);
|
|
UNREFERENCED_PARAMETER(RestoreFlags);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(FALSE);
|
|
}
|
|
|
|
#endif
|
|
|
|
WINSETUPAPI
|
|
BOOL
|
|
WINAPI
|
|
SetupPrepareQueueForRestore(
|
|
IN HSPFILEQ QueueHandle,
|
|
IN PCTSTR BackupPath,
|
|
IN DWORD RestoreFlags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes restore directory
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - file queue to modify
|
|
BackupPath - original backup directory to use for restore
|
|
RestoreFlags - options
|
|
|
|
Return Value:
|
|
|
|
TRUE if success, else FALSE
|
|
|
|
--*/
|
|
{
|
|
BOOL b = TRUE;
|
|
DWORD rc;
|
|
BOOL f = FALSE;
|
|
PSP_FILE_QUEUE Queue = (PSP_FILE_QUEUE)QueueHandle;
|
|
LONG RestorePathID;
|
|
|
|
//
|
|
// validate string pointer
|
|
//
|
|
if(!BackupPath) {
|
|
rc = ERROR_INVALID_PARAMETER;
|
|
goto clean;
|
|
}
|
|
//
|
|
// validate flags (currently not implemented)
|
|
//
|
|
if(RestoreFlags) {
|
|
rc = ERROR_INVALID_PARAMETER;
|
|
goto clean;
|
|
}
|
|
//
|
|
// validate QueueHandle
|
|
//
|
|
try {
|
|
if(Queue->Signature != SP_FILE_QUEUE_SIG) {
|
|
b = FALSE;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
b = FALSE;
|
|
}
|
|
if(!b) {
|
|
rc = ERROR_INVALID_HANDLE;
|
|
goto clean;
|
|
}
|
|
|
|
try {
|
|
//
|
|
// if a restore point has previously been set, return error
|
|
//
|
|
if(Queue->RestorePathID != -1) {
|
|
rc = ERROR_ALREADY_EXISTS;
|
|
leave;
|
|
}
|
|
RestorePathID = pSetupStringTableAddString(Queue->StringTable,
|
|
(PTSTR)BackupPath ,
|
|
STRTAB_CASE_SENSITIVE);
|
|
if (RestorePathID == -1) {
|
|
rc = ERROR_NOT_ENOUGH_MEMORY;
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// done - just need to set the restore-path
|
|
//
|
|
Queue->RestorePathID = RestorePathID;
|
|
|
|
WriteLogEntry(Queue->LogContext,
|
|
SETUP_LOG_WARNING,
|
|
MSG_LOG_RESTORE,
|
|
NULL,
|
|
BackupPath
|
|
);
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
rc = ERROR_INVALID_DATA;
|
|
}
|
|
|
|
f = TRUE;
|
|
rc = NO_ERROR;
|
|
clean:
|
|
//
|
|
// no cleanup required
|
|
//
|
|
SetLastError(rc);
|
|
return f;
|
|
}
|
|
|
|
|
|
#define SP_TEFLG_BITS_TO_RESET ( SP_TEFLG_SAVED \
|
|
| SP_TEFLG_TEMPNAME \
|
|
| SP_TEFLG_ORIGNAME \
|
|
| SP_TEFLG_MODIFIED \
|
|
| SP_TEFLG_MOVED \
|
|
| SP_TEFLG_BACKUPQUEUE \
|
|
| SP_TEFLG_RESTORED \
|
|
| SP_TEFLG_UNWIND \
|
|
| SP_TEFLG_SKIPPED \
|
|
| SP_TEFLG_INUSE \
|
|
| SP_TEFLG_RENAMEEXISTING )
|
|
|
|
BOOL
|
|
pSetupResetTarget(
|
|
IN PVOID StringTable,
|
|
IN LONG StringId,
|
|
IN PCTSTR String, OPTIONAL
|
|
IN PVOID ExtraData,
|
|
IN UINT ExtraDataSize,
|
|
IN LPARAM lParam
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine resets the SP_TARGET_ENT data stored with a string table entry
|
|
in a file queue's TargetLookupTable. This routine may be used as the
|
|
callback function to iterate such entries via pSetupStringTableEnum.
|
|
|
|
Arguments:
|
|
|
|
StringTable - Supplies a handle to the string table being enumerated
|
|
|
|
StringId - Supplies the ID of the current string
|
|
|
|
String - Optionally, supplies a pointer to the current string (this will
|
|
always be filled in when this routine is used as a callback for
|
|
pSetupStringTableEnum, but other callers may omit it, as it isn't
|
|
needed).
|
|
|
|
ExtraData - Supplies a pointer to the SP_TARGET_ENT data associatd with
|
|
the string
|
|
|
|
ExtraDataSize - Supplies the size of the buffer pointed to by ExtraData--
|
|
should always be sizeof(SP_TARGET_ENT)
|
|
|
|
lParam - unused
|
|
|
|
Return Value:
|
|
|
|
This routine always returns TRUE, so that all string entries will be
|
|
enumerated.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSP_TARGET_ENT TargetInfo;
|
|
BOOL b;
|
|
|
|
UNREFERENCED_PARAMETER(String);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
MYASSERT(ExtraData);
|
|
MYASSERT(ExtraDataSize == sizeof(SP_TARGET_ENT));
|
|
|
|
//
|
|
// Clear the bits that will get re-generated when the queue is committed
|
|
// again.
|
|
//
|
|
((PSP_TARGET_ENT)ExtraData)->InternalFlags &= ~SP_TEFLG_BITS_TO_RESET;
|
|
|
|
//
|
|
// Also need to reset the NewTargetFilename
|
|
//
|
|
((PSP_TARGET_ENT)ExtraData)->NewTargetFilename = -1;
|
|
|
|
//
|
|
// Store the modified data back to the string table entry
|
|
//
|
|
b = pSetupStringTableSetExtraData(StringTable,
|
|
StringId,
|
|
ExtraData,
|
|
ExtraDataSize
|
|
);
|
|
//
|
|
// This should never fail
|
|
//
|
|
MYASSERT(b);
|
|
|
|
return TRUE;
|
|
}
|
|
|