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.
1413 lines
40 KiB
1413 lines
40 KiB
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include "sxs.h"
|
|
|
|
BOOL ForceNTFSConversion;
|
|
|
|
ULONG
|
|
CheckRegKeyVolatility (
|
|
IN HKEY Root,
|
|
IN LPCTSTR KeyPath
|
|
)
|
|
|
|
{
|
|
HKEY Key;
|
|
HKEY TestKey;
|
|
ULONG Error;
|
|
PTSTR TestKeyName = TEXT( "$winnt32$_test" );
|
|
DWORD Disposition;
|
|
|
|
Error = RegOpenKeyEx( Root,
|
|
KeyPath,
|
|
0,
|
|
MAXIMUM_ALLOWED,
|
|
&Key );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
return ( Error );
|
|
|
|
}
|
|
|
|
Error = RegCreateKeyEx( Key,
|
|
TestKeyName,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
MAXIMUM_ALLOWED,
|
|
NULL,
|
|
&TestKey,
|
|
&Disposition );
|
|
|
|
if( Error == ERROR_SUCCESS ) {
|
|
RegCloseKey( TestKey );
|
|
RegDeleteKey( Key, TestKeyName );
|
|
}
|
|
RegCloseKey( Key );
|
|
return( Error );
|
|
}
|
|
|
|
|
|
ULONG
|
|
DumpRegKeyToInf(
|
|
IN PINFFILEGEN InfContext,
|
|
IN HKEY PredefinedKey,
|
|
IN LPCTSTR FullKeyPath,
|
|
IN BOOL DumpIfEmpty,
|
|
IN BOOL DumpSubKeys,
|
|
IN BOOL SetNoClobberFlag,
|
|
IN BOOL DumpIfVolatileKey
|
|
)
|
|
{
|
|
HKEY Key;
|
|
ULONG Error;
|
|
TCHAR SubKeyName[ MAX_PATH + 1 ];
|
|
ULONG SubKeyNameLength;
|
|
ULONG cSubKeys;
|
|
ULONG cValues;
|
|
ULONG MaxValueNameLength;
|
|
ULONG MaxValueLength;
|
|
LPTSTR ValueName;
|
|
PBYTE ValueData;
|
|
ULONG i;
|
|
LPTSTR SubKeyFullPath;
|
|
ULONG MaxSubKeyNameLength;
|
|
|
|
//
|
|
// Open the key for read access
|
|
//
|
|
Error = RegOpenKeyEx( PredefinedKey,
|
|
FullKeyPath,
|
|
0,
|
|
KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
|
|
&Key );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
//
|
|
// If the key doesn't exist, than assume it got dumped.
|
|
//
|
|
return( ( Error == ERROR_PATH_NOT_FOUND )? ERROR_SUCCESS : Error );
|
|
}
|
|
|
|
//
|
|
// Find out if the key is empty (has no subkeys, and no values)
|
|
//
|
|
Error = RegQueryInfoKey( Key,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&cSubKeys,
|
|
&MaxSubKeyNameLength, //There is a bug before build 3612 where this value may be wrong for HKEY_LOCAL_MACHINE\SYSTEM\ControlSet002
|
|
NULL,
|
|
&cValues,
|
|
&MaxValueNameLength,
|
|
&MaxValueLength,
|
|
NULL,
|
|
NULL );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
RegCloseKey( Key );
|
|
return( Error );
|
|
}
|
|
|
|
if( !DumpIfEmpty && (cSubKeys == 0) && (cValues == 0) ) {
|
|
RegCloseKey( Key );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
if( !DumpIfVolatileKey ) {
|
|
//
|
|
// If we are not supposed to dump volatile keys, then check if the key is volatile.
|
|
//
|
|
Error = CheckRegKeyVolatility ( PredefinedKey,
|
|
FullKeyPath );
|
|
if( Error == ERROR_CHILD_MUST_BE_VOLATILE ) {
|
|
//
|
|
// The key is volatile, so skip it.
|
|
//
|
|
RegCloseKey( Key );
|
|
return( ERROR_SUCCESS );
|
|
} else if( Error != ERROR_SUCCESS ) {
|
|
//
|
|
// We don't knlw if the key is volatile or non-volatile.
|
|
RegCloseKey( Key );
|
|
return( Error );
|
|
}
|
|
}
|
|
|
|
|
|
Error = InfRecordAddReg( InfContext,
|
|
PredefinedKey,
|
|
FullKeyPath,
|
|
NULL,
|
|
REG_NONE,
|
|
NULL,
|
|
0,
|
|
SetNoClobberFlag );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
RegCloseKey( Key );
|
|
return( Error );
|
|
}
|
|
|
|
|
|
if( cValues != 0 ) {
|
|
ValueName = (LPTSTR)MALLOC( (MaxValueNameLength + 1)*sizeof(TCHAR) );
|
|
if( !ValueName ) {
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
ValueData = (PBYTE)MALLOC( MaxValueLength );
|
|
if( !ValueData ) {
|
|
FREE( ValueName );
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
//
|
|
// Dump the value entries
|
|
//
|
|
for( i = 0; i < cValues; i++ ) {
|
|
ULONG ValueNameLength;
|
|
ULONG ValueType;
|
|
ULONG DataSize;
|
|
|
|
ValueNameLength = MaxValueNameLength + 1;
|
|
DataSize = MaxValueLength;
|
|
Error = RegEnumValue( Key, // handle of key to query
|
|
i,
|
|
ValueName,
|
|
&ValueNameLength,
|
|
NULL,
|
|
&ValueType,
|
|
ValueData,
|
|
&DataSize );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
break;
|
|
}
|
|
|
|
Error = InfRecordAddReg( InfContext,
|
|
PredefinedKey,
|
|
FullKeyPath,
|
|
ValueName,
|
|
ValueType,
|
|
ValueData,
|
|
DataSize,
|
|
SetNoClobberFlag );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
FREE( ValueName );
|
|
FREE( ValueData );
|
|
if( Error != ERROR_SUCCESS ) {
|
|
RegCloseKey( Key );
|
|
return( Error );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check if subkeys neeed to be dumped
|
|
//
|
|
if( !DumpSubKeys || (cSubKeys == 0) ) {
|
|
RegCloseKey( Key );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
//
|
|
// Dump the subkeys
|
|
//
|
|
SubKeyFullPath = (LPTSTR)MALLOC( (lstrlen(FullKeyPath) + 1 + MaxSubKeyNameLength + 1)*sizeof(TCHAR) );
|
|
if( SubKeyFullPath == NULL ) {
|
|
RegCloseKey( Key );
|
|
return( ERROR_NOT_ENOUGH_MEMORY );
|
|
}
|
|
|
|
for( i = 0; i < cSubKeys; i++ ) {
|
|
SubKeyNameLength = sizeof( SubKeyName )/sizeof( TCHAR );
|
|
|
|
Error = RegEnumKeyEx( Key,
|
|
i,
|
|
SubKeyName,
|
|
&SubKeyNameLength,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL );
|
|
if( Error != ERROR_SUCCESS ) {
|
|
break;
|
|
}
|
|
|
|
//These 3 operations are safe, since the max size of SubKeyFullPath is calculated above
|
|
lstrcpy( SubKeyFullPath, FullKeyPath );
|
|
lstrcat( SubKeyFullPath, TEXT("\\") );
|
|
lstrcat( SubKeyFullPath, SubKeyName );
|
|
Error = DumpRegKeyToInf( InfContext,
|
|
PredefinedKey,
|
|
SubKeyFullPath,
|
|
DumpIfEmpty,
|
|
DumpSubKeys,
|
|
SetNoClobberFlag,
|
|
DumpIfVolatileKey);
|
|
if( Error != ERROR_SUCCESS ) {
|
|
break;
|
|
}
|
|
}
|
|
FREE( SubKeyFullPath );
|
|
RegCloseKey( Key );
|
|
return( Error );
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
GetAndSaveNTFTInfo(
|
|
IN HWND ParentWindow
|
|
)
|
|
{
|
|
static BOOL Done = FALSE;
|
|
HKEY Key;
|
|
DWORD d;
|
|
LONG l;
|
|
TCHAR HiveName[MAX_PATH];
|
|
PINFFILEGEN InfContext;
|
|
|
|
LONG i;
|
|
LPTSTR KeysToMigrate[] = {
|
|
TEXT("SYSTEM\\DISK"),
|
|
TEXT("SYSTEM\\MountedDevices")
|
|
};
|
|
|
|
|
|
if(Done) {
|
|
return(TRUE);
|
|
}
|
|
|
|
Done = TRUE;
|
|
|
|
//
|
|
// Before we migrate the disk information, make the drive letters sticky.
|
|
// This will ensure that the drive letters assigned during textmode setup
|
|
// are consistent with the drive letters in the current system.
|
|
//
|
|
ForceStickyDriveLetters();
|
|
|
|
//
|
|
// Load up the setupreg.hiv hive.
|
|
//
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
if(Floppyless) {
|
|
lstrcpy(HiveName,LocalBootDirectory);
|
|
} else {
|
|
HiveName[0] = FirstFloppyDriveLetter;
|
|
HiveName[1] = TEXT(':');
|
|
HiveName[2] = 0;
|
|
}
|
|
#endif
|
|
} else {
|
|
//These are both size MAX_PATH tchars
|
|
lstrcpy(HiveName,LocalSourceWithPlatform);
|
|
}
|
|
|
|
l = InfStart( WINNT_MIGRATE_INF_FILE,
|
|
HiveName,
|
|
&InfContext);
|
|
|
|
if(l != NO_ERROR) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_CANT_SAVE_FT_INFO,
|
|
l,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
l = InfCreateSection( TEXT("Addreg"), &InfContext );
|
|
if(l != NO_ERROR) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_CANT_SAVE_FT_INFO,
|
|
l,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Dump each key to MIGRATE.INF.
|
|
//
|
|
for( i = 0; i < sizeof(KeysToMigrate)/sizeof(LPTSTR); i++ ) {
|
|
//
|
|
// Check if the key exists
|
|
//
|
|
l = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
KeysToMigrate[i],
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&Key
|
|
);
|
|
|
|
if(l != NO_ERROR) {
|
|
if( l == ERROR_FILE_NOT_FOUND ) {
|
|
//
|
|
// The key does not exist.
|
|
// This is OK, just continue the migration of other keys
|
|
//
|
|
continue;
|
|
} else {
|
|
//
|
|
// The key exists but we cannot read it
|
|
//
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_CANT_SAVE_FT_INFO,
|
|
l,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
InfEnd( &InfContext );
|
|
return(FALSE);
|
|
}
|
|
}
|
|
RegCloseKey( Key );
|
|
//
|
|
// The key exists, so go ahead and dump it.
|
|
//
|
|
l = DumpRegKeyToInf( InfContext,
|
|
HKEY_LOCAL_MACHINE,
|
|
KeysToMigrate[i],
|
|
FALSE,
|
|
FALSE,
|
|
FALSE,
|
|
TRUE );
|
|
|
|
if(l != NO_ERROR) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_CANT_SAVE_FT_INFO,
|
|
l,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
|
|
InfEnd( &InfContext );
|
|
return(FALSE);
|
|
}
|
|
}
|
|
InfEnd( &InfContext );
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOL
|
|
ForceBootFilesUncompressed(
|
|
IN HWND ParentWindow,
|
|
IN BOOL TellUserAboutError
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine ensures that critical boot files (ntldr and $ldr$ on amd64/x86)
|
|
are uncompressed. On ARC we also make sure setupldr is uncompressed,
|
|
even though this is not strictly necessary since the system partition
|
|
is always supposed to be FAT, just in case.
|
|
|
|
Arguments:
|
|
|
|
ParentWindow - supplies window handle for window to act as parent/owner of
|
|
any ui windows this routine may display
|
|
|
|
TellUserAboutError - if TRUE and and an error occurs, the user will get
|
|
an error message. Otherwise the routine does not tell the user
|
|
about errors.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether relevent files were processed
|
|
successfully.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Filename[MAX_PATH];
|
|
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
//
|
|
// For remote boot, the loader is on the server, so we don't need to
|
|
// worry about whether it's compressed.
|
|
//
|
|
if (RemoteBoot) {
|
|
return(TRUE);
|
|
}
|
|
#endif // defined(REMOTE_BOOT)
|
|
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
//
|
|
// File is NTLDR on BIOS, but don't do this unless we're
|
|
// dealing with the floppyless case.
|
|
//
|
|
if(!MakeBootMedia || !Floppyless) {
|
|
return(TRUE);
|
|
}
|
|
BuildSystemPartitionPathToFile (TEXT("NTLDR"), Filename, MAX_PATH);
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
BuildSystemPartitionPathToFile (SETUPLDR_FILENAME, Filename, MAX_PATH);
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
|
|
if(!ForceFileNoCompress(Filename)) {
|
|
if(TellUserAboutError) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
Filename
|
|
);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Also do $LDR$
|
|
//
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
BuildSystemPartitionPathToFile (AUX_BS_NAME, Filename, MAX_PATH);
|
|
if(!ForceFileNoCompress(Filename)) {
|
|
if(TellUserAboutError) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
Filename
|
|
);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} // if (!IsArc())
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL
|
|
InDriverCacheInf(
|
|
IN PVOID InfHandle,
|
|
IN PCTSTR FileName,
|
|
OUT PTSTR DriverCabName, OPTIONAL
|
|
IN DWORD BufferChars OPTIONAL
|
|
)
|
|
{
|
|
PCTSTR SectionName;
|
|
UINT i;
|
|
|
|
|
|
if( !InfHandle ) {
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Now get the section names that we have to search.
|
|
//
|
|
i = 0;
|
|
SectionName = InfGetFieldByKey (
|
|
InfHandle,
|
|
TEXT("Version"),
|
|
TEXT("CabFiles"),
|
|
i);
|
|
|
|
|
|
if (SectionName) {
|
|
|
|
|
|
//
|
|
// Search the sections for our entry.
|
|
//
|
|
do {
|
|
|
|
if( InfDoesEntryExistInSection(InfHandle, SectionName, FileName)){
|
|
if (DriverCabName) {
|
|
//
|
|
// fill out the parameter
|
|
//
|
|
PCTSTR p = InfGetFieldByKey (
|
|
InfHandle,
|
|
TEXT("Cabs"),
|
|
SectionName,
|
|
0
|
|
);
|
|
if (p) {
|
|
StringCchCopy (DriverCabName, BufferChars, p);
|
|
} else {
|
|
*DriverCabName = 0;
|
|
}
|
|
}
|
|
//
|
|
// we found a match
|
|
//
|
|
return(TRUE);
|
|
}
|
|
|
|
i++;
|
|
SectionName = InfGetFieldByKey (
|
|
InfHandle,
|
|
TEXT("Version"),
|
|
TEXT("CabFiles"),
|
|
i);
|
|
|
|
|
|
} while ( SectionName);
|
|
|
|
}
|
|
|
|
//
|
|
// If we get here, we didn't find a match.
|
|
//
|
|
return( FALSE );
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
CreatePrivateFilesInf(
|
|
IN PCTSTR PrivatesDirectory,
|
|
IN PCTSTR InfName)
|
|
{
|
|
|
|
TCHAR infPath[MAX_PATH];
|
|
TCHAR DriverInfName[MAX_PATH];
|
|
TCHAR Search[MAX_PATH];
|
|
WIN32_FIND_DATA CurrentFileInfo;
|
|
HANDLE CurrentFile;
|
|
PVOID InfHandle;
|
|
BOOL retval = FALSE;
|
|
DWORD d;
|
|
HANDLE hPrivateInfFile;
|
|
DWORD dontcare = 0;
|
|
PCSTR privates = "[Privates]\r\n";
|
|
|
|
StringCchCopy(infPath, ARRAYSIZE(infPath), LocalSourceWithPlatform);
|
|
if (!ConcatenatePaths( infPath, InfName, MAX_PATH)) {
|
|
goto e0;
|
|
}
|
|
|
|
StringCchCopy(Search, ARRAYSIZE(Search), PrivatesDirectory);
|
|
if (!ConcatenatePaths( Search, TEXT("*"), MAX_PATH)) {
|
|
goto e0;
|
|
}
|
|
|
|
StringCchCopy(DriverInfName, ARRAYSIZE(DriverInfName), NativeSourcePaths[0]);
|
|
if (!ConcatenatePaths( DriverInfName, DRVINDEX_INF, MAX_PATH)) {
|
|
goto e0;
|
|
}
|
|
|
|
CurrentFile = FindFirstFile(Search,&CurrentFileInfo);
|
|
|
|
if (CurrentFile == INVALID_HANDLE_VALUE) {
|
|
goto e0;
|
|
}
|
|
|
|
d = LoadInfFile( DriverInfName, FALSE, &InfHandle );
|
|
|
|
if (d != NO_ERROR) {
|
|
goto e1;
|
|
}
|
|
|
|
WritePrivateProfileString(TEXT("Version"),
|
|
TEXT("Signature"),
|
|
TEXT("\"$Windows NT$\""),
|
|
infPath);
|
|
|
|
#if defined(_X86_)
|
|
WritePrivateProfileString(
|
|
TEXT("DestinationDirs"),
|
|
TEXT("Privates"),
|
|
IsNEC98() ?
|
|
TEXT("10,\"Driver Cache\\nec98\"") :
|
|
TEXT("10,\"Driver Cache\\i386\""),
|
|
infPath
|
|
);
|
|
#elif defined(_AMD64_)
|
|
WritePrivateProfileString(
|
|
TEXT("DestinationDirs"),
|
|
TEXT("Privates"),
|
|
TEXT("10,\"Driver Cache\\amd64\""),
|
|
infPath
|
|
);
|
|
|
|
#elif defined(_IA64_)
|
|
WritePrivateProfileString(
|
|
TEXT("DestinationDirs"),
|
|
TEXT("Privates"),
|
|
TEXT("10,\"Driver Cache\\ia64\""),
|
|
infPath
|
|
);
|
|
#else
|
|
#error "No Target Architecture"
|
|
#endif
|
|
|
|
WritePrivateProfileString(TEXT("InstallSection"),
|
|
TEXT("CopyFiles"),
|
|
TEXT("Privates"),
|
|
infPath);
|
|
|
|
#ifndef UNICODE
|
|
WritePrivateProfileString (NULL, NULL, NULL, infPath);
|
|
#endif
|
|
|
|
//
|
|
// writeprivateprofilestring works for the above, but doesnt work for
|
|
// adding files to the section, so we have to do it manually...yuck!
|
|
//
|
|
hPrivateInfFile = CreateFile(
|
|
infPath,
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL
|
|
);
|
|
|
|
if (hPrivateInfFile == INVALID_HANDLE_VALUE) {
|
|
goto e2;
|
|
}
|
|
|
|
//
|
|
// seek to the end of the file so we don't overwrite everything we already
|
|
// put in there
|
|
//
|
|
SetFilePointer(hPrivateInfFile,0,0,FILE_END);
|
|
|
|
WriteFile(hPrivateInfFile,(LPCVOID)privates,lstrlenA(privates),&dontcare,NULL);
|
|
|
|
do {
|
|
if (InDriverCacheInf( InfHandle, CurrentFileInfo.cFileName, NULL, 0 )) {
|
|
CHAR AnsiFile[MAX_PATH+2]; //2 ==> CR, LF
|
|
DWORD Size;
|
|
DWORD Written;
|
|
|
|
#ifdef UNICODE
|
|
WideCharToMultiByte(
|
|
CP_ACP,
|
|
0,
|
|
CurrentFileInfo.cFileName,
|
|
-1,
|
|
AnsiFile,
|
|
sizeof(AnsiFile),
|
|
NULL,
|
|
NULL
|
|
);
|
|
#else
|
|
StringCbCopyA(AnsiFile,sizeof(AnsiFile),CurrentFileInfo.cFileName);
|
|
#endif
|
|
|
|
StringCbCatA(AnsiFile,sizeof(AnsiFile),"\r\n");
|
|
WriteFile(hPrivateInfFile,AnsiFile,lstrlenA(AnsiFile),&Written,NULL);
|
|
|
|
}
|
|
|
|
} while ( FindNextFile(CurrentFile,&CurrentFileInfo) );
|
|
|
|
CloseHandle(hPrivateInfFile);
|
|
|
|
retval = TRUE;
|
|
|
|
e2:
|
|
UnloadInfFile( InfHandle );
|
|
e1:
|
|
FindClose( CurrentFile );
|
|
e0:
|
|
return(retval);
|
|
}
|
|
|
|
|
|
DWORD
|
|
DoPostCopyingStuff(
|
|
IN PVOID ThreadParam
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine performs actions that are done after copying has been
|
|
finished. This includes
|
|
|
|
- amd64/X86 boot stuff (boot.ini, boot code, etc)
|
|
- Saving NTFT information into the setup hive
|
|
- Forcing ntldr or setupldr to be uncompressed
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
HANDLE ThreadHandle;
|
|
DWORD ThreadId;
|
|
BOOL b;
|
|
|
|
//
|
|
// Check to see if delta.cat was processed as a result of
|
|
// /m so that we can write the "includecatalog = delta.cat"
|
|
// to winnt.sif
|
|
//
|
|
|
|
if ((AlternateSourcePath[0] != UNICODE_NULL) && MakeLocalSource) {
|
|
TCHAR Buff[MAX_PATH];
|
|
LPCTSTR WinntSetupSection = WINNT_SETUPPARAMS;
|
|
|
|
//This is safe, since both buffers are of size MAX_PATH
|
|
lstrcpy( Buff, LocalSourceWithPlatform );
|
|
ConcatenatePaths( Buff, TEXT("delta.cat"), MAX_PATH);
|
|
|
|
|
|
if( FileExists(Buff,NULL) ){
|
|
|
|
// Write out entry into winnt.sif
|
|
|
|
WritePrivateProfileString(WinntSetupSection,WINNT_S_INCLUDECATALOG,TEXT("delta.cat"),ActualParamFile);
|
|
|
|
}
|
|
|
|
//
|
|
// also create an inf file for the files that were changed and copy it to the local source as well
|
|
//
|
|
CreatePrivateFilesInf(AlternateSourcePath, TEXT("delta.inf"));
|
|
|
|
}
|
|
|
|
#ifdef TEST_EXCEPTION
|
|
DoException( 4);
|
|
#endif
|
|
|
|
|
|
//
|
|
// ALWAYS do this, since the system might not boot otherwise.
|
|
//
|
|
if(b = ForceBootFilesUncompressed(ThreadParam,TRUE)) {
|
|
|
|
//
|
|
// In the BIOS case, lay boot code, munge boot.ini, etc.
|
|
//
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
if(MakeBootMedia && Floppyless) {
|
|
b = DoX86BootStuff(ThreadParam);
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} // if (!IsArc())
|
|
|
|
//
|
|
// In the NT case, also save off disk information into
|
|
// the tiny setup system hive. This is done on both clean
|
|
// install and upgrade case, so that drive letters can be
|
|
// preserved.
|
|
// Drive letters should not be migrated on OEM preinstall case
|
|
//
|
|
if(ISNT() && !OemPreinstall
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
&& MakeBootMedia
|
|
#endif
|
|
) {
|
|
if( !GetAndSaveNTFTInfo(ThreadParam) ) {
|
|
b = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
SXS_CHECK_LOCAL_SOURCE SxsCheckLocalSourceParameters = { 0 };
|
|
|
|
SxsCheckLocalSourceParameters.ParentWindow = ThreadParam;
|
|
if (!SxsCheckLocalSource(&SxsCheckLocalSourceParameters))
|
|
{
|
|
b = FALSE;
|
|
}
|
|
}
|
|
|
|
PostMessage(ThreadParam,WMX_I_AM_DONE,b,0);
|
|
return(b);
|
|
}
|
|
|
|
|
|
BOOL
|
|
IsNTFSConversionRecommended(
|
|
void
|
|
)
|
|
{
|
|
if (UnattendedOperation) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (TYPICAL() || !ISNT()) {
|
|
//
|
|
// NTFS conversion is not recommended
|
|
// for win9x upgrades or if the user chooses typical
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
if (NTFSConversionChanged) {
|
|
return ForceNTFSConversion;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
NTFSConvertWizPage(
|
|
IN HWND hdlg,
|
|
IN UINT msg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
PPAGE_RUNTIME_DATA WizPage = (PPAGE_RUNTIME_DATA)GetWindowLongPtr(hdlg,DWLP_USER);
|
|
static BOOL bPainted = FALSE;
|
|
|
|
|
|
switch(msg) {
|
|
case WM_INITDIALOG:
|
|
if (!UnattendedOperation) {
|
|
CheckRadioButton( hdlg, IDOK, IDCANCEL, IsNTFSConversionRecommended() ? IDOK : IDCANCEL );
|
|
if (TYPICAL())
|
|
{
|
|
ForceNTFSConversion = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_CTLCOLORDLG:
|
|
bPainted = TRUE;
|
|
return FALSE;
|
|
|
|
case WMX_ACTIVATEPAGE:
|
|
|
|
if(wParam) {
|
|
HCURSOR OldCursor;
|
|
MSG msgTemp;
|
|
TCHAR buf[MAX_PATH];
|
|
|
|
//
|
|
// don't activate the page in restart mode
|
|
//
|
|
if (Winnt32RestartedWithAF ()) {
|
|
if (GetPrivateProfileString(
|
|
WINNT_UNATTENDED,
|
|
TEXT("ForceNTFSConversion"),
|
|
TEXT(""),
|
|
buf,
|
|
sizeof(buf) / sizeof(TCHAR),
|
|
g_DynUpdtStatus->RestartAnswerFile
|
|
)) {
|
|
ForceNTFSConversion = !lstrcmpi (buf, WINNT_A_YES);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// Scanning for drives can take a bit of time, so we lets change
|
|
// the cursor to let the user know this should take a while
|
|
OldCursor = SetCursor(LoadCursor (NULL, IDC_WAIT));
|
|
|
|
|
|
#ifdef _X86_
|
|
|
|
//
|
|
// Skip if this is a clean install from Win95 so that dual boot is safe
|
|
//
|
|
if( !Upgrade && !ISNT() ){
|
|
SetCursor(OldCursor);
|
|
return( FALSE );
|
|
}
|
|
|
|
|
|
//
|
|
// We will skip this wizard page if in Win9x upgrade and Boot16 option is ON.
|
|
//
|
|
if (Upgrade && !ISNT() && (g_Boot16 == BOOT16_YES)) {
|
|
SetCursor(OldCursor);
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// We may not want to display this page under
|
|
// certain circumstances.
|
|
//
|
|
if( ISNT() && Upgrade ) {
|
|
TCHAR Text[MAX_PATH];
|
|
//
|
|
// We're on NT and we know where the %windir%
|
|
// will be since we're doing an upgrade. Is
|
|
// it on a partition that's already NTFS? If so,
|
|
// don't bother with this page.
|
|
//
|
|
MyGetWindowsDirectory( Text, MAX_PATH );
|
|
if( IsDriveNTFS( Text[0] ) ) {
|
|
SetCursor(OldCursor);
|
|
return FALSE;
|
|
}
|
|
|
|
if (IsArc()) {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
//
|
|
// Let's also make sure we're not asking to
|
|
// upgrade the system partition on ARC (which
|
|
// must remain FAT).
|
|
//
|
|
MyGetWindowsDirectory( Text, MAX_PATH );
|
|
if( SystemPartitionDriveLetter == Text[0] ) {
|
|
SetCursor(OldCursor);
|
|
return FALSE;
|
|
}
|
|
#endif // UNICODE
|
|
} // if (IsArc())
|
|
}
|
|
|
|
|
|
//
|
|
// Last, but not least, disallow the page if all partitions
|
|
// are already NTFS...
|
|
//
|
|
if( ISNT() ) {
|
|
BOOL AllNTFS = TRUE;
|
|
TCHAR DriveLetter;
|
|
for( DriveLetter = TEXT('A'); DriveLetter <= TEXT('Z'); DriveLetter++ ) {
|
|
|
|
//
|
|
// Skip the system partition drive on ARC
|
|
//
|
|
if( (IsArc() && (DriveLetter != SystemPartitionDriveLetter)) || !IsArc() ) {
|
|
|
|
AllNTFS &= (
|
|
//
|
|
// Is the drive NTFS?
|
|
//
|
|
(IsDriveNTFS(DriveLetter)) ||
|
|
|
|
//
|
|
// If it's removable, don't even
|
|
// consider it because we can't
|
|
// install there anyway. This gets
|
|
// around the problem where the
|
|
// user has a CD in his CDROM drive
|
|
// or has a floppy in his floppy drive
|
|
// while we're doing this check.
|
|
//
|
|
(MyGetDriveType(DriveLetter) != DRIVE_FIXED) );
|
|
|
|
}
|
|
}
|
|
|
|
if( AllNTFS ) {
|
|
SetCursor(OldCursor);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Activation.
|
|
//
|
|
|
|
//
|
|
// WMX_VALIDATE will return TRUE if the page should be skipped,
|
|
// that is if we are in unattended mode and the parameters are OK.
|
|
//
|
|
|
|
if (CallWindowProc ((WNDPROC)NTFSConvertWizPage, hdlg, WMX_VALIDATE, 0, 0)) {
|
|
SetCursor(OldCursor);
|
|
return FALSE;
|
|
}
|
|
|
|
// if we get this far, we want to empty the message cue, to make sure
|
|
// that people will see this page, and not accidentally agree to
|
|
// converting their drives because they were antsy
|
|
|
|
while (PeekMessage(&msgTemp,NULL,WM_MOUSEFIRST,WM_MOUSELAST,PM_REMOVE));
|
|
while (PeekMessage(&msgTemp,NULL,WM_KEYFIRST,WM_KEYLAST,PM_REMOVE));
|
|
|
|
SetCursor(OldCursor);
|
|
}
|
|
return TRUE;
|
|
|
|
case WMX_VALIDATE:
|
|
//
|
|
// In the unattended case, this page might get reactivated because of an error,
|
|
// in which case we don't want to automatically continue because we could
|
|
// get into an infinite loop.
|
|
//
|
|
if(!WizPage->PerPageData) {
|
|
WizPage->PerPageData = 1;
|
|
if (((UnattendedOperation) && (!CancelPending)) ||
|
|
(NTFSConversionChanged && (!CancelPending)) ||
|
|
(TYPICAL() && (!CancelPending)) ) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (TYPICAL() && (!CancelPending))
|
|
{
|
|
// If WizPage->PerPageData == 1 we already ran through the above check.
|
|
// and in the typical case we don't show the NTFS conversion page.
|
|
// Anything wrong with the unattend value for NTFS would have been
|
|
// cought the first time.
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
case WMX_NEXTBUTTON:
|
|
// don't let the user choose next until we know the screen has been painted.
|
|
if (!bPainted){
|
|
// while we're here, empty the queue of mouse/key presses so we might not
|
|
// have to follow this path again.
|
|
MSG m;
|
|
while (PeekMessage(&m,NULL,WM_MOUSEFIRST,WM_MOUSELAST,PM_REMOVE));
|
|
while (PeekMessage(&m,NULL,WM_KEYFIRST,WM_KEYLAST,PM_REMOVE));
|
|
return FALSE;
|
|
}
|
|
if (IsDlgButtonChecked( hdlg, IDOK ) == BST_CHECKED) {
|
|
ForceNTFSConversion = TRUE;
|
|
} else {
|
|
ForceNTFSConversion = FALSE;
|
|
}
|
|
return TRUE;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
UINT
|
|
MyGetWindowsDirectory(
|
|
LPTSTR MyBuffer,
|
|
UINT Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get the windows directory in a terminal-server-aware fashion.
|
|
|
|
|
|
Arguments:
|
|
|
|
MyBuffer - Holds the return string.
|
|
|
|
Size - How big is the buffer?
|
|
|
|
Return Value:
|
|
|
|
length of the string we copied or 0 if there was an error or if the
|
|
supplied buffer wasn't big enough
|
|
|
|
--*/
|
|
{
|
|
HMODULE hModuleKernel32;
|
|
FARPROC MyProc;
|
|
UINT ReturnVal = 0;
|
|
|
|
#if defined(UNICODE)
|
|
if( ISNT() ) {
|
|
|
|
//
|
|
// We can't trust GetWindowsDirectory because Terminal Server may be
|
|
// installed, so use GetSystemWindowsDirectory.
|
|
//
|
|
if( hModuleKernel32 = LoadLibrary( TEXT("kernel32") ) ) {
|
|
if( MyProc = GetProcAddress(hModuleKernel32,"GetSystemWindowsDirectoryW")) {
|
|
ReturnVal = (UINT)MyProc( MyBuffer, Size );
|
|
}
|
|
FreeLibrary(hModuleKernel32);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if( ReturnVal == 0 ) {
|
|
ReturnVal = GetWindowsDirectory( MyBuffer, Size );
|
|
}
|
|
//
|
|
// no matter what, make sure the buffer is nul-terminated
|
|
//
|
|
if (Size > 0) {
|
|
MyBuffer[Size - 1] = 0;
|
|
}
|
|
|
|
return ReturnVal < Size ? ReturnVal : 0;
|
|
}
|
|
|
|
//
|
|
// Calc how fast setup can coyp files
|
|
//
|
|
#define BUFFER_SIZE 0x1000
|
|
DWORD dwThroughPutSrcToDest;
|
|
DWORD dwThroughPutHDToHD;
|
|
|
|
DWORD GetThroughput(LPTSTR Source, LPTSTR Dest)
|
|
{
|
|
BYTE buffer[BUFFER_SIZE];
|
|
HANDLE hFile = NULL;
|
|
HANDLE hFileOut = NULL;
|
|
DWORD bytes;
|
|
DWORD written;
|
|
DWORD size;
|
|
DWORD ticks;
|
|
ticks = GetTickCount();
|
|
|
|
hFile = CreateFile(Source,
|
|
GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
hFileOut = CreateFile(Dest,
|
|
GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
size = 0;
|
|
if ((hFile != INVALID_HANDLE_VALUE) && (hFileOut != INVALID_HANDLE_VALUE))
|
|
|
|
{
|
|
do
|
|
{
|
|
ReadFile(hFile, buffer, BUFFER_SIZE, &bytes, NULL);
|
|
if (hFileOut)
|
|
WriteFile(hFileOut, buffer, bytes, &written, NULL);
|
|
size += bytes;
|
|
} while (bytes == BUFFER_SIZE);
|
|
CloseHandle(hFile);
|
|
if (hFileOut)
|
|
{
|
|
FlushFileBuffers(hFileOut);
|
|
CloseHandle(hFileOut);
|
|
}
|
|
ticks = (GetTickCount() - ticks);
|
|
// If less then a second, assume 1 second.
|
|
if (ticks == 0)
|
|
{
|
|
ticks = 1;
|
|
}
|
|
|
|
ticks = (size/ticks);
|
|
}
|
|
else
|
|
{
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hFile);
|
|
if (hFileOut != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hFileOut);
|
|
// Failed to open/create one of the files. Assume a through put of 5KB/msec
|
|
ticks = DEFAULT_IO_THROUGHPUT;
|
|
}
|
|
return ticks;
|
|
}
|
|
|
|
// Copy txtsetup.sif from the sources to %windir%\$win_nt$.~ls
|
|
// and determine the throughput for this.
|
|
// Then copy txtsetup.sif in the local folder to testfile.000 and
|
|
// calc the throughput for that.
|
|
// Remove the folder.
|
|
void CalcThroughput()
|
|
{
|
|
TCHAR SrcFolder[MAX_PATH];
|
|
TCHAR DestFolder[MAX_PATH];
|
|
TCHAR Folder[MAX_PATH];
|
|
|
|
MyGetWindowsDirectory(Folder, sizeof(DestFolder)/sizeof(TCHAR));
|
|
// Only use the driver
|
|
Folder[3] = TEXT('\0');
|
|
ConcatenatePaths( Folder, LOCAL_SOURCE_DIR, MAX_PATH);
|
|
if (CreateMultiLevelDirectory(Folder) == NO_ERROR)
|
|
{
|
|
lstrcpy(DestFolder, Folder);
|
|
ConcatenatePaths( DestFolder, TEXTMODE_INF, MAX_PATH);
|
|
lstrcpy(SrcFolder, NativeSourcePaths[0]);
|
|
ConcatenatePaths( SrcFolder, TEXTMODE_INF, MAX_PATH);
|
|
dwThroughPutSrcToDest = GetThroughput(SrcFolder, DestFolder);
|
|
//
|
|
lstrcpy(SrcFolder, DestFolder);
|
|
lstrcpy(DestFolder, Folder);
|
|
ConcatenatePaths( DestFolder, TEXT("testfile.000"), MAX_PATH);
|
|
dwThroughPutHDToHD = GetThroughput(SrcFolder, DestFolder);
|
|
MyDelnode(Folder);
|
|
wsprintf(Folder, TEXT("SrcToDest: %d bytes/msec HDtoHD: %d bytes/msec"),dwThroughPutSrcToDest, dwThroughPutHDToHD);
|
|
DebugLog(Winnt32LogInformation,Folder,0 );
|
|
}
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
|
|
#define NB10_SIG ((DWORD)'01BN')
|
|
#define RSDS_SIG ((DWORD)'SDSR')
|
|
|
|
typedef struct _NB10I // NB10 debug info
|
|
{
|
|
DWORD dwSig; // NB10
|
|
DWORD dwOffset; // offset, always 0
|
|
ULONG sig;
|
|
ULONG age;
|
|
char szPdb[_MAX_PATH];
|
|
} NB10I, *PNB10I;
|
|
|
|
typedef struct _NB10I_HEADER // NB10 debug info
|
|
{
|
|
DWORD dwSig; // NB10
|
|
DWORD dwOffset; // offset, always 0
|
|
ULONG sig;
|
|
ULONG age;
|
|
} NB10IH, *PNB10IH;
|
|
|
|
typedef struct _RSDSI // RSDS debug info
|
|
{
|
|
DWORD dwSig; // RSDS
|
|
GUID guidSig;
|
|
DWORD age;
|
|
char szPdb[_MAX_PATH * 3];
|
|
} RSDSI, *PRSDSI;
|
|
|
|
typedef struct _RSDSI_HEADER // RSDS debug info
|
|
{
|
|
DWORD dwSig; // RSDS
|
|
GUID guidSig;
|
|
DWORD age;
|
|
} RSDSIH, *PRSDSIH;
|
|
|
|
typedef union _CVDD
|
|
{
|
|
DWORD dwSig;
|
|
NB10I nb10i;
|
|
RSDSI rsdsi;
|
|
NB10IH nb10ih;
|
|
RSDSIH rsdsih;
|
|
} CVDD, *PCVDD;
|
|
|
|
|
|
//BUGBUG -- what about c:\\myfile.txt. (with a trailing dot character)
|
|
BOOL
|
|
ExtractFileName(PCHAR pName, PCHAR pFileName, IN INT pCchFileName)
|
|
{
|
|
// Extract the name part of the filename.
|
|
PCHAR pStartName, pEndName;
|
|
pEndName = pName + strlen(pName);
|
|
while ((*pEndName != '.') && (pEndName != pName)) {
|
|
pEndName--;
|
|
}
|
|
|
|
if (pEndName == pName) {
|
|
return FALSE;
|
|
}
|
|
|
|
// String consist of just '.' or no periods at all?
|
|
if ((pEndName == pName) ||
|
|
((pEndName-1) == pName))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
pStartName = pEndName-1;
|
|
|
|
while ((*pStartName != '\\') && (pStartName != pName)) {
|
|
pStartName--;
|
|
}
|
|
|
|
// Found either the start of the string (filename.pdb) or the first backslash
|
|
// path\filename.pdb.
|
|
|
|
if (*pStartName == '\\')
|
|
pStartName++;
|
|
|
|
// Someone pass us \\.?
|
|
if (pStartName == pEndName) {
|
|
return FALSE;
|
|
}
|
|
|
|
CopyMemory(pFileName, pStartName, min (pEndName - pStartName, pCchFileName));
|
|
return TRUE;
|
|
}
|
|
|
|
CHAR HalName[_MAX_FNAME];
|
|
|
|
PCHAR
|
|
FindRealHalName(TCHAR *pHalFileName)
|
|
{
|
|
HINSTANCE hHal = NULL;
|
|
PIMAGE_DEBUG_DIRECTORY pDebugData;
|
|
DWORD DebugSize, i;
|
|
BOOL NameFound = FALSE;
|
|
|
|
__try {
|
|
hHal = LoadLibraryEx(pHalFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
|
|
if (!hHal) {
|
|
__leave;
|
|
}
|
|
|
|
pDebugData = RtlImageDirectoryEntryToData(hHal, FALSE, IMAGE_DIRECTORY_ENTRY_DEBUG, &DebugSize);
|
|
|
|
// verify we have debug data and it's a reasonable size.
|
|
if (!pDebugData ||
|
|
(DebugSize < sizeof(IMAGE_DEBUG_DIRECTORY)) ||
|
|
(DebugSize % sizeof(IMAGE_DEBUG_DIRECTORY)))
|
|
{
|
|
__leave;
|
|
}
|
|
|
|
ZeroMemory(HalName, sizeof(HalName));
|
|
|
|
// See if we have CV or MISC debug data.
|
|
for (i = 0; i < DebugSize/sizeof(IMAGE_DEBUG_DIRECTORY); i++) {
|
|
if (pDebugData->Type == IMAGE_DEBUG_TYPE_MISC) {
|
|
// Misc data.
|
|
PIMAGE_DEBUG_MISC pMisc = (PIMAGE_DEBUG_MISC)((PCHAR)(hHal) - 1 + pDebugData->AddressOfRawData);
|
|
PCHAR pName = pMisc->Data;
|
|
NameFound = ExtractFileName(pName, HalName, ARRAYSIZE(HalName));
|
|
__leave;
|
|
}
|
|
|
|
if (pDebugData->Type == IMAGE_DEBUG_TYPE_CODEVIEW) {
|
|
// got cv, see if it's nb10 (pdb) or rsds (v7 pdb)
|
|
PCVDD pCodeView = (PCVDD)((PCHAR)(hHal) - 1 + pDebugData->AddressOfRawData);
|
|
if (pCodeView->dwSig == NB10_SIG) {
|
|
NameFound = ExtractFileName(pCodeView->nb10i.szPdb, HalName, ARRAYSIZE(HalName));
|
|
__leave;
|
|
}
|
|
|
|
if (pCodeView->dwSig == RSDS_SIG) {
|
|
NameFound = ExtractFileName(pCodeView->rsdsi.szPdb, HalName, ARRAYSIZE(HalName));
|
|
__leave;
|
|
}
|
|
}
|
|
}
|
|
} __except(EXCEPTION_EXECUTE_HANDLER) { }
|
|
|
|
if (hHal) {
|
|
FreeLibrary(hHal);
|
|
}
|
|
|
|
if (NameFound) {
|
|
return HalName;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
#endif
|