/*++ Copyright (c) 1995-2001 Microsoft Corporation Module Name: conflist.c Abstract: This module contains the API routines that manage conflict list reporting CM_Query_Resource_Conflict_List CM_Free_Resource_Conflict_Handle CM_Get_Resource_Conflict_Count CM_Get_Resource_Conflict_Details Author: Jamie Hunter (jamiehun) 4-14-1998 Environment: User mode only. Revision History: April-14-1998 jamiehun Addition of NT extended resource-conflict functions --*/ // // includes // #include "precomp.h" #include "cfgi.h" #include "setupapi.h" #include "spapip.h" typedef struct _CONFLICT_LIST_HEADER { HMACHINE Machine; // indicates relevent machine PPLUGPLAY_CONTROL_CONFLICT_LIST ConflictInfo; // data obtained via UMPNPMGR ULONG Signature; // marks this structure as a handle } CONFLICT_LIST_HEADER, *PCONFLICT_LIST_HEADER; // // Private prototypes // BOOL ValidateConfListHandle( PCONFLICT_LIST_HEADER pConfList ); VOID FreeConfListHandle( PCONFLICT_LIST_HEADER pConfList ); // // private prototypes from resdes.c // CONFIGRET CreateResDesHandle( PRES_DES prdResDes, DEVINST dnDevInst, ULONG ulLogType, ULONG ulLogTag, ULONG ulResType, ULONG ulResTag ); BOOL ValidateResDesHandle( PPrivate_Res_Des_Handle pResDes ); CONFIGRET Get32bitResDesFrom64bitResDes( IN RESOURCEID ResourceID, IN PCVOID ResData64, IN ULONG ResLen64, OUT PVOID * ResData32, OUT ULONG * ResLen32 ); // // private prototypes from logconf.c // CONFIGRET CreateLogConfHandle( PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulLogType, ULONG ulLogTag ); BOOL ValidateLogConfHandle( PPrivate_Log_Conf_Handle pLogConf ); // // API functions // CMAPI CONFIGRET WINAPI CM_Query_Resource_Conflict_List( OUT PCONFLICT_LIST pclConflictList, IN DEVINST dnDevInst, IN RESOURCEID ResourceID, IN PCVOID ResourceData, IN ULONG ResourceLen, IN ULONG ulFlags, IN HMACHINE hMachine ) /*++ Routine Description: Retrieves conflict list returns a handle for list Arguments: pclConflictList - holds returned conflict list handle dnDevInst Device we want to allocate a resource for ResourceID Type of resource, ResType_xxxx ResourceData Resource specific data ResourceLen length of ResourceData ulFlags Width of certain variable-size resource descriptor structure fields, where applicable. Currently, the following flags are defined: CM_RESDES_WIDTH_32 or CM_RESDES_WIDTH_64 If no flags are specified, the width of the variable-sized resource data supplied is assumed to be that native to the platform of the caller. hMachine - optional machine to query Return Value: CM status value --*/ { CONFIGRET Status = CR_SUCCESS; WCHAR DeviceID[MAX_DEVICE_ID_LEN]; PVOID hStringTable = NULL; handle_t hBinding = NULL; PPLUGPLAY_CONTROL_CONFLICT_LIST pConfList1 = NULL; PPLUGPLAY_CONTROL_CONFLICT_LIST pConfList2 = NULL; PCONFLICT_LIST_HEADER pConfListHeader = NULL; ULONG ConfListSize1; ULONG ConfListSize2; ULONG ulLen = MAX_DEVICE_ID_LEN; BOOL Success; PVOID ResourceData32 = NULL; ULONG ResourceLen32 = 0; try { // // validate parameters // if (dnDevInst == 0) { Status = CR_INVALID_DEVINST; goto Clean0; } if (INVALID_FLAGS(ulFlags, CM_RESDES_WIDTH_BITS)) { Status = CR_INVALID_FLAG; goto Clean0; } if ((ulFlags & CM_RESDES_WIDTH_32) && (ulFlags & CM_RESDES_WIDTH_64)) { Status = CR_INVALID_FLAG; goto Clean0; } #ifdef _WIN64 if ((ulFlags & CM_RESDES_WIDTH_BITS) == CM_RESDES_WIDTH_DEFAULT) { ulFlags |= CM_RESDES_WIDTH_64; } #endif // _WIN64 if (ulFlags & CM_RESDES_WIDTH_32) { ulFlags &= ~CM_RESDES_WIDTH_BITS; } if (pclConflictList == NULL) { Status = CR_INVALID_POINTER; goto Clean0; } if (ResourceData == NULL || ResourceLen == 0) { Status = CR_INVALID_POINTER; goto Clean0; } #if 0 if (ResourceID > ResType_MAX) { // ClassSpecific not allowed Status = CR_INVALID_RESOURCEID; goto Clean0; } #endif if (ResourceID == ResType_All) { Status = CR_INVALID_RESOURCEID; // can't specify All on a detect goto Clean0; } // // Initialize parameters // *pclConflictList = 0; // // setup rpc binding handle and string table handle // if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) { Status = CR_FAILURE; goto Clean0; } // // Make sure the server can support the client's 64-bit resdes request. // Only server versions 0x0501 and greater support CM_RESDES_WIDTH_64. // if (ulFlags & CM_RESDES_WIDTH_64) { if (!CM_Is_Version_Available_Ex((WORD)0x0501, hMachine)) { // // Server can only support 32-bit resdes. Have the client // convert the caller's 64-bit resdes to a 32-bit resdes for the // server. // ulFlags &= ~CM_RESDES_WIDTH_BITS; Status = Get32bitResDesFrom64bitResDes(ResourceID,ResourceData,ResourceLen,&ResourceData32,&ResourceLen32); if(Status != CR_SUCCESS) { goto Clean0; } if(ResourceData32) { ResourceData = ResourceData32; ResourceLen = ResourceLen32; } } } // // retreive device instance string that corresponds to dnDevInst // Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,DeviceID,&ulLen); if (Success == FALSE || INVALID_DEVINST(DeviceID)) { Status = CR_INVALID_DEVINST; goto Clean0; } pConfListHeader = (PCONFLICT_LIST_HEADER)pSetupMalloc(sizeof(CONFLICT_LIST_HEADER)); if (pConfListHeader == NULL) { Status = CR_OUT_OF_MEMORY; goto Clean0; } // // estimate size required to hold one conflict // ConfListSize1 = sizeof(PLUGPLAY_CONTROL_CONFLICT_LIST)+ // header + one entry sizeof(PLUGPLAY_CONTROL_CONFLICT_STRINGS)+ // strings marker (sizeof(WCHAR)*MAX_DEVICE_ID_LEN); // enough space for one string pConfList1 = (PPLUGPLAY_CONTROL_CONFLICT_LIST)pSetupMalloc(ConfListSize1); if (pConfList1 == NULL) { Status = CR_OUT_OF_MEMORY; goto Clean0; } // // first try // RpcTryExcept { // // call rpc service entry point // Status = PNP_QueryResConfList( hBinding, // rpc binding handle DeviceID, // device id string ResourceID, // resource type (LPBYTE)ResourceData, // actual res des data ResourceLen, // size in bytes of ResourceData (LPBYTE)pConfList1, // buffer ConfListSize1, // size of buffer ulFlags); // currently zero } RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) { KdPrintEx((DPFLTR_PNPMGR_ID, DBGF_ERRORS, "PNP_QueryResConfList (first pass) caused an exception (%d)\n", RpcExceptionCode())); Status = MapRpcExceptionToCR(RpcExceptionCode()); } RpcEndExcept if (Status != CR_SUCCESS) { goto Clean0; // quit for any error } if (pConfList1->ConflictsCounted > pConfList1->ConflictsListed) { // // need more space, multiple conflict // ConfListSize2 = pConfList1->RequiredBufferSize; pConfList2 = (PPLUGPLAY_CONTROL_CONFLICT_LIST)pSetupMalloc(ConfListSize2); if (pConfList2 != NULL) { // // Try to use this instead // RpcTryExcept { // // call rpc service entry point // Status = PNP_QueryResConfList( hBinding, // rpc binding handle DeviceID, // device id string ResourceID, // resource type (LPBYTE)ResourceData, // actual res des data ResourceLen, // size in bytes of ResourceData (LPBYTE)pConfList2, // buffer ConfListSize2, // size of buffer ulFlags); // currently zero } RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) { KdPrintEx((DPFLTR_PNPMGR_ID, DBGF_ERRORS, "PNP_QueryResConfList (second pass) caused an exception (%d)\n", RpcExceptionCode())); Status = MapRpcExceptionToCR(RpcExceptionCode()); } RpcEndExcept if (Status != CR_SUCCESS) { // // if we got error second time, but first time success // use what we got on first attempt // (I can't see this happening, but Murphey says it can) // pSetupFree(pConfList2); Status = CR_SUCCESS; } else { // // use second attempt // pSetupFree(pConfList1); pConfList1 = pConfList2; ConfListSize1 = ConfListSize2; } // // either way, we've deleted a buffer // pConfList2 = NULL; } } if(ConfListSize1 > pConfList1->RequiredBufferSize) { // // we can release some of the buffer we requested // ConfListSize2 = pConfList1->RequiredBufferSize; pConfList2 = (PPLUGPLAY_CONTROL_CONFLICT_LIST)pSetupRealloc(pConfList1,ConfListSize2); if(pConfList2) { // // success, we managed to save space // pConfList1 = pConfList2; ConfListSize1 = ConfListSize2; pConfList2 = NULL; } } // // if we get here, we have a successfully valid handle // pConfListHeader->Signature = CM_PRIVATE_CONFLIST_SIGNATURE; pConfListHeader->Machine = hMachine; pConfListHeader->ConflictInfo = pConfList1; *pclConflictList = (ULONG_PTR)pConfListHeader; pConfList1 = NULL; pConfListHeader = NULL; Clean0: NOTHING; } except(EXCEPTION_EXECUTE_HANDLER) { Status = CR_FAILURE; } // // cleanup // if (pConfListHeader != NULL) { pSetupFree(pConfListHeader); } if (pConfList1 != NULL) { pSetupFree(pConfList1); } if (pConfList2 != NULL) { pSetupFree(pConfList2); } if (ResourceData32) { pSetupFree(ResourceData32); } return Status; } // CM_Query_Resource_Conflict_List CMAPI CONFIGRET WINAPI CM_Free_Resource_Conflict_Handle( IN CONFLICT_LIST clConflictList ) /*++ Routine Description: Free's a conflict-list handle Arguments: clConflictList - handle of conflict list to free Return Value: CM status value --*/ { CONFIGRET Status = CR_SUCCESS; PCONFLICT_LIST_HEADER pConfList = NULL; try { // // Validate parameters // pConfList = (PCONFLICT_LIST_HEADER)clConflictList; if (!ValidateConfListHandle(pConfList)) { Status = CR_INVALID_CONFLICT_LIST; goto Clean0; } FreeConfListHandle(pConfList); Clean0: NOTHING; } except(EXCEPTION_EXECUTE_HANDLER) { Status = CR_FAILURE; } return Status; } CMAPI CONFIGRET WINAPI CM_Get_Resource_Conflict_Count( IN CONFLICT_LIST clConflictList, OUT PULONG pulCount ) /*++ Routine Description: Retrieves number of conflicts from list Arguments: clConflictList - handle of conflict list pulCount - filled with number of conflicts (0 if no conflicts) Return Value: CM status value --*/ { CONFIGRET Status = CR_SUCCESS; PCONFLICT_LIST_HEADER pConfList; try { // // Validate parameters // pConfList = (PCONFLICT_LIST_HEADER)clConflictList; if (!ValidateConfListHandle(pConfList)) { Status = CR_INVALID_CONFLICT_LIST; goto Clean0; } if (pulCount == NULL) { Status = CR_INVALID_POINTER; goto Clean0; } // // return count parameter // that can be used to iterate conflicts // *pulCount = pConfList->ConflictInfo->ConflictsListed; Clean0: NOTHING; } except(EXCEPTION_EXECUTE_HANDLER) { Status = CR_FAILURE; } return Status; } // CM_Free_Resource_Conflict_Handle CMAPI CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsW( IN CONFLICT_LIST clConflictList, IN ULONG ulIndex, IN OUT PCONFLICT_DETAILS_W pConflictDetails ) /*++ Routine Description: Retrieves conflict details for a specific conflict Arguments: clConflictList - handle of conflict list ulIndex - index of conflict to query, 0 to count-1 where count is obtained from CM_Get_Resource_Conflict_Count pConflictDetails - structure to be filled with conflict details must have CD_ulSize & CD_ulFlags initialized before calling function eg: pConflictDetails->CD_ulSize = sizeof(CONFLICT_DETAILS) pConflictDetails->CD_ulFlags = CM_CDMASK_ALL Return Value: CM status value --*/ { CONFIGRET Status = CR_SUCCESS; PCONFLICT_LIST_HEADER pConfList; PPLUGPLAY_CONTROL_CONFLICT_ENTRY pConfEntry; PWCHAR pString; ULONG ulFlags; PPLUGPLAY_CONTROL_CONFLICT_STRINGS ConfStrings; PVOID hStringTable = NULL; handle_t hBinding = NULL; HMACHINE hMachine = NULL; DEVINST dnDevInst; ULONG ulSize; try { // // Validate parameters // pConfList = (PCONFLICT_LIST_HEADER)clConflictList; if (!ValidateConfListHandle(pConfList)) { Status = CR_INVALID_CONFLICT_LIST; goto Clean0; } if (pConflictDetails == NULL) { Status = CR_INVALID_POINTER; goto Clean0; } if(pConflictDetails->CD_ulSize != sizeof(CONFLICT_DETAILS_W)) { // // currently only one structure size supported // Status = CR_INVALID_STRUCTURE_SIZE; goto Clean0; } if (INVALID_FLAGS(pConflictDetails->CD_ulMask, CM_CDMASK_VALID)) { // // CM_CDMASK_VALID describes the bits that are supported // Status = CR_INVALID_FLAG; goto Clean0; } if (pConflictDetails->CD_ulMask == 0) { // // must want something // Status = CR_INVALID_FLAG; goto Clean0; } if(ulIndex >= pConfList->ConflictInfo->ConflictsListed) { // // validate index // Status = CR_INVALID_INDEX; goto Clean0; } hMachine = (HMACHINE)(pConfList->Machine); if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) { // // handles // Status = CR_FAILURE; goto Clean0; } ConfStrings = (PPLUGPLAY_CONTROL_CONFLICT_STRINGS)&(pConfList->ConflictInfo->ConflictEntry[pConfList->ConflictInfo->ConflictsListed]); pConfEntry = pConfList->ConflictInfo->ConflictEntry + ulIndex; pString = ConfStrings->DeviceInstanceStrings + pConfEntry->DeviceInstance; // the string for this entry // // init requested parameters // ulFlags = pConflictDetails->CD_ulMask; pConflictDetails->CD_ulMask = 0; if (IS_FLAG_SET(ulFlags , CM_CDMASK_DEVINST)) { pConflictDetails->CD_dnDevInst = 0; } if (IS_FLAG_SET(ulFlags , CM_CDMASK_RESDES)) { pConflictDetails->CD_rdResDes = 0; } if (IS_FLAG_SET(ulFlags , CM_CDMASK_FLAGS)) { pConflictDetails->CD_ulFlags = 0; } if (IS_FLAG_SET(ulFlags , CM_CDMASK_DESCRIPTION)) { pConflictDetails->CD_szDescription[0] = 0; } // // fill in requested parameters // if (IS_FLAG_SET(ulFlags , CM_CDMASK_DEVINST)) { if (pString[0] == 0 || IS_FLAG_SET(pConfEntry->DeviceFlags,PNP_CE_LEGACY_DRIVER)) { // // not a valid dev-instance // dnDevInst = -1; } else { // // lookup DeviceID // ASSERT(pString && *pString && IsLegalDeviceId(pString)); dnDevInst = (DEVINST)pSetupStringTableAddString(hStringTable, pString, STRTAB_CASE_SENSITIVE); if (dnDevInst == (DEVINST)(-1)) { Status = CR_OUT_OF_MEMORY; // probably out of memory goto Clean0; } } pConflictDetails->CD_dnDevInst = dnDevInst; pConflictDetails->CD_ulMask |= CM_CDMASK_DEVINST; } if (IS_FLAG_SET(ulFlags , CM_CDMASK_RESDES)) { // // not implemented yet // pConflictDetails->CD_rdResDes = 0; } if (IS_FLAG_SET(ulFlags , CM_CDMASK_FLAGS)) { // // convert flags // pConflictDetails->CD_ulFlags = 0; if(IS_FLAG_SET(pConfEntry->DeviceFlags,PNP_CE_LEGACY_DRIVER)) { // // description describes a driver, not a device // pConflictDetails->CD_ulFlags |= CM_CDFLAGS_DRIVER; } if(IS_FLAG_SET(pConfEntry->DeviceFlags,PNP_CE_ROOT_OWNED)) { // // resource is owned by root device // pConflictDetails->CD_ulFlags |= CM_CDFLAGS_ROOT_OWNED; } if(IS_FLAG_SET(pConfEntry->DeviceFlags,PNP_CE_TRANSLATE_FAILED) || IS_FLAG_SET(pConfEntry->DeviceFlags,PNP_CE_ROOT_OWNED)) { // // resource cannot be allocated, but no descriptive text // pConflictDetails->CD_ulFlags |= CM_CDFLAGS_RESERVED; } } if (IS_FLAG_SET(ulFlags , CM_CDMASK_DESCRIPTION)) { if (pString[0] == 0 || IS_FLAG_SET(pConfEntry->DeviceFlags,PNP_CE_LEGACY_DRIVER)) { // // copy string directly, specifies legacy driver (or nothing for unavailable) // lstrcpynW(pConflictDetails->CD_szDescription,pString,MAX_PATH); } else { // // copy a descriptive name for P&P device // ASSERT(pString && *pString && IsLegalDeviceId(pString)); dnDevInst = (DEVINST)pSetupStringTableAddString(hStringTable, pString, STRTAB_CASE_SENSITIVE); if (dnDevInst == (DEVINST)(-1)) { Status = CR_OUT_OF_MEMORY; // probably out of memory goto Clean0; } ulSize = sizeof(pConflictDetails->CD_szDescription); if (CM_Get_DevNode_Registry_Property_ExW(dnDevInst, CM_DRP_FRIENDLYNAME, NULL, (LPBYTE)(pConflictDetails->CD_szDescription), &ulSize, 0,hMachine) != CR_SUCCESS) { ulSize = sizeof(pConflictDetails->CD_szDescription); if (CM_Get_DevNode_Registry_Property_ExW(dnDevInst, CM_DRP_DEVICEDESC, NULL, (LPBYTE)(pConflictDetails->CD_szDescription), &ulSize, 0,hMachine) != CR_SUCCESS) { // // unknown // pConflictDetails->CD_szDescription[0] = 0; } } } pConflictDetails->CD_ulMask |= CM_CDMASK_DESCRIPTION; } Clean0: NOTHING; } except(EXCEPTION_EXECUTE_HANDLER) { Status = CR_FAILURE; } return Status; } // CM_Get_Resource_Conflict_DetailsW BOOL ValidateConfListHandle( PCONFLICT_LIST_HEADER pConfList ) /*++ Routine Description: Validates a conflict-list handle pConfList must not be null, and must contain a valid signature Arguments: pConfList - handle to conflict list Return Value: TRUE if valid, FALSE if not valid --*/ { // // validate parameters // if (pConfList == NULL) { return FALSE; } // // check for the private conflict list signature // if (pConfList->Signature != CM_PRIVATE_CONFLIST_SIGNATURE) { return FALSE; } return TRUE; } // ValidateConfListHandle VOID FreeConfListHandle( PCONFLICT_LIST_HEADER pConfList ) /*++ Routine Description: Releases memory allocated for Conflict List Makes sure Signature is invalid Arguments: pConfList - valid handle to conflict list Return Value: none --*/ { if(pConfList != NULL) { pConfList->Signature = 0; if(pConfList->ConflictInfo) { pSetupFree(pConfList->ConflictInfo); } pSetupFree(pConfList); } return; } // FreeConfListHandle //------------------------------------------------------------------- // ANSI STUBS //------------------------------------------------------------------- CMAPI CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsA( IN CONFLICT_LIST clConflictList, IN ULONG ulIndex, IN OUT PCONFLICT_DETAILS_A pConflictDetails ) /*++ Routine Description: Ansi version of CM_Get_Resource_Conflict_DetailsW --*/ { CONFLICT_DETAILS_W detailsW; CONFIGRET Status = CR_SUCCESS; ULONG ulAnsiLength; try { // // Validate parameters we need for Ansi part // further validation occurs in Wide-char part // if (pConflictDetails == NULL) { Status = CR_INVALID_POINTER; goto Clean0; } if(pConflictDetails->CD_ulSize != sizeof(CONFLICT_DETAILS_A)) { // // currently only one structure size supported // Status = CR_INVALID_STRUCTURE_SIZE; goto Clean0; } if (INVALID_FLAGS(pConflictDetails->CD_ulMask, CM_CDMASK_VALID)) { // // CM_CDMASK_VALID describes the bits that are supported // Status = CR_INVALID_FLAG; goto Clean0; } if (pConflictDetails->CD_ulMask == 0) { // // must want something // Status = CR_INVALID_FLAG; goto Clean0; } ZeroMemory(&detailsW,sizeof(detailsW)); detailsW.CD_ulSize = sizeof(detailsW); detailsW.CD_ulMask = pConflictDetails->CD_ulMask; Status = CM_Get_Resource_Conflict_DetailsW(clConflictList,ulIndex,&detailsW); if (Status != CR_SUCCESS) { goto Clean0; } // // copy details // pConflictDetails->CD_ulMask = detailsW.CD_ulMask; if (IS_FLAG_SET(detailsW.CD_ulMask , CM_CDMASK_DEVINST)) { pConflictDetails->CD_dnDevInst = detailsW.CD_dnDevInst; } if (IS_FLAG_SET(detailsW.CD_ulMask , CM_CDMASK_RESDES)) { pConflictDetails->CD_rdResDes = detailsW.CD_rdResDes; } if (IS_FLAG_SET(detailsW.CD_ulMask , CM_CDMASK_FLAGS)) { pConflictDetails->CD_ulFlags = detailsW.CD_ulFlags; } if (IS_FLAG_SET(detailsW.CD_ulMask , CM_CDMASK_DESCRIPTION)) { pConflictDetails->CD_szDescription[0] = 0; // // need to convery from UNICODE to ANSI // ulAnsiLength = MAX_PATH; Status = PnPUnicodeToMultiByte(detailsW.CD_szDescription, MAX_PATH*sizeof(WCHAR), pConflictDetails->CD_szDescription, &ulAnsiLength); if (Status != CR_SUCCESS) { // // error occurred // Status = CR_FAILURE; } } Clean0: NOTHING; } except(EXCEPTION_EXECUTE_HANDLER) { Status = CR_FAILURE; } return Status; } // CM_Get_Resource_Conflict_DetailsA