able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/idwlog/netinfo.cpp

1063 lines
25 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
#include <string.h>
#include <regstr.h>
#include <cfgmgr32.h>
#include "netinfo.h"
// Globals
DEV_INFO *g_pdiDevList; // Head of device list
/*++
Routine Description: (21) GetDevNodeInfoAndCreateNewDevInfoNode
Creates new list node, then gets registry and resource information for
a specific device and copies it into that node. Finally, adds new node
to beginning of linked list
Arguments:
dnDevNode: the device to find information about
szDevNodeID: the registry path name of the device
szEnumBuffer: name of enumerator this device is under
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL GetDevNodeInfoAndCreateNewDevInfoNode(IN DEVNODE dnDevNode,
IN PTCHAR szDevNodeID,
IN PTCHAR szEnumBuffer)
{
LOG_CONF lcLogConf = 0, lcLogConfNew;
CONFIGRET cmret, cmret2;
PDEV_INFO pdiDevInfo=(PDEV_INFO)malloc(sizeof(DEV_INFO));
int i;
BOOL boolForcedFound = FALSE, boolAllocFound = FALSE;
USHORT ushLogConfType[4] = {BOOT_LOG_CONF, ALLOC_LOG_CONF, BASIC_LOG_CONF, FORCED_LOG_CONF};
if (pdiDevInfo == NULL)
goto RetFALSE;
// If this is not a PnP device, skip it
if (!lstrcmpi(szEnumBuffer, TEXT("Root"))) {
free(pdiDevInfo);
goto RetTRUE;
}
//
// Initialize fields inside the node
//
if (!InitializeInfoNode(pdiDevInfo, szDevNodeID, dnDevNode)) {
// This is a device we don't want to list. Skip it
free(pdiDevInfo);
goto RetTRUE;
}
for (i = 0; i < NUM_LOG_CONF_TYPES; i++) {
// Get logical configuration information
cmret = CM_Get_First_Log_Conf(&lcLogConfNew,
dnDevNode,
ushLogConfType[i]);
while (CR_SUCCESS == cmret) {
lcLogConf = lcLogConfNew;
if (ALLOC_LOG_CONF == ushLogConfType[i]) {
boolAllocFound = TRUE;
}
if (!(GetResDesList(pdiDevInfo, lcLogConf, ushLogConfType[i]))) {
goto RetFALSE;
}
cmret = CM_Get_Next_Log_Conf(&lcLogConfNew,
lcLogConf,
0);
cmret2 = CM_Free_Log_Conf_Handle(lcLogConf);
}
}
//
// If device has no Alloc configurations, skip
// to the next device
//
if (!boolAllocFound) {
//free(pdiDevInfo);
//goto RetTRUE;
}
//
// Insert new pdiDevInfo into Linked List of DevNodes
//
if (g_pdiDevList == NULL) {
//
// DevList is empty
//
g_pdiDevList = pdiDevInfo;
} else {
//
// Add new pdiDevInfo to beginning of linked list
//
pdiDevInfo->Next = g_pdiDevList;
g_pdiDevList->Prev = pdiDevInfo;
g_pdiDevList = pdiDevInfo;
}
RetTRUE:
return TRUE;
RetFALSE:
return FALSE;
}
/*++
Routine Description: (20) ParseEnumerator
Gets devices listed under enumerator name in registry
Arguments:
szEnumBuffer: the enumerator name
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL
ParseEnumerator(IN PTCHAR szEnumBuffer)
{
PTCHAR szDevIDBuffer = NULL;
PTCHAR szDevNodeID = NULL;
ULONG ulDevIDBufferLen = 0, ulCount = 0, ulStart = 0;
CONFIGRET cmret = CR_SUCCESS;
DEVNODE dnDevNode;
BOOL bReturn = TRUE;
//
// Get buffer length
//
cmret = CM_Get_Device_ID_List_Size(&ulDevIDBufferLen,
szEnumBuffer,
CM_GETIDLIST_FILTER_ENUMERATOR);
if (CR_SUCCESS != cmret) {
//ErrorLog(20, TEXT("CM_Get_Device_ID_List_Size"), cmret, NULL);
bReturn = FALSE;
goto RetFALSE;
}
if ((szDevIDBuffer =(PTCHAR) malloc(sizeof(TCHAR) * ulDevIDBufferLen)) == NULL ||
(szDevNodeID =(PTCHAR) malloc(sizeof(TCHAR) * ulDevIDBufferLen)) == NULL) {
bReturn = FALSE;
goto RetFALSE;
}
//
// Get the Device ID List
//
cmret = CM_Get_Device_ID_List(szEnumBuffer,
szDevIDBuffer,
ulDevIDBufferLen,
CM_GETIDLIST_FILTER_ENUMERATOR);
if (CR_SUCCESS != cmret) {
//ErrorLog(20, TEXT("CM_Get_Device_ID_List"), cmret, NULL);
bReturn = FALSE;
goto RetFALSE;
}
//
// Note that ulDevIDBufferLen is a loose upper bound. The API may have
// returned a size greater than the actual size of the list of strings.
//
for (ulCount = 0; ulCount < ulDevIDBufferLen; ulCount++) {
ulStart = ulCount;
if (szDevIDBuffer[ulCount] != '\0') {
cmret = CM_Locate_DevNode(&dnDevNode,
szDevIDBuffer + ulCount,
CM_LOCATE_DEVNODE_NORMAL);
//
// Go to the next substring
//
while (szDevIDBuffer[ulCount] != TEXT('\0')) {
ulCount++;
}
// Stop when we reach the double-NULL terminator
if (szDevIDBuffer[ulCount+1] == TEXT('\0')) {
ulCount=ulDevIDBufferLen;
continue;
}
if (cmret == CR_SUCCESS) {
_tcsncpy(szDevNodeID, szDevIDBuffer + ulStart, ulDevIDBufferLen);
// Found the DevNode, so add its information to the device list
if (!(GetDevNodeInfoAndCreateNewDevInfoNode(dnDevNode,
szDevNodeID,
szEnumBuffer))) {
bReturn = FALSE;
goto RetFALSE;
}
}
}
}
bReturn = TRUE;
RetFALSE:
// fix to rajeshm old code. Selective free bug number 137987
if (NULL != szDevIDBuffer)
free (szDevIDBuffer);
if (NULL != szDevNodeID)
free (szDevNodeID);
return bReturn;
}
void
CollectDevData() {
CONFIGRET cmret = CR_SUCCESS;
ULONG ulIndexNum = 0;
ULONG ulEnumBufferLen = 0;
PTCHAR szEnumBuffer;
szEnumBuffer = (PTCHAR) malloc(sizeof(TCHAR) * MAX_DEVNODE_ID_LEN);
if (NULL == szEnumBuffer)
return;
for (ulIndexNum = 0; cmret == CR_SUCCESS; ulIndexNum++) {
ulEnumBufferLen = MAX_DEVNODE_ID_LEN;
cmret = CM_Enumerate_Enumerators( ulIndexNum,
szEnumBuffer,
&ulEnumBufferLen,
0);
if (cmret == CR_SUCCESS)
ParseEnumerator(szEnumBuffer);
}
free (szEnumBuffer);
}
BOOL CopyRegistryLine(IN DEVNODE dnDevNode,
IN ULONG ulPropertyType,
IN PDEV_INFO pdiDevInfo)
/*++
Routine Description: (22) CopyRegistryLine
Copies one specific string of registry data to new list node
Arguments:
dnDevNode: the device to get information about
ulpropertyType: which registry string to get
pdiDevInfo: the new list node
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
{
ULONG ulRegDataLen = 0, ulRegDataType = 0;
CONFIGRET cmret = CR_SUCCESS;
PTCHAR szRegData = NULL;
//
// Get the length of the buffer don't bother checking return value
// If RegProperty doesn't exist, we'll just move on
//
CM_Get_DevNode_Registry_Property(dnDevNode,
ulPropertyType,
NULL,
NULL,
&ulRegDataLen,
0);
if (!ulRegDataLen ||
(szRegData = (PTCHAR) malloc(sizeof(TCHAR) * ulRegDataLen)) == NULL) {
goto RetFALSE;
}
//
// Now get the registry information
//
cmret = CM_Get_DevNode_Registry_Property( dnDevNode,
ulPropertyType,
&ulRegDataType,
szRegData,
&ulRegDataLen,
0);
if (CR_SUCCESS == cmret) {
if (!(CopyRegDataToDevInfoNode(pdiDevInfo,
ulPropertyType,
szRegData))) {
goto RetFALSE;
}
}
if (szRegData == NULL)
free (szRegData);
return TRUE;
RetFALSE:
return FALSE;
} /* CopyRegistryLine */
/*++
Routine Description: (23) CopyRegDataToDevInfoNode
Copies a registry string to a list node
Arguments:
pdiDevInfo: the new list node
ulPropertyType: which registry string to copy
szRegData: the data to be copied
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL CopyRegDataToDevInfoNode(IN OUT PDEV_INFO pdiDevInfo,
IN ULONG ulPropertyType,
IN PTCHAR szRegData)
{
if (pdiDevInfo == NULL) {
goto RetFALSE;
}
switch (ulPropertyType) {
case CM_DRP_DEVICEDESC:
_tcsncpy(pdiDevInfo->szDescription, szRegData, MAX_PATH );
break;
case CM_DRP_HARDWAREID:
_tcsncpy(pdiDevInfo->szHardwareID, szRegData, MAX_PATH );
break;
case CM_DRP_SERVICE:
_tcsncpy(pdiDevInfo->szService, szRegData, MAX_PATH );
break;
case CM_DRP_CLASS:
_tcsncpy(pdiDevInfo->szClass, szRegData, MAX_PATH );
break;
case CM_DRP_MFG:
_tcsncpy(pdiDevInfo->szManufacturer, szRegData, MAX_PATH );
break;
case CM_DRP_CONFIGFLAGS:
_tcsncpy(pdiDevInfo->szConfigFlags, szRegData, MAX_PATH );
break;
}
return TRUE;
RetFALSE:
return FALSE;
} /* CopyRegDataToDevInfoNode */
/*++
Routine Description: (58) InitializeInfoNode
Initialized fields inside the new node
Arguments:
pdiDevInfo: the node
szDevNodeID: used to find the dnDevNode in the future
dnDevNode: the device we're storing information about
Return Value:
BOOL: TRUE if we should keep this node, FALSE if we should throw it away
--*/
BOOL InitializeInfoNode(IN PDEV_INFO pdiDevInfo,
IN PTCHAR szDevNodeID,
IN DEVNODE dnDevNode)
{
if (pdiDevInfo) {
pdiDevInfo->Next = NULL;
pdiDevInfo->Prev = NULL;
pdiDevInfo->szDevNodeID[0] = TEXT('\0');
pdiDevInfo->szDescription[0] = TEXT('\0');
pdiDevInfo->szHardwareID[0] = TEXT('\0');
pdiDevInfo->szService[0] = TEXT('\0');
pdiDevInfo->szClass[0] = TEXT('\0');
pdiDevInfo->szManufacturer[0] = TEXT('\0');
pdiDevInfo->szConfigFlags[0] = TEXT('\0');
pdiDevInfo->szFriendlyName[0] = TEXT('\0');
pdiDevInfo->boolSavedOrigConfiguration = FALSE;
pdiDevInfo->boolDisabled = FALSE;
pdiDevInfo->prddForcedResDesData = NULL;
pdiDevInfo->prddAllocResDesData = NULL;
pdiDevInfo->prddBasicResDesData = NULL;
pdiDevInfo->prddBootResDesData = NULL;
//
// Store devNodeID in pdiDevInfo to get handles to devnode in future
//
_tcsncpy(pdiDevInfo->szDevNodeID, szDevNodeID, MAX_PATH);
// Extract information from the registry about this DevNode
CopyRegistryLine(dnDevNode, CM_DRP_DEVICEDESC, pdiDevInfo);
CopyRegistryLine(dnDevNode, CM_DRP_HARDWAREID, pdiDevInfo);
CopyRegistryLine(dnDevNode, CM_DRP_SERVICE, pdiDevInfo);
CopyRegistryLine(dnDevNode, CM_DRP_CLASS, pdiDevInfo);
CopyRegistryLine(dnDevNode, CM_DRP_MFG, pdiDevInfo);
CopyRegistryLine(dnDevNode, CM_DRP_CONFIGFLAGS, pdiDevInfo);
RecordFriendlyName(pdiDevInfo);
}
//
// Check the friendly name to see if we want to throw this node away
//
if (strcmp(pdiDevInfo->szFriendlyName, "STORAGE/Volume") == 0 ||
strcmp(pdiDevInfo->szFriendlyName, "Unknown Device") == 0) {
return FALSE;
}
return TRUE;
} /* InitializeInfoNode */
/*++
Routine Description: (57) RecordFriendlyName
Finds the best user friendly name for this device
Arguments:
pdiDevInfo: node containing all possible names
Return Value:
void
--*/
void
RecordFriendlyName(IN PDEV_INFO pdiDevInfo)
{
if (pdiDevInfo) {
if (pdiDevInfo->szDescription && pdiDevInfo->szDescription[0] != TEXT('\0'))
_tcsncpy(pdiDevInfo->szFriendlyName, pdiDevInfo->szDescription, MAX_PATH );
else if (pdiDevInfo->szHardwareID && pdiDevInfo->szHardwareID[0] != TEXT('\0'))
_tcsncpy(pdiDevInfo->szFriendlyName, pdiDevInfo->szHardwareID, MAX_PATH);
else if (pdiDevInfo->szManufacturer && pdiDevInfo->szManufacturer[0] != TEXT('\0'))
_tcsncpy(pdiDevInfo->szFriendlyName, pdiDevInfo->szHardwareID, MAX_PATH);
else if (pdiDevInfo->szService && pdiDevInfo->szService[0] != TEXT('\0'))
_tcsncpy(pdiDevInfo->szFriendlyName, pdiDevInfo->szService, MAX_PATH);
else if (pdiDevInfo->szClass && pdiDevInfo->szClass[0] != TEXT('\0'))
_tcsncpy(pdiDevInfo->szFriendlyName, pdiDevInfo->szClass, MAX_PATH);
else
_tcscpy(pdiDevInfo->szFriendlyName, TEXT("Unknown Device"));
}
} /* RecordFriendlyName */
/*++
Routine Description: (24) GetResDesList
Creates new resource data node and copies resource information to that node
Arguments:
pdiDevInfo: the list node which will contain the new resource node
lcLogConf: the logical configuration information
ulLogConfType: FORCED, ALLOC, BOOT, or BASIC logical configuration
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL
GetResDesList(IN OUT PDEV_INFO pdiDevInfo,
IN LOG_CONF lcLogConf,
IN ULONG ulLogConfType)
{
CONFIGRET cmret, cmret2;
RES_DES rdResDes = 0, rdResDesNew;
RESOURCEID ridResourceID = 0;
PRES_DES_DATA prddResDesData;
prddResDesData = (PRES_DES_DATA)malloc(sizeof(RES_DES_DATA));
if (prddResDesData == NULL)
goto c0;
prddResDesData->Next = NULL;
prddResDesData->Prev = NULL;
prddResDesData->pmresMEMResource = NULL;
prddResDesData->piresIOResource = NULL;
prddResDesData->pdresDMAResource = NULL;
prddResDesData->pqresIRQResource = NULL;
cmret = CM_Get_Next_Res_Des(&rdResDesNew,
lcLogConf,
ResType_All,
&ridResourceID,
0);
//
// Go through each resource type and copy data to new node
//
while (CR_SUCCESS == cmret) {
rdResDes = rdResDesNew;
if (ridResourceID >= ResType_Mem && ridResourceID <= ResType_IRQ) {
if (!(ProcessResDesInfo(prddResDesData,
rdResDes,
ridResourceID))) {
goto c1;
}
}
cmret = CM_Get_Next_Res_Des(&rdResDesNew,
rdResDes,
ResType_All,
&ridResourceID,
0);
cmret2 = CM_Free_Res_Des_Handle(rdResDes);
if (cmret2 != CR_SUCCESS) {
//ErrorLog(24, TEXT("CM_Free_Res_Des_Handle"), cmret2, NULL);
}
}
// Add the new node to the linked list
switch (ulLogConfType) {
case FORCED_LOG_CONF:
if (!pdiDevInfo->prddForcedResDesData) {
//
// This is the first entry into the linked list
//
pdiDevInfo->prddForcedResDesData = prddResDesData;
} else {
//
// Add new node to beginning of linked list
//
prddResDesData->Next = pdiDevInfo->prddForcedResDesData;
pdiDevInfo->prddForcedResDesData->Prev = prddResDesData;
pdiDevInfo->prddForcedResDesData = prddResDesData;
}
break;
case ALLOC_LOG_CONF:
if (!pdiDevInfo->prddAllocResDesData) {
//
// This is the first entry into the linked list
//
pdiDevInfo->prddAllocResDesData = prddResDesData;
} else {
//
// Add new node to beginning of linked list
//
prddResDesData->Next = pdiDevInfo->prddAllocResDesData;
pdiDevInfo->prddAllocResDesData->Prev = prddResDesData;
pdiDevInfo->prddAllocResDesData = prddResDesData;
}
break;
case BASIC_LOG_CONF:
if (!pdiDevInfo->prddBasicResDesData) {
//
// This is the first entry into the linked list
//
pdiDevInfo->prddBasicResDesData = prddResDesData;
} else {
//
// Add new node to beginning of linked list
//
prddResDesData->Next = pdiDevInfo->prddBasicResDesData;
pdiDevInfo->prddBasicResDesData->Prev = prddResDesData;
pdiDevInfo->prddBasicResDesData = prddResDesData;
}
break;
case BOOT_LOG_CONF:
if (!pdiDevInfo->prddBootResDesData) {
//
// This is the first entry into the linked list
//
pdiDevInfo->prddBootResDesData = prddResDesData;
} else {
//
// Add new node to beginning of linked list
//
prddResDesData->Next = pdiDevInfo->prddBootResDesData;
pdiDevInfo->prddBootResDesData->Prev = prddResDesData;
pdiDevInfo->prddBootResDesData = prddResDesData;
}
break;
default:
goto c1;
}
return TRUE;
c1:
free(prddResDesData);
c0:
return FALSE;
}
/* GetResDestList */
/*++
Routine Description: (25) ProcessResDesInfo
Gets information for one resource descriptor
Arguments:
prddResDesData: the new resource data node receiving the info
rdResDes: the resource descriptor containing the info
ridResourceID: tells the resource type (DMA, IO, MEM, IRQ, or CS)
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL
ProcessResDesInfo(IN OUT PRES_DES_DATA prddResDesData,
IN RES_DES rdResDes,
IN RESOURCEID ridResourceID)
{
PVOID pvResDesDataBuffer = NULL;
ULONG ulResDesDataBufferLen;
CONFIGRET cmret;
cmret = CM_Get_Res_Des_Data_Size(&ulResDesDataBufferLen,
rdResDes,
0);
if (CR_SUCCESS != cmret) {
//ErrorLog(25, TEXT("CM_Get_Res_Des_Data_Size"), cmret, NULL);
goto RetFALSE;
}
if ((pvResDesDataBuffer = malloc(sizeof(PVOID) * ulResDesDataBufferLen))
== NULL) {
// Log(25, SEV2, TEXT("resDesDataBuffer malloc size of %d failed."),
// ulResDesDataBufferLen);
goto RetFALSE;
}
//
// Get the data
//
cmret = CM_Get_Res_Des_Data(rdResDes,
pvResDesDataBuffer,
ulResDesDataBufferLen,
0);
if (CR_SUCCESS != cmret) {
//ErrorLog(25, TEXT("CM_Get_Res_Des_Data"), cmret, NULL);
goto RetFALSE;
}
//
// Copy data into ResDesData node
//
switch (ridResourceID) {
case ResType_Mem:
prddResDesData->pmresMEMResource = (PMEM_RESOURCE)pvResDesDataBuffer;
break;
case ResType_IO:
prddResDesData->piresIOResource = (PIO_RESOURCE)pvResDesDataBuffer;
break;
case ResType_DMA:
prddResDesData->pdresDMAResource = (PDMA_RESOURCE)pvResDesDataBuffer;
break;
case ResType_IRQ:
prddResDesData->pqresIRQResource = (PIRQ_RESOURCE)pvResDesDataBuffer;
break;
default:
// Log(25, SEV2, TEXT("Illegal ResourceID - %ul"), ridResourceID);
goto RetFALSE;
}
return TRUE;
RetFALSE:
return FALSE;
} /* ProcessResDesInfo */
/*++
Routine Description: (26) UpdateDeviceList
Frees resource information for all devices and then collects the
information again
Arguments:
none (g_pdiDevList is global head of device list)
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL UpdateDeviceList()
{
PDEV_INFO pdiTmpDevInfo;
pdiTmpDevInfo = g_pdiDevList;
//
// Go through linked list and delete each node's ResDes lists
//
while (pdiTmpDevInfo) {
if (pdiTmpDevInfo->prddForcedResDesData) {
DeleteResDesDataNode(pdiTmpDevInfo->prddForcedResDesData);
pdiTmpDevInfo->prddForcedResDesData = NULL;
}
if (pdiTmpDevInfo->prddAllocResDesData) {
DeleteResDesDataNode(pdiTmpDevInfo->prddAllocResDesData);
pdiTmpDevInfo->prddAllocResDesData = NULL;
}
if (pdiTmpDevInfo->prddBasicResDesData) {
DeleteResDesDataNode(pdiTmpDevInfo->prddBasicResDesData);
pdiTmpDevInfo->prddBasicResDesData = NULL;
}
if (pdiTmpDevInfo->prddBootResDesData) {
DeleteResDesDataNode(pdiTmpDevInfo->prddBootResDesData);
pdiTmpDevInfo->prddBootResDesData = NULL;
}
pdiTmpDevInfo = pdiTmpDevInfo->Next;
}
pdiTmpDevInfo = g_pdiDevList;
//
// Recreate the ResDesLists for each node
//
while (pdiTmpDevInfo) {
if (!(RecreateResDesList(pdiTmpDevInfo, FORCED_LOG_CONF)))
goto RetFALSE;
if (!(RecreateResDesList(pdiTmpDevInfo, ALLOC_LOG_CONF)))
goto RetFALSE;
if (!(RecreateResDesList(pdiTmpDevInfo, BASIC_LOG_CONF)))
goto RetFALSE;
if (!(RecreateResDesList(pdiTmpDevInfo, BOOT_LOG_CONF)))
goto RetFALSE;
pdiTmpDevInfo = pdiTmpDevInfo->Next;
}
return TRUE;
RetFALSE:
return FALSE;
} /* UpdateDeviceList */
/*++
Routine Description: (27) DeleteResDesDataNode
Deletes a string of RES_DES_DATA structures
Arguments:
prddTmpResDes: the head of the linked list
Return Value:
void
--*/
void
DeleteResDesDataNode(IN PRES_DES_DATA prddTmpResDes)
{
PRES_DES_DATA prddNextResDes;
while (prddTmpResDes) {
prddNextResDes = prddTmpResDes->Next;
free (prddTmpResDes);
prddTmpResDes = prddNextResDes;
}
} /* DeleteResDesDataNode */
/*++
Routine Description: (56) CopyDataToLogConf
Calls CM_Add_Res_Des to add a resDes to a lcLogConf
Arguments:
lcLogConf: the lcLogConf receiving the resDes
ridResType: ResType_Mem, IO, DMA or IRQ
pvResData: the new data
ulResourceLen: size of the data
Return Value:
BOOL: TRUE if the CM call succeeds, FALSE if not
--*/
BOOL
CopyDataToLogConf(IN LOG_CONF lcLogConf,
IN RESOURCEID ridResType,
IN PVOID pvResData,
IN ULONG ulResourceLen)
{
CONFIGRET cmret;
RES_DES rdResDes;
//
// Copy the data to the logConf
//
cmret = CM_Add_Res_Des(&rdResDes,
lcLogConf,
ridResType,
pvResData,
ulResourceLen,
0);
if (CR_SUCCESS != cmret) {
goto RetFALSE;
}
return TRUE;
RetFALSE:
return FALSE;
} /* CopyDataToLogConf */
/*++
Routine Description: (28) RecreateResDesList
Uses CM calls to find ResDes information and creates linked list
of this information inside of given DEV_INFO
Arguments:
pdiTmpDevInfo: the node receiving the information
ulLogConfType: the LogConf type (FORCED_LOG_CONF,
ALLOC_LOG_CONF,
BASIC_LOG_CONF,
BOOT_LOG_CONF)
Return Value:
BOOL: TRUE if function succeeds, FALSE if not
--*/
BOOL
RecreateResDesList(IN OUT PDEV_INFO pdiTmpDevInfo,
IN ULONG ulLogConfType)
{
CONFIGRET cmret, cmret2;
DEVNODE dnDevNode;
LOG_CONF lcLogConf, lcLogConfNew;
//
// Get handle to the devnode
//
cmret = CM_Locate_DevNode(&dnDevNode,
pdiTmpDevInfo->szDevNodeID,
CM_LOCATE_DEVNODE_NORMAL);
if (CR_SUCCESS != cmret) {
//ErrorLog(28, TEXT("CM_Locate_DevNode"), cmret, NULL);
goto RetFALSE;
}
//
// Get logical configuration information
//
cmret = CM_Get_First_Log_Conf(&lcLogConfNew,
dnDevNode,
ulLogConfType);
while (CR_SUCCESS == cmret) {
lcLogConf = lcLogConfNew;
if (!(GetResDesList(pdiTmpDevInfo, lcLogConf, ulLogConfType))) {
goto RetFALSE;
}
cmret = CM_Get_Next_Log_Conf(&lcLogConfNew,
lcLogConf,
0);
cmret2 = CM_Free_Log_Conf_Handle(lcLogConf);
if (CR_SUCCESS != cmret2) {
//ErrorLog(28, TEXT("CM_Free_Log_Conf"), cmret2, NULL);
}
}
return TRUE;
RetFALSE:
return FALSE;
} /* RecreateResDesList */
void Cleanup()
{
PDEV_INFO pdiDevInfo = g_pdiDevList;
PDEV_INFO pdiNextInfoNode;
while (pdiDevInfo) {
pdiNextInfoNode = pdiDevInfo->Next;
DeleteResDesDataNode(pdiDevInfo->prddForcedResDesData);
DeleteResDesDataNode(pdiDevInfo->prddAllocResDesData);
DeleteResDesDataNode(pdiDevInfo->prddBasicResDesData);
DeleteResDesDataNode(pdiDevInfo->prddBootResDesData);
free(pdiDevInfo);
pdiDevInfo = pdiNextInfoNode;
}
} /* Cleanup */
Reference in a new issue Copy permalink