[KS]
[reactos.git] / reactos / drivers / ksfilter / ks / api.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/ksfilter/ks/api.c
5 * PURPOSE: KS API functions
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9 #include "priv.h"
10
11 #define NDEBUG
12 #include <debug.h>
13
14 const GUID GUID_NULL = {0x00000000L, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
15 const GUID KSMEDIUMSETID_Standard = {0x4747B320L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
16
17 /*
18 @implemented
19 */
20 KSDDKAPI
21 NTSTATUS
22 NTAPI
23 KsAcquireResetValue(
24 IN PIRP Irp,
25 OUT KSRESET* ResetValue)
26 {
27 PIO_STACK_LOCATION IoStack;
28 KSRESET* Value;
29 NTSTATUS Status = STATUS_SUCCESS;
30
31 /* get current irp stack */
32 IoStack = IoGetCurrentIrpStackLocation(Irp);
33
34 /* check if there is reset value provided */
35 if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSRESET))
36 return STATUS_INVALID_PARAMETER;
37
38 if (Irp->RequestorMode == UserMode)
39 {
40 /* need to probe the buffer */
41 _SEH2_TRY
42 {
43 ProbeForRead(IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSRESET), sizeof(UCHAR));
44 Value = (KSRESET*)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
45 *ResetValue = *Value;
46 }
47 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
48 {
49 /* Exception, get the error code */
50 Status = _SEH2_GetExceptionCode();
51 }
52 _SEH2_END;
53 }
54 else
55 {
56 Value = (KSRESET*)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
57 *ResetValue = *Value;
58 }
59
60 return Status;
61 }
62
63 /*
64 @implemented
65 */
66 KSDDKAPI
67 VOID
68 NTAPI
69 KsAcquireDeviceSecurityLock(
70 IN KSDEVICE_HEADER DevHeader,
71 IN BOOLEAN Exclusive)
72 {
73 PKSIDEVICE_HEADER Header = (PKSIDEVICE_HEADER)DevHeader;
74
75 KeEnterCriticalRegion();
76
77 if (Exclusive)
78 {
79 ExAcquireResourceExclusiveLite(&Header->SecurityLock, TRUE);
80 }
81 else
82 {
83 ExAcquireResourceSharedLite(&Header->SecurityLock, TRUE);
84 }
85 }
86
87 /*
88 @implemented
89 */
90 KSDDKAPI
91 VOID
92 NTAPI
93 KsReleaseDeviceSecurityLock(
94 IN KSDEVICE_HEADER DevHeader)
95 {
96 PKSIDEVICE_HEADER Header = (PKSIDEVICE_HEADER)DevHeader;
97
98 DPRINT("KsReleaseDevice\n");
99
100 ExReleaseResourceLite(&Header->SecurityLock);
101 KeLeaveCriticalRegion();
102 }
103
104 /*
105 @implemented
106 */
107 KSDDKAPI
108 NTSTATUS
109 NTAPI
110 KsDefaultDispatchPnp(
111 IN PDEVICE_OBJECT DeviceObject,
112 IN PIRP Irp)
113 {
114 PDEVICE_EXTENSION DeviceExtension;
115 PKSIDEVICE_HEADER DeviceHeader;
116 PIO_STACK_LOCATION IoStack;
117 PDEVICE_OBJECT PnpDeviceObject;
118 NTSTATUS Status;
119 ULONG MinorFunction;
120
121 /* get current irp stack */
122 IoStack = IoGetCurrentIrpStackLocation(Irp);
123
124 /* caller wants to add the target device */
125 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
126
127 /* get device header */
128 DeviceHeader = (PKSIDEVICE_HEADER)DeviceExtension->DeviceHeader;
129
130 /* backup PnpBaseObject */
131 PnpDeviceObject = DeviceHeader->PnpDeviceObject;
132
133
134 /* backup minor function code */
135 MinorFunction = IoStack->MinorFunction;
136
137 if(MinorFunction == IRP_MN_REMOVE_DEVICE)
138 {
139 /* remove the device */
140 KsFreeDeviceHeader((KSDEVICE_HEADER)DeviceHeader);
141 }
142
143 /* skip current irp stack */
144 IoSkipCurrentIrpStackLocation(Irp);
145
146 /* call attached pnp device object */
147 Status = IoCallDriver(PnpDeviceObject, Irp);
148
149 if (MinorFunction == IRP_MN_REMOVE_DEVICE)
150 {
151 /* time is over */
152 IoDetachDevice(PnpDeviceObject);
153 /* delete device */
154 IoDeleteDevice(DeviceObject);
155 }
156 /* done */
157 return Status;
158 }
159
160 /*
161 @implemented
162 */
163 KSDDKAPI
164 NTSTATUS
165 NTAPI
166 KsDefaultDispatchPower(
167 IN PDEVICE_OBJECT DeviceObject,
168 IN PIRP Irp)
169 {
170 PDEVICE_EXTENSION DeviceExtension;
171 PKSIDEVICE_HEADER DeviceHeader;
172 PKSIOBJECT_HEADER ObjectHeader;
173 //PIO_STACK_LOCATION IoStack;
174 PLIST_ENTRY ListEntry;
175 NTSTATUS Status;
176
177 /* get current irp stack */
178 //IoStack = IoGetCurrentIrpStackLocation(Irp);
179
180 /* caller wants to add the target device */
181 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
182
183 /* get device header */
184 DeviceHeader = (PKSIDEVICE_HEADER)DeviceExtension->DeviceHeader;
185
186 /* FIXME locks */
187
188 /* loop our power dispatch list and call registered notification functions */
189 ListEntry = DeviceHeader->PowerDispatchList.Flink;
190 /* let's go */
191 while(ListEntry != &DeviceHeader->PowerDispatchList)
192 {
193 /* get object header */
194 ObjectHeader = (PKSIOBJECT_HEADER)CONTAINING_RECORD(ListEntry, KSIOBJECT_HEADER, PowerDispatchEntry);
195
196 /* does it have still a cb */
197 if (ObjectHeader->PowerDispatch)
198 {
199 /* call the power cb */
200 Status = ObjectHeader->PowerDispatch(ObjectHeader->PowerContext, Irp);
201 ASSERT(NT_SUCCESS(Status));
202 }
203
204 /* iterate to next entry */
205 ListEntry = ListEntry->Flink;
206 }
207
208 /* start next power irp */
209 PoStartNextPowerIrp(Irp);
210
211 /* skip current irp stack location */
212 IoSkipCurrentIrpStackLocation(Irp);
213
214 /* let's roll */
215 Status = PoCallDriver(DeviceHeader->PnpDeviceObject, Irp);
216
217 /* done */
218 return Status;
219 }
220
221 /*
222 @implemented
223 */
224 KSDDKAPI
225 NTSTATUS
226 NTAPI
227 KsDefaultForwardIrp(
228 IN PDEVICE_OBJECT DeviceObject,
229 IN PIRP Irp)
230 {
231 PDEVICE_EXTENSION DeviceExtension;
232 PKSIDEVICE_HEADER DeviceHeader;
233 //PIO_STACK_LOCATION IoStack;
234 NTSTATUS Status;
235
236 /* get current irp stack */
237 //IoStack = IoGetCurrentIrpStackLocation(Irp);
238
239 /* caller wants to add the target device */
240 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
241
242 /* get device header */
243 DeviceHeader = (PKSIDEVICE_HEADER)DeviceExtension->DeviceHeader;
244
245 /* forward the request to the PDO */
246 Status = IoCallDriver(DeviceHeader->PnpDeviceObject, Irp);
247
248 return Status;
249 }
250
251 /*
252 @implemented
253 */
254 KSDDKAPI
255 VOID
256 NTAPI
257 KsSetDevicePnpAndBaseObject(
258 IN KSDEVICE_HEADER Header,
259 IN PDEVICE_OBJECT PnpDeviceObject,
260 IN PDEVICE_OBJECT BaseDevice)
261 {
262 PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
263
264 DeviceHeader->PnpDeviceObject = PnpDeviceObject;
265 DeviceHeader->BaseDevice = BaseDevice;
266 }
267
268 /*
269 @implemented
270 */
271 KSDDKAPI
272 PDEVICE_OBJECT
273 NTAPI
274 KsQueryDevicePnpObject(
275 IN KSDEVICE_HEADER Header)
276 {
277 PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
278
279 /* return PnpDeviceObject */
280 return DeviceHeader->PnpDeviceObject;
281
282 }
283
284 /*
285 @implemented
286 */
287 KSDDKAPI
288 ACCESS_MASK
289 NTAPI
290 KsQueryObjectAccessMask(
291 IN KSOBJECT_HEADER Header)
292 {
293 PKSIOBJECT_HEADER ObjectHeader = (PKSIOBJECT_HEADER)Header;
294
295 /* return access mask */
296 return ObjectHeader->AccessMask;
297
298 }
299
300 /*
301 @unimplemented
302 */
303 KSDDKAPI
304 VOID
305 NTAPI
306 KsRecalculateStackDepth(
307 IN KSDEVICE_HEADER Header,
308 IN BOOLEAN ReuseStackLocation)
309 {
310 UNIMPLEMENTED;
311 }
312
313
314 /*
315 @implemented
316 */
317 KSDDKAPI
318 VOID
319 NTAPI
320 KsSetTargetState(
321 IN KSOBJECT_HEADER Header,
322 IN KSTARGET_STATE TargetState)
323 {
324 PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
325
326 /* set target state */
327 DeviceHeader->TargetState = TargetState;
328 }
329
330 /*
331 @implemented
332 */
333 KSDDKAPI
334 VOID
335 NTAPI
336 KsSetTargetDeviceObject(
337 IN KSOBJECT_HEADER Header,
338 IN PDEVICE_OBJECT TargetDevice OPTIONAL)
339 {
340 PDEVICE_EXTENSION DeviceExtension;
341 PKSIDEVICE_HEADER DeviceHeader;
342 PKSIOBJECT_HEADER ObjectHeader = (PKSIOBJECT_HEADER)Header;
343
344 if(ObjectHeader->TargetDevice)
345 {
346 /* there is already a target device set */
347 if (!TargetDevice)
348 {
349 /* caller wants to remove the target device */
350 DeviceExtension = (PDEVICE_EXTENSION)ObjectHeader->TargetDevice->DeviceExtension;
351
352 /* get device header */
353 DeviceHeader = (PKSIDEVICE_HEADER)DeviceExtension->DeviceHeader;
354
355 /* acquire lock */
356 KsAcquireDeviceSecurityLock((KSDEVICE_HEADER)DeviceHeader, FALSE);
357
358 /* remove entry */
359 RemoveEntryList(&ObjectHeader->TargetDeviceListEntry);
360
361 /* remove device pointer */
362 ObjectHeader->TargetDevice = NULL;
363
364 /* release lock */
365 KsReleaseDeviceSecurityLock((KSDEVICE_HEADER)DeviceHeader);
366 }
367 }
368 else
369 {
370 /* no target device yet set */
371 if (TargetDevice)
372 {
373 /* caller wants to add the target device */
374 DeviceExtension = (PDEVICE_EXTENSION)TargetDevice->DeviceExtension;
375
376 /* get device header */
377 DeviceHeader = (PKSIDEVICE_HEADER)DeviceExtension->DeviceHeader;
378
379 /* acquire lock */
380 KsAcquireDeviceSecurityLock((KSDEVICE_HEADER)DeviceHeader, FALSE);
381
382 /* insert list entry */
383 InsertTailList(&DeviceHeader->TargetDeviceList, &ObjectHeader->TargetDeviceListEntry);
384
385 /* store target device */
386 ObjectHeader->TargetDevice = TargetDevice;
387
388 /* release lock */
389 KsReleaseDeviceSecurityLock((KSDEVICE_HEADER)DeviceHeader);
390 }
391 }
392
393 }
394
395 /*
396 @implemented
397 */
398 KSDDKAPI
399 VOID
400 NTAPI
401 KsSetPowerDispatch(
402 IN KSOBJECT_HEADER Header,
403 IN PFNKSCONTEXT_DISPATCH PowerDispatch OPTIONAL,
404 IN PVOID PowerContext OPTIONAL)
405 {
406 PDEVICE_EXTENSION DeviceExtension;
407 PKSIDEVICE_HEADER DeviceHeader;
408 PKSIOBJECT_HEADER ObjectHeader = (PKSIOBJECT_HEADER)Header;
409
410 /* caller wants to add the target device */
411 DeviceExtension = (PDEVICE_EXTENSION)ObjectHeader->ParentDeviceObject->DeviceExtension;
412
413 /* get device header */
414 DeviceHeader = (PKSIDEVICE_HEADER)DeviceExtension->DeviceHeader;
415
416 /* acquire lock */
417 KsAcquireDeviceSecurityLock((KSDEVICE_HEADER)DeviceHeader, FALSE);
418
419 if (PowerDispatch)
420 {
421 /* add power dispatch entry */
422 InsertTailList(&DeviceHeader->PowerDispatchList, &ObjectHeader->PowerDispatchEntry);
423
424 /* store function and context */
425 ObjectHeader->PowerDispatch = PowerDispatch;
426 ObjectHeader->PowerContext = PowerContext;
427 }
428 else
429 {
430 /* remove power dispatch entry */
431 RemoveEntryList(&ObjectHeader->PowerDispatchEntry);
432
433 /* store function and context */
434 ObjectHeader->PowerDispatch = NULL;
435 ObjectHeader->PowerContext = NULL;
436
437 }
438
439 /* release lock */
440 KsReleaseDeviceSecurityLock((KSDEVICE_HEADER)DeviceHeader);
441 }
442
443
444 /*
445 @implemented
446 */
447 KSDDKAPI
448 PKSOBJECT_CREATE_ITEM
449 NTAPI
450 KsQueryObjectCreateItem(
451 IN KSOBJECT_HEADER Header)
452 {
453 PKSIOBJECT_HEADER ObjectHeader = (PKSIOBJECT_HEADER)Header;
454 return ObjectHeader->OriginalCreateItem;
455 }
456
457 NTSTATUS
458 KspAddCreateItemToList(
459 OUT PLIST_ENTRY ListHead,
460 IN ULONG ItemsCount,
461 IN PKSOBJECT_CREATE_ITEM ItemsList)
462 {
463 ULONG Index;
464 PCREATE_ITEM_ENTRY Entry;
465
466 /* add the items */
467 for(Index = 0; Index < ItemsCount; Index++)
468 {
469 /* allocate item */
470 Entry = AllocateItem(NonPagedPool, sizeof(CREATE_ITEM_ENTRY));
471 if (!Entry)
472 {
473 /* no memory */
474 return STATUS_INSUFFICIENT_RESOURCES;
475 }
476
477 /* initialize entry */
478 InitializeListHead(&Entry->ObjectItemList);
479 Entry->CreateItem = &ItemsList[Index];
480 Entry->ReferenceCount = 0;
481 Entry->ItemFreeCallback = NULL;
482
483 InsertTailList(ListHead, &Entry->Entry);
484 }
485 return STATUS_SUCCESS;
486 }
487
488 VOID
489 KspFreeCreateItems(
490 PLIST_ENTRY ListHead)
491 {
492 PCREATE_ITEM_ENTRY Entry;
493
494 while(!IsListEmpty(ListHead))
495 {
496 /* remove create item from list */
497 Entry = (PCREATE_ITEM_ENTRY)CONTAINING_RECORD(RemoveHeadList(ListHead), CREATE_ITEM_ENTRY, Entry);
498
499 /* caller shouldnt have any references */
500 //ASSERT(Entry->ReferenceCount == 0);
501 //ASSERT(IsListEmpty(&Entry->ObjectItemList));
502
503 /* does the creator wish notification */
504 if (Entry->ItemFreeCallback)
505 {
506 /* notify creator */
507 Entry->ItemFreeCallback(Entry->CreateItem);
508 }
509
510 /* free create item entry */
511 FreeItem(Entry);
512 }
513
514 }
515
516 /*
517 @implemented
518 */
519 KSDDKAPI
520 NTSTATUS
521 NTAPI
522 KsAllocateDeviceHeader(
523 OUT KSDEVICE_HEADER* OutHeader,
524 IN ULONG ItemsCount,
525 IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL)
526 {
527 NTSTATUS Status = STATUS_SUCCESS;
528 PKSIDEVICE_HEADER Header;
529
530 if (!OutHeader)
531 return STATUS_INVALID_PARAMETER;
532
533 /* allocate a device header */
534 Header = AllocateItem(PagedPool, sizeof(KSIDEVICE_HEADER));
535
536 /* check for success */
537 if (!Header)
538 return STATUS_INSUFFICIENT_RESOURCES;
539
540 /* clear all memory */
541 RtlZeroMemory(Header, sizeof(KSIDEVICE_HEADER));
542
543 /* initialize device mutex */
544 KeInitializeMutex(&Header->DeviceMutex, 0);
545
546 /* initialize target device list */
547 InitializeListHead(&Header->TargetDeviceList);
548 /* initialize power dispatch list */
549 InitializeListHead(&Header->PowerDispatchList);
550 /* initialize object bag lists */
551 InitializeListHead(&Header->ObjectBags);
552
553 /* initialize create item list */
554 InitializeListHead(&Header->ItemList);
555
556 /* initialize basic header */
557 Header->BasicHeader.Type = KsObjectTypeDevice;
558 Header->BasicHeader.KsDevice = &Header->KsDevice;
559 Header->BasicHeader.Parent.KsDevice = &Header->KsDevice;
560
561 /* are there any create items provided */
562 if (ItemsCount && ItemsList)
563 {
564 Status = KspAddCreateItemToList(&Header->ItemList, ItemsCount, ItemsList);
565
566 if (NT_SUCCESS(Status))
567 {
568 /* store item count */
569 Header->ItemListCount = ItemsCount;
570 }
571 else
572 {
573 /* release create items */
574 KspFreeCreateItems(&Header->ItemList);
575 }
576 }
577
578 /* store result */
579 *OutHeader = Header;
580
581 return Status;
582 }
583
584 /*
585 @implemented
586 */
587 KSDDKAPI
588 VOID
589 NTAPI
590 KsFreeDeviceHeader(
591 IN KSDEVICE_HEADER DevHeader)
592 {
593 PKSIDEVICE_HEADER Header;
594
595 Header = (PKSIDEVICE_HEADER)DevHeader;
596
597 if (!DevHeader)
598 return;
599
600 KspFreeCreateItems(&Header->ItemList);
601 FreeItem(Header);
602 }
603
604 /*
605 @implemented
606 */
607 KSDDKAPI
608 NTSTATUS
609 NTAPI
610 KsAllocateObjectHeader(
611 OUT KSOBJECT_HEADER *Header,
612 IN ULONG ItemsCount,
613 IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL,
614 IN PIRP Irp,
615 IN KSDISPATCH_TABLE* Table)
616 {
617 PIO_STACK_LOCATION IoStack;
618 //PDEVICE_EXTENSION DeviceExtension;
619 //PKSIDEVICE_HEADER DeviceHeader;
620 PKSIOBJECT_HEADER ObjectHeader;
621 //PKSOBJECT_CREATE_ITEM CreateItem;
622 NTSTATUS Status;
623
624 if (!Header)
625 return STATUS_INVALID_PARAMETER_1;
626
627 if (!Irp)
628 return STATUS_INVALID_PARAMETER_4;
629
630 if (!Table)
631 return STATUS_INVALID_PARAMETER_5;
632
633 /* get current stack location */
634 IoStack = IoGetCurrentIrpStackLocation(Irp);
635 /* get device extension */
636 //DeviceExtension = (PDEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
637 /* get device header */
638 //DeviceHeader = DeviceExtension->DeviceHeader;
639
640 /* sanity check */
641 ASSERT(IoStack->FileObject);
642 /* check for an file object */
643
644 /* allocate the object header */
645 ObjectHeader = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_HEADER));
646 if (!ObjectHeader)
647 return STATUS_INSUFFICIENT_RESOURCES;
648
649 /* initialize object header */
650 RtlZeroMemory(ObjectHeader, sizeof(KSIOBJECT_HEADER));
651
652 /* initialize create item list */
653 InitializeListHead(&ObjectHeader->ItemList);
654
655 /* get create item */
656 //CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
657
658 /* do we have a name */
659 if (IoStack->FileObject->FileName.Buffer)
660 {
661 /* copy object class */
662 ObjectHeader->ObjectClass.MaximumLength = IoStack->FileObject->FileName.MaximumLength;
663 ObjectHeader->ObjectClass.Buffer = AllocateItem(NonPagedPool, ObjectHeader->ObjectClass.MaximumLength);
664 if (!ObjectHeader->ObjectClass.Buffer)
665 {
666 FreeItem(ObjectHeader);
667 return STATUS_INSUFFICIENT_RESOURCES;
668 }
669 RtlCopyUnicodeString(&ObjectHeader->ObjectClass, &IoStack->FileObject->FileName);
670 }
671
672 /* copy dispatch table */
673 RtlCopyMemory(&ObjectHeader->DispatchTable, Table, sizeof(KSDISPATCH_TABLE));
674
675 /* store create items */
676 if (ItemsCount && ItemsList)
677 {
678 Status = KspAddCreateItemToList(&ObjectHeader->ItemList, ItemsCount, ItemsList);
679
680 if (NT_SUCCESS(Status))
681 {
682 /* store item count */
683 ObjectHeader->ItemListCount = ItemsCount;
684 }
685 else
686 {
687 /* destroy header*/
688 KsFreeObjectHeader(ObjectHeader);
689 return Status;
690 }
691 }
692 /* store the object in the file object */
693 IoStack->FileObject->FsContext2 = ObjectHeader;
694
695 /* store parent device */
696 ObjectHeader->ParentDeviceObject = IoGetRelatedDeviceObject(IoStack->FileObject);
697
698 /* store originating create item */
699 ObjectHeader->OriginalCreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
700
701 /* FIXME store access mask see KsQueryObjectAccessMask */
702 ObjectHeader->AccessMask = IoStack->Parameters.Create.SecurityContext->DesiredAccess;
703
704
705 /* store result */
706 *Header = ObjectHeader;
707
708 DPRINT("KsAllocateObjectHeader ObjectClass %S FileObject %p, ObjectHeader %p\n", ObjectHeader->ObjectClass.Buffer, IoStack->FileObject, ObjectHeader);
709
710 return STATUS_SUCCESS;
711
712 }
713
714 /*
715 @implemented
716 */
717 KSDDKAPI
718 VOID
719 NTAPI
720 KsFreeObjectHeader(
721 IN PVOID Header)
722 {
723 PKSIOBJECT_HEADER ObjectHeader = (PKSIOBJECT_HEADER) Header;
724
725 DPRINT("KsFreeObjectHeader Header %p Class %wZ\n", Header, &ObjectHeader->ObjectClass);
726
727 if (ObjectHeader->ObjectClass.Buffer)
728 {
729 /* release object class buffer */
730 FreeItem(ObjectHeader->ObjectClass.Buffer);
731 }
732
733 if (ObjectHeader->Unknown)
734 {
735 /* release associated object */
736 ObjectHeader->Unknown->lpVtbl->Release(ObjectHeader->Unknown);
737 }
738
739 /* free create items */
740 KspFreeCreateItems(&ObjectHeader->ItemList);
741
742 /* free object header */
743 FreeItem(ObjectHeader);
744
745 }
746
747 NTSTATUS
748 KspAddObjectCreateItemToList(
749 PLIST_ENTRY ListHead,
750 IN PDRIVER_DISPATCH Create,
751 IN PVOID Context,
752 IN PWCHAR ObjectClass,
753 IN PSECURITY_DESCRIPTOR SecurityDescriptor)
754 {
755 PLIST_ENTRY Entry;
756 PCREATE_ITEM_ENTRY CreateEntry;
757
758 /* point to first entry */
759 Entry = ListHead->Flink;
760
761 while(Entry != ListHead)
762 {
763 /* get create entry */
764 CreateEntry = (PCREATE_ITEM_ENTRY)CONTAINING_RECORD(Entry, CREATE_ITEM_ENTRY, Entry);
765 /* if the create item has no create routine, then it is free to use */
766 if (CreateEntry->CreateItem->Create == NULL)
767 {
768 /* sanity check */
769 ASSERT(IsListEmpty(&CreateEntry->ObjectItemList));
770 ASSERT(CreateEntry->ReferenceCount == 0);
771 /* use free entry */
772 CreateEntry->CreateItem->Context = Context;
773 CreateEntry->CreateItem->Create = Create;
774 RtlInitUnicodeString(&CreateEntry->CreateItem->ObjectClass, ObjectClass);
775 CreateEntry->CreateItem->SecurityDescriptor = SecurityDescriptor;
776
777 return STATUS_SUCCESS;
778 }
779
780 if (!wcsicmp(ObjectClass, CreateEntry->CreateItem->ObjectClass.Buffer))
781 {
782 /* the same object class already exists */
783 return STATUS_OBJECT_NAME_COLLISION;
784 }
785
786 /* iterate to next entry */
787 Entry = Entry->Flink;
788 }
789 return STATUS_ALLOTTED_SPACE_EXCEEDED;
790 }
791
792 /*
793 @implemented
794 */
795 KSDDKAPI
796 NTSTATUS
797 NTAPI
798 KsAddObjectCreateItemToDeviceHeader(
799 IN KSDEVICE_HEADER DevHeader,
800 IN PDRIVER_DISPATCH Create,
801 IN PVOID Context,
802 IN PWCHAR ObjectClass,
803 IN PSECURITY_DESCRIPTOR SecurityDescriptor)
804 {
805 PKSIDEVICE_HEADER Header;
806 NTSTATUS Status;
807
808 Header = (PKSIDEVICE_HEADER)DevHeader;
809
810 DPRINT("KsAddObjectCreateItemToDeviceHeader entered\n");
811
812 /* check if a device header has been provided */
813 if (!DevHeader)
814 return STATUS_INVALID_PARAMETER_1;
815
816 /* check if a create item has been provided */
817 if (!Create)
818 return STATUS_INVALID_PARAMETER_2;
819
820 /* check if a object class has been provided */
821 if (!ObjectClass)
822 return STATUS_INVALID_PARAMETER_4;
823
824 /* let others do the work */
825 Status = KspAddObjectCreateItemToList(&Header->ItemList, Create, Context, ObjectClass, SecurityDescriptor);
826
827 if (NT_SUCCESS(Status))
828 {
829 /* increment create item count */
830 InterlockedIncrement(&Header->ItemListCount);
831 }
832 DPRINT("KsAddObjectCreateItemToDeviceHeader Status %x\n", Status);
833 return Status;
834 }
835
836 /*
837 @implemented
838 */
839 KSDDKAPI
840 NTSTATUS
841 NTAPI
842 KsAddObjectCreateItemToObjectHeader(
843 IN KSOBJECT_HEADER ObjectHeader,
844 IN PDRIVER_DISPATCH Create,
845 IN PVOID Context,
846 IN PWCHAR ObjectClass,
847 IN PSECURITY_DESCRIPTOR SecurityDescriptor)
848 {
849 PKSIOBJECT_HEADER Header;
850 NTSTATUS Status;
851
852 Header = (PKSIOBJECT_HEADER)ObjectHeader;
853
854 DPRINT("KsAddObjectCreateItemToDeviceHeader entered\n");
855
856 /* check if a device header has been provided */
857 if (!Header)
858 return STATUS_INVALID_PARAMETER_1;
859
860 /* check if a create item has been provided */
861 if (!Create)
862 return STATUS_INVALID_PARAMETER_2;
863
864 /* check if a object class has been provided */
865 if (!ObjectClass)
866 return STATUS_INVALID_PARAMETER_4;
867
868 /* let's work */
869 Status = KspAddObjectCreateItemToList(&Header->ItemList, Create, Context, ObjectClass, SecurityDescriptor);
870
871 if (NT_SUCCESS(Status))
872 {
873 /* increment create item count */
874 InterlockedIncrement(&Header->ItemListCount);
875 }
876
877 return Status;
878 }
879
880 /*
881 @implemented
882 */
883 KSDDKAPI
884 NTSTATUS
885 NTAPI
886 KsAllocateObjectCreateItem(
887 IN KSDEVICE_HEADER DevHeader,
888 IN PKSOBJECT_CREATE_ITEM CreateItem,
889 IN BOOLEAN AllocateEntry,
890 IN PFNKSITEMFREECALLBACK ItemFreeCallback OPTIONAL)
891 {
892 PCREATE_ITEM_ENTRY CreateEntry;
893 PKSIDEVICE_HEADER Header;
894 PKSOBJECT_CREATE_ITEM Item;
895
896 Header = (PKSIDEVICE_HEADER)DevHeader;
897
898 if (!DevHeader)
899 return STATUS_INVALID_PARAMETER_1;
900
901 if (!CreateItem)
902 return STATUS_INVALID_PARAMETER_2;
903
904 /* first allocate a create entry */
905 CreateEntry = AllocateItem(NonPagedPool, sizeof(CREATE_ITEM_ENTRY));
906
907 /* check for allocation success */
908 if (!CreateEntry)
909 {
910 /* not enough resources */
911 return STATUS_INSUFFICIENT_RESOURCES;
912 }
913
914
915 if (AllocateEntry)
916 {
917 /* allocate create item */
918 Item = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM));
919 if (!Item)
920 {
921 /* no memory */
922 FreeItem(CreateEntry);
923 return STATUS_INSUFFICIENT_RESOURCES;
924 }
925
926 /* initialize descriptor */
927 Item->Context = CreateItem->Context;
928 Item->Create = CreateItem->Create;
929 Item->Flags = CreateItem->Flags;
930 Item->SecurityDescriptor = CreateItem->SecurityDescriptor;
931 Item->ObjectClass.Length = 0;
932 Item->ObjectClass.MaximumLength = CreateItem->ObjectClass.MaximumLength;
933
934 /* copy object class */
935 Item->ObjectClass.Buffer = AllocateItem(NonPagedPool, Item->ObjectClass.MaximumLength);
936 if (!Item->ObjectClass.Buffer)
937 {
938 /* release resources */
939 FreeItem(Item);
940 FreeItem(CreateEntry);
941
942 return STATUS_INSUFFICIENT_RESOURCES;
943 }
944 RtlCopyUnicodeString(&Item->ObjectClass, &CreateItem->ObjectClass);
945 }
946 else
947 {
948 if (ItemFreeCallback)
949 {
950 /* callback is only accepted when the create item is copied */
951 ItemFreeCallback = NULL;
952 }
953 /* use passed create item */
954 Item = CreateItem;
955 }
956
957 /* initialize create item entry */
958 InitializeListHead(&CreateEntry->ObjectItemList);
959 CreateEntry->ItemFreeCallback = ItemFreeCallback;
960 CreateEntry->CreateItem = Item;
961 CreateEntry->ReferenceCount = 0;
962
963 /* now insert the create item entry */
964 InsertTailList(&Header->ItemList, &CreateEntry->Entry);
965
966 /* increment item count */
967 InterlockedIncrement(&Header->ItemListCount);
968
969 return STATUS_SUCCESS;
970 }
971
972 NTSTATUS
973 KspObjectFreeCreateItems(
974 IN KSDEVICE_HEADER Header,
975 IN PKSOBJECT_CREATE_ITEM CreateItem)
976 {
977 UNIMPLEMENTED
978 return STATUS_NOT_IMPLEMENTED;
979 }
980
981 /*
982 @implemented
983 */
984 KSDDKAPI
985 NTSTATUS
986 NTAPI
987 KsFreeObjectCreateItem(
988 IN KSDEVICE_HEADER Header,
989 IN PUNICODE_STRING CreateItem)
990 {
991 KSOBJECT_CREATE_ITEM Item;
992
993 RtlZeroMemory(&Item, sizeof(KSOBJECT_CREATE_ITEM));
994 RtlInitUnicodeString(&Item.ObjectClass, CreateItem->Buffer);
995
996 return KspObjectFreeCreateItems(Header, &Item);
997 }
998
999
1000 /*
1001 @implemented
1002 */
1003 KSDDKAPI
1004 NTSTATUS
1005 NTAPI
1006 KsFreeObjectCreateItemsByContext(
1007 IN KSDEVICE_HEADER Header,
1008 IN PVOID Context)
1009 {
1010 KSOBJECT_CREATE_ITEM Item;
1011
1012 RtlZeroMemory(&Item, sizeof(KSOBJECT_CREATE_ITEM));
1013
1014 Item.Context = Context;
1015
1016 return KspObjectFreeCreateItems(Header, &Item);
1017 }
1018
1019 /*
1020 @implemented
1021 */
1022 KSDDKAPI
1023 NTSTATUS
1024 NTAPI
1025 KsCreateDefaultSecurity(
1026 IN PSECURITY_DESCRIPTOR ParentSecurity OPTIONAL,
1027 OUT PSECURITY_DESCRIPTOR* DefaultSecurity)
1028 {
1029 PGENERIC_MAPPING Mapping;
1030 SECURITY_SUBJECT_CONTEXT SubjectContext;
1031 NTSTATUS Status;
1032
1033 /* start capturing security context of calling thread */
1034 SeCaptureSubjectContext(&SubjectContext);
1035 /* get generic mapping */
1036 Mapping = IoGetFileObjectGenericMapping();
1037 /* build new descriptor */
1038 Status = SeAssignSecurity(ParentSecurity, NULL, DefaultSecurity, FALSE, &SubjectContext, Mapping, NonPagedPool);
1039 /* release security descriptor */
1040 SeReleaseSubjectContext(&SubjectContext);
1041 /* done */
1042 return Status;
1043 }
1044
1045 /*
1046 @unimplemented
1047 */
1048 KSDDKAPI
1049 NTSTATUS
1050 NTAPI
1051 KsForwardIrp(
1052 IN PIRP Irp,
1053 IN PFILE_OBJECT FileObject,
1054 IN BOOLEAN ReuseStackLocation)
1055 {
1056 UNIMPLEMENTED;
1057 return STATUS_UNSUCCESSFUL;
1058 }
1059
1060
1061 /*
1062 @unimplemented
1063 */
1064 KSDDKAPI
1065 NTSTATUS
1066 NTAPI
1067 KsForwardAndCatchIrp(
1068 IN PDEVICE_OBJECT DeviceObject,
1069 IN PIRP Irp,
1070 IN PFILE_OBJECT FileObject,
1071 IN KSSTACK_USE StackUse)
1072 {
1073 UNIMPLEMENTED;
1074 return STATUS_UNSUCCESSFUL;
1075 }
1076
1077
1078 NTSTATUS
1079 NTAPI
1080 KspSynchronousIoControlDeviceCompletion(
1081 IN PDEVICE_OBJECT DeviceObject,
1082 IN PIRP Irp,
1083 IN PVOID Context)
1084 {
1085 PIO_STATUS_BLOCK IoStatusBlock = (PIO_STATUS_BLOCK)Context;
1086
1087 IoStatusBlock->Information = Irp->IoStatus.Information;
1088 IoStatusBlock->Status = Irp->IoStatus.Status;
1089
1090 return STATUS_SUCCESS;
1091 }
1092
1093 /*
1094 @implemented
1095 */
1096 KSDDKAPI
1097 NTSTATUS
1098 NTAPI
1099 KsSynchronousIoControlDevice(
1100 IN PFILE_OBJECT FileObject,
1101 IN KPROCESSOR_MODE RequestorMode,
1102 IN ULONG IoControl,
1103 IN PVOID InBuffer,
1104 IN ULONG InSize,
1105 OUT PVOID OutBuffer,
1106 IN ULONG OutSize,
1107 OUT PULONG BytesReturned)
1108 {
1109 PKSIOBJECT_HEADER ObjectHeader;
1110 PDEVICE_OBJECT DeviceObject;
1111 KEVENT Event;
1112 PIRP Irp;
1113 IO_STATUS_BLOCK IoStatusBlock;
1114 PIO_STACK_LOCATION IoStack;
1115 NTSTATUS Status;
1116
1117 /* check for valid file object */
1118 if (!FileObject)
1119 return STATUS_INVALID_PARAMETER;
1120
1121 /* get device object to send the request to */
1122 DeviceObject = IoGetRelatedDeviceObject(FileObject);
1123 if (!DeviceObject)
1124 return STATUS_UNSUCCESSFUL;
1125
1126
1127 /* get object header */
1128 ObjectHeader = (PKSIOBJECT_HEADER)FileObject->FsContext2;
1129
1130 /* check if there is fast device io function */
1131 if (ObjectHeader && ObjectHeader->DispatchTable.FastDeviceIoControl)
1132 {
1133 IoStatusBlock.Status = STATUS_UNSUCCESSFUL;
1134 IoStatusBlock.Information = 0;
1135
1136 /* send the request */
1137 Status = ObjectHeader->DispatchTable.FastDeviceIoControl(FileObject, TRUE, InBuffer, InSize, OutBuffer, OutSize, IoControl, &IoStatusBlock, DeviceObject);
1138 /* check if the request was handled */
1139 //DPRINT("Handled %u Status %x Length %u\n", Status, IoStatusBlock.Status, IoStatusBlock.Information);
1140 if (Status)
1141 {
1142 /* store bytes returned */
1143 *BytesReturned = IoStatusBlock.Information;
1144 /* return status */
1145 return IoStatusBlock.Status;
1146 }
1147 }
1148
1149 /* initialize the event */
1150 KeInitializeEvent(&Event, NotificationEvent, FALSE);
1151
1152 /* create the irp */
1153 Irp = IoBuildDeviceIoControlRequest(IoControl, DeviceObject, InBuffer, InSize, OutBuffer, OutSize, FALSE, &Event, &IoStatusBlock);
1154
1155 if (!Irp)
1156 {
1157 /* no memory to allocate the irp */
1158 return STATUS_INSUFFICIENT_RESOURCES;
1159 }
1160
1161
1162 /* Store Fileobject */
1163 IoStack = IoGetNextIrpStackLocation(Irp);
1164 IoStack->FileObject = FileObject;
1165
1166 if (IoControl == IOCTL_KS_WRITE_STREAM)
1167 {
1168 Irp->AssociatedIrp.SystemBuffer = OutBuffer;
1169 }
1170 else if (IoControl == IOCTL_KS_READ_STREAM)
1171 {
1172 Irp->AssociatedIrp.SystemBuffer = InBuffer;
1173 }
1174
1175 IoSetCompletionRoutine(Irp, KspSynchronousIoControlDeviceCompletion, (PVOID)&IoStatusBlock, TRUE, TRUE, TRUE);
1176
1177 Status = IoCallDriver(DeviceObject, Irp);
1178 if (Status == STATUS_PENDING)
1179 {
1180 KeWaitForSingleObject(&Event, Executive, RequestorMode, FALSE, NULL);
1181 Status = IoStatusBlock.Status;
1182 }
1183
1184 *BytesReturned = IoStatusBlock.Information;
1185 return Status;
1186 }
1187
1188 /*
1189 @unimplemented
1190 */
1191 KSDDKAPI
1192 NTSTATUS
1193 NTAPI
1194 KsUnserializeObjectPropertiesFromRegistry(
1195 IN PFILE_OBJECT FileObject,
1196 IN HANDLE ParentKey OPTIONAL,
1197 IN PUNICODE_STRING RegistryPath OPTIONAL)
1198 {
1199 UNIMPLEMENTED
1200 return STATUS_NOT_IMPLEMENTED;
1201 }
1202
1203
1204 /*
1205 @implemented
1206 */
1207 KSDDKAPI
1208 NTSTATUS
1209 NTAPI
1210 KsCacheMedium(
1211 IN PUNICODE_STRING SymbolicLink,
1212 IN PKSPIN_MEDIUM Medium,
1213 IN ULONG PinDirection)
1214 {
1215 HANDLE hKey;
1216 UNICODE_STRING Path;
1217 UNICODE_STRING BasePath = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\MediumCache\\");
1218 UNICODE_STRING GuidString;
1219 NTSTATUS Status;
1220 OBJECT_ATTRIBUTES ObjectAttributes;
1221 BOOLEAN PathAdjusted = FALSE;
1222 ULONG Value = 0;
1223
1224 /* first check if the medium is standard */
1225 if (IsEqualGUIDAligned(&KSMEDIUMSETID_Standard, &Medium->Set) ||
1226 IsEqualGUIDAligned(&GUID_NULL, &Medium->Set))
1227 {
1228 /* no need to cache that */
1229 return STATUS_SUCCESS;
1230 }
1231
1232 /* convert guid to string */
1233 Status = RtlStringFromGUID(&Medium->Set, &GuidString);
1234 if (!NT_SUCCESS(Status))
1235 return Status;
1236
1237 /* allocate path buffer */
1238 Path.Length = 0;
1239 Path.MaximumLength = BasePath.MaximumLength + GuidString.MaximumLength + 10 * sizeof(WCHAR);
1240 Path.Buffer = AllocateItem(PagedPool, Path.MaximumLength);
1241 if (!Path.Buffer)
1242 {
1243 /* not enough resources */
1244 RtlFreeUnicodeString(&GuidString);
1245 return STATUS_INSUFFICIENT_RESOURCES;
1246 }
1247
1248 RtlAppendUnicodeStringToString(&Path, &BasePath);
1249 RtlAppendUnicodeStringToString(&Path, &GuidString);
1250 RtlAppendUnicodeToString(&Path, L"-");
1251 /* FIXME append real instance id */
1252 RtlAppendUnicodeToString(&Path, L"0");
1253 RtlAppendUnicodeToString(&Path, L"-");
1254 /* FIXME append real instance id */
1255 RtlAppendUnicodeToString(&Path, L"0");
1256
1257 /* free guid string */
1258 RtlFreeUnicodeString(&GuidString);
1259
1260 /* initialize object attributes */
1261 InitializeObjectAttributes(&ObjectAttributes, &Path, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
1262 /* create the key */
1263 Status = ZwCreateKey(&hKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1264
1265 /* free path buffer */
1266 FreeItem(Path.Buffer);
1267
1268 if (NT_SUCCESS(Status))
1269 {
1270 /* store symbolic link */
1271 if (SymbolicLink->Buffer[1] == L'?' && SymbolicLink->Buffer[2] == L'?')
1272 {
1273 /* replace kernel path with user mode path */
1274 SymbolicLink->Buffer[1] = L'\\';
1275 PathAdjusted = TRUE;
1276 }
1277
1278 /* store the key */
1279 Status = ZwSetValueKey(hKey, SymbolicLink, 0, REG_DWORD, &Value, sizeof(ULONG));
1280
1281 if (PathAdjusted)
1282 {
1283 /* restore kernel path */
1284 SymbolicLink->Buffer[1] = L'?';
1285 }
1286
1287 ZwClose(hKey);
1288 }
1289
1290 /* done */
1291 return Status;
1292 }
1293
1294 /*
1295 @implemented
1296 */
1297 NTSTATUS
1298 NTAPI
1299 DllInitialize(
1300 PUNICODE_STRING RegistryPath)
1301 {
1302 return STATUS_SUCCESS;
1303 }
1304
1305
1306 NTSTATUS
1307 NTAPI
1308 KopDispatchClose(
1309 IN PDEVICE_OBJECT DeviceObject,
1310 IN PIRP Irp)
1311 {
1312 PKO_OBJECT_HEADER Header;
1313 PIO_STACK_LOCATION IoStack;
1314 PDEVICE_EXTENSION DeviceExtension;
1315
1316 /* get current irp stack location */
1317 IoStack = IoGetCurrentIrpStackLocation(Irp);
1318
1319 /* get ko object header */
1320 Header = (PKO_OBJECT_HEADER)IoStack->FileObject->FsContext2;
1321
1322 /* free ks object header */
1323 KsFreeObjectHeader(Header->ObjectHeader);
1324
1325 /* free ko object header */
1326 FreeItem(Header);
1327
1328 /* get device extension */
1329 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
1330
1331 /* release bus object */
1332 KsDereferenceBusObject((KSDEVICE_HEADER)DeviceExtension->DeviceHeader);
1333
1334 /* complete request */
1335 Irp->IoStatus.Status = STATUS_SUCCESS;
1336 CompleteRequest(Irp, IO_NO_INCREMENT);
1337
1338 return STATUS_SUCCESS;
1339 }
1340
1341
1342
1343 static KSDISPATCH_TABLE KoDispatchTable =
1344 {
1345 KsDispatchInvalidDeviceRequest,
1346 KsDispatchInvalidDeviceRequest,
1347 KsDispatchInvalidDeviceRequest,
1348 KsDispatchInvalidDeviceRequest,
1349 KopDispatchClose,
1350 KsDispatchQuerySecurity,
1351 KsDispatchSetSecurity,
1352 KsDispatchFastIoDeviceControlFailure,
1353 KsDispatchFastReadFailure,
1354 KsDispatchFastReadFailure,
1355 };
1356
1357
1358 NTSTATUS
1359 NTAPI
1360 KopDispatchCreate(
1361 IN PDEVICE_OBJECT DeviceObject,
1362 IN PIRP Irp)
1363 {
1364 PKO_OBJECT_HEADER Header = NULL;
1365 PIO_STACK_LOCATION IoStack;
1366 PKO_DRIVER_EXTENSION DriverObjectExtension;
1367 NTSTATUS Status;
1368
1369 /* get current irp stack location */
1370 IoStack = IoGetCurrentIrpStackLocation(Irp);
1371
1372 if (!IoStack->FileObject)
1373 {
1374 DPRINT1("FileObject not attached!\n");
1375 Status = STATUS_UNSUCCESSFUL;
1376 goto cleanup;
1377 }
1378
1379 /* get driver object extension */
1380 DriverObjectExtension = (PKO_DRIVER_EXTENSION)IoGetDriverObjectExtension(DeviceObject->DriverObject, (PVOID)KoDriverInitialize);
1381 if (!DriverObjectExtension)
1382 {
1383 DPRINT1("No DriverObjectExtension!\n");
1384 Status = STATUS_UNSUCCESSFUL;
1385 goto cleanup;
1386 }
1387
1388 /* allocate ko object header */
1389 Header = (PKO_OBJECT_HEADER)AllocateItem(NonPagedPool, sizeof(KO_OBJECT_HEADER));
1390 if (!Header)
1391 {
1392 DPRINT1("failed to allocate KO_OBJECT_HEADER\n");
1393 Status = STATUS_INSUFFICIENT_RESOURCES;
1394 goto cleanup;
1395 }
1396
1397 /* initialize create item */
1398 Header->CreateItem.Create = KopDispatchCreate;
1399 RtlInitUnicodeString(&Header->CreateItem.ObjectClass, KOSTRING_CreateObject);
1400
1401
1402 /* now allocate the object header */
1403 Status = KsAllocateObjectHeader(&Header->ObjectHeader, 1, &Header->CreateItem, Irp, &KoDispatchTable);
1404 if (!NT_SUCCESS(Status))
1405 {
1406 /* failed */
1407 goto cleanup;
1408 }
1409
1410 /* FIXME
1411 * extract clsid and interface id from irp
1412 * call the standard create handler
1413 */
1414
1415 UNIMPLEMENTED
1416
1417 IoStack->FileObject->FsContext2 = (PVOID)Header;
1418
1419 Irp->IoStatus.Status = Status;
1420 CompleteRequest(Irp, IO_NO_INCREMENT);
1421
1422 return Status;
1423
1424 cleanup:
1425
1426 if (Header && Header->ObjectHeader)
1427 KsFreeObjectHeader(Header->ObjectHeader);
1428
1429 if (Header)
1430 FreeItem(Header);
1431
1432 Irp->IoStatus.Status = Status;
1433 CompleteRequest(Irp, IO_NO_INCREMENT);
1434 return Status;
1435 }
1436
1437
1438
1439 NTSTATUS
1440 NTAPI
1441 KopAddDevice(
1442 IN PDRIVER_OBJECT DriverObject,
1443 IN PDEVICE_OBJECT PhysicalDeviceObject)
1444 {
1445 NTSTATUS Status = STATUS_DEVICE_REMOVED;
1446 PDEVICE_OBJECT FunctionalDeviceObject= NULL;
1447 PDEVICE_OBJECT NextDeviceObject;
1448 PDEVICE_EXTENSION DeviceExtension;
1449 PKSOBJECT_CREATE_ITEM CreateItem;
1450
1451 /* create the device object */
1452 Status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION), NULL, FILE_DEVICE_KS, FILE_DEVICE_SECURE_OPEN, FALSE, &FunctionalDeviceObject);
1453 if (!NT_SUCCESS(Status))
1454 return Status;
1455
1456 /* allocate the create item */
1457 CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM));
1458
1459 if (!CreateItem)
1460 {
1461 /* not enough memory */
1462 IoDeleteDevice(FunctionalDeviceObject);
1463 return STATUS_INSUFFICIENT_RESOURCES;
1464 }
1465
1466 /* initialize create item */
1467 CreateItem->Create = KopDispatchCreate;
1468 RtlInitUnicodeString(&CreateItem->ObjectClass, KOSTRING_CreateObject);
1469
1470 /* get device extension */
1471 DeviceExtension = (PDEVICE_EXTENSION)FunctionalDeviceObject->DeviceExtension;
1472
1473 /* now allocate the device header */
1474 Status = KsAllocateDeviceHeader((KSDEVICE_HEADER*)&DeviceExtension->DeviceHeader, 1, CreateItem);
1475 if (!NT_SUCCESS(Status))
1476 {
1477 /* failed */
1478 IoDeleteDevice(FunctionalDeviceObject);
1479 FreeItem(CreateItem);
1480 return Status;
1481 }
1482
1483 /* now attach to device stack */
1484 NextDeviceObject = IoAttachDeviceToDeviceStack(FunctionalDeviceObject, PhysicalDeviceObject);
1485 if (NextDeviceObject)
1486 {
1487 /* store pnp base object */
1488 KsSetDevicePnpAndBaseObject((KSDEVICE_HEADER)DeviceExtension->DeviceHeader, NextDeviceObject, FunctionalDeviceObject);
1489 /* set device flags */
1490 FunctionalDeviceObject->Flags |= DO_DIRECT_IO | DO_POWER_PAGABLE;
1491 FunctionalDeviceObject->Flags &= ~ DO_DEVICE_INITIALIZING;
1492 }
1493 else
1494 {
1495 /* failed */
1496 KsFreeDeviceHeader((KSDEVICE_HEADER)DeviceExtension->DeviceHeader);
1497 FreeItem(CreateItem);
1498 IoDeleteDevice(FunctionalDeviceObject);
1499 Status = STATUS_DEVICE_REMOVED;
1500 }
1501
1502 /* return result */
1503 return Status;
1504 }
1505
1506
1507 /*
1508 @implemented
1509 */
1510 COMDDKAPI
1511 NTSTATUS
1512 NTAPI
1513 KoDeviceInitialize(
1514 IN PDEVICE_OBJECT DeviceObject)
1515 {
1516 PDEVICE_EXTENSION DeviceExtension;
1517
1518 /* get device extension */
1519 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
1520
1521 return KsAddObjectCreateItemToDeviceHeader((KSDEVICE_HEADER)DeviceExtension->DeviceHeader, KopDispatchCreate, NULL, KOSTRING_CreateObject, NULL);
1522 }
1523
1524 /*
1525 @implemented
1526 */
1527 COMDDKAPI
1528 NTSTATUS
1529 NTAPI
1530 KoDriverInitialize(
1531 IN PDRIVER_OBJECT DriverObject,
1532 IN PUNICODE_STRING RegistryPathName,
1533 IN KoCreateObjectHandler CreateObjectHandler)
1534 {
1535 PKO_DRIVER_EXTENSION DriverObjectExtension;
1536 NTSTATUS Status;
1537
1538 /* allocate driver object extension */
1539 Status = IoAllocateDriverObjectExtension(DriverObject, (PVOID)KoDriverInitialize, sizeof(KO_DRIVER_EXTENSION), (PVOID*)&DriverObjectExtension);
1540
1541 /* did it work */
1542 if (NT_SUCCESS(Status))
1543 {
1544 /* store create handler */
1545 DriverObjectExtension->CreateObjectHandler = CreateObjectHandler;
1546
1547 /* Setting our IRP handlers */
1548 DriverObject->MajorFunction[IRP_MJ_PNP] = KsDefaultDispatchPnp;
1549 DriverObject->MajorFunction[IRP_MJ_POWER] = KsDefaultDispatchPower;
1550 DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = KsDefaultForwardIrp;
1551
1552 /* The driver unload routine */
1553 DriverObject->DriverUnload = KsNullDriverUnload;
1554
1555 /* The driver-supplied AddDevice */
1556 DriverObject->DriverExtension->AddDevice = KopAddDevice;
1557
1558 /* KS handles these */
1559 DPRINT1("Setting KS function handlers\n");
1560 KsSetMajorFunctionHandler(DriverObject, IRP_MJ_CREATE);
1561 KsSetMajorFunctionHandler(DriverObject, IRP_MJ_CLOSE);
1562 KsSetMajorFunctionHandler(DriverObject, IRP_MJ_DEVICE_CONTROL);
1563
1564 }
1565
1566 return Status;
1567 }
1568
1569 /*
1570 @unimplemented
1571 */
1572 COMDDKAPI
1573 VOID
1574 NTAPI
1575 KoRelease(
1576 IN REFCLSID ClassId)
1577 {
1578
1579 }
1580
1581 /*
1582 @implemented
1583 */
1584 KSDDKAPI
1585 VOID
1586 NTAPI
1587 KsAcquireControl(
1588 IN PVOID Object)
1589 {
1590 PKSBASIC_HEADER BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
1591
1592 /* sanity check */
1593 ASSERT(BasicHeader->Type == KsObjectTypeFilter || BasicHeader->Type == KsObjectTypePin);
1594
1595 KeWaitForSingleObject(BasicHeader->ControlMutex, Executive, KernelMode, FALSE, NULL);
1596
1597 }
1598
1599 /*
1600 @implemented
1601 */
1602 VOID
1603 NTAPI
1604 KsReleaseControl(
1605 IN PVOID Object)
1606 {
1607 PKSBASIC_HEADER BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
1608
1609 /* sanity check */
1610 ASSERT(BasicHeader->Type == KsObjectTypeFilter || BasicHeader->Type == KsObjectTypePin);
1611
1612 KeReleaseMutex(BasicHeader->ControlMutex, FALSE);
1613 }
1614
1615
1616
1617 /*
1618 @implemented
1619 */
1620 KSDDKAPI
1621 VOID
1622 NTAPI
1623 KsAcquireDevice(
1624 IN PKSDEVICE Device)
1625 {
1626 IKsDevice *KsDevice;
1627 PKSIDEVICE_HEADER DeviceHeader;
1628
1629 DPRINT("KsAcquireDevice\n");
1630 DeviceHeader = (PKSIDEVICE_HEADER)CONTAINING_RECORD(Device, KSIDEVICE_HEADER, KsDevice);
1631
1632 /* get device interface*/
1633 KsDevice = (IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown;
1634
1635 /* acquire device mutex */
1636 KsDevice->lpVtbl->AcquireDevice(KsDevice);
1637 }
1638
1639 /*
1640 @implemented
1641 */
1642 VOID
1643 NTAPI
1644 KsReleaseDevice(
1645 IN PKSDEVICE Device)
1646 {
1647 IKsDevice *KsDevice;
1648 PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)CONTAINING_RECORD(Device, KSIDEVICE_HEADER, KsDevice);
1649
1650 /* get device interface*/
1651 KsDevice = (IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown;
1652
1653 /* release device mutex */
1654 KsDevice->lpVtbl->ReleaseDevice(KsDevice);
1655 }
1656
1657 /*
1658 @implemented
1659 */
1660 KSDDKAPI
1661 VOID
1662 NTAPI
1663 KsTerminateDevice(
1664 IN PDEVICE_OBJECT DeviceObject)
1665 {
1666 IKsDevice *KsDevice;
1667 PKSIDEVICE_HEADER DeviceHeader;
1668 PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
1669
1670 /* get device header */
1671 DeviceHeader = DeviceExtension->DeviceHeader;
1672
1673 /* get device interface*/
1674 KsDevice = (IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown;
1675
1676 /* now free device header */
1677 KsFreeDeviceHeader((KSDEVICE_HEADER)DeviceHeader);
1678
1679 /* release interface when available */
1680 if (KsDevice)
1681 {
1682 /* delete IKsDevice interface */
1683 KsDevice->lpVtbl->Release(KsDevice);
1684 }
1685 }
1686
1687 /*
1688 @implemented
1689 */
1690 KSDDKAPI
1691 VOID
1692 NTAPI
1693 KsCompletePendingRequest(
1694 IN PIRP Irp)
1695 {
1696 PIO_STACK_LOCATION IoStack;
1697
1698 /* get current irp stack location */
1699 IoStack = IoGetCurrentIrpStackLocation(Irp);
1700
1701 /* sanity check */
1702 ASSERT(Irp->IoStatus.Status != STATUS_PENDING);
1703
1704 if (IoStack->MajorFunction != IRP_MJ_CLOSE)
1705 {
1706 /* can be completed immediately */
1707 CompleteRequest(Irp, IO_NO_INCREMENT);
1708 return;
1709 }
1710
1711 /* did close operation fail */
1712 if (!NT_SUCCESS(Irp->IoStatus.Status))
1713 {
1714 /* closing failed, complete irp */
1715 CompleteRequest(Irp, IO_NO_INCREMENT);
1716 return;
1717 }
1718
1719 /* FIXME
1720 * delete object / device header
1721 * remove dead pin / filter instance
1722 */
1723 UNIMPLEMENTED
1724
1725 }
1726
1727 NTSTATUS
1728 NTAPI
1729 KspSetGetBusDataCompletion(
1730 IN PDEVICE_OBJECT DeviceObject,
1731 IN PIRP Irp,
1732 IN PVOID Context)
1733 {
1734 /* signal completion */
1735 KeSetEvent((PRKEVENT)Context, IO_NO_INCREMENT, FALSE);
1736
1737 /* more work needs be done, so dont free the irp */
1738 return STATUS_MORE_PROCESSING_REQUIRED;
1739
1740 }
1741
1742 NTSTATUS
1743 KspDeviceSetGetBusData(
1744 IN PDEVICE_OBJECT DeviceObject,
1745 IN ULONG DataType,
1746 IN PVOID Buffer,
1747 IN ULONG Offset,
1748 IN ULONG Length,
1749 IN BOOL bGet)
1750 {
1751 PIO_STACK_LOCATION IoStack;
1752 PIRP Irp;
1753 NTSTATUS Status;
1754 KEVENT Event;
1755
1756 /* allocate the irp */
1757 Irp = IoAllocateIrp(1, /*FIXME */
1758 FALSE);
1759
1760 if (!Irp)
1761 return STATUS_INSUFFICIENT_RESOURCES;
1762
1763 /* initialize the event */
1764 KeInitializeEvent(&Event, NotificationEvent, FALSE);
1765
1766 /* get next stack location */
1767 IoStack = IoGetNextIrpStackLocation(Irp);
1768
1769 /* setup a completion routine */
1770 IoSetCompletionRoutine(Irp, KspSetGetBusDataCompletion, (PVOID)&Event, TRUE, TRUE, TRUE);
1771
1772 /* setup parameters */
1773 IoStack->Parameters.ReadWriteConfig.Buffer = Buffer;
1774 IoStack->Parameters.ReadWriteConfig.Length = Length;
1775 IoStack->Parameters.ReadWriteConfig.Offset = Offset;
1776 IoStack->Parameters.ReadWriteConfig.WhichSpace = DataType;
1777 /* setup function code */
1778 IoStack->MajorFunction = IRP_MJ_PNP;
1779 IoStack->MinorFunction = (bGet ? IRP_MN_READ_CONFIG : IRP_MN_WRITE_CONFIG);
1780
1781 /* lets call the driver */
1782 Status = IoCallDriver(DeviceObject, Irp);
1783
1784 /* is the request still pending */
1785 if (Status == STATUS_PENDING)
1786 {
1787 /* have a nap */
1788 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
1789 /* update status */
1790 Status = Irp->IoStatus.Status;
1791 }
1792
1793 /* free the irp */
1794 IoFreeIrp(Irp);
1795 /* done */
1796 return Status;
1797 }
1798
1799 /*
1800 @implemented
1801 */
1802 KSDDKAPI
1803 ULONG
1804 NTAPI
1805 KsDeviceSetBusData(
1806 IN PKSDEVICE Device,
1807 IN ULONG DataType,
1808 IN PVOID Buffer,
1809 IN ULONG Offset,
1810 IN ULONG Length)
1811 {
1812 return KspDeviceSetGetBusData(Device->PhysicalDeviceObject, /* is this right? */
1813 DataType, Buffer, Offset, Length, FALSE);
1814 }
1815
1816
1817 /*
1818 @implemented
1819 */
1820 KSDDKAPI
1821 ULONG
1822 NTAPI
1823 KsDeviceGetBusData(
1824 IN PKSDEVICE Device,
1825 IN ULONG DataType,
1826 IN PVOID Buffer,
1827 IN ULONG Offset,
1828 IN ULONG Length)
1829 {
1830 return KspDeviceSetGetBusData(Device->PhysicalDeviceObject, /* is this right? */
1831 DataType, Buffer, Offset, Length, TRUE);
1832
1833 }
1834
1835 /*
1836 @implemented
1837 */
1838 KSDDKAPI
1839 void
1840 NTAPI
1841 KsDeviceRegisterAdapterObject(
1842 IN PKSDEVICE Device,
1843 IN PADAPTER_OBJECT AdapterObject,
1844 IN ULONG MaxMappingsByteCount,
1845 IN ULONG MappingTableStride)
1846 {
1847 PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)CONTAINING_RECORD(Device, KSIDEVICE_HEADER, KsDevice);
1848
1849 DeviceHeader->AdapterObject = AdapterObject;
1850 DeviceHeader->MaxMappingsByteCount = MaxMappingsByteCount;
1851 DeviceHeader->MappingTableStride = MappingTableStride;
1852
1853 }
1854
1855
1856 /*
1857 @implemented
1858 */
1859 KSDDKAPI
1860 PVOID
1861 NTAPI
1862 KsGetFirstChild(
1863 IN PVOID Object)
1864 {
1865 PKSBASIC_HEADER BasicHeader;
1866
1867 /* get the basic header */
1868 BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
1869
1870 /* type has to be either a device or a filter factory */
1871 ASSERT(BasicHeader->Type == KsObjectTypeDevice || BasicHeader->Type == KsObjectTypeFilterFactory);
1872
1873 return (PVOID)BasicHeader->FirstChild.Filter;
1874 }
1875
1876 /*
1877 @implemented
1878 */
1879 KSDDKAPI
1880 PVOID
1881 NTAPI
1882 KsGetNextSibling(
1883 IN PVOID Object)
1884 {
1885 PKSBASIC_HEADER BasicHeader;
1886
1887 /* get the basic header */
1888 BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
1889
1890 ASSERT(BasicHeader->Type == KsObjectTypeDevice || BasicHeader->Type == KsObjectTypeFilterFactory ||
1891 BasicHeader->Type == KsObjectTypeFilter || BasicHeader->Type == KsObjectTypePin);
1892
1893 return (PVOID)BasicHeader->Next.Pin;
1894 }
1895
1896 ULONG
1897 KspCountMethodSets(
1898 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
1899 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL)
1900 {
1901 ULONG Index, SubIndex, Count;
1902 BOOL bFound;
1903
1904 if (!AutomationTableA)
1905 return AutomationTableB->MethodSetsCount;
1906
1907 if (!AutomationTableB)
1908 return AutomationTableA->MethodSetsCount;
1909
1910
1911 DPRINT("AutomationTableA MethodItemSize %lu MethodSetsCount %lu\n", AutomationTableA->MethodItemSize, AutomationTableA->MethodSetsCount);
1912 DPRINT("AutomationTableB MethodItemSize %lu MethodSetsCount %lu\n", AutomationTableB->MethodItemSize, AutomationTableB->MethodSetsCount);
1913
1914 if (AutomationTableA->MethodItemSize && AutomationTableB->MethodItemSize)
1915 {
1916 /* sanity check */
1917 ASSERT(AutomationTableA->MethodItemSize == AutomationTableB->MethodItemSize);
1918 }
1919
1920 /* now iterate all property sets and compare their guids */
1921 Count = AutomationTableA->MethodSetsCount;
1922
1923 for(Index = 0; Index < AutomationTableB->MethodSetsCount; Index++)
1924 {
1925 /* set found to false */
1926 bFound = FALSE;
1927
1928 for(SubIndex = 0; SubIndex < AutomationTableA->MethodSetsCount; SubIndex++)
1929 {
1930 if (IsEqualGUIDAligned(AutomationTableB->MethodSets[Index].Set, AutomationTableA->MethodSets[SubIndex].Set))
1931 {
1932 /* same property set found */
1933 bFound = TRUE;
1934 break;
1935 }
1936 }
1937
1938 if (!bFound)
1939 Count++;
1940 }
1941
1942 return Count;
1943 }
1944
1945 ULONG
1946 KspCountEventSets(
1947 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
1948 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL)
1949 {
1950 ULONG Index, SubIndex, Count;
1951 BOOL bFound;
1952
1953 if (!AutomationTableA)
1954 return AutomationTableB->EventSetsCount;
1955
1956 if (!AutomationTableB)
1957 return AutomationTableA->EventSetsCount;
1958
1959 DPRINT("AutomationTableA EventItemSize %lu EventSetsCount %lu\n", AutomationTableA->EventItemSize, AutomationTableA->EventSetsCount);
1960 DPRINT("AutomationTableB EventItemSize %lu EventSetsCount %lu\n", AutomationTableB->EventItemSize, AutomationTableB->EventSetsCount);
1961
1962 if (AutomationTableA->EventItemSize && AutomationTableB->EventItemSize)
1963 {
1964 /* sanity check */
1965 ASSERT(AutomationTableA->EventItemSize == AutomationTableB->EventItemSize);
1966 }
1967
1968 /* now iterate all Event sets and compare their guids */
1969 Count = AutomationTableA->EventSetsCount;
1970
1971 for(Index = 0; Index < AutomationTableB->EventSetsCount; Index++)
1972 {
1973 /* set found to false */
1974 bFound = FALSE;
1975
1976 for(SubIndex = 0; SubIndex < AutomationTableA->EventSetsCount; SubIndex++)
1977 {
1978 if (IsEqualGUIDAligned(AutomationTableB->EventSets[Index].Set, AutomationTableA->EventSets[SubIndex].Set))
1979 {
1980 /* same Event set found */
1981 bFound = TRUE;
1982 break;
1983 }
1984 }
1985
1986 if (!bFound)
1987 Count++;
1988 }
1989
1990 return Count;
1991 }
1992
1993
1994 ULONG
1995 KspCountPropertySets(
1996 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
1997 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL)
1998 {
1999 ULONG Index, SubIndex, Count;
2000 BOOL bFound;
2001
2002 if (!AutomationTableA)
2003 return AutomationTableB->PropertySetsCount;
2004
2005 if (!AutomationTableB)
2006 return AutomationTableA->PropertySetsCount;
2007
2008 /* sanity check */
2009 DPRINT("AutomationTableA PropertyItemSize %lu PropertySetsCount %lu\n", AutomationTableA->PropertyItemSize, AutomationTableA->PropertySetsCount);
2010 DPRINT("AutomationTableB PropertyItemSize %lu PropertySetsCount %lu\n", AutomationTableB->PropertyItemSize, AutomationTableB->PropertySetsCount);
2011 ASSERT(AutomationTableA->PropertyItemSize == AutomationTableB->PropertyItemSize);
2012
2013 /* now iterate all property sets and compare their guids */
2014 Count = AutomationTableA->PropertySetsCount;
2015
2016 for(Index = 0; Index < AutomationTableB->PropertySetsCount; Index++)
2017 {
2018 /* set found to false */
2019 bFound = FALSE;
2020
2021 for(SubIndex = 0; SubIndex < AutomationTableA->PropertySetsCount; SubIndex++)
2022 {
2023 if (IsEqualGUIDAligned(AutomationTableB->PropertySets[Index].Set, AutomationTableA->PropertySets[SubIndex].Set))
2024 {
2025 /* same property set found */
2026 bFound = TRUE;
2027 break;
2028 }
2029 }
2030
2031 if (!bFound)
2032 Count++;
2033 }
2034
2035 return Count;
2036 }
2037
2038 NTSTATUS
2039 KspCopyMethodSets(
2040 OUT PKSAUTOMATION_TABLE Table,
2041 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
2042 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL)
2043 {
2044 ULONG Index, SubIndex, Count;
2045 BOOL bFound;
2046
2047 if (!AutomationTableA)
2048 {
2049 /* copy of property set */
2050 RtlMoveMemory((PVOID)Table->MethodSets, AutomationTableB->MethodSets, sizeof(KSMETHOD_SET) * AutomationTableB->MethodSetsCount);
2051 return STATUS_SUCCESS;
2052 }
2053 else if (!AutomationTableB)
2054 {
2055 /* copy of property set */
2056 RtlMoveMemory((PVOID)Table->MethodSets, AutomationTableA->MethodSets, sizeof(KSMETHOD_SET) * AutomationTableA->MethodSetsCount);
2057 return STATUS_SUCCESS;
2058 }
2059
2060 /* first copy all property items from dominant table */
2061 RtlMoveMemory((PVOID)Table->MethodSets, AutomationTableA->MethodSets, sizeof(KSMETHOD_SET) * AutomationTableA->MethodSetsCount);
2062 /* set counter */
2063 Count = AutomationTableA->MethodSetsCount;
2064
2065 /* now copy entries which aren't available in the dominant table */
2066 for(Index = 0; Index < AutomationTableB->MethodSetsCount; Index++)
2067 {
2068 /* set found to false */
2069 bFound = FALSE;
2070
2071 for(SubIndex = 0; SubIndex < AutomationTableA->MethodSetsCount; SubIndex++)
2072 {
2073 if (IsEqualGUIDAligned(AutomationTableB->MethodSets[Index].Set, AutomationTableA->MethodSets[SubIndex].Set))
2074 {
2075 /* same property set found */
2076 bFound = TRUE;
2077 break;
2078 }
2079 }
2080
2081 if (!bFound)
2082 {
2083 /* copy new property item set */
2084 RtlMoveMemory((PVOID)&Table->MethodSets[Count], &AutomationTableB->MethodSets[Index], sizeof(KSMETHOD_SET));
2085 Count++;
2086 }
2087 }
2088
2089 return STATUS_SUCCESS;
2090 }
2091
2092 VOID
2093 KspAddPropertyItem(
2094 OUT PKSPROPERTY_SET OutPropertySet,
2095 IN PKSPROPERTY_ITEM PropertyItem,
2096 IN ULONG PropertyItemSize)
2097 {
2098 PKSPROPERTY_ITEM CurrentPropertyItem;
2099 ULONG Index;
2100
2101 // check if the property item is already present
2102 CurrentPropertyItem = (PKSPROPERTY_ITEM)OutPropertySet->PropertyItem;
2103 for(Index = 0; Index < OutPropertySet->PropertiesCount; Index++)
2104 {
2105 if (CurrentPropertyItem->PropertyId == PropertyItem->PropertyId)
2106 {
2107 // item already present
2108 return;
2109 }
2110
2111 // next item
2112 CurrentPropertyItem = (PKSPROPERTY_ITEM)((ULONG_PTR)CurrentPropertyItem + PropertyItemSize);
2113 }
2114 // add item
2115 RtlCopyMemory(CurrentPropertyItem, PropertyItem, PropertyItemSize);
2116 OutPropertySet->PropertiesCount++;
2117 }
2118
2119 NTSTATUS
2120 KspMergePropertySet(
2121 OUT PKSAUTOMATION_TABLE Table,
2122 OUT PKSPROPERTY_SET OutPropertySet,
2123 IN PKSPROPERTY_SET PropertySetA,
2124 IN PKSPROPERTY_SET PropertySetB,
2125 IN KSOBJECT_BAG Bag OPTIONAL)
2126 {
2127 ULONG PropertyCount, Index;
2128 PKSPROPERTY_ITEM PropertyItem, CurrentPropertyItem;
2129 NTSTATUS Status;
2130
2131 // max properties
2132 PropertyCount = PropertySetA->PropertiesCount + PropertySetB->PropertiesCount;
2133
2134 // allocate items
2135 PropertyItem = AllocateItem(NonPagedPool, Table->PropertyItemSize * PropertyCount);
2136 if (!PropertyItem)
2137 return STATUS_INSUFFICIENT_RESOURCES;
2138
2139 if (Bag)
2140 {
2141 /* add table to object bag */
2142 Status = KsAddItemToObjectBag(Bag, PropertyItem, NULL);
2143 /* check for success */
2144 if (!NT_SUCCESS(Status))
2145 {
2146 /* free table */
2147 FreeItem(Table);
2148 return Status;
2149 }
2150 }
2151
2152 // copy entries from dominant table
2153 RtlCopyMemory(PropertyItem, PropertySetA->PropertyItem, Table->PropertyItemSize * PropertySetA->PropertiesCount);
2154
2155 // init property set
2156 OutPropertySet->PropertiesCount = PropertySetA->PropertiesCount;
2157 OutPropertySet->PropertyItem = PropertyItem;
2158
2159 // copy other entries
2160 CurrentPropertyItem = (PKSPROPERTY_ITEM)PropertySetB->PropertyItem;
2161 for(Index = 0; Index < PropertySetB->PropertiesCount; Index++)
2162 {
2163
2164 // add entries
2165 KspAddPropertyItem(OutPropertySet, CurrentPropertyItem, Table->PropertyItemSize);
2166
2167 // next entry
2168 CurrentPropertyItem = (PKSPROPERTY_ITEM)((ULONG_PTR)CurrentPropertyItem + Table->PropertyItemSize);
2169 }
2170
2171 // done
2172 return STATUS_SUCCESS;
2173 }
2174
2175
2176 NTSTATUS
2177 KspCopyPropertySets(
2178 OUT PKSAUTOMATION_TABLE Table,
2179 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
2180 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL,
2181 IN KSOBJECT_BAG Bag OPTIONAL)
2182 {
2183 ULONG Index, SubIndex, Count;
2184 BOOL bFound;
2185 NTSTATUS Status;
2186
2187 if (!AutomationTableA)
2188 {
2189 /* copy of property set */
2190 RtlMoveMemory((PVOID)Table->PropertySets, AutomationTableB->PropertySets, sizeof(KSPROPERTY_SET) * AutomationTableB->PropertySetsCount);
2191 return STATUS_SUCCESS;
2192 }
2193 else if (!AutomationTableB)
2194 {
2195 /* copy of property set */
2196 RtlMoveMemory((PVOID)Table->PropertySets, AutomationTableA->PropertySets, sizeof(KSPROPERTY_SET) * AutomationTableA->PropertySetsCount);
2197 return STATUS_SUCCESS;
2198 }
2199
2200 /* first copy all property items from dominant table */
2201 RtlMoveMemory((PVOID)Table->PropertySets, AutomationTableA->PropertySets, sizeof(KSPROPERTY_SET) * AutomationTableA->PropertySetsCount);
2202 /* set counter */
2203 Count = AutomationTableA->PropertySetsCount;
2204
2205 /* now copy entries which aren't available in the dominant table */
2206 for(Index = 0; Index < AutomationTableB->PropertySetsCount; Index++)
2207 {
2208 /* set found to false */
2209 bFound = FALSE;
2210
2211 for(SubIndex = 0; SubIndex < AutomationTableA->PropertySetsCount; SubIndex++)
2212 {
2213 if (IsEqualGUIDAligned(AutomationTableB->PropertySets[Index].Set, AutomationTableA->PropertySets[SubIndex].Set))
2214 {
2215 /* same property set found */
2216 bFound = TRUE;
2217 break;
2218 }
2219 }
2220
2221 if (!bFound)
2222 {
2223 /* copy new property item set */
2224 RtlMoveMemory((PVOID)&Table->PropertySets[Count], &AutomationTableB->PropertySets[Index], sizeof(KSPROPERTY_SET));
2225 Count++;
2226 }
2227 else
2228 {
2229 // merge property sets
2230 Status = KspMergePropertySet(Table, (PKSPROPERTY_SET)&Table->PropertySets[SubIndex], (PKSPROPERTY_SET)&AutomationTableA->PropertySets[SubIndex], (PKSPROPERTY_SET)&AutomationTableB->PropertySets[Index], Bag);
2231 if (!NT_SUCCESS(Status))
2232 {
2233 // failed to merge
2234 DPRINT1("[KS] Failed to merge %x\n", Status);
2235 return Status;
2236 }
2237 }
2238 }
2239
2240 return STATUS_SUCCESS;
2241 }
2242
2243 NTSTATUS
2244 KspCopyEventSets(
2245 OUT PKSAUTOMATION_TABLE Table,
2246 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
2247 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL)
2248 {
2249 ULONG Index, SubIndex, Count;
2250 BOOL bFound;
2251
2252 if (!AutomationTableA)
2253 {
2254 /* copy of Event set */
2255 RtlMoveMemory((PVOID)Table->EventSets, AutomationTableB->EventSets, sizeof(KSEVENT_SET) * AutomationTableB->EventSetsCount);
2256 return STATUS_SUCCESS;
2257 }
2258 else if (!AutomationTableB)
2259 {
2260 /* copy of Event set */
2261 RtlMoveMemory((PVOID)Table->EventSets, AutomationTableA->EventSets, sizeof(KSEVENT_SET) * AutomationTableA->EventSetsCount);
2262 return STATUS_SUCCESS;
2263 }
2264
2265 /* first copy all Event items from dominant table */
2266 RtlMoveMemory((PVOID)Table->EventSets, AutomationTableA->EventSets, sizeof(KSEVENT_SET) * AutomationTableA->EventSetsCount);
2267 /* set counter */
2268 Count = AutomationTableA->EventSetsCount;
2269
2270 /* now copy entries which aren't available in the dominant table */
2271 for(Index = 0; Index < AutomationTableB->EventSetsCount; Index++)
2272 {
2273 /* set found to false */
2274 bFound = FALSE;
2275
2276 for(SubIndex = 0; SubIndex < AutomationTableA->EventSetsCount; SubIndex++)
2277 {
2278 if (IsEqualGUIDAligned(AutomationTableB->EventSets[Index].Set, AutomationTableA->EventSets[SubIndex].Set))
2279 {
2280 /* same Event set found */
2281 bFound = TRUE;
2282 break;
2283 }
2284 }
2285
2286 if (!bFound)
2287 {
2288 /* copy new Event item set */
2289 RtlMoveMemory((PVOID)&Table->EventSets[Count], &AutomationTableB->EventSets[Index], sizeof(KSEVENT_SET));
2290 Count++;
2291 }
2292 }
2293
2294 return STATUS_SUCCESS;
2295 }
2296
2297
2298 /*
2299 @implemented
2300 */
2301 NTSTATUS
2302 NTAPI
2303 KsMergeAutomationTables(
2304 OUT PKSAUTOMATION_TABLE *AutomationTableAB,
2305 IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
2306 IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL,
2307 IN KSOBJECT_BAG Bag OPTIONAL)
2308 {
2309 PKSAUTOMATION_TABLE Table;
2310 NTSTATUS Status = STATUS_SUCCESS;
2311
2312 if (!AutomationTableA && !AutomationTableB)
2313 {
2314 /* nothing to merge */
2315 return STATUS_SUCCESS;
2316 }
2317
2318 /* allocate an automation table */
2319 Table = AllocateItem(NonPagedPool, sizeof(KSAUTOMATION_TABLE));
2320 if (!Table)
2321 return STATUS_INSUFFICIENT_RESOURCES;
2322
2323 if (Bag)
2324 {
2325 /* add table to object bag */
2326 Status = KsAddItemToObjectBag(Bag, Table, NULL);
2327 /* check for success */
2328 if (!NT_SUCCESS(Status))
2329 {
2330 /* free table */
2331 FreeItem(Table);
2332 return Status;
2333 }
2334 }
2335
2336 /* count property sets */
2337 Table->PropertySetsCount = KspCountPropertySets(AutomationTableA, AutomationTableB);
2338
2339 if (Table->PropertySetsCount)
2340 {
2341 if (AutomationTableA)
2342 {
2343 /* use item size from dominant automation table */
2344 Table->PropertyItemSize = AutomationTableA->PropertyItemSize;
2345 }
2346 else
2347 {
2348 /* use item size from 2nd automation table */
2349 Table->PropertyItemSize = AutomationTableB->PropertyItemSize;
2350 }
2351
2352 if (AutomationTableA && AutomationTableB)
2353 {
2354 // FIXME handle different propery item sizes
2355 ASSERT(AutomationTableA->PropertyItemSize == AutomationTableB->PropertyItemSize);
2356 }
2357
2358 /* now allocate the property sets */
2359 Table->PropertySets = AllocateItem(NonPagedPool, sizeof(KSPROPERTY_SET) * Table->PropertySetsCount);
2360
2361 if (!Table->PropertySets)
2362 {
2363 /* not enough memory */
2364 goto cleanup;
2365 }
2366
2367 if (Bag)
2368 {
2369 /* add set to property bag */
2370 Status = KsAddItemToObjectBag(Bag, (PVOID)Table->PropertySets, NULL);
2371 /* check for success */
2372 if (!NT_SUCCESS(Status))
2373 {
2374 /* cleanup table */
2375 goto cleanup;
2376 }
2377 }
2378 /* now copy the property sets */
2379 Status = KspCopyPropertySets(Table, AutomationTableA, AutomationTableB, Bag);
2380 if(!NT_SUCCESS(Status))
2381 goto cleanup;
2382
2383 }
2384
2385 /* now count the method sets */
2386 Table->MethodSetsCount = KspCountMethodSets(AutomationTableA, AutomationTableB);
2387
2388 if (Table->MethodSetsCount)
2389 {
2390 if (AutomationTableA)
2391 {
2392 /* use item size from dominant automation table */
2393 Table->MethodItemSize = AutomationTableA->MethodItemSize;
2394 }
2395 else
2396 {
2397 /* use item size from 2nd automation table */
2398 Table->MethodItemSize = AutomationTableB->MethodItemSize;
2399 }
2400
2401 /* now allocate the property sets */
2402 Table->MethodSets = AllocateItem(NonPagedPool, sizeof(KSMETHOD_SET) * Table->MethodSetsCount);
2403
2404 if (!Table->MethodSets)
2405 {
2406 /* not enough memory */
2407 goto cleanup;
2408 }
2409
2410 if (Bag)
2411 {
2412 /* add set to property bag */
2413 Status = KsAddItemToObjectBag(Bag, (PVOID)Table->MethodSets, NULL);
2414 /* check for success */
2415 if (!NT_SUCCESS(Status))
2416 {
2417 /* cleanup table */
2418 goto cleanup;
2419 }
2420 }
2421 /* now copy the property sets */
2422 Status = KspCopyMethodSets(Table, AutomationTableA, AutomationTableB);
2423 if(!NT_SUCCESS(Status))
2424 goto cleanup;
2425 }
2426
2427
2428 /* now count the event sets */
2429 Table->EventSetsCount = KspCountEventSets(AutomationTableA, AutomationTableB);
2430
2431 if (Table->EventSetsCount)
2432 {
2433 if (AutomationTableA)
2434 {
2435 /* use item size from dominant automation table */
2436 Table->EventItemSize = AutomationTableA->EventItemSize;
2437 }
2438 else
2439 {
2440 /* use item size from 2nd automation table */
2441 Table->EventItemSize = AutomationTableB->EventItemSize;
2442 }
2443
2444 /* now allocate the property sets */
2445 Table->EventSets = AllocateItem(NonPagedPool, sizeof(KSEVENT_SET) * Table->EventSetsCount);
2446
2447 if (!Table->EventSets)
2448 {
2449 /* not enough memory */
2450 goto cleanup;
2451 }
2452
2453 if (Bag)
2454 {
2455 /* add set to property bag */
2456 Status = KsAddItemToObjectBag(Bag, (PVOID)Table->EventSets, NULL);
2457 /* check for success */
2458 if (!NT_SUCCESS(Status))
2459 {
2460 /* cleanup table */
2461 goto cleanup;
2462 }
2463 }
2464 /* now copy the property sets */
2465 Status = KspCopyEventSets(Table, AutomationTableA, AutomationTableB);
2466 if(!NT_SUCCESS(Status))
2467 goto cleanup;
2468 }
2469
2470 /* store result */
2471 *AutomationTableAB = Table;
2472
2473 return Status;
2474
2475
2476 cleanup:
2477
2478 if (Table)
2479 {
2480 if (Table->PropertySets)
2481 {
2482 /* clean property sets */
2483 if (!Bag || !NT_SUCCESS(KsRemoveItemFromObjectBag(Bag, (PVOID)Table->PropertySets, TRUE)))
2484 FreeItem((PVOID)Table->PropertySets);
2485 }
2486
2487 if (Table->MethodSets)
2488 {
2489 /* clean property sets */
2490 if (!Bag || !NT_SUCCESS(KsRemoveItemFromObjectBag(Bag, (PVOID)Table->MethodSets, TRUE)))
2491 FreeItem((PVOID)Table->MethodSets);
2492 }
2493
2494 if (Table->EventSets)
2495 {
2496 /* clean property sets */
2497 if (!Bag || !NT_SUCCESS(KsRemoveItemFromObjectBag(Bag, (PVOID)Table->EventSets, TRUE)))
2498 FreeItem((PVOID)Table->EventSets);
2499 }
2500
2501 if (!Bag || !NT_SUCCESS(KsRemoveItemFromObjectBag(Bag, Table, TRUE)))
2502 FreeItem(Table);
2503 }
2504
2505 return STATUS_INSUFFICIENT_RESOURCES;
2506 }
2507
2508 /*
2509 @unimplemented
2510 */
2511 KSDDKAPI
2512 PUNKNOWN
2513 NTAPI
2514 KsRegisterAggregatedClientUnknown(
2515 IN PVOID Object,
2516 IN PUNKNOWN ClientUnknown)
2517 {
2518 PKSBASIC_HEADER BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
2519
2520 /* sanity check */
2521 ASSERT(BasicHeader->Type == KsObjectTypeDevice || BasicHeader->Type == KsObjectTypeFilterFactory ||
2522 BasicHeader->Type == KsObjectTypeFilter || BasicHeader->Type == KsObjectTypePin);
2523
2524 if (BasicHeader->ClientAggregate)
2525 {
2526 /* release existing aggregate */
2527 BasicHeader->ClientAggregate->lpVtbl->Release(BasicHeader->ClientAggregate);
2528 }
2529
2530 /* increment reference count */
2531 ClientUnknown->lpVtbl->AddRef(ClientUnknown);
2532
2533 /* store client aggregate */
2534 BasicHeader->ClientAggregate = ClientUnknown;
2535
2536 /* return objects outer unknown */
2537 return BasicHeader->OuterUnknown;
2538 }
2539
2540 /*
2541 @unimplemented
2542 */
2543 NTSTATUS
2544 NTAPI
2545 KsRegisterFilterWithNoKSPins(
2546 IN PDEVICE_OBJECT DeviceObject,
2547 IN const GUID* InterfaceClassGUID,
2548 IN ULONG PinCount,
2549 IN BOOL* PinDirection,
2550 IN KSPIN_MEDIUM* MediumList,
2551 IN GUID* CategoryList OPTIONAL)
2552 {
2553 ULONG Size, Index;
2554 NTSTATUS Status;
2555 PWSTR SymbolicLinkList;
2556 //PUCHAR Buffer;
2557 HANDLE hKey;
2558 UNICODE_STRING InterfaceString;
2559 //UNICODE_STRING FilterData = RTL_CONSTANT_STRING(L"FilterData");
2560
2561 if (!InterfaceClassGUID || !PinCount || !PinDirection || !MediumList)
2562 {
2563 /* all these parameters are required */
2564 return STATUS_INVALID_PARAMETER;
2565 }
2566
2567 /* calculate filter data value size */
2568 Size = PinCount * sizeof(KSPIN_MEDIUM);
2569 if (CategoryList)
2570 {
2571 /* add category list */
2572 Size += PinCount * sizeof(GUID);
2573 }
2574
2575 /* FIXME generate filter data blob */
2576 UNIMPLEMENTED
2577
2578 /* get symbolic link list */
2579 Status = IoGetDeviceInterfaces(InterfaceClassGUID, DeviceObject, DEVICE_INTERFACE_INCLUDE_NONACTIVE, &SymbolicLinkList);
2580 if (NT_SUCCESS(Status))
2581 {
2582 /* initialize first symbolic link */
2583 RtlInitUnicodeString(&InterfaceString, SymbolicLinkList);
2584
2585 /* open first device interface registry key */
2586 Status = IoOpenDeviceInterfaceRegistryKey(&InterfaceString, GENERIC_WRITE, &hKey);
2587
2588 if (NT_SUCCESS(Status))
2589 {
2590 /* write filter data */
2591 //Status = ZwSetValueKey(hKey, &FilterData, 0, REG_BINARY, Buffer, Size);
2592
2593 /* close the key */
2594 ZwClose(hKey);
2595 }
2596
2597 if (PinCount)
2598 {
2599 /* update medium cache */
2600 for(Index = 0; Index < PinCount; Index++)
2601 {
2602 KsCacheMedium(&InterfaceString, &MediumList[Index], PinDirection[Index]);
2603 }
2604 }
2605
2606 /* free the symbolic link list */
2607 FreeItem(SymbolicLinkList);
2608 }
2609
2610 return Status;
2611 }