drivers/network/afd/afd/main.c

   1 /* $Id$
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             drivers/net/afd/afd/main.c
   5  * PURPOSE:          Ancillary functions driver
   6  * PROGRAMMER:       Art Yerkes (ayerkes@speakeasy.net)
   7  * UPDATE HISTORY:
   8  * 20040630 Created
   9  *
  10  * Suggestions: Uniform naming (AfdXxx)
  11  */
  12
  13 /* INCLUDES */
  14
  15 #include "afd.h"
  16
  17 #if DBG
  18
  19 /* See debug.h for debug/trace constants */
  20 //DWORD DebugTraceLevel = DEBUG_ULTRA;
  21 DWORD DebugTraceLevel = MIN_TRACE;
  22
  23 #endif /* DBG */
  24
  25 void OskitDumpBuffer( PCHAR Data, UINT Len ) {
  26     unsigned int i;
  27
  28     for( i = 0; i < Len; i++ ) {
  29         if( i && !(i & 0xf) ) DbgPrint( "\n" );
  30         if( !(i & 0xf) ) DbgPrint( "%08x: ", (UINT)(Data + i) );
  31         DbgPrint( " %02x", Data[i] & 0xff );
  32     }
  33     DbgPrint("\n");
  34 }
  35
  36 /* FUNCTIONS */
  37
  38 NTSTATUS NTAPI
  39 DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
  40
  41 NTSTATUS NTAPI
  42 AfdGetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
  43                         PIO_STACK_LOCATION IrpSp)
  44 {
  45     PFILE_OBJECT FileObject = IrpSp->FileObject;
  46     PAFD_FCB FCB = FileObject->FsContext;
  47     UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
  48
  49     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
  50
  51     if (FCB->DisconnectOptionsSize == 0)
  52     {
  53         AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
  54         return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
  55     }
  56
  57     ASSERT(FCB->DisconnectOptions);
  58
  59     if (FCB->FilledDisconnectOptions < BufferSize) BufferSize = FCB->FilledDisconnectOptions;
  60
  61     RtlCopyMemory(Irp->UserBuffer,
  62                   FCB->DisconnectOptions,
  63                   BufferSize);
  64
  65     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, BufferSize);
  66 }
  67
  68 NTSTATUS
  69 NTAPI
  70 AfdSetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
  71                         PIO_STACK_LOCATION IrpSp)
  72 {
  73     PFILE_OBJECT FileObject = IrpSp->FileObject;
  74     PAFD_FCB FCB = FileObject->FsContext;
  75     PVOID DisconnectOptions = LockRequest(Irp, IrpSp, FALSE, NULL);
  76     UINT DisconnectOptionsSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
  77
  78     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
  79
  80     if (!DisconnectOptions)
  81         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
  82
  83     if (FCB->DisconnectOptions)
  84     {
  85         ExFreePool(FCB->DisconnectOptions);
  86         FCB->DisconnectOptions = NULL;
  87         FCB->DisconnectOptionsSize = 0;
  88         FCB->FilledDisconnectOptions = 0;
  89     }
  90
  91     FCB->DisconnectOptions = ExAllocatePool(PagedPool, DisconnectOptionsSize);
  92     if (!FCB->DisconnectOptions)
  93         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
  94
  95     RtlCopyMemory(FCB->DisconnectOptions,
  96                   DisconnectOptions,
  97                   DisconnectOptionsSize);
  98
  99     FCB->DisconnectOptionsSize = DisconnectOptionsSize;
 100
 101     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
 102 }
 103
 104 NTSTATUS
 105 NTAPI
 106 AfdSetDisconnectOptionsSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 107                       PIO_STACK_LOCATION IrpSp)
 108 {
 109     PFILE_OBJECT FileObject = IrpSp->FileObject;
 110     PAFD_FCB FCB = FileObject->FsContext;
 111     PUINT DisconnectOptionsSize = LockRequest(Irp, IrpSp, FALSE, NULL);
 112     UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
 113
 114     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 115
 116     if (!DisconnectOptionsSize)
 117         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 118
 119     if (BufferSize < sizeof(UINT))
 120     {
 121         AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
 122         return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, 0);
 123     }
 124
 125     if (FCB->DisconnectOptions)
 126     {
 127         ExFreePool(FCB->DisconnectOptions);
 128         FCB->DisconnectOptionsSize = 0;
 129         FCB->FilledDisconnectOptions = 0;
 130     }
 131
 132     FCB->DisconnectOptions = ExAllocatePool(PagedPool, *DisconnectOptionsSize);
 133     if (!FCB->DisconnectOptions) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 134
 135     FCB->DisconnectOptionsSize = *DisconnectOptionsSize;
 136
 137     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
 138 }
 139
 140 NTSTATUS NTAPI
 141 AfdGetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 142                   PIO_STACK_LOCATION IrpSp)
 143 {
 144     PFILE_OBJECT FileObject = IrpSp->FileObject;
 145     PAFD_FCB FCB = FileObject->FsContext;
 146     UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
 147
 148     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 149
 150     if (FCB->DisconnectDataSize == 0)
 151     {
 152         AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
 153         return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
 154     }
 155
 156     ASSERT(FCB->DisconnectData);
 157
 158     if (FCB->FilledDisconnectData < BufferSize)
 159         BufferSize = FCB->FilledDisconnectData;
 160
 161     RtlCopyMemory(Irp->UserBuffer,
 162                   FCB->DisconnectData,
 163                   BufferSize);
 164
 165     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, BufferSize);
 166 }
 167
 168 NTSTATUS
 169 NTAPI
 170 AfdSetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 171                      PIO_STACK_LOCATION IrpSp)
 172 {
 173     PFILE_OBJECT FileObject = IrpSp->FileObject;
 174     PAFD_FCB FCB = FileObject->FsContext;
 175     PVOID DisconnectData = LockRequest(Irp, IrpSp, FALSE, NULL);
 176     UINT DisconnectDataSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
 177
 178     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 179
 180     if (!DisconnectData)
 181         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 182
 183     if (FCB->DisconnectData)
 184     {
 185         ExFreePool(FCB->DisconnectData);
 186         FCB->DisconnectData = NULL;
 187         FCB->DisconnectDataSize = 0;
 188         FCB->FilledDisconnectData = 0;
 189     }
 190
 191     FCB->DisconnectData = ExAllocatePool(PagedPool, DisconnectDataSize);
 192     if (!FCB->DisconnectData)
 193         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 194
 195     RtlCopyMemory(FCB->DisconnectData,
 196                   DisconnectData,
 197                   DisconnectDataSize);
 198
 199     FCB->DisconnectDataSize = DisconnectDataSize;
 200
 201     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
 202 }
 203
 204 NTSTATUS
 205 NTAPI
 206 AfdSetDisconnectDataSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 207                       PIO_STACK_LOCATION IrpSp)
 208 {
 209     PFILE_OBJECT FileObject = IrpSp->FileObject;
 210     PAFD_FCB FCB = FileObject->FsContext;
 211     PUINT DisconnectDataSize = LockRequest(Irp, IrpSp, FALSE, NULL);
 212     UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
 213
 214     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 215
 216     if (!DisconnectDataSize)
 217         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 218
 219     if (BufferSize < sizeof(UINT))
 220     {
 221         AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
 222         return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, 0);
 223     }
 224
 225     if (FCB->DisconnectData)
 226     {
 227         ExFreePool(FCB->DisconnectData);
 228         FCB->DisconnectDataSize = 0;
 229         FCB->FilledDisconnectData = 0;
 230     }
 231
 232     FCB->DisconnectData = ExAllocatePool(PagedPool, *DisconnectDataSize);
 233     if (!FCB->DisconnectData)
 234         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 235
 236     FCB->DisconnectDataSize = *DisconnectDataSize;
 237
 238     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
 239 }
 240
 241 static NTSTATUS NTAPI
 242 AfdGetTdiHandles(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 243                 PIO_STACK_LOCATION IrpSp)
 244 {
 245     PFILE_OBJECT FileObject = IrpSp->FileObject;
 246     PAFD_FCB FCB = FileObject->FsContext;
 247     PULONG HandleFlags = LockRequest(Irp, IrpSp, TRUE, NULL);
 248     PAFD_TDI_HANDLE_DATA HandleData = Irp->UserBuffer;
 249
 250     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 251
 252     if (!HandleFlags)
 253         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 254
 255     if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG) ||
 256         IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(*HandleData))
 257     {
 258         AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
 259         return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, 0);
 260     }
 261
 262     if ((*HandleFlags) & AFD_ADDRESS_HANDLE)
 263         HandleData->TdiAddressHandle = FCB->AddressFile.Handle;
 264
 265     if ((*HandleFlags) & AFD_CONNECTION_HANDLE)
 266         HandleData->TdiConnectionHandle = FCB->Connection.Handle;
 267
 268     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
 269 }
 270
 271 static NTSTATUS NTAPI
 272 AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 273                 PIO_STACK_LOCATION IrpSp) {
 274     PAFD_FCB FCB;
 275     PFILE_OBJECT FileObject;
 276     PAFD_DEVICE_EXTENSION DeviceExt;
 277     PFILE_FULL_EA_INFORMATION EaInfo;
 278     PAFD_CREATE_PACKET ConnectInfo = NULL;
 279     //ULONG EaLength;
 280     PWCHAR EaInfoValue = NULL;
 281     //UINT Disposition;
 282     UINT i;
 283     NTSTATUS Status = STATUS_SUCCESS;
 284
 285     AFD_DbgPrint(MID_TRACE,("AfdCreate(DeviceObject %p Irp %p)\n",
 286                             DeviceObject, Irp));
 287
 288     DeviceExt = DeviceObject->DeviceExtension;
 289     FileObject = IrpSp->FileObject;
 290     //Disposition = (IrpSp->Parameters.Create.Options >> 24) & 0xff;
 291
 292     Irp->IoStatus.Information = 0;
 293
 294     EaInfo = Irp->AssociatedIrp.SystemBuffer;
 295
 296     if( EaInfo ) {
 297         ConnectInfo = (PAFD_CREATE_PACKET)(EaInfo->EaName + EaInfo->EaNameLength + 1);
 298         EaInfoValue = (PWCHAR)(((PCHAR)ConnectInfo) + sizeof(AFD_CREATE_PACKET));
 299
 300         //EaLength = sizeof(FILE_FULL_EA_INFORMATION) + EaInfo->EaNameLength + EaInfo->EaValueLength;
 301
 302         AFD_DbgPrint(MID_TRACE,("EaInfo: %x, EaInfoValue: %x\n",
 303                                 EaInfo, EaInfoValue));
 304     }
 305
 306     AFD_DbgPrint(MID_TRACE,("About to allocate the new FCB\n"));
 307
 308     FCB = ExAllocatePool(NonPagedPool, sizeof(AFD_FCB));
 309     if( FCB == NULL ) {
 310         Irp->IoStatus.Status = STATUS_NO_MEMORY;
 311         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 312         return STATUS_NO_MEMORY;
 313     }
 314
 315     AFD_DbgPrint(MID_TRACE,("Initializing the new FCB @ %x (FileObject %x Flags %x)\n",
 316                             FCB, FileObject, ConnectInfo ? ConnectInfo->EndpointFlags : 0));
 317
 318     RtlZeroMemory( FCB, sizeof( *FCB ) );
 319
 320     FCB->Flags = ConnectInfo ? ConnectInfo->EndpointFlags : 0;
 321     FCB->GroupID = ConnectInfo ? ConnectInfo->GroupID : 0;
 322     FCB->GroupType = 0; /* FIXME */
 323     FCB->State = SOCKET_STATE_CREATED;
 324     FCB->FileObject = FileObject;
 325     FCB->DeviceExt = DeviceExt;
 326     FCB->AddressFile.Handle = INVALID_HANDLE_VALUE;
 327     FCB->Connection.Handle = INVALID_HANDLE_VALUE;
 328
 329     KeInitializeMutex( &FCB->Mutex, 0 );
 330
 331     for( i = 0; i < MAX_FUNCTIONS; i++ ) {
 332         InitializeListHead( &FCB->PendingIrpList[i] );
 333     }
 334
 335     InitializeListHead( &FCB->DatagramList );
 336     InitializeListHead( &FCB->PendingConnections );
 337
 338     AFD_DbgPrint(MID_TRACE,("%x: Checking command channel\n", FCB));
 339
 340     if( ConnectInfo ) {
 341         FCB->TdiDeviceName.Length = ConnectInfo->SizeOfTransportName;
 342         FCB->TdiDeviceName.MaximumLength = FCB->TdiDeviceName.Length;
 343         FCB->TdiDeviceName.Buffer =
 344             ExAllocatePool( NonPagedPool, FCB->TdiDeviceName.Length );
 345
 346         if( !FCB->TdiDeviceName.Buffer ) {
 347             ExFreePool(FCB);
 348             AFD_DbgPrint(MID_TRACE,("Could not copy target string\n"));
 349             Irp->IoStatus.Status = STATUS_NO_MEMORY;
 350             IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
 351             return STATUS_NO_MEMORY;
 352         }
 353
 354         RtlCopyMemory( FCB->TdiDeviceName.Buffer,
 355                        ConnectInfo->TransportName,
 356                        FCB->TdiDeviceName.Length );
 357
 358         AFD_DbgPrint(MID_TRACE,("Success: %s %wZ\n",
 359                                 EaInfo->EaName, &FCB->TdiDeviceName));
 360     } else {
 361         AFD_DbgPrint(MID_TRACE,("Success: Control connection\n"));
 362     }
 363
 364     FileObject->FsContext = FCB;
 365
 366     /* It seems that UDP sockets are writable from inception */
 367     if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS ) {
 368         AFD_DbgPrint(MID_TRACE,("Packet oriented socket\n"));
 369
 370         /* A datagram socket is always sendable */
 371         FCB->PollState |= AFD_EVENT_SEND;
 372         FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
 373         PollReeval( FCB->DeviceExt, FCB->FileObject );
 374     }
 375
 376     if( !NT_SUCCESS(Status) ) {
 377         if( FCB->TdiDeviceName.Buffer ) ExFreePool( FCB->TdiDeviceName.Buffer );
 378         ExFreePool( FCB );
 379         FileObject->FsContext = NULL;
 380     }
 381
 382     Irp->IoStatus.Status = Status;
 383     IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
 384
 385     return Status;
 386 }
 387
 388 static NTSTATUS NTAPI
 389 AfdCleanupSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 390                  PIO_STACK_LOCATION IrpSp)
 391 {
 392     PFILE_OBJECT FileObject = IrpSp->FileObject;
 393     PAFD_FCB FCB = FileObject->FsContext;
 394     PLIST_ENTRY CurrentEntry, NextEntry;
 395     UINT Function;
 396     PIRP CurrentIrp;
 397
 398     if( !SocketAcquireStateLock( FCB ) ) return LostSocket(Irp);
 399
 400     for (Function = 0; Function < MAX_FUNCTIONS; Function++)
 401     {
 402         CurrentEntry = FCB->PendingIrpList[Function].Flink;
 403         while (CurrentEntry != &FCB->PendingIrpList[Function])
 404         {
 405            NextEntry = CurrentEntry->Flink;
 406            CurrentIrp = CONTAINING_RECORD(CurrentEntry, IRP, Tail.Overlay.ListEntry);
 407
 408            /* The cancel routine will remove the IRP from the list */
 409            IoCancelIrp(CurrentIrp);
 410
 411            CurrentEntry = NextEntry;
 412         }
 413     }
 414
 415     KillSelectsForFCB( FCB->DeviceExt, FileObject, FALSE );
 416
 417     return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
 418 }
 419
 420 static NTSTATUS NTAPI
 421 AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 422                PIO_STACK_LOCATION IrpSp)
 423 {
 424     PFILE_OBJECT FileObject = IrpSp->FileObject;
 425     PAFD_FCB FCB = FileObject->FsContext;
 426     UINT i;
 427     PAFD_IN_FLIGHT_REQUEST InFlightRequest[IN_FLIGHT_REQUESTS];
 428     PAFD_TDI_OBJECT_QELT Qelt;
 429     PLIST_ENTRY QeltEntry;
 430
 431
 432     AFD_DbgPrint(MID_TRACE,("AfdClose(DeviceObject %p Irp %p)\n",
 433                             DeviceObject, Irp));
 434
 435     if( !SocketAcquireStateLock( FCB ) ) return STATUS_FILE_CLOSED;
 436
 437     FCB->State = SOCKET_STATE_CLOSED;
 438
 439     InFlightRequest[0] = &FCB->ListenIrp;
 440     InFlightRequest[1] = &FCB->ReceiveIrp;
 441     InFlightRequest[2] = &FCB->SendIrp;
 442     InFlightRequest[3] = &FCB->ConnectIrp;
 443     InFlightRequest[4] = &FCB->DisconnectIrp;
 444
 445     /* Cancel our pending requests */
 446     for( i = 0; i < IN_FLIGHT_REQUESTS; i++ ) {
 447         if( InFlightRequest[i]->InFlightRequest ) {
 448             AFD_DbgPrint(MID_TRACE,("Cancelling in flight irp %d (%x)\n",
 449                                     i, InFlightRequest[i]->InFlightRequest));
 450             IoCancelIrp(InFlightRequest[i]->InFlightRequest);
 451         }
 452     }
 453
 454     KillSelectsForFCB( FCB->DeviceExt, FileObject, FALSE );
 455
 456     ASSERT(IsListEmpty(&FCB->PendingIrpList[FUNCTION_CONNECT]));
 457     ASSERT(IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]));
 458     ASSERT(IsListEmpty(&FCB->PendingIrpList[FUNCTION_RECV]));
 459     ASSERT(IsListEmpty(&FCB->PendingIrpList[FUNCTION_PREACCEPT]));
 460     ASSERT(IsListEmpty(&FCB->PendingIrpList[FUNCTION_DISCONNECT]));
 461
 462     while (!IsListEmpty(&FCB->PendingConnections))
 463     {
 464         QeltEntry = RemoveHeadList(&FCB->PendingConnections);
 465         Qelt = CONTAINING_RECORD(QeltEntry, AFD_TDI_OBJECT_QELT, ListEntry);
 466
 467         /* We have to close all pending connections or the listen won't get closed */
 468         TdiDisassociateAddressFile(Qelt->Object.Object);
 469         ObDereferenceObject(Qelt->Object.Object);
 470         ZwClose(Qelt->Object.Handle);
 471
 472         ExFreePool(Qelt);
 473     }
 474
 475     SocketStateUnlock( FCB );
 476
 477     if( FCB->EventSelect )
 478         ObDereferenceObject( FCB->EventSelect );
 479
 480     if( FCB->Context )
 481         ExFreePool( FCB->Context );
 482
 483     if( FCB->Recv.Window )
 484         ExFreePool( FCB->Recv.Window );
 485
 486     if( FCB->Send.Window )
 487         ExFreePool( FCB->Send.Window );
 488
 489     if( FCB->AddressFrom )
 490         ExFreePool( FCB->AddressFrom );
 491
 492     if( FCB->ConnectCallInfo )
 493         ExFreePool( FCB->ConnectCallInfo );
 494
 495     if( FCB->ConnectReturnInfo )
 496         ExFreePool( FCB->ConnectReturnInfo );
 497
 498     if( FCB->ConnectData )
 499         ExFreePool( FCB->ConnectData );
 500
 501     if( FCB->DisconnectData )
 502         ExFreePool( FCB->DisconnectData );
 503
 504     if( FCB->ConnectOptions )
 505         ExFreePool( FCB->ConnectOptions );
 506
 507     if( FCB->DisconnectOptions )
 508         ExFreePool( FCB->DisconnectOptions );
 509
 510     if( FCB->LocalAddress )
 511         ExFreePool( FCB->LocalAddress );
 512
 513     if( FCB->RemoteAddress )
 514         ExFreePool( FCB->RemoteAddress );
 515
 516     if( FCB->Connection.Object )
 517     {
 518         TdiDisassociateAddressFile(FCB->Connection.Object);
 519         ObDereferenceObject(FCB->Connection.Object);
 520     }
 521
 522     if( FCB->AddressFile.Object )
 523         ObDereferenceObject(FCB->AddressFile.Object);
 524
 525     if( FCB->AddressFile.Handle != INVALID_HANDLE_VALUE )
 526     {
 527         if (ZwClose(FCB->AddressFile.Handle) == STATUS_INVALID_HANDLE)
 528         {
 529             DbgPrint("INVALID ADDRESS FILE HANDLE VALUE: %x %x\n", FCB->AddressFile.Handle, FCB->AddressFile.Object);
 530         }
 531     }
 532
 533     if( FCB->Connection.Handle != INVALID_HANDLE_VALUE )
 534     {
 535         if (ZwClose(FCB->Connection.Handle) == STATUS_INVALID_HANDLE)
 536         {
 537             DbgPrint("INVALID CONNECTION HANDLE VALUE: %x %x\n", FCB->Connection.Handle, FCB->Connection.Object);
 538         }
 539     }
 540
 541     if( FCB->TdiDeviceName.Buffer )
 542         ExFreePool(FCB->TdiDeviceName.Buffer);
 543
 544     ExFreePool(FCB);
 545
 546     Irp->IoStatus.Status = STATUS_SUCCESS;
 547     Irp->IoStatus.Information = 0;
 548     IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
 549
 550     AFD_DbgPrint(MID_TRACE, ("Returning success.\n"));
 551
 552     return STATUS_SUCCESS;
 553 }
 554
 555 static
 556 NTSTATUS
 557 NTAPI
 558 DisconnectComplete(PDEVICE_OBJECT DeviceObject,
 559                    PIRP Irp,
 560                    PVOID Context)
 561 {
 562     PAFD_FCB FCB = Context;
 563     PIRP CurrentIrp;
 564     PLIST_ENTRY CurrentEntry;
 565
 566     if (!SocketAcquireStateLock(FCB))
 567         return STATUS_FILE_CLOSED;
 568
 569     ASSERT(FCB->DisconnectIrp.InFlightRequest == Irp);
 570     FCB->DisconnectIrp.InFlightRequest = NULL;
 571
 572     ASSERT(FCB->DisconnectPending);
 573     ASSERT((IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest) ||
 574            (FCB->DisconnectFlags & TDI_DISCONNECT_ABORT));
 575
 576     if (NT_SUCCESS(Irp->IoStatus.Status) && (FCB->DisconnectFlags & TDI_DISCONNECT_RELEASE))
 577     {
 578         FCB->FilledDisconnectData = MIN(FCB->DisconnectDataSize, FCB->ConnectReturnInfo->UserDataLength);
 579         if (FCB->FilledDisconnectData)
 580         {
 581             RtlCopyMemory(FCB->DisconnectData,
 582                           FCB->ConnectReturnInfo->UserData,
 583                           FCB->FilledDisconnectData);
 584         }
 585
 586         FCB->FilledDisconnectOptions = MIN(FCB->DisconnectOptionsSize, FCB->ConnectReturnInfo->OptionsLength);
 587         if (FCB->FilledDisconnectOptions)
 588         {
 589             RtlCopyMemory(FCB->DisconnectOptions,
 590                           FCB->ConnectReturnInfo->Options,
 591                           FCB->FilledDisconnectOptions);
 592         }
 593     }
 594
 595     FCB->DisconnectPending = FALSE;
 596
 597     while (!IsListEmpty(&FCB->PendingIrpList[FUNCTION_DISCONNECT]))
 598     {
 599         CurrentEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_DISCONNECT]);
 600         CurrentIrp = CONTAINING_RECORD(CurrentEntry, IRP, Tail.Overlay.ListEntry);
 601         CurrentIrp->IoStatus.Status = Irp->IoStatus.Status;
 602         CurrentIrp->IoStatus.Information = 0;
 603         UnlockRequest(CurrentIrp, IoGetCurrentIrpStackLocation(CurrentIrp));
 604         (void)IoSetCancelRoutine(CurrentIrp, NULL);
 605         IoCompleteRequest(CurrentIrp, IO_NETWORK_INCREMENT );
 606     }
 607
 608     if (!(FCB->DisconnectFlags & TDI_DISCONNECT_RELEASE))
 609     {
 610         /* Signal complete connection closure immediately */
 611         FCB->PollState |= AFD_EVENT_ABORT;
 612         FCB->PollStatus[FD_CLOSE_BIT] = Irp->IoStatus.Status;
 613         PollReeval(FCB->DeviceExt, FCB->FileObject);
 614     }
 615
 616     SocketStateUnlock(FCB);
 617
 618     return Irp->IoStatus.Status;
 619 }
 620
 621 static
 622 NTSTATUS
 623 DoDisconnect(PAFD_FCB FCB)
 624 {
 625     NTSTATUS Status;
 626
 627     ASSERT(FCB->DisconnectPending);
 628     ASSERT((IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest) ||
 629            (FCB->DisconnectFlags & TDI_DISCONNECT_ABORT));
 630
 631     if (FCB->DisconnectIrp.InFlightRequest)
 632     {
 633         return STATUS_PENDING;
 634     }
 635
 636     FCB->ConnectCallInfo->UserData = FCB->DisconnectData;
 637     FCB->ConnectCallInfo->UserDataLength = FCB->DisconnectDataSize;
 638     FCB->ConnectCallInfo->Options = FCB->DisconnectOptions;
 639     FCB->ConnectCallInfo->OptionsLength = FCB->DisconnectOptionsSize;
 640
 641     Status = TdiDisconnect(&FCB->DisconnectIrp.InFlightRequest,
 642                            FCB->Connection.Object,
 643                            &FCB->DisconnectTimeout,
 644                            FCB->DisconnectFlags,
 645                            &FCB->DisconnectIrp.Iosb,
 646                            DisconnectComplete,
 647                            FCB,
 648                            FCB->ConnectCallInfo,
 649                            FCB->ConnectReturnInfo);
 650     if (Status != STATUS_PENDING)
 651     {
 652         FCB->DisconnectPending = FALSE;
 653     }
 654
 655     return Status;
 656 }
 657
 658 VOID
 659 RetryDisconnectCompletion(PAFD_FCB FCB)
 660 {
 661     ASSERT(FCB->RemoteAddress);
 662
 663     if (IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest && FCB->DisconnectPending)
 664     {
 665         /* Sends are done; fire off a TDI_DISCONNECT request */
 666         DoDisconnect(FCB);
 667     }
 668 }
 669
 670 static NTSTATUS NTAPI
 671 AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 672               PIO_STACK_LOCATION IrpSp) {
 673     PFILE_OBJECT FileObject = IrpSp->FileObject;
 674     PAFD_FCB FCB = FileObject->FsContext;
 675     PAFD_DISCONNECT_INFO DisReq;
 676     NTSTATUS Status = STATUS_SUCCESS;
 677     USHORT Flags;
 678     PLIST_ENTRY CurrentEntry;
 679     PIRP CurrentIrp;
 680
 681     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 682
 683     if (!(DisReq = LockRequest(Irp, IrpSp, FALSE, NULL)))
 684         return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
 685                                        Irp, 0 );
 686
 687     /* Send direction only */
 688     if ((DisReq->DisconnectType & AFD_DISCONNECT_SEND) &&
 689         !(DisReq->DisconnectType & AFD_DISCONNECT_RECV))
 690     {
 691         /* Perform a controlled disconnect */
 692         Flags = TDI_DISCONNECT_RELEASE;
 693     }
 694     /* Receive direction or both */
 695     else
 696     {
 697         /* Mark that we can't issue another receive request */
 698         FCB->TdiReceiveClosed = TRUE;
 699
 700         /* Try to cancel a pending TDI receive IRP if there was one in progress */
 701         if (FCB->ReceiveIrp.InFlightRequest)
 702             IoCancelIrp(FCB->ReceiveIrp.InFlightRequest);
 703
 704         /* Discard any pending data */
 705         FCB->Recv.Content = 0;
 706         FCB->Recv.BytesUsed = 0;
 707
 708         /* Mark us as overread to complete future reads with an error */
 709         FCB->Overread = TRUE;
 710
 711         /* Set a successful close status to indicate a shutdown on overread */
 712         FCB->PollStatus[FD_CLOSE_BIT] = STATUS_SUCCESS;
 713
 714         /* Clear the receive event */
 715         FCB->PollState &= ~AFD_EVENT_RECEIVE;
 716
 717         /* Receive direction only */
 718         if ((DisReq->DisconnectType & AFD_DISCONNECT_RECV) &&
 719             !(DisReq->DisconnectType & AFD_DISCONNECT_SEND))
 720         {
 721             /* No need to tell the transport driver for receive direction only */
 722             return UnlockAndMaybeComplete( FCB, STATUS_SUCCESS, Irp, 0 );
 723         }
 724         else
 725         {
 726             /* Perform an abortive disconnect */
 727             Flags = TDI_DISCONNECT_ABORT;
 728         }
 729     }
 730
 731     if (!(FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS))
 732     {
 733         if (!FCB->ConnectCallInfo)
 734         {
 735             AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
 736             return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER,
 737                                            Irp, 0 );
 738         }
 739
 740         if (FCB->DisconnectPending)
 741         {
 742             if (FCB->DisconnectIrp.InFlightRequest)
 743             {
 744                 IoCancelIrp(FCB->DisconnectIrp.InFlightRequest);
 745                 ASSERT(!FCB->DisconnectIrp.InFlightRequest);
 746             }
 747             else
 748             {
 749                 while (!IsListEmpty(&FCB->PendingIrpList[FUNCTION_DISCONNECT]))
 750                 {
 751                     CurrentEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_DISCONNECT]);
 752                     CurrentIrp = CONTAINING_RECORD(CurrentEntry, IRP, Tail.Overlay.ListEntry);
 753                     CurrentIrp->IoStatus.Status = STATUS_CANCELLED;
 754                     CurrentIrp->IoStatus.Information = 0;
 755                     UnlockRequest(CurrentIrp, IoGetCurrentIrpStackLocation(CurrentIrp));
 756                     (void)IoSetCancelRoutine(CurrentIrp, NULL);
 757                     IoCompleteRequest(CurrentIrp, IO_NETWORK_INCREMENT );
 758                 }
 759             }
 760         }
 761
 762         FCB->DisconnectFlags = Flags;
 763         FCB->DisconnectTimeout = DisReq->Timeout;
 764         FCB->DisconnectPending = TRUE;
 765         FCB->SendClosed = TRUE;
 766         FCB->PollState &= ~AFD_EVENT_SEND;
 767
 768         Status = QueueUserModeIrp(FCB, Irp, FUNCTION_DISCONNECT);
 769         if (Status == STATUS_PENDING)
 770         {
 771             if ((IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest) ||
 772                 (FCB->DisconnectFlags & TDI_DISCONNECT_ABORT))
 773             {
 774                 /* Go ahead and execute the disconnect because we're ready for it */
 775                 Status = DoDisconnect(FCB);
 776             }
 777
 778             if (Status != STATUS_PENDING)
 779                 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
 780         }
 781
 782         if (Status == STATUS_PENDING)
 783         {
 784             SocketStateUnlock(FCB);
 785
 786             return Status;
 787         }
 788     }
 789     else
 790     {
 791         if (!(Flags & TDI_DISCONNECT_RELEASE))
 792         {
 793             if (!FCB->RemoteAddress)
 794             {
 795                 AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
 796                 return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
 797             }
 798
 799             ExFreePool(FCB->RemoteAddress);
 800
 801             FCB->RemoteAddress = NULL;
 802         }
 803
 804         FCB->PollState &= ~AFD_EVENT_SEND;
 805         FCB->SendClosed = TRUE;
 806     }
 807
 808     return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
 809 }
 810
 811 static NTSTATUS NTAPI
 812 AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
 813 {
 814     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 815     NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
 816 #if DBG
 817     PFILE_OBJECT FileObject = IrpSp->FileObject;
 818 #endif
 819
 820     AFD_DbgPrint(MID_TRACE,("AfdDispatch: %d\n", IrpSp->MajorFunction));
 821     if( IrpSp->MajorFunction != IRP_MJ_CREATE) {
 822         AFD_DbgPrint(MID_TRACE,("FO %x, IrpSp->FO %x\n",
 823                                 FileObject, IrpSp->FileObject));
 824         ASSERT(FileObject == IrpSp->FileObject);
 825     }
 826
 827     Irp->IoStatus.Information = 0;
 828
 829     switch(IrpSp->MajorFunction)
 830     {
 831         /* opening and closing handles to the device */
 832     case IRP_MJ_CREATE:
 833         /* Mostly borrowed from the named pipe file system */
 834         return AfdCreateSocket(DeviceObject, Irp, IrpSp);
 835
 836     case IRP_MJ_CLOSE:
 837         /* Ditto the borrowing */
 838         return AfdCloseSocket(DeviceObject, Irp, IrpSp);
 839
 840     case IRP_MJ_CLEANUP:
 841         return AfdCleanupSocket(DeviceObject, Irp, IrpSp);
 842
 843     /* write data */
 844     case IRP_MJ_WRITE:
 845         return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp, TRUE );
 846
 847     /* read data */
 848     case IRP_MJ_READ:
 849         return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp, TRUE );
 850
 851     case IRP_MJ_DEVICE_CONTROL:
 852     {
 853         switch( IrpSp->Parameters.DeviceIoControl.IoControlCode ) {
 854         case IOCTL_AFD_BIND:
 855             return AfdBindSocket( DeviceObject, Irp, IrpSp );
 856
 857         case IOCTL_AFD_CONNECT:
 858             return AfdStreamSocketConnect( DeviceObject, Irp, IrpSp );
 859
 860         case IOCTL_AFD_START_LISTEN:
 861             return AfdListenSocket( DeviceObject, Irp, IrpSp );
 862
 863         case IOCTL_AFD_RECV:
 864             return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp,
 865                                                FALSE );
 866
 867         case IOCTL_AFD_SELECT:
 868             return AfdSelect( DeviceObject, Irp, IrpSp );
 869
 870         case IOCTL_AFD_EVENT_SELECT:
 871             return AfdEventSelect( DeviceObject, Irp, IrpSp );
 872
 873         case IOCTL_AFD_ENUM_NETWORK_EVENTS:
 874             return AfdEnumEvents( DeviceObject, Irp, IrpSp );
 875
 876         case IOCTL_AFD_RECV_DATAGRAM:
 877             return AfdPacketSocketReadData( DeviceObject, Irp, IrpSp );
 878
 879         case IOCTL_AFD_SEND:
 880             return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp,
 881                                                 FALSE );
 882
 883         case IOCTL_AFD_SEND_DATAGRAM:
 884             return AfdPacketSocketWriteData( DeviceObject, Irp, IrpSp );
 885
 886         case IOCTL_AFD_GET_INFO:
 887             return AfdGetInfo( DeviceObject, Irp, IrpSp );
 888
 889         case IOCTL_AFD_SET_INFO:
 890             return AfdSetInfo( DeviceObject, Irp, IrpSp );
 891
 892         case IOCTL_AFD_GET_CONTEXT_SIZE:
 893             return AfdGetContextSize( DeviceObject, Irp, IrpSp );
 894
 895         case IOCTL_AFD_GET_CONTEXT:
 896             return AfdGetContext( DeviceObject, Irp, IrpSp );
 897
 898         case IOCTL_AFD_SET_CONTEXT:
 899             return AfdSetContext( DeviceObject, Irp, IrpSp );
 900
 901         case IOCTL_AFD_WAIT_FOR_LISTEN:
 902             return AfdWaitForListen( DeviceObject, Irp, IrpSp );
 903
 904         case IOCTL_AFD_ACCEPT:
 905             return AfdAccept( DeviceObject, Irp, IrpSp );
 906
 907         case IOCTL_AFD_DISCONNECT:
 908             return AfdDisconnect( DeviceObject, Irp, IrpSp );
 909
 910         case IOCTL_AFD_GET_SOCK_NAME:
 911             return AfdGetSockName( DeviceObject, Irp, IrpSp );
 912
 913         case IOCTL_AFD_GET_PEER_NAME:
 914             return AfdGetPeerName( DeviceObject, Irp, IrpSp );
 915
 916         case IOCTL_AFD_GET_CONNECT_DATA:
 917             return AfdGetConnectData(DeviceObject, Irp, IrpSp);
 918
 919         case IOCTL_AFD_SET_CONNECT_DATA:
 920             return AfdSetConnectData(DeviceObject, Irp, IrpSp);
 921
 922         case IOCTL_AFD_SET_DISCONNECT_DATA:
 923             return AfdSetDisconnectData(DeviceObject, Irp, IrpSp);
 924
 925         case IOCTL_AFD_GET_DISCONNECT_DATA:
 926             return AfdGetDisconnectData(DeviceObject, Irp, IrpSp);
 927
 928         case IOCTL_AFD_SET_CONNECT_DATA_SIZE:
 929             return AfdSetConnectDataSize(DeviceObject, Irp, IrpSp);
 930
 931         case IOCTL_AFD_SET_DISCONNECT_DATA_SIZE:
 932             return AfdSetDisconnectDataSize(DeviceObject, Irp, IrpSp);
 933
 934         case IOCTL_AFD_SET_CONNECT_OPTIONS:
 935             return AfdSetConnectOptions(DeviceObject, Irp, IrpSp);
 936
 937         case IOCTL_AFD_SET_DISCONNECT_OPTIONS:
 938             return AfdSetDisconnectOptions(DeviceObject, Irp, IrpSp);
 939
 940         case IOCTL_AFD_GET_CONNECT_OPTIONS:
 941             return AfdGetConnectOptions(DeviceObject, Irp, IrpSp);
 942
 943         case IOCTL_AFD_GET_DISCONNECT_OPTIONS:
 944             return AfdGetDisconnectOptions(DeviceObject, Irp, IrpSp);
 945
 946         case IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE:
 947             return AfdSetConnectOptionsSize(DeviceObject, Irp, IrpSp);
 948
 949         case IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE:
 950             return AfdSetDisconnectOptionsSize(DeviceObject, Irp, IrpSp);
 951
 952         case IOCTL_AFD_GET_TDI_HANDLES:
 953             return AfdGetTdiHandles(DeviceObject, Irp, IrpSp);
 954
 955         case IOCTL_AFD_DEFER_ACCEPT:
 956             DbgPrint("IOCTL_AFD_DEFER_ACCEPT is UNIMPLEMENTED!\n");
 957             break;
 958
 959         case IOCTL_AFD_GET_PENDING_CONNECT_DATA:
 960             DbgPrint("IOCTL_AFD_GET_PENDING_CONNECT_DATA is UNIMPLEMENTED!\n");
 961             break;
 962
 963         case IOCTL_AFD_VALIDATE_GROUP:
 964             DbgPrint("IOCTL_AFD_VALIDATE_GROUP is UNIMPLEMENTED!\n");
 965             break;
 966
 967         default:
 968             Status = STATUS_NOT_SUPPORTED;
 969             DbgPrint("Unknown IOCTL (0x%x)\n",
 970                      IrpSp->Parameters.DeviceIoControl.IoControlCode);
 971             break;
 972         }
 973         break;
 974     }
 975
 976 /* unsupported operations */
 977     default:
 978     {
 979         Status = STATUS_NOT_IMPLEMENTED;
 980         AFD_DbgPrint(MIN_TRACE,
 981                      ("Irp: Unknown Major code was %x\n",
 982                       IrpSp->MajorFunction));
 983         break;
 984     }
 985     }
 986
 987     AFD_DbgPrint(MID_TRACE, ("Returning %x\n", Status));
 988     Irp->IoStatus.Status = Status;
 989     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 990
 991     return Status;
 992 }
 993
 994 BOOLEAN CheckUnlockExtraBuffers(PAFD_FCB FCB, PIO_STACK_LOCATION IrpSp)
 995 {
 996     if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
 997     {
 998         if (IrpSp->MajorFunction == IRP_MJ_READ || IrpSp->MajorFunction == IRP_MJ_WRITE)
 999         {
1000             /* read()/write() call - no extra buffers */
1001             return FALSE;
1002         }
1003         else if (IrpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL)
1004         {
1005             if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV_DATAGRAM)
1006             {
1007                 /* recvfrom() call - extra buffers */
1008                 return TRUE;
1009             }
1010             else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV)
1011             {
1012                 /* recv() call - no extra buffers */
1013                 return FALSE;
1014             }
1015             else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND ||
1016                      IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND_DATAGRAM)
1017             {
1018                 /* send()/sendto() call - no extra buffers */
1019                 return FALSE;
1020             }
1021             else
1022             {
1023                 /* Unknown IOCTL */
1024                 ASSERT(FALSE);
1025                 return FALSE;
1026             }
1027         }
1028         else
1029         {
1030             /* Unknown IRP_MJ code */
1031             ASSERT(FALSE);
1032             return FALSE;
1033         }
1034     }
1035     else
1036     {
1037         /* Connection-oriented never has extra buffers */
1038         return FALSE;
1039     }
1040 }
1041
1042 VOID
1043 CleanupPendingIrp(PAFD_FCB FCB, PIRP Irp, PIO_STACK_LOCATION IrpSp, PAFD_ACTIVE_POLL Poll)
1044 {
1045     PAFD_RECV_INFO RecvReq;
1046     PAFD_SEND_INFO SendReq;
1047     PAFD_POLL_INFO PollReq;
1048
1049     if (IrpSp->MajorFunction == IRP_MJ_READ)
1050     {
1051         RecvReq = GetLockedData(Irp, IrpSp);
1052         UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
1053     }
1054     else if (IrpSp->MajorFunction == IRP_MJ_WRITE)
1055     {
1056         SendReq = GetLockedData(Irp, IrpSp);
1057         UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
1058     }
1059     else
1060     {
1061         ASSERT(IrpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL);
1062
1063         if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV)
1064         {
1065             RecvReq = GetLockedData(Irp, IrpSp);
1066             UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
1067         }
1068         else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND)
1069         {
1070             SendReq = GetLockedData(Irp, IrpSp);
1071             UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
1072         }
1073         else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SELECT)
1074         {
1075             ASSERT(Poll);
1076
1077             PollReq = Irp->AssociatedIrp.SystemBuffer;
1078             ZeroEvents(PollReq->Handles, PollReq->HandleCount);
1079             SignalSocket(Poll, NULL, PollReq, STATUS_CANCELLED);
1080         }
1081     }
1082 }
1083
1084 VOID NTAPI
1085 AfdCancelHandler(PDEVICE_OBJECT DeviceObject,
1086                  PIRP Irp)
1087 {
1088     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
1089     PFILE_OBJECT FileObject = IrpSp->FileObject;
1090     PAFD_FCB FCB = FileObject->FsContext;
1091     ULONG Function, IoctlCode;
1092     PIRP CurrentIrp;
1093     PLIST_ENTRY CurrentEntry;
1094     PAFD_DEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
1095     KIRQL OldIrql;
1096     PAFD_ACTIVE_POLL Poll;
1097
1098     IoReleaseCancelSpinLock(Irp->CancelIrql);
1099
1100     if (!SocketAcquireStateLock(FCB))
1101         return;
1102
1103     switch (IrpSp->MajorFunction)
1104     {
1105         case IRP_MJ_DEVICE_CONTROL:
1106             IoctlCode = IrpSp->Parameters.DeviceIoControl.IoControlCode;
1107             break;
1108
1109         case IRP_MJ_READ:
1110             IoctlCode = IOCTL_AFD_RECV;
1111             break;
1112
1113         case IRP_MJ_WRITE:
1114             IoctlCode = IOCTL_AFD_SEND;
1115             break;
1116
1117         default:
1118             ASSERT(FALSE);
1119             SocketStateUnlock(FCB);
1120             return;
1121     }
1122
1123     switch (IoctlCode)
1124     {
1125         case IOCTL_AFD_RECV:
1126         case IOCTL_AFD_RECV_DATAGRAM:
1127             Function = FUNCTION_RECV;
1128             break;
1129
1130         case IOCTL_AFD_SEND:
1131         case IOCTL_AFD_SEND_DATAGRAM:
1132             Function = FUNCTION_SEND;
1133             break;
1134
1135         case IOCTL_AFD_CONNECT:
1136             Function = FUNCTION_CONNECT;
1137             break;
1138
1139         case IOCTL_AFD_WAIT_FOR_LISTEN:
1140             Function = FUNCTION_PREACCEPT;
1141             break;
1142
1143         case IOCTL_AFD_SELECT:
1144             KeAcquireSpinLock(&DeviceExt->Lock, &OldIrql);
1145
1146             CurrentEntry = DeviceExt->Polls.Flink;
1147             while (CurrentEntry != &DeviceExt->Polls)
1148             {
1149                 Poll = CONTAINING_RECORD(CurrentEntry, AFD_ACTIVE_POLL, ListEntry);
1150
1151                 if (Irp == Poll->Irp)
1152                 {
1153                     CleanupPendingIrp(FCB, Irp, IrpSp, Poll);
1154                     KeReleaseSpinLock(&DeviceExt->Lock, OldIrql);
1155                     SocketStateUnlock(FCB);
1156                     return;
1157                 }
1158                 else
1159                 {
1160                     CurrentEntry = CurrentEntry->Flink;
1161                 }
1162             }
1163
1164             KeReleaseSpinLock(&DeviceExt->Lock, OldIrql);
1165
1166             SocketStateUnlock(FCB);
1167
1168             DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (IOCTL_AFD_SELECT)\n");
1169             return;
1170
1171         case IOCTL_AFD_DISCONNECT:
1172             Function = FUNCTION_DISCONNECT;
1173             break;
1174
1175         default:
1176             ASSERT(FALSE);
1177             UnlockAndMaybeComplete(FCB, STATUS_CANCELLED, Irp, 0);
1178             return;
1179     }
1180
1181     CurrentEntry = FCB->PendingIrpList[Function].Flink;
1182     while (CurrentEntry != &FCB->PendingIrpList[Function])
1183     {
1184         CurrentIrp = CONTAINING_RECORD(CurrentEntry, IRP, Tail.Overlay.ListEntry);
1185
1186         if (CurrentIrp == Irp)
1187         {
1188             RemoveEntryList(CurrentEntry);
1189             CleanupPendingIrp(FCB, Irp, IrpSp, NULL);
1190             UnlockAndMaybeComplete(FCB, STATUS_CANCELLED, Irp, 0);
1191             return;
1192         }
1193         else
1194         {
1195             CurrentEntry = CurrentEntry->Flink;
1196         }
1197     }
1198
1199     SocketStateUnlock(FCB);
1200
1201     DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (Function: %d)\n", Function);
1202 }
1203
1204 static VOID NTAPI
1205 AfdUnload(PDRIVER_OBJECT DriverObject)
1206 {
1207 }
1208
1209 NTSTATUS NTAPI
1210 DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
1211 {
1212     PDEVICE_OBJECT DeviceObject;
1213     UNICODE_STRING wstrDeviceName = RTL_CONSTANT_STRING(L"\\Device\\Afd");
1214     PAFD_DEVICE_EXTENSION DeviceExt;
1215     NTSTATUS Status;
1216
1217     /* register driver routines */
1218     DriverObject->MajorFunction[IRP_MJ_CLOSE] = AfdDispatch;
1219     DriverObject->MajorFunction[IRP_MJ_CREATE] = AfdDispatch;
1220     DriverObject->MajorFunction[IRP_MJ_CLEANUP] = AfdDispatch;
1221     DriverObject->MajorFunction[IRP_MJ_WRITE] = AfdDispatch;
1222     DriverObject->MajorFunction[IRP_MJ_READ] = AfdDispatch;
1223     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AfdDispatch;
1224     DriverObject->DriverUnload = AfdUnload;
1225
1226     Status = IoCreateDevice(DriverObject,
1227                             sizeof(AFD_DEVICE_EXTENSION),
1228                             &wstrDeviceName,
1229                             FILE_DEVICE_NAMED_PIPE,
1230                             0,
1231                             FALSE,
1232                             &DeviceObject);
1233
1234     /* failure */
1235     if (!NT_SUCCESS(Status))
1236     {
1237         return Status;
1238     }
1239
1240     DeviceExt = DeviceObject->DeviceExtension;
1241     KeInitializeSpinLock( &DeviceExt->Lock );
1242     InitializeListHead( &DeviceExt->Polls );
1243
1244     AFD_DbgPrint(MID_TRACE,("Device created: object %x ext %x\n",
1245                             DeviceObject, DeviceExt));
1246
1247     return Status;
1248 }
1249
1250 /* EOF */