reactos/drivers/ksfilter/ks/misc.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/ksfilter/ks/misc.c
   5  * PURPOSE:         KS Allocator functions
   6  * PROGRAMMER:      Johannes Anderwald
   7  */
   8
   9
  10 #include "priv.h"
  11
  12 PVOID
  13 AllocateItem(
  14     IN POOL_TYPE PoolType,
  15     IN SIZE_T NumberOfBytes)
  16 {
  17     PVOID Item = ExAllocatePool(PoolType, NumberOfBytes);
  18     if (!Item)
  19         return Item;
  20
  21     RtlZeroMemory(Item, NumberOfBytes);
  22     return Item;
  23 }
  24
  25 VOID
  26 FreeItem(
  27     IN PVOID Item)
  28 {
  29
  30     ExFreePool(Item);
  31 }
  32
  33 NTSTATUS
  34 NTAPI
  35 KspForwardIrpSynchronousCompletion(
  36     IN PDEVICE_OBJECT  DeviceObject,
  37     IN PIRP  Irp,
  38     IN PVOID  Context)
  39 {
  40     if (Irp->PendingReturned == TRUE)
  41     {
  42         KeSetEvent ((PKEVENT) Context, IO_NO_INCREMENT, FALSE);
  43     }
  44     return STATUS_MORE_PROCESSING_REQUIRED;
  45 }
  46
  47
  48 NTSTATUS
  49 KspForwardIrpSynchronous(
  50     IN  PDEVICE_OBJECT DeviceObject,
  51     IN  PIRP Irp)
  52 {
  53     KEVENT Event;
  54     NTSTATUS Status;
  55     PDEVICE_EXTENSION DeviceExtension;
  56     PKSIDEVICE_HEADER DeviceHeader;
  57
  58     ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
  59
  60     /* get device extension */
  61     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
  62     /* get device header */
  63     DeviceHeader = DeviceExtension->DeviceHeader;
  64
  65     /* initialize the notification event */
  66     KeInitializeEvent(&Event, NotificationEvent, FALSE);
  67
  68     IoCopyCurrentIrpStackLocationToNext(Irp);
  69
  70     IoSetCompletionRoutine(Irp, KspForwardIrpSynchronousCompletion, (PVOID)&Event, TRUE, TRUE, TRUE);
  71
  72     /* now call the driver */
  73     Status = IoCallDriver(DeviceHeader->BaseDevice, Irp);
  74     /* did the request complete yet */
  75     if (Status == STATUS_PENDING)
  76     {
  77         /* not yet, lets wait a bit */
  78         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
  79         Status = Irp->IoStatus.Status;
  80     }
  81     return Status;
  82 }
  83
  84 /*
  85     @unimplemented
  86 */
  87 KSDDKAPI NTSTATUS NTAPI
  88 KsPinDataIntersectionEx(
  89     IN  PIRP Irp,
  90     IN  PKSP_PIN Pin,
  91     OUT PVOID Data,
  92     IN  ULONG DescriptorsCount,
  93     IN  const KSPIN_DESCRIPTOR* Descriptor,
  94     IN  ULONG DescriptorSize,
  95     IN  PFNKSINTERSECTHANDLEREX IntersectHandler OPTIONAL,
  96     IN  PVOID HandlerContext OPTIONAL)
  97 {
  98     UNIMPLEMENTED;
  99     return STATUS_UNSUCCESSFUL;
 100 }
 101
 102
 103 NTSTATUS
 104 KspCopyCreateRequest(
 105     IN PIRP Irp,
 106     IN LPWSTR ObjectClass,
 107     IN OUT PULONG Size,
 108     OUT PVOID * Result)
 109 {
 110     PIO_STACK_LOCATION IoStack;
 111     ULONG ObjectLength, ParametersLength;
 112     PVOID Buffer;
 113
 114     /* get current irp stack */
 115     IoStack = IoGetCurrentIrpStackLocation(Irp);
 116
 117     /* get object class length */
 118     ObjectLength = (wcslen(ObjectClass) + 2) * sizeof(WCHAR);
 119
 120     /* check for minium length requirement */
 121     if (ObjectLength  + *Size > IoStack->FileObject->FileName.MaximumLength)
 122         return STATUS_UNSUCCESSFUL;
 123
 124     /* extract parameters length */
 125     ParametersLength = IoStack->FileObject->FileName.MaximumLength - ObjectLength;
 126
 127     /* allocate buffer */
 128     Buffer = AllocateItem(NonPagedPool, ParametersLength);
 129     if (!Buffer)
 130         return STATUS_INSUFFICIENT_RESOURCES;
 131
 132     /* copy parameters */
 133     RtlMoveMemory(Buffer, &IoStack->FileObject->FileName.Buffer[ObjectLength / sizeof(WCHAR)], ParametersLength);
 134
 135     /* store result */
 136     *Result = Buffer;
 137     *Size = ParametersLength;
 138
 139     return STATUS_SUCCESS;
 140 }
 141
 142 /*
 143     @implemented
 144 */
 145 KSDDKAPI
 146 PVOID
 147 NTAPI
 148 KsGetObjectFromFileObject(
 149     IN PFILE_OBJECT FileObject)
 150 {
 151     PKSIOBJECT_HEADER ObjectHeader;
 152
 153     /* get object header */
 154     ObjectHeader = (PKSIOBJECT_HEADER)FileObject->FsContext;
 155
 156     /* return associated object */
 157     return ObjectHeader->ObjectType;
 158 }
 159
 160 /*
 161     @implemented
 162 */
 163 KSDDKAPI
 164 KSOBJECTTYPE
 165 NTAPI
 166 KsGetObjectTypeFromFileObject(
 167     IN PFILE_OBJECT FileObject)
 168 {
 169     PKSIOBJECT_HEADER ObjectHeader;
 170
 171     /* get object header */
 172     ObjectHeader = (PKSIOBJECT_HEADER)FileObject->FsContext;
 173     /* return type */
 174     return ObjectHeader->Type;
 175 }
 176
 177 /*
 178     @implemented
 179 */
 180 KSOBJECTTYPE
 181 NTAPI
 182 KsGetObjectTypeFromIrp(
 183     IN PIRP  Irp)
 184 {
 185     PKSIOBJECT_HEADER ObjectHeader;
 186     PIO_STACK_LOCATION IoStack;
 187
 188     /* get current irp stack */
 189     IoStack = IoGetCurrentIrpStackLocation(Irp);
 190     /* get object header */
 191     ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext;
 192     /* return type */
 193     return ObjectHeader->Type;
 194 }
 195
 196 /*
 197     @unimplemented
 198 */
 199 PUNKNOWN
 200 NTAPI
 201 KsGetOuterUnknown(
 202     IN PVOID  Object)
 203 {
 204     UNIMPLEMENTED
 205     return NULL;
 206
 207 }
 208
 209 /*
 210     @implemented
 211 */
 212 KSDDKAPI
 213 PVOID
 214 NTAPI
 215 KsGetParent(
 216     IN PVOID Object)
 217 {
 218     PKSBASIC_HEADER BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
 219     /* sanity check */
 220     ASSERT(BasicHeader->Parent.KsDevice != NULL);
 221     /* return object type */
 222     return (PVOID)BasicHeader->Parent.KsDevice;
 223 }
 224
 225