ReactOS 0.4.17-dev-1281-g065abb3
Classes | Macros | Typedefs | Enumerations | Functions | Variables
desccheck.h File Reference
#include <pshpack1.h>
#include <poppack.h>
Include dependency graph for desccheck.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  HubDescContext
 
struct  HubLpmInfo
 
struct  HubMsOs20SetInfo
 
struct  HubPlatformFeatures
 
struct  HubMsOs20Common
 
struct  HubMsOs20SetHeader
 
struct  HubMsOs20Subset
 
struct  HubMsOs20CompatibleId
 
struct  HubMsOs20Registry
 
struct  HubMsOs20ResumeTime
 
struct  HubMsOs20ModelId
 
struct  HubMsOs20Ccgp
 
struct  HubMsOsString
 
struct  HubMsOsHeader
 
struct  HubMsOsContainerId
 
struct  HubMsOsExtConfigHeader
 
struct  HubMsOsExtConfigFunction
 
struct  HubMsOsExtConfig
 
struct  HubBosInfo
 
struct  HubMsOs20Info
 

Macros

#define HUB_DESC_BITMAP_ULONGS   8
 
#define HUB_BOS_SUPERSPEED_CAPABLE   0x00000001
 
#define HUB_BOS_ENHANCED_SUPERSPEED_CAPABLE   0x00000002
 
#define HUB_BOS_CHARGING_POLICY   0x00000004
 
#define HUB_MSOS20_SET_INFO   0x00000001
 
#define HUB_MSOS20_SET_HEADER   0x00000002
 
#define HUB_MSOS20_ALT_ENUM   0x00000004
 
#define HUB_MSOS20_CONFIG_SUBSET   0x00000008
 
#define HUB_MSOS20_FUNCTION_SUBSET   0x00000010
 
#define HUB_MSOS20_COMPATIBLE_ID   0x00000020
 
#define HUB_MSOS20_REGISTRY   0x00000040
 
#define HUB_MSOS20_RESUME_TIME   0x00000080
 
#define HUB_MSOS20_MODEL_ID   0x00000100
 
#define HUB_MSOS20_CCGP   0x00000200
 

Typedefs

typedef VOID(NTAPI * PFN_HUB_DESC_LOG) (_In_opt_ PVOID Context, _In_ HubDescCode Code, _In_ BOOLEAN Warning)
 

Enumerations

enum class  HubDescCode : ULONG {
  Hub20LengthTooLarge = 0 , Hub20LengthTooSmall = 1 , Hub20Null = 2 , Hub20BufferTooSmall = 3 ,
  Hub20RemovableMissingPort = 4 , Hub20RemovableReserved = 5 , Hub20WrongType = 6 , Hub20NoPorts = 7 ,
  Hub20PowerMaskNotOnes = 8 , Hub20CharacteristicsReserved = 9 , Hub30DecodeLatencyReserved = 10 , Hub30LengthTooLarge = 11 ,
  Hub30LengthTooSmall = 12 , Hub30BufferTooSmall = 13 , Hub30RemovableMissingPort = 14 , Hub30RemovableReserved = 15 ,
  Hub30WrongType = 16 , Hub30TooManyPorts = 17 , Hub30NoPorts = 18 , Hub30CharacteristicsReserved = 19 ,
  BosLengthTooLarge = 20 , BosLengthTooSmall = 21 , BosBufferLargerThanTotal = 22 , BosBufferTooSmall = 23 ,
  BosWrongType = 24 , BosCapCountMismatch = 25 , BosNoSuperSpeedCap = 26 , BosNull = 27 ,
  BosUnknownType = 28 , BosTotalLengthTooSmall = 29 , BulkAtLowSpeed = 30 , BulkAttributesReserved = 31 ,
  BulkMaxPacket = 32 , CompanionBulkReserved = 33 , CompanionBulkBurst = 34 , CompanionBulkStreams = 35 ,
  CompanionBulkBytesPerInterval = 36 , CompanionControlAttributes = 37 , CompanionControlBurst = 38 , CompanionControlBytesPerInterval = 39 ,
  CompanionNotSuperSpeed = 40 , CompanionUnexpected = 41 , CompanionLengthTooLarge = 42 , CompanionLengthTooSmall = 43 ,
  CompanionBufferTooSmall = 44 , CompanionInterruptBurst = 45 , CompanionInterruptBurstPacket = 46 , CompanionInterruptAttributes = 47 ,
  CompanionInterruptBytesPerInterval = 48 , CompanionIsochReserved = 49 , CompanionIsochBurst = 50 , CompanionIsochBurstPacket = 51 ,
  CompanionIsochMult = 52 , CompanionIsochBytesPerInterval = 53 , ConfigLengthTooLarge = 54 , ConfigLengthTooSmall = 55 ,
  ConfigBufferTooSmall = 56 , ConfigBufferTooSmallForInterfaces = 57 , ConfigWrongType = 58 , ConfigMissingCompanion = 59 ,
  ConfigNull = 60 , ConfigTotalLengthTooLarge = 61 , ConfigTotalLengthTooSmall = 62 , ContainerIdLengthTooLarge = 63 ,
  ContainerIdLengthTooSmall = 64 , ContainerIdBufferTooSmall = 65 , ContainerIdReserved = 66 , ControlAttributesReserved = 67 ,
  ControlMaxPacket = 68 , DeviceVersionNotBcd = 69 , DeviceLengthTooSmall = 70 , DeviceBufferTooSmall = 71 ,
  CapLengthTooSmall = 72 , CapBufferTooSmall = 73 , CapMultipleContainerId = 74 , CapMultipleSuperSpeed = 75 ,
  CapMultipleUsb20 = 76 , DeviceWrongType = 77 , DeviceMaxPacket0 = 78 , DeviceNull = 79 ,
  EndpointLengthTooLarge = 80 , EndpointLengthTooSmall = 81 , EndpointAttributesReserved = 82 , EndpointBufferTooSmall = 83 ,
  EndpointAddressReserved = 84 , EndpointBeforeInterface = 85 , EndpointNumberZero = 86 , HeaderPastBuffer = 87 ,
  HeaderPastTotalLength = 88 , HeaderLengthTooSmall = 89 , HeaderBufferTooSmall = 90 , HeaderLengthZero = 91 ,
  IadLengthTooLarge = 92 , IadLengthTooSmall = 93 , IadBufferTooSmall = 94 , IadCountTooLarge = 95 ,
  IadCountZero = 96 , IadFirstInterfaceTooLarge = 97 , InterfaceLengthTooLarge = 98 , InterfaceLengthTooSmall = 99 ,
  InterfaceBufferTooSmall = 100 , DuplicateAlternate = 101 , DuplicateEndpoint = 102 , DuplicateInterface = 103 ,
  FirstAlternateNotZero = 104 , AlternateOutOfOrder = 105 , InterfaceOutOfOrder = 106 , EndpointCountMismatch = 107 ,
  InterruptAttributesReserved = 108 , InterruptInterval = 109 , InterruptMaxPacket = 110 , IsochAtLowSpeed = 111 ,
  IsochInterval = 112 , IsochMaxPacket = 113 , MsOsContainerIdZero = 114 , MsOsContainerIdVersion = 115 ,
  MsOsContainerIdIndex = 116 , MsOsContainerIdBufferSize = 117 , MsOsContainerIdLength = 118 , MsOsExtConfigFirstInterface = 119 ,
  MsOsExtConfigVersion = 120 , MsOsExtConfigCount = 121 , MsOsExtConfigBufferSize = 122 , MsOsExtConfigCompatibleId = 123 ,
  MsOsExtConfigSubCompatibleId = 124 , MsOsExtConfigIndex = 125 , MsOsExtConfigBufferVsLength = 126 , MsOsExtConfigLengthVsCount = 127 ,
  StringLengthOdd = 128 , StringLengthTooLarge = 129 , StringLengthTooSmall = 130 , StringBufferTooSmall = 131 ,
  SerialNumberBadCharacter = 132 , StringWrongType = 133 , StringLengthVsBytes = 134 , SsCapLengthTooLarge = 135 ,
  SsCapLengthTooSmall = 136 , SsCapAttributesReserved = 137 , SsCapU1TooLarge = 138 , SsCapU2TooLarge = 139 ,
  SsCapBufferTooSmall = 140 , SsCapFunctionalityNotInSpeeds = 141 , SsCapFunctionalityReserved = 142 , SsCapSpeedsReserved = 143 ,
  SsCapNoSpeeds = 144 , Usb20CapLengthTooLarge = 145 , Usb20CapLengthTooSmall = 146 , Usb20CapReserved = 147 ,
  Usb20CapBufferTooSmall = 148 , BaselineBeslZero = 149 , BeslWithoutLpm = 150 , DeepBeslNotAboveBaseline = 151 ,
  DeepBeslZero = 152 , BosContainerIdZero = 153 , MsOs20MultipleSetHeaders = 154 , MsOs20SetHeaderLength = 155 ,
  ConfigSubsetLength = 156 , ConfigSubsetTotalTooSmall = 157 , ConfigSubsetTotalTooLarge = 158 , ConfigSubsetMisplacedFeature = 159 ,
  ConfigSubsetFeatureLength = 160 , FunctionSubsetLength = 161 , FunctionSubsetTotalTooSmall = 162 , FunctionSubsetTotalTooLarge = 163 ,
  FunctionSubsetMisplacedFeature = 164 , FunctionSubsetFeatureLength = 165 , MsOs20MultipleCompatibleId = 166 , MsOs20CompatibleIdLength = 167 ,
  MsOs20CompatibleIdAfterNull = 168 , MsOs20RegistryTooSmall = 169 , MsOs20RegistryNameTooLarge = 170 , MsOs20RegistryNameOddOrZero = 171 ,
  MsOs20RegistryDataTooLarge = 172 , MsOs20RegistryDataZero = 173 , MsOs20RegistryType = 174 , MsOs20MultipleResumeTime = 175 ,
  MsOs20ResumeTimeLength = 176 , MsOs20ResumeRecovery = 177 , MsOs20ResumeSignaling = 178 , MsOs20MultipleModelId = 181 ,
  MsOs20ModelIdLength = 182 , MsOs20ModelIdZero = 183 , MsOs20BytesVsSetInfo = 188 , MsOs20BytesTooSmall = 189 ,
  MsOs20HeaderLength = 190 , MsOs20TotalLengthMismatch = 191 , MsOs20VersionMismatch = 192 , MsOs20FeatureOutOfOrder = 193 ,
  MsOs20PastEnd = 194 , PlatformReserved = 195 , PlatformUuidZero = 196 , MsOs20MultiplePlatform = 197 ,
  MsOs20PlatformLength = 198 , MsOs20DuplicateVersion = 199 , MsOs20NoVersionMatch = 200 , MsOs20MultipleCcgp = 201 ,
  MsOs20CcgpLength = 202 , CapMultipleSuperSpeedPlus = 203 , CompanionIsochBytesNotOne = 204 , SspCompanionNotSuperSpeed = 205 ,
  SspCompanionUnexpected = 206 , SspCompanionLengthTooLarge = 207 , SspCompanionLengthTooSmall = 208 , SspCompanionBufferTooSmall = 209 ,
  SspCompanionReserved = 210 , SspCompanionBytesRange = 211 , ConfigMissingSspCompanion = 212 , SspCapLengthInvalid = 213 ,
  SspCapLengthTooSmall = 214 , SspCapAttributesReserved = 215 , SspCapFunctionalityReserved = 216 , SspCapBufferTooSmall = 217 ,
  SspCapReservedByte = 218 , SspCapReservedWord = 219 , SspAttrNotRx = 220 , SspAttrNotTx = 221 ,
  SspAttrTxMissing = 222 , SspAttrPairMismatch = 223 , SspAttrSymmetricMismatch = 224 , SspMinLaneMismatch = 225 ,
  SspSpeedIdDuplicate = 226 , SspSpeedIdCount = 227 , SspMinSpeedMissing = 228 , PdLengthTooLarge = 229 ,
  PdLengthTooSmall = 230 , PdBufferTooSmall = 231 , PdReserved = 232 , IsochPacketInAlternate0 = 233 ,
  DuplicateSerialNumber = 234 , BillboardLengthTooSmall = 235 , BillboardLengthInvalid = 236 , BillboardBufferTooSmall = 237 ,
  BillboardNoModes = 238 , BillboardTooManyModes = 239 , BillboardPreferredInvalid = 241 , CapMultipleBillboard = 245 ,
  BillboardDeviceVersion = 246 , PlatformFeaturesLength = 247 , PlatformFeaturesMultiple = 248 , PlatformFeaturesVersion = 249 ,
  PlatformFeaturesTooSmall = 250 , PlatformLengthTooSmall = 251 , PlatformBufferTooSmall = 253 , Count = 254
}
 

Functions

 C_ASSERT (sizeof(HubMsOs20SetInfo)==8)
 
 C_ASSERT (sizeof(HubPlatformFeatures)==26)
 
 C_ASSERT (sizeof(HubMsOs20SetHeader)==10)
 
 C_ASSERT (sizeof(HubMsOs20Subset)==8)
 
 C_ASSERT (sizeof(HubMsOs20CompatibleId)==20)
 
 C_ASSERT (sizeof(HubMsOsString)==18)
 
 C_ASSERT (sizeof(HubMsOsContainerId)==24)
 
 C_ASSERT (sizeof(HubMsOsExtConfigHeader)==16)
 
 C_ASSERT (sizeof(HubMsOsExtConfig)==40)
 
VOID NTAPI HubDescInitDeviceContext (_Out_ HubDescContext *Context, _In_ USHORT BcdUsb, _In_ USB_DEVICE_SPEED Speed, _In_ BOOLEAN Win8Behavior, _In_ ULONG SspIsochBurstCount, _In_opt_ PULONG Bitmap)
 
VOID NTAPI HubDescInitHubContext (_Out_ HubDescContext *Context, _In_ USHORT BcdUsb, _In_ USB_DEVICE_SPEED Speed)
 
PCSTR NTAPI HubDescCodeName (_In_ HubDescCode Code)
 
VOID NTAPI HubDescLog (_In_ const HubDescContext *Context, _In_ HubDescCode Code, _In_ BOOLEAN Warning)
 
BOOLEAN NTAPI HubDescCheckDevice (_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_DEVICE_DESCRIPTOR Descriptor, _In_ ULONG Length, _Inout_opt_ PBOOLEAN IsBillboard)
 
BOOLEAN NTAPI HubDescCheckConfiguration (_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_CONFIGURATION_DESCRIPTOR Descriptor, _In_ ULONG Length, _Out_opt_ PBOOLEAN SupportsStreams)
 
BOOLEAN NTAPI HubDescCheckBosHeader (_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_BOS_DESCRIPTOR Descriptor, _In_ ULONG Length)
 
 _IRQL_requires_ (PASSIVE_LEVEL) BOOLEAN NTAPI HubDescCheckBos(_In_ const HubDescContext *Context
 
 _Inout_updates_bytes_ (Length) PUSB_BOS_DESCRIPTOR Descriptor
 
BOOLEAN NTAPI HubDescCheckString (_In_ const HubDescContext *Context, _In_reads_bytes_(Length) PUSB_STRING_DESCRIPTOR Descriptor, _In_ ULONG Length, _Out_opt_ PULONG AdjustedLength)
 
BOOLEAN NTAPI HubDescCheckSerialNumber (_In_ const HubDescContext *Context, _In_reads_bytes_(*Length) PUSB_STRING_DESCRIPTOR Descriptor, _Inout_ PULONG Length)
 
BOOLEAN NTAPI HubDescCheckMsOsString (_In_ const HubDescContext *Context, _In_ const HubMsOsString *Descriptor)
 
BOOLEAN NTAPI HubDescCheckMsOsContainerIdHeader (_In_ const HubDescContext *Context, _In_reads_bytes_(Length) const HubMsOsHeader *Descriptor, _In_ ULONG Length)
 
BOOLEAN NTAPI HubDescCheckMsOsContainerId (_In_ const HubDescContext *Context, _In_reads_bytes_(Length) const HubMsOsContainerId *Descriptor, _In_ ULONG Length)
 
BOOLEAN NTAPI HubDescCheckMsOsExtConfigHeader (_In_ const HubDescContext *Context, _In_reads_bytes_(Length) const HubMsOsExtConfigHeader *Descriptor, _In_ ULONG Length)
 
BOOLEAN NTAPI HubDescCheckMsOsExtConfig (_In_ const HubDescContext *Context, _In_reads_bytes_(sizeof(HubMsOsExtConfig)) const HubMsOsExtConfig *Descriptor, _In_ ULONG Length)
 
 _In_reads_bytes_ (Length) PVOID Set
 
BOOLEAN NTAPI HubDescCheck20Hub (_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_HUB_DESCRIPTOR Descriptor, _In_ ULONG Length)
 
BOOLEAN NTAPI HubDescCheck30Hub (_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_30_HUB_DESCRIPTOR Descriptor, _In_ ULONG Length)
 
PUSB_COMMON_DESCRIPTOR NTAPI HubDescFind (_In_reads_bytes_(TotalLength) PVOID Buffer, _In_ ULONG TotalLength, _In_ PVOID Position, _In_ UCHAR Type)
 
PUSB_INTERFACE_DESCRIPTOR NTAPI HubDescFindInterface (_In_ PUSB_CONFIGURATION_DESCRIPTOR Config, _In_ PVOID Position, _In_ LONG Number, _In_ LONG Alternate, _In_ LONG Class, _In_ LONG SubClass, _In_ LONG Protocol, _Out_opt_ PBOOLEAN HasAlternates)
 
BOOLEAN NTAPI HubDescNextMsOs20 (_In_ PUCHAR End, _Inout_ HubMsOs20Common **Current)
 

Variables

_In_ ULONG Length
 
_In_ ULONG _Out_opt_ HubBosInfo * Info
 
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT U1ExitLatency
 
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT U2ExitLatency
 
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN LtmCapable
 
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN _Inout_opt_ HubLpmInfo * Lpm
 
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN _Inout_opt_ HubLpmInfo _Inout_opt_ PULONG DeviceFlags
 
_In_ ULONG _In_ const HubMsOs20SetInfo * SetInfo
 

Macro Definition Documentation

◆ HUB_BOS_CHARGING_POLICY

#define HUB_BOS_CHARGING_POLICY   0x00000004

Definition at line 318 of file desccheck.h.

◆ HUB_BOS_ENHANCED_SUPERSPEED_CAPABLE

#define HUB_BOS_ENHANCED_SUPERSPEED_CAPABLE   0x00000002

Definition at line 317 of file desccheck.h.

◆ HUB_BOS_SUPERSPEED_CAPABLE

#define HUB_BOS_SUPERSPEED_CAPABLE   0x00000001

Definition at line 316 of file desccheck.h.

◆ HUB_DESC_BITMAP_ULONGS

#define HUB_DESC_BITMAP_ULONGS   8

Definition at line 263 of file desccheck.h.

◆ HUB_MSOS20_ALT_ENUM

#define HUB_MSOS20_ALT_ENUM   0x00000004

Definition at line 490 of file desccheck.h.

◆ HUB_MSOS20_CCGP

#define HUB_MSOS20_CCGP   0x00000200

Definition at line 497 of file desccheck.h.

◆ HUB_MSOS20_COMPATIBLE_ID

#define HUB_MSOS20_COMPATIBLE_ID   0x00000020

Definition at line 493 of file desccheck.h.

◆ HUB_MSOS20_CONFIG_SUBSET

#define HUB_MSOS20_CONFIG_SUBSET   0x00000008

Definition at line 491 of file desccheck.h.

◆ HUB_MSOS20_FUNCTION_SUBSET

#define HUB_MSOS20_FUNCTION_SUBSET   0x00000010

Definition at line 492 of file desccheck.h.

◆ HUB_MSOS20_MODEL_ID

#define HUB_MSOS20_MODEL_ID   0x00000100

Definition at line 496 of file desccheck.h.

◆ HUB_MSOS20_REGISTRY

#define HUB_MSOS20_REGISTRY   0x00000040

Definition at line 494 of file desccheck.h.

◆ HUB_MSOS20_RESUME_TIME

#define HUB_MSOS20_RESUME_TIME   0x00000080

Definition at line 495 of file desccheck.h.

◆ HUB_MSOS20_SET_HEADER

#define HUB_MSOS20_SET_HEADER   0x00000002

Definition at line 489 of file desccheck.h.

◆ HUB_MSOS20_SET_INFO

#define HUB_MSOS20_SET_INFO   0x00000001

Definition at line 488 of file desccheck.h.

Typedef Documentation

◆ PFN_HUB_DESC_LOG

typedef VOID(NTAPI * PFN_HUB_DESC_LOG) (_In_opt_ PVOID Context, _In_ HubDescCode Code, _In_ BOOLEAN Warning)

Logging hook. Called for every finding after the bitmap bit is set.

Definition at line 267 of file desccheck.h.

Enumeration Type Documentation

◆ HubDescCode

enum class HubDescCode : ULONG
strong
Enumerator
Hub20LengthTooLarge 
Hub20LengthTooSmall 
Hub20Null 
Hub20BufferTooSmall 
Hub20RemovableMissingPort 
Hub20RemovableReserved 
Hub20WrongType 
Hub20NoPorts 
Hub20PowerMaskNotOnes 
Hub20CharacteristicsReserved 
Hub30DecodeLatencyReserved 
Hub30LengthTooLarge 
Hub30LengthTooSmall 
Hub30BufferTooSmall 
Hub30RemovableMissingPort 
Hub30RemovableReserved 
Hub30WrongType 
Hub30TooManyPorts 
Hub30NoPorts 
Hub30CharacteristicsReserved 
BosLengthTooLarge 
BosLengthTooSmall 
BosBufferLargerThanTotal 
BosBufferTooSmall 
BosWrongType 
BosCapCountMismatch 
BosNoSuperSpeedCap 
BosNull 
BosUnknownType 
BosTotalLengthTooSmall 
BulkAtLowSpeed 
BulkAttributesReserved 
BulkMaxPacket 
CompanionBulkReserved 
CompanionBulkBurst 
CompanionBulkStreams 
CompanionBulkBytesPerInterval 
CompanionControlAttributes 
CompanionControlBurst 
CompanionControlBytesPerInterval 
CompanionNotSuperSpeed 
CompanionUnexpected 
CompanionLengthTooLarge 
CompanionLengthTooSmall 
CompanionBufferTooSmall 
CompanionInterruptBurst 
CompanionInterruptBurstPacket 
CompanionInterruptAttributes 
CompanionInterruptBytesPerInterval 
CompanionIsochReserved 
CompanionIsochBurst 
CompanionIsochBurstPacket 
CompanionIsochMult 
CompanionIsochBytesPerInterval 
ConfigLengthTooLarge 
ConfigLengthTooSmall 
ConfigBufferTooSmall 
ConfigBufferTooSmallForInterfaces 
ConfigWrongType 
ConfigMissingCompanion 
ConfigNull 
ConfigTotalLengthTooLarge 
ConfigTotalLengthTooSmall 
ContainerIdLengthTooLarge 
ContainerIdLengthTooSmall 
ContainerIdBufferTooSmall 
ContainerIdReserved 
ControlAttributesReserved 
ControlMaxPacket 
DeviceVersionNotBcd 
DeviceLengthTooSmall 
DeviceBufferTooSmall 
CapLengthTooSmall 
CapBufferTooSmall 
CapMultipleContainerId 
CapMultipleSuperSpeed 
CapMultipleUsb20 
DeviceWrongType 
DeviceMaxPacket0 
DeviceNull 
EndpointLengthTooLarge 
EndpointLengthTooSmall 
EndpointAttributesReserved 
EndpointBufferTooSmall 
EndpointAddressReserved 
EndpointBeforeInterface 
EndpointNumberZero 
HeaderPastBuffer 
HeaderPastTotalLength 
HeaderLengthTooSmall 
HeaderBufferTooSmall 
HeaderLengthZero 
IadLengthTooLarge 
IadLengthTooSmall 
IadBufferTooSmall 
IadCountTooLarge 
IadCountZero 
IadFirstInterfaceTooLarge 
InterfaceLengthTooLarge 
InterfaceLengthTooSmall 
InterfaceBufferTooSmall 
DuplicateAlternate 
DuplicateEndpoint 
DuplicateInterface 
FirstAlternateNotZero 
AlternateOutOfOrder 
InterfaceOutOfOrder 
EndpointCountMismatch 
InterruptAttributesReserved 
InterruptInterval 
InterruptMaxPacket 
IsochAtLowSpeed 
IsochInterval 
IsochMaxPacket 
MsOsContainerIdZero 
MsOsContainerIdVersion 
MsOsContainerIdIndex 
MsOsContainerIdBufferSize 
MsOsContainerIdLength 
MsOsExtConfigFirstInterface 
MsOsExtConfigVersion 
MsOsExtConfigCount 
MsOsExtConfigBufferSize 
MsOsExtConfigCompatibleId 
MsOsExtConfigSubCompatibleId 
MsOsExtConfigIndex 
MsOsExtConfigBufferVsLength 
MsOsExtConfigLengthVsCount 
StringLengthOdd 
StringLengthTooLarge 
StringLengthTooSmall 
StringBufferTooSmall 
SerialNumberBadCharacter 
StringWrongType 
StringLengthVsBytes 
SsCapLengthTooLarge 
SsCapLengthTooSmall 
SsCapAttributesReserved 
SsCapU1TooLarge 
SsCapU2TooLarge 
SsCapBufferTooSmall 
SsCapFunctionalityNotInSpeeds 
SsCapFunctionalityReserved 
SsCapSpeedsReserved 
SsCapNoSpeeds 
Usb20CapLengthTooLarge 
Usb20CapLengthTooSmall 
Usb20CapReserved 
Usb20CapBufferTooSmall 
BaselineBeslZero 
BeslWithoutLpm 
DeepBeslNotAboveBaseline 
DeepBeslZero 
BosContainerIdZero 
MsOs20MultipleSetHeaders 
MsOs20SetHeaderLength 
ConfigSubsetLength 
ConfigSubsetTotalTooSmall 
ConfigSubsetTotalTooLarge 
ConfigSubsetMisplacedFeature 
ConfigSubsetFeatureLength 
FunctionSubsetLength 
FunctionSubsetTotalTooSmall 
FunctionSubsetTotalTooLarge 
FunctionSubsetMisplacedFeature 
FunctionSubsetFeatureLength 
MsOs20MultipleCompatibleId 
MsOs20CompatibleIdLength 
MsOs20CompatibleIdAfterNull 
MsOs20RegistryTooSmall 
MsOs20RegistryNameTooLarge 
MsOs20RegistryNameOddOrZero 
MsOs20RegistryDataTooLarge 
MsOs20RegistryDataZero 
MsOs20RegistryType 
MsOs20MultipleResumeTime 
MsOs20ResumeTimeLength 
MsOs20ResumeRecovery 
MsOs20ResumeSignaling 
MsOs20MultipleModelId 
MsOs20ModelIdLength 
MsOs20ModelIdZero 
MsOs20BytesVsSetInfo 
MsOs20BytesTooSmall 
MsOs20HeaderLength 
MsOs20TotalLengthMismatch 
MsOs20VersionMismatch 
MsOs20FeatureOutOfOrder 
MsOs20PastEnd 
PlatformReserved 
PlatformUuidZero 
MsOs20MultiplePlatform 
MsOs20PlatformLength 
MsOs20DuplicateVersion 
MsOs20NoVersionMatch 
MsOs20MultipleCcgp 
MsOs20CcgpLength 
CapMultipleSuperSpeedPlus 
CompanionIsochBytesNotOne 
SspCompanionNotSuperSpeed 
SspCompanionUnexpected 
SspCompanionLengthTooLarge 
SspCompanionLengthTooSmall 
SspCompanionBufferTooSmall 
SspCompanionReserved 
SspCompanionBytesRange 
ConfigMissingSspCompanion 
SspCapLengthInvalid 
SspCapLengthTooSmall 
SspCapAttributesReserved 
SspCapFunctionalityReserved 
SspCapBufferTooSmall 
SspCapReservedByte 
SspCapReservedWord 
SspAttrNotRx 
SspAttrNotTx 
SspAttrTxMissing 
SspAttrPairMismatch 
SspAttrSymmetricMismatch 
SspMinLaneMismatch 
SspSpeedIdDuplicate 
SspSpeedIdCount 
SspMinSpeedMissing 
PdLengthTooLarge 
PdLengthTooSmall 
PdBufferTooSmall 
PdReserved 
IsochPacketInAlternate0 
DuplicateSerialNumber 
BillboardLengthTooSmall 
BillboardLengthInvalid 
BillboardBufferTooSmall 
BillboardNoModes 
BillboardTooManyModes 
BillboardPreferredInvalid 
CapMultipleBillboard 
BillboardDeviceVersion 
PlatformFeaturesLength 
PlatformFeaturesMultiple 
PlatformFeaturesVersion 
PlatformFeaturesTooSmall 
PlatformLengthTooSmall 
PlatformBufferTooSmall 
Count 

Definition at line 14 of file desccheck.h.

15{
16 Hub20LengthTooLarge = 0,
17 Hub20LengthTooSmall = 1,
18 Hub20Null = 2,
19 Hub20BufferTooSmall = 3,
20 Hub20RemovableMissingPort = 4,
21 Hub20RemovableReserved = 5,
22 Hub20WrongType = 6,
23 Hub20NoPorts = 7,
24 Hub20PowerMaskNotOnes = 8,
25 Hub20CharacteristicsReserved = 9,
26 Hub30DecodeLatencyReserved = 10,
27 Hub30LengthTooLarge = 11,
28 Hub30LengthTooSmall = 12,
29 Hub30BufferTooSmall = 13,
30 Hub30RemovableMissingPort = 14,
31 Hub30RemovableReserved = 15,
32 Hub30WrongType = 16,
33 Hub30TooManyPorts = 17,
34 Hub30NoPorts = 18,
35 Hub30CharacteristicsReserved = 19,
36 BosLengthTooLarge = 20,
37 BosLengthTooSmall = 21,
38 BosBufferLargerThanTotal = 22,
39 BosBufferTooSmall = 23,
40 BosWrongType = 24,
41 BosCapCountMismatch = 25,
42 BosNoSuperSpeedCap = 26,
43 BosNull = 27,
44 BosUnknownType = 28,
45 BosTotalLengthTooSmall = 29,
46 BulkAtLowSpeed = 30,
47 BulkAttributesReserved = 31,
48 BulkMaxPacket = 32,
49 CompanionBulkReserved = 33,
50 CompanionBulkBurst = 34,
51 CompanionBulkStreams = 35,
52 CompanionBulkBytesPerInterval = 36,
53 CompanionControlAttributes = 37,
54 CompanionControlBurst = 38,
55 CompanionControlBytesPerInterval = 39,
56 CompanionNotSuperSpeed = 40,
57 CompanionUnexpected = 41,
58 CompanionLengthTooLarge = 42,
59 CompanionLengthTooSmall = 43,
60 CompanionBufferTooSmall = 44,
61 CompanionInterruptBurst = 45,
62 CompanionInterruptBurstPacket = 46,
63 CompanionInterruptAttributes = 47,
64 CompanionInterruptBytesPerInterval = 48,
65 CompanionIsochReserved = 49,
66 CompanionIsochBurst = 50,
67 CompanionIsochBurstPacket = 51,
68 CompanionIsochMult = 52,
69 CompanionIsochBytesPerInterval = 53,
70 ConfigLengthTooLarge = 54,
71 ConfigLengthTooSmall = 55,
72 ConfigBufferTooSmall = 56,
73 ConfigBufferTooSmallForInterfaces = 57,
74 ConfigWrongType = 58,
75 ConfigMissingCompanion = 59,
76 ConfigNull = 60,
77 ConfigTotalLengthTooLarge = 61,
78 ConfigTotalLengthTooSmall = 62,
79 ContainerIdLengthTooLarge = 63,
80 ContainerIdLengthTooSmall = 64,
81 ContainerIdBufferTooSmall = 65,
82 ContainerIdReserved = 66,
83 ControlAttributesReserved = 67,
84 ControlMaxPacket = 68,
85 DeviceVersionNotBcd = 69,
86 DeviceLengthTooSmall = 70,
87 DeviceBufferTooSmall = 71,
88 CapLengthTooSmall = 72,
89 CapBufferTooSmall = 73,
90 CapMultipleContainerId = 74,
91 CapMultipleSuperSpeed = 75,
92 CapMultipleUsb20 = 76,
93 DeviceWrongType = 77,
94 DeviceMaxPacket0 = 78,
95 DeviceNull = 79,
96 EndpointLengthTooLarge = 80,
97 EndpointLengthTooSmall = 81,
98 EndpointAttributesReserved = 82,
99 EndpointBufferTooSmall = 83,
100 EndpointAddressReserved = 84,
101 EndpointBeforeInterface = 85,
102 EndpointNumberZero = 86,
103 HeaderPastBuffer = 87,
104 HeaderPastTotalLength = 88,
105 HeaderLengthTooSmall = 89,
106 HeaderBufferTooSmall = 90,
107 HeaderLengthZero = 91,
108 IadLengthTooLarge = 92,
109 IadLengthTooSmall = 93,
110 IadBufferTooSmall = 94,
111 IadCountTooLarge = 95,
112 IadCountZero = 96,
113 IadFirstInterfaceTooLarge = 97,
114 InterfaceLengthTooLarge = 98,
115 InterfaceLengthTooSmall = 99,
116 InterfaceBufferTooSmall = 100,
117 DuplicateAlternate = 101,
118 DuplicateEndpoint = 102,
119 DuplicateInterface = 103,
120 FirstAlternateNotZero = 104,
121 AlternateOutOfOrder = 105,
122 InterfaceOutOfOrder = 106,
123 EndpointCountMismatch = 107,
124 InterruptAttributesReserved = 108,
125 InterruptInterval = 109,
126 InterruptMaxPacket = 110,
127 IsochAtLowSpeed = 111,
128 IsochInterval = 112,
129 IsochMaxPacket = 113,
130 MsOsContainerIdZero = 114,
131 MsOsContainerIdVersion = 115,
132 MsOsContainerIdIndex = 116,
133 MsOsContainerIdBufferSize = 117,
134 MsOsContainerIdLength = 118,
135 MsOsExtConfigFirstInterface = 119,
136 MsOsExtConfigVersion = 120,
137 MsOsExtConfigCount = 121,
138 MsOsExtConfigBufferSize = 122,
139 MsOsExtConfigCompatibleId = 123,
140 MsOsExtConfigSubCompatibleId = 124,
141 MsOsExtConfigIndex = 125,
142 MsOsExtConfigBufferVsLength = 126,
143 MsOsExtConfigLengthVsCount = 127,
144 StringLengthOdd = 128,
145 StringLengthTooLarge = 129,
146 StringLengthTooSmall = 130,
147 StringBufferTooSmall = 131,
148 SerialNumberBadCharacter = 132,
149 StringWrongType = 133,
150 StringLengthVsBytes = 134,
151 SsCapLengthTooLarge = 135,
152 SsCapLengthTooSmall = 136,
153 SsCapAttributesReserved = 137,
154 SsCapU1TooLarge = 138,
155 SsCapU2TooLarge = 139,
156 SsCapBufferTooSmall = 140,
157 SsCapFunctionalityNotInSpeeds = 141,
158 SsCapFunctionalityReserved = 142,
159 SsCapSpeedsReserved = 143,
160 SsCapNoSpeeds = 144,
161 Usb20CapLengthTooLarge = 145,
162 Usb20CapLengthTooSmall = 146,
163 Usb20CapReserved = 147,
164 Usb20CapBufferTooSmall = 148,
165 BaselineBeslZero = 149,
166 BeslWithoutLpm = 150,
167 DeepBeslNotAboveBaseline = 151,
168 DeepBeslZero = 152,
169 BosContainerIdZero = 153,
170 MsOs20MultipleSetHeaders = 154,
171 MsOs20SetHeaderLength = 155,
172 ConfigSubsetLength = 156,
173 ConfigSubsetTotalTooSmall = 157,
174 ConfigSubsetTotalTooLarge = 158,
175 ConfigSubsetMisplacedFeature = 159,
176 ConfigSubsetFeatureLength = 160,
177 FunctionSubsetLength = 161,
178 FunctionSubsetTotalTooSmall = 162,
179 FunctionSubsetTotalTooLarge = 163,
180 FunctionSubsetMisplacedFeature = 164,
181 FunctionSubsetFeatureLength = 165,
182 MsOs20MultipleCompatibleId = 166,
183 MsOs20CompatibleIdLength = 167,
184 MsOs20CompatibleIdAfterNull = 168,
185 MsOs20RegistryTooSmall = 169,
186 MsOs20RegistryNameTooLarge = 170,
187 MsOs20RegistryNameOddOrZero = 171,
188 MsOs20RegistryDataTooLarge = 172,
189 MsOs20RegistryDataZero = 173,
190 MsOs20RegistryType = 174,
191 MsOs20MultipleResumeTime = 175,
192 MsOs20ResumeTimeLength = 176,
193 MsOs20ResumeRecovery = 177,
194 MsOs20ResumeSignaling = 178,
195 MsOs20MultipleModelId = 181,
196 MsOs20ModelIdLength = 182,
197 MsOs20ModelIdZero = 183,
198 MsOs20BytesVsSetInfo = 188,
199 MsOs20BytesTooSmall = 189,
200 MsOs20HeaderLength = 190,
201 MsOs20TotalLengthMismatch = 191,
202 MsOs20VersionMismatch = 192,
203 MsOs20FeatureOutOfOrder = 193,
204 MsOs20PastEnd = 194,
205 PlatformReserved = 195,
206 PlatformUuidZero = 196,
207 MsOs20MultiplePlatform = 197,
208 MsOs20PlatformLength = 198,
209 MsOs20DuplicateVersion = 199,
210 MsOs20NoVersionMatch = 200,
211 MsOs20MultipleCcgp = 201,
212 MsOs20CcgpLength = 202,
213 CapMultipleSuperSpeedPlus = 203,
214 CompanionIsochBytesNotOne = 204,
215 SspCompanionNotSuperSpeed = 205,
216 SspCompanionUnexpected = 206,
217 SspCompanionLengthTooLarge = 207,
218 SspCompanionLengthTooSmall = 208,
219 SspCompanionBufferTooSmall = 209,
220 SspCompanionReserved = 210,
221 SspCompanionBytesRange = 211,
222 ConfigMissingSspCompanion = 212,
223 SspCapLengthInvalid = 213,
224 SspCapLengthTooSmall = 214,
225 SspCapAttributesReserved = 215,
226 SspCapFunctionalityReserved = 216,
227 SspCapBufferTooSmall = 217,
228 SspCapReservedByte = 218,
229 SspCapReservedWord = 219,
230 SspAttrNotRx = 220,
231 SspAttrNotTx = 221,
232 SspAttrTxMissing = 222,
233 SspAttrPairMismatch = 223,
234 SspAttrSymmetricMismatch = 224,
235 SspMinLaneMismatch = 225,
236 SspSpeedIdDuplicate = 226,
237 SspSpeedIdCount = 227,
238 SspMinSpeedMissing = 228,
239 PdLengthTooLarge = 229,
240 PdLengthTooSmall = 230,
241 PdBufferTooSmall = 231,
242 PdReserved = 232,
243 IsochPacketInAlternate0 = 233,
244 DuplicateSerialNumber = 234,
245 BillboardLengthTooSmall = 235,
246 BillboardLengthInvalid = 236,
247 BillboardBufferTooSmall = 237,
248 BillboardNoModes = 238,
249 BillboardTooManyModes = 239,
250 BillboardPreferredInvalid = 241,
251 CapMultipleBillboard = 245,
252 BillboardDeviceVersion = 246,
253 PlatformFeaturesLength = 247,
254 PlatformFeaturesMultiple = 248,
255 PlatformFeaturesVersion = 249,
256 PlatformFeaturesTooSmall = 250,
257 PlatformLengthTooSmall = 251,
258 PlatformBufferTooSmall = 253,
259 Count = 254
260};
HubDescCode::MsOs20PlatformLength
@ MsOs20PlatformLength
HubDescCode::ConfigBufferTooSmall
@ ConfigBufferTooSmall
HubDescCode::PlatformBufferTooSmall
@ PlatformBufferTooSmall
HubDescCode::SspCapAttributesReserved
@ SspCapAttributesReserved
HubDescCode::ConfigTotalLengthTooLarge
@ ConfigTotalLengthTooLarge
HubDescCode::FunctionSubsetLength
@ FunctionSubsetLength
HubDescCode::CompanionControlBytesPerInterval
@ CompanionControlBytesPerInterval
HubDescCode::PlatformFeaturesVersion
@ PlatformFeaturesVersion
HubDescCode::MsOs20ResumeTimeLength
@ MsOs20ResumeTimeLength
HubDescCode::MsOs20MultiplePlatform
@ MsOs20MultiplePlatform
HubDescCode::CapMultipleBillboard
@ CapMultipleBillboard
HubDescCode::InterfaceBufferTooSmall
@ InterfaceBufferTooSmall
HubDescCode::SspCompanionLengthTooSmall
@ SspCompanionLengthTooSmall
HubDescCode::BillboardPreferredInvalid
@ BillboardPreferredInvalid
HubDescCode::Hub20RemovableReserved
@ Hub20RemovableReserved
HubDescCode::MsOsContainerIdIndex
@ MsOsContainerIdIndex
HubDescCode::MsOs20MultipleResumeTime
@ MsOs20MultipleResumeTime
HubDescCode::IadFirstInterfaceTooLarge
@ IadFirstInterfaceTooLarge
HubDescCode::ConfigLengthTooSmall
@ ConfigLengthTooSmall
HubDescCode::Hub20RemovableMissingPort
@ Hub20RemovableMissingPort
HubDescCode::MsOsExtConfigBufferSize
@ MsOsExtConfigBufferSize
HubDescCode::FunctionSubsetMisplacedFeature
@ FunctionSubsetMisplacedFeature
HubDescCode::FirstAlternateNotZero
@ FirstAlternateNotZero
HubDescCode::BosBufferLargerThanTotal
@ BosBufferLargerThanTotal
HubDescCode::DeviceBufferTooSmall
@ DeviceBufferTooSmall
HubDescCode::SsCapAttributesReserved
@ SsCapAttributesReserved
HubDescCode::EndpointCountMismatch
@ EndpointCountMismatch
HubDescCode::MsOsExtConfigCompatibleId
@ MsOsExtConfigCompatibleId
HubDescCode::SspCompanionBytesRange
@ SspCompanionBytesRange
HubDescCode::MsOs20RegistryNameTooLarge
@ MsOs20RegistryNameTooLarge
HubDescCode::ConfigSubsetMisplacedFeature
@ ConfigSubsetMisplacedFeature
HubDescCode::FunctionSubsetTotalTooLarge
@ FunctionSubsetTotalTooLarge
HubDescCode::CompanionBulkReserved
@ CompanionBulkReserved
HubDescCode::MsOsExtConfigFirstInterface
@ MsOsExtConfigFirstInterface
HubDescCode::SspCompanionNotSuperSpeed
@ SspCompanionNotSuperSpeed
HubDescCode::PlatformFeaturesTooSmall
@ PlatformFeaturesTooSmall
HubDescCode::BosTotalLengthTooSmall
@ BosTotalLengthTooSmall
HubDescCode::MsOs20RegistryDataTooLarge
@ MsOs20RegistryDataTooLarge
HubDescCode::Hub30RemovableMissingPort
@ Hub30RemovableMissingPort
HubDescCode::MsOs20RegistryTooSmall
@ MsOs20RegistryTooSmall
HubDescCode::MsOsContainerIdVersion
@ MsOsContainerIdVersion
HubDescCode::DeepBeslNotAboveBaseline
@ DeepBeslNotAboveBaseline
HubDescCode::ConfigMissingCompanion
@ ConfigMissingCompanion
HubDescCode::BillboardDeviceVersion
@ BillboardDeviceVersion
HubDescCode::ConfigLengthTooLarge
@ ConfigLengthTooLarge
HubDescCode::CompanionIsochReserved
@ CompanionIsochReserved
HubDescCode::MsOs20BytesVsSetInfo
@ MsOs20BytesVsSetInfo
HubDescCode::MsOs20NoVersionMatch
@ MsOs20NoVersionMatch
HubDescCode::CompanionInterruptBurst
@ CompanionInterruptBurst
HubDescCode::SspCapBufferTooSmall
@ SspCapBufferTooSmall
HubDescCode::EndpointBeforeInterface
@ EndpointBeforeInterface
HubDescCode::EndpointAddressReserved
@ EndpointAddressReserved
HubDescCode::FunctionSubsetFeatureLength
@ FunctionSubsetFeatureLength
HubDescCode::SsCapFunctionalityReserved
@ SsCapFunctionalityReserved
HubDescCode::BillboardTooManyModes
@ BillboardTooManyModes
HubDescCode::BillboardBufferTooSmall
@ BillboardBufferTooSmall
HubDescCode::ContainerIdLengthTooLarge
@ ContainerIdLengthTooLarge
HubDescCode::CompanionInterruptBytesPerInterval
@ CompanionInterruptBytesPerInterval
HubDescCode::CompanionInterruptAttributes
@ CompanionInterruptAttributes
HubDescCode::IsochPacketInAlternate0
@ IsochPacketInAlternate0
HubDescCode::CapMultipleContainerId
@ CapMultipleContainerId
HubDescCode::CompanionIsochBytesPerInterval
@ CompanionIsochBytesPerInterval
HubDescCode::MsOs20ResumeSignaling
@ MsOs20ResumeSignaling
HubDescCode::BulkAttributesReserved
@ BulkAttributesReserved
HubDescCode::FunctionSubsetTotalTooSmall
@ FunctionSubsetTotalTooSmall
HubDescCode::SspCompanionLengthTooLarge
@ SspCompanionLengthTooLarge
HubDescCode::MsOs20CompatibleIdAfterNull
@ MsOs20CompatibleIdAfterNull
HubDescCode::MsOs20CompatibleIdLength
@ MsOs20CompatibleIdLength
HubDescCode::PlatformLengthTooSmall
@ PlatformLengthTooSmall
HubDescCode::EndpointAttributesReserved
@ EndpointAttributesReserved
HubDescCode::CompanionLengthTooSmall
@ CompanionLengthTooSmall
HubDescCode::CompanionControlBurst
@ CompanionControlBurst
HubDescCode::DeviceLengthTooSmall
@ DeviceLengthTooSmall
HubDescCode::MsOsExtConfigBufferVsLength
@ MsOsExtConfigBufferVsLength
HubDescCode::MsOs20RegistryNameOddOrZero
@ MsOs20RegistryNameOddOrZero
HubDescCode::SspCapFunctionalityReserved
@ SspCapFunctionalityReserved
HubDescCode::InterfaceLengthTooLarge
@ InterfaceLengthTooLarge
HubDescCode::InterfaceLengthTooSmall
@ InterfaceLengthTooSmall
HubDescCode::MsOsExtConfigSubCompatibleId
@ MsOsExtConfigSubCompatibleId
HubDescCode::InterruptAttributesReserved
@ InterruptAttributesReserved
HubDescCode::PlatformFeaturesLength
@ PlatformFeaturesLength
HubDescCode::CompanionControlAttributes
@ CompanionControlAttributes
HubDescCode::SsCapFunctionalityNotInSpeeds
@ SsCapFunctionalityNotInSpeeds
HubDescCode::MsOsContainerIdBufferSize
@ MsOsContainerIdBufferSize
HubDescCode::HeaderPastTotalLength
@ HeaderPastTotalLength
HubDescCode::ConfigSubsetFeatureLength
@ ConfigSubsetFeatureLength
HubDescCode::Usb20CapBufferTooSmall
@ Usb20CapBufferTooSmall
HubDescCode::MsOs20SetHeaderLength
@ MsOs20SetHeaderLength
HubDescCode::Hub30CharacteristicsReserved
@ Hub30CharacteristicsReserved
HubDescCode::SspCompanionBufferTooSmall
@ SspCompanionBufferTooSmall
HubDescCode::StringLengthTooSmall
@ StringLengthTooSmall
HubDescCode::ConfigTotalLengthTooSmall
@ ConfigTotalLengthTooSmall
HubDescCode::MsOs20MultipleSetHeaders
@ MsOs20MultipleSetHeaders
HubDescCode::MsOs20FeatureOutOfOrder
@ MsOs20FeatureOutOfOrder
HubDescCode::CompanionLengthTooLarge
@ CompanionLengthTooLarge
HubDescCode::MsOsExtConfigLengthVsCount
@ MsOsExtConfigLengthVsCount
HubDescCode::CompanionBulkStreams
@ CompanionBulkStreams
HubDescCode::MsOsContainerIdLength
@ MsOsContainerIdLength
HubDescCode::SspCompanionUnexpected
@ SspCompanionUnexpected
HubDescCode::EndpointLengthTooLarge
@ EndpointLengthTooLarge
HubDescCode::BillboardLengthInvalid
@ BillboardLengthInvalid
HubDescCode::ContainerIdBufferTooSmall
@ ContainerIdBufferTooSmall
HubDescCode::CompanionBufferTooSmall
@ CompanionBufferTooSmall
HubDescCode::PlatformFeaturesMultiple
@ PlatformFeaturesMultiple
HubDescCode::Usb20CapLengthTooSmall
@ Usb20CapLengthTooSmall
HubDescCode::DuplicateSerialNumber
@ DuplicateSerialNumber
HubDescCode::ContainerIdLengthTooSmall
@ ContainerIdLengthTooSmall
HubDescCode::CompanionInterruptBurstPacket
@ CompanionInterruptBurstPacket
HubDescCode::Usb20CapLengthTooLarge
@ Usb20CapLengthTooLarge
HubDescCode::CompanionBulkBytesPerInterval
@ CompanionBulkBytesPerInterval
HubDescCode::Hub30RemovableReserved
@ Hub30RemovableReserved
HubDescCode::BillboardLengthTooSmall
@ BillboardLengthTooSmall
HubDescCode::StringLengthTooLarge
@ StringLengthTooLarge
HubDescCode::ConfigSubsetTotalTooSmall
@ ConfigSubsetTotalTooSmall
HubDescCode::ConfigSubsetTotalTooLarge
@ ConfigSubsetTotalTooLarge
HubDescCode::HeaderLengthTooSmall
@ HeaderLengthTooSmall
HubDescCode::CompanionIsochBurstPacket
@ CompanionIsochBurstPacket
HubDescCode::ConfigMissingSspCompanion
@ ConfigMissingSspCompanion
HubDescCode::StringBufferTooSmall
@ StringBufferTooSmall
HubDescCode::MsOs20RegistryDataZero
@ MsOs20RegistryDataZero
HubDescCode::EndpointLengthTooSmall
@ EndpointLengthTooSmall
HubDescCode::MsOs20ResumeRecovery
@ MsOs20ResumeRecovery
HubDescCode::MsOs20TotalLengthMismatch
@ MsOs20TotalLengthMismatch
HubDescCode::MsOs20MultipleModelId
@ MsOs20MultipleModelId
HubDescCode::SerialNumberBadCharacter
@ SerialNumberBadCharacter
HubDescCode::ControlAttributesReserved
@ ControlAttributesReserved
HubDescCode::HeaderBufferTooSmall
@ HeaderBufferTooSmall
HubDescCode::Hub30DecodeLatencyReserved
@ Hub30DecodeLatencyReserved
HubDescCode::Hub20PowerMaskNotOnes
@ Hub20PowerMaskNotOnes
HubDescCode::CompanionNotSuperSpeed
@ CompanionNotSuperSpeed
HubDescCode::SspCompanionReserved
@ SspCompanionReserved
HubDescCode::Hub20CharacteristicsReserved
@ Hub20CharacteristicsReserved
HubDescCode::MsOsExtConfigVersion
@ MsOsExtConfigVersion
HubDescCode::CapMultipleSuperSpeedPlus
@ CapMultipleSuperSpeedPlus
HubDescCode::SspAttrSymmetricMismatch
@ SspAttrSymmetricMismatch
HubDescCode::CapMultipleSuperSpeed
@ CapMultipleSuperSpeed
HubDescCode::MsOs20MultipleCompatibleId
@ MsOs20MultipleCompatibleId
HubDescCode::MsOs20VersionMismatch
@ MsOs20VersionMismatch
HubDescCode::EndpointBufferTooSmall
@ EndpointBufferTooSmall
HubDescCode::CompanionIsochBytesNotOne
@ CompanionIsochBytesNotOne
HubDescCode::SspCapLengthTooSmall
@ SspCapLengthTooSmall
HubDescCode::ConfigBufferTooSmallForInterfaces
@ ConfigBufferTooSmallForInterfaces
HubDescCode::MsOs20DuplicateVersion
@ MsOs20DuplicateVersion

Function Documentation

◆ _In_reads_bytes_()

_In_reads_bytes_ ( Length  )

◆ _Inout_updates_bytes_()

_Inout_updates_bytes_ ( Length  )

◆ _IRQL_requires_()

_IRQL_requires_ ( PASSIVE_LEVEL  ) const

Whole BOS set. Outputs are filled even on FALSE, and a Billboard capability with bLength 40 or 44 gets its bLength fixed in the buffer.

MS OS 2.0 descriptor set. SetInfo is the entry the BOS walk selected; on failure Info->Flags is cleared.

◆ C_ASSERT() [1/9]

C_ASSERT ( sizeof(HubMsOs20CompatibleId)  = =20)

◆ C_ASSERT() [2/9]

C_ASSERT ( sizeof(HubMsOs20SetHeader)  = =10)

◆ C_ASSERT() [3/9]

C_ASSERT ( sizeof(HubMsOs20SetInfo)  = =8)

◆ C_ASSERT() [4/9]

C_ASSERT ( sizeof(HubMsOs20Subset)  = =8)

◆ C_ASSERT() [5/9]

C_ASSERT ( sizeof(HubMsOsContainerId)  = =24)

◆ C_ASSERT() [6/9]

C_ASSERT ( sizeof(HubMsOsExtConfig)  = =40)

◆ C_ASSERT() [7/9]

C_ASSERT ( sizeof(HubMsOsExtConfigHeader)  = =16)

◆ C_ASSERT() [8/9]

C_ASSERT ( sizeof(HubMsOsString)  = =18)

◆ C_ASSERT() [9/9]

C_ASSERT ( sizeof(HubPlatformFeatures)  = =26)

◆ HubDescCheck20Hub()

BOOLEAN NTAPI HubDescCheck20Hub ( _In_ const HubDescContext *  Context,
_In_reads_bytes_opt_(Length) PUSB_HUB_DESCRIPTOR  Descriptor,
_In_ ULONG  Length 
)

USB 2.0 hub descriptor. Hub ParseHubDescriptor for Full and High speed hubs.

Definition at line 3198 of file desccheck.cpp.

3202{
3203 Verdict Result = Verdict::Ok;
3204 ULONG Fixed = FIELD_OFFSET(USB_HUB_DESCRIPTOR, bRemoveAndPowerMask);
3205 ULONG Ports;
3206 ULONG RemovableBytes;
3207 ULONG PowerBytes;
3208 ULONG Expected;
3209 ULONG Used;
3210 UCHAR Spare;
3211 ULONG i;
3212
3213 if (Descriptor == NULL)
3214 {
3215 HubDescLog(Context, HubDescCode::Hub20Null, FALSE);
3216 return FALSE;
3217 }
3218
3219 if (Length < Fixed)
3220 {
3221 HubDescLog(Context, HubDescCode::Hub20BufferTooSmall, FALSE);
3222 return FALSE;
3223 }
3224
3225 Ports = Descriptor->bNumberOfPorts;
3226 if (Ports == 0)
3227 Note(Context, &Result, HubDescCode::Hub20NoPorts, Gate::Always);
3228
3229 /* DeviceRemovable has a reserved bit 0 plus one bit per port; the power mask is legacy */
3230 RemovableBytes = (Ports + 8) / 8;
3231 PowerBytes = (Ports + 7) / 8;
3232 Expected = Fixed + RemovableBytes + PowerBytes;
3233
3234 if (Descriptor->bDescriptorLength < Expected)
3235 Note(Context, &Result, HubDescCode::Hub20LengthTooSmall, Gate::NewRule);
3236
3237 if (Descriptor->bDescriptorLength > Expected)
3238 Note(Context, &Result, HubDescCode::Hub20LengthTooLarge, Gate::Versioned);
3239
3240 if (Descriptor->bDescriptorType != USB_20_HUB_DESCRIPTOR_TYPE)
3241 Note(Context, &Result, HubDescCode::Hub20WrongType, Gate::NewRule);
3242
3243 if (Descriptor->wHubCharacteristics & 0x0002)
3244 Note(Context, &Result, HubDescCode::Hub20CharacteristicsReserved, Gate::Reserved);
3245
3246 if (Descriptor->wHubCharacteristics & 0xFF00)
3247 Note(Context, &Result, HubDescCode::Hub20CharacteristicsReserved, Gate::Reserved);
3248
3249 if (Descriptor->bRemoveAndPowerMask[0] & 0x01)
3250 Note(Context, &Result, HubDescCode::Hub20RemovableReserved, Gate::Reserved);
3251
3252 /* Bits past the last port in the last DeviceRemovable byte */
3253 Used = (Ports + 1) % 8;
3254 if (Used != 0)
3255 {
3256 Spare = (UCHAR)(0xFF << Used);
3257 if (Descriptor->bRemoveAndPowerMask[RemovableBytes - 1] & Spare)
3258 Note(Context, &Result, HubDescCode::Hub20RemovableMissingPort, Gate::Versioned);
3259 }
3260
3261 for (i = 0; i < PowerBytes; i++)
3262 {
3263 if (Descriptor->bRemoveAndPowerMask[RemovableBytes + i] != 0xFF)
3264 Note(Context, &Result, HubDescCode::Hub20PowerMaskNotOnes, Gate::Versioned);
3265 }
3266
3267 return Result == Verdict::Ok;
3268}
Expected
BOOLEAN Expected
Definition: FsRtlExpression.c:22
Verdict
Verdict
Definition: desccheck.cpp:15
Gate::Versioned
@ Versioned
Gate::NewRule
@ NewRule
Gate::Always
@ Always
Gate::Reserved
@ Reserved
Result
Verdict Result
Definition: desccheck.cpp:2226
HubDescLog
VOID NTAPI HubDescLog(_In_ const HubDescContext *Context, _In_ HubDescCode Code, _In_ BOOLEAN Warning)
Definition: desccheck.cpp:383
FALSE
return FALSE
Definition: desccheck.cpp:3191
Note
static VOID NTAPI Note(_In_ const HubDescContext *Ctx, _Inout_ Verdict *Result, _In_ HubDescCode Code, _In_ Gate Kind)
Definition: desccheck.cpp:463
NULL
#define NULL
Definition: types.h:112
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Context
_In_ PIRP _In_ PIO_COMPLETION_ROUTINE _In_ PVOID Context
Definition: kse.h:81
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
Ports
static PS2_PORT Ports[PS2_PORTS]
Definition: ps2.c:52
_USB_HUB_DESCRIPTOR
Definition: usb100.h:170
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
ULONG
uint32_t ULONG
Definition: typedefs.h:59
USB_20_HUB_DESCRIPTOR_TYPE
#define USB_20_HUB_DESCRIPTOR_TYPE
Definition: usb200.h:280
Descriptor
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342

Referenced by HubCheckUsb2HubDescriptor().

◆ HubDescCheck30Hub()

BOOLEAN NTAPI HubDescCheck30Hub ( _In_ const HubDescContext *  Context,
_In_reads_bytes_opt_(Length) PUSB_30_HUB_DESCRIPTOR  Descriptor,
_In_ ULONG  Length 
)

USB 3.0 hub descriptor. Hub ParseHubDescriptor for SuperSpeed hubs.

Definition at line 3272 of file desccheck.cpp.

3276{
3277 Verdict Result = Verdict::Ok;
3278 ULONG Ports;
3279 ULONG Spare;
3280
3281 if (Descriptor == NULL)
3282 {
3283 DPRINT1("Hub %p has no SuperSpeed hub descriptor\n", Context->LogContext);
3284 return FALSE;
3285 }
3286
3287 if (Length < sizeof(USB_COMMON_DESCRIPTOR))
3288 {
3289 HubDescLog(Context, HubDescCode::Hub30BufferTooSmall, FALSE);
3290 return FALSE;
3291 }
3292
3293 if (Descriptor->bLength < sizeof(*Descriptor))
3294 Note(Context, &Result, HubDescCode::Hub30LengthTooSmall, Gate::Always);
3295
3296 if (Descriptor->bLength > sizeof(*Descriptor))
3297 Note(Context, &Result, HubDescCode::Hub30LengthTooLarge, Gate::Versioned);
3298
3299 if (Descriptor->bDescriptorType != USB_30_HUB_DESCRIPTOR_TYPE)
3300 Note(Context, &Result, HubDescCode::Hub30WrongType, Gate::Always);
3301
3302 Ports = Descriptor->bNumberOfPorts;
3303 if (Ports > 15)
3304 Note(Context, &Result, HubDescCode::Hub30TooManyPorts, Gate::Always);
3305
3306 if (Ports == 0)
3307 Note(Context, &Result, HubDescCode::Hub30NoPorts, Gate::Always);
3308
3309 if (Descriptor->wHubCharacteristics & 0x0002)
3310 Note(Context, &Result, HubDescCode::Hub30CharacteristicsReserved, Gate::Reserved);
3311
3312 if (Descriptor->wHubCharacteristics & 0xFFE0)
3313 Note(Context, &Result, HubDescCode::Hub30CharacteristicsReserved, Gate::Reserved);
3314
3315 if (Descriptor->bHubHdrDecLat >= 11)
3316 Note(Context, &Result, HubDescCode::Hub30DecodeLatencyReserved, Gate::Versioned);
3317
3318 if (Descriptor->DeviceRemovable & 0x0001)
3319 Note(Context, &Result, HubDescCode::Hub30RemovableReserved, Gate::Reserved);
3320
3321 /* Bits above the last port; with 15 or more ports none are left */
3322 Spare = (Ports + 1 < 16) ? (0xFFFFUL << (Ports + 1)) & 0xFFFF : 0;
3323 if (Descriptor->DeviceRemovable & Spare)
3324 Note(Context, &Result, HubDescCode::Hub30RemovableMissingPort, Gate::Versioned);
3325
3326 return Result == Verdict::Ok;
3327}
DPRINT1
#define DPRINT1
Definition: precomp.h:8
_USB_COMMON_DESCRIPTOR
Definition: usb100.h:165
USB_30_HUB_DESCRIPTOR_TYPE
#define USB_30_HUB_DESCRIPTOR_TYPE
Definition: usb200.h:281

Referenced by HubCheckUsb3HubDescriptor().

◆ HubDescCheckBosHeader()

BOOLEAN NTAPI HubDescCheckBosHeader ( _In_ const HubDescContext *  Context,
_In_reads_bytes_opt_(Length) PUSB_BOS_DESCRIPTOR  Descriptor,
_In_ ULONG  Length 
)

The 5 byte BOS header on its own. BosHeaderValid.

Definition at line 2197 of file desccheck.cpp.

2201{
2202 Verdict Result = Verdict::Ok;
2203 PUCHAR End;
2204 ULONG Advance;
2205
2206 CheckBosFixedPart(Context, Descriptor, Length, &End, &Advance, &Result);
2207 return Result == Verdict::Ok;
2208}
End
PUCHAR End
Definition: desccheck.cpp:2229
CheckBosFixedPart
static VOID NTAPI CheckBosFixedPart(_In_ const HubDescContext *Ctx, _In_opt_ PUSB_BOS_DESCRIPTOR Bos, _In_ ULONG Length, _Out_ PUCHAR *End, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1466
Advance
ULONG Advance
Definition: desccheck.cpp:2231
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53

Referenced by DeviceMachine::BosHeaderValid().

◆ HubDescCheckConfiguration()

BOOLEAN NTAPI HubDescCheckConfiguration ( _In_ const HubDescContext *  Context,
_In_reads_bytes_opt_(Length) PUSB_CONFIGURATION_DESCRIPTOR  Descriptor,
_In_ ULONG  Length,
_Out_opt_ PBOOLEAN  SupportsStreams 
)

Whole configuration descriptor set. SupportsStreams reflects the last companion.

Definition at line 1237 of file desccheck.cpp.

1242{
1243 ConfigWalk Walk;
1244 Verdict Result;
1245 BOOLEAN Valid = TRUE;
1246 PUCHAR Cursor;
1247
1248 if (SupportsStreams != NULL)
1249 *SupportsStreams = FALSE;
1250
1251 if (Descriptor == NULL)
1252 {
1253 HubDescLog(Context, HubDescCode::ConfigNull, FALSE);
1254 return FALSE;
1255 }
1256
1257 if (Length < sizeof(*Descriptor))
1258 {
1259 HubDescLog(Context, HubDescCode::ConfigBufferTooSmall, FALSE);
1260 return FALSE;
1261 }
1262
1263 RtlZeroMemory(&Walk, sizeof(Walk));
1264 Walk.Ctx = Context;
1265 Walk.Base = (PUCHAR)Descriptor;
1266 Walk.BufferLength = Length;
1267 Walk.End = Walk.Base + Length;
1268 Walk.Config = Descriptor;
1269 Walk.SupportsStreams = SupportsStreams;
1270
1271 Result = Verdict::Ok;
1272 CheckConfigFixedPart(&Walk, &Result);
1273 if (Result == Verdict::Fatal)
1274 return FALSE;
1275
1276 if (Result != Verdict::Ok)
1277 Valid = FALSE;
1278
1279 /* QUIRK: the walk starts after the 9 fixed bytes even when bLength is larger */
1280 Cursor = Walk.Base + sizeof(*Descriptor);
1281 while (Cursor < Walk.End)
1282 {
1283 PUSB_COMMON_DESCRIPTOR Desc = (PUSB_COMMON_DESCRIPTOR)Cursor;
1284 ULONG Advance;
1285
1286 Result = Verdict::Ok;
1287 CheckHeader(Context, Walk.Base, Length, Walk.End, Desc, &Advance, &Result);
1288 if (Result == Verdict::Fatal)
1289 return FALSE;
1290
1291 /* Compatibility mode lets header findings pass here (a Cypress mouse needs it) */
1292 if (Result == Verdict::Failed && !Context->Win8Behavior)
1293 Valid = FALSE;
1294
1295 Result = Verdict::Ok;
1296 switch (Desc->bDescriptorType)
1297 {
1298 case USB_INTERFACE_DESCRIPTOR_TYPE:
1299 Walk.WantCompanion = FALSE;
1300 Walk.WantSspCompanion = FALSE;
1301 CheckInterface(&Walk, (PUSB_INTERFACE_DESCRIPTOR)Desc, &Advance, &Result);
1302 break;
1303
1304 case USB_ENDPOINT_DESCRIPTOR_TYPE:
1305 Walk.WantSspCompanion = FALSE;
1306 CheckEndpoint(&Walk, (PUSB_ENDPOINT_DESCRIPTOR)Desc, &Advance, &Result);
1307 break;
1308
1309 case USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR_TYPE:
1310 Walk.WantSspCompanion = FALSE;
1311 CheckCompanion(&Walk, (PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR)Desc, &Advance, &Result);
1312 break;
1313
1314 case USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR_TYPE:
1315 CheckSspCompanion(&Walk,
1316 (PUSB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR)Desc,
1317 &Advance,
1318 &Result);
1319 break;
1320
1321 case USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE:
1322 Walk.WantCompanion = FALSE;
1323 Walk.WantSspCompanion = FALSE;
1324 CheckIad(&Walk, (PUSB_INTERFACE_ASSOCIATION_DESCRIPTOR)Desc, &Advance, &Result);
1325 break;
1326
1327 default:
1328 Walk.WantCompanion = FALSE;
1329 Walk.WantSspCompanion = FALSE;
1330 break;
1331 }
1332
1333 if (Result == Verdict::Fatal)
1334 return FALSE;
1335
1336 if (Result == Verdict::Failed)
1337 Valid = FALSE;
1338
1339 /* Zero padding at the end of the set is tolerated */
1340 if (Desc->bLength == 0)
1341 break;
1342
1343 Cursor += Advance;
1344 }
1345
1346 Result = Verdict::Ok;
1347 CheckPreviousInterface(&Walk, &Result);
1348 if (Result != Verdict::Ok)
1349 Valid = FALSE;
1350
1351 /* No validation code for this one */
1352 if (Walk.InterfacesFound != Descriptor->bNumInterfaces && GateApplies(Context, Gate::Legacy))
1353 {
1354 DPRINT1("%s %p configuration has %lu interfaces, bNumInterfaces %u\n",
1355 Context->ForHub ? "Hub" : "Device", Context->LogContext,
1356 Walk.InterfacesFound, Descriptor->bNumInterfaces);
1357 Valid = FALSE;
1358 }
1359
1360 return Valid;
1361}
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
Gate::Legacy
@ Legacy
CheckIad
static VOID NTAPI CheckIad(_Inout_ ConfigWalk *Walk, _In_ PUSB_INTERFACE_ASSOCIATION_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1193
CheckInterface
static VOID NTAPI CheckInterface(_Inout_ ConfigWalk *Walk, _In_ PUSB_INTERFACE_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:735
CheckConfigFixedPart
static VOID NTAPI CheckConfigFixedPart(_Inout_ ConfigWalk *Walk, _Inout_ Verdict *Result)
Definition: desccheck.cpp:636
CheckSspCompanion
static VOID NTAPI CheckSspCompanion(_Inout_ ConfigWalk *Walk, _In_ PUSB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1141
CheckHeader
static VOID NTAPI CheckHeader(_In_ const HubDescContext *Ctx, _In_ PUCHAR Base, _In_ ULONG BufferLength, _In_ PUCHAR End, _In_ PUSB_COMMON_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:591
GateApplies
static BOOLEAN NTAPI GateApplies(_In_ const HubDescContext *Ctx, _In_ Gate Kind)
Definition: desccheck.cpp:418
TRUE
TRUE
Definition: desccheck.cpp:2267
CheckCompanion
static VOID NTAPI CheckCompanion(_Inout_ ConfigWalk *Walk, _In_ PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1007
Length
_In_ ULONG Length
Definition: desccheck.cpp:2216
Cursor
PUCHAR Cursor
Definition: desccheck.cpp:2228
CheckPreviousInterface
static VOID NTAPI CheckPreviousInterface(_Inout_ ConfigWalk *Walk, _Inout_ Verdict *Result)
Definition: desccheck.cpp:712
Walk
BosWalk Walk
Definition: desccheck.cpp:2225
Valid
BOOLEAN Valid
Definition: desccheck.cpp:2227
CheckEndpoint
static VOID NTAPI CheckEndpoint(_Inout_ ConfigWalk *Walk, _In_ PUSB_ENDPOINT_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:945
BosWalk::Base
PUCHAR Base
Definition: desccheck.cpp:78
BosWalk::Ctx
const HubDescContext * Ctx
Definition: desccheck.cpp:77
BosWalk::BufferLength
ULONG BufferLength
Definition: desccheck.cpp:79
_USB_COMMON_DESCRIPTOR::bLength
UCHAR bLength
Definition: usb100.h:166
_USB_COMMON_DESCRIPTOR::bDescriptorType
UCHAR bDescriptorType
Definition: usb100.h:167
_USB_ENDPOINT_DESCRIPTOR
Definition: usb100.h:127
_USB_INTERFACE_ASSOCIATION_DESCRIPTOR
Definition: usb200.h:120
_USB_INTERFACE_DESCRIPTOR
Definition: usb100.h:147
_USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR
Definition: usb300.h:274
_USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR
Definition: usb300.h:255
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
USB_ENDPOINT_DESCRIPTOR_TYPE
#define USB_ENDPOINT_DESCRIPTOR_TYPE
Definition: usb100.h:53
PUSB_COMMON_DESCRIPTOR
struct _USB_COMMON_DESCRIPTOR * PUSB_COMMON_DESCRIPTOR
USB_INTERFACE_DESCRIPTOR_TYPE
#define USB_INTERFACE_DESCRIPTOR_TYPE
Definition: usb100.h:52
USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE
#define USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE
Definition: usb200.h:118
USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR_TYPE
#define USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR_TYPE
Definition: usb300.h:20
USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR_TYPE
#define USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR_TYPE
Definition: usb300.h:19

Referenced by DeviceMachine::ConfigDescriptorValid(), HubCheckConfigDescriptor(), and HubValidateHubConfiguration().

◆ HubDescCheckDevice()

BOOLEAN NTAPI HubDescCheckDevice ( _In_ const HubDescContext *  Context,
_In_reads_bytes_opt_(Length) PUSB_DEVICE_DESCRIPTOR  Descriptor,
_In_ ULONG  Length,
_Inout_opt_ PBOOLEAN  IsBillboard 
)

Device descriptor. Length is the bytes returned; IsBillboard is only ever set TRUE.

Definition at line 1367 of file desccheck.cpp.

1372{
1373 Verdict Result = Verdict::Ok;
1374 USHORT Version;
1375 ULONG Packet0;
1376 ULONG i;
1377
1378 if (Descriptor == NULL)
1379 {
1380 HubDescLog(Context, HubDescCode::DeviceNull, FALSE);
1381 return FALSE;
1382 }
1383
1384 if (Length < sizeof(USB_COMMON_DESCRIPTOR))
1385 {
1386 HubDescLog(Context, HubDescCode::DeviceBufferTooSmall, FALSE);
1387 return FALSE;
1388 }
1389
1390 if (Descriptor->bLength < sizeof(*Descriptor))
1391 Note(Context, &Result, HubDescCode::DeviceLengthTooSmall, Gate::Always);
1392
1393 if (Descriptor->bDescriptorType != USB_DEVICE_DESCRIPTOR_TYPE)
1394 Note(Context, &Result, HubDescCode::DeviceWrongType, Gate::Always);
1395
1396 if (Length < 8)
1397 {
1398 HubDescLog(Context, HubDescCode::DeviceBufferTooSmall, FALSE);
1399 return FALSE;
1400 }
1401
1402 /* Skipped on the 8 byte read, where these bytes are stale */
1403 if (Length >= RTL_SIZEOF_THROUGH_FIELD(USB_DEVICE_DESCRIPTOR, bcdDevice))
1404 {
1405 for (i = 0; i < 16; i += 4)
1406 {
1407 if (((Descriptor->bcdDevice >> i) & 0xF) > 9)
1408 {
1409 Note(Context, &Result, HubDescCode::DeviceVersionNotBcd, Gate::Warning);
1410 break;
1411 }
1412 }
1413 }
1414
1415 /* The gates use the context version; this one is the descriptor's own */
1416 Version = Descriptor->bcdUSB;
1417 if (Descriptor->bDeviceClass == USB_DEVICE_CLASS_BILLBOARD &&
1418 Descriptor->bDeviceSubClass == 0 &&
1419 Descriptor->bDeviceProtocol == 0)
1420 {
1421 if (Version > 0x0200 && Version < 0x0300)
1422 {
1423 if (IsBillboard != NULL)
1424 *IsBillboard = TRUE;
1425 }
1426 else
1427 {
1428 /* QUIRK: a USB 3.x Billboard device fails enumeration */
1429 Note(Context, &Result, HubDescCode::BillboardDeviceVersion, Gate::Always);
1430 }
1431 }
1432
1433 Packet0 = Descriptor->bMaxPacketSize0;
1434 switch (Context->Speed)
1435 {
1436 /* QUIRK: low and high speed can log the code twice */
1437 case UsbLowSpeed:
1438 case UsbHighSpeed:
1439 if (Packet0 != (Context->Speed == UsbLowSpeed ? 8UL : 64UL))
1440 {
1441 Note(Context, &Result, HubDescCode::DeviceMaxPacket0, Gate::Versioned);
1442 if (!IsSmallPacket(Packet0))
1443 Note(Context, &Result, HubDescCode::DeviceMaxPacket0, Gate::Always);
1444 }
1445 break;
1446
1447 case UsbFullSpeed:
1448 if (!IsSmallPacket(Packet0))
1449 Note(Context, &Result, HubDescCode::DeviceMaxPacket0, Gate::Always);
1450 break;
1451
1452 case UsbSuperSpeed:
1453 if (Packet0 != 9)
1454 Note(Context, &Result, HubDescCode::DeviceMaxPacket0, Gate::Versioned);
1455 break;
1456 }
1457
1458 return Result == Verdict::Ok;
1459}
Gate::Warning
@ Warning
IsSmallPacket
static BOOLEAN NTAPI IsSmallPacket(_In_ ULONG Size)
Definition: desccheck.cpp:569
RTL_SIZEOF_THROUGH_FIELD
#define RTL_SIZEOF_THROUGH_FIELD(type, field)
Definition: ntbasedef.h:684
USHORT
unsigned short USHORT
Definition: pedump.c:61
_USB_DEVICE_DESCRIPTOR
Definition: usb100.h:110
USB_DEVICE_DESCRIPTOR_TYPE
#define USB_DEVICE_DESCRIPTOR_TYPE
Definition: usb100.h:49
UsbSuperSpeed
@ UsbSuperSpeed
Definition: usb200.h:45
UsbHighSpeed
@ UsbHighSpeed
Definition: usb200.h:44
UsbLowSpeed
@ UsbLowSpeed
Definition: usb200.h:42
UsbFullSpeed
@ UsbFullSpeed
Definition: usb200.h:43
USB_DEVICE_CLASS_BILLBOARD
#define USB_DEVICE_CLASS_BILLBOARD
Definition: usb200.h:308
Version
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469

Referenced by DeviceMachine::DeviceDescriptorValid(), and DeviceMachine::FirstDescriptorValid().

◆ HubDescCheckMsOsContainerId()

BOOLEAN NTAPI HubDescCheckMsOsContainerId ( _In_ const HubDescContext *  Context,
_In_reads_bytes_(Length) const HubMsOsContainerId *  Descriptor,
_In_ ULONG  Length 
)

MS OS 1.0 container ID. ContainerIdKnown.

Definition at line 2541 of file desccheck.cpp.

2545{
2546 if (Length != sizeof(*Descriptor))
2547 {
2548 HubDescLog(Context, HubDescCode::MsOsContainerIdBufferSize, FALSE);
2549 return FALSE;
2550 }
2551
2552 if (IsAllZero(Descriptor->ContainerId, sizeof(Descriptor->ContainerId)))
2553 {
2554 HubDescLog(Context, HubDescCode::MsOsContainerIdZero, FALSE);
2555 return FALSE;
2556 }
2557
2558 return TRUE;
2559}
IsAllZero
static BOOLEAN NTAPI IsAllZero(_In_reads_bytes_(Length) const VOID *Buffer, _In_ ULONG Length)
Definition: desccheck.cpp:549

Referenced by DeviceMachine::ContainerIdKnown().

◆ HubDescCheckMsOsContainerIdHeader()

BOOLEAN NTAPI HubDescCheckMsOsContainerIdHeader ( _In_ const HubDescContext *  Context,
_In_reads_bytes_(Length) const HubMsOsHeader *  Descriptor,
_In_ ULONG  Length 
)

MS OS 1.0 container ID header. ContainerIdHeaderValid.

Definition at line 2505 of file desccheck.cpp.

2509{
2510 BOOLEAN Valid = TRUE;
2511
2512 if (Length != sizeof(*Descriptor))
2513 {
2514 HubDescLog(Context, HubDescCode::MsOsContainerIdBufferSize, FALSE);
2515 return FALSE;
2516 }
2517
2518 if (Descriptor->bcdVersion != 0x0100)
2519 {
2520 HubDescLog(Context, HubDescCode::MsOsContainerIdVersion, FALSE);
2521 Valid = FALSE;
2522 }
2523
2524 if (Descriptor->wIndex != 6)
2525 {
2526 HubDescLog(Context, HubDescCode::MsOsContainerIdIndex, FALSE);
2527 Valid = FALSE;
2528 }
2529
2530 if (Descriptor->dwLength != sizeof(HubMsOsContainerId))
2531 {
2532 HubDescLog(Context, HubDescCode::MsOsContainerIdLength, FALSE);
2533 Valid = FALSE;
2534 }
2535
2536 return Valid;
2537}

Referenced by DeviceMachine::ContainerIdHeaderValid().

◆ HubDescCheckMsOsExtConfig()

BOOLEAN NTAPI HubDescCheckMsOsExtConfig ( _In_ const HubDescContext *  Context,
_In_reads_bytes_(sizeof(HubMsOsExtConfig)) const HubMsOsExtConfig *  Descriptor,
_In_ ULONG  Length 
)

MS OS 1.0 extended configuration. The buffer must hold the 40 bytes the validated header promised, whatever Length says.

Definition at line 2606 of file desccheck.cpp.

2610{
2611 const HubMsOsExtConfigFunction* Function = &Descriptor->Function[0];
2612 Verdict Result = Verdict::Ok;
2613
2614 if (Length != Descriptor->Header.dwLength)
2615 Note(Context, &Result, HubDescCode::MsOsExtConfigBufferVsLength, Gate::NewRule);
2616
2617 /* Interface numbers are not compared with the configuration */
2618 if (!IsMsOs10IdValid(Function->CompatibleId))
2619 {
2620 HubDescLog(Context, HubDescCode::MsOsExtConfigCompatibleId, FALSE);
2621 return FALSE;
2622 }
2623
2624 if (!IsMsOs10IdValid(Function->SubCompatibleId))
2625 {
2626 HubDescLog(Context, HubDescCode::MsOsExtConfigSubCompatibleId, FALSE);
2627 return FALSE;
2628 }
2629
2630 return Result == Verdict::Ok;
2631}
Function
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
IsMsOs10IdValid
static BOOLEAN NTAPI IsMsOs10IdValid(_In_reads_(8) const UCHAR *Id)
Definition: desccheck.cpp:2471

Referenced by DeviceMachine::ExtendedConfigValid().

◆ HubDescCheckMsOsExtConfigHeader()

BOOLEAN NTAPI HubDescCheckMsOsExtConfigHeader ( _In_ const HubDescContext *  Context,
_In_reads_bytes_(Length) const HubMsOsExtConfigHeader *  Descriptor,
_In_ ULONG  Length 
)

MS OS 1.0 extended configuration header. ExtendedConfigHeaderValid.

Definition at line 2563 of file desccheck.cpp.

2567{
2568 BOOLEAN Valid = TRUE;
2569
2570 if (Length != sizeof(*Descriptor))
2571 {
2572 HubDescLog(Context, HubDescCode::MsOsExtConfigBufferSize, FALSE);
2573 return FALSE;
2574 }
2575
2576 if (Descriptor->bcdVersion != 0x0100)
2577 {
2578 HubDescLog(Context, HubDescCode::MsOsExtConfigVersion, FALSE);
2579 Valid = FALSE;
2580 }
2581
2582 if (Descriptor->wIndex != 4)
2583 {
2584 HubDescLog(Context, HubDescCode::MsOsExtConfigIndex, FALSE);
2585 Valid = FALSE;
2586 }
2587
2588 /* Only single function devices are supported */
2589 if (Descriptor->bCount != 1)
2590 {
2591 HubDescLog(Context, HubDescCode::MsOsExtConfigCount, FALSE);
2592 return FALSE;
2593 }
2594
2595 if (Descriptor->dwLength != sizeof(*Descriptor) + Descriptor->bCount * sizeof(HubMsOsExtConfigFunction))
2596 {
2597 HubDescLog(Context, HubDescCode::MsOsExtConfigLengthVsCount, FALSE);
2598 return FALSE;
2599 }
2600
2601 return Valid;
2602}

Referenced by DeviceMachine::ExtendedConfigHeaderValid().

◆ HubDescCheckMsOsString()

BOOLEAN NTAPI HubDescCheckMsOsString ( _In_ const HubDescContext *  Context,
_In_ const HubMsOsString *  Descriptor 
)

MS OS string descriptor (index 0xEE): signature only. MsOsDescriptorValid.

Definition at line 2490 of file desccheck.cpp.

2493{
2494 static const WCHAR Expected[7] = { 'M', 'S', 'F', 'T', '1', '0', '0' };
2495
2496 if (RtlEqualMemory(Descriptor->Signature, Expected, sizeof(Expected)))
2497 return TRUE;
2498
2499 DPRINT1("Device %p MS OS string has the wrong signature\n", Context->LogContext);
2500 return FALSE;
2501}
RtlEqualMemory
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
WCHAR
short WCHAR
Definition: pedump.c:58

Referenced by DeviceMachine::MsOsDescriptorValid().

◆ HubDescCheckSerialNumber()

BOOLEAN NTAPI HubDescCheckSerialNumber ( _In_ const HubDescContext *  Context,
_In_reads_bytes_ *Length PUSB_STRING_DESCRIPTOR  Descriptor,
_Inout_ PULONG  Length 
)

Serial number string. Length is the bytes returned on entry and the string bytes plus room for a NUL on success.

Definition at line 2418 of file desccheck.cpp.

2422{
2423 ULONG Adjusted;
2424 ULONG Chars;
2425 ULONG i;
2426 BOOLEAN Valid = TRUE;
2427
2428 if (CheckStringCore(Context, Descriptor, *Length, &Adjusted) != Verdict::Ok)
2429 return FALSE;
2430
2431 *Length = Descriptor->bLength - sizeof(USB_COMMON_DESCRIPTOR);
2432 Chars = *Length / sizeof(WCHAR);
2433 for (i = 0; i < Chars; i++)
2434 {
2435 WCHAR Ch = Descriptor->bString[i];
2436
2437 if (Ch == 0)
2438 break;
2439
2440 /* Printable ASCII only, and no comma since it separates instance ID parts */
2441 if (Ch < L' ' || Ch > 0x7F || Ch == L',')
2442 {
2443 HubDescLog(Context, HubDescCode::SerialNumberBadCharacter, FALSE);
2444 Valid = FALSE;
2445 }
2446 }
2447
2448 if (!Valid)
2449 return FALSE;
2450
2451 /* Room for a terminating NUL */
2452 *Length += sizeof(WCHAR);
2453 return TRUE;
2454}
CheckStringCore
static Verdict NTAPI CheckStringCore(_In_ const HubDescContext *Ctx, _In_reads_bytes_(Length) PUSB_STRING_DESCRIPTOR Desc, _In_ ULONG Length, _Out_ PULONG Adjusted)
Definition: desccheck.cpp:2354
L
#define L(x)
Definition: resources.c:13
Chars
ULONG Chars
Definition: hubtunnel.cpp:833
USB_COMMON_DESCRIPTOR
struct _USB_COMMON_DESCRIPTOR USB_COMMON_DESCRIPTOR

Referenced by DeviceMachine::SerialNumberValid().

◆ HubDescCheckString()

BOOLEAN NTAPI HubDescCheckString ( _In_ const HubDescContext *  Context,
_In_reads_bytes_(Length) PUSB_STRING_DESCRIPTOR  Descriptor,
_In_ ULONG  Length,
_Out_opt_ PULONG  AdjustedLength 
)

String descriptor. AdjustedLength is the usable byte count.

Definition at line 2400 of file desccheck.cpp.

2405{
2406 ULONG Adjusted;
2407 Verdict Result;
2408
2409 Result = CheckStringCore(Context, Descriptor, Length, &Adjusted);
2410 if (AdjustedLength != NULL)
2411 *AdjustedLength = Adjusted;
2412
2413 return Result == Verdict::Ok;
2414}

Referenced by DeviceMachine::AltModeStringValid(), DeviceMachine::BillboardStringValid(), and HubCacheString().

◆ HubDescCodeName()

PCSTR NTAPI HubDescCodeName ( _In_ HubDescCode  Code)

Name of a finding for debug prints.

Definition at line 128 of file desccheck.cpp.

130{
131 switch (Code)
132 {
133 HUB_DESC_NAME(Hub20LengthTooLarge);
134 HUB_DESC_NAME(Hub20LengthTooSmall);
135 HUB_DESC_NAME(Hub20Null);
136 HUB_DESC_NAME(Hub20BufferTooSmall);
137 HUB_DESC_NAME(Hub20RemovableMissingPort);
138 HUB_DESC_NAME(Hub20RemovableReserved);
139 HUB_DESC_NAME(Hub20WrongType);
140 HUB_DESC_NAME(Hub20NoPorts);
141 HUB_DESC_NAME(Hub20PowerMaskNotOnes);
142 HUB_DESC_NAME(Hub20CharacteristicsReserved);
143 HUB_DESC_NAME(Hub30DecodeLatencyReserved);
144 HUB_DESC_NAME(Hub30LengthTooLarge);
145 HUB_DESC_NAME(Hub30LengthTooSmall);
146 HUB_DESC_NAME(Hub30BufferTooSmall);
147 HUB_DESC_NAME(Hub30RemovableMissingPort);
148 HUB_DESC_NAME(Hub30RemovableReserved);
149 HUB_DESC_NAME(Hub30WrongType);
150 HUB_DESC_NAME(Hub30TooManyPorts);
151 HUB_DESC_NAME(Hub30NoPorts);
152 HUB_DESC_NAME(Hub30CharacteristicsReserved);
153 HUB_DESC_NAME(BosLengthTooLarge);
154 HUB_DESC_NAME(BosLengthTooSmall);
155 HUB_DESC_NAME(BosBufferLargerThanTotal);
156 HUB_DESC_NAME(BosBufferTooSmall);
157 HUB_DESC_NAME(BosWrongType);
158 HUB_DESC_NAME(BosCapCountMismatch);
159 HUB_DESC_NAME(BosNoSuperSpeedCap);
160 HUB_DESC_NAME(BosNull);
161 HUB_DESC_NAME(BosUnknownType);
162 HUB_DESC_NAME(BosTotalLengthTooSmall);
163 HUB_DESC_NAME(BulkAtLowSpeed);
164 HUB_DESC_NAME(BulkAttributesReserved);
165 HUB_DESC_NAME(BulkMaxPacket);
166 HUB_DESC_NAME(CompanionBulkReserved);
167 HUB_DESC_NAME(CompanionBulkBurst);
168 HUB_DESC_NAME(CompanionBulkStreams);
169 HUB_DESC_NAME(CompanionBulkBytesPerInterval);
170 HUB_DESC_NAME(CompanionControlAttributes);
171 HUB_DESC_NAME(CompanionControlBurst);
172 HUB_DESC_NAME(CompanionControlBytesPerInterval);
173 HUB_DESC_NAME(CompanionNotSuperSpeed);
174 HUB_DESC_NAME(CompanionUnexpected);
175 HUB_DESC_NAME(CompanionLengthTooLarge);
176 HUB_DESC_NAME(CompanionLengthTooSmall);
177 HUB_DESC_NAME(CompanionBufferTooSmall);
178 HUB_DESC_NAME(CompanionInterruptBurst);
179 HUB_DESC_NAME(CompanionInterruptBurstPacket);
180 HUB_DESC_NAME(CompanionInterruptAttributes);
181 HUB_DESC_NAME(CompanionInterruptBytesPerInterval);
182 HUB_DESC_NAME(CompanionIsochReserved);
183 HUB_DESC_NAME(CompanionIsochBurst);
184 HUB_DESC_NAME(CompanionIsochBurstPacket);
185 HUB_DESC_NAME(CompanionIsochMult);
186 HUB_DESC_NAME(CompanionIsochBytesPerInterval);
187 HUB_DESC_NAME(ConfigLengthTooLarge);
188 HUB_DESC_NAME(ConfigLengthTooSmall);
189 HUB_DESC_NAME(ConfigBufferTooSmall);
190 HUB_DESC_NAME(ConfigBufferTooSmallForInterfaces);
191 HUB_DESC_NAME(ConfigWrongType);
192 HUB_DESC_NAME(ConfigMissingCompanion);
193 HUB_DESC_NAME(ConfigNull);
194 HUB_DESC_NAME(ConfigTotalLengthTooLarge);
195 HUB_DESC_NAME(ConfigTotalLengthTooSmall);
196 HUB_DESC_NAME(ContainerIdLengthTooLarge);
197 HUB_DESC_NAME(ContainerIdLengthTooSmall);
198 HUB_DESC_NAME(ContainerIdBufferTooSmall);
199 HUB_DESC_NAME(ContainerIdReserved);
200 HUB_DESC_NAME(ControlAttributesReserved);
201 HUB_DESC_NAME(ControlMaxPacket);
202 HUB_DESC_NAME(DeviceVersionNotBcd);
203 HUB_DESC_NAME(DeviceLengthTooSmall);
204 HUB_DESC_NAME(DeviceBufferTooSmall);
205 HUB_DESC_NAME(CapLengthTooSmall);
206 HUB_DESC_NAME(CapBufferTooSmall);
207 HUB_DESC_NAME(CapMultipleContainerId);
208 HUB_DESC_NAME(CapMultipleSuperSpeed);
209 HUB_DESC_NAME(CapMultipleUsb20);
210 HUB_DESC_NAME(DeviceWrongType);
211 HUB_DESC_NAME(DeviceMaxPacket0);
212 HUB_DESC_NAME(DeviceNull);
213 HUB_DESC_NAME(EndpointLengthTooLarge);
214 HUB_DESC_NAME(EndpointLengthTooSmall);
215 HUB_DESC_NAME(EndpointAttributesReserved);
216 HUB_DESC_NAME(EndpointBufferTooSmall);
217 HUB_DESC_NAME(EndpointAddressReserved);
218 HUB_DESC_NAME(EndpointBeforeInterface);
219 HUB_DESC_NAME(EndpointNumberZero);
220 HUB_DESC_NAME(HeaderPastBuffer);
221 HUB_DESC_NAME(HeaderPastTotalLength);
222 HUB_DESC_NAME(HeaderLengthTooSmall);
223 HUB_DESC_NAME(HeaderBufferTooSmall);
224 HUB_DESC_NAME(HeaderLengthZero);
225 HUB_DESC_NAME(IadLengthTooLarge);
226 HUB_DESC_NAME(IadLengthTooSmall);
227 HUB_DESC_NAME(IadBufferTooSmall);
228 HUB_DESC_NAME(IadCountTooLarge);
229 HUB_DESC_NAME(IadCountZero);
230 HUB_DESC_NAME(IadFirstInterfaceTooLarge);
231 HUB_DESC_NAME(InterfaceLengthTooLarge);
232 HUB_DESC_NAME(InterfaceLengthTooSmall);
233 HUB_DESC_NAME(InterfaceBufferTooSmall);
234 HUB_DESC_NAME(DuplicateAlternate);
235 HUB_DESC_NAME(DuplicateEndpoint);
236 HUB_DESC_NAME(DuplicateInterface);
237 HUB_DESC_NAME(FirstAlternateNotZero);
238 HUB_DESC_NAME(AlternateOutOfOrder);
239 HUB_DESC_NAME(InterfaceOutOfOrder);
240 HUB_DESC_NAME(EndpointCountMismatch);
241 HUB_DESC_NAME(InterruptAttributesReserved);
242 HUB_DESC_NAME(InterruptInterval);
243 HUB_DESC_NAME(InterruptMaxPacket);
244 HUB_DESC_NAME(IsochAtLowSpeed);
245 HUB_DESC_NAME(IsochInterval);
246 HUB_DESC_NAME(IsochMaxPacket);
247 HUB_DESC_NAME(MsOsContainerIdZero);
248 HUB_DESC_NAME(MsOsContainerIdVersion);
249 HUB_DESC_NAME(MsOsContainerIdIndex);
250 HUB_DESC_NAME(MsOsContainerIdBufferSize);
251 HUB_DESC_NAME(MsOsContainerIdLength);
252 HUB_DESC_NAME(MsOsExtConfigFirstInterface);
253 HUB_DESC_NAME(MsOsExtConfigVersion);
254 HUB_DESC_NAME(MsOsExtConfigBufferSize);
255 HUB_DESC_NAME(MsOsExtConfigCompatibleId);
256 HUB_DESC_NAME(MsOsExtConfigSubCompatibleId);
257 HUB_DESC_NAME(MsOsExtConfigIndex);
258 HUB_DESC_NAME(MsOsExtConfigBufferVsLength);
259 HUB_DESC_NAME(StringLengthOdd);
260 HUB_DESC_NAME(StringLengthTooLarge);
261 HUB_DESC_NAME(StringLengthTooSmall);
262 HUB_DESC_NAME(StringBufferTooSmall);
263 HUB_DESC_NAME(SerialNumberBadCharacter);
264 HUB_DESC_NAME(StringWrongType);
265 HUB_DESC_NAME(StringLengthVsBytes);
266 HUB_DESC_NAME(SsCapLengthTooLarge);
267 HUB_DESC_NAME(SsCapLengthTooSmall);
268 HUB_DESC_NAME(SsCapAttributesReserved);
269 HUB_DESC_NAME(SsCapU1TooLarge);
270 HUB_DESC_NAME(SsCapU2TooLarge);
271 HUB_DESC_NAME(SsCapBufferTooSmall);
272 HUB_DESC_NAME(SsCapFunctionalityNotInSpeeds);
273 HUB_DESC_NAME(SsCapFunctionalityReserved);
274 HUB_DESC_NAME(SsCapSpeedsReserved);
275 HUB_DESC_NAME(SsCapNoSpeeds);
276 HUB_DESC_NAME(Usb20CapLengthTooLarge);
277 HUB_DESC_NAME(Usb20CapLengthTooSmall);
278 HUB_DESC_NAME(Usb20CapReserved);
279 HUB_DESC_NAME(Usb20CapBufferTooSmall);
280 HUB_DESC_NAME(BaselineBeslZero);
281 HUB_DESC_NAME(BeslWithoutLpm);
282 HUB_DESC_NAME(DeepBeslNotAboveBaseline);
283 HUB_DESC_NAME(DeepBeslZero);
284 HUB_DESC_NAME(BosContainerIdZero);
285 HUB_DESC_NAME(MsOs20MultipleSetHeaders);
286 HUB_DESC_NAME(MsOs20SetHeaderLength);
287 HUB_DESC_NAME(ConfigSubsetLength);
288 HUB_DESC_NAME(ConfigSubsetTotalTooSmall);
289 HUB_DESC_NAME(ConfigSubsetTotalTooLarge);
290 HUB_DESC_NAME(ConfigSubsetMisplacedFeature);
291 HUB_DESC_NAME(ConfigSubsetFeatureLength);
292 HUB_DESC_NAME(FunctionSubsetLength);
293 HUB_DESC_NAME(FunctionSubsetTotalTooSmall);
294 HUB_DESC_NAME(FunctionSubsetTotalTooLarge);
295 HUB_DESC_NAME(FunctionSubsetMisplacedFeature);
296 HUB_DESC_NAME(FunctionSubsetFeatureLength);
297 HUB_DESC_NAME(MsOs20MultipleCompatibleId);
298 HUB_DESC_NAME(MsOs20CompatibleIdLength);
299 HUB_DESC_NAME(MsOs20CompatibleIdAfterNull);
300 HUB_DESC_NAME(MsOs20RegistryTooSmall);
301 HUB_DESC_NAME(MsOs20RegistryNameTooLarge);
302 HUB_DESC_NAME(MsOs20RegistryNameOddOrZero);
303 HUB_DESC_NAME(MsOs20RegistryDataTooLarge);
304 HUB_DESC_NAME(MsOs20RegistryDataZero);
305 HUB_DESC_NAME(MsOs20RegistryType);
306 HUB_DESC_NAME(MsOs20MultipleResumeTime);
307 HUB_DESC_NAME(MsOs20ResumeTimeLength);
308 HUB_DESC_NAME(MsOs20ResumeRecovery);
309 HUB_DESC_NAME(MsOs20ResumeSignaling);
310 HUB_DESC_NAME(MsOs20MultipleModelId);
311 HUB_DESC_NAME(MsOs20ModelIdLength);
312 HUB_DESC_NAME(MsOs20ModelIdZero);
313 HUB_DESC_NAME(MsOs20BytesVsSetInfo);
314 HUB_DESC_NAME(MsOs20BytesTooSmall);
315 HUB_DESC_NAME(MsOs20HeaderLength);
316 HUB_DESC_NAME(MsOs20TotalLengthMismatch);
317 HUB_DESC_NAME(MsOs20VersionMismatch);
318 HUB_DESC_NAME(MsOs20FeatureOutOfOrder);
319 HUB_DESC_NAME(MsOs20PastEnd);
320 HUB_DESC_NAME(PlatformReserved);
321 HUB_DESC_NAME(PlatformUuidZero);
322 HUB_DESC_NAME(MsOs20MultiplePlatform);
323 HUB_DESC_NAME(MsOs20PlatformLength);
324 HUB_DESC_NAME(MsOs20DuplicateVersion);
325 HUB_DESC_NAME(MsOs20NoVersionMatch);
326 HUB_DESC_NAME(MsOs20MultipleCcgp);
327 HUB_DESC_NAME(MsOs20CcgpLength);
328 HUB_DESC_NAME(CapMultipleSuperSpeedPlus);
329 HUB_DESC_NAME(CompanionIsochBytesNotOne);
330 HUB_DESC_NAME(SspCompanionNotSuperSpeed);
331 HUB_DESC_NAME(SspCompanionUnexpected);
332 HUB_DESC_NAME(SspCompanionLengthTooLarge);
333 HUB_DESC_NAME(SspCompanionLengthTooSmall);
334 HUB_DESC_NAME(SspCompanionBufferTooSmall);
335 HUB_DESC_NAME(SspCompanionReserved);
336 HUB_DESC_NAME(SspCompanionBytesRange);
337 HUB_DESC_NAME(ConfigMissingSspCompanion);
338 HUB_DESC_NAME(SspCapLengthInvalid);
339 HUB_DESC_NAME(SspCapLengthTooSmall);
340 HUB_DESC_NAME(SspCapAttributesReserved);
341 HUB_DESC_NAME(SspCapFunctionalityReserved);
342 HUB_DESC_NAME(SspCapBufferTooSmall);
343 HUB_DESC_NAME(SspCapReservedByte);
344 HUB_DESC_NAME(SspCapReservedWord);
345 HUB_DESC_NAME(SspAttrNotRx);
346 HUB_DESC_NAME(SspAttrNotTx);
347 HUB_DESC_NAME(SspAttrTxMissing);
348 HUB_DESC_NAME(SspAttrPairMismatch);
349 HUB_DESC_NAME(SspAttrSymmetricMismatch);
350 HUB_DESC_NAME(SspMinLaneMismatch);
351 HUB_DESC_NAME(SspSpeedIdDuplicate);
352 HUB_DESC_NAME(SspMinSpeedMissing);
353 HUB_DESC_NAME(PdLengthTooLarge);
354 HUB_DESC_NAME(PdLengthTooSmall);
355 HUB_DESC_NAME(PdBufferTooSmall);
356 HUB_DESC_NAME(PdReserved);
357 HUB_DESC_NAME(IsochPacketInAlternate0);
358 HUB_DESC_NAME(DuplicateSerialNumber);
359 HUB_DESC_NAME(BillboardLengthTooSmall);
360 HUB_DESC_NAME(BillboardLengthInvalid);
361 HUB_DESC_NAME(BillboardBufferTooSmall);
362 HUB_DESC_NAME(BillboardNoModes);
363 HUB_DESC_NAME(BillboardTooManyModes);
364 HUB_DESC_NAME(BillboardPreferredInvalid);
365 HUB_DESC_NAME(CapMultipleBillboard);
366 HUB_DESC_NAME(BillboardDeviceVersion);
367 HUB_DESC_NAME(PlatformFeaturesLength);
368 HUB_DESC_NAME(PlatformFeaturesMultiple);
369 HUB_DESC_NAME(PlatformFeaturesVersion);
370 HUB_DESC_NAME(PlatformFeaturesTooSmall);
371 HUB_DESC_NAME(PlatformLengthTooSmall);
372 HUB_DESC_NAME(PlatformBufferTooSmall);
373
374 default:
375 return "Unknown";
376 }
377}
HUB_DESC_NAME
#define HUB_DESC_NAME(Code)
Definition: desccheck.cpp:124
Code
_In_ UCHAR _In_ UCHAR _In_ ULONG Code
Definition: wdfdevice.h:1707

Referenced by HubDescLog(), and HubLogHubFinding().

◆ HubDescFind()

PUSB_COMMON_DESCRIPTOR NTAPI HubDescFind ( _In_reads_bytes_(TotalLength) PVOID  Buffer,
_In_ ULONG  TotalLength,
_In_ PVOID  Position,
_In_ UCHAR  Type 
)

First descriptor of Type at or after Position, or NULL. Stops on a zero bLength.

Definition at line 3333 of file desccheck.cpp.

3338{
3339 PUCHAR End = (PUCHAR)Buffer + TotalLength;
3340 PUCHAR At = (PUCHAR)Position;
3341
3342 /* bLength is trusted; only the two header bytes are kept inside the buffer */
3343 while (At + sizeof(USB_COMMON_DESCRIPTOR) <= End)
3344 {
3345 PUSB_COMMON_DESCRIPTOR Desc = (PUSB_COMMON_DESCRIPTOR)At;
3346
3347 if (Desc->bLength == 0)
3348 return NULL;
3349
3350 if (Desc->bDescriptorType == Type)
3351 return Desc;
3352
3353 At += Desc->bLength;
3354 }
3355
3356 return NULL;
3357}
Type
Type
Definition: Type.h:7
Buffer
Definition: bufpool.h:45
Position
static COORD Position
Definition: mouse.c:34
TotalLength
_In_ ULONG TotalLength
Definition: usbdlib.h:185

Referenced by HubDescFindInterface().

◆ HubDescFindInterface()

PUSB_INTERFACE_DESCRIPTOR NTAPI HubDescFindInterface ( _In_ PUSB_CONFIGURATION_DESCRIPTOR  Config,
_In_ PVOID  Position,
_In_ LONG  Number,
_In_ LONG  Alternate,
_In_ LONG  Class,
_In_ LONG  SubClass,
_In_ LONG  Protocol,
_Out_opt_ PBOOLEAN  HasAlternates 
)

First matching interface at or after Position; -1 matches anything. HasAlternates is TRUE when that interface number has other settings.

Definition at line 3371 of file desccheck.cpp.

3380{
3381 PUSB_INTERFACE_DESCRIPTOR Match;
3382 PUSB_INTERFACE_DESCRIPTOR Next;
3383 ULONG SameNumber = 0;
3384 PUCHAR At = (PUCHAR)Position;
3385
3386 if (HasAlternates != NULL)
3387 *HasAlternates = FALSE;
3388
3389 if (Config->bLength < sizeof(*Config) ||
3390 Config->bDescriptorType != USB_CONFIGURATION_DESCRIPTOR_TYPE ||
3391 Config->wTotalLength < sizeof(*Config))
3392 {
3393 return NULL;
3394 }
3395
3396 for (;;)
3397 {
3398 Match = (PUSB_INTERFACE_DESCRIPTOR)HubDescFind(Config, Config->wTotalLength, At, USB_INTERFACE_DESCRIPTOR_TYPE);
3399 if (Match == NULL)
3400 return NULL;
3401
3402 /* Only the 2 byte header is known to be inside wTotalLength */
3403 if ((PUCHAR)Match + sizeof(*Match) > (PUCHAR)Config + Config->wTotalLength)
3404 return NULL;
3405
3406 At = (PUCHAR)Match + Match->bLength;
3407
3408 /* Every interface with the requested number counts, matching or not */
3409 if (Number != -1 && Match->bInterfaceNumber == Number)
3410 SameNumber++;
3411
3412 if (FieldMatches(Number, Match->bInterfaceNumber) &&
3413 FieldMatches(Alternate, Match->bAlternateSetting) &&
3414 FieldMatches(Class, Match->bInterfaceClass) &&
3415 FieldMatches(SubClass, Match->bInterfaceSubClass) &&
3416 FieldMatches(Protocol, Match->bInterfaceProtocol))
3417 {
3418 break;
3419 }
3420 }
3421
3422 if (HasAlternates == NULL)
3423 return Match;
3424
3425 /* QUIRK: only the very next interface is looked at, and never for a wildcard number */
3426 if (SameNumber <= 1)
3427 {
3428 Next = (PUSB_INTERFACE_DESCRIPTOR)HubDescFind(Config, Config->wTotalLength, At, USB_INTERFACE_DESCRIPTOR_TYPE);
3429 if (Next != NULL && Number != -1 &&
3430 (PUCHAR)Next + sizeof(*Next) <= (PUCHAR)Config + Config->wTotalLength &&
3431 Next->bInterfaceNumber == Number)
3432 SameNumber++;
3433 }
3434
3435 if (SameNumber > 1)
3436 *HasAlternates = TRUE;
3437
3438 return Match;
3439}
if
if(Length< sizeof(*Descriptor))
Definition: desccheck.cpp:2245
FieldMatches
static BOOLEAN NTAPI FieldMatches(_In_ LONG Wanted, _In_ UCHAR Actual)
Definition: desccheck.cpp:3362
HubDescFind
PUSB_COMMON_DESCRIPTOR NTAPI HubDescFind(_In_reads_bytes_(TotalLength) PVOID Buffer, _In_ ULONG TotalLength, _In_ PVOID Position, _In_ UCHAR Type)
Definition: desccheck.cpp:3333
Number
_In_ ULONG Number
Definition: haltypes.h:1940
Next
PACPI_METHOD_ARGUMENT Next
Definition: slotdev.cpp:96
_USB_INTERFACE_DESCRIPTOR::bInterfaceNumber
UCHAR bInterfaceNumber
Definition: usb100.h:150
_USB_INTERFACE_DESCRIPTOR::bInterfaceSubClass
UCHAR bInterfaceSubClass
Definition: usb100.h:154
_USB_INTERFACE_DESCRIPTOR::bInterfaceClass
UCHAR bInterfaceClass
Definition: usb100.h:153
_USB_INTERFACE_DESCRIPTOR::bInterfaceProtocol
UCHAR bInterfaceProtocol
Definition: usb100.h:155
_USB_INTERFACE_DESCRIPTOR::bAlternateSetting
UCHAR bAlternateSetting
Definition: usb100.h:151
_USB_INTERFACE_DESCRIPTOR::bLength
UCHAR bLength
Definition: usb100.h:148
Config
_Must_inspect_result_ _In_ WDFDEVICE _In_ PUCX_CONTROLLER_CONFIG Config
Definition: ucxcontroller.h:347
USB_CONFIGURATION_DESCRIPTOR_TYPE
#define USB_CONFIGURATION_DESCRIPTOR_TYPE
Definition: usb100.h:50
PUSB_INTERFACE_DESCRIPTOR
struct _USB_INTERFACE_DESCRIPTOR * PUSB_INTERFACE_DESCRIPTOR

Referenced by HubPickCompatIdInterface(), DeviceMachine::PrepareConfigLists(), and DeviceMachine::PrepareInterfaceLists().

◆ HubDescInitDeviceContext()

VOID NTAPI HubDescInitDeviceContext ( _Out_ HubDescContext *  Context,
_In_ USHORT  BcdUsb,
_In_ USB_DEVICE_SPEED  Speed,
_In_ BOOLEAN  Win8Behavior,
_In_ ULONG  SspIsochBurstCount,
_In_opt_ PULONG  Bitmap 
)

Device context: reads the global strictness flags. Set Log and LogContext afterwards.

Definition at line 91 of file desccheck.cpp.

98{
99 RtlZeroMemory(Context, sizeof(*Context));
100 Context->BcdUsb = BcdUsb;
101 Context->Speed = Speed;
102 Context->LegacyStrict = HubDriver.HasFlag(HubGlobal::EnableExtendedValidation);
103 Context->ReservedFields = HubDriver.HasFlag(HubGlobal::CheckReservedFields);
104 Context->Strictest = HubDriver.HasFlag(HubGlobal::StrictDescriptorChecks);
105 Context->Win8Behavior = Win8Behavior;
106 Context->SspIsochBurstCount = SspIsochBurstCount;
107 Context->Bitmap = Bitmap;
108}
HubDriver
HubDriverState HubDriver
Definition: entry.cpp:13
HubGlobal::StrictDescriptorChecks
@ StrictDescriptorChecks
HubGlobal::EnableExtendedValidation
@ EnableExtendedValidation
HubGlobal::CheckReservedFields
@ CheckReservedFields
HubDriverState::HasFlag
BOOLEAN HasFlag(_In_ HubGlobal Flag) const
Definition: hubdriver.h:119

Referenced by HubCheckConfigDescriptor(), HubDeviceDescContext(), and DeviceMachine::SerialNumberValid().

◆ HubDescInitHubContext()

VOID NTAPI HubDescInitHubContext ( _Out_ HubDescContext *  Context,
_In_ USHORT  BcdUsb,
_In_ USB_DEVICE_SPEED  Speed 
)

Hub context: version and speed only, global flags are never applied.

Definition at line 112 of file desccheck.cpp.

116{
117 RtlZeroMemory(Context, sizeof(*Context));
118 Context->BcdUsb = BcdUsb;
119 Context->Speed = Speed;
120 Context->ForHub = TRUE;
121}

Referenced by HubBuildDescContext().

◆ HubDescLog()

VOID NTAPI HubDescLog ( _In_ const HubDescContext *  Context,
_In_ HubDescCode  Code,
_In_ BOOLEAN  Warning 
)

Records one finding: sets the bitmap bit and calls the log hook.

Definition at line 383 of file desccheck.cpp.

387{
388 ULONG Bit = (ULONG)Code;
389
390 /* Warnings set the same bit as errors */
391 if (Context->Bitmap != NULL && Bit < HUB_DESC_BITMAP_ULONGS * 32)
392 Context->Bitmap[Bit / 32] |= 1UL << (Bit % 32);
393
394 if (Context->Log != NULL)
395 {
396 Context->Log(Context->LogContext, Code, Warning);
397 return;
398 }
399
400 /* Warning also covers findings whose gate does not apply to this device */
401 if (Warning)
402 {
403 DPRINT("%s %p descriptor check %s (%lu) ignored\n",
404 Context->ForHub ? "Hub" : "Device", Context->LogContext, HubDescCodeName(Code), Bit);
405 }
406 else
407 {
408 DPRINT1("%s %p descriptor check %s (%lu) failed\n",
409 Context->ForHub ? "Hub" : "Device", Context->LogContext, HubDescCodeName(Code), Bit);
410 }
411}
HubDescCodeName
PCSTR NTAPI HubDescCodeName(_In_ HubDescCode Code)
Definition: desccheck.cpp:128
HUB_DESC_BITMAP_ULONGS
#define HUB_DESC_BITMAP_ULONGS
Definition: desccheck.h:263
DPRINT
#define DPRINT
Definition: sndvol32.h:73

Referenced by CheckBillboardCap(), CheckHeader(), CheckMsOs20Ccgp(), CheckMsOs20CompatibleId(), CheckMsOs20Id(), CheckMsOs20ModelId(), CheckMsOs20Platform(), CheckMsOs20Registry(), CheckMsOs20ResumeTime(), CheckMsOs20SetHeader(), CheckMsOs20Subset(), DeviceMachine::ConfigDescriptorValid(), HubDescCheck20Hub(), HubDescCheck30Hub(), HubDescCheckConfiguration(), HubDescCheckDevice(), HubDescCheckMsOsContainerId(), HubDescCheckMsOsContainerIdHeader(), HubDescCheckMsOsExtConfig(), HubDescCheckMsOsExtConfigHeader(), HubDescCheckSerialNumber(), HubLogConfigTotalLengthMismatch(), if(), Note(), NoteFatal(), WalkMsOs20Set(), and while().

◆ HubDescNextMsOs20()

BOOLEAN NTAPI HubDescNextMsOs20 ( _In_ PUCHAR  End,
_Inout_ HubMsOs20Common **  Current 
)

Steps to the next MS OS 2.0 descriptor, or NULL at End. FALSE when a length runs past End.

Definition at line 2647 of file desccheck.cpp.

2650{
2651 HubMsOs20Common* Desc = *Current;
2652 PUCHAR At = (PUCHAR)Desc;
2653 PUCHAR Next;
2654
2655 *Current = NULL;
2656
2657 /* The current descriptor must itself fit before End */
2658 if (At + Desc->wLength > End)
2659 return FALSE;
2660
2661 if (Desc->wDescriptorType == HUB_MSOS20_TYPE_CONFIG_SUBSET ||
2662 Desc->wDescriptorType == HUB_MSOS20_TYPE_FUNCTION_SUBSET)
2663 {
2664 HubMsOs20Subset* Subset = (HubMsOs20Subset*)Desc;
2665
2666 if (Subset->wLength < sizeof(*Subset) || Subset->wTotalLength < sizeof(*Subset) + sizeof(*Desc))
2667 return FALSE;
2668
2669 Next = At + Subset->wTotalLength;
2670 }
2671 else
2672 {
2673 if (Desc->wLength < sizeof(*Desc))
2674 return FALSE;
2675
2676 Next = At + Desc->wLength;
2677 }
2678
2679 if (Next == End)
2680 return TRUE;
2681
2682 if (Next > End || Next + sizeof(*Desc) > End)
2683 return FALSE;
2684
2685 if (Next + ((HubMsOs20Common*)Next)->wLength > End)
2686 return FALSE;
2687
2688 *Current = (HubMsOs20Common*)Next;
2689 return TRUE;
2690}
HUB_MSOS20_TYPE_FUNCTION_SUBSET
#define HUB_MSOS20_TYPE_FUNCTION_SUBSET
Definition: desccheck.cpp:2638
HUB_MSOS20_TYPE_CONFIG_SUBSET
#define HUB_MSOS20_TYPE_CONFIG_SUBSET
Definition: desccheck.cpp:2637
Current
HubUxdSettings Current
Definition: hubregistry.cpp:1463
HubMsOs20Common::wLength
USHORT wLength
Definition: desccheck.h:347
HubMsOs20Common::wDescriptorType
USHORT wDescriptorType
Definition: desccheck.h:348
HubMsOs20Subset::wTotalLength
USHORT wTotalLength
Definition: desccheck.h:366
HubMsOs20Subset::wLength
USHORT wLength
Definition: desccheck.h:362

Referenced by CheckMsOs20Subset(), DeviceMachine::InstallMsOs20Values(), and WalkMsOs20Set().

Variable Documentation

◆ DeviceFlags

_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN _Inout_opt_ HubLpmInfo _Inout_opt_ PULONG DeviceFlags

Definition at line 588 of file desccheck.h.

◆ Info

_In_ ULONG _In_ const HubMsOs20SetInfo _Inout_ HubMsOs20Info* Info

Definition at line 583 of file desccheck.h.

◆ Length

_In_ ULONG Length

Definition at line 582 of file desccheck.h.

◆ Lpm

_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN _Inout_opt_ HubLpmInfo* Lpm

Definition at line 587 of file desccheck.h.

◆ LtmCapable

_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN LtmCapable

Definition at line 586 of file desccheck.h.

◆ SetInfo

_In_ ULONG _In_ const HubMsOs20SetInfo* SetInfo

Definition at line 663 of file desccheck.h.

◆ U1ExitLatency

_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT U1ExitLatency

Definition at line 584 of file desccheck.h.

◆ U2ExitLatency

_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT U2ExitLatency

Definition at line 585 of file desccheck.h.