pnpprop.c File Reference

#include <ntoskrnl.h>
#include <devpkey.h>
#include <debug.h>

Include dependency graph for pnpprop.c:

Go to the source code of this file.

Classes
struct	_PIP_PROP_OBJECT
struct	_PIP_PROP_NAME
struct	_PIP_BUILTIN_PROPERTY
struct	_PIP_PROP_TYPE_RULE
struct	_PIP_PROP_SAVED_VALUE
struct	_PIP_PROP_OUTPUT

Macros
#define	NDEBUG
#define	TAG_PNP_PROPERTY   'rPpP'
#define	PIP_PROP_REG_TYPE_MARK   0xFFFF0000UL
#define	PIP_PROP_FMTID_CHARS   (38 + 1)
#define	PIP_PROP_PID_CHARS   (8 + 1)
#define	PIP_PROP_PATH_CHARS   (10 + 1 + 38 + 1 + 8 + 1)
#define	PIP_PROP_MAX_QUERY_SIZE   0x10000
#define	PIP_PROP_READ_ONLY   0x00000001
#define	PIP_PROP_ROOT_ENUM_WRITE   0x00000002
#define	PIP_PROP_OBJECT_PROTECTED   0x00000001

Typedefs
typedef enum _PIP_PROP_OBJECT_KIND	PIP_PROP_OBJECT_KIND
typedef struct _PIP_PROP_OBJECT	PIP_PROP_OBJECT
typedef struct _PIP_PROP_OBJECT *	PPIP_PROP_OBJECT
typedef struct _PIP_PROP_NAME	PIP_PROP_NAME
typedef struct _PIP_PROP_NAME *	PPIP_PROP_NAME
typedef enum _PIP_PROP_SOURCE	PIP_PROP_SOURCE
typedef enum _PIP_PROP_FIELD	PIP_PROP_FIELD
typedef struct _PIP_BUILTIN_PROPERTY	PIP_BUILTIN_PROPERTY
typedef struct _PIP_BUILTIN_PROPERTY *	PPIP_BUILTIN_PROPERTY
typedef enum _PIP_PROP_CHECK	PIP_PROP_CHECK
typedef struct _PIP_PROP_TYPE_RULE	PIP_PROP_TYPE_RULE
typedef struct _PIP_PROP_SAVED_VALUE	PIP_PROP_SAVED_VALUE
typedef struct _PIP_PROP_SAVED_VALUE *	PPIP_PROP_SAVED_VALUE
typedef struct _PIP_PROP_OUTPUT	PIP_PROP_OUTPUT
typedef struct _PIP_PROP_OUTPUT *	PPIP_PROP_OUTPUT
typedef BOOLEAN(*	PIP_PROP_READER) (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _Inout_ PPIP_PROP_OUTPUT Out, _Out_ PNTSTATUS Status)
typedef enum _PIP_PROP_TARGET	PIP_PROP_TARGET

Enumerations
enum	_PIP_PROP_OBJECT_KIND { PipPropObjectDevice , PipPropObjectInterface }
enum	_PIP_PROP_SOURCE { PipSourceKeyValue , PipSourceRegistryProperty , PipSourceDeviceNode , PipSourceInterface }
enum	_PIP_PROP_FIELD {   PipFieldName , PipFieldInstanceId , PipFieldParent , PipFieldStatus ,   PipFieldProblemCode , PipFieldHasProblem , PipFieldIsPresent , PipFieldInterfaceClass ,   PipFieldInterfaceEnabled , PipFieldInterfaceDevice , PipFieldInterfaceReference }
enum	_PIP_PROP_CHECK {   PipCheckNone , PipCheckNoData , PipCheckBoolean , PipCheckFileTime ,   PipCheckString , PipCheckSecurity }
enum	_PIP_PROP_TARGET { PipTargetDenied , PipTargetBuiltin , PipTargetStore }

Functions
static BOOLEAN	PiPropIsSameKey (_In_ const DEVPROPKEY *Key1, _In_ const DEVPROPKEY *Key2)
static BOOLEAN	PiPropCheckElements (_In_ UCHAR Check, _In_reads_bytes_(Width *Count) PUCHAR Data, _In_ ULONG Width, _In_ ULONG Count)
static BOOLEAN	PiPropIsValidString (_In_reads_bytes_(Size) PCWSTR String, _In_ ULONG Size)
static BOOLEAN	PiPropIsValidStringList (_In_reads_bytes_(Size) PCWSTR List, _In_ ULONG Size)
static NTSTATUS	PiPropCheckPayload (_In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size)
static NTSTATUS	PiPropInitLocale (_Out_ PPIP_PROP_NAME Name, _In_ LCID Lcid)
static NTSTATUS	PiPropInitName (_Out_ PPIP_PROP_NAME Name, _In_ const DEVPROPKEY *Key, _In_ LCID Lcid)
static BOOLEAN	PiPropIsInterruptKey (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name)
static NTSTATUS	PiPropNormalizeStatus (_In_ NTSTATUS Status)
static NTSTATUS	PiPropCopyOut (_In_ DEVPROPTYPE SourceType, _In_reads_bytes_opt_(SourceSize) PVOID Source, _In_ ULONG SourceSize, _Out_ PDEVPROPTYPE Type, _Out_writes_bytes_to_opt_(Size, *RequiredSize) PVOID Data, _In_ ULONG Size, _Out_ PULONG RequiredSize)
static BOOLEAN	PiPropParseInterfaceName (_In_ PCUNICODE_STRING LinkName, _Out_ LPGUID ClassGuid)
static NTSTATUS NTAPI	PiPropGetInterfaceReference (_In_ PCUNICODE_STRING LinkName, _Out_ PUNICODE_STRING Reference)
static NTSTATUS	PiPropOpenObjectKey (_In_ PPIP_PROP_OBJECT Object, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE ObjectKey)
static NTSTATUS	PiPropBuildValuePath (_In_ PPIP_PROP_NAME Name, _Out_ PUNICODE_STRING Path, _Out_writes_(PIP_PROP_PATH_CHARS) PWCHAR Buffer)
static NTSTATUS	PiPropStoreQuery (_In_ HANDLE ObjectKey, _In_ PPIP_PROP_NAME Name, _Out_ PDEVPROPTYPE Type, _Out_writes_bytes_to_opt_(Size, *RequiredSize) PVOID Data, _In_ ULONG Size, _Out_ PULONG RequiredSize)
static NTSTATUS	PiPropPutValue (_In_ HANDLE ValueKey, _In_ PPIP_PROP_NAME Name, _In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size)
static NTSTATUS	PiPropCreateBranch (_In_ HANDLE Parent, _In_reads_(Depth) PCUNICODE_STRING *Parts, _In_ ULONG Depth, _In_ PPIP_PROP_NAME Name, _In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size)
static NTSTATUS	PiPropStoreWrite (_In_ HANDLE ObjectKey, _In_ PPIP_PROP_NAME Name, _In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size)
static BOOLEAN	PiPropIsKeyEmpty (_In_ HANDLE KeyHandle)
static NTSTATUS	PiPropStoreDelete (_In_ HANDLE ObjectKey, _In_ PPIP_PROP_NAME Name)
static	RTL_STATIC_LIST_HEAD (PiPropSavedValues)
static PPIP_PROP_SAVED_VALUE	PiPropFindSaved (_In_ PDEVICE_OBJECT Pdo)
static NTSTATUS	PiPropReplaceSaved (_In_ PDEVICE_OBJECT Pdo, _In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size, _Out_opt_ PBOOLEAN Replaced)
static const PIP_BUILTIN_PROPERTY *	PiPropBuiltinTable (_In_ PIP_PROP_OBJECT_KIND Kind, _Out_ PULONG Count)
static const PIP_BUILTIN_PROPERTY *	PiPropFindBuiltin (_In_ PPIP_PROP_OBJECT Object, _In_ const DEVPROPKEY *Key)
static NTSTATUS	PiPropAllocateBlob (_In_reads_bytes_(Size) PVOID Source, _In_ ULONG Size, _Outptr_result_bytebuffer_maybenull_(Size) PVOID *Blob)
static NTSTATUS	PiPropCaptureString (_In_reads_bytes_(RawSize) PCWSTR Raw, _In_ ULONG RawSize, _In_ BOOLEAN IsList, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropReadRegistryValue (_In_ HANDLE KeyHandle, _In_ PCWSTR ValueName, _In_ ULONG RegType, _In_ DEVPROPTYPE Type, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropReadKeyValue (_In_ PPIP_PROP_OBJECT Object, _In_ PCWSTR ValueName, _In_ ULONG RegType, _In_ DEVPROPTYPE Type, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropReadDeviceRegistryProperty (_In_ PPIP_PROP_OBJECT Object, _In_ const PIP_BUILTIN_PROPERTY *Builtin, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropReadDeviceNodeField (_In_ PPIP_PROP_OBJECT Object, _In_ PIP_PROP_FIELD Field, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropReadInterfaceField (_In_ PPIP_PROP_OBJECT Object, _In_ PIP_PROP_FIELD Field, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropReadBuiltin (_In_ PPIP_PROP_OBJECT Object, _In_ const PIP_BUILTIN_PROPERTY *Builtin, _Outptr_result_bytebuffer_maybenull_(*BlobSize) PVOID *Blob, _Out_ PULONG BlobSize)
static NTSTATUS	PiPropWriteBuiltin (_In_ PPIP_PROP_OBJECT Object, _In_ const PIP_BUILTIN_PROPERTY *Builtin, _In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size)
static BOOLEAN	PiPropReadFromBuiltin (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _Inout_ PPIP_PROP_OUTPUT Out, _Out_ PNTSTATUS Status)
static BOOLEAN	PiPropReadFromStore (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _Inout_ PPIP_PROP_OUTPUT Out, _Out_ PNTSTATUS Status)
static BOOLEAN	PiPropReadFromSaved (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _Inout_ PPIP_PROP_OUTPUT Out, _Out_ PNTSTATUS Status)
static NTSTATUS	PiPropGet (_In_ PPIP_PROP_OBJECT Object, _In_ const DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _In_ ULONG Size, _Out_writes_bytes_to_opt_(Size, *RequiredSize) PVOID Data, _Out_ PULONG RequiredSize, _Out_ PDEVPROPTYPE Type)
static PIP_PROP_TARGET	PiPropPickTarget (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _Out_ const PIP_BUILTIN_PROPERTY **Builtin)
static NTSTATUS	PiPropStoreApply (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _In_ DEVPROPTYPE Type, _In_reads_bytes_opt_(Size) PVOID Data, _In_ ULONG Size)
static BOOLEAN	PiPropShouldAnnounce (_In_ PDEVICE_NODE DeviceNode)
static NTSTATUS	PiPropSet (_In_ PPIP_PROP_OBJECT Object, _In_ const DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _In_ DEVPROPTYPE Type, _In_ ULONG Size, _In_reads_bytes_opt_(Size) PVOID Data)
static NTSTATUS	PiPropInitDeviceObject (_In_ PDEVICE_OBJECT Pdo, _Out_ PPIP_PROP_OBJECT Object)
static NTSTATUS	PiPropInitInterfaceObject (_In_ PCUNICODE_STRING SymbolicLinkName, _Out_ PPIP_PROP_OBJECT Object)
VOID	PiPropReleaseDevice (_In_ PDEVICE_OBJECT DeviceObject)
	_IRQL_requires_max_ (PASSIVE_LEVEL)

Variables
static const PIP_BUILTIN_PROPERTY	PipDeviceBuiltins []
static const PIP_BUILTIN_PROPERTY	PipInterfaceBuiltins []
static const DEVPROPKEY	PiPropInterruptKey
static const PIP_PROP_TYPE_RULE	PiPropTypeRules [MAX_DEVPROP_TYPE+1]
static EX_PUSH_LOCK	PiPropSavedLock
static const PIP_PROP_READER	PiPropReaders []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file pnpprop.c.

PIP_PROP_FMTID_CHARS

#define PIP_PROP_FMTID_CHARS   (38 + 1)

Definition at line 23 of file pnpprop.c.

PIP_PROP_MAX_QUERY_SIZE

#define PIP_PROP_MAX_QUERY_SIZE   0x10000

Definition at line 26 of file pnpprop.c.

PIP_PROP_OBJECT_PROTECTED

#define PIP_PROP_OBJECT_PROTECTED   0x00000001

Definition at line 31 of file pnpprop.c.

PIP_PROP_PATH_CHARS

#define PIP_PROP_PATH_CHARS   (10 + 1 + 38 + 1 + 8 + 1)

Definition at line 25 of file pnpprop.c.

PIP_PROP_PID_CHARS

#define PIP_PROP_PID_CHARS   (8 + 1)

Definition at line 24 of file pnpprop.c.

PIP_PROP_READ_ONLY

#define PIP_PROP_READ_ONLY   0x00000001

Definition at line 28 of file pnpprop.c.

PIP_PROP_REG_TYPE_MARK

#define PIP_PROP_REG_TYPE_MARK   0xFFFF0000UL

Definition at line 21 of file pnpprop.c.

PIP_PROP_ROOT_ENUM_WRITE

#define PIP_PROP_ROOT_ENUM_WRITE   0x00000002

Definition at line 29 of file pnpprop.c.

TAG_PNP_PROPERTY

#define TAG_PNP_PROPERTY   'rPpP'

Definition at line 18 of file pnpprop.c.

Typedef Documentation

PIP_BUILTIN_PROPERTY

typedef struct _PIP_BUILTIN_PROPERTY PIP_BUILTIN_PROPERTY

PIP_PROP_CHECK

typedef enum _PIP_PROP_CHECK PIP_PROP_CHECK

PIP_PROP_FIELD

typedef enum _PIP_PROP_FIELD PIP_PROP_FIELD

PIP_PROP_NAME

typedef struct _PIP_PROP_NAME PIP_PROP_NAME

PIP_PROP_OBJECT

typedef struct _PIP_PROP_OBJECT PIP_PROP_OBJECT

PIP_PROP_OBJECT_KIND

typedef enum _PIP_PROP_OBJECT_KIND PIP_PROP_OBJECT_KIND

PIP_PROP_OUTPUT

typedef struct _PIP_PROP_OUTPUT PIP_PROP_OUTPUT

PIP_PROP_READER

typedef BOOLEAN(* PIP_PROP_READER) (_In_ PPIP_PROP_OBJECT Object, _In_ PPIP_PROP_NAME Name, _Inout_ PPIP_PROP_OUTPUT Out, _Out_ PNTSTATUS Status)

Definition at line 1408 of file pnpprop.c.

PIP_PROP_SAVED_VALUE

typedef struct _PIP_PROP_SAVED_VALUE PIP_PROP_SAVED_VALUE

PIP_PROP_SOURCE

typedef enum _PIP_PROP_SOURCE PIP_PROP_SOURCE

PIP_PROP_TARGET

typedef enum _PIP_PROP_TARGET PIP_PROP_TARGET

PIP_PROP_TYPE_RULE

typedef struct _PIP_PROP_TYPE_RULE PIP_PROP_TYPE_RULE

PPIP_BUILTIN_PROPERTY

typedef struct _PIP_BUILTIN_PROPERTY * PPIP_BUILTIN_PROPERTY

PPIP_PROP_NAME

typedef struct _PIP_PROP_NAME * PPIP_PROP_NAME

PPIP_PROP_OBJECT

typedef struct _PIP_PROP_OBJECT * PPIP_PROP_OBJECT

PPIP_PROP_OUTPUT

typedef struct _PIP_PROP_OUTPUT * PPIP_PROP_OUTPUT

PPIP_PROP_SAVED_VALUE

typedef struct _PIP_PROP_SAVED_VALUE * PPIP_PROP_SAVED_VALUE

Enumeration Type Documentation

_PIP_PROP_CHECK

enum _PIP_PROP_CHECK

Enumerator
PipCheckNone
PipCheckNoData
PipCheckBoolean
PipCheckFileTime
PipCheckString
PipCheckSecurity

Definition at line 158 of file pnpprop.c.

{
    PipCheckNone,
    PipCheckNoData,
    PipCheckBoolean,
    PipCheckFileTime,
    PipCheckString,
    PipCheckSecurity
} PIP_PROP_CHECK;

_PIP_PROP_FIELD

enum _PIP_PROP_FIELD

Enumerator
PipFieldName
PipFieldInstanceId
PipFieldParent
PipFieldStatus
PipFieldProblemCode
PipFieldHasProblem
PipFieldIsPresent
PipFieldInterfaceClass
PipFieldInterfaceEnabled
PipFieldInterfaceDevice
PipFieldInterfaceReference

Definition at line 70 of file pnpprop.c.

{
    PipFieldName,
    PipFieldInstanceId,
    PipFieldParent,
    PipFieldStatus,
    PipFieldProblemCode,
    PipFieldHasProblem,
    PipFieldIsPresent,
    PipFieldInterfaceClass,
    PipFieldInterfaceEnabled,
    PipFieldInterfaceDevice,
    PipFieldInterfaceReference
} PIP_PROP_FIELD;

_PIP_PROP_OBJECT_KIND

enum _PIP_PROP_OBJECT_KIND

Enumerator
PipPropObjectDevice
PipPropObjectInterface

Definition at line 35 of file pnpprop.c.

{
    PipPropObjectDevice,
    PipPropObjectInterface
} PIP_PROP_OBJECT_KIND;

_PIP_PROP_SOURCE

enum _PIP_PROP_SOURCE

Enumerator
PipSourceKeyValue
PipSourceRegistryProperty
PipSourceDeviceNode
PipSourceInterface

Definition at line 62 of file pnpprop.c.

{
    PipSourceKeyValue,
    PipSourceRegistryProperty,
    PipSourceDeviceNode,
    PipSourceInterface
} PIP_PROP_SOURCE;

_PIP_PROP_TARGET

enum _PIP_PROP_TARGET

Enumerator
PipTargetDenied
PipTargetBuiltin
PipTargetStore

Definition at line 1542 of file pnpprop.c.

{
    PipTargetDenied,
    PipTargetBuiltin,
    PipTargetStore
} PIP_PROP_TARGET;

Function Documentation

_IRQL_requires_max_()

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 1745 of file pnpprop.c.

{
    PIP_PROP_OBJECT Object;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(Flags);
 
    Status = PiPropInitDeviceObject(Pdo, &Object);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* A NULL buffer deletes the property */
    if (!Data)
    {
        Type = DEVPROP_TYPE_EMPTY;
        Size = 0;
    }
 
    return PiPropSet(&Object, PropertyKey, Lcid, Type, Size, Data);
}

PiPropAllocateBlob()

static NTSTATUS PiPropAllocateBlob ( _In_reads_bytes_(Size) PVOID  Source, _In_ ULONG  Size, _Outptr_result_bytebuffer_maybenull_(Size) PVOID *  Blob  )

static

Definition at line 919 of file pnpprop.c.

{
    *Blob = NULL;
    if (Size == 0)
        return STATUS_INVALID_PARAMETER;
 
    *Blob = ExAllocatePoolWithTag(PagedPool, Size, TAG_PNP_PROPERTY);
    if (!*Blob)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    RtlCopyMemory(*Blob, Source, Size);
    return STATUS_SUCCESS;
}

Referenced by PiPropReadDeviceNodeField(), PiPropReadInterfaceField(), and PiPropReadRegistryValue().

PiPropBuildValuePath()

static NTSTATUS PiPropBuildValuePath ( _In_ PPIP_PROP_NAME  Name, _Out_ PUNICODE_STRING  Path, _Out_writes_(PIP_PROP_PATH_CHARS) PWCHAR  Buffer  )

static

Definition at line 555 of file pnpprop.c.

{
    RtlInitEmptyUnicodeString(Path, Buffer, PIP_PROP_PATH_CHARS * sizeof(WCHAR));
    return RtlUnicodeStringPrintf(Path,
                                  L"%s\\%wZ\\%wZ",
                                  REGSTR_KEY_DEVICE_PROPERTIES,
                                  &Name->Fmtid,
                                  &Name->Pid);
}

Referenced by PiPropStoreQuery(), and PiPropStoreWrite().

PiPropBuiltinTable()

static const PIP_BUILTIN_PROPERTY * PiPropBuiltinTable ( _In_ PIP_PROP_OBJECT_KIND  Kind, _Out_ PULONG  Count  )

static

Definition at line 878 of file pnpprop.c.

{
    switch (Kind)
    {
        case PipPropObjectDevice:
            *Count = RTL_NUMBER_OF(PipDeviceBuiltins);
            return PipDeviceBuiltins;
 
        case PipPropObjectInterface:
            *Count = RTL_NUMBER_OF(PipInterfaceBuiltins);
            return PipInterfaceBuiltins;
 
        default:
            *Count = 0;
            return NULL;
    }
}

Referenced by PiPropFindBuiltin().

PiPropCaptureString()

static NTSTATUS PiPropCaptureString ( _In_reads_bytes_(RawSize) PCWSTR  Raw, _In_ ULONG  RawSize, _In_ BOOLEAN  IsList, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 938 of file pnpprop.c.

{
    ULONG RawChars = RawSize / sizeof(WCHAR);
    ULONG Index, Out = 0;
    BOOLEAN InEntry = FALSE;
    PWCHAR String;
 
    String = ExAllocatePoolWithTag(PagedPool, (RawChars + 2) * sizeof(WCHAR), TAG_PNP_PROPERTY);
    if (!String)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    *Blob = String;
 
    for (Index = 0; Index < RawChars; Index++)
    {
        if (Raw[Index] != UNICODE_NULL)
        {
            String[Out++] = Raw[Index];
            InEntry = TRUE;
            continue;
        }
 
        if (!IsList || !InEntry)
            break;
 
        String[Out++] = UNICODE_NULL;
        InEntry = FALSE;
    }
 
    if (!IsList || InEntry)
        String[Out++] = UNICODE_NULL;
    if (IsList)
        String[Out++] = UNICODE_NULL;
 
    *BlobSize = Out * sizeof(WCHAR);
    return STATUS_SUCCESS;
}

Referenced by PiPropReadDeviceNodeField(), PiPropReadDeviceRegistryProperty(), PiPropReadInterfaceField(), and PiPropReadRegistryValue().

PiPropCheckElements()

static BOOLEAN PiPropCheckElements ( _In_ UCHAR  Check, _In_reads_bytes_(Width *Count) PUCHAR  Data, _In_ ULONG  Width, _In_ ULONG  Count  )

static

Definition at line 208 of file pnpprop.c.

{
    LONGLONG Time;
 
    for (; Count; Count--, Data += Width)
    {
        if (Check == PipCheckBoolean)
        {
            if ((*(PDEVPROP_BOOLEAN)Data != DEVPROP_FALSE) &&
                (*(PDEVPROP_BOOLEAN)Data != DEVPROP_TRUE))
                return FALSE;
        }
        else if (Check == PipCheckFileTime)
        {
            RtlCopyMemory(&Time, Data, sizeof(Time));
            if (Time < 0)
                return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by PiPropCheckPayload().

PiPropCheckPayload()

static NTSTATUS PiPropCheckPayload ( _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size  )

static

Definition at line 292 of file pnpprop.c.

{
    DEVPROPTYPE BaseType = Type & DEVPROP_MASK_TYPE;
    const PIP_PROP_TYPE_RULE *Rule;
    BOOLEAN Valid;
 
    if ((BaseType > MAX_DEVPROP_TYPE) || (Size && !Data))
        return STATUS_INVALID_PARAMETER;
 
    Rule = &PiPropTypeRules[BaseType];
 
    /* Everything above the base type must be a single known modifier */
    switch (Type - BaseType)
    {
        case 0:
            if (Rule->Width)
                Valid = (Size == Rule->Width);
            else if (Rule->Check == PipCheckNoData)
                Valid = (Size == 0);
            else if (Rule->Check == PipCheckString)
                Valid = PiPropIsValidString(Data, Size);
            else
                Valid = (Size != 0) &&
                        RtlValidRelativeSecurityDescriptor(Data, Size, 0) &&
                        (RtlLengthSecurityDescriptor(Data) == Size);
            break;
 
        case DEVPROP_TYPEMOD_ARRAY:
            Valid = (Rule->Width != 0) && (Size != 0) && !(Size % Rule->Width);
            break;
 
        case DEVPROP_TYPEMOD_LIST:
            Valid = Rule->ListAllowed && PiPropIsValidStringList(Data, Size);
            break;
 
        default:
            Valid = FALSE;
            break;
    }
 
    if (Valid && Rule->Width && (Rule->Check != PipCheckNone))
        Valid = PiPropCheckElements(Rule->Check, Data, Rule->Width, Size / Rule->Width);
 
    return Valid ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER;
}

Referenced by PiPropSet().

PiPropCopyOut()

static NTSTATUS PiPropCopyOut ( _In_ DEVPROPTYPE  SourceType, _In_reads_bytes_opt_(SourceSize) PVOID  Source, _In_ ULONG  SourceSize, _Out_ PDEVPROPTYPE  Type, _Out_writes_bytes_to_opt_(Size, *RequiredSize) PVOID  Data, _In_ ULONG  Size, _Out_ PULONG  RequiredSize  )

static

Definition at line 427 of file pnpprop.c.

{
    *Type = SourceType;
    *RequiredSize = SourceSize;
 
    /* An empty buffer only satisfies DEVPROP_TYPE_NULL */
    if ((Size < SourceSize) || (!Size && (SourceType != DEVPROP_TYPE_NULL)))
        return STATUS_BUFFER_TOO_SMALL;
 
    if (SourceSize)
        RtlCopyMemory(Data, Source, SourceSize);
 
    return STATUS_SUCCESS;
}

Referenced by PiPropReadFromBuiltin(), PiPropReadFromSaved(), and PiPropStoreQuery().

PiPropCreateBranch()

static NTSTATUS PiPropCreateBranch ( _In_ HANDLE  Parent, _In_reads_(Depth) PCUNICODE_STRING *  Parts, _In_ ULONG  Depth, _In_ PPIP_PROP_NAME  Name, _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size  )

static

Definition at line 667 of file pnpprop.c.

{
    const ACCESS_MASK Access = KEY_CREATE_SUB_KEY | KEY_SET_VALUE | DELETE;
    ULONG Disposition;
    HANDLE Child;
    NTSTATUS Status;
 
    Status = IopCreateRegistryKeyEx(&Child, Parent, (PUNICODE_STRING)Parts[0], Access,
                                    REG_OPTION_NON_VOLATILE, &Disposition);
    if (Status == STATUS_CHILD_MUST_BE_VOLATILE)
    {
        Status = IopCreateRegistryKeyEx(&Child, Parent, (PUNICODE_STRING)Parts[0], Access,
                                        REG_OPTION_VOLATILE, &Disposition);
    }
    if (!NT_SUCCESS(Status))
        return Status;
 
    if (Depth > 1)
        Status = PiPropCreateBranch(Child, Parts + 1, Depth - 1, Name, Type, Data, Size);
    else
        Status = PiPropPutValue(Child, Name, Type, Data, Size);
 
    if (!NT_SUCCESS(Status) && (Disposition == REG_CREATED_NEW_KEY))
        ZwDeleteKey(Child);
 
    ZwClose(Child);
    return Status;
}

Referenced by PiPropCreateBranch(), and PiPropStoreWrite().

PiPropFindBuiltin()

static const PIP_BUILTIN_PROPERTY * PiPropFindBuiltin ( _In_ PPIP_PROP_OBJECT  Object, _In_ const DEVPROPKEY *  Key  )

static

Definition at line 900 of file pnpprop.c.

{
    const PIP_BUILTIN_PROPERTY *Table;
    ULONG Count;
 
    Table = PiPropBuiltinTable(Object->Kind, &Count);
    for (; Count; Count--, Table++)
    {
        if (PiPropIsSameKey(Table->Key, Key))
            return Table;
    }
 
    return NULL;
}

Referenced by PiPropPickTarget(), and PiPropReadFromBuiltin().

PiPropFindSaved()

static PPIP_PROP_SAVED_VALUE PiPropFindSaved ( _In_ PDEVICE_OBJECT  Pdo )

static

Definition at line 810 of file pnpprop.c.

{
    PPIP_PROP_SAVED_VALUE Saved;
    PLIST_ENTRY Entry;
 
    for (Entry = PiPropSavedValues.Flink; Entry != &PiPropSavedValues; Entry = Entry->Flink)
    {
        Saved = CONTAINING_RECORD(Entry, PIP_PROP_SAVED_VALUE, Link);
        if (Saved->Pdo == Pdo)
            return Saved;
    }
 
    return NULL;
}

Referenced by PiPropReadFromSaved(), and PiPropReplaceSaved().

PiPropGet()

static NTSTATUS PiPropGet ( _In_ PPIP_PROP_OBJECT  Object, _In_ const DEVPROPKEY *  PropertyKey, _In_ LCID  Lcid, _In_ ULONG  Size, _Out_writes_bytes_to_opt_(Size, *RequiredSize) PVOID  Data, _Out_ PULONG  RequiredSize, _Out_ PDEVPROPTYPE  Type  )

static

Definition at line 1505 of file pnpprop.c.

{
    PIP_PROP_OUTPUT Out = { Data, Data ? Size : 0, 0, DEVPROP_TYPE_EMPTY };
    PIP_PROP_NAME Name;
    NTSTATUS Status;
    ULONG Index;
 
    PAGED_CODE();
 
    if (!PropertyKey || !RequiredSize || !Type)
        return STATUS_INVALID_PARAMETER;
 
    Status = PiPropInitName(&Name, PropertyKey, Lcid);
    if (NT_SUCCESS(Status))
    {
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        for (Index = 0; Index < RTL_NUMBER_OF(PiPropReaders); Index++)
        {
            if (PiPropReaders[Index](Object, &Name, &Out, &Status))
                break;
        }
    }
 
    *RequiredSize = Out.Required;
    *Type = Out.Type;
    return PiPropNormalizeStatus(Status);
}

PiPropGetInterfaceReference()

static NTSTATUS NTAPI PiPropGetInterfaceReference ( _In_ PCUNICODE_STRING  LinkName, _Out_ PUNICODE_STRING  Reference  )

static

Definition at line 488 of file pnpprop.c.

{
    USHORT Start, End, Chars;
 
    /* Both link prefixes are four characters */
    Chars = LinkName->Length / sizeof(WCHAR);
    Start = 4;
    while ((Start < Chars) && (LinkName->Buffer[Start] != L'\\'))
        Start++;
 
    if (Start >= Chars)
        return STATUS_OBJECT_NAME_NOT_FOUND;
 
    Start++;
    for (End = Start; End < Chars; End++)
    {
        if ((LinkName->Buffer[End] == L'\\') || (LinkName->Buffer[End] == L'/'))
            return STATUS_OBJECT_PATH_INVALID;
    }
 
    Reference->Buffer = &LinkName->Buffer[Start];
    Reference->Length = (End - Start) * sizeof(WCHAR);
    Reference->MaximumLength = Reference->Length;
    return STATUS_SUCCESS;
}

Referenced by PiPropReadInterfaceField().

PiPropInitDeviceObject()

static NTSTATUS PiPropInitDeviceObject ( _In_ PDEVICE_OBJECT  Pdo, _Out_ PPIP_PROP_OBJECT  Object  )

static

Definition at line 1683 of file pnpprop.c.

{
    PDEVICE_NODE DeviceNode = Pdo ? IopGetDeviceNode(Pdo) : NULL;
 
    if (!DeviceNode || (DeviceNode->Flags & DNF_LEGACY_RESOURCE_DEVICENODE))
    {
        DPRINT1("%p is not a PDO\n", Pdo);
        KeBugCheckEx(PNP_DETECTED_FATAL_ERROR, 0x2, (ULONG_PTR)Pdo, 0, 0);
    }
 
    if (!DeviceNode->InstancePath.Length)
        return STATUS_INVALID_DEVICE_REQUEST;
 
    RtlZeroMemory(Object, sizeof(*Object));
    Object->Kind = PipPropObjectDevice;
    Object->Pdo = Pdo;
    Object->DeviceNode = DeviceNode;
    Object->Name = &DeviceNode->InstancePath;
 
    if (DeviceNode == IopRootDeviceNode)
        Object->Flags |= PIP_PROP_OBJECT_PROTECTED;
 
    return STATUS_SUCCESS;
}

Referenced by _IRQL_requires_max_().

PiPropInitInterfaceObject()

static NTSTATUS PiPropInitInterfaceObject ( _In_ PCUNICODE_STRING  SymbolicLinkName, _Out_ PPIP_PROP_OBJECT  Object  )

static

Definition at line 1712 of file pnpprop.c.

{
    RtlZeroMemory(Object, sizeof(*Object));
 
    if (!SymbolicLinkName || !SymbolicLinkName->Buffer || !SymbolicLinkName->Length ||
        !PiPropParseInterfaceName(SymbolicLinkName, &Object->ClassGuid))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    Object->Kind = PipPropObjectInterface;
    Object->Name = SymbolicLinkName;
    return STATUS_SUCCESS;
}

PiPropInitLocale()

static NTSTATUS PiPropInitLocale ( _Out_ PPIP_PROP_NAME  Name, _In_ LCID  Lcid  )

static

Definition at line 343 of file pnpprop.c.

{
    RtlInitEmptyUnicodeString(&Name->Locale,
                              Name->LocaleBuffer,
                              sizeof(Name->LocaleBuffer));
 
    if ((Lcid != LOCALE_NEUTRAL) && !RtlLCIDToCultureName(Lcid, &Name->Locale))
    {
        DPRINT1("Cannot resolve LCID 0x%lx\n", Lcid);
        return STATUS_UNSUCCESSFUL;
    }
 
    return STATUS_SUCCESS;
}

Referenced by PiPropInitName().

PiPropInitName()

static NTSTATUS PiPropInitName ( _Out_ PPIP_PROP_NAME  Name, _In_ const DEVPROPKEY *  Key, _In_ LCID  Lcid  )

static

Definition at line 362 of file pnpprop.c.

{
    const GUID *Fmtid = &Key->fmtid;
    NTSTATUS Status;
 
    Name->Key = Key;
 
    Status = PiPropInitLocale(Name, Lcid);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = RtlStringCchPrintfW(Name->FmtidBuffer,
                                 RTL_NUMBER_OF(Name->FmtidBuffer),
                                 L"{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
                                 Fmtid->Data1, Fmtid->Data2, Fmtid->Data3,
                                 Fmtid->Data4[0], Fmtid->Data4[1],
                                 Fmtid->Data4[2], Fmtid->Data4[3],
                                 Fmtid->Data4[4], Fmtid->Data4[5],
                                 Fmtid->Data4[6], Fmtid->Data4[7]);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = RtlStringCchPrintfW(Name->PidBuffer,
                                 RTL_NUMBER_OF(Name->PidBuffer),
                                 L"%04lX",
                                 Key->pid);
    if (!NT_SUCCESS(Status))
        return Status;
 
    RtlInitUnicodeString(&Name->Fmtid, Name->FmtidBuffer);
    RtlInitUnicodeString(&Name->Pid, Name->PidBuffer);
    return STATUS_SUCCESS;
}

Referenced by PiPropGet(), and PiPropSet().

PiPropIsInterruptKey()

static BOOLEAN PiPropIsInterruptKey ( _In_ PPIP_PROP_OBJECT  Object, _In_ PPIP_PROP_NAME  Name  )

static

Definition at line 401 of file pnpprop.c.

{
    return (Object->Pdo != NULL) &&
           (Name->Locale.Length == 0) &&
           PiPropIsSameKey(Name->Key, &PiPropInterruptKey);
}

Referenced by PiPropReadFromSaved(), and PiPropStoreApply().

PiPropIsKeyEmpty()

static BOOLEAN PiPropIsKeyEmpty ( _In_ HANDLE  KeyHandle )

static

Definition at line 734 of file pnpprop.c.

{
    struct
    {
        KEY_FULL_INFORMATION Info;
        WCHAR ClassName[32];
    } Buffer;
    ULONG ResultLength;
    NTSTATUS Status;
 
    Status = ZwQueryKey(KeyHandle,
                        KeyFullInformation,
                        &Buffer,
                        sizeof(Buffer),
                        &ResultLength);
 
    return NT_SUCCESS(Status) &&
           (Buffer.Info.SubKeys == 0) &&
           (Buffer.Info.Values == 0);
}

Referenced by PiPropStoreDelete().

PiPropIsSameKey()

static BOOLEAN PiPropIsSameKey ( _In_ const DEVPROPKEY *  Key1, _In_ const DEVPROPKEY *  Key2  )

inlinestatic

Definition at line 150 of file pnpprop.c.

{
    return (Key1->pid == Key2->pid) &&
           RtlEqualMemory(&Key1->fmtid, &Key2->fmtid, sizeof(GUID));
}

Referenced by PiPropFindBuiltin(), and PiPropIsInterruptKey().

PiPropIsValidString()

static BOOLEAN PiPropIsValidString ( _In_reads_bytes_(Size) PCWSTR  String, _In_ ULONG  Size  )

static

Definition at line 237 of file pnpprop.c.

{
    ULONG Chars, Index;
 
    if ((Size < sizeof(WCHAR)) || (Size % sizeof(WCHAR)) ||
        (Size > UNICODE_STRING_MAX_BYTES))
    {
        return FALSE;
    }
 
    Chars = Size / sizeof(WCHAR);
    for (Index = 0; Index < Chars - 1; Index++)
    {
        if (String[Index] == UNICODE_NULL)
            return FALSE;
    }
 
    return (String[Chars - 1] == UNICODE_NULL);
}

Referenced by PiPropCheckPayload().

PiPropIsValidStringList()

static BOOLEAN PiPropIsValidStringList ( _In_reads_bytes_(Size) PCWSTR  List, _In_ ULONG  Size  )

static

Definition at line 261 of file pnpprop.c.

{
    ULONG Chars, Index, EntryStart;
 
    if ((Size < sizeof(WCHAR)) || (Size % sizeof(WCHAR)))
        return FALSE;
 
    Chars = Size / sizeof(WCHAR);
    EntryStart = 0;
 
    for (Index = 0; Index < Chars; Index++)
    {
        if (List[Index] != UNICODE_NULL)
            continue;
 
        if (Index == EntryStart)
            return (Index == Chars - 1);
 
        if ((Index - EntryStart + 1) * sizeof(WCHAR) > UNICODE_STRING_MAX_BYTES)
            return FALSE;
 
        EntryStart = Index + 1;
    }
 
    return FALSE;
}

Referenced by PiPropCheckPayload().

PiPropNormalizeStatus()

static NTSTATUS PiPropNormalizeStatus ( _In_ NTSTATUS  Status )

static

Definition at line 412 of file pnpprop.c.

{
    if ((Status == STATUS_NOT_FOUND) ||
        (Status == STATUS_OBJECT_PATH_NOT_FOUND) ||
        (Status == STATUS_KEY_DELETED))
    {
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    return Status;
}

Referenced by PiPropGet(), PiPropReadFromStore(), PiPropSet(), and PiPropStoreApply().

PiPropOpenObjectKey()

static NTSTATUS PiPropOpenObjectKey ( _In_ PPIP_PROP_OBJECT  Object, _In_ ACCESS_MASK  DesiredAccess, _Out_ PHANDLE  ObjectKey  )

static

Definition at line 520 of file pnpprop.c.

{
    UNICODE_STRING EnumKeyName =
        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum");
    HANDLE EnumKey;
    NTSTATUS Status;
 
    *ObjectKey = NULL;
 
    switch (Object->Kind)
    {
        case PipPropObjectInterface:
            return IopOpenDeviceInterfaceKeys(Object->Name, DesiredAccess, NULL, ObjectKey);
 
        default:
            break;
    }
 
    Status = IopOpenRegistryKeyEx(&EnumKey, NULL, &EnumKeyName, KEY_READ);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = IopOpenRegistryKeyEx(ObjectKey,
                                  EnumKey,
                                  (PUNICODE_STRING)Object->Name,
                                  DesiredAccess);
    ZwClose(EnumKey);
    return Status;
}

Referenced by PiPropReadFromStore(), PiPropReadKeyValue(), PiPropStoreApply(), and PiPropWriteBuiltin().

PiPropParseInterfaceName()

static BOOLEAN PiPropParseInterfaceName ( _In_ PCUNICODE_STRING  LinkName, _Out_ LPGUID  ClassGuid  )

static

Definition at line 452 of file pnpprop.c.

{
    static const UNICODE_STRING KernelPrefix = RTL_CONSTANT_STRING(L"\\??\\");
    static const UNICODE_STRING UserPrefix = RTL_CONSTANT_STRING(L"\\\\?\\");
    UNICODE_STRING GuidString;
    USHORT Index, Chars;
 
    if (LinkName->Length % sizeof(WCHAR))
        return FALSE;
 
    if (!RtlPrefixUnicodeString(&KernelPrefix, LinkName, FALSE) &&
        !RtlPrefixUnicodeString(&UserPrefix, LinkName, FALSE))
    {
        return FALSE;
    }
 
    Chars = LinkName->Length / sizeof(WCHAR);
    Index = 4;
    while ((Index < Chars) && (LinkName->Buffer[Index] != L'\\'))
        Index++;
 
    if (Index < 4 + 1 + 38)
        return FALSE;
 
    GuidString.Buffer = &LinkName->Buffer[Index - 38];
    GuidString.Length = GuidString.MaximumLength = 38 * sizeof(WCHAR);
 
    return NT_SUCCESS(RtlGUIDFromString(&GuidString, ClassGuid));
}

Referenced by PiPropInitInterfaceObject().

PiPropPickTarget()

static PIP_PROP_TARGET PiPropPickTarget ( _In_ PPIP_PROP_OBJECT  Object, _In_ PPIP_PROP_NAME  Name, _Out_ const PIP_BUILTIN_PROPERTY **  Builtin  )

static

Definition at line 1551 of file pnpprop.c.

{
    *Builtin = NULL;
 
    /* Localized values are still allowed on a protected object */
    if ((Object->Flags & PIP_PROP_OBJECT_PROTECTED) && !Name->Locale.Length)
        return PipTargetDenied;
 
    if (!Name->Locale.Length)
        *Builtin = PiPropFindBuiltin(Object, Name->Key);
 
    return *Builtin ? PipTargetBuiltin : PipTargetStore;
}

Referenced by PiPropSet().

PiPropPutValue()

static NTSTATUS PiPropPutValue ( _In_ HANDLE  ValueKey, _In_ PPIP_PROP_NAME  Name, _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size  )

static

Definition at line 650 of file pnpprop.c.

{
    return ZwSetValueKey(ValueKey,
                         &Name->Locale,
                         0,
                         PIP_PROP_REG_TYPE_MARK | Type,
                         Data,
                         Size);
}

Referenced by PiPropCreateBranch(), and PiPropStoreWrite().

PiPropReadBuiltin()

static NTSTATUS PiPropReadBuiltin ( _In_ PPIP_PROP_OBJECT  Object, _In_ const PIP_BUILTIN_PROPERTY *  Builtin, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 1300 of file pnpprop.c.

{
    switch (Builtin->Source)
    {
        case PipSourceKeyValue:
            return PiPropReadKeyValue(Object,
                                      Builtin->ValueName,
                                      Builtin->Selector,
                                      Builtin->Type,
                                      Blob,
                                      BlobSize);
 
        case PipSourceRegistryProperty:
            return PiPropReadDeviceRegistryProperty(Object, Builtin, Blob, BlobSize);
 
        case PipSourceDeviceNode:
            return PiPropReadDeviceNodeField(Object, Builtin->Selector, Blob, BlobSize);
 
        case PipSourceInterface:
            return PiPropReadInterfaceField(Object, Builtin->Selector, Blob, BlobSize);
 
        default:
            ASSERT(FALSE);
            return STATUS_INTERNAL_ERROR;
    }
}

Referenced by PiPropReadFromBuiltin().

PiPropReadDeviceNodeField()

static NTSTATUS PiPropReadDeviceNodeField ( _In_ PPIP_PROP_OBJECT  Object, _In_ PIP_PROP_FIELD  Field, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 1151 of file pnpprop.c.

{
    PDEVICE_NODE DeviceNode = Object->DeviceNode;
    DEVPROP_BOOLEAN Boolean;
    ULONG Value;
    NTSTATUS Status;
 
    switch (Field)
    {
        case PipFieldName:
            Status = PiPropReadKeyValue(Object, REGSTR_VAL_FRIENDLYNAME, REG_SZ,
                                        DEVPROP_TYPE_STRING, Blob, BlobSize);
            if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
            {
                Status = PiPropReadKeyValue(Object, REGSTR_VAL_DEVDESC, REG_SZ,
                                            DEVPROP_TYPE_STRING, Blob, BlobSize);
            }
            return Status;
 
        case PipFieldInstanceId:
            return PiPropCaptureString(Object->Name->Buffer,
                                       Object->Name->Length,
                                       FALSE,
                                       Blob,
                                       BlobSize);
 
        case PipFieldIsPresent:
            Boolean = (DeviceNode && !(DeviceNode->Flags & DNF_DEVICE_GONE)) ? DEVPROP_TRUE : DEVPROP_FALSE;
            *BlobSize = sizeof(Boolean);
            return PiPropAllocateBlob(&Boolean, sizeof(Boolean), Blob);
 
        default:
            break;
    }
 
    if (!DeviceNode)
        return STATUS_OBJECT_NAME_NOT_FOUND;
 
    switch (Field)
    {
        case PipFieldParent:
            if (!DeviceNode->Parent)
                return STATUS_OBJECT_NAME_NOT_FOUND;
 
            return PiPropCaptureString(DeviceNode->Parent->InstancePath.Buffer,
                                       DeviceNode->Parent->InstancePath.Length,
                                       FALSE,
                                       Blob,
                                       BlobSize);
 
        case PipFieldStatus:
            Value = IopGetDeviceNodeStatus(DeviceNode);
            break;
 
        case PipFieldProblemCode:
            Value = DeviceNode->Problem;
            break;
 
        case PipFieldHasProblem:
            Boolean = (DeviceNode->Flags & DNF_HAS_PROBLEM) ? DEVPROP_TRUE : DEVPROP_FALSE;
            *BlobSize = sizeof(Boolean);
            return PiPropAllocateBlob(&Boolean, sizeof(Boolean), Blob);
 
        default:
            ASSERT(FALSE);
            return STATUS_INTERNAL_ERROR;
    }
 
    *BlobSize = sizeof(Value);
    return PiPropAllocateBlob(&Value, sizeof(Value), Blob);
}

Referenced by PiPropReadBuiltin().

PiPropReadDeviceRegistryProperty()

static NTSTATUS PiPropReadDeviceRegistryProperty ( _In_ PPIP_PROP_OBJECT  Object, _In_ const PIP_BUILTIN_PROPERTY *  Builtin, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 1091 of file pnpprop.c.

{
    ULONG Length = 128, Needed;
    PVOID Buffer;
    NTSTATUS Status;
 
    if (!Object->Pdo)
        return STATUS_OBJECT_NAME_NOT_FOUND;
 
    for (;;)
    {
        Buffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_PNP_PROPERTY);
        if (!Buffer)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        Status = IoGetDeviceProperty(Object->Pdo,
                                     (DEVICE_REGISTRY_PROPERTY)Builtin->Selector,
                                     Length,
                                     Buffer,
                                     &Needed);
        if (Status != STATUS_BUFFER_TOO_SMALL)
            break;
 
        ExFreePoolWithTag(Buffer, TAG_PNP_PROPERTY);
 
        Length = ALIGN_UP_BY(max(Needed, Length * 2), sizeof(WCHAR));
        if (Length > PIP_PROP_MAX_QUERY_SIZE)
            return STATUS_UNSUCCESSFUL;
    }
 
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(Buffer, TAG_PNP_PROPERTY);
        return Status;
    }
 
    if (Builtin->Type == DEVPROP_TYPE_STRING)
    {
        Status = PiPropCaptureString(Buffer, Needed, FALSE, Blob, BlobSize);
        ExFreePoolWithTag(Buffer, TAG_PNP_PROPERTY);
        return Status;
    }
 
    if (Needed != PiPropTypeRules[Builtin->Type].Width)
    {
        ExFreePoolWithTag(Buffer, TAG_PNP_PROPERTY);
        return STATUS_OBJECT_TYPE_MISMATCH;
    }
 
    *Blob = Buffer;
    *BlobSize = Needed;
    return STATUS_SUCCESS;
}

Referenced by PiPropReadBuiltin().

PiPropReadFromBuiltin()

static BOOLEAN PiPropReadFromBuiltin ( _In_ PPIP_PROP_OBJECT  Object, _In_ PPIP_PROP_NAME  Name, _Inout_ PPIP_PROP_OUTPUT  Out, _Out_ PNTSTATUS  Status  )

static

Definition at line 1417 of file pnpprop.c.

{
    const PIP_BUILTIN_PROPERTY *Builtin;
    ULONG BlobSize;
    PVOID Blob;
 
    if (Name->Locale.Length)
        return FALSE;
 
    Builtin = PiPropFindBuiltin(Object, Name->Key);
    if (!Builtin)
        return FALSE;
 
    *Status = PiPropReadBuiltin(Object, Builtin, &Blob, &BlobSize);
    if (NT_SUCCESS(*Status))
    {
        *Status = PiPropCopyOut(Builtin->Type, Blob, BlobSize,
                                &Out->Type, Out->Data, Out->Size, &Out->Required);
        ExFreePoolWithTag(Blob, TAG_PNP_PROPERTY);
    }
 
    return TRUE;
}

PiPropReadFromSaved()

static BOOLEAN PiPropReadFromSaved ( _In_ PPIP_PROP_OBJECT  Object, _In_ PPIP_PROP_NAME  Name, _Inout_ PPIP_PROP_OUTPUT  Out, _Out_ PNTSTATUS  Status  )

static

Definition at line 1469 of file pnpprop.c.

{
    PPIP_PROP_SAVED_VALUE Saved;
 
    if (!PiPropIsInterruptKey(Object, Name))
        return FALSE;
 
    KeEnterCriticalRegion();
    ExAcquirePushLockShared(&PiPropSavedLock);
 
    Saved = PiPropFindSaved(Object->Pdo);
    if (Saved)
    {
        *Status = PiPropCopyOut(Saved->Type, Saved->Data, Saved->Size,
                                &Out->Type, Out->Data, Out->Size, &Out->Required);
    }
 
    ExReleasePushLockShared(&PiPropSavedLock);
    KeLeaveCriticalRegion();
 
    return (Saved != NULL);
}

PiPropReadFromStore()

static BOOLEAN PiPropReadFromStore ( _In_ PPIP_PROP_OBJECT  Object, _In_ PPIP_PROP_NAME  Name, _Inout_ PPIP_PROP_OUTPUT  Out, _Out_ PNTSTATUS  Status  )

static

Definition at line 1447 of file pnpprop.c.

{
    HANDLE ObjectKey;
 
    /* Writers change one value at a time, and a key deleted under us reads as not found */
    *Status = PiPropOpenObjectKey(Object, KEY_READ, &ObjectKey);
    if (NT_SUCCESS(*Status))
    {
        *Status = PiPropStoreQuery(ObjectKey, Name, &Out->Type,
                                   Out->Data, Out->Size, &Out->Required);
        ZwClose(ObjectKey);
    }
 
    return (PiPropNormalizeStatus(*Status) != STATUS_OBJECT_NAME_NOT_FOUND);
}

PiPropReadInterfaceField()

static NTSTATUS PiPropReadInterfaceField ( _In_ PPIP_PROP_OBJECT  Object, _In_ PIP_PROP_FIELD  Field, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 1229 of file pnpprop.c.

{
    UNICODE_STRING ControlName = RTL_CONSTANT_STRING(L"Control");
    HANDLE DeviceKey, InstanceKey, ControlKey;
    PKEY_VALUE_FULL_INFORMATION Info;
    DEVPROP_BOOLEAN Enabled;
    UNICODE_STRING Reference;
    NTSTATUS Status;
 
    Status = IopOpenDeviceInterfaceKeys(Object->Name, KEY_READ, &DeviceKey, &InstanceKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    switch (Field)
    {
        case PipFieldInterfaceClass:
            *BlobSize = sizeof(GUID);
            Status = PiPropAllocateBlob(&Object->ClassGuid, sizeof(GUID), Blob);
            break;
 
        case PipFieldInterfaceEnabled:
            Enabled = DEVPROP_FALSE;
            if (NT_SUCCESS(IopOpenRegistryKeyEx(&ControlKey, InstanceKey, &ControlName, KEY_QUERY_VALUE)))
            {
                if (NT_SUCCESS(IopGetRegistryValue(ControlKey, L"Linked", &Info)))
                {
                    if ((Info->Type == REG_DWORD) &&
                        (Info->DataLength == sizeof(ULONG)) &&
                        (*(PULONG)((PUCHAR)Info + Info->DataOffset) != 0))
                    {
                        Enabled = DEVPROP_TRUE;
                    }
                    ExFreePool(Info);
                }
                ZwClose(ControlKey);
            }
 
            *BlobSize = sizeof(Enabled);
            Status = PiPropAllocateBlob(&Enabled, sizeof(Enabled), Blob);
            break;
 
        case PipFieldInterfaceDevice:
            Status = PiPropReadRegistryValue(DeviceKey, L"DeviceInstance", REG_SZ,
                                             DEVPROP_TYPE_STRING, Blob, BlobSize);
            break;
 
        case PipFieldInterfaceReference:
            Status = PiPropGetInterfaceReference(Object->Name, &Reference);
            if (!NT_SUCCESS(Status))
                break;
 
            Status = PiPropCaptureString(Reference.Buffer, Reference.Length, FALSE, Blob, BlobSize);
            break;
 
        default:
            ASSERT(FALSE);
            Status = STATUS_INTERNAL_ERROR;
            break;
    }
 
    ZwClose(InstanceKey);
    ZwClose(DeviceKey);
    return Status;
}

Referenced by PiPropReadBuiltin().

PiPropReadKeyValue()

static NTSTATUS PiPropReadKeyValue ( _In_ PPIP_PROP_OBJECT  Object, _In_ PCWSTR  ValueName, _In_ ULONG  RegType, _In_ DEVPROPTYPE  Type, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 1069 of file pnpprop.c.

{
    HANDLE ObjectKey;
    NTSTATUS Status;
 
    Status = PiPropOpenObjectKey(Object, KEY_QUERY_VALUE, &ObjectKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = PiPropReadRegistryValue(ObjectKey, ValueName, RegType, Type, Blob, BlobSize);
    ZwClose(ObjectKey);
    return Status;
}

Referenced by PiPropReadBuiltin(), and PiPropReadDeviceNodeField().

PiPropReadRegistryValue()

static NTSTATUS PiPropReadRegistryValue ( _In_ HANDLE  KeyHandle, _In_ PCWSTR  ValueName, _In_ ULONG  RegType, _In_ DEVPROPTYPE  Type, _Outptr_result_bytebuffer_maybenull_ *BlobSize PVOID *  Blob, _Out_ PULONG  BlobSize  )

static

Definition at line 983 of file pnpprop.c.

{
    PKEY_VALUE_FULL_INFORMATION Info;
    PVOID RawData;
    ULONG RawSize;
    NTSTATUS Status;
 
    Status = IopGetRegistryValue(KeyHandle, (PWSTR)ValueName, &Info);
    if (!NT_SUCCESS(Status))
        return Status;
 
    RawData = (PUCHAR)Info + Info->DataOffset;
    RawSize = Info->DataLength;
 
    /* REG_EXPAND_SZ is accepted where REG_SZ is expected */
    if ((Info->Type != RegType) &&
        !((RegType == REG_SZ) && (Info->Type == REG_EXPAND_SZ)))
    {
        DPRINT1("Value '%S' has type %lu, expected %lu\n", ValueName, Info->Type, RegType);
        ExFreePool(Info);
        return STATUS_OBJECT_TYPE_MISMATCH;
    }
 
    switch (Type)
    {
        case DEVPROP_TYPE_STRING:
        case DEVPROP_TYPE_STRING_LIST:
            Status = PiPropCaptureString(RawData,
                                         RawSize,
                                         (Type == DEVPROP_TYPE_STRING_LIST),
                                         Blob,
                                         BlobSize);
            break;
 
        case DEVPROP_TYPE_UINT32:
            if (RawSize != sizeof(ULONG))
            {
                Status = STATUS_OBJECT_TYPE_MISMATCH;
                break;
            }
            Status = PiPropAllocateBlob(RawData, RawSize, Blob);
            *BlobSize = RawSize;
            break;
 
        case DEVPROP_TYPE_GUID:
        {
            UNICODE_STRING GuidString;
            GUID Guid;
 
            Status = PiPropCaptureString(RawData, RawSize, FALSE, Blob, BlobSize);
            if (!NT_SUCCESS(Status))
                break;
 
            RtlInitUnicodeString(&GuidString, *Blob);
            Status = RtlGUIDFromString(&GuidString, &Guid);
            if (NT_SUCCESS(Status))
            {
                RtlCopyMemory(*Blob, &Guid, sizeof(Guid));
                *BlobSize = sizeof(Guid);
            }
            else
            {
                ExFreePoolWithTag(*Blob, TAG_PNP_PROPERTY);
                Status = STATUS_OBJECT_TYPE_MISMATCH;
            }
            break;
        }
 
        default:
            ASSERT(FALSE);
            Status = STATUS_INTERNAL_ERROR;
            break;
    }
 
    ExFreePool(Info);
    return Status;
}

Referenced by PiPropReadInterfaceField(), and PiPropReadKeyValue().

PiPropReleaseDevice()

VOID PiPropReleaseDevice

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 1731 of file pnpprop.c.

{
    PAGED_CODE();
 
    PiPropReplaceSaved(DeviceObject, DEVPROP_TYPE_EMPTY, NULL, 0, NULL);
}

Referenced by IopDeleteDevice().

PiPropReplaceSaved()

static NTSTATUS PiPropReplaceSaved ( _In_ PDEVICE_OBJECT  Pdo, _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size, _Out_opt_ PBOOLEAN  Replaced  )

static

Definition at line 829 of file pnpprop.c.

{
    PPIP_PROP_SAVED_VALUE Fresh = NULL, Stale;
 
    if (Type != DEVPROP_TYPE_EMPTY)
    {
        Fresh = ExAllocatePoolWithTag(PagedPool,
                                      FIELD_OFFSET(PIP_PROP_SAVED_VALUE, Data) + Size,
                                      TAG_PNP_PROPERTY);
        if (!Fresh)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        Fresh->Pdo = Pdo;
        Fresh->Type = Type;
        Fresh->Size = Size;
        if (Size)
            RtlCopyMemory(Fresh->Data, Data, Size);
    }
 
    KeEnterCriticalRegion();
    ExAcquirePushLockExclusive(&PiPropSavedLock);
 
    Stale = PiPropFindSaved(Pdo);
    if (Stale)
        RemoveEntryList(&Stale->Link);
    if (Fresh)
        InsertTailList(&PiPropSavedValues, &Fresh->Link);
 
    ExReleasePushLockExclusive(&PiPropSavedLock);
    KeLeaveCriticalRegion();
 
    if (Replaced)
        *Replaced = (Stale != NULL);
 
    if (Stale)
        ExFreePoolWithTag(Stale, TAG_PNP_PROPERTY);
 
    return STATUS_SUCCESS;
}

Referenced by PiPropReleaseDevice(), and PiPropStoreApply().

PiPropSet()

static NTSTATUS PiPropSet ( _In_ PPIP_PROP_OBJECT  Object, _In_ const DEVPROPKEY *  PropertyKey, _In_ LCID  Lcid, _In_ DEVPROPTYPE  Type, _In_ ULONG  Size, _In_reads_bytes_opt_(Size) PVOID  Data  )

static

Definition at line 1629 of file pnpprop.c.

{
    const PIP_BUILTIN_PROPERTY *Builtin;
    PIP_PROP_TARGET Target;
    PIP_PROP_NAME Name;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    if (!PropertyKey)
        return STATUS_INVALID_PARAMETER;
 
    Status = PiPropCheckPayload(Type, Data, Size);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = PiPropInitName(&Name, PropertyKey, Lcid);
    if (!NT_SUCCESS(Status))
        return Status;
 
    if ((Type == DEVPROP_TYPE_STRING_INDIRECT) && Name.Locale.Length)
        return STATUS_INVALID_PARAMETER;
 
    Target = PiPropPickTarget(Object, &Name, &Builtin);
    if (Target == PipTargetDenied)
        return STATUS_ACCESS_DENIED;
 
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(&PpRegistryDeviceResource, TRUE);
 
    if (Target == PipTargetBuiltin)
        Status = PiPropWriteBuiltin(Object, Builtin, Type, Data, Size);
    else
        Status = PiPropStoreApply(Object, &Name, Type, Data, Size);
 
    ExReleaseResourceLite(&PpRegistryDeviceResource);
    KeLeaveCriticalRegion();
 
    if (Object->DeviceNode && PiPropShouldAnnounce(Object->DeviceNode))
        IopQueueDevicePropertyChangeEvent(&Object->DeviceNode->InstancePath);
 
    return PiPropNormalizeStatus(Status);
}

Referenced by _IRQL_requires_max_().

PiPropShouldAnnounce()

static BOOLEAN PiPropShouldAnnounce ( _In_ PDEVICE_NODE  DeviceNode )

inlinestatic

Definition at line 1612 of file pnpprop.c.

{
    switch (DeviceNode->State)
    {
        case DeviceNodeUnspecified:
        case DeviceNodeUninitialized:
        case DeviceNodeInitialized:
            return FALSE;
 
        default:
            return TRUE;
    }
}

Referenced by PiPropSet().

PiPropStoreApply()

static NTSTATUS PiPropStoreApply ( _In_ PPIP_PROP_OBJECT  Object, _In_ PPIP_PROP_NAME  Name, _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size  )

static

Definition at line 1570 of file pnpprop.c.

{
    BOOLEAN Replaced;
    HANDLE ObjectKey;
    NTSTATUS Status;
 
    Status = PiPropOpenObjectKey(Object, KEY_READ | KEY_CREATE_SUB_KEY, &ObjectKey);
    if (NT_SUCCESS(Status))
    {
        if (Type == DEVPROP_TYPE_EMPTY)
            Status = PiPropStoreDelete(ObjectKey, Name);
        else
            Status = PiPropStoreWrite(ObjectKey, Name, Type, Data, Size);
 
        ZwClose(ObjectKey);
    }
 
    if (!PiPropIsInterruptKey(Object, Name))
        return Status;
 
    if (NT_SUCCESS(Status))
        return PiPropReplaceSaved(Object->Pdo, Type, Data, Size, NULL);
 
    /* Deleting a value that only exists in the saved copy still succeeds */
    if ((Type == DEVPROP_TYPE_EMPTY) &&
        (PiPropNormalizeStatus(Status) == STATUS_OBJECT_NAME_NOT_FOUND))
    {
        PiPropReplaceSaved(Object->Pdo, Type, NULL, 0, &Replaced);
        if (Replaced)
            Status = STATUS_SUCCESS;
    }
 
    return Status;
}

Referenced by PiPropSet().

PiPropStoreDelete()

static NTSTATUS PiPropStoreDelete ( _In_ HANDLE  ObjectKey, _In_ PPIP_PROP_NAME  Name  )

static

Definition at line 758 of file pnpprop.c.

{
    UNICODE_STRING PropertiesName = RTL_CONSTANT_STRING(REGSTR_KEY_DEVICE_PROPERTIES);
    PUNICODE_STRING Chain[] = { &PropertiesName, &Name->Fmtid, &Name->Pid };
    HANDLE Keys[RTL_NUMBER_OF(Chain) + 1];
    ULONG Depth;
    NTSTATUS Status = STATUS_SUCCESS;
 
    Keys[0] = ObjectKey;
    for (Depth = 0; Depth < RTL_NUMBER_OF(Chain); Depth++)
    {
        Status = IopOpenRegistryKeyEx(&Keys[Depth + 1],
                                      Keys[Depth],
                                      Chain[Depth],
                                      KEY_QUERY_VALUE | KEY_SET_VALUE | DELETE);
        if (!NT_SUCCESS(Status))
            break;
    }
 
    if (NT_SUCCESS(Status))
        Status = ZwDeleteValueKey(Keys[Depth], &Name->Locale);
 
    for (; Depth > 0; Depth--)
    {
        if (NT_SUCCESS(Status) && PiPropIsKeyEmpty(Keys[Depth]))
            ZwDeleteKey(Keys[Depth]);
 
        ZwClose(Keys[Depth]);
    }
 
    return Status;
}

Referenced by PiPropStoreApply().

PiPropStoreQuery()

static NTSTATUS PiPropStoreQuery ( _In_ HANDLE  ObjectKey, _In_ PPIP_PROP_NAME  Name, _Out_ PDEVPROPTYPE  Type, _Out_writes_bytes_to_opt_(Size, *RequiredSize) PVOID  Data, _In_ ULONG  Size, _Out_ PULONG  RequiredSize  )

static

Definition at line 570 of file pnpprop.c.

{
    struct
    {
        KEY_VALUE_PARTIAL_INFORMATION Info;
        UCHAR Inline[64];
    } Small;
    PKEY_VALUE_PARTIAL_INFORMATION Info = &Small.Info;
    WCHAR PathBuffer[PIP_PROP_PATH_CHARS];
    UNICODE_STRING Path;
    HANDLE PropertyKey;
    ULONG InfoSize;
    NTSTATUS Status;
 
    Status = PiPropBuildValuePath(Name, &Path, PathBuffer);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = IopOpenRegistryKeyEx(&PropertyKey, ObjectKey, &Path, KEY_QUERY_VALUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    InfoSize = sizeof(Small);
    for (;;)
    {
        Status = ZwQueryValueKey(PropertyKey,
                                 &Name->Locale,
                                 KeyValuePartialInformation,
                                 Info,
                                 InfoSize,
                                 &InfoSize);
        if ((Status != STATUS_BUFFER_OVERFLOW) && (Status != STATUS_BUFFER_TOO_SMALL))
            break;
 
        if (Info != &Small.Info)
            ExFreePoolWithTag(Info, TAG_PNP_PROPERTY);
 
        Info = ExAllocatePoolWithTag(PagedPool, InfoSize, TAG_PNP_PROPERTY);
        if (!Info)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
    }
    ZwClose(PropertyKey);
 
    if (NT_SUCCESS(Status))
    {
        if ((Info->Type & PIP_PROP_REG_TYPE_MARK) == PIP_PROP_REG_TYPE_MARK)
        {
            Status = PiPropCopyOut(Info->Type & ~PIP_PROP_REG_TYPE_MARK,
                                   Info->Data,
                                   Info->DataLength,
                                   Type,
                                   Data,
                                   Size,
                                   RequiredSize);
        }
        else
        {
            DPRINT1("Unexpected value type 0x%lx for %wZ\\%wZ\n",
                    Info->Type, &Name->Fmtid, &Name->Pid);
            Status = STATUS_OBJECT_NAME_NOT_FOUND;
        }
    }
 
    if (Info && (Info != &Small.Info))
        ExFreePoolWithTag(Info, TAG_PNP_PROPERTY);
 
    return Status;
}

Referenced by PiPropReadFromStore().

PiPropStoreWrite()

static NTSTATUS PiPropStoreWrite ( _In_ HANDLE  ObjectKey, _In_ PPIP_PROP_NAME  Name, _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size  )

static

Definition at line 705 of file pnpprop.c.

{
    UNICODE_STRING PropertiesName = RTL_CONSTANT_STRING(REGSTR_KEY_DEVICE_PROPERTIES);
    PCUNICODE_STRING Parts[] = { &PropertiesName, &Name->Fmtid, &Name->Pid };
    WCHAR PathBuffer[PIP_PROP_PATH_CHARS];
    UNICODE_STRING Path;
    HANDLE ValueKey;
    NTSTATUS Status;
 
    Status = PiPropBuildValuePath(Name, &Path, PathBuffer);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = IopOpenRegistryKeyEx(&ValueKey, ObjectKey, &Path, KEY_SET_VALUE);
    if (!NT_SUCCESS(Status))
        return PiPropCreateBranch(ObjectKey, Parts, RTL_NUMBER_OF(Parts), Name, Type, Data, Size);
 
    Status = PiPropPutValue(ValueKey, Name, Type, Data, Size);
    ZwClose(ValueKey);
    return Status;
}

Referenced by PiPropStoreApply().

PiPropWriteBuiltin()

static NTSTATUS PiPropWriteBuiltin ( _In_ PPIP_PROP_OBJECT  Object, _In_ const PIP_BUILTIN_PROPERTY *  Builtin, _In_ DEVPROPTYPE  Type, _In_reads_bytes_opt_(Size) PVOID  Data, _In_ ULONG  Size  )

static

Definition at line 1333 of file pnpprop.c.

{
    static const UNICODE_STRING RootEnumerator = RTL_CONSTANT_STRING(L"ROOT\\");
    UNICODE_STRING ValueName;
    HANDLE ObjectKey;
    NTSTATUS Status;
 
    if ((Builtin->Flags & PIP_PROP_READ_ONLY) ||
        (Builtin->Source != PipSourceKeyValue))
    {
        return STATUS_ACCESS_DENIED;
    }
 
    if ((Builtin->Flags & PIP_PROP_ROOT_ENUM_WRITE) &&
        !RtlPrefixUnicodeString(&RootEnumerator, Object->Name, TRUE))
    {
        return STATUS_ACCESS_DENIED;
    }
 
    if ((Type != DEVPROP_TYPE_EMPTY) && (Type != Builtin->Type))
        return STATUS_INVALID_PARAMETER;
 
    Status = PiPropOpenObjectKey(Object, KEY_SET_VALUE, &ObjectKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    RtlInitUnicodeString(&ValueName, Builtin->ValueName);
 
    if (Type == DEVPROP_TYPE_EMPTY)
    {
        Status = ZwDeleteValueKey(ObjectKey, &ValueName);
    }
    else if (Type == DEVPROP_TYPE_GUID)
    {
        UNICODE_STRING GuidString;
        GUID Guid;
 
        RtlCopyMemory(&Guid, Data, sizeof(Guid));
        Status = RtlStringFromGUID(&Guid, &GuidString);
        if (NT_SUCCESS(Status))
        {
            Status = ZwSetValueKey(ObjectKey,
                                   &ValueName,
                                   0,
                                   REG_SZ,
                                   GuidString.Buffer,
                                   GuidString.Length + sizeof(UNICODE_NULL));
            RtlFreeUnicodeString(&GuidString);
        }
    }
    else
    {
        Status = ZwSetValueKey(ObjectKey, &ValueName, 0, Builtin->Selector, Data, Size);
    }
 
    ZwClose(ObjectKey);
    return Status;
}

Referenced by PiPropSet().

RTL_STATIC_LIST_HEAD()

static RTL_STATIC_LIST_HEAD ( PiPropSavedValues  )

static

Variable Documentation

PipDeviceBuiltins

const PIP_BUILTIN_PROPERTY PipDeviceBuiltins[]

static

Definition at line 97 of file pnpprop.c.

Referenced by PiPropBuiltinTable().

PipInterfaceBuiltins

const PIP_BUILTIN_PROPERTY PipInterfaceBuiltins[]

static

Initial value:

=
{
    { &DEVPKEY_DeviceInterface_ClassGuid,       DEVPROP_TYPE_GUID,    PipSourceInterface,        PIP_PROP_READ_ONLY,       NULL, PipFieldInterfaceClass },
    { &DEVPKEY_DeviceInterface_Enabled,         DEVPROP_TYPE_BOOLEAN, PipSourceInterface,        PIP_PROP_READ_ONLY,       NULL, PipFieldInterfaceEnabled },
    { &DEVPKEY_Device_InstanceId,               DEVPROP_TYPE_STRING,  PipSourceInterface,        PIP_PROP_READ_ONLY,       NULL, PipFieldInterfaceDevice },
    { &DEVPKEY_DeviceInterface_ReferenceString, DEVPROP_TYPE_STRING,  PipSourceInterface,        PIP_PROP_READ_ONLY,       NULL, PipFieldInterfaceReference },
}

Definition at line 132 of file pnpprop.c.

Referenced by PiPropBuiltinTable().

PiPropInterruptKey

const DEVPROPKEY PiPropInterruptKey

static

Initial value:

=
{
    { 0xF0E20F09, 0xD97A, 0x49A9, { 0x80, 0x46, 0xBB, 0x6E, 0x22, 0xE6, 0xBB, 0x2E } },
    2
}

Definition at line 140 of file pnpprop.c.

Referenced by PiPropIsInterruptKey().

PiPropReaders

const PIP_PROP_READER PiPropReaders[]

static

Initial value:

=
{
    PiPropReadFromBuiltin,
    PiPropReadFromStore,
    PiPropReadFromSaved
}

Definition at line 1496 of file pnpprop.c.

Referenced by PiPropGet().

PiPropSavedLock

EX_PUSH_LOCK PiPropSavedLock

static

Definition at line 805 of file pnpprop.c.

Referenced by PiPropReadFromSaved(), and PiPropReplaceSaved().

PiPropTypeRules

const PIP_PROP_TYPE_RULE PiPropTypeRules[MAX_DEVPROP_TYPE+1]

static

Initial value:

=
{
    { 0,                       FALSE, PipCheckNoData },     
    { 0,                       FALSE, PipCheckNoData },     
    { sizeof(CHAR),            FALSE, PipCheckNone },       
    { sizeof(UCHAR),           FALSE, PipCheckNone },       
    { sizeof(SHORT),           FALSE, PipCheckNone },       
    { sizeof(USHORT),          FALSE, PipCheckNone },       
    { sizeof(LONG),            FALSE, PipCheckNone },       
    { sizeof(ULONG),           FALSE, PipCheckNone },       
    { sizeof(LONGLONG),        FALSE, PipCheckNone },       
    { sizeof(ULONGLONG),       FALSE, PipCheckNone },       
    { sizeof(ULONG),           FALSE, PipCheckNone },       
    { sizeof(ULONGLONG),       FALSE, PipCheckNone },       
    { 16,                      FALSE, PipCheckNone },       
    { sizeof(GUID),            FALSE, PipCheckNone },       
    { sizeof(LONGLONG),        FALSE, PipCheckNone },       
    { sizeof(ULONGLONG),       FALSE, PipCheckNone },       
    { sizeof(LARGE_INTEGER),   FALSE, PipCheckFileTime },   
    { sizeof(DEVPROP_BOOLEAN), FALSE, PipCheckBoolean },    
    { 0,                       TRUE,  PipCheckString },     
    { 0,                       FALSE, PipCheckSecurity },   
    { 0,                       TRUE,  PipCheckString },     
    { sizeof(DEVPROPKEY),      FALSE, PipCheckNone },       
    { sizeof(DEVPROPTYPE),     FALSE, PipCheckNone },       
    { sizeof(ULONG),           FALSE, PipCheckNone },       
    { sizeof(NTSTATUS),        FALSE, PipCheckNone },       
    { 0,                       FALSE, PipCheckString },     
}

Definition at line 176 of file pnpprop.c.

Referenced by PiPropCheckPayload(), and PiPropReadDeviceRegistryProperty().