ReactOS 0.4.15-dev-8227-g32d615f
protocol.c File Reference
#include "ndissys.h"
Include dependency graph for protocol.c:

Go to the source code of this file.

Classes

struct  _DMA_CONTEXT
 

Macros

#define SERVICES_KEY   L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
 
#define LINKAGE_KEY   L"\\Linkage"
 
#define PARAMETERS_KEY   L"\\Parameters\\"
 
#define WORKER_TEST   0
 

Typedefs

typedef struct _DMA_CONTEXT DMA_CONTEXT
 
typedef struct _DMA_CONTEXTPDMA_CONTEXT
 

Functions

PNET_PNP_EVENT ProSetupPnPEvent (NET_PNP_EVENT_CODE EventCode, PVOID EventBuffer, ULONG EventBufferLength)
 
NDIS_STATUS ProSendAndFreePnPEvent (PLOGICAL_ADAPTER Adapter, PNET_PNP_EVENT PnPEvent, PIRP Irp)
 
NTSTATUS NTAPI NdisIPwrSetPower (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS NTAPI NdisIPwrQueryPower (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS NTAPI NdisIPnPQueryStopDevice (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS NTAPI NdisIPnPCancelStopDevice (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
VOID EXPORT NdisCompleteBindAdapter (IN NDIS_HANDLE BindAdapterContext, IN NDIS_STATUS Status, IN NDIS_STATUS OpenStatus)
 
VOID EXPORT NdisCompleteUnbindAdapter (IN NDIS_HANDLE UnbindAdapterContext, IN NDIS_STATUS Status)
 
NDIS_STATUS ProIndicatePacket (PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
 
NDIS_STATUS NTAPI ProRequest (IN NDIS_HANDLE MacBindingHandle, IN PNDIS_REQUEST NdisRequest)
 
NDIS_STATUS NTAPI ProReset (IN NDIS_HANDLE MacBindingHandle)
 
VOID NTAPI ScatterGatherSendPacket (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PSCATTER_GATHER_LIST ScatterGather, IN PVOID Context)
 
NDIS_STATUS proSendPacketToMiniport (PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
 
NDIS_STATUS NTAPI ProSend (IN NDIS_HANDLE MacBindingHandle, IN PNDIS_PACKET Packet)
 
VOID NTAPI ProSendPackets (IN NDIS_HANDLE NdisBindingHandle, IN PPNDIS_PACKET PacketArray, IN UINT NumberOfPackets)
 
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)
 
VOID EXPORT NdisCloseAdapter (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle)
 
VOID EXPORT NdisDeregisterProtocol (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisProtocolHandle)
 
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)
 
PADAPTER_BINDING NTAPI LocateAdapterBindingByName (IN PPROTOCOL_BINDING ProtocolBinding, IN PNDIS_STRING AdapterName)
 
VOID NTAPI ndisBindMiniportsToProtocol (OUT PNDIS_STATUS Status, IN PPROTOCOL_BINDING Protocol)
 
VOID EXPORT NdisRegisterProtocol (OUT PNDIS_STATUS Status, OUT PNDIS_HANDLE NdisProtocolHandle, IN PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics, IN UINT CharacteristicsLength)
 
VOID EXPORT NdisRequest (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN PNDIS_REQUEST NdisRequest)
 
VOID EXPORT NdisReset (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle)
 
VOID EXPORT NdisSend (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN PNDIS_PACKET Packet)
 
VOID EXPORT NdisSendPackets (IN NDIS_HANDLE NdisBindingHandle, IN PPNDIS_PACKET PacketArray, IN UINT NumberOfPackets)
 
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)
 
VOID NTAPI NdisReEnumerateProtocolBindings (IN NDIS_HANDLE NdisProtocolHandle)
 
VOID EXPORT NdisGetDriverHandle (IN PNDIS_HANDLE NdisBindingHandle, OUT PNDIS_HANDLE NdisDriverHandle)
 

Variables

LIST_ENTRY ProtocolListHead
 
KSPIN_LOCK ProtocolListLock
 

Macro Definition Documentation

◆ LINKAGE_KEY

#define LINKAGE_KEY   L"\\Linkage"

Definition at line 16 of file protocol.c.

◆ PARAMETERS_KEY

#define PARAMETERS_KEY   L"\\Parameters\\"

Definition at line 17 of file protocol.c.

◆ SERVICES_KEY

#define SERVICES_KEY   L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"

Definition at line 15 of file protocol.c.

◆ WORKER_TEST

#define WORKER_TEST   0

Definition at line 22 of file protocol.c.

Typedef Documentation

◆ DMA_CONTEXT

◆ PDMA_CONTEXT

Function Documentation

◆ LocateAdapterBindingByName()

PADAPTER_BINDING NTAPI LocateAdapterBindingByName ( IN PPROTOCOL_BINDING  ProtocolBinding,
IN PNDIS_STRING  AdapterName 
)

Definition at line 878 of file protocol.c.

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}
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
UCHAR KIRQL
Definition: env_spec_w32.h:591
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
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
_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
PLOGICAL_ADAPTER Adapter
Definition: protocol.h:29
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
NDIS_MINIPORT_BLOCK NdisMiniportBlock
Definition: miniport.h:89
UNICODE_STRING MiniportName
Definition: ndis.h:2511
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by ndisBindMiniportsToProtocol().

◆ ndisBindMiniportsToProtocol()

VOID NTAPI ndisBindMiniportsToProtocol ( OUT PNDIS_STATUS  Status,
IN PPROTOCOL_BINDING  Protocol 
)

Definition at line 908 of file protocol.c.

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}
static USHORT PathLength
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
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define NDIS_DbgPrint(_t_, _x_)
Definition: debug.h:40
LIST_ENTRY AdapterListHead
Definition: miniport.c:57
PLOGICAL_ADAPTER MiniLocateDevice(PNDIS_STRING AdapterName)
Definition: miniport.c:690
#define SERVICES_KEY
Definition: protocol.c:15
PADAPTER_BINDING NTAPI LocateAdapterBindingByName(IN PPROTOCOL_BINDING ProtocolBinding, IN PNDIS_STRING AdapterName)
Definition: protocol.c:878
#define PARAMETERS_KEY
Definition: protocol.c:17
#define LINKAGE_KEY
Definition: protocol.c:16
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define PagedPool
Definition: env_spec_w32.h:308
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
Status
Definition: gdiplustypes.h:25
_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
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
_Out_ PNDIS_HANDLE _In_ PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics
Definition: ndis.h:6135
#define NDIS_STATUS_SUCCESS
Definition: ndis.h:346
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
#define NDIS_STATUS_RESOURCES
Definition: ndis.h:466
#define NDIS_TAG
Definition: ndissys.h:29
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
@ KeyValuePartialInformation
Definition: nt_native.h:1182
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#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 STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
uint32_t ULONG
Definition: typedefs.h:59
_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
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by NdisIPnPStartDevice(), NdisReEnumerateProtocolBindings(), and NdisRegisterProtocol().

◆ NdisCloseAdapter()

VOID EXPORT NdisCloseAdapter ( OUT PNDIS_STATUS  Status,
IN NDIS_HANDLE  NdisBindingHandle 
)

Definition at line 703 of file protocol.c.

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}
#define GET_ADAPTER_BINDING(Handle)
Definition: protocol.h:39
_Must_inspect_result_ _In_ NDIS_HANDLE NdisBindingHandle
Definition: ndis.h:4735
#define ExInterlockedRemoveEntryList(_List, _Lock)
Definition: ndissys.h:37
LIST_ENTRY ProtocolListEntry
Definition: protocol.h:25
PPROTOCOL_BINDING ProtocolBinding
Definition: protocol.h:28
LIST_ENTRY AdapterListEntry
Definition: protocol.h:26
KSPIN_LOCK Lock
Definition: ndis.h:2520
KSPIN_LOCK Lock
Definition: protocol.h:12

Referenced by BindAdapterByName(), LANUnregisterAdapter(), and UnbindAdapterByContext().

◆ NdisCompleteBindAdapter()

VOID EXPORT NdisCompleteBindAdapter ( IN NDIS_HANDLE  BindAdapterContext,
IN NDIS_STATUS  Status,
IN NDIS_STATUS  OpenStatus 
)

Definition at line 193 of file protocol.c.

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}
LIST_ENTRY ProtocolListHead
Definition: protocol.c:19
KSPIN_LOCK ProtocolListLock
Definition: protocol.c:20
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140

◆ NdisCompleteUnbindAdapter()

VOID EXPORT NdisCompleteUnbindAdapter ( IN NDIS_HANDLE  UnbindAdapterContext,
IN NDIS_STATUS  Status 
)

Definition at line 224 of file protocol.c.

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}

◆ NdisDeregisterProtocol()

VOID EXPORT NdisDeregisterProtocol ( OUT PNDIS_STATUS  Status,
IN NDIS_HANDLE  NdisProtocolHandle 
)

Definition at line 734 of file protocol.c.

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}
#define GET_PROTOCOL_BINDING(Handle)
Definition: protocol.h:18

Referenced by LANUnregisterProtocol().

◆ NdisGetDriverHandle()

VOID EXPORT NdisGetDriverHandle ( IN PNDIS_HANDLE  NdisBindingHandle,
OUT PNDIS_HANDLE  NdisDriverHandle 
)

Definition at line 1353 of file protocol.c.

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}
struct _ADAPTER_BINDING * PADAPTER_BINDING
_Out_ PNDIS_HANDLE NdisDriverHandle
Definition: ndis.h:6064

◆ NdisIPnPCancelStopDevice()

NTSTATUS NTAPI NdisIPnPCancelStopDevice ( IN PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 172 of file protocol.c.

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}
_In_ PIRP Irp
Definition: csq.h:116
struct _LOGICAL_ADAPTER * PLOGICAL_ADAPTER
PNET_PNP_EVENT ProSetupPnPEvent(NET_PNP_EVENT_CODE EventCode, PVOID EventBuffer, ULONG EventBufferLength)
Definition: protocol.c:30
NDIS_STATUS ProSendAndFreePnPEvent(PLOGICAL_ADAPTER Adapter, PNET_PNP_EVENT PnPEvent, PIRP Irp)
Definition: protocol.c:66
@ NetEventCancelRemoveDevice
Definition: netpnp.h:18
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055

Referenced by NdisIDispatchPnp().

◆ NdisIPnPQueryStopDevice()

NTSTATUS NTAPI NdisIPnPQueryStopDevice ( IN PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 154 of file protocol.c.

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}
@ NetEventQueryRemoveDevice
Definition: netpnp.h:17

Referenced by NdisIDispatchPnp().

◆ NdisIPwrQueryPower()

NTSTATUS NTAPI NdisIPwrQueryPower ( IN PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 132 of file protocol.c.

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}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
#define ASSERT(a)
Definition: mode.c:44
@ NetEventQueryPower
Definition: netpnp.h:16
enum _NDIS_DEVICE_POWER_STATE NDIS_DEVICE_POWER_STATE
@ DevicePowerState
Definition: ntpoapi.h:63
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:639

◆ NdisIPwrSetPower()

NTSTATUS NTAPI NdisIPwrSetPower ( IN PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 111 of file protocol.c.

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}
@ NetEventSetPower
Definition: netpnp.h:15

◆ NdisOpenAdapter()

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 at line 764 of file protocol.c.

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}
unsigned char BOOLEAN
return Found
Definition: dirsup.c:1270
#define FALSE
Definition: types.h:117
NDIS_STATUS NTAPI ProSend(IN NDIS_HANDLE MacBindingHandle, IN PNDIS_PACKET Packet)
Definition: protocol.c:473
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
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 NonPagedPool
Definition: env_spec_w32.h:307
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
unsigned int UINT
Definition: ndis.h:50
PVOID NDIS_HANDLE
Definition: ndis.h:338
#define NDIS_STATUS_FAILURE
Definition: ndis.h:465
_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
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT MediumArraySize
Definition: ndis.h:6013
#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
NDIS_OPEN_BLOCK NdisOpenBlock
Definition: protocol.h:22
LIST_ENTRY ProtocolListHead
Definition: miniport.h:94
NDIS_MEDIUM MediaType
Definition: ndis.h:2548
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

Referenced by BindAdapterByName(), and LANRegisterAdapter().

◆ NdisReEnumerateProtocolBindings()

VOID NTAPI NdisReEnumerateProtocolBindings ( IN NDIS_HANDLE  NdisProtocolHandle)

Definition at line 1340 of file protocol.c.

1341{
1342 NDIS_STATUS NdisStatus;
1343
1345}
VOID NTAPI ndisBindMiniportsToProtocol(OUT PNDIS_STATUS Status, IN PPROTOCOL_BINDING Protocol)
Definition: protocol.c:908
int NDIS_STATUS
Definition: ntddndis.h:475

◆ NdisRegisterProtocol()

VOID EXPORT NdisRegisterProtocol ( OUT PNDIS_STATUS  Status,
OUT PNDIS_HANDLE  NdisProtocolHandle,
IN PNDIS_PROTOCOL_CHARACTERISTICS  ProtocolCharacteristics,
IN UINT  CharacteristicsLength 
)

Definition at line 1115 of file protocol.c.

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}
NTSTATUS RtlUpcaseUnicodeString(PUNICODE_STRING dst, PUNICODE_STRING src, BOOLEAN Alloc)
Definition: string_lib.cpp:46
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
_Out_ PNDIS_HANDLE _In_ PNDIS_PROTOCOL_CHARACTERISTICS _In_ UINT CharacteristicsLength
Definition: ndis.h:6136
#define NDIS_STATUS_BAD_VERSION
Definition: ndis.h:468
#define NDIS_STATUS_PENDING
Definition: ndis.h:347
struct _NDIS30_PROTOCOL_CHARACTERISTICS NDIS30_PROTOCOL_CHARACTERISTICS
#define NDIS_STATUS_BAD_CHARACTERISTICS
Definition: ndis.h:469
struct _NDIS50_PROTOCOL_CHARACTERISTICS NDIS50_PROTOCOL_CHARACTERISTICS
struct _NDIS40_PROTOCOL_CHARACTERISTICS NDIS40_PROTOCOL_CHARACTERISTICS
@ NetEventBindsComplete
Definition: netpnp.h:21
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

Referenced by DriverEntry(), and LANRegisterProtocol().

◆ NdisRequest()

VOID EXPORT NdisRequest ( OUT PNDIS_STATUS  Status,
IN NDIS_HANDLE  NdisBindingHandle,
IN PNDIS_REQUEST  NdisRequest 
)

Definition at line 1239 of file protocol.c.

1250{
1252}
_In_opt_ NDIS_HANDLE _In_opt_ NDIS_HANDLE _Inout_ PNDIS_REQUEST NdisRequest
Definition: ndis.h:1573

◆ NdisReset()

VOID EXPORT NdisReset ( OUT PNDIS_STATUS  Status,
IN NDIS_HANDLE  NdisBindingHandle 
)

Definition at line 1259 of file protocol.c.

1262{
1264}

◆ NdisSend()

VOID EXPORT NdisSend ( OUT PNDIS_STATUS  Status,
IN NDIS_HANDLE  NdisBindingHandle,
IN PNDIS_PACKET  Packet 
)

Definition at line 1272 of file protocol.c.

1283{
1285}
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1549

Referenced by LANTransmit(), and NduDispatchWrite().

◆ NdisSendPackets()

VOID EXPORT NdisSendPackets ( IN NDIS_HANDLE  NdisBindingHandle,
IN PPNDIS_PACKET  PacketArray,
IN UINT  NumberOfPackets 
)

Definition at line 1293 of file protocol.c.

1297{
1299}
_In_ PPNDIS_PACKET _In_ UINT NumberOfPackets
Definition: ndis.h:5121
_In_ PPNDIS_PACKET PacketArray
Definition: ndis.h:5120

◆ NdisTransferData()

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 at line 1307 of file protocol.c.

1326{
1328 MacReceiveContext,
1329 ByteOffset,
1330 BytesToTransfer,
1331 Packet,
1333}
IN PDCB IN PCCB IN VBO IN OUT PULONG OUT PDIRENT OUT PBCB OUT PVBO ByteOffset
Definition: fatprocs.h:731
_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

Referenced by NduReceive(), and ProtocolReceive().

◆ ProIndicatePacket()

NDIS_STATUS ProIndicatePacket ( PLOGICAL_ADAPTER  Adapter,
PNDIS_PACKET  Packet 
)

Definition at line 243 of file protocol.c.

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}
UINT CopyPacketToBuffer(PUCHAR DstData, PNDIS_PACKET SrcPacket, UINT SrcOffset, UINT Length)
Definition: buffer.c:172
VOID MiniIndicateData(PLOGICAL_ADAPTER Adapter, NDIS_HANDLE MacReceiveContext, PVOID HeaderBuffer, UINT HeaderBufferSize, PVOID LookaheadBuffer, UINT LookaheadBufferSize, UINT PacketSize)
Definition: miniport.c:175
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
FORCEINLINE ULONG KeGetCurrentProcessorNumber(VOID)
Definition: ke.h:341
ULONG MediumHeaderSize
Definition: miniport.h:95
unsigned char * PUCHAR
Definition: typedefs.h:53

Referenced by MiniportWorker(), and ProSend().

◆ ProRequest()

NDIS_STATUS NTAPI ProRequest ( IN NDIS_HANDLE  MacBindingHandle,
IN PNDIS_REQUEST  NdisRequest 
)

Definition at line 308 of file protocol.c.

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}
NDIS_STATUS MiniDoRequest(PLOGICAL_ADAPTER Adapter, PNDIS_REQUEST NdisRequest)
Definition: miniport.c:1107
VOID FASTCALL MiniQueueWorkItem(PLOGICAL_ADAPTER Adapter, NDIS_WORK_ITEM_TYPE WorkItemType, PVOID WorkItemContext, BOOLEAN Top)
Definition: miniport.c:982
BOOLEAN MiniIsBusy(PLOGICAL_ADAPTER Adapter, NDIS_WORK_ITEM_TYPE Type)
Definition: miniport.c:142
struct _NDIS_REQUEST_MAC_BLOCK * PNDIS_REQUEST_MAC_BLOCK
@ NdisWorkItemRequest
Definition: ndis.h:2294
PNDIS_OPEN_BLOCK Binding
Definition: protocol.h:34

Referenced by NdisOpenAdapter(), and NdisRequest().

◆ ProReset()

NDIS_STATUS NTAPI ProReset ( IN NDIS_HANDLE  MacBindingHandle)

Definition at line 349 of file protocol.c.

351{
352 PADAPTER_BINDING AdapterBinding = MacBindingHandle;
353
354 /* FIXME: Wait for all packets to be sent */
355
356 return MiniReset(AdapterBinding->Adapter);
357}
NDIS_STATUS MiniReset(PLOGICAL_ADAPTER Adapter)
Definition: miniport.c:902

Referenced by NdisOpenAdapter(), and NdisReset().

◆ ProSend()

NDIS_STATUS NTAPI ProSend ( IN NDIS_HANDLE  MacBindingHandle,
IN PNDIS_PACKET  Packet 
)

Definition at line 473 of file protocol.c.

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}
BOOLEAN MiniAdapterHasAddress(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
Definition: miniport.c:616
VOID NTAPI ScatterGatherSendPacket(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PSCATTER_GATHER_LIST ScatterGather, IN PVOID Context)
Definition: protocol.c:360
NDIS_STATUS ProIndicatePacket(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
Definition: protocol.c:243
NDIS_STATUS proSendPacketToMiniport(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
Definition: protocol.c:389
#define ULONG_PTR
Definition: config.h:101
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
@ NdisWorkItemSendLoopback
Definition: ndis.h:2300
MDL * PNDIS_BUFFER
Definition: ndis.h:343
#define NDIS_MAC_OPTION_NO_LOOPBACK
Definition: ndis.h:685
#define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
Definition: ke.h:174
PDEVICE_OBJECT PhysicalDeviceObject
Definition: ndis.h:2553
#define MmGetMdlVirtualAddress(_Mdl)

Referenced by NdisOpenAdapter(), and NdisSend().

◆ ProSendAndFreePnPEvent()

NDIS_STATUS ProSendAndFreePnPEvent ( PLOGICAL_ADAPTER  Adapter,
PNET_PNP_EVENT  PnPEvent,
PIRP  Irp 
)

Definition at line 66 of file protocol.c.

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}
IoMarkIrpPending(Irp)
PNP_EVENT_HANDLER PnPEventHandler
Definition: ndis.h:1899
ULONG_PTR NdisReserved[4]
Definition: netpnp.h:35
PVOID Buffer
Definition: netpnp.h:33
NDIS_PROTOCOL_CHARACTERISTICS Chars
Definition: protocol.h:13

Referenced by NdisIPnPCancelStopDevice(), NdisIPnPQueryStopDevice(), NdisIPwrQueryPower(), and NdisIPwrSetPower().

◆ ProSendPackets()

VOID NTAPI ProSendPackets ( IN NDIS_HANDLE  NdisBindingHandle,
IN PPNDIS_PACKET  PacketArray,
IN UINT  NumberOfPackets 
)

Definition at line 577 of file protocol.c.

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}
VOID NTAPI MiniSendComplete(IN NDIS_HANDLE MiniportAdapterHandle, IN PNDIS_PACKET Packet, IN NDIS_STATUS Status)
Definition: miniport.c:530
#define NDIS_ATTRIBUTE_DESERIALIZE
Definition: ndis.h:588
#define NDIS_GET_PACKET_STATUS(_Packet)
Definition: ndis.h:3436
NDIS_HANDLE MiniportAdapterContext
Definition: ndis.h:2510
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

Referenced by NdisIPnPStartDevice(), NdisOpenAdapter(), and NdisSendPackets().

◆ proSendPacketToMiniport()

NDIS_STATUS proSendPacketToMiniport ( PLOGICAL_ADAPTER  Adapter,
PNDIS_PACKET  Packet 
)

Definition at line 389 of file protocol.c.

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}
VOID MiniWorkItemComplete(PLOGICAL_ADAPTER Adapter, NDIS_WORK_ITEM_TYPE WorkItemType)
Definition: miniport.c:964
@ NdisWorkItemSend
Definition: ndis.h:2295

Referenced by ProSend(), and ScatterGatherSendPacket().

◆ ProSetupPnPEvent()

PNET_PNP_EVENT ProSetupPnPEvent ( NET_PNP_EVENT_CODE  EventCode,
PVOID  EventBuffer,
ULONG  EventBufferLength 
)

Definition at line 30 of file protocol.c.

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}
_In_ NDIS_STATUS EventCode
Definition: ndis.h:4751
ULONG BufferLength
Definition: netpnp.h:34
NET_PNP_EVENT_CODE NetEvent
Definition: netpnp.h:32

Referenced by NdisIPnPCancelStopDevice(), NdisIPnPQueryStopDevice(), NdisIPwrQueryPower(), NdisIPwrSetPower(), and NdisRegisterProtocol().

◆ ProTransferData()

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 at line 639 of file protocol.c.

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}
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

Referenced by NdisOpenAdapter(), and NdisTransferData().

◆ ScatterGatherSendPacket()

VOID NTAPI ScatterGatherSendPacket ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PSCATTER_GATHER_LIST  ScatterGather,
IN PVOID  Context 
)

Definition at line 360 of file protocol.c.

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}
#define NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, InfoType)
Definition: ndis.h:1351
@ ScatterGatherListPacketInfo
Definition: ndis.h:1183
PLOGICAL_ADAPTER Adapter
Definition: protocol.c:25
PNDIS_PACKET Packet
Definition: protocol.c:26
_In_ struct _IRP _In_ struct _SCATTER_GATHER_LIST * ScatterGather
Definition: iotypes.h:2375

Referenced by ProSend().

Variable Documentation

◆ ProtocolListHead

LIST_ENTRY ProtocolListHead

◆ ProtocolListLock