#include "precomp.h"
+/* Define this to bugcheck on double complete */
+/* #define BREAK_ON_DOUBLE_COMPLETE */
+
+UINT TransferDataCalled = 0;
+UINT TransferDataCompleteCalled = 0;
+UINT LanReceiveWorkerCalled = 0;
+BOOLEAN LanReceiveWorkerBusy = FALSE;
+
+#define CCS_ROOT L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet"
+#define TCPIP_GUID L"{4D36E972-E325-11CE-BFC1-08002BE10318}"
+
+#define NGFP(_Packet) \
+ { \
+ PVOID _Header; \
+ ULONG _ContigSize, _TotalSize; \
+ PNDIS_BUFFER _NdisBuffer; \
+ \
+ TI_DbgPrint(MID_TRACE,("Checking Packet %x\n", _Packet)); \
+ NdisGetFirstBufferFromPacket(_Packet, \
+ &_NdisBuffer, \
+ &_Header, \
+ &_ContigSize, \
+ &_TotalSize); \
+ TI_DbgPrint(MID_TRACE,("NdisBuffer: %x\n", _NdisBuffer)); \
+ TI_DbgPrint(MID_TRACE,("Header : %x\n", _Header)); \
+ TI_DbgPrint(MID_TRACE,("ContigSize: %x\n", _ContigSize)); \
+ TI_DbgPrint(MID_TRACE,("TotalSize : %x\n", _TotalSize)); \
+ }
+
typedef struct _LAN_WQ_ITEM {
LIST_ENTRY ListEntry;
PNDIS_PACKET Packet;
LIST_ENTRY AdapterListHead;
KSPIN_LOCK AdapterListLock;
-/* Work around being called back into afd at Dpc level */
-KSPIN_LOCK LanWorkLock;
-LIST_ENTRY LanWorkList;
-WORK_QUEUE_ITEM LanWorkItem;
+/* Double complete protection */
+KSPIN_LOCK LanSendCompleteLock;
+LIST_ENTRY LanSendCompleteList;
+
+VOID LanChainCompletion( PLAN_ADAPTER Adapter, PNDIS_PACKET NdisPacket ) {
+ PLAN_WQ_ITEM PendingCompletion =
+ ExAllocatePool( NonPagedPool, sizeof(LAN_WQ_ITEM) );
+
+ if( !PendingCompletion ) return;
+
+ PendingCompletion->Packet = NdisPacket;
+ PendingCompletion->Adapter = Adapter;
+
+ ExInterlockedInsertTailList( &LanSendCompleteList,
+ &PendingCompletion->ListEntry,
+ &LanSendCompleteLock );
+}
+
+BOOLEAN LanShouldComplete( PLAN_ADAPTER Adapter, PNDIS_PACKET NdisPacket ) {
+ PLIST_ENTRY ListEntry;
+ PLAN_WQ_ITEM CompleteEntry;
+ KIRQL OldIrql;
+
+ KeAcquireSpinLock( &LanSendCompleteLock, &OldIrql );
+ for( ListEntry = LanSendCompleteList.Flink;
+ ListEntry != &LanSendCompleteList;
+ ListEntry = ListEntry->Flink ) {
+ CompleteEntry = CONTAINING_RECORD(ListEntry, LAN_WQ_ITEM, ListEntry);
+
+ if( CompleteEntry->Adapter == Adapter &&
+ CompleteEntry->Packet == NdisPacket ) {
+ RemoveEntryList( ListEntry );
+ KeReleaseSpinLock( &LanSendCompleteLock, OldIrql );
+ ExFreePool( CompleteEntry );
+ return TRUE;
+ }
+ }
+ KeReleaseSpinLock( &LanSendCompleteLock, OldIrql );
+
+ DbgPrint("NDIS completed the same send packet twice "
+ "(Adapter %x Packet %x)!!\n", Adapter, NdisPacket);
+#ifdef BREAK_ON_DOUBLE_COMPLETE
+ KeBugCheck(0);
+#endif
+
+ return FALSE;
+}
NDIS_STATUS NDISCall(
PLAN_ADAPTER Adapter,
}
+NTSTATUS TcpipLanGetDwordOid
+( PIP_INTERFACE Interface,
+ NDIS_OID Oid,
+ PDWORD Result ) {
+ /* Get maximum frame size */
+ if( Interface->Context ) {
+ return NDISCall((PLAN_ADAPTER)Interface->Context,
+ NdisRequestQueryInformation,
+ Oid,
+ Result,
+ sizeof(DWORD));
+ } else switch( Oid ) { /* Loopback Case */
+ case OID_GEN_HARDWARE_STATUS:
+ *Result = NdisHardwareStatusReady;
+ return STATUS_SUCCESS;
+
+ default:
+ return STATUS_INVALID_PARAMETER;
+ }
+}
+
+
VOID STDCALL ProtocolOpenAdapterComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status,
*/
{
TI_DbgPrint(DEBUG_DATALINK, ("Calling completion routine\n"));
- ASSERT_KM_POINTER(Packet);
- ASSERT_KM_POINTER(PC(Packet));
- ASSERT_KM_POINTER(PC(Packet)->DLComplete);
- (*PC(Packet)->DLComplete)( PC(Packet)->Context, Packet, Status);
- TI_DbgPrint(DEBUG_DATALINK, ("Finished\n"));
+ if( LanShouldComplete( (PLAN_ADAPTER)BindingContext, Packet ) ) {
+ ASSERT_KM_POINTER(Packet);
+ ASSERT_KM_POINTER(PC(Packet));
+ ASSERT_KM_POINTER(PC(Packet)->DLComplete);
+ (*PC(Packet)->DLComplete)( PC(Packet)->Context, Packet, Status);
+ TI_DbgPrint(DEBUG_DATALINK, ("Finished\n"));
+ }
}
-VOID STDCALL LanReceiveWorker( PVOID Context ) {
+VOID LanReceiveWorker( PVOID Context ) {
UINT PacketType;
- PLIST_ENTRY ListEntry;
- PLAN_WQ_ITEM WorkItem;
+ PLAN_WQ_ITEM WorkItem = (PLAN_WQ_ITEM)Context;
PNDIS_PACKET Packet;
PLAN_ADAPTER Adapter;
UINT BytesTransferred;
PNDIS_BUFFER NdisBuffer;
IP_PACKET IPPacket;
-
TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
- while( (ListEntry =
- ExInterlockedRemoveHeadList( &LanWorkList, &LanWorkLock )) ) {
- WorkItem = CONTAINING_RECORD(ListEntry, LAN_WQ_ITEM, ListEntry);
-
- Packet = WorkItem->Packet;
- Adapter = WorkItem->Adapter;
- BytesTransferred = WorkItem->BytesTransferred;
+ Packet = WorkItem->Packet;
+ Adapter = WorkItem->Adapter;
+ BytesTransferred = WorkItem->BytesTransferred;
+
+ IPPacket.NdisPacket = Packet;
+
+ NdisGetFirstBufferFromPacket(Packet,
+ &NdisBuffer,
+ &IPPacket.Header,
+ &IPPacket.ContigSize,
+ &IPPacket.TotalSize);
+
+ IPPacket.ContigSize = IPPacket.TotalSize = BytesTransferred;
+ /* Determine which upper layer protocol that should receive
+ this packet and pass it to the correct receive handler */
+
+ TI_DbgPrint(MID_TRACE,
+ ("ContigSize: %d, TotalSize: %d, BytesTransferred: %d\n",
+ IPPacket.ContigSize, IPPacket.TotalSize,
+ BytesTransferred));
+
+ PacketType = PC(IPPacket.NdisPacket)->PacketType;
+ IPPacket.Position = 0;
+
+ TI_DbgPrint
+ (DEBUG_DATALINK,
+ ("Ether Type = %x ContigSize = %d Total = %d\n",
+ PacketType, IPPacket.ContigSize, IPPacket.TotalSize));
+
+ switch (PacketType) {
+ case ETYPE_IPv4:
+ case ETYPE_IPv6:
+ TI_DbgPrint(MID_TRACE,("Received IP Packet\n"));
+ IPReceive(Adapter->Context, &IPPacket);
+ break;
+ case ETYPE_ARP:
+ TI_DbgPrint(MID_TRACE,("Received ARP Packet\n"));
+ ARPReceive(Adapter->Context, &IPPacket);
+ default:
+ break;
+ }
+
+ FreeNdisPacket( Packet );
+}
- ExFreePool( WorkItem );
+VOID LanSubmitReceiveWork(
+ NDIS_HANDLE BindingContext,
+ PNDIS_PACKET Packet,
+ NDIS_STATUS Status,
+ UINT BytesTransferred) {
+ LAN_WQ_ITEM WQItem;
+ PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
+ PVOID LanWorkItem;
- IPPacket.NdisPacket = Packet;
-
- NdisGetFirstBufferFromPacket(Packet,
- &NdisBuffer,
- &IPPacket.Header,
- &IPPacket.ContigSize,
- &IPPacket.TotalSize);
-
- IPPacket.ContigSize = IPPacket.TotalSize = BytesTransferred;
- /* Determine which upper layer protocol that should receive
- this packet and pass it to the correct receive handler */
-
- TI_DbgPrint(MID_TRACE,
- ("ContigSize: %d, TotalSize: %d, BytesTransferred: %d\n",
- IPPacket.ContigSize, IPPacket.TotalSize,
- BytesTransferred));
-
- /*OskitDumpBuffer( IPPacket.Header, IPPacket.TotalSize );*/
-
- PacketType = PC(IPPacket.NdisPacket)->PacketType;
- IPPacket.Position = 0;
-
- TI_DbgPrint
- (DEBUG_DATALINK,
- ("Ether Type = %x ContigSize = %d Total = %d\n",
- PacketType, IPPacket.ContigSize, IPPacket.TotalSize));
-
- switch (PacketType) {
- case ETYPE_IPv4:
- case ETYPE_IPv6:
- TI_DbgPrint(MID_TRACE,("Received IP Packet\n"));
- IPReceive(Adapter->Context, &IPPacket);
- break;
- case ETYPE_ARP:
- TI_DbgPrint(MID_TRACE,("Received ARP Packet\n"));
- ARPReceive(Adapter->Context, &IPPacket);
- default:
- break;
- }
+ TI_DbgPrint(DEBUG_DATALINK,("called\n"));
- FreeNdisPacket( Packet );
- }
+ WQItem.Packet = Packet;
+ WQItem.Adapter = Adapter;
+ WQItem.BytesTransferred = BytesTransferred;
+
+ if( !ChewCreate
+ ( &LanWorkItem, sizeof(LAN_WQ_ITEM), LanReceiveWorker, &WQItem ) )
+ ASSERT(0);
}
VOID STDCALL ProtocolTransferDataComplete(
* type and pass it to the correct receive handler
*/
{
- BOOLEAN WorkStart;
- PLAN_WQ_ITEM WQItem;
- PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+
+ TI_DbgPrint(DEBUG_DATALINK,("called\n"));
+
+ TransferDataCompleteCalled++;
+ ASSERT(TransferDataCompleteCalled <= TransferDataCalled);
if( Status != NDIS_STATUS_SUCCESS ) return;
- WQItem = ExAllocatePool( NonPagedPool, sizeof(LAN_WQ_ITEM) );
- if( !WQItem ) return;
-
- TcpipAcquireSpinLockAtDpcLevel( &LanWorkLock );
- WorkStart = IsListEmpty( &LanWorkList );
- WQItem->Packet = Packet;
- WQItem->Adapter = Adapter;
- WQItem->BytesTransferred = BytesTransferred;
- InsertTailList( &LanWorkList, &WQItem->ListEntry );
- if( WorkStart )
- ExQueueWorkItem( &LanWorkItem, CriticalWorkQueue );
- TcpipReleaseSpinLockFromDpcLevel( &LanWorkLock );
+
+ LanSubmitReceiveWork( BindingContext, Packet, Status, BytesTransferred );
}
NDIS_STATUS STDCALL ProtocolReceive(
/* Get a transfer data packet */
- TI_DbgPrint(DEBUG_DATALINK, ("Adapter: %x (MTU %d)\n",
+ TI_DbgPrint(DEBUG_DATALINK, ("Adapter: %x (MTU %d)\n",
Adapter, Adapter->MTU));
NdisStatus = AllocatePacketWithBuffer( &NdisPacket, NULL,
IPPacket.NdisPacket = NdisPacket;
IPPacket.Position = 0;
+ TransferDataCalled++;
+
if (LookaheadBufferSize == PacketSize)
{
/* Optimized code path for packets that are fully contained in
ASSERT(PacketSize <= Adapter->MTU);
NdisTransferData(&NdisStatus, Adapter->NdisHandle,
- MacReceiveContext, 0, PacketSize,
+ MacReceiveContext, 0, PacketSize,
NdisPacket, &BytesTransferred);
}
else
* SystemSpecific2: Unused & must not be touched
*/
{
- /* XXX confirm that this is still true, or re-word the following comment */
- /* we get to ignore BindContext because we will never pend an operation with NDIS */
- TI_DbgPrint(DEBUG_DATALINK, ("Called with registry path %wZ for %wZ\n", SystemSpecific1, DeviceName));
- *Status = LANRegisterAdapter(DeviceName, SystemSpecific1);
+ /* XXX confirm that this is still true, or re-word the following comment */
+ /* we get to ignore BindContext because we will never pend an operation with NDIS */
+ TI_DbgPrint(DEBUG_DATALINK, ("Called with registry path %wZ for %wZ\n", SystemSpecific1, DeviceName));
+ *Status = LANRegisterAdapter(DeviceName, SystemSpecific1);
}
KIRQL OldIrql;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)Context;
- TI_DbgPrint(DEBUG_DATALINK,
+ TI_DbgPrint(DEBUG_DATALINK,
("Called( NdisPacket %x, Offset %d, Adapter %x )\n",
NdisPacket, Offset, Adapter));
Adapter->HWAddress[4] & 0xff,
Adapter->HWAddress[5] & 0xff));
- /* XXX arty -- Handled adjustment in a saner way than before ...
+ /* XXX arty -- Handled adjustment in a saner way than before ...
* not needed immediately */
GetDataPtr( NdisPacket, 0, &Data, &Size );
+ LanChainCompletion( Adapter, NdisPacket );
+
if (Adapter->State == LAN_STATE_STARTED) {
switch (Adapter->Media) {
case NdisMedium802_3:
RtlCopyMemory(EHeader->SrcAddr, Adapter->HWAddress, IEEE_802_ADDR_LENGTH);
switch (Type) {
- case LAN_PROTO_IPv4:
- EHeader->EType = ETYPE_IPv4;
- break;
- case LAN_PROTO_ARP:
- EHeader->EType = ETYPE_ARP;
- break;
- case LAN_PROTO_IPv6:
- EHeader->EType = ETYPE_IPv6;
- break;
- default:
+ case LAN_PROTO_IPv4:
+ EHeader->EType = ETYPE_IPv4;
+ break;
+ case LAN_PROTO_ARP:
+ EHeader->EType = ETYPE_ARP;
+ break;
+ case LAN_PROTO_IPv6:
+ EHeader->EType = ETYPE_IPv6;
+ break;
+ default:
#ifdef DBG
- /* Should not happen */
- TI_DbgPrint(MIN_TRACE, ("Unknown LAN protocol.\n"));
+ /* Should not happen */
+ TI_DbgPrint(MIN_TRACE, ("Unknown LAN protocol.\n"));
- ProtocolSendComplete((NDIS_HANDLE)Context,
- NdisPacket,
- NDIS_STATUS_FAILURE);
+ ProtocolSendComplete((NDIS_HANDLE)Context,
+ NdisPacket,
+ NDIS_STATUS_FAILURE);
#endif
- return;
+ return;
}
break;
TI_DbgPrint( MID_TRACE, ("LinkAddress: %x\n", LinkAddress));
if( LinkAddress ) {
TI_DbgPrint
- ( MID_TRACE,
- ("Link Address [%02x %02x %02x %02x %02x %02x]\n",
+ ( MID_TRACE,
+ ("Link Address [%02x %02x %02x %02x %02x %02x]\n",
((PCHAR)LinkAddress)[0] & 0xff,
((PCHAR)LinkAddress)[1] & 0xff,
((PCHAR)LinkAddress)[2] & 0xff,
((PCHAR)LinkAddress)[5] & 0xff));
}
- /*OskitDumpBuffer( Data, Size );*/
-
TcpipAcquireSpinLock( &Adapter->Lock, &OldIrql );
TI_DbgPrint(MID_TRACE, ("NdisSend\n"));
NdisSend(&NdisStatus, Adapter->NdisHandle, NdisPacket);
- TI_DbgPrint(MID_TRACE, ("NdisSend Done\n"));
+ TI_DbgPrint(MID_TRACE, ("NdisSend %s\n",
+ NdisStatus == NDIS_STATUS_PENDING ?
+ "Pending" : "Complete"));
TcpipReleaseSpinLock( &Adapter->Lock, OldIrql );
+ /* I had a talk with vizzini: these really ought to be here.
+ * we're supposed to see these completed by ndis *only* when
+ * status_pending is returned. Note that this is different from
+ * the situation with IRPs. */
if (NdisStatus != NDIS_STATUS_PENDING)
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NdisStatus);
} else {
}
}
-static NTSTATUS
+static NTSTATUS
OpenRegistryKey( PNDIS_STRING RegistryPath, PHANDLE RegHandle ) {
OBJECT_ATTRIBUTES Attributes;
NTSTATUS Status;
-
+
InitializeObjectAttributes(&Attributes, RegistryPath, OBJ_CASE_INSENSITIVE, 0, 0);
- Status = ZwOpenKey(RegHandle, GENERIC_READ, &Attributes);
+ Status = ZwOpenKey(RegHandle, KEY_ALL_ACCESS, &Attributes);
return Status;
}
-static NTSTATUS ReadIPAddressFromRegistry( HANDLE RegHandle,
- PWCHAR RegistryValue,
- PIP_ADDRESS *Address ) {
+static NTSTATUS ReadStringFromRegistry( HANDLE RegHandle,
+ PWCHAR RegistryValue,
+ PUNICODE_STRING String ) {
UNICODE_STRING ValueName;
- UNICODE_STRING UnicodeAddress;
+ UNICODE_STRING UnicodeString;
NTSTATUS Status;
ULONG ResultLength;
UCHAR buf[1024];
PKEY_VALUE_PARTIAL_INFORMATION Information = (PKEY_VALUE_PARTIAL_INFORMATION)buf;
- ANSI_STRING AnsiAddress;
- ULONG AnsiLen;
RtlInitUnicodeString(&ValueName, RegistryValue);
- Status =
- ZwQueryValueKey(RegHandle,
- &ValueName,
- KeyValuePartialInformation,
- Information,
- sizeof(buf),
+ Status =
+ ZwQueryValueKey(RegHandle,
+ &ValueName,
+ KeyValuePartialInformation,
+ Information,
+ sizeof(buf),
&ResultLength);
if (!NT_SUCCESS(Status))
return Status;
/* IP address is stored as a REG_MULTI_SZ - we only pay attention to the first one though */
TI_DbgPrint(MIN_TRACE, ("Information DataLength: 0x%x\n", Information->DataLength));
-
- UnicodeAddress.Buffer = (PWCHAR)&Information->Data;
- UnicodeAddress.Length = Information->DataLength;
- UnicodeAddress.MaximumLength = Information->DataLength;
-
- AnsiLen = RtlUnicodeStringToAnsiSize(&UnicodeAddress);
- if(!AnsiLen)
- return STATUS_NO_MEMORY;
-
- AnsiAddress.Buffer = exAllocatePoolWithTag(PagedPool, AnsiLen, 0x01020304);
- if(!AnsiAddress.Buffer)
- return STATUS_NO_MEMORY;
- AnsiAddress.Length = AnsiLen;
- AnsiAddress.MaximumLength = AnsiLen;
-
- Status = RtlUnicodeStringToAnsiString(&AnsiAddress, &UnicodeAddress, FALSE);
- if (!NT_SUCCESS(Status)) {
- exFreePool(AnsiAddress.Buffer);
- return STATUS_UNSUCCESSFUL;
+ UnicodeString.Buffer = (PWCHAR)&Information->Data;
+ UnicodeString.Length = Information->DataLength - sizeof(WCHAR);
+ UnicodeString.MaximumLength = Information->DataLength;
+
+ String->Buffer =
+ (PWCHAR)exAllocatePool( NonPagedPool,
+ UnicodeString.MaximumLength + sizeof(WCHAR) );
+
+ if( !String->Buffer ) return STATUS_NO_MEMORY;
+
+ String->MaximumLength = UnicodeString.MaximumLength;
+ RtlCopyUnicodeString( String, &UnicodeString );
+
+ return STATUS_SUCCESS;
+}
+
+/*
+ * Utility to copy and append two unicode strings.
+ *
+ * IN OUT PUNICODE_STRING ResultFirst -> First string and result
+ * IN PUNICODE_STRING Second -> Second string to append
+ * IN BOOL Deallocate -> TRUE: Deallocate First string before
+ * overwriting.
+ *
+ * Returns NTSTATUS.
+ */
+
+NTSTATUS NTAPI AppendUnicodeString(PUNICODE_STRING ResultFirst,
+ PUNICODE_STRING Second,
+ BOOL Deallocate) {
+ NTSTATUS Status;
+ UNICODE_STRING Ustr = *ResultFirst;
+ PWSTR new_string = ExAllocatePoolWithTag
+ (PagedPool,
+ (ResultFirst->Length + Second->Length + sizeof(WCHAR)), TAG_STRING);
+ if( !new_string ) {
+ return STATUS_NO_MEMORY;
}
-
- AnsiAddress.Buffer[AnsiAddress.Length] = 0;
- *Address = AddrBuildIPv4(inet_addr(AnsiAddress.Buffer));
- if (!Address) {
- exFreePool(AnsiAddress.Buffer);
- return STATUS_UNSUCCESSFUL;
+ memcpy( new_string, ResultFirst->Buffer, ResultFirst->Length );
+ memcpy( new_string + ResultFirst->Length / sizeof(WCHAR),
+ Second->Buffer, Second->Length );
+ if( Deallocate ) RtlFreeUnicodeString(ResultFirst);
+ ResultFirst->Length = Ustr.Length + Second->Length;
+ ResultFirst->MaximumLength = ResultFirst->Length;
+ new_string[ResultFirst->Length / sizeof(WCHAR)] = 0;
+ Status = RtlCreateUnicodeString(ResultFirst,new_string) ?
+ STATUS_SUCCESS : STATUS_NO_MEMORY;
+ ExFreePool(new_string);
+ return Status;
+}
+
+static NTSTATUS CheckForDeviceDesc( PUNICODE_STRING EnumKeyName,
+ PUNICODE_STRING TargetKeyName,
+ PUNICODE_STRING Name,
+ PUNICODE_STRING DeviceDesc ) {
+ UNICODE_STRING RootDevice = { 0 }, LinkageKeyName = { 0 };
+ UNICODE_STRING DescKeyName = { 0 }, Linkage = { 0 };
+ UNICODE_STRING BackSlash = { 0 };
+ HANDLE DescKey = NULL, LinkageKey = NULL;
+ NTSTATUS Status;
+
+ TI_DbgPrint(DEBUG_DATALINK,("EnumKeyName %wZ\n", EnumKeyName));
+
+ RtlInitUnicodeString(&BackSlash, L"\\");
+ RtlInitUnicodeString(&Linkage, L"\\Linkage");
+
+ RtlInitUnicodeString(&DescKeyName, L"");
+ AppendUnicodeString( &DescKeyName, EnumKeyName, FALSE );
+ AppendUnicodeString( &DescKeyName, &BackSlash, TRUE );
+ AppendUnicodeString( &DescKeyName, TargetKeyName, TRUE );
+
+ RtlInitUnicodeString(&LinkageKeyName, L"");
+ AppendUnicodeString( &LinkageKeyName, &DescKeyName, FALSE );
+ AppendUnicodeString( &LinkageKeyName, &Linkage, TRUE );
+
+ Status = OpenRegistryKey( &LinkageKeyName, &LinkageKey );
+ if( !NT_SUCCESS(Status) ) goto cleanup;
+
+ Status = ReadStringFromRegistry( LinkageKey, L"RootDevice", &RootDevice );
+ if( !NT_SUCCESS(Status) ) goto cleanup;
+
+ if( RtlCompareUnicodeString( &RootDevice, Name, TRUE ) == 0 ) {
+ Status = OpenRegistryKey( &DescKeyName, &DescKey );
+ if( !NT_SUCCESS(Status) ) goto cleanup;
+
+ Status = ReadStringFromRegistry( DescKey, L"DriverDesc", DeviceDesc );
+ if( !NT_SUCCESS(Status) ) goto cleanup;
+
+ TI_DbgPrint(DEBUG_DATALINK,("ADAPTER DESC: %wZ\n", DeviceDesc));
+ } else Status = STATUS_UNSUCCESSFUL;
+
+cleanup:
+ RtlFreeUnicodeString( &RootDevice );
+ RtlFreeUnicodeString( &LinkageKeyName );
+ RtlFreeUnicodeString( &DescKeyName );
+ if( LinkageKey ) NtClose( LinkageKey );
+ if( DescKey ) NtClose( DescKey );
+
+ TI_DbgPrint(DEBUG_DATALINK,("Returning %x\n", Status));
+
+ return Status;
+}
+
+static NTSTATUS FindDeviceDescForAdapter( PUNICODE_STRING Name,
+ PUNICODE_STRING DeviceDesc ) {
+ UNICODE_STRING EnumKeyName, TargetKeyName;
+ HANDLE EnumKey;
+ NTSTATUS Status;
+ ULONG i;
+ KEY_BASIC_INFORMATION *Kbio =
+ ExAllocatePool(NonPagedPool, sizeof(KEY_BASIC_INFORMATION));
+ ULONG KbioLength = sizeof(KEY_BASIC_INFORMATION), ResultLength;
+
+ RtlInitUnicodeString
+ (&EnumKeyName, CCS_ROOT L"\\Control\\Class\\" TCPIP_GUID);
+
+ Status = OpenRegistryKey( &EnumKeyName, &EnumKey );
+
+ if( !NT_SUCCESS(Status) )
+ TI_DbgPrint(DEBUG_DATALINK,("Couldn't open Enum key %wZ: %x\n",
+ &EnumKeyName, Status));
+
+ for( i = 0; NT_SUCCESS(Status); i++ ) {
+ Status = ZwEnumerateKey( EnumKey, i, KeyBasicInformation,
+ Kbio, KbioLength, &ResultLength );
+
+ if( Status == STATUS_BUFFER_TOO_SMALL ) {
+ ExFreePool( Kbio );
+ KbioLength = ResultLength;
+ Kbio = ExAllocatePool( NonPagedPool, KbioLength );
+
+ Status = ZwEnumerateKey( EnumKey, i, KeyBasicInformation,
+ Kbio, KbioLength, &ResultLength );
+
+ TI_DbgPrint(DEBUG_DATALINK,("Couldn't enum key child %d\n", i));
+ return Status;
+ }
+
+ if( NT_SUCCESS(Status) ) {
+ TargetKeyName.Length = TargetKeyName.MaximumLength =
+ Kbio->NameLength;
+ TargetKeyName.Buffer = Kbio->Name;
+
+ Status = CheckForDeviceDesc
+ ( &EnumKeyName, &TargetKeyName, Name, DeviceDesc );
+ if( NT_SUCCESS(Status) ) {
+ NtClose( EnumKey );
+ return Status;
+ } else Status = STATUS_SUCCESS;
+ }
}
- return *Address ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
+ RtlInitUnicodeString( DeviceDesc, L"" );
+ AppendUnicodeString( DeviceDesc, &TargetKeyName, FALSE );
+ NtClose( EnumKey );
+ return STATUS_UNSUCCESSFUL;
+}
+
+VOID GetName( PUNICODE_STRING RegistryKey,
+ PUNICODE_STRING OutName ) {
+ PWCHAR Ptr;
+ UNICODE_STRING PartialRegistryKey;
+
+ PartialRegistryKey.Buffer =
+ RegistryKey->Buffer + wcslen(CCS_ROOT L"\\Services\\");
+ Ptr = PartialRegistryKey.Buffer;
+
+ while( *Ptr != L'\\' &&
+ ((PCHAR)Ptr) < ((PCHAR)RegistryKey->Buffer) + RegistryKey->Length )
+ Ptr++;
+
+ PartialRegistryKey.Length = PartialRegistryKey.MaximumLength =
+ (Ptr - PartialRegistryKey.Buffer) * sizeof(WCHAR);
+
+ RtlInitUnicodeString( OutName, L"" );
+ AppendUnicodeString( OutName, &PartialRegistryKey, FALSE );
}
VOID BindAdapter(
*/
{
PIP_INTERFACE IF;
- PIP_ADDRESS Address = 0;
- PIP_ADDRESS Netmask = 0;
NDIS_STATUS NdisStatus;
LLIP_BIND_INFO BindInfo;
+ IP_ADDRESS DefaultMask = { 0 };
ULONG Lookahead = LOOKAHEAD_SIZE;
NTSTATUS Status;
HANDLE RegHandle = 0;
&Lookahead,
sizeof(ULONG));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
- TI_DbgPrint(MID_TRACE, ("Could not set lookahead buffer size (0x%X).\n", NdisStatus));
+ TI_DbgPrint(DEBUG_DATALINK, ("Could not set lookahead buffer size (0x%X).\n", NdisStatus));
return;
}
return;
}
- /*
- * Query per-adapter configuration from the registry
+ /*
+ * Query per-adapter configuration from the registry
* In case anyone is curious: there *is* an Ndis configuration api
* for this sort of thing, but it doesn't really support things like
* REG_MULTI_SZ very well, and there is a note in the DDK that says that
* protocol drivers developed for win2k and above just use the native
* services (ZwOpenKey, etc).
*/
-
+
+ GetName( RegistryPath, &IF->Name );
+
Status = OpenRegistryKey( RegistryPath, &RegHandle );
-
- if(NT_SUCCESS(Status))
- Status = ReadIPAddressFromRegistry( RegHandle, L"IPAddress",
- &Address );
- if(NT_SUCCESS(Status))
- Status = ReadIPAddressFromRegistry( RegHandle, L"SubnetMask",
- &Netmask );
-
- if(!NT_SUCCESS(Status) || !Address || !Netmask)
- {
- TI_DbgPrint(MIN_TRACE, ("Unable to open protocol-specific registry key: 0x%x\n", Status));
-
- /* XXX how do we proceed? No ip address, no parameters... do we guess? */
- if(RegHandle)
- ZwClose(RegHandle);
- IPDestroyInterface(IF);
- return;
- }
-
- TI_DbgPrint
- (MID_TRACE,
- ("--> Our IP address on this interface: '%s'\n",
- A2S(Address)));
-
- TI_DbgPrint
- (MID_TRACE,
- ("--> Our net mask on this interface: '%s'\n",
- A2S(Netmask)));
- /* Create a net table entry for this interface */
- if (!IPCreateNTE(IF, Address, AddrCountPrefixBits(Netmask))) {
- TI_DbgPrint(MIN_TRACE, ("IPCreateNTE() failed.\n"));
- IPDestroyInterface(IF);
- return;
+ if(NT_SUCCESS(Status)) {
+ Status = FindDeviceDescForAdapter( &IF->Name, &IF->Description );
+ TI_DbgPrint(DEBUG_DATALINK,("Adapter Description: %wZ\n",
+ &IF->Description));
}
+ DefaultMask.Type = IP_ADDRESS_V4;
+
+ IF->Unicast = DefaultMask;
+ IF->Netmask = DefaultMask;
+
+ IF->Broadcast.Type = IP_ADDRESS_V4;
+ IF->Broadcast.Address.IPv4Address =
+ IF->Unicast.Address.IPv4Address |
+ ~IF->Netmask.Address.IPv4Address;
+
+ TI_DbgPrint(DEBUG_DATALINK,("BCAST(IF) %s\n", A2S(&IF->Broadcast)));
+
+ /* Get maximum link speed */
+ NdisStatus = NDISCall(Adapter,
+ NdisRequestQueryInformation,
+ OID_GEN_LINK_SPEED,
+ &IF->Speed,
+ sizeof(UINT));
+
+ if( !NT_SUCCESS(NdisStatus) )
+ IF->Speed = IP_DEFAULT_LINK_SPEED;
+
/* Register interface with IP layer */
IPRegisterInterface(IF);
OID_GEN_CURRENT_PACKET_FILTER,
&Adapter->PacketFilter,
sizeof(UINT));
+
if (NdisStatus != NDIS_STATUS_SUCCESS) {
- TI_DbgPrint(MID_TRACE, ("Could not set packet filter (0x%X).\n", NdisStatus));
+ TI_DbgPrint(DEBUG_DATALINK, ("Could not set packet filter (0x%X).\n", NdisStatus));
IPDestroyInterface(IF);
return;
}
NDIS_STATUS LANRegisterAdapter(
PNDIS_STRING AdapterName,
- PNDIS_STRING RegistryPath)
+ PNDIS_STRING RegistryPath)
/*
* FUNCTION: Registers protocol with an NDIS adapter
* ARGUMENTS:
IF->HeaderSize = sizeof(ETH_HEADER);
IF->MinFrameSize = 60;
AddressOID = OID_802_3_CURRENT_ADDRESS;
- IF->PacketFilter =
+ IF->PacketFilter =
NDIS_PACKET_TYPE_BROADCAST |
NDIS_PACKET_TYPE_DIRECTED |
NDIS_PACKET_TYPE_MULTICAST;
NdisCloseAdapter(&NdisStatus, NdisHandle);
if (NdisStatus == NDIS_STATUS_PENDING) {
TcpipWaitForSingleObject(&Adapter->Event,
- UserRequest,
- KernelMode,
- FALSE,
- NULL);
+ UserRequest,
+ KernelMode,
+ FALSE,
+ NULL);
NdisStatus = Adapter->NdisStatus;
}
} else
ProtChars.StatusCompleteHandler = ProtocolStatusComplete;
ProtChars.BindAdapterHandler = ProtocolBindAdapter;
- /* Try to register protocol */
+ /* Try to register protocol */
NdisRegisterProtocol(&NdisStatus,
&NdisProtocolHandle,
&ProtChars,
sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
if (NdisStatus != NDIS_STATUS_SUCCESS)
- {
- TI_DbgPrint(MID_TRACE, ("NdisRegisterProtocol failed, status 0x%x\n", NdisStatus));
+ {
+ TI_DbgPrint(DEBUG_DATALINK, ("NdisRegisterProtocol failed, status 0x%x\n", NdisStatus));
return (NTSTATUS)NdisStatus;
- }
+ }
ProtocolRegistered = TRUE;
CurrentEntry = AdapterListHead.Flink;
while (CurrentEntry != &AdapterListHead) {
NextEntry = CurrentEntry->Flink;
- Current = CONTAINING_RECORD(CurrentEntry, LAN_ADAPTER, ListEntry);
+ Current = CONTAINING_RECORD(CurrentEntry, LAN_ADAPTER, ListEntry);
/* Unregister it */
LANUnregisterAdapter(Current);
CurrentEntry = NextEntry;
}
VOID LANStartup() {
- InitializeListHead( &LanWorkList );
- ExInitializeWorkItem( &LanWorkItem, LanReceiveWorker, NULL );
+ InitializeListHead( &LanSendCompleteList );
+ KeInitializeSpinLock( &LanSendCompleteLock );
}
VOID LANShutdown() {
PLAN_WQ_ITEM WorkItem;
PLIST_ENTRY ListEntry;
- TcpipAcquireSpinLock( &LanWorkLock, &OldIrql );
- while( !IsListEmpty( &LanWorkList ) ) {
- ListEntry = RemoveHeadList( &LanWorkList );
+ KeAcquireSpinLock( &LanSendCompleteLock, &OldIrql );
+ while( !IsListEmpty( &LanSendCompleteList ) ) {
+ ListEntry = RemoveHeadList( &LanSendCompleteList );
WorkItem = CONTAINING_RECORD(ListEntry, LAN_WQ_ITEM, ListEntry);
FreeNdisPacket( WorkItem->Packet );
ExFreePool( WorkItem );
}
- TcpipReleaseSpinLock( &LanWorkLock, OldIrql );
+ KeReleaseSpinLock( &LanSendCompleteLock, OldIrql );
}
/* EOF */
projects / reactos.git / blobdiff