mirror of https://github.com/tongzx/nt5src
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.
876 lines
25 KiB
876 lines
25 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 2000
|
|
//
|
|
// File: miscutil.c
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "HotPlug.h"
|
|
#include <initguid.h>
|
|
#include <ntddstor.h>
|
|
#include <wdmguid.h>
|
|
|
|
LPTSTR
|
|
FormatString(
|
|
LPCTSTR format,
|
|
...
|
|
)
|
|
{
|
|
LPTSTR str = NULL;
|
|
va_list arglist;
|
|
va_start(arglist, format);
|
|
|
|
if (FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
format,
|
|
0,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
|
|
(LPTSTR)&str,
|
|
0,
|
|
&arglist
|
|
) == 0) {
|
|
|
|
str = NULL;
|
|
}
|
|
|
|
va_end(arglist);
|
|
|
|
return str;
|
|
}
|
|
|
|
PTCHAR
|
|
BuildLocationInformation(
|
|
DEVINST DevInst,
|
|
HMACHINE hMachine
|
|
)
|
|
{
|
|
CONFIGRET ConfigRet;
|
|
ULONG ulSize;
|
|
DWORD UINumber;
|
|
PTCHAR Location = NULL;
|
|
PTCHAR ParentName;
|
|
DEVINST DevInstParent;
|
|
int BusLocationStringId;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
TCHAR UINumberDescFormat[MAX_PATH];
|
|
TCHAR szFormat[MAX_PATH];
|
|
HKEY hKey;
|
|
DWORD Type = REG_SZ;
|
|
|
|
szBuffer[0] = TEXT('\0');
|
|
|
|
|
|
//
|
|
// We will first get any LocationInformation for the device. This will either
|
|
// be in the LocationInformationOverride value in the devices driver (software) key
|
|
// or if that is not present we will look for the LocationInformation value in
|
|
// the devices device (hardware) key.
|
|
//
|
|
ulSize = sizeof(szBuffer);
|
|
if (CR_SUCCESS == CM_Open_DevNode_Key_Ex(DevInst,
|
|
KEY_READ,
|
|
0,
|
|
RegDisposition_OpenExisting,
|
|
&hKey,
|
|
CM_REGISTRY_SOFTWARE,
|
|
hMachine
|
|
)) {
|
|
|
|
RegQueryValueEx(hKey,
|
|
REGSTR_VAL_LOCATION_INFORMATION_OVERRIDE,
|
|
NULL,
|
|
&Type,
|
|
(const PBYTE)szBuffer,
|
|
&ulSize
|
|
);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
//
|
|
// If the buffer is empty then we didn't get the LocationInformationOverride
|
|
// value in the device's software key. So, we will see if their is a
|
|
// LocationInformation value in the device's hardware key.
|
|
//
|
|
if (szBuffer[0] == TEXT('\0')) {
|
|
|
|
//
|
|
// Get the LocationInformation for this device.
|
|
//
|
|
ulSize = sizeof(szBuffer);
|
|
CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_LOCATION_INFORMATION,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
}
|
|
|
|
//
|
|
// UINumber has precedence over all other location information so check if this
|
|
// device has a UINumber
|
|
//
|
|
ulSize = sizeof(UINumber);
|
|
if ((CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_UI_NUMBER,
|
|
NULL,
|
|
&UINumber,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
) == CR_SUCCESS) &&
|
|
(ulSize > 0)) {
|
|
|
|
UINumberDescFormat[0] = TEXT('\0');
|
|
ulSize = sizeof(UINumberDescFormat);
|
|
|
|
//
|
|
// Get the UINumber description format string from the device's parent,
|
|
// if there is one, otherwise default to 'Location %1'
|
|
if ((CM_Get_Parent_Ex(&DevInstParent, DevInst, 0, hMachine) == CR_SUCCESS) &&
|
|
(CM_Get_DevNode_Registry_Property_Ex(DevInstParent,
|
|
CM_DRP_UI_NUMBER_DESC_FORMAT,
|
|
NULL,
|
|
UINumberDescFormat,
|
|
&ulSize,
|
|
0,
|
|
hMachine) == CR_SUCCESS) &&
|
|
*UINumberDescFormat) {
|
|
|
|
} else {
|
|
|
|
LoadString(hHotPlug, IDS_UI_NUMBER_DESC_FORMAT, UINumberDescFormat, sizeof(UINumberDescFormat)/sizeof(TCHAR));
|
|
}
|
|
|
|
//
|
|
// Prepend "at " to the begining of the UINumber string.
|
|
//
|
|
LoadString(hHotPlug, IDS_AT, szFormat, sizeof(szFormat)/sizeof(TCHAR));
|
|
lstrcat(szFormat, UINumberDescFormat);
|
|
|
|
//
|
|
// Fill in the UINumber string
|
|
//
|
|
Location = FormatString(szFormat, UINumber);
|
|
}
|
|
|
|
//
|
|
// We don't have a UINumber but we do have LocationInformation
|
|
//
|
|
else if (*szBuffer) {
|
|
|
|
LoadString(hHotPlug, IDS_LOCATION, szFormat, sizeof(szFormat)/sizeof(TCHAR));
|
|
Location = (PTCHAR)LocalAlloc(LPTR, lstrlen(szBuffer)*sizeof(TCHAR) + sizeof(szFormat) + sizeof(TCHAR));
|
|
|
|
if (Location) {
|
|
|
|
wsprintf(Location, szFormat, szBuffer);
|
|
}
|
|
}
|
|
|
|
//
|
|
// We don't have a UINumber or LocationInformation so we need to get a description
|
|
// of the parent of this device.
|
|
//
|
|
else {
|
|
|
|
ConfigRet = CM_Get_Parent_Ex(&DevInstParent, DevInst, 0, hMachine);
|
|
if (ConfigRet == CR_SUCCESS) {
|
|
|
|
//
|
|
// Try the registry for FRIENDLYNAME
|
|
//
|
|
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInstParent,
|
|
CM_DRP_FRIENDLYNAME,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
if (ConfigRet != CR_SUCCESS || !*szBuffer) {
|
|
//
|
|
// Try the registry for DEVICEDESC
|
|
//
|
|
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInstParent,
|
|
CM_DRP_DEVICEDESC,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
if (ConfigRet != CR_SUCCESS || !*szBuffer) {
|
|
|
|
GUID ClassGuid;
|
|
|
|
|
|
//
|
|
// Initialize ClassGuid to GUID_NULL
|
|
//
|
|
CopyMemory(&ClassGuid,
|
|
&GUID_NULL,
|
|
sizeof(GUID)
|
|
);
|
|
|
|
//
|
|
// Try the registry for CLASSNAME
|
|
//
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInstParent,
|
|
CM_DRP_CLASSGUID,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
|
|
|
|
if (ConfigRet == CR_SUCCESS) {
|
|
|
|
pSetupGuidFromString(szBuffer, &ClassGuid);
|
|
}
|
|
|
|
|
|
if (!IsEqualGUID(ClassGuid, GUID_NULL) &&
|
|
!IsEqualGUID(ClassGuid, GUID_DEVCLASS_UNKNOWN))
|
|
{
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInstParent,
|
|
CM_DRP_CLASS,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
}
|
|
|
|
else {
|
|
|
|
ConfigRet = ~CR_SUCCESS;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*szBuffer) {
|
|
|
|
LoadString(hHotPlug, IDS_LOCATION_NOUINUMBER, szFormat, sizeof(szFormat)/sizeof(TCHAR));
|
|
Location = (PTCHAR)LocalAlloc(LPTR, lstrlen(szBuffer)*sizeof(TCHAR) + sizeof(szFormat) + sizeof(TCHAR));
|
|
|
|
if (Location) {
|
|
|
|
wsprintf(Location, szFormat, szBuffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Location;
|
|
}
|
|
|
|
PTCHAR
|
|
BuildFriendlyName(
|
|
DEVINST DevInst,
|
|
HMACHINE hMachine
|
|
)
|
|
{
|
|
PTCHAR FriendlyName;
|
|
CONFIGRET ConfigRet;
|
|
ULONG ulSize;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
|
|
//
|
|
// Try the registry for FRIENDLYNAME
|
|
//
|
|
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_FRIENDLYNAME,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
if (ConfigRet != CR_SUCCESS || !*szBuffer) {
|
|
//
|
|
// Try the registry for DEVICEDESC
|
|
//
|
|
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_DEVICEDESC,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
if (ConfigRet != CR_SUCCESS || !*szBuffer) {
|
|
GUID ClassGuid;
|
|
|
|
//
|
|
// Initialize ClassGuid to GUID_NULL
|
|
//
|
|
CopyMemory(&ClassGuid,
|
|
&GUID_NULL,
|
|
sizeof(GUID)
|
|
);
|
|
|
|
//
|
|
// Try the registry for CLASSNAME
|
|
//
|
|
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_CLASSGUID,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
|
|
|
|
if (ConfigRet == CR_SUCCESS) {
|
|
|
|
pSetupGuidFromString(szBuffer, &ClassGuid);
|
|
}
|
|
|
|
|
|
if (!IsEqualGUID(ClassGuid, GUID_NULL) &&
|
|
!IsEqualGUID(ClassGuid, GUID_DEVCLASS_UNKNOWN))
|
|
{
|
|
ulSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_CLASS,
|
|
NULL,
|
|
szBuffer,
|
|
&ulSize,
|
|
0,
|
|
hMachine
|
|
);
|
|
}
|
|
|
|
else {
|
|
|
|
ConfigRet = ~CR_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ConfigRet == CR_SUCCESS && *szBuffer) {
|
|
|
|
FriendlyName = (PTCHAR)LocalAlloc(LPTR, ulSize);
|
|
if (FriendlyName) {
|
|
|
|
memcpy(FriendlyName, szBuffer, ulSize);
|
|
}
|
|
}
|
|
|
|
else {
|
|
|
|
FriendlyName = NULL;
|
|
}
|
|
|
|
|
|
return FriendlyName;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* SetDlgText - Set Dialog Text Field
|
|
*
|
|
* Concatenates a number of string resources and does a SetWindowText()
|
|
* for a dialog text control.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* hDlg - Dialog handle
|
|
* iControl - Dialog control ID to receive text
|
|
* nStartString - ID of first string resource to concatenate
|
|
* nEndString - ID of last string resource to concatenate
|
|
*
|
|
* Note: the string IDs must be consecutive.
|
|
*/
|
|
|
|
void
|
|
SetDlgText(HWND hDlg, int iControl, int nStartString, int nEndString)
|
|
{
|
|
int iX;
|
|
TCHAR szText[MAX_PATH];
|
|
|
|
szText[0] = '\0';
|
|
|
|
for (iX = nStartString; iX<= nEndString; iX++) {
|
|
|
|
LoadString(hHotPlug,
|
|
iX,
|
|
szText + lstrlen(szText),
|
|
sizeof(szText)/sizeof(TCHAR) - lstrlen(szText)
|
|
);
|
|
}
|
|
|
|
if (iControl) {
|
|
|
|
SetDlgItemText(hDlg, iControl, szText);
|
|
}
|
|
|
|
else {
|
|
|
|
SetWindowText(hDlg, szText);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
HotPlugPropagateMessage(
|
|
HWND hWnd,
|
|
UINT uMessage,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
while ((hWnd = GetWindow(hWnd, GW_CHILD))) {
|
|
|
|
SendMessage(hWnd, uMessage, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
RemovalPermission(
|
|
void
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int
|
|
HPMessageBox(
|
|
HWND hWnd,
|
|
int IdText,
|
|
int IdCaption,
|
|
UINT Type
|
|
)
|
|
{
|
|
TCHAR szText[MAX_PATH];
|
|
TCHAR szCaption[MAX_PATH];
|
|
|
|
if (LoadString(hHotPlug, IdText, szText, MAX_PATH) &&
|
|
LoadString(hHotPlug, IdCaption, szCaption, MAX_PATH))
|
|
{
|
|
return MessageBox(hWnd, szText, szCaption, Type);
|
|
}
|
|
|
|
return IDIGNORE;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
InvalidateTreeItemRect(
|
|
HWND hwndTree,
|
|
HTREEITEM hTreeItem
|
|
)
|
|
{
|
|
RECT rect;
|
|
|
|
if (hTreeItem && TreeView_GetItemRect(hwndTree, hTreeItem, &rect, FALSE)) {
|
|
|
|
InvalidateRect(hwndTree, &rect, FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
DWORD
|
|
GetHotPlugFlags(
|
|
PHKEY phKey
|
|
)
|
|
{
|
|
HKEY hKey;
|
|
LONG Error;
|
|
DWORD HotPlugFlags, cbHotPlugFlags;
|
|
|
|
Error = RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SYSTRAY, &hKey);
|
|
if (Error == ERROR_SUCCESS) {
|
|
|
|
cbHotPlugFlags = sizeof(HotPlugFlags);
|
|
|
|
Error = RegQueryValueEx(hKey,
|
|
szHotPlugFlags,
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)&HotPlugFlags,
|
|
&cbHotPlugFlags
|
|
);
|
|
|
|
if (phKey) {
|
|
|
|
*phKey = hKey;
|
|
}
|
|
|
|
else {
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
if (Error != ERROR_SUCCESS) {
|
|
|
|
HotPlugFlags = 0;
|
|
}
|
|
|
|
return HotPlugFlags;
|
|
}
|
|
|
|
//
|
|
// This function determines if the device is a boot storage device.
|
|
// We spit out a warning when users are trying to remove or disable
|
|
// a boot storage device(or a device contains a boot storage device).
|
|
//
|
|
// INPUT:
|
|
// NONE
|
|
// OUTPUT:
|
|
// TRUE if the device is a boot device
|
|
// FALSE if the device is not a boot device
|
|
LPTSTR
|
|
DevNodeToDriveLetter(
|
|
DEVINST DevInst
|
|
)
|
|
{
|
|
ULONG ulSize;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
TCHAR DeviceID[MAX_DEVICE_ID_LEN];
|
|
PTSTR DriveString = NULL;
|
|
PTSTR DeviceInterface = NULL;
|
|
|
|
if (CM_Get_Device_ID_Ex(DevInst,
|
|
DeviceID,
|
|
sizeof(DeviceID)/sizeof(TCHAR),
|
|
0,
|
|
NULL
|
|
) != CR_SUCCESS) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// create a device info list contains all the interface classed
|
|
// exposed by this device.
|
|
ulSize = 0;
|
|
|
|
if ((CM_Get_Device_Interface_List_Size(&ulSize,
|
|
(LPGUID)&VolumeClassGuid,
|
|
DeviceID,
|
|
0) == CR_SUCCESS) &&
|
|
(ulSize > 1) &&
|
|
((DeviceInterface = (PTSTR)LocalAlloc(LPTR, ulSize*sizeof(TCHAR))) != NULL) &&
|
|
(CM_Get_Device_Interface_List((LPGUID)&VolumeClassGuid,
|
|
DeviceID,
|
|
DeviceInterface,
|
|
ulSize,
|
|
0
|
|
) == CR_SUCCESS) &&
|
|
*DeviceInterface)
|
|
{
|
|
PTSTR devicePath, p;
|
|
TCHAR thisVolumeName[MAX_PATH];
|
|
TCHAR enumVolumeName[MAX_PATH];
|
|
TCHAR driveName[4];
|
|
ULONG length;
|
|
BOOL bResult;
|
|
|
|
length = lstrlen(DeviceInterface);
|
|
devicePath = (PTSTR)LocalAlloc(LPTR, (length + 1) * sizeof(TCHAR) + sizeof(UNICODE_NULL));
|
|
|
|
if (devicePath) {
|
|
|
|
lstrcpyn(devicePath, DeviceInterface, length + 1);
|
|
|
|
p = wcschr(&(devicePath[4]), TEXT('\\'));
|
|
|
|
if (!p) {
|
|
//
|
|
// No refstring is present in the symbolic link; add a trailing
|
|
// '\' char (as required by GetVolumeNameForVolumeMountPoint).
|
|
//
|
|
p = devicePath + length;
|
|
*p = TEXT('\\');
|
|
}
|
|
|
|
p++;
|
|
*p = UNICODE_NULL;
|
|
|
|
thisVolumeName[0] = UNICODE_NULL;
|
|
bResult = GetVolumeNameForVolumeMountPoint(devicePath,
|
|
thisVolumeName,
|
|
MAX_PATH
|
|
);
|
|
LocalFree(devicePath);
|
|
|
|
if (bResult && thisVolumeName[0]) {
|
|
|
|
driveName[1] = TEXT(':');
|
|
driveName[2] = TEXT('\\');
|
|
driveName[3] = TEXT('\0');
|
|
|
|
for (driveName[0] = TEXT('A'); driveName[0] <= TEXT('Z'); driveName[0]++) {
|
|
|
|
enumVolumeName[0] = TEXT('\0');
|
|
|
|
GetVolumeNameForVolumeMountPoint(driveName, enumVolumeName, MAX_PATH);
|
|
|
|
if (!lstrcmpi(thisVolumeName, enumVolumeName)) {
|
|
|
|
driveName[2] = TEXT('\0');
|
|
|
|
wsprintf(szBuffer, TEXT(" - (%s)"), driveName);
|
|
|
|
DriveString = (PTSTR)LocalAlloc(LPTR, (lstrlen(szBuffer) + 1) * sizeof(TCHAR));
|
|
|
|
if (DriveString) {
|
|
|
|
lstrcpy(DriveString, szBuffer);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DeviceInterface) {
|
|
|
|
LocalFree(DeviceInterface);
|
|
}
|
|
|
|
return DriveString;
|
|
}
|
|
|
|
BOOL
|
|
IsHotPlugDevice(
|
|
DEVINST DevInst,
|
|
HMACHINE hMachine
|
|
)
|
|
/**+
|
|
|
|
A device is considered a HotPlug device if the following are TRUE:
|
|
- has Capability CM_DEVCAP_REMOVABLE
|
|
- does NOT have Capability CM_DEVCAP_SURPRISEREMOVALOK
|
|
- does NOT have Capability CM_DEVCAP_DOCKDEVICE
|
|
- must be started (have the DN_STARTED devnode flag)
|
|
- unless has capability CM_DEVCAP_EJECTSUPPORTED
|
|
- or unless has capability CM_DEVCAP_RAWDEVICEOK
|
|
|
|
Returns:
|
|
TRUE if this is a HotPlug device
|
|
FALSE if this is not a HotPlug device.
|
|
|
|
-**/
|
|
{
|
|
DWORD Capabilities;
|
|
DWORD Len;
|
|
DWORD Status, Problem;
|
|
|
|
Capabilities = Status = Problem = 0;
|
|
|
|
Len = sizeof(Capabilities);
|
|
|
|
if (CM_Get_DevNode_Registry_Property_Ex(DevInst,
|
|
CM_DRP_CAPABILITIES,
|
|
NULL,
|
|
(PVOID)&Capabilities,
|
|
&Len,
|
|
0,
|
|
hMachine) != CR_SUCCESS) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (CM_Get_DevNode_Status_Ex(&Status,
|
|
&Problem,
|
|
DevInst,
|
|
0,
|
|
hMachine) != CR_SUCCESS) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// If this device is not removable, or it is surprise removal ok, or
|
|
// it is a dock device, then it is not a hotplug device.
|
|
//
|
|
if ((!(Capabilities & CM_DEVCAP_REMOVABLE)) ||
|
|
(Capabilities & CM_DEVCAP_SURPRISEREMOVALOK) ||
|
|
(Capabilities & CM_DEVCAP_DOCKDEVICE)) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We won't consider a device to be a hotplug device if it is not started,
|
|
// unless it is either RAW capabile or an eject capable device.
|
|
//
|
|
// The reason for this test is that a bus driver might set the
|
|
// CM_DEVCAP_REMOVABLE capability, but if the PDO doesn't get loaded then
|
|
// it can't set the CM_DEVCAP_SURPRISEREMOVALOK. So we won't trust the
|
|
// CM_DEVCAP_REMOVABLE capability if the PDO is not started.
|
|
//
|
|
if ((!(Capabilities & CM_DEVCAP_EJECTSUPPORTED)) &&
|
|
(!(Status & DN_STARTED))) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
OpenPipeAndEventHandles(
|
|
IN LPWSTR szCmd,
|
|
OUT LPHANDLE lphHotPlugPipe,
|
|
OUT LPHANDLE lphHotPlugEvent
|
|
)
|
|
{
|
|
BOOL status = FALSE;
|
|
HANDLE hPipe = INVALID_HANDLE_VALUE;
|
|
HANDLE hEvent = NULL;
|
|
ULONG ulEventNameSize;
|
|
WCHAR szEventName[MAX_PATH];
|
|
DWORD dwBytesRead;
|
|
|
|
|
|
__try {
|
|
//
|
|
// Validate supplied arguments.
|
|
//
|
|
if (!lphHotPlugPipe || !lphHotPlugEvent) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Make sure that a named pipe was specified in the cmd line.
|
|
//
|
|
if(!szCmd || !*szCmd) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Wait for the specified named pipe to become available from the server.
|
|
//
|
|
if (!WaitNamedPipe(szCmd,
|
|
180000) // BUGBUG-2000/07/10-jamesca: How long should we wait?
|
|
) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Open a handle to the specified named pipe
|
|
//
|
|
hPipe = CreateFile(szCmd,
|
|
GENERIC_READ,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
if (hPipe == INVALID_HANDLE_VALUE) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// The very first thing in the pipe should be the size of the event name.
|
|
//
|
|
if (ReadFile(hPipe,
|
|
(LPVOID)&ulEventNameSize,
|
|
sizeof(ULONG),
|
|
&dwBytesRead,
|
|
NULL)) {
|
|
|
|
ASSERT(ulEventNameSize != 0);
|
|
if ((ulEventNameSize == 0) ||
|
|
(ulEventNameSize > MAX_PATH)) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// The next thing in the pipe should be the name of the event.
|
|
//
|
|
if (!ReadFile(hPipe,
|
|
(LPVOID)&szEventName,
|
|
ulEventNameSize,
|
|
&dwBytesRead,
|
|
NULL)) {
|
|
goto clean0;
|
|
}
|
|
|
|
} else {
|
|
if (GetLastError() == ERROR_INVALID_HANDLE) {
|
|
//
|
|
// The handle to the named pipe is not valid. Make sure we don't
|
|
// try to close it on exit.
|
|
//
|
|
hPipe = INVALID_HANDLE_VALUE;
|
|
}
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Open a handle to the specified named event that we can set and wait on.
|
|
//
|
|
hEvent = OpenEventW(EVENT_MODIFY_STATE | SYNCHRONIZE,
|
|
FALSE,
|
|
szEventName);
|
|
if (hEvent == NULL) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// We should now have valid handles to both the pipe and the event.
|
|
//
|
|
status = TRUE;
|
|
ASSERT((hPipe != INVALID_HANDLE_VALUE) && hEvent);
|
|
|
|
|
|
clean0:
|
|
;
|
|
|
|
} __except(EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
status = FALSE;
|
|
}
|
|
|
|
if (status) {
|
|
|
|
*lphHotPlugPipe = hPipe;
|
|
*lphHotPlugEvent = hEvent;
|
|
|
|
} else {
|
|
|
|
if (hPipe != INVALID_HANDLE_VALUE) {
|
|
CloseHandle(hPipe);
|
|
}
|
|
if (hEvent) {
|
|
CloseHandle(hEvent);
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|