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	GetDeviceStatus (_In_ LPWSTR pDeviceID, _Out_ DWORD *pulStatus, _Out_ DWORD *pulProblem)
static BOOL	IsValidDeviceInstanceID (_In_ PWSTR pszDeviceInstanceID)
static BOOL	IsRootDeviceInstanceID (_In_ PWSTR pszDeviceInstanceID)
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	MoveDeviceInstance (LPWSTR pszDeviceInstanceDestination, LPWSTR pszDeviceInstanceSource)
static CONFIGRET	SetupDeviceInstance (LPWSTR pszDeviceInstance, DWORD ulFlags)
static CONFIGRET	EnableDeviceInstance (LPWSTR pszDeviceInstance)
static CONFIGRET	DisableDeviceInstance (LPWSTR pszDeviceInstance)
static CONFIGRET	ReenumerateDeviceInstance (_In_ LPWSTR pszDeviceInstance, _In_ ULONG ulFlags)
DWORD WINAPI	PNP_DeviceInstanceAction (handle_t hBinding, DWORD ulAction, DWORD ulFlags, 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 2918 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 2897 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().

CreateDeviceInstance()

static CONFIGRET CreateDeviceInstance ( LPWSTR  pszDeviceID )

static

Definition at line 2524 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 ( LPWSTR  pszDeviceInstance )

static

Definition at line 2737 of file rpcserver.c.

{
    DPRINT("DisableDeviceInstance: not implemented\n");
    /* FIXME */
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by PNP_DeviceInstanceAction().

EnableDeviceInstance()

static CONFIGRET EnableDeviceInstance ( LPWSTR  pszDeviceInstance )

static

Definition at line 2719 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;

    DPRINT("Enable device instance %S\n", pszDeviceInstance);

    RtlInitUnicodeString(&ResetDeviceData.DeviceInstance, pszDeviceInstance);
    Status = NtPlugPlayControl(PlugPlayControlResetDevice, &ResetDeviceData, sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA));
    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 927 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 1311 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().

GetDeviceInstanceList()

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

static

Definition at line 785 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 1198 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  pDeviceID, _Out_ DWORD *  pulStatus, _Out_ DWORD *  pulProblem  )

static

Definition at line 196 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;

    DPRINT("GetDeviceStatus(%S %p %p)\n",
           pDeviceID, pulStatus, pulProblem);

    RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
                         pDeviceID);
    PlugPlayData.Operation = 0; /* Get 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_(), and PNP_GetDeviceStatus().

GetEnumeratorInstanceList()

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

Definition at line 856 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 1250 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 615 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 1049 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 666 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 1099 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 297 of file rpcserver.c.

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

    return FALSE;
}

Referenced by PNP_CreateDevInst(), and PNP_QueryRemove().

IsValidDeviceInstanceID()

static BOOL IsValidDeviceInstanceID ( _In_ PWSTR  pszDeviceInstanceID )

static

Definition at line 231 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_GetClassInstance(), PNP_GetCustomDevProp(), PNP_GetDepth(), PNP_GetDeviceRegProp(), PNP_GetDeviceStatus(), PNP_GetInterfaceDeviceList(), PNP_GetInterfaceDeviceListSize(), PNP_GetRelatedDeviceInstance(), PNP_HwProfFlags(), PNP_QueryRemove(), PNP_RequestDeviceEject(), 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);
}

MoveDeviceInstance()

static CONFIGRET MoveDeviceInstance ( LPWSTR  pszDeviceInstanceDestination, LPWSTR  pszDeviceInstanceSource  )

static

Definition at line 2699 of file rpcserver.c.

{
    DPRINT("MoveDeviceInstance: not implemented\n");
    /* FIXME */
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by PNP_DeviceInstanceAction().

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 EnableDeviceInstance(), GetDeviceStatus(), GetRelationsInstanceList(), GetRelationsInstanceListSize(), PNP_GetDepth(), PNP_GetDeviceRegProp(), PNP_GetInterfaceDeviceList(), PNP_GetInterfaceDeviceListSize(), PNP_GetRelatedDeviceInstance(), PNP_QueryRemove(), PNP_RequestDeviceEject(), PNP_RequestEjectPC(), and ReenumerateDeviceInstance().

PNP_AddEmptyLogConf()

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

Definition at line 3466 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 2941 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() called\n");
    DPRINT("  DeviceInstance: %S\n", pszDeviceID);
    DPRINT("  DeviceId: %S\n", pszID);
    DPRINT("  Flags: %lx\n", 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 3543 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_ApplyPowerSettings()

DWORD WINAPI PNP_ApplyPowerSettings

(

handle_t

hBinding

)

Definition at line 4070 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_Connect()

DWORD WINAPI PNP_Connect

(

handle_t

hBinding

)

Definition at line 323 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 2632 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 1986 of file rpcserver.c.

{
    HKEY hKey = 0;

    if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                        pszSubKey,
                        0,
                        NULL,
                        0,
                        KEY_ALL_ACCESS,
                        NULL,
                        &hKey,
                        NULL))
        return CR_REGISTRY_ERROR;

    /* FIXME: Set security key */

    RegCloseKey(hKey);

    return CR_SUCCESS;
}

PNP_DeleteClassKey()

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

Definition at line 2130 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;

    UNREFERENCED_PARAMETER(hBinding);

    DPRINT("PNP_GetClassName(%S, %lx) called\n", 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 2016 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 4127 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 3657 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	ulAction,
		DWORD	ulFlags,
		LPWSTR	pszDeviceInstance1,
		LPWSTR	pszDeviceInstance2
	)

Definition at line 2782 of file rpcserver.c.

{
    CONFIGRET ret = CR_SUCCESS;

    UNREFERENCED_PARAMETER(hBinding);

    DPRINT("PNP_DeviceInstanceAction() called\n");

    switch (ulAction)
    {
        case PNP_DEVINST_MOVE:
            ret = MoveDeviceInstance(pszDeviceInstance1,
                                     pszDeviceInstance2);
            break;

        case PNP_DEVINST_SETUP:
            ret = SetupDeviceInstance(pszDeviceInstance1,
                                      ulFlags);
            break;

        case PNP_DEVINST_ENABLE:
            ret = EnableDeviceInstance(pszDeviceInstance1);
            break;

        case PNP_DEVINST_DISABLE:
            ret = DisableDeviceInstance(pszDeviceInstance1);
            break;

        case PNP_DEVINST_REENUMERATE:
            ret = ReenumerateDeviceInstance(pszDeviceInstance1,
                                            ulFlags);
            break;

        default:
            DPRINT1("Unknown device action %lu: not implemented\n", ulAction);
            ret = CR_CALL_NOT_IMPLEMENTED;
    }

    DPRINT("PNP_DeviceInstanceAction() done (returns %lx)\n", ret);

    return ret;
}

Referenced by CM_Disable_DevNode_Ex(), 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 2871 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_Disconnect()

DWORD WINAPI PNP_Disconnect

(

handle_t

hBinding

)

Definition at line 312 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
    return CR_SUCCESS;
}

PNP_DriverStoreAddDriverPackage()

DWORD WINAPI PNP_DriverStoreAddDriverPackage

(

handle_t

hBinding

)

Definition at line 4081 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_DriverStoreDeleteDriverPackage()

DWORD WINAPI PNP_DriverStoreDeleteDriverPackage

(

handle_t

hBinding

)

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

{
    CONFIGRET ret = CR_SUCCESS;
    HKEY hKey;
    DWORD dwError;

    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);

    DPRINT("PNP_EnumerateSubKeys() called\n");

    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 3481 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 3562 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 3961 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 2031 of file rpcserver.c.

{
    HKEY hKey;
    DWORD dwError;

    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(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 1870 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 2073 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() called\n");

    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 2300 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() called\n");

    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 3848 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 1421 of file rpcserver.c.

{
    PLUGPLAY_CONTROL_DEPTH_DATA PlugPlayData;
    CONFIGRET ret = CR_SUCCESS;
    NTSTATUS Status;

    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);

    DPRINT("PNP_GetDepth() called\n");

    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 976 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() called\n");

    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().

PNP_GetDeviceListSize()

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

Definition at line 1346 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%lx)\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().

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 1463 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() called\n");

    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;
            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;
            break;

        case CM_DRP_LEGACYBUSTYPE:
            PlugPlayData.Property = PNP_PROPERTY_LEGACYBUSTYPE;
            break;

        case CM_DRP_BUSNUMBER:
            PlugPlayData.Property = PNP_PROPERTY_BUSNUMBER;
            break;

        case CM_DRP_ENUMERATOR_NAME:
            PlugPlayData.Property = PNP_PROPERTY_ENUMERATOR_NAME;
            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;
            break;

        case CM_DRP_UI_NUMBER_DESC_FORMAT:
            lpValueName = L"UINumberDescFormat";
            break;

        case CM_DRP_DEVICE_POWER_DATA:
            PlugPlayData.Property = PNP_PROPERTY_POWER_DATA;
            break;

        case CM_DRP_REMOVAL_POLICY:
            PlugPlayData.Property = PNP_PROPERTY_REMOVAL_POLICY;
            break;

        case CM_DRP_REMOVAL_POLICY_HW_DEFAULT:
            PlugPlayData.Property = PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT;
            break;

        case CM_DRP_REMOVAL_POLICY_OVERRIDE:
            lpValueName = L"RemovalPolicy";
            break;

        case CM_DRP_INSTALL_STATE:
            PlugPlayData.Property = PNP_PROPERTY_INSTALL_STATE;
            break;

#if (WINVER >= _WIN32_WINNT_WS03)
        case CM_DRP_LOCATION_PATHS:
            PlugPlayData.Property = PNP_PROPERTY_LOCATION_PATHS;
            break;
#endif

#if (WINVER >= _WIN32_WINNT_WIN7)
        case CM_DRP_BASE_CONTAINERID:
            PlugPlayData.Property = PNP_PROPERTY_CONTAINERID;
            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(), and PNP_GetClassInstance().

PNP_GetDeviceStatus()

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

Definition at line 2834 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);

    DPRINT("PNP_GetDeviceStatus(%p %S %p %p)\n",
           hBinding, pDeviceID, pulStatus, pulProblem, ulFlags);

    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_DEVINST;

    return GetDeviceStatus(pDeviceID, pulStatus, pulProblem);
}

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

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Get_First_Log_Conf_Ex().

PNP_GetGlobalState()

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

Definition at line 348 of file rpcserver.c.

{
    UNREFERENCED_PARAMETER(hBinding);
    UNREFERENCED_PARAMETER(ulFlags);

    *pulState = CM_GLOBAL_STATE_CAN_DO_UI | CM_GLOBAL_STATE_SERVICES_AVAILABLE;
    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 3331 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 2161 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

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

{
    NTSTATUS Status;
    PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA PlugPlayData;
    DWORD ret = CR_SUCCESS;

    UNREFERENCED_PARAMETER(hBinding);

    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_GetInterfaceDeviceListSize() 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 2223 of file rpcserver.c.

{
    NTSTATUS Status;
    PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA PlugPlayData;
    DWORD ret = CR_SUCCESS;

    UNREFERENCED_PARAMETER(hBinding);

    DPRINT("PNP_GetInterfaceDeviceListSize() called\n");

    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 3527 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 3511 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

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

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

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 4020 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 4002 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 506 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() called\n");
    DPRINT("  Relationship %ld\n", ulRelationship);
    DPRINT("  DeviceId %S\n", pDeviceID);

    if (!IsValidDeviceInstanceID(pDeviceID))
        return CR_INVALID_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 3600 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 3619 of file rpcserver.c.

{
    UNIMPLEMENTED;
    return CR_CALL_NOT_IMPLEMENTED;
}

PNP_GetRootDeviceInstance()

DWORD WINAPI PNP_GetRootDeviceInstance	(	handle_t	hBinding,
		LPWSTR