[KS]
[reactos.git] / reactos / drivers / ksfilter / ks / connectivity.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/ksfilter/ks/connectivity.c
5 * PURPOSE: KS Pin functions
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9
10 #include "priv.h"
11
12 KSPIN_INTERFACE StandardPinInterface =
13 {
14 {STATIC_KSINTERFACESETID_Standard},
15 KSINTERFACE_STANDARD_STREAMING,
16 0
17 };
18
19 KSPIN_MEDIUM StandardPinMedium =
20 {
21 {STATIC_KSMEDIUMSETID_Standard},
22 KSMEDIUM_TYPE_ANYINSTANCE,
23 0
24 };
25
26 const GUID KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT = {0xf4aeb342, 0x0329, 0x4fdd, {0xa8, 0xfd, 0x4a, 0xff, 0x49, 0x26, 0xc9, 0x78}};
27
28 /*
29 @implemented
30 */
31 KSDDKAPI
32 NTSTATUS
33 NTAPI
34 KsCreatePin(
35 IN HANDLE FilterHandle,
36 IN PKSPIN_CONNECT Connect,
37 IN ACCESS_MASK DesiredAccess,
38 OUT PHANDLE ConnectionHandle)
39 {
40 UINT ConnectSize = sizeof(KSPIN_CONNECT);
41
42 PKSDATAFORMAT_WAVEFORMATEX Format = (PKSDATAFORMAT_WAVEFORMATEX)(Connect + 1);
43 if (Format->DataFormat.FormatSize == sizeof(KSDATAFORMAT) ||
44 Format->DataFormat.FormatSize == sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATEX))
45 {
46 ConnectSize += Format->DataFormat.FormatSize;
47 }
48
49 return KspCreateObjectType(FilterHandle,
50 KSSTRING_Pin,
51 (PVOID)Connect,
52 ConnectSize,
53 DesiredAccess,
54 ConnectionHandle);
55 }
56
57 NTSTATUS
58 KspValidateConnectRequest(
59 IN PIRP Irp,
60 IN ULONG DescriptorsCount,
61 IN PVOID Descriptors,
62 IN ULONG DescriptorSize,
63 OUT PKSPIN_CONNECT* Connect)
64 {
65 PKSPIN_CONNECT ConnectDetails;
66 PKSPIN_INTERFACE Interface;
67 PKSPIN_MEDIUM Medium;
68 ULONG Size;
69 NTSTATUS Status;
70 ULONG Index;
71 ULONG Count;
72 BOOLEAN Found;
73 PKSPIN_DESCRIPTOR Descriptor;
74
75 /* did the caller miss the connect parameter */
76 if (!Connect)
77 return STATUS_INVALID_PARAMETER;
78
79 /* set create param size */
80 Size = sizeof(KSPIN_CONNECT);
81
82 /* fetch create parameters */
83 Status = KspCopyCreateRequest(Irp,
84 KSSTRING_Pin,
85 &Size,
86 (PVOID*)&ConnectDetails);
87
88 /* check for success */
89 if (!NT_SUCCESS(Status))
90 return Status;
91
92 /* is pin id out of bounds */
93 if (ConnectDetails->PinId >= DescriptorsCount)
94 return STATUS_INVALID_PARAMETER;
95
96 if (DescriptorSize == sizeof(KSPIN_DESCRIPTOR))
97 {
98 /* standard pin descriptor */
99 Descriptor = (PKSPIN_DESCRIPTOR)((ULONG_PTR)Descriptors + sizeof(KSPIN_DESCRIPTOR) * ConnectDetails->PinId);
100 }
101 else
102 {
103 /* extended / variable pin descriptor */
104 Descriptor = &((PKSPIN_DESCRIPTOR_EX)((ULONG_PTR)Descriptors + DescriptorSize * ConnectDetails->PinId))->PinDescriptor;
105 }
106
107
108 /* does the pin have interface details filled in */
109 if (Descriptor->InterfacesCount && Descriptor->Interfaces)
110 {
111 /* use provided pin interface count */
112 Count = Descriptor->InterfacesCount;
113 Interface = (PKSPIN_INTERFACE)Descriptor->Interfaces;
114 }
115 else
116 {
117 /* use standard pin interface */
118 Count = 1;
119 Interface = &StandardPinInterface;
120 }
121
122 /* now check the interface */
123 Found = FALSE;
124 Index = 0;
125 do
126 {
127 UNICODE_STRING GuidString, GuidString2;
128 RtlStringFromGUID(&Interface[Index].Set, &GuidString);
129 RtlStringFromGUID(&ConnectDetails->Interface.Set, &GuidString2);
130
131 DPRINT("Driver Interface %S Id %u\n", GuidString.Buffer, Interface[Index].Id);
132 DPRINT("Connect Interface %S Id %u\n", GuidString2.Buffer, ConnectDetails->Interface.Id);
133
134 if (IsEqualGUIDAligned(&Interface[Index].Set, &ConnectDetails->Interface.Set) &&
135 Interface[Index].Id == ConnectDetails->Interface.Id)
136 {
137 /* found a matching interface */
138 Found = TRUE;
139 break;
140 }
141 /* iterate to next interface */
142 Index++;
143 }while(Index < Count);
144
145 if (!Found)
146 {
147 /* pin doesnt support this interface */
148 return STATUS_NO_MATCH;
149 }
150
151 /* does the pin have medium details filled in */
152 if (Descriptor->MediumsCount && Descriptor->Mediums)
153 {
154 /* use provided pin interface count */
155 Count = Descriptor->MediumsCount;
156 Medium = (PKSPIN_MEDIUM)Descriptor->Mediums;
157 }
158 else
159 {
160 /* use standard pin interface */
161 Count = 1;
162 Medium = &StandardPinMedium;
163 }
164
165 /* now check the interface */
166 Found = FALSE;
167 Index = 0;
168 do
169 {
170 UNICODE_STRING GuidString, GuidString2;
171 RtlStringFromGUID(&Medium[Index].Set, &GuidString);
172 RtlStringFromGUID(&ConnectDetails->Medium.Set, &GuidString2);
173
174 DPRINT("Driver Medium %S Id %u\n", GuidString.Buffer, Medium[Index].Id);
175 DPRINT("Connect Medium %S Id %u\n", GuidString2.Buffer, ConnectDetails->Medium.Id);
176
177
178 if (IsEqualGUIDAligned(&Medium[Index].Set, &ConnectDetails->Medium.Set) &&
179 Medium[Index].Id == ConnectDetails->Medium.Id)
180 {
181 /* found a matching interface */
182 Found = TRUE;
183 break;
184 }
185
186
187
188 /* iterate to next medium */
189 Index++;
190 }while(Index < Count);
191
192 if (!Found)
193 {
194 /* pin doesnt support this medium */
195 return STATUS_NO_MATCH;
196 }
197
198 /// FIXME
199 /// implement format checking
200
201 *Connect = ConnectDetails;
202 return STATUS_SUCCESS;
203 }
204
205 /*
206 @implemented
207 */
208 KSDDKAPI
209 NTSTATUS
210 NTAPI
211 KsValidateConnectRequest(
212 IN PIRP Irp,
213 IN ULONG DescriptorsCount,
214 IN KSPIN_DESCRIPTOR* Descriptor,
215 OUT PKSPIN_CONNECT* Connect)
216 {
217 return KspValidateConnectRequest(Irp, DescriptorsCount, Descriptor, sizeof(KSPIN_DESCRIPTOR), Connect);
218 }
219
220 NTSTATUS
221 KspReadMediaCategory(
222 IN LPGUID Category,
223 PKEY_VALUE_PARTIAL_INFORMATION *OutInformation)
224 {
225 UNICODE_STRING MediaPath = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\MediaCategories\\");
226 UNICODE_STRING Name = RTL_CONSTANT_STRING(L"Name");
227 UNICODE_STRING GuidString, Path;
228 NTSTATUS Status;
229 OBJECT_ATTRIBUTES ObjectAttributes;
230 HANDLE hKey;
231 ULONG Size;
232 PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
233
234 /* convert the guid to string */
235 Status = RtlStringFromGUID(Category, &GuidString);
236 if (!NT_SUCCESS(Status))
237 return Status;
238
239 /* allocate buffer for the registry key */
240 Path.Length = 0;
241 Path.MaximumLength = MediaPath.MaximumLength + GuidString.MaximumLength;
242 Path.Buffer = ExAllocatePool(NonPagedPool, Path.MaximumLength);
243 if (!Path.Buffer)
244 {
245 /* not enough memory */
246 RtlFreeUnicodeString(&GuidString);
247 return STATUS_INSUFFICIENT_RESOURCES;
248 }
249
250 RtlAppendUnicodeStringToString(&Path, &MediaPath);
251 RtlAppendUnicodeStringToString(&Path, &GuidString);
252
253 /* free guid string */
254 RtlFreeUnicodeString(&GuidString);
255
256 /* initialize object attributes */
257 InitializeObjectAttributes(&ObjectAttributes, &Path, OBJ_CASE_INSENSITIVE, NULL, NULL);
258
259 /* open the key */
260 Status = ZwOpenKey(&hKey, GENERIC_READ, &ObjectAttributes);
261
262 DPRINT("ZwOpenKey() status 0x%08lx %S\n", Status, Path.Buffer);
263
264 /* free path buffer */
265 ExFreePool(Path.Buffer);
266
267 /* check for success */
268 if (!NT_SUCCESS(Status))
269 {
270 DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
271 return Status;
272 }
273
274 /* query the name size */
275 Status = ZwQueryValueKey(hKey, &Name, KeyValuePartialInformation, NULL, 0, &Size);
276 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
277 {
278 /* failed to query for name key */
279 ZwClose(hKey);
280 return Status;
281 }
282
283 /* allocate buffer to read key info */
284 KeyInfo = (PKEY_VALUE_PARTIAL_INFORMATION) ExAllocatePool(NonPagedPool, Size);
285 if (!KeyInfo)
286 {
287 /* not enough memory */
288 ZwClose(hKey);
289 return STATUS_INSUFFICIENT_RESOURCES;
290 }
291
292 /* now read the info */
293 Status = ZwQueryValueKey(hKey, &Name, KeyValuePartialInformation, (PVOID)KeyInfo, Size, &Size);
294
295 /* close the key */
296 ZwClose(hKey);
297
298 if (!NT_SUCCESS(Status))
299 {
300 /* failed to read key */
301 ExFreePool(KeyInfo);
302 return Status;
303 }
304
305 /* store key information */
306 *OutInformation = KeyInfo;
307 return Status;
308 }
309
310 KSDDKAPI
311 NTSTATUS
312 NTAPI
313 KspPinPropertyHandler(
314 IN PIRP Irp,
315 IN PKSPROPERTY Property,
316 IN OUT PVOID Data,
317 IN ULONG DescriptorsCount,
318 IN const KSPIN_DESCRIPTOR* Descriptors,
319 IN ULONG DescriptorSize)
320 {
321 KSP_PIN * Pin;
322 KSMULTIPLE_ITEM * Item;
323 PIO_STACK_LOCATION IoStack;
324 ULONG Size, Index;
325 PVOID Buffer;
326 PKSDATARANGE_AUDIO *WaveFormatOut;
327 PKSDATAFORMAT_WAVEFORMATEX WaveFormatIn;
328 PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
329 const KSPIN_DESCRIPTOR *Descriptor;
330 NTSTATUS Status = STATUS_NOT_SUPPORTED;
331 ULONG Count;
332 const PKSDATARANGE* DataRanges;
333
334 IoStack = IoGetCurrentIrpStackLocation(Irp);
335 Buffer = Irp->UserBuffer;
336
337 //DPRINT("KsPinPropertyHandler Irp %p Property %p Data %p DescriptorsCount %u Descriptor %p OutputLength %u Id %u\n", Irp, Property, Data, DescriptorsCount, Descriptor, IoStack->Parameters.DeviceIoControl.OutputBufferLength, Property->Id);
338
339 /* convert to PKSP_PIN */
340 Pin = (KSP_PIN*)Property;
341
342 if (Property->Id != KSPROPERTY_PIN_CTYPES)
343 {
344 if (Pin->PinId >= DescriptorsCount)
345 {
346 /* invalid parameter */
347 return STATUS_INVALID_PARAMETER;
348 }
349 }
350
351 if (DescriptorSize == sizeof(KSPIN_DESCRIPTOR))
352 {
353 /* it is simple pin descriptor */
354 Descriptor = &Descriptors[Pin->PinId];
355 }
356 else
357 {
358 /* get offset to pin descriptor */
359 Descriptor = &(((PKSPIN_DESCRIPTOR_EX)((ULONG_PTR)Descriptors + Pin->PinId * DescriptorSize))->PinDescriptor);
360 }
361
362 switch(Property->Id)
363 {
364 case KSPROPERTY_PIN_CTYPES:
365 (*(PULONG)Buffer) = DescriptorsCount;
366 Irp->IoStatus.Information = sizeof(ULONG);
367 Status = STATUS_SUCCESS;
368 break;
369 case KSPROPERTY_PIN_DATAFLOW:
370
371 Size = sizeof(KSPIN_DATAFLOW);
372 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
373 {
374 Irp->IoStatus.Information = Size;
375 Status = STATUS_BUFFER_TOO_SMALL;
376 break;
377 }
378
379 *((KSPIN_DATAFLOW*)Buffer) = Descriptor->DataFlow;
380 Irp->IoStatus.Information = sizeof(KSPIN_DATAFLOW);
381 Status = STATUS_SUCCESS;
382 break;
383
384 case KSPROPERTY_PIN_DATARANGES:
385 case KSPROPERTY_PIN_CONSTRAINEDDATARANGES:
386
387 Size = sizeof(KSMULTIPLE_ITEM);
388 DPRINT("Id %lu PinId %lu DataRangesCount %lu ConstrainedDataRangesCount %lu\n", Property->Id, Pin->PinId, Descriptor->DataRangesCount, Descriptor->ConstrainedDataRangesCount);
389
390 if (Property->Id == KSPROPERTY_PIN_DATARANGES || Descriptor->ConstrainedDataRangesCount == 0)
391 {
392 DataRanges = Descriptor->DataRanges;
393 Count = Descriptor->DataRangesCount;
394 }
395 else
396 {
397 DataRanges = Descriptor->ConstrainedDataRanges;
398 Count = Descriptor->ConstrainedDataRangesCount;
399 }
400
401 for (Index = 0; Index < Count; Index++)
402 {
403 Size += ((DataRanges[Index]->FormatSize + 0x7) & ~0x7);
404 }
405
406 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == 0)
407 {
408 /* buffer too small */
409 Irp->IoStatus.Information = Size;
410 Status = STATUS_BUFFER_OVERFLOW;
411 break;
412 }
413
414 Item = (KSMULTIPLE_ITEM*)Buffer;
415
416 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(ULONG))
417 {
418 /* store the result size */
419 Item->Size = Size;
420 Irp->IoStatus.Information = sizeof(ULONG);
421 Status = STATUS_SUCCESS;
422 break;
423 }
424
425 /* store descriptor size */
426 Item->Size = Size;
427 Item->Count = Count;
428
429 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(KSMULTIPLE_ITEM))
430 {
431 Irp->IoStatus.Information = sizeof(KSMULTIPLE_ITEM);
432 Status = STATUS_SUCCESS;
433 break;
434 }
435
436 /* now copy all dataranges */
437 Data = (PUCHAR)(Item +1);
438
439 /* alignment assert */
440 ASSERT(((ULONG_PTR)Data & 0x7) == 0);
441
442 for (Index = 0; Index < Count; Index++)
443 {
444 UNICODE_STRING GuidString;
445 /* convert the guid to string */
446 RtlStringFromGUID(&DataRanges[Index]->MajorFormat, &GuidString);
447 DPRINT("Index %lu MajorFormat %S\n", Index, GuidString.Buffer);
448 RtlStringFromGUID(&DataRanges[Index]->SubFormat, &GuidString);
449 DPRINT("Index %lu SubFormat %S\n", Index, GuidString.Buffer);
450 RtlStringFromGUID(&DataRanges[Index]->Specifier, &GuidString);
451 DPRINT("Index %lu Specifier %S\n", Index, GuidString.Buffer);
452 RtlStringFromGUID(&DataRanges[Index]->Specifier, &GuidString);
453 DPRINT("Index %lu FormatSize %lu Flags %lu SampleSize %lu Reserved %lu KSDATAFORMAT %lu\n", Index,
454 DataRanges[Index]->FormatSize, DataRanges[Index]->Flags, DataRanges[Index]->SampleSize, DataRanges[Index]->Reserved, sizeof(KSDATAFORMAT));
455
456 RtlMoveMemory(Data, DataRanges[Index], DataRanges[Index]->FormatSize);
457 Data = ((PUCHAR)Data + DataRanges[Index]->FormatSize);
458 /* alignment assert */
459 ASSERT(((ULONG_PTR)Data & 0x7) == 0);
460 Data = (PVOID)(((ULONG_PTR)Data + 0x7) & ~0x7);
461 }
462
463 Status = STATUS_SUCCESS;
464 Irp->IoStatus.Information = Size;
465 break;
466 case KSPROPERTY_PIN_INTERFACES:
467
468 if (Descriptor->Interfaces)
469 {
470 /* use mediums provided by driver */
471 return KsHandleSizedListQuery(Irp, Descriptor->InterfacesCount, sizeof(KSPIN_MEDIUM), Descriptor->Interfaces);
472 }
473 else
474 {
475 /* use standard medium */
476 return KsHandleSizedListQuery(Irp, 1, sizeof(KSPIN_INTERFACE), &StandardPinInterface);
477 }
478 break;
479
480 case KSPROPERTY_PIN_MEDIUMS:
481
482 if (Descriptor->MediumsCount)
483 {
484 /* use mediums provided by driver */
485 return KsHandleSizedListQuery(Irp, Descriptor->MediumsCount, sizeof(KSPIN_MEDIUM), Descriptor->Mediums);
486 }
487 else
488 {
489 /* use standard medium */
490 return KsHandleSizedListQuery(Irp, 1, sizeof(KSPIN_MEDIUM), &StandardPinMedium);
491 }
492 break;
493
494 case KSPROPERTY_PIN_COMMUNICATION:
495
496 Size = sizeof(KSPIN_COMMUNICATION);
497 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
498 {
499 Irp->IoStatus.Information = Size;
500 Status = STATUS_BUFFER_TOO_SMALL;
501 break;
502 }
503
504 *((KSPIN_COMMUNICATION*)Buffer) = Descriptor->Communication;
505
506 Status = STATUS_SUCCESS;
507 Irp->IoStatus.Information = Size;
508 break;
509
510 case KSPROPERTY_PIN_CATEGORY:
511
512 Size = sizeof(GUID);
513 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
514 {
515 Irp->IoStatus.Information = Size;
516 Status = STATUS_BUFFER_TOO_SMALL;
517 break;
518 }
519 if (Descriptor->Category)
520 {
521 RtlMoveMemory(Buffer, Descriptor->Category, sizeof(GUID));
522 }
523
524 Status = STATUS_SUCCESS;
525 Irp->IoStatus.Information = Size;
526 break;
527
528 case KSPROPERTY_PIN_NAME:
529 if (!Descriptor->Name)
530 {
531 Irp->IoStatus.Information = 0;
532 Status = STATUS_SUCCESS;
533 break;
534 }
535
536 Status = KspReadMediaCategory((LPGUID)Descriptor->Name, &KeyInfo);
537 if (!NT_SUCCESS(Status))
538 {
539 Irp->IoStatus.Information = 0;
540 break;
541 }
542
543 Irp->IoStatus.Information = KeyInfo->DataLength + sizeof(WCHAR);
544
545 if (KeyInfo->DataLength + sizeof(WCHAR) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
546 {
547 Status = STATUS_BUFFER_OVERFLOW;
548 ExFreePool(KeyInfo);
549 break;
550 }
551
552 RtlMoveMemory(Irp->UserBuffer, &KeyInfo->Data, KeyInfo->DataLength);
553 ((LPWSTR)Irp->UserBuffer)[KeyInfo->DataLength / sizeof(WCHAR)] = L'\0';
554 ExFreePool(KeyInfo);
555 break;
556 case KSPROPERTY_PIN_PROPOSEDATAFORMAT:
557 Size = sizeof(KSDATAFORMAT);
558 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
559 {
560 Irp->IoStatus.Information = Size;
561 Status = STATUS_BUFFER_TOO_SMALL;
562 break;
563 }
564 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength != sizeof(KSDATAFORMAT_WAVEFORMATEX))
565 {
566 UNIMPLEMENTED
567 Status = STATUS_NOT_IMPLEMENTED;
568 Irp->IoStatus.Information = 0;
569 break;
570 }
571
572 WaveFormatIn = (PKSDATAFORMAT_WAVEFORMATEX)Buffer;
573 if (!Descriptor->DataRanges || !Descriptor->DataRangesCount)
574 {
575 Status = STATUS_UNSUCCESSFUL;
576 Irp->IoStatus.Information = 0;
577 break;
578 }
579 WaveFormatOut = (PKSDATARANGE_AUDIO*)Descriptor->DataRanges;
580 for(Index = 0; Index < Descriptor->DataRangesCount; Index++)
581 {
582 if (WaveFormatOut[Index]->DataRange.FormatSize != sizeof(KSDATARANGE_AUDIO))
583 {
584 UNIMPLEMENTED
585 continue;
586 }
587
588 if (WaveFormatOut[Index]->MinimumSampleFrequency > WaveFormatIn->WaveFormatEx.nSamplesPerSec ||
589 WaveFormatOut[Index]->MaximumSampleFrequency < WaveFormatIn->WaveFormatEx.nSamplesPerSec ||
590 WaveFormatOut[Index]->MinimumBitsPerSample > WaveFormatIn->WaveFormatEx.wBitsPerSample ||
591 WaveFormatOut[Index]->MaximumBitsPerSample < WaveFormatIn->WaveFormatEx.wBitsPerSample ||
592 WaveFormatOut[Index]->MaximumChannels < WaveFormatIn->WaveFormatEx.nChannels)
593 {
594 Irp->IoStatus.Status = STATUS_NO_MATCH;
595 Irp->IoStatus.Information = 0;
596 return STATUS_NO_MATCH;
597 }
598 else
599 {
600 Irp->IoStatus.Status = STATUS_SUCCESS;
601 Irp->IoStatus.Information = 0;
602 return STATUS_SUCCESS;
603 }
604 }
605 Status = STATUS_NO_MATCH;
606 Irp->IoStatus.Information = 0;
607 break;
608 default:
609 DPRINT1("Unhandled property request %x\n", Property->Id);
610 Status = STATUS_NOT_IMPLEMENTED;
611 Irp->IoStatus.Information = 0;
612 }
613
614 return Status;
615 }
616
617 /*
618 @implemented
619 */
620 KSDDKAPI
621 NTSTATUS
622 NTAPI
623 KsPinPropertyHandler(
624 IN PIRP Irp,
625 IN PKSPROPERTY Property,
626 IN OUT PVOID Data,
627 IN ULONG DescriptorsCount,
628 IN const KSPIN_DESCRIPTOR* Descriptor)
629 {
630 return KspPinPropertyHandler(Irp, Property, Data, DescriptorsCount, Descriptor, sizeof(KSPIN_DESCRIPTOR));
631 }
632
633 /*
634 @unimplemented
635 */
636 KSDDKAPI NTSTATUS NTAPI
637 KsPinDataIntersectionEx(
638 IN PIRP Irp,
639 IN PKSP_PIN Pin,
640 OUT PVOID Data,
641 IN ULONG DescriptorsCount,
642 IN const KSPIN_DESCRIPTOR* Descriptor,
643 IN ULONG DescriptorSize,
644 IN PFNKSINTERSECTHANDLEREX IntersectHandler OPTIONAL,
645 IN PVOID HandlerContext OPTIONAL)
646 {
647 UNIMPLEMENTED;
648 return STATUS_UNSUCCESSFUL;
649 }
650
651 /*
652 @implemented
653 */
654 KSDDKAPI
655 NTSTATUS
656 NTAPI
657 KsPinDataIntersection(
658 IN PIRP Irp,
659 IN PKSP_PIN Pin,
660 OUT PVOID Data,
661 IN ULONG DescriptorsCount,
662 IN const KSPIN_DESCRIPTOR* Descriptor,
663 IN PFNKSINTERSECTHANDLER IntersectHandler)
664 {
665 KSMULTIPLE_ITEM * Item;
666 KSDATARANGE * DataRange;
667 PIO_STACK_LOCATION IoStack;
668 ULONG Size;
669 ULONG Index;
670 NTSTATUS Status;
671
672 /* get current irp stack location */
673 IoStack = IoGetCurrentIrpStackLocation(Irp);
674
675 /* calculate minimum data size */
676 Size = sizeof(KSP_PIN) + sizeof(KSMULTIPLE_ITEM) + sizeof(KSDATARANGE);
677 if (IoStack->Parameters.DeviceIoControl.InputBufferLength < Size)
678 {
679 /* buffer too small */
680 Irp->IoStatus.Information = Size;
681 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
682 return STATUS_BUFFER_TOO_SMALL;
683 }
684 /* is pin id out of bounds */
685 if (Pin->PinId >= DescriptorsCount)
686 {
687 /* it is */
688 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
689 Irp->IoStatus.Information = 0;
690 return STATUS_INVALID_PARAMETER;
691 }
692
693 /* get start item */
694 Item = (KSMULTIPLE_ITEM*)(Pin + 1);
695 /* get first data range */
696 DataRange = (KSDATARANGE*)(Item + 1);
697 /* iterate through all data ranges */
698 for(Index = 0; Index < Item->Count; Index++, DataRange++)
699 {
700 /* call intersect handler */
701 Status = IntersectHandler(Irp, Pin, DataRange, Data);
702 if (NT_SUCCESS(Status))
703 {
704 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < DataRange->FormatSize)
705 {
706 /* buffer is too small */
707 Irp->IoStatus.Information = DataRange->FormatSize;
708 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
709 return STATUS_BUFFER_TOO_SMALL;
710 }
711 RtlMoveMemory(Irp->UserBuffer, DataRange, sizeof(KSDATARANGE));
712 Irp->IoStatus.Information = sizeof(KSDATARANGE);
713 Irp->IoStatus.Status = STATUS_SUCCESS;
714 return STATUS_SUCCESS;
715 }
716
717 }
718
719 Irp->IoStatus.Information = 0;
720 Irp->IoStatus.Status = STATUS_NO_MATCH;
721 return STATUS_NO_MATCH;
722 }
723
724 /*
725 @implemented
726 */
727
728 KSDDKAPI
729 NTSTATUS
730 NTAPI
731 KsHandleSizedListQuery(
732 IN PIRP Irp,
733 IN ULONG DataItemsCount,
734 IN ULONG DataItemSize,
735 IN const VOID* DataItems)
736 {
737 ULONG Size;
738 PIO_STACK_LOCATION IoStack;
739 PKSMULTIPLE_ITEM Item;
740
741 /* get current irp stack location */
742 IoStack = IoGetCurrentIrpStackLocation(Irp);
743
744 /* calculate size */
745 Size = DataItemSize * DataItemsCount + sizeof(KSMULTIPLE_ITEM);
746
747 /* get multiple item */
748 Item = (PKSMULTIPLE_ITEM)Irp->UserBuffer;
749
750 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == 0)
751 {
752 /* buffer too small */
753 Irp->IoStatus.Information = Size;
754
755 return STATUS_BUFFER_OVERFLOW;
756 }
757
758 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(ULONG))
759 {
760 /* store just the size */
761 Item->Size = Size;
762 Irp->IoStatus.Information = sizeof(ULONG);
763
764 return STATUS_SUCCESS;
765 }
766
767
768 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(KSMULTIPLE_ITEM))
769 {
770 /* buffer too small */
771 return STATUS_BUFFER_TOO_SMALL;
772 }
773
774 Item->Count = DataItemsCount;
775 Item->Size = DataItemSize;
776
777 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(KSMULTIPLE_ITEM))
778 {
779 /* buffer can only hold the length descriptor */
780 Irp->IoStatus.Information = sizeof(KSMULTIPLE_ITEM);
781 return STATUS_SUCCESS;
782 }
783
784 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength >= Size)
785 {
786 /* copy items */
787 RtlMoveMemory((PVOID)(Item + 1), DataItems, DataItemSize * DataItemsCount);
788 /* store result */
789 Irp->IoStatus.Information = Size;
790 /* done */
791 return STATUS_SUCCESS;
792 }
793 else
794 {
795 /* buffer too small */
796 return STATUS_BUFFER_TOO_SMALL;
797 }
798 }
799