rpcserver.c File Reference

#include "precomp.h"
#include <debug.h>

Include dependency graph for rpcserver.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
DWORD WINAPI	RpcServerThread (LPVOID lpParameter)
void __RPC_FAR *__RPC_USER	midl_user_allocate (SIZE_T len)
void __RPC_USER	midl_user_free (void __RPC_FAR *ptr)
static CONFIGRET WINAPI	NtStatusToCrError (NTSTATUS Status)
static VOID	SplitDeviceInstanceID (IN LPWSTR pszDeviceInstanceID, OUT LPWSTR pszEnumerator, OUT LPWSTR pszDevice, OUT LPWSTR pszInstance)
static CONFIGRET	ClearDeviceStatus (_In_ LPWSTR pszDeviceID, _In_ DWORD ulStatus, _In_ DWORD ulProblem)
static CONFIGRET	GetDeviceStatus (_In_ LPWSTR pszDeviceID, _Out_ DWORD *pulStatus, _Out_ DWORD *pulProblem)
static CONFIGRET	SetDeviceStatus (_In_ LPWSTR pszDeviceID, _In_ DWORD ulStatus, _In_ DWORD ulProblem)
static CONFIGRET	DisableDeviceInstance (_In_ LPWSTR pszDeviceInstance, _Inout_opt_ PPNP_VETO_TYPE pVetoType, _Inout_opt_ LPWSTR pszVetoName, _In_ DWORD ulNameLength)
static BOOL	IsValidDeviceInstanceID (_In_ PWSTR pszDeviceInstanceID)
static BOOL	IsRootDeviceInstanceID (_In_ PWSTR pszDeviceInstanceID)
static BOOL	IsPresentDeviceInstanceID (_In_ LPWSTR pszDeviceInstanceID)
static CONFIGRET	OpenConfigurationKey (_In_ LPCWSTR pszDeviceID, _In_ DWORD ulLogConfType, _Out_ PHKEY phKey)
static CONFIGRET	GetConfigurationData (_In_ HKEY hKey, _In_ ULONG ulLogConfType, _Out_ PULONG pulRegDataType, _Out_ PULONG pulDataSize, _Out_ LPBYTE *ppBuffer, _In_ ULONG ulValueNameBufferSize, _Out_opt_ LPWSTR pszValueNameBuffer)
static PCM_FULL_RESOURCE_DESCRIPTOR	NextResourceDescriptor (_In_ PCM_FULL_RESOURCE_DESCRIPTOR pDescriptor)
static PIO_RESOURCE_LIST	NextResourceRequirement (_In_ PIO_RESOURCE_LIST pResourceList)
static BOOL	IsCallerInteractive (_In_ handle_t hBinding)
VOID __RPC_USER	PNP_NOTIFY_HANDLE_rundown (PNP_NOTIFY_HANDLE pHandle)
DWORD WINAPI	PNP_Disconnect (handle_t hBinding)
DWORD WINAPI	PNP_Connect (handle_t hBinding)
DWORD WINAPI	PNP_GetVersion (handle_t hBinding, WORD *pVersion)
DWORD WINAPI	PNP_GetGlobalState (handle_t hBinding, DWORD *pulState, DWORD ulFlags)
DWORD WINAPI	PNP_InitDetection (handle_t hBinding)
DWORD WINAPI	PNP_ReportLogOn (handle_t hBinding, BOOL Admin, DWORD ProcessId)
DWORD WINAPI	PNP_ValidateDeviceInstance (handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
DWORD WINAPI	PNP_GetRootDeviceInstance (handle_t hBinding, LPWSTR pDeviceID, PNP_RPC_STRING_LEN ulLength)
DWORD WINAPI	PNP_GetRelatedDeviceInstance (handle_t hBinding, DWORD ulRelationship, LPWSTR pDeviceID, LPWSTR pRelatedDeviceId, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_EnumerateSubKeys (handle_t hBinding, DWORD ulBranch, DWORD ulIndex, LPWSTR Buffer, PNP_RPC_STRING_LEN ulLength, PNP_RPC_STRING_LEN *pulRequiredLen, DWORD ulFlags)
static CONFIGRET	GetRelationsInstanceList (_In_ PWSTR pszDevice, _In_ DWORD ulFlags, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
static CONFIGRET	GetServiceInstanceList (_In_ PWSTR pszService, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
static CONFIGRET	GetDeviceInstanceList (_In_ PWSTR pszDevice, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
CONFIGRET	GetEnumeratorInstanceList (_In_ PWSTR pszEnumerator, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
static CONFIGRET	GetAllInstanceList (_Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
DWORD WINAPI	PNP_GetDeviceList (handle_t hBinding, LPWSTR pszFilter, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
static CONFIGRET	GetRelationsInstanceListSize (_In_ PWSTR pszDevice, _In_ DWORD ulFlags, _Inout_ PDWORD pulLength)
static CONFIGRET	GetServiceInstanceListSize (_In_ PWSTR pszService, _Out_ PDWORD pulLength)
static CONFIGRET	GetDeviceInstanceListSize (_In_ LPCWSTR pszDevice, _Out_ PULONG pulLength)
static CONFIGRET	GetEnumeratorInstanceListSize (_In_ LPCWSTR pszEnumerator, _Out_ PULONG pulLength)
static CONFIGRET	GetAllInstanceListSize (_Out_ PULONG pulLength)
DWORD WINAPI	PNP_GetDeviceListSize (handle_t hBinding, LPWSTR pszFilter, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_GetDepth (handle_t hBinding, LPWSTR pszDeviceID, DWORD *pulDepth, DWORD ulFlags)
DWORD WINAPI	PNP_GetDeviceRegProp (handle_t hBinding, LPWSTR pDeviceID, DWORD ulProperty, DWORD *pulRegDataType, BYTE *Buffer, PNP_PROP_SIZE *pulTransferLen, PNP_PROP_SIZE *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_SetDeviceRegProp (handle_t hBinding, LPWSTR pDeviceId, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
DWORD WINAPI	PNP_GetClassInstance (handle_t hBinding, LPWSTR pDeviceId, LPWSTR pszClassInstance, PNP_RPC_STRING_LEN ulLength)
DWORD WINAPI	PNP_CreateKey (handle_t hBinding, LPWSTR pszSubKey, DWORD samDesired, DWORD ulFlags)
DWORD WINAPI	PNP_DeleteRegistryKey (handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentKey, LPWSTR pszChildKey, DWORD ulFlags)
DWORD WINAPI	PNP_GetClassCount (handle_t hBinding, DWORD *pulClassCount, DWORD ulFlags)
DWORD WINAPI	PNP_GetClassName (handle_t hBinding, LPWSTR pszClassGuid, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_DeleteClassKey (handle_t hBinding, LPWSTR pszClassGuid, DWORD ulFlags)
DWORD WINAPI	PNP_GetInterfaceDeviceAlias (handle_t hBinding, LPWSTR pszInterfaceDevice, GUID *AliasInterfaceGuid, LPWSTR pszAliasInterfaceDevice, PNP_RPC_STRING_LEN *pulLength, PNP_RPC_STRING_LEN *pulTransferLen, DWORD ulFlags)
DWORD WINAPI	PNP_GetInterfaceDeviceList (handle_t hBinding, GUID *InterfaceGuid, LPWSTR pszDeviceID, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_GetInterfaceDeviceListSize (handle_t hBinding, PNP_RPC_BUFFER_SIZE *pulLen, GUID *InterfaceGuid, LPWSTR pszDeviceID, DWORD ulFlags)
DWORD WINAPI	PNP_RegisterDeviceClassAssociation (handle_t hBinding, LPWSTR pszDeviceID, GUID *InterfaceGuid, LPWSTR pszReference, LPWSTR pszSymLink, PNP_RPC_STRING_LEN *pulLength, PNP_RPC_STRING_LEN *pulTransferLen, DWORD ulFlags)
DWORD WINAPI	PNP_UnregisterDeviceClassAssociation (handle_t hBinding, LPWSTR pszInterfaceDevice, DWORD ulFlags)
DWORD WINAPI	PNP_GetClassRegProp (handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD *pulRegDataType, BYTE *Buffer, PNP_RPC_STRING_LEN *pulTransferLen, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_SetClassRegProp (handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
static CONFIGRET	CreateDeviceInstance (_In_ LPWSTR pszDeviceID, _In_ BOOL bPhantomDevice)
static CONFIGRET	GenerateDeviceID (_Inout_ LPWSTR pszDeviceID, _In_ PNP_RPC_STRING_LEN ulLength)
DWORD WINAPI	PNP_CreateDevInst (handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentDeviceID, PNP_RPC_STRING_LEN ulLength, DWORD ulFlags)
static CONFIGRET	SetupDeviceInstance (_In_ LPWSTR pszDeviceInstance, _In_ DWORD ulMinorAction)
static CONFIGRET	EnableDeviceInstance (_In_ LPWSTR pszDeviceInstance)
static CONFIGRET	ReenumerateDeviceInstance (_In_ LPWSTR pszDeviceInstance, _In_ ULONG ulMinorAction)
DWORD WINAPI	PNP_DeviceInstanceAction (handle_t hBinding, DWORD ulMajorAction, DWORD ulMinorAction, LPWSTR pszDeviceInstance1, LPWSTR pszDeviceInstance2)
DWORD WINAPI	PNP_GetDeviceStatus (handle_t hBinding, LPWSTR pDeviceID, DWORD *pulStatus, DWORD *pulProblem, DWORD ulFlags)
DWORD WINAPI	PNP_SetDeviceProblem (handle_t hBinding, LPWSTR pDeviceID, DWORD ulProblem, DWORD ulFlags)
DWORD WINAPI	PNP_DisableDevInst (handle_t hBinding, LPWSTR pDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
DWORD WINAPI	PNP_UninstallDevInst (handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
static BOOL	CheckForDeviceId (LPWSTR lpDeviceIdList, LPWSTR lpDeviceId)
static VOID	AppendDeviceId (LPWSTR lpDeviceIdList, LPDWORD lpDeviceIdListSize, LPWSTR lpDeviceId)
DWORD WINAPI	PNP_AddID (handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszID, DWORD ulFlags)
DWORD WINAPI	PNP_RegisterDriver (handle_t hBinding, LPWSTR pszDeviceID, DWORD ulFlags)
DWORD WINAPI	PNP_QueryRemove (handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
DWORD WINAPI	PNP_RequestDeviceEject (handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
CONFIGRET WINAPI	PNP_IsDockStationPresent (handle_t hBinding, BOOL *Present)
DWORD WINAPI	PNP_RequestEjectPC (handle_t hBinding)
DWORD WINAPI	PNP_HwProfFlags (handle_t hBinding, DWORD ulAction, LPWSTR pDeviceID, DWORD ulConfig, DWORD *pulValue, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
DWORD WINAPI	PNP_GetHwProfInfo (handle_t hBinding, DWORD ulIndex, HWPROFILEINFO *pHWProfileInfo, DWORD ulProfileInfoSize, DWORD ulFlags)
DWORD WINAPI	PNP_AddEmptyLogConf (handle_t hBinding, LPWSTR pDeviceID, DWORD ulPriority, DWORD *pulLogConfTag, DWORD ulFlags)
DWORD WINAPI	PNP_FreeLogConf (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulLogConfTag, DWORD ulFlags)
DWORD WINAPI	PNP_GetFirstLogConf (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD *pulLogConfTag, DWORD ulFlags)
DWORD WINAPI	PNP_GetNextLogConf (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulCurrentTag, DWORD *pulNextTag, DWORD ulFlags)
DWORD WINAPI	PNP_GetLogConfPriority (handle_t hBinding, LPWSTR pDeviceID, DWORD ulType, DWORD ulTag, DWORD *pPriority, DWORD ulFlags)
DWORD WINAPI	PNP_AddResDes (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD *pulResourceTag, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, DWORD ulFlags)
DWORD WINAPI	PNP_FreeResDes (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulPreviousResType, DWORD *pulPreviousResTag, DWORD ulFlags)
DWORD WINAPI	PNP_GetNextResDes (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulNextResType, DWORD *pulNextResTag, DWORD ulFlags)
DWORD WINAPI	PNP_GetResDesData (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, BYTE *Buffer, PNP_RPC_BUFFER_SIZE BufferLen, DWORD ulFlags)
DWORD WINAPI	PNP_GetResDesDataSize (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulSize, DWORD ulFlags)
DWORD WINAPI	PNP_ModifyResDes (handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID CurrentResourceID, RESOURCEID NewResourceID, DWORD ulResourceTag, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, DWORD ulFlags)
DWORD WINAPI	PNP_DetectResourceConflict (handle_t hBinding, LPWSTR pDeviceID, RESOURCEID ResourceID, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, BOOL *pbConflictDetected, DWORD ulFlags)
DWORD WINAPI	PNP_QueryResConfList (handle_t hBinding, LPWSTR pDeviceID, RESOURCEID ResourceID, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, BYTE *Buffer, PNP_RPC_BUFFER_SIZE BufferLen, DWORD ulFlags)
DWORD WINAPI	PNP_SetHwProf (handle_t hBinding, DWORD ulHardwareProfile, DWORD ulFlags)
DWORD WINAPI	PNP_QueryArbitratorFreeData (handle_t hBinding, BYTE *pData, DWORD DataLen, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
DWORD WINAPI	PNP_QueryArbitratorFreeSize (handle_t hBinding, DWORD *pulSize, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
CONFIGRET WINAPI	PNP_RunDetection (handle_t hBinding, DWORD ulFlags)
DWORD WINAPI	PNP_RegisterNotification (handle_t hBinding, DWORD_PTR hRecipient, LPWSTR pszName, BYTE *pNotificationFilter, DWORD ulNotificationFilterSize, DWORD ulFlags, PNP_NOTIFY_HANDLE *pNotifyHandle, DWORD ulProcessId, DWORD *pulUnknown9)
DWORD WINAPI	PNP_UnregisterNotification (handle_t hBinding, PNP_NOTIFY_HANDLE *pNotifyHandle)
DWORD WINAPI	PNP_GetCustomDevProp (handle_t hBinding, LPWSTR pDeviceID, LPWSTR CustomPropName, DWORD *pulRegDataType, BYTE *Buffer, PNP_RPC_STRING_LEN *pulTransferLen, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_GetVersionInternal (handle_t hBinding, WORD *pwVersion)
DWORD WINAPI	PNP_GetBlockedDriverInfo (handle_t hBinding, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulTransferLen, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
DWORD WINAPI	PNP_GetServerSideDeviceInstallFlags (handle_t hBinding, DWORD *pulSSDIFlags, DWORD ulFlags)
DWORD WINAPI	PNP_GetObjectPropKeys (handle_t hBinding, LPWSTR ObjectName, DWORD ObjectType, LPWSTR PropertyCultureName, PNP_PROP_COUNT *PropertyCount, PNP_PROP_COUNT *TransferLen, DEVPROPKEY *PropertyKeys, DWORD Flags)
DWORD WINAPI	PNP_GetObjectProp (handle_t hBinding, LPWSTR ObjectName, DWORD ObjectType, LPWSTR PropertyCultureName, const DEVPROPKEY *PropertyKey, DEVPROPTYPE *PropertyType, PNP_PROP_SIZE *PropertySize, PNP_PROP_SIZE *TransferLen, BYTE *PropertyBuffer, DWORD Flags)
DWORD WINAPI	PNP_SetObjectProp (handle_t hBinding, LPWSTR ObjectName, DWORD ObjectType, LPWSTR PropertyCultureName, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, PNP_PROP_SIZE PropertySize, BYTE *PropertyBuffer, DWORD Flags)
DWORD WINAPI	PNP_InstallDevInst (handle_t hBinding)
DWORD WINAPI	PNP_ApplyPowerSettings (handle_t hBinding)
DWORD WINAPI	PNP_DriverStoreAddDriverPackage (handle_t hBinding)
DWORD WINAPI	PNP_DriverStoreDeleteDriverPackage (handle_t hBinding)
DWORD WINAPI	PNP_RegisterServiceNotification (handle_t hBinding)
DWORD WINAPI	PNP_SetActiveService (handle_t hBinding, LPWSTR pszFilter, DWORD ulFlags)
DWORD WINAPI	PNP_DeleteServiceDevices (handle_t hBinding)

Variables
static WCHAR	szRootDeviceInstanceID [] = L"HTREE\\ROOT\\0"
LUID	LoadDriverPrivilege = {SE_LOAD_DRIVER_PRIVILEGE, 0}
LIST_ENTRY	NotificationListHead
RTL_RESOURCE	NotificationListLock

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 33 of file rpcserver.c.

Function Documentation

AppendDeviceId()

static VOID AppendDeviceId ( LPWSTR  lpDeviceIdList, LPDWORD  lpDeviceIdListSize, LPWSTR  lpDeviceId  )

static

Definition at line 3776 of file rpcserver.c.

{
    DWORD dwLen;
    DWORD dwPos;
 
    dwLen = wcslen(lpDeviceId);
    dwPos = (*lpDeviceIdListSize / sizeof(WCHAR)) - 1;
 
    wcscpy(&lpDeviceIdList[dwPos], lpDeviceId);
 
    dwPos += (dwLen + 1);
 
    lpDeviceIdList[dwPos] = 0;
 
    *lpDeviceIdListSize = dwPos * sizeof(WCHAR);
}

Referenced by PNP_AddID().

CheckForDeviceId()

static BOOL CheckForDeviceId ( LPWSTR  lpDeviceIdList, LPWSTR  lpDeviceId  )

static

Definition at line 3755 of file rpcserver.c.

{
    LPWSTR lpPtr;
    DWORD dwLength;
 
    lpPtr = lpDeviceIdList;
    while (*lpPtr != 0)
    {
        dwLength = wcslen(lpPtr);
        if (0 == _wcsicmp(lpPtr, lpDeviceId))
            return TRUE;
 
        lpPtr += (dwLength + 1);
    }
 
    return FALSE;
}

Referenced by PNP_AddID().

ClearDeviceStatus()

static CONFIGRET ClearDeviceStatus ( _In_ LPWSTR  pszDeviceID, _In_ DWORD  ulStatus, _In_ DWORD  ulProblem  )

static

Definition at line 202 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT1("ClearDeviceStatus(%S 0x%lx 0x%lx)\n",
            pszDeviceID, ulStatus, ulProblem);
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
    PlugPlayData.Operation = PNP_CLEAR_DEVICE_STATUS;
    PlugPlayData.DeviceStatus = ulStatus;
    PlugPlayData.DeviceProblem = ulProblem;
 
    Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by PNP_SetDeviceProblem(), and SetupDeviceInstance().

CreateDeviceInstance()

static CONFIGRET CreateDeviceInstance ( _In_ LPWSTR  pszDeviceID, _In_ BOOL  bPhantomDevice  )

static

Definition at line 3128 of file rpcserver.c.

{
    WCHAR szEnumerator[MAX_DEVICE_ID_LEN];
    WCHAR szDevice[MAX_DEVICE_ID_LEN];
    WCHAR szInstance[MAX_DEVICE_ID_LEN];
    HKEY hKeyEnumerator;
    HKEY hKeyDevice;
    HKEY hKeyInstance;
    HKEY hKeyControl;
    LONG lError;
 
    /* Split the instance ID */
    SplitDeviceInstanceID(pszDeviceID,
                          szEnumerator,
                          szDevice,
                          szInstance);
 
    /* Open or create the enumerator key */
    lError = RegCreateKeyExW(hEnumKey,
                             szEnumerator,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_ALL_ACCESS,
                             NULL,
                             &hKeyEnumerator,
                             NULL);
    if (lError != ERROR_SUCCESS)
    {
        return CR_REGISTRY_ERROR;
    }
 
    /* Open or create the device key */
    lError = RegCreateKeyExW(hKeyEnumerator,
                             szDevice,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_ALL_ACCESS,
                             NULL,
                             &hKeyDevice,
                             NULL);
 
    /* Close the enumerator key */
    RegCloseKey(hKeyEnumerator);
 
    if (lError != ERROR_SUCCESS)
    {
        return CR_REGISTRY_ERROR;
    }
 
    /* Try to open the instance key and fail if it exists */
    lError = RegOpenKeyExW(hKeyDevice,
                           szInstance,
                           0,
                           KEY_SET_VALUE,
                           &hKeyInstance);
    if (lError == ERROR_SUCCESS)
    {
        DPRINT1("Instance %S already exists!\n", szInstance);
        RegCloseKey(hKeyInstance);
        RegCloseKey(hKeyDevice);
        return CR_ALREADY_SUCH_DEVINST;
    }
 
    /* Create a new instance key */
    lError = RegCreateKeyExW(hKeyDevice,
                             szInstance,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_ALL_ACCESS,
                             NULL,
                             &hKeyInstance,
                             NULL);
 
    /* Close the device key */
    RegCloseKey(hKeyDevice);
 
    if (lError != ERROR_SUCCESS)
    {
        return CR_REGISTRY_ERROR;
    }
 
    if (bPhantomDevice)
    {
        DWORD dwPhantomValue = 1;
        RegSetValueExW(hKeyInstance,
                       L"Phantom",
                       0,
                       REG_DWORD,
                       (PBYTE)&dwPhantomValue,
                       sizeof(dwPhantomValue));
    }
 
    /* Create the 'Control' sub key */
    lError = RegCreateKeyExW(hKeyInstance,
                             L"Control",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_ALL_ACCESS,
                             NULL,
                             &hKeyControl,
                             NULL);
    if (lError == ERROR_SUCCESS)
    {
        RegCloseKey(hKeyControl);
    }
 
    RegCloseKey(hKeyInstance);
 
    return (lError == ERROR_SUCCESS) ? CR_SUCCESS : CR_REGISTRY_ERROR;
}

Referenced by PNP_CreateDevInst().

DisableDeviceInstance()

static CONFIGRET DisableDeviceInstance ( _In_ LPWSTR  pszDeviceInstance, _Inout_opt_ PPNP_VETO_TYPE  pVetoType, _Inout_opt_ LPWSTR  pszVetoName, _In_ DWORD  ulNameLength  )

static

Definition at line 297 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_QUERY_REMOVE_DATA QueryRemoveData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT1("DisableDeviceInstance(%S %p %p %lu)\n",
            pszDeviceInstance, pVetoType, pszVetoName, ulNameLength);
 
    RtlInitUnicodeString(&QueryRemoveData.DeviceInstance,
                         pszDeviceInstance);
 
    QueryRemoveData.Flags = 0;
    QueryRemoveData.VetoType = 0;
    QueryRemoveData.VetoName = pszVetoName;
    QueryRemoveData.NameLength = ulNameLength;
 
    Status = NtPlugPlayControl(PlugPlayControlQueryAndRemoveDevice,
                               &QueryRemoveData,
                               sizeof(PLUGPLAY_CONTROL_QUERY_REMOVE_DATA));
    if (Status == STATUS_NO_SUCH_DEVICE)
    {
        ret = CR_INVALID_DEVNODE;
    }
    else if (Status == STATUS_PLUGPLAY_QUERY_VETOED)
    {
        if (pVetoType != NULL)
            *pVetoType = QueryRemoveData.VetoType;
 
        ret = CR_REMOVE_VETOED;
    }
    else if (!NT_SUCCESS(Status))
    {
        ret = NtStatusToCrError(Status);
    }
 
    return ret;
}

Referenced by PNP_DisableDevInst().

EnableDeviceInstance()

static CONFIGRET EnableDeviceInstance ( _In_ LPWSTR  pszDeviceInstance )

static

Definition at line 3483 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEVICE_CONTROL_DATA ControlData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT("Enable device instance %S\n", pszDeviceInstance);
 
    RtlInitUnicodeString(&ControlData.DeviceInstance, pszDeviceInstance);
    Status = NtPlugPlayControl(PlugPlayControlStartDevice, &ControlData, sizeof(ControlData));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by PNP_DeviceInstanceAction().

GenerateDeviceID()

static CONFIGRET GenerateDeviceID ( _Inout_ LPWSTR  pszDeviceID, _In_ PNP_RPC_STRING_LEN  ulLength  )

static

Definition at line 3248 of file rpcserver.c.

{
    WCHAR szGeneratedInstance[MAX_DEVICE_ID_LEN];
    HKEY hKey;
    DWORD dwInstanceNumber;
    DWORD dwError = ERROR_SUCCESS;
    CONFIGRET ret = CR_SUCCESS;
 
    /* Fail, if the device name contains backslashes */
    if (wcschr(pszDeviceID, L'\\') != NULL)
        return CR_INVALID_DEVICE_ID;
 
    /* Generated ID is: Root<Device ID><Instance number> */
    dwInstanceNumber = 0;
    while (dwError == ERROR_SUCCESS)
    {
        if (dwInstanceNumber >= 10000)
            return CR_FAILURE;
 
        swprintf(szGeneratedInstance, L"Root\\%ls\\%04lu",
                 pszDeviceID, dwInstanceNumber);
 
        /* Try to open the enum key of the device instance */
        dwError = RegOpenKeyEx(hEnumKey, szGeneratedInstance, 0, KEY_QUERY_VALUE, &hKey);
        if (dwError == ERROR_SUCCESS)
        {
            RegCloseKey(hKey);
            dwInstanceNumber++;
        }
    }
 
    /* pszDeviceID is an out parameter too for generated IDs */
    if (wcslen(szGeneratedInstance) > ulLength)
    {
        ret = CR_BUFFER_SMALL;
    }
    else
    {
        wcscpy(pszDeviceID, szGeneratedInstance);
    }
 
    return ret;
}

Referenced by PNP_CreateDevInst().

GetAllInstanceList()

static CONFIGRET GetAllInstanceList ( _Inout_ PWSTR  pszBuffer, _Inout_ PDWORD  pulLength  )

static

Definition at line 1365 of file rpcserver.c.

{
    WCHAR szEnumeratorBuffer[MAX_DEVICE_ID_LEN];
    PWSTR pPtr;
    DWORD dwIndex, dwEnumeratorLength, dwUsedLength, dwRemainingLength, dwPathLength;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    dwUsedLength = 0;
    dwRemainingLength = *pulLength;
    pPtr = pszBuffer;
 
    for (dwIndex = 0; ; dwIndex++)
    {
        dwEnumeratorLength = MAX_DEVICE_ID_LEN;
        dwError = RegEnumKeyExW(hEnumKey,
                                dwIndex,
                                szEnumeratorBuffer,
                                &dwEnumeratorLength,
                                NULL, NULL, NULL, NULL);
        if (dwError != ERROR_SUCCESS)
            break;
 
        dwPathLength = dwRemainingLength;
        ret = GetEnumeratorInstanceList(szEnumeratorBuffer,
                                        pPtr,
                                        &dwPathLength);
        if (ret != CR_SUCCESS)
            break;
 
        dwUsedLength += dwPathLength - 1;
        dwRemainingLength -= dwPathLength - 1;
        pPtr += dwPathLength - 1;
    }
 
    if (ret == CR_SUCCESS)
        *pulLength = dwUsedLength + 1;
    else
        *pulLength = 0;
 
    return ret;
}

Referenced by PNP_GetDeviceList().

GetAllInstanceListSize()

static CONFIGRET GetAllInstanceListSize ( _Out_ PULONG  pulLength )

static

Definition at line 1750 of file rpcserver.c.

{
    WCHAR szEnumeratorBuffer[MAX_DEVICE_ID_LEN];
    DWORD dwIndex, dwEnumeratorLength, dwBufferLength;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    for (dwIndex = 0; ; dwIndex++)
    {
        dwEnumeratorLength = MAX_DEVICE_ID_LEN;
        dwError = RegEnumKeyExW(hEnumKey,
                                dwIndex,
                                szEnumeratorBuffer,
                                &dwEnumeratorLength,
                                NULL, NULL, NULL, NULL);
        if (dwError != ERROR_SUCCESS)
            break;
 
        /* Get the size of all device instances for the enumerator */
        ret = GetEnumeratorInstanceListSize(szEnumeratorBuffer,
                                            &dwBufferLength);
        if (ret != CR_SUCCESS)
            break;
 
        *pulLength += dwBufferLength;
    }
 
    return ret;
}

Referenced by PNP_GetDeviceListSize().

GetConfigurationData()

static CONFIGRET GetConfigurationData ( _In_ HKEY  hKey, _In_ ULONG  ulLogConfType, _Out_ PULONG  pulRegDataType, _Out_ PULONG  pulDataSize, _Out_ LPBYTE *  ppBuffer, _In_ ULONG  ulValueNameBufferSize, _Out_opt_ LPWSTR  pszValueNameBuffer  )

static

Definition at line 495 of file rpcserver.c.

{
    LPCWSTR pszValueName;
 
    switch (ulLogConfType)
    {
        case BOOT_LOG_CONF:
            pszValueName = L"BootConfig";
            *pulRegDataType = REG_RESOURCE_LIST;
            break;
 
        case ALLOC_LOG_CONF:
            pszValueName = L"AllocConfig";
            *pulRegDataType = REG_RESOURCE_LIST;
            break;
 
        case FORCED_LOG_CONF:
            pszValueName = L"ForcedConfig";
            *pulRegDataType = REG_RESOURCE_LIST;
            break;
 
        case FILTERED_LOG_CONF:
            pszValueName = L"FilteredConfigVector";
            *pulRegDataType = REG_RESOURCE_REQUIREMENTS_LIST;
            break;
 
        case BASIC_LOG_CONF:
            pszValueName = L"BasicConfigVector";
            *pulRegDataType = REG_RESOURCE_REQUIREMENTS_LIST;
            break;
 
        case OVERRIDE_LOG_CONF:
            pszValueName = L"OverrideConfigVector";
            *pulRegDataType = REG_RESOURCE_REQUIREMENTS_LIST;
            break;
 
        default:
            DPRINT1("Unsupported configuration type!\n");
            return CR_FAILURE;
    }
 
    /* Return the selected configuration value name */
    if ((ulValueNameBufferSize > 0) && (pszValueNameBuffer != NULL) &&
        (wcslen(pszValueName) + 1 <= ulValueNameBufferSize))
        wcscpy(pszValueNameBuffer, pszValueName);
 
    /* Get the configuration data size */
    if (RegQueryValueExW(hKey,
                         pszValueName,
                         NULL,
                         NULL,
                         NULL,
                         pulDataSize) != ERROR_SUCCESS)
    {
        return CR_INVALID_LOG_CONF;
    }
 
    /* Allocate the buffer */
    *ppBuffer = HeapAlloc(GetProcessHeap(), 0, *pulDataSize);
    if (*ppBuffer == NULL)
    {
        return CR_OUT_OF_MEMORY;
    }
 
    /* Retrieve the configuration data */
    if (RegQueryValueExW(hKey,
                         pszValueName,
                         NULL,
                         NULL,
                         (LPBYTE)*ppBuffer,
                         pulDataSize) != ERROR_SUCCESS)
    {
        return CR_INVALID_LOG_CONF;
    }
 
    return CR_SUCCESS;
}

Referenced by PNP_AddEmptyLogConf(), PNP_FreeLogConf(), PNP_GetFirstLogConf(), PNP_GetNextLogConf(), and PNP_GetNextResDes().

GetDeviceInstanceList()

static CONFIGRET GetDeviceInstanceList ( _In_ PWSTR  pszDevice, _Inout_ PWSTR  pszBuffer, _Inout_ PDWORD  pulLength  )

static

Definition at line 1223 of file rpcserver.c.

{
    WCHAR szInstanceBuffer[MAX_DEVICE_ID_LEN];
    WCHAR szPathBuffer[512];
    HKEY hDeviceKey;
    DWORD dwInstanceLength, dwPathLength, dwUsedLength;
    DWORD dwIndex, dwError;
    PWSTR pPtr;
    CONFIGRET ret = CR_SUCCESS;
 
    /* Open the device key */
    dwError = RegOpenKeyExW(hEnumKey,
                            pszDevice,
                            0,
                            KEY_ENUMERATE_SUB_KEYS,
                            &hDeviceKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the device key (Error %lu)\n", dwError);
        return CR_REGISTRY_ERROR;
    }
 
    dwUsedLength = 0;
    pPtr = pszBuffer;
 
    for (dwIndex = 0; ; dwIndex++)
    {
        dwInstanceLength = MAX_DEVICE_ID_LEN;
        dwError = RegEnumKeyExW(hDeviceKey,
                                dwIndex,
                                szInstanceBuffer,
                                &dwInstanceLength,
                                NULL,
                                NULL,
                                NULL,
                                NULL);
        if (dwError != ERROR_SUCCESS)
            break;
 
        wsprintf(szPathBuffer, L"%s\\%s", pszDevice, szInstanceBuffer);
        DPRINT("Path: %S\n", szPathBuffer);
 
        dwPathLength = wcslen(szPathBuffer) + 1;
        if (dwUsedLength + dwPathLength + 1 > *pulLength)
        {
            ret = CR_BUFFER_SMALL;
            break;
        }
 
        wcscpy(pPtr, szPathBuffer);
        dwUsedLength += dwPathLength;
        pPtr += dwPathLength;
 
        *pPtr = UNICODE_NULL;
    }
 
    RegCloseKey(hDeviceKey);
 
    if (ret == CR_SUCCESS)
        *pulLength = dwUsedLength + 1;
    else
        *pulLength = 0;
 
    return ret;
}

Referenced by GetEnumeratorInstanceList(), and PNP_GetDeviceList().

GetDeviceInstanceListSize()

static CONFIGRET GetDeviceInstanceListSize ( _In_ LPCWSTR  pszDevice, _Out_ PULONG  pulLength  )

static

Definition at line 1637 of file rpcserver.c.

{
    HKEY hDeviceKey;
    DWORD dwSubKeys, dwMaxSubKeyLength;
    DWORD dwError;
 
    /* Open the device key */
    dwError = RegOpenKeyExW(hEnumKey,
                            pszDevice,
                            0,
                            KEY_READ,
                            &hDeviceKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the device key (Error %lu)\n", dwError);
        return CR_REGISTRY_ERROR;
    }
 
    /* Retrieve the number of device instances and the maximum name length */
    dwError = RegQueryInfoKeyW(hDeviceKey,
                               NULL,
                               NULL,
                               NULL,
                               &dwSubKeys,
                               &dwMaxSubKeyLength,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("RegQueryInfoKeyW failed (Error %lu)\n", dwError);
        dwSubKeys = 0;
        dwMaxSubKeyLength = 0;
    }
 
    /* Close the device key */
    RegCloseKey(hDeviceKey);
 
    /* Return the largest possible buffer size */
    *pulLength = dwSubKeys * (wcslen(pszDevice) + 1 + dwMaxSubKeyLength + 1);
 
    return CR_SUCCESS;
}

Referenced by GetEnumeratorInstanceListSize(), and PNP_GetDeviceListSize().

GetDeviceStatus()

static CONFIGRET GetDeviceStatus ( _In_ LPWSTR  pszDeviceID, _Out_ DWORD *  pulStatus, _Out_ DWORD *  pulProblem  )

static

Definition at line 232 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT("GetDeviceStatus(%S %p %p)\n",
           pszDeviceID, pulStatus, pulProblem);
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
    PlugPlayData.Operation = PNP_GET_DEVICE_STATUS;
 
    Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulStatus = PlugPlayData.DeviceStatus;
        *pulProblem = PlugPlayData.DeviceProblem;
    }
    else
    {
        ret = NtStatusToCrError(Status);
    }
 
    return ret;
}

Referenced by DECLARE_INTERFACE_(), IsPresentDeviceInstanceID(), PNP_GetDeviceStatus(), PNP_SetDeviceProblem(), and SetupDeviceInstance().

GetEnumeratorInstanceList()

CONFIGRET GetEnumeratorInstanceList	(	_In_ PWSTR	pszEnumerator,
		_Inout_ PWSTR	pszBuffer,
		_Inout_ PDWORD	pulLength
	)

Definition at line 1294 of file rpcserver.c.

{
    WCHAR szDeviceBuffer[MAX_DEVICE_ID_LEN];
    WCHAR szPathBuffer[512];
    HKEY hEnumeratorKey;
    PWSTR pPtr;
    DWORD dwIndex, dwDeviceLength, dwUsedLength, dwRemainingLength, dwPathLength;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    /* Open the enumerator key */
    dwError = RegOpenKeyExW(hEnumKey,
                            pszEnumerator,
                            0,
                            KEY_ENUMERATE_SUB_KEYS,
                            &hEnumeratorKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the enumerator key (Error %lu)\n", dwError);
        return CR_REGISTRY_ERROR;
    }
 
    dwUsedLength = 0;
    dwRemainingLength = *pulLength;
    pPtr = pszBuffer;
 
    for (dwIndex = 0; ; dwIndex++)
    {
        dwDeviceLength = MAX_DEVICE_ID_LEN;
        dwError = RegEnumKeyExW(hEnumeratorKey,
                                dwIndex,
                                szDeviceBuffer,
                                &dwDeviceLength,
                                NULL,
                                NULL,
                                NULL,
                                NULL);
        if (dwError != ERROR_SUCCESS)
            break;
 
        wsprintf(szPathBuffer, L"%s\\%s", pszEnumerator, szDeviceBuffer);
        DPRINT("Path: %S\n", szPathBuffer);
 
        dwPathLength = dwRemainingLength;
        ret = GetDeviceInstanceList(szPathBuffer,
                                    pPtr,
                                    &dwPathLength);
        if (ret != CR_SUCCESS)
            break;
 
        dwUsedLength += dwPathLength - 1;
        dwRemainingLength -= dwPathLength - 1;
        pPtr += dwPathLength - 1;
    }
 
    RegCloseKey(hEnumeratorKey);
 
    if (ret == CR_SUCCESS)
        *pulLength = dwUsedLength + 1;
    else
        *pulLength = 0;
 
    return ret;
}

Referenced by GetAllInstanceList(), and PNP_GetDeviceList().

GetEnumeratorInstanceListSize()

static CONFIGRET GetEnumeratorInstanceListSize ( _In_ LPCWSTR  pszEnumerator, _Out_ PULONG  pulLength  )

static

Definition at line 1689 of file rpcserver.c.

{
    WCHAR szDeviceBuffer[MAX_DEVICE_ID_LEN];
    WCHAR szPathBuffer[512];
    HKEY hEnumeratorKey;
    DWORD dwIndex, dwDeviceLength, dwBufferLength;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    *pulLength = 0;
 
    /* Open the enumerator key */
    dwError = RegOpenKeyExW(hEnumKey,
                            pszEnumerator,
                            0,
                            KEY_ENUMERATE_SUB_KEYS,
                            &hEnumeratorKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the enumerator key (Error %lu)\n", dwError);
        return CR_REGISTRY_ERROR;
    }
 
    for (dwIndex = 0; ; dwIndex++)
    {
        dwDeviceLength = MAX_DEVICE_ID_LEN;
        dwError = RegEnumKeyExW(hEnumeratorKey,
                                dwIndex,
                                szDeviceBuffer,
                                &dwDeviceLength,
                                NULL,
                                NULL,
                                NULL,
                                NULL);
        if (dwError != ERROR_SUCCESS)
            break;
 
        wsprintf(szPathBuffer, L"%s\\%s", pszEnumerator, szDeviceBuffer);
        DPRINT("Path: %S\n", szPathBuffer);
 
        ret = GetDeviceInstanceListSize(szPathBuffer, &dwBufferLength);
        if (ret != CR_SUCCESS)
        {
            *pulLength = 0;
            break;
        }
 
        *pulLength += dwBufferLength;
    }
 
    /* Close the enumerator key */
    RegCloseKey(hEnumeratorKey);
 
    return ret;
}

Referenced by GetAllInstanceListSize(), and PNP_GetDeviceListSize().

GetRelationsInstanceList()

static CONFIGRET GetRelationsInstanceList ( _In_ PWSTR  pszDevice, _In_ DWORD  ulFlags, _Inout_ PWSTR  pszBuffer, _Inout_ PDWORD  pulLength  )

static

Definition at line 1053 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA PlugPlayData;
    NTSTATUS Status;
    CONFIGRET ret = CR_SUCCESS;
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDevice);
 
    if (ulFlags & CM_GETIDLIST_FILTER_BUSRELATIONS)
    {
        PlugPlayData.Relations = 3;
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_POWERRELATIONS)
    {
        PlugPlayData.Relations = 2;
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_REMOVALRELATIONS)
    {
        PlugPlayData.Relations = 1;
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_EJECTRELATIONS)
    {
        PlugPlayData.Relations = 0;
    }
 
    PlugPlayData.BufferSize = *pulLength * sizeof(WCHAR);
    PlugPlayData.Buffer = pszBuffer;
 
    Status = NtPlugPlayControl(PlugPlayControlQueryDeviceRelations,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulLength = PlugPlayData.BufferSize / sizeof(WCHAR);
    }
    else
    {
        ret = NtStatusToCrError(Status);
    }
 
    return ret;
}

Referenced by PNP_GetDeviceList().

GetRelationsInstanceListSize()

static CONFIGRET GetRelationsInstanceListSize ( _In_ PWSTR  pszDevice, _In_ DWORD  ulFlags, _Inout_ PDWORD  pulLength  )

static

Definition at line 1488 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA PlugPlayData;
    NTSTATUS Status;
    CONFIGRET ret = CR_SUCCESS;
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDevice);
 
    if (ulFlags & CM_GETIDLIST_FILTER_BUSRELATIONS)
    {
        PlugPlayData.Relations = 3;
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_POWERRELATIONS)
    {
        PlugPlayData.Relations = 2;
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_REMOVALRELATIONS)
    {
        PlugPlayData.Relations = 1;
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_EJECTRELATIONS)
    {
        PlugPlayData.Relations = 0;
    }
 
    PlugPlayData.BufferSize = 0;
    PlugPlayData.Buffer = NULL;
 
    Status = NtPlugPlayControl(PlugPlayControlQueryDeviceRelations,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulLength = PlugPlayData.BufferSize / sizeof(WCHAR);
    }
    else
    {
        ret = NtStatusToCrError(Status);
    }
 
    return ret;
}

Referenced by PNP_GetDeviceListSize().

GetServiceInstanceList()

static CONFIGRET GetServiceInstanceList ( _In_ PWSTR  pszService, _Inout_ PWSTR  pszBuffer, _Inout_ PDWORD  pulLength  )

static

Definition at line 1104 of file rpcserver.c.

{
    WCHAR szPathBuffer[512];
    WCHAR szName[16];
    HKEY hServicesKey = NULL, hServiceKey = NULL, hEnumKey = NULL;
    DWORD dwValues, dwSize, dwIndex, dwUsedLength, dwPathLength;
    DWORD dwError;
    PWSTR pPtr;
    CONFIGRET ret = CR_SUCCESS;
 
    /* Open the device key */
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"System\\CurrentControlSet\\Services",
                            0,
                            KEY_READ,
                            &hServicesKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the services key (Error %lu)\n", dwError);
        return CR_REGISTRY_ERROR;
    }
 
    dwError = RegOpenKeyExW(hServicesKey,
                            pszService,
                            0,
                            KEY_READ,
                            &hServiceKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the service key (Error %lu)\n", dwError);
        ret = CR_REGISTRY_ERROR;
        goto Done;
    }
 
    dwError = RegOpenKeyExW(hServiceKey,
                            L"Enum",
                            0,
                            KEY_READ,
                            &hEnumKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the service enum key (Error %lu)\n", dwError);
        ret = CR_REGISTRY_ERROR;
        goto Done;
    }
 
    /* Retrieve the number of device instances */
    dwSize = sizeof(DWORD);
    dwError = RegQueryValueExW(hEnumKey,
                               L"Count",
                               NULL,
                               NULL,
                               (LPBYTE)&dwValues,
                               &dwSize);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("RegQueryValueExW failed (Error %lu)\n", dwError);
        dwValues = 1;
    }
 
    DPRINT("dwValues %lu\n", dwValues);
 
    dwUsedLength = 0;
    pPtr = pszBuffer;
 
    for (dwIndex = 0; dwIndex < dwValues; dwIndex++)
    {
        wsprintf(szName, L"%lu", dwIndex);
 
        dwSize = sizeof(szPathBuffer);
        dwError = RegQueryValueExW(hEnumKey,
                                   szName,
                                   NULL,
                                   NULL,
                                   (LPBYTE)szPathBuffer,
                                   &dwSize);
        if (dwError != ERROR_SUCCESS)
            break;
 
        DPRINT("Path: %S\n", szPathBuffer);
 
        dwPathLength = wcslen(szPathBuffer) + 1;
        if (dwUsedLength + dwPathLength + 1 > *pulLength)
        {
            ret = CR_BUFFER_SMALL;
            break;
        }
 
        wcscpy(pPtr, szPathBuffer);
        dwUsedLength += dwPathLength;
        pPtr += dwPathLength;
 
        *pPtr = UNICODE_NULL;
    }
 
Done:
    if (hEnumKey != NULL)
        RegCloseKey(hEnumKey);
 
    if (hServiceKey != NULL)
        RegCloseKey(hServiceKey);
 
    if (hServicesKey != NULL)
        RegCloseKey(hServicesKey);
 
    if (ret == CR_SUCCESS)
        *pulLength = dwUsedLength + 1;
    else
        *pulLength = 0;
 
    return ret;
}

Referenced by PNP_GetDeviceList().

GetServiceInstanceListSize()

static CONFIGRET GetServiceInstanceListSize ( _In_ PWSTR  pszService, _Out_ PDWORD  pulLength  )

static

Definition at line 1538 of file rpcserver.c.

{
    HKEY hServicesKey = NULL, hServiceKey = NULL, hEnumKey = NULL;
    DWORD dwValues, dwMaxValueLength, dwSize;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    /* Open the device key */
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"System\\CurrentControlSet\\Services",
                            0,
                            KEY_READ,
                            &hServicesKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the services key (Error %lu)\n", dwError);
        return CR_REGISTRY_ERROR;
    }
 
    dwError = RegOpenKeyExW(hServicesKey,
                            pszService,
                            0,
                            KEY_READ,
                            &hServiceKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the service key (Error %lu)\n", dwError);
        ret = CR_REGISTRY_ERROR;
        goto Done;
    }
 
    dwError = RegOpenKeyExW(hServiceKey,
                            L"Enum",
                            0,
                            KEY_READ,
                            &hEnumKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the service enum key (Error %lu)\n", dwError);
        ret = CR_REGISTRY_ERROR;
        goto Done;
    }
 
    /* Retrieve the number of device instances */
    dwSize = sizeof(DWORD);
    dwError = RegQueryValueExW(hEnumKey,
                               L"Count",
                               NULL,
                               NULL,
                               (LPBYTE)&dwValues,
                               &dwSize);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("RegQueryValueExW failed (Error %lu)\n", dwError);
        dwValues = 1;
    }
 
    /* Retrieve the maximum instance name length */
    dwError = RegQueryInfoKeyW(hEnumKey,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               &dwMaxValueLength,
                               NULL,
                               NULL);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("RegQueryInfoKeyW failed (Error %lu)\n", dwError);
        dwMaxValueLength = MAX_DEVICE_ID_LEN;
    }
 
    DPRINT("dwValues %lu  dwMaxValueLength %lu\n", dwValues, dwMaxValueLength / sizeof(WCHAR));
 
    /* Return the largest possible buffer size */
    *pulLength = dwValues * dwMaxValueLength / sizeof(WCHAR) + 2;
 
Done:
    if (hEnumKey != NULL)
        RegCloseKey(hEnumKey);
 
    if (hServiceKey != NULL)
        RegCloseKey(hServiceKey);
 
    if (hServicesKey != NULL)
        RegCloseKey(hServicesKey);
 
    return ret;
}

Referenced by PNP_GetDeviceListSize().

IsCallerInteractive()

static BOOL IsCallerInteractive ( _In_ handle_t  hBinding )

static

Definition at line 638 of file rpcserver.c.

{
    SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
    HANDLE hToken;
    PSID pInteractiveSid = NULL;
    BOOL bInteractive = FALSE;
    RPC_STATUS RpcStatus;
 
    DPRINT("IsCallerInteractive(%p)\n", hBinding);
 
    /* Allocate an interactive user sid */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_INTERACTIVE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &pInteractiveSid))
    {
        DPRINT1("AllocateAndInitializeSid failed\n");
        return FALSE;
    }
 
    /* Impersonate the client */
    RpcStatus = RpcImpersonateClient(hBinding);
    if (RpcStatus != RPC_S_OK)
    {
        DPRINT1("RpcImpersonateClient failed (Status 0x%08lx)\n", RpcStatus);
        goto done;
    }
 
    /* Open the thread token and check for interactive user membership */
    if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &hToken))
    {
        CheckTokenMembership(hToken, pInteractiveSid, &bInteractive);
        CloseHandle(hToken);
    }
 
    /* Revert the impersonation */
    RpcRevertToSelf();
 
done:
    if (pInteractiveSid)
        FreeSid(pInteractiveSid);
 
    return bInteractive;
}

Referenced by PNP_ReportLogOn().

IsPresentDeviceInstanceID()

static BOOL IsPresentDeviceInstanceID ( _In_ LPWSTR  pszDeviceInstanceID )

static

Definition at line 421 of file rpcserver.c.

{
    DWORD ulStatus, ulProblem;
 
    return (GetDeviceStatus(pszDeviceInstanceID, &ulStatus, &ulProblem) == CR_SUCCESS);
}

Referenced by PNP_CreateDevInst(), and PNP_GetRelatedDeviceInstance().

IsRootDeviceInstanceID()

static BOOL IsRootDeviceInstanceID ( _In_ PWSTR  pszDeviceInstanceID )

static

Definition at line 409 of file rpcserver.c.

{
    if (_wcsicmp(pszDeviceInstanceID, szRootDeviceInstanceID) == 0)
        return TRUE;
 
    return FALSE;
}

Referenced by PNP_AddEmptyLogConf(), PNP_CreateDevInst(), PNP_DisableDevInst(), PNP_GetRelatedDeviceInstance(), PNP_QueryRemove(), and SetupDeviceInstance().

IsValidDeviceInstanceID()

static BOOL IsValidDeviceInstanceID ( _In_ PWSTR  pszDeviceInstanceID )

static

Definition at line 343 of file rpcserver.c.

{
    INT nPartLength[3] = {0, 0, 0};
    INT nLength = 0, nParts = 0;
    PWCHAR p;
 
    DPRINT("IsValidDeviceInstanceID(%S)\n",
           pszDeviceInstanceID);
 
    if (pszDeviceInstanceID == NULL)
    {
        DPRINT("Device instance ID is NULL!\n");
        return FALSE;
    }
 
    p = pszDeviceInstanceID;
    while (*p != UNICODE_NULL)
    {
        if (*p == L'\\')
        {
            nParts++;
            if (nParts >= 3)
            {
                DPRINT("Too many separators: %d\n", nParts);
                return FALSE;
            }
        }
        else
        {
            nPartLength[nParts]++;
        }
 
        nLength++;
        if (nLength >= MAX_DEVICE_ID_LEN)
        {
            DPRINT("Too long: %d\n", nLength);
            return FALSE;
        }
 
        p++;
    }
 
    if (nParts != 2)
    {
        DPRINT("Invalid number of separtors: %d\n", nParts);
        return FALSE;
    }
 
    if ((nPartLength[0] == 0) ||
        (nPartLength[1] == 0) ||
        (nPartLength[2] == 0))
    {
        DPRINT("Invalid part lengths: %d %d %d\n",
               nPartLength[0], nPartLength[1], nPartLength[2]);
        return FALSE;
    }
 
    DPRINT("Valid device instance ID!\n");
 
    return TRUE;
}

Referenced by PNP_AddEmptyLogConf(), PNP_CreateKey(), PNP_DisableDevInst(), PNP_FreeLogConf(), PNP_GetClassInstance(), PNP_GetCustomDevProp(), PNP_GetDepth(), PNP_GetDeviceRegProp(), PNP_GetDeviceStatus(), PNP_GetFirstLogConf(), PNP_GetInterfaceDeviceList(), PNP_GetInterfaceDeviceListSize(), PNP_GetNextLogConf(), PNP_GetNextResDes(), PNP_GetRelatedDeviceInstance(), PNP_HwProfFlags(), PNP_QueryRemove(), PNP_RegisterDeviceClassAssociation(), PNP_RegisterDriver(), PNP_RequestDeviceEject(), PNP_SetDeviceProblem(), PNP_SetDeviceRegProp(), and PNP_ValidateDeviceInstance().

midl_user_allocate()

void __RPC_FAR *__RPC_USER midl_user_allocate

(

SIZE_T

len

)

Definition at line 114 of file rpcserver.c.

{
    return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
}

midl_user_free()

void __RPC_USER midl_user_free

(

void __RPC_FAR *

ptr

)

Definition at line 120 of file rpcserver.c.

{
    HeapFree(GetProcessHeap(), 0, ptr);
}

NextResourceDescriptor()

static PCM_FULL_RESOURCE_DESCRIPTOR NextResourceDescriptor ( _In_ PCM_FULL_RESOURCE_DESCRIPTOR  pDescriptor )

static

Definition at line 583 of file rpcserver.c.

{
    PBYTE pNext = NULL;
    ULONG ulLastIndex = 0;
 
    if (pDescriptor == NULL)
        return NULL;
 
    /* Skip the full resource descriptor */
    pNext = (LPBYTE)pDescriptor + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
 
    /* Skip the partial resource descriptors */
    pNext += (pDescriptor->PartialResourceList.Count - 1) *
         sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
 
    /* Skip the device specific data, if present */
    if (pDescriptor->PartialResourceList.Count > 0)
    {
        ulLastIndex = pDescriptor->PartialResourceList.Count - 1;
 
        if (pDescriptor->PartialResourceList.PartialDescriptors[ulLastIndex].Type ==
            CmResourceTypeDeviceSpecific)
        {
            pNext += pDescriptor->PartialResourceList.PartialDescriptors[ulLastIndex].
                     u.DeviceSpecificData.DataSize;
        }
    }
 
    return (PCM_FULL_RESOURCE_DESCRIPTOR)pNext;
}

Referenced by PNP_AddEmptyLogConf(), and PNP_FreeLogConf().

NextResourceRequirement()

static PIO_RESOURCE_LIST NextResourceRequirement ( _In_ PIO_RESOURCE_LIST  pResourceList )

static

Definition at line 618 of file rpcserver.c.

{
    LPBYTE pNext = NULL;
 
    if (pResourceList == NULL)
        return NULL;
 
    /* Skip the resource list */
    pNext = (LPBYTE)pResourceList + sizeof(IO_RESOURCE_LIST);
 
    /* Skip the resource descriptors */
    pNext += (pResourceList->Count - 1) * sizeof(IO_RESOURCE_DESCRIPTOR);
 
    return (PIO_RESOURCE_LIST)pNext;
}

Referenced by PNP_AddEmptyLogConf().

NtStatusToCrError()

static CONFIGRET WINAPI NtStatusToCrError ( NTSTATUS  Status )

static

Definition at line 127 of file rpcserver.c.

{
    switch (Status)
    {
        case STATUS_NOT_IMPLEMENTED:
            return CR_CALL_NOT_IMPLEMENTED;
 
        case STATUS_INVALID_PARAMETER:
            return CR_INVALID_DATA;
 
        case STATUS_NO_SUCH_DEVICE:
            return CR_NO_SUCH_DEVINST;
 
        case STATUS_ACCESS_DENIED:
            return CR_ACCESS_DENIED;
 
        case STATUS_BUFFER_TOO_SMALL:
            return CR_BUFFER_SMALL;
 
        case STATUS_OBJECT_NAME_NOT_FOUND:
            return CR_NO_SUCH_VALUE;
 
        default:
            return CR_FAILURE;
    }
}

Referenced by ClearDeviceStatus(), DisableDeviceInstance(), EnableDeviceInstance(), GetDeviceStatus(), GetRelationsInstanceList(), GetRelationsInstanceListSize(), PNP_GetDepth(), PNP_GetDeviceRegProp(), PNP_GetInterfaceDeviceAlias(), PNP_GetInterfaceDeviceList(), PNP_GetInterfaceDeviceListSize(), PNP_GetRelatedDeviceInstance(), PNP_QueryRemove(), PNP_RegisterDeviceClassAssociation(), PNP_RequestDeviceEject(), PNP_RequestEjectPC(), PNP_UnregisterDeviceClassAssociation(), ReenumerateDeviceInstance(), SetDeviceStatus(), and SetupDeviceInstance().

OpenConfigurationKey()

static CONFIGRET OpenConfigurationKey ( _In_ LPCWSTR  pszDeviceID, _In_ DWORD  ulLogConfType, _Out_ PHKEY  phKey  )

static

Definition at line 432 of file rpcserver.c.

{
    WCHAR szKeyName[MAX_PATH];
    PCWSTR pszSubKeyName;
    HKEY hInstanceKey;
    DWORD dwError;
 
    /* Build the full device instance key name */
    wcscpy(szKeyName, L"System\\CurrentControlSet\\Enum\\");
    wcscat(szKeyName, pszDeviceID);
 
    /* Open the device instance key */
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            szKeyName,
                            0,
                            KEY_QUERY_VALUE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY,
                            &hInstanceKey);
    if (dwError != ERROR_SUCCESS)
        return CR_INVALID_DEVINST;
 
    switch (ulLogConfType)
    {
        case BOOT_LOG_CONF:
        case BASIC_LOG_CONF:
            pszSubKeyName = L"LogConf";
            break;
 
        case ALLOC_LOG_CONF:
        case FILTERED_LOG_CONF:
            pszSubKeyName = L"Control";
            break;
 
        default:
            DPRINT1("Unsupported configuration type!\n");
            return CR_FAILURE;
    }
 
    /* Create or open the LogConf key */
    dwError = RegCreateKeyExW(hInstanceKey,
                              pszSubKeyName,
                              0,
                              NULL,
                              REG_OPTION_NON_VOLATILE,
                              KEY_ALL_ACCESS,
                              NULL,
                              phKey,
                              NULL);
 
    /* Close the device instance key */
    RegCloseKey(hInstanceKey);
 
    if (dwError != ERROR_SUCCESS)
        return CR_REGISTRY_ERROR;
 
    return CR_SUCCESS;
}

Referenced by PNP_AddEmptyLogConf(), PNP_FreeLogConf(), PNP_GetFirstLogConf(), PNP_GetNextLogConf(), and PNP_GetNextResDes().

PNP_AddEmptyLogConf()

DWORD WINAPI PNP_AddEmptyLogConf	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulPriority,
		DWORD *	pulLogConfTag,
		DWORD	ulFlags
	)

Definition at line 4333 of file rpcserver.c.

{
    HKEY hConfigKey = NULL;
    DWORD RegDataType = 0;
    ULONG ulDataSize = 0, ulNewSize = 0;
    PBYTE pDataBuffer = NULL;
    WCHAR szValueNameBuffer[LOGCONF_NAME_BUFFER_SIZE];
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_AddEmptyLogConf(%p %S %lu %p 0x%08lx)\n",
           hBinding, pDeviceID, ulPriority, pulLogConfTag, ulFlags);
 
    if (pulLogConfTag == NULL)
        return CR_INVALID_POINTER;
 
    *pulLogConfTag = 0;
 
    if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID) || IsRootDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVNODE;
 
    ret = OpenConfigurationKey(pDeviceID,
                               ulFlags & LOG_CONF_BITS,
                               &hConfigKey);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    ret = GetConfigurationData(hConfigKey,
                               ulFlags & LOG_CONF_BITS,
                               &RegDataType,
                               &ulDataSize,
                               &pDataBuffer,
                               LOGCONF_NAME_BUFFER_SIZE,
                               szValueNameBuffer);
 
    if (ret != CR_SUCCESS || ulDataSize == 0)
    {
        ret = CR_SUCCESS;
 
        if (RegDataType == REG_RESOURCE_LIST)
        {
            PCM_RESOURCE_LIST pResourceList = NULL;
            PCM_FULL_RESOURCE_DESCRIPTOR pResource = NULL;
 
            /* Allocate a buffer for the new configuration */
            ulDataSize = sizeof(CM_RESOURCE_LIST) - sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
            pDataBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulDataSize);
            if (pDataBuffer == NULL)
            {
                ret = CR_OUT_OF_MEMORY;
                goto done;
            }
 
            pResourceList = (PCM_RESOURCE_LIST)pDataBuffer;
            pResourceList->Count = 1;
 
            pResource = (PCM_FULL_RESOURCE_DESCRIPTOR)&pResourceList->List[0];
            pResource->InterfaceType = InterfaceTypeUndefined;
            pResource->BusNumber = 0;
            pResource->PartialResourceList.Version = 1;
            pResource->PartialResourceList.Revision = 1;
            pResource->PartialResourceList.Count = 0;
        }
        else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
        {
            PIO_RESOURCE_REQUIREMENTS_LIST pRequirementsList = NULL;
            PIO_RESOURCE_LIST pResourceList = NULL;
 
            ulDataSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST);
            pDataBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulDataSize);
            if (pDataBuffer == NULL)
            {
                ret = CR_OUT_OF_MEMORY;
                goto done;
            }
 
            pRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)pDataBuffer;
            pRequirementsList->ListSize = ulDataSize;
            pRequirementsList->InterfaceType = InterfaceTypeUndefined;
            pRequirementsList->BusNumber = 0;
            pRequirementsList->SlotNumber = 0;
            pRequirementsList->AlternativeLists = 1;
 
            pResourceList = (PIO_RESOURCE_LIST)&pRequirementsList->List[0];
            pResourceList->Version = 1;
            pResourceList->Revision = 1;
            pResourceList->Count = 1;
 
            pResourceList->Descriptors[0].Option = IO_RESOURCE_PREFERRED;
            pResourceList->Descriptors[0].Type = CmResourceTypeConfigData;
            pResourceList->Descriptors[0].u.ConfigData.Priority = ulPriority;
        }
        else
        {
            ret = CR_FAILURE;
            goto done;
        }
    }
    else
    {
        if (RegDataType == REG_RESOURCE_LIST)
        {
            PCM_RESOURCE_LIST pResourceList = NULL;
            PCM_FULL_RESOURCE_DESCRIPTOR pResource = NULL;
            ULONG ulIndex;
 
            /* Reallocate a larger buffer in order to add the new configuration */
            ulNewSize = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) - sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
            pDataBuffer = HeapReAlloc(GetProcessHeap(),
                                      0,
                                      pDataBuffer,
                                      ulDataSize + ulNewSize);
            if (pDataBuffer == NULL)
            {
                ret = CR_OUT_OF_MEMORY;
                goto done;
            }
 
            pResourceList = (PCM_RESOURCE_LIST)pDataBuffer;
 
            /* Get a pointer to the new (uninitialized) resource descriptor */
            pResource = (PCM_FULL_RESOURCE_DESCRIPTOR)&pResourceList->List[0];
            for (ulIndex = 0; ulIndex < pResourceList->Count; ulIndex++)
                pResource = NextResourceDescriptor(pResource);
 
            /* Initialize the new resource descriptor */
            pResourceList->Count++;
            pResource->InterfaceType= InterfaceTypeUndefined;
            pResource->BusNumber = 0;
            pResource->PartialResourceList.Version = 1;
            pResource->PartialResourceList.Revision = 1;
            pResource->PartialResourceList.Count = 0;
 
            *pulLogConfTag = ulIndex;
        }
        else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
        {
            PIO_RESOURCE_REQUIREMENTS_LIST pRequirementsList = NULL;
            PIO_RESOURCE_LIST pResourceList = NULL;
            ULONG ulIndex;
 
            /* Reallocate a larger buffer in order to add the new configuration */
            ulNewSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST);
            pDataBuffer = HeapReAlloc(GetProcessHeap(),
                                      0,
                                      pDataBuffer,
                                      ulDataSize + ulNewSize);
            if (pDataBuffer == NULL)
            {
                ret = CR_OUT_OF_MEMORY;
                goto done;
            }
 
            pRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)pDataBuffer;
            pResourceList = (PIO_RESOURCE_LIST)&pRequirementsList->List[0];
            for (ulIndex = 0; ulIndex < pRequirementsList->AlternativeLists - 1; ulIndex++)
                pResourceList = NextResourceRequirement(pResourceList);
 
            pRequirementsList->ListSize = ulDataSize + ulNewSize;
            pRequirementsList->AlternativeLists++;
 
            pResourceList->Version = 1;
            pResourceList->Revision = 1;
            pResourceList->Count = 1;
 
            pResourceList->Descriptors[0].Option = IO_RESOURCE_PREFERRED;
            pResourceList->Descriptors[0].Type = CmResourceTypeConfigData;
            pResourceList->Descriptors[0].u.ConfigData.Priority = ulPriority;
 
            *pulLogConfTag = ulIndex;
        }
        else
        {
            ret = CR_FAILURE;
            goto done;
        }
    }
 
    /* Store the configuration */
    if (RegSetValueEx(hConfigKey,
                      szValueNameBuffer,
                      0,
                      RegDataType,
                      pDataBuffer,
                      ulDataSize + ulNewSize) != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
done:
    if (pDataBuffer != NULL)
        HeapFree(GetProcessHeap(), 0, pDataBuffer);
 
    if (hConfigKey != NULL)
        RegCloseKey(hConfigKey);
 
    DPRINT("PNP_AddEmptyLogConf() returns %lu\n", ret);
 
    return ret;
}

Referenced by CM_Add_Empty_Log_Conf_Ex().

PNP_AddID()

DWORD WINAPI PNP_AddID	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		LPWSTR	pszID,
		DWORD	ulFlags
	)

Definition at line 3799 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    HKEY hDeviceKey;
    LPWSTR pszSubKey;
    DWORD dwDeviceIdListSize;
    DWORD dwNewDeviceIdSize;
    WCHAR * pszDeviceIdList = NULL;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_AddID(%p %S %S 0x%08lx)\n",
           hBinding, pszDeviceID, pszID, ulFlags);
 
    if (RegOpenKeyExW(hEnumKey,
                      pszDeviceID,
                      0,
                      KEY_QUERY_VALUE | KEY_SET_VALUE,
                      &hDeviceKey) != ERROR_SUCCESS)
    {
        DPRINT("Failed to open the device key!\n");
        return CR_INVALID_DEVNODE;
    }
 
    pszSubKey = (ulFlags & CM_ADD_ID_COMPATIBLE) ? L"CompatibleIDs" : L"HardwareID";
 
    if (RegQueryValueExW(hDeviceKey,
                         pszSubKey,
                         NULL,
                         NULL,
                         NULL,
                         &dwDeviceIdListSize) != ERROR_SUCCESS)
    {
        DPRINT("Failed to query the desired ID string!\n");
        ret = CR_REGISTRY_ERROR;
        goto Done;
    }
 
    dwNewDeviceIdSize = lstrlenW(pszDeviceID);
    if (!dwNewDeviceIdSize)
    {
        ret = CR_INVALID_POINTER;
        goto Done;
    }
 
    dwDeviceIdListSize += (dwNewDeviceIdSize + 2) * sizeof(WCHAR);
 
    pszDeviceIdList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwDeviceIdListSize);
    if (!pszDeviceIdList)
    {
        DPRINT("Failed to allocate memory for the desired ID string!\n");
        ret = CR_OUT_OF_MEMORY;
        goto Done;
    }
 
    if (RegQueryValueExW(hDeviceKey,
                         pszSubKey,
                         NULL,
                         NULL,
                         (LPBYTE)pszDeviceIdList,
                         &dwDeviceIdListSize) != ERROR_SUCCESS)
    {
        DPRINT("Failed to query the desired ID string!\n");
        ret = CR_REGISTRY_ERROR;
        goto Done;
    }
 
    /* Check whether the device ID is already in use */
    if (CheckForDeviceId(pszDeviceIdList, pszDeviceID))
    {
        DPRINT("Device ID was found in the ID string!\n");
        ret = CR_SUCCESS;
        goto Done;
    }
 
    /* Append the Device ID */
    AppendDeviceId(pszDeviceIdList, &dwDeviceIdListSize, pszID);
 
    if (RegSetValueExW(hDeviceKey,
                       pszSubKey,
                       0,
                       REG_MULTI_SZ,
                       (LPBYTE)pszDeviceIdList,
                       dwDeviceIdListSize) != ERROR_SUCCESS)
    {
        DPRINT("Failed to set the desired ID string!\n");
        ret = CR_REGISTRY_ERROR;
    }
 
Done:
    RegCloseKey(hDeviceKey);
    if (pszDeviceIdList)
        HeapFree(GetProcessHeap(), 0, pszDeviceIdList);
 
    DPRINT("PNP_AddID() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Add_ID_ExW().

PNP_AddResDes()

DWORD WINAPI PNP_AddResDes	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfTag,
		DWORD	ulLogConfType,
		RESOURCEID	ResourceID,
		DWORD *	pulResourceTag,
		BYTE *	ResourceData,
		PNP_RPC_BUFFER_SIZE	ResourceLen,
		DWORD	ulFlags
	)

Definition at line 4927 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_ApplyPowerSettings()

DWORD WINAPI PNP_ApplyPowerSettings

(

handle_t

hBinding

)

Definition at line 5613 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_Connect()

DWORD WINAPI PNP_Connect

(

handle_t

hBinding

)

Definition at line 711 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
    return CR_SUCCESS;
}

PNP_CreateDevInst()

DWORD WINAPI PNP_CreateDevInst	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		LPWSTR	pszParentDeviceID,
		PNP_RPC_STRING_LEN	ulLength,
		DWORD	ulFlags
	)

Definition at line 3298 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEVICE_CONTROL_DATA ControlData;
    HKEY hKey = NULL;
    DWORD dwSize, dwPhantom;
    NTSTATUS Status;
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_CreateDevInst(%p %S %S %lu 0x%08lx)\n",
           hBinding, pszParentDeviceID, pszDeviceID, ulLength, ulFlags);
 
    if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
        return CR_INVALID_FLAG;
 
    if (pszDeviceID == NULL || pszParentDeviceID == NULL)
        return CR_INVALID_POINTER;
 
    /* Fail, if the parent device is not the root device */
    if (!IsRootDeviceInstanceID(pszParentDeviceID))
        return CR_INVALID_DEVINST;
 
    if (ulFlags & CM_CREATE_DEVNODE_GENERATE_ID)
    {
        ret = GenerateDeviceID(pszDeviceID,
                               ulLength);
        if (ret != CR_SUCCESS)
            return ret;
    }
 
    /* Try to open the device instance key */
    RegOpenKeyEx(hEnumKey, pszDeviceID, 0, KEY_READ | KEY_WRITE, &hKey);
 
    if (ulFlags & CM_CREATE_DEVNODE_PHANTOM)
    {
        /* Fail, if the device already exists */
        if (hKey != NULL)
        {
            ret = CR_ALREADY_SUCH_DEVINST;
            goto done;
        }
 
        /* Create the phantom device instance */
        ret = CreateDeviceInstance(pszDeviceID, TRUE);
    }
    else
    {
        /* Fail, if the device exists and is present */
        if ((hKey != NULL) && (IsPresentDeviceInstanceID(pszDeviceID)))
        {
            ret = CR_ALREADY_SUCH_DEVINST;
            goto done;
        }
 
        /* If it does not already exist ... */
        if (hKey == NULL)
        {
            /* Create the device instance */
            ret = CreateDeviceInstance(pszDeviceID, FALSE);
 
            /* Open the device instance key */
            RegOpenKeyEx(hEnumKey, pszDeviceID, 0, KEY_READ | KEY_WRITE, &hKey);
        }
 
        /* Create a device node for the device */
        RtlInitUnicodeString(&ControlData.DeviceInstance, pszDeviceID);
        Status = NtPlugPlayControl(PlugPlayControlInitializeDevice,
                                   &ControlData,
                                   sizeof(ControlData));
        if (!NT_SUCCESS(Status))
        {
            ret = CR_FAILURE;
            goto done;
        }
 
        /* If the device is a phantom device, turn it into a normal device */
        if (hKey != NULL)
        {
            dwPhantom = 0;
            dwSize = sizeof(DWORD);
            RegQueryValueEx(hKey, L"Phantom", NULL, NULL, (PBYTE)&dwPhantom, &dwSize);
 
            if (dwPhantom != 0)
                RegDeleteValue(hKey, L"Phantom");
        }
    }
 
done:
    if (hKey)
        RegCloseKey(hKey);
 
    DPRINT("PNP_CreateDevInst() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Create_DevNode_ExW().

PNP_CreateKey()

DWORD WINAPI PNP_CreateKey	(	handle_t	hBinding,
		LPWSTR	pszSubKey,
		DWORD	samDesired,
		DWORD	ulFlags
	)

Definition at line 2438 of file rpcserver.c.

{
    HKEY hDeviceKey = NULL, hParametersKey = NULL;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(samDesired);
 
    DPRINT("PNP_CreateKey(%p %S 0x%lx 0x%08lx)\n",
           hBinding, pszSubKey, samDesired, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pszSubKey))
        return CR_INVALID_DEVINST;
 
    dwError = RegOpenKeyExW(hEnumKey,
                            pszSubKey,
                            0,
                            KEY_WRITE,
                            &hDeviceKey);
    if (dwError != ERROR_SUCCESS)
    {
        ret = CR_INVALID_DEVNODE;
        goto done;
    }
 
    dwError = RegCreateKeyExW(hDeviceKey,
                              L"Device Parameters",
                              0,
                              NULL,
                              REG_OPTION_NON_VOLATILE,
                              KEY_ALL_ACCESS,
                              NULL,
                              &hParametersKey,
                              NULL);
    if (dwError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    /* FIXME: Set key security */
 
done:
    if (hParametersKey != NULL)
        RegCloseKey(hParametersKey);
 
    if (hDeviceKey != NULL)
        RegCloseKey(hDeviceKey);
 
    return ret;
}

PNP_DeleteClassKey()

DWORD WINAPI PNP_DeleteClassKey	(	handle_t	hBinding,
		LPWSTR	pszClassGuid,
		DWORD	ulFlags
	)

Definition at line 2620 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_DeleteClassKey(%p %S 0x%08lx)\n",
           hBinding, pszClassGuid, ulFlags);
 
    if (ulFlags & CM_DELETE_CLASS_SUBKEYS)
    {
        if (SHDeleteKeyW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
            ret = CR_REGISTRY_ERROR;
    }
    else
    {
        if (RegDeleteKeyW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
            ret = CR_REGISTRY_ERROR;
    }
 
    DPRINT("PNP_DeleteClassKey() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Delete_Class_Key_Ex().

PNP_DeleteRegistryKey()

DWORD WINAPI PNP_DeleteRegistryKey	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		LPWSTR	pszParentKey,
		LPWSTR	pszChildKey,
		DWORD	ulFlags
	)

Definition at line 2502 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Delete_DevNode_Key_Ex().

PNP_DeleteServiceDevices()

DWORD WINAPI PNP_DeleteServiceDevices

(

handle_t

hBinding

)

Definition at line 5670 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_DetectResourceConflict()

DWORD WINAPI PNP_DetectResourceConflict	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		RESOURCEID	ResourceID,
		BYTE *	ResourceData,
		PNP_RPC_BUFFER_SIZE	ResourceLen,
		BOOL *	pbConflictDetected,
		DWORD	ulFlags
	)

Definition at line 5119 of file rpcserver.c.

{
    DPRINT("PNP_DetectResourceConflict()\n");
 
    if (pbConflictDetected != NULL)
        *pbConflictDetected = FALSE;
 
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_DeviceInstanceAction()

DWORD WINAPI PNP_DeviceInstanceAction	(	handle_t	hBinding,
		DWORD	ulMajorAction,
		DWORD	ulMinorAction,
		LPWSTR	pszDeviceInstance1,
		LPWSTR	pszDeviceInstance2
	)

Definition at line 3538 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_DeviceInstanceAction(%p %lu 0x%08lx %S %S)\n",
           hBinding, ulMajorAction, ulMinorAction,
           pszDeviceInstance1, pszDeviceInstance2);
 
    switch (ulMajorAction)
    {
        case PNP_DEVINST_SETUP:
            ret = SetupDeviceInstance(pszDeviceInstance1,
                                      ulMinorAction);
            break;
 
        case PNP_DEVINST_ENABLE:
            ret = EnableDeviceInstance(pszDeviceInstance1);
            break;
 
        case PNP_DEVINST_REENUMERATE:
            ret = ReenumerateDeviceInstance(pszDeviceInstance1,
                                            ulMinorAction);
            break;
 
        default:
            DPRINT1("Unknown device action %lu: not implemented\n", ulMajorAction);
            ret = CR_CALL_NOT_IMPLEMENTED;
    }
 
    DPRINT("PNP_DeviceInstanceAction() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Enable_DevNode_Ex(), CM_Move_DevNode_Ex(), CM_Reenumerate_DevNode_Ex(), and CM_Setup_DevNode_Ex().

PNP_DisableDevInst()

DWORD WINAPI PNP_DisableDevInst	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		PPNP_VETO_TYPE	pVetoType,
		LPWSTR	pszVetoName,
		DWORD	ulNameLength,
		DWORD	ulFlags
	)

Definition at line 3714 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT1("PNP_DisableDevInst(%p %S %p %p %lu 0x%08lx)\n",
            hBinding, pDeviceID, pVetoType, pszVetoName, ulNameLength, ulFlags);
 
    if (ulFlags & ~CM_DISABLE_BITS)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID) ||
        IsRootDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    return DisableDeviceInstance(pDeviceID,
                                 pVetoType,
                                 pszVetoName,
                                 ulNameLength);
}

Referenced by CM_Disable_DevNode_Ex().

PNP_Disconnect()

DWORD WINAPI PNP_Disconnect

(

handle_t

hBinding

)

Definition at line 700 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
    return CR_SUCCESS;
}

PNP_DriverStoreAddDriverPackage()

DWORD WINAPI PNP_DriverStoreAddDriverPackage

(

handle_t

hBinding

)

Definition at line 5624 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_DriverStoreDeleteDriverPackage()

DWORD WINAPI PNP_DriverStoreDeleteDriverPackage

(

handle_t

hBinding

)

Definition at line 5635 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_EnumerateSubKeys()

DWORD WINAPI PNP_EnumerateSubKeys	(	handle_t	hBinding,
		DWORD	ulBranch,
		DWORD	ulIndex,
		LPWSTR	Buffer,
		PNP_RPC_STRING_LEN	ulLength,
		PNP_RPC_STRING_LEN *	pulRequiredLen,
		DWORD	ulFlags
	)

Definition at line 993 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    HKEY hKey;
    DWORD dwError;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_EnumerateSubKeys(%p %lu %lu %p %lu %p 0x%08lx)\n",
           hBinding, ulBranch, ulIndex, Buffer, ulLength,
           pulRequiredLen, ulFlags);
 
    switch (ulBranch)
    {
        case PNP_ENUMERATOR_SUBKEYS:
            hKey = hEnumKey;
            break;
 
        case PNP_CLASS_SUBKEYS:
            hKey = hClassKey;
            break;
 
        default:
            return CR_FAILURE;
    }
 
    *pulRequiredLen = ulLength;
    dwError = RegEnumKeyExW(hKey,
                            ulIndex,
                            Buffer,
                            pulRequiredLen,
                            NULL,
                            NULL,
                            NULL,
                            NULL);
    if (dwError != ERROR_SUCCESS)
    {
        ret = (dwError == ERROR_NO_MORE_ITEMS) ? CR_NO_SUCH_VALUE : CR_FAILURE;
    }
    else
    {
        (*pulRequiredLen)++;
    }
 
    DPRINT("PNP_EnumerateSubKeys() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Enumerate_Classes_Ex(), and CM_Enumerate_Enumerators_ExW().

PNP_FreeLogConf()

DWORD WINAPI PNP_FreeLogConf	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfType,
		DWORD	ulLogConfTag,
		DWORD	ulFlags
	)

Definition at line 4550 of file rpcserver.c.

{
    HKEY hConfigKey = NULL;
    DWORD RegDataType = 0;
    ULONG ulDataSize = 0;
    LPBYTE pDataBuffer = NULL;
    WCHAR szValueNameBuffer[LOGCONF_NAME_BUFFER_SIZE];
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_FreeLogConf(%p %S %lu %lu 0x%08lx)\n",
           hBinding, pDeviceID, ulLogConfType, ulLogConfTag, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVNODE;
 
    ret = OpenConfigurationKey(pDeviceID,
                               ulLogConfType,
                               &hConfigKey);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    ret = GetConfigurationData(hConfigKey,
                               ulLogConfType,
                               &RegDataType,
                               &ulDataSize,
                               &pDataBuffer,
                               LOGCONF_NAME_BUFFER_SIZE,
                               szValueNameBuffer);
    if (ret != CR_SUCCESS)
    {
        ret = CR_INVALID_LOG_CONF;
        goto done;
    }
 
    if (RegDataType == REG_RESOURCE_LIST)
    {
        PCM_RESOURCE_LIST pResourceList = (PCM_RESOURCE_LIST)pDataBuffer;
 
        if (pResourceList->Count <= 1)
        {
            /* Delete the key if there is only one or no configuration in the key */
            DPRINT("Delete value %S\n", szValueNameBuffer);
            RegDeleteValue(hConfigKey, szValueNameBuffer);
        }
        else
        {
            PCM_FULL_RESOURCE_DESCRIPTOR pResource = NULL, pNextResource = NULL;
            ULONG ulIndex, ulMoveSize;
            DWORD dwError;
 
            /* Fail if we try to delete an entry outside of our resource list */
            if (ulLogConfTag >= pResourceList->Count)
            {
                ret = CR_INVALID_LOG_CONF;
                goto done;
            }
 
            /* Get a pointer to the resource descriptor to be deleted */
            pResource = (PCM_FULL_RESOURCE_DESCRIPTOR)&pResourceList->List[0];
            for (ulIndex = 0; ulIndex < ulLogConfTag; ulIndex++)
                pResource = NextResourceDescriptor(pResource);
 
            /* Delete the resource descriptor */
            if (ulLogConfTag == pResourceList->Count - 1)
            {
                /* Delete the last resource descriptor */
                ulDataSize = (ULONG)((ULONG_PTR)pResource - (ULONG_PTR)pResourceList);
            }
            else
            {
                pNextResource = NextResourceDescriptor(pResource);
 
                ulMoveSize = ulDataSize - (DWORD)((ULONG_PTR)pNextResource - (ULONG_PTR)pResourceList);
                MoveMemory(pResource, pNextResource, ulMoveSize);
 
                ulDataSize -= (DWORD)((ULONG_PTR)pNextResource - (ULONG_PTR)pResource);
            }
 
            pResourceList->Count--;
 
            /* Store the new configuration */
            dwError = RegSetValueEx(hConfigKey,
                                    szValueNameBuffer,
                                    0,
                                    RegDataType,
                                    pDataBuffer,
                                    ulDataSize);
            if (dwError != ERROR_SUCCESS)
            {
                ret = CR_REGISTRY_ERROR;
                goto done;
            }
        }
    }
    else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
    {
        if (((PIO_RESOURCE_REQUIREMENTS_LIST)pDataBuffer)->AlternativeLists <= 1)
        {
            /* Delete the key if there is only one or no configuration in the key */
            DPRINT("Delete value %S\n", szValueNameBuffer);
            RegDeleteValue(hConfigKey, szValueNameBuffer);
        }
        else
        {
            /* FIXME */
        }
    }
    else
    {
        ret = CR_FAILURE;
        goto done;
    }
 
done:
    if (pDataBuffer != NULL)
        HeapFree(GetProcessHeap(), 0, pDataBuffer);
 
    if (hConfigKey != NULL)
        RegCloseKey(hConfigKey);
 
    DPRINT("PNP_FreeLogConf() returns %lu\n", ret);
 
    return ret;
}

Referenced by CM_Free_Log_Conf_Ex().

PNP_FreeResDes()

DWORD WINAPI PNP_FreeResDes	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfTag,
		DWORD	ulLogConfType,
		RESOURCEID	ResourceID,
		DWORD	ulResourceTag,
		DWORD *	pulPreviousResType,
		DWORD *	pulPreviousResTag,
		DWORD	ulFlags
	)

Definition at line 4946 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_GetBlockedDriverInfo()

DWORD WINAPI PNP_GetBlockedDriverInfo	(	handle_t	hBinding,
		BYTE *	Buffer,
		PNP_RPC_BUFFER_SIZE *	pulTransferLen,
		PNP_RPC_BUFFER_SIZE *	pulLength,
		DWORD	ulFlags
	)

Definition at line 5504 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CMP_GetBlockedDriverInfo().

PNP_GetClassCount()

DWORD WINAPI PNP_GetClassCount	(	handle_t	hBinding,
		DWORD *	pulClassCount,
		DWORD	ulFlags
	)

Definition at line 2517 of file rpcserver.c.

{
    HKEY hKey;
    DWORD dwError;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_GetClassCount(%p %p 0x%08lx)\n",
           hBinding, pulClassCount, ulFlags);
 
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            REGSTR_PATH_CLASS,
                            0,
                            KEY_QUERY_VALUE,
                            &hKey);
    if (dwError != ERROR_SUCCESS)
        return CR_INVALID_DATA;
 
    dwError = RegQueryInfoKeyW(hKey,
                               NULL,
                               NULL,
                               NULL,
                               pulClassCount,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL);
    RegCloseKey(hKey);
    if (dwError != ERROR_SUCCESS)
        return CR_INVALID_DATA;
 
    return CR_SUCCESS;
}

PNP_GetClassInstance()

DWORD WINAPI PNP_GetClassInstance	(	handle_t	hBinding,
		LPWSTR	pDeviceId,
		LPWSTR	pszClassInstance,
		PNP_RPC_STRING_LEN	ulLength
	)

Definition at line 2322 of file rpcserver.c.

{
    WCHAR szClassGuid[40];
    WCHAR szClassInstance[5];
    HKEY hDeviceClassKey = NULL;
    HKEY hClassInstanceKey;
    ULONG ulTransferLength, ulDataLength;
    DWORD dwDataType, dwDisposition, i;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_GetClassInstance(%p %S %p %lu)\n",
           hBinding, pDeviceId, pszClassInstance, ulLength);
 
    if (!IsValidDeviceInstanceID(pDeviceId))
        return CR_INVALID_DEVINST;
 
    ulTransferLength = ulLength;
    ret = PNP_GetDeviceRegProp(hBinding,
                               pDeviceId,
                               CM_DRP_DRIVER,
                               &dwDataType,
                               (BYTE *)pszClassInstance,
                               &ulTransferLength,
                               &ulLength,
                               0);
    if (ret == CR_SUCCESS)
        return ret;
 
    ulTransferLength = sizeof(szClassGuid);
    ulDataLength = sizeof(szClassGuid);
    ret = PNP_GetDeviceRegProp(hBinding,
                               pDeviceId,
                               CM_DRP_CLASSGUID,
                               &dwDataType,
                               (BYTE *)szClassGuid,
                               &ulTransferLength,
                               &ulDataLength,
                               0);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("PNP_GetDeviceRegProp() failed (Error %lu)\n", ret);
        goto done;
    }
 
    dwError = RegOpenKeyExW(hClassKey,
                            szClassGuid,
                            0,
                            KEY_READ,
                            &hDeviceClassKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("RegOpenKeyExW() failed (Error %lu)\n", dwError);
        ret = CR_FAILURE;
        goto done;
    }
 
    for (i = 0; i < 10000; i++)
    {
        wsprintf(szClassInstance, L"%04lu", i);
 
        dwError = RegCreateKeyExW(hDeviceClassKey,
                                  szClassInstance,
                                  0,
                                  NULL,
                                  REG_OPTION_NON_VOLATILE,
                                  KEY_ALL_ACCESS,
                                  NULL,
                                  &hClassInstanceKey,
                                  &dwDisposition);
        if (dwError == ERROR_SUCCESS)
        {
            RegCloseKey(hClassInstanceKey);
 
            if (dwDisposition == REG_CREATED_NEW_KEY)
            {
                wsprintf(pszClassInstance,
                         L"%s\\%s",
                         szClassGuid,
                         szClassInstance);
 
                ulDataLength = (wcslen(pszClassInstance) + 1) * sizeof(WCHAR);
                ret = PNP_SetDeviceRegProp(hBinding,
                                           pDeviceId,
                                           CM_DRP_DRIVER,
                                           REG_SZ,
                                           (BYTE *)pszClassInstance,
                                           ulDataLength,
                                           0);
                if (ret != CR_SUCCESS)
                {
                    DPRINT1("PNP_SetDeviceRegProp() failed (Error %lu)\n", ret);
                    RegDeleteKeyW(hDeviceClassKey,
                                  szClassInstance);
                }
 
                break;
            }
        }
    }
 
done:
    if (hDeviceClassKey != NULL)
        RegCloseKey(hDeviceClassKey);
 
    return ret;
}

Referenced by GetDeviceInstanceKeyPath().

PNP_GetClassName()

DWORD WINAPI PNP_GetClassName	(	handle_t	hBinding,
		LPWSTR	pszClassGuid,
		LPWSTR	Buffer,
		PNP_RPC_STRING_LEN *	pulLength,
		DWORD	ulFlags
	)

Definition at line 2562 of file rpcserver.c.

{
    WCHAR szKeyName[MAX_PATH];
    CONFIGRET ret = CR_SUCCESS;
    HKEY hKey;
    DWORD dwSize;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_GetClassName(%p %S %p %p 0x%08lx)\n",
           hBinding, pszClassGuid, Buffer, pulLength, ulFlags);
 
    lstrcpyW(szKeyName, L"System\\CurrentControlSet\\Control\\Class\\");
    if (lstrlenW(pszClassGuid) + 1 < sizeof(szKeyName)/sizeof(WCHAR)-(lstrlenW(szKeyName) * sizeof(WCHAR)))
        lstrcatW(szKeyName, pszClassGuid);
    else
        return CR_INVALID_DATA;
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                      szKeyName,
                      0,
                      KEY_QUERY_VALUE,
                      &hKey))
        return CR_REGISTRY_ERROR;
 
    dwSize = *pulLength * sizeof(WCHAR);
    if (RegQueryValueExW(hKey,
                         L"Class",
                         NULL,
                         NULL,
                         (LPBYTE)Buffer,
                         &dwSize))
    {
        *pulLength = 0;
        ret = CR_REGISTRY_ERROR;
    }
    else
    {
        *pulLength = dwSize / sizeof(WCHAR);
    }
 
    RegCloseKey(hKey);
 
    DPRINT("PNP_GetClassName() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Get_Class_Name_ExW().

PNP_GetClassRegProp()

DWORD WINAPI PNP_GetClassRegProp	(	handle_t	hBinding,
		LPWSTR	pszClassGuid,
		DWORD	ulProperty,
		DWORD *	pulRegDataType,
		BYTE *	Buffer,
		PNP_RPC_STRING_LEN *	pulTransferLen,
		PNP_RPC_STRING_LEN *	pulLength,
		DWORD	ulFlags
	)

Definition at line 2899 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    LPWSTR lpValueName = NULL;
    HKEY hInstKey = NULL;
    HKEY hPropKey = NULL;
    LONG lError;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetClassRegProp(%p %S %lu %p %p %p %p 0x%08lx)\n",
           hBinding, pszClassGuid, ulProperty, pulRegDataType,
           Buffer, pulTransferLen, pulLength, ulFlags);
 
    if (pulTransferLen == NULL || pulLength == NULL)
    {
        ret = CR_INVALID_POINTER;
        goto done;
    }
 
    if (ulFlags != 0)
    {
        ret = CR_INVALID_FLAG;
        goto done;
    }
 
    if (*pulLength < *pulTransferLen)
        *pulLength = *pulTransferLen;
 
    *pulTransferLen = 0;
 
    switch (ulProperty)
    {
        case CM_CRP_SECURITY:
            lpValueName = L"Security";
            break;
 
        case CM_CRP_DEVTYPE:
            lpValueName = L"DeviceType";
            break;
 
        case CM_CRP_EXCLUSIVE:
            lpValueName = L"Exclusive";
            break;
 
        case CM_CRP_CHARACTERISTICS:
            lpValueName = L"DeviceCharacteristics";
            break;
 
        default:
            ret = CR_INVALID_PROPERTY;
            goto done;
    }
 
    DPRINT("Value name: %S\n", lpValueName);
 
    lError = RegOpenKeyExW(hClassKey,
                           pszClassGuid,
                           0,
                           KEY_READ,
                           &hInstKey);
    if (lError != ERROR_SUCCESS)
    {
        *pulLength = 0;
        ret = CR_NO_SUCH_REGISTRY_KEY;
        goto done;
    }
 
    lError = RegOpenKeyExW(hInstKey,
                           L"Properties",
                           0,
                           KEY_READ,
                           &hPropKey);
    if (lError != ERROR_SUCCESS)
    {
        *pulLength = 0;
        ret = CR_NO_SUCH_REGISTRY_KEY;
        goto done;
    }
 
    lError = RegQueryValueExW(hPropKey,
                              lpValueName,
                              NULL,
                              pulRegDataType,
                              Buffer,
                              pulLength);
    if (lError != ERROR_SUCCESS)
    {
        if (lError == ERROR_MORE_DATA)
        {
            ret = CR_BUFFER_SMALL;
        }
        else
        {
            *pulLength = 0;
            ret = CR_NO_SUCH_VALUE;
        }
    }
 
done:
    if (ret == CR_SUCCESS)
        *pulTransferLen = *pulLength;
 
    if (hPropKey != NULL)
        RegCloseKey(hPropKey);
 
    if (hInstKey != NULL)
        RegCloseKey(hInstKey);
 
    DPRINT("PNP_GetClassRegProp() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Get_Class_Registry_PropertyW().

PNP_GetCustomDevProp()

DWORD WINAPI PNP_GetCustomDevProp	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		LPWSTR	CustomPropName,
		DWORD *	pulRegDataType,
		BYTE *	Buffer,
		PNP_RPC_STRING_LEN *	pulTransferLen,
		PNP_RPC_STRING_LEN *	pulLength,
		DWORD	ulFlags
	)

Definition at line 5391 of file rpcserver.c.

{
    HKEY hDeviceKey = NULL;
    HKEY hParamKey = NULL;
    LONG lError;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetCustomDevProp() called\n");
 
    if (pulTransferLen == NULL || pulLength == NULL)
    {
        ret = CR_INVALID_POINTER;
        goto done;
    }
 
    if (ulFlags & ~CM_CUSTOMDEVPROP_BITS)
    {
        ret = CR_INVALID_FLAG;
        goto done;
    }
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    if (*pulLength < *pulTransferLen)
        *pulLength = *pulTransferLen;
 
    *pulTransferLen = 0;
 
    lError = RegOpenKeyExW(hEnumKey,
                           pDeviceID,
                           0,
                           KEY_READ,
                           &hDeviceKey);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    lError = RegOpenKeyExW(hDeviceKey,
                           L"Device Parameters",
                           0,
                           KEY_READ,
                           &hParamKey);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    lError = RegQueryValueExW(hParamKey,
                              CustomPropName,
                              NULL,
                              pulRegDataType,
                              Buffer,
                              pulLength);
    if (lError != ERROR_SUCCESS)
    {
        if (lError == ERROR_MORE_DATA)
        {
            ret = CR_BUFFER_SMALL;
        }
        else
        {
            *pulLength = 0;
            ret = CR_NO_SUCH_VALUE;
        }
    }
 
done:
    if (ret == CR_SUCCESS)
        *pulTransferLen = *pulLength;
 
    if (hParamKey != NULL)
        RegCloseKey(hParamKey);
 
    if (hDeviceKey != NULL)
        RegCloseKey(hDeviceKey);
 
    DPRINT("PNP_GetCustomDevProp() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Get_DevNode_Custom_Property_ExW().

PNP_GetDepth()

DWORD WINAPI PNP_GetDepth	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		DWORD *	pulDepth,
		DWORD	ulFlags
	)

Definition at line 1860 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEPTH_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_GetDepth(%p %S %p 0x%08lx)\n",
           hBinding, pszDeviceID, pulDepth, ulFlags);
 
    if (!IsValidDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
 
    Status = NtPlugPlayControl(PlugPlayControlGetDeviceDepth,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_DEPTH_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulDepth = PlugPlayData.Depth;
    }
    else
    {
        ret = NtStatusToCrError(Status);
    }
 
    DPRINT("PNP_GetDepth() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Get_Depth_Ex().

PNP_GetDeviceList()

DWORD WINAPI PNP_GetDeviceList	(	handle_t	hBinding,
		LPWSTR	pszFilter,
		LPWSTR	Buffer,
		PNP_RPC_STRING_LEN *	pulLength,
		DWORD	ulFlags
	)

Definition at line 1414 of file rpcserver.c.

{
    WCHAR szEnumerator[MAX_DEVICE_ID_LEN];
    WCHAR szDevice[MAX_DEVICE_ID_LEN];
    WCHAR szInstance[MAX_DEVICE_ID_LEN];
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_GetDeviceList(%p %S %p %p 0x%08lx)\n",
           hBinding, pszFilter, Buffer, pulLength, ulFlags);
 
    if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
        return CR_INVALID_FLAG;
 
    if (pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if ((ulFlags != CM_GETIDLIST_FILTER_NONE) &&
        (pszFilter == NULL))
        return CR_INVALID_POINTER;
 
    if (ulFlags &
        (CM_GETIDLIST_FILTER_BUSRELATIONS |
         CM_GETIDLIST_FILTER_POWERRELATIONS |
         CM_GETIDLIST_FILTER_REMOVALRELATIONS |
         CM_GETIDLIST_FILTER_EJECTRELATIONS))
    {
        ret = GetRelationsInstanceList(pszFilter,
                                       ulFlags,
                                       Buffer,
                                       pulLength);
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_SERVICE)
    {
        ret = GetServiceInstanceList(pszFilter,
                                     Buffer,
                                     pulLength);
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_ENUMERATOR)
    {
        SplitDeviceInstanceID(pszFilter,
                              szEnumerator,
                              szDevice,
                              szInstance);
 
        if (*szEnumerator != UNICODE_NULL && *szDevice != UNICODE_NULL)
        {
            ret = GetDeviceInstanceList(pszFilter,
                                        Buffer,
                                        pulLength);
        }
        else
        {
            ret = GetEnumeratorInstanceList(pszFilter,
                                            Buffer,
                                            pulLength);
        }
    }
    else /* CM_GETIDLIST_FILTER_NONE */
    {
        ret = GetAllInstanceList(Buffer,
                                 pulLength);
    }
 
    return ret;
}

Referenced by CM_Get_Device_ID_List_ExW(), and DeviceInstallThread().

PNP_GetDeviceListSize()

DWORD WINAPI PNP_GetDeviceListSize	(	handle_t	hBinding,
		LPWSTR	pszFilter,
		PNP_RPC_BUFFER_SIZE *	pulLength,
		DWORD	ulFlags
	)

Definition at line 1785 of file rpcserver.c.

{
    WCHAR szEnumerator[MAX_DEVICE_ID_LEN];
    WCHAR szDevice[MAX_DEVICE_ID_LEN];
    WCHAR szInstance[MAX_DEVICE_ID_LEN];
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_GetDeviceListSize(%p %S %p 0x%08lx)\n",
           hBinding, pszFilter, pulLength, ulFlags);
 
    if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
        return CR_INVALID_FLAG;
 
    if (pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if ((ulFlags != CM_GETIDLIST_FILTER_NONE) &&
        (pszFilter == NULL))
        return CR_INVALID_POINTER;
 
    *pulLength = 0;
 
    if (ulFlags &
        (CM_GETIDLIST_FILTER_BUSRELATIONS |
         CM_GETIDLIST_FILTER_POWERRELATIONS |
         CM_GETIDLIST_FILTER_REMOVALRELATIONS |
         CM_GETIDLIST_FILTER_EJECTRELATIONS))
    {
        ret = GetRelationsInstanceListSize(pszFilter,
                                           ulFlags,
                                           pulLength);
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_SERVICE)
    {
        ret = GetServiceInstanceListSize(pszFilter,
                                         pulLength);
    }
    else if (ulFlags & CM_GETIDLIST_FILTER_ENUMERATOR)
    {
        SplitDeviceInstanceID(pszFilter,
                              szEnumerator,
                              szDevice,
                              szInstance);
 
        if (*szEnumerator != UNICODE_NULL && *szDevice != UNICODE_NULL)
        {
            ret = GetDeviceInstanceListSize(pszFilter,
                                            pulLength);
        }
        else
        {
            ret = GetEnumeratorInstanceListSize(pszFilter,
                                                pulLength);
        }
    }
    else /* CM_GETIDLIST_FILTER_NONE */
    {
        ret = GetAllInstanceListSize(pulLength);
    }
 
    /* Add one character for the terminating double UNICODE_NULL */
    if (ret == CR_SUCCESS)
        (*pulLength) += 1;
 
    return ret;
}

Referenced by CM_Get_Device_ID_List_Size_ExW(), and DeviceInstallThread().

PNP_GetDeviceRegProp()

DWORD WINAPI PNP_GetDeviceRegProp	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulProperty,
		DWORD *	pulRegDataType,
		BYTE *	Buffer,
		PNP_PROP_SIZE *	pulTransferLen,
		PNP_PROP_SIZE *	pulLength,
		DWORD	ulFlags
	)

Definition at line 1903 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_PROPERTY_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    LPWSTR lpValueName = NULL;
    HKEY hKey = NULL;
    LONG lError;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetDeviceRegProp(%p %S %lu %p %p %p %p 0x%08lx)\n",
           hBinding, pDeviceID, ulProperty, pulRegDataType, Buffer,
           pulTransferLen, pulLength, ulFlags);
 
    if (pulTransferLen == NULL || pulLength == NULL)
    {
        ret = CR_INVALID_POINTER;
        goto done;
    }
 
    if (ulFlags != 0)
    {
        ret = CR_INVALID_FLAG;
        goto done;
    }
 
    /* Check pDeviceID */
    if (!IsValidDeviceInstanceID(pDeviceID))
    {
        ret = CR_INVALID_DEVINST;
        goto done;
    }
 
    if (*pulLength < *pulTransferLen)
        *pulLength = *pulTransferLen;
 
    *pulTransferLen = 0;
 
    switch (ulProperty)
    {
        case CM_DRP_DEVICEDESC:
            lpValueName = L"DeviceDesc";
            break;
 
        case CM_DRP_HARDWAREID:
            lpValueName = L"HardwareID";
            break;
 
        case CM_DRP_COMPATIBLEIDS:
            lpValueName = L"CompatibleIDs";
            break;
 
        case CM_DRP_SERVICE:
            lpValueName = L"Service";
            break;
 
        case CM_DRP_CLASS:
            lpValueName = L"Class";
            break;
 
        case CM_DRP_CLASSGUID:
            lpValueName = L"ClassGUID";
            break;
 
        case CM_DRP_DRIVER:
            lpValueName = L"Driver";
            break;
 
        case CM_DRP_CONFIGFLAGS:
            lpValueName = L"ConfigFlags";
            break;
 
        case CM_DRP_MFG:
            lpValueName = L"Mfg";
            break;
 
        case CM_DRP_FRIENDLYNAME:
            lpValueName = L"FriendlyName";
            break;
 
        case CM_DRP_LOCATION_INFORMATION:
            lpValueName = L"LocationInformation";
            break;
 
        case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
            PlugPlayData.Property = PNP_PROPERTY_PHYSICAL_DEVICE_OBJECT_NAME;
            *pulRegDataType = REG_SZ;
            break;
 
        case CM_DRP_CAPABILITIES:
            lpValueName = L"Capabilities";
            break;
 
        case CM_DRP_UI_NUMBER:
            PlugPlayData.Property = PNP_PROPERTY_UI_NUMBER;
            break;
 
        case CM_DRP_UPPERFILTERS:
            lpValueName = L"UpperFilters";
            break;
 
        case CM_DRP_LOWERFILTERS:
            lpValueName = L"LowerFilters";
            break;
 
        case CM_DRP_BUSTYPEGUID:
            PlugPlayData.Property = PNP_PROPERTY_BUSTYPEGUID;
            *pulRegDataType = REG_BINARY;
            break;
 
        case CM_DRP_LEGACYBUSTYPE:
            PlugPlayData.Property = PNP_PROPERTY_LEGACYBUSTYPE;
            *pulRegDataType = REG_DWORD;
            break;
 
        case CM_DRP_BUSNUMBER:
            PlugPlayData.Property = PNP_PROPERTY_BUSNUMBER;
            *pulRegDataType = REG_DWORD;
            break;
 
        case CM_DRP_ENUMERATOR_NAME:
            PlugPlayData.Property = PNP_PROPERTY_ENUMERATOR_NAME;
            *pulRegDataType = REG_SZ;
            break;
 
        case CM_DRP_SECURITY:
            lpValueName = L"Security";
            break;
 
        case CM_DRP_DEVTYPE:
            lpValueName = L"DeviceType";
            break;
 
        case CM_DRP_EXCLUSIVE:
            lpValueName = L"Exclusive";
            break;
 
        case CM_DRP_CHARACTERISTICS:
            lpValueName = L"DeviceCharacteristics";
            break;
 
        case CM_DRP_ADDRESS:
            PlugPlayData.Property = PNP_PROPERTY_ADDRESS;
            *pulRegDataType = REG_DWORD;
            break;
 
        case CM_DRP_UI_NUMBER_DESC_FORMAT:
            lpValueName = L"UINumberDescFormat";
            break;
 
        case CM_DRP_DEVICE_POWER_DATA:
            PlugPlayData.Property = PNP_PROPERTY_POWER_DATA;
            *pulRegDataType = REG_BINARY;
            break;
 
        case CM_DRP_REMOVAL_POLICY:
            PlugPlayData.Property = PNP_PROPERTY_REMOVAL_POLICY;
            *pulRegDataType = REG_DWORD;
            break;
 
        case CM_DRP_REMOVAL_POLICY_HW_DEFAULT:
            PlugPlayData.Property = PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT;
            *pulRegDataType = REG_DWORD;
            break;
 
        case CM_DRP_REMOVAL_POLICY_OVERRIDE:
            lpValueName = L"RemovalPolicy";
            *pulRegDataType = REG_DWORD;
            break;
 
        case CM_DRP_INSTALL_STATE:
            PlugPlayData.Property = PNP_PROPERTY_INSTALL_STATE;
            *pulRegDataType = REG_DWORD;
            break;
 
#if (WINVER >= _WIN32_WINNT_WS03)
        case CM_DRP_LOCATION_PATHS:
            PlugPlayData.Property = PNP_PROPERTY_LOCATION_PATHS;
            *pulRegDataType = REG_MULTI_SZ;
            break;
#endif
 
#if (WINVER >= _WIN32_WINNT_WIN7)
        case CM_DRP_BASE_CONTAINERID:
            PlugPlayData.Property = PNP_PROPERTY_CONTAINERID;
            *pulRegDataType = REG_SZ;
            break;
#endif
 
        default:
            ret = CR_INVALID_PROPERTY;
            goto done;
    }
 
    DPRINT("Value name: %S\n", lpValueName);
 
    if (lpValueName)
    {
        /* Retrieve information from the Registry */
        lError = RegOpenKeyExW(hEnumKey,
                               pDeviceID,
                               0,
                               KEY_QUERY_VALUE,
                               &hKey);
        if (lError != ERROR_SUCCESS)
        {
            hKey = NULL;
            *pulLength = 0;
            ret = CR_INVALID_DEVNODE;
            goto done;
        }
 
        lError = RegQueryValueExW(hKey,
                                  lpValueName,
                                  NULL,
                                  pulRegDataType,
                                  Buffer,
                                  pulLength);
        if (lError != ERROR_SUCCESS)
        {
            if (lError == ERROR_MORE_DATA)
            {
                ret = CR_BUFFER_SMALL;
            }
            else
            {
                *pulLength = 0;
                ret = CR_NO_SUCH_VALUE;
            }
        }
    }
    else
    {
        /* Retrieve information from the Device Node */
        RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                             pDeviceID);
        PlugPlayData.Buffer = Buffer;
        PlugPlayData.BufferSize = *pulLength;
 
        Status = NtPlugPlayControl(PlugPlayControlProperty,
                                   (PVOID)&PlugPlayData,
                                   sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA));
        if (NT_SUCCESS(Status))
        {
            *pulLength = PlugPlayData.BufferSize;
        }
        else
        {
            ret = NtStatusToCrError(Status);
        }
    }
 
done:
    if (pulTransferLen)
        *pulTransferLen = (ret == CR_SUCCESS) ? *pulLength : 0;
 
    if (hKey != NULL)
        RegCloseKey(hKey);
 
    DPRINT("PNP_GetDeviceRegProp() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Get_DevNode_Registry_Property_ExW(), GetDeviceInstanceKeyPath(), PNP_GetClassInstance(), and PNP_GetDeviceStatus().

PNP_GetDeviceStatus()

DWORD WINAPI PNP_GetDeviceStatus	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD *	pulStatus,
		DWORD *	pulProblem,
		DWORD	ulFlags
	)

Definition at line 3583 of file rpcserver.c.

{
    DWORD ulDataType, ulTransferLength, ulLength;
    DWORD ulCapabilities, ulConfigFlags;
    CONFIGRET ret;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_GetDeviceStatus(%p %S %p %p 0x%08lx)\n",
           hBinding, pDeviceID, pulStatus, pulProblem, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if ((pulStatus == NULL) || (pulProblem == NULL))
        return CR_INVALID_POINTER;
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    ret = GetDeviceStatus(pDeviceID, pulStatus, pulProblem);
    if (ret != CR_SUCCESS)
        return ret;
 
    /* Check for DN_REMOVABLE */
    ulTransferLength = sizeof(ulCapabilities);
    ulLength = sizeof(ulCapabilities);
    ret = PNP_GetDeviceRegProp(NULL,
                               pDeviceID,
                               CM_DRP_CAPABILITIES,
                               &ulDataType,
                               (PBYTE)&ulCapabilities,
                               &ulTransferLength,
                               &ulLength,
                               0);
    if (ret != CR_SUCCESS)
        ulCapabilities = 0;
 
    if (ulCapabilities & CM_DEVCAP_REMOVABLE)
        *pulStatus |= DN_REMOVABLE;
 
    /* Check for DN_MANUAL */
    ulTransferLength = sizeof(ulConfigFlags);
    ulLength = sizeof(ulConfigFlags);
    ret = PNP_GetDeviceRegProp(NULL,
                               pDeviceID,
                               CM_DRP_CONFIGFLAGS,
                               &ulDataType,
                               (PBYTE)&ulConfigFlags,
                               &ulTransferLength,
                               &ulLength,
                               0);
    if (ret != CR_SUCCESS)
        ulConfigFlags = 0;
 
    if (ulConfigFlags & CONFIGFLAG_MANUAL_INSTALL)
        *pulStatus |= DN_MANUAL;
 
    /* Check for failed install */
    if (((*pulStatus & DN_HAS_PROBLEM) == 0) && (ulConfigFlags & CONFIGFLAG_FAILEDINSTALL))
    {
        *pulStatus |= DN_HAS_PROBLEM;
        *pulProblem = CM_PROB_FAILED_INSTALL;
    }
 
    return CR_SUCCESS;
}

Referenced by CM_Get_DevNode_Status_Ex().

PNP_GetFirstLogConf()

DWORD WINAPI PNP_GetFirstLogConf	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfType,
		DWORD *	pulLogConfTag,
		DWORD	ulFlags
	)

Definition at line 4691 of file rpcserver.c.

{
    HKEY hConfigKey = NULL;
    DWORD RegDataType = 0;
    ULONG ulDataSize = 0;
    LPBYTE lpData = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_GetFirstLogConf(%p %S %lu %p 0x%08lx)\n",
           hBinding, pDeviceID, ulLogConfType, pulLogConfTag, ulFlags);
 
    if (pulLogConfTag == NULL)
        return CR_INVALID_POINTER;
 
    *pulLogConfTag = (DWORD)0;
 
    if (ulFlags & ~LOG_CONF_BITS)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    ret = OpenConfigurationKey(pDeviceID,
                               ulLogConfType,
                               &hConfigKey);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    ret = GetConfigurationData(hConfigKey,
                               ulLogConfType,
                               &RegDataType,
                               &ulDataSize,
                               &lpData,
                               0,
                               NULL);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("GetConfigurationData() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    DPRINT1("Data size %lu\n", ulDataSize);
    if (ulDataSize == 0 || lpData == NULL)
    {
        DPRINT1("No config data available!\n");
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    /* Get the first tag */
    if (RegDataType == REG_RESOURCE_LIST)
    {
        DPRINT("REG_RESOURCE_LIST->Count %lu\n", ((PCM_RESOURCE_LIST)lpData)->Count);
 
        /* Fail, if we do not have any resource */
        if (((PCM_RESOURCE_LIST)lpData)->Count == 0)
        {
            DPRINT1("No resource descriptors!\n");
            ret = CR_NO_MORE_LOG_CONF;
            goto done;
        }
    }
    else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
    {
        DPRINT("REG_RESOURCE_REQUIREMENTS_LIST->AlternativeLists %lu\n",
               ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists);
 
        /* Fail, if we do not have any requirements */
        if (((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists == 0)
        {
            ret = CR_NO_MORE_LOG_CONF;
            goto done;
        }
    }
 
done:
    if (lpData != NULL)
        HeapFree(GetProcessHeap(), 0, lpData);
 
    if (hConfigKey != NULL)
        RegCloseKey(hConfigKey);
 
    DPRINT("PNP_GetFirstLogConf() returns %lu\n", ret);
 
    return ret;
}

Referenced by CM_Get_First_Log_Conf_Ex().

PNP_GetGlobalState()

DWORD WINAPI PNP_GetGlobalState	(	handle_t	hBinding,
		DWORD *	pulState,
		DWORD	ulFlags
	)

Definition at line 740 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetGlobalState(%p %p 0x%08lx)\n",
           hBinding, pulState, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    *pulState = CM_GLOBAL_STATE_CAN_DO_UI | CM_GLOBAL_STATE_SERVICES_AVAILABLE;
 
    if (g_ShuttingDown)
        *pulState |= CM_GLOBAL_STATE_SHUTTING_DOWN;
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Global_State_Ex().

PNP_GetHwProfInfo()

DWORD WINAPI PNP_GetHwProfInfo	(	handle_t	hBinding,
		DWORD	ulIndex,
		HWPROFILEINFO *	pHWProfileInfo,
		DWORD	ulProfileInfoSize,
		DWORD	ulFlags
	)

Definition at line 4198 of file rpcserver.c.

{
    WCHAR szProfileName[5];
    HKEY hKeyConfig = NULL;
    HKEY hKeyProfiles = NULL;
    HKEY hKeyProfile = NULL;
    DWORD dwDisposition;
    DWORD dwSize;
    LONG lError;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetHwProfInfo() called\n");
 
    if (ulProfileInfoSize == 0)
    {
        ret = CR_INVALID_DATA;
        goto done;
    }
 
    if (ulFlags != 0)
    {
        ret = CR_INVALID_FLAG;
        goto done;
    }
 
    /* Initialize the profile information */
    pHWProfileInfo->HWPI_ulHWProfile = 0;
    pHWProfileInfo->HWPI_szFriendlyName[0] = 0;
    pHWProfileInfo->HWPI_dwFlags = 0;
 
    /* Open the 'IDConfigDB' key */
    lError = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                             L"System\\CurrentControlSet\\Control\\IDConfigDB",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_QUERY_VALUE,
                             NULL,
                             &hKeyConfig,
                             &dwDisposition);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    /* Open the 'Hardware Profiles' subkey */
    lError = RegCreateKeyExW(hKeyConfig,
                             L"Hardware Profiles",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
                             NULL,
                             &hKeyProfiles,
                             &dwDisposition);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    if (ulIndex == (ULONG)-1)
    {
        dwSize = sizeof(ULONG);
        lError = RegQueryValueExW(hKeyConfig,
                                  L"CurrentConfig",
                                  NULL,
                                  NULL,
                                  (LPBYTE)&pHWProfileInfo->HWPI_ulHWProfile,
                                  &dwSize);
        if (lError != ERROR_SUCCESS)
        {
            pHWProfileInfo->HWPI_ulHWProfile = 0;
            ret = CR_REGISTRY_ERROR;
            goto done;
        }
    }
    else
    {
        /* FIXME: not implemented yet */
        ret = CR_CALL_NOT_IMPLEMENTED;
        goto done;
    }
 
    swprintf(szProfileName, L"%04lu", pHWProfileInfo->HWPI_ulHWProfile);
 
    lError = RegOpenKeyExW(hKeyProfiles,
                           szProfileName,
                           0,
                           KEY_QUERY_VALUE,
                           &hKeyProfile);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    dwSize = sizeof(pHWProfileInfo->HWPI_szFriendlyName);
    lError = RegQueryValueExW(hKeyProfile,
                              L"FriendlyName",
                              NULL,
                              NULL,
                              (LPBYTE)&pHWProfileInfo->HWPI_szFriendlyName,
                              &dwSize);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
done:
    if (hKeyProfile != NULL)
        RegCloseKey(hKeyProfile);
 
    if (hKeyProfiles != NULL)
        RegCloseKey(hKeyProfiles);
 
    if (hKeyConfig != NULL)
        RegCloseKey(hKeyConfig);
 
    return ret;
}

Referenced by CM_Get_Hardware_Profile_Info_ExW().

PNP_GetInterfaceDeviceAlias()

DWORD WINAPI PNP_GetInterfaceDeviceAlias	(	handle_t	hBinding,
		LPWSTR	pszInterfaceDevice,
		GUID *	AliasInterfaceGuid,
		LPWSTR	pszAliasInterfaceDevice,
		PNP_RPC_STRING_LEN *	pulLength,
		PNP_RPC_STRING_LEN *	pulTransferLen,
		DWORD	ulFlags
	)

Definition at line 2652 of file rpcserver.c.

{
    NTSTATUS Status;
    PLUGPLAY_CONTROL_INTERFACE_ALIAS_DATA PlugPlayData;
    DWORD ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetInterfaceDeviceAlias(%p %S %p %p %p %p 0x%08lx)\n",
           hBinding, pszInterfaceDevice, AliasInterfaceGuid, pszAliasInterfaceDevice, pulLength,
           pulTransferLen, ulFlags);
 
    if ((AliasInterfaceGuid == NULL) ||
        (pulLength == NULL))
        return  CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    RtlInitUnicodeString(&PlugPlayData.SymbolicLinkName, pszInterfaceDevice);
    PlugPlayData.AliasInterfaceClassGuid = AliasInterfaceGuid;
    PlugPlayData.AliasSymbolicLinkName = pszAliasInterfaceDevice;
    PlugPlayData.AliasSymbolicLinkNameLength = *pulTransferLen;
 
    Status = NtPlugPlayControl(PlugPlayControlGetInterfaceDeviceAlias,
                               &PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_INTERFACE_ALIAS_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulLength = PlugPlayData.AliasSymbolicLinkNameLength;
        *pulTransferLen = *pulLength + 1;
    }
    else
    {
        *pulLength = 0;
        *pulTransferLen = 0;
        ret = NtStatusToCrError(Status);
    }
 
    DPRINT("PNP_GetInterfaceDeviceAlias() done (returns %lx)\n", ret);
    return ret;
}

Referenced by CM_Get_Device_Interface_Alias_ExW().

PNP_GetInterfaceDeviceList()

DWORD WINAPI PNP_GetInterfaceDeviceList	(	handle_t	hBinding,
		GUID *	InterfaceGuid,
		LPWSTR	pszDeviceID,
		BYTE *	Buffer,
		PNP_RPC_BUFFER_SIZE *	pulLength,
		DWORD	ulFlags
	)

Definition at line 2706 of file rpcserver.c.

{
    NTSTATUS Status;
    PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA PlugPlayData;
    DWORD ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetInterfaceDeviceList(%p %p %S %p %p 0x%08lx)\n",
           hBinding, InterfaceGuid, pszDeviceID, Buffer, pulLength, ulFlags);
 
    if (!IsValidDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
 
    PlugPlayData.Flags = ulFlags;
    PlugPlayData.FilterGuid = InterfaceGuid;
    PlugPlayData.Buffer = Buffer;
    PlugPlayData.BufferSize = *pulLength;
 
    Status = NtPlugPlayControl(PlugPlayControlGetInterfaceDeviceList,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulLength = PlugPlayData.BufferSize;
    }
    else
    {
        ret = NtStatusToCrError(Status);
    }
 
    DPRINT("PNP_GetInterfaceDeviceList() done (returns %lx)\n", ret);
    return ret;
}

Referenced by CM_Get_Device_Interface_List_ExW().

PNP_GetInterfaceDeviceListSize()

DWORD WINAPI PNP_GetInterfaceDeviceListSize	(	handle_t	hBinding,
		PNP_RPC_BUFFER_SIZE *	pulLen,
		GUID *	InterfaceGuid,
		LPWSTR	pszDeviceID,
		DWORD	ulFlags
	)

Definition at line 2754 of file rpcserver.c.

{
    NTSTATUS Status;
    PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA PlugPlayData;
    DWORD ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetInterfaceDeviceListSize(%p %p %p %S 0x%08lx)\n",
           hBinding, pulLen, InterfaceGuid, pszDeviceID, ulFlags);
 
    if (!IsValidDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
 
    PlugPlayData.FilterGuid = InterfaceGuid;
    PlugPlayData.Buffer = NULL;
    PlugPlayData.BufferSize = 0;
    PlugPlayData.Flags = ulFlags;
 
    Status = NtPlugPlayControl(PlugPlayControlGetInterfaceDeviceList,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulLen = PlugPlayData.BufferSize;
    }
    else
    {
        ret = NtStatusToCrError(Status);
    }
 
    DPRINT("PNP_GetInterfaceDeviceListSize() done (returns %lx)\n", ret);
    return ret;
}

Referenced by CM_Get_Device_Interface_List_Size_ExW().

PNP_GetLogConfPriority()

DWORD WINAPI PNP_GetLogConfPriority	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulType,
		DWORD	ulTag,
		DWORD *	pPriority,
		DWORD	ulFlags
	)

Definition at line 4911 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Get_Log_Conf_Priority_Ex().

PNP_GetNextLogConf()

DWORD WINAPI PNP_GetNextLogConf	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfType,
		DWORD	ulCurrentTag,
		DWORD *	pulNextTag,
		DWORD	ulFlags
	)

Definition at line 4792 of file rpcserver.c.

{
    HKEY hConfigKey = NULL;
    DWORD RegDataType = 0;
    ULONG ulDataSize = 0;
    LPBYTE lpData = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT("PNP_GetNextLogConf(%p %S %lu %lu %p 0x%08lx)\n",
           hBinding, pDeviceID, ulLogConfType, ulCurrentTag, pulNextTag, ulFlags);
 
    if (pulNextTag == NULL)
        return CR_INVALID_POINTER;
 
    *pulNextTag = (DWORD)0;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    ret = OpenConfigurationKey(pDeviceID,
                               ulLogConfType,
                               &hConfigKey);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    ret = GetConfigurationData(hConfigKey,
                               ulLogConfType,
                               &RegDataType,
                               &ulDataSize,
                               &lpData,
                               0,
                               NULL);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("GetConfigurationData() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    DPRINT("Data size %lu\n", ulDataSize);
 
    if (ulDataSize == 0 || lpData == NULL)
    {
        DPRINT1("No config data available!\n");
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    /* Check if the next entry is available */
    if (RegDataType == REG_RESOURCE_LIST)
    {
        DPRINT("REG_RESOURCE_LIST->Count %lu\n", ((PCM_RESOURCE_LIST)lpData)->Count);
 
        /* Fail, if we are beyond the end of the list */
        if (ulCurrentTag >= ((PCM_RESOURCE_LIST)lpData)->Count)
        {
            ret = CR_INVALID_LOG_CONF;
            goto done;
        }
 
        /* Indicate that we reached the end of the list */
        if (ulCurrentTag == ((PCM_RESOURCE_LIST)lpData)->Count - 1)
        {
            ret = CR_NO_MORE_LOG_CONF;
            goto done;
        }
    }
    else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
    {
        DPRINT("REG_RESOURCE_REQUIREMENTS_LIST->AlternativeLists %lu\n",
               ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists);
 
        /* Fail, if we are beyond the end of the list */
        if (ulCurrentTag >= ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists)
        {
            ret = CR_INVALID_LOG_CONF;
            goto done;
        }
 
        /* Indicate that we reached the end of the list */
        if (ulCurrentTag == ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists - 1)
        {
            ret = CR_NO_MORE_LOG_CONF;
            goto done;
        }
    }
 
    /* Return the next tag value */
    *pulNextTag = ulCurrentTag + 1;
 
done:
    if (lpData != NULL)
        HeapFree(GetProcessHeap(), 0, lpData);
 
    if (hConfigKey != NULL)
        RegCloseKey(hConfigKey);
 
    DPRINT("PNP_GetNextLogConf() returns %lu\n", ret);
 
    return ret;
}

Referenced by CM_Get_Next_Log_Conf_Ex().

PNP_GetNextResDes()

DWORD WINAPI PNP_GetNextResDes	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfTag,
		DWORD	ulLogConfType,
		RESOURCEID	ResourceID,
		DWORD	ulResourceTag,
		DWORD *	pulNextResType,
		DWORD *	pulNextResTag,
		DWORD	ulFlags
	)

Definition at line 4965 of file rpcserver.c.

{
    HKEY hConfigKey = NULL;
    DWORD RegDataType = 0;
    ULONG ulDataSize = 0;
    LPBYTE lpData = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    DPRINT1("PNP_GetNextResDes(%p %S 0x%lx %lu %lu %ul %p %p 0x%08lx)\n",
           hBinding, pDeviceID, ulLogConfTag, ulLogConfType, ResourceID,
           ulResourceTag, pulNextResType, pulNextResTag, ulFlags);
 
    if (pulNextResType == NULL)
        return CR_INVALID_POINTER;
 
    *pulNextResType = 0;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    ret = OpenConfigurationKey(pDeviceID,
                               ulLogConfType,
                               &hConfigKey);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    ret = GetConfigurationData(hConfigKey,
                               ulLogConfType,
                               &RegDataType,
                               &ulDataSize,
                               &lpData,
                               0,
                               NULL);
    if (ret != CR_SUCCESS)
    {
        DPRINT1("GetConfigurationData() failed (Error %lu)\n", ret);
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    DPRINT1("Data size %lu\n", ulDataSize);
 
    if (ulDataSize == 0 || lpData == NULL)
    {
        DPRINT1("No config data available!\n");
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
    /* Get the next resource descriptor */
    if (RegDataType == REG_RESOURCE_LIST)
    {
        DPRINT1("FIXME: REG_RESOURCE_LIST\n");
        /* FIXME */
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
    else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
    {
        DPRINT1("FIXME: REG_RESOURCE_REQUIREMENTS_LIST\n");
        /* FIXME */
        ret = CR_NO_MORE_LOG_CONF;
        goto done;
    }
 
done:
    if (lpData != NULL)
        HeapFree(GetProcessHeap(), 0, lpData);
 
    if (hConfigKey != NULL)
        RegCloseKey(hConfigKey);
 
    DPRINT1("PNP_GetNextResDes() returns %lu\n", ret);
 
    return ret;
}

Referenced by CM_Get_Next_Res_Des_Ex().

PNP_GetObjectProp()

DWORD WINAPI PNP_GetObjectProp	(	handle_t	hBinding,
		LPWSTR	ObjectName,
		DWORD	ObjectType,
		LPWSTR	PropertyCultureName,
		const DEVPROPKEY *	PropertyKey,
		DEVPROPTYPE *	PropertyType,
		PNP_PROP_SIZE *	PropertySize,
		PNP_PROP_SIZE *	TransferLen,
		BYTE *	PropertyBuffer,
		DWORD	Flags
	)

Definition at line 5563 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_GetObjectPropKeys()

DWORD WINAPI PNP_GetObjectPropKeys	(	handle_t	hBinding,
		LPWSTR	ObjectName,
		DWORD	ObjectType,
		LPWSTR	PropertyCultureName,
		PNP_PROP_COUNT *	PropertyCount,
		PNP_PROP_COUNT *	TransferLen,
		DEVPROPKEY *	PropertyKeys,
		DWORD	Flags
	)

Definition at line 5545 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_GetRelatedDeviceInstance()

DWORD WINAPI PNP_GetRelatedDeviceInstance	(	handle_t	hBinding,
		DWORD	ulRelationship,
		LPWSTR	pDeviceID,
		LPWSTR	pRelatedDeviceId,
		PNP_RPC_STRING_LEN *	pulLength,
		DWORD	ulFlags
	)

Definition at line 915 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_RELATED_DEVICE_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_GetRelatedDeviceInstance(%p %lu %S %p %p 0x%lx)\n",
           hBinding, ulRelationship, pDeviceID, pRelatedDeviceId,
           pulLength, ulFlags);
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    if (ulRelationship == PNP_GET_PARENT_DEVICE_INSTANCE)
    {
        /* The root device does not have a parent */
        if (IsRootDeviceInstanceID(pDeviceID))
            return CR_NO_SUCH_DEVINST;
 
        /* Return the root device for non existing devices */
        if (!IsPresentDeviceInstanceID(pDeviceID))
        {
            if ((wcslen(szRootDeviceInstanceID) + 1) > *pulLength)
            {
                *pulLength = wcslen(szRootDeviceInstanceID) + 1;
                return CR_BUFFER_SMALL;
            }
 
            wcscpy(pRelatedDeviceId, szRootDeviceInstanceID);
            *pulLength = wcslen(szRootDeviceInstanceID) + 1;
            return CR_SUCCESS;
        }
    }
    else if (ulRelationship == PNP_GET_SIBLING_DEVICE_INSTANCE)
    {
        /* The root device does not have siblings */
        if (IsRootDeviceInstanceID(pDeviceID))
            return CR_NO_SUCH_DEVINST;
    }
 
    RtlInitUnicodeString(&PlugPlayData.TargetDeviceInstance,
                         pDeviceID);
 
    PlugPlayData.Relation = ulRelationship;
 
    PlugPlayData.RelatedDeviceInstanceLength = *pulLength;
    PlugPlayData.RelatedDeviceInstance = pRelatedDeviceId;
 
    Status = NtPlugPlayControl(PlugPlayControlGetRelatedDevice,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA));
    if (!NT_SUCCESS(Status))
    {
        ret = NtStatusToCrError(Status);
    }
 
    DPRINT("PNP_GetRelatedDeviceInstance() done (returns %lx)\n", ret);
    if (ret == CR_SUCCESS)
    {
        DPRINT("RelatedDevice: %wZ\n", &PlugPlayData.RelatedDeviceInstance);
    }
 
    return ret;
}

Referenced by CM_Get_Child_Ex(), CM_Get_Parent_Ex(), and CM_Get_Sibling_Ex().

PNP_GetResDesData()

DWORD WINAPI PNP_GetResDesData	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfTag,
		DWORD	ulLogConfType,
		RESOURCEID	ResourceID,
		DWORD	ulResourceTag,
		BYTE *	Buffer,
		PNP_RPC_BUFFER_SIZE	BufferLen,
		DWORD	ulFlags
	)

Definition at line 5062 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_GetResDesDataSize()

DWORD WINAPI PNP_GetResDesDataSize	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfTag,
		DWORD	ulLogConfType,
		RESOURCEID	ResourceID,
		DWORD	ulResourceTag,
		DWORD *	pulSize,
		DWORD	ulFlags
	)

Definition at line 5081 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_GetRootDeviceInstance()

DWORD WINAPI PNP_GetRootDeviceInstance	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		PNP_RPC_STRING_LEN	ulLength
	)

Definition at line 878 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetRootDeviceInstance(%p %S %lu)\n",
           hBinding, pDeviceID, ulLength);
 
    if (!pDeviceID)
    {
        ret = CR_INVALID_POINTER;
        goto Done;
    }
 
    if (ulLength < lstrlenW(szRootDeviceInstanceID) + 1)
    {
        ret = CR_BUFFER_SMALL;
        goto Done;
    }
 
    lstrcpyW(pDeviceID,
             szRootDeviceInstanceID);
 
Done:
    DPRINT("PNP_GetRootDeviceInstance() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Locate_DevNode_ExW().

PNP_GetServerSideDeviceInstallFlags()

DWORD WINAPI PNP_GetServerSideDeviceInstallFlags	(	handle_t	hBinding,
		DWORD *	pulSSDIFlags,
		DWORD	ulFlags
	)

Definition at line 5519 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT1("PNP_GetServerSideDeviceInstallFlags(%p %p %lu)\n",
            hBinding, pulSSDIFlags, ulFlags);
 
    if (pulSSDIFlags == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    /* FIXME */
    *pulSSDIFlags = 0;
 
    return CR_SUCCESS;
}

Referenced by CMP_GetServerSideDeviceInstallFlags().

PNP_GetVersion()

DWORD WINAPI PNP_GetVersion	(	handle_t	hBinding,
		WORD *	pVersion
	)

Definition at line 722 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_GetVersion(%p %p)\n",
           hBinding, pVersion);
 
    *pVersion = CONFIGMG_VERSION;
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Version_Ex(), CM_Is_Version_Available_Ex(), and CMP_WaitServicesAvailable().

PNP_GetVersionInternal()

DWORD WINAPI PNP_GetVersionInternal	(	handle_t	hBinding,
		WORD *	pwVersion
	)

Definition at line 5490 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
 
    *pwVersion = WINVER;
    return CR_SUCCESS;
}

PNP_HwProfFlags()

DWORD WINAPI PNP_HwProfFlags	(	handle_t	hBinding,
		DWORD	ulAction,
		LPWSTR	pDeviceID,
		DWORD	ulConfig,
		DWORD *	pulValue,
		PPNP_VETO_TYPE	pVetoType,
		LPWSTR	pszVetoName,
		DWORD	ulNameLength,
		DWORD	ulFlags
	)

Definition at line 4114 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    WCHAR szKeyName[MAX_PATH];
    HKEY hKey;
    HKEY hDeviceKey;
    DWORD dwSize;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_HwProfFlags() called\n");
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    if (ulConfig == 0)
    {
        wcscpy(szKeyName,
               L"System\\CurrentControlSet\\HardwareProfiles\\Current\\System\\CurrentControlSet\\Enum");
    }
    else
    {
        swprintf(szKeyName,
                 L"System\\CurrentControlSet\\HardwareProfiles\\%04lu\\System\\CurrentControlSet\\Enum",
                 ulConfig);
    }
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                      szKeyName,
                      0,
                      KEY_QUERY_VALUE,
                      &hKey) != ERROR_SUCCESS)
        return CR_REGISTRY_ERROR;
 
    if (ulAction == PNP_GET_HWPROFFLAGS)
    {
         if (RegOpenKeyExW(hKey,
                           pDeviceID,
                           0,
                           KEY_QUERY_VALUE,
                           &hDeviceKey) != ERROR_SUCCESS)
         {
            *pulValue = 0;
         }
         else
         {
             dwSize = sizeof(DWORD);
             if (RegQueryValueExW(hDeviceKey,
                                  L"CSConfigFlags",
                                  NULL,
                                  NULL,
                                  (LPBYTE)pulValue,
                                  &dwSize) != ERROR_SUCCESS)
             {
                 *pulValue = 0;
             }
 
             RegCloseKey(hDeviceKey);
         }
    }
    else if (ulAction == PNP_SET_HWPROFFLAGS)
    {
        /* FIXME: not implemented yet */
        ret = CR_CALL_NOT_IMPLEMENTED;
    }
 
    RegCloseKey(hKey);
 
    return ret;
}

Referenced by CM_Get_HW_Prof_Flags_ExW(), and CM_Set_HW_Prof_Flags_ExW().

PNP_InitDetection()

DWORD WINAPI PNP_InitDetection

(

handle_t

hBinding

)

Definition at line 765 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_InitDetection(%p)\n",
           hBinding);
 
    return CR_SUCCESS;
}

Referenced by CMP_Init_Detection().

PNP_InstallDevInst()

DWORD WINAPI PNP_InstallDevInst

(

handle_t

hBinding

)

Definition at line 5602 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_IsDockStationPresent()

CONFIGRET WINAPI PNP_IsDockStationPresent	(	handle_t	hBinding,
		BOOL *	Present
	)

Definition at line 4026 of file rpcserver.c.

{
    HKEY hKey;
    DWORD dwType;
    DWORD dwValue;
    DWORD dwSize;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT1("PNP_IsDockStationPresent(%p %p)\n",
            hBinding, Present);
 
    *Present = FALSE;
 
    if (RegOpenKeyExW(HKEY_CURRENT_CONFIG,
                      L"CurrentDockInfo",
                      0,
                      KEY_READ,
                      &hKey) != ERROR_SUCCESS)
        return CR_REGISTRY_ERROR;
 
    dwSize = sizeof(DWORD);
    if (RegQueryValueExW(hKey,
                         L"DockingState",
                         NULL,
                         &dwType,
                         (LPBYTE)&dwValue,
                         &dwSize) != ERROR_SUCCESS)
        ret = CR_REGISTRY_ERROR;
 
    RegCloseKey(hKey);
 
    if (ret == CR_SUCCESS)
    {
        if (dwType != REG_DWORD || dwSize != sizeof(DWORD))
        {
            ret = CR_REGISTRY_ERROR;
        }
        else if (dwValue != 0)
        {
            *Present = TRUE;
        }
    }
 
    DPRINT1("PNP_IsDockStationPresent() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Is_Dock_Station_Present_Ex().

PNP_ModifyResDes()

DWORD WINAPI PNP_ModifyResDes	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulLogConfTag,
		DWORD	ulLogConfType,
		RESOURCEID	CurrentResourceID,
		RESOURCEID	NewResourceID,
		DWORD	ulResourceTag,
		BYTE *	ResourceData,
		PNP_RPC_BUFFER_SIZE	ResourceLen,
		DWORD	ulFlags
	)

Definition at line 5099 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_NOTIFY_HANDLE_rundown()

VOID __RPC_USER PNP_NOTIFY_HANDLE_rundown

(

PNP_NOTIFY_HANDLE

pHandle

)

Definition at line 688 of file rpcserver.c.

{
    DPRINT1("PNP_NOTIFY_HANDLE_rundown(%p)\n", pHandle);
}

PNP_QueryArbitratorFreeData()

DWORD WINAPI PNP_QueryArbitratorFreeData	(	handle_t	hBinding,
		BYTE *	pData,
		DWORD	DataLen,
		LPWSTR	pDeviceID,
		RESOURCEID	ResourceID,
		DWORD	ulFlags
	)

Definition at line 5170 of file rpcserver.c.

{
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Query_Arbitrator_Free_Data_Ex().

PNP_QueryArbitratorFreeSize()

DWORD WINAPI PNP_QueryArbitratorFreeSize	(	handle_t	hBinding,
		DWORD *	pulSize,
		LPWSTR	pDeviceID,
		RESOURCEID	ResourceID,
		DWORD	ulFlags
	)

Definition at line 5185 of file rpcserver.c.

{
    if (pulSize != NULL)
        *pulSize = 0;
 
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Query_Arbitrator_Free_Size_Ex().

PNP_QueryRemove()

DWORD WINAPI PNP_QueryRemove	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		PPNP_VETO_TYPE	pVetoType,
		LPWSTR	pszVetoName,
		DWORD	ulNameLength,
		DWORD	ulFlags
	)

Definition at line 3929 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_QUERY_REMOVE_DATA PlugPlayData;
    NTSTATUS Status;
    DWORD ret = CR_SUCCESS;
 
    DPRINT1("PNP_QueryRemove(%p %S %p %p %lu 0x%lx)\n",
            hBinding, pszDeviceID, pVetoType, pszVetoName,
            ulNameLength, ulFlags);
 
    if (ulFlags & ~CM_REMOVE_BITS)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pszDeviceID) ||
        IsRootDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    if (pVetoType != NULL)
        *pVetoType = PNP_VetoTypeUnknown;
 
    if (pszVetoName != NULL && ulNameLength > 0)
        *pszVetoName = UNICODE_NULL;
 
    RtlZeroMemory(&PlugPlayData, sizeof(PlugPlayData));
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
    PlugPlayData.VetoName = pszVetoName;
    PlugPlayData.NameLength = ulNameLength;
//    PlugPlayData.Flags =
 
    Status = NtPlugPlayControl(PlugPlayControlQueryAndRemoveDevice,
                               &PlugPlayData,
                               sizeof(PlugPlayData));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by CM_Query_And_Remove_SubTree_ExW().

PNP_QueryResConfList()

DWORD WINAPI PNP_QueryResConfList	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		RESOURCEID	ResourceID,
		BYTE *	ResourceData,
		PNP_RPC_BUFFER_SIZE	ResourceLen,
		BYTE *	Buffer,
		PNP_RPC_BUFFER_SIZE	BufferLen,
		DWORD	ulFlags
	)

Definition at line 5140 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Query_Resource_Conflict_List().

PNP_RegisterDeviceClassAssociation()

DWORD WINAPI PNP_RegisterDeviceClassAssociation	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		GUID *	InterfaceGuid,
		LPWSTR	pszReference,
		LPWSTR	pszSymLink,
		PNP_RPC_STRING_LEN *	pulLength,
		PNP_RPC_STRING_LEN *	pulTransferLen,
		DWORD	ulFlags
	)

Definition at line 2801 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA PlugPlayData;
    NTSTATUS Status;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT1("PNP_RegisterDeviceClassAssociation(%p %S %p %S %S %p %p 0x%08lx)\n",
           hBinding, pszDeviceID, InterfaceGuid, pszReference, pszSymLink,
           pulLength, pulTransferLen, ulFlags);
 
    if ((InterfaceGuid == NULL) ||
        (pszSymLink == NULL) ||
        (pulLength == NULL) ||
        (pulTransferLen == NULL))
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance, pszDeviceID);
    PlugPlayData.InterfaceGuid = InterfaceGuid;
    RtlInitUnicodeString(&PlugPlayData.Reference, pszReference);
    PlugPlayData.Register = TRUE;
    PlugPlayData.SymbolicLinkName = pszSymLink;
    PlugPlayData.SymbolicLinkNameLength = *pulLength;
 
    Status = NtPlugPlayControl(PlugPlayControlDeviceClassAssociation,
                               &PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA));
    if (NT_SUCCESS(Status))
    {
        *pulLength = PlugPlayData.SymbolicLinkNameLength;
        *pulTransferLen = *pulLength;
    }
    else
    {
        *pulLength = 0;
        ret = NtStatusToCrError(Status);
    }
 
    return ret;
}

Referenced by CM_Register_Device_Interface_ExW().

PNP_RegisterDriver()

DWORD WINAPI PNP_RegisterDriver	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		DWORD	ulFlags
	)

Definition at line 3906 of file rpcserver.c.

{
    DPRINT("PNP_RegisterDriver(%p %S 0x%lx)\n",
           hBinding, pszDeviceID, ulFlags);
 
    if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    SetDeviceStatus(pszDeviceID, 0, 0);
 
    return CR_SUCCESS;
}

Referenced by CM_Register_Device_Driver_Ex().

PNP_RegisterNotification()

DWORD WINAPI PNP_RegisterNotification	(	handle_t	hBinding,
		DWORD_PTR	hRecipient,
		LPWSTR	pszName,
		BYTE *	pNotificationFilter,
		DWORD	ulNotificationFilterSize,
		DWORD	ulFlags,
		PNP_NOTIFY_HANDLE *	pNotifyHandle,
		DWORD	ulProcessId,
		DWORD *	pulUnknown9
	)

Definition at line 5213 of file rpcserver.c.

{
    PDEV_BROADCAST_DEVICEINTERFACE_W pBroadcastDeviceInterface;
    PDEV_BROADCAST_HANDLE pBroadcastDeviceHandle;
    PNOTIFY_ENTRY pNotifyData = NULL;
    DWORD ret = CR_SUCCESS;
 
    DPRINT1("PNP_RegisterNotification(%p %p '%S' %p %lu 0x%lx %p %lx %p)\n",
           hBinding, hRecipient, pszName, pNotificationFilter,
           ulNotificationFilterSize, ulFlags, pNotifyHandle, ulProcessId, pulUnknown9);
 
    if (pNotifyHandle == NULL)
        return CR_INVALID_POINTER;
 
    *pNotifyHandle = NULL;
 
    if (pNotificationFilter == NULL ||
        pulUnknown9 == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~0x7)
        return CR_INVALID_FLAG;
 
    if ((ulNotificationFilterSize < sizeof(DEV_BROADCAST_HDR)) ||
        (((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_size < sizeof(DEV_BROADCAST_HDR)))
        return CR_INVALID_DATA;
 
    if (((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
    {
        DPRINT1("DBT_DEVTYP_DEVICEINTERFACE\n");
        pBroadcastDeviceInterface = (PDEV_BROADCAST_DEVICEINTERFACE_W)pNotificationFilter;
 
        if ((ulNotificationFilterSize < sizeof(DEV_BROADCAST_DEVICEINTERFACE_W)) ||
            (pBroadcastDeviceInterface->dbcc_size < sizeof(DEV_BROADCAST_DEVICEINTERFACE_W)))
            return CR_INVALID_DATA;
 
        pNotifyData = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NOTIFY_ENTRY));
        if (pNotifyData == NULL)
        {
            ret = CR_OUT_OF_MEMORY;
            goto done;
        }
 
        pNotifyData->dwType = CLASS_NOTIFICATION;
 
        if (pszName != NULL)
        {
            pNotifyData->pszName = RtlAllocateHeap(GetProcessHeap(),
                                                   HEAP_ZERO_MEMORY,
                                                   (wcslen(pszName) + 1) * sizeof(WCHAR));
            if (pNotifyData->pszName == NULL)
            {
                ret = CR_OUT_OF_MEMORY;
                goto done;
            }
 
            wcscpy(pNotifyData->pszName, pszName);
        }
 
        if ((ulFlags & DEVICE_NOTIFY_SERVICE_HANDLE) == DEVICE_NOTIFY_WINDOW_HANDLE)
        {
            pNotifyData->hRecipient = hRecipient;
        }
        else
        {
            DPRINT("Validate service: %S\n", pszName);
            if (I_ScValidatePnpService(NULL,
                                       pszName,
                                       (SERVICE_STATUS_HANDLE *)&pNotifyData->hRecipient) != ERROR_SUCCESS)
            {
                DPRINT1("I_ScValidatePnpService failed!\n");
                ret = CR_INVALID_DATA;
                goto done;
            }
 
            DPRINT("Service status handle: %p\n", pNotifyData->hRecipient);
        }
 
        pNotifyData->ulFlags = ulFlags;
 
        if ((ulFlags & DEVICE_NOTIFY_ALL_INTERFACE_CLASSES) == 0)
        {
            CopyMemory(&pNotifyData->ClassGuid,
                       &pBroadcastDeviceInterface->dbcc_classguid,
                       sizeof(GUID));
        }
 
        /* Add the entry to the notification list */
        RtlAcquireResourceExclusive(&NotificationListLock, TRUE);
        InsertTailList(&NotificationListHead, &pNotifyData->ListEntry);
        RtlReleaseResource(&NotificationListLock);
 
        DPRINT("pNotifyData: %p\n", pNotifyData);
        *pNotifyHandle = (PNP_NOTIFY_HANDLE)pNotifyData;
    }
    else if (((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_devicetype == DBT_DEVTYP_HANDLE)
    {
        DPRINT1("DBT_DEVTYP_HANDLE\n");
        pBroadcastDeviceHandle = (PDEV_BROADCAST_HANDLE)pNotificationFilter;
 
        if ((ulNotificationFilterSize < sizeof(DEV_BROADCAST_HANDLE)) ||
            (pBroadcastDeviceHandle->dbch_size < sizeof(DEV_BROADCAST_HANDLE)))
        {
            ret = CR_INVALID_DATA;
            goto done;
        }
 
        if (ulFlags & DEVICE_NOTIFY_ALL_INTERFACE_CLASSES)
        {
            ret = CR_INVALID_FLAG;
            goto done;
        }
 
        /* FIXME */
    }
    else
    {
        DPRINT1("Invalid device type %lu\n", ((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_devicetype);
        ret = CR_INVALID_DATA;
    }
 
done:
    if (ret != CR_SUCCESS)
    {
        if (pNotifyData)
        {
            if (pNotifyData->pszName)
                RtlFreeHeap(GetProcessHeap(), 0, pNotifyData->pszName);
 
            RtlFreeHeap(GetProcessHeap(), 0, pNotifyData);
        }
    }
 
    return ret;
}

Referenced by CMP_RegisterNotification().

PNP_RegisterServiceNotification()

DWORD WINAPI PNP_RegisterServiceNotification

(

handle_t

hBinding

)

Definition at line 5646 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_ReportLogOn()

DWORD WINAPI PNP_ReportLogOn	(	handle_t	hBinding,
		BOOL	Admin,
		DWORD	ProcessId
	)

Definition at line 780 of file rpcserver.c.

{
    DWORD ReturnValue = CR_FAILURE;
    HANDLE hProcess = NULL;
 
    UNREFERENCED_PARAMETER(Admin);
 
    DPRINT("PNP_ReportLogOn(%p %u, %u)\n",
           hBinding, Admin, ProcessId);
 
    /* Fail, if the caller is not an interactive user */
    if ((g_IsLiveMedium == FALSE) && (IsCallerInteractive(hBinding) == FALSE))
        goto cleanup;
 
    /* Get the users token */
    hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, ProcessId);
 
    if (!hProcess)
    {
        DPRINT1("OpenProcess failed with error %u\n", GetLastError());
        goto cleanup;
    }
 
    if (hUserToken)
    {
        CloseHandle(hUserToken);
        hUserToken = NULL;
    }
 
    if (!OpenProcessToken(hProcess, TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_QUERY, &hUserToken))
    {
        DPRINT1("OpenProcessToken failed with error %u\n", GetLastError());
        goto cleanup;
    }
 
    /* Trigger the installer thread */
    if (hInstallEvent)
        SetEvent(hInstallEvent);
 
    ReturnValue = CR_SUCCESS;
 
cleanup:
    if (hProcess)
        CloseHandle(hProcess);
 
    return ReturnValue;
}

Referenced by CMP_Report_LogOn().

PNP_RequestDeviceEject()

DWORD WINAPI PNP_RequestDeviceEject	(	handle_t	hBinding,
		LPWSTR	pszDeviceID,
		PPNP_VETO_TYPE	pVetoType,
		LPWSTR	pszVetoName,
		DWORD	ulNameLength,
		DWORD	ulFlags
	)

Definition at line 3978 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_QUERY_REMOVE_DATA PlugPlayData;
    NTSTATUS Status;
    DWORD ret = CR_SUCCESS;
 
    DPRINT1("PNP_RequestDeviceEject(%p %S %p %p %lu 0x%lx)\n",
            hBinding, pszDeviceID, pVetoType, pszVetoName,
            ulNameLength, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pszDeviceID))
        return CR_INVALID_DEVINST;
 
    if (pVetoType != NULL)
        *pVetoType = PNP_VetoTypeUnknown;
 
    if (pszVetoName != NULL && ulNameLength > 0)
        *pszVetoName = UNICODE_NULL;
 
    RtlZeroMemory(&PlugPlayData, sizeof(PlugPlayData));
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
    PlugPlayData.VetoName = pszVetoName;
    PlugPlayData.NameLength = ulNameLength;
//    PlugPlayData.Flags =
 
    Status = NtPlugPlayControl(PlugPlayControlQueryAndRemoveDevice,
                               &PlugPlayData,
                               sizeof(PlugPlayData));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by CM_Request_Device_Eject_ExW(), and PNP_RequestEjectPC().

PNP_RequestEjectPC()

DWORD WINAPI PNP_RequestEjectPC

(

handle_t

hBinding

)

Definition at line 4082 of file rpcserver.c.

{
    WCHAR szDockDeviceInstance[MAX_DEVICE_ID_LEN];
    PLUGPLAY_CONTROL_RETRIEVE_DOCK_DATA DockData;
    NTSTATUS Status;
 
    DPRINT("PNP_RequestEjectPC(%p)\n", hBinding);
 
    /* Retrieve the dock device */
    DockData.DeviceInstanceLength = ARRAYSIZE(szDockDeviceInstance);
    DockData.DeviceInstance = szDockDeviceInstance;
 
    Status = NtPlugPlayControl(PlugPlayControlRetrieveDock,
                               &DockData,
                               sizeof(DockData));
    if (!NT_SUCCESS(Status))
        return NtStatusToCrError(Status);
 
    /* Eject the dock device */
    return PNP_RequestDeviceEject(hBinding,
                                  szDockDeviceInstance,
                                  NULL,
                                  NULL,
                                  0,
                                  0);
}

Referenced by CM_Request_Eject_PC_Ex().

PNP_RunDetection()

CONFIGRET WINAPI PNP_RunDetection	(	handle_t	hBinding,
		DWORD	ulFlags
	)

Definition at line 5202 of file rpcserver.c.

{
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Run_Detection_Ex().

PNP_SetActiveService()

DWORD WINAPI PNP_SetActiveService	(	handle_t	hBinding,
		LPWSTR	pszFilter,
		DWORD	ulFlags
	)

Definition at line 5657 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_SetClassRegProp()

DWORD WINAPI PNP_SetClassRegProp	(	handle_t	hBinding,
		LPWSTR	pszClassGuid,
		DWORD	ulProperty,
		DWORD	ulDataType,
		BYTE *	Buffer,
		PNP_PROP_SIZE	ulLength,
		DWORD	ulFlags
	)

Definition at line 3025 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    LPWSTR lpValueName = NULL;
    HKEY hInstKey = 0;
    HKEY hPropKey = 0;
    LONG lError;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT("PNP_SetClassRegProp(%p %S %lu %lu %p %lu 0x%08lx)\n",
           hBinding, pszClassGuid, ulProperty, ulDataType,
           Buffer, ulLength, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    switch (ulProperty)
    {
        case CM_CRP_SECURITY:
            lpValueName = L"Security";
            break;
 
        case CM_CRP_DEVTYPE:
            lpValueName = L"DeviceType";
            break;
 
        case CM_CRP_EXCLUSIVE:
            lpValueName = L"Exclusive";
            break;
 
        case CM_CRP_CHARACTERISTICS:
            lpValueName = L"DeviceCharacteristics";
            break;
 
        default:
            return CR_INVALID_PROPERTY;
    }
 
    lError = RegOpenKeyExW(hClassKey,
                           pszClassGuid,
                           0,
                           KEY_WRITE,
                           &hInstKey);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_NO_SUCH_REGISTRY_KEY;
        goto done;
    }
 
    /* FIXME: Set security descriptor */
    lError = RegCreateKeyExW(hInstKey,
                             L"Properties",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_ALL_ACCESS,
                             NULL,
                             &hPropKey,
                             NULL);
    if (lError != ERROR_SUCCESS)
    {
        ret = CR_REGISTRY_ERROR;
        goto done;
    }
 
    if (ulLength == 0)
    {
        if (RegDeleteValueW(hPropKey,
                            lpValueName))
            ret = CR_REGISTRY_ERROR;
    }
    else
    {
        if (RegSetValueExW(hPropKey,
                           lpValueName,
                           0,
                           ulDataType,
                           Buffer,
                           ulLength))
            ret = CR_REGISTRY_ERROR;
    }
 
done:
    if (hPropKey != NULL)
        RegCloseKey(hPropKey);
 
    if (hInstKey != NULL)
        RegCloseKey(hInstKey);
 
    return ret;
}

Referenced by CM_Set_Class_Registry_PropertyW().

PNP_SetDeviceProblem()

DWORD WINAPI PNP_SetDeviceProblem	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulProblem,
		DWORD	ulFlags
	)

Definition at line 3661 of file rpcserver.c.

{
    ULONG ulOldStatus, ulOldProblem;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT1("PNP_SetDeviceProblem(%p %S %lu 0x%08lx)\n",
           hBinding, pDeviceID, ulProblem, ulFlags);
 
    if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
        return CR_INVALID_FLAG;
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    ret = GetDeviceStatus(pDeviceID,
                          &ulOldStatus,
                          &ulOldProblem);
    if (ret != CR_SUCCESS)
        return ret;
 
    if (((ulFlags & CM_SET_DEVNODE_PROBLEM_OVERRIDE) == 0) &&
        (ulOldProblem != 0) &&
        (ulOldProblem != ulProblem))
    {
        return CR_FAILURE;
    }
 
    if (ulProblem == 0)
    {
        ret = ClearDeviceStatus(pDeviceID,
                                DN_HAS_PROBLEM,
                                ulOldProblem);
    }
    else
    {
        ret = SetDeviceStatus(pDeviceID,
                              DN_HAS_PROBLEM,
                              ulProblem);
    }
 
    return ret;
}

Referenced by CM_Set_DevNode_Problem_Ex().

PNP_SetDeviceRegProp()

DWORD WINAPI PNP_SetDeviceRegProp	(	handle_t	hBinding,
		LPWSTR	pDeviceId,
		DWORD	ulProperty,
		DWORD	ulDataType,
		BYTE *	Buffer,
		PNP_PROP_SIZE	ulLength,
		DWORD	ulFlags
	)

Definition at line 2180 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    LPWSTR lpValueName = NULL;
    HKEY hKey = 0;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_SetDeviceRegProp(%p %S %lu %lu %p %lu 0x%08lx)\n",
           hBinding, pDeviceId, ulProperty, ulDataType, Buffer,
           ulLength, ulFlags);
 
    if (!IsValidDeviceInstanceID(pDeviceId))
        return CR_INVALID_DEVINST;
 
    switch (ulProperty)
    {
        case CM_DRP_DEVICEDESC:
            lpValueName = L"DeviceDesc";
            break;
 
        case CM_DRP_HARDWAREID:
            lpValueName = L"HardwareID";
            break;
 
        case CM_DRP_COMPATIBLEIDS:
            lpValueName = L"CompatibleIDs";
            break;
 
        case CM_DRP_SERVICE:
            lpValueName = L"Service";
            break;
 
        case CM_DRP_CLASS:
            lpValueName = L"Class";
            break;
 
        case CM_DRP_CLASSGUID:
            lpValueName = L"ClassGUID";
            break;
 
        case CM_DRP_DRIVER:
            lpValueName = L"Driver";
            break;
 
        case CM_DRP_CONFIGFLAGS:
            lpValueName = L"ConfigFlags";
            break;
 
        case CM_DRP_MFG:
            lpValueName = L"Mfg";
            break;
 
        case CM_DRP_FRIENDLYNAME:
            lpValueName = L"FriendlyName";
            break;
 
        case CM_DRP_LOCATION_INFORMATION:
            lpValueName = L"LocationInformation";
            break;
 
        case CM_DRP_UPPERFILTERS:
            lpValueName = L"UpperFilters";
            break;
 
        case CM_DRP_LOWERFILTERS:
            lpValueName = L"LowerFilters";
            break;
 
        case CM_DRP_SECURITY:
            lpValueName = L"Security";
            break;
 
        case CM_DRP_DEVTYPE:
            lpValueName = L"DeviceType";
            break;
 
        case CM_DRP_EXCLUSIVE:
            lpValueName = L"Exclusive";
            break;
 
        case CM_DRP_CHARACTERISTICS:
            lpValueName = L"DeviceCharacteristics";
            break;
 
        case CM_DRP_UI_NUMBER_DESC_FORMAT:
            lpValueName = L"UINumberDescFormat";
            break;
 
        case CM_DRP_REMOVAL_POLICY_OVERRIDE:
            lpValueName = L"RemovalPolicy";
            break;
 
        default:
            return CR_INVALID_PROPERTY;
    }
 
    DPRINT("Value name: %S\n", lpValueName);
 
    if (RegOpenKeyExW(hEnumKey,
                      pDeviceId,
                      0,
                      KEY_SET_VALUE,
                      &hKey))
        return CR_INVALID_DEVNODE;
 
    if (ulLength == 0)
    {
        if (RegDeleteValueW(hKey,
                            lpValueName))
            ret = CR_REGISTRY_ERROR;
    }
    else
    {
        if (RegSetValueExW(hKey,
                           lpValueName,
                           0,
                           ulDataType,
                           Buffer,
                           ulLength))
            ret = CR_REGISTRY_ERROR;
    }
 
    RegCloseKey(hKey);
 
    DPRINT("PNP_SetDeviceRegProp() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Set_DevNode_Registry_Property_ExW(), and PNP_GetClassInstance().

PNP_SetHwProf()

DWORD WINAPI PNP_SetHwProf	(	handle_t	hBinding,
		DWORD	ulHardwareProfile,
		DWORD	ulFlags
	)

Definition at line 5158 of file rpcserver.c.

{
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Set_HW_Prof_Ex().

PNP_SetObjectProp()

DWORD WINAPI PNP_SetObjectProp	(	handle_t	hBinding,
		LPWSTR	ObjectName,
		DWORD	ObjectType,
		LPWSTR	PropertyCultureName,
		const DEVPROPKEY *	PropertyKey,
		DEVPROPTYPE	PropertyType,
		PNP_PROP_SIZE	PropertySize,
		BYTE *	PropertyBuffer,
		DWORD	Flags
	)

Definition at line 5583 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_UninstallDevInst()

DWORD WINAPI PNP_UninstallDevInst	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulFlags
	)

Definition at line 3744 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Uninstall_DevNode_Ex().

PNP_UnregisterDeviceClassAssociation()

DWORD WINAPI PNP_UnregisterDeviceClassAssociation	(	handle_t	hBinding,
		LPWSTR	pszInterfaceDevice,
		DWORD	ulFlags
	)

Definition at line 2861 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA PlugPlayData;
    NTSTATUS Status;
    CONFIGRET ret = CR_SUCCESS;
 
    UNREFERENCED_PARAMETER(hBinding);
 
    DPRINT1("PNP_UnregisterDeviceClassAssociation(%p %S 0x%08lx)\n",
           hBinding, pszInterfaceDevice, ulFlags);
 
    if (pszInterfaceDevice == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    ZeroMemory(&PlugPlayData, sizeof(PlugPlayData));
    PlugPlayData.Register = FALSE;
    PlugPlayData.SymbolicLinkName = pszInterfaceDevice;
    PlugPlayData.SymbolicLinkNameLength = wcslen(pszInterfaceDevice) + 1;
 
    Status = NtPlugPlayControl(PlugPlayControlDeviceClassAssociation,
                               &PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by CM_Unregister_Device_Interface_ExW().

PNP_UnregisterNotification()

DWORD WINAPI PNP_UnregisterNotification	(	handle_t	hBinding,
		PNP_NOTIFY_HANDLE *	pNotifyHandle
	)

Definition at line 5362 of file rpcserver.c.

{
    PNOTIFY_ENTRY pEntry;
 
    DPRINT1("PNP_UnregisterNotification(%p %p)\n",
           hBinding, pNotifyHandle);
 
    pEntry = (PNOTIFY_ENTRY)*pNotifyHandle;
    if (pEntry == NULL)
        return CR_INVALID_DATA;
 
    RtlAcquireResourceExclusive(&NotificationListLock, TRUE);
    RemoveEntryList(&pEntry->ListEntry);
    RtlReleaseResource(&NotificationListLock);
 
    if (pEntry->pszName)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pEntry->pszName);
    RtlFreeHeap(RtlGetProcessHeap(), 0, pEntry);
    *pNotifyHandle = NULL;
 
    return CR_SUCCESS;
}

Referenced by CMP_UnregisterNotification().

PNP_ValidateDeviceInstance()

DWORD WINAPI PNP_ValidateDeviceInstance	(	handle_t	hBinding,
		LPWSTR	pDeviceID,
		DWORD	ulFlags
	)

Definition at line 835 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;
    HKEY hDeviceKey = NULL;
 
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);
 
    DPRINT("PNP_ValidateDeviceInstance(%p %S 0x%08lx)\n",
           hBinding, pDeviceID, ulFlags);
 
    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;
 
    if (RegOpenKeyExW(hEnumKey,
                      pDeviceID,
                      0,
                      KEY_READ,
                      &hDeviceKey))
    {
        DPRINT("Could not open the Device Key!\n");
        ret = CR_NO_SUCH_DEVNODE;
        goto Done;
    }
 
    /* FIXME: add more tests */
 
Done:
    if (hDeviceKey != NULL)
        RegCloseKey(hDeviceKey);
 
    DPRINT("PNP_ValidateDeviceInstance() done (returns %lx)\n", ret);
 
    return ret;
}

Referenced by CM_Locate_DevNode_ExW().

ReenumerateDeviceInstance()

static CONFIGRET ReenumerateDeviceInstance ( _In_ LPWSTR  pszDeviceInstance, _In_ ULONG  ulMinorAction  )

static

Definition at line 3502 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA EnumerateDeviceData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT1("ReenumerateDeviceInstance(%S 0x%08lx)\n",
           pszDeviceInstance, ulMinorAction);
 
    if (ulMinorAction & ~CM_REENUMERATE_BITS)
        return CR_INVALID_FLAG;
 
    if (ulMinorAction & CM_REENUMERATE_RETRY_INSTALLATION)
    {
        DPRINT1("CM_REENUMERATE_RETRY_INSTALLATION not implemented!\n");
    }
 
    RtlInitUnicodeString(&EnumerateDeviceData.DeviceInstance,
                         pszDeviceInstance);
    EnumerateDeviceData.Flags = 0;
 
    Status = NtPlugPlayControl(PlugPlayControlEnumerateDevice,
                               &EnumerateDeviceData,
                               sizeof(PLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by PNP_DeviceInstanceAction().

RpcServerThread()

DWORD WINAPI RpcServerThread

(

LPVOID

lpParameter

)

Definition at line 48 of file rpcserver.c.

{
    RPC_STATUS Status;
    BOOLEAN RegisteredProtSeq = FALSE;
 
    UNREFERENCED_PARAMETER(lpParameter);
 
    DPRINT("RpcServerThread() called\n");
 
    InitializeListHead(&NotificationListHead);
    RtlInitializeResource(&NotificationListLock);
 
#if 0
    /* 2k/XP/2k3-compatible protocol sequence/endpoint */
    Status = RpcServerUseProtseqEpW(L"ncacn_np",
                                    20,
                                    L"\\pipe\\ntsvcs",
                                    NULL);  // Security descriptor
    if (Status == RPC_S_OK)
        RegisteredProtSeq = TRUE;
    else
        DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
#endif
 
    /* Vista/7-compatible protocol sequence/endpoint */
    Status = RpcServerUseProtseqEpW(L"ncacn_np",
                                    20,
                                    L"\\pipe\\plugplay",
                                    NULL);  // Security descriptor
    if (Status == RPC_S_OK)
        RegisteredProtSeq = TRUE;
    else
        DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
 
    /* Make sure there's a usable endpoint */
    if (RegisteredProtSeq == FALSE)
        return 0;
 
    Status = RpcServerRegisterIf(pnp_v1_0_s_ifspec,
                                 NULL,
                                 NULL);
    if (Status != RPC_S_OK)
    {
        DPRINT1("RpcServerRegisterIf() failed (Status %lx)\n", Status);
        return 0;
    }
 
    Status = RpcServerListen(1,
                             20,
                             FALSE);
    if (Status != RPC_S_OK)
    {
        DPRINT1("RpcServerListen() failed (Status %lx)\n", Status);
        return 0;
    }
 
    /* ROS HACK (this should never happen...) */
    DPRINT1("*** Other devices won't be installed correctly. If something\n");
    DPRINT1("*** doesn't work, try to reboot to get a new chance.\n");
 
    DPRINT("RpcServerThread() done\n");
 
    return 0;
}

Referenced by ServiceMain().

SetDeviceStatus()

static CONFIGRET SetDeviceStatus ( _In_ LPWSTR  pszDeviceID, _In_ DWORD  ulStatus, _In_ DWORD  ulProblem  )

static

Definition at line 267 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT1("SetDeviceStatus(%S 0x%lx 0x%lx)\n",
            pszDeviceID, ulStatus, ulProblem);
 
    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pszDeviceID);
    PlugPlayData.Operation = PNP_SET_DEVICE_STATUS;
    PlugPlayData.DeviceStatus = ulStatus;
    PlugPlayData.DeviceProblem = ulProblem;
 
    Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
                               (PVOID)&PlugPlayData,
                               sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
    return ret;
}

Referenced by PNP_RegisterDriver(), and PNP_SetDeviceProblem().

SetupDeviceInstance()

static CONFIGRET SetupDeviceInstance ( _In_ LPWSTR  pszDeviceInstance, _In_ DWORD  ulMinorAction  )

static

Definition at line 3400 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEVICE_CONTROL_DATA ControlData;
    HKEY hDeviceKey = NULL;
    DWORD dwDisableCount, dwSize;
    DWORD ulStatus, ulProblem;
    DWORD dwError;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;
 
    DPRINT1("SetupDeviceInstance(%S 0x%08lx)\n",
            pszDeviceInstance, ulMinorAction);
 
    if (IsRootDeviceInstanceID(pszDeviceInstance))
        return CR_INVALID_DEVINST;
 
    if (ulMinorAction & ~CM_SETUP_BITS)
        return CR_INVALID_FLAG;
 
    if ((ulMinorAction == CM_SETUP_DOWNLOAD) ||
        (ulMinorAction == CM_SETUP_WRITE_LOG_CONFS))
        return CR_SUCCESS;
 
    dwError = RegOpenKeyExW(hEnumKey,
                            pszDeviceInstance,
                            0,
                            KEY_READ,
                            &hDeviceKey);
    if (dwError != ERROR_SUCCESS)
        return CR_INVALID_DEVNODE;
 
    dwSize = sizeof(dwDisableCount);
    dwError = RegQueryValueExW(hDeviceKey,
                               L"DisableCount",
                               NULL,
                               NULL,
                               (LPBYTE)&dwDisableCount,
                               &dwSize);
    if ((dwError == ERROR_SUCCESS) &&
        (dwDisableCount > 0))
    {
        goto done;
    }
 
    GetDeviceStatus(pszDeviceInstance,
                    &ulStatus,
                    &ulProblem);
 
    if (ulStatus & DN_STARTED)
    {
        goto done;
    }
 
    if (ulStatus & DN_HAS_PROBLEM)
    {
        ret = ClearDeviceStatus(pszDeviceInstance,
                                DN_HAS_PROBLEM,
                                ulProblem);
    }
 
    if (ret != CR_SUCCESS)
        goto done;
 
    /* Start the device */
    RtlInitUnicodeString(&ControlData.DeviceInstance,
                         pszDeviceInstance);
    Status = NtPlugPlayControl(PlugPlayControlStartDevice,
                               &ControlData,
                               sizeof(PLUGPLAY_CONTROL_DEVICE_CONTROL_DATA));
    if (!NT_SUCCESS(Status))
        ret = NtStatusToCrError(Status);
 
done:
    if (hDeviceKey != NULL)
        RegCloseKey(hDeviceKey);
 
    return ret;
}

Referenced by PNP_DeviceInstanceAction().

SplitDeviceInstanceID()

static VOID SplitDeviceInstanceID ( IN LPWSTR  pszDeviceInstanceID, OUT LPWSTR  pszEnumerator, OUT LPWSTR  pszDevice, OUT LPWSTR  pszInstance  )

static

Definition at line 156 of file rpcserver.c.

{
    WCHAR szLocalDeviceInstanceID[MAX_DEVICE_ID_LEN];
    LPWSTR lpEnumerator = NULL;
    LPWSTR lpDevice = NULL;
    LPWSTR lpInstance = NULL;
    LPWSTR ptr;
 
    wcscpy(szLocalDeviceInstanceID, pszDeviceInstanceID);
 
    *pszEnumerator = 0;
    *pszDevice = 0;
    *pszInstance = 0;
 
    lpEnumerator = szLocalDeviceInstanceID;
 
    ptr = wcschr(lpEnumerator, L'\\');
    if (ptr != NULL)
    {
        *ptr = 0;
        lpDevice = ++ptr;
 
        ptr = wcschr(lpDevice, L'\\');
        if (ptr != NULL)
        {
            *ptr = 0;
            lpInstance = ++ptr;
        }
    }
 
    if (lpEnumerator != NULL)
        wcscpy(pszEnumerator, lpEnumerator);
 
    if (lpDevice != NULL)
        wcscpy(pszDevice, lpDevice);
 
    if (lpInstance != NULL)
        wcscpy(pszInstance, lpInstance);
}

Referenced by CreateDeviceInstance(), PNP_GetDeviceList(), and PNP_GetDeviceListSize().

Variable Documentation

LoadDriverPrivilege

LUID LoadDriverPrivilege = {SE_LOAD_DRIVER_PRIVILEGE, 0}

Definition at line 40 of file rpcserver.c.

NotificationListHead

LIST_ENTRY NotificationListHead

Definition at line 42 of file rpcserver.c.

Referenced by PNP_RegisterNotification(), ProcessDeviceClassChangeEvent(), and RpcServerThread().

NotificationListLock

RTL_RESOURCE NotificationListLock

Definition at line 43 of file rpcserver.c.

Referenced by PNP_RegisterNotification(), PNP_UnregisterNotification(), ProcessDeviceClassChangeEvent(), and RpcServerThread().

szRootDeviceInstanceID

WCHAR szRootDeviceInstanceID[] = L"HTREE\\ROOT\\0"

static

Definition at line 39 of file rpcserver.c.

Referenced by IsRootDeviceInstanceID(), PNP_GetRelatedDeviceInstance(), and PNP_GetRootDeviceInstance().