reactos/drivers/ksfilter/ks/irp.c

   1 /*
   2     ReactOS Kernel Streaming
   3     IRP Helpers
   4 */
   5
   6 #include "priv.h"
   7
   8 /*
   9     @unimplemented
  10 */
  11 KSDDKAPI NTSTATUS NTAPI
  12 KsAcquireResetValue(
  13     IN  PIRP Irp,
  14     OUT KSRESET* ResetValue)
  15 {
  16     UNIMPLEMENTED;
  17     return STATUS_UNSUCCESSFUL;
  18 }
  19
  20 /*
  21     @unimplemented
  22 */
  23 KSDDKAPI VOID NTAPI
  24 KsAddIrpToCancelableQueue(
  25     IN  OUT PLIST_ENTRY QueueHead,
  26     IN  PKSPIN_LOCK SpinLock,
  27     IN  PIRP Irp,
  28     IN  KSLIST_ENTRY_LOCATION ListLocation,
  29     IN  PDRIVER_CANCEL DriverCancel OPTIONAL)
  30 {
  31     UNIMPLEMENTED;
  32 }
  33
  34 /*
  35     @unimplemented
  36 */
  37 KSDDKAPI NTSTATUS NTAPI
  38 KsAddObjectCreateItemToObjectHeader(
  39     IN  KSOBJECT_HEADER Header,
  40     IN  PDRIVER_DISPATCH Create,
  41     IN  PVOID Context,
  42     IN  PWCHAR ObjectClass,
  43     IN  PSECURITY_DESCRIPTOR SecurityDescriptor)
  44 {
  45     UNIMPLEMENTED;
  46     return STATUS_UNSUCCESSFUL;
  47 }
  48
  49
  50 /*
  51     @implemented
  52 */
  53 KSDDKAPI
  54 NTSTATUS
  55 NTAPI
  56 KsAddObjectCreateItemToDeviceHeader(
  57     IN  KSDEVICE_HEADER DevHeader,
  58     IN  PDRIVER_DISPATCH Create,
  59     IN  PVOID Context,
  60     IN  PWCHAR ObjectClass,
  61     IN  PSECURITY_DESCRIPTOR SecurityDescriptor)
  62 {
  63     PKSIDEVICE_HEADER Header;
  64     PKSOBJECT_CREATE_ITEM ItemList;
  65     PKSIOBJECT_HEADER ObjectList;
  66
  67     Header = (PKSIDEVICE_HEADER)DevHeader;
  68
  69     if (!DevHeader)
  70         return STATUS_INVALID_PARAMETER_1;
  71
  72     if (!Create)
  73         return STATUS_INVALID_PARAMETER_2;
  74
  75     if (!ObjectClass)
  76         return STATUS_INVALID_PARAMETER_4;
  77
  78     if (Header->FreeIndex >= Header->MaxItems && Header->ItemsListProvided)
  79         return STATUS_ALLOTTED_SPACE_EXCEEDED;
  80
  81     if (Header->FreeIndex >= Header->MaxItems)
  82     {
  83         ItemList = ExAllocatePoolWithTag(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * (Header->MaxItems + 1), TAG('H','D','S','K'));
  84         if (!ItemList)
  85             return STATUS_INSUFFICIENT_RESOURCES;
  86
  87         ObjectList = ExAllocatePoolWithTag(PagedPool, sizeof(KSIOBJECT_HEADER) * (Header->MaxItems + 1), TAG('H','D','S','K'));
  88         if (!ObjectList)
  89         {
  90             ExFreePoolWithTag(ItemList, TAG('H','D','S','K'));
  91             return STATUS_INSUFFICIENT_RESOURCES;
  92         }
  93
  94         RtlMoveMemory(ItemList, Header->ItemsList, Header->MaxItems * sizeof(KSOBJECT_CREATE_ITEM));
  95         ExFreePoolWithTag(Header->ItemsList, TAG('H','D','S','K'));
  96
  97         RtlMoveMemory(ObjectList, Header->ObjectList, Header->MaxItems * sizeof(KSIOBJECT_HEADER));
  98         ExFreePoolWithTag(Header->ObjectList, TAG('H','D','S','K'));
  99
 100         Header->MaxItems++;
 101         Header->ItemsList = ItemList;
 102     }
 103
 104     if (Header->FreeIndex < Header->MaxItems)
 105     {
 106         Header->ItemsList[Header->FreeIndex].Context = Context;
 107         Header->ItemsList[Header->FreeIndex].Create = Create;
 108         Header->ItemsList[Header->FreeIndex].Flags = 0;
 109         RtlInitUnicodeString(&Header->ItemsList[Header->FreeIndex].ObjectClass, ObjectClass);
 110         Header->ItemsList[Header->FreeIndex].SecurityDescriptor = SecurityDescriptor;
 111
 112         Header->FreeIndex++;
 113         return STATUS_SUCCESS;
 114     }
 115
 116     return STATUS_ALLOTTED_SPACE_EXCEEDED;
 117 }
 118
 119 /*
 120     @implemented
 121 */
 122 KSDDKAPI NTSTATUS NTAPI
 123 KsAllocateDeviceHeader(
 124     OUT KSDEVICE_HEADER* OutHeader,
 125     IN  ULONG ItemsCount,
 126     IN  PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL)
 127 {
 128     PKSIDEVICE_HEADER Header;
 129
 130     if (!OutHeader)
 131         return STATUS_INVALID_PARAMETER;
 132
 133     Header = ExAllocatePoolWithTag(PagedPool, sizeof(KSIDEVICE_HEADER), TAG('H','D','S','K'));
 134
 135     if (!Header)
 136         return STATUS_INSUFFICIENT_RESOURCES;
 137
 138     RtlZeroMemory(Header, sizeof(KSIDEVICE_HEADER));
 139
 140     if (ItemsCount)
 141     {
 142         Header->ObjectList = ExAllocatePoolWithTag(PagedPool, sizeof(KSIOBJECT_HEADER) * ItemsCount, TAG('H','D','S','K'));
 143         if (!Header->ObjectList)
 144         {
 145             ExFreePoolWithTag(Header, TAG('H','D','S','K'));
 146             return STATUS_INSUFFICIENT_RESOURCES;
 147         }
 148         RtlZeroMemory(Header->ObjectList, sizeof(KSIOBJECT_HEADER) * ItemsCount);
 149     }
 150
 151     Header->MaxItems = ItemsCount;
 152     Header->FreeIndex = 0;
 153     Header->ItemsList = ItemsList;
 154     Header->ItemsListProvided = (ItemsList != NULL) ? TRUE : FALSE;
 155
 156     *OutHeader = Header;
 157
 158     return STATUS_SUCCESS;
 159 }
 160
 161 /*
 162     @unimplemented
 163
 164     http://www.osronline.com/DDKx/stream/ksfunc_3sc3.htm
 165 */
 166 KSDDKAPI
 167 NTSTATUS
 168 NTAPI
 169 KsAllocateObjectCreateItem(
 170     IN  KSDEVICE_HEADER DevHeader,
 171     IN  PKSOBJECT_CREATE_ITEM CreateItem,
 172     IN  BOOLEAN AllocateEntry,
 173     IN  PFNKSITEMFREECALLBACK ItemFreeCallback OPTIONAL)
 174 {
 175     PKSIDEVICE_HEADER Header;
 176
 177     Header = (PKSIDEVICE_HEADER)DevHeader;
 178
 179     if (!DevHeader)
 180         return STATUS_INVALID_PARAMETER_1;
 181
 182     if (!CreateItem)
 183         return STATUS_INVALID_PARAMETER_2;
 184
 185     //FIXME
 186     //handle ItemFreeCallback
 187     //
 188
 189     UNIMPLEMENTED
 190     return STATUS_UNSUCCESSFUL;
 191 }
 192
 193
 194 /*
 195     @unimplemented
 196 */
 197 KSDDKAPI VOID NTAPI
 198 KsFreeDeviceHeader(
 199     IN  KSDEVICE_HEADER Header)
 200 {
 201     if (!Header)
 202         return;
 203
 204     /* TODO: Free content first */
 205
 206     ExFreePoolWithTag(Header, TAG('H','D','S','K'));
 207 }
 208
 209 /*
 210     @unimplemented
 211 */
 212 KSDDKAPI NTSTATUS NTAPI
 213 KsAllocateExtraData(
 214     IN  PIRP Irp,
 215     IN  ULONG ExtraSize,
 216     OUT PVOID* ExtraBuffer)
 217 {
 218     UNIMPLEMENTED;
 219     return STATUS_UNSUCCESSFUL;
 220 }
 221
 222 /*
 223     @unimplemented
 224
 225     Initialize the required file context header.
 226     Allocates KSOBJECT_HEADER structure.
 227     Irp is an IRP_MJ_CREATE structure.
 228     Driver must allocate KSDISPATCH_TABLE and initialize it first.
 229
 230     http://www.osronline.com/DDKx/stream/ksfunc_0u2b.htm
 231 */
 232 KSDDKAPI
 233 NTSTATUS
 234 NTAPI
 235 KsAllocateObjectHeader(
 236     OUT KSOBJECT_HEADER *Header,
 237     IN  ULONG ItemsCount,
 238     IN  PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL,
 239     IN  PIRP Irp,
 240     IN  KSDISPATCH_TABLE* Table)
 241 {
 242     PKSIDEVICE_HEADER DeviceHeader;
 243     ULONG Index;
 244
 245     if (!Header)
 246         return STATUS_INVALID_PARAMETER_1;
 247
 248     if (!Irp)
 249         return STATUS_INVALID_PARAMETER_4;
 250
 251     DeviceHeader = (PKSIDEVICE_HEADER)Irp->Tail.Overlay.DriverContext[3];
 252     Index = (ULONG)Irp->Tail.Overlay.DriverContext[2];
 253
 254     RtlCopyMemory(&DeviceHeader->ObjectList[Index].DispatchTable, Table, sizeof(KSDISPATCH_TABLE));
 255     DeviceHeader->ObjectList[Index].CreateItem = ItemsList;
 256     DeviceHeader->ObjectList[Index].Initialized = TRUE;
 257
 258     *Header = &DeviceHeader->ObjectList[Index];
 259     return STATUS_SUCCESS;
 260
 261 }
 262
 263 /*
 264     @unimplemented
 265 */
 266 KSDDKAPI VOID NTAPI
 267 KsFreeObjectHeader(
 268     IN  PVOID Header)
 269 {
 270     ExFreePoolWithTag(Header, TAG('H','O','S','K'));
 271
 272     /* TODO */
 273
 274     UNIMPLEMENTED;
 275 }
 276
 277 /*
 278     @unimplemented
 279 */
 280 KSDDKAPI VOID NTAPI
 281 KsCancelIo(
 282     IN  OUT PLIST_ENTRY QueueHead,
 283     IN  PKSPIN_LOCK SpinLock)
 284 {
 285     UNIMPLEMENTED;
 286 }
 287
 288 /*
 289     @unimplemented
 290 */
 291 KSDDKAPI VOID NTAPI
 292 KsCancelRoutine(
 293     IN  PDEVICE_OBJECT DeviceObject,
 294     IN  PIRP Irp)
 295 {
 296     UNIMPLEMENTED;
 297 }
 298
 299 /*
 300     @unimplemented
 301 */
 302 KSDDKAPI NTSTATUS NTAPI
 303 KsDefaultDeviceIoCompletion(
 304     IN  PDEVICE_OBJECT DeviceObject,
 305     IN  PIRP Irp)
 306 {
 307     UNIMPLEMENTED;
 308     return STATUS_UNSUCCESSFUL;
 309 }
 310
 311 /*
 312     @unimplemented
 313 */
 314 KSDDKAPI BOOLEAN NTAPI
 315 KsDispatchFastIoDeviceControlFailure(
 316     IN  PFILE_OBJECT FileObject,
 317     IN  BOOLEAN Wait,
 318     IN  PVOID InputBuffer  OPTIONAL,
 319     IN  ULONG InputBufferLength,
 320     OUT PVOID OutputBuffer  OPTIONAL,
 321     IN  ULONG OutputBufferLength,
 322     IN  ULONG IoControlCode,
 323     OUT PIO_STATUS_BLOCK IoStatus,
 324     IN  PDEVICE_OBJECT DeviceObject)   /* always return false */
 325 {
 326     return FALSE;
 327 }
 328
 329 /*
 330     @unimplemented
 331 */
 332 KSDDKAPI BOOLEAN NTAPI
 333 KsDispatchFastReadFailure(
 334     IN  PFILE_OBJECT FileObject,
 335     IN  PLARGE_INTEGER FileOffset,
 336     IN  ULONG Length,
 337     IN  BOOLEAN Wait,
 338     IN  ULONG LockKey,
 339     OUT PVOID Buffer,
 340     OUT PIO_STATUS_BLOCK IoStatus,
 341     IN  PDEVICE_OBJECT DeviceObject)   /* always return false */
 342 {
 343     return FALSE;
 344 }
 345
 346 /*
 347     Used in dispatch table entries that aren't handled and need to return
 348     STATUS_INVALID_DEVICE_REQUEST.
 349 */
 350 KSDDKAPI NTSTATUS NTAPI
 351 KsDispatchInvalidDeviceRequest(
 352     IN  PDEVICE_OBJECT DeviceObject,
 353     IN  PIRP Irp)
 354 {
 355     Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
 356     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 357
 358     return STATUS_INVALID_DEVICE_REQUEST;
 359 }
 360
 361 /*
 362     @unimplemented
 363 */
 364 KSDDKAPI NTSTATUS NTAPI
 365 KsDispatchSpecificMethod(
 366     IN  PIRP Irp,
 367     IN  PFNKSHANDLER Handler)
 368 {
 369     UNIMPLEMENTED;
 370     return STATUS_UNSUCCESSFUL;
 371 }
 372
 373 /*
 374     @unimplemented
 375 */
 376 KSDDKAPI NTSTATUS NTAPI
 377 KsDispatchSpecificProperty(
 378     IN  PIRP Irp,
 379     IN  PFNKSHANDLER Handler)
 380 {
 381     UNIMPLEMENTED;
 382     return STATUS_UNSUCCESSFUL;
 383 }
 384
 385 /*
 386     @unimplemented
 387 */
 388 KSDDKAPI NTSTATUS NTAPI
 389 KsForwardAndCatchIrp(
 390     IN  PDEVICE_OBJECT DeviceObject,
 391     IN  PIRP Irp,
 392     IN  PFILE_OBJECT FileObject,
 393     IN  KSSTACK_USE StackUse)
 394 {
 395     UNIMPLEMENTED;
 396     return STATUS_UNSUCCESSFUL;
 397 }
 398
 399 /*
 400     @unimplemented
 401 */
 402 KSDDKAPI NTSTATUS NTAPI
 403 KsForwardIrp(
 404     IN  PIRP Irp,
 405     IN  PFILE_OBJECT FileObject,
 406     IN  BOOLEAN ReuseStackLocation)
 407 {
 408     UNIMPLEMENTED;
 409     return STATUS_UNSUCCESSFUL;
 410 }
 411
 412 /*
 413     @unimplemented
 414 */
 415 KSDDKAPI NTSTATUS NTAPI
 416 KsGetChildCreateParameter(
 417     IN  PIRP Irp,
 418     OUT PVOID* CreateParameter)
 419 {
 420     UNIMPLEMENTED;
 421     return STATUS_UNSUCCESSFUL;
 422 }
 423
 424 /*
 425     @unimplemented
 426 */
 427 KSDDKAPI NTSTATUS NTAPI
 428 KsMoveIrpsOnCancelableQueue(
 429     IN  OUT PLIST_ENTRY SourceList,
 430     IN  PKSPIN_LOCK SourceLock,
 431     IN  OUT PLIST_ENTRY DestinationList,
 432     IN  PKSPIN_LOCK DestinationLock OPTIONAL,
 433     IN  KSLIST_ENTRY_LOCATION ListLocation,
 434     IN  PFNKSIRPLISTCALLBACK ListCallback,
 435     IN  PVOID Context)
 436 {
 437     UNIMPLEMENTED;
 438     return STATUS_UNSUCCESSFUL;
 439 }
 440
 441 /*
 442     @unimplemented
 443 */
 444 KSDDKAPI NTSTATUS NTAPI
 445 KsProbeStreamIrp(
 446     IN  PIRP Irp,
 447     IN  ULONG ProbeFlags,
 448     IN  ULONG HeaderSize)
 449 {
 450     UNIMPLEMENTED;
 451     return STATUS_UNSUCCESSFUL;
 452 }
 453
 454 /*
 455     @unimplemented
 456 */
 457 KSDDKAPI NTSTATUS NTAPI
 458 KsQueryInformationFile(
 459     IN  PFILE_OBJECT FileObject,
 460     OUT PVOID FileInformation,
 461     IN  ULONG Length,
 462     IN  FILE_INFORMATION_CLASS FileInformationClass)
 463 {
 464     UNIMPLEMENTED;
 465     return STATUS_UNSUCCESSFUL;
 466 }
 467
 468 /*
 469     @unimplemented
 470 */
 471 KSDDKAPI ACCESS_MASK NTAPI
 472 KsQueryObjectAccessMask(
 473     IN KSOBJECT_HEADER Header)
 474 {
 475     UNIMPLEMENTED;
 476     return STATUS_UNSUCCESSFUL;
 477 }
 478
 479 /*
 480     @unimplemented
 481 */
 482 KSDDKAPI PKSOBJECT_CREATE_ITEM NTAPI
 483 KsQueryObjectCreateItem(
 484     IN KSOBJECT_HEADER Header)
 485 {
 486     UNIMPLEMENTED;
 487 /*    return STATUS_UNSUCCESSFUL; */
 488     return NULL;
 489 }
 490
 491 /*
 492     @unimplemented
 493 */
 494 KSDDKAPI NTSTATUS NTAPI
 495 KsReadFile(
 496     IN  PFILE_OBJECT FileObject,
 497     IN  PKEVENT Event OPTIONAL,
 498     IN  PVOID PortContext OPTIONAL,
 499     OUT PIO_STATUS_BLOCK IoStatusBlock,
 500     OUT PVOID Buffer,
 501     IN  ULONG Length,
 502     IN  ULONG Key OPTIONAL,
 503     IN  KPROCESSOR_MODE RequestorMode)
 504 {
 505     UNIMPLEMENTED;
 506     return STATUS_UNSUCCESSFUL;
 507 }
 508
 509 /*
 510     @unimplemented
 511 */
 512 KSDDKAPI VOID NTAPI
 513 KsReleaseIrpOnCancelableQueue(
 514     IN  PIRP Irp,
 515     IN  PDRIVER_CANCEL DriverCancel OPTIONAL)
 516 {
 517     UNIMPLEMENTED;
 518 }
 519
 520 /*
 521     @unimplemented
 522 */
 523 KSDDKAPI PIRP NTAPI
 524 KsRemoveIrpFromCancelableQueue(
 525     IN  OUT PLIST_ENTRY QueueHead,
 526     IN  PKSPIN_LOCK SpinLock,
 527     IN  KSLIST_ENTRY_LOCATION ListLocation,
 528     IN  KSIRP_REMOVAL_OPERATION RemovalOperation)
 529 {
 530     UNIMPLEMENTED;
 531     return NULL;
 532     /*return STATUS_UNSUCCESSFUL; */
 533 }
 534
 535 /*
 536     @unimplemented
 537 */
 538 KSDDKAPI VOID NTAPI
 539 KsRemoveSpecificIrpFromCancelableQueue(
 540     IN  PIRP Irp)
 541 {
 542     UNIMPLEMENTED;
 543 }
 544
 545 /*
 546     @unimplemented
 547 */
 548 KSDDKAPI NTSTATUS NTAPI
 549 KsSetInformationFile(
 550     IN  PFILE_OBJECT FileObject,
 551     IN  PVOID FileInformation,
 552     IN  ULONG Length,
 553     IN  FILE_INFORMATION_CLASS FileInformationClass)
 554 {
 555     UNIMPLEMENTED;
 556     return STATUS_UNSUCCESSFUL;
 557 }
 558
 559
 560
 561 NTAPI
 562 NTSTATUS
 563 KsCreate(
 564     IN  PDEVICE_OBJECT DeviceObject,
 565     IN  PIRP Irp)
 566 {
 567     PIO_STACK_LOCATION IoStack;
 568     PDEVICE_EXTENSION DeviceExtension;
 569     PKSIDEVICE_HEADER DeviceHeader;
 570     ULONG Index;
 571     NTSTATUS Status;
 572
 573     IoStack = IoGetCurrentIrpStackLocation(Irp);
 574
 575     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 576     DeviceHeader = DeviceExtension->DeviceHeader;
 577
 578     DPRINT1("KS / Create\n");
 579
 580     /* first call all create handlers */
 581     for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
 582     {
 583         KSCREATE_ITEM_IRP_STORAGE(Irp) = &DeviceHeader->ItemsList[Index];
 584
 585         Irp->Tail.Overlay.DriverContext[3] = (PVOID)DeviceHeader;
 586         Irp->Tail.Overlay.DriverContext[2] = (PVOID)Index;
 587
 588         DeviceHeader->ObjectList[Index].Initialized = FALSE;
 589         Status = DeviceHeader->ItemsList[Index].Create(DeviceObject, Irp);
 590         if (!NT_SUCCESS(Status))
 591         {
 592             DeviceHeader->ObjectList[Index].Initialized = FALSE;
 593         }
 594     }
 595
 596
 597     return STATUS_SUCCESS;
 598 }
 599
 600 static NTAPI
 601 NTSTATUS
 602 KsClose(
 603     IN  PDEVICE_OBJECT DeviceObject,
 604     IN  PIRP Irp)
 605 {
 606     PIO_STACK_LOCATION IoStack;
 607     PDEVICE_EXTENSION DeviceExtension;
 608     PKSIDEVICE_HEADER DeviceHeader;
 609     ULONG Index;
 610     NTSTATUS Status;
 611
 612     DPRINT1("KS / CLOSE\n");
 613
 614     IoStack = IoGetCurrentIrpStackLocation(Irp);
 615
 616     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 617     DeviceHeader = DeviceExtension->DeviceHeader;
 618
 619     for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
 620     {
 621         if (DeviceHeader->ObjectList[Index].Initialized)
 622         {
 623             Status = DeviceHeader->ObjectList->DispatchTable.Close(DeviceObject, Irp);
 624             DeviceHeader->ObjectList[Index].Initialized = FALSE;
 625         }
 626     }
 627
 628     return STATUS_SUCCESS;
 629 }
 630
 631 static NTAPI
 632 NTSTATUS
 633 KsDeviceControl(
 634     IN  PDEVICE_OBJECT DeviceObject,
 635     IN  PIRP Irp)
 636 {
 637     PIO_STACK_LOCATION IoStack;
 638     PDEVICE_EXTENSION DeviceExtension;
 639     PKSIDEVICE_HEADER DeviceHeader;
 640     ULONG Index;
 641     NTSTATUS Status;
 642
 643     IoStack = IoGetCurrentIrpStackLocation(Irp);
 644
 645     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 646     DeviceHeader = DeviceExtension->DeviceHeader;
 647
 648     DPRINT1("KS / DeviceControl NumDevices %x\n", DeviceHeader->FreeIndex);
 649
 650     for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
 651     {
 652         if (DeviceHeader->ObjectList[Index].Initialized)
 653         {
 654             DPRINT1("Calling DeviceIoControl\n");
 655             Status = DeviceHeader->ObjectList->DispatchTable.DeviceIoControl(DeviceObject, Irp);
 656         }
 657     }
 658
 659     return STATUS_SUCCESS;
 660 }
 661
 662 static NTAPI
 663 NTSTATUS
 664 KsRead(
 665     IN  PDEVICE_OBJECT DeviceObject,
 666     IN  PIRP Irp)
 667 {
 668     PIO_STACK_LOCATION IoStack;
 669     PDEVICE_EXTENSION DeviceExtension;
 670     PKSIDEVICE_HEADER DeviceHeader;
 671     ULONG Index;
 672     NTSTATUS Status;
 673
 674     IoStack = IoGetCurrentIrpStackLocation(Irp);
 675
 676     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 677     DeviceHeader = DeviceExtension->DeviceHeader;
 678
 679     DPRINT1("KS / Read\n");
 680
 681     for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
 682     {
 683         if (DeviceHeader->ObjectList[Index].Initialized)
 684         {
 685             Status = DeviceHeader->ObjectList->DispatchTable.Read(DeviceObject, Irp);
 686         }
 687     }
 688
 689     return STATUS_SUCCESS;
 690 }
 691
 692 static NTAPI
 693 NTSTATUS
 694 KsWrite(
 695     IN  PDEVICE_OBJECT DeviceObject,
 696     IN  PIRP Irp)
 697 {
 698     PIO_STACK_LOCATION IoStack;
 699     PDEVICE_EXTENSION DeviceExtension;
 700     PKSIDEVICE_HEADER DeviceHeader;
 701     ULONG Index;
 702     NTSTATUS Status;
 703
 704     IoStack = IoGetCurrentIrpStackLocation(Irp);
 705
 706     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 707     DeviceHeader = DeviceExtension->DeviceHeader;
 708
 709     DPRINT1("KS / Write\n");
 710
 711     for(Index = 0; Index < DeviceHeader->FreeIndex; Index++)
 712     {
 713         if (DeviceHeader->ObjectList[Index].Initialized)
 714         {
 715             Status = DeviceHeader->ObjectList->DispatchTable.Write(DeviceObject, Irp);
 716         }
 717     }
 718     return STATUS_SUCCESS;
 719 }
 720
 721 static NTAPI
 722 NTSTATUS
 723 KsFlushBuffers(
 724     IN  PDEVICE_OBJECT DeviceObject,
 725     IN  PIRP Irp)
 726 {
 727     DPRINT1("KS / FlushBuffers\n");
 728     return STATUS_UNSUCCESSFUL;
 729 }
 730
 731 static NTAPI
 732 NTSTATUS
 733 KsQuerySecurity(
 734     IN  PDEVICE_OBJECT DeviceObject,
 735     IN  PIRP Irp)
 736 {
 737     DPRINT1("KS / QuerySecurity\n");
 738     return STATUS_UNSUCCESSFUL;
 739 }
 740
 741 static NTAPI
 742 NTSTATUS
 743 KsSetSecurity(
 744     IN  PDEVICE_OBJECT DeviceObject,
 745     IN  PIRP Irp)
 746 {
 747     DPRINT1("KS / SetSecurity\n");
 748     return STATUS_UNSUCCESSFUL;
 749 }
 750
 751 /*
 752     @implemented
 753 */
 754 KSDDKAPI NTSTATUS NTAPI
 755 KsSetMajorFunctionHandler(
 756     IN  PDRIVER_OBJECT DriverObject,
 757     IN  ULONG MajorFunction)
 758 {
 759     /*
 760         Sets a DriverObject's major function handler to point to an internal
 761         function we implement.
 762
 763         TODO: Deal with KSDISPATCH_FASTIO
 764     */
 765
 766     switch ( MajorFunction )
 767     {
 768         case IRP_MJ_CREATE:
 769             DriverObject->MajorFunction[MajorFunction] = KsCreate;
 770             break;
 771         case IRP_MJ_CLOSE:
 772             DriverObject->MajorFunction[MajorFunction] = KsClose;
 773             break;
 774         case IRP_MJ_DEVICE_CONTROL:
 775             DriverObject->MajorFunction[MajorFunction] = KsDeviceControl;
 776             break;
 777         case IRP_MJ_READ:
 778             DriverObject->MajorFunction[MajorFunction] = KsRead;
 779             break;
 780         case IRP_MJ_WRITE:
 781             DriverObject->MajorFunction[MajorFunction] = KsWrite;
 782             break;
 783         case IRP_MJ_FLUSH_BUFFERS :
 784             DriverObject->MajorFunction[MajorFunction] = KsFlushBuffers;
 785             break;
 786         case IRP_MJ_QUERY_SECURITY:
 787             DriverObject->MajorFunction[MajorFunction] = KsQuerySecurity;
 788             break;
 789         case IRP_MJ_SET_SECURITY:
 790             DriverObject->MajorFunction[MajorFunction] = KsSetSecurity;
 791             break;
 792
 793         default:
 794             return STATUS_INVALID_PARAMETER;    /* is this right? */
 795     };
 796
 797     return STATUS_SUCCESS;
 798 }
 799
 800 /*
 801     @implemented
 802 */
 803 KSDDKAPI
 804 NTSTATUS
 805 NTAPI
 806 KsDispatchIrp(
 807     IN  PDEVICE_OBJECT DeviceObject,
 808     IN  PIRP Irp)
 809 {
 810     PIO_STACK_LOCATION IoStack;
 811
 812     /* Calls a dispatch routine corresponding to the function code of the IRP */
 813     /*
 814         First we need to get the dispatch table. An opaque header is pointed to by
 815         FsContext. The first element points to this table. This table is the key
 816         to dispatching the IRP correctly.
 817     */
 818
 819     IoStack = IoGetCurrentIrpStackLocation(Irp);
 820     DPRINT1("KsDispatchIrp %x\n", IoStack->MajorFunction);
 821
 822     switch (IoStack->MajorFunction)
 823     {
 824         case IRP_MJ_CREATE:
 825             return KsCreate(DeviceObject, Irp);
 826         case IRP_MJ_CLOSE:
 827             return KsClose(DeviceObject, Irp);
 828             break;
 829         case IRP_MJ_DEVICE_CONTROL:
 830             return KsDeviceControl(DeviceObject, Irp);
 831             break;
 832         case IRP_MJ_READ:
 833             return KsRead(DeviceObject, Irp);
 834             break;
 835         case IRP_MJ_WRITE:
 836             return KsWrite(DeviceObject, Irp);
 837             break;
 838         case IRP_MJ_FLUSH_BUFFERS:
 839             return KsFlushBuffers(DeviceObject, Irp);
 840             break;
 841         case IRP_MJ_QUERY_SECURITY:
 842             return KsQuerySecurity(DeviceObject, Irp);
 843             break;
 844         case IRP_MJ_SET_SECURITY:
 845             return KsSetSecurity(DeviceObject, Irp);
 846             break;
 847         default:
 848             return STATUS_INVALID_PARAMETER;    /* is this right? */
 849     };
 850 }
 851
 852
 853 /*
 854     @unimplemented
 855 */
 856 KSDDKAPI NTSTATUS NTAPI
 857 KsStreamIo(
 858     IN  PFILE_OBJECT FileObject,
 859     IN  PKEVENT Event OPTIONAL,
 860     IN  PVOID PortContext OPTIONAL,
 861     IN  PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL,
 862     IN  PVOID CompletionContext OPTIONAL,
 863     IN  KSCOMPLETION_INVOCATION CompletionInvocationFlags OPTIONAL,
 864     OUT PIO_STATUS_BLOCK IoStatusBlock,
 865     IN  OUT PVOID StreamHeaders,
 866     IN  ULONG Length,
 867     IN  ULONG Flags,
 868     IN  KPROCESSOR_MODE RequestorMode)
 869 {
 870     UNIMPLEMENTED;
 871     return STATUS_UNSUCCESSFUL;
 872 }
 873
 874 /*
 875     @unimplemented
 876 */
 877 KSDDKAPI NTSTATUS NTAPI
 878 KsWriteFile(
 879     IN  PFILE_OBJECT FileObject,
 880     IN  PKEVENT Event OPTIONAL,
 881     IN  PVOID PortContext OPTIONAL,
 882     OUT PIO_STATUS_BLOCK IoStatusBlock,
 883     IN  PVOID Buffer,
 884     IN  ULONG Length,
 885     IN  ULONG Key OPTIONAL,
 886     IN  KPROCESSOR_MODE RequestorMode)
 887 {
 888     UNIMPLEMENTED;
 889     return STATUS_UNSUCCESSFUL;
 890 }
 891
 892 /*
 893     @unimplemented
 894 */
 895 KSDDKAPI NTSTATUS NTAPI
 896 KsDefaultForwardIrp(
 897     IN PDEVICE_OBJECT DeviceObject,
 898     IN PIRP Irp)
 899 {
 900     UNIMPLEMENTED;
 901     return STATUS_UNSUCCESSFUL;
 902 }
 903