reactos/drivers/ksfilter/ks/irp.c

   1 /*
   2     ReactOS Kernel Streaming
   3     IRP Helpers
   4 */
   5
   6 #include <ntddk.h>
   7 #include <debug.h>
   8 #include <ks.h>
   9
  10 #define TAG(A, B, C, D) (IN ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
  11
  12 /*
  13     @unimplemented
  14 */
  15 KSDDKAPI NTSTATUS NTAPI
  16 KsAcquireResetValue(
  17     IN  PIRP Irp,
  18     OUT KSRESET* ResetValue)
  19 {
  20     UNIMPLEMENTED;
  21     return STATUS_UNSUCCESSFUL;
  22 }
  23
  24 /*
  25     @unimplemented
  26 */
  27 KSDDKAPI VOID NTAPI
  28 KsAddIrpToCancelableQueue(
  29     IN  OUT PLIST_ENTRY QueueHead,
  30     IN  PKSPIN_LOCK SpinLock,
  31     IN  PIRP Irp,
  32     IN  KSLIST_ENTRY_LOCATION ListLocation,
  33     IN  PDRIVER_CANCEL DriverCancel OPTIONAL)
  34 {
  35     UNIMPLEMENTED;
  36 }
  37
  38 /*
  39     @unimplemented
  40 */
  41 KSDDKAPI NTSTATUS NTAPI
  42 KsAddObjectCreateItemToDeviceHeader(
  43     IN  KSDEVICE_HEADER Header,
  44     IN  PDRIVER_DISPATCH Create,
  45     IN  PVOID Context,
  46     IN  PWCHAR ObjectClass,
  47     IN  PSECURITY_DESCRIPTOR SecurityDescriptor)
  48 {
  49     UNIMPLEMENTED;
  50     return STATUS_UNSUCCESSFUL;
  51 }
  52
  53 /*
  54     @unimplemented
  55 */
  56 KSDDKAPI NTSTATUS NTAPI
  57 KsAddObjectCreateItemToObjectHeader(
  58     IN  KSOBJECT_HEADER Header,
  59     IN  PDRIVER_DISPATCH Create,
  60     IN  PVOID Context,
  61     IN  PWCHAR ObjectClass,
  62     IN  PSECURITY_DESCRIPTOR SecurityDescriptor)
  63 {
  64     UNIMPLEMENTED;
  65     return STATUS_UNSUCCESSFUL;
  66 }
  67
  68 /*
  69     @unimplemented
  70 */
  71 KSDDKAPI NTSTATUS NTAPI
  72 KsAllocateDeviceHeader(
  73     OUT KSDEVICE_HEADER* Header,
  74     IN  ULONG ItemsCount,
  75     IN  PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL)
  76 {
  77     /* Allocates memory for the KSDEVICE_HEADER structure */
  78
  79     if ( ! Header )
  80         return STATUS_INVALID_PARAMETER;
  81
  82     Header = ExAllocatePoolWithTag(PagedPool, sizeof(KSDEVICE_HEADER), TAG('H','D','S','K'));
  83
  84     if ( ! Header )
  85         return STATUS_INSUFFICIENT_RESOURCES;
  86
  87     /* TODO: Actually do something with the header, perhaps? */
  88
  89     return STATUS_SUCCESS;
  90 }
  91
  92 /*
  93     @unimplemented
  94 */
  95 KSDDKAPI VOID NTAPI
  96 KsFreeDeviceHeader(
  97     IN  KSDEVICE_HEADER Header)
  98 {
  99     if ( ! Header )
 100         return;
 101
 102     /* TODO: Free content first */
 103
 104     ExFreePoolWithTag(Header, TAG('H','D','S','K'));
 105 }
 106
 107 /*
 108     @unimplemented
 109 */
 110 KSDDKAPI NTSTATUS NTAPI
 111 KsAllocateExtraData(
 112     IN  PIRP Irp,
 113     IN  ULONG ExtraSize,
 114     OUT PVOID* ExtraBuffer)
 115 {
 116     UNIMPLEMENTED;
 117     return STATUS_UNSUCCESSFUL;
 118 }
 119
 120 /*
 121     @unimplemented
 122
 123     http://www.osronline.com/DDKx/stream/ksfunc_3sc3.htm
 124 */
 125 KSDDKAPI NTSTATUS NTAPI
 126 KsAllocateObjectCreateItem(
 127     IN  KSDEVICE_HEADER Header,
 128     IN  PKSOBJECT_CREATE_ITEM CreateItem,
 129     IN  BOOLEAN AllocateEntry,
 130     IN  PFNKSITEMFREECALLBACK ItemFreeCallback OPTIONAL)
 131 {
 132     UNIMPLEMENTED;
 133     return STATUS_UNSUCCESSFUL;
 134 }
 135
 136 /*
 137     @unimplemented
 138
 139     Initialize the required file context header.
 140     Allocates KSOBJECT_HEADER structure.
 141     Irp is an IRP_MJ_CREATE structure.
 142     Driver must allocate KSDISPATCH_TABLE and initialize it first.
 143
 144     http://www.osronline.com/DDKx/stream/ksfunc_0u2b.htm
 145 */
 146 KSDDKAPI NTSTATUS NTAPI
 147 KsAllocateObjectHeader(
 148     OUT PVOID Header,
 149     IN  ULONG ItemsCount,
 150     IN  PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL,
 151     IN  PIRP Irp,
 152     IN  KSDISPATCH_TABLE* Table)
 153 {
 154     /* NOTE: PKSOBJECT_HEADER is not defined yet */
 155 #if 0
 156     PKSOBJECT_HEADER object_header;
 157
 158     /* TODO: Validate parameters */
 159
 160     object_header = ExAllocatePoolWithTag(PagedPool, sizeof(KSOBJECT_HEADER), TAG('H','O','S','K'));
 161
 162     if ( ! object_header )
 163     {
 164         return STATUS_INSUFFICIENT_RESOURCES;
 165     }
 166
 167     (PVOID)(*Header) = object_header;
 168
 169     /* TODO ... */
 170 #endif
 171
 172     UNIMPLEMENTED;
 173     return STATUS_UNSUCCESSFUL;
 174 }
 175
 176 /*
 177     @unimplemented
 178 */
 179 KSDDKAPI VOID NTAPI
 180 KsFreeObjectHeader(
 181     IN  PVOID Header)
 182 {
 183     ExFreePoolWithTag(Header, TAG('H','O','S','K'));
 184
 185     /* TODO */
 186
 187     UNIMPLEMENTED;
 188 }
 189
 190 /*
 191     @unimplemented
 192 */
 193 KSDDKAPI VOID NTAPI
 194 KsCancelIo(
 195     IN  OUT PLIST_ENTRY QueueHead,
 196     IN  PKSPIN_LOCK SpinLock)
 197 {
 198     UNIMPLEMENTED;
 199 }
 200
 201 /*
 202     @unimplemented
 203 */
 204 KSDDKAPI VOID NTAPI
 205 KsCancelRoutine(
 206     IN  PDEVICE_OBJECT DeviceObject,
 207     IN  PIRP Irp)
 208 {
 209     UNIMPLEMENTED;
 210 }
 211
 212 /*
 213     @unimplemented
 214 */
 215 KSDDKAPI NTSTATUS NTAPI
 216 KsDefaultDeviceIoCompletion(
 217     IN  PDEVICE_OBJECT DeviceObject,
 218     IN  PIRP Irp)
 219 {
 220     UNIMPLEMENTED;
 221     return STATUS_UNSUCCESSFUL;
 222 }
 223
 224 /*
 225     @unimplemented
 226 */
 227 KSDDKAPI BOOLEAN NTAPI
 228 KsDispatchFastIoDeviceControlFailure(
 229     IN  PFILE_OBJECT FileObject,
 230     IN  BOOLEAN Wait,
 231     IN  PVOID InputBuffer  OPTIONAL,
 232     IN  ULONG InputBufferLength,
 233     OUT PVOID OutputBuffer  OPTIONAL,
 234     IN  ULONG OutputBufferLength,
 235     IN  ULONG IoControlCode,
 236     OUT PIO_STATUS_BLOCK IoStatus,
 237     IN  PDEVICE_OBJECT DeviceObject)   /* always return false */
 238 {
 239     return FALSE;
 240 }
 241
 242 /*
 243     @unimplemented
 244 */
 245 KSDDKAPI BOOLEAN NTAPI
 246 KsDispatchFastReadFailure(
 247     IN  PFILE_OBJECT FileObject,
 248     IN  PLARGE_INTEGER FileOffset,
 249     IN  ULONG Length,
 250     IN  BOOLEAN Wait,
 251     IN  ULONG LockKey,
 252     OUT PVOID Buffer,
 253     OUT PIO_STATUS_BLOCK IoStatus,
 254     IN  PDEVICE_OBJECT DeviceObject)   /* always return false */
 255 {
 256     return FALSE;
 257 }
 258
 259 /*
 260     Used in dispatch table entries that aren't handled and need to return
 261     STATUS_INVALID_DEVICE_REQUEST.
 262 */
 263 KSDDKAPI NTSTATUS NTAPI
 264 KsDispatchInvalidDeviceRequest(
 265     IN  PDEVICE_OBJECT DeviceObject,
 266     IN  PIRP Irp)
 267 {
 268     Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
 269     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 270
 271     return STATUS_INVALID_DEVICE_REQUEST;
 272 }
 273
 274 /*
 275     @unimplemented
 276 */
 277 KSDDKAPI NTSTATUS NTAPI
 278 KsDispatchIrp(
 279     IN  PDEVICE_OBJECT DeviceObject,
 280     IN  PIRP Irp)
 281 {
 282     /* Calls a dispatch routine corresponding to the function code of the IRP */
 283
 284     /*
 285         First we need to get the dispatch table. An opaque header is pointed to by
 286         FsContext. The first element points to this table. This table is the key
 287         to dispatching the IRP correctly.
 288     */
 289
 290     UNIMPLEMENTED;
 291     return STATUS_UNSUCCESSFUL;
 292 }
 293
 294 /*
 295     @unimplemented
 296 */
 297 KSDDKAPI NTSTATUS NTAPI
 298 KsDispatchSpecificMethod(
 299     IN  PIRP Irp,
 300     IN  PFNKSHANDLER Handler)
 301 {
 302     UNIMPLEMENTED;
 303     return STATUS_UNSUCCESSFUL;
 304 }
 305
 306 /*
 307     @unimplemented
 308 */
 309 KSDDKAPI NTSTATUS NTAPI
 310 KsDispatchSpecificProperty(
 311     IN  PIRP Irp,
 312     IN  PFNKSHANDLER Handler)
 313 {
 314     UNIMPLEMENTED;
 315     return STATUS_UNSUCCESSFUL;
 316 }
 317
 318 /*
 319     @unimplemented
 320 */
 321 KSDDKAPI NTSTATUS NTAPI
 322 KsForwardAndCatchIrp(
 323     IN  PDEVICE_OBJECT DeviceObject,
 324     IN  PIRP Irp,
 325     IN  PFILE_OBJECT FileObject,
 326     IN  KSSTACK_USE StackUse)
 327 {
 328     UNIMPLEMENTED;
 329     return STATUS_UNSUCCESSFUL;
 330 }
 331
 332 /*
 333     @unimplemented
 334 */
 335 KSDDKAPI NTSTATUS NTAPI
 336 KsForwardIrp(
 337     IN  PIRP Irp,
 338     IN  PFILE_OBJECT FileObject,
 339     IN  BOOLEAN ReuseStackLocation)
 340 {
 341     UNIMPLEMENTED;
 342     return STATUS_UNSUCCESSFUL;
 343 }
 344
 345 /*
 346     @unimplemented
 347 */
 348 KSDDKAPI NTSTATUS NTAPI
 349 KsGetChildCreateParameter(
 350     IN  PIRP Irp,
 351     OUT PVOID* CreateParameter)
 352 {
 353     UNIMPLEMENTED;
 354     return STATUS_UNSUCCESSFUL;
 355 }
 356
 357 /*
 358     @unimplemented
 359 */
 360 KSDDKAPI NTSTATUS NTAPI
 361 KsMoveIrpsOnCancelableQueue(
 362     IN  OUT PLIST_ENTRY SourceList,
 363     IN  PKSPIN_LOCK SourceLock,
 364     IN  OUT PLIST_ENTRY DestinationList,
 365     IN  PKSPIN_LOCK DestinationLock OPTIONAL,
 366     IN  KSLIST_ENTRY_LOCATION ListLocation,
 367     IN  PFNKSIRPLISTCALLBACK ListCallback,
 368     IN  PVOID Context)
 369 {
 370     UNIMPLEMENTED;
 371     return STATUS_UNSUCCESSFUL;
 372 }
 373
 374 /*
 375     @unimplemented
 376 */
 377 KSDDKAPI NTSTATUS NTAPI
 378 KsProbeStreamIrp(
 379     IN  PIRP Irp,
 380     IN  ULONG ProbeFlags,
 381     IN  ULONG HeaderSize)
 382 {
 383     UNIMPLEMENTED;
 384     return STATUS_UNSUCCESSFUL;
 385 }
 386
 387 /*
 388     @unimplemented
 389 */
 390 KSDDKAPI NTSTATUS NTAPI
 391 KsQueryInformationFile(
 392     IN  PFILE_OBJECT FileObject,
 393     OUT PVOID FileInformation,
 394     IN  ULONG Length,
 395     IN  FILE_INFORMATION_CLASS FileInformationClass)
 396 {
 397     UNIMPLEMENTED;
 398     return STATUS_UNSUCCESSFUL;
 399 }
 400
 401 /*
 402     @unimplemented
 403 */
 404 KSDDKAPI ACCESS_MASK NTAPI
 405 KsQueryObjectAccessMask(
 406     IN KSOBJECT_HEADER Header)
 407 {
 408     UNIMPLEMENTED;
 409     return STATUS_UNSUCCESSFUL;
 410 }
 411
 412 /*
 413     @unimplemented
 414 */
 415 KSDDKAPI PKSOBJECT_CREATE_ITEM NTAPI
 416 KsQueryObjectCreateItem(
 417     IN KSOBJECT_HEADER Header)
 418 {
 419     UNIMPLEMENTED;
 420 /*    return STATUS_UNSUCCESSFUL; */
 421     return NULL;
 422 }
 423
 424 /*
 425     @unimplemented
 426 */
 427 KSDDKAPI NTSTATUS NTAPI
 428 KsReadFile(
 429     IN  PFILE_OBJECT FileObject,
 430     IN  PKEVENT Event OPTIONAL,
 431     IN  PVOID PortContext OPTIONAL,
 432     OUT PIO_STATUS_BLOCK IoStatusBlock,
 433     OUT PVOID Buffer,
 434     IN  ULONG Length,
 435     IN  ULONG Key OPTIONAL,
 436     IN  KPROCESSOR_MODE RequestorMode)
 437 {
 438     UNIMPLEMENTED;
 439     return STATUS_UNSUCCESSFUL;
 440 }
 441
 442 /*
 443     @unimplemented
 444 */
 445 KSDDKAPI VOID NTAPI
 446 KsReleaseIrpOnCancelableQueue(
 447     IN  PIRP Irp,
 448     IN  PDRIVER_CANCEL DriverCancel OPTIONAL)
 449 {
 450     UNIMPLEMENTED;
 451 }
 452
 453 /*
 454     @unimplemented
 455 */
 456 KSDDKAPI PIRP NTAPI
 457 KsRemoveIrpFromCancelableQueue(
 458     IN  OUT PLIST_ENTRY QueueHead,
 459     IN  PKSPIN_LOCK SpinLock,
 460     IN  KSLIST_ENTRY_LOCATION ListLocation,
 461     IN  KSIRP_REMOVAL_OPERATION RemovalOperation)
 462 {
 463     UNIMPLEMENTED;
 464     return NULL;
 465     /*return STATUS_UNSUCCESSFUL; */
 466 }
 467
 468 /*
 469     @unimplemented
 470 */
 471 KSDDKAPI VOID NTAPI
 472 KsRemoveSpecificIrpFromCancelableQueue(
 473     IN  PIRP Irp)
 474 {
 475     UNIMPLEMENTED;
 476 }
 477
 478 /*
 479     @unimplemented
 480 */
 481 KSDDKAPI NTSTATUS NTAPI
 482 KsSetInformationFile(
 483     IN  PFILE_OBJECT FileObject,
 484     IN  PVOID FileInformation,
 485     IN  ULONG Length,
 486     IN  FILE_INFORMATION_CLASS FileInformationClass)
 487 {
 488     UNIMPLEMENTED;
 489     return STATUS_UNSUCCESSFUL;
 490 }
 491
 492
 493
 494 /*
 495     IRP handlers
 496     NOT USED
 497 */
 498 #if 0
 499 static NTAPI
 500 NTSTATUS
 501 KsCreate(
 502     IN  PDEVICE_OBJECT DeviceObject,
 503     IN  PIRP Irp)
 504 {
 505     DPRINT1("KS / Create\n");
 506     return STATUS_UNSUCCESSFUL;
 507 }
 508
 509 static NTAPI
 510 NTSTATUS
 511 KsClose(
 512     IN  PDEVICE_OBJECT DeviceObject,
 513     IN  PIRP Irp)
 514 {
 515     DPRINT1("KS / Close\n");
 516     return STATUS_UNSUCCESSFUL;
 517 }
 518
 519 static NTAPI
 520 NTSTATUS
 521 KsDeviceControl(
 522     IN  PDEVICE_OBJECT DeviceObject,
 523     IN  PIRP Irp)
 524 {
 525     DPRINT1("KS / DeviceControl\n");
 526     return STATUS_UNSUCCESSFUL;
 527 }
 528
 529 static NTAPI
 530 NTSTATUS
 531 KsRead(
 532     IN  PDEVICE_OBJECT DeviceObject,
 533     IN  PIRP Irp)
 534 {
 535     DPRINT1("KS / Read\n");
 536     return STATUS_UNSUCCESSFUL;
 537 }
 538
 539 static NTAPI
 540 NTSTATUS
 541 KsWrite(
 542     IN  PDEVICE_OBJECT DeviceObject,
 543     IN  PIRP Irp)
 544 {
 545     DPRINT1("KS / Write\n");
 546     return STATUS_UNSUCCESSFUL;
 547 }
 548
 549 static NTAPI
 550 NTSTATUS
 551 KsFlushBuffers(
 552     IN  PDEVICE_OBJECT DeviceObject,
 553     IN  PIRP Irp)
 554 {
 555     DPRINT1("KS / FlushBuffers\n");
 556     return STATUS_UNSUCCESSFUL;
 557 }
 558
 559 static NTAPI
 560 NTSTATUS
 561 KsQuerySecurity(
 562     IN  PDEVICE_OBJECT DeviceObject,
 563     IN  PIRP Irp)
 564 {
 565     DPRINT1("KS / QuerySecurity\n");
 566     return STATUS_UNSUCCESSFUL;
 567 }
 568
 569 static NTAPI
 570 NTSTATUS
 571 KsSetSecurity(
 572     IN  PDEVICE_OBJECT DeviceObject,
 573     IN  PIRP Irp)
 574 {
 575     DPRINT1("KS / SetSecurity\n");
 576     return STATUS_UNSUCCESSFUL;
 577 }
 578 #endif
 579
 580
 581 static NTAPI
 582 NTSTATUS
 583 KsInternalIrpDispatcher(
 584     IN  PDEVICE_OBJECT DeviceObject,
 585     IN  PIRP Irp)
 586 {
 587     /* TODO - Nothing implemented really yet! */
 588
 589     DPRINT1("KS IRP dispatch function called\n");
 590
 591     //PKSDISPATCH_TABLE ks_dispatch_table = NULL;
 592
 593     /* ks_dispatch_table is the first element in a structure pointed to by FsContext */
 594
 595     switch ( IoGetCurrentIrpStackLocation(Irp)->MajorFunction )
 596     {
 597         case IRP_MJ_CREATE :
 598 /*            return ks_dispatch_table->Create(DeviceObject, Irp);*/
 599
 600         /* TODO ... */
 601
 602         default :
 603             return STATUS_INVALID_PARAMETER;
 604     };
 605 }
 606
 607
 608 /*
 609     @unimplemented
 610 */
 611 KSDDKAPI NTSTATUS NTAPI
 612 KsSetMajorFunctionHandler(
 613     IN  PDRIVER_OBJECT DriverObject,
 614     IN  ULONG MajorFunction)
 615 {
 616     /*
 617         Sets a DriverObject's major function handler to point to an internal
 618         function we implement.
 619
 620         TODO: Deal with KSDISPATCH_FASTIO
 621     */
 622
 623     switch ( MajorFunction )
 624     {
 625         case IRP_MJ_CREATE :
 626         case IRP_MJ_CLOSE :
 627         case IRP_MJ_DEVICE_CONTROL :
 628         case IRP_MJ_READ :
 629         case IRP_MJ_WRITE :
 630         case IRP_MJ_FLUSH_BUFFERS :
 631         case IRP_MJ_QUERY_SECURITY :
 632         case IRP_MJ_SET_SECURITY :
 633             DriverObject->MajorFunction[MajorFunction] = KsInternalIrpDispatcher;
 634             break;
 635
 636         default :
 637             return STATUS_INVALID_PARAMETER;    /* is this right? */
 638     };
 639
 640     return STATUS_SUCCESS;
 641 }
 642
 643 /*
 644     @unimplemented
 645 */
 646 KSDDKAPI NTSTATUS NTAPI
 647 KsStreamIo(
 648     IN  PFILE_OBJECT FileObject,
 649     IN  PKEVENT Event OPTIONAL,
 650     IN  PVOID PortContext OPTIONAL,
 651     IN  PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL,
 652     IN  PVOID CompletionContext OPTIONAL,
 653     IN  KSCOMPLETION_INVOCATION CompletionInvocationFlags OPTIONAL,
 654     OUT PIO_STATUS_BLOCK IoStatusBlock,
 655     IN  OUT PVOID StreamHeaders,
 656     IN  ULONG Length,
 657     IN  ULONG Flags,
 658     IN  KPROCESSOR_MODE RequestorMode)
 659 {
 660     UNIMPLEMENTED;
 661     return STATUS_UNSUCCESSFUL;
 662 }
 663
 664 /*
 665     @unimplemented
 666 */
 667 KSDDKAPI NTSTATUS NTAPI
 668 KsWriteFile(
 669     IN  PFILE_OBJECT FileObject,
 670     IN  PKEVENT Event OPTIONAL,
 671     IN  PVOID PortContext OPTIONAL,
 672     OUT PIO_STATUS_BLOCK IoStatusBlock,
 673     IN  PVOID Buffer,
 674     IN  ULONG Length,
 675     IN  ULONG Key OPTIONAL,
 676     IN  KPROCESSOR_MODE RequestorMode)
 677 {
 678     UNIMPLEMENTED;
 679     return STATUS_UNSUCCESSFUL;
 680 }