/*++ Copyright (c) 1993-2000 Microsoft Corporation Module Name: devreg.c Abstract: Device Installer routines for registry storage/retrieval. Author: Lonny McMichael (lonnym) 1-July-1995 Revision History: --*/ #include "precomp.h" #pragma hdrstop // // Private function prototypes // DWORD pSetupOpenOrCreateDevRegKey( IN PDEVICE_INFO_SET DeviceInfoSet, IN PDEVINFO_ELEM DevInfoElem, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN BOOL Create, IN REGSAM samDesired, OUT PHKEY hDevRegKey ); BOOL pSetupFindUniqueKey( IN HKEY hkRoot, IN LPTSTR SubKey, IN ULONG SubKeyLength ); DWORD pSetupOpenOrCreateInterfaceDeviceRegKey( IN HKEY hInterfaceClassKey, IN PDEVICE_INFO_SET DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA InterfaceDeviceData, IN BOOL Create, IN REGSAM samDesired, OUT PHKEY hInterfaceDeviceKey ); DWORD pSetupDeleteInterfaceDeviceKey( IN HKEY hInterfaceClassKey, IN PDEVICE_INFO_SET DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA InterfaceDeviceData ); HKEY WINAPI SetupDiOpenClassRegKey( IN CONST GUID *ClassGuid, OPTIONAL IN REGSAM samDesired ) /*++ Routine Description: This API opens the installer class registry key or a specific class installer's subkey. Arguments: ClassGuid - Optionally, supplies a pointer to the GUID of the class whose key is to be opened. If this parameter is NULL, then the root of the class tree will be opened. samDesired - Specifies the access you require for this key. Return Value: If the function succeeds, the return value is a handle to an opened registry key. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. Remarks: This API _will not_ create a registry key if it doesn't already exist. The handle returned from this API must be closed by calling RegCloseKey. To get at the interface class (DeviceClasses) branch, or to access the registry on a remote machine, use SetupDiOpenClassRegKeyEx. --*/ { return SetupDiOpenClassRegKeyEx(ClassGuid, samDesired, DIOCR_INSTALLER, NULL, NULL); } #ifdef UNICODE // // ANSI version // HKEY WINAPI SetupDiOpenClassRegKeyExA( IN CONST GUID *ClassGuid, OPTIONAL IN REGSAM samDesired, IN DWORD Flags, IN PCSTR MachineName, OPTIONAL IN PVOID Reserved ) { PCWSTR UnicodeMachineName; DWORD rc; HKEY hk; hk = INVALID_HANDLE_VALUE; if(MachineName) { rc = pSetupCaptureAndConvertAnsiArg(MachineName, &UnicodeMachineName); } else { UnicodeMachineName = NULL; rc = NO_ERROR; } if(rc == NO_ERROR) { hk = SetupDiOpenClassRegKeyExW(ClassGuid, samDesired, Flags, UnicodeMachineName, Reserved ); rc = GetLastError(); if(UnicodeMachineName) { MyFree(UnicodeMachineName); } } SetLastError(rc); return hk; } #else // // Unicode version // HKEY WINAPI SetupDiOpenClassRegKeyExW( IN CONST GUID *ClassGuid, OPTIONAL IN REGSAM samDesired, IN DWORD Flags, IN PCWSTR MachineName, OPTIONAL IN PVOID Reserved ) { UNREFERENCED_PARAMETER(ClassGuid); UNREFERENCED_PARAMETER(samDesired); UNREFERENCED_PARAMETER(Flags); UNREFERENCED_PARAMETER(MachineName); UNREFERENCED_PARAMETER(Reserved); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } #endif HKEY WINAPI SetupDiOpenClassRegKeyEx( IN CONST GUID *ClassGuid, OPTIONAL IN REGSAM samDesired, IN DWORD Flags, IN PCTSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ Routine Description: This API opens the root of either the installer or the interface class registry branch, or a specified class subkey under one of these branches. If the root key is requested, it will be created if not already present (i.e., you're always guaranteed to get a handle to the root unless a registry error occurs). If a particular class subkey is requested, it will be returned if present. Otherwise, this API will return ERROR_INVALID_CLASS. Arguments: ClassGuid - Optionally, supplies a pointer to the GUID of the class whose key is to be opened. If this parameter is NULL, then the root of the class tree will be opened. This GUID is either an installer class or an interface class depending on the Flags argument. samDesired - Specifies the access you require for this key. Flags - Specifies which registry branch the key is to be opened for. May be one of the following values: DIOCR_INSTALLER - Open the class installer (Class) branch. DIOCR_INTERFACE - Open the interface class (DeviceClasses) branch. MachineName - If specified, this value indicates the remote machine where the key is to be opened. Reserved - Reserved for future use--must be NULL. Return Value: If the function succeeds, the return value is a handle to an opened registry key. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. Remarks: The handle returned from this API must be closed by calling RegCloseKey. --*/ { HKEY hk; CONFIGRET cr; DWORD Err = NO_ERROR; HMACHINE hMachine = NULL; // // Make sure the user didn't pass us anything in the Reserved parameter. // if(Reserved) { SetLastError(ERROR_INVALID_PARAMETER); return INVALID_HANDLE_VALUE; } // // Validate the flags (really, just an enum for now, but treated as // flags for future extensibility). // if((Flags & ~(DIOCR_INSTALLER | DIOCR_INTERFACE)) || ((Flags != DIOCR_INSTALLER) && (Flags != DIOCR_INTERFACE))) { SetLastError(ERROR_INVALID_FLAGS); return INVALID_HANDLE_VALUE; } try { if(MachineName) { if(CR_SUCCESS != (cr = CM_Connect_Machine(MachineName, &hMachine))) { // // Make sure machine handle is still invalid, so we won't // try to disconnect later. // hMachine = NULL; Err = MapCrToSpError(cr, ERROR_INVALID_DATA); goto clean0; } } if((cr = CM_Open_Class_Key_Ex((LPGUID)ClassGuid, NULL, samDesired, ClassGuid ? RegDisposition_OpenExisting : RegDisposition_OpenAlways, &hk, (Flags & DIOCR_INSTALLER) ? CM_OPEN_CLASS_KEY_INSTALLER : CM_OPEN_CLASS_KEY_INTERFACE, hMachine)) != CR_SUCCESS) { if(cr == CR_NO_SUCH_REGISTRY_KEY) { Err = ERROR_INVALID_CLASS; } else { Err = MapCrToSpError(cr, ERROR_INVALID_DATA); } } clean0: ; // nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; // // Reference the following variable(s) so the compiler will respect our statement // ordering w.r.t. assignment. // hMachine = hMachine; } if(hMachine) { CM_Disconnect_Machine(hMachine); } SetLastError(Err); return (Err == NO_ERROR) ? hk : INVALID_HANDLE_VALUE; } #ifdef UNICODE // // ANSI version // HKEY WINAPI SetupDiCreateDevRegKeyA( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN HINF InfHandle, OPTIONAL IN PCSTR InfSectionName OPTIONAL ) { DWORD rc; PWSTR name; HKEY h; if(InfSectionName) { rc = pSetupCaptureAndConvertAnsiArg(InfSectionName,&name); if(rc != NO_ERROR) { SetLastError(rc); return(INVALID_HANDLE_VALUE); } } else { name = NULL; } h = SetupDiCreateDevRegKeyW( DeviceInfoSet, DeviceInfoData, Scope, HwProfile, KeyType, InfHandle, name ); rc = GetLastError(); if(name) { MyFree(name); } SetLastError(rc); return(h); } #else // // Unicode stub // HKEY WINAPI SetupDiCreateDevRegKeyW( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN HINF InfHandle, OPTIONAL IN PCWSTR InfSectionName OPTIONAL ) { UNREFERENCED_PARAMETER(DeviceInfoSet); UNREFERENCED_PARAMETER(DeviceInfoData); UNREFERENCED_PARAMETER(Scope); UNREFERENCED_PARAMETER(HwProfile); UNREFERENCED_PARAMETER(KeyType); UNREFERENCED_PARAMETER(InfHandle); UNREFERENCED_PARAMETER(InfSectionName); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(INVALID_HANDLE_VALUE); } #endif HKEY WINAPI SetupDiCreateDevRegKey( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN HINF InfHandle, OPTIONAL IN PCTSTR InfSectionName OPTIONAL ) /*++ Routine Description: This routine creates a registry storage key for device-specific configuration information, and returns a handle to the key. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing information about the device instance whose registry configuration storage key is to be created. DeviceInfoData - Supplies a pointer to a SP_DEVINFO_DATA structure indicating the device instance to create the registry key for. Scope - Specifies the scope of the registry key to be created. This determines where the information is actually stored--the key created may be one that is global (i.e., constant regardless of current hardware profile) or hardware profile-specific. May be one of the following values: DICS_FLAG_GLOBAL - Create a key to store global configuration information. DICS_FLAG_CONFIGSPECIFIC - Create a key to store hardware profile-specific information. HwProfile - Specifies the hardware profile to create a key for, if the Scope parameter is set to DICS_FLAG_CONFIGSPECIFIC. If this parameter is 0, then the key for the current hardware profile should be created (i.e., in the Class branch under HKEY_CURRENT_CONFIG). If Scope is DICS_FLAG_GLOBAL, then this parameter is ignored. KeyType - Specifies the type of registry storage key to be created. May be one of the following values: DIREG_DEV - Create a hardware registry key for the device. This is the key for storage of driver-independent configuration information. (This key is in the device instance key in the Enum branch. DIREG_DRV - Create a software, or driver, registry key for the device. (This key is located in the class branch.) InfHandle - Optionally, supplies the handle of an opened INF file containing an install section to be executed for the newly-created key. If this parameter is specified, then InfSectionName must be specified as well. InfSectionName - Optionally, supplies the name of an install section in the INF file specified by InfHandle. This section will be executed for the newly created key. If this parameter is specified, then InfHandle must be specified as well. Return Value: If the function succeeds, the return value is a handle to a newly-created registry key where private configuration data pertaining to this device instance may be stored/retrieved. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. Remarks: The handle returned from this routine must be closed by calling RegCloseKey. The specified device instance must have been previously registered (i.e., if it was created via SetupDiCreateDeviceInfo, then SetupDiRegisterDeviceInfo must have been subsequently called.) During GUI-mode setup on Windows NT, quiet-install behavior is always employed in the absence of a user-supplied file queue, regardless of whether the device information element has the DI_QUIETINSTALL flag set. --*/ { HKEY hk = INVALID_HANDLE_VALUE; PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; PSP_FILE_CALLBACK MsgHandler; PVOID MsgHandlerContext; BOOL MsgHandlerIsNativeCharWidth; BOOL NoProgressUI; if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return INVALID_HANDLE_VALUE; } Err = NO_ERROR; try { // // Get a pointer to the element for the specified device // instance. // if(!(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet, DeviceInfoData, NULL))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } // // Create the requested registry storage key. // if((Err = pSetupOpenOrCreateDevRegKey(pDeviceInfoSet, DevInfoElem, Scope, HwProfile, KeyType, TRUE, KEY_ALL_ACCESS, &hk)) != NO_ERROR) { goto clean0; } // // We successfully created the storage key, now run an INF install // section against it (if specified). // if(InfHandle && (InfHandle != INVALID_HANDLE_VALUE) && InfSectionName) { // // If a copy msg handler and context haven't been specified, then use // the default one. // if(DevInfoElem->InstallParamBlock.InstallMsgHandler) { MsgHandler = DevInfoElem->InstallParamBlock.InstallMsgHandler; MsgHandlerContext = DevInfoElem->InstallParamBlock.InstallMsgHandlerContext; MsgHandlerIsNativeCharWidth = DevInfoElem->InstallParamBlock.InstallMsgHandlerIsNativeCharWidth; } else { NoProgressUI = (GuiSetupInProgress || (DevInfoElem->InstallParamBlock.Flags & DI_QUIETINSTALL)); if(!(MsgHandlerContext = SetupInitDefaultQueueCallbackEx( DevInfoElem->InstallParamBlock.hwndParent, (NoProgressUI ? INVALID_HANDLE_VALUE : NULL), 0, 0, NULL))) { Err = ERROR_NOT_ENOUGH_MEMORY; goto clean0; } MsgHandler = SetupDefaultQueueCallback; MsgHandlerIsNativeCharWidth = TRUE; } if(!_SetupInstallFromInfSection(DevInfoElem->InstallParamBlock.hwndParent, InfHandle, InfSectionName, SPINST_ALL, hk, NULL, 0, MsgHandler, MsgHandlerContext, ((KeyType == DIREG_DEV) ? DeviceInfoSet : INVALID_HANDLE_VALUE), ((KeyType == DIREG_DEV) ? DeviceInfoData : NULL), MsgHandlerIsNativeCharWidth, NULL )) { Err = GetLastError(); } // // If we used the default msg handler, release the default context now. // if(!DevInfoElem->InstallParamBlock.InstallMsgHandler) { SetupTermDefaultQueueCallback(MsgHandlerContext); } } clean0: ; // Nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } UnlockDeviceInfoSet(pDeviceInfoSet); if(Err == NO_ERROR) { return hk; } else { if(hk != INVALID_HANDLE_VALUE) { RegCloseKey(hk); } SetLastError(Err); return INVALID_HANDLE_VALUE; } } HKEY WINAPI SetupDiOpenDevRegKey( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN REGSAM samDesired ) /*++ Routine Description: This routine opens a registry storage key for device-specific configuration information, and returns a handle to the key. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing information about the device instance whose registry configuration storage key is to be opened. DeviceInfoData - Supplies a pointer to a SP_DEVINFO_DATA structure indicating the device instance to open the registry key for. Scope - Specifies the scope of the registry key to be opened. This determines where the information is actually stored--the key opened may be one that is global (i.e., constant regardless of current hardware profile) or hardware profile-specific. May be one of the following values: DICS_FLAG_GLOBAL - Open a key to store global configuration information. DICS_FLAG_CONFIGSPECIFIC - Open a key to store hardware profile-specific information. HwProfile - Specifies the hardware profile to open a key for, if the Scope parameter is set to DICS_FLAG_CONFIGSPECIFIC. If this parameter is 0, then the key for the current hardware profile should be opened (i.e., in the Class branch under HKEY_CURRENT_CONFIG). If Scope is SPDICS_FLAG_GLOBAL, then this parameter is ignored. KeyType - Specifies the type of registry storage key to be opened. May be one of the following values: DIREG_DEV - Open a hardware registry key for the device. This is the key for storage of driver-independent configuration information. (This key is in the device instance key in the Enum branch. DIREG_DRV - Open a software (i.e., driver) registry key for the device. (This key is located in the class branch.) samDesired - Specifies the access you require for this key. Return Value: If the function succeeds, the return value is a handle to an opened registry key where private configuration data pertaining to this device instance may be stored/retrieved. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. Remarks: The handle returned from this routine must be closed by calling RegCloseKey. The specified device instance must have been previously registered (i.e., if it was created via SetupDiCreateDeviceInfo, then SetupDiRegisterDeviceInfo must have been subsequently called.) --*/ { HKEY hk; PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return INVALID_HANDLE_VALUE; } Err = NO_ERROR; try { // // Get a pointer to the element for the specified device // instance. // if(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet, DeviceInfoData, NULL)) { // // Open the requested registry storage key. // Err = pSetupOpenOrCreateDevRegKey(pDeviceInfoSet, DevInfoElem, Scope, HwProfile, KeyType, FALSE, samDesired, &hk ); } else { Err = ERROR_INVALID_PARAMETER; } } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } UnlockDeviceInfoSet(pDeviceInfoSet); SetLastError(Err); return (Err == NO_ERROR) ? hk : INVALID_HANDLE_VALUE; } DWORD pSetupOpenOrCreateDevRegKey( IN PDEVICE_INFO_SET pDeviceInfoSet, IN PDEVINFO_ELEM DevInfoElem, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN BOOL Create, IN REGSAM samDesired, OUT PHKEY hDevRegKey ) /*++ Routine Description: This routine creates or opens a registry storage key for the specified device information element, and returns a handle to the opened key. Arguments: DeviceInfoSet - Supplies a pointer to the device information set containing the element for which a registry storage key is to be created/opened. DevInfoElem - Supplies a pointer to the device information element for which a registry storage key is to be created/opened. Scope - Specifies the scope of the registry key to be created/opened. This determines where the information is actually stored--the key created may be one that is global (i.e., constant regardless of current hardware profile) or hardware profile-specific. May be one of the following values: DICS_FLAG_GLOBAL - Create/open a key to store global configuration information. DICS_FLAG_CONFIGSPECIFIC - Create/open a key to store hardware profile-specific information. HwProfile - Specifies the hardware profile to create/open a key for, if the Scope parameter is set to DICS_FLAG_CONFIGSPECIFIC. If this parameter is 0, then the key for the current hardware profile should be created/opened (i.e., in the Class branch under HKEY_CURRENT_CONFIG). If Scope is SPDICS_FLAG_GLOBAL, then this parameter is ignored. KeyType - Specifies the type of registry storage key to be created/opened. May be one of the following values: DIREG_DEV - Create/open a hardware registry key for the device. This is the key for storage of driver-independent configuration information. (This key is in the device instance key in the Enum branch. DIREG_DRV - Create/open a software, or driver, registry key for the device. (This key is located in the class branch.) Create - Specifies whether the key should be created if doesn't already exist. samDesired - Specifies the access you require for this key. hDevRegKey - Supplies the address of a variable that receives a handle to the requested registry key. (This variable will only be written to if the handle is successfully opened.) Return Value: If the function is successful, the return value is NO_ERROR, otherwise, it is the ERROR_* code indicating the error that occurred. Remarks: If a software key is requested (DIREG_DRV), and there isn't already a 'Driver' value entry, then one will be created. This entry is of the form: \ where is a base-10, 4-digit number that is unique within that class. --*/ { ULONG RegistryBranch; CONFIGRET cr; DWORD Err, Disposition; HKEY hk, hkClass; TCHAR DriverKey[GUID_STRING_LEN + 5]; // Eg, {4d36e978-e325-11ce-bfc1-08002be10318}\0000 ULONG DriverKeyLength; TCHAR EmptyString = TEXT('\0'); // // Under Win95, the class key uses the class name instead of its GUID. The maximum // length of a class name is less than the length of a GUID string, but put a check // here just to make sure that this assumption remains valid. // #if MAX_CLASS_NAME_LEN > MAX_GUID_STRING_LEN #error MAX_CLASS_NAME_LEN is larger than MAX_GUID_STRING_LEN--fix DriverKey! #endif // // Figure out what flags to pass to CM_Open_DevInst_Key // switch(KeyType) { case DIREG_DEV : RegistryBranch = CM_REGISTRY_HARDWARE; break; case DIREG_DRV : // // This key may only be opened if the device instance has been registered. // if(!(DevInfoElem->DiElemFlags & DIE_IS_REGISTERED)) { return ERROR_DEVINFO_NOT_REGISTERED; } // // Retrieve the 'Driver' registry property which indicates where the // storage key is located in the class branch. // DriverKeyLength = sizeof(DriverKey); if((cr = CM_Get_DevInst_Registry_Property_Ex(DevInfoElem->DevInst, CM_DRP_DRIVER, NULL, DriverKey, &DriverKeyLength, 0, pDeviceInfoSet->hMachine)) != CR_SUCCESS) { if(cr != CR_NO_SUCH_VALUE) { return (cr == CR_INVALID_DEVINST) ? ERROR_NO_SUCH_DEVINST : ERROR_INVALID_DATA; } else if(!Create) { return ERROR_KEY_DOES_NOT_EXIST; } // // The Driver entry doesn't exist, and we should create it. // hk = INVALID_HANDLE_VALUE; if(CM_Open_Class_Key_Ex(NULL, NULL, KEY_ALL_ACCESS, RegDisposition_OpenAlways, &hkClass, 0, pDeviceInfoSet->hMachine) != CR_SUCCESS) { // // This shouldn't fail. // return ERROR_INVALID_DATA; } try { // // Find a unique key name under this class key. // DriverKeyLength = SIZECHARS(DriverKey); if(CM_Get_Class_Key_Name_Ex(&(DevInfoElem->ClassGuid), DriverKey, &DriverKeyLength, 0, pDeviceInfoSet->hMachine) != CR_SUCCESS) { Err = ERROR_INVALID_CLASS; goto clean0; } DriverKeyLength--; // don't want to include terminating NULL. while(pSetupFindUniqueKey(hkClass, DriverKey, DriverKeyLength)) { if((Err = RegCreateKeyEx(hkClass, DriverKey, 0, &EmptyString, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hk, &Disposition)) == ERROR_SUCCESS) { // // Everything's great, unless the Disposition indicates // that the key already existed. That means that someone // else claimed the key before we got a chance to. In // that case, we close this key, and try again. // if(Disposition == REG_OPENED_EXISTING_KEY) { RegCloseKey(hk); hk = INVALID_HANDLE_VALUE; // // Truncate off the class instance part, to be replaced // with a new instance number the next go-around. // DriverKey[GUID_STRING_LEN - 1] = TEXT('\0'); } else { break; } } else { hk = INVALID_HANDLE_VALUE; break; } } if(Err != NO_ERROR) { // NO_ERROR == ERROR_SUCCESS goto clean0; } // // Set the device instance's 'Driver' registry property to reflect the // new software registry storage location. // CM_Set_DevInst_Registry_Property_Ex(DevInfoElem->DevInst, CM_DRP_DRIVER, DriverKey, sizeof(DriverKey), 0, pDeviceInfoSet->hMachine); clean0: ; // nothing to do } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; // // Access the hk variable so that the compiler will respect // the statement ordering in the try clause. // hk = hk; } if(hk != INVALID_HANDLE_VALUE) { RegCloseKey(hk); } RegCloseKey(hkClass); if(Err != NO_ERROR) { return Err; } } RegistryBranch = CM_REGISTRY_SOFTWARE; break; default : return ERROR_INVALID_FLAGS; } if(Scope == DICS_FLAG_CONFIGSPECIFIC) { RegistryBranch |= CM_REGISTRY_CONFIG; } else if(Scope != DICS_FLAG_GLOBAL) { return ERROR_INVALID_FLAGS; } cr = CM_Open_DevInst_Key_Ex(DevInfoElem->DevInst, samDesired, HwProfile, (Create ? RegDisposition_OpenAlways : RegDisposition_OpenExisting), &hk, RegistryBranch, pDeviceInfoSet->hMachine); if(cr == CR_SUCCESS) { *hDevRegKey = hk; Err = NO_ERROR; } else { switch(cr) { case CR_INVALID_DEVINST : Err = ERROR_NO_SUCH_DEVINST; break; case CR_NO_SUCH_REGISTRY_KEY : Err = ERROR_KEY_DOES_NOT_EXIST; break; default : Err = ERROR_INVALID_DATA; } } return Err; } BOOL WINAPI _SetupDiGetDeviceRegistryProperty( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL #ifdef UNICODE IN ,BOOL Ansi #endif ) { PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; CONFIGRET cr; ULONG CmRegProperty, PropLength; if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } Err = NO_ERROR; try { // // Get a pointer to the element for the specified device // instance. // if(!(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet, DeviceInfoData, NULL))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } if(Property < SPDRP_MAXIMUM_PROPERTY) { CmRegProperty = (ULONG)SPDRP_TO_CMDRP(Property); } else { Err = ERROR_INVALID_REG_PROPERTY; goto clean0; } PropLength = PropertyBufferSize; #ifdef UNICODE if(Ansi) { cr = CM_Get_DevInst_Registry_Property_ExA( DevInfoElem->DevInst, CmRegProperty, PropertyRegDataType, PropertyBuffer, &PropLength, 0, pDeviceInfoSet->hMachine); } else #endif cr = CM_Get_DevInst_Registry_Property_Ex(DevInfoElem->DevInst, CmRegProperty, PropertyRegDataType, PropertyBuffer, &PropLength, 0, pDeviceInfoSet->hMachine); if((cr == CR_SUCCESS) || (cr == CR_BUFFER_SMALL)) { if(RequiredSize) { *RequiredSize = PropLength; } } if(cr != CR_SUCCESS) { switch(cr) { case CR_INVALID_DEVINST : Err = ERROR_NO_SUCH_DEVINST; break; case CR_INVALID_PROPERTY : Err = ERROR_INVALID_REG_PROPERTY; break; case CR_BUFFER_SMALL : Err = ERROR_INSUFFICIENT_BUFFER; break; default : Err = ERROR_INVALID_DATA; } } clean0: ; // Nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } UnlockDeviceInfoSet(pDeviceInfoSet); SetLastError(Err); return (Err == NO_ERROR); } #ifdef UNICODE // // ANSI version // BOOL WINAPI SetupDiGetDeviceRegistryPropertyA( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) { BOOL b; b = _SetupDiGetDeviceRegistryProperty( DeviceInfoSet, DeviceInfoData, Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize, TRUE ); return(b); } #else // // Unicode stub // BOOL WINAPI SetupDiGetDeviceRegistryPropertyW( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) { UNREFERENCED_PARAMETER(DeviceInfoSet); UNREFERENCED_PARAMETER(DeviceInfoData); UNREFERENCED_PARAMETER(Property); UNREFERENCED_PARAMETER(PropertyRegDataType); UNREFERENCED_PARAMETER(PropertyBuffer); UNREFERENCED_PARAMETER(PropertyBufferSize); UNREFERENCED_PARAMETER(RequiredSize); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } #endif BOOL WINAPI SetupDiGetDeviceRegistryProperty( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) /*++ Routine Description: This routine retrieves the specified property from the Plug & Play device storage location in the registry. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing information about the device instance to retrieve a Plug & Play registry property for. DeviceInfoData - Supplies a pointer to a SP_DEVINFO_DATA structure indicating the device instance to retrieve the Plug & Play registry property for. Property - Supplies an ordinal specifying the property to be retrieved. Refer to sdk\inc\setupapi.h for a complete list of properties that may be retrieved. PropertyRegDataType - Optionally, supplies the address of a variable that will receive the data type of the property being retrieved. This will be one of the standard registry data types (REG_SZ, REG_BINARY, etc.) PropertyBuffer - Supplies the address of a buffer that receives the property data. PropertyBufferSize - Supplies the length, in bytes, of PropertyBuffer. RequiredSize - Optionally, supplies the address of a variable that receives the number of bytes required to store the requested property in the buffer. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. If the supplied buffer was not large enough to hold the requested property, the error will be ERROR_INSUFFICIENT_BUFFER, and RequiredSize will specify how large the buffer needs to be. --*/ { BOOL b; b = _SetupDiGetDeviceRegistryProperty( DeviceInfoSet, DeviceInfoData, Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize #ifdef UNICODE ,FALSE #endif ); return(b); } BOOL WINAPI _SetupDiSetDeviceRegistryProperty( IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize #ifdef UNICODE IN ,BOOL Ansi #endif ) { PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; CONFIGRET cr; ULONG CmRegProperty; GUID ClassGuid; BOOL ClassGuidSpecified; TCHAR ClassName[MAX_CLASS_NAME_LEN]; DWORD ClassNameLength; if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } Err = NO_ERROR; try { // // Get a pointer to the element for the specified device // instance. // if(!(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet, DeviceInfoData, NULL))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } // // Make sure the property code is in-range, and is not SPDRP_CLASS // (the Class property is not settable directly, and is automatically // updated when the ClassGUID property changes). // if((Property < SPDRP_MAXIMUM_PROPERTY) && (Property != SPDRP_CLASS)) { CmRegProperty = (ULONG)SPDRP_TO_CMDRP(Property); } else { Err = ERROR_INVALID_REG_PROPERTY; goto clean0; } // // If the property we're setting is ClassGUID, then we need to check to // see whether the new GUID is different from the current one. If there's // no change, then we're done. // if(CmRegProperty == CM_DRP_CLASSGUID) { if(!PropertyBuffer) { // // Then the intent is to reset the device's class GUID. Make // sure they passed us a buffer length of zero. // if(PropertyBufferSize) { Err = ERROR_INVALID_PARAMETER; goto clean0; } ClassGuidSpecified = FALSE; } else { #ifdef UNICODE // // If we're being called from the ANSI API then we need // to convert the ANSI string representation of the GUID // to Unicode before we convert the string to an actual GUID. // PCWSTR UnicodeGuidString; if(Ansi) { UnicodeGuidString = pSetupAnsiToUnicode((PCSTR)PropertyBuffer); if(!UnicodeGuidString) { Err = ERROR_NOT_ENOUGH_MEMORY; goto clean0; } } else { UnicodeGuidString = (PCWSTR)PropertyBuffer; } Err = pSetupGuidFromString(UnicodeGuidString,&ClassGuid); if(UnicodeGuidString != (PCWSTR)PropertyBuffer) { MyFree(UnicodeGuidString); } if(Err != NO_ERROR) { goto clean0; } #else if((Err = pSetupGuidFromString((PCTSTR)PropertyBuffer, &ClassGuid)) != NO_ERROR) { goto clean0; } #endif ClassGuidSpecified = TRUE; } if(IsEqualGUID(&(DevInfoElem->ClassGuid), (ClassGuidSpecified ? &ClassGuid : &GUID_NULL))) { // // No change--nothing to do. // goto clean0; } // // We're changing the class of this device. First, make sure that the // set containing this device doesn't have an associated class (otherwise, // we'll suddenly have a device whose class doesn't match the set's class). // if(pDeviceInfoSet->HasClassGuid) { Err = ERROR_CLASS_MISMATCH; } else { Err = InvalidateHelperModules(DeviceInfoSet, DeviceInfoData, 0); } if(Err != NO_ERROR) { goto clean0; } // // Everything seems to be in order. Before going any further, we need to // delete any software keys associated with this device, so we don't leave // orphans in the registry when we change the device's class. // pSetupDeleteDevRegKeys(DevInfoElem->DevInst, DICS_FLAG_GLOBAL | DICS_FLAG_CONFIGSPECIFIC, (DWORD)-1, DIREG_DRV, TRUE ); // // Now delete the Driver property for this device... // CM_Set_DevInst_Registry_Property(DevInfoElem->DevInst, CM_DRP_DRIVER, NULL, 0, 0 ); } #ifdef UNICODE if(Ansi) { cr = CM_Set_DevInst_Registry_PropertyA( DevInfoElem->DevInst, CmRegProperty, (PVOID)PropertyBuffer, PropertyBufferSize, 0 ); } else #endif cr = CM_Set_DevInst_Registry_Property(DevInfoElem->DevInst, CmRegProperty, (PVOID)PropertyBuffer, PropertyBufferSize, 0 ); if(cr == CR_SUCCESS) { // // If we were setting the device's ClassGUID property, then we need to // update its Class name property as well. // if(CmRegProperty == CM_DRP_CLASSGUID) { if(ClassGuidSpecified) { if(!SetupDiClassNameFromGuid(&ClassGuid, ClassName, SIZECHARS(ClassName), &ClassNameLength)) { // // We couldn't retrieve the corresponding class name. // Set ClassNameLength to zero so that we reset class // name below. // ClassNameLength = 0; } } else { // // Resetting ClassGUID--we want to reset class name also. // ClassNameLength = 0; } CM_Set_DevInst_Registry_Property(DevInfoElem->DevInst, CM_DRP_CLASS, ClassNameLength ? (PVOID)ClassName : NULL, ClassNameLength * sizeof(TCHAR), 0 ); // // Finally, update the device's class GUID, and also update the // caller-supplied SP_DEVINFO_DATA structure to reflect the device's // new class. // CopyMemory(&(DevInfoElem->ClassGuid), (ClassGuidSpecified ? &ClassGuid : &GUID_NULL), sizeof(GUID) ); CopyMemory(&(DeviceInfoData->ClassGuid), (ClassGuidSpecified ? &ClassGuid : &GUID_NULL), sizeof(GUID) ); } } else { switch(cr) { case CR_INVALID_DEVINST : Err = ERROR_NO_SUCH_DEVINST; break; case CR_INVALID_PROPERTY : Err = ERROR_INVALID_REG_PROPERTY; break; case CR_INVALID_DATA : Err = ERROR_INVALID_PARAMETER; break; default : Err = ERROR_INVALID_DATA; } } clean0: ; // Nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } UnlockDeviceInfoSet(pDeviceInfoSet); SetLastError(Err); return (Err == NO_ERROR); } #ifdef UNICODE // // ANSI version // BOOL WINAPI SetupDiSetDeviceRegistryPropertyA( IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize ) { BOOL b; b = _SetupDiSetDeviceRegistryProperty( DeviceInfoSet, DeviceInfoData, Property, PropertyBuffer, PropertyBufferSize, TRUE ); return(b); } #else // // Unicode stub // BOOL WINAPI SetupDiSetDeviceRegistryPropertyW( IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize ) { UNREFERENCED_PARAMETER(DeviceInfoSet); UNREFERENCED_PARAMETER(DeviceInfoData); UNREFERENCED_PARAMETER(Property); UNREFERENCED_PARAMETER(PropertyBuffer); UNREFERENCED_PARAMETER(PropertyBufferSize); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } #endif BOOL WINAPI SetupDiSetDeviceRegistryProperty( IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize ) /*++ Routine Description: This routine sets the specified Plug & Play device registry property. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing information about the device instance to set a Plug & Play registry property for. DeviceInfoData - Supplies a pointer to a SP_DEVINFO_DATA structure indicating the device instance to set the Plug & Play registry property for. If the ClassGUID property is being set, then this structure will be updated upon return to reflect the device's new class. Property - Supplies an ordinal specifying the property to be set. Refer to sdk\inc\setupapi.h for a complete listing of values that may be set (these values are denoted with 'R/W' in their descriptive comment). PropertyBuffer - Supplies the address of a buffer containing the new data for the property. If the property is being cleared, then this pointer should be NULL, and PropertyBufferSize must be zero. PropertyBufferSize - Supplies the length, in bytes, of PropertyBuffer. If PropertyBuffer isn't specified (i.e., the property is to be cleared), then this value must be zero. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. Remarks: Note that the Class property cannot be set. This is because it is based on the corresponding ClassGUID, and is automatically updated when that property changes. Also, note that when the ClassGUID property changes, this routine automatically cleans up any software keys associated with the device. Otherwise, we would be left with orphaned registry keys. --*/ { BOOL b; b = _SetupDiSetDeviceRegistryProperty( DeviceInfoSet, DeviceInfoData, Property, PropertyBuffer, PropertyBufferSize #ifdef UNICODE ,FALSE #endif ); return(b); } DWORD _SetupDiGetClassRegistryProperty( IN CONST GUID *ClassGuid, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize, OPTIONAL IN PCTSTR MachineName, OPTIONAL IN BOOL Ansi ) /*++ See SetupDiGetClassRegistryProperty --*/ { DWORD Err; CONFIGRET cr; ULONG CmRegProperty, PropLength; HMACHINE hMachine = NULL; Err = NO_ERROR; #ifndef UNICODE UNREFERENCED_PARAMETER(Ansi); #endif try { // // if we want to set register for another machine, find that machine // if(MachineName) { if(CR_SUCCESS != (cr = CM_Connect_Machine(MachineName, &hMachine))) { // // Make sure machine handle is still invalid, so we won't // try to disconnect later. // hMachine = NULL; Err = MapCrToSpError(cr, ERROR_INVALID_DATA); leave; } } if(Property < SPCRP_MAXIMUM_PROPERTY) { CmRegProperty = (ULONG)SPCRP_TO_CMCRP(Property); } else { Err = ERROR_INVALID_REG_PROPERTY; leave; } PropLength = PropertyBufferSize; #ifdef UNICODE if(Ansi) { cr = CM_Get_Class_Registry_PropertyA( (LPGUID)ClassGuid, CmRegProperty, PropertyRegDataType, PropertyBuffer, &PropLength, 0, hMachine); } else { cr = CM_Get_Class_Registry_PropertyW( (LPGUID)ClassGuid, CmRegProperty, PropertyRegDataType, PropertyBuffer, &PropLength, 0, hMachine); } #else // // on ANSI version // cr = CM_Get_Class_Registry_Property( (LPGUID)ClassGuid, CmRegProperty, PropertyRegDataType, PropertyBuffer, &PropLength, 0, hMachine); #endif if((cr == CR_SUCCESS) || (cr == CR_BUFFER_SMALL)) { if(RequiredSize) { *RequiredSize = PropLength; } } if(cr != CR_SUCCESS) { switch(cr) { case CR_INVALID_DEVINST : Err = ERROR_NO_SUCH_DEVINST; break; case CR_INVALID_PROPERTY : Err = ERROR_INVALID_REG_PROPERTY; break; case CR_BUFFER_SMALL : Err = ERROR_INSUFFICIENT_BUFFER; break; default : Err = MapCrToSpError(cr, ERROR_INVALID_DATA); } } } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } if (hMachine != NULL) { CM_Disconnect_Machine(hMachine); } return Err; } #ifdef UNICODE // // ANSI version // WINSETUPAPI BOOL WINAPI SetupDiGetClassRegistryPropertyA( IN CONST GUID *ClassGuid, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize, OPTIONAL IN PCSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ See SetupDiGetClassRegistryProperty --*/ { PCWSTR MachineString = NULL; DWORD Err = NO_ERROR; if (Reserved != NULL) { // // make sure caller doesn't pass a value here // so we know we can use this at a later date SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } try { // // convert machine-name to local // if (MachineName != NULL) { MachineString = pSetupAnsiToUnicode(MachineName); if(!MachineString) { Err = ERROR_NOT_ENOUGH_MEMORY; leave; } } Err = _SetupDiGetClassRegistryProperty(ClassGuid, Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize, MachineString, TRUE); } except(EXCEPTION_EXECUTE_HANDLER) { Err = NO_ERROR; } if (MachineString != NULL) { MyFree(MachineString); } SetLastError(Err); return (BOOL)(Err == NO_ERROR); } #else // // UNICODE stub // WINSETUPAPI BOOL WINAPI SetupDiGetClassRegistryPropertyW( IN CONST GUID *ClassGuid, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize, OPTIONAL IN PCWSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ See SetupDiGetClassRegistryProperty --*/ { UNREFERENCED_PARAMETER(ClassGuid); UNREFERENCED_PARAMETER(Property); UNREFERENCED_PARAMETER(PropertyRegDataType); UNREFERENCED_PARAMETER(PropertyBuffer); UNREFERENCED_PARAMETER(PropertyBufferSize); UNREFERENCED_PARAMETER(RequiredSize); UNREFERENCED_PARAMETER(MachineName); UNREFERENCED_PARAMETER(Reserved); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } #endif // UNICODE WINSETUPAPI BOOL WINAPI SetupDiGetClassRegistryProperty( IN CONST GUID *ClassGuid, IN DWORD Property, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize, OPTIONAL IN PCTSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ Routine Description: This routine gets the specified Plug & Play device class registry property. This is just a wrapper around the Config Mgr API Typically the properties here can be overridden on a per-device basis, however this routine returns the class properties only. Arguments: ClassGuid - Supplies the class Guid that the property is to be got from Property - Supplies an ordinal specifying the property to be set. Refer to sdk\inc\setupapi.h for a complete listing of values that may be set (these values are denoted with 'R/W' in their descriptive comment). PropertyBuffer - Supplies the address of a buffer containing the new data for the property. If the property is being cleared, then this pointer should be NULL, and PropertyBufferSize must be zero. PropertyBufferSize - Supplies the length, in bytes, of PropertyBuffer. If PropertyBuffer isn't specified (i.e., the property is to be cleared), then this value must be zero. MachineName - Allows properties to be set on a remote machine (if Non-NULL) Reserved - should be nULL Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. --*/ { DWORD Err = NO_ERROR; if (Reserved != NULL) { // // make sure caller doesn't pass a value here // so we know we can use this at a later date SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } Err = _SetupDiGetClassRegistryProperty(ClassGuid, Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize, MachineName, FALSE); SetLastError(Err); return (BOOL)(Err == NO_ERROR); } DWORD _SetupDiSetClassRegistryProperty( IN CONST GUID *ClassGuid, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize, IN PCTSTR MachineName, OPTIONAL IN BOOL Ansi ) /*++ See SetupDiGetClassRegistryProperty --*/ { DWORD Err; CONFIGRET cr; ULONG CmRegProperty, PropLength; HMACHINE hMachine = NULL; Err = NO_ERROR; try { // // if we want to set register for another machine, find that machine // if(MachineName) { if(CR_SUCCESS != (cr = CM_Connect_Machine(MachineName, &hMachine))) { // // Make sure machine handle is still invalid, so we won't // try to disconnect later. // hMachine = NULL; Err = MapCrToSpError(cr, ERROR_INVALID_DATA); leave; } } if(Property < SPCRP_MAXIMUM_PROPERTY) { CmRegProperty = (ULONG)SPCRP_TO_CMCRP(Property); } else { Err = ERROR_INVALID_REG_PROPERTY; leave; } PropLength = PropertyBufferSize; #ifdef UNICODE if(Ansi) { cr = CM_Set_Class_Registry_PropertyA( (LPGUID)ClassGuid, CmRegProperty, PropertyBuffer, PropLength, 0, hMachine); } else { cr = CM_Set_Class_Registry_PropertyW( (LPGUID)ClassGuid, CmRegProperty, PropertyBuffer, PropLength, 0, hMachine); } #else // // on ANSI version // cr = CM_Set_Class_Registry_Property( (LPGUID)ClassGuid, CmRegProperty, PropertyBuffer, PropLength, 0, hMachine); #endif if(cr != CR_SUCCESS) { switch(cr) { case CR_INVALID_PROPERTY : Err = ERROR_INVALID_REG_PROPERTY; break; default : Err = MapCrToSpError(cr, ERROR_INVALID_DATA); } } } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } if (hMachine != NULL) { CM_Disconnect_Machine(hMachine); } return Err; } #ifdef UNICODE // // ANSI version // WINSETUPAPI BOOL WINAPI SetupDiSetClassRegistryPropertyA( IN CONST GUID *ClassGuid, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize, IN PCSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ See SetupDiSetClassRegistryProperty --*/ { PCWSTR MachineString = NULL; DWORD Err = NO_ERROR; if (Reserved != NULL) { // // make sure caller doesn't pass a value here // so we know we can use this at a later date SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } try { // // convert machine-name to local // if (MachineName != NULL) { MachineString = pSetupAnsiToUnicode(MachineName); if(!MachineString) { Err = ERROR_NOT_ENOUGH_MEMORY; leave; } } Err = _SetupDiSetClassRegistryProperty(ClassGuid, Property, PropertyBuffer, PropertyBufferSize, MachineString, TRUE); } except(EXCEPTION_EXECUTE_HANDLER) { Err = NO_ERROR; } if (MachineString != NULL) { MyFree(MachineString); } SetLastError(Err); return (BOOL)(Err == NO_ERROR); } #else // // UNICODE stub // WINSETUPAPI BOOL WINAPI SetupDiSetClassRegistryPropertyW( IN CONST GUID *ClassGuid, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize, IN PCWSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ See SetupDiSetClassRegistryProperty --*/ { UNREFERENCED_PARAMETER(ClassGuid); UNREFERENCED_PARAMETER(Property); UNREFERENCED_PARAMETER(PropertyBuffer); UNREFERENCED_PARAMETER(PropertyBufferSize); UNREFERENCED_PARAMETER(MachineName); UNREFERENCED_PARAMETER(Reserved); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } #endif // UNICODE WINSETUPAPI BOOL WINAPI SetupDiSetClassRegistryProperty( IN CONST GUID *ClassGuid, IN DWORD Property, IN CONST BYTE* PropertyBuffer, OPTIONAL IN DWORD PropertyBufferSize, IN PCTSTR MachineName, OPTIONAL IN PVOID Reserved ) /*++ Routine Description: This routine sets the specified Plug & Play device class registry property. This is just a wrapper around the Config Mgr API Typically the properties here can be overridden on a per-device basis Arguments: ClassGuid - Supplies the class Guid for the P&P device, that the property is to be set for Property - Supplies an ordinal specifying the property to be retrieved. Refer to sdk\inc\setupapi.h for a complete list of properties that may be retrieved. PropertyRegDataType - Optionally, supplies the address of a variable that will receive the data type of the property being retrieved. This will be one of the standard registry data types (REG_SZ, REG_BINARY, etc.) PropertyBuffer - Supplies the address of a buffer that receives the property data. PropertyBufferSize - Supplies the length, in bytes, of PropertyBuffer. RequiredSize - Optionally, supplies the address of a variable that receives the number of bytes required to store the requested property in the buffer. MachineName - Allows properties to be got from a remote machine (if Non-NULL) Reserved - should be nULL Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. --*/ { DWORD Err; Err = _SetupDiSetClassRegistryProperty(ClassGuid, Property, PropertyBuffer, PropertyBufferSize, MachineName, FALSE); SetLastError(Err); return (BOOL)(Err == NO_ERROR); } BOOL pSetupFindUniqueKey( IN HKEY hkRoot, IN LPTSTR SubKey, IN ULONG SubKeyLength ) /*++ Routine Description: This routine finds a unique key under the specified subkey. This key is of the form \xxxx, where xxxx is a base-10, 4-digit number. Arguments: hkRoot - Root key under which the specified SubKey is located. SubKey - Name of the subkey, under which a unique key is to be generated. SubKeyLength - Supplies the length of the SubKey string, not including terminating NULL. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. --*/ { INT i; HKEY hk; for(i = 0; i <= 9999; i++) { wsprintf(&(SubKey[SubKeyLength]), pszUniqueSubKey, i); if(RegOpenKeyEx(hkRoot, SubKey, 0, KEY_READ, &hk) != ERROR_SUCCESS) { return TRUE; } RegCloseKey(hk); } return FALSE; } BOOL WINAPI SetupDiDeleteDevRegKey( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType ) /*++ Routine Description: This routine deletes the specified registry key(s) associated with a device information element. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing the device instance to delete key(s) for. DeviceInfoData - Supplies a pointer to a SP_DEVINFO_DATA structure indicating the device instance to delete key(s) for. Scope - Specifies the scope of the registry key to be deleted. This determines where the key to be deleted is located--the key may be one that is global (i.e., constant regardless of current hardware profile) or hardware profile-specific. May be a combination of the following values: DICS_FLAG_GLOBAL - Delete the key that stores global configuration information. DICS_FLAG_CONFIGSPECIFIC - Delete the key that stores hardware profile-specific information. HwProfile - Specifies the hardware profile to delete a key for, if the Scope parameter includes the DICS_FLAG_CONFIGSPECIFIC flag. If this parameter is 0, then the key for the current hardware profile should be deleted (i.e., in the Class branch under HKEY_CURRENT_CONFIG). If this parameter is 0xFFFFFFFF, then the key for _all_ hardware profiles should be deleted. KeyType - Specifies the type of registry storage key to be deleted. May be one of the following values: DIREG_DEV - Delete the hardware registry key for the device. This is the key for storage of driver-independent configuration information. (This key is in the device instance key in the Enum branch. DIREG_DRV - Delete the software (i.e., driver) registry key for the device. (This key is located in the class branch.) DIREG_BOTH - Delete both the hardware and software keys for the device. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. --*/ { PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; CONFIGRET cr; if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } try { // // Get a pointer to the element for the specified device // instance. // if(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet, DeviceInfoData, NULL)) { Err = pSetupDeleteDevRegKeys(DevInfoElem->DevInst, Scope, HwProfile, KeyType, FALSE); } else { Err = ERROR_INVALID_PARAMETER; } } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } UnlockDeviceInfoSet(pDeviceInfoSet); SetLastError(Err); return(Err == NO_ERROR); } DWORD pSetupDeleteDevRegKeys( IN DEVINST DevInst, IN DWORD Scope, IN DWORD HwProfile, IN DWORD KeyType, IN BOOL DeleteUserKeys ) /*++ Routine Description: This is the worker routine for SetupDiDeleteDevRegKey. See the discussion of that API for details. Return Value: If successful, the return value is NO_ERROR; If failure, the return value is a Win32 error code indicating the cause of failure. Remarks: Even if one of the operations in this routine fails, all operations will be attempted. Thus, as many keys as possible will be deleted. The error returned will be the first error that was encountered in this case. --*/ { CONFIGRET cr, crTemp; DWORD Err; cr = CR_SUCCESS; if(Scope & DICS_FLAG_GLOBAL) { if((KeyType == DIREG_DEV) || (KeyType == DIREG_BOTH)) { crTemp = CM_Delete_DevInst_Key(DevInst, 0, CM_REGISTRY_HARDWARE); if((cr == CR_SUCCESS) && (crTemp != CR_SUCCESS) && (crTemp != CR_NO_SUCH_REGISTRY_KEY)) { cr = crTemp; } } if((KeyType == DIREG_DRV) || (KeyType == DIREG_BOTH)) { crTemp = CM_Delete_DevInst_Key(DevInst, 0, CM_REGISTRY_SOFTWARE); if((cr == CR_SUCCESS) && (crTemp != CR_SUCCESS) && (crTemp != CR_NO_SUCH_REGISTRY_KEY)) { cr = crTemp; } } } if(Scope & DICS_FLAG_CONFIGSPECIFIC) { if((KeyType == DIREG_DEV) || (KeyType == DIREG_BOTH)) { crTemp = CM_Delete_DevInst_Key(DevInst, HwProfile, CM_REGISTRY_HARDWARE | CM_REGISTRY_CONFIG); if((cr == CR_SUCCESS) && (crTemp != CR_SUCCESS) && (crTemp != CR_NO_SUCH_REGISTRY_KEY)) { cr = crTemp; } } if((KeyType == DIREG_DRV) || (KeyType == DIREG_BOTH)) { crTemp = CM_Delete_DevInst_Key(DevInst, HwProfile, CM_REGISTRY_SOFTWARE | CM_REGISTRY_CONFIG); if((cr == CR_SUCCESS) && (crTemp != CR_SUCCESS) && (crTemp != CR_NO_SUCH_REGISTRY_KEY)) { cr = crTemp; } } } if(DeleteUserKeys) { if((KeyType == DIREG_DEV) || (KeyType == DIREG_BOTH)) { crTemp = CM_Delete_DevInst_Key(DevInst, 0, CM_REGISTRY_HARDWARE | CM_REGISTRY_USER); if((cr == CR_SUCCESS) && (crTemp != CR_SUCCESS) && (crTemp != CR_NO_SUCH_REGISTRY_KEY)) { cr = crTemp; } } if((KeyType == DIREG_DRV) || (KeyType == DIREG_BOTH)) { crTemp = CM_Delete_DevInst_Key(DevInst, 0, CM_REGISTRY_SOFTWARE | CM_REGISTRY_USER); if((cr == CR_SUCCESS) && (crTemp != CR_SUCCESS) && (crTemp != CR_NO_SUCH_REGISTRY_KEY)) { cr = crTemp; } } } // // Now translate the ConfigMgr return code into a Win32 one. // switch(cr) { case CR_SUCCESS : Err = NO_ERROR; break; case CR_REGISTRY_ERROR : Err = ERROR_ACCESS_DENIED; break; case CR_INVALID_DEVINST : Err = ERROR_NO_SUCH_DEVINST; break; default : Err = ERROR_INVALID_DATA; } return Err; } #ifdef UNICODE // // ANSI version // HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyA( IN HDEVINFO DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, IN DWORD Reserved, IN REGSAM samDesired, IN HINF InfHandle, OPTIONAL IN PCSTR InfSectionName OPTIONAL ) { DWORD rc; PWSTR name; HKEY h; if(InfSectionName) { rc = pSetupCaptureAndConvertAnsiArg(InfSectionName, &name); if(rc != NO_ERROR) { SetLastError(rc); return(INVALID_HANDLE_VALUE); } } else { name = NULL; } h = SetupDiCreateDeviceInterfaceRegKeyW(DeviceInfoSet, DeviceInterfaceData, Reserved, samDesired, InfHandle, name ); rc = GetLastError(); if(name) { MyFree(name); } SetLastError(rc); return(h); } #else // // Unicode stub // HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyW( IN HDEVINFO DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, IN DWORD Reserved, IN REGSAM samDesired, IN HINF InfHandle, OPTIONAL IN PCWSTR InfSectionName OPTIONAL ) { UNREFERENCED_PARAMETER(DeviceInfoSet); UNREFERENCED_PARAMETER(DeviceInterfaceData); UNREFERENCED_PARAMETER(Reserved); UNREFERENCED_PARAMETER(samDesired); UNREFERENCED_PARAMETER(InfHandle); UNREFERENCED_PARAMETER(InfSectionName); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(INVALID_HANDLE_VALUE); } #endif HKEY WINAPI SetupDiCreateDeviceInterfaceRegKey( IN HDEVINFO DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, IN DWORD Reserved, IN REGSAM samDesired, IN HINF InfHandle, OPTIONAL IN PCTSTR InfSectionName OPTIONAL ) /*++ Routine Description: This routine creates a registry storage key for a particular device interface, and returns a handle to the key. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing the device interface for whom a registry key is to be created. DeviceInterfaceData - Supplies a pointer to a device interface data structure indicating which device interface a key is to be created for. Reserved - Reserved for future use, must be set to 0. samDesired - Specifies the registry access desired for the resulting key handle. InfHandle - Optionally, supplies the handle of an opened INF file containing an install section to be executed for the newly-created key. If this parameter is specified, then InfSectionName must be specified as well. InfSectionName - Optionally, supplies the name of an install section in the INF file specified by InfHandle. This section will be executed for the newly created key. If this parameter is specified, then InfHandle must be specified as well. Return Value: If the function succeeds, the return value is a handle to a newly-created registry key where private configuration data pertaining to this device interface may be stored/retrieved. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. Remarks: The handle returned from this routine must be closed by calling RegCloseKey. During GUI-mode setup on Windows NT, quiet-install behavior is always employed in the absence of a user-supplied file queue, regardless of whether the device information element has the DI_QUIETINSTALL flag set. --*/ { HKEY hk, hSubKey; PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; PSP_FILE_CALLBACK MsgHandler; PVOID MsgHandlerContext; BOOL MsgHandlerIsNativeCharWidth; BOOL NoProgressUI; if(Reserved != 0) { SetLastError(ERROR_INVALID_PARAMETER); return INVALID_HANDLE_VALUE; } if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return INVALID_HANDLE_VALUE; } Err = NO_ERROR; hk = hSubKey = INVALID_HANDLE_VALUE; try { // // Get a pointer to the device information element for the specified // interface device. // if(!(DevInfoElem = FindDevInfoElemForInterfaceDevice(pDeviceInfoSet, DeviceInterfaceData))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } hk = SetupDiOpenClassRegKeyEx(&(DeviceInterfaceData->InterfaceClassGuid), KEY_READ, DIOCR_INTERFACE, NULL, NULL ); if(hk == INVALID_HANDLE_VALUE) { // // We couldn't open the interface class subkey--this should never happen. // Err = GetLastError(); goto clean0; } // // Now, create the client-accessible registry storage key for this interface device. // Err = pSetupOpenOrCreateInterfaceDeviceRegKey(hk, pDeviceInfoSet, DeviceInterfaceData, TRUE, samDesired, &hSubKey ); RegCloseKey(hk); hk = INVALID_HANDLE_VALUE; if(Err != NO_ERROR) { goto clean0; } // // We successfully created the storage key, now run an INF install // section against it (if specified). // if(InfHandle && (InfHandle != INVALID_HANDLE_VALUE) && InfSectionName) { // // If a copy msg handler and context haven't been specified, then // use the default one. // if(DevInfoElem->InstallParamBlock.InstallMsgHandler) { MsgHandler = DevInfoElem->InstallParamBlock.InstallMsgHandler; MsgHandlerContext = DevInfoElem->InstallParamBlock.InstallMsgHandlerContext; MsgHandlerIsNativeCharWidth = DevInfoElem->InstallParamBlock.InstallMsgHandlerIsNativeCharWidth; } else { NoProgressUI = (GuiSetupInProgress || (DevInfoElem->InstallParamBlock.Flags & DI_QUIETINSTALL)); if(!(MsgHandlerContext = SetupInitDefaultQueueCallbackEx( DevInfoElem->InstallParamBlock.hwndParent, (NoProgressUI ? INVALID_HANDLE_VALUE : NULL), 0, 0, NULL))) { Err = ERROR_NOT_ENOUGH_MEMORY; goto clean0; } MsgHandler = SetupDefaultQueueCallback; MsgHandlerIsNativeCharWidth = TRUE; } if(!_SetupInstallFromInfSection(DevInfoElem->InstallParamBlock.hwndParent, InfHandle, InfSectionName, SPINST_ALL ^ SPINST_LOGCONFIG, hSubKey, NULL, 0, MsgHandler, MsgHandlerContext, INVALID_HANDLE_VALUE, NULL, MsgHandlerIsNativeCharWidth, NULL )) { Err = GetLastError(); } // // If we used the default msg handler, release the default context // now. // if(!DevInfoElem->InstallParamBlock.InstallMsgHandler) { SetupTermDefaultQueueCallback(MsgHandlerContext); } } clean0: ; // Nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; if(hk != INVALID_HANDLE_VALUE) { RegCloseKey(hk); } // // Access the following registry handle so that the compiler will // respect statement ordering w.r.t. its assignment. // hSubKey = hSubKey; } UnlockDeviceInfoSet(pDeviceInfoSet); if(Err == NO_ERROR) { return hSubKey; } else { if(hSubKey != INVALID_HANDLE_VALUE) { RegCloseKey(hSubKey); } SetLastError(Err); return INVALID_HANDLE_VALUE; } } HKEY WINAPI SetupDiOpenDeviceInterfaceRegKey( IN HDEVINFO DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, IN DWORD Reserved, IN REGSAM samDesired ) /*++ Routine Description: This routine opens a registry storage key for a particular device interface, and returns a handle to the key. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing the device interface for whom a registry key is to be opened. InterfaceDeviceData - Supplies a pointer to a device interface data structure indicating which device interface a key is to be opened for. Reserved - Reserved for future use, must be set to 0. samDesired - Specifies the access you require for this key. Return Value: If the function succeeds, the return value is a handle to an opened registry key where private configuration data pertaining to this device interface may be stored/retrieved. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. Remarks: The handle returned from this routine must be closed by calling RegCloseKey. --*/ { HKEY hk, hSubKey; PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; if(Reserved != 0) { SetLastError(ERROR_INVALID_PARAMETER); return INVALID_HANDLE_VALUE; } if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return INVALID_HANDLE_VALUE; } Err = NO_ERROR; hk = INVALID_HANDLE_VALUE; try { // // Get a pointer to the device information element for the specified // interface device. // if(!(DevInfoElem = FindDevInfoElemForInterfaceDevice(pDeviceInfoSet, DeviceInterfaceData))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } hk = SetupDiOpenClassRegKeyEx(&(DeviceInterfaceData->InterfaceClassGuid), KEY_READ, DIOCR_INTERFACE, NULL, NULL ); if(hk == INVALID_HANDLE_VALUE) { // // We couldn't open the interface class subkey--this should never happen. // Err = GetLastError(); goto clean0; } // // Now, open up the client-accessible registry storage key for this interface device. // Err = pSetupOpenOrCreateInterfaceDeviceRegKey(hk, pDeviceInfoSet, DeviceInterfaceData, FALSE, samDesired, &hSubKey ); clean0: ; // nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; // // Access the following registry handle so that the compiler will respect // statement ordering w.r.t. its assignment. // hk = hk; } UnlockDeviceInfoSet(pDeviceInfoSet); if(hk != INVALID_HANDLE_VALUE) { RegCloseKey(hk); } SetLastError(Err); return (Err == NO_ERROR) ? hSubKey : INVALID_HANDLE_VALUE; } BOOL WINAPI SetupDiDeleteDeviceInterfaceRegKey( IN HDEVINFO DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, IN DWORD Reserved ) /*++ Routine Description: This routine deletes the registry key associated with a device interface. Arguments: DeviceInfoSet - Supplies a handle to the device information set containing the device interface whose registry key is to be deleted. DeviceInterfaceData - Supplies a pointer to a device interface data structure indicating which device interface is to have its registry key deleted. Reserved - Reserved for future use, must be set to 0. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. --*/ { HKEY hk; PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; if(Reserved != 0) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } hk = INVALID_HANDLE_VALUE; try { // // Get a pointer to the device information element for the specified // interface device. // if(!(DevInfoElem = FindDevInfoElemForInterfaceDevice(pDeviceInfoSet, DeviceInterfaceData))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } hk = SetupDiOpenClassRegKeyEx(&(DeviceInterfaceData->InterfaceClassGuid), KEY_READ, DIOCR_INTERFACE, NULL, NULL ); if(hk == INVALID_HANDLE_VALUE) { // // We couldn't open the interface class subkey--this should never happen. // Err = GetLastError(); goto clean0; } // // Now delete the interface device key. // Err = pSetupDeleteInterfaceDeviceKey(hk, pDeviceInfoSet, DeviceInterfaceData); clean0: ; // nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; // // Access the following registry handle so the compiler will respect statement // ordering w.r.t. its assignment. // hk = hk; } UnlockDeviceInfoSet(pDeviceInfoSet); if(hk != INVALID_HANDLE_VALUE) { RegCloseKey(hk); } SetLastError(Err); return(Err == NO_ERROR); } DWORD pSetupOpenOrCreateInterfaceDeviceRegKey( IN HKEY hInterfaceClassKey, IN PDEVICE_INFO_SET DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA InterfaceDeviceData, IN BOOL Create, IN REGSAM samDesired, OUT PHKEY hInterfaceDeviceKey ) /*++ Routine Description: This routine creates or opens a registry storage key for the specified interface device, and returns a handle to the opened key. Arguments: hInterfaceClassKey - Supplies a handle to the opened driver key, underneath which resides the interface device key to be deleted. DeviceInfoSet - Supplies a pointer to the device information set containing the interface device for which a registry storage key is to be created/opened. InterfaceDeviceData - Supplies a pointer to an interface device data structure indicating which interface device a key is to be opened/created for. Create - Specifies whether the key should be created if doesn't already exist. samDesired - Specifies the access you require for this key. hInterfaceDeviceKey - Supplies the address of a variable that receives a handle to the requested registry key. (This variable will only be written to if the handle is successfully opened.) Return Value: If the function is successful, the return value is NO_ERROR, otherwise, it is the ERROR_* code indicating the error that occurred. Remarks: The algorithm used to form the storage keys for an interface device must be kept in sync with the kernel mode implementation of IoOpenDeviceClassRegistryKey. --*/ { DWORD Err; PINTERFACE_DEVICE_NODE InterfaceDeviceNode; LPGUID ClassGuid; HKEY hInterfaceDeviceRootKey, hSubKey; DWORD Disposition; PCTSTR DevicePath; Err = NO_ERROR; hInterfaceDeviceRootKey = INVALID_HANDLE_VALUE; try { // // Get the interface device node, and verify that its class matches what the // caller passed us. // InterfaceDeviceNode = (PINTERFACE_DEVICE_NODE)(InterfaceDeviceData->Reserved); ClassGuid = &(DeviceInfoSet->GuidTable[InterfaceDeviceNode->GuidIndex]); if(!IsEqualGUID(ClassGuid, &(InterfaceDeviceData->InterfaceClassGuid))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } // // Verify that this interface device hasn't been removed. // if(InterfaceDeviceNode->Flags & SPINT_REMOVED) { Err = ERROR_DEVICE_INTERFACE_REMOVED; goto clean0; } // // OK, now open the interface device's root storage key. // DevicePath = pStringTableStringFromId(DeviceInfoSet->StringTable, InterfaceDeviceNode->SymLinkName ); if(ERROR_SUCCESS != OpenDeviceInterfaceSubKey(hInterfaceClassKey, DevicePath, KEY_READ, &hInterfaceDeviceRootKey, NULL, NULL)) { // // Make sure hInterfaceDeviceRootKey is still INVALID_HANDLE_VALUE, so we // won't try to close it later. // hInterfaceDeviceRootKey = INVALID_HANDLE_VALUE; Err = ERROR_INVALID_PARAMETER; goto clean0; } if(Create) { Err = RegCreateKeyEx(hInterfaceDeviceRootKey, pszDeviceParameters, 0, NULL, REG_OPTION_NON_VOLATILE, samDesired, NULL, &hSubKey, &Disposition ); } else { Err = RegOpenKeyEx(hInterfaceDeviceRootKey, pszDeviceParameters, 0, samDesired, &hSubKey ); } clean0: ; // nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; // // Access the following variable so the compiler will respect statement ordering // w.r.t. assignment. // hInterfaceDeviceRootKey = hInterfaceDeviceRootKey; } if(hInterfaceDeviceRootKey != INVALID_HANDLE_VALUE) { RegCloseKey(hInterfaceDeviceRootKey); } if(Err == NO_ERROR) { *hInterfaceDeviceKey = hSubKey; } return Err; } DWORD pSetupDeleteInterfaceDeviceKey( IN HKEY hInterfaceClassKey, IN PDEVICE_INFO_SET DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA InterfaceDeviceData ) /*++ Routine Description: This routine deletes an interface device registry key (recursively deleting any subkeys as well). Arguments: hInterfaceClassKey - Supplies the handle to the registry key underneath which the 2-level interface class hierarchy exists. DeviceInfoSet - Supplies a pointer to the device information set containing the interface device whose registry key is to be deleted. InterfaceDeviceData - Supplies a pointer to an interface device data structure indicating which interface device is to have its registry key deleted. Return Value: If successful, the return value is NO_ERROR; If failure, the return value is a Win32 error code indicating the cause of failure. --*/ { DWORD Err; PINTERFACE_DEVICE_NODE InterfaceDeviceNode; LPGUID ClassGuid; HKEY hInterfaceDeviceRootKey; PCTSTR DevicePath; Err = NO_ERROR; hInterfaceDeviceRootKey = INVALID_HANDLE_VALUE; try { // // Get the interface device node, and verify that its class matches what the // caller passed us. // InterfaceDeviceNode = (PINTERFACE_DEVICE_NODE)(InterfaceDeviceData->Reserved); ClassGuid = &(DeviceInfoSet->GuidTable[InterfaceDeviceNode->GuidIndex]); if(!IsEqualGUID(ClassGuid, &(InterfaceDeviceData->InterfaceClassGuid))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } // // Verify that this interface device hasn't been removed. // if(InterfaceDeviceNode->Flags & SPINT_REMOVED) { Err = ERROR_DEVICE_INTERFACE_REMOVED; goto clean0; } // // OK, now open the interface device's root storage key. // DevicePath = pStringTableStringFromId(DeviceInfoSet->StringTable, InterfaceDeviceNode->SymLinkName ); if(ERROR_SUCCESS != OpenDeviceInterfaceSubKey(hInterfaceClassKey, DevicePath, KEY_READ, &hInterfaceDeviceRootKey, NULL, NULL)) { // // Make sure hInterfaceDeviceRootKey is still INVALID_HANDLE_VALUE, so we // won't try to close it later. // hInterfaceDeviceRootKey = INVALID_HANDLE_VALUE; Err = ERROR_INVALID_PARAMETER; goto clean0; } Err = pSetupRegistryDelnode(hInterfaceDeviceRootKey, pszDeviceParameters); clean0: ; // nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; // // Access the following variable so the compiler will respect statement ordering // w.r.t. assignment. // hInterfaceDeviceRootKey = hInterfaceDeviceRootKey; } if(hInterfaceDeviceRootKey != INVALID_HANDLE_VALUE) { RegCloseKey(hInterfaceDeviceRootKey); } return Err; } #ifdef UNICODE BOOL WINAPI _SetupDiGetCustomDeviceProperty( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN CONST VOID *CustomPropertyName, // ANSI or Unicode, depending on "Ansi" param. IN DWORD Flags, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize, OPTIONAL IN BOOL Ansi ) { PDEVICE_INFO_SET pDeviceInfoSet; DWORD Err; PDEVINFO_ELEM DevInfoElem; CONFIGRET cr; ULONG PropLength, CmFlags; // // At present, there's only one valid flag... // if(Flags & ~DICUSTOMDEVPROP_MERGE_MULTISZ) { SetLastError(ERROR_INVALID_FLAGS); return FALSE; } if(!(pDeviceInfoSet = AccessDeviceInfoSet(DeviceInfoSet))) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } Err = NO_ERROR; try { // // Get a pointer to the element for the specified device // instance. // if(!(DevInfoElem = FindAssociatedDevInfoElem(pDeviceInfoSet, DeviceInfoData, NULL))) { Err = ERROR_INVALID_PARAMETER; goto clean0; } if(Flags & DICUSTOMDEVPROP_MERGE_MULTISZ) { CmFlags = CM_CUSTOMDEVPROP_MERGE_MULTISZ; } else { CmFlags = 0; } PropLength = PropertyBufferSize; if(Ansi) { cr = CM_Get_DevInst_Custom_Property_ExA( DevInfoElem->DevInst, CustomPropertyName, PropertyRegDataType, PropertyBuffer, &PropLength, CmFlags, pDeviceInfoSet->hMachine ); } else { cr = CM_Get_DevInst_Custom_Property_ExW( DevInfoElem->DevInst, CustomPropertyName, PropertyRegDataType, PropertyBuffer, &PropLength, CmFlags, pDeviceInfoSet->hMachine ); } if((cr == CR_SUCCESS) || (cr == CR_BUFFER_SMALL)) { if(RequiredSize) { *RequiredSize = PropLength; } } if(cr != CR_SUCCESS) { switch(cr) { case CR_INVALID_DEVINST : Err = ERROR_NO_SUCH_DEVINST; break; case CR_BUFFER_SMALL : Err = ERROR_INSUFFICIENT_BUFFER; break; case CR_NO_SUCH_VALUE : Err = ERROR_NOT_FOUND; break; default : Err = ERROR_INVALID_DATA; } } clean0: ; // Nothing to do. } except(EXCEPTION_EXECUTE_HANDLER) { Err = ERROR_INVALID_PARAMETER; } UnlockDeviceInfoSet(pDeviceInfoSet); SetLastError(Err); return (Err == NO_ERROR); } #endif #ifdef UNICODE // // Unicode version // BOOL WINAPI SetupDiGetCustomDevicePropertyW( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN PCWSTR CustomPropertyName, IN DWORD Flags, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) /*++ Routine Description: This routine retrieves the data for the specified property, either from the device information element's hardware key, or from the most-specific per-hardware-id storage key containing that property. Arguments: DeviceInfoSet -- Supplies a handle to the device information set containing information about the device instance to retrieve a Plug & Play registry property for. DeviceInfoData -- Supplies a pointer to a SP_DEVINFO_DATA structure indicating the device instance to retrieve the Plug & Play registry property for CustomPropertyName - Supplies the name of the property to be retrieved. Flags - Supplies flags controlling how the property data is to be retrieved. May be a combination of the following values: DICUSTOMDEVPROP_MERGE_MULTISZ : Merge the devnode-specific REG_SZ or REG_MULTI_SZ property (if present) with the per-hardware-id REG_SZ or REG_MULTI_SZ property (if present). The resultant data will always be a multi-sz list. PropertyRegDataType -- Optionally, supplies the address of a variable that will receive the data type of the property being retrieved. This will be one of the standard registry data types (REG_SZ, REG_BINARY, etc.) PropertyBuffer -- Supplies the address of a buffer that receives the property data. PropertyBufferSize -- Supplies the length, in bytes, of PropertyBuffer. RequiredSize -- Optionally, supplies the address of a variable that receives the number of bytes required to store the requested property in the buffer. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE. To get extended error information, call GetLastError. If the supplied buffer was not large enough to hold the requested property, the error will be ERROR_INSUFFICIENT_BUFFER and RequiredSize will specify how large the buffer needs to be. --*/ { BOOL b; b = _SetupDiGetCustomDeviceProperty( DeviceInfoSet, DeviceInfoData, CustomPropertyName, Flags, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize, FALSE // want Unicode results ); return(b); } // // ANSI version // BOOL WINAPI SetupDiGetCustomDevicePropertyA( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN PCSTR CustomPropertyName, IN DWORD Flags, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) /*++ Routine Description: (See SetupDiGetCustomDevicePropertyW) --*/ { BOOL b; b = _SetupDiGetCustomDeviceProperty( DeviceInfoSet, DeviceInfoData, CustomPropertyName, Flags, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize, TRUE // want ANSI results ); return(b); } #else // Both Unicode and ANSI stubs are unimplemented in ANSI setupapi... // // Unicode stub // BOOL WINAPI SetupDiGetCustomDevicePropertyW( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN PCWSTR CustomPropertyName, IN DWORD Flags, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) { UNREFERENCED_PARAMETER(DeviceInfoSet); UNREFERENCED_PARAMETER(DeviceInfoData); UNREFERENCED_PARAMETER(CustomPropertyName); UNREFERENCED_PARAMETER(Flags); UNREFERENCED_PARAMETER(PropertyRegDataType); UNREFERENCED_PARAMETER(PropertyBuffer); UNREFERENCED_PARAMETER(PropertyBufferSize); UNREFERENCED_PARAMETER(RequiredSize); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } // // ANSI stub // BOOL WINAPI SetupDiGetCustomDevicePropertyA( IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN PCSTR CustomPropertyName, IN DWORD Flags, OUT PDWORD PropertyRegDataType, OPTIONAL OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL ) { UNREFERENCED_PARAMETER(DeviceInfoSet); UNREFERENCED_PARAMETER(DeviceInfoData); UNREFERENCED_PARAMETER(CustomPropertyName); UNREFERENCED_PARAMETER(Flags); UNREFERENCED_PARAMETER(PropertyRegDataType); UNREFERENCED_PARAMETER(PropertyBuffer); UNREFERENCED_PARAMETER(PropertyBufferSize); UNREFERENCED_PARAMETER(RequiredSize); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } #endif