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