reactos/drivers/network/afd/afd/select.c

   1 /* $Id$
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             drivers/net/afd/afd/select.c
   5  * PURPOSE:          Ancillary functions driver
   6  * PROGRAMMER:       Art Yerkes (ayerkes@speakeasy.net)
   7  * UPDATE HISTORY:
   8  * 20040708 Created
   9  */
  10 #include "afd.h"
  11 #include "tdi_proto.h"
  12 #include "tdiconn.h"
  13 #include "debug.h"
  14
  15 static VOID PrintEvents( ULONG Events ) {
  16 #if DBG
  17     char *events_list[] = { "AFD_EVENT_RECEIVE",
  18                             "AFD_EVENT_OOB_RECEIVE",
  19                             "AFD_EVENT_SEND",
  20                             "AFD_EVENT_DISCONNECT",
  21                             "AFD_EVENT_ABORT",
  22                             "AFD_EVENT_CLOSE",
  23                             "AFD_EVENT_CONNECT",
  24                             "AFD_EVENT_ACCEPT",
  25                             "AFD_EVENT_CONNECT_FAIL",
  26                             "AFD_EVENT_QOS",
  27                             "AFD_EVENT_GROUP_QOS",
  28                             NULL };
  29     int i;
  30
  31     for( i = 0; events_list[i]; i++ )
  32         if( Events & (1 << i) ) AFD_DbgPrint(MID_TRACE,("%s ", events_list[i] ));
  33 #endif
  34 }
  35
  36 static VOID CopyBackStatus( PAFD_HANDLE HandleArray,
  37                      UINT HandleCount ) {
  38     UINT i;
  39
  40     for( i = 0; i < HandleCount; i++ ) {
  41         HandleArray[i].Events = HandleArray[i].Status;
  42         HandleArray[i].Status = 0;
  43     }
  44 }
  45
  46 static VOID ZeroEvents( PAFD_HANDLE HandleArray,
  47                  UINT HandleCount ) {
  48     UINT i;
  49
  50     for( i = 0; i < HandleCount; i++ )
  51         HandleArray[i].Status = 0;
  52 }
  53
  54
  55 /* you must pass either Poll OR Irp */
  56 static VOID SignalSocket(
  57    PAFD_ACTIVE_POLL Poll OPTIONAL,
  58    PIRP _Irp OPTIONAL,
  59    PAFD_POLL_INFO PollReq,
  60         NTSTATUS Status
  61    )
  62 {
  63     UINT i;
  64     PIRP Irp = _Irp ? _Irp : Poll->Irp;
  65     AFD_DbgPrint(MID_TRACE,("Called (Status %x)\n", Status));
  66
  67     if (Poll)
  68     {
  69        KeCancelTimer( &Poll->Timer );
  70       RemoveEntryList( &Poll->ListEntry );
  71       ExFreePool( Poll );
  72    }
  73
  74     Irp->IoStatus.Status = Status;
  75     Irp->IoStatus.Information =
  76         FIELD_OFFSET(AFD_POLL_INFO, Handles) + sizeof(AFD_HANDLE) * PollReq->HandleCount;
  77     CopyBackStatus( PollReq->Handles,
  78                     PollReq->HandleCount );
  79     for( i = 0; i < PollReq->HandleCount; i++ ) {
  80         AFD_DbgPrint
  81             (MAX_TRACE,
  82              ("Handle(%x): Got %x,%x\n",
  83               PollReq->Handles[i].Handle,
  84               PollReq->Handles[i].Events,
  85               PollReq->Handles[i].Status));
  86     }
  87     UnlockHandles( AFD_HANDLES(PollReq), PollReq->HandleCount );
  88     if( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
  89     AFD_DbgPrint(MID_TRACE,("Completing\n"));
  90     IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
  91     AFD_DbgPrint(MID_TRACE,("Done\n"));
  92 }
  93
  94 static VOID SelectTimeout( PKDPC Dpc,
  95                     PVOID DeferredContext,
  96                     PVOID SystemArgument1,
  97                     PVOID SystemArgument2 ) {
  98     PAFD_ACTIVE_POLL Poll = DeferredContext;
  99     PAFD_POLL_INFO PollReq;
 100     PIRP Irp;
 101     KIRQL OldIrql;
 102     PAFD_DEVICE_EXTENSION DeviceExt;
 103
 104     AFD_DbgPrint(MID_TRACE,("Called\n"));
 105
 106     Irp = Poll->Irp;
 107     DeviceExt = Poll->DeviceExt;
 108     PollReq = Irp->AssociatedIrp.SystemBuffer;
 109
 110     ZeroEvents( PollReq->Handles, PollReq->HandleCount );
 111
 112     KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
 113     SignalSocket( Poll, NULL, PollReq, STATUS_TIMEOUT );
 114     KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
 115
 116     AFD_DbgPrint(MID_TRACE,("Timeout\n"));
 117 }
 118
 119 VOID KillSelectsForFCB( PAFD_DEVICE_EXTENSION DeviceExt,
 120                         PFILE_OBJECT FileObject,
 121                         BOOLEAN OnlyExclusive ) {
 122     KIRQL OldIrql;
 123     PLIST_ENTRY ListEntry;
 124     PAFD_ACTIVE_POLL Poll;
 125     PIRP Irp;
 126     PAFD_POLL_INFO PollReq;
 127     PAFD_HANDLE HandleArray;
 128     UINT i;
 129
 130     AFD_DbgPrint(MID_TRACE,("Killing selects that refer to %x\n", FileObject));
 131
 132     KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
 133
 134     ListEntry = DeviceExt->Polls.Flink;
 135     while ( ListEntry != &DeviceExt->Polls ) {
 136         Poll = CONTAINING_RECORD(ListEntry, AFD_ACTIVE_POLL, ListEntry);
 137         ListEntry = ListEntry->Flink;
 138         Irp = Poll->Irp;
 139         PollReq = Irp->AssociatedIrp.SystemBuffer;
 140         HandleArray = AFD_HANDLES(PollReq);
 141
 142         for( i = 0; i < PollReq->HandleCount; i++ ) {
 143             AFD_DbgPrint(MAX_TRACE,("Req: %x, This %x\n",
 144                                     HandleArray[i].Handle, FileObject));
 145             if( (PVOID)HandleArray[i].Handle == FileObject &&
 146                 (!OnlyExclusive || (OnlyExclusive && Poll->Exclusive)) ) {
 147                 ZeroEvents( PollReq->Handles, PollReq->HandleCount );
 148                 SignalSocket( Poll, NULL, PollReq, STATUS_CANCELLED );
 149             }
 150         }
 151     }
 152
 153     KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
 154
 155     AFD_DbgPrint(MID_TRACE,("Done\n"));
 156 }
 157
 158 NTSTATUS NTAPI
 159 AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 160            PIO_STACK_LOCATION IrpSp ) {
 161     NTSTATUS Status = STATUS_NO_MEMORY;
 162     PAFD_FCB FCB;
 163     PFILE_OBJECT FileObject;
 164     PAFD_POLL_INFO PollReq = Irp->AssociatedIrp.SystemBuffer;
 165     PAFD_DEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
 166     UINT CopySize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
 167     UINT AllocSize =
 168         CopySize + sizeof(AFD_ACTIVE_POLL) - sizeof(AFD_POLL_INFO);
 169     KIRQL OldIrql;
 170     UINT i, Signalled = 0;
 171     ULONG Exclusive = PollReq->Exclusive;
 172
 173     AFD_DbgPrint(MID_TRACE,("Called (HandleCount %d Timeout %d)\n",
 174                             PollReq->HandleCount,
 175                             (INT)(PollReq->Timeout.QuadPart)));
 176
 177     SET_AFD_HANDLES(PollReq,
 178                     LockHandles( PollReq->Handles, PollReq->HandleCount ));
 179
 180     if( !AFD_HANDLES(PollReq) ) {
 181         Irp->IoStatus.Status = STATUS_NO_MEMORY;
 182         Irp->IoStatus.Information = 0;
 183         IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
 184         return STATUS_NO_MEMORY;
 185     }
 186
 187     if( Exclusive ) {
 188         for( i = 0; i < PollReq->HandleCount; i++ ) {
 189             if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
 190
 191             KillSelectsForFCB( DeviceExt,
 192                                (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle,
 193                                TRUE );
 194         }
 195     }
 196
 197     ZeroEvents( PollReq->Handles,
 198                 PollReq->HandleCount );
 199
 200         KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
 201
 202         for( i = 0; i < PollReq->HandleCount; i++ ) {
 203             if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
 204
 205             FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
 206             FCB = FileObject->FsContext;
 207
 208             AFD_DbgPrint(MID_TRACE, ("AFD: Select Events: "));
 209             PrintEvents( PollReq->Handles[i].Events );
 210             AFD_DbgPrint(MID_TRACE,("\n"));
 211
 212             PollReq->Handles[i].Status =
 213                     PollReq->Handles[i].Events & FCB->PollState;
 214             if( PollReq->Handles[i].Status ) {
 215                     AFD_DbgPrint(MID_TRACE,("Signalling %x with %x\n",
 216                                             FCB, FCB->PollState));
 217                     Signalled++;
 218             }
 219         }
 220
 221         if( Signalled ) {
 222             Status = STATUS_SUCCESS;
 223             Irp->IoStatus.Status = Status;
 224             SignalSocket( NULL, Irp, PollReq, Status );
 225         } else {
 226
 227        PAFD_ACTIVE_POLL Poll = NULL;
 228
 229        Poll = ExAllocatePool( NonPagedPool, AllocSize );
 230
 231        if (Poll){
 232           Poll->Irp = Irp;
 233           Poll->DeviceExt = DeviceExt;
 234           Poll->Exclusive = Exclusive;
 235
 236           KeInitializeTimerEx( &Poll->Timer, NotificationTimer );
 237
 238           KeInitializeDpc( (PRKDPC)&Poll->TimeoutDpc,
 239              (PKDEFERRED_ROUTINE)SelectTimeout,
 240              Poll );
 241
 242           InsertTailList( &DeviceExt->Polls, &Poll->ListEntry );
 243
 244           KeSetTimer( &Poll->Timer, PollReq->Timeout, &Poll->TimeoutDpc );
 245
 246           Status = STATUS_PENDING;
 247           IoMarkIrpPending( Irp );
 248        } else {
 249           AFD_DbgPrint(MAX_TRACE, ("FIXME: do something with the IRP!\n"));
 250           Status = STATUS_NO_MEMORY;
 251        }
 252         }
 253
 254         KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
 255
 256     AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
 257
 258     return Status;
 259 }
 260
 261 NTSTATUS NTAPI
 262 AfdEventSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 263                 PIO_STACK_LOCATION IrpSp ) {
 264     PFILE_OBJECT FileObject = IrpSp->FileObject;
 265     NTSTATUS Status = STATUS_NO_MEMORY;
 266     PAFD_EVENT_SELECT_INFO EventSelectInfo =
 267         (PAFD_EVENT_SELECT_INFO)LockRequest( Irp, IrpSp );
 268     PAFD_FCB FCB = FileObject->FsContext;
 269
 270     if( !SocketAcquireStateLock( FCB ) ) {
 271         return LostSocket( Irp );
 272     }
 273
 274     if ( !EventSelectInfo ) {
 275          return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
 276                                    0 );
 277     }
 278     AFD_DbgPrint(MID_TRACE,("Called (Event %x Triggers %x)\n",
 279                             EventSelectInfo->EventObject,
 280                             EventSelectInfo->Events));
 281
 282     if( FCB->EventSelect ) ObDereferenceObject( FCB->EventSelect );
 283     FCB->EventSelect = NULL;
 284
 285     if( EventSelectInfo->EventObject && EventSelectInfo->Events ) {
 286         Status = ObReferenceObjectByHandle( (PVOID)EventSelectInfo->
 287                                             EventObject,
 288                                             FILE_ALL_ACCESS,
 289                                             NULL,
 290                                             KernelMode,
 291                                             (PVOID *)&FCB->EventSelect,
 292                                             NULL );
 293
 294         if( !NT_SUCCESS(Status) )
 295             FCB->EventSelect = NULL;
 296         else
 297             FCB->EventSelectTriggers = EventSelectInfo->Events;
 298     } else
 299         Status = STATUS_INVALID_PARAMETER;
 300
 301     AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
 302
 303     return UnlockAndMaybeComplete( FCB, Status, Irp,
 304                                    0 );
 305 }
 306
 307 NTSTATUS NTAPI
 308 AfdEnumEvents( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 309                PIO_STACK_LOCATION IrpSp ) {
 310     PFILE_OBJECT FileObject = IrpSp->FileObject;
 311     PAFD_ENUM_NETWORK_EVENTS_INFO EnumReq =
 312         (PAFD_ENUM_NETWORK_EVENTS_INFO)LockRequest( Irp, IrpSp );
 313     PAFD_FCB FCB = FileObject->FsContext;
 314
 315     AFD_DbgPrint(MID_TRACE,("Called (FCB %x)\n", FCB));
 316
 317     if( !SocketAcquireStateLock( FCB ) ) {
 318         return LostSocket( Irp );
 319     }
 320
 321     if ( !EnumReq ) {
 322          return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
 323                                    0 );
 324     }
 325
 326     EnumReq->PollEvents = FCB->PollState;
 327     RtlZeroMemory( EnumReq->EventStatus, sizeof(EnumReq->EventStatus) );
 328
 329     return UnlockAndMaybeComplete( FCB, STATUS_SUCCESS, Irp,
 330                                    0 );
 331 }
 332
 333 /* * * NOTE ALWAYS CALLED AT DISPATCH_LEVEL * * */
 334 static BOOLEAN UpdatePollWithFCB( PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject ) {
 335     UINT i;
 336     PAFD_FCB FCB;
 337     UINT Signalled = 0;
 338     PAFD_POLL_INFO PollReq = Poll->Irp->AssociatedIrp.SystemBuffer;
 339
 340     ASSERT( KeGetCurrentIrql() == DISPATCH_LEVEL );
 341
 342     for( i = 0; i < PollReq->HandleCount; i++ ) {
 343         if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
 344
 345         FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
 346         FCB = FileObject->FsContext;
 347
 348         PollReq->Handles[i].Status = PollReq->Handles[i].Events & FCB->PollState;
 349         if( PollReq->Handles[i].Status ) {
 350             AFD_DbgPrint(MID_TRACE,("Signalling %x with %x\n",
 351                                         FCB, FCB->PollState));
 352             Signalled++;
 353         }
 354     }
 355
 356     return Signalled ? 1 : 0;
 357 }
 358
 359 VOID PollReeval( PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject ) {
 360     PAFD_ACTIVE_POLL Poll = NULL;
 361     PLIST_ENTRY ThePollEnt = NULL;
 362     PAFD_FCB FCB;
 363     KIRQL OldIrql;
 364     PAFD_POLL_INFO PollReq;
 365
 366     AFD_DbgPrint(MID_TRACE,("Called: DeviceExt %x FileObject %x\n",
 367                             DeviceExt, FileObject));
 368
 369     KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
 370
 371     /* Take care of any event select signalling */
 372     FCB = (PAFD_FCB)FileObject->FsContext;
 373
 374     if( !FCB ) {
 375         KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
 376         return;
 377     }
 378
 379     /* Now signal normal select irps */
 380     ThePollEnt = DeviceExt->Polls.Flink;
 381
 382     while( ThePollEnt != &DeviceExt->Polls ) {
 383         Poll = CONTAINING_RECORD( ThePollEnt, AFD_ACTIVE_POLL, ListEntry );
 384         PollReq = Poll->Irp->AssociatedIrp.SystemBuffer;
 385         AFD_DbgPrint(MID_TRACE,("Checking poll %x\n", Poll));
 386
 387         if( UpdatePollWithFCB( Poll, FileObject ) ) {
 388             ThePollEnt = ThePollEnt->Flink;
 389             AFD_DbgPrint(MID_TRACE,("Signalling socket\n"));
 390             SignalSocket( Poll, NULL, PollReq, STATUS_SUCCESS );
 391         } else
 392             ThePollEnt = ThePollEnt->Flink;
 393     }
 394
 395     KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
 396
 397     if( FCB->EventSelect && (FCB->PollState & FCB->EventSelectTriggers) ) {
 398         AFD_DbgPrint(MID_TRACE,("Setting event %x\n", FCB->EventSelect));
 399         KeSetEvent( FCB->EventSelect, IO_NETWORK_INCREMENT, FALSE );
 400     }
 401
 402     AFD_DbgPrint(MID_TRACE,("Leaving\n"));
 403 }