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.
1914 lines
52 KiB
1914 lines
52 KiB
/*++
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
misc.c
|
|
|
|
Abstract:
|
|
|
|
This module contains miscellaneous Configuration Manager API routines.
|
|
|
|
CM_Get_Version
|
|
CM_Is_Version_Available
|
|
CM_Connect_Machine
|
|
CM_Disconnect_Machine
|
|
CM_Get_Global_State
|
|
CM_Run_Detection
|
|
CM_Query_Arbitrator_Free_Data
|
|
CM_Query_Resource_Conflicts
|
|
CM_Query_Arbitrator_Free_Size
|
|
|
|
CMP_Report_LogOn
|
|
CMP_Init_Detection
|
|
CMP_WaitServicesAvailable
|
|
CMP_WaitNoPendingInstallEvents
|
|
CMP_GetBlockedDriverInfo
|
|
|
|
Author:
|
|
|
|
Paula Tomlinson (paulat) 6-20-1995
|
|
|
|
Environment:
|
|
|
|
User mode only.
|
|
|
|
Revision History:
|
|
|
|
20-Jun-1995 paulat
|
|
|
|
Creation and initial implementation.
|
|
|
|
--*/
|
|
|
|
|
|
//
|
|
// includes
|
|
//
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include "cfgi.h"
|
|
#include "pnpipc.h"
|
|
|
|
|
|
//
|
|
// global data
|
|
//
|
|
extern PVOID hLocalStringTable; // NOT MODIFIED BY THESE PROCEDURES
|
|
extern WCHAR LocalMachineNameNetBIOS[]; // NOT MODIFIED BY THESE PROCEDURES
|
|
extern WCHAR LocalMachineNameDnsFullyQualified[];// NOT MODIFIED BY THESE PROCEDURES
|
|
|
|
#define NUM_LOGON_RETRIES 30
|
|
|
|
|
|
//
|
|
// Private prototypes
|
|
//
|
|
|
|
CONFIGRET
|
|
IsRemoteServiceRunning(
|
|
IN LPCWSTR UNCServerName,
|
|
IN LPCWSTR ServiceName
|
|
);
|
|
|
|
|
|
|
|
WORD
|
|
CM_Get_Version_Ex(
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the version number of the Configuration Manager APIs.
|
|
|
|
Arguments:
|
|
|
|
hMachine - Machine handle returned from CM_Connect_Machine or NULL.
|
|
|
|
Return value:
|
|
|
|
The function returns the major revision number in the high byte and the
|
|
minor revision number in the low byte. For example, version 4.0 of
|
|
Configuration Manager returns 0x0400.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
WORD wVersion = (WORD)CFGMGR32_VERSION;
|
|
handle_t hBinding = NULL;
|
|
|
|
//
|
|
// setup rpc binding handle
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return wVersion = 0;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetVersion(
|
|
hBinding, // rpc machine name
|
|
&wVersion); // server side version
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_WARNINGS,
|
|
"PNP_GetVersion caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
SetLastError(RpcExceptionCode());
|
|
wVersion = 0;
|
|
}
|
|
RpcEndExcept
|
|
|
|
return wVersion;
|
|
|
|
} // CM_Get_Version_Ex
|
|
|
|
|
|
|
|
BOOL
|
|
CM_Is_Version_Available_Ex(
|
|
IN WORD wVersion,
|
|
IN HMACHINE hMachine
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns whether a specific version of the Configuration Manager
|
|
APIs are available.
|
|
|
|
Arguments:
|
|
|
|
wVersion - Version to query.
|
|
|
|
hMachine - Machine to connect to.
|
|
|
|
Return value:
|
|
|
|
The function returns TRUE if the version of the Configuration Manager APIs is
|
|
equal to or greater than the specified version.
|
|
|
|
--*/
|
|
{
|
|
handle_t hBinding = NULL;
|
|
WORD wVersionInternal;
|
|
|
|
//
|
|
// version 0x0400 is available on all servers, by definition.
|
|
//
|
|
if (wVersion <= (WORD)0x0400) {
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// retrieve the internal server version.
|
|
//
|
|
if (!PnPGetVersion(hMachine, &wVersionInternal)) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// versions up to and including the internal server version are available.
|
|
//
|
|
return (wVersion <= wVersionInternal);
|
|
|
|
} // CM_Is_Version_Available_Ex
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CM_Connect_MachineW(
|
|
IN PCWSTR UNCServerName,
|
|
OUT PHMACHINE phMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine connects to the machine specified and returns a handle that
|
|
is then passed to future calls to the Ex versions of the CM routines.
|
|
This allows callers to get device information on remote machines.
|
|
|
|
Arguments:
|
|
|
|
UNCServerName - Specifies the UNC name of the remote machine to connect to.
|
|
|
|
phMachine - Specifies the address of a variable to receive a handle to
|
|
the connected machine.
|
|
|
|
Return value:
|
|
|
|
If the function succeeds, it returns CR_SUCCESS, otherwise it returns one
|
|
of the CR_* error codes.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
WORD wVersion = 0, wVersionInternal;
|
|
PPNP_MACHINE pMachine = NULL;
|
|
size_t UNCServerNameLen;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (!ARGUMENT_PRESENT(phMachine)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
*phMachine = NULL;
|
|
|
|
//
|
|
// if machine name specified, check for UNC format
|
|
//
|
|
if ((ARGUMENT_PRESENT(UNCServerName)) &&
|
|
(UNCServerName[0] != L'\0')) {
|
|
|
|
//
|
|
// Check that the length in not any longer than the longest possible
|
|
// name we can possibly save, including the NULL terminating
|
|
// character.
|
|
//
|
|
if (FAILED(StringCchLength(
|
|
UNCServerName,
|
|
MAX_PATH + 3,
|
|
&UNCServerNameLen))) {
|
|
Status = CR_INVALID_MACHINENAME;
|
|
goto Clean0;
|
|
}
|
|
|
|
ASSERT(UNCServerNameLen < (MAX_PATH + 3));
|
|
|
|
//
|
|
// Check that the machine name is a UNC name.
|
|
//
|
|
if ((UNCServerNameLen < 3) ||
|
|
(UNCServerName[0] != L'\\') ||
|
|
(UNCServerName[1] != L'\\')) {
|
|
Status = CR_INVALID_MACHINENAME;
|
|
goto Clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// allocate memory for the machine structure and initialize it
|
|
//
|
|
pMachine = (PPNP_MACHINE)pSetupMalloc(sizeof(PNP_MACHINE));
|
|
|
|
if(!pMachine) {
|
|
Status = CR_OUT_OF_MEMORY;
|
|
goto Clean0;
|
|
}
|
|
|
|
|
|
if ((!ARGUMENT_PRESENT(UNCServerName)) ||
|
|
(UNCServerName[0] == L'\0') ||
|
|
(!lstrcmpi(UNCServerName, LocalMachineNameNetBIOS)) ||
|
|
(!lstrcmpi(UNCServerName, LocalMachineNameDnsFullyQualified))) {
|
|
|
|
//----------------------------------------------------------
|
|
// If no machine name was passed in or the machine name
|
|
// matches the local name, use local machine info rather
|
|
// than creating a new binding.
|
|
//----------------------------------------------------------
|
|
|
|
PnPGetGlobalHandles(NULL,
|
|
&pMachine->hStringTable,
|
|
&pMachine->hBindingHandle);
|
|
|
|
if (!ARGUMENT_PRESENT(UNCServerName)) {
|
|
|
|
if (FAILED(StringCchCopy(
|
|
pMachine->szMachineName,
|
|
SIZECHARS(pMachine->szMachineName),
|
|
LocalMachineNameNetBIOS))) {
|
|
Status = CR_INVALID_MACHINENAME;
|
|
goto Clean0;
|
|
}
|
|
|
|
} else {
|
|
|
|
if (FAILED(StringCchCopy(
|
|
pMachine->szMachineName,
|
|
SIZECHARS(pMachine->szMachineName),
|
|
UNCServerName))) {
|
|
Status = CR_INVALID_MACHINENAME;
|
|
goto Clean0;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// First, make sure that the RemoteRegistry service is running on
|
|
// the remote machine, since RemoteRegistry is required for several
|
|
// cfgmgr32/setupapi services.
|
|
//
|
|
Status = IsRemoteServiceRunning(UNCServerName,
|
|
L"RemoteRegistry");
|
|
if (Status != CR_SUCCESS) {
|
|
goto Clean0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
// A remote machine name was specified so explicitly force a
|
|
// new binding for this machine.
|
|
//-------------------------------------------------------------
|
|
|
|
pMachine->hBindingHandle =
|
|
(PVOID)PNP_HANDLE_bind((PNP_HANDLE)UNCServerName);
|
|
|
|
if (pMachine->hBindingHandle == NULL) {
|
|
|
|
if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
|
|
Status = CR_OUT_OF_MEMORY;
|
|
} else if (GetLastError() == ERROR_INVALID_COMPUTERNAME) {
|
|
Status = CR_INVALID_MACHINENAME;
|
|
} else {
|
|
Status = CR_FAILURE;
|
|
}
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// initialize a string table for use with this connection to
|
|
// the remote machine
|
|
//
|
|
pMachine->hStringTable = pSetupStringTableInitialize();
|
|
|
|
if (pMachine->hStringTable == NULL) {
|
|
Status = CR_OUT_OF_MEMORY;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// Add a priming string (see dll entrypt in main.c for details)
|
|
//
|
|
pSetupStringTableAddString(pMachine->hStringTable,
|
|
PRIMING_STRING,
|
|
STRTAB_CASE_SENSITIVE);
|
|
|
|
//
|
|
// save the machine name
|
|
//
|
|
if (FAILED(StringCchCopy(
|
|
pMachine->szMachineName,
|
|
SIZECHARS(pMachine->szMachineName),
|
|
UNCServerName))) {
|
|
Status = CR_INVALID_MACHINENAME;
|
|
goto Clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// test the binding by calling the simplest RPC call (good way
|
|
// for the caller to know whether the service is actually
|
|
// running)
|
|
//
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetVersion(
|
|
pMachine->hBindingHandle,
|
|
&wVersion);
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_WARNINGS,
|
|
"PNP_GetVersion caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
if (Status == CR_SUCCESS) {
|
|
//
|
|
// we got the standard version alright, now try to determine the
|
|
// internal version of the server. initialize the version supplied
|
|
// to the internal version of the client.
|
|
//
|
|
wVersionInternal = (WORD)CFGMGR32_VERSION_INTERNAL;
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetVersionInternal(
|
|
pMachine->hBindingHandle,
|
|
&wVersionInternal);
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
//
|
|
// rpc exception may occur if the interface does not exist on
|
|
// the server, indicating a server version prior to NT 5.1.
|
|
//
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_WARNINGS,
|
|
"PNP_GetVersionInternal caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
if (Status == CR_SUCCESS) {
|
|
//
|
|
// PNP_GetVersionInternal exists on NT 5.1 and later.
|
|
//
|
|
ASSERT(wVersionInternal >= (WORD)0x0501);
|
|
|
|
//
|
|
// use the real internal version of the server instead of the
|
|
// static version returned by PNP_GetVersion.
|
|
//
|
|
wVersion = wVersionInternal;
|
|
}
|
|
|
|
//
|
|
// no matter what happened while trying to retrieve the internal
|
|
// version of the server, we were successful before this.
|
|
//
|
|
Status = CR_SUCCESS;
|
|
}
|
|
|
|
if (Status == CR_SUCCESS) {
|
|
pMachine->ulSignature = (ULONG)MACHINE_HANDLE_SIGNATURE;
|
|
pMachine->wVersion = wVersion;
|
|
*phMachine = (HMACHINE)pMachine;
|
|
}
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
//
|
|
// Reference the following variables so the compiler will respect
|
|
// statement ordering w.r.t. their assignment.
|
|
//
|
|
pMachine = pMachine;
|
|
}
|
|
|
|
if ((Status != CR_SUCCESS) && (pMachine != NULL)) {
|
|
pSetupFree(pMachine);
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Connect_MachineW
|
|
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CM_Disconnect_Machine(
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine disconnects from a machine that was previously connected to
|
|
with the CM_Connect_Machine call.
|
|
|
|
Arguments:
|
|
|
|
hMachine - Specifies a machine handle previously returned by a call to
|
|
CM_Connect_Machine.
|
|
|
|
Return value:
|
|
|
|
If the function succeeds, it returns CR_SUCCESS, otherwise it returns one
|
|
of the CR_* error codes.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
PPNP_MACHINE pMachine = NULL;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (hMachine == NULL) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
pMachine = (PPNP_MACHINE)hMachine;
|
|
|
|
if (pMachine->ulSignature != (ULONG)MACHINE_HANDLE_SIGNATURE) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// only free the machine info if it's not the local machine
|
|
//
|
|
if (pMachine->hStringTable != hLocalStringTable) {
|
|
//
|
|
// free the rpc binding for this remote machine
|
|
//
|
|
PNP_HANDLE_unbind((PNP_HANDLE)pMachine->szMachineName,
|
|
(handle_t)pMachine->hBindingHandle);
|
|
|
|
//
|
|
// release the string table
|
|
//
|
|
pSetupStringTableDestroy(pMachine->hStringTable);
|
|
}
|
|
|
|
//
|
|
// invalidate the signature so we never try to free it again.
|
|
//
|
|
pMachine->ulSignature = 0;
|
|
|
|
//
|
|
// free the memory for the PNP_MACHINE struct
|
|
//
|
|
pSetupFree(pMachine);
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Disconnect_Machine
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CM_Get_Global_State_Ex(
|
|
OUT PULONG pulState,
|
|
IN ULONG ulFlags,
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the global state of the configuration manager.
|
|
|
|
Parameters:
|
|
|
|
pulState Supplies the address of the variable that receives the
|
|
Configuration Manager’s state. May be a combination of the
|
|
following values:
|
|
|
|
Configuration Manager Global State Flags:
|
|
CM_GLOBAL_STATE_CAN_DO_UI
|
|
Can UI be initiated? [TBD: On NT, this may relate to
|
|
whether anyone is logged in]
|
|
CM_GLOBAL_STATE_SERVICES_AVAILABLE
|
|
Are the CM APIs available? (on Windows NT this is always set)
|
|
CM_GLOBAL_STATE_SHUTTING_DOWN
|
|
The Configuration Manager is shutting down.
|
|
[TBD: Does this only happen at shutdown/restart time?]
|
|
CM_GLOBAL_STATE_DETECTION_PENDING
|
|
The Configuration Manager is about to initiate some
|
|
sort of detection.
|
|
|
|
Windows 95 also defines the following additional flag:
|
|
CM_GLOBAL_STATE_ON_BIG_STACK
|
|
[TBD: What should this be defaulted to for NT?]
|
|
|
|
ulFlags Not used, must be zero.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is CR_SUCCESS.
|
|
If the function fails, the return value is a CR error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
handle_t hBinding = NULL;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (!ARGUMENT_PRESENT(pulState)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (INVALID_FLAGS(ulFlags, 0)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetGlobalState(
|
|
hBinding, // rpc binding handle
|
|
pulState, // returns global state
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_GetGlobalState caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Get_Global_State_Ex
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CM_Run_Detection_Ex(
|
|
IN ULONG ulFlags,
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine loads and executes a detection module.
|
|
|
|
Parameters:
|
|
|
|
ulFlags - Specifies the reason for the detection. Can be one of the
|
|
following values:
|
|
|
|
Detection Flags:
|
|
CM_DETECT_NEW_PROFILE - Run detection for a new hardware
|
|
profile.
|
|
CM_DETECT_CRASHED - Previously attempted detection crashed.
|
|
|
|
(Windows 95 defines the following two unused flags as well:
|
|
CM_DETECT_HWPROF_FIRST_BOOT and CM_DETECT_RUN.)
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is CR_SUCCESS.
|
|
If the function fails, the return value is CR_INVALID_FLAG.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
handle_t hBinding = NULL;
|
|
HANDLE hToken;
|
|
ULONG ulPrivilege;
|
|
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (INVALID_FLAGS(ulFlags, CM_DETECT_BITS)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// Enable privileges required by the server
|
|
//
|
|
ulPrivilege = SE_LOAD_DRIVER_PRIVILEGE;
|
|
hToken = PnPEnablePrivileges(&ulPrivilege, 1);
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_RunDetection(
|
|
hBinding,
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_RunDetection caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
//
|
|
// Restore previous privileges
|
|
//
|
|
PnPRestorePrivileges(hToken);
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Run_Detection_Ex
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CM_Query_Arbitrator_Free_Data_Ex(
|
|
OUT PVOID pData,
|
|
IN ULONG DataLen,
|
|
IN DEVINST dnDevInst,
|
|
IN RESOURCEID ResourceID,
|
|
IN ULONG ulFlags,
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns information about available resources of a
|
|
particular type. If the given size is not large enough, this API
|
|
truncates the data and returns CR_BUFFER_SMALL. To determine the
|
|
buffer size needed to receive all the available resource information,
|
|
use the CM_Query_Arbitrator_Free_Size API.
|
|
|
|
Parameters:
|
|
|
|
pData Supplies the address of the buffer that receives information
|
|
on the available resources for the resource type specified
|
|
by ResourceID.
|
|
|
|
DataLen Supplies the size, in bytes, of the data buffer.
|
|
|
|
dnDevNode Supplies the handle of the device instance associated with
|
|
the arbitrator. This is only meaningful for local
|
|
arbitrators--for global arbitrators, specify the root device
|
|
instance or NULL. On Windows NT, this parameter must
|
|
specify either the Root device instance or NULL.
|
|
|
|
ResourceID Supplies the type of the resource. Can be one of the ResType
|
|
values listed in Section 2.1.2.1.. (This API returns
|
|
CR_INVALID_RESOURCEID if this value is ResType_All or
|
|
ResType_None.)
|
|
|
|
ulFlags Must be zero.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is CR_SUCCESS.
|
|
If the function fails, the return value is one of the following:
|
|
CR_BUFFER_SMALL,
|
|
CR_FAILURE,
|
|
CR_INVALID_DEVNODE,
|
|
CR_INVALID_FLAG,
|
|
CR_INVALID_POINTER, or
|
|
CR_INVALID_RESOURCEID.
|
|
(Windows 95 may also return CR_NO_ARBITRATOR.)
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
|
|
PVOID hStringTable = NULL;
|
|
handle_t hBinding = NULL;
|
|
ULONG ulLen = MAX_DEVICE_ID_LEN;
|
|
BOOL Success;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (dnDevInst == 0) {
|
|
Status = CR_INVALID_DEVINST;
|
|
goto Clean0;
|
|
}
|
|
|
|
if ((!ARGUMENT_PRESENT(pData)) || (DataLen == 0)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (INVALID_FLAGS(ulFlags, CM_QUERY_ARBITRATOR_BITS)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (ResourceID > ResType_MAX && ResourceID != ResType_ClassSpecific) {
|
|
Status = CR_INVALID_RESOURCEID;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// retrieve the device instance ID string associated with the devinst
|
|
//
|
|
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
|
|
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
|
|
Status = CR_INVALID_DEVINST;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_QueryArbitratorFreeData(
|
|
hBinding,
|
|
pData,
|
|
DataLen,
|
|
pDeviceID,
|
|
ResourceID,
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_QueryArbitratorFreeData caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Query_Arbitrator_Free_Data_Ex
|
|
|
|
|
|
#if 0
|
|
|
|
CONFIGRET
|
|
WINAPI
|
|
CM_Query_Resource_Conflicts_Ex(
|
|
IN DEVINST dnDevInst,
|
|
IN RESOURCEID ResourceID,
|
|
IN PCVOID ResourceData,
|
|
IN ULONG ResourceLen,
|
|
IN OUT PVOID pData,
|
|
IN OUT PULONG pulDataLen,
|
|
IN ULONG ulFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a list of devnodes that own resources that would
|
|
conflict with the specified resource. If there are no conflicts, the
|
|
returned list is NULL. If the caller supplied buffer is not large enough,
|
|
CR_BUFFER_SMALL is returned and pulDataLen contains the required buffer
|
|
size.
|
|
|
|
Parameters:
|
|
|
|
dnDevInst Supplies the handle of the device instance associated with
|
|
the arbitrator. This is only meaningful for local
|
|
arbitrators--for global arbitrators, specify the root device
|
|
instance or NULL. On Windows NT, this parameter must
|
|
specify either the Root device instance or NULL. ???
|
|
|
|
ResourceID Supplies the type of the resource. Can be one of the ResType
|
|
values listed in Section 2.1.2.1.. (This API returns
|
|
CR_INVALID_RESOURCEID if this value is ResType_All or
|
|
ResType_None.)
|
|
|
|
ResourceData Supplies the adress of an IO_DES, MEM_DES, DMA_DES, IRQ_DES,
|
|
etc, structure, depending on the given resource type.
|
|
|
|
ResourceLen Supplies the size, in bytes, of the structure pointed to
|
|
by ResourceData.
|
|
|
|
pData Supplies the address of the buffer that receives information
|
|
on the available resources for the resource type specified
|
|
by ResourceID.
|
|
|
|
pulDataLen Supplies the size, in bytes, of the data buffer.
|
|
|
|
ulFlags Must be zero.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is CR_SUCCESS.
|
|
If the function fails, the return value is one of the following:
|
|
CR_BUFFER_SMALL,
|
|
CR_FAILURE,
|
|
CR_INVALID_DEVNODE,
|
|
CR_INVALID_FLAG,
|
|
CR_INVALID_POINTER, or
|
|
CR_INVALID_RESOURCEID.
|
|
(Windows 95 may also return CR_NO_ARBITRATOR.)
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
|
|
PVOID hStringTable = NULL;
|
|
handle_t hBinding = NULL;
|
|
ULONG ulLen = MAX_DEVICE_ID_LEN;
|
|
BOOL Success;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (dnDevInst == 0) {
|
|
Status = CR_INVALID_DEVINST;
|
|
goto Clean0;
|
|
}
|
|
|
|
if ((!ARGUMENT_PRESENT(pData)) ||
|
|
(!ARGUMENT_PRESENT(pulDataLen)) ||
|
|
(*pulDataLen == 0)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (INVALID_FLAGS(ulFlags, CM_QUERY_ARBITRATOR_BITS)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (ResourceID > ResType_MAX && ResourceID != ResType_ClassSpecific) {
|
|
Status = CR_INVALID_RESOURCEID;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// retrieve the device instance ID string associated with the devinst
|
|
//
|
|
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
|
|
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
|
|
Status = CR_INVALID_DEVINST;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_QueryArbitratorFreeData(
|
|
hBinding,
|
|
pData,
|
|
DataLen,
|
|
pDeviceID,
|
|
ResourceID,
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_QueryArbitratorFreeData caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Query_Resource_Conflicts_Ex
|
|
#endif
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CM_Query_Arbitrator_Free_Size_Ex(
|
|
OUT PULONG pulSize,
|
|
IN DEVINST dnDevInst,
|
|
IN RESOURCEID ResourceID,
|
|
IN ULONG ulFlags,
|
|
IN HMACHINE hMachine
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
This routine retrieves the size of the available resource information
|
|
that would be returned in a call to the CM_Query_Arbitrator_Free_Data
|
|
API.
|
|
|
|
Parameters:
|
|
|
|
pulSize Supplies the address of the variable that receives the size,
|
|
in bytes, that is required to hold the available resource
|
|
information.
|
|
|
|
dnDevNode Supplies the handle of the device instance associated with
|
|
the arbitrator. This is only meaningful for local
|
|
arbitrators--for global arbitrators, specify the root
|
|
device instance or NULL. On Windows NT, this parameter
|
|
must specify either the Root device instance or NULL.
|
|
|
|
ResourceID Supplies the type of the resource. Can be one of the
|
|
ResType values listed in Section 2.1.2.1.. (This API returns
|
|
CR_INVALID_RESOURCEID if this value is ResType_All or
|
|
ResType_None.)
|
|
|
|
ulFlags CM_QUERY_ARBITRATOR_BITS.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is CR_SUCCESS.
|
|
If the function fails, the return value is one of the following:
|
|
CR_FAILURE,
|
|
CR_INVALID_DEVNODE,
|
|
CR_INVALID_FLAG,
|
|
CR_INVALID_POINTER, or
|
|
CR_INVALID_RESOURCEID.
|
|
(Windows 95 may also return CR_NO_ARBITRATOR.)
|
|
|
|
--*/
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
|
|
PVOID hStringTable = NULL;
|
|
handle_t hBinding = NULL;
|
|
ULONG ulLen = MAX_DEVICE_ID_LEN;
|
|
BOOL Success;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (dnDevInst == 0) {
|
|
Status = CR_INVALID_DEVINST;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (!ARGUMENT_PRESENT(pulSize)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (INVALID_FLAGS(ulFlags, CM_QUERY_ARBITRATOR_BITS)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (ResourceID > ResType_MAX && ResourceID != ResType_ClassSpecific) {
|
|
Status = CR_INVALID_RESOURCEID;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// retrieve the device instance ID string associated with the devinst
|
|
//
|
|
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
|
|
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
|
|
Status = CR_INVALID_DEVINST;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_QueryArbitratorFreeSize(
|
|
hBinding,
|
|
pulSize,
|
|
pDeviceID,
|
|
ResourceID,
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_QueryArbitratorFreeSize caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Query_Arbitrator_Free_Size_Ex
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// Private CM routines
|
|
//-------------------------------------------------------------------
|
|
|
|
|
|
CONFIGRET
|
|
CMP_Report_LogOn(
|
|
IN ULONG ulPrivateID,
|
|
IN DWORD ProcessID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is a private routine to notify the PlugPlay service that an interactive
|
|
user has logged in. It is currently only called by userinit.exe.
|
|
|
|
Parameters:
|
|
|
|
ulPrivateID -
|
|
|
|
Specifies the value of the private id.
|
|
|
|
ProcessID -
|
|
|
|
Specifies the process id of the calling process. Currently, this
|
|
routine is only called by userinit.exe.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is CR_SUCCESS.
|
|
If the function fails, the return value is one of the following:
|
|
CR_FAILURE,
|
|
CR_INVALID_DATA
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
handle_t hBinding = NULL;
|
|
DWORD Retries = 0;
|
|
|
|
UNREFERENCED_PARAMETER(ProcessID);
|
|
|
|
try {
|
|
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (ulPrivateID != 0x07020420) {
|
|
Status = CR_INVALID_DATA;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
// this is always to the local server, by definition
|
|
//
|
|
if (!PnPGetGlobalHandles(NULL, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
for (Retries = 0; Retries < NUM_LOGON_RETRIES; Retries++) {
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_ReportLogOn(
|
|
hBinding, // rpc binding handle
|
|
FALSE, // Is Admin? (not used by server)
|
|
GetCurrentProcessId()); // calling process id
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_ReportLogOn caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ((Status == CR_NO_CM_SERVICES) ||
|
|
(Status == CR_REMOTE_COMM_FAILURE)) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PlugPlay services not available (%d), retrying...\n",
|
|
Status));
|
|
|
|
//
|
|
// This is some error related to the service not being
|
|
// available, wait and try again.
|
|
//
|
|
Sleep(5000);
|
|
continue;
|
|
|
|
} else {
|
|
//
|
|
// Some other error, the service may never be available so bail
|
|
// out now.
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CMP_Report_LogOn
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CMP_Init_Detection(
|
|
IN ULONG ulPrivateID
|
|
)
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
handle_t hBinding = NULL;
|
|
HANDLE hToken;
|
|
ULONG ulPrivilege;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (ulPrivateID != 0x07020420) {
|
|
Status = CR_INVALID_DATA;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
// this is always to the local server, by definition
|
|
//
|
|
if (!PnPGetGlobalHandles(NULL, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// Enable privileges required by the server
|
|
//
|
|
ulPrivilege = SE_LOAD_DRIVER_PRIVILEGE;
|
|
hToken = PnPEnablePrivileges(&ulPrivilege, 1);
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_InitDetection(
|
|
hBinding); // rpc binding handle
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_ERRORS,
|
|
"PNP_InitDetection caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
//
|
|
// Restore previous privileges
|
|
//
|
|
PnPRestorePrivileges(hToken);
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CMP_Init_Detection
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CMP_WaitServicesAvailable(
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine determines whether the user-mode pnp manager server side
|
|
(umpnpmgr) is up and running yet (providing the PNP_Xxx side of the
|
|
config manager apis).
|
|
|
|
Parameters:
|
|
|
|
hMachine - private (opaque) cm machine handle. If NULL, the call refers
|
|
to the local machine.
|
|
|
|
Return Value:
|
|
|
|
If the service is avialable upon return then CR_SUCCESS is returned.
|
|
If some other failure occurs, CR_FAILURE is returned.
|
|
|
|
--*/
|
|
{
|
|
CONFIGRET Status = CR_NO_CM_SERVICES;
|
|
handle_t hBinding = NULL;
|
|
WORD wVersion;
|
|
|
|
try {
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
while ((Status == CR_NO_CM_SERVICES) ||
|
|
(Status == CR_MACHINE_UNAVAILABLE) ||
|
|
(Status == CR_REMOTE_COMM_FAILURE)) {
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetVersion(
|
|
hBinding, // rpc machine name
|
|
&wVersion); // server size version
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_WARNINGS,
|
|
"PNP_GetVersion caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
if (Status == CR_SUCCESS) {
|
|
|
|
//
|
|
// Service is avilable now, return success.
|
|
//
|
|
|
|
goto Clean0;
|
|
}
|
|
|
|
if ((Status == CR_NO_CM_SERVICES) ||
|
|
(Status == CR_MACHINE_UNAVAILABLE) ||
|
|
(Status == CR_REMOTE_COMM_FAILURE)) {
|
|
|
|
//
|
|
// This is some error related to the service not being
|
|
// available, wait and try again.
|
|
//
|
|
|
|
Sleep(5000);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Some other error, the service may never be avaiable
|
|
// so bail out now.
|
|
//
|
|
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
}
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CMP_WaitServicesAvailable
|
|
|
|
|
|
|
|
DWORD
|
|
CMP_WaitNoPendingInstallEvents(
|
|
IN DWORD dwTimeout
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine waits until there are no pending device install events.
|
|
If a timeout value is specified then it will return either when no
|
|
install events are pending or when the timeout period has expired,
|
|
whichever comes first. This routine is intended to be called after
|
|
user-logon, only.
|
|
|
|
NOTE: New install events can occur at anytime, this routine just
|
|
indicates that there are no install events at this moment.
|
|
|
|
Parameters:
|
|
|
|
dwTimeout - Specifies the time-out interval, in milliseconds. The function
|
|
returns if the interval elapses, even if there are still pending
|
|
install events. If dwTimeout is zero, the function just tests whether
|
|
there are pending install events and returns immediately. If
|
|
dwTimeout is INFINITE, the function's time-out interval never elapses.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value indicates the event that caused
|
|
the function to return. If the function fails, the return value is
|
|
WAIT_FAILED. To get extended error information, call GetLastError.
|
|
The return value on success is one of the following values:
|
|
|
|
WAIT_ABANDONED The specified object is a mutex object that was not
|
|
released by the thread that owned the mutex object before
|
|
the owning thread terminated. Ownership of the mutex
|
|
object is granted to the calling thread, and the mutex is
|
|
set to nonsignaled.
|
|
WAIT_OBJECT_0 The state of the specified object is signaled.
|
|
WAIT_TIMEOUT The time-out interval elapsed, and the object's state is
|
|
nonsignaled.
|
|
|
|
--*/
|
|
{
|
|
DWORD Status = WAIT_FAILED;
|
|
HANDLE hEvent = NULL;
|
|
|
|
try {
|
|
|
|
hEvent = OpenEvent(SYNCHRONIZE, FALSE, PNP_NO_INSTALL_EVENTS);
|
|
|
|
if (hEvent == NULL) {
|
|
Status = WAIT_FAILED;
|
|
} else {
|
|
Status = WaitForSingleObject(hEvent, dwTimeout);
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = WAIT_FAILED;
|
|
}
|
|
|
|
if (hEvent) {
|
|
CloseHandle(hEvent);
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CMP_WaitNoPendingInstallEvents
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CMP_GetBlockedDriverInfo(
|
|
OUT LPBYTE Buffer,
|
|
IN OUT PULONG pulLength,
|
|
IN ULONG ulFlags,
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the list of drivers that have been blocked from
|
|
loading on the system since boot.
|
|
|
|
Arguments:
|
|
|
|
Buffer - Supplies the address of the buffer that receives the list of
|
|
drivers that have been blocked from loading on the system. Can
|
|
be NULL when simply retrieving data size.
|
|
|
|
pulLength - Supplies the address of the variable that contains the size, in
|
|
bytes, of the buffer. If the variable is initially zero, the
|
|
API replaces it with the buffer size needed to receive all the
|
|
data. In this case, the Buffer parameter is ignored.
|
|
|
|
ulFlags - Must be zero.
|
|
|
|
hMachine - Machine handle returned from CM_Connect_Machine or NULL.
|
|
|
|
Return value:
|
|
|
|
If the function succeeds, it returns CR_SUCCESS, otherwise it returns one of
|
|
the CR_* error codes.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status;
|
|
ULONG ulTransferLen;
|
|
BYTE NullBuffer = 0;
|
|
handle_t hBinding = NULL;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (!ARGUMENT_PRESENT(pulLength)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if ((!ARGUMENT_PRESENT(Buffer)) && (*pulLength != 0)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (INVALID_FLAGS(ulFlags, 0)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// NOTE: The ulTransferLen variable is just used to control
|
|
// how much data is marshalled via rpc between address spaces.
|
|
// ulTransferLen should be set on entry to the size of the Buffer.
|
|
// The last parameter should also be the size of the Buffer on entry
|
|
// and on exit contains either the amount transferred (if a transfer
|
|
// occured) or the amount required, this value should be passed back
|
|
// in the callers pulLength parameter.
|
|
//
|
|
ulTransferLen = *pulLength;
|
|
if (!ARGUMENT_PRESENT(Buffer)) {
|
|
Buffer = &NullBuffer;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetBlockedDriverInfo(
|
|
hBinding, // rpc binding handle
|
|
Buffer, // receives blocked driver info
|
|
&ulTransferLen, // input/output buffer size
|
|
pulLength, // bytes copied (or bytes required)
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_WARNINGS,
|
|
"PNP_GetBlockedDriverInfo caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CMP_GetBlockedDriverInfo
|
|
|
|
|
|
|
|
CONFIGRET
|
|
CMP_GetServerSideDeviceInstallFlags(
|
|
IN PULONG pulSSDIFlags,
|
|
IN ULONG ulFlags,
|
|
IN HMACHINE hMachine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the server side device install flags.
|
|
|
|
Arguments:
|
|
|
|
pulSSDIFlags - Pointer to a ULONG that receives the server side device
|
|
install flags.
|
|
|
|
ulFlags - Must be zero.
|
|
|
|
hMachine - Machine handle returned from CM_Connect_Machine or NULL.
|
|
|
|
Return value:
|
|
|
|
If the function succeeds, it returns CR_SUCCESS, otherwise it returns one of
|
|
the CR_* error codes.
|
|
|
|
--*/
|
|
|
|
{
|
|
CONFIGRET Status;
|
|
handle_t hBinding = NULL;
|
|
|
|
try {
|
|
//
|
|
// validate parameters
|
|
//
|
|
if (!ARGUMENT_PRESENT(pulSSDIFlags)) {
|
|
Status = CR_INVALID_POINTER;
|
|
goto Clean0;
|
|
}
|
|
|
|
if (INVALID_FLAGS(ulFlags, 0)) {
|
|
Status = CR_INVALID_FLAG;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// setup rpc binding handle (don't need string table handle)
|
|
//
|
|
if (!PnPGetGlobalHandles(hMachine, NULL, &hBinding)) {
|
|
Status = CR_FAILURE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// No special privileges are required by the server
|
|
//
|
|
|
|
RpcTryExcept {
|
|
//
|
|
// call rpc service entry point
|
|
//
|
|
Status = PNP_GetServerSideDeviceInstallFlags(
|
|
hBinding, // rpc binding handle
|
|
pulSSDIFlags, // receives server side device install flags
|
|
ulFlags); // not used
|
|
}
|
|
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
|
|
|
KdPrintEx((DPFLTR_PNPMGR_ID,
|
|
DBGF_WARNINGS,
|
|
"PNP_GetServerSideDeviceInstallFlags caused an exception (%d)\n",
|
|
RpcExceptionCode()));
|
|
|
|
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
|
}
|
|
RpcEndExcept
|
|
|
|
Clean0:
|
|
NOTHING;
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = CR_FAILURE;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CMP_GetServerSideDeviceInstallFlags
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// Local Stubs
|
|
//-------------------------------------------------------------------
|
|
|
|
|
|
WORD
|
|
CM_Get_Version(
|
|
VOID
|
|
)
|
|
{
|
|
return CM_Get_Version_Ex(NULL);
|
|
}
|
|
|
|
|
|
BOOL
|
|
CM_Is_Version_Available(
|
|
IN WORD wVersion
|
|
)
|
|
{
|
|
return CM_Is_Version_Available_Ex(wVersion, NULL);
|
|
}
|
|
|
|
|
|
CONFIGRET
|
|
CM_Get_Global_State(
|
|
OUT PULONG pulState,
|
|
IN ULONG ulFlags
|
|
)
|
|
{
|
|
return CM_Get_Global_State_Ex(pulState, ulFlags, NULL);
|
|
}
|
|
|
|
|
|
CONFIGRET
|
|
CM_Query_Arbitrator_Free_Data(
|
|
OUT PVOID pData,
|
|
IN ULONG DataLen,
|
|
IN DEVINST dnDevInst,
|
|
IN RESOURCEID ResourceID,
|
|
IN ULONG ulFlags
|
|
)
|
|
{
|
|
return CM_Query_Arbitrator_Free_Data_Ex(pData, DataLen, dnDevInst,
|
|
ResourceID, ulFlags, NULL);
|
|
}
|
|
|
|
|
|
CONFIGRET
|
|
CM_Query_Arbitrator_Free_Size(
|
|
OUT PULONG pulSize,
|
|
IN DEVINST dnDevInst,
|
|
IN RESOURCEID ResourceID,
|
|
IN ULONG ulFlags
|
|
)
|
|
{
|
|
return CM_Query_Arbitrator_Free_Size_Ex(pulSize, dnDevInst, ResourceID,
|
|
ulFlags, NULL);
|
|
}
|
|
|
|
|
|
CONFIGRET
|
|
CM_Run_Detection(
|
|
IN ULONG ulFlags
|
|
)
|
|
{
|
|
return CM_Run_Detection_Ex(ulFlags, NULL);
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// ANSI Stubs
|
|
//-------------------------------------------------------------------
|
|
|
|
|
|
CONFIGRET
|
|
CM_Connect_MachineA(
|
|
IN PCSTR UNCServerName,
|
|
OUT PHMACHINE phMachine
|
|
)
|
|
{
|
|
CONFIGRET Status = CR_SUCCESS;
|
|
PWSTR pUniName = NULL;
|
|
|
|
if ((!ARGUMENT_PRESENT(UNCServerName)) ||
|
|
(UNCServerName[0] == '\0')) {
|
|
//
|
|
// no explicit name specified, so assume local machine and
|
|
// nothing to translate
|
|
//
|
|
Status = CM_Connect_MachineW(pUniName,
|
|
phMachine);
|
|
|
|
} else if (pSetupCaptureAndConvertAnsiArg(UNCServerName, &pUniName) == NO_ERROR) {
|
|
|
|
Status = CM_Connect_MachineW(pUniName,
|
|
phMachine);
|
|
pSetupFree(pUniName);
|
|
|
|
} else {
|
|
Status = CR_INVALID_DATA;
|
|
}
|
|
|
|
return Status;
|
|
|
|
} // CM_Connect_MachineA
|
|
|
|
|