able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/winnt32/dll/unsupdrv.c

1669 lines
42 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#define STRSAFE_NO_DEPRECATE
#include "strsafe.h"
#pragma hdrstop
#ifdef UNICODE
#define DRIVER_VALUE_ENTRY TEXT("Driver");
BOOL
IsServiceToBeDisabled(
IN PVOID NtCompatInfHandle,
IN LPTSTR ServiceName
)
{
PLIST_ENTRY Next;
PCOMPATIBILITY_DATA CompData;
BOOL serviceDisabled = FALSE;
//
// iterate through all compdata structures
//
Next = CompatibilityData.Flink;
if (Next) {
while ((ULONG_PTR)Next != (ULONG_PTR)&CompatibilityData) {
CompData = CONTAINING_RECORD(Next, COMPATIBILITY_DATA, ListEntry);
Next = CompData->ListEntry.Flink;
//
// now look for services that match our service name
//
if (CompData->Type == TEXT('s') && lstrcmpi (CompData->ServiceName, ServiceName) == 0) {
//
// make sure the service is marked to be disabled
//
if ((CompData->RegValDataSize == sizeof (DWORD)) &&
(*(PDWORD)CompData->RegValData == SERVICE_DISABLED)
) {
//
// we found it!
//
serviceDisabled = TRUE;
break;
}
}
}
}
return serviceDisabled;
}
BOOL
IsDriverCopyToBeSkipped(
IN PVOID NtCompatInfHandle,
IN LPTSTR ServiceName,
IN LPTSTR FilePath
)
{
LONG LineCount;
LONG i;
LPTSTR SectionName = TEXT("DriversToSkipCopy");
LPTSTR FileName;
BOOL DisableCopy;
if ((!NtCompatInfHandle) || (!FilePath)) {
MYASSERT(FALSE);
return TRUE;
}
FileName = _tcsrchr( FilePath, TEXT('\\') );
if (!FileName) {
FileName = FilePath;
}
else {
FileName++;
}
//
// Check if the driver is listed under [DriversToSkipCopy] in ntcompat.inf.
//
if( (LineCount = InfGetSectionLineCount( NtCompatInfHandle,
SectionName )) == -1 ) {
//
// section doesn't exist.
//
return( FALSE );
}
DisableCopy = FALSE;
for( i = 0; i < LineCount; i++ ) {
LPTSTR p;
p = (LPTSTR)InfGetFieldByIndex( NtCompatInfHandle,
SectionName,
i,
0 );
if( p && !lstrcmpi( p, FileName ) ) {
DisableCopy = TRUE;
break;
}
}
return( DisableCopy );
}
BOOL
LoadHwdbLib (
OUT HMODULE* HwdbLib,
OUT PHWDB_ENTRY_POINTS HwdbEntries
)
{
TCHAR pathSupportLib[MAX_PATH];
HMODULE hwdbLib;
DWORD rc;
if (!FindPathToWinnt32File (S_HWDB_DLL, pathSupportLib, MAX_PATH)) {
return FALSE;
}
hwdbLib = LoadLibraryEx (pathSupportLib, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
if (!hwdbLib) {
return FALSE;
}
HwdbEntries->HwdbInitialize = (PHWDBINITIALIZE) GetProcAddress (hwdbLib, S_HWDBAPI_HWDBINITIALIZE);
HwdbEntries->HwdbTerminate = (PHWDBTERMINATE) GetProcAddress (hwdbLib, S_HWDBAPI_HWDBTERMINATE);
HwdbEntries->HwdbOpen = (PHWDBOPEN) GetProcAddress (hwdbLib, S_HWDBAPI_HWDBOPEN);
HwdbEntries->HwdbClose = (PHWDBCLOSE) GetProcAddress (hwdbLib, S_HWDBAPI_HWDBCLOSE);
HwdbEntries->HwdbHasAnyDriver = (PHWDBHASANYDRIVER) GetProcAddress (hwdbLib, S_HWDBAPI_HWDBHASANYDRIVER);
if (!HwdbEntries->HwdbInitialize ||
!HwdbEntries->HwdbTerminate ||
!HwdbEntries->HwdbOpen ||
!HwdbEntries->HwdbClose ||
!HwdbEntries->HwdbHasAnyDriver
) {
ZeroMemory (HwdbEntries, sizeof (*HwdbEntries));
rc = GetLastError ();
FreeLibrary (hwdbLib);
SetLastError (rc);
return FALSE;
}
*HwdbLib = hwdbLib;
return TRUE;
}
BOOL
pAnyPnpIdSupported (
IN PCTSTR PnpIDs
)
{
HMODULE hwdbLib;
HANDLE hwdbDatabase;
HWDB_ENTRY_POINTS hwdbEntries;
TCHAR hwdbPath[MAX_PATH];
BOOL unsupported;
BOOL b = TRUE;
if (!FindPathToWinnt32File (S_HWCOMP_DAT, hwdbPath, MAX_PATH)) {
DynUpdtDebugLog (Winnt32LogWarning, TEXT("%1 not found"), 0, S_HWCOMP_DAT);
return b;
}
if (!LoadHwdbLib (&hwdbLib, &hwdbEntries)) {
DebugLog (
Winnt32LogWarning,
TEXT("LoadHwdbLib failed (rc=%u)"),
0,
GetLastError ()
);
return b;
}
if (hwdbEntries.HwdbInitialize (NULL)) {
hwdbDatabase = hwdbEntries.HwdbOpen (hwdbPath);
if (hwdbDatabase) {
b = hwdbEntries.HwdbHasAnyDriver (hwdbDatabase, PnpIDs, &unsupported);
hwdbEntries.HwdbClose (hwdbDatabase);
}
hwdbEntries.HwdbTerminate ();
}
FreeLibrary (hwdbLib);
return b;
}
PTSTR
pGetDevicePnpIDs (
IN PCTSTR DeviceRegKey
)
{
LONG rc;
HKEY deviceKey;
DWORD type;
DWORD size1, size2;
PTSTR pnpIds;
PTSTR p = NULL;
rc = RegOpenKeyEx (
HKEY_LOCAL_MACHINE,
DeviceRegKey,
0,
KEY_QUERY_VALUE,
&deviceKey
);
if (rc != ERROR_SUCCESS) {
DebugLog (
Winnt32LogWarning,
TEXT("Failed to open device key %s (rc=%u)"),
0,
DeviceRegKey,
rc
);
return p;
}
__try {
size1 = 0;
rc = RegQueryValueEx (
deviceKey,
TEXT("HardwareID"),
NULL,
&type,
NULL,
&size1
);
if (rc == ERROR_SUCCESS) {
if (type != REG_MULTI_SZ) {
size1 = 0;
DebugLog (
Winnt32LogWarning,
TEXT("Unexpected type of %s of %s (type=%u)"),
0,
TEXT("HardwareID"),
DeviceRegKey,
type
);
}
} else {
DebugLog (
Winnt32LogWarning,
TEXT("Couldn't find value %s of %s (rc=%u)"),
0,
TEXT("HardwareID"),
DeviceRegKey,
rc
);
}
size2 = 0;
rc = RegQueryValueEx (
deviceKey,
TEXT("CompatibleIDs"),
NULL,
&type,
NULL,
&size2
);
if (rc == ERROR_SUCCESS) {
if (type != REG_MULTI_SZ) {
size2 = 0;
DebugLog (
Winnt32LogWarning,
TEXT("Unexpected type of %s of %s (type=%u)"),
0,
TEXT("CompatibleIDs"),
DeviceRegKey,
type
);
}
} else {
DebugLog (
Winnt32LogWarning,
TEXT("Couldn't find value %s of %s (rc=%u)"),
0,
TEXT("CompatibleIDs"),
DeviceRegKey,
rc
);
}
if (size1 + size2 < sizeof (TCHAR)) {
DebugLog (
Winnt32LogWarning,
TEXT("Couldn't get list of PnpIDs for %s"),
0,
DeviceRegKey
);
__leave;
}
pnpIds = MALLOC (size1 + size2);
if (!pnpIds) {
__leave;
}
pnpIds[0] = 0;
p = pnpIds;
if (size1 >= sizeof (TCHAR)) {
rc = RegQueryValueEx (
deviceKey,
TEXT("HardwareID"),
NULL,
NULL,
(LPBYTE)pnpIds,
&size1
);
if (rc == ERROR_SUCCESS) {
pnpIds += size1 / sizeof (TCHAR) - 1;
}
}
if (size2 >= sizeof (TCHAR)) {
rc = RegQueryValueEx (
deviceKey,
TEXT("CompatibleIDs"),
NULL,
NULL,
(LPBYTE)pnpIds,
&size2
);
}
}
__finally {
RegCloseKey (deviceKey);
}
return p;
}
BOOL
pAllServicedDevicesSupported (
IN HKEY ServiceKey
)
{
LONG rc;
HKEY enumSubKey;
DWORD nextInstance;
DWORD instance;
TCHAR buf[20];
DWORD type;
DWORD size;
PTSTR enumSuffixStr;
HKEY deviceKey;
PTSTR deviceKeyStr;
PTSTR pnpIds;
BOOL unsupported;
BOOL b = TRUE;
rc = RegOpenKeyEx (
ServiceKey,
TEXT("Enum"),
0,
KEY_QUERY_VALUE,
&enumSubKey
);
if (rc != ERROR_SUCCESS) {
DebugLog (
Winnt32LogWarning,
TEXT("Failed to open Enum subkey (rc=%u)"),
0,
rc
);
return b;
}
__try {
size = sizeof (nextInstance);
rc = RegQueryValueEx (
enumSubKey,
TEXT("NextInstance"),
NULL,
&type,
(LPBYTE)&nextInstance,
&size
);
if (rc != ERROR_SUCCESS) {
DebugLog (
Winnt32LogWarning,
TEXT("Failed to open %s value (rc=%u)"),
0,
TEXT("NextInstance"),
rc
);
__leave;
}
if (type != REG_DWORD) {
DebugLog (
Winnt32LogWarning,
TEXT("Unexpected value type for %s (type=%u)"),
0,
TEXT("NextInstance"),
type
);
__leave;
}
for (instance = 0; b && instance < nextInstance; instance++) {
wsprintf (buf, TEXT("%lu"), instance);
rc = RegQueryValueEx (
enumSubKey,
buf,
NULL,
&type,
NULL,
&size
);
if (rc != ERROR_SUCCESS || type != REG_SZ) {
continue;
}
enumSuffixStr = MALLOC (size);
if (!enumSuffixStr) {
__leave;
}
rc = RegQueryValueEx (
enumSubKey,
buf,
NULL,
NULL,
(LPBYTE)enumSuffixStr,
&size
);
if (rc == ERROR_SUCCESS) {
size = sizeof ("SYSTEM\\CurrentControlSet\\Enum") + lstrlen (enumSuffixStr) + 1;
deviceKeyStr = MALLOC (size * sizeof (TCHAR));
if (!deviceKeyStr) {
__leave;
}
BuildPath2 (deviceKeyStr, size, TEXT("SYSTEM\\CurrentControlSet\\Enum"), enumSuffixStr);
pnpIds = pGetDevicePnpIDs (deviceKeyStr);
FREE (deviceKeyStr);
if (!pAnyPnpIdSupported (pnpIds)) {
b = FALSE;
}
FREE (pnpIds);
}
FREE (enumSuffixStr);
}
}
__finally {
RegCloseKey (enumSubKey);
}
return b;
}
BOOL
IsInfInLayoutInf(
IN PCTSTR InfPath
)
/*++
Routine Description:
Determine if an INF file is shiped in-box with the operating system.
This is acomplished by looking up the INF name in the [SourceDisksFiles]
section of layout.inf
Arguments:
InfPath - supplies name (may include path) of INF. No checking is done
to ensure INF lives in %windir%\Inf--this is caller's responsibility.
Return Value:
If TRUE, this is an in-box INF. If FALSE, it's not an in-box INF, this
could be an OEM<n>.INF or an inf illegaly copied into the INF directory.
--*/
{
BOOL bInBoxInf = FALSE;
HINF hInf = INVALID_HANDLE_VALUE;
UINT SourceId;
PCTSTR infFileName;
if (SetupapiGetSourceFileLocation) {
hInf = SetupapiOpenInfFile(TEXT("layout.inf"), NULL, INF_STYLE_WIN4, NULL);
if (hInf != INVALID_HANDLE_VALUE) {
infFileName = _tcsrchr(InfPath, TEXT('\\') );
if (infFileName) {
infFileName++;
} else {
infFileName = InfPath;
}
if(SetupapiGetSourceFileLocation(hInf,
NULL,
infFileName,
&SourceId,
NULL,
0,
NULL)) {
bInBoxInf = TRUE;
}
SetupapiCloseInfFile(hInf);
}
}
return bInBoxInf;
}
BOOL
pIsOEMService (
IN PCTSTR ServiceKeyName,
OUT PTSTR OemInfPath, OPTIONAL
IN INT BufferSize OPTIONAL
)
{
ULONG BufferLen = 0;
PTSTR Buffer = NULL;
PTSTR p;
DEVNODE DevNode;
CONFIGRET cr;
HKEY hKey;
TCHAR InfPath[MAX_PATH];
DWORD dwType, dwSize;
BOOL IsOemService = FALSE;
//
// See how larger of a buffer we need to hold the list of device
// instance Ids for this service.
//
cr = CM_Get_Device_ID_List_Size(&BufferLen,
ServiceKeyName,
CM_GETIDLIST_FILTER_SERVICE);
if (cr != CR_SUCCESS) {
//
// Encountered an error so just bail out.
//
goto clean0;
}
if (BufferLen == 0) {
//
// No devices are using this service, so just bail out.
//
goto clean0;
}
Buffer = MALLOC(BufferLen*sizeof(TCHAR));
if (Buffer == NULL) {
goto clean0;
}
//
// Get the list of device instance Ids for this service.
//
cr = CM_Get_Device_ID_List(ServiceKeyName,
Buffer,
BufferLen,
CM_GETIDLIST_FILTER_SERVICE | CM_GETIDLIST_DONOTGENERATE);
if (cr != CR_SUCCESS) {
//
// failed to get the list of devices for this service.
//
goto clean0;
}
//
// Enumerate through the list of devices using this service.
//
for (p = Buffer; !IsOemService && *p; p += (lstrlen(p) + 1)) {
//
// Get a DevNode from the device instance Id.
//
cr = CM_Locate_DevNode(&DevNode, p, 0);
if (cr != CR_SUCCESS) {
continue;
}
//
// Open the device's SOFTWARE key so we can get it's INF path.
//
cr = CM_Open_DevNode_Key(DevNode,
KEY_READ,
0,
RegDisposition_OpenExisting,
&hKey,
CM_REGISTRY_SOFTWARE);
if (cr != CR_SUCCESS) {
//
// Software key doesn't exist?
//
continue;
}
dwType = REG_SZ;
dwSize = sizeof(InfPath);
if (RegQueryValueEx(hKey,
REGSTR_VAL_INFPATH,
NULL,
&dwType,
(LPBYTE)InfPath,
&dwSize) != ERROR_SUCCESS) {
//
// If there is no InfPath in the SOFTWARE key then we don't know
// what INF this device is using.
//
RegCloseKey(hKey);
continue;
}
if (!IsInfInLayoutInf(InfPath)) {
IsOemService = TRUE;
if (OemInfPath) {
StringCchCopy (OemInfPath, BufferSize, InfPath);
}
}
RegCloseKey(hKey);
}
clean0:
if (Buffer) {
FREE(Buffer);
}
return IsOemService;
}
BOOL
IsDeviceSupported(
IN PVOID TxtsetupSifHandle,
IN HKEY ServiceKey,
IN LPTSTR ServiceKeyName,
OUT LPTSTR FileName
)
{
ULONG Error;
ULONG Type;
BYTE Buffer[ (MAX_PATH + 1)*sizeof(TCHAR) ];
PBYTE Data;
ULONG cbData;
BOOL b = TRUE;
LPTSTR DriverPath;
LPTSTR DriverName;
LONG LineCount;
LONG i;
BOOL DeviceSupported;
Data = Buffer;
cbData = sizeof( Buffer );
Error = RegQueryValueEx( ServiceKey,
TEXT("ImagePath"),
NULL,
&Type,
Data,
&cbData );
if( (Error == ERROR_PATH_NOT_FOUND) ||
(Error == ERROR_FILE_NOT_FOUND) ) {
//
// ImagePath does not exist.
// In this case the driver name is <service name>.sys
//
lstrcpy( (LPTSTR)( Data ), ServiceKeyName );
lstrcat( (LPTSTR)( Data ), TEXT(".sys") );
Error = ERROR_SUCCESS;
}
if( Error == ERROR_MORE_DATA ) {
Data = (PBYTE)MALLOC( cbData );
if( Data == NULL ) {
//
// We failed the malloc. Just assume the device
// isn't supported.
//
return( FALSE );
}
Error = RegQueryValueEx( ServiceKey,
TEXT("ImagePath"),
NULL,
&Type,
Data,
&cbData );
}
if( Error != ERROR_SUCCESS ) {
//
// We can' retrieve the drivers information.
// Assume that the device is supported
//
if( Data != Buffer ) {
FREE( Data );
}
return( TRUE );
}
DriverPath = (LPTSTR)Data;
DriverName = _tcsrchr( DriverPath, TEXT('\\') );
if( DriverName != NULL ) {
DriverName++;
} else {
DriverName = DriverPath;
}
//
// Search for the driver name on the following sections of txtsetup.sif:
// [SCSI.load]
//
if( (LineCount = InfGetSectionLineCount( TxtsetupSifHandle,
TEXT("SCSI.load") )) == -1 ) {
//
// We can't retrieve the drivers information.
// Assume that the device is supported
//
if( Data != Buffer ) {
FREE( Data );
}
return( TRUE );
}
DeviceSupported = FALSE;
for( i = 0; i < LineCount; i++ ) {
LPTSTR p;
p = (LPTSTR)InfGetFieldByIndex( TxtsetupSifHandle,
TEXT("SCSI.load"),
i,
0 );
if( p == NULL ) {
continue;
}
if( !lstrcmpi( p, DriverName ) ) {
DeviceSupported = TRUE;
break;
}
}
//
// NTBUG9: 603644
// OnW2K+, verify if there is inbox support for ALL devices
// currently supported by this driver
// If there's any that doesn't have support,
// then the OEM driver must be migrated
//
if (ISNT() && BuildNumber >= NT50 && DeviceSupported) {
if (pIsOEMService (ServiceKeyName, NULL, 0)) {
if (!pAllServicedDevicesSupported (ServiceKey)) {
DeviceSupported = FALSE;
}
}
}
#ifdef _X86_
//
// one more thing: check if this device is supplied by OEMs via answer file (NTBUG9: 306041)
//
if (!DeviceSupported) {
POEM_BOOT_FILE p;
for (p = OemBootFiles; p; p = p->Next) {
if (!lstrcmpi (p->Filename, DriverName)) {
DeviceSupported = TRUE;
break;
}
}
}
#endif
if( !DeviceSupported ) {
LPTSTR q;
CharLower( DriverPath );
q = _tcsstr( DriverPath, TEXT("system32") );
if( q == NULL ) {
lstrcpy( FileName, TEXT("system32\\drivers\\") );
lstrcat( FileName, DriverName );
} else {
lstrcpy( FileName, q );
}
}
if( Data != Buffer ) {
FREE( Data );
}
return( DeviceSupported );
}
VOID
FreeHardwareIdList(
IN PUNSUPORTED_PNP_HARDWARE_ID HardwareIdList
)
{
PUNSUPORTED_PNP_HARDWARE_ID p, q;
p = HardwareIdList;
while( p != NULL ) {
FREE( p->Id );
FREE( p->Service );
FREE( p->ClassGuid );
q = p->Next;
FREE( p );
p = q;
}
}
VOID
FreeFileInfoList(
IN PUNSUPORTED_DRIVER_FILE_INFO FileInfoList
)
{
PUNSUPORTED_DRIVER_FILE_INFO p, q;
p = FileInfoList;
while( p != NULL ) {
FREE( p->FileName );
FREE( p->TargetDirectory );
q = p->Next;
FREE( p );
p = q;
}
}
VOID
FreeRegistryInfoList(
IN PUNSUPORTED_DRIVER_REGKEY_INFO RegistryInfoList
)
{
PUNSUPORTED_DRIVER_REGKEY_INFO p, q;
p = RegistryInfoList;
while( p != NULL ) {
FREE( p->KeyPath );
q = p->Next;
FREE( p );
p = q;
}
}
BOOL
BuildHardwareIdInfo(
IN LPTSTR ServiceName,
OUT PUNSUPORTED_PNP_HARDWARE_ID* HardwareIdList
)
{
ULONG BufferLen;
DEVNODE DevNode;
PTSTR Buffer, Service, Id, HwId, DevId;
PBYTE Value;
ULONG ValueSize;
PUNSUPORTED_PNP_HARDWARE_ID TempList, Entry;
BOOL Result;
DWORD Type;
if (CM_Get_Device_ID_List_Size(&BufferLen,
ServiceName,
CM_GETIDLIST_FILTER_SERVICE
) != CR_SUCCESS ||
(BufferLen == 0)) {
return ( FALSE );
}
Result = TRUE;
Value = NULL;
TempList = NULL;
Buffer = MALLOC(BufferLen * sizeof(TCHAR));
if (Buffer == NULL) {
Result = FALSE;
goto Clean;
}
ValueSize = REGSTR_VAL_MAX_HCID_LEN * sizeof(TCHAR);
Value = MALLOC(ValueSize);
if (Value == NULL) {
Result = FALSE;
goto Clean;
}
if (CM_Get_Device_ID_List(ServiceName,
Buffer,
BufferLen,
CM_GETIDLIST_FILTER_SERVICE | CM_GETIDLIST_DONOTGENERATE
) != CR_SUCCESS) {
Result = FALSE;
goto Clean;
}
for (DevId = Buffer; *DevId; DevId += lstrlen(DevId) + 1) {
if (CM_Locate_DevNode(&DevNode, DevId, 0) == CR_SUCCESS) {
ValueSize = REGSTR_VAL_MAX_HCID_LEN * sizeof(TCHAR);
if (CM_Get_DevNode_Registry_Property(DevNode, CM_DRP_HARDWAREID, &Type, Value, &ValueSize, 0) == CR_SUCCESS &&
Type == REG_MULTI_SZ) {
for( HwId = (PTSTR)Value;
( (ULONG_PTR)HwId < (ULONG_PTR)(Value + ValueSize) ) && ( lstrlen( HwId ) );
HwId += lstrlen( HwId ) + 1 ) {
Entry = MALLOC( sizeof( UNSUPORTED_PNP_HARDWARE_ID ) );
Id = DupString( HwId );
Service = DupString( ServiceName );
if( (Entry == NULL) || (Id == NULL) || (Service == NULL) ) {
if( Entry != NULL ) {
FREE( Entry );
}
if( Id != NULL ) {
FREE( Id );
}
if( Service != NULL ) {
FREE( Service );
}
Result = FALSE;
goto Clean;
}
//
// Add the new entry to the front of the list.
//
Entry->Id = Id;
Entry->Service = Service;
Entry->ClassGuid = NULL;
Entry->Next = TempList;
TempList = Entry;
}
}
}
}
Clean:
if ( Buffer ) {
FREE( Buffer );
}
if ( Value ) {
FREE( Value );
}
if (Result == TRUE) {
*HardwareIdList = TempList;
} else if ( TempList ) {
FreeHardwareIdList( TempList );
}
return ( Result );
}
BOOL
BuildDriverFileInformation(
IN LPTSTR FilePath,
OUT PUNSUPORTED_DRIVER_FILE_INFO* FileInfo
)
{
TCHAR FullPath[ MAX_PATH + 1 ];
LPTSTR p, q, r;
PUNSUPORTED_DRIVER_FILE_INFO TempFileInfo = NULL;
*FileInfo = NULL;
lstrcpy( FullPath, FilePath );
p = _tcsrchr( FullPath, TEXT('\\') );
if(!p)
return FALSE;
*p = TEXT('\0');
p++;
q = DupString( FullPath );
r = DupString( p );
TempFileInfo = MALLOC( sizeof( UNSUPORTED_DRIVER_FILE_INFO ) );
if( ( q == NULL ) || ( r == NULL ) || ( TempFileInfo == NULL ) ) {
goto clean0;
}
TempFileInfo->Next = NULL;
TempFileInfo->FileName = r;
TempFileInfo->TargetDirectory = q;
*FileInfo = TempFileInfo;
return( TRUE );
clean0:
if( q != NULL ) {
FREE( q );
}
if( r != NULL ) {
FREE( r );
}
if( TempFileInfo != NULL ) {
FREE( TempFileInfo );
}
return( FALSE );
}
BOOL
BuildDriverRegistryInformation(
IN LPTSTR ServiceName,
OUT PUNSUPORTED_DRIVER_REGKEY_INFO* RegInfo
)
{
TCHAR KeyPath[ MAX_PATH + 1 ];
LPTSTR p;
PUNSUPORTED_DRIVER_REGKEY_INFO TempRegInfo = NULL;
*RegInfo = NULL;
lstrcpy( KeyPath, TEXT( "SYSTEM\\CurrentControlSet\\Services\\" ) );
lstrcat( KeyPath, ServiceName );
p = DupString( KeyPath );
TempRegInfo = MALLOC( sizeof( UNSUPORTED_DRIVER_REGKEY_INFO ) );
if( ( p == NULL ) || ( TempRegInfo == NULL ) ) {
goto clean0;
}
TempRegInfo->Next = NULL;
TempRegInfo->PredefinedKey = HKEY_LOCAL_MACHINE;
TempRegInfo->KeyPath = p;
TempRegInfo->MigrateVolatileKeys = FALSE;
*RegInfo = TempRegInfo;
return( TRUE );
clean0:
if( p != NULL ) {
FREE( p );
}
if( TempRegInfo != NULL ) {
FREE( TempRegInfo );
}
return( FALSE );
}
VOID
FreeDriverInformationList(
IN OUT PUNSUPORTED_DRIVER_INFO* DriverInfo
)
{
while( *DriverInfo != NULL ) {
PUNSUPORTED_DRIVER_INFO p;
p = *DriverInfo;
*DriverInfo = p->Next;
if( p->DriverId != NULL ) {
FREE( p->DriverId );
}
if( p->KeyList != NULL ) {
FreeRegistryInfoList( p->KeyList );
}
if( p->FileList != NULL ) {
FreeFileInfoList( p->FileList );
}
if( p-> HardwareIdsList != NULL ) {
FreeHardwareIdList( p-> HardwareIdsList );
}
FREE( p );
}
*DriverInfo = NULL;
}
BOOL
BuildDriverInformation(
IN HKEY ServiceKey,
IN LPTSTR ServiceName,
IN LPTSTR FilePath,
OUT PUNSUPORTED_DRIVER_INFO* DriverInfo
)
{
ULONG Error;
BOOL b1, b2, b3 = TRUE;
PUNSUPORTED_PNP_HARDWARE_ID TempIdInfo = NULL;
PUNSUPORTED_DRIVER_INFO TempFiltersInfo = NULL;
PUNSUPORTED_DRIVER_FILE_INFO TempFileInfo = NULL;
PUNSUPORTED_DRIVER_REGKEY_INFO TempRegInfo = NULL;
PUNSUPORTED_DRIVER_INFO TempDriverInfo = NULL;
*DriverInfo = NULL;
//
// Get hardware id info
//
b1 = BuildHardwareIdInfo( ServiceName,
&TempIdInfo );
//
// Then get the file information
//
b2 = BuildDriverFileInformation( FilePath,
&TempFileInfo );
//
// Then get the registry information
//
b3 = BuildDriverRegistryInformation( ServiceName,
&TempRegInfo );
if( !b1 || !b2 || !b3 ) {
goto cleanup1;
}
TempDriverInfo = MALLOC( sizeof( UNSUPORTED_DRIVER_INFO ) );
if( TempDriverInfo == NULL ) {
goto cleanup1;
}
TempDriverInfo->Next = NULL;
TempDriverInfo->DriverId = DupString( ServiceName );
TempDriverInfo->KeyList = TempRegInfo;
TempDriverInfo->FileList = TempFileInfo;
TempDriverInfo->HardwareIdsList = TempIdInfo;
TempDriverInfo->Next = *DriverInfo;
*DriverInfo = TempDriverInfo;
return( TRUE );
cleanup1:
if( TempIdInfo != NULL ) {
FreeHardwareIdList( TempIdInfo );
}
if( TempFileInfo != NULL ) {
FreeFileInfoList( TempFileInfo );
}
if( TempRegInfo != NULL ) {
FreeRegistryInfoList( TempRegInfo );
}
return( FALSE );
}
BOOL
BuildUnsupportedDriverList(
IN PVOID TxtsetupSifHandle,
OUT PUNSUPORTED_DRIVER_INFO* DriverList
)
{
ULONG Error;
HKEY ScsiKey;
ULONG SubKeys;
ULONG i;
LPTSTR szScsiPath = TEXT("HARDWARE\\DEVICEMAP\\Scsi");
*DriverList = NULL;
//
// Find out if there is a SCSI miniport driver on this machine.
//
Error = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
szScsiPath,
0,
KEY_READ,
&ScsiKey );
if( Error != ERROR_SUCCESS ) {
//
// Nothing to migrate
//
return( TRUE );
}
//
// Find out the number of subkeys under HKLM\HARDWARE\DEVICEMAP\Scsi.
//
Error = RegQueryInfoKey ( ScsiKey,
NULL,
NULL,
NULL,
&SubKeys,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL );
if( (Error != ERROR_SUCCESS) || (SubKeys == 0) ) {
//
// If we can't determine the number of subkeys, or if there is no
// subkey, then there is nothing to migrate, and we assume that all
// SCSI drivers are supported on NT.
//
RegCloseKey( ScsiKey );
return( TRUE );
}
//
// Each subkey of HKLM\HARDWARE\DEVICEMAP\Scsi points to a service that controls
// a SCSI device. We check each one of them to find out the ones that are controlled
// by a driver that is not on the NT product.
//
for( i = 0; i < SubKeys; i++ ) {
TCHAR SubKeyName[ MAX_PATH + 1 ];
TCHAR ServiceKeyPath[ MAX_PATH + 1 ];
ULONG Length;
FILETIME LastWriteTime;
HKEY Key;
BYTE Data[ 512 ];
ULONG DataSize;
ULONG Type;
PUNSUPORTED_DRIVER_INFO DriverInfo, p;
BOOL DeviceAlreadyFound;
TCHAR FilePath[ MAX_PATH + 1 ];
Length = sizeof( SubKeyName ) / sizeof( TCHAR );
Error = RegEnumKeyEx( ScsiKey,
i,
SubKeyName,
&Length,
NULL,
NULL,
NULL,
&LastWriteTime );
if( Error != ERROR_SUCCESS ) {
//
// Ignore this device and assume it is supported.
//
continue;
}
Error = RegOpenKeyEx( ScsiKey,
SubKeyName,
0,
KEY_READ,
&Key );
if( Error != ERROR_SUCCESS ) {
//
// Ignore this device and assume it is supported.
//
continue;
}
DataSize = sizeof( Data );
Error = RegQueryValueEx( Key,
TEXT("Driver"),
NULL,
&Type,
Data,
&DataSize );
if( Error != ERROR_SUCCESS ) {
//
// Ignore this device and assume it is supported.
//
RegCloseKey( Key );
continue;
}
RegCloseKey( Key );
//
// Find out if this device is supported on NT 5.0
//
lstrcpy( ServiceKeyPath, TEXT("SYSTEM\\CurrentControlSet\\Services\\" ) );
lstrcat( ServiceKeyPath, (LPTSTR)Data );
Error = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
ServiceKeyPath,
0,
KEY_READ,
&Key );
if( Error != ERROR_SUCCESS ) {
//
// Assume it is supported, since there is nothing else we can do here.
//
continue;
}
if( IsDeviceSupported( TxtsetupSifHandle,
Key,
(LPTSTR)Data,
FilePath
) ) {
RegCloseKey( Key );
continue;
}
//
// Find out if this device is already in our list
//
DeviceAlreadyFound = FALSE;
for( p = (PUNSUPORTED_DRIVER_INFO)*DriverList; p && !DeviceAlreadyFound; p = p->Next ) {
if( !lstrcmpi( p->DriverId, (LPTSTR)Data ) ) {
DeviceAlreadyFound = TRUE;
}
}
if( DeviceAlreadyFound ) {
RegCloseKey( Key );
continue;
}
//
// Find out if the device is listed in the section [ServicesToDisable] in dosnet.inf
//
if( IsServiceToBeDisabled( NtcompatInf,
(LPTSTR)Data ) ) {
RegCloseKey( Key );
continue;
}
//
// Find out if the file is listed in the [DriversToSkipCopy] section in
// ntcompat.inf.
//
if( IsDriverCopyToBeSkipped( NtcompatInf,
(LPTSTR)Data,
FilePath ) ) {
RegCloseKey( Key );
continue;
}
//
// The driver for this device is not supported and needs to be migrated.
//
DriverInfo = NULL;
if( !BuildDriverInformation( Key,
(LPTSTR)Data,
FilePath,
&DriverInfo ) ) {
//
// If we cannot build the driver information for this device, then
// we inform the user that we detected an unsupported device, but that
// we cannot migrate it. The user will have to provide the OEM disk
// for this device during setupldr or textmode setup phases.
//
RegCloseKey( Key );
FreeDriverInformationList( DriverList );
return( FALSE );
}
DriverInfo->Next = (PUNSUPORTED_DRIVER_INFO)*DriverList;
(PUNSUPORTED_DRIVER_INFO)*DriverList = DriverInfo;
RegCloseKey( Key );
}
RegCloseKey( ScsiKey );
return( TRUE );
}
DWORD
DumpRegInfoToInf(
IN PUNSUPORTED_DRIVER_REGKEY_INFO RegList,
IN LPTSTR DriverId,
IN PINFFILEGEN Context
)
{
LPTSTR SectionName;
DWORD Error;
LPTSTR szAddReg = TEXT("AddReg.");
PUNSUPORTED_DRIVER_REGKEY_INFO p;
Error = ERROR_SUCCESS;
SectionName = MALLOC( (lstrlen( szAddReg ) + lstrlen( DriverId ) + 1)*sizeof(TCHAR) );
if( SectionName == NULL ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto c0;
}
lstrcpy( SectionName, szAddReg );
lstrcat( SectionName, DriverId );
Error = InfCreateSection( SectionName, &Context );
for( p = RegList; p != NULL; p = p->Next ) {
#if 0
Error = DumpRegInfoToInfWorker( p->PredefinedKey,
p->KeyPath,
Context );
#endif
Error = DumpRegKeyToInf( Context,
p->PredefinedKey,
p->KeyPath,
TRUE,
TRUE,
TRUE,
p->MigrateVolatileKeys );
if( Error != ERROR_SUCCESS ) {
goto c0;
}
}
c0:
if( SectionName != NULL ) {
FREE( SectionName );
}
return( Error );
}
DWORD
DumpFileInfoToInf(
IN PUNSUPORTED_DRIVER_FILE_INFO FileList,
IN LPTSTR DriverId,
IN PINFFILEGEN Context
)
{
LPTSTR SectionName;
DWORD Error;
LPTSTR szFiles = TEXT("Files.");
PUNSUPORTED_DRIVER_FILE_INFO p;
TCHAR Line[ MAX_PATH ];
Error = ERROR_SUCCESS;
SectionName = MALLOC( (lstrlen( szFiles ) + lstrlen( DriverId ) + 1)*sizeof(TCHAR) );
if( SectionName == NULL ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto c0;
}
lstrcpy( SectionName, szFiles );
lstrcat( SectionName, DriverId );
Error = InfCreateSection( SectionName, &Context );
for( p = FileList; p != NULL; p = p->Next ) {
lstrcpy( Line, p->FileName );
lstrcat( Line, TEXT(",") );
lstrcat( Line, p->TargetDirectory );
Error = WriteText(Context->FileHandle,MSG_INF_SINGLELINE,Line);
if( Error != ERROR_SUCCESS ) {
goto c0;
}
}
c0:
if( SectionName != NULL ) {
FREE( SectionName );
}
return( Error );
}
DWORD
DumpHardwareIdsToInf(
IN PUNSUPORTED_PNP_HARDWARE_ID HwIdList,
IN LPTSTR DriverId,
IN PINFFILEGEN Context
)
{
LPTSTR SectionName;
DWORD Error;
LPTSTR szHardwareIds = TEXT("HardwareIds.");
PUNSUPORTED_PNP_HARDWARE_ID p;
LPTSTR Line;
ULONG Length;
Error = ERROR_SUCCESS;
SectionName = MALLOC( (lstrlen( szHardwareIds ) + lstrlen( DriverId ) + 1)*sizeof( TCHAR ) );
if( SectionName == NULL ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto c0;
}
lstrcpy( SectionName, szHardwareIds );
lstrcat( SectionName, DriverId );
Error = InfCreateSection( SectionName, &Context );
for( p = HwIdList; p != NULL; p = p->Next ) {
Length = (lstrlen( p->Id ) + lstrlen( p->Service ) + 3)*sizeof(TCHAR);
if( p->ClassGuid ) {
Length += (lstrlen( p->ClassGuid) + 1 )*sizeof(TCHAR);
}
Line = MALLOC( Length );
if( Line == NULL ) {
goto c0;
}
lstrcpy( Line, p->Id );
lstrcat( Line, TEXT("=") );
lstrcat( Line, p->Service );
if( p->ClassGuid ) {
lstrcat( Line, TEXT(",") );
lstrcat( Line, p->ClassGuid );
}
Error = WriteText(Context->FileHandle,MSG_INF_SINGLELINE,Line);
FREE( Line );
if( Error != ERROR_SUCCESS ) {
goto c0;
}
}
c0:
if( SectionName != NULL ) {
FREE( SectionName );
}
return( Error );
}
BOOL
SaveUnsupportedDriverInfo(
IN HWND ParentWindow,
IN LPTSTR FileName,
IN PUNSUPORTED_DRIVER_INFO DriverList
)
{
HKEY Key;
DWORD d;
LONG l = ERROR_SUCCESS;
TCHAR Path[MAX_PATH];
PINFFILEGEN InfContext;
TCHAR SectionName[MAX_PATH];
PUNSUPORTED_DRIVER_INFO p;
#ifdef _X86_
if(Floppyless) {
lstrcpy(Path,LocalBootDirectory);
} else {
Path[0] = FirstFloppyDriveLetter;
Path[1] = TEXT(':');
Path[2] = 0;
}
#else
lstrcpy(Path,LocalSourceWithPlatform);
#endif
l = InfStart( FileName,
Path,
&InfContext);
if(l != ERROR_SUCCESS) {
return(FALSE);
}
for( p = DriverList; p != NULL; p = p->Next ) {
if( p->KeyList != NULL ) {
l = DumpRegInfoToInf( p->KeyList,p->DriverId, InfContext );
if(l != ERROR_SUCCESS) {
goto c0;
}
}
if( p->FileList ) {
l = DumpFileInfoToInf( p->FileList, p->DriverId, InfContext );
if(l != ERROR_SUCCESS) {
goto c0;
}
}
if( p->HardwareIdsList ) {
l = DumpHardwareIdsToInf( p->HardwareIdsList, p->DriverId, InfContext );
if(l != ERROR_SUCCESS) {
goto c0;
}
}
}
if( DriverList != NULL ) {
l = InfCreateSection( TEXT("Devices"), &InfContext );
if(l != NO_ERROR) {
goto c0;
}
for( p = DriverList; p != NULL; p = p->Next ) {
l = WriteText(InfContext->FileHandle,MSG_INF_SINGLELINE,p->DriverId);
if(l != ERROR_SUCCESS) {
goto c0;
}
}
}
c0:
InfEnd( &InfContext );
if( l != ERROR_SUCCESS ) {
lstrcat( Path, TEXT("\\") );
lstrcat( Path, FileName );
DeleteFile( Path );
return( FALSE );
}
return(TRUE);
}
BOOL
MigrateUnsupportedNTDrivers(
IN HWND ParentWindow,
IN PVOID TxtsetupSifHandle
)
{
BOOL b;
PUNSUPORTED_DRIVER_INFO UnsupportedDriverList = NULL;
b = BuildUnsupportedDriverList( TxtsetupSif, &UnsupportedDriverList );
if( !CheckUpgradeOnly && b ) {
if( UnsupportedDriverList ) {
b = SaveUnsupportedDriverInfo( ParentWindow, WINNT_UNSUPDRV_INF_FILE, UnsupportedDriverList );
if( b ) {
b = AddUnsupportedFilesToCopyList( ParentWindow, UnsupportedDriverList );
if( !b ) {
TCHAR Path[ MAX_PATH + 1 ];
//
// If we failed to add the files to the copy list, then
// delete unsupdrv.inf since there is no point in migrating
// these drivers.
//
#ifdef _X86_
if(Floppyless) {
lstrcpy(Path,LocalBootDirectory);
} else {
Path[0] = FirstFloppyDriveLetter;
Path[1] = TEXT(':');
Path[2] = 0;
}
#else
lstrcpy(Path,LocalSourceWithPlatform);
#endif
lstrcat( Path, TEXT("\\") );
lstrcat( Path, WINNT_UNSUPDRV_INF_FILE );
DeleteFile( Path );
}
}
}
FreeDriverInformationList( &UnsupportedDriverList );
}
if( !b ) {
//
// Inform the user that unsupported drivers could not be migrated.
//
MessageBoxFromMessage( ParentWindow,
MSG_CANT_MIGRATE_UNSUP_DRIVERS,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
return( b );
}
#endif
Reference in a new issue Copy permalink