Synchronize with trunk revision 59636 (just before Alex's CreateProcess revamp).
[reactos.git] / drivers / ksfilter / ks / irp.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/ksfilter/ks/factory.c
5 * PURPOSE: KS Allocator functions
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9
10 #include "priv.h"
11
12 /*
13 @implemented
14 */
15 KSDDKAPI
16 NTSTATUS
17 NTAPI
18 KsDispatchQuerySecurity(
19 IN PDEVICE_OBJECT DeviceObject,
20 IN PIRP Irp)
21 {
22 PKSOBJECT_CREATE_ITEM CreateItem;
23 PIO_STACK_LOCATION IoStack;
24 NTSTATUS Status;
25 ULONG Length;
26
27 /* get current irp stack */
28 IoStack = IoGetCurrentIrpStackLocation(Irp);
29
30 /* get create item */
31 CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
32
33 if (!CreateItem || !CreateItem->SecurityDescriptor)
34 {
35 /* no create item */
36 Irp->IoStatus.Status = STATUS_NO_SECURITY_ON_OBJECT;
37 CompleteRequest(Irp, IO_NO_INCREMENT);
38 return STATUS_NO_SECURITY_ON_OBJECT;
39 }
40
41
42 /* get input length */
43 Length = IoStack->Parameters.QuerySecurity.Length;
44
45 /* clone the security descriptor */
46 Status = SeQuerySecurityDescriptorInfo(&IoStack->Parameters.QuerySecurity.SecurityInformation, (PSECURITY_DESCRIPTOR)Irp->UserBuffer, &Length, &CreateItem->SecurityDescriptor);
47
48 DPRINT("SeQuerySecurityDescriptorInfo Status %x\n", Status);
49 /* store result */
50 Irp->IoStatus.Status = Status;
51 Irp->IoStatus.Information = Length;
52
53 CompleteRequest(Irp, IO_NO_INCREMENT);
54 return Status;
55 }
56
57 /*
58 @implemented
59 */
60 KSDDKAPI
61 NTSTATUS
62 NTAPI
63 KsDispatchSetSecurity(
64 IN PDEVICE_OBJECT DeviceObject,
65 IN PIRP Irp)
66 {
67 PKSOBJECT_CREATE_ITEM CreateItem;
68 PIO_STACK_LOCATION IoStack;
69 PGENERIC_MAPPING Mapping;
70 PSECURITY_DESCRIPTOR Descriptor;
71 NTSTATUS Status;
72
73 /* get current irp stack */
74 IoStack = IoGetCurrentIrpStackLocation(Irp);
75
76 /* get create item */
77 CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
78
79 if (!CreateItem || !CreateItem->SecurityDescriptor)
80 {
81 /* no create item */
82 Irp->IoStatus.Status = STATUS_NO_SECURITY_ON_OBJECT;
83 CompleteRequest(Irp, IO_NO_INCREMENT);
84 return STATUS_NO_SECURITY_ON_OBJECT;
85 }
86
87 /* backup old descriptor */
88 Descriptor = CreateItem->SecurityDescriptor;
89
90 /* get generic mapping */
91 Mapping = IoGetFileObjectGenericMapping();
92
93 /* change security descriptor */
94 Status = SeSetSecurityDescriptorInfo(NULL, /*FIXME */
95 &IoStack->Parameters.SetSecurity.SecurityInformation,
96 IoStack->Parameters.SetSecurity.SecurityDescriptor,
97 &CreateItem->SecurityDescriptor,
98 NonPagedPool,
99 Mapping);
100
101 if (NT_SUCCESS(Status))
102 {
103 /* free old descriptor */
104 FreeItem(Descriptor);
105
106 /* mark create item as changed */
107 CreateItem->Flags |= KSCREATE_ITEM_SECURITYCHANGED;
108 }
109
110 /* store result */
111 Irp->IoStatus.Status = Status;
112 CompleteRequest(Irp, IO_NO_INCREMENT);
113
114 return Status;
115 }
116
117 /*
118 @unimplemented
119 */
120 KSDDKAPI
121 NTSTATUS
122 NTAPI
123 KsDispatchSpecificMethod(
124 IN PIRP Irp,
125 IN PFNKSHANDLER Handler)
126 {
127 UNIMPLEMENTED;
128 return STATUS_UNSUCCESSFUL;
129 }
130
131
132 /*
133 @implemented
134 */
135 KSDDKAPI
136 NTSTATUS
137 NTAPI
138 KsReadFile(
139 IN PFILE_OBJECT FileObject,
140 IN PKEVENT Event OPTIONAL,
141 IN PVOID PortContext OPTIONAL,
142 OUT PIO_STATUS_BLOCK IoStatusBlock,
143 OUT PVOID Buffer,
144 IN ULONG Length,
145 IN ULONG Key OPTIONAL,
146 IN KPROCESSOR_MODE RequestorMode)
147 {
148 PDEVICE_OBJECT DeviceObject;
149 PIRP Irp;
150 NTSTATUS Status;
151 BOOLEAN Result;
152 KEVENT LocalEvent;
153
154 if (Event)
155 {
156 /* make sure event is reset */
157 KeClearEvent(Event);
158 }
159
160 if (RequestorMode == UserMode)
161 {
162 /* probe the user buffer */
163 _SEH2_TRY
164 {
165 ProbeForWrite(Buffer, Length, sizeof(UCHAR));
166 Status = STATUS_SUCCESS;
167 }
168 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
169 {
170 /* Exception, get the error code */
171 Status = _SEH2_GetExceptionCode();
172 }
173 _SEH2_END;
174
175 if (!NT_SUCCESS(Status))
176 {
177 DPRINT1("Invalid user buffer provided\n");
178 return Status;
179 }
180 }
181
182 /* get corresponding device object */
183 DeviceObject = IoGetRelatedDeviceObject(FileObject);
184
185 /* fast-io read is only available for kernel mode clients */
186 if (RequestorMode == KernelMode && ExGetPreviousMode() == KernelMode &&
187 DeviceObject->DriverObject->FastIoDispatch->FastIoRead)
188 {
189 /* call fast io write */
190 Result = DeviceObject->DriverObject->FastIoDispatch->FastIoRead(FileObject, &FileObject->CurrentByteOffset, Length, TRUE, Key, Buffer, IoStatusBlock, DeviceObject);
191
192 if (Result && NT_SUCCESS(IoStatusBlock->Status))
193 {
194 /* request was handeled and succeeded */
195 return STATUS_SUCCESS;
196 }
197 }
198
199 /* do the slow way */
200 if (!Event)
201 {
202 /* initialize temp event */
203 KeInitializeEvent(&LocalEvent, NotificationEvent, FALSE);
204 Event = &LocalEvent;
205 }
206
207 /* build the irp packet */
208 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ, DeviceObject, Buffer, Length, &FileObject->CurrentByteOffset, Event, IoStatusBlock);
209 if (!Irp)
210 {
211 /* not enough resources */
212 return STATUS_INSUFFICIENT_RESOURCES;
213 }
214
215 /* send the packet */
216 Status = IoCallDriver(DeviceObject, Irp);
217
218 if (Status == STATUS_PENDING)
219 {
220 /* operation is pending, is sync file object */
221 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
222 {
223 /* it is so wait */
224 KeWaitForSingleObject(Event, Executive, RequestorMode, FALSE, NULL);
225 Status = IoStatusBlock->Status;
226 }
227 }
228 /* return result */
229 return Status;
230 }
231
232 /*
233 @implemented
234 */
235 KSDDKAPI
236 NTSTATUS
237 NTAPI
238 KsWriteFile(
239 IN PFILE_OBJECT FileObject,
240 IN PKEVENT Event OPTIONAL,
241 IN PVOID PortContext OPTIONAL,
242 OUT PIO_STATUS_BLOCK IoStatusBlock,
243 IN PVOID Buffer,
244 IN ULONG Length,
245 IN ULONG Key OPTIONAL,
246 IN KPROCESSOR_MODE RequestorMode)
247 {
248 PDEVICE_OBJECT DeviceObject;
249 PIRP Irp;
250 NTSTATUS Status;
251 BOOLEAN Result;
252 KEVENT LocalEvent;
253
254 if (Event)
255 {
256 /* make sure event is reset */
257 KeClearEvent(Event);
258 }
259
260 if (RequestorMode == UserMode)
261 {
262 /* probe the user buffer */
263 _SEH2_TRY
264 {
265 ProbeForRead(Buffer, Length, sizeof(UCHAR));
266 Status = STATUS_SUCCESS;
267 }
268 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
269 {
270 /* Exception, get the error code */
271 Status = _SEH2_GetExceptionCode();
272 }
273 _SEH2_END;
274
275 if (!NT_SUCCESS(Status))
276 {
277 DPRINT1("Invalid user buffer provided\n");
278 return Status;
279 }
280 }
281
282 /* get corresponding device object */
283 DeviceObject = IoGetRelatedDeviceObject(FileObject);
284
285 /* fast-io write is only available for kernel mode clients */
286 if (RequestorMode == KernelMode && ExGetPreviousMode() == KernelMode &&
287 DeviceObject->DriverObject->FastIoDispatch->FastIoWrite)
288 {
289 /* call fast io write */
290 Result = DeviceObject->DriverObject->FastIoDispatch->FastIoWrite(FileObject, &FileObject->CurrentByteOffset, Length, TRUE, Key, Buffer, IoStatusBlock, DeviceObject);
291
292 if (Result && NT_SUCCESS(IoStatusBlock->Status))
293 {
294 /* request was handeled and succeeded */
295 return STATUS_SUCCESS;
296 }
297 }
298
299 /* do the slow way */
300 if (!Event)
301 {
302 /* initialize temp event */
303 KeInitializeEvent(&LocalEvent, NotificationEvent, FALSE);
304 Event = &LocalEvent;
305 }
306
307 /* build the irp packet */
308 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, DeviceObject, Buffer, Length, &FileObject->CurrentByteOffset, Event, IoStatusBlock);
309 if (!Irp)
310 {
311 /* not enough resources */
312 return STATUS_INSUFFICIENT_RESOURCES;
313 }
314
315 /* send the packet */
316 Status = IoCallDriver(DeviceObject, Irp);
317
318 if (Status == STATUS_PENDING)
319 {
320 /* operation is pending, is sync file object */
321 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
322 {
323 /* it is so wait */
324 KeWaitForSingleObject(Event, Executive, RequestorMode, FALSE, NULL);
325 Status = IoStatusBlock->Status;
326 }
327 }
328 /* return result */
329 return Status;
330 }
331
332 /*
333 @implemented
334 */
335 KSDDKAPI
336 NTSTATUS
337 NTAPI
338 KsQueryInformationFile(
339 IN PFILE_OBJECT FileObject,
340 OUT PVOID FileInformation,
341 IN ULONG Length,
342 IN FILE_INFORMATION_CLASS FileInformationClass)
343 {
344 PDEVICE_OBJECT DeviceObject;
345 PFAST_IO_DISPATCH FastIoDispatch;
346 PIRP Irp;
347 PIO_STACK_LOCATION IoStack;
348 IO_STATUS_BLOCK IoStatus;
349 KEVENT Event;
350 LARGE_INTEGER Offset;
351 IO_STATUS_BLOCK StatusBlock;
352 NTSTATUS Status;
353
354 /* get related file object */
355 DeviceObject = IoGetRelatedDeviceObject(FileObject);
356
357 /* get fast i/o table */
358 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch;
359
360 /* is there a fast table */
361 if (FastIoDispatch)
362 {
363 /* check the class */
364 if (FileInformationClass == FileBasicInformation)
365 {
366 /* use FastIoQueryBasicInfo routine */
367 if (FastIoDispatch->FastIoQueryBasicInfo)
368 {
369 return FastIoDispatch->FastIoQueryBasicInfo(FileObject, TRUE, (PFILE_BASIC_INFORMATION)FileInformation, &IoStatus, DeviceObject);
370 }
371 }
372 else if (FileInformationClass == FileStandardInformation)
373 {
374 /* use FastIoQueryBasicInfo routine */
375 if (FastIoDispatch->FastIoQueryBasicInfo)
376 {
377 return FastIoDispatch->FastIoQueryStandardInfo(FileObject, TRUE, (PFILE_STANDARD_INFORMATION)FileInformation, &IoStatus, DeviceObject);
378 }
379 }
380 }
381 /* clear event */
382 KeClearEvent(&FileObject->Event);
383
384 /* initialize event */
385 KeInitializeEvent(&Event, NotificationEvent, FALSE);
386
387 /* set offset to zero */
388 Offset.QuadPart = 0L;
389
390 /* build the request */
391 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_QUERY_INFORMATION, IoGetRelatedDeviceObject(FileObject), NULL, 0, &Offset, &Event, &StatusBlock);
392
393 if (!Irp)
394 return STATUS_INSUFFICIENT_RESOURCES;
395
396 /* get next stack location */
397 IoStack = IoGetNextIrpStackLocation(Irp);
398
399 /* setup parameters */
400 IoStack->Parameters.QueryFile.FileInformationClass = FileInformationClass;
401 IoStack->Parameters.QueryFile.Length = Length;
402 Irp->AssociatedIrp.SystemBuffer = FileInformation;
403
404
405 /* call the driver */
406 Status = IoCallDriver(IoGetRelatedDeviceObject(FileObject), Irp);
407
408 if (Status == STATUS_PENDING)
409 {
410 /* wait for the operation to complete */
411 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
412
413 /* is object sync */
414 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
415 Status = FileObject->FinalStatus;
416 else
417 Status = StatusBlock.Status;
418 }
419
420 /* done */
421 return Status;
422 }
423
424 /*
425 @implemented
426 */
427 KSDDKAPI
428 NTSTATUS
429 NTAPI
430 KsSetInformationFile(
431 IN PFILE_OBJECT FileObject,
432 IN PVOID FileInformation,
433 IN ULONG Length,
434 IN FILE_INFORMATION_CLASS FileInformationClass)
435 {
436 PIO_STACK_LOCATION IoStack;
437 PDEVICE_OBJECT DeviceObject;
438 PIRP Irp;
439 PVOID Buffer;
440 KEVENT Event;
441 LARGE_INTEGER Offset;
442 IO_STATUS_BLOCK IoStatus;
443 NTSTATUS Status;
444
445 /* get related device object */
446 DeviceObject = IoGetRelatedDeviceObject(FileObject);
447
448 /* copy file information */
449 Buffer = AllocateItem(NonPagedPool, Length);
450 if (!Buffer)
451 return STATUS_INSUFFICIENT_RESOURCES;
452
453 _SEH2_TRY
454 {
455 ProbeForRead(Buffer, Length, sizeof(UCHAR));
456 RtlMoveMemory(Buffer, FileInformation, Length);
457 Status = STATUS_SUCCESS;
458 }
459 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
460 {
461 /* Exception, get the error code */
462 Status = _SEH2_GetExceptionCode();
463 }
464 _SEH2_END;
465
466 if (!NT_SUCCESS(Status))
467 {
468 /* invalid user buffer */
469 FreeItem(Buffer);
470 return Status;
471 }
472
473 /* initialize the event */
474 KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
475
476 /* zero offset */
477 Offset.QuadPart = 0LL;
478
479 /* build the irp */
480 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SET_INFORMATION, DeviceObject, NULL, 0, &Offset, &Event, &IoStatus);
481
482 if (!Irp)
483 {
484 /* failed to allocate irp */
485 FreeItem(Buffer);
486 return STATUS_INSUFFICIENT_RESOURCES;
487 }
488
489 /* get next stack location */
490 IoStack = IoGetNextIrpStackLocation(Irp);
491
492 /* set irp parameters */
493 IoStack->Parameters.SetFile.FileInformationClass = FileInformationClass;
494 IoStack->Parameters.SetFile.Length = Length;
495 IoStack->Parameters.SetFile.FileObject = FileObject;
496 Irp->AssociatedIrp.SystemBuffer = Buffer;
497 Irp->UserBuffer = FileInformation;
498
499 /* dispatch the irp */
500 Status = IoCallDriver(DeviceObject, Irp);
501
502 if (Status == STATUS_PENDING)
503 {
504 /* wait untill the operation has completed */
505 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
506 /* is a sync file object */
507 if (FileObject->Flags & FO_SYNCHRONOUS_IO)
508 Status = FileObject->FinalStatus;
509 else
510 Status = IoStatus.Status;
511 }
512 /* done */
513 return Status;
514 }
515
516 /*
517 @implemented
518 */
519 KSDDKAPI
520 NTSTATUS
521 NTAPI
522 KsStreamIo(
523 IN PFILE_OBJECT FileObject,
524 IN PKEVENT Event OPTIONAL,
525 IN PVOID PortContext OPTIONAL,
526 IN PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL,
527 IN PVOID CompletionContext OPTIONAL,
528 IN KSCOMPLETION_INVOCATION CompletionInvocationFlags OPTIONAL,
529 OUT PIO_STATUS_BLOCK IoStatusBlock,
530 IN OUT PVOID StreamHeaders,
531 IN ULONG Length,
532 IN ULONG Flags,
533 IN KPROCESSOR_MODE RequestorMode)
534 {
535 PIRP Irp;
536 PIO_STACK_LOCATION IoStack;
537 PDEVICE_OBJECT DeviceObject;
538 NTSTATUS Status;
539 LARGE_INTEGER Offset;
540 PKSIOBJECT_HEADER ObjectHeader;
541 BOOLEAN Ret;
542
543 /* get related device object */
544 DeviceObject = IoGetRelatedDeviceObject(FileObject);
545 /* sanity check */
546 ASSERT(DeviceObject != NULL);
547
548 /* is there a event provided */
549 if (Event)
550 {
551 /* reset event */
552 KeClearEvent(Event);
553 }
554
555 if (RequestorMode || ExGetPreviousMode() == KernelMode)
556 {
557 /* requestor is from kernel land */
558 ObjectHeader = (PKSIOBJECT_HEADER)FileObject->FsContext2;
559
560 if (ObjectHeader)
561 {
562 /* there is a object header */
563 if (Flags == KSSTREAM_READ)
564 {
565 /* is fast read supported */
566 if (ObjectHeader->DispatchTable.FastRead)
567 {
568 /* call fast read dispatch routine */
569 Ret = ObjectHeader->DispatchTable.FastRead(FileObject, NULL, Length, FALSE, 0, StreamHeaders, IoStatusBlock, DeviceObject);
570
571 if (Ret)
572 {
573 /* the request was handeled */
574 return IoStatusBlock->Status;
575 }
576 }
577 }
578 else if (Flags == KSSTREAM_WRITE)
579 {
580 /* is fast write supported */
581 if (ObjectHeader->DispatchTable.FastWrite)
582 {
583 /* call fast write dispatch routine */
584 Ret = ObjectHeader->DispatchTable.FastWrite(FileObject, NULL, Length, FALSE, 0, StreamHeaders, IoStatusBlock, DeviceObject);
585
586 if (Ret)
587 {
588 /* the request was handeled */
589 return IoStatusBlock->Status;
590 }
591 }
592 }
593 }
594 }
595
596 /* clear file object event */
597 KeClearEvent(&FileObject->Event);
598
599 /* set the offset to zero */
600 Offset.QuadPart = 0LL;
601
602 /* now build the irp */
603 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_DEVICE_CONTROL,
604 DeviceObject, (PVOID)StreamHeaders, Length, &Offset, Event, IoStatusBlock);
605 if (!Irp)
606 {
607 /* not enough memory */
608 return STATUS_INSUFFICIENT_RESOURCES;
609 }
610
611 /* setup irp parameters */
612 Irp->RequestorMode = RequestorMode;
613 Irp->Overlay.AsynchronousParameters.UserApcContext = PortContext;
614 Irp->Tail.Overlay.OriginalFileObject = FileObject;
615 Irp->UserBuffer = StreamHeaders;
616
617 /* get next irp stack location */
618 IoStack = IoGetNextIrpStackLocation(Irp);
619 /* setup stack parameters */
620 IoStack->FileObject = FileObject;
621 IoStack->Parameters.DeviceIoControl.InputBufferLength = Length;
622 IoStack->Parameters.DeviceIoControl.Type3InputBuffer = StreamHeaders;
623 IoStack->Parameters.DeviceIoControl.IoControlCode = (Flags == KSSTREAM_READ ? IOCTL_KS_READ_STREAM : IOCTL_KS_WRITE_STREAM);
624
625 if (CompletionRoutine)
626 {
627 /* setup completion routine for async processing */
628 IoSetCompletionRoutine(Irp, CompletionRoutine, CompletionContext, (CompletionInvocationFlags & KsInvokeOnSuccess), (CompletionInvocationFlags & KsInvokeOnError), (CompletionInvocationFlags & KsInvokeOnCancel));
629 }
630
631 /* now call the driver */
632 Status = IoCallDriver(DeviceObject, Irp);
633 /* done */
634 return Status;
635 }
636
637 /*
638 @implemented
639 */
640 KSDDKAPI
641 NTSTATUS
642 NTAPI
643 KsProbeStreamIrp(
644 IN PIRP Irp,
645 IN ULONG ProbeFlags,
646 IN ULONG HeaderSize)
647 {
648 PMDL Mdl;
649 PVOID Buffer;
650 LOCK_OPERATION Operation;
651 NTSTATUS Status = STATUS_SUCCESS;
652 PKSSTREAM_HEADER StreamHeader;
653 PIO_STACK_LOCATION IoStack;
654 ULONG Length;
655 //BOOLEAN AllocateMdl = FALSE;
656
657 /* get current irp stack */
658 IoStack = IoGetCurrentIrpStackLocation(Irp);
659
660 Length = IoStack->Parameters.DeviceIoControl.OutputBufferLength;
661
662 if (Irp->RequestorMode == KernelMode || Irp->AssociatedIrp.SystemBuffer)
663 {
664 if (Irp->RequestorMode == KernelMode)
665 {
666 /* no need to allocate stream header */
667 Irp->AssociatedIrp.SystemBuffer = Irp->UserBuffer;
668 }
669 AllocMdl:
670 /* check if alloc mdl flag is passed */
671 if (!(ProbeFlags & KSPROBE_ALLOCATEMDL))
672 {
673 /* nothing more to do */
674 return STATUS_SUCCESS;
675 }
676 if (Irp->MdlAddress)
677 {
678 ProbeMdl:
679 if (ProbeFlags & KSPROBE_PROBEANDLOCK)
680 {
681 if (Irp->MdlAddress->MdlFlags & (MDL_PAGES_LOCKED | MDL_SOURCE_IS_NONPAGED_POOL))
682 {
683 if (ProbeFlags & KSPROBE_SYSTEMADDRESS)
684 {
685 _SEH2_TRY
686 {
687 /* loop through all mdls and probe them */
688 Mdl = Irp->MdlAddress;
689 do
690 {
691 /* the mapping can fail */
692 Mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
693
694 if (Mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL))
695 {
696 /* no need to probe these pages */
697 Buffer = Mdl->MappedSystemVa;
698 }
699 else
700 {
701 /* probe that mdl */
702 Buffer = MmMapLockedPages(Mdl, KernelMode);
703 }
704
705 /* check if the mapping succeeded */
706 if (!Buffer)
707 {
708 /* raise exception we'll catch */
709 ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
710 }
711
712 /* iterate to next mdl */
713 Mdl = Mdl->Next;
714
715 }while(Mdl);
716 }
717 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
718 {
719 /* Exception, get the error code */
720 Status = _SEH2_GetExceptionCode();
721 } _SEH2_END;
722 }
723 }
724 else
725 {
726 _SEH2_TRY
727 {
728 /* loop through all mdls and probe them */
729 Mdl = Irp->MdlAddress;
730
731 /* determine operation */
732 if (!(ProbeFlags & KSPROBE_STREAMWRITE) || (ProbeFlags & KSPROBE_MODIFY))
733 {
734 /* operation is read / modify stream, need write access */
735 Operation = IoWriteAccess;
736 }
737 else
738 {
739 /* operation is write to device, so we need read access */
740 Operation = IoReadAccess;
741 }
742
743 do
744 {
745 /* probe the pages */
746 MmProbeAndLockPages(Mdl, Irp->RequestorMode, Operation);
747
748 if (ProbeFlags & KSPROBE_SYSTEMADDRESS)
749 {
750 /* the mapping can fail */
751 Mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
752
753 if (Mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL))
754 {
755 /* no need to probe these pages */
756 Buffer = Mdl->MappedSystemVa;
757 }
758 else
759 {
760 /* probe that mdl */
761 Buffer = MmMapLockedPages(Mdl, KernelMode);
762 }
763
764 /* check if the mapping succeeded */
765 if (!Buffer)
766 {
767 /* raise exception we'll catch */
768 ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
769 }
770 }
771
772 /* iterate to next mdl */
773 Mdl = Mdl->Next;
774
775 }while(Mdl);
776 }
777 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
778 {
779 /* Exception, get the error code */
780 Status = _SEH2_GetExceptionCode();
781 } _SEH2_END;
782 }
783 }
784 return Status;
785 }
786
787 /* check all stream headers */
788 StreamHeader = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
789 ASSERT(StreamHeader);
790 _SEH2_TRY
791 {
792 do
793 {
794 if (HeaderSize)
795 {
796 /* does the supplied header size match stream header size and no type changed */
797 if (StreamHeader->Size != HeaderSize && !(StreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TYPECHANGED))
798 {
799 /* invalid stream header */
800 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
801 }
802 }
803 else
804 {
805 /* stream must be at least of size KSSTREAM_HEADER and size must be 8-byte block aligned */
806 if (StreamHeader->Size < sizeof(KSSTREAM_HEADER) || (StreamHeader->Size & 7))
807 {
808 /* invalid stream header */
809 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
810 }
811 }
812
813 if (Length < StreamHeader->Size)
814 {
815 /* length is too short */
816 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
817 }
818
819 if (ProbeFlags & KSPROBE_STREAMWRITE)
820 {
821 if (StreamHeader->DataUsed > StreamHeader->FrameExtent)
822 {
823 /* frame extend can never be smaller */
824 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
825 }
826
827 /* is this stream change packet */
828 if (StreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TYPECHANGED)
829 {
830 if (Length != sizeof(KSSTREAM_HEADER) || (PVOID)StreamHeader != Irp->AssociatedIrp.SystemBuffer)
831 {
832 /* stream changed - must be send in a single packet */
833 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
834 }
835
836 if (!(ProbeFlags & KSPROBE_ALLOWFORMATCHANGE))
837 {
838 /* caller does not permit format changes */
839 ExRaiseStatus(STATUS_INVALID_PARAMETER);
840 }
841
842 if (StreamHeader->FrameExtent)
843 {
844 /* allocate an mdl */
845 Mdl = IoAllocateMdl(StreamHeader->Data, StreamHeader->FrameExtent, FALSE, TRUE, Irp);
846
847 if (!Mdl)
848 {
849 /* not enough memory */
850 ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
851 }
852
853 /* break-out to probe for the irp */
854 break;
855 }
856 }
857 }
858 else
859 {
860 if (StreamHeader->DataUsed)
861 {
862 /* DataUsed must be zero for stream read operation */
863 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
864 }
865
866 if (StreamHeader->OptionsFlags)
867 {
868 /* no flags supported for reading */
869 ExRaiseStatus(STATUS_INVALID_PARAMETER);
870 }
871 }
872
873 if (StreamHeader->FrameExtent)
874 {
875 /* allocate an mdl */
876 ASSERT(Irp->MdlAddress == NULL);
877 Mdl = IoAllocateMdl(StreamHeader->Data, StreamHeader->FrameExtent, FALSE, TRUE, Irp);
878 if (!Mdl)
879 {
880 /* not enough memory */
881 ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
882 }
883 }
884
885 /* move to next stream header */
886 Length -= StreamHeader->Size;
887 StreamHeader = (PKSSTREAM_HEADER)((ULONG_PTR)StreamHeader + StreamHeader->Size);
888 }while(Length);
889 }
890 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
891 {
892 /* Exception, get the error code */
893 Status = _SEH2_GetExceptionCode();
894 }_SEH2_END;
895
896 /* now probe the allocated mdl's */
897 if (!NT_SUCCESS(Status))
898 {
899 DPRINT("Status %x\n", Status);
900 return Status;
901 }
902 else
903 goto ProbeMdl;
904 }
905
906 /* probe user mode buffers */
907 if (Length && ( (!HeaderSize) || (Length % HeaderSize == 0) || ((ProbeFlags & KSPROBE_ALLOWFORMATCHANGE) && (Length == sizeof(KSSTREAM_HEADER))) ) )
908 {
909 /* allocate stream header buffer */
910 Irp->AssociatedIrp.SystemBuffer = AllocateItem(NonPagedPool, Length);
911
912 if (!Irp->AssociatedIrp.SystemBuffer)
913 {
914 /* no memory */
915 return STATUS_INSUFFICIENT_RESOURCES;
916 }
917
918 /* mark irp as buffered so that changes the stream headers are propagated back */
919 Irp->Flags = IRP_DEALLOCATE_BUFFER | IRP_BUFFERED_IO;
920
921 _SEH2_TRY
922 {
923 if (ProbeFlags & KSPROBE_STREAMWRITE)
924 {
925 if (ProbeFlags & KSPROBE_MODIFY)
926 ProbeForWrite(Irp->UserBuffer, Length, sizeof(UCHAR));
927 else
928 ProbeForRead(Irp->UserBuffer, Length, sizeof(UCHAR));
929 }
930 else
931 {
932 /* stream reads means writing */
933 ProbeForWrite(Irp->UserBuffer, Length, sizeof(UCHAR));
934
935 /* set input operation flags */
936 Irp->Flags |= IRP_INPUT_OPERATION;
937 }
938
939 /* copy stream buffer */
940 RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer, Irp->UserBuffer, Length);
941 }
942 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
943 {
944 /* Exception, get the error code */
945 Status = _SEH2_GetExceptionCode();
946 }_SEH2_END;
947
948 if (!NT_SUCCESS(Status))
949 {
950 /* failed */
951 return Status;
952 }
953
954 if (ProbeFlags & KSPROBE_ALLOCATEMDL)
955 {
956 /* alloc mdls */
957 goto AllocMdl;
958 }
959
960 /* check all stream headers */
961 StreamHeader = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
962
963 _SEH2_TRY
964 {
965 do
966 {
967 if (HeaderSize)
968 {
969 /* does the supplied header size match stream header size and no type changed */
970 if (StreamHeader->Size != HeaderSize && !(StreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TYPECHANGED))
971 {
972 /* invalid stream header */
973 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
974 }
975 }
976 else
977 {
978 /* stream must be at least of size KSSTREAM_HEADER and size must be 8-byte block aligned */
979 if (StreamHeader->Size < sizeof(KSSTREAM_HEADER) || (StreamHeader->Size & 7))
980 {
981 /* invalid stream header */
982 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
983 }
984 }
985
986 if (Length < StreamHeader->Size)
987 {
988 /* length is too short */
989 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
990 }
991
992 if (ProbeFlags & KSPROBE_STREAMWRITE)
993 {
994 if (StreamHeader->DataUsed > StreamHeader->FrameExtent)
995 {
996 /* frame extend can never be smaller */
997 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
998 }
999
1000 /* is this stream change packet */
1001 if (StreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TYPECHANGED)
1002 {
1003 if (Length != sizeof(KSSTREAM_HEADER) || (PVOID)StreamHeader != Irp->AssociatedIrp.SystemBuffer)
1004 {
1005 /* stream changed - must be send in a single packet */
1006 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
1007 }
1008
1009 if (!(ProbeFlags & KSPROBE_ALLOWFORMATCHANGE))
1010 {
1011 /* caller does not permit format changes */
1012 ExRaiseStatus(STATUS_INVALID_PARAMETER);
1013 }
1014
1015 if (StreamHeader->FrameExtent)
1016 {
1017 /* allocate an mdl */
1018 Mdl = IoAllocateMdl(StreamHeader->Data, StreamHeader->FrameExtent, FALSE, TRUE, Irp);
1019
1020 if (!Mdl)
1021 {
1022 /* not enough memory */
1023 ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
1024 }
1025
1026 /* break out to probe for the irp */
1027 //AllocateMdl = TRUE;
1028 break;
1029 }
1030 }
1031 }
1032 else
1033 {
1034 if (StreamHeader->DataUsed)
1035 {
1036 /* DataUsed must be zero for stream read operation */
1037 ExRaiseStatus(STATUS_INVALID_BUFFER_SIZE);
1038 }
1039
1040 if (StreamHeader->OptionsFlags)
1041 {
1042 /* no flags supported for reading */
1043 ExRaiseStatus(STATUS_INVALID_PARAMETER);
1044 }
1045 }
1046
1047 /* move to next stream header */
1048 Length -= StreamHeader->Size;
1049 StreamHeader = (PKSSTREAM_HEADER)((ULONG_PTR)StreamHeader + StreamHeader->Size);
1050 }while(Length);
1051
1052 }_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1053 {
1054 /* Exception, get the error code */
1055 Status = _SEH2_GetExceptionCode();
1056 }_SEH2_END;
1057
1058 /* now probe the allocated mdl's */
1059 if (NT_SUCCESS(Status))
1060 goto AllocMdl;
1061 else
1062 return Status;
1063 }
1064
1065 return STATUS_INVALID_BUFFER_SIZE;
1066 }
1067
1068 /*
1069 @implemented
1070 */
1071 KSDDKAPI
1072 NTSTATUS
1073 NTAPI
1074 KsAllocateExtraData(
1075 IN PIRP Irp,
1076 IN ULONG ExtraSize,
1077 OUT PVOID* ExtraBuffer)
1078 {
1079 PIO_STACK_LOCATION IoStack;
1080 ULONG Count, Index;
1081 PUCHAR Buffer, BufferOrg;
1082 PKSSTREAM_HEADER Header;
1083 NTSTATUS Status = STATUS_SUCCESS;
1084
1085 /* get current irp stack */
1086 IoStack = IoGetCurrentIrpStackLocation(Irp);
1087
1088 /* sanity check */
1089 ASSERT(IoStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSSTREAM_HEADER));
1090
1091 /* get total length */
1092 Count = IoStack->Parameters.DeviceIoControl.InputBufferLength / sizeof(KSSTREAM_HEADER);
1093
1094 /* allocate buffer */
1095 Buffer = BufferOrg = AllocateItem(NonPagedPool, Count * (sizeof(KSSTREAM_HEADER) + ExtraSize));
1096 if (!Buffer)
1097 return STATUS_INSUFFICIENT_RESOURCES;
1098
1099 _SEH2_TRY
1100 {
1101 /* get input buffer */
1102 Header = (PKSSTREAM_HEADER)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
1103 for(Index = 0; Index < Count; Index++)
1104 {
1105 /* copy stream header */
1106 RtlMoveMemory(Buffer, Header, sizeof(KSSTREAM_HEADER));
1107
1108 /* move to next header */
1109 Header++;
1110 /* increment output buffer offset */
1111 Buffer += sizeof(KSSTREAM_HEADER) + ExtraSize;
1112 }
1113 }
1114 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1115 {
1116 /* Exception, get the error code */
1117 Status = _SEH2_GetExceptionCode();
1118 }
1119 _SEH2_END;
1120
1121 if (!NT_SUCCESS(Status))
1122 {
1123 /* free buffer on exception */
1124 FreeItem(Buffer);
1125 return Status;
1126 }
1127
1128 /* store result */
1129 *ExtraBuffer = BufferOrg;
1130
1131 /* done */
1132 return STATUS_SUCCESS;
1133 }
1134
1135 /*
1136 @implemented
1137 */
1138 KSDDKAPI
1139 VOID
1140 NTAPI
1141 KsNullDriverUnload(
1142 IN PDRIVER_OBJECT DriverObject)
1143 {
1144 }
1145
1146 /*
1147 @implemented
1148 */
1149 KSDDKAPI
1150 NTSTATUS
1151 NTAPI
1152 KsDispatchInvalidDeviceRequest(
1153 IN PDEVICE_OBJECT DeviceObject,
1154 IN PIRP Irp)
1155 {
1156 Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
1157 CompleteRequest(Irp, IO_NO_INCREMENT);
1158
1159 return STATUS_INVALID_DEVICE_REQUEST;
1160 }
1161
1162 /*
1163 @implemented
1164 */
1165 KSDDKAPI
1166 NTSTATUS
1167 NTAPI
1168 KsDefaultDeviceIoCompletion(
1169 IN PDEVICE_OBJECT DeviceObject,
1170 IN PIRP Irp)
1171 {
1172 PIO_STACK_LOCATION IoStack;
1173 NTSTATUS Status;
1174
1175 /* get current irp stack */
1176 IoStack = IoGetCurrentIrpStackLocation(Irp);
1177
1178 if (IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_PROPERTY &&
1179 IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_METHOD &&
1180 IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_ENABLE_EVENT &&
1181 IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_DISABLE_EVENT)
1182 {
1183 if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_RESET_STATE)
1184 {
1185 /* fake success */
1186 Status = STATUS_SUCCESS;
1187 }
1188 else
1189 {
1190 /* request unsupported */
1191 Status = STATUS_INVALID_DEVICE_REQUEST;
1192 }
1193 }
1194 else
1195 {
1196 /* property / method / event not found */
1197 Status = STATUS_PROPSET_NOT_FOUND;
1198 }
1199
1200 /* complete request */
1201 Irp->IoStatus.Status = Status;
1202 CompleteRequest(Irp, IO_NO_INCREMENT);
1203
1204
1205 return Status;
1206 }
1207
1208 /*
1209 @implemented
1210 */
1211 KSDDKAPI
1212 BOOLEAN
1213 NTAPI
1214 KsDispatchFastIoDeviceControlFailure(
1215 IN PFILE_OBJECT FileObject,
1216 IN BOOLEAN Wait,
1217 IN PVOID InputBuffer OPTIONAL,
1218 IN ULONG InputBufferLength,
1219 OUT PVOID OutputBuffer OPTIONAL,
1220 IN ULONG OutputBufferLength,
1221 IN ULONG IoControlCode,
1222 OUT PIO_STATUS_BLOCK IoStatus,
1223 IN PDEVICE_OBJECT DeviceObject)
1224 {
1225 return FALSE;
1226 }
1227
1228 /*
1229 @implemented
1230 */
1231 KSDDKAPI
1232 BOOLEAN
1233 NTAPI
1234 KsDispatchFastReadFailure(
1235 IN PFILE_OBJECT FileObject,
1236 IN PLARGE_INTEGER FileOffset,
1237 IN ULONG Length,
1238 IN BOOLEAN Wait,
1239 IN ULONG LockKey,
1240 OUT PVOID Buffer,
1241 OUT PIO_STATUS_BLOCK IoStatus,
1242 IN PDEVICE_OBJECT DeviceObject)
1243 {
1244 return FALSE;
1245 }
1246
1247
1248 /*
1249 @implemented
1250 */
1251 KSDDKAPI
1252 VOID
1253 NTAPI
1254 KsCancelIo(
1255 IN OUT PLIST_ENTRY QueueHead,
1256 IN PKSPIN_LOCK SpinLock)
1257 {
1258 PDRIVER_CANCEL OldDriverCancel;
1259 PIO_STACK_LOCATION IoStack;
1260 PLIST_ENTRY Entry;
1261 PLIST_ENTRY NextEntry;
1262 PIRP Irp;
1263 KIRQL OldLevel;
1264
1265 /* acquire spinlock */
1266 KeAcquireSpinLock(SpinLock, &OldLevel);
1267 /* point to first entry */
1268 Entry = QueueHead->Flink;
1269 /* loop all items */
1270 while(Entry != QueueHead)
1271 {
1272 /* get irp offset */
1273 Irp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
1274
1275 /* get next entry */
1276 NextEntry = Entry->Flink;
1277
1278 /* set cancelled bit */
1279 Irp->Cancel = TRUE;
1280
1281 /* now set the cancel routine */
1282 OldDriverCancel = IoSetCancelRoutine(Irp, NULL);
1283 if (OldDriverCancel)
1284 {
1285 /* this irp hasnt been yet used, so free to cancel */
1286 KeReleaseSpinLock(SpinLock, OldLevel);
1287
1288 /* get current irp stack */
1289 IoStack = IoGetCurrentIrpStackLocation(Irp);
1290
1291 /* acquire cancel spinlock */
1292 IoAcquireCancelSpinLock(&Irp->CancelIrql);
1293
1294 /* call provided cancel routine */
1295 OldDriverCancel(IoStack->DeviceObject, Irp);
1296
1297 /* re-acquire spinlock */
1298 KeAcquireSpinLock(SpinLock, &OldLevel);
1299 }
1300
1301 /* move on to next entry */
1302 Entry = NextEntry;
1303 }
1304
1305 /* the irp has already been canceled */
1306 KeReleaseSpinLock(SpinLock, OldLevel);
1307
1308 }
1309
1310 /*
1311 @implemented
1312 */
1313 KSDDKAPI
1314 VOID
1315 NTAPI
1316 KsReleaseIrpOnCancelableQueue(
1317 IN PIRP Irp,
1318 IN PDRIVER_CANCEL DriverCancel OPTIONAL)
1319 {
1320 PKSPIN_LOCK SpinLock;
1321 PDRIVER_CANCEL OldDriverCancel;
1322 PIO_STACK_LOCATION IoStack;
1323 KIRQL OldLevel;
1324
1325 /* check for required parameters */
1326 if (!Irp)
1327 return;
1328
1329 if (!DriverCancel)
1330 {
1331 /* default to KsCancelRoutine */
1332 DriverCancel = KsCancelRoutine;
1333 }
1334
1335 /* get current irp stack */
1336 IoStack = IoGetCurrentIrpStackLocation(Irp);
1337
1338 /* get internal queue lock */
1339 SpinLock = KSQUEUE_SPINLOCK_IRP_STORAGE(Irp);
1340
1341 /* acquire spinlock */
1342 KeAcquireSpinLock(SpinLock, &OldLevel);
1343
1344 /* now set the cancel routine */
1345 OldDriverCancel = IoSetCancelRoutine(Irp, DriverCancel);
1346
1347 if (Irp->Cancel && OldDriverCancel == NULL)
1348 {
1349 /* the irp has already been canceled */
1350 KeReleaseSpinLock(SpinLock, OldLevel);
1351
1352 /* cancel routine requires that cancel spinlock is held */
1353 IoAcquireCancelSpinLock(&Irp->CancelIrql);
1354
1355 /* cancel irp */
1356 DriverCancel(IoStack->DeviceObject, Irp);
1357 }
1358 else
1359 {
1360 /* done */
1361 KeReleaseSpinLock(SpinLock, OldLevel);
1362 }
1363 }
1364
1365 /*
1366 @implemented
1367 */
1368 KSDDKAPI
1369 PIRP
1370 NTAPI
1371 KsRemoveIrpFromCancelableQueue(
1372 IN OUT PLIST_ENTRY QueueHead,
1373 IN PKSPIN_LOCK SpinLock,
1374 IN KSLIST_ENTRY_LOCATION ListLocation,
1375 IN KSIRP_REMOVAL_OPERATION RemovalOperation)
1376 {
1377 PIRP Irp;
1378 PLIST_ENTRY CurEntry;
1379 KIRQL OldIrql;
1380
1381 DPRINT("KsRemoveIrpFromCancelableQueue ListHead %p SpinLock %p ListLocation %x RemovalOperation %x\n", QueueHead, SpinLock, ListLocation, RemovalOperation);
1382
1383 /* check parameters */
1384 if (!QueueHead || !SpinLock)
1385 return NULL;
1386
1387 /* check if parameter ListLocation is valid */
1388 if (ListLocation != KsListEntryTail && ListLocation != KsListEntryHead)
1389 return NULL;
1390
1391 /* acquire list lock */
1392 KeAcquireSpinLock(SpinLock, &OldIrql);
1393
1394 /* point to queue head */
1395 CurEntry = QueueHead;
1396
1397 do
1398 {
1399 /* reset irp to null */
1400 Irp = NULL;
1401
1402 /* iterate to next entry */
1403 if (ListLocation == KsListEntryHead)
1404 CurEntry = CurEntry->Flink;
1405 else
1406 CurEntry = CurEntry->Blink;
1407
1408 /* is the end of list reached */
1409 if (CurEntry == QueueHead)
1410 {
1411 /* reached end of list */
1412 break;
1413 }
1414
1415 /* get irp offset */
1416 Irp = (PIRP)CONTAINING_RECORD(CurEntry, IRP, Tail.Overlay.ListEntry);
1417
1418 if (Irp->Cancel)
1419 {
1420 /* irp has been canceled */
1421 break;
1422 }
1423
1424 if (Irp->CancelRoutine)
1425 {
1426 /* remove cancel routine */
1427 Irp->CancelRoutine = NULL;
1428
1429 if (RemovalOperation == KsAcquireAndRemove || RemovalOperation == KsAcquireAndRemoveOnlySingleItem)
1430 {
1431 /* remove irp from list */
1432 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
1433 }
1434
1435 if (RemovalOperation == KsAcquireAndRemoveOnlySingleItem || RemovalOperation == KsAcquireOnlySingleItem)
1436 break;
1437 }
1438
1439 }while(TRUE);
1440
1441 /* release lock */
1442 KeReleaseSpinLock(SpinLock, OldIrql);
1443
1444 if (!Irp || Irp->CancelRoutine == NULL)
1445 {
1446 /* either an irp has been acquired or nothing found */
1447 return Irp;
1448 }
1449
1450 /* time to remove the canceled irp */
1451 IoAcquireCancelSpinLock(&OldIrql);
1452 /* acquire list lock */
1453 KeAcquireSpinLockAtDpcLevel(SpinLock);
1454
1455 if (RemovalOperation == KsAcquireAndRemove || RemovalOperation == KsAcquireAndRemoveOnlySingleItem)
1456 {
1457 /* remove it */
1458 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
1459 }
1460
1461 /* release list lock */
1462 KeReleaseSpinLockFromDpcLevel(SpinLock);
1463
1464 /* release cancel spinlock */
1465 IoReleaseCancelSpinLock(OldIrql);
1466 /* no non canceled irp has been found */
1467 return NULL;
1468 }
1469
1470 /*
1471 @implemented
1472 */
1473 KSDDKAPI
1474 NTSTATUS
1475 NTAPI
1476 KsMoveIrpsOnCancelableQueue(
1477 IN OUT PLIST_ENTRY SourceList,
1478 IN PKSPIN_LOCK SourceLock,
1479 IN OUT PLIST_ENTRY DestinationList,
1480 IN PKSPIN_LOCK DestinationLock OPTIONAL,
1481 IN KSLIST_ENTRY_LOCATION ListLocation,
1482 IN PFNKSIRPLISTCALLBACK ListCallback,
1483 IN PVOID Context)
1484 {
1485 KIRQL OldLevel;
1486 PLIST_ENTRY SrcEntry;
1487 PIRP Irp;
1488 NTSTATUS Status = STATUS_SUCCESS;
1489
1490 if (!DestinationLock)
1491 {
1492 /* no destination lock just acquire the source lock */
1493 KeAcquireSpinLock(SourceLock, &OldLevel);
1494 }
1495 else
1496 {
1497 /* acquire cancel spinlock */
1498 IoAcquireCancelSpinLock(&OldLevel);
1499
1500 /* now acquire source lock */
1501 KeAcquireSpinLockAtDpcLevel(SourceLock);
1502
1503 /* now acquire destination lock */
1504 KeAcquireSpinLockAtDpcLevel(DestinationLock);
1505 }
1506
1507 /* point to list head */
1508 SrcEntry = SourceList;
1509
1510 /* now move all irps */
1511 while(TRUE)
1512 {
1513 if (ListLocation == KsListEntryTail)
1514 {
1515 /* move queue downwards */
1516 SrcEntry = SrcEntry->Flink;
1517 }
1518 else
1519 {
1520 /* move queue upwards */
1521 SrcEntry = SrcEntry->Blink;
1522 }
1523
1524 if (SrcEntry == SourceList)
1525 {
1526 /* eof list reached */
1527 break;
1528 }
1529
1530 /* get irp offset */
1531 Irp = (PIRP)CONTAINING_RECORD(SrcEntry, IRP, Tail.Overlay.ListEntry);
1532
1533 /* now check if irp can be moved */
1534 Status = ListCallback(Irp, Context);
1535
1536 /* check if irp can be moved */
1537 if (Status == STATUS_SUCCESS)
1538 {
1539 /* remove irp from src list */
1540 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
1541
1542 if (ListLocation == KsListEntryTail)
1543 {
1544 /* insert irp end of list */
1545 InsertTailList(DestinationList, &Irp->Tail.Overlay.ListEntry);
1546 }
1547 else
1548 {
1549 /* insert irp head of list */
1550 InsertHeadList(DestinationList, &Irp->Tail.Overlay.ListEntry);
1551 }
1552
1553 /* do we need to update the irp lock */
1554 if (DestinationLock)
1555 {
1556 /* update irp lock */
1557 KSQUEUE_SPINLOCK_IRP_STORAGE(Irp) = DestinationLock;
1558 }
1559 }
1560 else
1561 {
1562 if (Status != STATUS_NO_MATCH)
1563 {
1564 /* callback decided to stop enumeration */
1565 break;
1566 }
1567
1568 /* reset return value */
1569 Status = STATUS_SUCCESS;
1570 }
1571 }
1572
1573 if (!DestinationLock)
1574 {
1575 /* release source lock */
1576 KeReleaseSpinLock(SourceLock, OldLevel);
1577 }
1578 else
1579 {
1580 /* now release destination lock */
1581 KeReleaseSpinLockFromDpcLevel(DestinationLock);
1582
1583 /* now release source lock */
1584 KeReleaseSpinLockFromDpcLevel(SourceLock);
1585
1586
1587 /* now release cancel spinlock */
1588 IoReleaseCancelSpinLock(OldLevel);
1589 }
1590
1591 /* done */
1592 return Status;
1593 }
1594
1595 /*
1596 @implemented
1597 */
1598 KSDDKAPI
1599 VOID
1600 NTAPI
1601 KsRemoveSpecificIrpFromCancelableQueue(
1602 IN PIRP Irp)
1603 {
1604 PKSPIN_LOCK SpinLock;
1605 KIRQL OldLevel;
1606
1607 DPRINT("KsRemoveSpecificIrpFromCancelableQueue %p\n", Irp);
1608
1609 /* get internal queue lock */
1610 SpinLock = KSQUEUE_SPINLOCK_IRP_STORAGE(Irp);
1611
1612 /* acquire spinlock */
1613 KeAcquireSpinLock(SpinLock, &OldLevel);
1614
1615 /* remove the irp from the list */
1616 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
1617
1618 /* release spinlock */
1619 KeReleaseSpinLock(SpinLock, OldLevel);
1620 }
1621
1622
1623 /*
1624 @implemented
1625 */
1626 KSDDKAPI
1627 VOID
1628 NTAPI
1629 KsAddIrpToCancelableQueue(
1630 IN OUT PLIST_ENTRY QueueHead,
1631 IN PKSPIN_LOCK SpinLock,
1632 IN PIRP Irp,
1633 IN KSLIST_ENTRY_LOCATION ListLocation,
1634 IN PDRIVER_CANCEL DriverCancel OPTIONAL)
1635 {
1636 PDRIVER_CANCEL OldDriverCancel;
1637 PIO_STACK_LOCATION IoStack;
1638 KIRQL OldLevel;
1639
1640 /* check for required parameters */
1641 if (!QueueHead || !SpinLock || !Irp)
1642 return;
1643
1644 /* get current irp stack */
1645 IoStack = IoGetCurrentIrpStackLocation(Irp);
1646
1647 DPRINT("KsAddIrpToCancelableQueue QueueHead %p SpinLock %p Irp %p ListLocation %x DriverCancel %p\n", QueueHead, SpinLock, Irp, ListLocation, DriverCancel);
1648
1649 // HACK for ms portcls
1650 if (IoStack->MajorFunction == IRP_MJ_CREATE)
1651 {
1652 // complete the request
1653 DPRINT1("MS HACK\n");
1654 Irp->IoStatus.Status = STATUS_SUCCESS;
1655 CompleteRequest(Irp, IO_NO_INCREMENT);
1656
1657 return;
1658 }
1659
1660
1661 if (!DriverCancel)
1662 {
1663 /* default to KsCancelRoutine */
1664 DriverCancel = KsCancelRoutine;
1665 }
1666
1667
1668 /* acquire spinlock */
1669 KeAcquireSpinLock(SpinLock, &OldLevel);
1670
1671 if (ListLocation == KsListEntryTail)
1672 {
1673 /* insert irp to tail of list */
1674 InsertTailList(QueueHead, &Irp->Tail.Overlay.ListEntry);
1675 }
1676 else
1677 {
1678 /* insert irp to head of list */
1679 InsertHeadList(QueueHead, &Irp->Tail.Overlay.ListEntry);
1680 }
1681
1682 /* store internal queue lock */
1683 KSQUEUE_SPINLOCK_IRP_STORAGE(Irp) = SpinLock;
1684
1685 /* now set the cancel routine */
1686 OldDriverCancel = IoSetCancelRoutine(Irp, DriverCancel);
1687
1688 if (Irp->Cancel && OldDriverCancel == NULL)
1689 {
1690 /* the irp has already been canceled */
1691 KeReleaseSpinLock(SpinLock, OldLevel);
1692
1693 /* cancel routine requires that cancel spinlock is held */
1694 IoAcquireCancelSpinLock(&Irp->CancelIrql);
1695
1696 /* cancel irp */
1697 DriverCancel(IoStack->DeviceObject, Irp);
1698 }
1699 else
1700 {
1701 /* done */
1702 KeReleaseSpinLock(SpinLock, OldLevel);
1703 }
1704 }
1705
1706 /*
1707 @implemented
1708 */
1709 KSDDKAPI
1710 VOID
1711 NTAPI
1712 KsCancelRoutine(
1713 IN PDEVICE_OBJECT DeviceObject,
1714 IN PIRP Irp)
1715 {
1716 PKSPIN_LOCK SpinLock;
1717
1718 /* get internal queue lock */
1719 SpinLock = KSQUEUE_SPINLOCK_IRP_STORAGE(Irp);
1720
1721 /* acquire spinlock */
1722 KeAcquireSpinLockAtDpcLevel(SpinLock);
1723
1724 /* sanity check */
1725 ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
1726
1727 /* release cancel spinlock */
1728 IoReleaseCancelSpinLock(Irp->CancelIrql);
1729
1730 /* remove the irp from the list */
1731 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
1732
1733 /* release spinlock */
1734 KeReleaseSpinLock(SpinLock, Irp->CancelIrql);
1735
1736 /* has the irp already been canceled */
1737 if (Irp->IoStatus.Status != STATUS_CANCELLED)
1738 {
1739 /* let's complete it */
1740 Irp->IoStatus.Status = STATUS_CANCELLED;
1741 CompleteRequest(Irp, IO_NO_INCREMENT);
1742 }
1743 }
1744
1745 NTSTATUS
1746 FindMatchingCreateItem(
1747 PLIST_ENTRY ListHead,
1748 PUNICODE_STRING String,
1749 OUT PCREATE_ITEM_ENTRY *OutCreateItem)
1750 {
1751 PLIST_ENTRY Entry;
1752 PCREATE_ITEM_ENTRY CreateItemEntry;
1753 UNICODE_STRING RefString;
1754 LPWSTR pStr;
1755 ULONG Count;
1756
1757 /* Copy the input string */
1758 RefString = *String;
1759
1760 /* Check if the string starts with a backslash */
1761 if (String->Buffer[0] == L'\\')
1762 {
1763 /* Skip backslash */
1764 RefString.Buffer++;
1765 RefString.Length -= sizeof(WCHAR);
1766 }
1767 else
1768 {
1769 /* get terminator */
1770 pStr = String->Buffer;
1771 Count = String->Length / sizeof(WCHAR);
1772 while ((Count > 0) && (*pStr != L'\\'))
1773 {
1774 pStr++;
1775 Count--;
1776 }
1777
1778 /* sanity check */
1779 ASSERT(Count != 0);
1780
1781 // request is for pin / node / allocator
1782 RefString.Length = (USHORT)((PCHAR)pStr - (PCHAR)String->Buffer);
1783 }
1784
1785 /* point to first entry */
1786 Entry = ListHead->Flink;
1787
1788 /* loop all device items */
1789 while (Entry != ListHead)
1790 {
1791 /* get create item entry */
1792 CreateItemEntry = (PCREATE_ITEM_ENTRY)CONTAINING_RECORD(Entry,
1793 CREATE_ITEM_ENTRY,
1794 Entry);
1795
1796 ASSERT(CreateItemEntry->CreateItem);
1797
1798 if(CreateItemEntry->CreateItem->Flags & KSCREATE_ITEM_WILDCARD)
1799 {
1800 /* create item is default */
1801 *OutCreateItem = CreateItemEntry;
1802 return STATUS_SUCCESS;
1803 }
1804
1805 if (!CreateItemEntry->CreateItem->Create)
1806 {
1807 /* skip free create item */
1808 Entry = Entry->Flink;
1809 continue;
1810 }
1811
1812 DPRINT("CreateItem %S Length %u Request %wZ %u\n",
1813 CreateItemEntry->CreateItem->ObjectClass.Buffer,
1814 CreateItemEntry->CreateItem->ObjectClass.Length,
1815 &RefString,
1816 RefString.Length);
1817
1818 if (CreateItemEntry->CreateItem->ObjectClass.Length > RefString.Length)
1819 {
1820 /* create item doesnt match in length */
1821 Entry = Entry->Flink;
1822 continue;
1823 }
1824
1825 /* now check if the object class is the same */
1826 if (!RtlCompareUnicodeString(&CreateItemEntry->CreateItem->ObjectClass,
1827 &RefString,
1828 TRUE))
1829 {
1830 /* found matching create item */
1831 *OutCreateItem = CreateItemEntry;
1832 return STATUS_SUCCESS;
1833 }
1834 /* iterate to next */
1835 Entry = Entry->Flink;
1836 }
1837
1838 return STATUS_NOT_FOUND;
1839 }
1840
1841 NTSTATUS
1842 NTAPI
1843 KspCreate(
1844 IN PDEVICE_OBJECT DeviceObject,
1845 IN PIRP Irp)
1846 {
1847 PCREATE_ITEM_ENTRY CreateItemEntry;
1848 PIO_STACK_LOCATION IoStack;
1849 PDEVICE_EXTENSION DeviceExtension;
1850 PKSIDEVICE_HEADER DeviceHeader;
1851 PKSIOBJECT_HEADER ObjectHeader;
1852 NTSTATUS Status;
1853
1854 DPRINT("KS / CREATE\n");
1855
1856 /* get current stack location */
1857 IoStack = IoGetCurrentIrpStackLocation(Irp);
1858 /* get device extension */
1859 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
1860 /* get device header */
1861 DeviceHeader = DeviceExtension->DeviceHeader;
1862
1863
1864 if (IoStack->FileObject->FileName.Buffer == NULL)
1865 {
1866 /* FIXME Pnp-Issue */
1867 DPRINT("Using reference string hack\n");
1868 Irp->IoStatus.Information = 0;
1869 /* set return status */
1870 Irp->IoStatus.Status = STATUS_SUCCESS;
1871 CompleteRequest(Irp, IO_NO_INCREMENT);
1872 return STATUS_SUCCESS;
1873 }
1874
1875 if (IoStack->FileObject->RelatedFileObject != NULL)
1876 {
1877 /* request is to instantiate a pin / node / clock / allocator */
1878 ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->RelatedFileObject->FsContext2;
1879
1880 /* sanity check */
1881 ASSERT(ObjectHeader);
1882
1883 /* find a matching a create item */
1884 Status = FindMatchingCreateItem(&ObjectHeader->ItemList,
1885 &IoStack->FileObject->FileName,
1886 &CreateItemEntry);
1887 }
1888 else
1889 {
1890 /* request to create a filter */
1891 Status = FindMatchingCreateItem(&DeviceHeader->ItemList,
1892 &IoStack->FileObject->FileName,
1893 &CreateItemEntry);
1894 }
1895
1896 if (NT_SUCCESS(Status))
1897 {
1898 /* set object create item */
1899 KSCREATE_ITEM_IRP_STORAGE(Irp) = CreateItemEntry->CreateItem;
1900
1901 /* call create function */
1902 Status = CreateItemEntry->CreateItem->Create(DeviceObject, Irp);
1903
1904 if (NT_SUCCESS(Status))
1905 {
1906 /* increment create item reference count */
1907 InterlockedIncrement(&CreateItemEntry->ReferenceCount);
1908 }
1909 return Status;
1910 }
1911
1912 Irp->IoStatus.Information = 0;
1913 /* set return status */
1914 Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
1915 CompleteRequest(Irp, IO_NO_INCREMENT);
1916 return STATUS_UNSUCCESSFUL;
1917 }
1918
1919 NTSTATUS
1920 NTAPI
1921 KspDispatchIrp(
1922 IN PDEVICE_OBJECT DeviceObject,
1923 IN PIRP Irp)
1924 {
1925 PIO_STACK_LOCATION IoStack;
1926 //PDEVICE_EXTENSION DeviceExtension;
1927 PKSIOBJECT_HEADER ObjectHeader;
1928 //PKSIDEVICE_HEADER DeviceHeader;
1929 PDRIVER_DISPATCH Dispatch;
1930 NTSTATUS Status;
1931
1932 /* get current stack location */
1933 IoStack = IoGetCurrentIrpStackLocation(Irp);
1934
1935 /* get device extension */
1936 //DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
1937 /* get device header */
1938 //DeviceHeader = DeviceExtension->DeviceHeader;
1939
1940 ASSERT(IoStack->FileObject);
1941
1942 /* get object header */
1943 ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext2;
1944
1945 if (!ObjectHeader)
1946 {
1947 /* FIXME Pnp-Issue*/
1948 Irp->IoStatus.Status = STATUS_SUCCESS;
1949 Irp->IoStatus.Information = 0;
1950 /* complete and forget */
1951 CompleteRequest(Irp, IO_NO_INCREMENT);
1952 return STATUS_SUCCESS;
1953 }
1954
1955 /* sanity check */
1956 ASSERT(ObjectHeader);
1957 /* store create item */
1958 //KSCREATE_ITEM_IRP_STORAGE(Irp) = (PKSOBJECT_CREATE_ITEM)0x12345678; //ObjectHeader->CreateItem;
1959
1960 /* retrieve matching dispatch function */
1961 switch(IoStack->MajorFunction)
1962 {
1963 case IRP_MJ_CLOSE:
1964 Dispatch = ObjectHeader->DispatchTable.Close;
1965 break;
1966 case IRP_MJ_DEVICE_CONTROL:
1967 Dispatch = ObjectHeader->DispatchTable.DeviceIoControl;
1968 break;
1969 case IRP_MJ_READ:
1970 Dispatch = ObjectHeader->DispatchTable.Read;
1971 break;
1972 case IRP_MJ_WRITE:
1973 Dispatch = ObjectHeader->DispatchTable.Write;
1974 break;
1975 case IRP_MJ_FLUSH_BUFFERS :
1976 Dispatch = ObjectHeader->DispatchTable.Flush;
1977 break;
1978 case IRP_MJ_QUERY_SECURITY:
1979 Dispatch = ObjectHeader->DispatchTable.QuerySecurity;
1980 break;
1981 case IRP_MJ_SET_SECURITY:
1982 Dispatch = ObjectHeader->DispatchTable.SetSecurity;
1983 break;
1984 case IRP_MJ_PNP:
1985 Dispatch = KsDefaultDispatchPnp;
1986 break;
1987 default:
1988 Dispatch = NULL;
1989 }
1990
1991 /* is the request supported */
1992 if (Dispatch)
1993 {
1994 /* now call the dispatch function */
1995 Status = Dispatch(DeviceObject, Irp);
1996 }
1997 else
1998 {
1999 /* not supported request */
2000 Status = KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
2001 }
2002
2003 /* done */
2004 return Status;
2005 }
2006
2007 /*
2008 @implemented
2009 */
2010 KSDDKAPI
2011 NTSTATUS
2012 NTAPI
2013 KsSetMajorFunctionHandler(
2014 IN PDRIVER_OBJECT DriverObject,
2015 IN ULONG MajorFunction)
2016 {
2017 DPRINT("KsSetMajorFunctionHandler Function %x\n", MajorFunction);
2018
2019 switch ( MajorFunction )
2020 {
2021 case IRP_MJ_CREATE:
2022 DriverObject->MajorFunction[MajorFunction] = KspCreate;
2023 break;
2024 case IRP_MJ_DEVICE_CONTROL:
2025 case IRP_MJ_CLOSE:
2026 case IRP_MJ_READ:
2027 case IRP_MJ_WRITE:
2028 case IRP_MJ_FLUSH_BUFFERS :
2029 case IRP_MJ_QUERY_SECURITY:
2030 case IRP_MJ_SET_SECURITY:
2031 DriverObject->MajorFunction[MajorFunction] = KspDispatchIrp;
2032 break;
2033 default:
2034 DPRINT1("NotSupported %x\n", MajorFunction);
2035 return STATUS_INVALID_PARAMETER;
2036 };
2037
2038 return STATUS_SUCCESS;
2039 }
2040
2041 /*
2042 @implemented
2043 */
2044 KSDDKAPI
2045 NTSTATUS
2046 NTAPI
2047 KsDispatchIrp(
2048 IN PDEVICE_OBJECT DeviceObject,
2049 IN PIRP Irp)
2050 {
2051 PIO_STACK_LOCATION IoStack;
2052 PKSIDEVICE_HEADER DeviceHeader;
2053 PDEVICE_EXTENSION DeviceExtension;
2054
2055 DPRINT("KsDispatchIrp DeviceObject %p Irp %p\n", DeviceObject, Irp);
2056
2057 /* get device extension */
2058 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
2059
2060 /* get device header */
2061 DeviceHeader = DeviceExtension->DeviceHeader;
2062
2063
2064 /* get current irp stack */
2065 IoStack = IoGetCurrentIrpStackLocation(Irp);
2066
2067 if (IoStack->MajorFunction <= IRP_MJ_DEVICE_CONTROL)
2068 {
2069 if (IoStack->MajorFunction == IRP_MJ_CREATE)
2070 {
2071 /* check internal type */
2072 if (DeviceHeader->BasicHeader.OuterUnknown) /* FIXME improve check */
2073 {
2074 /* AVStream client */
2075 return IKsDevice_Create(DeviceObject, Irp);
2076 }
2077 else
2078 {
2079 /* external client (portcls) */
2080 return KspCreate(DeviceObject, Irp);
2081 }
2082 }
2083
2084 switch (IoStack->MajorFunction)
2085 {
2086 case IRP_MJ_CLOSE:
2087 case IRP_MJ_READ:
2088 case IRP_MJ_WRITE:
2089 case IRP_MJ_FLUSH_BUFFERS:
2090 case IRP_MJ_QUERY_SECURITY:
2091 case IRP_MJ_SET_SECURITY:
2092 case IRP_MJ_PNP:
2093 case IRP_MJ_DEVICE_CONTROL:
2094 return KspDispatchIrp(DeviceObject, Irp);
2095 default:
2096 return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
2097 }
2098 }
2099
2100 /* dispatch power */
2101 if (IoStack->MajorFunction == IRP_MJ_POWER)
2102 {
2103 /* check internal type */
2104 if (DeviceHeader->BasicHeader.OuterUnknown) /* FIXME improve check */
2105 {
2106 /* AVStream client */
2107 return IKsDevice_Power(DeviceObject, Irp);
2108 }
2109 else
2110 {
2111 /* external client (portcls) */
2112 return KsDefaultDispatchPower(DeviceObject, Irp);
2113 }
2114 }
2115 else if (IoStack->MajorFunction == IRP_MJ_PNP) /* dispatch pnp */
2116 {
2117 /* check internal type */
2118 if (DeviceHeader->BasicHeader.OuterUnknown) /* FIXME improve check */
2119 {
2120 /* AVStream client */
2121 return IKsDevice_Pnp(DeviceObject, Irp);
2122 }
2123 else
2124 {
2125 /* external client (portcls) */
2126 return KsDefaultDispatchPnp(DeviceObject, Irp);
2127 }
2128 }
2129 else if (IoStack->MajorFunction == IRP_MJ_SYSTEM_CONTROL)
2130 {
2131 /* forward irp */
2132 return KsDefaultForwardIrp(DeviceObject, Irp);
2133 }
2134 else
2135 {
2136 /* not supported */
2137 return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
2138 }
2139 }
2140
2141 /*
2142 @unimplemented
2143 */
2144 KSDDKAPI
2145 ULONG
2146 NTAPI
2147 KsGetNodeIdFromIrp(
2148 IN PIRP Irp)
2149 {
2150 UNIMPLEMENTED
2151 return KSFILTER_NODE;
2152 }
2153