xref: /reactos/drivers/network/ndisuio/protocol.c (revision b819608e) 
1 /*
2  * COPYRIGHT:   See COPYING in the top level directory
3  * PROJECT:     ReactOS NDIS User I/O driver
4  * FILE:        protocol.c
5  * PURPOSE:     Protocol stuff
6  * PROGRAMMERS: Cameron Gutman (cameron.gutman@reactos.org)
7  */
8 
9 #include "ndisuio.h"
10 
11 #define NDEBUG
12 #include <debug.h>
13 
14 VOID
15 NTAPI
16 NduOpenAdapterComplete(NDIS_HANDLE ProtocolBindingContext,
17                        NDIS_STATUS Status,
18                        NDIS_STATUS OpenStatus)
19 {
20     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
21 
22     DPRINT("Asynchronous adapter open completed\n");
23 
24     /* Store the final status and signal the event */
25     AdapterContext->AsyncStatus = Status;
26     KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
27 }
28 
29 VOID
30 NTAPI
31 NduCloseAdapterComplete(NDIS_HANDLE ProtocolBindingContext,
32                         NDIS_STATUS Status)
33 {
34     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
35 
36     DPRINT("Asynchronous adapter close completed\n");
37 
38     /* Store the final status and signal the event */
39     AdapterContext->AsyncStatus = Status;
40     KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
41 }
42 
43 VOID
44 NTAPI
45 NduSendComplete(NDIS_HANDLE ProtocolBindingContext,
46                 PNDIS_PACKET Packet,
47                 NDIS_STATUS Status)
48 {
49     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
50 
51     DPRINT("Asynchronous adapter send completed\n");
52 
53     /* Store the final status and signal the event */
54     AdapterContext->AsyncStatus = Status;
55     KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
56 }
57 
58 VOID
59 NTAPI
60 NduTransferDataComplete(NDIS_HANDLE ProtocolBindingContext,
61                         PNDIS_PACKET Packet,
62                         NDIS_STATUS Status,
63                         UINT BytesTransferred)
64 {
65     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
66 
67     DPRINT("Asynchronous adapter transfer completed\n");
68 
69     /* Store the final status and signal the event */
70     AdapterContext->AsyncStatus = Status;
71     KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
72 }
73 
74 VOID
75 NTAPI
76 NduResetComplete(NDIS_HANDLE ProtocolBindingContext,
77                  NDIS_STATUS Status)
78 {
79     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
80 
81     DPRINT("Asynchronous adapter reset completed\n");
82 
83     /* Store the final status and signal the event */
84     AdapterContext->AsyncStatus = Status;
85     KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
86 }
87 
88 VOID
89 NTAPI
90 NduRequestComplete(NDIS_HANDLE ProtocolBindingContext,
91                    PNDIS_REQUEST NdisRequest,
92                    NDIS_STATUS Status)
93 {
94     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
95 
96     DPRINT("Asynchronous adapter request completed\n");
97 
98     /* Store the final status and signal the event */
99     AdapterContext->AsyncStatus = Status;
100     KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
101 }
102 
103 NDIS_STATUS
104 NTAPI
105 NduReceive(NDIS_HANDLE ProtocolBindingContext,
106            NDIS_HANDLE MacReceiveContext,
107            PVOID HeaderBuffer,
108            UINT HeaderBufferSize,
109            PVOID LookAheadBuffer,
110            UINT LookaheadBufferSize,
111            UINT PacketSize)
112 {
113     PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
114     PNDISUIO_PACKET_ENTRY PacketEntry;
115     PVOID PacketBuffer;
116     PNDIS_PACKET Packet;
117     NDIS_STATUS Status;
118     UINT BytesTransferred;
119 
120     DPRINT("Received a %d byte packet\n", PacketSize);
121 
122     /* Discard if nobody is waiting for it */
123     if (AdapterContext->OpenCount == 0)
124         return NDIS_STATUS_NOT_ACCEPTED;
125 
126     /* Allocate a buffer to hold the packet data and header */
127     PacketBuffer = ExAllocatePool(NonPagedPool, PacketSize + HeaderBufferSize);
128     if (!PacketBuffer)
129         return NDIS_STATUS_NOT_ACCEPTED;
130 
131     /* Allocate the packet descriptor and buffer */
132     Packet = CreatePacketFromPoolBuffer(AdapterContext,
133                                         (PUCHAR)PacketBuffer + HeaderBufferSize,
134                                         PacketSize);
135     if (!Packet)
136     {
137         ExFreePool(PacketBuffer);
138         return NDIS_STATUS_NOT_ACCEPTED;
139     }
140 
141     /* Transfer the packet data into our data buffer */
142     if (LookaheadBufferSize == PacketSize)
143     {
144         NdisCopyLookaheadData((PVOID)((PUCHAR)PacketBuffer + HeaderBufferSize),
145                               LookAheadBuffer,
146                               PacketSize,
147                               AdapterContext->MacOptions);
148         BytesTransferred = PacketSize;
149     }
150     else
151     {
152         NdisTransferData(&Status,
153                          AdapterContext->BindingHandle,
154                          MacReceiveContext,
155                          0,
156                          PacketSize,
157                          Packet,
158                          &BytesTransferred);
159         if (Status == NDIS_STATUS_PENDING)
160         {
161             KeWaitForSingleObject(&AdapterContext->AsyncEvent,
162                                   Executive,
163                                   KernelMode,
164                                   FALSE,
165                                   NULL);
166             Status = AdapterContext->AsyncStatus;
167         }
168         if (Status != NDIS_STATUS_SUCCESS)
169         {
170             DPRINT1("Failed to transfer data with status 0x%x\n", Status);
171             CleanupAndFreePacket(Packet, TRUE);
172             return NDIS_STATUS_NOT_ACCEPTED;
173         }
174     }
175 
176     /* Copy the header data */
177     RtlCopyMemory(PacketBuffer, HeaderBuffer, HeaderBufferSize);
178 
179     /* Free the packet descriptor and buffers
180        but not the pool because we still need it */
181     CleanupAndFreePacket(Packet, FALSE);
182 
183     /* Allocate a packet entry from pool */
184     PacketEntry = ExAllocatePool(NonPagedPool, sizeof(NDISUIO_PACKET_ENTRY) + BytesTransferred + HeaderBufferSize - 1);
185     if (!PacketEntry)
186     {
187         ExFreePool(PacketBuffer);
188         return NDIS_STATUS_RESOURCES;
189     }
190 
191     /* Initialize the packet entry and copy in packet data */
192     PacketEntry->PacketLength = BytesTransferred + HeaderBufferSize;
193     RtlCopyMemory(PacketEntry->PacketData, PacketBuffer, PacketEntry->PacketLength);
194 
195     /* Free the old buffer */
196     ExFreePool(PacketBuffer);
197 
198     /* Insert the packet on the adapter's packet list */
199     ExInterlockedInsertTailList(&AdapterContext->PacketList,
200                                 &PacketEntry->ListEntry,
201                                 &AdapterContext->Spinlock);
202 
203     /* Signal the read event */
204     KeSetEvent(&AdapterContext->PacketReadEvent,
205                IO_NETWORK_INCREMENT,
206                FALSE);
207 
208     return NDIS_STATUS_SUCCESS;
209 }
210 
211 VOID
212 NTAPI
213 NduReceiveComplete(NDIS_HANDLE ProtocolBindingContext)
214 {
215     /* No op */
216 }
217 
218 VOID
219 NTAPI
220 NduStatus(NDIS_HANDLE ProtocolBindingContext,
221           NDIS_STATUS GeneralStatus,
222           PVOID StatusBuffer,
223           UINT StatusBufferSize)
224 {
225     /* FIXME: Implement status tracking */
226 }
227 
228 VOID
229 NTAPI
230 NduStatusComplete(NDIS_HANDLE ProtocolBindingContext)
231 {
232     /* FIXME: Implement status tracking */
233 }
234 
235 static
236 NDIS_STATUS
237 UnbindAdapterByContext(PNDISUIO_ADAPTER_CONTEXT AdapterContext)
238 {
239     KIRQL OldIrql;
240     PLIST_ENTRY CurrentEntry;
241     PNDISUIO_OPEN_ENTRY OpenEntry;
242     PNDISUIO_PACKET_ENTRY PacketEntry;
243     NDIS_STATUS Status;
244 
245     DPRINT("Unbinding adapter %wZ\n", &AdapterContext->DeviceName);
246 
247     /* FIXME: We don't do anything with outstanding reads */
248 
249     /* Remove the adapter context from the global list */
250     KeAcquireSpinLock(&GlobalAdapterListLock, &OldIrql);
251     RemoveEntryList(&AdapterContext->ListEntry);
252     KeReleaseSpinLock(&GlobalAdapterListLock, OldIrql);
253 
254     /* Free the device name string */
255     RtlFreeUnicodeString(&AdapterContext->DeviceName);
256 
257     /* Invalidate all handles to this adapter */
258     CurrentEntry = AdapterContext->OpenEntryList.Flink;
259     while (CurrentEntry != &AdapterContext->OpenEntryList)
260     {
261         OpenEntry = CONTAINING_RECORD(CurrentEntry, NDISUIO_OPEN_ENTRY, ListEntry);
262 
263         /* Make sure the entry is sane */
264         ASSERT(OpenEntry->FileObject);
265 
266         /* Remove the adapter context pointer */
267         ASSERT(AdapterContext == OpenEntry->FileObject->FsContext);
268         OpenEntry->FileObject->FsContext = NULL;
269         AdapterContext->OpenCount--;
270 
271         /* Remove the open entry pointer */
272         ASSERT(OpenEntry == OpenEntry->FileObject->FsContext2);
273         OpenEntry->FileObject->FsContext2 = NULL;
274 
275         /* Move to the next entry */
276         CurrentEntry = CurrentEntry->Flink;
277 
278         /* Free the open entry */
279         ExFreePool(OpenEntry);
280     }
281 
282     /* If this fails, we have a refcount mismatch somewhere */
283     ASSERT(AdapterContext->OpenCount == 0);
284 
285     /* Free all pending packet entries */
286     CurrentEntry = AdapterContext->PacketList.Flink;
287     while (CurrentEntry != &AdapterContext->PacketList)
288     {
289         PacketEntry = CONTAINING_RECORD(CurrentEntry, NDISUIO_PACKET_ENTRY, ListEntry);
290 
291         /* Move to the next entry */
292         CurrentEntry = CurrentEntry->Flink;
293 
294         /* Free the packet entry */
295         ExFreePool(PacketEntry);
296     }
297 
298     /* Send the close request */
299     NdisCloseAdapter(&Status,
300                      AdapterContext->BindingHandle);
301 
302     /* Wait for a pending close */
303     if (Status == NDIS_STATUS_PENDING)
304     {
305         KeWaitForSingleObject(&AdapterContext->AsyncEvent,
306                               Executive,
307                               KernelMode,
308                               FALSE,
309                               NULL);
310         Status = AdapterContext->AsyncStatus;
311     }
312 
313     /* Free the context */
314     ExFreePool(AdapterContext);
315 
316     return Status;
317 }
318 
319 static
320 NDIS_STATUS
321 BindAdapterByName(PNDIS_STRING DeviceName)
322 {
323     NDIS_STATUS OpenErrorStatus;
324     PNDISUIO_ADAPTER_CONTEXT AdapterContext;
325     NDIS_MEDIUM SupportedMedia[1] = {NdisMedium802_3};
326     UINT SelectedMedium;
327     NDIS_STATUS Status;
328     NDIS_REQUEST Request;
329 
330     /* Allocate the adapter context */
331     AdapterContext = ExAllocatePool(NonPagedPool, sizeof(*AdapterContext));
332     if (!AdapterContext)
333     {
334         return NDIS_STATUS_RESOURCES;
335     }
336 
337     /* Set up the adapter context */
338     RtlZeroMemory(AdapterContext, sizeof(*AdapterContext));
339     KeInitializeEvent(&AdapterContext->AsyncEvent, SynchronizationEvent, FALSE);
340     KeInitializeEvent(&AdapterContext->PacketReadEvent, SynchronizationEvent, FALSE);
341     KeInitializeSpinLock(&AdapterContext->Spinlock);
342     InitializeListHead(&AdapterContext->PacketList);
343     InitializeListHead(&AdapterContext->OpenEntryList);
344     AdapterContext->OpenCount = 0;
345 
346     AdapterContext->DeviceName.Length =
347     AdapterContext->DeviceName.MaximumLength = DeviceName->Length;
348     AdapterContext->DeviceName.Buffer = ExAllocatePool(NonPagedPool, DeviceName->Length);
349     if (!AdapterContext->DeviceName.Buffer)
350     {
351         ExFreePool(AdapterContext);
352         return NDIS_STATUS_RESOURCES;
353     }
354 
355     /* Copy the device name into the adapter context */
356     RtlCopyMemory(AdapterContext->DeviceName.Buffer, DeviceName->Buffer, DeviceName->Length);
357 
358     DPRINT("Binding adapter %wZ\n", &AdapterContext->DeviceName);
359 
360     /* Create the buffer pool */
361     NdisAllocateBufferPool(&Status,
362                            &AdapterContext->BufferPoolHandle,
363                            50);
364     if (Status != NDIS_STATUS_SUCCESS)
365     {
366         DPRINT1("Failed to allocate buffer pool with status 0x%x\n", Status);
367         RtlFreeUnicodeString(&AdapterContext->DeviceName);
368         ExFreePool(AdapterContext);
369         return Status;
370     }
371 
372     /* Create the packet pool */
373     NdisAllocatePacketPool(&Status,
374                            &AdapterContext->PacketPoolHandle,
375                            25,
376                            PROTOCOL_RESERVED_SIZE_IN_PACKET);
377     if (Status != NDIS_STATUS_SUCCESS)
378     {
379         DPRINT1("Failed to allocate packet pool with status 0x%x\n", Status);
380         NdisFreeBufferPool(AdapterContext->BufferPoolHandle);
381         RtlFreeUnicodeString(&AdapterContext->DeviceName);
382         ExFreePool(AdapterContext);
383         return Status;
384     }
385 
386     /* Send the open request */
387     NdisOpenAdapter(&Status,
388                     &OpenErrorStatus,
389                     &AdapterContext->BindingHandle,
390                     &SelectedMedium,
391                     SupportedMedia,
392                     1,
393                     GlobalProtocolHandle,
394                     AdapterContext,
395                     DeviceName,
396                     0,
397                     NULL);
398 
399     /* Wait for a pending open */
400     if (Status == NDIS_STATUS_PENDING)
401     {
402         KeWaitForSingleObject(&AdapterContext->AsyncEvent,
403                               Executive,
404                               KernelMode,
405                               FALSE,
406                               NULL);
407         Status = AdapterContext->AsyncStatus;
408     }
409 
410     /* Check the final status */
411     if (Status != NDIS_STATUS_SUCCESS)
412     {
413         DPRINT1("Failed to open adapter for bind with status 0x%x\n", Status);
414         NdisFreePacketPool(AdapterContext->PacketPoolHandle);
415         NdisFreeBufferPool(AdapterContext->BufferPoolHandle);
416         RtlFreeUnicodeString(&AdapterContext->DeviceName);
417         ExFreePool(AdapterContext);
418         return Status;
419     }
420 
421     /* Get the MAC options */
422     Request.RequestType = NdisRequestQueryInformation;
423     Request.DATA.QUERY_INFORMATION.Oid = OID_GEN_MAC_OPTIONS;
424     Request.DATA.QUERY_INFORMATION.InformationBuffer = &AdapterContext->MacOptions;
425     Request.DATA.QUERY_INFORMATION.InformationBufferLength = sizeof(ULONG);
426     NdisRequest(&Status,
427                 AdapterContext->BindingHandle,
428                 &Request);
429 
430     /* Wait for a pending request */
431     if (Status == NDIS_STATUS_PENDING)
432     {
433         KeWaitForSingleObject(&AdapterContext->AsyncEvent,
434                               Executive,
435                               KernelMode,
436                               FALSE,
437                               NULL);
438         Status = AdapterContext->AsyncStatus;
439     }
440 
441     /* Check the final status */
442     if (Status != NDIS_STATUS_SUCCESS)
443     {
444         NDIS_STATUS CloseStatus;
445 
446         DPRINT1("Failed to get MAC options with status 0x%x\n", Status);
447 
448         NdisCloseAdapter(&CloseStatus,
449                          AdapterContext->BindingHandle);
450         if (CloseStatus == NDIS_STATUS_PENDING)
451         {
452             KeWaitForSingleObject(&AdapterContext->AsyncEvent,
453                                   Executive,
454                                   KernelMode,
455                                   FALSE,
456                                   NULL);
457         }
458 
459         NdisFreePacketPool(AdapterContext->PacketPoolHandle);
460         NdisFreeBufferPool(AdapterContext->BufferPoolHandle);
461         RtlFreeUnicodeString(&AdapterContext->DeviceName);
462         ExFreePool(AdapterContext);
463         return Status;
464     }
465 
466     /* Add the adapter context to the global list */
467     ExInterlockedInsertTailList(&GlobalAdapterList,
468                                 &AdapterContext->ListEntry,
469                                 &GlobalAdapterListLock);
470 
471     return STATUS_SUCCESS;
472 }
473 
474 VOID
475 NTAPI
476 NduBindAdapter(PNDIS_STATUS Status,
477                NDIS_HANDLE BindContext,
478                PNDIS_STRING DeviceName,
479                PVOID SystemSpecific1,
480                PVOID SystemSpecific2)
481 {
482     /* Use our helper function to create a context for this adapter */
483     *Status = BindAdapterByName(DeviceName);
484 }
485 
486 VOID
487 NTAPI
488 NduUnbindAdapter(PNDIS_STATUS Status,
489                  NDIS_HANDLE ProtocolBindingContext,
490                  NDIS_HANDLE UnbindContext)
491 {
492     /* This is forced unbind. UnbindAdapterByContext() will take care of
493      * invalidating file handles pointer to this adapter for us */
494     *Status = UnbindAdapterByContext(ProtocolBindingContext);
495 }
496