- Fix implementation of KsAddObjectCreateItemToDeviceHeader

- Hackplement KsAllocateObjectCreateItem
- Fix implementation of KsAllocateObjectHeader and store the result either in the passed irp or device header
- Implement Reading / Writing / DeviceIoControl / Flush / QuerySecurity / SetSecurity operation using the object file header
- Implement KsSynchronousIoControlDevice function

svn path=/trunk/; revision=39668

reactos/drivers/ksfilter/ks/irp.c

@@ -61,98 +61,118 @@ KsAddObjectCreateItemToDeviceHeader(
     IN  PSECURITY_DESCRIPTOR SecurityDescriptor)
 {
     PKSIDEVICE_HEADER Header;
-    PKSOBJECT_CREATE_ITEM ItemList;
+    ULONG FreeIndex, Index;
-    PKSIOBJECT_HEADER ObjectList;
 
     Header = (PKSIDEVICE_HEADER)DevHeader;
 
+    DPRINT1("KsAddObjectCreateItemToDeviceHeader entered\n");
+
+     /* check if a device header has been provided */
     if (!DevHeader)
         return STATUS_INVALID_PARAMETER_1;
 
+    /* check if a create item has been provided */
     if (!Create)
         return STATUS_INVALID_PARAMETER_2;
 
+    /* check if a object class has been provided */
     if (!ObjectClass)
         return STATUS_INVALID_PARAMETER_4;
 
-    if (Header->FreeIndex >= Header->MaxItems && Header->ItemsListProvided)
+    FreeIndex = (ULONG)-1;
-        return STATUS_ALLOTTED_SPACE_EXCEEDED;
+    /* now scan the list and check for a free item */
-
+    for(Index = 0; Index < Header->MaxItems; Index++)
-    if (Header->FreeIndex >= Header->MaxItems)
     {
-        ItemList = ExAllocatePoolWithTag(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * (Header->MaxItems + 1), TAG('H','D','S','K'));
+        if (!Header->ItemList[Index].bCreated)
-        if (!ItemList)
-            return STATUS_INSUFFICIENT_RESOURCES;
-
-        ObjectList = ExAllocatePoolWithTag(PagedPool, sizeof(KSIOBJECT_HEADER) * (Header->MaxItems + 1), TAG('H','D','S','K'));
-        if (!ObjectList)
         {
-            ExFreePoolWithTag(ItemList, TAG('H','D','S','K'));
+            if (FreeIndex == (ULONG)-1)
-            return STATUS_INSUFFICIENT_RESOURCES;
+                FreeIndex = Index;
+
+            continue;
+        }
+        else if (!wcsicmp(ObjectClass, Header->ItemList[Index].CreateItem.ObjectClass.Buffer))
+        {
+            /* the same object class already exists */
+            return STATUS_OBJECT_NAME_COLLISION;
         }
-
-        RtlMoveMemory(ItemList, Header->ItemsList, Header->MaxItems * sizeof(KSOBJECT_CREATE_ITEM));
-        ExFreePoolWithTag(Header->ItemsList, TAG('H','D','S','K'));
-
-        RtlMoveMemory(ObjectList, Header->ObjectList, Header->MaxItems * sizeof(KSIOBJECT_HEADER));
-        ExFreePoolWithTag(Header->ObjectList, TAG('H','D','S','K'));
-
-        Header->MaxItems++;
-        Header->ItemsList = ItemList;
     }
-
+    /* found a free index */
-    if (Header->FreeIndex < Header->MaxItems)
+    if (FreeIndex == (ULONG)-1)
     {
-        Header->ItemsList[Header->FreeIndex].Context = Context;
+        /* allocate a new device entry */
-        Header->ItemsList[Header->FreeIndex].Create = Create;
+        PDEVICE_ITEM Item = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_ITEM) * (Header->MaxItems + 1), TAG_DEVICE_HEADER);
-        Header->ItemsList[Header->FreeIndex].Flags = 0;
+        if (!Item)
-        RtlInitUnicodeString(&Header->ItemsList[Header->FreeIndex].ObjectClass, ObjectClass);
+            return STATUS_INSUFFICIENT_RESOURCES;
-        Header->ItemsList[Header->FreeIndex].SecurityDescriptor = SecurityDescriptor;
 
-        Header->FreeIndex++;
+        RtlMoveMemory(Item, Header->ItemList, Header->MaxItems * sizeof(DEVICE_ITEM));
-        return STATUS_SUCCESS;
+        ExFreePoolWithTag(Header->ItemList, TAG_DEVICE_HEADER);
+        
+        Header->ItemList = Item;
+        FreeIndex = Header->MaxItems;
+        Header->MaxItems++;
     }
 
-    return STATUS_ALLOTTED_SPACE_EXCEEDED;
+    /* store the new item */
+    Header->ItemList[FreeIndex].bCreated = TRUE;
+    Header->ItemList[FreeIndex].CreateItem.Create = Create;
+    Header->ItemList[FreeIndex].CreateItem.Context = Context;
+    RtlInitUnicodeString(&Header->ItemList[FreeIndex].CreateItem.ObjectClass, ObjectClass);
+    Header->ItemList[FreeIndex].CreateItem.SecurityDescriptor = SecurityDescriptor;
+    Header->ItemList[FreeIndex].CreateItem.Flags = 0;
+    return STATUS_SUCCESS;
 }
 
 /*
     @implemented
 */
-KSDDKAPI NTSTATUS NTAPI
+KSDDKAPI
+NTSTATUS
+NTAPI
 KsAllocateDeviceHeader(
     OUT KSDEVICE_HEADER* OutHeader,
     IN  ULONG ItemsCount,
     IN  PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL)
 {
+    ULONG Index = 0;
     PKSIDEVICE_HEADER Header;
 
     if (!OutHeader)
         return STATUS_INVALID_PARAMETER;
 
-    Header = ExAllocatePoolWithTag(PagedPool, sizeof(KSIDEVICE_HEADER), TAG('H','D','S','K'));
+    /* allocate a device header */
+    Header = ExAllocatePoolWithTag(PagedPool, sizeof(KSIDEVICE_HEADER), TAG_DEVICE_HEADER);
 
+    /* check for success */
     if (!Header)
         return STATUS_INSUFFICIENT_RESOURCES;
 
+    /* clear all memory */
     RtlZeroMemory(Header, sizeof(KSIDEVICE_HEADER));
 
-    if (ItemsCount)
+    /* initialize spin lock */
+    KeInitializeSpinLock(&Header->ItemListLock);
+
+    /* are there any create items provided */
+    if (ItemsCount && ItemsList)
     {
-        Header->ObjectList = ExAllocatePoolWithTag(PagedPool, sizeof(KSIOBJECT_HEADER) * ItemsCount, TAG('H','D','S','K'));
+        /* allocate space for device item list */
-        if (!Header->ObjectList)
+        Header->ItemList = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_ITEM) * ItemsCount, TAG_DEVICE_HEADER);
+        if (!Header->ItemList)
         {
-            ExFreePoolWithTag(Header, TAG('H','D','S','K'));
+            ExFreePoolWithTag(Header, TAG_DEVICE_HEADER);
             return STATUS_INSUFFICIENT_RESOURCES;
         }
-        RtlZeroMemory(Header->ObjectList, sizeof(KSIOBJECT_HEADER) * ItemsCount);
+        RtlZeroMemory(Header->ItemList, sizeof(DEVICE_ITEM) * ItemsCount);
+
+        for(Index = 0; Index < ItemsCount; Index++)
+        {
+            /* copy provided create items */
+            RtlMoveMemory(&Header->ItemList[Index], &ItemsList[Index], sizeof(KSOBJECT_CREATE_ITEM));
+        }
+        Header->MaxItems = ItemsCount;
     }
 
-    Header->MaxItems = ItemsCount;
+    /* store result */
-    Header->FreeIndex = 0;
-    Header->ItemsList = ItemsList;
-    Header->ItemsListProvided = (ItemsList != NULL) ? TRUE : FALSE;
-
     *OutHeader = Header;
 
     return STATUS_SUCCESS;
@@ -185,25 +205,31 @@ KsAllocateObjectCreateItem(
     //FIXME
     //handle ItemFreeCallback
     //
+    if (AllocateEntry && ItemFreeCallback)
+        DPRINT1("Ignoring ItemFreeCallback\n");
 
-    UNIMPLEMENTED
+    return KsAddObjectCreateItemToDeviceHeader(DevHeader, CreateItem->Create, CreateItem->Context, CreateItem->ObjectClass.Buffer, CreateItem->SecurityDescriptor);
-    return STATUS_UNSUCCESSFUL;
 }
 
 
 /*
-    @unimplemented
+    @implemented
 */
-KSDDKAPI VOID NTAPI
+KSDDKAPI
+VOID
+NTAPI
 KsFreeDeviceHeader(
-    IN  KSDEVICE_HEADER Header)
+    IN  KSDEVICE_HEADER DevHeader)
 {
-    if (!Header)
+    PKSIDEVICE_HEADER Header;
+
+    Header = (PKSIDEVICE_HEADER)DevHeader;
+
+    if (!DevHeader)
         return;
 
-    /* TODO: Free content first */
+    ExFreePoolWithTag(Header->ItemList, TAG_DEVICE_HEADER);
-
+    ExFreePoolWithTag(Header, TAG_DEVICE_HEADER);
-    ExFreePoolWithTag(Header, TAG('H','D','S','K'));
 }
 
 /*
@@ -239,8 +265,11 @@ KsAllocateObjectHeader(
     IN  PIRP Irp,
     IN  KSDISPATCH_TABLE* Table)
 {
+    PIO_STACK_LOCATION IoStack;
+    PDEVICE_EXTENSION DeviceExtension;
     PKSIDEVICE_HEADER DeviceHeader;
-    ULONG Index;
+    PKSIOBJECT_HEADER ObjectHeader;
+    WCHAR ObjectClass[50];
 
     if (!Header)
         return STATUS_INVALID_PARAMETER_1;
@@ -248,14 +277,75 @@ KsAllocateObjectHeader(
     if (!Irp)
         return STATUS_INVALID_PARAMETER_4;
 
-    DeviceHeader = (PKSIDEVICE_HEADER)Irp->Tail.Overlay.DriverContext[3];
+    if (!Table)
-    Index = (ULONG)Irp->Tail.Overlay.DriverContext[2];
+        return STATUS_INVALID_PARAMETER_5;
 
-    RtlCopyMemory(&DeviceHeader->ObjectList[Index].DispatchTable, Table, sizeof(KSDISPATCH_TABLE));
+    /* get current stack location */
-    DeviceHeader->ObjectList[Index].CreateItem = ItemsList;
+    IoStack = IoGetCurrentIrpStackLocation(Irp);
-    DeviceHeader->ObjectList[Index].Initialized = TRUE;
+    /* get device extension */
+    DeviceExtension = (PDEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
+    /* get device header */
+    DeviceHeader = DeviceExtension->DeviceHeader;
+
+    ObjectClass[0] = L'\0';
+    /* check for an file object */
+    if (IoStack->FileObject != NULL)
+    {
+        /* validate the file name */
+        if (IoStack->FileObject->FileName.Length >= 38)
+        {
+            RtlMoveMemory(ObjectClass, IoStack->FileObject->FileName.Buffer, 38 * sizeof(WCHAR));
+            ObjectClass[38] = L'\0';
+            DPRINT1("ObjectClass %S\n", ObjectClass);
+        }
+    }
+    /* allocate the object header */
+    ObjectHeader = ExAllocatePoolWithTag(NonPagedPool, sizeof(KSIOBJECT_HEADER), TAG_DEVICE_HEADER);
+    if (!ObjectHeader)
+        return STATUS_INSUFFICIENT_RESOURCES;
+
+    /* initialize object header */
+    RtlZeroMemory(ObjectHeader, sizeof(KSIOBJECT_HEADER));
+
+    /* do we have a name */
+    if (ObjectClass[0])
+    {
+        ObjectHeader->ObjectClass = ExAllocatePoolWithTag(NonPagedPool, 40 * sizeof(WCHAR), TAG_DEVICE_HEADER);
+        if (ObjectHeader->ObjectClass)
+        {
+            wcscpy(ObjectHeader->ObjectClass, ObjectClass);
+        }
+    }
+
+    /* copy dispatch table */
+    RtlCopyMemory(&ObjectHeader->DispatchTable, Table, sizeof(KSDISPATCH_TABLE));
+    /* store create items */
+    if (ItemsCount && ItemsList)
+    {
+        ObjectHeader->ItemCount = ItemsCount;
+        ObjectHeader->CreateItem = ItemsList;
+    }
+
+    /* was the request for a pin/clock/node */
+    if (IoStack->FileObject)
+    {
+        /* store the object in the file object */
+        ASSERT(IoStack->FileObject->FsContext == NULL);
+        IoStack->FileObject->FsContext = ObjectHeader;
+    }
+    else
+    {
+        /* the object header is for device */
+        ASSERT(DeviceHeader->DeviceIndex < DeviceHeader->MaxItems);
+        DeviceHeader->ItemList[DeviceHeader->DeviceIndex].ObjectHeader = ObjectHeader;
+    }
+
+    /* store result */
+    *Header = ObjectHeader;
+
+
+    DPRINT1("KsAllocateObjectHeader ObjectClass %S FileObject %p, ObjectHeader %p\n", ObjectClass, IoStack->FileObject, ObjectHeader);
 
-    *Header = &DeviceHeader->ObjectList[Index];
     return STATUS_SUCCESS;
 
 }
@@ -263,15 +353,14 @@ KsAllocateObjectHeader(
 /*
     @unimplemented
 */
-KSDDKAPI VOID NTAPI
+KSDDKAPI
+VOID
+NTAPI
 KsFreeObjectHeader(
     IN  PVOID Header)
 {
-    ExFreePoolWithTag(Header, TAG('H','O','S','K'));
 
-    /* TODO */
 
-    UNIMPLEMENTED;
 }
 
 /*
@@ -568,33 +657,34 @@ KsCreate(
     PDEVICE_EXTENSION DeviceExtension;
     PKSIDEVICE_HEADER DeviceHeader;
     ULONG Index;
-    NTSTATUS Status;
+    NTSTATUS Status = STATUS_SUCCESS;
+    KIRQL OldLevel;
 
+    DPRINT1("KS / CREATE\n");
+    /* get current stack location */
     IoStack = IoGetCurrentIrpStackLocation(Irp);
-
+    /* get device extension */
     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
+    /* get device header */
     DeviceHeader = DeviceExtension->DeviceHeader;
 
-    DPRINT1("KS / Create\n");
+    /* acquire list lock */
-
+    KeAcquireSpinLock(&DeviceHeader->ItemListLock, &OldLevel);
-    /* first call all create handlers */
+    /* loop all device items */
-    for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
+    for(Index = 0; Index < DeviceHeader->MaxItems; Index++)
     {
-        KSCREATE_ITEM_IRP_STORAGE(Irp) = &DeviceHeader->ItemsList[Index];
+        if (DeviceHeader->ItemList[Index].bCreated && DeviceHeader->ItemList[Index].ObjectHeader == NULL)
-        
-        Irp->Tail.Overlay.DriverContext[3] = (PVOID)DeviceHeader;
-        Irp->Tail.Overlay.DriverContext[2] = (PVOID)Index;
-
-        DeviceHeader->ObjectList[Index].Initialized = FALSE;
-        Status = DeviceHeader->ItemsList[Index].Create(DeviceObject, Irp);
-        if (!NT_SUCCESS(Status))
         {
-            DeviceHeader->ObjectList[Index].Initialized = FALSE;
+            DeviceHeader->DeviceIndex = Index;
+             /* set object create item */
+            KSCREATE_ITEM_IRP_STORAGE(Irp) = &DeviceHeader->ItemList[Index].CreateItem;
+            Status = DeviceHeader->ItemList[Index].CreateItem.Create(DeviceObject, Irp);
         }
     }
 
-
+    /* release lock */
-    return STATUS_SUCCESS;
+    KeReleaseSpinLock(&DeviceHeader->ItemListLock, OldLevel);
+    return Status;
 }
 
 static NTAPI
@@ -604,28 +694,25 @@ KsClose(
     IN  PIRP Irp)
 {
     PIO_STACK_LOCATION IoStack;
-    PDEVICE_EXTENSION DeviceExtension;
+    PKSIOBJECT_HEADER ObjectHeader;
-    PKSIDEVICE_HEADER DeviceHeader;
+
-    ULONG Index;
+    /* get current stack location */
-    NTSTATUS Status;
+    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
     DPRINT1("KS / CLOSE\n");
 
-    IoStack = IoGetCurrentIrpStackLocation(Irp);
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
-
-    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
-    DeviceHeader = DeviceExtension->DeviceHeader;
-
-    for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
     {
-        if (DeviceHeader->ObjectList[Index].Initialized)
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
-        {
-            Status = DeviceHeader->ObjectList->DispatchTable.Close(DeviceObject, Irp);
-            DeviceHeader->ObjectList[Index].Initialized = FALSE;
-        }
-    }
 
-    return STATUS_SUCCESS;
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
+        return ObjectHeader->DispatchTable.Close(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        return STATUS_SUCCESS;
+    }
 }
 
 static NTAPI
@@ -635,28 +722,25 @@ KsDeviceControl(
     IN  PIRP Irp)
 {
     PIO_STACK_LOCATION IoStack;
-    PDEVICE_EXTENSION DeviceExtension;
+    PKSIOBJECT_HEADER ObjectHeader;
-    PKSIDEVICE_HEADER DeviceHeader;
-    ULONG Index;
-    NTSTATUS Status;
 
+    /* get current stack location */
     IoStack = IoGetCurrentIrpStackLocation(Irp);
 
-    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
+    DPRINT1("KS / DeviceControl\n");
-    DeviceHeader = DeviceExtension->DeviceHeader;
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
-
-    DPRINT1("KS / DeviceControl NumDevices %x\n", DeviceHeader->FreeIndex);
-
-    for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
     {
-        if (DeviceHeader->ObjectList[Index].Initialized)
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
-        {
-            DPRINT1("Calling DeviceIoControl\n");
-            Status = DeviceHeader->ObjectList->DispatchTable.DeviceIoControl(DeviceObject, Irp);
-        }
-    }
 
-    return STATUS_SUCCESS;
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
+        return ObjectHeader->DispatchTable.DeviceIoControl(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        KeBugCheckEx(0, 0, 0, 0, 0);
+        return STATUS_SUCCESS;
+    }
 }
 
 static NTAPI
@@ -666,27 +750,25 @@ KsRead(
     IN  PIRP Irp)
 {
     PIO_STACK_LOCATION IoStack;
-    PDEVICE_EXTENSION DeviceExtension;
+    PKSIOBJECT_HEADER ObjectHeader;
-    PKSIDEVICE_HEADER DeviceHeader;
-    ULONG Index;
-    NTSTATUS Status;
 
+    /* get current stack location */
     IoStack = IoGetCurrentIrpStackLocation(Irp);
 
-    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
-    DeviceHeader = DeviceExtension->DeviceHeader;
-
     DPRINT1("KS / Read\n");
-
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
-    for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
     {
-        if (DeviceHeader->ObjectList[Index].Initialized)
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
-        {
-            Status = DeviceHeader->ObjectList->DispatchTable.Read(DeviceObject, Irp);
-        }
-    }
 
-    return STATUS_SUCCESS;
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
+        return ObjectHeader->DispatchTable.Read(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        KeBugCheckEx(0, 0, 0, 0, 0);
+        return STATUS_SUCCESS;
+    }
 }
 
 static NTAPI
@@ -696,26 +778,25 @@ KsWrite(
     IN  PIRP Irp)
 {
     PIO_STACK_LOCATION IoStack;
-    PDEVICE_EXTENSION DeviceExtension;
+    PKSIOBJECT_HEADER ObjectHeader;
-    PKSIDEVICE_HEADER DeviceHeader;
-    ULONG Index;
-    NTSTATUS Status;
 
+    /* get current stack location */
     IoStack = IoGetCurrentIrpStackLocation(Irp);
 
-    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
-    DeviceHeader = DeviceExtension->DeviceHeader;
-
     DPRINT1("KS / Write\n");
-
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
-    for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
     {
-        if (DeviceHeader->ObjectList[Index].Initialized)
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
-        {
+
-            Status = DeviceHeader->ObjectList->DispatchTable.Write(DeviceObject, Irp);
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
-        }
+        return ObjectHeader->DispatchTable.Write(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        KeBugCheckEx(0, 0, 0, 0, 0);
+        return STATUS_SUCCESS;
     }
-    return STATUS_SUCCESS;
 }
 
 static NTAPI
@@ -724,8 +805,26 @@ KsFlushBuffers(
     IN  PDEVICE_OBJECT DeviceObject,
     IN  PIRP Irp)
 {
+    PIO_STACK_LOCATION IoStack;
+    PKSIOBJECT_HEADER ObjectHeader;
+
+    /* get current stack location */
+    IoStack = IoGetCurrentIrpStackLocation(Irp);
+
     DPRINT1("KS / FlushBuffers\n");
-    return STATUS_UNSUCCESSFUL;
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
+    {
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
+
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
+        return ObjectHeader->DispatchTable.Flush(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        KeBugCheckEx(0, 0, 0, 0, 0);
+        return STATUS_SUCCESS;
+    }
 }
 
 static NTAPI
@@ -734,8 +833,26 @@ KsQuerySecurity(
     IN  PDEVICE_OBJECT DeviceObject,
     IN  PIRP Irp)
 {
+    PIO_STACK_LOCATION IoStack;
+    PKSIOBJECT_HEADER ObjectHeader;
+
+    /* get current stack location */
+    IoStack = IoGetCurrentIrpStackLocation(Irp);
+
     DPRINT1("KS / QuerySecurity\n");
-    return STATUS_UNSUCCESSFUL;
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
+    {
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
+
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
+        return ObjectHeader->DispatchTable.QuerySecurity(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        KeBugCheckEx(0, 0, 0, 0, 0);
+        return STATUS_SUCCESS;
+    }
 }
 
 static NTAPI
@@ -744,8 +861,26 @@ KsSetSecurity(
     IN  PDEVICE_OBJECT DeviceObject,
     IN  PIRP Irp)
 {
+    PIO_STACK_LOCATION IoStack;
+    PKSIOBJECT_HEADER ObjectHeader;
+
+    /* get current stack location */
+    IoStack = IoGetCurrentIrpStackLocation(Irp);
+
     DPRINT1("KS / SetSecurity\n");
-    return STATUS_UNSUCCESSFUL;
+    if (IoStack->FileObject && IoStack->FileObject->FsContext)
+    {
+        ObjectHeader = (PKSIOBJECT_HEADER) IoStack->FileObject->FsContext;
+
+        KSCREATE_ITEM_IRP_STORAGE(Irp) = ObjectHeader->CreateItem;
+        return ObjectHeader->DispatchTable.SetSecurity(DeviceObject, Irp);
+    }
+    else
+    {
+        DPRINT1("Expected Object Header\n");
+        KeBugCheckEx(0, 0, 0, 0, 0);
+        return STATUS_SUCCESS;
+    }
 }
 
 /*

reactos/drivers/ksfilter/ks/kstypes.h

@@ -1,25 +1,34 @@
 #ifndef KSTYPES_H__
 #define KSTYPES_H__
 
+struct KSIDEVICE_HEADER;
+
 typedef struct
 {
     KSDISPATCH_TABLE DispatchTable;
-    LIST_ENTRY ListEntry;
+    LPWSTR ObjectClass;
-    ACCESS_MASK AccessMask;
+    ULONG ItemCount;
     PKSOBJECT_CREATE_ITEM CreateItem;
-    BOOL Initialized;
 
 }KSIOBJECT_HEADER, *PKSIOBJECT_HEADER;
 
 typedef struct
 {
-    ULONG MaxItems;
+    BOOL bCreated;
-    ULONG FreeIndex;
+    PKSIOBJECT_HEADER ObjectHeader;
-    PKSOBJECT_CREATE_ITEM ItemsList;
+    KSOBJECT_CREATE_ITEM CreateItem;
-    PKSIOBJECT_HEADER ObjectList;
+}DEVICE_ITEM, *PDEVICE_ITEM;
-    UCHAR ItemsListProvided;
-    PDEVICE_OBJECT LowerDeviceObject;
 
+
+typedef struct
+{
+    USHORT MaxItems;
+    DEVICE_ITEM *ItemList;
+
+    ULONG DeviceIndex;
+    KSPIN_LOCK ItemListLock;
+
+    PDEVICE_OBJECT NextDeviceObject;
     ERESOURCE SecurityLock;
 }KSIDEVICE_HEADER, *PKSIDEVICE_HEADER;
 

reactos/drivers/ksfilter/ks/misc.c

@@ -228,9 +228,11 @@ KsSetTargetState(
 }
 
 /*
-    @unimplemented
+    @implemented
 */
-KSDDKAPI NTSTATUS NTAPI
+KSDDKAPI
+NTSTATUS
+NTAPI
 KsSynchronousIoControlDevice(
     IN  PFILE_OBJECT FileObject,
     IN  KPROCESSOR_MODE RequestorMode,
@@ -238,11 +240,43 @@ KsSynchronousIoControlDevice(
     IN  PVOID InBuffer,
     IN  ULONG InSize,
     OUT PVOID OutBuffer,
-    IN  ULONG OUtSize,
+    IN  ULONG OutSize,
     OUT PULONG BytesReturned)
 {
-    UNIMPLEMENTED;
+    PDEVICE_OBJECT DeviceObject;
-    return STATUS_UNSUCCESSFUL;
+    KEVENT Event;
+    PIRP Irp;
+    IO_STATUS_BLOCK IoStatusBlock;
+    PIO_STACK_LOCATION IoStack;
+    NTSTATUS Status;
+
+    /* check for valid file object */
+    if (!FileObject)
+        return STATUS_INVALID_PARAMETER;
+
+    /* get device object to send the request to */
+    DeviceObject = IoGetRelatedDeviceObject(FileObject);
+    if (!DeviceObject)
+        return STATUS_UNSUCCESSFUL;
+
+    /* initialize the event */
+    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+    /* create the irp */
+    Irp =  IoBuildDeviceIoControlRequest(IoControl, DeviceObject, InBuffer, InSize, OutBuffer, OutSize, FALSE, &Event, &IoStatusBlock);
+
+    /* HACK */
+    IoStack = IoGetNextIrpStackLocation(Irp);
+    IoStack->FileObject = FileObject;
+
+    Status = IoCallDriver(DeviceObject, Irp);
+    if (Status == STATUS_PENDING)
+    {
+        KeWaitForSingleObject(&Event, Executive, RequestorMode, FALSE, NULL);
+    }
+
+    *BytesReturned = IoStatusBlock.Information;
+    return IoStatusBlock.Status;
 }
 
 

reactos/drivers/ksfilter/ks/priv.h

@@ -1,10 +1,11 @@
 #ifndef PRIV_H__
 #define PRIV_H__
 
+#include <ntifs.h>
 #include <ntddk.h>
 #include <debug.h>
-#include <ks.h>
 #include <portcls.h>
+#include <ks.h>
 #include <kcom.h>
 
 #include "ksfunc.h"
@@ -12,7 +13,7 @@
 #include "ksiface.h"
 
 
-
+#define TAG_DEVICE_HEADER TAG('H','D','S','K')
 
 
 

reactos/drivers/ksfilter/ks/topology.c

@@ -52,7 +52,8 @@ KspCreateObjectType(
                           NULL,
                           IO_NO_PARAMETER_CHECKING | IO_FORCE_ACCESS_CHECK);
 
-    ExFreePool(Name.Buffer);
+    // HACK HACK HACK HACK
+    //ExFreePool(Name.Buffer);
     return Status;
 }