This graph shows which files directly or indirectly include this file:

Classes
struct	_USBD_INTERFACE_LIST_ENTRY

struct	_COMPOSITE_DEVICE_CAPABILITIES

struct	_REGISTER_COMPOSITE_DEVICE

struct	_REQUEST_REMOTE_WAKE_NOTIFICATION

Macros
#define	DECLSPEC_EXPORT __declspec(dllexport)

#define	UsbBuildInterruptOrBulkTransferRequest(urb, length, pipeHandle, transferBuffer, transferBufferMDL, transferBufferLength, transferFlags, link)

#define	UsbBuildGetDescriptorRequest(urb, length, descriptorType, descriptorIndex, languageId, transferBuffer, transferBufferMDL, transferBufferLength, link)

#define	UsbBuildGetStatusRequest(urb, op, index, transferBuffer, transferBufferMDL, link)

#define	UsbBuildFeatureRequest(urb, op, featureSelector, index, link)

#define	UsbBuildSelectConfigurationRequest(urb, length, configurationDescriptor)

#define	UsbBuildSelectInterfaceRequest(urb, length, configurationHandle, interfaceNumber, alternateSetting)

#define	UsbBuildVendorRequest(urb, cmd, length, transferFlags, reservedbits, request, value, index, transferBuffer, transferBufferMDL, transferBufferLength, link)

#define	UsbBuildOsFeatureDescriptorRequest(urb, length, interface, index, transferBuffer, transferBufferMDL, transferBufferLength, link)

#define	USBD_CLIENT_CONTRACT_VERSION_INVALID 0xFFFFFFFF

#define	USBD_CLIENT_CONTRACT_VERSION_602 0x602

#define	USBD_INTERFACE_VERSION_600 0x600

#define	USBD_INTERFACE_VERSION_602 0x602

#define	USBD_INTERFACE_VERSION_603 0x603

#define	URB_STATUS(urb) ((urb)->UrbHeader.Status)

#define	GET_SELECT_CONFIGURATION_REQUEST_SIZE(totalInterfaces, totalPipes)

#define	GET_SELECT_INTERFACE_REQUEST_SIZE(totalPipes)

#define	GET_USBD_INTERFACE_SIZE(numEndpoints)

#define	GET_ISO_URB_SIZE(n)

Typedefs
typedef struct _USBD_INTERFACE_LIST_ENTRY	USBD_INTERFACE_LIST_ENTRY

typedef struct _USBD_INTERFACE_LIST_ENTRY *	PUSBD_INTERFACE_LIST_ENTRY

typedef USBD_FUNCTION_HANDLE *	PUSBD_FUNCTION_HANDLE

typedef struct _COMPOSITE_DEVICE_CAPABILITIES	COMPOSITE_DEVICE_CAPABILITIES

typedef struct _COMPOSITE_DEVICE_CAPABILITIES *	PCOMPOSITE_DEVICE_CAPABILITIES

typedef struct _REGISTER_COMPOSITE_DEVICE	REGISTER_COMPOSITE_DEVICE

typedef struct _REGISTER_COMPOSITE_DEVICE *	PREGISTER_COMPOSITE_DEVICE

typedef struct _REQUEST_REMOTE_WAKE_NOTIFICATION	REQUEST_REMOTE_WAKE_NOTIFICATION

typedef struct _REQUEST_REMOTE_WAKE_NOTIFICATION *	PREQUEST_REMOTE_WAKE_NOTIFICATION

Functions
	DECLARE_HANDLE (USBD_HANDLE)

	DECLARE_HANDLE (USBDI_HANDLE)

	DECLARE_HANDLE (USBD_FUNCTION_HANDLE)

	_IRQL_requires_max_ (DISPATCH_LEVEL) DECLSPEC_IMPORT VOID NTAPI USBD_GetUSBDIVersion(_Out_ PUSBD_VERSION_INFORMATION VersionInformation)

DECLSPEC_IMPORT PUSB_INTERFACE_DESCRIPTOR NTAPI	USBD_ParseConfigurationDescriptor (_In_ PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, _In_ UCHAR InterfaceNumber, _In_ UCHAR AlternateSetting)

DECLSPEC_IMPORT PURB NTAPI	USBD_CreateConfigurationRequest (_In_ PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, _Out_ PUSHORT Siz)

	_IRQL_requires_max_ (APC_LEVEL) DECLSPEC_IMPORT PUSB_COMMON_DESCRIPTOR NTAPI USBD_ParseDescriptors(_In_ PVOID DescriptorBuffer
	Probes and locks virtual pages in memory for the specified process.

	_IRQL_requires_max_ (PASSIVE_LEVEL) DECLSPEC_EXPORT ULONG NTAPI USBD_GetInterfaceLength(_In_ PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor
	Queries information details about a security descriptor.

	_Inout_updates_bytes_ (ParameterLength) PVOID Parameter

_In_ ULONG	_In_reads_bytes_ (KeyNameLength) PWSTR KeyName

DECLSPEC_EXPORT NTSTATUS NTAPI	USBD_QueryBusTime (_In_ PDEVICE_OBJECT RootHubPdo, _Out_ PULONG CurrentFrame)

_Must_inspect_result_	_IRQL_requires_ (PASSIVE_LEVEL) NTSTATUS NTAPI USBD_CreateHandle(_In_ PDEVICE_OBJECT DeviceObject
	Sends a synchronous IOCTL to the specified device object.

_Must_inspect_result_ _In_ const GUID _In_ ULONG	_When_ (OutputBufferLength==0, _Pre_null_) _When_(OutputBufferLength !=0 &&ResultLength

_Must_inspect_result_ _In_ const GUID _In_ ULONG	_Out_writes_bytes_ (OutputBufferLength)) _When_(OutputBufferLength !=0 &&ResultLength !

_Must_inspect_result_ _In_ const GUID _In_ ULONG	_Out_writes_bytes_to_opt_ (OutputBufferLength, *ResultLength)) PUCHAR OutputBuffer

_Must_inspect_result_ _In_ const GUID _In_ ULONG _Out_opt_	_When_ (ResultLength !=NULL, _Deref_out_range_(<=, OutputBufferLength)) PULONG ResultLength)

	_Outptr_result_bytebuffer_ (sizeof(URB)) PURB *Urb)

_In_ ULONG	_Outptr_result_bytebuffer_ (sizeof(struct _URB_ISOCH_TRANSFER)+(NumberOfIsochPackets sizeof(USBD_ISO_PACKET_DESCRIPTOR)) - sizeof(USBD_ISO_PACKET_DESCRIPTOR)) PURB Urb)

	DEFINE_GUID (GUID_USB_CAPABILITY_CHAINED_MDLS, 0xf5ceeb23, 0xad90, 0x458c, 0x97, 0x9a, 0xd5, 0x9b, 0x3a, 0xd6, 0x88, 0x4f)

	DEFINE_GUID (GUID_USB_CAPABILITY_STATIC_STREAMS, 0x09051e1f, 0x0dc9, 0x4e6b, 0x8b, 0x12, 0x96, 0x0c, 0xbd, 0x81, 0xaa, 0x8f)

	DEFINE_GUID (GUID_USB_CAPABILITY_SELECTIVE_SUSPEND, 0x755c630d, 0xc8a0, 0x4765, 0x94, 0x6f, 0x90, 0xcc, 0x70, 0x38, 0x56, 0xa4)

	DEFINE_GUID (GUID_USB_CAPABILITY_FUNCTION_SUSPEND, 0xf4563183, 0xd66e, 0x42bd, 0xbd, 0x53, 0x1a, 0xc7, 0xb0, 0x4c, 0xd5, 0x9d)

	DEFINE_GUID (GUID_USB_CAPABILITY_HIGH_BANDWIDTH_ISOCH, 0x9c8a8a27, 0x15f9, 0x42e3, 0xa3, 0x56, 0xcd, 0xa6, 0xae, 0x97, 0xa8, 0xc8)

	DEFINE_GUID (GUID_USB_CAPABILITY_DEVICE_CONNECTION_HIGH_SPEED_COMPATIBLE, 0x81a885a6, 0xf239, 0x42a2, 0x83, 0x97, 0xa5, 0xd9, 0x5b, 0xea, 0x69, 0x53)

	DEFINE_GUID (GUID_USB_CAPABILITY_DEVICE_CONNECTION_SUPER_SPEED_COMPATIBLE, 0x8a2f776c, 0x9bd0, 0x4f29, 0x97, 0x71, 0xc7, 0xa3, 0x88, 0x46, 0xd4, 0xc7)

	DEFINE_GUID (GUID_USB_CAPABILITY_TIME_SYNC, 0xbb6e6472, 0x4be5, 0x44a3, 0x96, 0x41, 0x34, 0x5e, 0x56, 0xac, 0x34, 0x85)

	DEFINE_GUID (GUID_USB_CAPABILITY_SSP_ISOCH_PIPE_FLAGS, 0x59819125, 0x33a3, 0x421a, 0xa5, 0xdd, 0x37, 0x63, 0x9f, 0x30, 0xb9, 0x3e)

	DEFINE_GUID (GUID_USB_CAPABILITY_CONTROLLER_EUSB2_DOUBLE_ISOCH_COMPATIBLE, 0x5f0e4b3f, 0xde94, 0x473a, 0xa3, 0x73, 0x78, 0x1a, 0xcb, 0x92, 0xb5, 0xe8)

Variables
_In_ ULONG	TotalLength

_In_ ULONG _In_ PVOID	StartPosition

_In_ ULONG _In_ PVOID _In_ LONG	DescriptorType

_In_ PVOID _In_ LONG	InterfaceNumber

_In_ PVOID _In_ LONG _In_ LONG	AlternateSetting

_In_ PVOID _In_ LONG _In_ LONG _In_ LONG	InterfaceClass

_In_ PVOID _In_ LONG _In_ LONG _In_ LONG _In_ LONG	InterfaceSubClass

_In_ PVOID _In_ LONG _In_ LONG _In_ LONG _In_ LONG _In_ LONG	InterfaceProtocol

_In_ PUSBD_INTERFACE_LIST_ENTRY	InterfaceList

_In_ PUCHAR	BufferEnd

_In_ PDEVICE_OBJECT	FilterDeviceObject

_In_ ULONG	ParameterLength

_In_ ULONG _In_ ULONG	KeyNameLength

_In_ UCHAR	EndpointType

_In_ UCHAR _In_ BOOLEAN	LowSpeed

_In_ ULONG	BufferLength

_In_ ULONG _In_ USHORT	Level

_In_ ULONG _In_ USHORT _Out_ PUCHAR *	Offset

_In_ ULONG _In_ USHORT _Out_ PUCHAR _In_opt_ ULONG	Tag

_Must_inspect_result_ _In_ PDEVICE_OBJECT	TargetDeviceObject

_Must_inspect_result_ _In_ PDEVICE_OBJECT _In_ ULONG	USBDClientContractVersion

_Must_inspect_result_ _In_ PDEVICE_OBJECT _In_ ULONG _In_ ULONG	PoolTag

_Must_inspect_result_ _In_ PDEVICE_OBJECT _In_ ULONG _In_ ULONG _Out_ USBD_HANDLE *	USBDHandle

_Must_inspect_result_ _In_ const GUID *	CapabilityType

_Must_inspect_result_ _In_ const GUID _In_ ULONG	OutputBufferLength

_In_ ULONG	NumberOfIsochPackets

_In_opt_ PUSB_CONFIGURATION_DESCRIPTOR	ConfigurationDescriptor

_In_opt_ PUSB_CONFIGURATION_DESCRIPTOR _Inout_ PUSBD_INTERFACE_LIST_ENTRY _Outptr_ PURB *	Urb

_In_ USBD_CONFIGURATION_HANDLE	ConfigurationHandle

_In_ USBD_CONFIGURATION_HANDLE _Inout_ PUSBD_INTERFACE_LIST_ENTRY	InterfaceListEntry

_In_ PIO_STACK_LOCATION	IoStackLocation

_In_ ULONG	USBDInterfaceVersion

_In_ COMPOSITE_DEVICE_CAPABILITIES	CapabilityFlags

_In_ COMPOSITE_DEVICE_CAPABILITIES _In_ ULONG	FunctionCount

_In_ COMPOSITE_DEVICE_CAPABILITIES _In_ ULONG _Out_ PREGISTER_COMPOSITE_DEVICE	RegisterCompositeDevice

Macro Definition Documentation

◆ DECLSPEC_EXPORT

#define DECLSPEC_EXPORT __declspec(dllexport)

Definition at line 4 of file usbdlib.h.

◆ GET_ISO_URB_SIZE

#define GET_ISO_URB_SIZE ( n )

Value:

(sizeof(struct _URB_ISOCH_TRANSFER)+ \

sizeof(USBD_ISO_PACKET_DESCRIPTOR)*n)

n

GLdouble n

Definition: glext.h:7729

_URB_ISOCH_TRANSFER

Definition: usb.h:526

_USBD_ISO_PACKET_DESCRIPTOR

Definition: usb.h:520

sizeof

ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

Definition at line 152 of file usbdlib.h.

◆ GET_SELECT_CONFIGURATION_REQUEST_SIZE

#define GET_SELECT_CONFIGURATION_REQUEST_SIZE	(	totalInterfaces,
		totalPipes
	)

Value:

  (sizeof(struct _URB_SELECT_CONFIGURATION) +                              \
  ((totalInterfaces-1) * sizeof(USBD_INTERFACE_INFORMATION)) +             \
  ((totalPipes-totalInterfaces)*sizeof(USBD_PIPE_INFORMATION)))

Definition at line 139 of file usbdlib.h.

◆ GET_SELECT_INTERFACE_REQUEST_SIZE

#define GET_SELECT_INTERFACE_REQUEST_SIZE ( totalPipes )

Value:

(sizeof(struct _URB_SELECT_INTERFACE) + \

((totalPipes-1)*sizeof(USBD_PIPE_INFORMATION)))

_URB_SELECT_INTERFACE

Definition: usb.h:313

USBD_PIPE_INFORMATION

struct _USBD_PIPE_INFORMATION USBD_PIPE_INFORMATION

Definition at line 144 of file usbdlib.h.

◆ GET_USBD_INTERFACE_SIZE

#define GET_USBD_INTERFACE_SIZE ( numEndpoints )

Value:

(sizeof(USBD_INTERFACE_INFORMATION) + \

(sizeof(USBD_PIPE_INFORMATION)*(numEndpoints)) - sizeof(USBD_PIPE_INFORMATION))

Definition at line 148 of file usbdlib.h.

◆ URB_STATUS

#define URB_STATUS ( urb ) ((urb)->UrbHeader.Status)

Definition at line 137 of file usbdlib.h.

◆ UsbBuildFeatureRequest

#define UsbBuildFeatureRequest	(	urb,
		op,
		featureSelector,
		index,
		link
	)

Value:

  {  \
  (urb)->UrbHeader.Function =  (op);                                     \
  (urb)->UrbHeader.Length = sizeof(struct _URB_CONTROL_FEATURE_REQUEST); \
  (urb)->UrbControlFeatureRequest.FeatureSelector = (featureSelector);   \
  (urb)->UrbControlFeatureRequest.Index = (index);                       \
  (urb)->UrbControlFeatureRequest.UrbLink = (link);                      \
}

Definition at line 45 of file usbdlib.h.

◆ UsbBuildGetDescriptorRequest

#define UsbBuildGetDescriptorRequest	(	urb,
		length,
		descriptorType,
		descriptorIndex,
		languageId,
		transferBuffer,
		transferBufferMDL,
		transferBufferLength,
		link
	)

Value:

  { \
  (urb)->UrbHeader.Function =  URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE;                                                                                         \
  (urb)->UrbHeader.Length = (length);                                                                                                                           \
  (urb)->UrbControlDescriptorRequest.TransferBufferLength = (transferBufferLength);                                                                             \
  (urb)->UrbControlDescriptorRequest.TransferBufferMDL = (transferBufferMDL);                                                                                   \
  (urb)->UrbControlDescriptorRequest.TransferBuffer = (transferBuffer);                                                                                         \
  (urb)->UrbControlDescriptorRequest.DescriptorType = (descriptorType);                                                                                         \
  (urb)->UrbControlDescriptorRequest.Index = (descriptorIndex);                                                                                                 \
  (urb)->UrbControlDescriptorRequest.LanguageId = (languageId);                                                                                                 \
  (urb)->UrbControlDescriptorRequest.UrbLink = (link);                                                                                                          \
}

Definition at line 23 of file usbdlib.h.

◆ UsbBuildGetStatusRequest

#define UsbBuildGetStatusRequest	(	urb,
		op,
		index,
		transferBuffer,
		transferBufferMDL,
		link
	)

Value:

  { \
  (urb)->UrbHeader.Function =  (op);                                                        \
  (urb)->UrbHeader.Length = sizeof(struct _URB_CONTROL_GET_STATUS_REQUEST);                 \
  (urb)->UrbControlGetStatusRequest.TransferBufferLength = sizeof(USHORT);                  \
  (urb)->UrbControlGetStatusRequest.TransferBufferMDL = (transferBufferMDL);                \
  (urb)->UrbControlGetStatusRequest.TransferBuffer = (transferBuffer);                      \
  (urb)->UrbControlGetStatusRequest.Index = (index);                                        \
  (urb)->UrbControlGetStatusRequest.UrbLink = (link);                                       \
}

Definition at line 35 of file usbdlib.h.

◆ UsbBuildInterruptOrBulkTransferRequest

#define UsbBuildInterruptOrBulkTransferRequest	(	urb,
		length,
		pipeHandle,
		transferBuffer,
		transferBufferMDL,
		transferBufferLength,
		transferFlags,
		link
	)

Value:

  { \
  (urb)->UrbHeader.Function = URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER;                                                                                 \
  (urb)->UrbHeader.Length = (length);                                                                                                                  \
  (urb)->UrbBulkOrInterruptTransfer.PipeHandle = (pipeHandle);                                                                                         \
  (urb)->UrbBulkOrInterruptTransfer.TransferBufferLength = (transferBufferLength);                                                                     \
  (urb)->UrbBulkOrInterruptTransfer.TransferBufferMDL = (transferBufferMDL);                                                                           \
  (urb)->UrbBulkOrInterruptTransfer.TransferBuffer = (transferBuffer);                                                                                 \
  (urb)->UrbBulkOrInterruptTransfer.TransferFlags = (transferFlags);                                                                                   \
  (urb)->UrbBulkOrInterruptTransfer.UrbLink = (link);                                                                                                  \
}

Definition at line 12 of file usbdlib.h.

◆ UsbBuildOsFeatureDescriptorRequest

#define UsbBuildOsFeatureDescriptorRequest	(	urb,
		length,
		interface,
		index,
		transferBuffer,
		transferBufferMDL,
		transferBufferLength,
		link
	)

Value:

  { \
  (urb)->UrbHeader.Function = URB_FUNCTION_GET_MS_FEATURE_DESCRIPTOR;                                                                      \
  (urb)->UrbHeader.Length = (length);                                                                                                      \
  (urb)->UrbOSFeatureDescriptorRequest.TransferBufferLength = (transferBufferLength);                                                      \
  (urb)->UrbOSFeatureDescriptorRequest.TransferBufferMDL = (transferBufferMDL);                                                            \
  (urb)->UrbOSFeatureDescriptorRequest.TransferBuffer = (transferBuffer);                                                                  \
  (urb)->UrbOSFeatureDescriptorRequest.InterfaceNumber = (interface);                                                                      \
  (urb)->UrbOSFeatureDescriptorRequest.MS_FeatureDescriptorIndex = (index);                                                                \
  (urb)->UrbOSFeatureDescriptorRequest.UrbLink = (link);                                                                                    \
}

Definition at line 84 of file usbdlib.h.

◆ UsbBuildSelectConfigurationRequest

#define UsbBuildSelectConfigurationRequest	(	urb,
		length,
		configurationDescriptor
	)

Value:

  {   \
  (urb)->UrbHeader.Function =  URB_FUNCTION_SELECT_CONFIGURATION;                    \
  (urb)->UrbHeader.Length = (length);                                                \
  (urb)->UrbSelectConfiguration.ConfigurationDescriptor = (configurationDescriptor); \
}

Definition at line 53 of file usbdlib.h.

◆ UsbBuildSelectInterfaceRequest

#define UsbBuildSelectInterfaceRequest	(	urb,
		length,
		configurationHandle,
		interfaceNumber,
		alternateSetting
	)

Value:

  {             \
  (urb)->UrbHeader.Function =  URB_FUNCTION_SELECT_INTERFACE;                                                             \
  (urb)->UrbHeader.Length = (length);                                                                                     \
  (urb)->UrbSelectInterface.Interface.AlternateSetting = (alternateSetting);                                              \
  (urb)->UrbSelectInterface.Interface.InterfaceNumber = (interfaceNumber);                                                \
  (urb)->UrbSelectInterface.Interface.Length = (length - sizeof(struct _URB_HEADER) - sizeof(USBD_CONFIGURATION_HANDLE)); \
  (urb)->UrbSelectInterface.ConfigurationHandle = (configurationHandle);                                                  \
}

Definition at line 59 of file usbdlib.h.

◆ UsbBuildVendorRequest

#define UsbBuildVendorRequest	(	urb,
		cmd,
		length,
		transferFlags,
		reservedbits,
		request,
		value,
		index,
		transferBuffer,
		transferBufferMDL,
		transferBufferLength,
		link
	)

Value:

  { \
  (urb)->UrbHeader.Function =  cmd;                                                                                                                                  \
  (urb)->UrbHeader.Length = (length);                                                                                                                                \
  (urb)->UrbControlVendorClassRequest.TransferBufferLength = (transferBufferLength);                                                                                 \
  (urb)->UrbControlVendorClassRequest.TransferBufferMDL = (transferBufferMDL);                                                                                       \
  (urb)->UrbControlVendorClassRequest.TransferBuffer = (transferBuffer);                                                                                             \
  (urb)->UrbControlVendorClassRequest.RequestTypeReservedBits = (reservedbits);                                                                                      \
  (urb)->UrbControlVendorClassRequest.Request = (request);                                                                                                           \
  (urb)->UrbControlVendorClassRequest.Value = (value);                                                                                                               \
  (urb)->UrbControlVendorClassRequest.Index = (index);                                                                                                               \
  (urb)->UrbControlVendorClassRequest.TransferFlags = (transferFlags);                                                                                               \
  (urb)->UrbControlVendorClassRequest.UrbLink = (link);                                                                                                              \
}

Definition at line 68 of file usbdlib.h.

◆ USBD_CLIENT_CONTRACT_VERSION_602

#define USBD_CLIENT_CONTRACT_VERSION_602 0x602

Definition at line 100 of file usbdlib.h.

◆ USBD_CLIENT_CONTRACT_VERSION_INVALID

#define USBD_CLIENT_CONTRACT_VERSION_INVALID 0xFFFFFFFF

Definition at line 99 of file usbdlib.h.

◆ USBD_INTERFACE_VERSION_600

#define USBD_INTERFACE_VERSION_600 0x600

Definition at line 102 of file usbdlib.h.

◆ USBD_INTERFACE_VERSION_602

#define USBD_INTERFACE_VERSION_602 0x602

Definition at line 103 of file usbdlib.h.

◆ USBD_INTERFACE_VERSION_603

#define USBD_INTERFACE_VERSION_603 0x603

Definition at line 104 of file usbdlib.h.

Typedef Documentation

◆ COMPOSITE_DEVICE_CAPABILITIES

typedef struct _COMPOSITE_DEVICE_CAPABILITIES COMPOSITE_DEVICE_CAPABILITIES

◆ PCOMPOSITE_DEVICE_CAPABILITIES

typedef struct _COMPOSITE_DEVICE_CAPABILITIES * PCOMPOSITE_DEVICE_CAPABILITIES

◆ PREGISTER_COMPOSITE_DEVICE

typedef struct _REGISTER_COMPOSITE_DEVICE * PREGISTER_COMPOSITE_DEVICE

◆ PREQUEST_REMOTE_WAKE_NOTIFICATION

typedef struct _REQUEST_REMOTE_WAKE_NOTIFICATION * PREQUEST_REMOTE_WAKE_NOTIFICATION

◆ PUSBD_FUNCTION_HANDLE

typedef USBD_FUNCTION_HANDLE* PUSBD_FUNCTION_HANDLE

Definition at line 111 of file usbdlib.h.

◆ PUSBD_INTERFACE_LIST_ENTRY

typedef struct _USBD_INTERFACE_LIST_ENTRY * PUSBD_INTERFACE_LIST_ENTRY

◆ REGISTER_COMPOSITE_DEVICE

typedef struct _REGISTER_COMPOSITE_DEVICE REGISTER_COMPOSITE_DEVICE

◆ REQUEST_REMOTE_WAKE_NOTIFICATION

typedef struct _REQUEST_REMOTE_WAKE_NOTIFICATION REQUEST_REMOTE_WAKE_NOTIFICATION

◆ USBD_INTERFACE_LIST_ENTRY

typedef struct _USBD_INTERFACE_LIST_ENTRY USBD_INTERFACE_LIST_ENTRY

Function Documentation

◆ _In_reads_bytes_()

_In_ ULONG _In_reads_bytes_ ( KeyNameLength )

◆ _Inout_updates_bytes_()

_Inout_updates_bytes_ ( ParameterLength )

◆ _IRQL_requires_()

_Must_inspect_result_ _IRQL_requires_ ( PASSIVE_LEVEL )

Sends a synchronous IOCTL to the specified device object.

Parameters

[in]	IoControlCode	The IOCTL to send to the device.
[in]	DeviceObject	Pointer to the device object that will handle the IOCTL.
[in]	InputBuffer	Optional pointer to a buffer containing input data for the IOCTL. When specified, the buffer should be at least of InputBufferLength size.
[in]	InputBufferLength	Size in bytes, of the buffer pointed by InputBuffer.
[out]	OutputBuffer	Optional pointer to a buffer that will receive output data from the IOCTL. When specified, the buffer should be at least of OutputBufferLength size.
[in]	OutputBufferLength	Size in bytes, of the buffer pointed by OutputBuffer.
[in]	FileObject	Optional pointer to a file object that may be necessary for the IOCTL.

Returns: An NTSTATUS code indicating success or failure of this function.

Note: Must be called at PASSIVE_LEVEL with all APCs enabled.

Nothing is found unless the PCI bus driver publishes the properties.

The root hub name without its prefix; NULL when the PDO has no name.

Grows a private buffer to what the helper asks for.

Lets KMDF handle the IRP, then hands it back here still uncompleted.

Waits for the device machine to answer a PnP or power event; returns the PnP status.

Deletes the UCX endpoints of the disabled pipes, then the interface record.

One 4 byte value; the registry type is not checked.

Reread whenever user experience settings change; the open status is returned.

Sends a synchronous IOCTL to the specified device object.

STATUS_SUCCESS when the caller's token is an administrator's.

Sends a synchronous IOCTL to the specified device object.

Reads one value of a walk. A missing value only clears Present; FALSE means stop.

Reads up to Size bytes of a value into a zeroed buffer; the type is not checked.

Writes a REG_BINARY value into the device's usbflags subkey.

Sets or clears ExtPropertiesInstalled from ExtPropDescSemaphore in the hardware key.

Fails only when a port cannot be bound to the USB4 host router its ACPI node names.

Assigns device, hardware, compatible, container and instance ids to a new child PDO.

Answers IRP_MN_QUERY_DEVICE_TEXT on a child PDO; always completes the IRP.

Takes the connector map lock, needed around HubConnectorFindCompanion.

Device hardware key values read at PDO prepare hardware.

Saves the MS OS 2.0 set info in usbflags when the set asks for alternate enumeration.

MsOs20Flags and EnumerationRetryCount, written at PDO start.

Rereads the UXD record; UpdateRequired says whether the device id changes.

Replacement PnP id of a UXD reserved device, or an empty String. Always succeeds.

Telemetry values under the device's Ceip subkey.

BootPathSurpriseRemovalCount + 1.

This machine's dual role features for a dual role partner.

Tells UCX the WDM PDO of the device; call right after the child PDO was created.

IOCTL_INTERNAL_USB_GET_CONTROLLER_NAME: Argument1 and its length Argument2.

IOCTL_INTERNAL_USB_GET_BUS_INFO for the device: the 16 byte USB_BUS_NOTIFICATION at Argument1.

Registers the GUID_USB_WMI_NODE_INFO instance of a child PDO (not for hubs or composites).

Registers the boot device surprise removal event on an external, non hub boot PDO.

Fires the boot device surprise removal event, if one is registered.

Sends a synchronous IOCTL to the specified device object.

Publishes "<port>#<host>" for every bound port on the hub's PDO. QUIRK: with no bound port an older value is left in place.

Binds USB 3 ports to the host routers named by the USB4 DVSEC; an earlier ACPI mapping wins.

Waits on a PnP handshake event with no timeout, printing a watchdog line every minute so a stuck machine is visible in the debugger.

Copies up to Size bytes of a device property; a failed query leaves the field zero.

Only the controller name length is real; both bandwidth fields read 0.

The answer overlays a USB_HUB_NAME on TotalSize, so TotalSize comes back as the name length + 4.

Evaluates a method without arguments into Output.

Drops every MSI descriptor and keeps only lists that still offer a line interrupt.

Picks the list with the best MSI offer: MSI-X first, then the most messages.

Keeps message descriptors covering Wanted messages and removes the others.

Evaluates _DSM on the controller ACPI object with a buffer as Arg3; returns up to 8 result bytes, 0 on failure.

Definition at line 2121 of file class.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Entering function.\n",
                DeviceObject));
 
    //
    // Send down Inquiry for VPD_THIRD_PARTY_COPY_PAGE and cache away the device parameters
    // from WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR.
    //
    status = ClasspGetBlockDeviceTokenLimitsInfo(DeviceObject);
 
    if (NT_SUCCESS(status)) {
 
        ULONG maxListIdentifier = MaxTokenOperationListIdentifier;
 
        //
        // Query the maximum list identifier to use for TokenOperation commands.
        //
        if (NT_SUCCESS(ClasspGetMaximumTokenListIdentifier(DeviceObject, REG_DISK_CLASS_CONTROL, &maxListIdentifier))) {
            if (maxListIdentifier >= MIN_TOKEN_LIST_IDENTIFIERS) {
 
                NT_ASSERT(maxListIdentifier <= MAX_TOKEN_LIST_IDENTIFIERS);
                MaxTokenOperationListIdentifier = maxListIdentifier;
            }
        }
 
    }
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));
 
    return status;
}

◆ _IRQL_requires_max_() [1/3]

_IRQL_requires_max_ ( APC_LEVEL )

Probes and locks virtual pages in memory for the specified process.

Parameters

[in,out]	MemoryDescriptorList	Memory Descriptor List (MDL) containing the buffer to be probed and locked.
[in]	Process	The process for which the buffer should be probed and locked.
[in]	AccessMode	Access mode for probing the pages. Can be KernelMode or UserMode.
[in]	LockOperation	The type of the probing and locking operation. Can be IoReadAccess, IoWriteAccess or IoModifyAccess.

Returns: Nothing.

See also: MmProbeAndLockPages

Remarks: Must be called at IRQL <= APC_LEVEL

Probes and locks virtual pages in memory for the specified process.

Frees previously reserved amount of memory in system virtual address space.

Parameters

[in]	NumberOfBytes	Size, in bytes, of memory to reserve.
[in]	PoolTag	Pool Tag identifying the buffer. Usually consists from 4 characters in reversed order.

Returns: A pointer to the 1st memory block of the reserved buffer in case of success, NULL otherwise.

Remarks: Must be called at IRQL <= APC_LEVEL

Parameters

[in]	BaseAddress	A pointer to the 1st memory block of the reserved buffer.
[in]	PoolTag	Pool Tag identifying the buffer. Usually consists from 4 characters in reversed order.

Returns: Nothing.

See also: MmAllocateMappingAddress

Remarks: Must be called at IRQL <= APC_LEVEL

Definition at line 37 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;
 
#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif
 
    NTSTATUS Status;
 
#if DBG
 
    KIRQL SaveIrql = KeGetCurrentIrql();
 
#endif
 
    ASSERT_OPTIONAL_IRP( Irp );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    FsRtlEnterFileSystem();
 
#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif
 
    //
    //  Loop until this request has been completed or posted.
    //
 
    do {
 
        //
        //  Use a try-except to handle the exception cases.
        //
 
        _SEH2_TRY {
 
            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //
 
            if (IrpContext == NULL) {
 
                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //
 
                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
 
                    Wait = TRUE;
 
                } else {
 
                    Wait = CanFsdWait( Irp );
                }
 
                IrpContext = CdCreateIrpContext( Irp, Wait );
 
                //
                //  Update the thread context information.
                //
 
                CdSetThreadContext( IrpContext, &ThreadContext );
 
#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif
 
            //
            //  Otherwise cleanup the IrpContext for the retry.
            //
 
            } else {
 
                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //
 
                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }
 
            //
            //  Case on the major irp code.
            //
 
            switch (IrpContext->MajorFunction) {
 
            case IRP_MJ_CREATE :
 
                Status = CdCommonCreate( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLOSE :
 
                Status = CdCommonClose( IrpContext, Irp );
                break;
 
            case IRP_MJ_READ :
 
                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //
 
                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {
 
                    Status = CdCompleteMdl( IrpContext, Irp );
 
                } else {
 
                    Status = CdCommonRead( IrpContext, Irp );
                }
 
                break;
 
            case IRP_MJ_WRITE :
 
                Status = CdCommonWrite( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_INFORMATION :
 
                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_SET_INFORMATION :
 
                Status = CdCommonSetInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_VOLUME_INFORMATION :
 
                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_DIRECTORY_CONTROL :
 
                Status = CdCommonDirControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_FILE_SYSTEM_CONTROL :
 
                Status = CdCommonFsControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_DEVICE_CONTROL :
 
                Status = CdCommonDevControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_LOCK_CONTROL :
 
                Status = CdCommonLockControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLEANUP :
 
                Status = CdCommonCleanup( IrpContext, Irp );
                break;
 
            case IRP_MJ_PNP :
 
                Status = CdCommonPnp( IrpContext, Irp );
                break;
 
            case IRP_MJ_SHUTDOWN :
 
                Status = CdCommonShutdown( IrpContext, Irp );
                break;
 
            default :
 
                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }
 
        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;
 
    } while (Status == STATUS_CANT_WAIT);
 
#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif
 
    FsRtlExitFileSystem();
 
    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));
 
    return Status;
}

◆ _IRQL_requires_max_() [2/3]

_IRQL_requires_max_ ( DISPATCH_LEVEL )

IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION; the idle machine owns the IRP afterwards.

Records hub over current in the hub hardware key, once per devnode.

First selective suspend of the device; the registry write runs in a work item.

"USB device not recognized" popup for a port.

A hub was attached beyond the allowed tier depth.

The selected configuration draws more power than the port can give.

The controller ran out of bandwidth for the device; fired by the out of bandwidth timer.

Definition at line 77 of file common.c.

{
    NTSTATUS                    status;
    BOOLEAN                     requestSent = FALSE;
 
    BOOLEAN                     shouldRetry = TRUE;
    PCDB                        cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb;
    ULONG                       timeoutValue = DeviceExtension->TimeOutValue;
    ULONG                       retryCount = 1;
 
    // reset some fields.
    DeviceExtension->PowerContext.RetryIntervalIn100ns = 0;
    status = PowerContextReuseRequest(DeviceExtension);
    RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);
 
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    // set proper timeout value and max retry count.
    switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown)
    {
    case PowerDownDeviceInitial:
    case PowerDownDeviceQuiesced:
    case PowerDownDeviceStopped:
        break;
 
    case PowerDownDeviceLocked:
        // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case
        // as we want to give best try on SYNC CACHE command.
        retryCount = MAXIMUM_RETRIES;
        timeoutValue = DeviceExtension->TimeOutValue;
        break;
 
    case PowerDownDeviceFlushed:
    {
        // Case of issuing STOP UNIT command
        // As "Imme" bit is set to '1', this command should be completed in short time.
        // This command is at low importance, failure of this command has very small impact.
        ULONG secondsRemaining = 0;
 
#if (WINVER >= 0x0601)
        // this API is introduced in Windows7
        PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);
#endif
 
        if (secondsRemaining == 0)
        {
            // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values.
            retryCount = MAXIMUM_RETRIES;
            timeoutValue = SCSI_CDROM_TIMEOUT;
        }
        else
        {
            // plan to leave about 30 seconds to lower level drivers if possible.
            if (secondsRemaining >= 32)
            {
                retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1;
                timeoutValue = SCSI_CDROM_TIMEOUT;
 
                if (retryCount > MAXIMUM_RETRIES)
                {
                    retryCount = MAXIMUM_RETRIES;
                }
 
                if (retryCount == 1)
                {
                    timeoutValue = secondsRemaining - 30;
                }
            }
            else
            {
                // issue the command with minimal timeout value and do not retry on it.
                retryCount = 1;
                timeoutValue = 2;
            }
        }
    }
        break;
    default:
        NT_ASSERT( FALSE );
        status = STATUS_NOT_IMPLEMENTED;
        return status;
    }
 
    DeviceExtension->PowerContext.RetryCount = retryCount;
 
    // issue command.
    while (shouldRetry)
    {
 
        // set SRB fields.
        DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
                                                     SRB_FLAGS_NO_QUEUE_FREEZE |
                                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE |
                                                     SRB_FLAGS_D3_PROCESSING;
 
        DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;
 
        if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
        {
            // Case of issuing SYNC CACHE command.
            DeviceExtension->PowerContext.Srb.CdbLength = 10;
            cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed)
        {
            // Case of issuing STOP UNIT command.
            DeviceExtension->PowerContext.Srb.CdbLength = 6;
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.Start = 0;
            cdb->START_STOP.Immediate = 1;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
        }
 
        // Set up completion routine and context if requested
        if (CompletionRoutine)
        {
            WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest,
                                           CompletionRoutine,
                                           Context);
        }
 
        status = RequestSend(DeviceExtension,
                             DeviceExtension->PowerContext.PowerRequest,
                             DeviceExtension->IoTarget,
                             CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             &requestSent);
 
        if (requestSent)
        {
            if ((CompletionRoutine == NULL) &&
                (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS))
            {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_POWER,
                            "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n",
                            DeviceExtension->PowerContext.PowerRequest,
                            (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT",
                            &DeviceExtension->PowerContext.Srb,
                            DeviceExtension->PowerContext.Srb.SrbStatus));
 
                NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));
 
                shouldRetry = RequestSenseInfoInterpret(DeviceExtension,
                                                        DeviceExtension->PowerContext.PowerRequest,
                                                        &(DeviceExtension->PowerContext.Srb),
                                                        retryCount - DeviceExtension->PowerContext.RetryCount,
                                                        &status,
                                                        &(DeviceExtension->PowerContext.RetryIntervalIn100ns));
 
                if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0))
                {
                    shouldRetry = FALSE;
                }
            }
            else
            {
                // succeeded, do not need to retry.
                shouldRetry = FALSE;
            }
 
        }
        else
        {
            // request failed to be sent
            shouldRetry = FALSE;
        }
 
        if (shouldRetry)
        {
            LARGE_INTEGER t;
            t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns;
            KeDelayExecutionThread(KernelMode, FALSE, &t);
 
            status = PowerContextReuseRequest(DeviceExtension);
            if (!NT_SUCCESS(status))
            {
                shouldRetry = FALSE;
            }
        }
    }
 
    if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
    {
        // record SYNC CACHE command completion time stamp.
        KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime);
    }
 
    return status;
}

◆ _IRQL_requires_max_() [3/3]

_IRQL_requires_max_ ( PASSIVE_LEVEL )

Queries information details about a security descriptor.

Computes the quota size of a security descriptor.

Assigns a security descriptor for a new object.

An extended function that assigns a security descriptor for a new object.

Frees a security descriptor.

An extended function that sets new information data to a security descriptor.

Modifies some information data about a security descriptor.

Parameters

[in]	SecurityInformation	Security information details to be queried from a security descriptor.
[out]	SecurityDescriptor	The returned security descriptor with security information data.
[in,out]	Length	The returned length of a security descriptor.
[in,out]	ObjectsSecurityDescriptor	The returned object security descriptor.

Returns: Returns STATUS_SUCCESS if the operations have been completed successfully and that the specific information about the security descriptor has been queried. STATUS_BUFFER_TOO_SMALL is returned if the buffer size is too small to contain the queried info about the security descriptor.

Parameters

[in]	Object	If specified, the function will use this arbitrary object that points to an object security descriptor.
[in]	SecurityInformation	Security information details to be set.
[in]	SecurityDescriptor	A security descriptor where its info is to be changed.
[in,out]	ObjectsSecurityDescriptor	The returned pointer to security descriptor objects.
[in]	PoolType	Pool type for the new security descriptor to allocate.
[in]	GenericMapping	The generic mapping of access rights masks.

Returns: See SeSetSecurityDescriptorInfoEx.

Parameters

[in]	Object	If specified, the function will use this arbitrary object that points to an object security descriptor.
[in]	SecurityInformation	Security information details to be set.
[in]	SecurityDescriptor	A security descriptor where its info is to be changed.
[in,out]	ObjectsSecurityDescriptor	The returned pointer to security descriptor objects.
[in]	AutoInheritFlags	Flags bitmask inheritation, influencing how the security descriptor can be inherited and if it can be in the first place.
[in]	PoolType	Pool type for the new security descriptor to allocate.
[in]	GenericMapping	The generic mapping of access rights masks.

Returns: Returns STATUS_SUCCESS if the operations have been completed without problems and that new info has been set to the security descriptor. STATUS_NO_SECURITY_ON_OBJECT is returned if the object does not have a security descriptor. STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the new security descriptor with new info set has failed.

Parameters

[in] SecurityDescriptor A security descriptor to be freed from memory.

Returns: Returns STATUS_SUCCESS.

Parameters

[in]	_ParentDescriptor	A security descriptor of the parent object that is being created.
[in]	_ExplicitDescriptor	An explicit security descriptor that is applied to a new object.
[out]	NewDescriptor	The new allocated security descriptor.
[in]	ObjectType	The type of the new object.
[in]	IsDirectoryObject	Set this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]	AutoInheritFlags	Automatic inheritance flags that influence how access control entries within ACLs from security descriptors are inherited.
[in]	SubjectContext	Security subject context of the new object.
[in]	GenericMapping	Generic mapping of access mask rights.
[in]	PoolType	This parameter is unused.

Returns: Returns STATUS_SUCCESS if the operations have been completed successfully and that the security descriptor has been assigned to the new object. STATUS_NO_TOKEN is returned if the caller hasn't supplied a valid argument to a security subject context. STATUS_INVALID_OWNER is returned if the caller hasn't supplied a parent descriptor that belongs to the main user (owner). STATUS_INVALID_PRIMARY_GROUP is returned by the same reason as with the previous NTSTATUS code. The two NTSTATUS codes are returned if the calling thread stated that the owner and/or group is defaulted to the parent descriptor (SEF_DEFAULT_OWNER_FROM_PARENT and/or SEF_DEFAULT_GROUP_FROM_PARENT respectively). STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the descriptor buffer has failed. A failure NTSTATUS is returned otherwise.

Parameters

[in]	ParentDescriptor	A security descriptor of the parent object that is being created.
[in]	ExplicitDescriptor	An explicit security descriptor that is applied to a new object.
[out]	NewDescriptor	The new allocated security descriptor.
[in]	IsDirectoryObject	Set this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]	SubjectContext	Security subject context of the new object.
[in]	GenericMapping	Generic mapping of access mask rights.
[in]	PoolType	This parameter is unused.

Returns: See SeAssignSecurityEx.

Parameters

[in]	SecurityDescriptor	A security descriptor.
[out]	QuotaInfoSize	The returned quota size of the given security descriptor to the caller. The function may return 0 to this parameter if the descriptor doesn't have a group or a discretionary access control list (DACL) even.

Returns: Returns STATUS_SUCCESS if the quota size of a security descriptor has been computed successfully. STATUS_UNKNOWN_REVISION is returned if the security descriptor has an invalid revision.

Definition at line 923 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;
 
    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));
 
        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);
 
        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;
 
        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);
 
            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;
 
            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }
 
    return Status;
}

◆ _Out_writes_bytes_()

_Must_inspect_result_ _In_ const GUID _In_ ULONG _Out_writes_bytes_ ( OutputBufferLength ) &&

pure virtual

◆ _Out_writes_bytes_to_opt_()

_Must_inspect_result_ _In_ const GUID _In_ ULONG _Out_writes_bytes_to_opt_	(	OutputBufferLength	,
		*	ResultLength
	)

◆ _Outptr_result_bytebuffer_() [1/2]

_In_ ULONG _Outptr_result_bytebuffer_ ( sizeof(struct _URB_ISOCH_TRANSFER)+(NumberOfIsochPackets *sizeof(USBD_ISO_PACKET_DESCRIPTOR)) - sizeof(USBD_ISO_PACKET_DESCRIPTOR) )

◆ _Outptr_result_bytebuffer_() [2/2]

_Outptr_result_bytebuffer_ ( sizeof(URB) )

◆ _When_() [1/2]

_Must_inspect_result_ _In_ const GUID _In_ ULONG _When_	(	OutputBufferLength	= `= 0`,
		_Pre_null_
	)		&&

pure virtual

◆ _When_() [2/2]

_Must_inspect_result_ _In_ const GUID _In_ ULONG _Out_opt_ _When_	(	ResultLength !	= `NULL`,
		_Deref_out_range_(<=, OutputBufferLength)
	)

◆ DECLARE_HANDLE() [1/3]

DECLARE_HANDLE ( USBD_FUNCTION_HANDLE )

◆ DECLARE_HANDLE() [2/3]

DECLARE_HANDLE ( USBD_HANDLE )

◆ DECLARE_HANDLE() [3/3]

DECLARE_HANDLE ( USBDI_HANDLE )

◆ DEFINE_GUID() [1/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_CHAINED_MDLS	,
		0xf5ceeb23	,
		0xad90	,
		0x458c	,
		0x97	,
		0x9a	,
		0xd5	,
		0x9b	,
		0x3a	,
		0xd6	,
		0x88	,
		0x4f
	)

◆ DEFINE_GUID() [2/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_CONTROLLER_EUSB2_DOUBLE_ISOCH_COMPATIBLE	,
		0x5f0e4b3f	,
		0xde94	,
		0x473a	,
		0xa3	,
		0x73	,
		0x78	,
		0x1a	,
		0xcb	,
		0x92	,
		0xb5	,
		0xe8
	)

◆ DEFINE_GUID() [3/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_DEVICE_CONNECTION_HIGH_SPEED_COMPATIBLE	,
		0x81a885a6	,
		0xf239	,
		0x42a2	,
		0x83	,
		0x97	,
		0xa5	,
		0xd9	,
		0x5b	,
		0xea	,
		0x69	,
		0x53
	)

◆ DEFINE_GUID() [4/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_DEVICE_CONNECTION_SUPER_SPEED_COMPATIBLE	,
		0x8a2f776c	,
		0x9bd0	,
		0x4f29	,
		0x97	,
		0x71	,
		0xc7	,
		0xa3	,
		0x88	,
		0x46	,
		0xd4	,
		0xc7
	)

◆ DEFINE_GUID() [5/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_FUNCTION_SUSPEND	,
		0xf4563183	,
		0xd66e	,
		0x42bd	,
		0xbd	,
		0x53	,
		0x1a	,
		0xc7	,
		0xb0	,
		0x4c	,
		0xd5	,
		0x9d
	)

◆ DEFINE_GUID() [6/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_HIGH_BANDWIDTH_ISOCH	,
		0x9c8a8a27	,
		0x15f9	,
		0x42e3	,
		0xa3	,
		0x56	,
		0xcd	,
		0xa6	,
		0xae	,
		0x97	,
		0xa8	,
		0xc8
	)

◆ DEFINE_GUID() [7/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_SELECTIVE_SUSPEND	,
		0x755c630d	,
		0xc8a0	,
		0x4765	,
		0x94	,
		0x6f	,
		0x90	,
		0xcc	,
		0x70	,
		0x38	,
		0x56	,
		0xa4
	)

◆ DEFINE_GUID() [8/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_SSP_ISOCH_PIPE_FLAGS	,
		0x59819125	,
		0x33a3	,
		0x421a	,
		0xa5	,
		0xdd	,
		0x37	,
		0x63	,
		0x9f	,
		0x30	,
		0xb9	,
		0x3e
	)

◆ DEFINE_GUID() [9/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_STATIC_STREAMS	,
		0x09051e1f	,
		0x0dc9	,
		0x4e6b	,
		0x8b	,
		0x12	,
		0x96	,
		0x0c	,
		0xbd	,
		0x81	,
		0xaa	,
		0x8f
	)

◆ DEFINE_GUID() [10/10]

DEFINE_GUID	(	GUID_USB_CAPABILITY_TIME_SYNC	,
		0xbb6e6472	,
		0x4be5	,
		0x44a3	,
		0x96	,
		0x41	,
		0x34	,
		0x5e	,
		0x56	,
		0xac	,
		0x34	,
		0x85
	)

◆ USBD_CreateConfigurationRequest()

DECLSPEC_IMPORT PURB NTAPI USBD_CreateConfigurationRequest	(	_In_ PUSB_CONFIGURATION_DESCRIPTOR	ConfigurationDescriptor,
		_Out_ PUSHORT	Siz
	)

◆ USBD_ParseConfigurationDescriptor()

DECLSPEC_IMPORT PUSB_INTERFACE_DESCRIPTOR NTAPI USBD_ParseConfigurationDescriptor	(	_In_ PUSB_CONFIGURATION_DESCRIPTOR	ConfigurationDescriptor,
		_In_ UCHAR	InterfaceNumber,
		_In_ UCHAR	AlternateSetting
	)