reactos/drivers/net/afd/afd/event.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS Ancillary Function Driver
   4  * FILE:        afd/event.c
   5  * PURPOSE:     TDI event handlers
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/09-2000 Created
   9  */
  10 #include <afd.h>
  11
  12 NTSTATUS AfdEventError(
  13     IN PVOID TdiEventContext,
  14     IN NTSTATUS Status)
  15 {
  16     AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
  17
  18     return STATUS_SUCCESS;
  19 }
  20
  21
  22 NTSTATUS AfdEventDisconnect(
  23     IN PVOID TdiEventContext,
  24     IN CONNECTION_CONTEXT ConnectionContext,
  25     IN LONG DisconnectDataLength,
  26     IN PVOID DisconnectData,
  27     IN LONG DisconnectInformationLength,
  28     IN PVOID DisconnectInformation,
  29     IN ULONG DisconnectFlags)
  30 {
  31     AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
  32
  33     return STATUS_SUCCESS;
  34 }
  35
  36
  37 NTSTATUS AfdEventReceive(
  38     IN PVOID TdiEventContext,
  39     IN CONNECTION_CONTEXT ConnectionContext,
  40     IN ULONG ReceiveFlags,
  41     IN ULONG BytesIndicated,
  42     IN ULONG BytesAvailable,
  43     OUT ULONG *BytesTaken,
  44     IN PVOID Tsdu,
  45     OUT PIRP *IoRequestPacket)
  46 {
  47     AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
  48
  49     return STATUS_SUCCESS;
  50 }
  51
  52
  53 TDI_STATUS ClientEventReceiveExpedited(
  54     IN PVOID TdiEventContext,
  55     IN CONNECTION_CONTEXT ConnectionContext,
  56     IN ULONG ReceiveFlags,
  57     IN ULONG BytesIndicated,
  58     IN ULONG BytesAvailable,
  59     OUT ULONG *BytesTaken,
  60     IN PVOID Tsdu,
  61     OUT PIRP *IoRequestPacket)
  62 {
  63     AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
  64
  65     return STATUS_SUCCESS;
  66 }
  67
  68
  69 NTSTATUS ClientEventChainedReceive(
  70     IN PVOID TdiEventContext,
  71     IN CONNECTION_CONTEXT ConnectionContext,
  72     IN ULONG ReceiveFlags,
  73     IN ULONG ReceiveLength,
  74     IN ULONG StartingOffset,
  75     IN PMDL Tsdu,
  76     IN PVOID TsduDescriptor)
  77 {
  78     AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
  79
  80     return STATUS_SUCCESS;
  81 }
  82
  83
  84 NTSTATUS AfdEventReceiveDatagramHandler(
  85   IN PVOID TdiEventContext,
  86   IN LONG SourceAddressLength,
  87   IN PVOID SourceAddress,
  88   IN LONG OptionsLength,
  89   IN PVOID Options,
  90   IN ULONG ReceiveDatagramFlags,
  91   IN ULONG BytesIndicated,
  92   IN ULONG BytesAvailable,
  93   OUT ULONG *BytesTaken,
  94   IN PVOID Tsdu,
  95   OUT PIRP *IoRequestPacket)
  96 {
  97   PAFDFCB FCB = (PAFDFCB)TdiEventContext;
  98   PAFD_READ_REQUEST ReadRequest;
  99   PVOID ReceiveBuffer;
 100   PAFD_BUFFER Buffer;
 101   PLIST_ENTRY Entry;
 102   NTSTATUS Status;
 103   KIRQL OldIrql;
 104
 105   AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
 106
 107   AFD_DbgPrint(MID_TRACE, ("Receiving (%d) bytes from (0x%X).\n",
 108     BytesAvailable, *(PULONG)SourceAddress));
 109
 110   ReceiveBuffer = ExAllocatePool(NonPagedPool, BytesAvailable);
 111   if (!ReceiveBuffer) {
 112     return STATUS_INSUFFICIENT_RESOURCES;
 113   }
 114
 115   /*Buffer = (PAFD_BUFFER)ExAllocateFromNPagedLookasideList(
 116     &BufferLookasideList);*/
 117   Buffer = (PAFD_BUFFER)ExAllocatePool(NonPagedPool, sizeof(AFD_BUFFER));
 118   if (!Buffer) {
 119     ExFreePool(ReceiveBuffer);
 120     return STATUS_INSUFFICIENT_RESOURCES;
 121   }
 122
 123   Buffer->Buffer.len = BytesAvailable;
 124   Buffer->Buffer.buf = ReceiveBuffer;
 125
 126   ExInterlockedInsertTailList(
 127     &FCB->ReceiveQueue,
 128     &Buffer->ListEntry,
 129     &FCB->ReceiveQueueLock);
 130
 131   KeAcquireSpinLock(&FCB->ReadRequestQueueLock, &OldIrql);
 132
 133   if (!IsListEmpty(&FCB->ReadRequestQueue)) {
 134     Entry = RemoveHeadList(&FCB->ReceiveQueue);
 135     ReadRequest = CONTAINING_RECORD(Entry, AFD_READ_REQUEST, ListEntry);
 136
 137     Status = FillWSABuffers(
 138       FCB,
 139       ReadRequest->RecvFromRequest->Buffers,
 140       ReadRequest->RecvFromRequest->BufferCount,
 141       &ReadRequest->RecvFromReply->NumberOfBytesRecvd);
 142     ReadRequest->RecvFromReply->Status = NO_ERROR;
 143
 144     ReadRequest->Irp->IoStatus.Information = 0;
 145     ReadRequest->Irp->IoStatus.Status = Status;
 146     IoCompleteRequest(ReadRequest->Irp, IO_NETWORK_INCREMENT);
 147   }
 148
 149   KeReleaseSpinLock(&FCB->ReadRequestQueueLock, OldIrql);
 150
 151   *BytesTaken = BytesAvailable;
 152
 153   AFD_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 154
 155   return STATUS_SUCCESS;
 156 }
 157
 158
 159 NTSTATUS AfdRegisterEventHandlers(
 160     PAFDFCB FCB)
 161 {
 162     NTSTATUS Status;
 163
 164     assert(FCB->TdiAddressObject);
 165
 166     /* Report errors for all types of sockets */
 167     Status = TdiSetEventHandler(FCB->TdiAddressObject,
 168         TDI_EVENT_ERROR,
 169         (PVOID)AfdEventError,
 170         (PVOID)FCB);
 171     if (!NT_SUCCESS(Status)) { return Status; }
 172
 173     switch (FCB->SocketType) {
 174     case SOCK_STREAM:
 175         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 176             TDI_EVENT_DISCONNECT,
 177             (PVOID)AfdEventDisconnect,
 178             (PVOID)FCB);
 179         if (!NT_SUCCESS(Status)) { return Status; }
 180
 181         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 182             TDI_EVENT_RECEIVE,
 183             (PVOID)AfdEventReceive,
 184             (PVOID)FCB);
 185         if (!NT_SUCCESS(Status)) { return Status; }
 186
 187         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 188             TDI_EVENT_RECEIVE_EXPEDITED,
 189             (PVOID)ClientEventReceiveExpedited,
 190             (PVOID)FCB);
 191         if (!NT_SUCCESS(Status)) { return Status; }
 192
 193         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 194             TDI_EVENT_CHAINED_RECEIVE,
 195             (PVOID)ClientEventChainedReceive,
 196             (PVOID)FCB);
 197         if (!NT_SUCCESS(Status)) { return Status; }
 198         break;
 199
 200     case SOCK_DGRAM:
 201     case SOCK_RAW:
 202         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 203             TDI_EVENT_RECEIVE_DATAGRAM,
 204             (PVOID)AfdEventReceiveDatagramHandler,
 205             (PVOID)FCB);
 206         if (!NT_SUCCESS(Status)) { return Status; }
 207     }
 208     return STATUS_SUCCESS;
 209 }
 210
 211
 212 NTSTATUS AfdDeregisterEventHandlers(
 213     PAFDFCB FCB)
 214 {
 215     NTSTATUS Status;
 216
 217     Status = TdiSetEventHandler(FCB->TdiAddressObject,
 218         TDI_EVENT_ERROR,
 219         NULL,
 220         NULL);
 221     if (!NT_SUCCESS(Status)) { return Status; }
 222
 223     switch (FCB->SocketType) {
 224     case SOCK_STREAM:
 225         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 226             TDI_EVENT_DISCONNECT,
 227             NULL,
 228             NULL);
 229         if (!NT_SUCCESS(Status)) { return Status; }
 230
 231         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 232             TDI_EVENT_RECEIVE,
 233             NULL,
 234             NULL);
 235         if (!NT_SUCCESS(Status)) { return Status; }
 236
 237         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 238             TDI_EVENT_RECEIVE_EXPEDITED,
 239             NULL,
 240             NULL);
 241         if (!NT_SUCCESS(Status)) { return Status; }
 242
 243         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 244             TDI_EVENT_CHAINED_RECEIVE,
 245             NULL,
 246             NULL);
 247         if (!NT_SUCCESS(Status)) { return Status; }
 248         break;
 249
 250     case SOCK_DGRAM:
 251     case SOCK_RAW:
 252         Status = TdiSetEventHandler(FCB->TdiAddressObject,
 253             TDI_EVENT_RECEIVE_DATAGRAM,
 254             NULL,
 255             NULL);
 256         if (!NT_SUCCESS(Status)) { return Status; }
 257     }
 258     return STATUS_SUCCESS;
 259 }
 260
 261
 262 /* EOF */