drivers/filesystems/npfs/create.c

   1 /*
   2 * COPYRIGHT:  See COPYING in the top level directory
   3 * PROJECT:    ReactOS kernel
   4 * FILE:       drivers/filesystems/npfs/create.c
   5 * PURPOSE:    Named pipe filesystem
   6 * PROGRAMMER: David Welch <welch@cwcom.net>
   7 */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include "npfs.h"
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 //#define USING_PROPER_NPFS_WAIT_SEMANTICS
  17
  18 /* FUNCTIONS *****************************************************************/
  19
  20 VOID
  21 NpfsDereferenceFcb(PNPFS_FCB Fcb)
  22 {
  23     PNPFS_VCB Vcb = Fcb->Vcb;
  24
  25     KeLockMutex(&Vcb->PipeListLock);
  26     if (InterlockedDecrement(&Fcb->RefCount) == 0)
  27     {
  28         DPRINT("NpfsDereferenceFcb. Deleting %p\n", Fcb);
  29         RemoveEntryList(&Fcb->PipeListEntry);
  30         RtlFreeUnicodeString(&Fcb->PipeName);
  31         ExFreePoolWithTag(Fcb, TAG_NPFS_FCB);
  32     }
  33     KeUnlockMutex(&Vcb->PipeListLock);
  34 }
  35
  36 static
  37 PNPFS_CCB
  38 NpfsAllocateCcb(CCB_TYPE Type, PNPFS_FCB Fcb)
  39 {
  40     PNPFS_CCB Ccb;
  41
  42     Ccb = ExAllocatePoolWithTag(NonPagedPool, sizeof(NPFS_CCB), TAG_NPFS_CCB);
  43     if (!Ccb)
  44     {
  45         return NULL;
  46     }
  47
  48     RtlZeroMemory(Ccb, sizeof(NPFS_CCB));
  49
  50     Ccb->RefCount = 1;
  51     Ccb->Type = Type;
  52     // FIXME: why does this function not reference Fcb?
  53     Ccb->Fcb = Fcb;
  54     Ccb->OtherSide = NULL;
  55
  56     return Ccb;
  57 }
  58
  59 static
  60 VOID
  61 NpfsReferenceCcb(PNPFS_CCB Ccb)
  62 {
  63     ASSERT(Ccb->RefCount > 0);
  64     InterlockedIncrement(&Ccb->RefCount);
  65 }
  66
  67 static
  68 VOID
  69 NpfsDereferenceCcb(PNPFS_CCB Ccb)
  70 {
  71     /* Decrement reference count */
  72     ASSERT(Ccb->RefCount > 0);
  73     if (InterlockedDecrement(&Ccb->RefCount) == 0)
  74     {
  75         /* Its zero, delete CCB */
  76         ExFreePoolWithTag(Ccb, TAG_NPFS_CCB);
  77     }
  78 }
  79
  80 static
  81 VOID
  82 NpfsCcbSetOtherSide(PNPFS_CCB Ccb, PNPFS_CCB OtherSide)
  83 {
  84     /* Dereference old other side */
  85     if (Ccb->OtherSide) NpfsDereferenceCcb(Ccb->OtherSide);
  86
  87     /* Reference the new other side */
  88     if (OtherSide) NpfsReferenceCcb(OtherSide);
  89
  90     /* Set new value */
  91     Ccb->OtherSide = OtherSide;
  92 }
  93
  94 PNPFS_FCB
  95 NpfsFindPipe(PNPFS_VCB Vcb,
  96              PUNICODE_STRING PipeName)
  97 {
  98     PLIST_ENTRY CurrentEntry;
  99     PNPFS_FCB Fcb;
 100
 101     CurrentEntry = Vcb->PipeListHead.Flink;
 102     while (CurrentEntry != &Vcb->PipeListHead)
 103     {
 104         Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, PipeListEntry);
 105         if (RtlCompareUnicodeString(PipeName,
 106             &Fcb->PipeName,
 107             TRUE) == 0)
 108         {
 109             DPRINT("<%wZ> = <%wZ>\n", PipeName, &Fcb->PipeName);
 110             (VOID)InterlockedIncrement(&Fcb->RefCount);
 111             return Fcb;
 112         }
 113
 114         CurrentEntry = CurrentEntry->Flink;
 115     }
 116
 117     return NULL;
 118 }
 119
 120
 121 static PNPFS_CCB
 122 NpfsFindListeningServerInstance(PNPFS_FCB Fcb)
 123 {
 124     PLIST_ENTRY CurrentEntry;
 125     PNPFS_WAITER_ENTRY Waiter;
 126     KIRQL oldIrql;
 127     PIRP Irp;
 128
 129     CurrentEntry = Fcb->WaiterListHead.Flink;
 130     while (CurrentEntry != &Fcb->WaiterListHead)
 131     {
 132         Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
 133         Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
 134         if (Waiter->Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
 135         {
 136             DPRINT("Server found! CCB %p\n", Waiter->Ccb);
 137
 138             IoAcquireCancelSpinLock(&oldIrql);
 139             if (!Irp->Cancel)
 140             {
 141                 if (IoSetCancelRoutine(Irp, NULL) != NULL)
 142                 {
 143                     IoReleaseCancelSpinLock(oldIrql);
 144                     return Waiter->Ccb;
 145                 }
 146             }
 147             IoReleaseCancelSpinLock(oldIrql);
 148         }
 149
 150         CurrentEntry = CurrentEntry->Flink;
 151     }
 152
 153     return NULL;
 154 }
 155
 156
 157 static VOID
 158 NpfsSignalAndRemoveListeningServerInstance(PNPFS_FCB Fcb,
 159                                            PNPFS_CCB Ccb)
 160 {
 161     PLIST_ENTRY CurrentEntry;
 162     PNPFS_WAITER_ENTRY Waiter;
 163     PIRP Irp;
 164
 165     CurrentEntry = Fcb->WaiterListHead.Flink;
 166     while (CurrentEntry != &Fcb->WaiterListHead)
 167     {
 168         Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
 169         if (Waiter->Ccb == Ccb)
 170         {
 171             DPRINT("Server found! CCB %p\n", Waiter->Ccb);
 172
 173             RemoveEntryList(&Waiter->Entry);
 174             Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
 175             Irp->IoStatus.Status = STATUS_SUCCESS;
 176             Irp->IoStatus.Information = 0;
 177             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 178             break;
 179         }
 180         CurrentEntry = CurrentEntry->Flink;
 181     }
 182 }
 183
 184
 185 static VOID
 186 NpfsOpenFileSystem(PNPFS_FCB Fcb,
 187                    PFILE_OBJECT FileObject,
 188                    PIO_STATUS_BLOCK IoStatus)
 189 {
 190     PNPFS_CCB Ccb;
 191
 192     DPRINT("NpfsOpenFileSystem()\n");
 193
 194     Ccb = NpfsAllocateCcb(CCB_DEVICE, Fcb);
 195     if (Ccb == NULL)
 196     {
 197         IoStatus->Status = STATUS_NO_MEMORY;
 198         return;
 199     }
 200
 201     Ccb->FileObject = FileObject;
 202
 203     FileObject->FsContext = Fcb;
 204     FileObject->FsContext2 = Ccb;
 205
 206     IoStatus->Information = FILE_OPENED;
 207     IoStatus->Status = STATUS_SUCCESS;
 208
 209     return;
 210 }
 211
 212
 213 static VOID
 214 NpfsOpenRootDirectory(PNPFS_FCB Fcb,
 215                       PFILE_OBJECT FileObject,
 216                       PIO_STATUS_BLOCK IoStatus)
 217 {
 218     PNPFS_CCB Ccb;
 219
 220     DPRINT("NpfsOpenRootDirectory()\n");
 221
 222     Ccb = NpfsAllocateCcb(CCB_DIRECTORY, Fcb);
 223     if (Ccb == NULL)
 224     {
 225         IoStatus->Status = STATUS_NO_MEMORY;
 226         return;
 227     }
 228
 229     Ccb->FileObject = FileObject;
 230
 231     FileObject->FsContext = Fcb;
 232     FileObject->FsContext2 = Ccb;
 233
 234     IoStatus->Information = FILE_OPENED;
 235     IoStatus->Status = STATUS_SUCCESS;
 236
 237     return;
 238 }
 239
 240
 241 NTSTATUS NTAPI
 242 NpfsCreate(PDEVICE_OBJECT DeviceObject,
 243            PIRP Irp)
 244 {
 245     PEXTENDED_IO_STACK_LOCATION IoStack;
 246     PUNICODE_STRING FileName;
 247     PFILE_OBJECT FileObject;
 248     PFILE_OBJECT RelatedFileObject;
 249     PNPFS_FCB Fcb;
 250     PNPFS_CCB ClientCcb;
 251     PNPFS_CCB ServerCcb = NULL;
 252     PNPFS_VCB Vcb;
 253     NTSTATUS Status;
 254 #ifndef USING_PROPER_NPFS_WAIT_SEMANTICS
 255     ACCESS_MASK DesiredAccess;
 256     BOOLEAN SpecialAccess;
 257 #endif
 258
 259     DPRINT("NpfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 260
 261     Vcb = (PNPFS_VCB)DeviceObject->DeviceExtension;
 262     IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp);
 263     FileObject = IoStack->FileObject;
 264     RelatedFileObject = FileObject->RelatedFileObject;
 265     FileName = &FileObject->FileName;
 266 #ifndef USING_PROPER_NPFS_WAIT_SEMANTICS
 267     DesiredAccess = IoStack->Parameters.CreatePipe.SecurityContext->DesiredAccess;
 268 #endif
 269
 270     DPRINT("FileObject %p\n", FileObject);
 271     DPRINT("FileName %wZ\n", &FileObject->FileName);
 272
 273     Irp->IoStatus.Information = 0;
 274
 275 #ifndef USING_PROPER_NPFS_WAIT_SEMANTICS
 276     SpecialAccess = ((DesiredAccess & SPECIFIC_RIGHTS_ALL) == FILE_READ_ATTRIBUTES);
 277     if (SpecialAccess)
 278     {
 279         DPRINT("NpfsCreate() open client end for special use!\n");
 280     }
 281 #endif
 282
 283     DPRINT("FileName->Length: %hu  RelatedFileObject: %p\n", FileName->Length, RelatedFileObject);
 284
 285     /* Open the file system */
 286     if (FileName->Length == 0 &&
 287         (RelatedFileObject == NULL || ((PNPFS_CCB)RelatedFileObject->FsContext2)->Type == CCB_DEVICE))
 288     {
 289         DPRINT("Open the file system\n");
 290
 291         NpfsOpenFileSystem(Vcb->DeviceFcb,
 292                            FileObject,
 293                            &Irp->IoStatus);
 294
 295         Status = Irp->IoStatus.Status;
 296         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 297         return Status;
 298     }
 299
 300     /* Open the root directory */
 301     if ((FileName->Length == 2 && FileName->Buffer[0] == L'\\' && RelatedFileObject == NULL) ||
 302         (FileName->Length == 0 && ((PNPFS_CCB)RelatedFileObject->FsContext2)->Type == CCB_DIRECTORY))
 303     {
 304         DPRINT("Open the root directory\n");
 305
 306         NpfsOpenRootDirectory(Vcb->RootFcb,
 307                               FileObject,
 308                               &Irp->IoStatus);
 309
 310         Status = Irp->IoStatus.Status;
 311         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 312         return Status;
 313     }
 314
 315
 316     /*
 317     * Step 1. Find the pipe we're trying to open.
 318     */
 319     KeLockMutex(&Vcb->PipeListLock);
 320     Fcb = NpfsFindPipe(Vcb, &FileObject->FileName);
 321     if (Fcb == NULL)
 322     {
 323         /* Not found, bail out with error. */
 324         DPRINT("No pipe found!\n");
 325         KeUnlockMutex(&Vcb->PipeListLock);
 326         Irp->IoStatus.Status = STATUS_OBJECT_NAME_NOT_FOUND;
 327         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 328         return STATUS_OBJECT_NAME_NOT_FOUND;
 329     }
 330
 331     KeUnlockMutex(&Vcb->PipeListLock);
 332
 333     /*
 334     * Acquire the lock for CCB lists. From now on no modifications to the
 335     * CCB lists are allowed, because it can cause various misconsistencies.
 336     */
 337     KeLockMutex(&Fcb->CcbListLock);
 338
 339     /*
 340     * Step 2. Create the client CCB.
 341     */
 342     ClientCcb = NpfsAllocateCcb(CCB_PIPE, Fcb);
 343     if (ClientCcb == NULL)
 344     {
 345         DPRINT("No memory!\n");
 346         KeUnlockMutex(&Fcb->CcbListLock);
 347         NpfsDereferenceFcb(Fcb);
 348         Irp->IoStatus.Status = STATUS_NO_MEMORY;
 349         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 350         return STATUS_NO_MEMORY;
 351     }
 352
 353     ClientCcb->FileObject = FileObject;
 354     ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
 355     ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END;
 356 #ifndef USING_PROPER_NPFS_WAIT_SEMANTICS
 357     ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE;
 358 #else
 359     ClientCcb->PipeState = FILE_PIPE_DISCONNECTED_STATE;
 360 #endif
 361     InitializeListHead(&ClientCcb->ReadRequestListHead);
 362
 363     DPRINT("CCB: %p\n", ClientCcb);
 364
 365     /* Initialize data list. */
 366     if (Fcb->OutboundQuota)
 367     {
 368         ClientCcb->Data = ExAllocatePoolWithTag(PagedPool,
 369                                                 Fcb->OutboundQuota,
 370                                                 TAG_NPFS_CCB_DATA);
 371         if (ClientCcb->Data == NULL)
 372         {
 373             DPRINT("No memory!\n");
 374             NpfsDereferenceCcb(ClientCcb);
 375             KeUnlockMutex(&Fcb->CcbListLock);
 376             NpfsDereferenceFcb(Fcb);
 377             Irp->IoStatus.Status = STATUS_NO_MEMORY;
 378             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 379             return STATUS_NO_MEMORY;
 380         }
 381     }
 382     else
 383     {
 384         ClientCcb->Data = NULL;
 385     }
 386
 387     ClientCcb->ReadPtr = ClientCcb->Data;
 388     ClientCcb->WritePtr = ClientCcb->Data;
 389     ClientCcb->ReadDataAvailable = 0;
 390     ClientCcb->WriteQuotaAvailable = Fcb->OutboundQuota;
 391     ClientCcb->MaxDataLength = Fcb->OutboundQuota;
 392     ExInitializeFastMutex(&ClientCcb->DataListLock);
 393     KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE);
 394     KeInitializeEvent(&ClientCcb->ReadEvent, NotificationEvent, FALSE);
 395     KeInitializeEvent(&ClientCcb->WriteEvent, NotificationEvent, FALSE);
 396
 397
 398     /*
 399     * Step 3. Search for listening server CCB.
 400     */
 401 #ifndef USING_PROPER_NPFS_WAIT_SEMANTICS
 402     if (!SpecialAccess)
 403     {
 404 #endif
 405         /*
 406         * WARNING: Point of no return! Once we get the server CCB it's
 407         * possible that we completed a wait request and so we have to
 408         * complete even this request.
 409         */
 410
 411         ServerCcb = NpfsFindListeningServerInstance(Fcb);
 412         if (ServerCcb == NULL)
 413         {
 414             PLIST_ENTRY CurrentEntry;
 415             PNPFS_CCB Ccb;
 416
 417             /*
 418             * If no waiting server CCB was found then try to pick
 419             * one of the listing server CCB on the pipe.
 420             */
 421
 422             CurrentEntry = Fcb->ServerCcbListHead.Flink;
 423             while (CurrentEntry != &Fcb->ServerCcbListHead)
 424             {
 425                 Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry);
 426                 if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
 427                 {
 428                     ServerCcb = Ccb;
 429                     break;
 430                 }
 431                 CurrentEntry = CurrentEntry->Flink;
 432             }
 433
 434             /*
 435             * No one is listening to me?! I'm so lonely... :(
 436             */
 437
 438             if (ServerCcb == NULL)
 439             {
 440                 /* Not found, bail out with error for FILE_OPEN requests. */
 441                 DPRINT("No listening server CCB found!\n");
 442                 if (ClientCcb->Data)
 443                 {
 444                     ExFreePoolWithTag(ClientCcb->Data, TAG_NPFS_CCB_DATA);
 445                 }
 446
 447                 NpfsDereferenceCcb(ClientCcb);
 448                 KeUnlockMutex(&Fcb->CcbListLock);
 449                 NpfsDereferenceFcb(Fcb);
 450                 Irp->IoStatus.Status = STATUS_OBJECT_NAME_NOT_FOUND;
 451                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 452                 return STATUS_OBJECT_NAME_NOT_FOUND;
 453             }
 454         }
 455         else
 456         {
 457             /* Signal the server thread and remove it from the waiter list */
 458             /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */
 459             NpfsSignalAndRemoveListeningServerInstance(Fcb, ServerCcb);
 460         }
 461 #ifndef USING_PROPER_NPFS_WAIT_SEMANTICS
 462     }
 463     else if (IsListEmpty(&Fcb->ServerCcbListHead))
 464     {
 465         DPRINT("No server fcb found!\n");
 466
 467         if (ClientCcb->Data)
 468         {
 469             ExFreePoolWithTag(ClientCcb->Data, TAG_NPFS_CCB_DATA);
 470         }
 471
 472         NpfsDereferenceCcb(ClientCcb);
 473         KeUnlockMutex(&Fcb->CcbListLock);
 474         NpfsDereferenceFcb(Fcb);
 475         Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
 476         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 477         return STATUS_UNSUCCESSFUL;
 478     }
 479 #endif
 480
 481     /*
 482     * Step 4. Add the client CCB to a list and connect it if possible.
 483     */
 484
 485     /* Add the client CCB to the pipe CCB list. */
 486     InsertTailList(&Fcb->ClientCcbListHead, &ClientCcb->CcbListEntry);
 487
 488     /* Connect to listening server side */
 489     if (ServerCcb)
 490     {
 491         NpfsCcbSetOtherSide(ClientCcb, ServerCcb);
 492         NpfsCcbSetOtherSide(ServerCcb, ClientCcb);
 493         ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
 494         ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
 495         KeSetEvent(&ServerCcb->ConnectEvent, IO_NO_INCREMENT, FALSE);
 496     }
 497
 498     KeUnlockMutex(&Fcb->CcbListLock);
 499
 500     FileObject->FsContext = Fcb;
 501     FileObject->FsContext2 = ClientCcb;
 502     FileObject->Flags |= FO_NAMED_PIPE;
 503
 504     Irp->IoStatus.Status = STATUS_SUCCESS;
 505     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 506
 507     DPRINT("Success!\n");
 508
 509     return STATUS_SUCCESS;
 510 }
 511
 512
 513 NTSTATUS NTAPI
 514 NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
 515                     PIRP Irp)
 516 {
 517     PEXTENDED_IO_STACK_LOCATION IoStack;
 518     PFILE_OBJECT FileObject;
 519     PNPFS_VCB Vcb;
 520     PNPFS_FCB Fcb;
 521     PNPFS_CCB Ccb;
 522     PNAMED_PIPE_CREATE_PARAMETERS Buffer;
 523
 524     DPRINT("NpfsCreateNamedPipe(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 525
 526     Vcb = (PNPFS_VCB)DeviceObject->DeviceExtension;
 527     IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp);
 528     FileObject = IoStack->FileObject;
 529     DPRINT("FileObject %p\n", FileObject);
 530     DPRINT("Pipe name %wZ\n", &FileObject->FileName);
 531
 532     Buffer = IoStack->Parameters.CreatePipe.Parameters;
 533
 534     Irp->IoStatus.Information = 0;
 535
 536     if (!(IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) ||
 537         (IoStack->Parameters.CreatePipe.ShareAccess & ~(FILE_SHARE_READ|FILE_SHARE_WRITE)))
 538     {
 539         Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
 540         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 541         return STATUS_INVALID_PARAMETER;
 542     }
 543
 544     KeLockMutex(&Vcb->PipeListLock);
 545
 546     /*
 547     * First search for existing Pipe with the same name.
 548     */
 549     Fcb = NpfsFindPipe(Vcb, &FileObject->FileName);
 550     if (Fcb != NULL)
 551     {
 552         /*
 553         * Found Pipe with the same name. Check if we are
 554         * allowed to use it.
 555         */
 556         KeUnlockMutex(&Vcb->PipeListLock);
 557
 558         if (Fcb->CurrentInstances >= Fcb->MaximumInstances)
 559         {
 560             DPRINT("Out of instances.\n");
 561             NpfsDereferenceFcb(Fcb);
 562             Irp->IoStatus.Status = STATUS_INSTANCE_NOT_AVAILABLE;
 563             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 564             return STATUS_INSTANCE_NOT_AVAILABLE;
 565         }
 566
 567         if (Fcb->MaximumInstances != Buffer->MaximumInstances ||
 568             Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart ||
 569             Fcb->PipeType != Buffer->NamedPipeType)
 570         {
 571             DPRINT("Asked for invalid pipe mode.\n");
 572             NpfsDereferenceFcb(Fcb);
 573             Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
 574             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 575             return STATUS_ACCESS_DENIED;
 576         }
 577     }
 578     else
 579     {
 580         Fcb = ExAllocatePoolWithTag(NonPagedPool, sizeof(NPFS_FCB), TAG_NPFS_FCB);
 581         if (Fcb == NULL)
 582         {
 583             KeUnlockMutex(&Vcb->PipeListLock);
 584             Irp->IoStatus.Status = STATUS_NO_MEMORY;
 585             Irp->IoStatus.Information = 0;
 586             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 587             return STATUS_NO_MEMORY;
 588         }
 589
 590         Fcb->Type = FCB_PIPE;
 591         Fcb->Vcb = Vcb;
 592         Fcb->RefCount = 1;
 593         Fcb->PipeName.Length = FileObject->FileName.Length;
 594         Fcb->PipeName.MaximumLength = Fcb->PipeName.Length + sizeof(UNICODE_NULL);
 595         Fcb->PipeName.Buffer = ExAllocatePoolWithTag(NonPagedPool,
 596                                                      Fcb->PipeName.MaximumLength,
 597                                                      TAG_NPFS_NAMEBLOCK);
 598         if (Fcb->PipeName.Buffer == NULL)
 599         {
 600             KeUnlockMutex(&Vcb->PipeListLock);
 601             ExFreePoolWithTag(Fcb, TAG_NPFS_FCB);
 602             Irp->IoStatus.Status = STATUS_NO_MEMORY;
 603             Irp->IoStatus.Information = 0;
 604             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 605             return STATUS_NO_MEMORY;
 606         }
 607
 608         RtlCopyUnicodeString(&Fcb->PipeName, &FileObject->FileName);
 609
 610         InitializeListHead(&Fcb->ServerCcbListHead);
 611         InitializeListHead(&Fcb->ClientCcbListHead);
 612         InitializeListHead(&Fcb->WaiterListHead);
 613         KeInitializeMutex(&Fcb->CcbListLock, 0);
 614
 615         Fcb->PipeType = Buffer->NamedPipeType;
 616         Fcb->ServerReadMode = Buffer->ReadMode;
 617         /* MSDN documentation reads that clients always start off in byte mode */
 618         Fcb->ClientReadMode = FILE_PIPE_BYTE_STREAM_MODE;
 619
 620         Fcb->CompletionMode = Buffer->CompletionMode;
 621         switch (IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE))
 622         {
 623         case FILE_SHARE_READ:
 624             Fcb->PipeConfiguration = FILE_PIPE_OUTBOUND;
 625             break;
 626         case FILE_SHARE_WRITE:
 627             Fcb->PipeConfiguration = FILE_PIPE_INBOUND;
 628             break;
 629         case FILE_SHARE_READ|FILE_SHARE_WRITE:
 630             Fcb->PipeConfiguration = FILE_PIPE_FULL_DUPLEX;
 631             break;
 632         }
 633         Fcb->MaximumInstances = Buffer->MaximumInstances;
 634         Fcb->CurrentInstances = 0;
 635         Fcb->TimeOut = Buffer->DefaultTimeout;
 636         if (!(Fcb->PipeConfiguration & FILE_PIPE_OUTBOUND) ||
 637             Fcb->PipeConfiguration & FILE_PIPE_FULL_DUPLEX)
 638         {
 639             if (Buffer->InboundQuota == 0)
 640             {
 641                 Fcb->InboundQuota = Vcb->DefaultQuota;
 642             }
 643             else
 644             {
 645                 Fcb->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota);
 646                 if (Fcb->InboundQuota < Vcb->MinQuota)
 647                 {
 648                     Fcb->InboundQuota = Vcb->MinQuota;
 649                 }
 650                 else if (Fcb->InboundQuota > Vcb->MaxQuota)
 651                 {
 652                     Fcb->InboundQuota = Vcb->MaxQuota;
 653                 }
 654             }
 655         }
 656         else
 657         {
 658             Fcb->InboundQuota = 0;
 659         }
 660
 661         if (Fcb->PipeConfiguration & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND))
 662         {
 663             if (Buffer->OutboundQuota == 0)
 664             {
 665                 Fcb->OutboundQuota = Vcb->DefaultQuota;
 666             }
 667             else
 668             {
 669                 Fcb->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota);
 670                 if (Fcb->OutboundQuota < Vcb->MinQuota)
 671                 {
 672                     Fcb->OutboundQuota = Vcb->MinQuota;
 673                 }
 674                 else if (Fcb->OutboundQuota > Vcb->MaxQuota)
 675                 {
 676                     Fcb->OutboundQuota = Vcb->MaxQuota;
 677                 }
 678             }
 679         }
 680         else
 681         {
 682             Fcb->OutboundQuota = 0;
 683         }
 684
 685         InsertTailList(&Vcb->PipeListHead, &Fcb->PipeListEntry);
 686         KeUnlockMutex(&Vcb->PipeListLock);
 687     }
 688
 689     Ccb = NpfsAllocateCcb(CCB_PIPE, Fcb);
 690     if (Ccb == NULL)
 691     {
 692         NpfsDereferenceFcb(Fcb);
 693         Irp->IoStatus.Status = STATUS_NO_MEMORY;
 694         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 695         return STATUS_NO_MEMORY;
 696     }
 697
 698     Ccb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
 699
 700     if (Fcb->InboundQuota)
 701     {
 702         Ccb->Data = ExAllocatePoolWithTag(PagedPool,
 703                                           Fcb->InboundQuota,
 704                                           TAG_NPFS_CCB_DATA);
 705         if (Ccb->Data == NULL)
 706         {
 707             NpfsDereferenceCcb(Ccb);
 708             NpfsDereferenceFcb(Fcb);
 709
 710             Irp->IoStatus.Status = STATUS_NO_MEMORY;
 711             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 712             return STATUS_NO_MEMORY;
 713         }
 714     }
 715     else
 716     {
 717         Ccb->Data = NULL;
 718     }
 719
 720     Ccb->ReadPtr = Ccb->Data;
 721     Ccb->WritePtr = Ccb->Data;
 722     Ccb->ReadDataAvailable = 0;
 723     Ccb->WriteQuotaAvailable = Fcb->InboundQuota;
 724     Ccb->MaxDataLength = Fcb->InboundQuota;
 725     InitializeListHead(&Ccb->ReadRequestListHead);
 726     ExInitializeFastMutex(&Ccb->DataListLock);
 727
 728     Fcb->CurrentInstances++;
 729
 730     Ccb->Fcb = Fcb;
 731     Ccb->FileObject = FileObject;
 732     Ccb->PipeEnd = FILE_PIPE_SERVER_END;
 733     Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
 734
 735     DPRINT("CCB: %p\n", Ccb);
 736
 737     KeInitializeEvent(&Ccb->ConnectEvent, SynchronizationEvent, FALSE);
 738     KeInitializeEvent(&Ccb->ReadEvent, NotificationEvent, FALSE);
 739     KeInitializeEvent(&Ccb->WriteEvent, NotificationEvent, FALSE);
 740
 741     KeLockMutex(&Fcb->CcbListLock);
 742     InsertTailList(&Fcb->ServerCcbListHead, &Ccb->CcbListEntry);
 743     KeUnlockMutex(&Fcb->CcbListLock);
 744
 745     FileObject->FsContext = Fcb;
 746     FileObject->FsContext2 = Ccb;
 747     FileObject->Flags |= FO_NAMED_PIPE;
 748
 749     Irp->IoStatus.Status = STATUS_SUCCESS;
 750     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 751
 752     DPRINT("Success!\n");
 753
 754     return STATUS_SUCCESS;
 755 }
 756
 757
 758 NTSTATUS NTAPI
 759 NpfsCleanup(PDEVICE_OBJECT DeviceObject,
 760             PIRP Irp)
 761 {
 762     //PNPFS_VCB Vcb;
 763     PIO_STACK_LOCATION IoStack;
 764     PFILE_OBJECT FileObject;
 765     PNPFS_CCB Ccb, OtherSide;
 766     PNPFS_FCB Fcb;
 767     BOOLEAN Server;
 768
 769     DPRINT("NpfsCleanup(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 770
 771     IoStack = IoGetCurrentIrpStackLocation(Irp);
 772     //Vcb = (PNPFS_VCB)DeviceObject->DeviceExtension;
 773     FileObject = IoStack->FileObject;
 774     Ccb = FileObject->FsContext2;
 775
 776     if (Ccb == NULL)
 777     {
 778         DPRINT("Success!\n");
 779         Irp->IoStatus.Status = STATUS_SUCCESS;
 780         Irp->IoStatus.Information = 0;
 781         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 782         return STATUS_SUCCESS;
 783     }
 784
 785     if (Ccb->Type == CCB_DEVICE)
 786     {
 787         DPRINT("Cleanup the file system!\n");
 788         Irp->IoStatus.Status = STATUS_SUCCESS;
 789         Irp->IoStatus.Information = 0;
 790         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 791         return STATUS_SUCCESS;
 792     }
 793
 794     if (Ccb->Type == CCB_DIRECTORY)
 795     {
 796         DPRINT("Cleanup the root directory!\n");
 797         Irp->IoStatus.Status = STATUS_SUCCESS;
 798         Irp->IoStatus.Information = 0;
 799         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 800         return STATUS_SUCCESS;
 801     }
 802
 803     DPRINT("CCB %p\n", Ccb);
 804     Fcb = Ccb->Fcb;
 805
 806     DPRINT("Cleaning pipe %wZ\n", &Fcb->PipeName);
 807
 808     KeLockMutex(&Fcb->CcbListLock);
 809
 810     Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
 811
 812     if (Server)
 813     {
 814         /* FIXME: Clean up existing connections here ?? */
 815         DPRINT("Server\n");
 816     }
 817     else
 818     {
 819         DPRINT("Client\n");
 820     }
 821     if ((Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) && (Ccb->OtherSide))
 822     {
 823         OtherSide = Ccb->OtherSide;
 824         ASSERT(OtherSide->OtherSide == Ccb);
 825
 826         /* Lock the server first */
 827         if (Server)
 828         {
 829             ExAcquireFastMutex(&Ccb->DataListLock);
 830             ExAcquireFastMutex(&OtherSide->DataListLock);
 831         }
 832         else
 833         {
 834             ExAcquireFastMutex(&OtherSide->DataListLock);
 835             ExAcquireFastMutex(&Ccb->DataListLock);
 836         }
 837
 838         /* Unlink FCBs */
 839         NpfsCcbSetOtherSide(OtherSide, NULL);
 840         NpfsCcbSetOtherSide(Ccb, NULL);
 841
 842         /*
 843         * Signaling the write event. If is possible that an other
 844         * thread waits for an empty buffer.
 845         */
 846         KeSetEvent(&OtherSide->ReadEvent, IO_NO_INCREMENT, FALSE);
 847         KeSetEvent(&OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
 848         if (Server)
 849         {
 850             ExReleaseFastMutex(&OtherSide->DataListLock);
 851             ExReleaseFastMutex(&Ccb->DataListLock);
 852         }
 853         else
 854         {
 855             ExReleaseFastMutex(&Ccb->DataListLock);
 856             ExReleaseFastMutex(&OtherSide->DataListLock);
 857         }
 858     }
 859     else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
 860     {
 861         PLIST_ENTRY Entry;
 862         PNPFS_WAITER_ENTRY WaitEntry = NULL;
 863         BOOLEAN Complete = FALSE;
 864         KIRQL oldIrql;
 865         PIRP tmpIrp;
 866
 867         Entry = Ccb->Fcb->WaiterListHead.Flink;
 868         while (Entry != &Ccb->Fcb->WaiterListHead)
 869         {
 870             WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry);
 871             if (WaitEntry->Ccb == Ccb)
 872             {
 873                 RemoveEntryList(Entry);
 874                 tmpIrp = CONTAINING_RECORD(WaitEntry, IRP, Tail.Overlay.DriverContext);
 875                 IoAcquireCancelSpinLock(&oldIrql);
 876                 Complete = (NULL != IoSetCancelRoutine(tmpIrp, NULL));
 877                 IoReleaseCancelSpinLock(oldIrql);
 878                 if (Complete)
 879                 {
 880                     tmpIrp->IoStatus.Status = STATUS_PIPE_BROKEN;
 881                     tmpIrp->IoStatus.Information = 0;
 882                     IoCompleteRequest(tmpIrp, IO_NO_INCREMENT);
 883                 }
 884                 break;
 885             }
 886             Entry = Entry->Flink;
 887         }
 888
 889     }
 890     Ccb->PipeState = FILE_PIPE_CLOSING_STATE;
 891
 892     KeUnlockMutex(&Fcb->CcbListLock);
 893
 894     ExAcquireFastMutex(&Ccb->DataListLock);
 895     if (Ccb->Data)
 896     {
 897         ExFreePoolWithTag(Ccb->Data, TAG_NPFS_CCB_DATA);
 898         Ccb->Data = NULL;
 899         Ccb->ReadPtr = NULL;
 900         Ccb->WritePtr = NULL;
 901     }
 902     ExReleaseFastMutex(&Ccb->DataListLock);
 903
 904     Irp->IoStatus.Status = STATUS_SUCCESS;
 905     Irp->IoStatus.Information = 0;
 906     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 907
 908     DPRINT("Success!\n");
 909
 910     return STATUS_SUCCESS;
 911 }
 912
 913 NTSTATUS NTAPI
 914 NpfsClose(PDEVICE_OBJECT DeviceObject,
 915           PIRP Irp)
 916 {
 917     PIO_STACK_LOCATION IoStack;
 918     PFILE_OBJECT FileObject;
 919     //PNPFS_VCB Vcb;
 920     PNPFS_FCB Fcb;
 921     PNPFS_CCB Ccb;
 922     BOOLEAN Server;
 923
 924     DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 925
 926     IoStack = IoGetCurrentIrpStackLocation(Irp);
 927     //Vcb = (PNPFS_VCB)DeviceObject->DeviceExtension;
 928     FileObject = IoStack->FileObject;
 929     Ccb = FileObject->FsContext2;
 930
 931     if (Ccb == NULL)
 932     {
 933         DPRINT("Success!\n");
 934         Irp->IoStatus.Status = STATUS_SUCCESS;
 935         Irp->IoStatus.Information = 0;
 936         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 937         return STATUS_SUCCESS;
 938     }
 939
 940     if (Ccb->Type == CCB_DEVICE)
 941     {
 942         DPRINT("Closing the file system!\n");
 943
 944         NpfsDereferenceCcb(Ccb);
 945         FileObject->FsContext = NULL;
 946         FileObject->FsContext2 = NULL;
 947
 948         Irp->IoStatus.Status = STATUS_SUCCESS;
 949         Irp->IoStatus.Information = 0;
 950         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 951         return STATUS_SUCCESS;
 952     }
 953
 954     if (Ccb->Type == CCB_DIRECTORY)
 955     {
 956         DPRINT("Closing the root directory!\n");
 957
 958         if (Ccb->u.Directory.SearchPattern.Buffer != NULL)
 959             ExFreePoolWithTag(Ccb->u.Directory.SearchPattern.Buffer,
 960                               TAG_NPFS_NAMEBLOCK);
 961
 962         NpfsDereferenceCcb(Ccb);
 963         FileObject->FsContext = NULL;
 964         FileObject->FsContext2 = NULL;
 965
 966         Irp->IoStatus.Status = STATUS_SUCCESS;
 967         Irp->IoStatus.Information = 0;
 968         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 969         return STATUS_SUCCESS;
 970     }
 971
 972     DPRINT("CCB %p\n", Ccb);
 973     Fcb = Ccb->Fcb;
 974
 975     DPRINT("Closing pipe %wZ\n", &Fcb->PipeName);
 976
 977     KeLockMutex(&Fcb->CcbListLock);
 978
 979     Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
 980
 981     if (Server)
 982     {
 983         DPRINT("Server\n");
 984         Fcb->CurrentInstances--;
 985     }
 986     else
 987     {
 988         DPRINT("Client\n");
 989     }
 990
 991     /* Disconnect the pipes */
 992     if (Ccb->OtherSide)
 993     {
 994         /* FIXME: Timo wants it rewritten */
 995         /*ASSERT(Ccb->OtherSide->OtherSide == Ccb);*/
 996         NpfsCcbSetOtherSide(Ccb->OtherSide, NULL);
 997         NpfsCcbSetOtherSide(Ccb, NULL);
 998     }
 999
1000     ASSERT(Ccb->PipeState == FILE_PIPE_CLOSING_STATE);
1001
1002     FileObject->FsContext2 = NULL;
1003
1004     RemoveEntryList(&Ccb->CcbListEntry);
1005
1006     NpfsDereferenceCcb(Ccb);
1007
1008     KeUnlockMutex(&Fcb->CcbListLock);
1009
1010     NpfsDereferenceFcb(Fcb);
1011     FileObject->FsContext = NULL;
1012
1013     Irp->IoStatus.Status = STATUS_SUCCESS;
1014     Irp->IoStatus.Information = 0;
1015     IoCompleteRequest(Irp, IO_NO_INCREMENT);
1016
1017     DPRINT("Success!\n");
1018
1019     return STATUS_SUCCESS;
1020 }
1021
1022 /* EOF */