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