archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/shell/osshell/snapins/devmgr/snapin/machine.h

535 lines
22 KiB
Raw Permalink Blame History

#ifndef __MACHINE_H_
#define __MACHINE_H_
/*++
Copyright (C) 1997-1999 Microsoft Corporation
Module Name:
machine.h
Abstract:
header file that declares CMachine, CDevInfoist and CMachineList classes
Author:
William Hsieh (williamh) created
Revision History:
--*/
LRESULT CALLBACK dmNotifyWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef BOOL (*LPFNINSTALLDEVINST)(HWND hwndParent, LPCTSTR DeviceId, BOOL UpdateDriver, DWORD* pReboot);
typedef BOOL (*LPFNROLLBACKDRIVER)(HWND hwndParent, LPCTSTR RegistryKey, DWORD Flags, DWORD* pReboot);
class CDevice;
class CClass;
class CComputer;
class CLogConf;
class CResDes;
class CMachineList;
class CFolder;
#define DM_NOTIFY_TIMERID 0x444d4d44
//This class represents SETUPAPI's <Device Information List>
//
// WARNING !!!
// no copy constructor and assignment operator are provided ---
// DO NOT ASSIGN A CDevInfoList from one to another!!!!!
class CDevInfoList
{
public:
CDevInfoList(HDEVINFO hDevInfo = INVALID_HANDLE_VALUE, HWND hwndParent = NULL)
:m_hDevInfo(hDevInfo), m_hwndParent(hwndParent)
{
}
virtual ~CDevInfoList()
{
if (INVALID_HANDLE_VALUE != m_hDevInfo)
DiDestroyDeviceInfoList();
}
operator HDEVINFO()
{
return m_hDevInfo;
}
BOOL DiGetDeviceInfoListDetail(PSP_DEVINFO_LIST_DETAIL_DATA DetailData)
{
return SetupDiGetDeviceInfoListDetail(m_hDevInfo, DetailData);
}
BOOL DiOpenDeviceInfo(LPCTSTR DeviceID, HWND hwndParent, DWORD OpenFlags,
PSP_DEVINFO_DATA DevData)
{
return SetupDiOpenDeviceInfo(m_hDevInfo, DeviceID, hwndParent, OpenFlags,
DevData);
}
BOOL DiEnumDeviceInfo(DWORD Index, PSP_DEVINFO_DATA DevData)
{
return SetupDiEnumDeviceInfo(m_hDevInfo, Index, DevData);
}
BOOL DiBuildDriverInfoList(PSP_DEVINFO_DATA DevData, DWORD DriverType)
{
return SetupDiBuildDriverInfoList(m_hDevInfo, DevData, DriverType);
}
BOOL DiEnumDriverInfo(PSP_DEVINFO_DATA DevData, DWORD DriverType, DWORD Index,
PSP_DRVINFO_DATA DrvData)
{
return SetupDiEnumDriverInfo(m_hDevInfo, DevData, DriverType, Index, DrvData);
}
BOOL DiGetDriverInfoDetail(PSP_DEVINFO_DATA DevData, PSP_DRVINFO_DATA DrvData,
PSP_DRVINFO_DETAIL_DATA DrvDetailData,
DWORD DrvDetailDataSize,
PDWORD RequiredSize)
{
return SetupDiGetDriverInfoDetail(m_hDevInfo, DevData, DrvData,
DrvDetailData,
DrvDetailDataSize,
RequiredSize);
}
BOOL DiDestroyDriverInfoList(PSP_DEVINFO_DATA DevData, DWORD DriverType)
{
return SetupDiDestroyDriverInfoList(m_hDevInfo, DevData, DriverType);
}
BOOL DiCallClassInstaller(DI_FUNCTION InstallFunction, PSP_DEVINFO_DATA DevData)
{
return SetupDiCallClassInstaller(InstallFunction, m_hDevInfo, DevData);
}
BOOL DiRemoveDevice(PSP_DEVINFO_DATA DevData)
{
return SetupDiRemoveDevice(m_hDevInfo, DevData);
}
BOOL DiChangeState(PSP_DEVINFO_DATA DevData)
{
return SetupDiChangeState(m_hDevInfo, DevData);
}
HKEY DiOpenDevRegKey(PSP_DEVINFO_DATA DevData, DWORD Scope, DWORD HwProfile,
DWORD KeyType, REGSAM samDesired)
{
return SetupDiOpenDevRegKey(m_hDevInfo, DevData, Scope, HwProfile,
KeyType, samDesired);
}
BOOL DiGetDeviceRegistryProperty(PSP_DEVINFO_DATA DevData, DWORD Property,
PDWORD PropertyDataType, PBYTE PropertyBuffer,
DWORD PropertyBufferSize, PDWORD RequiredSize)
{
return SetupDiGetDeviceRegistryProperty(m_hDevInfo, DevData,
Property, PropertyDataType,
PropertyBuffer,
PropertyBufferSize,
RequiredSize
);
}
BOOL DiGetDeviceInstallParams(PSP_DEVINFO_DATA DevData,
PSP_DEVINSTALL_PARAMS DevInstParams)
{
return SetupDiGetDeviceInstallParams(m_hDevInfo, DevData, DevInstParams);
}
BOOL DiGetClassInstallParams(PSP_DEVINFO_DATA DevData,
PSP_CLASSINSTALL_HEADER ClassInstallHeader,
DWORD ClassInstallParamsSize,
PDWORD RequiredSize)
{
return SetupDiGetClassInstallParams(m_hDevInfo, DevData,
ClassInstallHeader,
ClassInstallParamsSize,
RequiredSize);
}
BOOL DiSetDeviceInstallParams(PSP_DEVINFO_DATA DevData,
PSP_DEVINSTALL_PARAMS DevInstParams)
{
return SetupDiSetDeviceInstallParams(m_hDevInfo, DevData, DevInstParams);
}
BOOL DiSetClassInstallParams(PSP_DEVINFO_DATA DevData,
PSP_CLASSINSTALL_HEADER ClassInstallHeader,
DWORD ClassInstallParamsSize)
{
return SetupDiSetClassInstallParams(m_hDevInfo, DevData,
ClassInstallHeader,
ClassInstallParamsSize);
}
BOOL DiGetClassDevPropertySheet(PSP_DEVINFO_DATA DevData,
LPPROPSHEETHEADER PropertySheetHeader,
DWORD PagesAllowed,
DWORD Flags)
{
return SetupDiGetClassDevPropertySheets(m_hDevInfo, DevData,
PropertySheetHeader, PagesAllowed,
NULL, Flags);
}
BOOL DiGetExtensionPropSheetPage(PSP_DEVINFO_DATA DevData,
LPFNADDPROPSHEETPAGE pfnAddPropSheetPage,
DWORD PageType,
LPARAM lParam
);
BOOL DiGetSelectedDriver(PSP_DEVINFO_DATA DevData, PSP_DRVINFO_DATA DriverInfoData)
{
return SetupDiGetSelectedDriver(m_hDevInfo, DevData, DriverInfoData);
}
BOOL DiSetSelectedDriver(PSP_DEVINFO_DATA DevData, PSP_DRVINFO_DATA DriverInfoData)
{
return SetupDiSetSelectedDriver(m_hDevInfo, DevData, DriverInfoData);
}
BOOL DiEnumDeviceInterfaces(DWORD Index, LPGUID InterfaceGuid, PSP_DEVICE_INTERFACE_DATA InterfaceData)
{
return SetupDiEnumDeviceInterfaces(m_hDevInfo, NULL, InterfaceGuid, Index, InterfaceData);
}
BOOL DiGetInterfaceDetailData(PSP_DEVICE_INTERFACE_DATA pInterfaceData,
PSP_DEVICE_INTERFACE_DETAIL_DATA pDetailData,
DWORD Size, DWORD* pRequiredSize)
{
return SetupDiGetDeviceInterfaceDetail(m_hDevInfo, pInterfaceData,
pDetailData, Size,
pRequiredSize, NULL);
}
BOOL DiTurnOnDiFlags(PSP_DEVINFO_DATA DevData, DWORD FlagMask );
BOOL DiTurnOffDiFlags(PSP_DEVINFO_DATA DevData, DWORD FlagsMask);
BOOL DiTurnOnDiExFlags(PSP_DEVINFO_DATA DevData, DWORD FlagMask );
BOOL DiTurnOffDiExFlags(PSP_DEVINFO_DATA DevData, DWORD FlagsMask);
BOOL InstallDevInst(HWND hwndParent, LPCTSTR DeviceID, BOOL UpdateDriver, DWORD* pReboot);
BOOL RollbackDriver(HWND hwndParent, LPCTSTR RegistryKeyName, DWORD Flags, DWORD* pReboot);
DWORD DiGetFlags(PSP_DEVINFO_DATA DevData = NULL);
DWORD DiGetExFlags(PSP_DEVINFO_DATA DevData = NULL);
void DiDestroyDeviceInfoList();
BOOL DiGetDeviceMFGString(PSP_DEVINFO_DATA DevData, String& str);
BOOL DiGetDeviceMFGString(PSP_DEVINFO_DATA DevData, TCHAR* pBuffer, DWORD Size, DWORD* pRequiredSize = NULL);
BOOL DiGetDeviceIDString(PSP_DEVINFO_DATA DevData, String& str);
BOOL DiGetDeviceIDString(PSP_DEVINFO_DATA DevData, TCHAR* pBuffer, DWORD Size, DWORD* pRequiredSize = NULL);
HWND OwnerWindow()
{
return m_hwndParent;
}
protected:
HDEVINFO m_hDevInfo;
HWND m_hwndParent;
private:
CDevInfoList(const CDevInfoList&);
CDevInfoList& operator=(const CDevInfoList&);
};
class CMachine : public CDevInfoList
{
public:
CMachine(LPCTSTR MachineName = NULL);
virtual ~CMachine();
operator HMACHINE()
{
return m_hMachine;
}
LPCTSTR GetMachineDisplayName()
{
return (LPCTSTR)m_strMachineDisplayName;
}
LPCTSTR GetMachineFullName()
{
return (LPCTSTR)m_strMachineFullName;
}
LPCTSTR GetRemoteMachineFullName()
{
return m_IsLocal ? NULL : (LPCTSTR)m_strMachineFullName;
}
HMACHINE GetHMachine()
{
return m_hMachine;
}
BOOL LoadStringWithMachineName(int StringId, LPTSTR Buffer, DWORD* BufferLen);
BOOL IsLocal()
{
return m_IsLocal;
}
BOOL AttachFolder(CFolder* pFolder);
void DetachFolder(CFolder* pFolder);
BOOL IsFolderAttached(CFolder* pFolder);
BOOL AttachPropertySheet(HWND hwndPropertySheet);
void DetachPropertySheet(HWND hwndPropertySheet);
HWND GetDeviceWindowHandle(LPCTSTR DeviceId);
HWND GetClassWindowHandle(LPGUID ClassGuid);
BOOL AttachChildMachine(CMachine* ChildMachine);
void DetachChildMachine(CMachine* ChildMachine);
BOOL EnuemerateDevice(int Index, CDevice** ppDevice);
BOOL Initialize(
HWND hwndParent = NULL,
LPCTSTR DeviceId = NULL,
LPGUID ClassGuid = NULL
);
DWORD GetNumberOfClasses() const
{
return m_listClass.GetCount();
}
DWORD GetNumberOfDevices() const
{
return (DWORD)m_listDevice.GetCount();
}
BOOL GetFirstClass(CClass** ppClass, PVOID& Context);
BOOL GetNextClass(CClass** ppClass, PVOID& Context);
BOOL GetFirstDevice(CDevice** ppDevice, PVOID& Context);
BOOL GetNextDevice(CDevice** ppDevice, PVOID& Context);
CDevice* DevNodeToDevice(DEVNODE dn);
CDevice* DeviceIDToDevice(LPCTSTR DeviceID);
CClass* ClassGuidToClass(LPGUID ClassGuid);
BOOL Reenumerate();
BOOL DoMiniRefresh();
BOOL Refresh();
int GetComputerIconIndex()
{
return m_ComputerIndex;
}
int GetResourceIconIndex()
{
return m_ResourceIndex;
}
BOOL ShouldPropertySheetDestroy()
{
return m_PropertySheetShoudDestroy;
}
void SetPropertySheetShouldDestroy()
{
m_PropertySheetShoudDestroy = TRUE;
}
BOOL GetDigitalSigner(LPTSTR FullInfPath, String& DigitalSigner);
BOOL DoNotCreateDevice(SC_HANDLE SCMHandle, LPGUID ClassGuid, DEVINST DevInst);
BOOL IsUserAGuest()
{
return m_UserIsAGuest;
}
HDEVINFO DiCreateDeviceInfoList(LPGUID ClassGuid, HWND hwndParent)
{
return SetupDiCreateDeviceInfoListEx(ClassGuid, hwndParent,
GetRemoteMachineFullName(), NULL);
}
HDEVINFO DiCreateDeviceInterfaceList(LPGUID InterfaceGuid, LPCTSTR DeviceId, HWND hwndParent)
{
return SetupDiGetClassDevsEx(InterfaceGuid, DeviceId, m_hwndParent, DIGCF_DEVICEINTERFACE,
NULL, GetRemoteMachineFullName(), NULL);
}
HDEVINFO DiGetClassDevs(LPGUID ClassGuid, LPCTSTR Enumerator, HWND hwndParent, DWORD Flags)
{
return SetupDiGetClassDevsEx(ClassGuid, Enumerator, hwndParent,
Flags, NULL, GetRemoteMachineFullName(), NULL
);
}
HIMAGELIST DiGetClassImageList()
{
return m_ImageListData.ImageList;
}
BOOL DiBuildClassInfoList(DWORD Flags, LPGUID ClassGuid,
DWORD ClassGuidListSize, PDWORD RequiredSize)
{
return SetupDiBuildClassInfoListEx(Flags, ClassGuid,
ClassGuidListSize, RequiredSize,
GetRemoteMachineFullName(), NULL);
}
BOOL DiGetClassDescription(LPGUID ClassGuid, LPTSTR ClassDescription,
DWORD ClassDescriptionSize, PDWORD RequiredSize)
{
return SetupDiGetClassDescriptionEx(ClassGuid, ClassDescription,
ClassDescriptionSize,
RequiredSize,
GetRemoteMachineFullName(),
NULL);
}
HKEY DiOpenClassRegKey(LPGUID ClassGuid, REGSAM samDesired, DWORD Flags)
{
return SetupDiOpenClassRegKeyEx(ClassGuid, samDesired, Flags,
GetRemoteMachineFullName(), NULL);
}
BOOL DiGetHwProfileList(PDWORD HwProfileList, DWORD HwProfileListSize,
PDWORD RequiredSize, PDWORD CurrentIndex)
{
return SetupDiGetHwProfileListEx(HwProfileList, HwProfileListSize,
RequiredSize, CurrentIndex,
GetRemoteMachineFullName(), NULL);
}
BOOL DiLoadClassIcon(LPGUID ClassGuid, HICON* LargeIcon, PINT MiniIconIndex)
{
return SetupDiLoadClassIcon(ClassGuid, LargeIcon, MiniIconIndex);
}
BOOL DiGetClassImageList(PSP_CLASSIMAGELIST_DATA pImageListData)
{
return SetupDiGetClassImageListEx(pImageListData,
GetRemoteMachineFullName(), NULL);
}
BOOL DiDestroyClassImageList(PSP_CLASSIMAGELIST_DATA pImageListData)
{
return SetupDiDestroyClassImageList(pImageListData);
}
BOOL DiGetClassImageIndex(LPGUID ClassGuid, PINT ImageIndex)
{
return SetupDiGetClassImageIndex(&m_ImageListData, ClassGuid, ImageIndex);
}
int DiDrawMiniIcon(HDC hdc, RECT rc, int IconIndex, DWORD Flags)
{
return SetupDiDrawMiniIcon(hdc, rc, IconIndex, Flags);
}
BOOL DiClassNameFromGuid(LPGUID ClassGuid, LPTSTR ClassName,
DWORD ClassNameSize, PDWORD RequiredSize)
{
return SetupDiClassNameFromGuidEx(ClassGuid, ClassName,
ClassNameSize, RequiredSize,
GetRemoteMachineFullName(), NULL);
}
BOOL DiGetHwProfileFriendlyName(DWORD HwProfile, LPTSTR FriendlyName,
DWORD FriendlyNameSize,
PDWORD RequiredSize)
{
return SetupDiGetHwProfileFriendlyNameEx(HwProfile, FriendlyName,
FriendlyNameSize,
RequiredSize,
GetRemoteMachineFullName(),
NULL);
}
BOOL DiGetClassFriendlyNameString(LPGUID Guid, String& strClass);
BOOL DiDestroyDeviceInfoList(HDEVINFO hDevInfo)
{
return SetupDiDestroyDeviceInfoList(hDevInfo);
}
///////////////////////////////////////////////////////////////////////////
//// Configuration Manager APIs
////
CONFIGRET GetLastCR()
{
return m_LastCR;
}
BOOL CmGetConfigFlags(DEVNODE dn, DWORD* pFlags);
BOOL CmGetCapabilities(DEVNODE dn, DWORD* pCapabilities);
BOOL CmGetDeviceIDString(DEVNODE dn, String& str);
BOOL CmGetDescriptionString(DEVNODE dn, String& str);
BOOL CmGetMFGString(DEVNODE dn, String& str);
BOOL CmGetProviderString(DEVNODE dn, String& str);
BOOL CmGetDriverDateString(DEVNODE dn, String& str);
BOOL CmGetDriverDateData(DEVNODE dn, FILETIME *ft);
BOOL CmGetDriverVersionString(DEVNODE dn, String& str);
BOOL CmGetClassGuid(DEVNODE dn, GUID& Guid);
BOOL CmGetHardwareIDs(DEVNODE dn, PVOID Buffer, ULONG* BufferLen);
BOOL CmGetCompatibleIDs(DEVNODE dn, PVOID Buffer, ULONG* BufferLen);
BOOL CmGetStatus(DEVNODE dn, DWORD* pProblem, DWORD* pStatus);
BOOL CmGetKnownLogConf(DEVNODE dn, LOG_CONF* plc, DWORD* plcType);
BOOL CmReenumerate(DEVNODE dn, ULONG Flags);
BOOL CmGetHwProfileFlags(DEVNODE dn, ULONG Profile, ULONG* pFlags);
BOOL CmGetHwProfileFlags(LPCTSTR DeviceID, ULONG Profile, ULONG* pFlags);
BOOL CmSetHwProfileFlags(DEVNODE dn, ULONG Profile, ULONG Flags);
BOOL CmSetHwProfileFlags(LPCTSTR DeviceID, ULONG Profile, ULONG Flags);
BOOL CmGetCurrentHwProfile(ULONG* phwpf);
BOOL CmGetHwProfileInfo(int Index, PHWPROFILEINFO pHwProfileInfo);
BOOL CmGetBusGuid(DEVNODE dn, LPGUID Guid);
BOOL CmGetBusGuidString(DEVNODE dn, String& str);
DEVNODE CmGetParent(DEVNODE dn);
DEVNODE CmGetChild(DEVNODE dn);
DEVNODE CmGetSibling(DEVNODE dn);
DEVNODE CmGetRootDevNode();
BOOL CmHasResources(DEVNODE dn);
BOOL CmHasDrivers(DEVNODE dn);
DWORD CmGetResDesDataSize(RES_DES rd);
BOOL CmGetResDesData(RES_DES rd, PVOID pData, ULONG DataSize);
BOOL CmGetNextResDes(PRES_DES prdNext, RES_DES rd, RESOURCEID ForResource,
PRESOURCEID pTheResource);
void CmFreeResDesHandle(RES_DES rd);
void CmFreeResDes(PRES_DES prdPrev, RES_DES rd);
void CmFreeLogConfHandle(LOG_CONF lc);
int CmGetNumberOfBasicLogConf(DEVNODE dn);
BOOL CmGetFirstLogConf(DEVNODE dn, LOG_CONF* plc, ULONG Type);
BOOL CmGetNextLogConf(LOG_CONF* plcNext, LOG_CONF lcRef, ULONG Type);
ULONG CmGetArbitratorFreeDataSize(DEVNODE dn, RESOURCEID ResType);
BOOL CmGetArbitratorFreeData(DEVNODE dn, PVOID pBuffer, ULONG BufferSize,
RESOURCEID ResType);
BOOL CmTestRangeAvailable(RANGE_LIST RangeList, DWORDLONG dlBase,
DWORDLONG dlEnd);
void CmDeleteRange(RANGE_LIST RangeList, DWORDLONG dlBase, DWORDLONG dlLen);
BOOL CmGetFirstRange(RANGE_LIST RangeList, DWORDLONG* pdlBase,
DWORDLONG* pdlLen, RANGE_ELEMENT* pre);
BOOL CmGetNextRange(RANGE_ELEMENT* pre, DWORDLONG* pdlBase, DWORDLONG* pdlLen);
void CmFreeRangeList(RANGE_LIST RangeList);
BOOL CmGetDeviceIdListSize(LPCTSTR Fileter, ULONG* Size, ULONG Flags);
BOOL CmGetDeviceIdList(LPCTSTR Filter, TCHAR* Buffer, ULONG BufferSize, ULONG Flags);
CONFIGRET CmGetRegistryProperty(DEVNODE dn, ULONG Property,
PVOID pBuffer,
ULONG* BufferSize);
BOOL EnableRefresh(BOOL fEnable);
BOOL ScheduleRefresh();
void Lock()
{
EnterCriticalSection(&m_CriticalSection);
}
void Unlock()
{
LeaveCriticalSection(&m_CriticalSection);
}
CComputer* m_pComputer;
CMachine* m_ParentMachine;
UINT m_msgRefresh;
static DWORD WaitDialogThread(PVOID Parameter);
private:
// no copy constructor and no assigment operator
CMachine(const CMachine& MachineSrc);
CMachine& operator=(const CMachine& MachineSrc);
BOOL BuildClassesFromGuidList(LPGUID GuidList, DWORD Guids);
CONFIGRET CmGetRegistrySoftwareProperty(DEVNODE dn, LPCTSTR ValueName,
PVOID pBuffer, ULONG* pBufferSize);
void CreateDeviceTree(CDevice* pParent, CDevice* pSibling, DEVNODE dn);
BOOL CreateClassesAndDevices(LPCTSTR DeviceId = NULL, LPGUID ClassGuid = NULL);
void DestroyClassesAndDevices();
BOOL CreateNotifyWindow();
BOOL pGetOriginalInfName(LPTSTR InfName, String& OriginalInfName);
String m_strMachineDisplayName;
String m_strMachineFullName;
HMACHINE m_hMachine;
CONFIGRET m_LastCR;
CList<CClass*, CClass*> m_listClass;
SP_CLASSIMAGELIST_DATA m_ImageListData;
int m_ComputerIndex;
int m_ResourceIndex;
CList<CDevice*, CDevice*> m_listDevice;
DWORD m_Flags;
BOOL m_Initialized;
BOOL m_IsLocal;
BOOL m_PropertySheetShoudDestroy;
BOOL m_UserIsAGuest;
HWND m_hwndNotify;
CList<CFolder*, CFolder*> m_listFolders;
int m_RefreshDisableCounter;
BOOL m_RefreshPending;
BOOL m_ShowNonPresentDevices;
CRITICAL_SECTION m_CriticalSection;
CRITICAL_SECTION m_PropertySheetCriticalSection;
CRITICAL_SECTION m_ChildMachineCriticalSection;
CList<HWND, HWND> m_listPropertySheets;
CList<CMachine*, CMachine*> m_listChildMachines;
};
class CMachineList
{
public:
CMachineList() {};
~CMachineList();
BOOL CreateMachine(HWND hwndParent, LPCTSTR MachineName, CMachine** ppMachine);
CMachine* FindMachine(LPCTSTR MachineName);
private:
CMachineList(const CMachineList& MachineListSrc);
CMachineList& operator=(const CMachineList& MachineListSrc);
CList<CMachine*, CMachine*> m_listMachines;
};
#endif //__MACHINE_H_