ReactOS 0.4.17-dev-1281-g065abb3
desccheck.cpp
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS SuperSpeed USB Hub Driver
3 * LICENSE: MIT (https://spdx.org/licenses/MIT)
4 * PURPOSE: Descriptor validation for devices and hubs
5 * COPYRIGHT: Copyright 2026 Justin Miller <justin.miller@reactos.org>
6 */
7
8#include "usbhub3.h"
9
10#define NDEBUG
11#include <debug.h>
12
13/* Outcome of one descriptor check */
14enum class Verdict : UCHAR
15{
16 Ok,
17 Failed,
18 Fatal
19};
20
21/* When a finding fails the descriptor; it is always logged */
22enum class Gate : UCHAR
23{
24 Always,
25 Legacy,
26 NewRule,
27 Versioned,
28 Cap20,
29 CapSs,
30 CapSsp,
31 Reserved,
32 LogOnly,
33 Warning
34};
35
36/* Newest dwWindowsVersion an MS OS 2.0 descriptor set may target: the one the hub reports */
37#define HUB_MSOS20_NEWEST_VERSION NTDDI_WIN11_GE
38
39/* MS OS 2.0 subsets never nest this deep in a sane device */
40#define HUB_MSOS20_MAX_DEPTH 8
41
42static const GUID HubMsOs20PlatformUuid =
43 { 0xD8DD60DF, 0x4589, 0x4CC7, { 0x9C, 0xD2, 0x65, 0x9D, 0x9E, 0x64, 0x8A, 0x9F } };
44
45static const GUID HubPlatformFeaturesUuid =
46 { 0xA6C10D69, 0x5E2F, 0x480D, { 0xA5, 0x23, 0x52, 0xC0, 0x56, 0xFA, 0xD4, 0xB4 } };
47
48/* Walk state for one configuration descriptor set */
49struct ConfigWalk
50{
51 const HubDescContext* Ctx;
52 PUCHAR Base;
53 ULONG BufferLength;
54 PUCHAR End;
55 PUSB_CONFIGURATION_DESCRIPTOR Config;
56 PBOOLEAN SupportsStreams;
57 PUSB_ENDPOINT_DESCRIPTOR LastEndpoint;
58 ULONG InterfaceSeen[8];
59 ULONG AlternateSeen[8];
60 ULONG EndpointSeen[8];
61 ULONG InterfacesFound;
62 ULONG EndpointsDeclared;
63 ULONG EndpointsCounted;
64 UCHAR Interface;
65 UCHAR Alternate;
66 BOOLEAN HadInterface;
67 BOOLEAN HadEndpoint;
68 BOOLEAN WantCompanion;
69 BOOLEAN WantSspCompanion;
70 BOOLEAN GotCompanion;
71 BOOLEAN GotSspCompanion;
72};
73
74/* Walk state for one BOS descriptor set */
75struct BosWalk
76{
77 const HubDescContext* Ctx;
78 PUCHAR Base;
79 ULONG BufferLength;
80 HubBosInfo* Info;
81 PUSHORT U1;
82 PUSHORT U2;
83 PBOOLEAN Ltm;
84 HubLpmInfo* Lpm;
85};
86
87/* Context and logging */
88
89VOID
90NTAPI
91HubDescInitDeviceContext(
92 _Out_ HubDescContext* Context,
93 _In_ USHORT BcdUsb,
94 _In_ USB_DEVICE_SPEED Speed,
95 _In_ BOOLEAN Win8Behavior,
96 _In_ ULONG SspIsochBurstCount,
97 _In_opt_ PULONG Bitmap)
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}
109
110VOID
111NTAPI
112HubDescInitHubContext(
113 _Out_ HubDescContext* Context,
114 _In_ USHORT BcdUsb,
115 _In_ USB_DEVICE_SPEED Speed)
116{
117 RtlZeroMemory(Context, sizeof(*Context));
118 Context->BcdUsb = BcdUsb;
119 Context->Speed = Speed;
120 Context->ForHub = TRUE;
121}
122
123/* Name of a validation code for the debug log */
124#define HUB_DESC_NAME(Code) case HubDescCode::Code: return #Code
125
126PCSTR
127NTAPI
128HubDescCodeName(
129 _In_ HubDescCode Code)
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}
378
379#undef HUB_DESC_NAME
380
381VOID
382NTAPI
383HubDescLog(
384 _In_ const HubDescContext* Context,
385 _In_ HubDescCode Code,
386 _In_ BOOLEAN Warning)
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}
412
413/* Shared helpers */
414
415static
416BOOLEAN
417NTAPI
418GateApplies(
419 _In_ const HubDescContext* Ctx,
420 _In_ Gate Kind)
421{
422 USHORT Bcd = Ctx->BcdUsb;
423 BOOLEAN Newer = Ctx->Strictest || Bcd > 0x0200;
424
425 switch (Kind)
426 {
427 case Gate::Always:
428 return TRUE;
429
430 case Gate::Legacy:
431 return Newer || Ctx->LegacyStrict;
432
433 case Gate::NewRule:
434 return Newer;
435
436 case Gate::Versioned:
437 return Ctx->Strictest ||
438 (Bcd >= 0x0201 && Bcd <= 0x0210) ||
439 (Bcd >= 0x0300 && Bcd <= 0x0310);
440
441 /* QUIRK: 0x0210 itself is excluded for the USB 2.0 extension */
442 case Gate::Cap20:
443 return Ctx->Strictest || (Bcd >= 0x0201 && Bcd < 0x0210);
444
445 case Gate::CapSs:
446 return Ctx->Strictest || (Bcd >= 0x0300 && Bcd <= 0x0310);
447
448 case Gate::CapSsp:
449 return Ctx->Strictest || Bcd == 0x0310;
450
451 case Gate::Reserved:
452 return Ctx->ReservedFields;
453
454 default:
455 return FALSE;
456 }
457}
458
460static
461VOID
462NTAPI
463Note(
464 _In_ const HubDescContext* Ctx,
465 _Inout_ Verdict* Result,
466 _In_ HubDescCode Code,
467 _In_ Gate Kind)
468{
469 BOOLEAN Enforced = GateApplies(Ctx, Kind);
470
471 /* Only an enforced finding prints as an error */
472 HubDescLog(Ctx, Code, !Enforced);
473 if (Enforced)
474 *Result = Verdict::Failed;
475}
476
478static
479VOID
480NTAPI
481NoteFatal(
482 _In_ const HubDescContext* Ctx,
483 _Inout_ Verdict* Result,
484 _In_ HubDescCode Code)
485{
486 HubDescLog(Ctx, Code, FALSE);
487 *Result = Verdict::Fatal;
488}
489
491static
492VOID
493NTAPI
494StartCheck(
495 _In_ const HubDescContext* Ctx,
496 _Inout_ Verdict* Result)
497{
498 if (Ctx->Win8Behavior)
499 *Result = Verdict::Ok;
500}
501
503static
504BOOLEAN
505NTAPI
506AssumeSize(
507 _In_ const HubDescContext* Ctx,
508 _Inout_ Verdict* Result,
509 _In_ HubDescCode Code,
510 _In_ Gate Kind,
511 _In_ ULONG Size,
512 _In_ ULONG Left,
513 _Inout_ PULONG Advance)
514{
515 Note(Ctx, Result, Code, Kind);
516 if (Size > Left)
517 {
518 *Result = Verdict::Fatal;
519 return FALSE;
520 }
521
522 *Advance = Size;
523 return TRUE;
524}
525
526static
527BOOLEAN
528NTAPI
529BitIsSet(
530 _In_reads_(8) const ULONG* Bits,
531 _In_ UCHAR Index)
532{
533 return (Bits[Index / 32] & (1UL << (Index % 32))) != 0;
534}
535
536static
537VOID
538NTAPI
539BitSet(
540 _Inout_updates_(8) PULONG Bits,
541 _In_ UCHAR Index)
542{
543 Bits[Index / 32] |= 1UL << (Index % 32);
544}
545
546static
547BOOLEAN
548NTAPI
549IsAllZero(
550 _In_reads_bytes_(Length) const VOID* Buffer,
551 _In_ ULONG Length)
552{
553 const UCHAR* Bytes = (const UCHAR*)Buffer;
554 ULONG i;
555
556 for (i = 0; i < Length; i++)
557 {
558 if (Bytes[i] != 0)
559 return FALSE;
560 }
561
562 return TRUE;
563}
564
566static
567BOOLEAN
568NTAPI
569IsSmallPacket(
570 _In_ ULONG Size)
571{
572 return Size == 8 || Size == 16 || Size == 32 || Size == 64;
573}
574
576static
577ULONG
578NTAPI
579BytesLeft(
580 _In_ PUCHAR Base,
581 _In_ ULONG BufferLength,
582 _In_ const VOID* Descriptor)
583{
584 return BufferLength - (ULONG)((const UCHAR*)Descriptor - Base);
585}
586
587/* Common header of every descriptor inside a configuration or BOS set */
588static
589VOID
590NTAPI
591CheckHeader(
592 _In_ const HubDescContext* Ctx,
593 _In_ PUCHAR Base,
594 _In_ ULONG BufferLength,
595 _In_ PUCHAR End,
596 _In_ PUSB_COMMON_DESCRIPTOR Desc,
597 _Out_ PULONG Advance,
598 _Inout_ Verdict* Result)
599{
600 ULONG Left = BytesLeft(Base, BufferLength, Desc);
601
602 StartCheck(Ctx, Result);
603 if (Left < sizeof(*Desc))
604 {
605 *Advance = 0;
606 NoteFatal(Ctx, Result, HubDescCode::HeaderBufferTooSmall);
607 return;
608 }
609
610 *Advance = Desc->bLength;
611 if (Desc->bLength > Left)
612 {
613 Note(Ctx, Result, HubDescCode::HeaderPastBuffer, Gate::Always);
614 *Advance = Left;
615 }
616
617 if (Desc->bLength > (ULONG)(End - (PUCHAR)Desc))
618 Note(Ctx, Result, HubDescCode::HeaderPastTotalLength, Gate::Always);
619
620 if (Desc->bLength < sizeof(*Desc))
621 Note(Ctx, Result, HubDescCode::HeaderLengthTooSmall, Gate::NewRule);
622
623 if (Desc->bLength == 0)
624 {
625 HubDescLog(Ctx, HubDescCode::HeaderLengthZero, !GateApplies(Ctx, Gate::NewRule));
626 if (GateApplies(Ctx, Gate::NewRule))
627 *Result = Verdict::Fatal;
628 }
629}
630
631/* Configuration descriptor set */
632
633static
634VOID
635NTAPI
636CheckConfigFixedPart(
637 _Inout_ ConfigWalk* Walk,
638 _Inout_ Verdict* Result)
639{
640 const HubDescContext* Ctx = Walk->Ctx;
641 PUSB_CONFIGURATION_DESCRIPTOR Config = Walk->Config;
642 ULONG Needed;
643
644 /* A short or mistyped header is Fatal, but a later finding can still make it Failed */
645 if (Config->bLength < sizeof(*Config))
646 NoteFatal(Ctx, Result, HubDescCode::ConfigLengthTooSmall);
647
648 if (Config->bLength > sizeof(*Config))
649 Note(Ctx, Result, HubDescCode::ConfigLengthTooLarge, Gate::NewRule);
650
651 if (Config->bDescriptorType != USB_CONFIGURATION_DESCRIPTOR_TYPE)
652 NoteFatal(Ctx, Result, HubDescCode::ConfigWrongType);
653
654 if (Walk->BufferLength < sizeof(*Config))
655 {
656 Note(Ctx, Result, HubDescCode::ConfigBufferTooSmall, Gate::Legacy);
657 return;
658 }
659
660 Needed = sizeof(*Config) + Config->bNumInterfaces * sizeof(USB_INTERFACE_DESCRIPTOR);
661 if (Needed > Walk->BufferLength)
662 Note(Ctx, Result, HubDescCode::ConfigBufferTooSmallForInterfaces, Gate::Legacy);
663
664 Walk->End = Walk->Base + Config->wTotalLength;
665 if (Config->wTotalLength > Walk->BufferLength)
666 {
667 Note(Ctx, Result, HubDescCode::ConfigTotalLengthTooLarge, Gate::Legacy);
668 Walk->End = Walk->Base + Walk->BufferLength;
669 }
670
671 if (Config->wTotalLength < Needed)
672 {
673 Note(Ctx, Result, HubDescCode::ConfigTotalLengthTooSmall, Gate::Legacy);
674 Walk->End = Walk->Base + Walk->BufferLength;
675 }
676}
677
679static
680VOID
681NTAPI
682CheckPreviousEndpoint(
683 _Inout_ ConfigWalk* Walk,
684 _Inout_ Verdict* Result)
685{
686 const HubDescContext* Ctx = Walk->Ctx;
687
688 StartCheck(Ctx, Result);
689 if (!Walk->HadEndpoint)
690 {
691 Walk->HadEndpoint = TRUE;
692 }
693 else if (Ctx->Speed == UsbSuperSpeed)
694 {
695 if (!Walk->GotCompanion)
696 Note(Ctx, Result, HubDescCode::ConfigMissingCompanion, Gate::Always);
697
698 if (Walk->WantSspCompanion && !Walk->GotSspCompanion)
699 Note(Ctx, Result, HubDescCode::ConfigMissingSspCompanion, Gate::Always);
700 }
701
702 Walk->GotCompanion = FALSE;
703 Walk->WantCompanion = FALSE;
704 Walk->GotSspCompanion = FALSE;
705 Walk->WantSspCompanion = FALSE;
706}
707
709static
710VOID
711NTAPI
712CheckPreviousInterface(
713 _Inout_ ConfigWalk* Walk,
714 _Inout_ Verdict* Result)
715{
716 StartCheck(Walk->Ctx, Result);
717 if (!Walk->HadInterface)
718 {
719 Walk->HadInterface = TRUE;
720 return;
721 }
722
723 CheckPreviousEndpoint(Walk, Result);
724 if (*Result == Verdict::Fatal)
725 return;
726
727 /* QUIRK: one code for too few and too many endpoints */
728 if (Walk->EndpointsCounted != Walk->EndpointsDeclared)
729 Note(Walk->Ctx, Result, HubDescCode::EndpointCountMismatch, Gate::Legacy);
730}
731
732static
733VOID
734NTAPI
735CheckInterface(
736 _Inout_ ConfigWalk* Walk,
737 _In_ PUSB_INTERFACE_DESCRIPTOR Desc,
738 _Out_ PULONG Advance,
739 _Inout_ Verdict* Result)
740{
741 const HubDescContext* Ctx = Walk->Ctx;
742 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Desc);
743 BOOLEAN First;
744 BOOLEAN NewNumber;
745 UCHAR Number;
746 UCHAR Alternate;
747
748 StartCheck(Ctx, Result);
749 *Advance = Desc->bLength;
750
751 if (Desc->bLength < sizeof(*Desc) &&
752 !AssumeSize(Ctx, Result, HubDescCode::InterfaceLengthTooSmall, Gate::Legacy, sizeof(*Desc), Left, Advance))
753 {
754 return;
755 }
756
757 if (Desc->bLength > sizeof(*Desc))
758 Note(Ctx, Result, HubDescCode::InterfaceLengthTooLarge, Gate::Legacy);
759
760 if (*Advance > Left)
761 {
762 Note(Ctx, Result, HubDescCode::InterfaceBufferTooSmall, Gate::Legacy);
763 return;
764 }
765
766 Number = Desc->bInterfaceNumber;
767 Alternate = Desc->bAlternateSetting;
768 First = !Walk->HadInterface;
769 NewNumber = First || Number != Walk->Interface;
770
771 /* In compatibility mode this forgives the length findings above */
772 CheckPreviousInterface(Walk, Result);
773 if (*Result == Verdict::Fatal)
774 return;
775
776 if (NewNumber)
777 {
778 if (BitIsSet(Walk->InterfaceSeen, Number))
779 Note(Ctx, Result, HubDescCode::DuplicateInterface, Gate::Legacy);
780
781 if (!First && Walk->Interface > Number)
782 Note(Ctx, Result, HubDescCode::InterfaceOutOfOrder, Gate::Legacy);
783
784 if (Alternate != 0)
785 Note(Ctx, Result, HubDescCode::FirstAlternateNotZero, Gate::Legacy);
786
787 RtlZeroMemory(Walk->AlternateSeen, sizeof(Walk->AlternateSeen));
788 BitSet(Walk->InterfaceSeen, Number);
789 Walk->InterfacesFound++;
790 Walk->Interface = Number;
791 }
792 else
793 {
794 if (BitIsSet(Walk->AlternateSeen, Alternate))
795 Note(Ctx, Result, HubDescCode::DuplicateAlternate, Gate::Legacy);
796
797 if (Walk->Alternate >= Alternate)
798 Note(Ctx, Result, HubDescCode::AlternateOutOfOrder, Gate::Legacy);
799 }
800
801 RtlZeroMemory(Walk->EndpointSeen, sizeof(Walk->EndpointSeen));
802 Walk->EndpointsCounted = 0;
803 Walk->EndpointsDeclared = Desc->bNumEndpoints;
804 Walk->HadEndpoint = FALSE;
805 BitSet(Walk->AlternateSeen, Alternate);
806 Walk->Alternate = Alternate;
807}
808
809/* Packet size, interval and attribute rules per transfer type and speed */
810static
811VOID
812NTAPI
813CheckEndpointType(
814 _In_ ConfigWalk* Walk,
815 _In_ PUSB_ENDPOINT_DESCRIPTOR Desc,
816 _Inout_ Verdict* Result)
817{
818 const HubDescContext* Ctx = Walk->Ctx;
819 USB_DEVICE_SPEED Speed = Ctx->Speed;
820 ULONG Packet = Desc->wMaxPacketSize;
821 ULONG Size = Packet & 0x7FF;
822 ULONG Mult = (Packet >> 11) & 0x3;
823 ULONG Spare = Packet >> 13;
824 UCHAR Extra = Desc->bmAttributes & ~USB_ENDPOINT_TYPE_MASK;
825 BOOLEAN BadInterval = Desc->bInterval == 0 || Desc->bInterval > 16;
826
827 switch (Desc->bmAttributes & USB_ENDPOINT_TYPE_MASK)
828 {
829 case USB_ENDPOINT_TYPE_CONTROL:
830 if (Extra != 0)
831 Note(Ctx, Result, HubDescCode::ControlAttributesReserved, Gate::Reserved);
832
833 if (Speed == UsbLowSpeed && Packet != 8)
834 {
835 Note(Ctx, Result, HubDescCode::ControlMaxPacket,
836 (Packet > 8 || Packet == 0) ? Gate::Always : Gate::Versioned);
837 }
838 else if (Speed == UsbFullSpeed && !IsSmallPacket(Packet))
839 {
840 Note(Ctx, Result, HubDescCode::ControlMaxPacket, Packet == 0 ? Gate::Always : Gate::Versioned);
841 }
842 else if ((Speed == UsbHighSpeed && Packet != 64) || (Speed == UsbSuperSpeed && Packet != 512))
843 {
844 Note(Ctx, Result, HubDescCode::ControlMaxPacket, Gate::Versioned);
845 }
846 break;
847
848 case USB_ENDPOINT_TYPE_INTERRUPT:
849 /* SuperSpeed interrupt attribute bits are not looked at */
850 if (Speed != UsbSuperSpeed && Extra != 0)
851 Note(Ctx, Result, HubDescCode::InterruptAttributesReserved, Gate::Reserved);
852
853 if (Speed == UsbLowSpeed)
854 {
855 if (Packet > 8)
856 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Always);
857
858 if (Packet == 0)
859 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Always);
860 }
861 else if (Speed == UsbFullSpeed)
862 {
863 if (Packet > 64)
864 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Always);
865 }
866 else if (Speed == UsbHighSpeed)
867 {
868 if (Size > 1024)
869 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Versioned);
870
871 if (Spare != 0)
872 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Versioned);
873
874 if (Mult == 3)
875 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Versioned);
876 }
877 else if (Speed == UsbSuperSpeed && Packet > 1024)
878 {
879 Note(Ctx, Result, HubDescCode::InterruptMaxPacket, Gate::Versioned);
880 }
881
882 /* High speed intervals are not looked at */
883 if ((Speed == UsbLowSpeed || Speed == UsbFullSpeed) && Desc->bInterval == 0)
884 Note(Ctx, Result, HubDescCode::InterruptInterval, Gate::Versioned);
885 break;
886
887 case USB_ENDPOINT_TYPE_BULK:
888 if (Extra != 0)
889 Note(Ctx, Result, HubDescCode::BulkAttributesReserved, Gate::Reserved);
890
891 if (Speed == UsbLowSpeed)
892 Note(Ctx, Result, HubDescCode::BulkAtLowSpeed, Gate::Always);
893 else if (Speed == UsbFullSpeed && !IsSmallPacket(Packet))
894 Note(Ctx, Result, HubDescCode::BulkMaxPacket, Packet == 0 ? Gate::Always : Gate::Versioned);
895 else if ((Speed == UsbHighSpeed && Packet != 512) || (Speed == UsbSuperSpeed && Packet != 1024))
896 Note(Ctx, Result, HubDescCode::BulkMaxPacket, Gate::Versioned);
897 break;
898
899 case USB_ENDPOINT_TYPE_ISOCHRONOUS:
900 /* Logged, never enforced */
901 if (Walk->Alternate == 0 && Packet > 0)
902 Note(Ctx, Result, HubDescCode::IsochPacketInAlternate0, Gate::LogOnly);
903
904 if (Speed == UsbLowSpeed)
905 {
906 Note(Ctx, Result, HubDescCode::IsochAtLowSpeed, Gate::Always);
907 break;
908 }
909
910 if (Speed == UsbFullSpeed)
911 {
912 if (Packet > 1023)
913 Note(Ctx, Result, HubDescCode::IsochMaxPacket, Gate::Always);
914 }
915 else if (Speed == UsbHighSpeed)
916 {
917 if (Size > 1024)
918 Note(Ctx, Result, HubDescCode::IsochMaxPacket, Gate::Versioned);
919
920 if (Spare != 0)
921 Note(Ctx, Result, HubDescCode::IsochMaxPacket, Gate::Versioned);
922
923 if (Mult == 3)
924 Note(Ctx, Result, HubDescCode::IsochMaxPacket, Gate::Versioned);
925 }
926 else if (Speed == UsbSuperSpeed)
927 {
928 if (Packet > 1024)
929 Note(Ctx, Result, HubDescCode::IsochMaxPacket, Gate::Versioned);
930 }
931 else
932 {
933 break;
934 }
935
936 if (BadInterval)
937 Note(Ctx, Result, HubDescCode::IsochInterval, Gate::Versioned);
938 break;
939 }
940}
941
942static
943VOID
944NTAPI
945CheckEndpoint(
946 _Inout_ ConfigWalk* Walk,
947 _In_ PUSB_ENDPOINT_DESCRIPTOR Desc,
948 _Out_ PULONG Advance,
949 _Inout_ Verdict* Result)
950{
951 const HubDescContext* Ctx = Walk->Ctx;
952 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Desc);
953
954 StartCheck(Ctx, Result);
955 *Advance = Desc->bLength;
956
957 CheckPreviousEndpoint(Walk, Result);
958 if (*Result == Verdict::Fatal)
959 return;
960
961 if (Desc->bLength < sizeof(*Desc) &&
962 !AssumeSize(Ctx, Result, HubDescCode::EndpointLengthTooSmall, Gate::Legacy, sizeof(*Desc), Left, Advance))
963 {
964 return;
965 }
966
967 /* Audio class endpoints are 9 bytes long */
968 if (Desc->bLength > sizeof(*Desc))
969 Note(Ctx, Result, HubDescCode::EndpointLengthTooLarge, Gate::Warning);
970
971 if (*Advance > Left)
972 {
973 Note(Ctx, Result, HubDescCode::EndpointBufferTooSmall, Gate::Legacy);
974 return;
975 }
976
977 if (!Walk->HadInterface)
978 {
979 Note(Ctx, Result, HubDescCode::EndpointBeforeInterface, Gate::Legacy);
980 return;
981 }
982
983 if ((Desc->bEndpointAddress & 0x0F) == 0)
984 Note(Ctx, Result, HubDescCode::EndpointNumberZero, Gate::NewRule);
985
986 if (Desc->bEndpointAddress & 0x70)
987 Note(Ctx, Result, HubDescCode::EndpointAddressReserved, Gate::Versioned);
988
989 if (Desc->bmAttributes & 0xC0)
990 Note(Ctx, Result, HubDescCode::EndpointAttributesReserved, Gate::Reserved);
991
992 CheckEndpointType(Walk, Desc, Result);
993
994 if (BitIsSet(Walk->EndpointSeen, Desc->bEndpointAddress))
995 Note(Ctx, Result, HubDescCode::DuplicateEndpoint, Gate::Legacy);
996
997 BitSet(Walk->EndpointSeen, Desc->bEndpointAddress);
998 Walk->EndpointsCounted++;
999 Walk->GotCompanion = FALSE;
1000 Walk->WantCompanion = TRUE;
1001 Walk->LastEndpoint = Desc;
1002}
1003
1004static
1005VOID
1006NTAPI
1007CheckCompanion(
1008 _Inout_ ConfigWalk* Walk,
1009 _In_ PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR Desc,
1010 _Out_ PULONG Advance,
1011 _Inout_ Verdict* Result)
1012{
1013 const HubDescContext* Ctx = Walk->Ctx;
1014 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Desc);
1015 PUSB_ENDPOINT_DESCRIPTOR Endpoint;
1016 ULONG Packet;
1017 ULONG Burst;
1018 ULONG Attributes;
1019 ULONG Mult;
1020 ULONG Ceiling;
1021 BOOLEAN SspFollows;
1022
1023 StartCheck(Ctx, Result);
1024 *Advance = Desc->bLength;
1025
1026 /* QUIRK: so the output only reflects the last companion in the set */
1027 if (Walk->SupportsStreams != NULL)
1028 *Walk->SupportsStreams = FALSE;
1029
1030 /* USB 2.0 PHDC class descriptors share this type */
1031 if (Ctx->Speed != UsbSuperSpeed)
1032 {
1033 Note(Ctx, Result, HubDescCode::CompanionNotSuperSpeed, Gate::LogOnly);
1034 return;
1035 }
1036
1037 if (Desc->bLength < sizeof(*Desc) &&
1038 !AssumeSize(Ctx, Result, HubDescCode::CompanionLengthTooSmall, Gate::Always, sizeof(*Desc), Left, Advance))
1039 {
1040 return;
1041 }
1042
1043 if (Desc->bLength > sizeof(*Desc))
1044 Note(Ctx, Result, HubDescCode::CompanionLengthTooLarge, Gate::Versioned);
1045
1046 if (!Walk->WantCompanion)
1047 {
1048 Note(Ctx, Result, HubDescCode::CompanionUnexpected, Gate::Always);
1049 return;
1050 }
1051
1052 Walk->GotCompanion = TRUE;
1053 Walk->WantCompanion = FALSE;
1054
1055 if (*Advance > Left)
1056 {
1057 Note(Ctx, Result, HubDescCode::CompanionBufferTooSmall, Gate::NewRule);
1058 return;
1059 }
1060
1061 Endpoint = Walk->LastEndpoint;
1062 Packet = Endpoint->wMaxPacketSize;
1063 Burst = Desc->bMaxBurst;
1064 Attributes = Desc->bmAttributes.AsUchar;
1065 Mult = Attributes & 0x3;
1066 Ceiling = Packet * (Burst + 1) * (Mult + 1);
1067
1068 switch (Endpoint->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1069 {
1070 case USB_ENDPOINT_TYPE_CONTROL:
1071 if (Burst != 0)
1072 Note(Ctx, Result, HubDescCode::CompanionControlBurst, Gate::Versioned);
1073
1074 if (Attributes != 0)
1075 Note(Ctx, Result, HubDescCode::CompanionControlAttributes, Gate::Reserved);
1076
1077 if (Desc->wBytesPerInterval != 0)
1078 Note(Ctx, Result, HubDescCode::CompanionControlBytesPerInterval, Gate::Versioned);
1079 break;
1080
1081 case USB_ENDPOINT_TYPE_BULK:
1082 if (Burst > 15)
1083 Note(Ctx, Result, HubDescCode::CompanionBulkBurst, Gate::Versioned);
1084
1085 if ((Attributes & 0x1F) != 0 && Walk->SupportsStreams != NULL)
1086 *Walk->SupportsStreams = TRUE;
1087
1088 if ((Attributes & 0x1F) > 16)
1089 Note(Ctx, Result, HubDescCode::CompanionBulkStreams, Gate::Versioned);
1090
1091 if (Attributes & 0xE0)
1092 Note(Ctx, Result, HubDescCode::CompanionBulkReserved, Gate::Reserved);
1093
1094 if (Desc->wBytesPerInterval != 0)
1095 Note(Ctx, Result, HubDescCode::CompanionBulkBytesPerInterval, Gate::Versioned);
1096 break;
1097
1098 case USB_ENDPOINT_TYPE_INTERRUPT:
1099 if (Burst > 15)
1100 Note(Ctx, Result, HubDescCode::CompanionInterruptBurst, Gate::Versioned);
1101
1102 if (Burst != 0 && Packet != 1024)
1103 Note(Ctx, Result, HubDescCode::CompanionInterruptBurstPacket, Gate::Versioned);
1104
1105 if (Attributes != 0)
1106 Note(Ctx, Result, HubDescCode::CompanionInterruptAttributes, Gate::Reserved);
1107
1108 if (Desc->wBytesPerInterval > Ceiling)
1109 Note(Ctx, Result, HubDescCode::CompanionInterruptBytesPerInterval, Gate::Warning);
1110 break;
1111
1112 case USB_ENDPOINT_TYPE_ISOCHRONOUS:
1113 SspFollows = (Attributes & 0x80) != 0;
1114 Walk->GotSspCompanion = FALSE;
1115 Walk->WantSspCompanion = SspFollows;
1116
1117 if (Burst > 15)
1118 Note(Ctx, Result, HubDescCode::CompanionIsochBurst, Gate::Versioned);
1119
1120 if (Burst != 0 && Packet != 1024)
1121 Note(Ctx, Result, HubDescCode::CompanionIsochBurstPacket, Gate::Versioned);
1122
1123 if (!SspFollows && Mult > 2)
1124 Note(Ctx, Result, HubDescCode::CompanionIsochMult, Gate::Versioned);
1125
1126 if (Attributes & 0x7C)
1127 Note(Ctx, Result, HubDescCode::CompanionIsochReserved, Gate::Reserved);
1128
1129 if (!SspFollows && Desc->wBytesPerInterval > Ceiling)
1130 Note(Ctx, Result, HubDescCode::CompanionIsochBytesPerInterval, Gate::Warning);
1131
1132 if (SspFollows && Desc->wBytesPerInterval != 1)
1133 Note(Ctx, Result, HubDescCode::CompanionIsochBytesNotOne, Gate::Reserved);
1134 break;
1135 }
1136}
1137
1138static
1139VOID
1140NTAPI
1141CheckSspCompanion(
1142 _Inout_ ConfigWalk* Walk,
1143 _In_ PUSB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR Desc,
1144 _Out_ PULONG Advance,
1145 _Inout_ Verdict* Result)
1146{
1147 const HubDescContext* Ctx = Walk->Ctx;
1148 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Desc);
1149
1150 StartCheck(Ctx, Result);
1151 *Advance = Desc->bLength;
1152
1153 if (Ctx->Speed != UsbSuperSpeed || Ctx->SspIsochBurstCount == 0)
1154 {
1155 Note(Ctx, Result, HubDescCode::SspCompanionNotSuperSpeed, Gate::Always);
1156 return;
1157 }
1158
1159 if (Desc->bLength < sizeof(*Desc) &&
1160 !AssumeSize(Ctx, Result, HubDescCode::SspCompanionLengthTooSmall, Gate::Always, sizeof(*Desc), Left, Advance))
1161 {
1162 return;
1163 }
1164
1165 if (Desc->bLength > sizeof(*Desc))
1166 Note(Ctx, Result, HubDescCode::SspCompanionLengthTooLarge, Gate::Versioned);
1167
1168 if (!Walk->WantSspCompanion)
1169 {
1170 Note(Ctx, Result, HubDescCode::SspCompanionUnexpected, Gate::Always);
1171 return;
1172 }
1173
1174 Walk->GotSspCompanion = TRUE;
1175 Walk->WantSspCompanion = FALSE;
1176
1177 if (*Advance > Left)
1178 {
1179 Note(Ctx, Result, HubDescCode::SspCompanionBufferTooSmall, Gate::NewRule);
1180 return;
1181 }
1182
1183 if (Desc->wReserved != 0)
1184 Note(Ctx, Result, HubDescCode::SspCompanionReserved, Gate::Reserved);
1185
1186 if (Desc->dwBytesPerInterval < 0xC001 || Desc->dwBytesPerInterval > 0xFFFFFF)
1187 Note(Ctx, Result, HubDescCode::SspCompanionBytesRange, Gate::Reserved);
1188}
1189
1190static
1191VOID
1192NTAPI
1193CheckIad(
1194 _Inout_ ConfigWalk* Walk,
1195 _In_ PUSB_INTERFACE_ASSOCIATION_DESCRIPTOR Desc,
1196 _Out_ PULONG Advance,
1197 _Inout_ Verdict* Result)
1198{
1199 const HubDescContext* Ctx = Walk->Ctx;
1200 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Desc);
1201 ULONG Declared = Walk->Config->bNumInterfaces;
1202
1203 StartCheck(Ctx, Result);
1204 *Advance = Desc->bLength;
1205
1206 if (Desc->bLength < sizeof(*Desc) &&
1207 !AssumeSize(Ctx, Result, HubDescCode::IadLengthTooSmall, Gate::Legacy, sizeof(*Desc), Left, Advance))
1208 {
1209 return;
1210 }
1211
1212 if (Desc->bLength > sizeof(*Desc))
1213 Note(Ctx, Result, HubDescCode::IadLengthTooLarge, Gate::Legacy);
1214
1215 if (*Advance > Left)
1216 {
1217 Note(Ctx, Result, HubDescCode::IadBufferTooSmall, Gate::Legacy);
1218 return;
1219 }
1220
1221 if ((ULONG)Desc->bFirstInterface + Desc->bInterfaceCount > 256)
1222 Note(Ctx, Result, HubDescCode::IadFirstInterfaceTooLarge, Gate::Legacy);
1223
1224 if (Desc->bInterfaceCount > Declared)
1225 Note(Ctx, Result, HubDescCode::IadCountTooLarge, Gate::Legacy);
1226
1227 /* Same test USBCCGP makes */
1228 if (Desc->bInterfaceCount + Walk->InterfacesFound > Declared)
1229 Note(Ctx, Result, HubDescCode::IadCountTooLarge, Gate::NewRule);
1230
1231 if (Desc->bInterfaceCount == 0)
1232 Note(Ctx, Result, HubDescCode::IadCountZero, Gate::Legacy);
1233}
1234
1235BOOLEAN
1236NTAPI
1237HubDescCheckConfiguration(
1238 _In_ const HubDescContext* Context,
1239 _In_reads_bytes_opt_(Length) PUSB_CONFIGURATION_DESCRIPTOR Descriptor,
1240 _In_ ULONG Length,
1241 _Out_opt_ PBOOLEAN SupportsStreams)
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}
1362
1363/* Device descriptor */
1364
1365BOOLEAN
1366NTAPI
1367HubDescCheckDevice(
1368 _In_ const HubDescContext* Context,
1369 _In_reads_bytes_opt_(Length) PUSB_DEVICE_DESCRIPTOR Descriptor,
1370 _In_ ULONG Length,
1371 _Inout_opt_ PBOOLEAN IsBillboard)
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}
1460
1461/* BOS descriptor set */
1462
1463static
1464VOID
1465NTAPI
1466CheckBosFixedPart(
1467 _In_ const HubDescContext* Ctx,
1468 _In_opt_ PUSB_BOS_DESCRIPTOR Bos,
1469 _In_ ULONG Length,
1470 _Out_ PUCHAR* End,
1471 _Out_ PULONG Advance,
1472 _Inout_ Verdict* Result)
1473{
1474 ULONG Minimum;
1475
1476 StartCheck(Ctx, Result);
1477 *Advance = sizeof(*Bos);
1478 *End = NULL;
1479
1480 if (Bos == NULL)
1481 {
1482 NoteFatal(Ctx, Result, HubDescCode::BosNull);
1483 return;
1484 }
1485
1486 /* Every caller supplies 5 bytes, so this never fails in practice */
1487 if (Length < sizeof(*Bos))
1488 {
1489 NoteFatal(Ctx, Result, HubDescCode::BosBufferTooSmall);
1490 return;
1491 }
1492
1493 if (Bos->bDescriptorType != USB_BOS_DESCRIPTOR_TYPE)
1494 Note(Ctx, Result, HubDescCode::BosWrongType, Gate::Always);
1495
1496 if (Bos->bLength < sizeof(*Bos))
1497 Note(Ctx, Result, HubDescCode::BosLengthTooSmall, Gate::Always);
1498
1499 *End = (PUCHAR)Bos + Bos->wTotalLength;
1500 if (Bos->bLength > sizeof(*Bos))
1501 {
1502 Note(Ctx, Result, HubDescCode::BosLengthTooLarge, Gate::Versioned);
1503 *Advance = Bos->bLength;
1504 }
1505
1506 Minimum = Bos->bLength + Bos->bNumDeviceCaps * sizeof(USB_COMMON_DESCRIPTOR);
1507 if (Bos->wTotalLength < sizeof(*Bos))
1508 {
1509 Note(Ctx, Result, HubDescCode::BosTotalLengthTooSmall, Gate::Always);
1510 *End = (PUCHAR)Bos + Length;
1511 }
1512
1513 if (Bos->wTotalLength < Minimum)
1514 {
1515 Note(Ctx, Result, HubDescCode::BosTotalLengthTooSmall, Gate::Always);
1516 *End = (PUCHAR)Bos + Length;
1517 }
1518
1519 /* QUIRK: reuses the wTotalLength code */
1520 if (Bos->bNumDeviceCaps == 0)
1521 Note(Ctx, Result, HubDescCode::BosTotalLengthTooSmall, Gate::Versioned);
1522}
1523
1524static
1525VOID
1526NTAPI
1527CheckUsb20Cap(
1528 _Inout_ BosWalk* Walk,
1529 _In_ PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR Cap,
1530 _Inout_ PULONG Advance,
1531 _Inout_ Verdict* Result)
1532{
1533 const HubDescContext* Ctx = Walk->Ctx;
1534 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
1535 HubLpmInfo* Lpm = Walk->Lpm;
1536 ULONG Attributes;
1537 UCHAR Baseline;
1538 UCHAR Deep;
1539
1540 StartCheck(Ctx, Result);
1541 if (Cap->bLength < sizeof(*Cap) &&
1542 !AssumeSize(Ctx, Result, HubDescCode::Usb20CapLengthTooSmall, Gate::Always, sizeof(*Cap), Left, Advance))
1543 {
1544 return;
1545 }
1546
1547 if (Cap->bLength > sizeof(*Cap))
1548 Note(Ctx, Result, HubDescCode::Usb20CapLengthTooLarge, Gate::Cap20);
1549
1550 if (*Advance > Left)
1551 {
1552 Note(Ctx, Result, HubDescCode::Usb20CapBufferTooSmall, Gate::NewRule);
1553 return;
1554 }
1555
1556 Attributes = Cap->bmAttributes.AsUlong;
1557 if (Attributes & USB_DEVICE_CAPABILITY_USB20_EXTENSION_BMATTRIBUTES_RESERVED_MASK)
1558 Note(Ctx, Result, HubDescCode::Usb20CapReserved, Gate::Reserved);
1559
1560 if (!Cap->bmAttributes.LPMCapable)
1561 {
1562 if (Cap->bmAttributes.BESLAndAlternateHIRDSupported)
1563 Note(Ctx, Result, HubDescCode::BeslWithoutLpm, Gate::NewRule);
1564 return;
1565 }
1566
1567 /* QUIRK: written even for a duplicate capability, and never cleared */
1568 if (Lpm != NULL)
1569 {
1570 Lpm->Capable = TRUE;
1571 if (Cap->bmAttributes.BESLAndAlternateHIRDSupported)
1572 Lpm->BeslAndAltHird = TRUE;
1573 }
1574
1575 Baseline = (UCHAR)Cap->bmAttributes.BaselineBESL;
1576 Deep = (UCHAR)Cap->bmAttributes.DeepBESL;
1577
1578 if (Cap->bmAttributes.BaselineBESLValid)
1579 {
1580 if (Baseline == 0)
1581 {
1582 Note(Ctx, Result, HubDescCode::BaselineBeslZero, Gate::NewRule);
1583 }
1584 else if (Lpm != NULL)
1585 {
1586 Lpm->BaselineValid = TRUE;
1587 Lpm->Baseline = Baseline;
1588 }
1589 }
1590
1591 if (!Cap->bmAttributes.DeepBESLValid)
1592 return;
1593
1594 if (Cap->bmAttributes.BaselineBESLValid && Deep <= Baseline)
1595 {
1596 Note(Ctx, Result, HubDescCode::DeepBeslNotAboveBaseline, Gate::NewRule);
1597 }
1598 else if (Deep == 0)
1599 {
1600 Note(Ctx, Result, HubDescCode::DeepBeslZero, Gate::NewRule);
1601 }
1602 else if (Lpm != NULL)
1603 {
1604 Lpm->DeepValid = TRUE;
1605 Lpm->Deep = Deep;
1606 }
1607}
1608
1609static
1610VOID
1611NTAPI
1612CheckSuperSpeedCap(
1613 _Inout_ BosWalk* Walk,
1614 _In_ PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR Cap,
1615 _Inout_ PULONG Advance,
1616 _Inout_ Verdict* Result)
1617{
1618 const HubDescContext* Ctx = Walk->Ctx;
1619 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
1620 ULONG Speeds;
1621
1622 StartCheck(Ctx, Result);
1623
1624 /* QUIRK: the LTM output is cleared and never set, so the BOS never makes a device LTM capable */
1625 if (Walk->Ltm != NULL)
1626 *Walk->Ltm = FALSE;
1627
1628 if (Cap->bLength < sizeof(*Cap) &&
1629 !AssumeSize(Ctx, Result, HubDescCode::SsCapLengthTooSmall, Gate::Always, sizeof(*Cap), Left, Advance))
1630 {
1631 return;
1632 }
1633
1634 if (Cap->bLength > sizeof(*Cap))
1635 Note(Ctx, Result, HubDescCode::SsCapLengthTooLarge, Gate::CapSs);
1636
1637 if (*Advance > Left)
1638 {
1639 Note(Ctx, Result, HubDescCode::SsCapBufferTooSmall, Gate::NewRule);
1640 return;
1641 }
1642
1643 if (Cap->bmAttributes & USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_RESERVED_MASK)
1644 Note(Ctx, Result, HubDescCode::SsCapAttributesReserved, Gate::Reserved);
1645
1646 Speeds = Cap->wSpeedsSupported;
1647 if (Speeds & USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_RESERVED_MASK)
1648 Note(Ctx, Result, HubDescCode::SsCapSpeedsReserved, Gate::Reserved);
1649
1650 if (Speeds == 0)
1651 Note(Ctx, Result, HubDescCode::SsCapNoSpeeds, Gate::Always);
1652
1653 if (Cap->bFunctionalitySupport > 3)
1654 Note(Ctx, Result, HubDescCode::SsCapFunctionalityReserved, Gate::Reserved);
1655 else if ((Speeds & (1UL << Cap->bFunctionalitySupport)) == 0)
1656 Note(Ctx, Result, HubDescCode::SsCapFunctionalityNotInSpeeds, Gate::Always);
1657
1658 if (Cap->bU1DevExitLat > USB_DEVICE_CAPABILITY_SUPERSPEED_U1_DEVICE_EXIT_MAX_VALUE)
1659 Note(Ctx, Result, HubDescCode::SsCapU1TooLarge, Gate::CapSs);
1660 else if (Walk->U1 != NULL)
1661 *Walk->U1 = Cap->bU1DevExitLat;
1662
1663 if (Cap->wU2DevExitLat > USB_DEVICE_CAPABILITY_SUPERSPEED_U2_DEVICE_EXIT_MAX_VALUE)
1664 Note(Ctx, Result, HubDescCode::SsCapU2TooLarge, Gate::CapSs);
1665 else if (Walk->U2 != NULL)
1666 *Walk->U2 = Cap->wU2DevExitLat;
1667}
1668
1670static
1671VOID
1672NTAPI
1673CheckSublinkSpeeds(
1674 _In_ const HubDescContext* Ctx,
1675 _In_ PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR Cap,
1676 _In_ ULONG Present,
1677 _Inout_ Verdict* Result)
1678{
1679 ULONG Last = Cap->bmAttributes.SublinkSpeedAttrCount;
1680 ULONG MinimumId = Cap->wFunctionalitySupport.SublinkSpeedAttrID;
1681 BOOLEAN Symmetric;
1682 BOOLEAN MinimumFound = FALSE;
1683 ULONG SeenIds = 0;
1684 ULONG Unique = 0;
1685 ULONG i;
1686
1687 for (i = 0; i <= Last; i += 2)
1688 {
1689 /* Stop at the last entry bLength covers */
1690 if (i >= Present)
1691 return;
1692
1693 if (Cap->bmSublinkSpeedAttr[i].SublinkTypeDir != USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_RX)
1694 {
1695 Note(Ctx, Result, HubDescCode::SspAttrNotRx, Gate::NewRule);
1696 return;
1697 }
1698
1699 if (i == Last)
1700 {
1701 Note(Ctx, Result, HubDescCode::SspAttrTxMissing, Gate::NewRule);
1702 return;
1703 }
1704
1705 if (i + 1 >= Present)
1706 return;
1707
1708 if (Cap->bmSublinkSpeedAttr[i + 1].SublinkTypeDir != USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_TX)
1709 {
1710 Note(Ctx, Result, HubDescCode::SspAttrNotTx, Gate::NewRule);
1711 return;
1712 }
1713
1714 if (Cap->bmSublinkSpeedAttr[i].SublinkSpeedAttrID != Cap->bmSublinkSpeedAttr[i + 1].SublinkSpeedAttrID ||
1715 Cap->bmSublinkSpeedAttr[i].SublinkTypeMode != Cap->bmSublinkSpeedAttr[i + 1].SublinkTypeMode ||
1716 Cap->bmSublinkSpeedAttr[i].LinkProtocol != Cap->bmSublinkSpeedAttr[i + 1].LinkProtocol)
1717 {
1718 Note(Ctx, Result, HubDescCode::SspAttrPairMismatch, Gate::NewRule);
1719 }
1720
1721 Symmetric = Cap->bmSublinkSpeedAttr[i].SublinkTypeMode == USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_SYMMETRIC;
1722 if (Symmetric &&
1723 (Cap->bmSublinkSpeedAttr[i].LaneSpeedExponent != Cap->bmSublinkSpeedAttr[i + 1].LaneSpeedExponent ||
1724 Cap->bmSublinkSpeedAttr[i].LaneSpeedMantissa != Cap->bmSublinkSpeedAttr[i + 1].LaneSpeedMantissa))
1725 {
1726 Note(Ctx, Result, HubDescCode::SspAttrSymmetricMismatch, Gate::NewRule);
1727 }
1728
1729 if (Cap->bmSublinkSpeedAttr[i].SublinkSpeedAttrID == MinimumId)
1730 {
1731 MinimumFound = TRUE;
1732 if (Symmetric &&
1733 Cap->wFunctionalitySupport.MinRxLaneCount != Cap->wFunctionalitySupport.MinTxLaneCount)
1734 {
1735 Note(Ctx, Result, HubDescCode::SspMinLaneMismatch, Gate::NewRule);
1736 }
1737 }
1738
1739 if (SeenIds & (1UL << Cap->bmSublinkSpeedAttr[i].SublinkSpeedAttrID))
1740 {
1741 Note(Ctx, Result, HubDescCode::SspSpeedIdDuplicate, Gate::NewRule);
1742 }
1743 else
1744 {
1745 SeenIds |= 1UL << Cap->bmSublinkSpeedAttr[i].SublinkSpeedAttrID;
1746 Unique++;
1747 }
1748 }
1749
1750 if (Cap->bmAttributes.SublinkSpeedIDCount + 1UL != Unique)
1751 Note(Ctx, Result, HubDescCode::SspSpeedIdCount, Gate::NewRule);
1752
1753 if (!MinimumFound)
1754 Note(Ctx, Result, HubDescCode::SspMinSpeedMissing, Gate::NewRule);
1755}
1756
1757static
1758VOID
1759NTAPI
1760CheckSuperSpeedPlusCap(
1761 _Inout_ BosWalk* Walk,
1762 _In_ PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR Cap,
1763 _Inout_ PULONG Advance,
1764 _Inout_ Verdict* Result)
1765{
1766 const HubDescContext* Ctx = Walk->Ctx;
1767 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
1768 ULONG Fixed = FIELD_OFFSET(USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR, bmSublinkSpeedAttr);
1769 ULONG Entry = sizeof(Cap->bmSublinkSpeedAttr[0]);
1770
1771 StartCheck(Ctx, Result);
1772 if (Cap->bLength < sizeof(*Cap) &&
1773 !AssumeSize(Ctx, Result, HubDescCode::SspCapLengthTooSmall, Gate::Always, sizeof(*Cap), Left, Advance))
1774 {
1775 return;
1776 }
1777
1778 if (Cap->bLength != sizeof(*Cap) + Entry * Cap->bmAttributes.SublinkSpeedAttrCount)
1779 Note(Ctx, Result, HubDescCode::SspCapLengthInvalid, Gate::CapSsp);
1780
1781 if (*Advance > Left)
1782 {
1783 Note(Ctx, Result, HubDescCode::SspCapBufferTooSmall, Gate::NewRule);
1784 return;
1785 }
1786
1787 if (Cap->bmAttributes.Reserved != 0)
1788 Note(Ctx, Result, HubDescCode::SspCapAttributesReserved, Gate::Reserved);
1789
1790 if (Cap->wFunctionalitySupport.Reserved != 0)
1791 Note(Ctx, Result, HubDescCode::SspCapFunctionalityReserved, Gate::Reserved);
1792
1793 if (Cap->bReserved != 0)
1794 Note(Ctx, Result, HubDescCode::SspCapReservedByte, Gate::Reserved);
1795
1796 if (Cap->wReserved != 0)
1797 Note(Ctx, Result, HubDescCode::SspCapReservedWord, Gate::Reserved);
1798
1799 CheckSublinkSpeeds(Ctx, Cap, (*Advance - Fixed) / Entry, Result);
1800}
1801
1802static
1803VOID
1804NTAPI
1805CheckContainerIdCap(
1806 _Inout_ BosWalk* Walk,
1807 _In_ PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR Cap,
1808 _Inout_ PULONG Advance,
1809 _Inout_ Verdict* Result)
1810{
1811 const HubDescContext* Ctx = Walk->Ctx;
1812 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
1813
1814 StartCheck(Ctx, Result);
1815 if (Cap->bLength < sizeof(*Cap) &&
1816 !AssumeSize(Ctx, Result, HubDescCode::ContainerIdLengthTooSmall, Gate::Always, sizeof(*Cap), Left, Advance))
1817 {
1818 return;
1819 }
1820
1821 if (Cap->bLength > sizeof(*Cap))
1822 Note(Ctx, Result, HubDescCode::ContainerIdLengthTooLarge, Gate::Versioned);
1823
1824 if (*Advance > Left)
1825 {
1826 Note(Ctx, Result, HubDescCode::ContainerIdBufferTooSmall, Gate::NewRule);
1827 return;
1828 }
1829
1830 if (Cap->bReserved != 0)
1831 Note(Ctx, Result, HubDescCode::ContainerIdReserved, Gate::Reserved);
1832
1833 /* These devices still enumerate; only the ID is dropped */
1834 if (IsAllZero(Cap->ContainerID, sizeof(Cap->ContainerID)))
1835 {
1836 Note(Ctx, Result, HubDescCode::BosContainerIdZero, Gate::Warning);
1837 Walk->Info->DiscardContainerId = TRUE;
1838 }
1839}
1840
1842static
1843BOOLEAN
1844NTAPI
1845MsOs20VersionUsable(
1846 _In_ ULONG Version)
1847{
1848 return Version <= HUB_MSOS20_NEWEST_VERSION;
1849}
1850
1851static
1852VOID
1853NTAPI
1854CheckMsOs20Platform(
1855 _Inout_ BosWalk* Walk,
1856 _In_ PUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR Cap,
1857 _Inout_ Verdict* Result)
1858{
1859 const HubDescContext* Ctx = Walk->Ctx;
1860 ULONG Fixed = FIELD_OFFSET(USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR, CapabililityData);
1861 HubMsOs20SetInfo* Sets = (HubMsOs20SetInfo*)((PUCHAR)Cap + Fixed);
1862 ULONG Count;
1863 ULONG Best = 0;
1864 ULONG i, j;
1865
1866 if (Walk->Info->MsOs20SetInfo != NULL)
1867 {
1868 NoteFatal(Ctx, Result, HubDescCode::MsOs20MultiplePlatform);
1869 return;
1870 }
1871
1872 if (Cap->bLength < Fixed + sizeof(*Sets) || (Cap->bLength - Fixed) % sizeof(*Sets) != 0)
1873 {
1874 NoteFatal(Ctx, Result, HubDescCode::MsOs20PlatformLength);
1875 return;
1876 }
1877
1878 Count = (Cap->bLength - Fixed) / sizeof(*Sets);
1879
1880 /* Logged once per equal pair */
1881 for (i = 0; i < Count; i++)
1882 {
1883 for (j = i + 1; j < Count; j++)
1884 {
1885 if (Sets[i].dwWindowsVersion == Sets[j].dwWindowsVersion)
1886 NoteFatal(Ctx, Result, HubDescCode::MsOs20DuplicateVersion);
1887 }
1888 }
1889
1890 /* Newest set this OS can use */
1891 for (i = 0; i < Count; i++)
1892 {
1893 if (Sets[i].dwWindowsVersion > Best && MsOs20VersionUsable(Sets[i].dwWindowsVersion))
1894 {
1895 Best = Sets[i].dwWindowsVersion;
1896 Walk->Info->MsOs20SetInfo = &Sets[i];
1897 }
1898 }
1899
1900 if (Best == 0)
1901 HubDescLog(Ctx, HubDescCode::MsOs20NoVersionMatch, TRUE);
1902}
1903
1904static
1905VOID
1906NTAPI
1907CheckPlatformFeatures(
1908 _Inout_ BosWalk* Walk,
1909 _In_ HubPlatformFeatures* Cap,
1910 _Inout_ Verdict* Result)
1911{
1912 const HubDescContext* Ctx = Walk->Ctx;
1913
1914 if (Cap->bLength < sizeof(*Cap))
1915 {
1916 NoteFatal(Ctx, Result, HubDescCode::PlatformFeaturesTooSmall);
1917 return;
1918 }
1919
1920 /* Later versions may be longer */
1921 if (Cap->Version == 1 && Cap->bLength != sizeof(*Cap))
1922 {
1923 NoteFatal(Ctx, Result, HubDescCode::PlatformFeaturesLength);
1924 return;
1925 }
1926
1927 if (Cap->Version == 0)
1928 {
1929 NoteFatal(Ctx, Result, HubDescCode::PlatformFeaturesVersion);
1930 return;
1931 }
1932
1933 if (Walk->Info->PlatformFeatures != NULL)
1934 {
1935 NoteFatal(Ctx, Result, HubDescCode::PlatformFeaturesMultiple);
1936 return;
1937 }
1938
1939 Walk->Info->PlatformFeatures = Cap;
1940}
1941
1942static
1943VOID
1944NTAPI
1945CheckPlatformCap(
1946 _Inout_ BosWalk* Walk,
1947 _In_ PUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR Cap,
1948 _Inout_ PULONG Advance,
1949 _Inout_ Verdict* Result)
1950{
1951 const HubDescContext* Ctx = Walk->Ctx;
1952 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
1953 ULONG Fixed = FIELD_OFFSET(USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR, CapabililityData);
1954 PUCHAR Uuid = (PUCHAR)Cap + FIELD_OFFSET(USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR, PlatformCapabilityUuid);
1955
1956 StartCheck(Ctx, Result);
1957 if (Cap->bLength < Fixed &&
1958 !AssumeSize(Ctx, Result, HubDescCode::PlatformLengthTooSmall, Gate::Always, Fixed, Left, Advance))
1959 {
1960 return;
1961 }
1962
1963 if (*Advance > Left)
1964 {
1965 Note(Ctx, Result, HubDescCode::PlatformBufferTooSmall, Gate::NewRule);
1966 return;
1967 }
1968
1969 if (Cap->bReserved != 0)
1970 Note(Ctx, Result, HubDescCode::PlatformReserved, Gate::Reserved);
1971
1972 if (IsAllZero(Uuid, sizeof(GUID)))
1973 {
1974 NoteFatal(Ctx, Result, HubDescCode::PlatformUuidZero);
1975 return;
1976 }
1977
1978 /* Other platform UUIDs are accepted as they are */
1979 if (IsEqualGUID(*(const GUID*)Uuid, HubMsOs20PlatformUuid))
1980 CheckMsOs20Platform(Walk, Cap, Result);
1981 else if (IsEqualGUID(*(const GUID*)Uuid, HubPlatformFeaturesUuid))
1982 CheckPlatformFeatures(Walk, (HubPlatformFeatures*)Cap, Result);
1983}
1984
1985static
1986VOID
1987NTAPI
1988CheckPowerDeliveryCap(
1989 _Inout_ BosWalk* Walk,
1990 _In_ PUSB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR Cap,
1991 _Inout_ PULONG Advance,
1992 _Inout_ Verdict* Result)
1993{
1994 const HubDescContext* Ctx = Walk->Ctx;
1995 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
1996
1997 StartCheck(Ctx, Result);
1998 if (Cap->bLength < sizeof(*Cap) &&
1999 !AssumeSize(Ctx, Result, HubDescCode::PdLengthTooSmall, Gate::Always, sizeof(*Cap), Left, Advance))
2000 {
2001 return;
2002 }
2003
2004 if (Cap->bLength > sizeof(*Cap))
2005 Note(Ctx, Result, HubDescCode::PdLengthTooLarge, Gate::Versioned);
2006
2007 if (*Advance > Left)
2008 {
2009 Note(Ctx, Result, HubDescCode::PdBufferTooSmall, Gate::NewRule);
2010 return;
2011 }
2012
2013 if (Cap->bReserved != 0 ||
2014 Cap->bmAttributes.Reserved1 != 0 ||
2015 Cap->bmAttributes.Reserved2 != 0 ||
2016 Cap->bmAttributes.Reserved3 != 0)
2017 {
2018 Note(Ctx, Result, HubDescCode::PdReserved, Gate::Reserved);
2019 }
2020
2021 if (Cap->bmAttributes.ChargingPolicy)
2022 Walk->Info->ChargingPolicy = TRUE;
2023}
2024
2025static
2026VOID
2027NTAPI
2028CheckBillboardCap(
2029 _Inout_ BosWalk* Walk,
2030 _Inout_ PUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR Cap,
2031 _Inout_ PULONG Advance,
2032 _Inout_ Verdict* Result)
2033{
2034 const HubDescContext* Ctx = Walk->Ctx;
2035 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
2036 ULONG Mode = sizeof(Cap->AlternateMode[0]);
2037 ULONG Modes = Cap->bNumberOfAlternateModes;
2038 ULONG Expected;
2039 BOOLEAN Repaired;
2040
2041 StartCheck(Ctx, Result);
2042 if (Left < sizeof(*Cap))
2043 {
2044 NoteFatal(Ctx, Result, HubDescCode::BillboardBufferTooSmall);
2045 return;
2046 }
2047
2048 /* The structure holds one mode; zero modes gives 44 */
2049 Expected = sizeof(*Cap) - Mode + Modes * Mode;
2050 if (Cap->bLength != Expected)
2051 {
2052 /* QUIRK: the walk moves by the computed length from here on */
2053 *Advance = Expected;
2054 Repaired = (Cap->bLength == 40 || Cap->bLength == 44);
2055 HubDescLog(Ctx, HubDescCode::BillboardLengthInvalid, Repaired || !GateApplies(Ctx, Gate::CapSsp));
2056
2057 /* QUIRK: early spec revisions gave the base length; repair it in the caller's buffer */
2058 if (Repaired)
2059 Cap->bLength = (UCHAR)Expected;
2060 else if (GateApplies(Ctx, Gate::CapSsp))
2061 *Result = Verdict::Failed;
2062 }
2063
2064 if (*Advance > Left)
2065 {
2066 Note(Ctx, Result, HubDescCode::BillboardBufferTooSmall, Gate::NewRule);
2067 return;
2068 }
2069
2070 if (Modes == 0)
2071 {
2072 NoteFatal(Ctx, Result, HubDescCode::BillboardNoModes);
2073 return;
2074 }
2075
2076 if (Modes > 128)
2077 {
2078 NoteFatal(Ctx, Result, HubDescCode::BillboardTooManyModes);
2079 return;
2080 }
2081
2082 /* QUIRK: an index equal to the mode count passes */
2083 if (Cap->bPreferredAlternateMode > Modes)
2084 NoteFatal(Ctx, Result, HubDescCode::BillboardPreferredInvalid);
2085}
2086
2088static
2089VOID
2090NTAPI
2091CheckCapability(
2092 _Inout_ BosWalk* Walk,
2093 _Inout_ PUSB_DEVICE_CAPABILITY_DESCRIPTOR Cap,
2094 _Out_ PULONG Advance,
2095 _Inout_ Verdict* Result)
2096{
2097 const HubDescContext* Ctx = Walk->Ctx;
2098 HubBosInfo* Info = Walk->Info;
2099 ULONG Left = BytesLeft(Walk->Base, Walk->BufferLength, Cap);
2100
2101 StartCheck(Ctx, Result);
2102
2103 /* QUIRK: latencies survive only when the SuperSpeed capability comes last */
2104 if (Walk->U1 != NULL)
2105 *Walk->U1 = 0;
2106
2107 if (Walk->U2 != NULL)
2108 *Walk->U2 = 0;
2109
2110 *Advance = Cap->bLength;
2111 if (Cap->bLength < sizeof(*Cap) &&
2112 !AssumeSize(Ctx, Result, HubDescCode::CapLengthTooSmall, Gate::Always, sizeof(*Cap), Left, Advance))
2113 {
2114 return;
2115 }
2116
2117 if (sizeof(*Cap) > Left)
2118 {
2119 Note(Ctx, Result, HubDescCode::CapBufferTooSmall, Gate::NewRule);
2120 return;
2121 }
2122
2123 /* QUIRK: in compatibility mode the specific checks below start over */
2124 switch (Cap->bDevCapabilityType)
2125 {
2126 case USB_DEVICE_CAPABILITY_USB20_EXTENSION:
2127 CheckUsb20Cap(Walk, (PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR)Cap, Advance, Result);
2128 if (*Result == Verdict::Fatal)
2129 return;
2130
2131 if (Info->Usb20 != NULL)
2132 Note(Ctx, Result, HubDescCode::CapMultipleUsb20, Gate::Always);
2133 else
2134 Info->Usb20 = (PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR)Cap;
2135 break;
2136
2137 case USB_DEVICE_CAPABILITY_SUPERSPEED_USB:
2138 CheckSuperSpeedCap(Walk, (PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR)Cap, Advance, Result);
2139 if (*Result == Verdict::Fatal)
2140 return;
2141
2142 if (Info->SuperSpeed != NULL)
2143 Note(Ctx, Result, HubDescCode::CapMultipleSuperSpeed, Gate::Always);
2144 else
2145 Info->SuperSpeed = (PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR)Cap;
2146 break;
2147
2148 case USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB:
2149 CheckSuperSpeedPlusCap(Walk, (PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR)Cap, Advance, Result);
2150 if (*Result == Verdict::Fatal)
2151 return;
2152
2153 if (Info->SuperSpeedPlus != NULL)
2154 Note(Ctx, Result, HubDescCode::CapMultipleSuperSpeedPlus, Gate::Always);
2155 else
2156 Info->SuperSpeedPlus = (PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR)Cap;
2157 break;
2158
2159 case USB_DEVICE_CAPABILITY_CONTAINER_ID:
2160 CheckContainerIdCap(Walk, (PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR)Cap, Advance, Result);
2161 if (*Result == Verdict::Fatal)
2162 return;
2163
2164 if (Info->ContainerId != NULL)
2165 Note(Ctx, Result, HubDescCode::CapMultipleContainerId, Gate::Always);
2166 else if (!Info->DiscardContainerId)
2167 Info->ContainerId = (PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR)Cap;
2168 break;
2169
2170 case USB_DEVICE_CAPABILITY_PLATFORM:
2171 CheckPlatformCap(Walk, (PUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR)Cap, Advance, Result);
2172 break;
2173
2174 case USB_DEVICE_CAPABILITY_POWER_DELIVERY:
2175 CheckPowerDeliveryCap(Walk, (PUSB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR)Cap, Advance, Result);
2176 break;
2177
2178 case USB_DEVICE_CAPABILITY_BILLBOARD:
2179 CheckBillboardCap(Walk, (PUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR)Cap, Advance, Result);
2180 if (*Result == Verdict::Fatal)
2181 return;
2182
2183 if (Info->Billboard != NULL)
2184 Note(Ctx, Result, HubDescCode::CapMultipleBillboard, Gate::Always);
2185 else
2186 Info->Billboard = (PUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR)Cap;
2187 break;
2188
2189 /* Wireless USB, battery, PD ports, PTM, firmware status and unknown types */
2190 default:
2191 break;
2192 }
2193}
2194
2195BOOLEAN
2196NTAPI
2197HubDescCheckBosHeader(
2198 _In_ const HubDescContext* Context,
2199 _In_reads_bytes_opt_(Length) PUSB_BOS_DESCRIPTOR Descriptor,
2200 _In_ ULONG Length)
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}
2209
2210_IRQL_requires_(PASSIVE_LEVEL)
2211BOOLEAN
2212NTAPI
2213HubDescCheckBos(
2214 _In_ const HubDescContext* Context,
2215 _Inout_updates_bytes_(Length) PUSB_BOS_DESCRIPTOR Descriptor,
2216 _In_ ULONG Length,
2217 _Out_opt_ HubBosInfo* Info,
2218 _Out_opt_ PUSHORT U1ExitLatency,
2219 _Out_opt_ PUSHORT U2ExitLatency,
2220 _Inout_opt_ PBOOLEAN LtmCapable,
2221 _Inout_opt_ HubLpmInfo* Lpm,
2222 _Inout_opt_ PULONG DeviceFlags)
2223{
2224 HubBosInfo LocalInfo;
2225 BosWalk Walk;
2226 Verdict Result;
2227 BOOLEAN Valid = TRUE;
2228 PUCHAR Cursor;
2229 PUCHAR End;
2230 PUCHAR Limit;
2231 ULONG Advance;
2232 ULONG Found = 0;
2233
2234 if (Info == NULL)
2235 Info = &LocalInfo;
2236
2237 if (U1ExitLatency != NULL)
2238 *U1ExitLatency = 0;
2239
2240 if (U2ExitLatency != NULL)
2241 *U2ExitLatency = 0;
2242
2243 RtlZeroMemory(Info, sizeof(*Info));
2244
2245 if (Length < sizeof(*Descriptor))
2246 {
2247 HubDescLog(Context, HubDescCode::BosBufferTooSmall, FALSE);
2248 return FALSE;
2249 }
2250
2251 Result = Verdict::Ok;
2252 CheckBosFixedPart(Context, Descriptor, Length, &End, &Advance, &Result);
2253 if (Result == Verdict::Fatal)
2254 return FALSE;
2255
2256 if (Result != Verdict::Ok)
2257 Valid = FALSE;
2258
2259 if (Length < Descriptor->wTotalLength)
2260 {
2261 HubDescLog(Context, HubDescCode::BosBufferTooSmall, FALSE);
2262 Valid = FALSE;
2263 }
2264
2265 /* A Genesys 2.1 hub returns more than wTotalLength */
2266 if (Length > Descriptor->wTotalLength)
2267 HubDescLog(Context, HubDescCode::BosBufferLargerThanTotal, TRUE);
2268
2269 Walk.Ctx = Context;
2270 Walk.Base = (PUCHAR)Descriptor;
2271 Walk.BufferLength = Length;
2272 Walk.Info = Info;
2273 Walk.U1 = U1ExitLatency;
2274 Walk.U2 = U2ExitLatency;
2275 Walk.Ltm = LtmCapable;
2276 Walk.Lpm = Lpm;
2277
2278 /* Stop at the buffer end even when wTotalLength runs past it */
2279 Limit = Walk.Base + Length;
2280
2281 Cursor = Walk.Base + Advance;
2282 while (Cursor < End)
2283 {
2284 PUSB_COMMON_DESCRIPTOR Desc = (PUSB_COMMON_DESCRIPTOR)Cursor;
2285
2286 /* Code 23 was logged above when wTotalLength overran the buffer */
2287 if (Cursor >= Limit)
2288 return FALSE;
2289
2290 Result = Verdict::Ok;
2291 CheckHeader(Context, Walk.Base, Length, End, Desc, &Advance, &Result);
2292 if (Result == Verdict::Fatal)
2293 return FALSE;
2294
2295 if (Result != Verdict::Ok)
2296 Valid = FALSE;
2297
2298 Result = Verdict::Ok;
2299 if (Desc->bDescriptorType == USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE)
2300 CheckCapability(&Walk, (PUSB_DEVICE_CAPABILITY_DESCRIPTOR)Desc, &Advance, &Result);
2301 else
2302 HubDescLog(Context, HubDescCode::BosUnknownType, TRUE);
2303
2304 if (Result == Verdict::Fatal)
2305 return FALSE;
2306
2307 if (Result != Verdict::Ok)
2308 Valid = FALSE;
2309
2310 /* QUIRK: every descriptor counts toward bNumDeviceCaps, whatever its type */
2311 Found++;
2312
2313 /* A zero length descriptor would otherwise loop forever */
2314 if (Advance == 0)
2315 break;
2316
2317 Cursor += Advance;
2318 }
2319
2320 if (Found != Descriptor->bNumDeviceCaps)
2321 {
2322 HubDescLog(Context, HubDescCode::BosCapCountMismatch, FALSE);
2323 Valid = FALSE;
2324 }
2325
2326 if (Info->SuperSpeed != NULL)
2327 {
2328 if (DeviceFlags != NULL)
2329 *DeviceFlags |= HUB_BOS_SUPERSPEED_CAPABLE;
2330 }
2331 else if (Context->Speed == UsbSuperSpeed)
2332 {
2333 HubDescLog(Context, HubDescCode::BosNoSuperSpeedCap, FALSE);
2334 Valid = FALSE;
2335 }
2336
2337 if (DeviceFlags != NULL)
2338 {
2339 if (Info->SuperSpeedPlus != NULL)
2340 *DeviceFlags |= HUB_BOS_ENHANCED_SUPERSPEED_CAPABLE;
2341
2342 if (Info->ChargingPolicy)
2343 *DeviceFlags |= HUB_BOS_CHARGING_POLICY;
2344 }
2345
2346 return Valid;
2347}
2348
2349/* Strings */
2350
2351static
2352Verdict
2353NTAPI
2354CheckStringCore(
2355 _In_ const HubDescContext* Ctx,
2356 _In_reads_bytes_(Length) PUSB_STRING_DESCRIPTOR Desc,
2357 _In_ ULONG Length,
2358 _Out_ PULONG Adjusted)
2359{
2360 Verdict Result = Verdict::Ok;
2361
2362 if (Length < sizeof(USB_COMMON_DESCRIPTOR))
2363 {
2364 *Adjusted = 0;
2365 NoteFatal(Ctx, &Result, HubDescCode::StringBufferTooSmall);
2366 return Result;
2367 }
2368
2369 *Adjusted = Desc->bLength;
2370 if (Desc->bLength > Length)
2371 {
2372 Note(Ctx, &Result, HubDescCode::StringLengthTooLarge, Gate::Always);
2373 *Adjusted = Length;
2374 }
2375
2376 /* No characters at all */
2377 if (Desc->bLength <= sizeof(USB_COMMON_DESCRIPTOR))
2378 {
2379 Note(Ctx, &Result, HubDescCode::StringLengthTooSmall, Gate::Always);
2380 *Adjusted = Length;
2381 }
2382
2383 if (Desc->bDescriptorType != USB_STRING_DESCRIPTOR_TYPE)
2384 Note(Ctx, &Result, HubDescCode::StringWrongType, Gate::Always);
2385
2386 if (Desc->bLength & 1)
2387 {
2388 Note(Ctx, &Result, HubDescCode::StringLengthOdd, Gate::Always);
2389 *Adjusted &= ~1UL;
2390 }
2391
2392 if (Desc->bLength != Length)
2393 Note(Ctx, &Result, HubDescCode::StringLengthVsBytes, Gate::LogOnly);
2394
2395 return Result;
2396}
2397
2398BOOLEAN
2399NTAPI
2400HubDescCheckString(
2401 _In_ const HubDescContext* Context,
2402 _In_reads_bytes_(Length) PUSB_STRING_DESCRIPTOR Descriptor,
2403 _In_ ULONG Length,
2404 _Out_opt_ PULONG AdjustedLength)
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}
2415
2416BOOLEAN
2417NTAPI
2418HubDescCheckSerialNumber(
2419 _In_ const HubDescContext* Context,
2420 _In_reads_bytes_(*Length) PUSB_STRING_DESCRIPTOR Descriptor,
2421 _Inout_ PULONG Length)
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}
2455
2456/* MS OS 1.0 descriptors */
2457
2459static
2460BOOLEAN
2461NTAPI
2462IsMsOsIdChar(
2463 _In_ UCHAR Ch)
2464{
2465 return (Ch >= 'A' && Ch <= 'Z') || (Ch >= '0' && Ch <= '9') || Ch == '_';
2466}
2467
2468static
2469BOOLEAN
2470NTAPI
2471IsMsOs10IdValid(
2472 _In_reads_(8) const UCHAR* Id)
2473{
2474 BOOLEAN Ended = FALSE;
2475 ULONG i;
2476
2477 for (i = 0; i < 8; i++)
2478 {
2479 if (Id[i] == 0)
2480 Ended = TRUE;
2481 else if (Ended || !IsMsOsIdChar(Id[i]))
2482 return FALSE;
2483 }
2484
2485 return TRUE;
2486}
2487
2488BOOLEAN
2489NTAPI
2490HubDescCheckMsOsString(
2491 _In_ const HubDescContext* Context,
2492 _In_ const HubMsOsString* Descriptor)
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}
2502
2503BOOLEAN
2504NTAPI
2505HubDescCheckMsOsContainerIdHeader(
2506 _In_ const HubDescContext* Context,
2507 _In_reads_bytes_(Length) const HubMsOsHeader* Descriptor,
2508 _In_ ULONG Length)
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}
2538
2539BOOLEAN
2540NTAPI
2541HubDescCheckMsOsContainerId(
2542 _In_ const HubDescContext* Context,
2543 _In_reads_bytes_(Length) const HubMsOsContainerId* Descriptor,
2544 _In_ ULONG Length)
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}
2560
2561BOOLEAN
2562NTAPI
2563HubDescCheckMsOsExtConfigHeader(
2564 _In_ const HubDescContext* Context,
2565 _In_reads_bytes_(Length) const HubMsOsExtConfigHeader* Descriptor,
2566 _In_ ULONG Length)
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}
2603
2604BOOLEAN
2605NTAPI
2606HubDescCheckMsOsExtConfig(
2607 _In_ const HubDescContext* Context,
2608 _In_reads_bytes_(sizeof(HubMsOsExtConfig)) const HubMsOsExtConfig* Descriptor,
2609 _In_ ULONG Length)
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}
2632
2633/* MS OS 2.0 descriptor set */
2634
2635/* wDescriptorType values */
2636#define HUB_MSOS20_TYPE_SET_HEADER 0
2637#define HUB_MSOS20_TYPE_CONFIG_SUBSET 1
2638#define HUB_MSOS20_TYPE_FUNCTION_SUBSET 2
2639#define HUB_MSOS20_TYPE_COMPATIBLE_ID 3
2640#define HUB_MSOS20_TYPE_REGISTRY 4
2641#define HUB_MSOS20_TYPE_RESUME_TIME 5
2642#define HUB_MSOS20_TYPE_MODEL_ID 6
2643#define HUB_MSOS20_TYPE_CCGP 7
2644
2645BOOLEAN
2646NTAPI
2647HubDescNextMsOs20(
2648 _In_ PUCHAR End,
2649 _Inout_ HubMsOs20Common** Current)
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}
2691
2692static
2693BOOLEAN
2694NTAPI
2695CheckMsOs20Feature(
2696 _In_ const HubDescContext* Ctx,
2697 _Inout_ HubMsOs20Info* Info,
2698 _In_ HubMsOs20Common* Desc,
2699 _In_ PUCHAR End,
2700 _In_ ULONG Depth);
2701
2702static
2703BOOLEAN
2704NTAPI
2705CheckMsOs20SetHeader(
2706 _In_ const HubDescContext* Ctx,
2707 _Inout_ HubMsOs20Info* Info,
2708 _In_ HubMsOs20Common* Desc)
2709{
2710 BOOLEAN Valid = TRUE;
2711
2712 if (Info->Flags & HUB_MSOS20_SET_HEADER)
2713 {
2714 HubDescLog(Ctx, HubDescCode::MsOs20MultipleSetHeaders, FALSE);
2715 Valid = FALSE;
2716 }
2717
2718 if (Desc->wLength != sizeof(HubMsOs20SetHeader))
2719 {
2720 HubDescLog(Ctx, HubDescCode::MsOs20SetHeaderLength, FALSE);
2721 Valid = FALSE;
2722 }
2723
2724 if (Valid)
2725 Info->Flags |= HUB_MSOS20_SET_HEADER;
2726
2727 return Valid;
2728}
2729
2731static
2732BOOLEAN
2733NTAPI
2734MsOs20AllowedIn(
2735 _In_ BOOLEAN Function,
2736 _In_ ULONG Type)
2737{
2738 if (Type == HUB_MSOS20_TYPE_COMPATIBLE_ID || Type == HUB_MSOS20_TYPE_REGISTRY)
2739 return TRUE;
2740
2741 return !Function && Type == HUB_MSOS20_TYPE_FUNCTION_SUBSET;
2742}
2743
2744static
2745BOOLEAN
2746NTAPI
2747CheckMsOs20Subset(
2748 _In_ const HubDescContext* Ctx,
2749 _Inout_ HubMsOs20Info* Info,
2750 _In_ HubMsOs20Common* Desc,
2751 _In_ PUCHAR End,
2752 _In_ ULONG Depth)
2753{
2754 HubMsOs20Subset* Subset = (HubMsOs20Subset*)Desc;
2755 BOOLEAN Function = Desc->wDescriptorType == HUB_MSOS20_TYPE_FUNCTION_SUBSET;
2756 HubDescCode LengthCode = Function ? HubDescCode::FunctionSubsetLength : HubDescCode::ConfigSubsetLength;
2757 HubDescCode SmallCode = Function ? HubDescCode::FunctionSubsetTotalTooSmall : HubDescCode::ConfigSubsetTotalTooSmall;
2758 HubDescCode LargeCode = Function ? HubDescCode::FunctionSubsetTotalTooLarge : HubDescCode::ConfigSubsetTotalTooLarge;
2759 HubDescCode StepCode = Function ? HubDescCode::FunctionSubsetFeatureLength : HubDescCode::ConfigSubsetFeatureLength;
2760 HubMsOs20Info Private;
2761 HubMsOs20Common* Cursor;
2762 PUCHAR SubsetEnd;
2763 BOOLEAN Valid = TRUE;
2764
2765 if (Subset->wLength != sizeof(*Subset))
2766 {
2767 HubDescLog(Ctx, LengthCode, FALSE);
2768 return FALSE;
2769 }
2770
2771 if (Subset->wTotalLength < sizeof(*Subset) + sizeof(*Desc))
2772 {
2773 HubDescLog(Ctx, SmallCode, FALSE);
2774 return FALSE;
2775 }
2776
2777 SubsetEnd = (PUCHAR)Subset + Subset->wTotalLength;
2778 if (SubsetEnd > End)
2779 {
2780 HubDescLog(Ctx, LargeCode, FALSE);
2781 return FALSE;
2782 }
2783
2784 /* Nested configuration subsets would otherwise recurse without bound */
2785 if (Depth >= HUB_MSOS20_MAX_DEPTH)
2786 {
2787 HubDescLog(Ctx, StepCode, FALSE);
2788 return FALSE;
2789 }
2790
2791 /* QUIRK: what a subset holds is checked into a private record, then dropped */
2792 RtlZeroMemory(&Private, sizeof(Private));
2793
2794 Cursor = (HubMsOs20Common*)((PUCHAR)Subset + sizeof(*Subset));
2795 while (Cursor != NULL)
2796 {
2797 ULONG Type = Cursor->wDescriptorType;
2798
2799 if (Type <= HUB_MSOS20_TYPE_CCGP)
2800 {
2801 if (!MsOs20AllowedIn(Function, Type))
2802 {
2803 if (Function)
2804 {
2805 HubDescLog(Ctx, HubDescCode::FunctionSubsetMisplacedFeature, FALSE);
2806 Valid = FALSE;
2807 }
2808 else
2809 {
2810 HubDescLog(Ctx, HubDescCode::ConfigSubsetMisplacedFeature, TRUE);
2811 }
2812 }
2813
2814 /* Skip a first entry that runs past the subset; the step below fails it */
2815 if ((PUCHAR)Cursor + Cursor->wLength <= SubsetEnd &&
2816 !CheckMsOs20Feature(Ctx, &Private, Cursor, SubsetEnd, Depth + 1))
2817 {
2818 Valid = FALSE;
2819 }
2820 }
2821
2822 if (!HubDescNextMsOs20(SubsetEnd, &Cursor))
2823 {
2824 HubDescLog(Ctx, StepCode, FALSE);
2825 return FALSE;
2826 }
2827 }
2828
2829 if (Valid)
2830 Info->Flags |= Function ? HUB_MSOS20_FUNCTION_SUBSET : HUB_MSOS20_CONFIG_SUBSET;
2831
2832 return Valid;
2833}
2834
2836static
2837BOOLEAN
2838NTAPI
2839CheckMsOs20Id(
2840 _In_ const HubDescContext* Ctx,
2841 _In_reads_(8) const UCHAR* Id)
2842{
2843 BOOLEAN Ended = FALSE;
2844 ULONG i;
2845
2846 for (i = 0; i < 8; i++)
2847 {
2848 if (Ended && Id[i] != 0)
2849 {
2850 HubDescLog(Ctx, HubDescCode::MsOs20CompatibleIdAfterNull, FALSE);
2851 return FALSE;
2852 }
2853
2854 if (Id[i] == 0)
2855 {
2856 Ended = TRUE;
2857 }
2858 else if (!IsMsOsIdChar(Id[i]))
2859 {
2860 HubDescLog(Ctx, HubDescCode::MsOs20CompatibleIdLength, FALSE);
2861 return FALSE;
2862 }
2863 }
2864
2865 return TRUE;
2866}
2867
2868static
2869BOOLEAN
2870NTAPI
2871CheckMsOs20CompatibleId(
2872 _In_ const HubDescContext* Ctx,
2873 _Inout_ HubMsOs20Info* Info,
2874 _In_ HubMsOs20Common* Desc)
2875{
2876 HubMsOs20CompatibleId* Id = (HubMsOs20CompatibleId*)Desc;
2877 BOOLEAN Valid = TRUE;
2878
2879 if (Info->Flags & HUB_MSOS20_COMPATIBLE_ID)
2880 {
2881 HubDescLog(Ctx, HubDescCode::MsOs20MultipleCompatibleId, FALSE);
2882 Valid = FALSE;
2883 }
2884
2885 if (Id->wLength != sizeof(*Id))
2886 {
2887 HubDescLog(Ctx, HubDescCode::MsOs20CompatibleIdLength, FALSE);
2888 return FALSE;
2889 }
2890
2891 if (!CheckMsOs20Id(Ctx, Id->CompatibleId) || !CheckMsOs20Id(Ctx, Id->SubCompatibleId))
2892 return FALSE;
2893
2894 if (Valid)
2895 {
2896 Info->CompatibleId = Id;
2897 Info->Flags |= HUB_MSOS20_COMPATIBLE_ID;
2898 }
2899
2900 return Valid;
2901}
2902
2903static
2904BOOLEAN
2905NTAPI
2906CheckMsOs20Registry(
2907 _In_ const HubDescContext* Ctx,
2908 _Inout_ HubMsOs20Info* Info,
2909 _In_ HubMsOs20Common* Desc)
2910{
2911 HubMsOs20Registry* Reg = (HubMsOs20Registry*)Desc;
2912 ULONG Total = Reg->wLength;
2913 ULONG NameLength;
2914 USHORT DataLength;
2915
2916 /* Header, a one character name, the data length and one data byte */
2917 if (Total < sizeof(*Reg) + sizeof(WCHAR) + sizeof(USHORT) + 1)
2918 {
2919 HubDescLog(Ctx, HubDescCode::MsOs20RegistryTooSmall, FALSE);
2920 return FALSE;
2921 }
2922
2923 NameLength = Reg->wPropertyNameLength;
2924 if (Total < sizeof(*Reg) + NameLength + sizeof(USHORT) + 1)
2925 {
2926 HubDescLog(Ctx, HubDescCode::MsOs20RegistryNameTooLarge, FALSE);
2927 return FALSE;
2928 }
2929
2930 if (NameLength == 0 || (NameLength % sizeof(WCHAR)) != 0)
2931 {
2932 HubDescLog(Ctx, HubDescCode::MsOs20RegistryNameOddOrZero, FALSE);
2933 return FALSE;
2934 }
2935
2936 RtlCopyMemory(&DataLength, (PUCHAR)Reg + sizeof(*Reg) + NameLength, sizeof(DataLength));
2937 if (Total < sizeof(*Reg) + NameLength + sizeof(USHORT) + DataLength)
2938 {
2939 HubDescLog(Ctx, HubDescCode::MsOs20RegistryDataTooLarge, FALSE);
2940 return FALSE;
2941 }
2942
2943 if (DataLength == 0)
2944 {
2945 HubDescLog(Ctx, HubDescCode::MsOs20RegistryDataZero, FALSE);
2946 return FALSE;
2947 }
2948
2949 if (Reg->wPropertyDataType < REG_SZ || Reg->wPropertyDataType > REG_MULTI_SZ)
2950 {
2951 HubDescLog(Ctx, HubDescCode::MsOs20RegistryType, FALSE);
2952 return FALSE;
2953 }
2954
2955 /* Any number of registry properties is fine */
2956 Info->Flags |= HUB_MSOS20_REGISTRY;
2957 return TRUE;
2958}
2959
2960static
2961BOOLEAN
2962NTAPI
2963CheckMsOs20ResumeTime(
2964 _In_ const HubDescContext* Ctx,
2965 _Inout_ HubMsOs20Info* Info,
2966 _In_ HubMsOs20Common* Desc)
2967{
2968 HubMsOs20ResumeTime* Resume = (HubMsOs20ResumeTime*)Desc;
2969 BOOLEAN Valid = TRUE;
2970
2971 if (Info->Flags & HUB_MSOS20_RESUME_TIME)
2972 {
2973 HubDescLog(Ctx, HubDescCode::MsOs20MultipleResumeTime, FALSE);
2974 Valid = FALSE;
2975 }
2976
2977 if (Resume->wLength != sizeof(*Resume))
2978 {
2979 HubDescLog(Ctx, HubDescCode::MsOs20ResumeTimeLength, FALSE);
2980 return FALSE;
2981 }
2982
2983 if (Resume->bResumeRecoveryTime > 10)
2984 {
2985 HubDescLog(Ctx, HubDescCode::MsOs20ResumeRecovery, FALSE);
2986 Valid = FALSE;
2987 }
2988
2989 /* The hub drives resume signaling for at most 20 ms */
2990 if (Resume->bResumeSignalingTime == 0 || Resume->bResumeSignalingTime > 20)
2991 HubDescLog(Ctx, HubDescCode::MsOs20ResumeSignaling, TRUE);
2992
2993 if (Valid)
2994 {
2995 Info->ResumeTime = Resume;
2996 Info->Flags |= HUB_MSOS20_RESUME_TIME;
2997 }
2998
2999 return Valid;
3000}
3001
3002static
3003BOOLEAN
3004NTAPI
3005CheckMsOs20ModelId(
3006 _In_ const HubDescContext* Ctx,
3007 _Inout_ HubMsOs20Info* Info,
3008 _In_ HubMsOs20Common* Desc)
3009{
3010 HubMsOs20ModelId* Model = (HubMsOs20ModelId*)Desc;
3011
3012 if (Info->Flags & HUB_MSOS20_MODEL_ID)
3013 {
3014 HubDescLog(Ctx, HubDescCode::MsOs20MultipleModelId, FALSE);
3015 return FALSE;
3016 }
3017
3018 if (Model->wLength != sizeof(*Model))
3019 {
3020 HubDescLog(Ctx, HubDescCode::MsOs20ModelIdLength, FALSE);
3021 return FALSE;
3022 }
3023
3024 if (IsAllZero(Model->ModelId, sizeof(Model->ModelId)))
3025 {
3026 HubDescLog(Ctx, HubDescCode::MsOs20ModelIdZero, FALSE);
3027 return FALSE;
3028 }
3029
3030 Info->ModelId = Model;
3031 Info->Flags |= HUB_MSOS20_MODEL_ID;
3032 return TRUE;
3033}
3034
3035static
3036BOOLEAN
3037NTAPI
3038CheckMsOs20Ccgp(
3039 _In_ const HubDescContext* Ctx,
3040 _Inout_ HubMsOs20Info* Info,
3041 _In_ HubMsOs20Common* Desc)
3042{
3043 if (Info->Flags & HUB_MSOS20_CCGP)
3044 {
3045 HubDescLog(Ctx, HubDescCode::MsOs20MultipleCcgp, FALSE);
3046 return FALSE;
3047 }
3048
3049 if (Desc->wLength != sizeof(HubMsOs20Ccgp))
3050 {
3051 HubDescLog(Ctx, HubDescCode::MsOs20CcgpLength, FALSE);
3052 return FALSE;
3053 }
3054
3055 Info->Ccgp = (HubMsOs20Ccgp*)Desc;
3056 Info->Flags |= HUB_MSOS20_CCGP;
3057 return TRUE;
3058}
3059
3060static
3061BOOLEAN
3062NTAPI
3063CheckMsOs20Feature(
3064 _In_ const HubDescContext* Ctx,
3065 _Inout_ HubMsOs20Info* Info,
3066 _In_ HubMsOs20Common* Desc,
3067 _In_ PUCHAR End,
3068 _In_ ULONG Depth)
3069{
3070 switch (Desc->wDescriptorType)
3071 {
3072 case HUB_MSOS20_TYPE_SET_HEADER:
3073 return CheckMsOs20SetHeader(Ctx, Info, Desc);
3074
3075 case HUB_MSOS20_TYPE_CONFIG_SUBSET:
3076 case HUB_MSOS20_TYPE_FUNCTION_SUBSET:
3077 return CheckMsOs20Subset(Ctx, Info, Desc, End, Depth);
3078
3079 case HUB_MSOS20_TYPE_COMPATIBLE_ID:
3080 return CheckMsOs20CompatibleId(Ctx, Info, Desc);
3081
3082 case HUB_MSOS20_TYPE_REGISTRY:
3083 return CheckMsOs20Registry(Ctx, Info, Desc);
3084
3085 case HUB_MSOS20_TYPE_RESUME_TIME:
3086 return CheckMsOs20ResumeTime(Ctx, Info, Desc);
3087
3088 case HUB_MSOS20_TYPE_MODEL_ID:
3089 return CheckMsOs20ModelId(Ctx, Info, Desc);
3090
3091 case HUB_MSOS20_TYPE_CCGP:
3092 return CheckMsOs20Ccgp(Ctx, Info, Desc);
3093
3094 default:
3095 return TRUE;
3096 }
3097}
3098
3099static
3100BOOLEAN
3101NTAPI
3102WalkMsOs20Set(
3103 _In_ const HubDescContext* Ctx,
3104 _In_reads_bytes_(Length) PVOID Set,
3105 _In_ ULONG Length,
3106 _In_ const HubMsOs20SetInfo* SetInfo,
3107 _Inout_ HubMsOs20Info* Info)
3108{
3109 HubMsOs20SetHeader* Header = (HubMsOs20SetHeader*)Set;
3110 HubMsOs20Common* Cursor;
3111 PUCHAR End;
3112 BOOLEAN Valid = TRUE;
3113
3114 if (Length != SetInfo->wLength)
3115 {
3116 HubDescLog(Ctx, HubDescCode::MsOs20BytesVsSetInfo, FALSE);
3117 return FALSE;
3118 }
3119
3120 if (Length < sizeof(*Header))
3121 {
3122 HubDescLog(Ctx, HubDescCode::MsOs20BytesTooSmall, FALSE);
3123 return FALSE;
3124 }
3125
3126 if (Header->wLength != sizeof(*Header))
3127 {
3128 HubDescLog(Ctx, HubDescCode::MsOs20HeaderLength, FALSE);
3129 return FALSE;
3130 }
3131
3132 if (Header->wTotalLength != SetInfo->wLength)
3133 {
3134 HubDescLog(Ctx, HubDescCode::MsOs20TotalLengthMismatch, FALSE);
3135 return FALSE;
3136 }
3137
3138 if (Header->dwWindowsVersion > SetInfo->dwWindowsVersion)
3139 {
3140 HubDescLog(Ctx, HubDescCode::MsOs20VersionMismatch, FALSE);
3141 return FALSE;
3142 }
3143
3144 /* The walk starts at the set header itself */
3145 End = (PUCHAR)Header + Header->wTotalLength;
3146 Cursor = (HubMsOs20Common*)Header;
3147 while (Cursor != NULL)
3148 {
3149 ULONG Type = Cursor->wDescriptorType;
3150
3151 if (Type <= HUB_MSOS20_TYPE_CCGP)
3152 {
3153 if (!CheckMsOs20Feature(Ctx, Info, Cursor, End, 0))
3154 Valid = FALSE;
3155
3156 /* Top level features must come before any subset */
3157 if (Type != HUB_MSOS20_TYPE_CONFIG_SUBSET &&
3158 Type != HUB_MSOS20_TYPE_FUNCTION_SUBSET &&
3159 (Info->Flags & (HUB_MSOS20_CONFIG_SUBSET | HUB_MSOS20_FUNCTION_SUBSET)))
3160 {
3161 HubDescLog(Ctx, HubDescCode::MsOs20FeatureOutOfOrder, FALSE);
3162 Valid = FALSE;
3163 }
3164 }
3165
3166 if (!HubDescNextMsOs20(End, &Cursor))
3167 {
3168 HubDescLog(Ctx, HubDescCode::MsOs20PastEnd, FALSE);
3169 return FALSE;
3170 }
3171 }
3172
3173 return Valid;
3174}
3175
3176_IRQL_requires_(PASSIVE_LEVEL)
3177BOOLEAN
3178NTAPI
3179HubDescCheckMsOs20Set(
3180 _In_ const HubDescContext* Context,
3181 _In_reads_bytes_(Length) PVOID Set,
3182 _In_ ULONG Length,
3183 _In_ const HubMsOs20SetInfo* SetInfo,
3184 _Inout_ HubMsOs20Info* Info)
3185{
3186 if (WalkMsOs20Set(Context, Set, Length, SetInfo, Info))
3187 return TRUE;
3188
3189 /* QUIRK: this also drops the set info and alternate enumeration bits from the BOS */
3190 Info->Flags = 0;
3191 return FALSE;
3192}
3193
3194/* Hub descriptors */
3195
3196BOOLEAN
3197NTAPI
3198HubDescCheck20Hub(
3199 _In_ const HubDescContext* Context,
3200 _In_reads_bytes_opt_(Length) PUSB_HUB_DESCRIPTOR Descriptor,
3201 _In_ ULONG Length)
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}
3269
3270BOOLEAN
3271NTAPI
3272HubDescCheck30Hub(
3273 _In_ const HubDescContext* Context,
3274 _In_reads_bytes_opt_(Length) PUSB_30_HUB_DESCRIPTOR Descriptor,
3275 _In_ ULONG Length)
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}
3328
3329/* Search helpers */
3330
3331PUSB_COMMON_DESCRIPTOR
3332NTAPI
3333HubDescFind(
3334 _In_reads_bytes_(TotalLength) PVOID Buffer,
3335 _In_ ULONG TotalLength,
3336 _In_ PVOID Position,
3337 _In_ UCHAR Type)
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}
3358
3359static
3360BOOLEAN
3361NTAPI
3362FieldMatches(
3363 _In_ LONG Wanted,
3364 _In_ UCHAR Actual)
3365{
3366 return Wanted == -1 || Wanted == (LONG)Actual;
3367}
3368
3369PUSB_INTERFACE_DESCRIPTOR
3370NTAPI
3371HubDescFindInterface(
3372 _In_ PUSB_CONFIGURATION_DESCRIPTOR Config,
3373 _In_ PVOID Position,
3374 _In_ LONG Number,
3375 _In_ LONG Alternate,
3376 _In_ LONG Class,
3377 _In_ LONG SubClass,
3378 _In_ LONG Protocol,
3379 _Out_opt_ PBOOLEAN HasAlternates)
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}
Id
DWORD Id
Definition: CLayerUIPropPage.cpp:47
First
WCHAR First[]
Definition: FormatMessage.c:11
Expected
BOOLEAN Expected
Definition: FsRtlExpression.c:22
Type
Type
Definition: Type.h:7
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
REG_SZ
#define REG_SZ
Definition: layer.c:22
DPRINT1
#define DPRINT1
Definition: precomp.h:8
Function
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
Buffer
Definition: bufpool.h:45
Header
Definition: Header.h:9
Depth
UINT Depth
Definition: d3d12.idl:4644
CheckPreviousEndpoint
static VOID NTAPI CheckPreviousEndpoint(_Inout_ ConfigWalk *Walk, _Inout_ Verdict *Result)
Definition: desccheck.cpp:682
HUB_MSOS20_TYPE_COMPATIBLE_ID
#define HUB_MSOS20_TYPE_COMPATIBLE_ID
Definition: desccheck.cpp:2639
HUB_MSOS20_TYPE_SET_HEADER
#define HUB_MSOS20_TYPE_SET_HEADER
Definition: desccheck.cpp:2636
Verdict
Verdict
Definition: desccheck.cpp:15
Gate
Gate
Definition: desccheck.cpp:23
Gate::Versioned
@ Versioned
Gate::Legacy
@ Legacy
Gate::Warning
@ Warning
Gate::CapSsp
@ CapSsp
Gate::LogOnly
@ LogOnly
Gate::NewRule
@ NewRule
Gate::Always
@ Always
Gate::Reserved
@ Reserved
HUB_MSOS20_TYPE_FUNCTION_SUBSET
#define HUB_MSOS20_TYPE_FUNCTION_SUBSET
Definition: desccheck.cpp:2638
CheckMsOs20Platform
static VOID NTAPI CheckMsOs20Platform(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR Cap, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1854
WalkMsOs20Set
static BOOLEAN NTAPI WalkMsOs20Set(_In_ const HubDescContext *Ctx, _In_reads_bytes_(Length) PVOID Set, _In_ ULONG Length, _In_ const HubMsOs20SetInfo *SetInfo, _Inout_ HubMsOs20Info *Info)
Definition: desccheck.cpp:3102
HubDescInitHubContext
VOID NTAPI HubDescInitHubContext(_Out_ HubDescContext *Context, _In_ USHORT BcdUsb, _In_ USB_DEVICE_SPEED Speed)
Definition: desccheck.cpp:112
Found
ULONG Found
Definition: desccheck.cpp:2232
CheckIad
static VOID NTAPI CheckIad(_Inout_ ConfigWalk *Walk, _In_ PUSB_INTERFACE_ASSOCIATION_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1193
Info
_In_ ULONG _Out_opt_ HubBosInfo * Info
Definition: desccheck.cpp:2217
CheckSuperSpeedCap
static VOID NTAPI CheckSuperSpeedCap(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1612
CheckMsOs20ModelId
static BOOLEAN NTAPI CheckMsOs20ModelId(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc)
Definition: desccheck.cpp:3005
Result
Verdict Result
Definition: desccheck.cpp:2226
CheckInterface
static VOID NTAPI CheckInterface(_Inout_ ConfigWalk *Walk, _In_ PUSB_INTERFACE_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:735
HubDescNextMsOs20
BOOLEAN NTAPI HubDescNextMsOs20(_In_ PUCHAR End, _Inout_ HubMsOs20Common **Current)
Definition: desccheck.cpp:2647
HubDescCheckMsOsString
BOOLEAN NTAPI HubDescCheckMsOsString(_In_ const HubDescContext *Context, _In_ const HubMsOsString *Descriptor)
Definition: desccheck.cpp:2490
HubDescCheck30Hub
BOOLEAN NTAPI HubDescCheck30Hub(_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_30_HUB_DESCRIPTOR Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:3272
HUB_MSOS20_MAX_DEPTH
#define HUB_MSOS20_MAX_DEPTH
Definition: desccheck.cpp:40
CheckMsOs20ResumeTime
static BOOLEAN NTAPI CheckMsOs20ResumeTime(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc)
Definition: desccheck.cpp:2963
CheckMsOs20CompatibleId
static BOOLEAN NTAPI CheckMsOs20CompatibleId(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc)
Definition: desccheck.cpp:2871
HubDescCheckConfiguration
BOOLEAN NTAPI HubDescCheckConfiguration(_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_CONFIGURATION_DESCRIPTOR Descriptor, _In_ ULONG Length, _Out_opt_ PBOOLEAN SupportsStreams)
Definition: desccheck.cpp:1237
HubDescLog
VOID NTAPI HubDescLog(_In_ const HubDescContext *Context, _In_ HubDescCode Code, _In_ BOOLEAN Warning)
Definition: desccheck.cpp:383
CheckBillboardCap
static VOID NTAPI CheckBillboardCap(_Inout_ BosWalk *Walk, _Inout_ PUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:2028
CheckPlatformFeatures
static VOID NTAPI CheckPlatformFeatures(_Inout_ BosWalk *Walk, _In_ HubPlatformFeatures *Cap, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1907
LtmCapable
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN LtmCapable
Definition: desccheck.cpp:2220
CheckMsOs20SetHeader
static BOOLEAN NTAPI CheckMsOs20SetHeader(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc)
Definition: desccheck.cpp:2705
HubDescCheckMsOsExtConfigHeader
BOOLEAN NTAPI HubDescCheckMsOsExtConfigHeader(_In_ const HubDescContext *Context, _In_reads_bytes_(Length) const HubMsOsExtConfigHeader *Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:2563
if
if(Length< sizeof(*Descriptor))
Definition: desccheck.cpp:2245
CheckConfigFixedPart
static VOID NTAPI CheckConfigFixedPart(_Inout_ ConfigWalk *Walk, _Inout_ Verdict *Result)
Definition: desccheck.cpp:636
HubDescCheckDevice
BOOLEAN NTAPI HubDescCheckDevice(_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_DEVICE_DESCRIPTOR Descriptor, _In_ ULONG Length, _Inout_opt_ PBOOLEAN IsBillboard)
Definition: desccheck.cpp:1367
CheckMsOs20Registry
static BOOLEAN NTAPI CheckMsOs20Registry(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc)
Definition: desccheck.cpp:2906
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
HUB_MSOS20_TYPE_RESUME_TIME
#define HUB_MSOS20_TYPE_RESUME_TIME
Definition: desccheck.cpp:2641
HUB_MSOS20_TYPE_REGISTRY
#define HUB_MSOS20_TYPE_REGISTRY
Definition: desccheck.cpp:2640
SetInfo
_In_ ULONG _In_ const HubMsOs20SetInfo * SetInfo
Definition: desccheck.cpp:3183
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
Limit
PUCHAR Limit
Definition: desccheck.cpp:2230
GateApplies
static BOOLEAN NTAPI GateApplies(_In_ const HubDescContext *Ctx, _In_ Gate Kind)
Definition: desccheck.cpp:418
IsMsOsIdChar
static BOOLEAN NTAPI IsMsOsIdChar(_In_ UCHAR Ch)
Definition: desccheck.cpp:2462
TRUE
TRUE
Definition: desccheck.cpp:2267
CheckPowerDeliveryCap
static VOID NTAPI CheckPowerDeliveryCap(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1988
NoteFatal
static VOID NTAPI NoteFatal(_In_ const HubDescContext *Ctx, _Inout_ Verdict *Result, _In_ HubDescCode Code)
Definition: desccheck.cpp:481
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)
Definition: desccheck.cpp:91
Base
Walk Base
Definition: desccheck.cpp:2270
HubDescCheck20Hub
BOOLEAN NTAPI HubDescCheck20Hub(_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_HUB_DESCRIPTOR Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:3198
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
FieldMatches
static BOOLEAN NTAPI FieldMatches(_In_ LONG Wanted, _In_ UCHAR Actual)
Definition: desccheck.cpp:3362
U1ExitLatency
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT U1ExitLatency
Definition: desccheck.cpp:2218
HUB_MSOS20_TYPE_MODEL_ID
#define HUB_MSOS20_TYPE_MODEL_ID
Definition: desccheck.cpp:2642
MsOs20VersionUsable
static BOOLEAN NTAPI MsOs20VersionUsable(_In_ ULONG Version)
Definition: desccheck.cpp:1845
HubDescCheckSerialNumber
BOOLEAN NTAPI HubDescCheckSerialNumber(_In_ const HubDescContext *Context, _In_reads_bytes_(*Length) PUSB_STRING_DESCRIPTOR Descriptor, _Inout_ PULONG Length)
Definition: desccheck.cpp:2418
CheckSublinkSpeeds
static VOID NTAPI CheckSublinkSpeeds(_In_ const HubDescContext *Ctx, _In_ PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR Cap, _In_ ULONG Present, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1673
End
PUCHAR End
Definition: desccheck.cpp:2229
BitIsSet
static BOOLEAN NTAPI BitIsSet(_In_reads_(8) const ULONG *Bits, _In_ UCHAR Index)
Definition: desccheck.cpp:529
U2ExitLatency
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT U2ExitLatency
Definition: desccheck.cpp:2219
HUB_MSOS20_TYPE_CCGP
#define HUB_MSOS20_TYPE_CCGP
Definition: desccheck.cpp:2643
CheckContainerIdCap
static VOID NTAPI CheckContainerIdCap(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1805
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
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
CheckMsOs20Feature
static BOOLEAN NTAPI CheckMsOs20Feature(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc, _In_ PUCHAR End, _In_ ULONG Depth)
Definition: desccheck.cpp:3063
StartCheck
static VOID NTAPI StartCheck(_In_ const HubDescContext *Ctx, _Inout_ Verdict *Result)
Definition: desccheck.cpp:494
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
HubDescCheckMsOsContainerId
BOOLEAN NTAPI HubDescCheckMsOsContainerId(_In_ const HubDescContext *Context, _In_reads_bytes_(Length) const HubMsOsContainerId *Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:2541
Ctx
Walk Ctx
Definition: desccheck.cpp:2269
AssumeSize
static BOOLEAN NTAPI AssumeSize(_In_ const HubDescContext *Ctx, _Inout_ Verdict *Result, _In_ HubDescCode Code, _In_ Gate Kind, _In_ ULONG Size, _In_ ULONG Left, _Inout_ PULONG Advance)
Definition: desccheck.cpp:506
CheckMsOs20Id
static BOOLEAN NTAPI CheckMsOs20Id(_In_ const HubDescContext *Ctx, _In_reads_(8) const UCHAR *Id)
Definition: desccheck.cpp:2839
HubDescCheckMsOsContainerIdHeader
BOOLEAN NTAPI HubDescCheckMsOsContainerIdHeader(_In_ const HubDescContext *Context, _In_reads_bytes_(Length) const HubMsOsHeader *Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:2505
CheckUsb20Cap
static VOID NTAPI CheckUsb20Cap(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1527
IsAllZero
static BOOLEAN NTAPI IsAllZero(_In_reads_bytes_(Length) const VOID *Buffer, _In_ ULONG Length)
Definition: desccheck.cpp:549
BytesLeft
static ULONG NTAPI BytesLeft(_In_ PUCHAR Base, _In_ ULONG BufferLength, _In_ const VOID *Descriptor)
Definition: desccheck.cpp:579
CheckEndpointType
static VOID NTAPI CheckEndpointType(_In_ ConfigWalk *Walk, _In_ PUSB_ENDPOINT_DESCRIPTOR Desc, _Inout_ Verdict *Result)
Definition: desccheck.cpp:813
HubDescCheckString
BOOLEAN NTAPI HubDescCheckString(_In_ const HubDescContext *Context, _In_reads_bytes_(Length) PUSB_STRING_DESCRIPTOR Descriptor, _In_ ULONG Length, _Out_opt_ PULONG AdjustedLength)
Definition: desccheck.cpp:2400
Length
_In_ ULONG Length
Definition: desccheck.cpp:2216
IsSmallPacket
static BOOLEAN NTAPI IsSmallPacket(_In_ ULONG Size)
Definition: desccheck.cpp:569
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)
Definition: desccheck.cpp:3371
FALSE
return FALSE
Definition: desccheck.cpp:3191
CheckMsOs20Subset
static BOOLEAN NTAPI CheckMsOs20Subset(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc, _In_ PUCHAR End, _In_ ULONG Depth)
Definition: desccheck.cpp:2747
HubDescCodeName
PCSTR NTAPI HubDescCodeName(_In_ HubDescCode Code)
Definition: desccheck.cpp:128
Cursor
PUCHAR Cursor
Definition: desccheck.cpp:2228
MsOs20AllowedIn
static BOOLEAN NTAPI MsOs20AllowedIn(_In_ BOOLEAN Function, _In_ ULONG Type)
Definition: desccheck.cpp:2734
DeviceFlags
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN _Inout_opt_ HubLpmInfo _Inout_opt_ PULONG DeviceFlags
Definition: desccheck.cpp:2223
CheckSuperSpeedPlusCap
static VOID NTAPI CheckSuperSpeedPlusCap(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1760
CheckPreviousInterface
static VOID NTAPI CheckPreviousInterface(_Inout_ ConfigWalk *Walk, _Inout_ Verdict *Result)
Definition: desccheck.cpp:712
CheckMsOs20Ccgp
static BOOLEAN NTAPI CheckMsOs20Ccgp(_In_ const HubDescContext *Ctx, _Inout_ HubMsOs20Info *Info, _In_ HubMsOs20Common *Desc)
Definition: desccheck.cpp:3038
Walk
BosWalk Walk
Definition: desccheck.cpp:2225
Valid
BOOLEAN Valid
Definition: desccheck.cpp:2227
BitSet
static VOID NTAPI BitSet(_Inout_updates_(8) PULONG Bits, _In_ UCHAR Index)
Definition: desccheck.cpp:539
HubPlatformFeaturesUuid
static const GUID HubPlatformFeaturesUuid
Definition: desccheck.cpp:45
Lpm
_In_ ULONG _Out_opt_ HubBosInfo _Out_opt_ PUSHORT _Out_opt_ PUSHORT _Inout_opt_ PBOOLEAN _Inout_opt_ HubLpmInfo * Lpm
Definition: desccheck.cpp:2221
CheckEndpoint
static VOID NTAPI CheckEndpoint(_Inout_ ConfigWalk *Walk, _In_ PUSB_ENDPOINT_DESCRIPTOR Desc, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:945
HUB_DESC_NAME
#define HUB_DESC_NAME(Code)
Definition: desccheck.cpp:124
Advance
ULONG Advance
Definition: desccheck.cpp:2231
HUB_MSOS20_TYPE_CONFIG_SUBSET
#define HUB_MSOS20_TYPE_CONFIG_SUBSET
Definition: desccheck.cpp:2637
HubDescCheckMsOsExtConfig
BOOLEAN NTAPI HubDescCheckMsOsExtConfig(_In_ const HubDescContext *Context, _In_reads_bytes_(sizeof(HubMsOsExtConfig)) const HubMsOsExtConfig *Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:2606
IsMsOs10IdValid
static BOOLEAN NTAPI IsMsOs10IdValid(_In_reads_(8) const UCHAR *Id)
Definition: desccheck.cpp:2471
HUB_MSOS20_NEWEST_VERSION
#define HUB_MSOS20_NEWEST_VERSION
Definition: desccheck.cpp:37
CheckPlatformCap
static VOID NTAPI CheckPlatformCap(_Inout_ BosWalk *Walk, _In_ PUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR Cap, _Inout_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:1945
CheckCapability
static VOID NTAPI CheckCapability(_Inout_ BosWalk *Walk, _Inout_ PUSB_DEVICE_CAPABILITY_DESCRIPTOR Cap, _Out_ PULONG Advance, _Inout_ Verdict *Result)
Definition: desccheck.cpp:2091
HubDescCheckBosHeader
BOOLEAN NTAPI HubDescCheckBosHeader(_In_ const HubDescContext *Context, _In_reads_bytes_opt_(Length) PUSB_BOS_DESCRIPTOR Descriptor, _In_ ULONG Length)
Definition: desccheck.cpp:2197
HubMsOs20PlatformUuid
static const GUID HubMsOs20PlatformUuid
Definition: desccheck.cpp:42
Note
static VOID NTAPI Note(_In_ const HubDescContext *Ctx, _Inout_ Verdict *Result, _In_ HubDescCode Code, _In_ Gate Kind)
Definition: desccheck.cpp:463
HUB_MSOS20_COMPATIBLE_ID
#define HUB_MSOS20_COMPATIBLE_ID
Definition: desccheck.h:493
HUB_MSOS20_REGISTRY
#define HUB_MSOS20_REGISTRY
Definition: desccheck.h:494
HUB_BOS_SUPERSPEED_CAPABLE
#define HUB_BOS_SUPERSPEED_CAPABLE
Definition: desccheck.h:316
HUB_MSOS20_CONFIG_SUBSET
#define HUB_MSOS20_CONFIG_SUBSET
Definition: desccheck.h:491
HUB_MSOS20_RESUME_TIME
#define HUB_MSOS20_RESUME_TIME
Definition: desccheck.h:495
HUB_MSOS20_FUNCTION_SUBSET
#define HUB_MSOS20_FUNCTION_SUBSET
Definition: desccheck.h:492
HUB_DESC_BITMAP_ULONGS
#define HUB_DESC_BITMAP_ULONGS
Definition: desccheck.h:263
HubDescCode
HubDescCode
Definition: desccheck.h:15
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
HUB_MSOS20_MODEL_ID
#define HUB_MSOS20_MODEL_ID
Definition: desccheck.h:496
HUB_BOS_ENHANCED_SUPERSPEED_CAPABLE
#define HUB_BOS_ENHANCED_SUPERSPEED_CAPABLE
Definition: desccheck.h:317
HUB_BOS_CHARGING_POLICY
#define HUB_BOS_CHARGING_POLICY
Definition: desccheck.h:318
HUB_MSOS20_SET_HEADER
#define HUB_MSOS20_SET_HEADER
Definition: desccheck.h:489
HUB_MSOS20_CCGP
#define HUB_MSOS20_CCGP
Definition: desccheck.h:497
Entry
PLIST_ENTRY Entry
Definition: devhcd.cpp:1262
Actual
ULONG Actual
Definition: devhcd.cpp:1400
Attributes
_In_ ULONG Attributes
Definition: dispmprt.h:1077
DataLength
_In_ D3DDDI_VIDEO_PRESENT_TARGET_ID _In_ ULONG _In_ ULONG DataLength
Definition: dispmprt.h:233
NULL
#define NULL
Definition: types.h:112
L
#define L(x)
Definition: resources.c:13
_IRQL_requires_
#define _IRQL_requires_(irql)
Definition: driverspecs.h:229
HubDriver
HubDriverState HubDriver
Definition: entry.cpp:13
PASSIVE_LEVEL
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
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
j
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 GLint GLint j
Definition: glfuncs.h:250
Mode
_In_ ULONG Mode
Definition: hubbusif.h:303
HubGlobal::StrictDescriptorChecks
@ StrictDescriptorChecks
HubGlobal::EnableExtendedValidation
@ EnableExtendedValidation
HubGlobal::CheckReservedFields
@ CheckReservedFields
Current
HubUxdSettings Current
Definition: hubregistry.cpp:1463
Present
_In_ PCWSTR _Out_ PULONG _Out_ PBOOLEAN Present
Definition: hubregistry.cpp:127
Chars
ULONG Chars
Definition: hubtunnel.cpp:833
Endpoint
_In_ UCXHUB_DEVICE_CONTEXT _In_ UCXENDPOINT Endpoint
Definition: hubucx.h:238
Total
ULONG Total
Definition: hubwmi.cpp:548
Wanted
_In_ ULONG Wanted
Definition: intr.cpp:782
RtlEqualMemory
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
Context
_In_ PIRP _In_ PIO_COMPLETION_ROUTINE _In_ PVOID Context
Definition: kse.h:81
Bytes
_In_ UINT Bytes
Definition: mmcopy.h:9
Packet
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1549
Number
_In_ ULONG Number
Definition: haltypes.h:1940
_In_reads_bytes_
#define _In_reads_bytes_(s)
Definition: no_sal2.h:170
_In_reads_
#define _In_reads_(s)
Definition: no_sal2.h:168
_Out_opt_
#define _Out_opt_
Definition: no_sal2.h:214
_Inout_updates_
#define _Inout_updates_(s)
Definition: no_sal2.h:182
_Inout_
#define _Inout_
Definition: no_sal2.h:162
_Inout_opt_
#define _Inout_opt_
Definition: no_sal2.h:216
_Out_
#define _Out_
Definition: no_sal2.h:160
_In_
#define _In_
Definition: no_sal2.h:158
_In_opt_
#define _In_opt_
Definition: no_sal2.h:212
_Inout_updates_bytes_
#define _Inout_updates_bytes_(s)
Definition: no_sal2.h:184
_In_reads_bytes_opt_
#define _In_reads_bytes_opt_(s)
Definition: no_sal2.h:224
REG_MULTI_SZ
#define REG_MULTI_SZ
Definition: nt_native.h:1504
RTL_SIZEOF_THROUGH_FIELD
#define RTL_SIZEOF_THROUGH_FIELD(type, field)
Definition: ntbasedef.h:684
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
Set
static BOOL Set
Definition: pageheap.c:10
WCHAR
short WCHAR
Definition: pedump.c:58
LONG
long LONG
Definition: pedump.c:60
USHORT
unsigned short USHORT
Definition: pedump.c:61
NameLength
Input NameLength
Definition: portacpi.cpp:298
Ports
static PS2_PORT Ports[PS2_PORTS]
Definition: ps2.c:52
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
Next
PACPI_METHOD_ARGUMENT Next
Definition: slotdev.cpp:96
Uuid
_In_ const GUID * Uuid
Definition: slotdev.cpp:84
DPRINT
#define DPRINT
Definition: sndvol32.h:73
BosWalk::Base
PUCHAR Base
Definition: desccheck.cpp:78
BosWalk::Ctx
const HubDescContext * Ctx
Definition: desccheck.cpp:77
BosWalk::Ltm
PBOOLEAN Ltm
Definition: desccheck.cpp:83
BosWalk::U1
PUSHORT U1
Definition: desccheck.cpp:81
BosWalk::Lpm
HubLpmInfo * Lpm
Definition: desccheck.cpp:84
BosWalk::Info
HubBosInfo * Info
Definition: desccheck.cpp:80
BosWalk::BufferLength
ULONG BufferLength
Definition: desccheck.cpp:79
BosWalk::U2
PUSHORT U2
Definition: desccheck.cpp:82
ConfigWalk::HadInterface
BOOLEAN HadInterface
Definition: desccheck.cpp:66
ConfigWalk::Ctx
const HubDescContext * Ctx
Definition: desccheck.cpp:51
ConfigWalk::WantSspCompanion
BOOLEAN WantSspCompanion
Definition: desccheck.cpp:69
ConfigWalk::Config
PUSB_CONFIGURATION_DESCRIPTOR Config
Definition: desccheck.cpp:55
ConfigWalk::InterfacesFound
ULONG InterfacesFound
Definition: desccheck.cpp:61
ConfigWalk::GotCompanion
BOOLEAN GotCompanion
Definition: desccheck.cpp:70
ConfigWalk::EndpointsCounted
ULONG EndpointsCounted
Definition: desccheck.cpp:63
ConfigWalk::BufferLength
ULONG BufferLength
Definition: desccheck.cpp:53
ConfigWalk::EndpointSeen
ULONG EndpointSeen[8]
Definition: desccheck.cpp:60
ConfigWalk::End
PUCHAR End
Definition: desccheck.cpp:54
ConfigWalk::Alternate
UCHAR Alternate
Definition: desccheck.cpp:65
ConfigWalk::InterfaceSeen
ULONG InterfaceSeen[8]
Definition: desccheck.cpp:58
ConfigWalk::Interface
UCHAR Interface
Definition: desccheck.cpp:64
ConfigWalk::HadEndpoint
BOOLEAN HadEndpoint
Definition: desccheck.cpp:67
ConfigWalk::Base
PUCHAR Base
Definition: desccheck.cpp:52
ConfigWalk::EndpointsDeclared
ULONG EndpointsDeclared
Definition: desccheck.cpp:62
ConfigWalk::GotSspCompanion
BOOLEAN GotSspCompanion
Definition: desccheck.cpp:71
ConfigWalk::WantCompanion
BOOLEAN WantCompanion
Definition: desccheck.cpp:68
ConfigWalk::LastEndpoint
PUSB_ENDPOINT_DESCRIPTOR LastEndpoint
Definition: desccheck.cpp:57
ConfigWalk::AlternateSeen
ULONG AlternateSeen[8]
Definition: desccheck.cpp:59
ConfigWalk::SupportsStreams
PBOOLEAN SupportsStreams
Definition: desccheck.cpp:56
HubBosInfo::PlatformFeatures
HubPlatformFeatures * PlatformFeatures
Definition: desccheck.h:481
HubBosInfo::ChargingPolicy
BOOLEAN ChargingPolicy
Definition: desccheck.h:484
HubBosInfo::MsOs20SetInfo
HubMsOs20SetInfo * MsOs20SetInfo
Definition: desccheck.h:479
HubBosInfo::DiscardContainerId
BOOLEAN DiscardContainerId
Definition: desccheck.h:483
HubDriverState::HasFlag
BOOLEAN HasFlag(_In_ HubGlobal Flag) const
Definition: hubdriver.h:119
HubMsOs20Common::wLength
USHORT wLength
Definition: desccheck.h:347
HubMsOs20Common::wDescriptorType
USHORT wDescriptorType
Definition: desccheck.h:348
HubMsOs20ModelId::ModelId
UCHAR ModelId[16]
Definition: desccheck.h:398
HubMsOs20Registry::wPropertyDataType
USHORT wPropertyDataType
Definition: desccheck.h:382
HubMsOs20Registry::wPropertyNameLength
USHORT wPropertyNameLength
Definition: desccheck.h:383
HubMsOs20ResumeTime::bResumeSignalingTime
UCHAR bResumeSignalingTime
Definition: desccheck.h:391
HubMsOs20ResumeTime::bResumeRecoveryTime
UCHAR bResumeRecoveryTime
Definition: desccheck.h:390
HubMsOs20SetInfo::dwWindowsVersion
ULONG dwWindowsVersion
Definition: desccheck.h:325
HubMsOs20Subset::wTotalLength
USHORT wTotalLength
Definition: desccheck.h:366
HubMsOs20Subset::wLength
USHORT wLength
Definition: desccheck.h:362
_USB_30_HUB_DESCRIPTOR
Definition: usb300.h:284
_USB_BOS_DESCRIPTOR
Definition: usb300.h:100
_USB_COMMON_DESCRIPTOR
Definition: usb100.h:165
_USB_COMMON_DESCRIPTOR::bLength
UCHAR bLength
Definition: usb100.h:166
_USB_COMMON_DESCRIPTOR::bDescriptorType
UCHAR bDescriptorType
Definition: usb100.h:167
_USB_CONFIGURATION_DESCRIPTOR
Definition: usb100.h:136
_USB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR
Definition: usb300.h:231
_USB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR
Definition: usb300.h:183
_USB_DEVICE_CAPABILITY_DESCRIPTOR
Definition: usb300.h:107
_USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR
Definition: usb300.h:191
_USB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR
Definition: usb300.h:200
_USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR
Definition: usb300.h:157
_USB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR
Definition: usb300.h:133
_USB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR
Definition: usb300.h:113
_USB_DEVICE_DESCRIPTOR
Definition: usb100.h:110
_USB_ENDPOINT_DESCRIPTOR
Definition: usb100.h:127
_USB_HUB_DESCRIPTOR
Definition: usb100.h:170
_USB_INTERFACE_ASSOCIATION_DESCRIPTOR
Definition: usb200.h:120
_USB_INTERFACE_DESCRIPTOR
Definition: usb100.h:147
_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
_USB_STRING_DESCRIPTOR
Definition: usb100.h:159
_USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR
Definition: usb300.h:274
_USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR
Definition: usb300.h:255
Modes
static const VBE_MODE Modes[VBE_MODE_COUNT]
Definition: vbe.c:189
Position
static COORD Position
Definition: mouse.c:34
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
PBOOLEAN
unsigned char * PBOOLEAN
Definition: typedefs.h:53
NTAPI
#define NTAPI
Definition: typedefs.h:36
PUSHORT
uint16_t * PUSHORT
Definition: typedefs.h:56
PCSTR
const char * PCSTR
Definition: typedefs.h:52
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59
Config
_Must_inspect_result_ _In_ WDFDEVICE _In_ PUCX_CONTROLLER_CONFIG Config
Definition: ucxcontroller.h:347
USB_ENDPOINT_TYPE_INTERRUPT
#define USB_ENDPOINT_TYPE_INTERRUPT
Definition: usb100.h:65
USB_CONFIGURATION_DESCRIPTOR_TYPE
#define USB_CONFIGURATION_DESCRIPTOR_TYPE
Definition: usb100.h:50
USB_ENDPOINT_DESCRIPTOR_TYPE
#define USB_ENDPOINT_DESCRIPTOR_TYPE
Definition: usb100.h:53
PUSB_INTERFACE_DESCRIPTOR
struct _USB_INTERFACE_DESCRIPTOR * PUSB_INTERFACE_DESCRIPTOR
USB_ENDPOINT_TYPE_CONTROL
#define USB_ENDPOINT_TYPE_CONTROL
Definition: usb100.h:62
USB_DEVICE_DESCRIPTOR_TYPE
#define USB_DEVICE_DESCRIPTOR_TYPE
Definition: usb100.h:49
USB_STRING_DESCRIPTOR_TYPE
#define USB_STRING_DESCRIPTOR_TYPE
Definition: usb100.h:51
USB_ENDPOINT_TYPE_ISOCHRONOUS
#define USB_ENDPOINT_TYPE_ISOCHRONOUS
Definition: usb100.h:63
PUSB_COMMON_DESCRIPTOR
struct _USB_COMMON_DESCRIPTOR * PUSB_COMMON_DESCRIPTOR
USB_INTERFACE_DESCRIPTOR
struct _USB_INTERFACE_DESCRIPTOR USB_INTERFACE_DESCRIPTOR
USB_ENDPOINT_TYPE_MASK
#define USB_ENDPOINT_TYPE_MASK
Definition: usb100.h:61
USB_INTERFACE_DESCRIPTOR_TYPE
#define USB_INTERFACE_DESCRIPTOR_TYPE
Definition: usb100.h:52
USB_COMMON_DESCRIPTOR
struct _USB_COMMON_DESCRIPTOR USB_COMMON_DESCRIPTOR
USB_ENDPOINT_TYPE_BULK
#define USB_ENDPOINT_TYPE_BULK
Definition: usb100.h:64
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
USB_DEVICE_SPEED
enum _USB_DEVICE_SPEED USB_DEVICE_SPEED
USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE
#define USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE
Definition: usb200.h:118
USB_20_HUB_DESCRIPTOR_TYPE
#define USB_20_HUB_DESCRIPTOR_TYPE
Definition: usb200.h:280
USB_30_HUB_DESCRIPTOR_TYPE
#define USB_30_HUB_DESCRIPTOR_TYPE
Definition: usb200.h:281
USB_DEVICE_CAPABILITY_CONTAINER_ID
#define USB_DEVICE_CAPABILITY_CONTAINER_ID
Definition: usb300.h:28
USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_RESERVED_MASK
#define USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_RESERVED_MASK
Definition: usb300.h:43
USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_SYMMETRIC
#define USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_SYMMETRIC
Definition: usb300.h:57
USB_DEVICE_CAPABILITY_SUPERSPEED_USB
#define USB_DEVICE_CAPABILITY_SUPERSPEED_USB
Definition: usb300.h:27
PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR
struct _USB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR * PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR
USB_BOS_DESCRIPTOR_TYPE
#define USB_BOS_DESCRIPTOR_TYPE
Definition: usb300.h:17
USB_DEVICE_CAPABILITY_SUPERSPEED_U2_DEVICE_EXIT_MAX_VALUE
#define USB_DEVICE_CAPABILITY_SUPERSPEED_U2_DEVICE_EXIT_MAX_VALUE
Definition: usb300.h:49
PUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR
struct _USB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR * PUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR
USB_DEVICE_CAPABILITY_PLATFORM
#define USB_DEVICE_CAPABILITY_PLATFORM
Definition: usb300.h:29
USB_DEVICE_CAPABILITY_BILLBOARD
#define USB_DEVICE_CAPABILITY_BILLBOARD
Definition: usb300.h:36
PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR
struct _USB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR * PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR
PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR
struct _USB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR * PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR
USB_DEVICE_CAPABILITY_SUPERSPEED_U1_DEVICE_EXIT_MAX_VALUE
#define USB_DEVICE_CAPABILITY_SUPERSPEED_U1_DEVICE_EXIT_MAX_VALUE
Definition: usb300.h:48
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
USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB
#define USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB
Definition: usb300.h:34
USB_DEVICE_CAPABILITY_POWER_DELIVERY
#define USB_DEVICE_CAPABILITY_POWER_DELIVERY
Definition: usb300.h:30
USB_DEVICE_CAPABILITY_USB20_EXTENSION_BMATTRIBUTES_RESERVED_MASK
#define USB_DEVICE_CAPABILITY_USB20_EXTENSION_BMATTRIBUTES_RESERVED_MASK
Definition: usb300.h:39
USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_RX
#define USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_RX
Definition: usb300.h:59
USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_RESERVED_MASK
#define USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_RESERVED_MASK
Definition: usb300.h:41
USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE
#define USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE
Definition: usb300.h:18
USB_DEVICE_CAPABILITY_USB20_EXTENSION
#define USB_DEVICE_CAPABILITY_USB20_EXTENSION
Definition: usb300.h:26
PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR
struct _USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR * PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR
USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_TX
#define USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_TX
Definition: usb300.h:60
TotalLength
_In_ ULONG TotalLength
Definition: usbdlib.h:185
Count
USHORT Count
Definition: userreq.cpp:200
Info
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539
Code
_In_ UCHAR _In_ UCHAR _In_ ULONG Code
Definition: wdfdevice.h:1707
BufferLength
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3777
Version
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
Descriptor
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342