reactos/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 #include "tdi_proto.h"
  17 #include "tdiconn.h"
  18 #include "debug.h"
  19
  20 #ifdef DBG
  21
  22 /* See debug.h for debug/trace constants */
  23 //DWORD DebugTraceLevel = DEBUG_ULTRA;
  24 DWORD DebugTraceLevel = 0;
  25
  26 #endif /* DBG */
  27
  28 void OskitDumpBuffer( PCHAR Data, UINT Len ) {
  29     unsigned int i;
  30
  31     for( i = 0; i < Len; i++ ) {
  32         if( i && !(i & 0xf) ) DbgPrint( "\n" );
  33         if( !(i & 0xf) ) DbgPrint( "%08x: ", (UINT)(Data + i) );
  34         DbgPrint( " %02x", Data[i] & 0xff );
  35     }
  36     DbgPrint("\n");
  37 }
  38
  39 /* FUNCTIONS */
  40
  41 NTSTATUS NTAPI
  42 DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
  43
  44 static NTSTATUS NTAPI
  45 AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
  46                 PIO_STACK_LOCATION IrpSp) {
  47     PAFD_FCB FCB;
  48     PFILE_OBJECT FileObject;
  49     PAFD_DEVICE_EXTENSION DeviceExt;
  50     PFILE_FULL_EA_INFORMATION EaInfo;
  51     PAFD_CREATE_PACKET ConnectInfo = NULL;
  52     ULONG EaLength;
  53     PWCHAR EaInfoValue = NULL;
  54     UINT Disposition, i;
  55     NTSTATUS Status = STATUS_SUCCESS;
  56
  57     AFD_DbgPrint(MID_TRACE,
  58                  ("AfdCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp));
  59
  60     DeviceExt = DeviceObject->DeviceExtension;
  61     FileObject = IrpSp->FileObject;
  62     Disposition = (IrpSp->Parameters.Create.Options >> 24) & 0xff;
  63
  64     Irp->IoStatus.Information = 0;
  65
  66     EaInfo = Irp->AssociatedIrp.SystemBuffer;
  67
  68     if( EaInfo ) {
  69         ConnectInfo = (PAFD_CREATE_PACKET)(EaInfo->EaName + EaInfo->EaNameLength + 1);
  70         EaInfoValue = (PWCHAR)(((PCHAR)ConnectInfo) + sizeof(AFD_CREATE_PACKET));
  71
  72         EaLength = sizeof(FILE_FULL_EA_INFORMATION) +
  73             EaInfo->EaNameLength +
  74             EaInfo->EaValueLength;
  75
  76         AFD_DbgPrint(MID_TRACE,("EaInfo: %x, EaInfoValue: %x\n",
  77                                 EaInfo, EaInfoValue));
  78     }
  79
  80     AFD_DbgPrint(MID_TRACE,("About to allocate the new FCB\n"));
  81
  82     FCB = ExAllocatePool(NonPagedPool, sizeof(AFD_FCB));
  83     if( FCB == NULL ) {
  84         Irp->IoStatus.Status = STATUS_NO_MEMORY;
  85         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  86         return STATUS_NO_MEMORY;
  87     }
  88
  89     AFD_DbgPrint(MID_TRACE,("Initializing the new FCB @ %x (FileObject %x Flags %x)\n", FCB, FileObject, ConnectInfo ? ConnectInfo->EndpointFlags : 0));
  90
  91     RtlZeroMemory( FCB, sizeof( *FCB ) );
  92
  93     FCB->Flags = ConnectInfo ? ConnectInfo->EndpointFlags : 0;
  94     FCB->State = SOCKET_STATE_CREATED;
  95     FCB->FileObject = FileObject;
  96     FCB->DeviceExt = DeviceExt;
  97     FCB->Recv.Size = DEFAULT_RECEIVE_WINDOW_SIZE;
  98     FCB->Send.Size = DEFAULT_SEND_WINDOW_SIZE;
  99
 100     KeInitializeSpinLock( &FCB->SpinLock );
 101     ExInitializeFastMutex( &FCB->Mutex );
 102     KeInitializeEvent( &FCB->StateLockedEvent, NotificationEvent, FALSE );
 103
 104     for( i = 0; i < MAX_FUNCTIONS; i++ ) {
 105         InitializeListHead( &FCB->PendingIrpList[i] );
 106     }
 107
 108     InitializeListHead( &FCB->DatagramList );
 109     InitializeListHead( &FCB->PendingConnections );
 110
 111     AFD_DbgPrint(MID_TRACE,("%x: Checking command channel\n", FCB));
 112
 113     if( ConnectInfo ) {
 114         FCB->TdiDeviceName.Length = ConnectInfo->SizeOfTransportName;
 115         FCB->TdiDeviceName.MaximumLength = FCB->TdiDeviceName.Length;
 116         FCB->TdiDeviceName.Buffer =
 117             ExAllocatePool( NonPagedPool, FCB->TdiDeviceName.Length );
 118
 119         if( !FCB->TdiDeviceName.Buffer ) {
 120             ExFreePool(FCB);
 121             AFD_DbgPrint(MID_TRACE,("Could not copy target string\n"));
 122             Irp->IoStatus.Status = STATUS_NO_MEMORY;
 123             IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
 124             return STATUS_NO_MEMORY;
 125         }
 126
 127         RtlCopyMemory( FCB->TdiDeviceName.Buffer,
 128                        ConnectInfo->TransportName,
 129                        FCB->TdiDeviceName.Length );
 130
 131         AFD_DbgPrint(MID_TRACE,("Success: %s %wZ\n",
 132                                 EaInfo->EaName, &FCB->TdiDeviceName));
 133     } else {
 134         AFD_DbgPrint(MID_TRACE,("Success: Control connection\n"));
 135     }
 136
 137     FileObject->FsContext = FCB;
 138
 139     /* It seems that UDP sockets are writable from inception */
 140     if( FCB->Flags & SGID_CONNECTIONLESS ) {
 141         AFD_DbgPrint(MID_TRACE,("Packet oriented socket\n"));
 142         /* Allocate our backup buffer */
 143         FCB->Recv.Window = ExAllocatePool( NonPagedPool, FCB->Recv.Size );
 144         if( !FCB->Recv.Window ) Status = STATUS_NO_MEMORY;
 145         FCB->Send.Window = ExAllocatePool( NonPagedPool, FCB->Send.Size );
 146         if( !FCB->Send.Window ) {
 147             if( FCB->Recv.Window ) ExFreePool( FCB->Recv.Window );
 148             Status = STATUS_NO_MEMORY;
 149         }
 150         /* A datagram socket is always sendable */
 151         FCB->PollState |= AFD_EVENT_SEND;
 152         PollReeval( FCB->DeviceExt, FCB->FileObject );
 153     }
 154
 155     if( !NT_SUCCESS(Status) ) {
 156         if( FCB->TdiDeviceName.Buffer ) ExFreePool( FCB->TdiDeviceName.Buffer );
 157         ExFreePool( FCB );
 158         FileObject->FsContext = NULL;
 159     }
 160
 161     Irp->IoStatus.Status = Status;
 162     IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
 163
 164     return Status;
 165 }
 166
 167 VOID DestroySocket( PAFD_FCB FCB ) {
 168     UINT i;
 169     BOOLEAN ReturnEarly = FALSE;
 170     PAFD_IN_FLIGHT_REQUEST InFlightRequest[IN_FLIGHT_REQUESTS];
 171
 172     AFD_DbgPrint(MIN_TRACE,("Called (%x)\n", FCB));
 173
 174     if( !SocketAcquireStateLock( FCB ) ) return;
 175
 176     FCB->State = SOCKET_STATE_CLOSED;
 177
 178     InFlightRequest[0] = &FCB->ListenIrp;
 179     InFlightRequest[1] = &FCB->ReceiveIrp;
 180     InFlightRequest[2] = &FCB->SendIrp;
 181     InFlightRequest[3] = &FCB->ConnectIrp;
 182
 183     /* Return early here because we might be called in the mean time. */
 184     if( FCB->Critical ||
 185         FCB->ListenIrp.InFlightRequest ||
 186         FCB->ReceiveIrp.InFlightRequest ||
 187         FCB->SendIrp.InFlightRequest ||
 188         FCB->ConnectIrp.InFlightRequest ) {
 189         AFD_DbgPrint(MIN_TRACE,("Leaving socket alive (%x %x %x %x)\n",
 190                                 FCB->ListenIrp.InFlightRequest,
 191                                 FCB->ReceiveIrp.InFlightRequest,
 192                                 FCB->SendIrp.InFlightRequest,
 193                                 FCB->ConnectIrp.InFlightRequest));
 194         ReturnEarly = TRUE;
 195     }
 196
 197     /* After PoolReeval, this FCB should not be involved in any outstanding
 198      * poll requests */
 199
 200     /* Cancel our pending requests */
 201     for( i = 0; i < IN_FLIGHT_REQUESTS; i++ ) {
 202         if( InFlightRequest[i]->InFlightRequest ) {
 203             AFD_DbgPrint(MID_TRACE,("Cancelling in flight irp %d (%x)\n",
 204                                     i, InFlightRequest[i]->InFlightRequest));
 205             IoCancelIrp(InFlightRequest[i]->InFlightRequest);
 206             InFlightRequest[i]->InFlightRequest = NULL;
 207         }
 208     }
 209
 210     SocketStateUnlock( FCB );
 211
 212     if( ReturnEarly ) return;
 213
 214     if( FCB->Recv.Window )
 215         ExFreePool( FCB->Recv.Window );
 216     if( FCB->Send.Window )
 217         ExFreePool( FCB->Send.Window );
 218     if( FCB->AddressFrom )
 219         ExFreePool( FCB->AddressFrom );
 220     if( FCB->LocalAddress )
 221         ExFreePool( FCB->LocalAddress );
 222     if( FCB->RemoteAddress )
 223         ExFreePool( FCB->RemoteAddress );
 224     if( FCB->TdiDeviceName.Buffer )
 225         ExFreePool(FCB->TdiDeviceName.Buffer);
 226
 227     /* HACK HACK HACK */
 228     TdiCloseDevice( FCB->Connection.Handle,
 229                     FCB->Connection.Object );
 230     TdiCloseDevice( FCB->AddressFile.Handle,
 231                     FCB->AddressFile.Object );
 232
 233     ExFreePool(FCB);
 234     AFD_DbgPrint(MIN_TRACE,("Deleted (%x)\n", FCB));
 235
 236     AFD_DbgPrint(MIN_TRACE,("Leaving\n"));
 237 }
 238
 239 static NTSTATUS NTAPI
 240 AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 241                PIO_STACK_LOCATION IrpSp)
 242 {
 243     PFILE_OBJECT FileObject = IrpSp->FileObject;
 244     PAFD_FCB FCB = FileObject->FsContext;
 245
 246     AFD_DbgPrint(MID_TRACE,
 247                  ("AfdClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp));
 248
 249     AFD_DbgPrint(MID_TRACE,("FCB %x\n", FCB));
 250
 251     FCB->PollState |= AFD_EVENT_CLOSE;
 252     PollReeval( FCB->DeviceExt, FileObject );
 253     KillSelectsForFCB( FCB->DeviceExt, FileObject, FALSE );
 254
 255     if( FCB->EventSelect ) ObDereferenceObject( FCB->EventSelect );
 256
 257     FileObject->FsContext = NULL;
 258     DestroySocket( FCB );
 259
 260     Irp->IoStatus.Status = STATUS_SUCCESS;
 261     Irp->IoStatus.Information = 0;
 262     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 263
 264     AFD_DbgPrint(MID_TRACE, ("Returning success.\n"));
 265
 266     return STATUS_SUCCESS;
 267 }
 268
 269 static NTSTATUS NTAPI
 270 AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
 271               PIO_STACK_LOCATION IrpSp) {
 272     PFILE_OBJECT FileObject = IrpSp->FileObject;
 273     PAFD_FCB FCB = FileObject->FsContext;
 274     PAFD_DISCONNECT_INFO DisReq;
 275     IO_STATUS_BLOCK Iosb;
 276     PTDI_CONNECTION_INFORMATION ConnInfo;
 277     NTSTATUS Status;
 278     USHORT Flags = 0;
 279
 280     if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
 281
 282     if( !(DisReq = LockRequest( Irp, IrpSp )) )
 283         return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
 284                                        Irp, 0, NULL );
 285
 286     if (NULL == FCB->RemoteAddress)
 287       {
 288         ConnInfo = NULL;
 289       }
 290     else
 291       {
 292         Status = TdiBuildNullConnectionInfo
 293             ( &ConnInfo, FCB->RemoteAddress->Address[0].AddressType );
 294
 295         if( !NT_SUCCESS(Status) || !ConnInfo )
 296             return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
 297                                            Irp, 0, NULL );
 298       }
 299
 300     if( DisReq->DisconnectType & AFD_DISCONNECT_SEND )
 301         Flags |= TDI_DISCONNECT_RELEASE;
 302     if( DisReq->DisconnectType & AFD_DISCONNECT_RECV ||
 303         DisReq->DisconnectType & AFD_DISCONNECT_ABORT )
 304         Flags |= TDI_DISCONNECT_ABORT;
 305
 306     Status = TdiDisconnect( FCB->Connection.Object,
 307                             &DisReq->Timeout,
 308                             Flags,
 309                             &Iosb,
 310                             NULL,
 311                             NULL,
 312                             FCB->AddressFrom,
 313                             ConnInfo);
 314
 315     if (ConnInfo) ExFreePool( ConnInfo );
 316
 317     return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
 318 }
 319
 320 static NTSTATUS NTAPI
 321 AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
 322 {
 323     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 324     NTSTATUS Status = STATUS_SUCCESS;
 325 #ifdef DBG
 326     PFILE_OBJECT FileObject = IrpSp->FileObject;
 327 #endif
 328
 329     AFD_DbgPrint(MID_TRACE,("AfdDispatch: %d\n", IrpSp->MajorFunction));
 330     if( IrpSp->MajorFunction != IRP_MJ_CREATE) {
 331         AFD_DbgPrint(MID_TRACE,("FO %x, IrpSp->FO %x\n",
 332                                 FileObject, IrpSp->FileObject));
 333         ASSERT(FileObject == IrpSp->FileObject);
 334     }
 335
 336     Irp->IoStatus.Information = 0;
 337
 338     switch(IrpSp->MajorFunction)
 339     {
 340         /* opening and closing handles to the device */
 341     case IRP_MJ_CREATE:
 342         /* Mostly borrowed from the named pipe file system */
 343         return AfdCreateSocket(DeviceObject, Irp, IrpSp);
 344
 345     case IRP_MJ_CLOSE:
 346         /* Ditto the borrowing */
 347         return AfdCloseSocket(DeviceObject, Irp, IrpSp);
 348
 349     /* write data */
 350     case IRP_MJ_WRITE:
 351         return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp, TRUE );
 352
 353     /* read data */
 354     case IRP_MJ_READ:
 355         return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp, TRUE );
 356
 357     case IRP_MJ_DEVICE_CONTROL:
 358     {
 359         switch( IrpSp->Parameters.DeviceIoControl.IoControlCode ) {
 360         case IOCTL_AFD_BIND:
 361             return AfdBindSocket( DeviceObject, Irp, IrpSp );
 362
 363         case IOCTL_AFD_CONNECT:
 364             return AfdStreamSocketConnect( DeviceObject, Irp, IrpSp );
 365
 366         case IOCTL_AFD_START_LISTEN:
 367             return AfdListenSocket( DeviceObject, Irp, IrpSp );
 368
 369         case IOCTL_AFD_RECV:
 370             return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp,
 371                                                FALSE );
 372
 373         case IOCTL_AFD_SELECT:
 374             return AfdSelect( DeviceObject, Irp, IrpSp );
 375
 376         case IOCTL_AFD_EVENT_SELECT:
 377             return AfdEventSelect( DeviceObject, Irp, IrpSp );
 378
 379         case IOCTL_AFD_ENUM_NETWORK_EVENTS:
 380             return AfdEnumEvents( DeviceObject, Irp, IrpSp );
 381
 382         case IOCTL_AFD_RECV_DATAGRAM:
 383             return AfdPacketSocketReadData( DeviceObject, Irp, IrpSp );
 384
 385         case IOCTL_AFD_SEND:
 386             return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp,
 387                                                 FALSE );
 388
 389         case IOCTL_AFD_SEND_DATAGRAM:
 390             return AfdPacketSocketWriteData( DeviceObject, Irp, IrpSp );
 391
 392         case IOCTL_AFD_GET_INFO:
 393             return AfdGetInfo( DeviceObject, Irp, IrpSp );
 394
 395         case IOCTL_AFD_GET_CONTEXT:
 396             return AfdGetContext( DeviceObject, Irp, IrpSp );
 397
 398         case IOCTL_AFD_SET_CONTEXT:
 399             return AfdSetContext( DeviceObject, Irp, IrpSp );
 400
 401         case IOCTL_AFD_WAIT_FOR_LISTEN:
 402             return AfdWaitForListen( DeviceObject, Irp, IrpSp );
 403
 404         case IOCTL_AFD_ACCEPT:
 405             return AfdAccept( DeviceObject, Irp, IrpSp );
 406
 407         case IOCTL_AFD_DISCONNECT:
 408             return AfdDisconnect( DeviceObject, Irp, IrpSp );
 409
 410         case IOCTL_AFD_GET_SOCK_NAME:
 411             return AfdGetSockOrPeerName( DeviceObject, Irp, IrpSp, TRUE );
 412
 413         case IOCTL_AFD_GET_PEER_NAME:
 414             return AfdGetSockOrPeerName( DeviceObject, Irp, IrpSp, FALSE );
 415
 416         case IOCTL_AFD_GET_TDI_HANDLES:
 417             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_TDI_HANDLES\n"));
 418             break;
 419
 420         case IOCTL_AFD_SET_INFO:
 421             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_INFO\n"));
 422             break;
 423
 424         case IOCTL_AFD_SET_CONNECT_DATA:
 425             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_DATA\n"));
 426             break;
 427
 428         case IOCTL_AFD_SET_CONNECT_OPTIONS:
 429             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_OPTIONS\n"));
 430             break;
 431
 432         case IOCTL_AFD_SET_DISCONNECT_DATA:
 433             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_DATA\n"));
 434             break;
 435
 436         case IOCTL_AFD_SET_DISCONNECT_OPTIONS:
 437             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_OPTIONS\n"));
 438             break;
 439
 440         case IOCTL_AFD_GET_CONNECT_DATA:
 441             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_CONNECT_DATA\n"));
 442             break;
 443
 444         case IOCTL_AFD_GET_CONNECT_OPTIONS:
 445             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_CONNECT_OPTIONS\n"));
 446             break;
 447
 448         case IOCTL_AFD_GET_DISCONNECT_DATA:
 449             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_DISCONNECT_DATA\n"));
 450             break;
 451
 452         case IOCTL_AFD_GET_DISCONNECT_OPTIONS:
 453             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_DISCONNECT_OPTIONS\n"));
 454             break;
 455
 456         case IOCTL_AFD_SET_CONNECT_DATA_SIZE:
 457             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_DATA_SIZE\n"));
 458             break;
 459
 460         case IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE:
 461             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE\n"));
 462             break;
 463
 464         case IOCTL_AFD_SET_DISCONNECT_DATA_SIZE:
 465             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_DATA_SIZE\n"));
 466             break;
 467
 468         case IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE:
 469             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE\n"));
 470             break;
 471
 472         case IOCTL_AFD_DEFER_ACCEPT:
 473             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_DEFER_ACCEPT\n"));
 474             break;
 475
 476         case IOCTL_AFD_GET_PENDING_CONNECT_DATA:
 477             AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_PENDING_CONNECT_DATA\n"));
 478             break;
 479
 480         default:
 481             Status = STATUS_NOT_IMPLEMENTED;
 482             AFD_DbgPrint(MIN_TRACE, ("Unknown IOCTL (0x%x)\n",
 483                                      IrpSp->Parameters.DeviceIoControl.
 484                                      IoControlCode));
 485             break;
 486         }
 487         break;
 488     }
 489
 490 /* unsupported operations */
 491     default:
 492     {
 493         Status = STATUS_NOT_IMPLEMENTED;
 494         AFD_DbgPrint(MIN_TRACE,
 495                      ("Irp: Unknown Major code was %x\n",
 496                       IrpSp->MajorFunction));
 497         break;
 498     }
 499     }
 500
 501     AFD_DbgPrint(MID_TRACE, ("Returning %x\n", Status));
 502     Irp->IoStatus.Status = Status;
 503     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 504
 505     return (Status);
 506 }
 507
 508 static VOID NTAPI
 509 AfdUnload(PDRIVER_OBJECT DriverObject)
 510 {
 511 }
 512
 513 NTSTATUS NTAPI
 514 DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
 515 {
 516     PDEVICE_OBJECT DeviceObject;
 517     UNICODE_STRING wstrDeviceName = RTL_CONSTANT_STRING(L"\\Device\\Afd");
 518     PAFD_DEVICE_EXTENSION DeviceExt;
 519     NTSTATUS Status;
 520
 521     /* register driver routines */
 522     DriverObject->MajorFunction[IRP_MJ_CLOSE] = AfdDispatch;
 523     DriverObject->MajorFunction[IRP_MJ_CREATE] = AfdDispatch;
 524     DriverObject->MajorFunction[IRP_MJ_WRITE] = AfdDispatch;
 525     DriverObject->MajorFunction[IRP_MJ_READ] = AfdDispatch;
 526     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AfdDispatch;
 527     DriverObject->DriverUnload = AfdUnload;
 528
 529     Status = IoCreateDevice
 530         ( DriverObject,
 531           sizeof(AFD_DEVICE_EXTENSION),
 532           &wstrDeviceName,
 533           FILE_DEVICE_NAMED_PIPE,
 534           0,
 535           FALSE,
 536           &DeviceObject );
 537
 538     /* failure */
 539     if(!NT_SUCCESS(Status))
 540     {
 541         return (Status);
 542     }
 543
 544     DeviceExt = DeviceObject->DeviceExtension;
 545     KeInitializeSpinLock( &DeviceExt->Lock );
 546     InitializeListHead( &DeviceExt->Polls );
 547
 548     AFD_DbgPrint(MID_TRACE,("Device created: object %x ext %x\n",
 549                             DeviceObject, DeviceExt));
 550
 551     return (Status);
 552 }
 553
 554 /* EOF */