reactos/drivers/ksfilter/ks/property.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/ksfilter/ks/event.c
   5  * PURPOSE:         KS property handling functions
   6  * PROGRAMMER:      Johannes Anderwald
   7  */
   8
   9 #include "priv.h"
  10
  11 const GUID KSPROPTYPESETID_General = {0x97E99BA0L, 0xBDEA, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
  12
  13 NTSTATUS
  14 FindPropertyHandler(
  15     IN PIO_STATUS_BLOCK IoStatus,
  16     IN  const KSPROPERTY_SET* PropertySet,
  17     IN ULONG PropertySetCount,
  18     IN PKSPROPERTY Property,
  19     IN ULONG InputBufferLength,
  20     IN ULONG OutputBufferLength,
  21     OUT PVOID OutputBuffer,
  22     OUT PFNKSHANDLER *PropertyHandler,
  23     OUT PKSPROPERTY_SET * Set,
  24     OUT PKSPROPERTY_ITEM *PropertyItem)
  25 {
  26     ULONG Index, ItemIndex;
  27
  28     for(Index = 0; Index < PropertySetCount; Index++)
  29     {
  30         ASSERT(PropertySet[Index].Set);
  31
  32         if (IsEqualGUIDAligned(&Property->Set, PropertySet[Index].Set))
  33         {
  34             for(ItemIndex = 0; ItemIndex < PropertySet[Index].PropertiesCount; ItemIndex++)
  35             {
  36                 if (PropertySet[Index].PropertyItem[ItemIndex].PropertyId == Property->Id)
  37                 {
  38                     if (PropertySet[Index].PropertyItem[ItemIndex].MinProperty > InputBufferLength)
  39                     {
  40                         /* too small input buffer */
  41                         IoStatus->Information = PropertySet[Index].PropertyItem[ItemIndex].MinProperty;
  42                         return STATUS_INVALID_PARAMETER;
  43                     }
  44
  45                     if (PropertySet[Index].PropertyItem[ItemIndex].MinData > OutputBufferLength)
  46                     {
  47                         /* too small output buffer */
  48                         IoStatus->Information = PropertySet[Index].PropertyItem[ItemIndex].MinData;
  49                         return STATUS_MORE_ENTRIES;
  50                     }
  51
  52                     /* store property set */
  53                     *Set = (PKSPROPERTY_SET)&PropertySet[Index];
  54                     *PropertyItem = (PKSPROPERTY_ITEM)&PropertySet[Index].PropertyItem[ItemIndex];
  55
  56                     if (Property->Flags & KSPROPERTY_TYPE_SET)
  57                     {
  58                         /* store property handler */
  59                         *PropertyHandler = PropertySet[Index].PropertyItem[ItemIndex].SetPropertyHandler;
  60                         return STATUS_SUCCESS;
  61                     }
  62
  63                     if (Property->Flags & KSPROPERTY_TYPE_GET)
  64                     {
  65                         /* store property handler */
  66                         *PropertyHandler = PropertySet[Index].PropertyItem[ItemIndex].GetPropertyHandler;
  67                         return STATUS_SUCCESS;
  68                     }
  69
  70
  71                     if (Property->Flags & KSPROPERTY_TYPE_BASICSUPPORT)
  72                     {
  73                         PULONG Flags;
  74                         PKSPROPERTY_DESCRIPTION Description;
  75
  76                         if (sizeof(ULONG) > OutputBufferLength)
  77                         {
  78                             /* too small buffer */
  79                             return STATUS_INVALID_PARAMETER;
  80                         }
  81
  82                         /* get output buffer */
  83                         Flags = (PULONG)OutputBuffer;
  84
  85                         /* clear flags */
  86                         *Flags = 0;
  87
  88                         IoStatus->Information = sizeof(ULONG);
  89
  90                         if (PropertySet[Index].PropertyItem[ItemIndex].SupportHandler)
  91                         {
  92                             /* use support handler from driver */
  93                             *PropertyHandler = PropertySet[Index].PropertyItem[ItemIndex].SupportHandler;
  94                             return STATUS_SUCCESS;
  95                         }
  96
  97                         if (PropertySet[Index].PropertyItem[ItemIndex].GetSupported)
  98                             *Flags |= KSPROPERTY_TYPE_GET;
  99
 100                         if (PropertySet[Index].PropertyItem[ItemIndex].SetSupported)
 101                             *Flags |= KSPROPERTY_TYPE_SET;
 102
 103                         if (OutputBufferLength >= sizeof(KSPROPERTY_DESCRIPTION))
 104                         {
 105                             /* get output buffer */
 106                             Description = (PKSPROPERTY_DESCRIPTION)OutputBuffer;
 107
 108                             /* store result */
 109                             Description->DescriptionSize = sizeof(KSPROPERTY_DESCRIPTION);
 110                             Description->PropTypeSet.Set = KSPROPTYPESETID_General;
 111                             Description->PropTypeSet.Id = 0;
 112                             Description->PropTypeSet.Flags = 0;
 113                             Description->MembersListCount = 0;
 114                             Description->Reserved = 0;
 115
 116                             IoStatus->Information = sizeof(KSPROPERTY_DESCRIPTION);
 117                         }
 118                         return STATUS_SUCCESS;
 119                     }
 120                 }
 121             }
 122         }
 123     }
 124     return STATUS_NOT_FOUND;
 125 }
 126
 127
 128 NTSTATUS
 129 KspPropertyHandler(
 130     IN PIRP Irp,
 131     IN  ULONG PropertySetsCount,
 132     IN  const KSPROPERTY_SET* PropertySet,
 133     IN  PFNKSALLOCATOR Allocator OPTIONAL,
 134     IN  ULONG PropertyItemSize OPTIONAL)
 135 {
 136     PKSPROPERTY Property;
 137     PKSPROPERTY_ITEM PropertyItem;
 138     PKSPROPERTY_SET Set;
 139     PIO_STACK_LOCATION IoStack;
 140     NTSTATUS Status;
 141     PFNKSHANDLER PropertyHandler = NULL;
 142     ULONG Index, InputBufferLength, OutputBufferLength, TotalSize;
 143     LPGUID Guid;
 144     //UNICODE_STRING GuidBuffer;
 145
 146     /* get current irp stack */
 147     IoStack = IoGetCurrentIrpStackLocation(Irp);
 148
 149     /* get parameters */
 150     OutputBufferLength = (IoStack->Parameters.DeviceIoControl.OutputBufferLength + 7) & ~7;
 151     InputBufferLength = IoStack->Parameters.DeviceIoControl.InputBufferLength;
 152
 153     /* check for invalid buffer length size */
 154     if (OutputBufferLength < IoStack->Parameters.DeviceIoControl.OutputBufferLength)
 155     {
 156         /* unsigned overflow */
 157         return STATUS_INVALID_BUFFER_SIZE;
 158     }
 159
 160     /* check for integer overflow */
 161     if (InputBufferLength + OutputBufferLength < IoStack->Parameters.DeviceIoControl.OutputBufferLength)
 162     {
 163         /* overflow */
 164         return STATUS_INVALID_BUFFER_SIZE;
 165     }
 166
 167     /* check if inputbuffer at least holds KSPROPERTY item */
 168     if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY))
 169     {
 170         /* invalid parameter */
 171         return STATUS_INVALID_BUFFER_SIZE;
 172     }
 173
 174     /* get total size */
 175     TotalSize = InputBufferLength + OutputBufferLength;
 176
 177     /* get input property request */
 178     Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 179
 180     /* have the parameters been checked yet */
 181     if (!Irp->AssociatedIrp.SystemBuffer)
 182     {
 183         /* is it from user mode */
 184         if (Irp->RequestorMode == UserMode)
 185         {
 186             /* probe user buffer */
 187             ProbeForRead(IoStack->Parameters.DeviceIoControl.Type3InputBuffer, InputBufferLength, 1);
 188         }
 189
 190         /* do we have an allocator */
 191         if ((Allocator) && (Property->Flags & (KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_SET)))
 192         {
 193             /* call allocator */
 194             Status = Allocator(Irp, TotalSize, (Property->Flags & KSPROPERTY_TYPE_GET));
 195
 196             /* check for success */
 197             if (!NT_SUCCESS(Status))
 198                 return Status;
 199         }
 200         else
 201         {
 202             /* allocate buffer */
 203             Irp->AssociatedIrp.SystemBuffer = AllocateItem(NonPagedPool, TotalSize);
 204
 205             /* sanity check */
 206             ASSERT(Irp->AssociatedIrp.SystemBuffer != NULL);
 207
 208             /* mark irp as buffered so that changes the stream headers are propagated back */
 209             Irp->Flags |= IRP_DEALLOCATE_BUFFER | IRP_BUFFERED_IO;
 210         }
 211
 212         /* now copy the buffer */
 213         RtlCopyMemory((PVOID)((ULONG_PTR)Irp->AssociatedIrp.SystemBuffer + OutputBufferLength), IoStack->Parameters.DeviceIoControl.Type3InputBuffer, InputBufferLength);
 214
 215         /* use new property buffer */
 216         Property = (PKSPROPERTY)((ULONG_PTR)Irp->AssociatedIrp.SystemBuffer + OutputBufferLength);
 217
 218         /* is it a set operation */
 219         if (Property->Flags & KSPROPERTY_TYPE_SET)
 220         {
 221             /* for set operations, the output parameters need to be copied */
 222             if (Irp->RequestorMode == UserMode)
 223             {
 224                 /* probe user parameter */
 225                 ProbeForRead(Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength, 1);
 226             }
 227
 228             /* copy parameters, needs un-aligned parameter length */
 229             RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
 230         }
 231
 232         /* is there an output buffer */
 233         if (IoStack->Parameters.DeviceIoControl.OutputBufferLength)
 234         {
 235             /* is it from user mode */
 236             if (Irp->RequestorMode == UserMode)
 237             {
 238                 /* probe buffer for writing */
 239                 ProbeForWrite(Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength, 1);
 240             }
 241
 242             if (!Allocator || !(Property->Flags & KSPROPERTY_TYPE_GET))
 243             {
 244                 /* it is an input operation */
 245                 Irp->Flags |= IRP_INPUT_OPERATION;
 246             }
 247         }
 248     }
 249     else
 250     {
 251         /* use new property buffer */
 252         Property = (PKSPROPERTY)((ULONG_PTR)Irp->AssociatedIrp.SystemBuffer + OutputBufferLength);
 253     }
 254
 255     //RtlStringFromGUID(&Property->Set, &GuidBuffer);
 256
 257     //DPRINT("KspPropertyHandler Irp %p PropertySetsCount %u PropertySet %p Allocator %p PropertyItemSize %u ExpectedPropertyItemSize %u\n", Irp, PropertySetsCount, PropertySet, Allocator, PropertyItemSize, sizeof(KSPROPERTY_ITEM));
 258     //DPRINT("PropertyId %lu PropertyFlags %x Guid %S\n", Property->Id, Property->Flags, GuidBuffer.Buffer);
 259
 260     //RtlFreeUnicodeString(&GuidBuffer);
 261
 262     /* sanity check */
 263     ASSERT(PropertyItemSize == 0 || PropertyItemSize == sizeof(KSPROPERTY_ITEM));
 264
 265     /* find the property handler */
 266     Status = FindPropertyHandler(&Irp->IoStatus, PropertySet, PropertySetsCount, Property, InputBufferLength, OutputBufferLength, Irp->AssociatedIrp.SystemBuffer, &PropertyHandler, &Set, &PropertyItem);
 267
 268     if (NT_SUCCESS(Status) && PropertyHandler)
 269     {
 270         /* store set */
 271         KSPROPERTY_SET_IRP_STORAGE(Irp) = Set;
 272
 273         /* are any custom property item sizes used */
 274         if (PropertyItemSize)
 275         {
 276             /* store custom property item */
 277             KSPROPERTY_ITEM_IRP_STORAGE(Irp) = PropertyItem;
 278         }
 279
 280         /* call property handler */
 281         Status = PropertyHandler(Irp, Property, (OutputBufferLength > 0 ? Irp->AssociatedIrp.SystemBuffer : NULL));
 282
 283         if (Status == STATUS_BUFFER_TOO_SMALL)
 284         {
 285             /* output buffer is too small */
 286             if (Allocator)
 287             {
 288                 /* allocate the requested amount */
 289                 Status = Allocator(Irp, Irp->IoStatus.Information, FALSE);
 290
 291                 /* check if the block was allocated */
 292                 if (!NT_SUCCESS(Status))
 293                 {
 294                     /* no memory */
 295                     return STATUS_INSUFFICIENT_RESOURCES;
 296                 }
 297
 298                 /* re-call property handler */
 299                 Status = PropertyHandler(Irp, Property, Irp->AssociatedIrp.SystemBuffer);
 300             }
 301         }
 302     }
 303     else if (IsEqualGUIDAligned(&Property->Set, &GUID_NULL) && Property->Id == 0 && (Property->Flags & KSPROPERTY_TYPE_SETSUPPORT) == KSPROPERTY_TYPE_SETSUPPORT)
 304     {
 305         // store output size
 306         Irp->IoStatus.Information = sizeof(GUID) * PropertySetsCount;
 307         if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GUID) * PropertySetsCount)
 308         {
 309             // buffer too small
 310             return STATUS_MORE_ENTRIES;
 311         }
 312
 313         // get output buffer
 314         Guid = (LPGUID)Irp->AssociatedIrp.SystemBuffer;
 315
 316        // copy property guids from property sets
 317        for(Index = 0; Index < PropertySetsCount; Index++)
 318        {
 319            RtlMoveMemory(&Guid[Index], PropertySet[Index].Set, sizeof(GUID));
 320        }
 321        Status = STATUS_SUCCESS;
 322     }
 323
 324     /* done */
 325     return Status;
 326 }
 327
 328 /*
 329     @implemented
 330 */
 331 KSDDKAPI
 332 NTSTATUS
 333 NTAPI
 334 KsPropertyHandler(
 335     IN  PIRP Irp,
 336     IN  ULONG PropertySetsCount,
 337     IN  const KSPROPERTY_SET* PropertySet)
 338 {
 339     return KspPropertyHandler(Irp, PropertySetsCount, PropertySet, NULL, 0);
 340 }
 341
 342
 343 /*
 344     @implemented
 345 */
 346 KSDDKAPI
 347 NTSTATUS
 348 NTAPI
 349 KsPropertyHandlerWithAllocator(
 350     IN  PIRP Irp,
 351     IN  ULONG PropertySetsCount,
 352     IN  PKSPROPERTY_SET PropertySet,
 353     IN  PFNKSALLOCATOR Allocator OPTIONAL,
 354     IN  ULONG PropertyItemSize OPTIONAL)
 355 {
 356     return KspPropertyHandler(Irp, PropertySetsCount, PropertySet, Allocator, PropertyItemSize);
 357 }
 358
 359 NTSTATUS
 360 FindFastPropertyHandler(
 361     IN ULONG FastIoCount,
 362     IN const KSFASTPROPERTY_ITEM * FastIoTable,
 363     IN PKSPROPERTY PropertyId,
 364     OUT PFNKSFASTHANDLER * FastPropertyHandler)
 365 {
 366     ULONG Index;
 367
 368     /* iterate through all items */
 369     for(Index = 0; Index < FastIoCount; Index++)
 370     {
 371         if (PropertyId->Id == FastIoTable[Index].PropertyId)
 372         {
 373             if (PropertyId->Flags & KSPROPERTY_TYPE_SET)
 374             {
 375                 if (FastIoTable[Index].SetSupported)
 376                 {
 377                     *FastPropertyHandler = FastIoTable[Index].SetPropertyHandler;
 378                     return STATUS_SUCCESS;
 379                 }
 380             }
 381
 382             if (PropertyId->Flags & KSPROPERTY_TYPE_GET)
 383             {
 384                 if (FastIoTable[Index].GetSupported)
 385                 {
 386                     *FastPropertyHandler = FastIoTable[Index].GetPropertyHandler;
 387                     return STATUS_SUCCESS;
 388                 }
 389             }
 390         }
 391
 392     }
 393     /* no fast property handler found */
 394     return STATUS_NOT_FOUND;
 395 }
 396
 397
 398 /*
 399     @implemented
 400 */
 401 KSDDKAPI
 402 BOOLEAN
 403 NTAPI
 404 KsFastPropertyHandler(
 405     IN  PFILE_OBJECT FileObject,
 406     IN  PKSPROPERTY UNALIGNED Property,
 407     IN  ULONG PropertyLength,
 408     IN  OUT PVOID UNALIGNED Data,
 409     IN  ULONG DataLength,
 410     OUT PIO_STATUS_BLOCK IoStatus,
 411     IN  ULONG PropertySetsCount,
 412     IN  const KSPROPERTY_SET* PropertySet)
 413 {
 414     KSPROPERTY PropRequest;
 415     KPROCESSOR_MODE Mode;
 416     NTSTATUS Status = STATUS_SUCCESS;
 417     ULONG Index;
 418     PFNKSFASTHANDLER FastPropertyHandler;
 419
 420     if (PropertyLength < sizeof(KSPROPERTY))
 421     {
 422         /* invalid request */
 423         return FALSE;
 424     }
 425
 426     /* get previous mode */
 427     Mode = ExGetPreviousMode();
 428
 429     if (Mode == KernelMode)
 430     {
 431         /* just copy it */
 432         RtlMoveMemory(&PropRequest, Property, sizeof(KSPROPERTY));
 433     }
 434     else
 435     {
 436         /* need to probe the buffer */
 437         _SEH2_TRY
 438         {
 439             ProbeForRead(Property, sizeof(KSPROPERTY), sizeof(UCHAR));
 440             RtlMoveMemory(&PropRequest, Property, sizeof(KSPROPERTY));
 441         }
 442         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 443         {
 444             /* Exception, get the error code */
 445             Status = _SEH2_GetExceptionCode();
 446         }_SEH2_END;
 447
 448         if (!NT_SUCCESS(Status))
 449             return FALSE;
 450     }
 451
 452     /* are there any property sets provided */
 453     if (PropertySetsCount)
 454     {
 455         /* iterate through all property sets count */
 456         Index = 0;
 457         do
 458         {
 459             /* does the property id match */
 460             if (IsEqualGUIDAligned(PropertySet[Index].Set, &PropRequest.Set))
 461             {
 462                 /* try to find a fast property handler */
 463                 Status = FindFastPropertyHandler(PropertySet[Index].FastIoCount, PropertySet[Index].FastIoTable, &PropRequest, &FastPropertyHandler);
 464
 465                 if (NT_SUCCESS(Status))
 466                 {
 467                     /* call fast property handler */
 468                     ASSERT(PropertyLength == sizeof(KSPROPERTY)); /* FIXME check if property length is bigger -> copy params */
 469                     ASSERT(Mode == KernelMode); /* FIXME need to probe usermode output buffer */
 470                     return FastPropertyHandler(FileObject, &PropRequest, sizeof(KSPROPERTY), Data, DataLength, IoStatus);
 471                 }
 472             }
 473             /* move to next item */
 474             Index++;
 475         }while(Index < PropertySetsCount);
 476     }
 477     return FALSE;
 478 }
 479
 480 /*
 481     @implemented
 482 */
 483 KSDDKAPI
 484 NTSTATUS
 485 NTAPI
 486 KsDispatchSpecificProperty(
 487     IN  PIRP Irp,
 488     IN  PFNKSHANDLER Handler)
 489 {
 490     PIO_STACK_LOCATION IoStack;
 491
 492     /* get current irp stack location */
 493     IoStack = IoGetCurrentIrpStackLocation(Irp);
 494
 495     return Handler(Irp, IoStack->Parameters.DeviceIoControl.Type3InputBuffer, Irp->UserBuffer);
 496 }
 497