ReactOS 0.4.15-dev-8127-g6338913
protocol.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS NDIS library
4 * FILE: ndis/protocol.c
5 * PURPOSE: Routines used by NDIS protocol drivers
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Vizzini (vizzini@plasmic.com)
8 * REVISIONS:
9 * CSH 01/08-2000 Created
10 * 09-13-2003 Vizzini Updates for SendPackets support
11 */
12
13#include "ndissys.h"
14
15#define SERVICES_KEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
16#define LINKAGE_KEY L"\\Linkage"
17#define PARAMETERS_KEY L"\\Parameters\\"
18
21
22#define WORKER_TEST 0
23
24typedef struct _DMA_CONTEXT {
28
32 PVOID EventBuffer,
33 ULONG EventBufferLength)
34{
35 PNET_PNP_EVENT PnPEvent;
36
37 PnPEvent = ExAllocatePool(PagedPool, sizeof(NET_PNP_EVENT));
38 if (!PnPEvent) {
39 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
40 return NULL;
41 }
42
43 RtlZeroMemory(PnPEvent, sizeof(NET_PNP_EVENT));
44
45 PnPEvent->NetEvent = EventCode;
46
47 if (EventBuffer != NULL)
48 {
49 PnPEvent->Buffer = ExAllocatePool(PagedPool, EventBufferLength);
50 if (!PnPEvent->Buffer)
51 {
52 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
53 ExFreePool(PnPEvent);
54 return NULL;
55 }
56
57 PnPEvent->BufferLength = EventBufferLength;
58
59 RtlCopyMemory(PnPEvent->Buffer, EventBuffer, PnPEvent->BufferLength);
60 }
61
62 return PnPEvent;
63}
64
67 PLOGICAL_ADAPTER Adapter,
68 PNET_PNP_EVENT PnPEvent,
69 PIRP Irp)
70{
71 PLIST_ENTRY CurrentEntry;
73 PADAPTER_BINDING AdapterBinding;
74
75 CurrentEntry = Adapter->ProtocolListHead.Flink;
76
77 while (CurrentEntry != &Adapter->ProtocolListHead)
78 {
79 AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, AdapterListEntry);
80
81 Status = (*AdapterBinding->ProtocolBinding->Chars.PnPEventHandler)(
82 AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
83 PnPEvent);
84
86 {
88 /* Yes, I know this is stupid */
89 PnPEvent->NdisReserved[0] = (ULONG_PTR)Irp;
90 PnPEvent->NdisReserved[1] = (ULONG_PTR)CurrentEntry->Flink;
92 }
93 else if (Status != NDIS_STATUS_SUCCESS)
94 {
95 if (PnPEvent->Buffer) ExFreePool(PnPEvent->Buffer);
96 ExFreePool(PnPEvent);
97 return Status;
98 }
99
100 CurrentEntry = CurrentEntry->Flink;
101 }
102
103 if (PnPEvent->Buffer) ExFreePool(PnPEvent->Buffer);
104 ExFreePool(PnPEvent);
105
106 return NDIS_STATUS_SUCCESS;
107}
108
110NTAPI
113 PIRP Irp)
114{
115 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
116 PNET_PNP_EVENT PnPEvent;
118
119 ASSERT(Stack->Parameters.Power.Type == DevicePowerState);
120
121 PnPEvent = ProSetupPnPEvent(NetEventSetPower, &Stack->Parameters.Power.State, sizeof(NDIS_DEVICE_POWER_STATE));
122 if (!PnPEvent) {
123 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
125 }
126
127 return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
128}
129
131NTAPI
134 PIRP Irp)
135{
136 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
137 PNET_PNP_EVENT PnPEvent;
139
140 ASSERT(Stack->Parameters.Power.Type == DevicePowerState);
141
142 PnPEvent = ProSetupPnPEvent(NetEventQueryPower, &Stack->Parameters.Power.State, sizeof(NDIS_DEVICE_POWER_STATE));
143 if (!PnPEvent) {
144 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
146 }
147
148 return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
149}
150
151
153NTAPI
156 PIRP Irp)
157{
158 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
159 PNET_PNP_EVENT PnPEvent;
160
162 if (!PnPEvent) {
163 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
165 }
166
167 return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
168}
169
171NTAPI
174 PIRP Irp)
175{
176 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
177 PNET_PNP_EVENT PnPEvent;
178
180 if (!PnPEvent) {
181 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
183 }
184
185 return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
186}
187
188/*
189 * @implemented
190 */
191VOID
192EXPORT
194 IN NDIS_HANDLE BindAdapterContext,
197/*
198 * FUNCTION: Indicates a packet to bound protocols
199 * ARGUMENTS:
200 * Adapter = Pointer to logical adapter
201 * Packet = Pointer to packet to indicate
202 * RETURNS:
203 * Status of operation
204 * NOTES:
205 * - FIXME: partially-implemented
206 */
207{
208 PROTOCOL_BINDING *Protocol = (PROTOCOL_BINDING *)BindAdapterContext;
209
210 if (!NT_SUCCESS(Status)) {
211 NDIS_DbgPrint(MIN_TRACE, ("Binding failed (%x)\n", Status));
212 return;
213 }
214
215 /* Put protocol binding struct on global list */
217}
218
219/*
220 * @implemented
221 */
222VOID
223EXPORT
225 IN NDIS_HANDLE UnbindAdapterContext,
227{
228 /* We probably need to do more here but for now we just do
229 * the opposite of what NdisCompleteBindAdapter does
230 */
231
232 PROTOCOL_BINDING *Protocol = (PROTOCOL_BINDING *)UnbindAdapterContext;
233
234 if (!NT_SUCCESS(Status)) {
235 NDIS_DbgPrint(MIN_TRACE, ("Unbinding failed (%x)\n", Status));
236 return;
237 }
238
240}
241
244 PLOGICAL_ADAPTER Adapter,
246/*
247 * FUNCTION: Indicates a packet to bound protocols
248 * ARGUMENTS:
249 * Adapter = Pointer to logical adapter
250 * Packet = Pointer to packet to indicate
251 * RETURNS:
252 * STATUS_SUCCESS in all cases
253 * NOTES:
254 * - XXX ATM, this only handles loopback packets - is that its designed function?
255 */
256{
257 UINT BufferedLength;
258 UINT PacketLength;
260 PUCHAR LookaheadBuffer;
261
262 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
263
264#if DBG
265 MiniDisplayPacket(Packet, "INDICATE");
266#endif
267
268 NdisQueryPacket(Packet, NULL, NULL, NULL, &PacketLength);
269
270 LookaheadBuffer = ExAllocatePool(NonPagedPool, PacketLength);
271 if (!LookaheadBuffer) {
272 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
274 }
275
276 NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
278 {
279 BufferedLength = CopyPacketToBuffer(LookaheadBuffer, Packet, 0, PacketLength);
280 Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()] = Packet;
281 }
283
284 if (BufferedLength > Adapter->MediumHeaderSize)
285 {
286 /* XXX Change this to call SendPackets so we don't have to duplicate this wacky logic */
287 MiniIndicateData(Adapter, NULL, LookaheadBuffer, Adapter->MediumHeaderSize,
288 &LookaheadBuffer[Adapter->MediumHeaderSize], BufferedLength - Adapter->MediumHeaderSize,
289 PacketLength - Adapter->MediumHeaderSize);
290 }
291 else
292 {
293 MiniIndicateData(Adapter, NULL, LookaheadBuffer, Adapter->MediumHeaderSize, NULL, 0, 0);
294 }
295
296 ExFreePool(LookaheadBuffer);
297
299 {
300 Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()] = NULL;
301 }
303
304 return NDIS_STATUS_SUCCESS;
305}
306
309 IN NDIS_HANDLE MacBindingHandle,
311/*
312 * FUNCTION: Forwards a request to an NDIS miniport
313 * ARGUMENTS:
314 * MacBindingHandle = Adapter binding handle
315 * NdisRequest = Pointer to request to perform
316 * RETURNS:
317 * Status of operation
318 */
319{
320 PADAPTER_BINDING AdapterBinding;
321 PLOGICAL_ADAPTER Adapter;
323
324 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
325
326 ASSERT(MacBindingHandle);
327 AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
328
329 ASSERT(AdapterBinding->Adapter);
330 Adapter = AdapterBinding->Adapter;
331
332 MacBlock->Binding = &AdapterBinding->NdisOpenBlock;
333
334#if WORKER_TEST
336 return NDIS_STATUS_PENDING;
337#else
338 if (MiniIsBusy(Adapter, NdisWorkItemRequest)) {
340 return NDIS_STATUS_PENDING;
341 }
342
343 return MiniDoRequest(Adapter, NdisRequest);
344#endif
345}
346
347
350 IN NDIS_HANDLE MacBindingHandle)
351{
352 PADAPTER_BINDING AdapterBinding = MacBindingHandle;
353
354 /* FIXME: Wait for all packets to be sent */
355
356 return MiniReset(AdapterBinding->Adapter);
357}
358
362 IN PIRP Irp,
365{
366 PDMA_CONTEXT DmaContext = Context;
367 PLOGICAL_ADAPTER Adapter = DmaContext->Adapter;
368 PNDIS_PACKET Packet = DmaContext->Packet;
370
371 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
372
375
377
379 NDIS_DbgPrint(MAX_TRACE, ("Completing packet.\n"));
380 MiniSendComplete(Adapter,
381 Packet,
382 Status);
383 }
384
385 ExFreePool(DmaContext);
386}
387
390{
391#if WORKER_TEST
393 return NDIS_STATUS_PENDING;
394#else
395 KIRQL RaiseOldIrql;
396 NDIS_STATUS NdisStatus;
397
398 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
399
400 if(MiniIsBusy(Adapter, NdisWorkItemSend)) {
401 NDIS_DbgPrint(MID_TRACE, ("Busy: NdisWorkItemSend.\n"));
402
404 return NDIS_STATUS_PENDING;
405 }
406
407#if DBG
408 MiniDisplayPacket(Packet, "SEND");
409#endif
410
411 if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
412 {
414 {
415 NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
416 (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
418 NdisStatus = NDIS_STATUS_PENDING;
419 } else {
420 /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
421 KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
422 {
423 NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
424 (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
426 }
427 KeLowerIrql(RaiseOldIrql);
428
429 NdisStatus = NDIS_GET_PACKET_STATUS(Packet);
430 if (NdisStatus == NDIS_STATUS_RESOURCES) {
432 NdisStatus = NDIS_STATUS_PENDING;
433 }
434 }
435
436 if (NdisStatus != NDIS_STATUS_PENDING) {
438 }
439
440 return NdisStatus;
441 } else {
443 {
444 NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
445 NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
446 Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, Packet->Private.Flags);
447 NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
448 } else {
449 /* Send is called at DISPATCH_LEVEL for all serialized miniports */
450 KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
451 NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
452 NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
453 Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, Packet->Private.Flags);
454 NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
455 KeLowerIrql(RaiseOldIrql);
456
457 if (NdisStatus == NDIS_STATUS_RESOURCES) {
459 NdisStatus = NDIS_STATUS_PENDING;
460 }
461 }
462
463 if (NdisStatus != NDIS_STATUS_PENDING) {
465 }
466
467 return NdisStatus;
468 }
469#endif
470}
471
474 IN NDIS_HANDLE MacBindingHandle,
476/*
477 * FUNCTION: Forwards a request to send a packet to an NDIS miniport
478 * ARGUMENTS:
479 * MacBindingHandle = Adapter binding handle
480 * Packet = Pointer to NDIS packet descriptor
481 * RETURNS:
482 * NDIS_STATUS_SUCCESS if the packet was successfully sent
483 * NDIS_STATUS_PENDING if the miniport was busy or a serialized miniport returned NDIS_STATUS_RESOURCES
484 */
485{
486 PADAPTER_BINDING AdapterBinding;
487 PLOGICAL_ADAPTER Adapter;
488 PNDIS_BUFFER NdisBuffer;
490 NDIS_STATUS NdisStatus;
491 UINT PacketLength;
493
494 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
495
496 ASSERT(MacBindingHandle);
497 AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
498
499 ASSERT(AdapterBinding);
500 Adapter = AdapterBinding->Adapter;
501
502 ASSERT(Adapter);
503
504 /* if the following is not true, KeRaiseIrql() below will break */
506
507 /* XXX what is this crazy black magic? */
508 Packet->Reserved[1] = (ULONG_PTR)MacBindingHandle;
509
510 /*
511 * Test the packet to see if it is a MAC loopback.
512 *
513 * We may have to loop this packet if miniport cannot.
514 * If dest MAC address of packet == MAC address of adapter,
515 * this is a loopback frame.
516 */
517
520 {
521#if WORKER_TEST
523 return NDIS_STATUS_PENDING;
524#else
525 return ProIndicatePacket(Adapter, Packet);
526#endif
527 } else {
528 if (Adapter->NdisMiniportBlock.ScatterGatherListSize != 0)
529 {
530 NDIS_DbgPrint(MID_TRACE, ("Using Scatter/Gather DMA\n"));
531
533 NULL,
534 NULL,
535 &NdisBuffer,
536 &PacketLength);
537
539 if (!Context) {
540 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
542 }
543
544 Context->Adapter = Adapter;
545 Context->Packet = Packet;
546
548
549 KeFlushIoBuffers(NdisBuffer, FALSE, TRUE);
550
551 NdisStatus = Adapter->NdisMiniportBlock.SystemAdapterObject->DmaOperations->GetScatterGatherList(
552 Adapter->NdisMiniportBlock.SystemAdapterObject,
554 NdisBuffer,
555 MmGetMdlVirtualAddress(NdisBuffer),
556 PacketLength,
558 Context,
559 TRUE);
560
562
563 if (!NT_SUCCESS(NdisStatus)) {
564 NDIS_DbgPrint(MIN_TRACE, ("GetScatterGatherList failed! (%x)\n", NdisStatus));
565 return NdisStatus;
566 }
567
568 return NDIS_STATUS_PENDING;
569 }
570
571
572 return proSendPacketToMiniport(Adapter, Packet);
573 }
574}
575
581{
582 PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
583 PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
584 KIRQL RaiseOldIrql;
585 NDIS_STATUS NdisStatus;
586 UINT i;
587
588 if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
589 {
591 {
592 (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
594 }
595 else
596 {
597 /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
598 KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
599 (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
601 KeLowerIrql(RaiseOldIrql);
602 for (i = 0; i < NumberOfPackets; i++)
603 {
604 NdisStatus = NDIS_GET_PACKET_STATUS(PacketArray[i]);
605 if (NdisStatus != NDIS_STATUS_PENDING)
606 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
607 }
608 }
609 }
610 else
611 {
613 {
614 for (i = 0; i < NumberOfPackets; i++)
615 {
616 NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
618 if (NdisStatus != NDIS_STATUS_PENDING)
619 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
620 }
621 }
622 else
623 {
624 /* Send is called at DISPATCH_LEVEL for all serialized miniports */
625 KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
626 for (i = 0; i < NumberOfPackets; i++)
627 {
628 NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
630 if (NdisStatus != NDIS_STATUS_PENDING)
631 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
632 }
633 KeLowerIrql(RaiseOldIrql);
634 }
635 }
636}
637
640 IN NDIS_HANDLE MacBindingHandle,
641 IN NDIS_HANDLE MacReceiveContext,
643 IN UINT BytesToTransfer,
646/*
647 * FUNCTION: Forwards a request to copy received data into a protocol-supplied packet
648 * ARGUMENTS:
649 * MacBindingHandle = Adapter binding handle
650 * MacReceiveContext = MAC receive context
651 * ByteOffset = Offset in packet to place data
652 * BytesToTransfer = Number of bytes to copy into packet
653 * Packet = Pointer to NDIS packet descriptor
654 * BytesTransferred = Address of buffer to place number of bytes copied
655 */
656{
657 PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
658 PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
661
662 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
663
664 /* FIXME: Interrupts must be disabled for adapter */
665 /* XXX sd - why is that true? */
666
667 if (Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()]) {
668 NDIS_DbgPrint(MAX_TRACE, ("LoopPacket\n"));
669 /* NDIS is responsible for looping this packet */
671 ByteOffset + Adapter->MediumHeaderSize,
672 BytesToTransfer + Adapter->MediumHeaderSize,
673 Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()],
674 0,
676 return NDIS_STATUS_SUCCESS;
677 }
678
679 ASSERT(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.TransferDataHandler);
680
682
683 Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.TransferDataHandler)(
684 Packet,
687 MacReceiveContext,
689 BytesToTransfer);
690
692
693 return Status;
694}
695
696
697
698/*
699 * @implemented
700 */
701VOID
702EXPORT
706/*
707 * FUNCTION: Closes an adapter opened with NdisOpenAdapter
708 * ARGUMENTS:
709 * Status = Address of buffer for status information
710 * NdisBindingHandle = Handle returned by NdisOpenAdapter
711 */
712{
714
715 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
716
717 /* Remove from protocol's bound adapters list */
718 ExInterlockedRemoveEntryList(&AdapterBinding->ProtocolListEntry, &AdapterBinding->ProtocolBinding->Lock);
719
720 /* Remove protocol from adapter's bound protocols list */
722
723 ExFreePool(AdapterBinding);
724
726}
727
728
729/*
730 * @implemented
731 */
732VOID
733EXPORT
737/*
738 * FUNCTION: Releases the resources allocated by NdisRegisterProtocol
739 * ARGUMENTS:
740 * Status = Address of buffer for status information
741 * NdisProtocolHandle = Handle returned by NdisRegisterProtocol
742 */
743{
745
746 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
747
748 /* FIXME: Make sure no adapter bindings exist */
749
750 /* Remove protocol from global list */
752
754
756}
757
758
759/*
760 * @implemented
761 */
762VOID
763EXPORT
769 IN PNDIS_MEDIUM MediumArray,
776/*
777 * FUNCTION: Opens an adapter for communication
778 * ARGUMENTS:
779 * Status = Address of buffer for status information
780 * OpenErrorStatus = Address of buffer for secondary error code
781 * NdisBindingHandle = Address of buffer for adapter binding handle
782 * SelectedMediumIndex = Address of buffer for selected medium
783 * MediumArray = Pointer to an array of NDIS_MEDIUMs called can support
784 * MediumArraySize = Number of elements in MediumArray
785 * NdisProtocolHandle = Handle returned by NdisRegisterProtocol
786 * ProtocolBindingContext = Pointer to caller supplied context area
787 * AdapterName = Pointer to buffer with name of adapter
788 * OpenOptions = Bitmask with flags passed to next-lower driver
789 * AddressingInformation = Optional pointer to buffer with NIC specific information
790 */
791{
792 UINT i;
794 PLOGICAL_ADAPTER Adapter;
795 PADAPTER_BINDING AdapterBinding;
797
798 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
799
801 {
802 NDIS_DbgPrint(MIN_TRACE, ("NdisProtocolHandle is NULL\n"));
804 return;
805 }
806
807 Adapter = MiniLocateDevice(AdapterName);
808 if (!Adapter)
809 {
810 NDIS_DbgPrint(MIN_TRACE, ("Adapter not found.\n"));
812 return;
813 }
814
815 /* Find the media type in the list provided by the protocol driver */
816 Found = FALSE;
817 for (i = 0; i < MediumArraySize; i++)
818 {
819 if (Adapter->NdisMiniportBlock.MediaType == MediumArray[i])
820 {
822 Found = TRUE;
823 break;
824 }
825 }
826
827 if (!Found)
828 {
829 NDIS_DbgPrint(MIN_TRACE, ("Medium is not supported.\n"));
831 return;
832 }
833
834 /* Now that we have confirmed that the adapter can be opened, create a binding */
835
836 AdapterBinding = ExAllocatePool(NonPagedPool, sizeof(ADAPTER_BINDING));
837 if (!AdapterBinding)
838 {
839 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
841 return;
842 }
843
844 RtlZeroMemory(AdapterBinding, sizeof(ADAPTER_BINDING));
845
846 AdapterBinding->ProtocolBinding = Protocol;
847 AdapterBinding->Adapter = Adapter;
848 AdapterBinding->NdisOpenBlock.ProtocolBindingContext = ProtocolBindingContext;
849
850 /* Set fields required by some NDIS macros */
851 AdapterBinding->NdisOpenBlock.BindingHandle = (NDIS_HANDLE)AdapterBinding;
852
853 /* Set handlers (some NDIS macros require these) */
854
855 AdapterBinding->NdisOpenBlock.RequestHandler = ProRequest;
856 AdapterBinding->NdisOpenBlock.ResetHandler = ProReset;
857 AdapterBinding->NdisOpenBlock.SendHandler = ProSend;
858 AdapterBinding->NdisOpenBlock.SendPacketsHandler = ProSendPackets;
859 AdapterBinding->NdisOpenBlock.TransferDataHandler = ProTransferData;
860
861 AdapterBinding->NdisOpenBlock.RequestCompleteHandler =
862 Protocol->Chars.RequestCompleteHandler;
863
864 /* Put on protocol's bound adapters list */
865 ExInterlockedInsertTailList(&Protocol->AdapterListHead, &AdapterBinding->ProtocolListEntry, &Protocol->Lock);
866
867 /* Put protocol on adapter's bound protocols list */
868 NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
870
871 *NdisBindingHandle = (NDIS_HANDLE)AdapterBinding;
872
874}
875
877NTAPI
879{
880 PLIST_ENTRY CurrentEntry;
881 PADAPTER_BINDING AdapterBinding;
883
884 KeAcquireSpinLock(&ProtocolBinding->Lock, &OldIrql);
885
886 CurrentEntry = ProtocolBinding->AdapterListHead.Flink;
887
888 while (CurrentEntry != &ProtocolBinding->AdapterListHead)
889 {
890 AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, ProtocolListEntry);
891
893 {
894 KeReleaseSpinLock(&ProtocolBinding->Lock, OldIrql);
895 return AdapterBinding;
896 }
897
898 CurrentEntry = CurrentEntry->Flink;
899 }
900
901 KeReleaseSpinLock(&ProtocolBinding->Lock, OldIrql);
902
903 return NULL;
904}
905
906VOID
907NTAPI
909{
910 /*
911 * bind the protocol to all of its miniports
912 *
913 * open registry path
914 * get list of devices from Bind key
915 * call BindAdapterHandler for each
916 */
919 WCHAR *RegistryPathStr, *DataPtr = NULL;
920 NTSTATUS NtStatus;
921 HANDLE DriverKeyHandle = NULL;
922 PKEY_VALUE_PARTIAL_INFORMATION KeyInformation = NULL;
926 PLIST_ENTRY CurrentEntry = NULL;
927
928 RegistryPathStr = ExAllocatePoolWithTag(PagedPool, sizeof(SERVICES_KEY) + ProtocolCharacteristics->Name.Length + sizeof(LINKAGE_KEY), NDIS_TAG + __LINE__);
929 if(!RegistryPathStr)
930 {
931 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
933 return;
934 }
935
936 wcscpy(RegistryPathStr, SERVICES_KEY);
937 wcsncat(RegistryPathStr, ((WCHAR *)ProtocolCharacteristics->Name.Buffer), ProtocolCharacteristics->Name.Length / sizeof(WCHAR));
938 RegistryPathStr[wcslen(SERVICES_KEY)+ProtocolCharacteristics->Name.Length/sizeof(WCHAR)] = 0;
939 wcscat(RegistryPathStr, LINKAGE_KEY);
940
941 RtlInitUnicodeString(&RegistryPath, RegistryPathStr);
942 NDIS_DbgPrint(MAX_TRACE, ("Opening configuration key: %wZ\n", &RegistryPath));
943
945 NtStatus = ZwOpenKey(&DriverKeyHandle, KEY_READ, &ObjectAttributes);
946
947 ExFreePool(RegistryPathStr);
948
949 if(NT_SUCCESS(NtStatus))
950 {
951 NDIS_DbgPrint(MAX_TRACE, ("Successfully opened the registry configuration\n"));
952
954
955 NtStatus = ZwQueryValueKey(DriverKeyHandle, &ValueName, KeyValuePartialInformation, NULL, 0, &ResultLength);
956 if(NtStatus != STATUS_BUFFER_OVERFLOW && NtStatus != STATUS_BUFFER_TOO_SMALL && NtStatus != STATUS_SUCCESS)
957 {
958 NDIS_DbgPrint(MIN_TRACE, ("Unable to query the Bind value for size\n"));
959 ZwClose(DriverKeyHandle);
960 }
961 else
962 {
964 if(!KeyInformation)
965 {
966 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
967 ZwClose(DriverKeyHandle);
968 NtStatus = STATUS_NO_MEMORY;
969 }
970 else
971 {
972 NtStatus = ZwQueryValueKey(DriverKeyHandle, &ValueName, KeyValuePartialInformation, KeyInformation,
974
975 ZwClose(DriverKeyHandle);
976
977 if(!NT_SUCCESS(NtStatus))
978 {
979 NDIS_DbgPrint(MIN_TRACE, ("Unable to query the Bind value\n"));
980 ExFreePool(KeyInformation);
981 KeyInformation = NULL;
982 }
983 }
984 }
985 }
986
987 if (!NT_SUCCESS(NtStatus))
988 {
989 NDIS_DbgPrint(MID_TRACE, ("Performing global bind for protocol '%wZ'\n", &ProtocolCharacteristics->Name));
990 KeyInformation = NULL;
991
992 CurrentEntry = AdapterListHead.Flink;
993 }
994 else
995 {
996 NDIS_DbgPrint(MID_TRACE, ("Performing standard bind for protocol '%wZ'\n", &ProtocolCharacteristics->Name));
997
998 DataPtr = (WCHAR*)KeyInformation->Data;
999 }
1000
1001 /* Assume success for now */
1003
1004 while (TRUE)
1005 {
1006 /* BindContext is for tracking pending binding operations */
1007 VOID *BindContext = 0;
1010 WCHAR *RegistryPathStr = NULL;
1011 ULONG PathLength = 0;
1012 PLOGICAL_ADAPTER Adapter;
1013
1014 if (KeyInformation)
1015 {
1016 /* Parse the REG_MULTI_SZ entry for device names */
1017 if (!(*DataPtr))
1018 break;
1019
1021 }
1022 else
1023 {
1024 /* Use the device name from the global adapter list */
1025 if (CurrentEntry == &AdapterListHead)
1026 break;
1027
1028 Adapter = CONTAINING_RECORD(CurrentEntry, LOGICAL_ADAPTER, ListEntry);
1029
1031 }
1032
1033 /* Make sure the adapter has started */
1035 {
1036 /* It wasn't in the global miniport list, so skip the bind entry */
1037 goto next;
1038 }
1039
1040 /* Make sure this device isn't already bound to this protocol */
1042 {
1043 /* It was already in this protocol's bound adapter list, so skip the bind entry */
1044 goto next;
1045 }
1046
1047 /*
1048 * RegistryPath should be:
1049 * \Registry\Machine\System\CurrentControlSet\Services\Nic1\Parameters\Tcpip
1050 *
1051 * This is constructed as follows:
1052 * SERVICES_KEY + extracted device name + Protocol name from characteristics
1053 */
1054
1055 PathLength = sizeof(SERVICES_KEY) + /* \Registry\Machine\System\CurrentControlSet\Services\ */
1056 wcslen( DeviceName.Buffer + 8 ) * sizeof(WCHAR) + /* Adapter1 (extracted from \Device\Adapter1) */
1057 sizeof(PARAMETERS_KEY) + /* \Parameters\ */
1058 ProtocolCharacteristics->Name.Length + sizeof(WCHAR); /* Tcpip */
1059
1060 RegistryPathStr = ExAllocatePool(PagedPool, PathLength);
1061 if(!RegistryPathStr)
1062 {
1063 NDIS_DbgPrint(MIN_TRACE, ("insufficient resources.\n"));
1065 break;
1066 }
1067
1068 wcscpy(RegistryPathStr, SERVICES_KEY);
1069 wcscat(RegistryPathStr, DeviceName.Buffer + 8 );
1070 wcscat(RegistryPathStr, PARAMETERS_KEY);
1071 wcsncat(RegistryPathStr, ProtocolCharacteristics->Name.Buffer, ProtocolCharacteristics->Name.Length / sizeof(WCHAR) );
1072
1073 RegistryPathStr[PathLength/sizeof(WCHAR) - 1] = 0;
1074
1075 RtlInitUnicodeString(&RegistryPath, RegistryPathStr);
1076
1077 NDIS_DbgPrint(MAX_TRACE, ("Calling protocol's BindAdapter handler with DeviceName %wZ and RegistryPath %wZ\n",
1079
1080 {
1081 BIND_HANDLER BindHandler = ProtocolCharacteristics->BindAdapterHandler;
1082 if(BindHandler)
1083 {
1084 BindHandler(Status, BindContext, &DeviceName, &RegistryPath, 0);
1085 NDIS_DbgPrint(MID_TRACE, ("%wZ's BindAdapter handler returned 0x%x for %wZ\n", &ProtocolCharacteristics->Name, *Status, &DeviceName));
1086 }
1087 else
1088 NDIS_DbgPrint(MID_TRACE, ("No protocol bind handler specified\n"));
1089 }
1090
1091 next:
1092 if (KeyInformation)
1093 {
1094 /* Advance to the next adapter in the REG_MULTI_SZ */
1095 DataPtr += (DeviceName.Length / sizeof(WCHAR)) + 1;
1096 }
1097 else
1098 {
1099 /* Advance to the next adapter in the global list */
1100 CurrentEntry = CurrentEntry->Flink;
1101 }
1102 }
1103
1104 if (KeyInformation)
1105 {
1106 ExFreePool(KeyInformation);
1107 }
1108}
1109
1110/*
1111 * @implemented
1112 */
1113VOID
1114EXPORT
1120/*
1121 * FUNCTION: Registers an NDIS driver's ProtocolXxx entry points
1122 * ARGUMENTS:
1123 * Status = Address of buffer for status information
1124 * NdisProtocolHandle = Address of buffer for handle used to identify the driver
1125 * ProtocolCharacteristics = Pointer to NDIS_PROTOCOL_CHARACTERISTICS structure
1126 * CharacteristicsLength = Size of structure which ProtocolCharacteristics targets
1127 * NOTES:
1128 * - you *must* set NdisProtocolHandle before doing anything that could wind up
1129 * getting BindAdapterHandler, as it will probably call OpenAdapter with this handle
1130 * - the above implies that the initialization of the protocol block must be complete
1131 * by then
1132 * TODO:
1133 * - break this function up - probably do a 'ndisRefreshProtocolBindings' function
1134 * - make this thing able to handle >1 protocol
1135 */
1136{
1138 NTSTATUS NtStatus;
1139 UINT MinSize;
1140 PNET_PNP_EVENT PnPEvent;
1141
1142 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
1143
1145
1146 /* first validate the PROTOCOL_CHARACTERISTICS */
1147 switch (ProtocolCharacteristics->MajorNdisVersion)
1148 {
1149 case 0x03:
1150 /* we don't really want to support ndis3 drivers - so we complain for now */
1151 NDIS_DbgPrint(MID_TRACE, ("NDIS 3 protocol attempting to register\n"));
1152 MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS);
1153 break;
1154
1155 case 0x04:
1156 MinSize = sizeof(NDIS40_PROTOCOL_CHARACTERISTICS);
1157 break;
1158
1159 case 0x05:
1160 MinSize = sizeof(NDIS50_PROTOCOL_CHARACTERISTICS);
1161 break;
1162
1163 default:
1165 NDIS_DbgPrint(MIN_TRACE, ("Incorrect characteristics size\n"));
1166 return;
1167 }
1168
1169 if (CharacteristicsLength < MinSize)
1170 {
1171 NDIS_DbgPrint(MIN_TRACE, ("Bad protocol characteristics.\n"));
1173 return;
1174 }
1175
1176 /* set up the protocol block */
1178 if (!Protocol)
1179 {
1180 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
1182 return;
1183 }
1184
1187
1188 NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name, &ProtocolCharacteristics->Name, TRUE);
1189 if (!NT_SUCCESS(NtStatus))
1190 {
1191 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
1194 return;
1195 }
1196
1198
1199 InitializeListHead(&Protocol->AdapterListHead);
1200
1201 /* We must set this before the call to ndisBindMiniportsToProtocol because the protocol's
1202 * BindAdapter handler might need it */
1203
1205
1207
1208 /* Should we only send this if ndisBindMiniportsToProtocol succeeds? */
1210 if (PnPEvent)
1211 {
1212 if (Protocol->Chars.PnPEventHandler)
1213 {
1214 /* We call this with a NULL binding context because it affects all bindings */
1215 NtStatus = (*Protocol->Chars.PnPEventHandler)(NULL,
1216 PnPEvent);
1217
1218 /* FIXME: We don't support this yet */
1219 ASSERT(NtStatus != NDIS_STATUS_PENDING);
1220 }
1221
1222 ExFreePool(PnPEvent);
1223 }
1224
1225 if (*Status == NDIS_STATUS_SUCCESS) {
1227 } else {
1228 NDIS_DbgPrint(MIN_TRACE, ("Binding failed (%x)\n", *Status));
1231 }
1232}
1233
1234/*
1235 * @implemented
1236 */
1237VOID
1238EXPORT
1243/*
1244 * FUNCTION: Forwards a request to an NDIS driver
1245 * ARGUMENTS:
1246 * Status = Address of buffer for status information
1247 * NdisBindingHandle = Adapter binding handle
1248 * NdisRequest = Pointer to request to perform
1249 */
1250{
1252}
1253
1254/*
1255 * @implemented
1256 */
1257VOID
1258EXPORT
1262{
1264}
1265
1266/*
1267 * @implemented
1268 */
1269#undef NdisSend
1270VOID
1271EXPORT
1276/*
1277 * FUNCTION: Forwards a request to send a packet
1278 * ARGUMENTS:
1279 * Status = Address of buffer for status information
1280 * NdisBindingHandle = Adapter binding handle
1281 * Packet = Pointer to NDIS packet descriptor
1282 */
1283{
1285}
1286
1287/*
1288 * @implemented
1289 */
1290#undef NdisSendPackets
1291VOID
1292EXPORT
1297{
1299}
1300
1301/*
1302 * @implemented
1303 */
1304#undef NdisTransferData
1305VOID
1306EXPORT
1310 IN NDIS_HANDLE MacReceiveContext,
1312 IN UINT BytesToTransfer,
1315/*
1316 * FUNCTION: Forwards a request to copy received data into a protocol-supplied packet
1317 * ARGUMENTS:
1318 * Status = Address of buffer for status information
1319 * NdisBindingHandle = Adapter binding handle
1320 * MacReceiveContext = MAC receive context
1321 * ByteOffset = Offset in packet to place data
1322 * BytesToTransfer = Number of bytes to copy into packet
1323 * Packet = Pointer to NDIS packet descriptor
1324 * BytesTransferred = Address of buffer to place number of bytes copied
1325 */
1326{
1328 MacReceiveContext,
1329 ByteOffset,
1330 BytesToTransfer,
1331 Packet,
1333}
1334
1335/*
1336 * @implemented
1337 */
1338VOID
1339NTAPI
1341{
1342 NDIS_STATUS NdisStatus;
1343
1345}
1346
1347
1348/*
1349 * @implemented
1350 */
1351VOID
1352EXPORT
1356/*
1357 * FUNCTION:
1358 * ARGUMENTS:
1359 * NOTES:
1360 * NDIS 5.0
1361 */
1362{
1364
1365 if (!Binding)
1366 {
1367 NDIS_DbgPrint(MIN_TRACE, ("Bad binding handle\n"));
1369 return;
1370 }
1371
1372 *NdisDriverHandle = Binding->Adapter->NdisMiniportBlock.DriverHandle;
1373}
1374
1375/* EOF */
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
static USHORT PathLength
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
#define MIN_TRACE
Definition: debug.h:14
#define MID_TRACE
Definition: debug.h:15
#define MAX_TRACE
Definition: debug.h:16
UINT CopyPacketToBuffer(PUCHAR DstData, PNDIS_PACKET SrcPacket, UINT SrcOffset, UINT Length)
Definition: buffer.c:172
return Found
Definition: dirsup.c:1270
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
_In_ PIRP Irp
Definition: csq.h:116
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define NDIS_DbgPrint(_t_, _x_)
Definition: debug.h:40
LIST_ENTRY AdapterListHead
Definition: miniport.c:57
VOID MiniWorkItemComplete(PLOGICAL_ADAPTER Adapter, NDIS_WORK_ITEM_TYPE WorkItemType)
Definition: miniport.c:964
VOID NTAPI MiniSendComplete(IN NDIS_HANDLE MiniportAdapterHandle, IN PNDIS_PACKET Packet, IN NDIS_STATUS Status)
Definition: miniport.c:530
NDIS_STATUS MiniDoRequest(PLOGICAL_ADAPTER Adapter, PNDIS_REQUEST NdisRequest)
Definition: miniport.c:1107
struct _LOGICAL_ADAPTER * PLOGICAL_ADAPTER
NDIS_STATUS MiniReset(PLOGICAL_ADAPTER Adapter)
Definition: miniport.c:902
BOOLEAN MiniAdapterHasAddress(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
Definition: miniport.c:616
VOID FASTCALL MiniQueueWorkItem(PLOGICAL_ADAPTER Adapter, NDIS_WORK_ITEM_TYPE WorkItemType, PVOID WorkItemContext, BOOLEAN Top)
Definition: miniport.c:982
PLOGICAL_ADAPTER MiniLocateDevice(PNDIS_STRING AdapterName)
Definition: miniport.c:690
BOOLEAN MiniIsBusy(PLOGICAL_ADAPTER Adapter, NDIS_WORK_ITEM_TYPE Type)
Definition: miniport.c:142
VOID MiniIndicateData(PLOGICAL_ADAPTER Adapter, NDIS_HANDLE MacReceiveContext, PVOID HeaderBuffer, UINT HeaderBufferSize, PVOID LookaheadBuffer, UINT LookaheadBufferSize, UINT PacketSize)
Definition: miniport.c:175
#define GET_PROTOCOL_BINDING(Handle)
Definition: protocol.h:18
struct _NDIS_REQUEST_MAC_BLOCK * PNDIS_REQUEST_MAC_BLOCK
struct _ADAPTER_BINDING * PADAPTER_BINDING
#define GET_ADAPTER_BINDING(Handle)
Definition: protocol.h:39
VOID EXPORT NdisCopyFromPacketToPacket(IN PNDIS_PACKET Destination, IN UINT DestinationOffset, IN UINT BytesToCopy, IN PNDIS_PACKET Source, IN UINT SourceOffset, OUT PUINT BytesCopied)
Definition: buffer.c:571
VOID NTAPI ScatterGatherSendPacket(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PSCATTER_GATHER_LIST ScatterGather, IN PVOID Context)
Definition: protocol.c:360
LIST_ENTRY ProtocolListHead
Definition: protocol.c:19
VOID EXPORT NdisOpenAdapter(OUT PNDIS_STATUS Status, OUT PNDIS_STATUS OpenErrorStatus, OUT PNDIS_HANDLE NdisBindingHandle, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE NdisProtocolHandle, IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_STRING AdapterName, IN UINT OpenOptions, IN PSTRING AddressingInformation OPTIONAL)
Definition: protocol.c:764
VOID EXPORT NdisDeregisterProtocol(OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisProtocolHandle)
Definition: protocol.c:734
#define SERVICES_KEY
Definition: protocol.c:15
NTSTATUS NTAPI NdisIPnPCancelStopDevice(IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: protocol.c:172
NTSTATUS NTAPI NdisIPwrQueryPower(IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: protocol.c:132
PNET_PNP_EVENT ProSetupPnPEvent(NET_PNP_EVENT_CODE EventCode, PVOID EventBuffer, ULONG EventBufferLength)
Definition: protocol.c:30
VOID NTAPI ndisBindMiniportsToProtocol(OUT PNDIS_STATUS Status, IN PPROTOCOL_BINDING Protocol)
Definition: protocol.c:908
VOID EXPORT NdisCompleteBindAdapter(IN NDIS_HANDLE BindAdapterContext, IN NDIS_STATUS Status, IN NDIS_STATUS OpenStatus)
Definition: protocol.c:193
struct _DMA_CONTEXT * PDMA_CONTEXT
NDIS_STATUS NTAPI ProSend(IN NDIS_HANDLE MacBindingHandle, IN PNDIS_PACKET Packet)
Definition: protocol.c:473
VOID EXPORT NdisSendPackets(IN NDIS_HANDLE NdisBindingHandle, IN PPNDIS_PACKET PacketArray, IN UINT NumberOfPackets)
Definition: protocol.c:1293
PADAPTER_BINDING NTAPI LocateAdapterBindingByName(IN PPROTOCOL_BINDING ProtocolBinding, IN PNDIS_STRING AdapterName)
Definition: protocol.c:878
VOID EXPORT NdisCompleteUnbindAdapter(IN NDIS_HANDLE UnbindAdapterContext, IN NDIS_STATUS Status)
Definition: protocol.c:224
struct _DMA_CONTEXT DMA_CONTEXT
#define PARAMETERS_KEY
Definition: protocol.c:17
NDIS_STATUS ProSendAndFreePnPEvent(PLOGICAL_ADAPTER Adapter, PNET_PNP_EVENT PnPEvent, PIRP Irp)
Definition: protocol.c:66
VOID NTAPI NdisReEnumerateProtocolBindings(IN NDIS_HANDLE NdisProtocolHandle)
Definition: protocol.c:1340
NDIS_STATUS ProIndicatePacket(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
Definition: protocol.c:243
NTSTATUS NTAPI NdisIPwrSetPower(IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: protocol.c:111
NDIS_STATUS NTAPI ProTransferData(IN NDIS_HANDLE MacBindingHandle, IN NDIS_HANDLE MacReceiveContext, IN UINT ByteOffset, IN UINT BytesToTransfer, IN OUT PNDIS_PACKET Packet, OUT PUINT BytesTransferred)
Definition: protocol.c:639
NDIS_STATUS NTAPI ProRequest(IN NDIS_HANDLE MacBindingHandle, IN PNDIS_REQUEST NdisRequest)
Definition: protocol.c:308
#define LINKAGE_KEY
Definition: protocol.c:16
NTSTATUS NTAPI NdisIPnPQueryStopDevice(IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: protocol.c:154
VOID EXPORT NdisSend(OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN PNDIS_PACKET Packet)
Definition: protocol.c:1272
VOID EXPORT NdisReset(OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle)
Definition: protocol.c:1259
VOID EXPORT NdisCloseAdapter(OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle)
Definition: protocol.c:703
VOID EXPORT NdisTransferData(OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN NDIS_HANDLE MacReceiveContext, IN UINT ByteOffset, IN UINT BytesToTransfer, IN OUT PNDIS_PACKET Packet, OUT PUINT BytesTransferred)
Definition: protocol.c:1307
VOID EXPORT NdisRegisterProtocol(OUT PNDIS_STATUS Status, OUT PNDIS_HANDLE NdisProtocolHandle, IN PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics, IN UINT CharacteristicsLength)
Definition: protocol.c:1115
KSPIN_LOCK ProtocolListLock
Definition: protocol.c:20
NDIS_STATUS proSendPacketToMiniport(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
Definition: protocol.c:389
VOID EXPORT NdisGetDriverHandle(IN PNDIS_HANDLE NdisBindingHandle, OUT PNDIS_HANDLE NdisDriverHandle)
Definition: protocol.c:1353
NDIS_STATUS NTAPI ProReset(IN NDIS_HANDLE MacBindingHandle)
Definition: protocol.c:349
VOID NTAPI ProSendPackets(IN NDIS_HANDLE NdisBindingHandle, IN PPNDIS_PACKET PacketArray, IN UINT NumberOfPackets)
Definition: protocol.c:577
#define ULONG_PTR
Definition: config.h:101
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
UCHAR KIRQL
Definition: env_spec_w32.h:591
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
NTSTATUS RtlUpcaseUnicodeString(PUNICODE_STRING dst, PUNICODE_STRING src, BOOLEAN Alloc)
Definition: string_lib.cpp:46
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define NonPagedPool
Definition: env_spec_w32.h:307
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
#define PagedPool
Definition: env_spec_w32.h:308
IN PDCB IN PCCB IN VBO IN OUT PULONG OUT PDIRENT OUT PBCB OUT PVBO ByteOffset
Definition: fatprocs.h:731
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
Status
Definition: gdiplustypes.h:25
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
IoMarkIrpPending(Irp)
#define ASSERT(a)
Definition: mode.c:44
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
_Out_ PNDIS_HANDLE _In_ PNDIS_PROTOCOL_CHARACTERISTICS _In_ UINT CharacteristicsLength
Definition: ndis.h:6136
#define NDIS_STATUS_BAD_VERSION
Definition: ndis.h:468
_Must_inspect_result_ _In_ NDIS_HANDLE NdisBindingHandle
Definition: ndis.h:4735
#define NDIS_STATUS_PENDING
Definition: ndis.h:347
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1549
struct _NDIS30_PROTOCOL_CHARACTERISTICS NDIS30_PROTOCOL_CHARACTERISTICS
unsigned int * PUINT
Definition: ndis.h:50
unsigned int UINT
Definition: ndis.h:50
PVOID NDIS_HANDLE
Definition: ndis.h:338
#define NDIS_STATUS_BAD_CHARACTERISTICS
Definition: ndis.h:469
static __inline VOID NdisQueryPacket(IN PNDIS_PACKET Packet, OUT PUINT PhysicalBufferCount OPTIONAL, OUT PUINT BufferCount OPTIONAL, OUT PNDIS_BUFFER *FirstBuffer OPTIONAL, OUT PUINT TotalPacketLength OPTIONAL)
Definition: ndis.h:3593
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT _In_ NDIS_HANDLE _In_ NDIS_HANDLE _In_ PNDIS_STRING _In_ UINT _In_opt_ PSTRING AddressingInformation
Definition: ndis.h:6018
@ NdisWorkItemSendLoopback
Definition: ndis.h:2300
@ NdisWorkItemSend
Definition: ndis.h:2295
@ NdisWorkItemRequest
Definition: ndis.h:2294
#define NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, InfoType)
Definition: ndis.h:1351
#define NDIS_STATUS_FAILURE
Definition: ndis.h:465
struct _NDIS50_PROTOCOL_CHARACTERISTICS NDIS50_PROTOCOL_CHARACTERISTICS
_In_ PPNDIS_PACKET _In_ UINT NumberOfPackets
Definition: ndis.h:5121
_In_ PPNDIS_PACKET PacketArray
Definition: ndis.h:5120
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT _In_ NDIS_HANDLE _In_ NDIS_HANDLE ProtocolBindingContext
Definition: ndis.h:6015
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT SelectedMediumIndex
Definition: ndis.h:6011
_In_ NDIS_STATUS EventCode
Definition: ndis.h:4751
_Out_ PNDIS_HANDLE _In_ PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics
Definition: ndis.h:6135
_Out_ PNDIS_HANDLE NdisDriverHandle
Definition: ndis.h:6064
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT _In_ NDIS_HANDLE _In_ NDIS_HANDLE _In_ PNDIS_STRING _In_ UINT OpenOptions
Definition: ndis.h:6017
#define NDIS_STATUS_SUCCESS
Definition: ndis.h:346
#define NDIS_ATTRIBUTE_DESERIALIZE
Definition: ndis.h:588
MDL * PNDIS_BUFFER
Definition: ndis.h:343
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT MediumArraySize
Definition: ndis.h:6013
@ ScatterGatherListPacketInfo
Definition: ndis.h:1183
struct _NDIS40_PROTOCOL_CHARACTERISTICS NDIS40_PROTOCOL_CHARACTERISTICS
#define NDIS_GET_PACKET_STATUS(_Packet)
Definition: ndis.h:3436
#define NDIS_STATUS_UNSUPPORTED_MEDIA
Definition: ndis.h:490
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS OpenErrorStatus
Definition: ndis.h:6009
#define NDIS_STATUS_ADAPTER_NOT_FOUND
Definition: ndis.h:470
#define NDIS_MAC_OPTION_NO_LOOPBACK
Definition: ndis.h:685
* PNDIS_STATUS
Definition: ndis.h:45
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT _In_ NDIS_HANDLE _In_ NDIS_HANDLE _In_ PNDIS_STRING AdapterName
Definition: ndis.h:6016
_In_opt_ NDIS_HANDLE _In_opt_ NDIS_HANDLE _Inout_ PNDIS_REQUEST NdisRequest
Definition: ndis.h:1573
VOID(NTAPI * BIND_HANDLER)(OUT PNDIS_STATUS Status, IN NDIS_HANDLE BindContext, IN PNDIS_STRING DeviceName, IN PVOID SystemSpecific1, IN PVOID SystemSpecific2)
Definition: ndis.h:1844
_In_ NDIS_STATUS _In_ NDIS_STATUS OpenStatus
Definition: ndis.h:6035
#define NDIS_STATUS_RESOURCES
Definition: ndis.h:466
#define NDIS_TAG
Definition: ndissys.h:29
#define ExInterlockedRemoveEntryList(_List, _Lock)
Definition: ndissys.h:37
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
enum _NET_PNP_EVENT_CODE NET_PNP_EVENT_CODE
@ NetEventSetPower
Definition: netpnp.h:15
@ NetEventQueryRemoveDevice
Definition: netpnp.h:17
@ NetEventBindsComplete
Definition: netpnp.h:21
@ NetEventCancelRemoveDevice
Definition: netpnp.h:18
@ NetEventQueryPower
Definition: netpnp.h:16
@ KeyValuePartialInformation
Definition: nt_native.h:1182
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
enum _NDIS_DEVICE_POWER_STATE NDIS_DEVICE_POWER_STATE
enum _NDIS_MEDIUM * PNDIS_MEDIUM
int NDIS_STATUS
Definition: ntddndis.h:475
@ DevicePowerState
Definition: ntpoapi.h:63
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define L(x)
Definition: ntvdm.h:50
static unsigned __int64 next
Definition: rand_nt.c:6
_CRTIMP wchar_t *__cdecl wcsncat(wchar_t *_Dest, const wchar_t *_Source, size_t _Count)
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
Definition: ke.h:174
FORCEINLINE ULONG KeGetCurrentProcessorNumber(VOID)
Definition: ke.h:341
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
LIST_ENTRY ProtocolListEntry
Definition: protocol.h:25
PLOGICAL_ADAPTER Adapter
Definition: protocol.h:29
NDIS_OPEN_BLOCK NdisOpenBlock
Definition: protocol.h:22
PPROTOCOL_BINDING ProtocolBinding
Definition: protocol.h:28
LIST_ENTRY AdapterListEntry
Definition: protocol.h:26
PLOGICAL_ADAPTER Adapter
Definition: protocol.c:25
PNDIS_PACKET Packet
Definition: protocol.c:26
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LIST_ENTRY ProtocolListHead
Definition: miniport.h:94
NDIS_MINIPORT_BLOCK NdisMiniportBlock
Definition: miniport.h:89
ULONG MediumHeaderSize
Definition: miniport.h:95
PNP_EVENT_HANDLER PnPEventHandler
Definition: ndis.h:1899
NDIS_MEDIUM MediaType
Definition: ndis.h:2548
KSPIN_LOCK Lock
Definition: ndis.h:2520
NDIS_HANDLE MiniportAdapterContext
Definition: ndis.h:2510
PDEVICE_OBJECT PhysicalDeviceObject
Definition: ndis.h:2553
UNICODE_STRING MiniportName
Definition: ndis.h:2511
PNDIS_M_DRIVER_BLOCK DriverHandle
Definition: ndis.h:2509
NDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics
Definition: miniport.h:22
NDIS_PACKET_PRIVATE Private
Definition: ndis.h:735
PNDIS_OPEN_BLOCK Binding
Definition: protocol.h:34
ULONG BufferLength
Definition: netpnp.h:34
ULONG_PTR NdisReserved[4]
Definition: netpnp.h:35
PVOID Buffer
Definition: netpnp.h:33
NET_PNP_EVENT_CODE NetEvent
Definition: netpnp.h:32
NDIS_PROTOCOL_CHARACTERISTICS Chars
Definition: protocol.h:13
KSPIN_LOCK Lock
Definition: protocol.h:12
#define NTAPI
Definition: typedefs.h:36
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define IN
Definition: typedefs.h:39
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
unsigned char * PUCHAR
Definition: typedefs.h:53
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:639
_Must_inspect_result_ _In_ WDFUSBDEVICE _In_opt_ WDFREQUEST _In_opt_ PWDF_REQUEST_SEND_OPTIONS _In_ PWDF_USB_CONTROL_SETUP_PACKET _In_opt_ PWDF_MEMORY_DESCRIPTOR _Out_opt_ PULONG BytesTransferred
Definition: wdfusb.h:1342
struct _SCATTER_GATHER_LIST * PSCATTER_GATHER_LIST
Definition: iotypes.h:2204
_In_ struct _IRP _In_ struct _SCATTER_GATHER_LIST * ScatterGather
Definition: iotypes.h:2375
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
#define MmGetMdlVirtualAddress(_Mdl)
__wchar_t WCHAR
Definition: xmlstorage.h:180