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 CONFIGRET	OpenConfigurationKey (_In_ LPCWSTR pszDeviceID, _Out_ PHKEY phKey)
static CONFIGRET	GetConfigurationData (_In_ HKEY hKey, _In_ ULONG ulLogConfType, _Out_ PULONG pulRegDataType, _Out_ PULONG pulDataSize, _Out_ LPBYTE *ppBuffer)
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 (LPWSTR pszDeviceID)
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 ulUnknown2, LPWSTR pszName, BYTE *pNotificationFilter, DWORD ulNotificationFilterSize, DWORD ulFlags, DWORD *pulNotify, DWORD ulUnknown8, DWORD *pulUnknown9)
DWORD WINAPI	PNP_UnregisterNotification (handle_t hBinding, DWORD ulNotify)
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"

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 3382 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 3361 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 196 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 ( LPWSTR  pszDeviceID )

static

Definition at line 2831 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;
    }

    /* 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 291 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 3089 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().

GetAllInstanceList()

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

static

Definition at line 1173 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 1558 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  )

static

Definition at line 459 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;
    }

    /* 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_GetFirstLogConf(), PNP_GetNextLogConf(), and PNP_GetNextResDes().

GetDeviceInstanceList()

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

static

Definition at line 1031 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 1445 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 226 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_(), PNP_GetDeviceStatus(), PNP_SetDeviceProblem(), and SetupDeviceInstance().

GetEnumeratorInstanceList()

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

Definition at line 1102 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 1497 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 861 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 1296 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 912 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 1346 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().

IsRootDeviceInstanceID()

static BOOL IsRootDeviceInstanceID ( _In_ PWSTR  pszDeviceInstanceID )

static

Definition at line 403 of file rpcserver.c.

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

    return FALSE;
}

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

IsValidDeviceInstanceID()

static BOOL IsValidDeviceInstanceID ( _In_ PWSTR  pszDeviceInstanceID )

static

Definition at line 337 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_CreateKey(), PNP_DisableDevInst(), 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_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 108 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 114 of file rpcserver.c.

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

NtStatusToCrError()

static CONFIGRET WINAPI NtStatusToCrError ( NTSTATUS  Status )

static

Definition at line 121 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_GetInterfaceDeviceList(), PNP_GetInterfaceDeviceListSize(), PNP_GetRelatedDeviceInstance(), PNP_QueryRemove(), PNP_RequestDeviceEject(), PNP_RequestEjectPC(), ReenumerateDeviceInstance(), SetDeviceStatus(), and SetupDeviceInstance().

OpenConfigurationKey()

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

static

Definition at line 415 of file rpcserver.c.

{
    WCHAR szKeyName[MAX_PATH];
    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;

    /* Create or open the LogConf key */
    dwError = RegCreateKeyExW(hInstanceKey,
                              L"LogConf",
                              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_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 3939 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

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 3405 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 4174 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_ApplyPowerSettings()

DWORD WINAPI PNP_ApplyPowerSettings

(

handle_t

hBinding

)

Definition at line 4776 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_Connect()

DWORD WINAPI PNP_Connect

(

handle_t

hBinding

)

Definition at line 554 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 2939 of file rpcserver.c.

{
    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)
    {
        WCHAR szGeneratedInstance[MAX_DEVICE_ID_LEN];
        DWORD dwInstanceNumber;

        /* Generated ID is: Root<Device ID><Instance number> */
        dwInstanceNumber = 0;
        do
        {
            swprintf(szGeneratedInstance, L"Root\\%ls\\%04lu",
                     pszDeviceID, dwInstanceNumber);

            /* Try to create a device instance with this ID */
            ret = CreateDeviceInstance(szGeneratedInstance);

            dwInstanceNumber++;
        }
        while (ret == CR_ALREADY_SUCH_DEVINST);

        if (ret == CR_SUCCESS)
        {
            /* pszDeviceID is an out parameter too for generated IDs */
            if (wcslen(szGeneratedInstance) > ulLength)
            {
                ret = CR_BUFFER_SMALL;
            }
            else
            {
                wcscpy(pszDeviceID, szGeneratedInstance);
            }
        }
    }
    else
    {
        /* Create the device instance */
        ret = CreateDeviceInstance(pszDeviceID);
    }

    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 2246 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 2428 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 2310 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 4833 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 4363 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 3144 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 3320 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 543 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
    return CR_SUCCESS;
}

PNP_DriverStoreAddDriverPackage()

DWORD WINAPI PNP_DriverStoreAddDriverPackage

(

handle_t

hBinding

)

Definition at line 4787 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_DriverStoreDeleteDriverPackage()

DWORD WINAPI PNP_DriverStoreDeleteDriverPackage

(

handle_t

hBinding

)

Definition at line 4798 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 801 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 3954 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

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 4193 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 4667 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 2325 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 2130 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 2370 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 2603 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 4554 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 1668 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 1222 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 1593 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 1711 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 3189 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 3969 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,
                               &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);
    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;
    }

    /* Get the first tag */
    if (RegDataType == REG_RESOURCE_LIST)
    {
        DPRINT("REG_RESOURCE_LIST\n");

        DPRINT("ResourceList->Count %lu\n", ((PCM_RESOURCE_LIST)lpData)->Count);
        if (((PCM_RESOURCE_LIST)lpData)->Count == 0)
        {
            DPRINT1("No resource descriptors!\n");
            ret = CR_NO_MORE_LOG_CONF;
            goto done;
        }

        DPRINT("lpData %p\n", lpData);
        DPRINT("&List[0] %p\n", &(((PCM_RESOURCE_LIST)lpData)->List[0]));

        *pulLogConfTag = (DWORD)((DWORD_PTR)&(((PCM_RESOURCE_LIST)lpData)->List[0]) - (DWORD_PTR)lpData);
        DPRINT("Offset (Tag): 0x%08lx\n", *pulLogConfTag);
    }
    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 !=