svn path=/trunk/; revision=1317
Header = (PARP_HEADER)Packet->Header;
/* FIXME: Ethernet only */
Header = (PARP_HEADER)Packet->Header;
/* FIXME: Ethernet only */
- if (WN2H(Header->HWType) != 1)
+ if (WN2H(Header->HWType) != 1) {
+ TI_DbgPrint(DEBUG_ARP, ("Unknown ARP hardware type (0x%X).\n", WN2H(Header->HWType)));
/* Check protocol type */
/* Check protocol type */
- if (Header->ProtoType != ETYPE_IPv4)
+ if (Header->ProtoType != ETYPE_IPv4) {
+ TI_DbgPrint(DEBUG_ARP, ("Unknown ARP protocol type (0x%X).\n", WN2H(Header->ProtoType)));
SenderHWAddress = (PVOID)((ULONG_PTR)Header + sizeof(ARP_HEADER));
SenderProtoAddress = (PVOID)((ULONG_PTR)SenderHWAddress + Header->HWAddrLen);
SenderHWAddress = (PVOID)((ULONG_PTR)Header + sizeof(ARP_HEADER));
SenderProtoAddress = (PVOID)((ULONG_PTR)SenderHWAddress + Header->HWAddrLen);
TargetProtoAddress = (PVOID)((ULONG_PTR)SenderProtoAddress +
Header->ProtoAddrLen + Header->HWAddrLen);
TargetProtoAddress = (PVOID)((ULONG_PTR)SenderProtoAddress +
Header->ProtoAddrLen + Header->HWAddrLen);
- Address = AddrBuildIPv4(*(PULONG)(TargetProtoAddress));
+ Address = AddrBuildIPv4(*((PULONG)TargetProtoAddress));
ADE = IPLocateADE(Address, ADE_UNICAST);
if (!ADE) {
ADE = IPLocateADE(Address, ADE_UNICAST);
if (!ADE) {
- TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
+ TI_DbgPrint(DEBUG_ARP, ("Target address (0x%X) is not mine.\n", *((PULONG)TargetProtoAddress)));
return;
}
/* Check if we know the sender */
return;
}
/* Check if we know the sender */
- AddrInitIPv4(Address, *(PULONG)(SenderProtoAddress));
+ AddrInitIPv4(Address, *((PULONG)SenderProtoAddress));
NCE = NBLocateNeighbor(Address);
if (NCE) {
DereferenceObject(Address);
NCE = NBLocateNeighbor(Address);
if (NCE) {
DereferenceObject(Address);
ARP_OPCODE_REPLY); /* ARP reply */
if (NdisPacket) {
PC(NdisPacket)->DLComplete = ARPTransmitComplete;
ARP_OPCODE_REPLY); /* ARP reply */
if (NdisPacket) {
PC(NdisPacket)->DLComplete = ARPTransmitComplete;
- (*Interface->Transmit)(Interface->Context, NdisPacket,
- MaxLLHeaderSize, SenderHWAddress, LAN_PROTO_ARP);
+ (*Interface->Transmit)(Interface->Context,
+ NdisPacket,
+ MaxLLHeaderSize,
+ SenderHWAddress,
+ LAN_PROTO_ARP);
NDIS_HANDLE NdisProtocolHandle = (NDIS_HANDLE)NULL;
BOOLEAN ProtocolRegistered = FALSE;
NDIS_HANDLE NdisProtocolHandle = (NDIS_HANDLE)NULL;
BOOLEAN ProtocolRegistered = FALSE;
-PLAN_ADAPTER Adapters = NULL;
+LIST_ENTRY AdapterListHead;
+KSPIN_LOCK AdapterListLock;
if (Adapter->State != LAN_STATE_RESETTING) {
NdisRequest(&NdisStatus, Adapter->NdisHandle, &Request);
if (Adapter->State != LAN_STATE_RESETTING) {
NdisRequest(&NdisStatus, Adapter->NdisHandle, &Request);
NdisStatus = NDIS_STATUS_NOT_ACCEPTED;
NdisStatus = NDIS_STATUS_NOT_ACCEPTED;
/* Wait for NDIS to complete the request */
if (NdisStatus == NDIS_STATUS_PENDING) {
/* Wait for NDIS to complete the request */
if (NdisStatus == NDIS_STATUS_PENDING) {
- KeWaitForSingleObject(&Adapter->Event, UserRequest, KernelMode, FALSE, NULL);
+ KeWaitForSingleObject(&Adapter->Event,
+ UserRequest,
+ KernelMode,
+ FALSE,
+ NULL);
NdisStatus = Adapter->NdisStatus;
}
NdisStatus = Adapter->NdisStatus;
}
- NdisAllocateBuffer(&NdisStatus, &Buffer, GlobalBufferPool, Data, Adapter->MTU);
+ NdisAllocateBuffer(&NdisStatus,
+ &Buffer,
+ GlobalBufferPool,
+ Data,
+ Adapter->MTU);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
NdisFreePacket(NdisPacket);
ExFreePool(Data);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
NdisFreePacket(NdisPacket);
ExFreePool(Data);
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
KeSetEvent(&Adapter->Event, 0, FALSE);
}
KeSetEvent(&Adapter->Event, 0, FALSE);
}
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
Adapter->NdisStatus = Status;
Adapter->NdisStatus = Status;
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
/* Save status of request and signal an event */
Adapter->NdisStatus = Status;
/* Save status of request and signal an event */
Adapter->NdisStatus = Status;
* Status = Status of the operation
*/
{
* Status = Status of the operation
*/
{
- PLAN_ADAPTER Adapter = BindingContext;
+ PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
AdjustPacket(Packet, Adapter->HeaderSize, PC(Packet)->DLOffset);
AdjustPacket(Packet, Adapter->HeaderSize, PC(Packet)->DLOffset);
UINT PacketType;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
UINT PacketType;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
if (Status == NDIS_STATUS_SUCCESS) {
PNDIS_BUFFER NdisBuffer;
IP_PACKET IPPacket;
if (Status == NDIS_STATUS_SUCCESS) {
PNDIS_BUFFER NdisBuffer;
IP_PACKET IPPacket;
- NdisGetFirstBufferFromPacket(
- Packet, &NdisBuffer, &IPPacket.Header,
- &IPPacket.ContigSize, &IPPacket.TotalSize);
+ IPPacket.NdisPacket = Packet;
+
+ NdisGetFirstBufferFromPacket(Packet,
+ &NdisBuffer,
+ &IPPacket.Header,
+ &IPPacket.ContigSize,
+ &IPPacket.TotalSize);
/* Determine which upper layer protocol that should receive
this packet and pass it to the correct receive handler */
/* Determine which upper layer protocol that should receive
this packet and pass it to the correct receive handler */
USHORT EType;
UINT PacketType;
IP_PACKET IPPacket;
USHORT EType;
UINT PacketType;
IP_PACKET IPPacket;
+ PNDIS_PACKET NdisPacket;
+ PNDIS_BUFFER NdisBuffer;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
PETH_HEADER EHeader = (PETH_HEADER)HeaderBuffer;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
PETH_HEADER EHeader = (PETH_HEADER)HeaderBuffer;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
- if ((Adapter->State != LAN_STATE_STARTED) ||
- HeaderBufferSize < Adapter->HeaderSize)
- /* Adapter is not started or the header was too small */
+ if (Adapter->State != LAN_STATE_STARTED) {
+ TI_DbgPrint(DEBUG_DATALINK, ("Adapter is stopped.\n"));
return NDIS_STATUS_NOT_ACCEPTED;
return NDIS_STATUS_NOT_ACCEPTED;
+ }
+
+ if (HeaderBufferSize < Adapter->HeaderSize) {
+ TI_DbgPrint(DEBUG_DATALINK, ("Runt frame received.\n"));
+ return NDIS_STATUS_NOT_ACCEPTED;
+ }
if (Adapter->Media == NdisMedium802_3) {
/* Ethernet and IEEE 802.3 frames can be destinguished by
looking at the IEEE 802.3 length field. This field is
less than or equal to 1500 for a valid IEEE 802.3 frame
if (Adapter->Media == NdisMedium802_3) {
/* Ethernet and IEEE 802.3 frames can be destinguished by
looking at the IEEE 802.3 length field. This field is
less than or equal to 1500 for a valid IEEE 802.3 frame
- and larger than 1500 is it's a valid Ether-Type value.
+ and larger than 1500 is it's a valid EtherType value.
See RFC 1122, section 2.3.3 for more information */
See RFC 1122, section 2.3.3 for more information */
- if (((EType = EHeader->EType) != ETYPE_IPv4) && (EType != ETYPE_ARP))
+ /* FIXME: Test for Ethernet and IEEE 802.3 frame */
+ if (((EType = EHeader->EType) != ETYPE_IPv4) && (EType != ETYPE_ARP)) {
+ TI_DbgPrint(DEBUG_DATALINK, ("Not IP or ARP frame. EtherType (0x%X).\n", EType));
return NDIS_STATUS_NOT_ACCEPTED;
return NDIS_STATUS_NOT_ACCEPTED;
- /* We use Ether-Type constants to destinguish packets */
+ }
+ /* We use EtherType constants to destinguish packet types */
+ } else {
+ TI_DbgPrint(MIN_TRACE, ("Unsupported media.\n"));
/* FIXME: Support other medias */
return NDIS_STATUS_NOT_ACCEPTED;
/* FIXME: Support other medias */
return NDIS_STATUS_NOT_ACCEPTED;
- if (LookaheadBufferSize < PacketSize) {
- NDIS_STATUS NdisStatus;
- PNDIS_PACKET NdisPacket;
- UINT BytesTransferred;
-
- /* Get transfer data packet */
-
- KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+ /* Get a transfer data packet */
- NdisPacket = Adapter->TDPackets;
- if (NdisPacket == (PNDIS_PACKET)NULL) {
- /* We don't have a free packet descriptor. Drop the packet */
- KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
- return NDIS_STATUS_SUCCESS;
- }
- Adapter->TDPackets = PC(NdisPacket)->Context;
+ KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+ NdisPacket = Adapter->TDPackets;
+ if (NdisPacket == (PNDIS_PACKET)NULL) {
+ TI_DbgPrint(DEBUG_DATALINK, ("No available packet descriptors.\n"));
+ /* We don't have a free packet descriptor. Drop the packet */
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+ return NDIS_STATUS_SUCCESS;
+ }
+ Adapter->TDPackets = PC(NdisPacket)->Context;
+
+ KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+
+ if (LookaheadBufferSize < PacketSize) {
+ NDIS_STATUS NdisStatus;
+ UINT BytesTransferred;
- NdisTransferData(&NdisStatus, Adapter->NdisHandle,
- MacReceiveContext, 0, PacketSize,
- NdisPacket, &BytesTransferred);
+ NdisTransferData(&NdisStatus,
+ Adapter->NdisHandle,
+ MacReceiveContext,
+ 0,
+ PacketSize,
+ NdisPacket,
+ &BytesTransferred);
if (NdisStatus != NDIS_STATUS_PENDING)
ProtocolTransferDataComplete(BindingContext,
if (NdisStatus != NDIS_STATUS_PENDING)
ProtocolTransferDataComplete(BindingContext,
- NdisPacket, NdisStatus, BytesTransferred);
+ NdisPacket,
+ NdisStatus,
+ BytesTransferred);
return NDIS_STATUS_SUCCESS;
}
/* We got all the data in the lookahead buffer */
return NDIS_STATUS_SUCCESS;
}
/* We got all the data in the lookahead buffer */
- RtlZeroMemory(&IPPacket, sizeof(IPPacket));
- IPPacket.Header = LookaheadBuffer;
- IPPacket.TotalSize = PacketSize;
+
+ IPPacket.NdisPacket = NdisPacket;
+
+ NdisGetFirstBufferFromPacket(NdisPacket,
+ &NdisBuffer,
+ &IPPacket.Header,
+ &IPPacket.ContigSize,
+ &IPPacket.TotalSize);
+
+ RtlCopyMemory(IPPacket.Header, LookaheadBuffer, PacketSize);
switch (PacketType) {
case ETYPE_IPv4:
switch (PacketType) {
case ETYPE_IPv4:
+ /* Release the packet descriptor */
+ KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+
+ PC(NdisPacket)->Context = Adapter->TDPackets;
+ Adapter->TDPackets = NdisPacket;
+
+ KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+
return NDIS_STATUS_SUCCESS;
}
return NDIS_STATUS_SUCCESS;
}
* BindingContext = Pointer to a device context (LAN_ADAPTER)
*/
{
* BindingContext = Pointer to a device context (LAN_ADAPTER)
*/
{
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
* StatusBufferSize = Number of bytes in StatusBuffer
*/
{
* StatusBufferSize = Number of bytes in StatusBuffer
*/
{
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
* BindingContext = Pointer to a device context (LAN_ADAPTER)
*/
{
* BindingContext = Pointer to a device context (LAN_ADAPTER)
*/
{
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
PVOID Data;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)Context;
PVOID Data;
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)Context;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
/* NDIS send routines don't have an offset argument so we
must offset the data in upper layers and adjust the
/* NDIS send routines don't have an offset argument so we
must offset the data in upper layers and adjust the
switch (Adapter->Media) {
case NdisMedium802_3:
EHeader = (PETH_HEADER)Data;
switch (Adapter->Media) {
case NdisMedium802_3:
EHeader = (PETH_HEADER)Data;
/* Unicast address */
RtlCopyMemory(EHeader->DstAddr, LinkAddress, IEEE_802_ADDR_LENGTH);
/* Unicast address */
RtlCopyMemory(EHeader->DstAddr, LinkAddress, IEEE_802_ADDR_LENGTH);
/* Broadcast address */
RtlFillMemory(EHeader->DstAddr, IEEE_802_ADDR_LENGTH, 0xFF);
/* Broadcast address */
RtlFillMemory(EHeader->DstAddr, IEEE_802_ADDR_LENGTH, 0xFF);
RtlCopyMemory(EHeader->SrcAddr, Adapter->HWAddress, IEEE_802_ADDR_LENGTH);
RtlCopyMemory(EHeader->SrcAddr, Adapter->HWAddress, IEEE_802_ADDR_LENGTH);
EHeader->EType = ETYPE_IPv6;
break;
default:
EHeader->EType = ETYPE_IPv6;
break;
default:
/* 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);
/* FIXME: Support other medias */
break;
}
/* FIXME: Support other medias */
break;
}
NdisSend(&NdisStatus, Adapter->NdisHandle, NdisPacket);
if (NdisStatus != NDIS_STATUS_PENDING)
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NdisStatus);
NdisSend(&NdisStatus, Adapter->NdisHandle, NdisPacket);
if (NdisStatus != NDIS_STATUS_PENDING)
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NdisStatus);
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NDIS_STATUS_CLOSED);
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NDIS_STATUS_CLOSED);
LLIP_BIND_INFO BindInfo;
ULONG Lookahead = LOOKAHEAD_SIZE;
LLIP_BIND_INFO BindInfo;
ULONG Lookahead = LOOKAHEAD_SIZE;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
Adapter->State = LAN_STATE_OPENING;
Adapter->State = LAN_STATE_OPENING;
- NdisStatus = NDISCall(Adapter, NdisRequestSetInformation,
- OID_GEN_CURRENT_LOOKAHEAD, &Lookahead, sizeof(ULONG));
+ NdisStatus = NDISCall(Adapter,
+ NdisRequestSetInformation,
+ OID_GEN_CURRENT_LOOKAHEAD,
+ &Lookahead,
+ sizeof(ULONG));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MID_TRACE, ("Could not set lookahead buffer size (0x%X).\n", NdisStatus));
return;
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MID_TRACE, ("Could not set lookahead buffer size (0x%X).\n", NdisStatus));
return;
PC(Packet)->Context = Adapter->TDPackets;
Adapter->TDPackets = Packet;
if (!Packet) {
PC(Packet)->Context = Adapter->TDPackets;
Adapter->TDPackets = Packet;
if (!Packet) {
- TI_DbgPrint(MID_TRACE, ("Could not allocate transfer data packet (out of resources).\n"));
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
FreeTDPackets(Adapter);
return;
}
FreeTDPackets(Adapter);
return;
}
- /* Reference the interface for the NTE. The reference for
- the address is just passed on to the NTE */
+ /* Reference the interface for the NTE. The reference
+ for the address is just passed on to the NTE */
ReferenceObject(IF);
/* Register interface with IP layer */
IPRegisterInterface(IF);
/* Set packet filter so we can send and receive packets */
ReferenceObject(IF);
/* Register interface with IP layer */
IPRegisterInterface(IF);
/* Set packet filter so we can send and receive packets */
- NdisStatus = NDISCall(Adapter, NdisRequestSetInformation,
- OID_GEN_CURRENT_PACKET_FILTER, &Adapter->PacketFilter, sizeof(UINT));
+ NdisStatus = NDISCall(Adapter,
+ NdisRequestSetInformation,
+ 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));
FreeTDPackets(Adapter);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MID_TRACE, ("Could not set packet filter (0x%X).\n", NdisStatus));
FreeTDPackets(Adapter);
* Adapter = Pointer to LAN_ADAPTER structure
*/
{
* Adapter = Pointer to LAN_ADAPTER structure
*/
{
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
if (Adapter->State == LAN_STATE_STARTED) {
PIP_INTERFACE IF = Adapter->Context;
if (Adapter->State == LAN_STATE_STARTED) {
PIP_INTERFACE IF = Adapter->Context;
UINT AddressOID;
UINT Speed;
UINT AddressOID;
UINT Speed;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
IF = ExAllocatePool(NonPagedPool, sizeof(LAN_ADAPTER));
IF = ExAllocatePool(NonPagedPool, sizeof(LAN_ADAPTER));
+ if (!IF) {
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NDIS_STATUS_RESOURCES;
return NDIS_STATUS_RESOURCES;
RtlZeroMemory(IF, sizeof(LAN_ADAPTER));
RtlZeroMemory(IF, sizeof(LAN_ADAPTER));
MediaArray[MEDIA_ETH] = NdisMedium802_3;
/* Open the adapter. */
MediaArray[MEDIA_ETH] = NdisMedium802_3;
/* Open the adapter. */
- NdisOpenAdapter(&NdisStatus, &OpenStatus, &IF->NdisHandle, &MediaIndex,
- MediaArray, MAX_MEDIA, NdisProtocolHandle, IF, AdapterName, 0, NULL);
+ NdisOpenAdapter(&NdisStatus,
+ &OpenStatus,
+ &IF->NdisHandle,
+ &MediaIndex,
+ MediaArray,
+ MAX_MEDIA,
+ NdisProtocolHandle,
+ IF,
+ AdapterName,
+ 0,
+ NULL);
/* Wait until the adapter is opened */
if (NdisStatus == NDIS_STATUS_PENDING)
/* Wait until the adapter is opened */
if (NdisStatus == NDIS_STATUS_PENDING)
}
/* Get maximum frame size */
}
/* Get maximum frame size */
- NdisStatus = NDISCall(IF, NdisRequestQueryInformation,
- OID_GEN_MAXIMUM_FRAME_SIZE, &IF->MTU, sizeof(UINT));
+ NdisStatus = NDISCall(IF,
+ NdisRequestQueryInformation,
+ OID_GEN_MAXIMUM_FRAME_SIZE,
+ &IF->MTU,
+ sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
ExFreePool(IF);
return NdisStatus;
}
/* Get maximum packet size */
if (NdisStatus != NDIS_STATUS_SUCCESS) {
ExFreePool(IF);
return NdisStatus;
}
/* Get maximum packet size */
- NdisStatus = NDISCall(IF, NdisRequestQueryInformation,
- OID_GEN_MAXIMUM_TOTAL_SIZE, &IF->MaxPacketSize, sizeof(UINT));
+ NdisStatus = NDISCall(IF,
+ NdisRequestQueryInformation,
+ OID_GEN_MAXIMUM_TOTAL_SIZE,
+ &IF->MaxPacketSize,
+ sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for maximum packet size failed.\n"));
ExFreePool(IF);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for maximum packet size failed.\n"));
ExFreePool(IF);
}
/* Get maximum number of packets we can pass to NdisSend(Packets) at one time */
}
/* Get maximum number of packets we can pass to NdisSend(Packets) at one time */
- NdisStatus = NDISCall(IF, NdisRequestQueryInformation,
- OID_GEN_MAXIMUM_SEND_PACKETS, &IF->MaxSendPackets, sizeof(UINT));
+ NdisStatus = NDISCall(IF,
+ NdisRequestQueryInformation,
+ OID_GEN_MAXIMUM_SEND_PACKETS,
+ &IF->MaxSendPackets,
+ sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS)
/* Legacy NIC drivers may not support this query, if it fails we
assume it can send at least one packet per call to NdisSend(Packets) */
IF->MaxSendPackets = 1;
/* Get current hardware address */
if (NdisStatus != NDIS_STATUS_SUCCESS)
/* Legacy NIC drivers may not support this query, if it fails we
assume it can send at least one packet per call to NdisSend(Packets) */
IF->MaxSendPackets = 1;
/* Get current hardware address */
- NdisStatus = NDISCall(IF, NdisRequestQueryInformation, AddressOID,
- IF->HWAddress, IF->HWAddressLength);
+ NdisStatus = NDISCall(IF,
+ NdisRequestQueryInformation,
+ AddressOID,
+ &IF->HWAddress,
+ IF->HWAddressLength);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for current hardware address failed.\n"));
ExFreePool(IF);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for current hardware address failed.\n"));
ExFreePool(IF);
}
/* Get maximum link speed */
}
/* Get maximum link speed */
- NdisStatus = NDISCall(IF, NdisRequestQueryInformation,
- OID_GEN_LINK_SPEED, &Speed, sizeof(UINT));
+ NdisStatus = NDISCall(IF,
+ NdisRequestQueryInformation,
+ OID_GEN_LINK_SPEED,
+ &Speed,
+ sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for maximum link speed failed.\n"));
ExFreePool(IF);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for maximum link speed failed.\n"));
ExFreePool(IF);
*Adapter = IF;
/* Add adapter to the adapter list */
*Adapter = IF;
/* Add adapter to the adapter list */
- IF->Next = Adapters;
- Adapters = IF;
+ ExInterlockedInsertTailList(&AdapterListHead,
+ &IF->ListEntry,
+ &AdapterListLock);
/* Bind adapter to IP layer */
BindAdapter(IF);
/* Bind adapter to IP layer */
BindAdapter(IF);
- TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Leaving.\n"));
return NDIS_STATUS_SUCCESS;
}
return NDIS_STATUS_SUCCESS;
}
{
KIRQL OldIrql;
NDIS_HANDLE NdisHandle;
{
KIRQL OldIrql;
NDIS_HANDLE NdisHandle;
- PLAN_ADAPTER IF, PrevIF;
- BOOLEAN Found = FALSE;
NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
-
- /* Search the adapter list for the specified adapter and remove it */
- IF = Adapters;
- if (IF) {
- if (Adapter != Adapters) {
- PrevIF = IF;
- while ((IF) && (!Found)) {
- if (IF == Adapter) {
- /* We've found the adapter, now remove it from the list */
- PrevIF->Next = IF->Next;
- Found = TRUE;
- }
- PrevIF = IF;
- IF = IF->Next;
- }
- } else {
- Adapters = NULL;
- Found = TRUE;
- }
- }
- if (!Found) {
- TI_DbgPrint(MIN_TRACE, ("Leaving (adapter was not in list).\n"));
- return NDIS_STATUS_ADAPTER_NOT_FOUND;
- }
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
+ /* Unlink the adapter from the list */
+ RemoveEntryList(&Adapter->ListEntry);
/* Unbind adapter from IP layer */
UnbindAdapter(Adapter);
/* Unbind adapter from IP layer */
UnbindAdapter(Adapter);
NdisCloseAdapter(&NdisStatus, NdisHandle);
if (NdisStatus == NDIS_STATUS_PENDING) {
KeWaitForSingleObject(&Adapter->Event,
NdisCloseAdapter(&NdisStatus, NdisHandle);
if (NdisStatus == NDIS_STATUS_PENDING) {
KeWaitForSingleObject(&Adapter->Event,
- UserRequest, KernelMode, FALSE, NULL);
+ UserRequest,
+ KernelMode,
+ FALSE,
+ NULL);
NdisStatus = Adapter->NdisStatus;
}
} else
NdisStatus = Adapter->NdisStatus;
}
} else
NDIS_STATUS NdisStatus;
NDIS_PROTOCOL_CHARACTERISTICS ProtChars;
NDIS_STATUS NdisStatus;
NDIS_PROTOCOL_CHARACTERISTICS ProtChars;
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
+ InitializeListHead(&AdapterListHead);
+ KeInitializeSpinLock(&AdapterListLock);
+
/* Set up protocol characteristics */
RtlZeroMemory(&ProtChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
/* Set up protocol characteristics */
RtlZeroMemory(&ProtChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
- ProtChars.MajorNdisVersion = NDIS_VERSION_MAJOR;
- ProtChars.MinorNdisVersion = NDIS_VERSION_MINOR;
- ProtChars.Name.Length = Name->Length;
- ProtChars.Name.Buffer = (PVOID)Name->Buffer;
- ProtChars.OpenAdapterCompleteHandler = ProtocolOpenAdapterComplete;
- ProtChars.CloseAdapterCompleteHandler = ProtocolCloseAdapterComplete;
- ProtChars.ResetCompleteHandler = ProtocolResetComplete;
- ProtChars.RequestCompleteHandler = ProtocolRequestComplete;
+ ProtChars.MajorNdisVersion = NDIS_VERSION_MAJOR;
+ ProtChars.MinorNdisVersion = NDIS_VERSION_MINOR;
+ ProtChars.Name.Length = Name->Length;
+ ProtChars.Name.Buffer = (PVOID)Name->Buffer;
+ ProtChars.OpenAdapterCompleteHandler = ProtocolOpenAdapterComplete;
+ ProtChars.CloseAdapterCompleteHandler = ProtocolCloseAdapterComplete;
+ ProtChars.ResetCompleteHandler = ProtocolResetComplete;
+ ProtChars.RequestCompleteHandler = ProtocolRequestComplete;
ProtChars.u2.SendCompleteHandler = ProtocolSendComplete;
ProtChars.u3.TransferDataCompleteHandler = ProtocolTransferDataComplete;
ProtChars.u4.ReceiveHandler = ProtocolReceive;
ProtChars.u2.SendCompleteHandler = ProtocolSendComplete;
ProtChars.u3.TransferDataCompleteHandler = ProtocolTransferDataComplete;
ProtChars.u4.ReceiveHandler = ProtocolReceive;
- ProtChars.ReceiveCompleteHandler = ProtocolReceiveComplete;
- ProtChars.StatusHandler = ProtocolStatus;
- ProtChars.StatusCompleteHandler = ProtocolStatusComplete;
+ ProtChars.ReceiveCompleteHandler = ProtocolReceiveComplete;
+ ProtChars.StatusHandler = ProtocolStatus;
+ ProtChars.StatusCompleteHandler = ProtocolStatusComplete;
/* Try to register protocol */
/* Try to register protocol */
- NdisRegisterProtocol(
- &NdisStatus, &NdisProtocolHandle, &ProtChars,
- sizeof(NDIS_PROTOCOL_CHARACTERISTICS) + Name->Length);
+ NdisRegisterProtocol(&NdisStatus,
+ &NdisProtocolHandle,
+ &ProtChars,
+ sizeof(NDIS_PROTOCOL_CHARACTERISTICS) + Name->Length);
if (NdisStatus != NDIS_STATUS_SUCCESS)
return (NTSTATUS)NdisStatus;
if (NdisStatus != NDIS_STATUS_SUCCESS)
return (NTSTATUS)NdisStatus;
* NOTES: Does not care wether we are already registered
*/
{
* NOTES: Does not care wether we are already registered
*/
{
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
if (ProtocolRegistered) {
NDIS_STATUS NdisStatus;
if (ProtocolRegistered) {
NDIS_STATUS NdisStatus;
+ PLIST_ENTRY CurrentEntry;
+ PLIST_ENTRY NextEntry;
+ PLAN_ADAPTER Current;
+ KIRQL OldIrql;
+
+ KeAcquireSpinLock(&AdapterListLock, &OldIrql);
+
+ /* Search the list and remove every adapter we find */
+ CurrentEntry = AdapterListHead.Flink;
+ while (CurrentEntry != &AdapterListHead) {
+ NextEntry = CurrentEntry->Flink;
+ Current = CONTAINING_RECORD(CurrentEntry, LAN_ADAPTER, ListEntry);
+ /* Unregister it */
+ LANUnregisterAdapter(Current);
+ CurrentEntry = NextEntry;
+ }
- while (Adapters)
- NdisStatus = LANUnregisterAdapter(Adapters);
+ KeReleaseSpinLock(&AdapterListLock, OldIrql);
NdisDeregisterProtocol(&NdisStatus, NdisProtocolHandle);
ProtocolRegistered = FALSE;
NdisDeregisterProtocol(&NdisStatus, NdisProtocolHandle);
ProtocolRegistered = FALSE;
{
KIRQL OldIrql;
PNDIS_PACKET NdisPacket;
{
KIRQL OldIrql;
PNDIS_PACKET NdisPacket;
+ PNDIS_BUFFER NdisBuffer;
TI_DbgPrint(MAX_TRACE, ("Called.\n"));
TI_DbgPrint(MAX_TRACE, ("Called.\n"));
IPPacket.NdisPacket = NdisPacket;
NdisGetFirstBufferFromPacket(NdisPacket,
IPPacket.NdisPacket = NdisPacket;
NdisGetFirstBufferFromPacket(NdisPacket,
- &Buffer,
- &IPPacket.Header,
- &IPPacket.ContigSize,
- &IPPacket.TotalSize);
+ &NdisBuffer,
+ &IPPacket.Header,
+ &IPPacket.ContigSize,
+ &IPPacket.TotalSize);
IPReceive(Context, &IPPacket);
IPReceive(Context, &IPPacket);
#define DEBUG_IRP 0x00000400
#define DEBUG_REFCOUNT 0x00000800
#define DEBUG_ADDRFILE 0x00001000
#define DEBUG_IRP 0x00000400
#define DEBUG_REFCOUNT 0x00000800
#define DEBUG_ADDRFILE 0x00001000
-#define DEBUG_IP 0x00002000
-#define DEBUG_ROUTER 0x00004000
-#define DEBUG_RCACHE 0x00008000
-#define DEBUG_NCACHE 0x00010000
+#define DEBUG_DATALINK 0x00002000
+#define DEBUG_ARP 0x00004000
+#define DEBUG_IP 0x00008000
+#define DEBUG_ICMP 0x00010000
+#define DEBUG_ROUTER 0x00020000
+#define DEBUG_RCACHE 0x00040000
+#define DEBUG_NCACHE 0x00080000
#define DEBUG_ULTRA 0xFFFFFFFF
#ifdef DBG
#define DEBUG_ULTRA 0xFFFFFFFF
#ifdef DBG
/* Per adapter information */
typedef struct LAN_ADAPTER {
/* Per adapter information */
typedef struct LAN_ADAPTER {
- struct LAN_ADAPTER *Next; /* Pointer to next adapter */
+ LIST_ENTRY ListEntry; /* Entry on list */
KSPIN_LOCK Lock; /* Lock for this structure */
UCHAR State; /* State of the adapter */
KEVENT Event; /* Opening event */
KSPIN_LOCK Lock; /* Lock for this structure */
UCHAR State; /* State of the adapter */
KEVENT Event; /* Opening event */
#define LOOKAHEAD_SIZE 128
/* Ethernet types. We swap constants so we can compare values at runtime
#define LOOKAHEAD_SIZE 128
/* Ethernet types. We swap constants so we can compare values at runtime
- without swapping them */
+ without swapping them there */
#define ETYPE_IPv4 WH2N(0x0800)
#define ETYPE_IPv6 WH2N(0x0000) /* FIXME */
#define ETYPE_ARP WH2N(0x0806)
#define ETYPE_IPv4 WH2N(0x0800)
#define ETYPE_IPv6 WH2N(0x0000) /* FIXME */
#define ETYPE_ARP WH2N(0x0806)
#define LAN_PROTO_IPv6 0x0001 /* Internet Protocol version 6 */
#define LAN_PROTO_ARP 0x0002 /* Address Resolution Protocol */
#define LAN_PROTO_IPv6 0x0001 /* Internet Protocol version 6 */
#define LAN_PROTO_ARP 0x0002 /* Address Resolution Protocol */
-extern PLAN_ADAPTER Adapters;
-
NDIS_STATUS LANRegisterAdapter(
PNDIS_STRING AdapterName,
NDIS_STATUS LANRegisterAdapter(
PNDIS_STRING AdapterName,
{
PIP_PACKET IPPacket = (PIP_PACKET)Context;
{
PIP_PACKET IPPacket = (PIP_PACKET)Context;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
-
- TI_DbgPrint(MAX_TRACE, ("Freeing NDIS packet (%X).\n", Packet));
+ TI_DbgPrint(DEBUG_ICMP, ("Freeing NDIS packet (%X).\n", Packet));
/* Free packet */
FreeNdisPacket(Packet);
/* Free packet */
FreeNdisPacket(Packet);
- TI_DbgPrint(MAX_TRACE, ("Freeing IP packet at %X.\n", IPPacket));
+ TI_DbgPrint(DEBUG_ICMP, ("Freeing IP packet at %X.\n", IPPacket));
PoolFreeBuffer(IPPacket);
}
PoolFreeBuffer(IPPacket);
}
PVOID DataBuffer;
ULONG Size;
PVOID DataBuffer;
ULONG Size;
- TI_DbgPrint(MAX_TRACE, ("Called. DataSize = %d.\n", DataSize));
+ TI_DbgPrint(DEBUG_ICMP, ("Called. DataSize (%d).\n", DataSize));
/* Prepare ICMP packet */
IPPacket = PoolAllocateBuffer(sizeof(IP_PACKET));
if (!IPPacket)
return NULL;
/* Prepare ICMP packet */
IPPacket = PoolAllocateBuffer(sizeof(IP_PACKET));
if (!IPPacket)
return NULL;
- TI_DbgPrint(MAX_TRACE, ("IPPacket at %X.\n", IPPacket));
+ TI_DbgPrint(DEBUG_ICMP, ("IPPacket at (0x%X).\n", IPPacket));
Size = MaxLLHeaderSize + sizeof(IPv4_HEADER) +
sizeof(ICMP_HEADER) + DataSize;
Size = MaxLLHeaderSize + sizeof(IPv4_HEADER) +
sizeof(ICMP_HEADER) + DataSize;
- TI_DbgPrint(MAX_TRACE, ("Size = %d, Data at %X.\n", Size, DataBuffer));
+ TI_DbgPrint(DEBUG_ICMP, ("Size (%d). Data at (0x%X).\n", Size, DataBuffer));
/* Allocate NDIS packet */
NdisAllocatePacket(&NdisStatus, &NdisPacket, GlobalPacketPool);
/* Allocate NDIS packet */
NdisAllocatePacket(&NdisStatus, &NdisPacket, GlobalPacketPool);
- TI_DbgPrint(MAX_TRACE, ("NdisPacket at %X.\n", NdisPacket));
+ TI_DbgPrint(MAX_TRACE, ("NdisPacket at (0x%X).\n", NdisPacket));
/* Allocate NDIS buffer for maximum link level header and ICMP packet */
NdisAllocateBuffer(&NdisStatus, &NdisBuffer, GlobalBufferPool,
/* Allocate NDIS buffer for maximum link level header and ICMP packet */
NdisAllocateBuffer(&NdisStatus, &NdisBuffer, GlobalBufferPool,
- TI_DbgPrint(MAX_TRACE, ("NdisBuffer at %X.\n", NdisBuffer));
+ TI_DbgPrint(MAX_TRACE, ("NdisBuffer at (0x%X).\n", NdisBuffer));
/* Link NDIS buffer into packet */
NdisChainBufferAtFront(NdisPacket, NdisBuffer);
/* Link NDIS buffer into packet */
NdisChainBufferAtFront(NdisPacket, NdisBuffer);
PICMP_HEADER ICMPHeader;
PIP_PACKET NewPacket;
UINT DataSize;
PICMP_HEADER ICMPHeader;
PIP_PACKET NewPacket;
UINT DataSize;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_ICMP, ("Called.\n"));
ICMPHeader = (PICMP_HEADER)IPPacket->Data;
ICMPHeader = (PICMP_HEADER)IPPacket->Data;
- TI_DbgPrint(MID_TRACE, ("Size = %d.\n", IPPacket->TotalSize));
+ TI_DbgPrint(DEBUG_ICMP, ("Size (%d).\n", IPPacket->TotalSize));
- TI_DbgPrint(MID_TRACE, ("HeaderSize = %d.\n", IPPacket->HeaderSize));
+ TI_DbgPrint(DEBUG_ICMP, ("HeaderSize (%d).\n", IPPacket->HeaderSize));
- TI_DbgPrint(MID_TRACE, ("Type = %d.\n", ICMPHeader->Type));
+ TI_DbgPrint(DEBUG_ICMP, ("Type (%d).\n", ICMPHeader->Type));
- TI_DbgPrint(MID_TRACE, ("Code = %d.\n", ICMPHeader->Code));
+ TI_DbgPrint(DEBUG_ICMP, ("Code (%d).\n", ICMPHeader->Code));
- TI_DbgPrint(MID_TRACE, ("Checksum = %X.\n", ICMPHeader->Checksum));
+ TI_DbgPrint(DEBUG_ICMP, ("Checksum (0x%X).\n", ICMPHeader->Checksum));
- /* Checksum ICMP header and data and compare */
- Checksum = DN2H(IPv4Checksum(IPPacket->Data, IPPacket->TotalSize - IPPacket->HeaderSize, 0));
- if (Checksum != 0xFFFF) {
- TI_DbgPrint(MIN_TRACE, ("Bad ICMP checksum (0x%X).\n", Checksum));
+ /* Checksum ICMP header and data */
+ if (!CorrectChecksum(IPPacket->Data, IPPacket->TotalSize - IPPacket->HeaderSize)) {
+ TI_DbgPrint(DEBUG_ICMP, ("Bad ICMP checksum.\n"));
/* Discard packet */
return;
}
/* Discard packet */
return;
}
/* Reply with an ICMP echo reply message */
DataSize = IPPacket->TotalSize - IPPacket->HeaderSize - sizeof(ICMP_HEADER);
NewPacket = PrepareICMPPacket(NTE, &IPPacket->SrcAddr, DataSize);
/* Reply with an ICMP echo reply message */
DataSize = IPPacket->TotalSize - IPPacket->HeaderSize - sizeof(ICMP_HEADER);
NewPacket = PrepareICMPPacket(NTE, &IPPacket->SrcAddr, DataSize);
+ if (!NewPacket) {
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
/* Copy ICMP header and data into new packet */
RtlCopyMemory(NewPacket->Data, IPPacket->Data, DataSize + sizeof(ICMP_HEADER));
/* Copy ICMP header and data into new packet */
RtlCopyMemory(NewPacket->Data, IPPacket->Data, DataSize + sizeof(ICMP_HEADER));
ICMPTransmit(NTE, NewPacket);
ICMPTransmit(NTE, NewPacket);
- TI_DbgPrint(MID_TRACE, ("Echo reply sent.\n"));
+ TI_DbgPrint(DEBUG_ICMP, ("Echo reply sent.\n"));
- TI_DbgPrint(MID_TRACE, ("Discarded ICMP datagram of unknown type.\n"));
+ TI_DbgPrint(DEBUG_ICMP, ("Discarded ICMP datagram of unknown type.\n"));
/* Discard packet */
break;
}
/* Discard packet */
break;
}
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_ICMP, ("Called.\n"));
/* Calculate checksum of ICMP header and data */
((PICMP_HEADER)IPPacket->Data)->Checksum = (USHORT)
/* Calculate checksum of ICMP header and data */
((PICMP_HEADER)IPPacket->Data)->Checksum = (USHORT)
/* We're done with the RCN */
DereferenceObject(RCN);
} else {
/* We're done with the RCN */
DereferenceObject(RCN);
} else {
- TI_DbgPrint(MIN_TRACE, ("RCN at 0x%X.\n", RCN));
+ TI_DbgPrint(MIN_TRACE, ("RCN at (0x%X).\n", RCN));
/* No route to destination (or no free resources) */
/* No route to destination (or no free resources) */
- TI_DbgPrint(MIN_TRACE, ("No route to destination address 0x%X.\n",
+ TI_DbgPrint(DEBUG_ICMP, ("No route to destination address 0x%X.\n",
IPPacket->DstAddr.Address.IPv4Address));
/* Discard packet */
FreeNdisPacket(IPPacket->NdisPacket);
IPPacket->DstAddr.Address.IPv4Address));
/* Discard packet */
FreeNdisPacket(IPPacket->NdisPacket);
UINT DataSize;
PIP_PACKET NewPacket;
UINT DataSize;
PIP_PACKET NewPacket;
- TI_DbgPrint(MID_TRACE, ("Called (Type=%d, Code=%d).\n", Type, Code));
+ TI_DbgPrint(DEBUG_ICMP, ("Called. Type (%d) Code (%d).\n", Type, Code));
DataSize = IPPacket->TotalSize;
if ((DataSize) > (576 - sizeof(IPv4_HEADER) - sizeof(ICMP_HEADER)))
DataSize = 576;
NewPacket = PrepareICMPPacket(NTE, &IPPacket->SrcAddr, DataSize);
DataSize = IPPacket->TotalSize;
if ((DataSize) > (576 - sizeof(IPv4_HEADER) - sizeof(ICMP_HEADER)))
DataSize = 576;
NewPacket = PrepareICMPPacket(NTE, &IPPacket->SrcAddr, DataSize);
+ if (!NewPacket) {
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
RtlCopyMemory((PVOID)((ULONG_PTR)NewPacket->Data + sizeof(ICMP_HEADER)),
IPPacket->Header, DataSize);
RtlCopyMemory((PVOID)((ULONG_PTR)NewPacket->Data + sizeof(ICMP_HEADER)),
IPPacket->Header, DataSize);
PLIST_ENTRY CurrentADEEntry;
PIP_INTERFACE CurrentIF;
PADDRESS_ENTRY CurrentADE;
PLIST_ENTRY CurrentADEEntry;
PIP_INTERFACE CurrentIF;
PADDRESS_ENTRY CurrentADE;
BOOLEAN LoopbackIsRegistered = FALSE;
#endif
TI_DbgPrint(DEBUG_IP, ("Called. AddressType (0x%X).\n", AddressType));
BOOLEAN LoopbackIsRegistered = FALSE;
#endif
TI_DbgPrint(DEBUG_IP, ("Called. AddressType (0x%X).\n", AddressType));
CurrentIFEntry = InterfaceListHead.Flink;
while (CurrentIFEntry != &InterfaceListHead) {
CurrentIF = CONTAINING_RECORD(CurrentIFEntry, IP_INTERFACE, ListEntry);
CurrentIFEntry = InterfaceListHead.Flink;
while (CurrentIFEntry != &InterfaceListHead) {
CurrentIF = CONTAINING_RECORD(CurrentIFEntry, IP_INTERFACE, ListEntry);
if (CurrentIF != Loopback) {
#endif
/* Search the address entry list and return the first appropriate ADE found */
if (CurrentIF != Loopback) {
#endif
/* Search the address entry list and return the first appropriate ADE found */
return CurrentADE;
}
CurrentADEEntry = CurrentADEEntry->Flink;
return CurrentADE;
}
CurrentADEEntry = CurrentADEEntry->Flink;
} else
LoopbackIsRegistered = TRUE;
#endif
CurrentIFEntry = CurrentIFEntry->Flink;
}
} else
LoopbackIsRegistered = TRUE;
#endif
CurrentIFEntry = CurrentIFEntry->Flink;
}
/* No address was found. Use loopback interface if available */
if (LoopbackIsRegistered) {
CurrentADEEntry = Loopback->ADEListHead.Flink;
/* No address was found. Use loopback interface if available */
if (LoopbackIsRegistered) {
CurrentADEEntry = Loopback->ADEListHead.Flink;
TI_DbgPrint(DEBUG_IP, ("Called. BindInfo (0x%X).\n", BindInfo));
TI_DbgPrint(DEBUG_IP, ("Called. BindInfo (0x%X).\n", BindInfo));
+#ifdef DBG
+ if (BindInfo->Address) {
+ PUCHAR A = BindInfo->Address;
+ TI_DbgPrint(DEBUG_IP, ("Interface address (%02X %02X %02X %02X %02X %02X).\n",
+ A[0], A[1], A[2], A[3], A[4], A[5]));
+ }
+#endif
+
IF = PoolAllocateBuffer(sizeof(IP_INTERFACE));
if (!IF) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NULL;
}
IF = PoolAllocateBuffer(sizeof(IP_INTERFACE));
if (!IF) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NULL;
}
- IF->RefCount = 1;
- IF->Context = BindInfo->Context;
- IF->HeaderSize = BindInfo->HeaderSize;
+ IF->RefCount = 1;
+ IF->Context = BindInfo->Context;
+ IF->HeaderSize = BindInfo->HeaderSize;
if (IF->HeaderSize > MaxLLHeaderSize)
MaxLLHeaderSize = IF->HeaderSize;
if (IF->HeaderSize > MaxLLHeaderSize)
MaxLLHeaderSize = IF->HeaderSize;
- IF->MinFrameSize = BindInfo->MinFrameSize;
+ IF->MinFrameSize = BindInfo->MinFrameSize;
if (IF->MinFrameSize > MinLLFrameSize)
MinLLFrameSize = IF->MinFrameSize;
if (IF->MinFrameSize > MinLLFrameSize)
MinLLFrameSize = IF->MinFrameSize;
}
PC(NdisPacket)->DLComplete = IPSendComplete;
}
PC(NdisPacket)->DLComplete = IPSendComplete;
- (*NCE->Interface->Transmit)(NCE->Interface->Context, NdisPacket,
- MaxLLHeaderSize, NCE->LinkAddress, LAN_PROTO_IPv4);
+ (*NCE->Interface->Transmit)(NCE->Interface->Context,
+ NdisPacket,
+ MaxLLHeaderSize,
+ NCE->LinkAddress,
+ LAN_PROTO_IPv4);
/* See debug.h for debug/trace constants */
DWORD DebugTraceLevel = MIN_TRACE;
/* See debug.h for debug/trace constants */
DWORD DebugTraceLevel = MIN_TRACE;
#endif /* DBG */
PDEVICE_OBJECT TCPDeviceObject = NULL;
#endif /* DBG */
PDEVICE_OBJECT TCPDeviceObject = NULL;
* DriverObject = Pointer to driver object created by the system
*/
{
* DriverObject = Pointer to driver object created by the system
*/
{
KIRQL OldIrql;
KeAcquireSpinLock(&AddressFileListLock, &OldIrql);
KIRQL OldIrql;
KeAcquireSpinLock(&AddressFileListLock, &OldIrql);
- if (!IsListEmpty(AddressFileList)) {
+ if (!IsListEmpty(&AddressFileListHead)) {
TI_DbgPrint(MIN_TRACE, ("Open address file objects exists.\n"));
}
KeReleaseSpinLock(&AddressFileListLock, OldIrql);
TI_DbgPrint(MIN_TRACE, ("Open address file objects exists.\n"));
}
KeReleaseSpinLock(&AddressFileListLock, OldIrql);
LoopUnregisterAdapter(NULL);
/* Unregister protocol with NDIS */
LoopUnregisterAdapter(NULL);
/* Unregister protocol with NDIS */
/* Shutdown transport level protocol subsystems */
TCPShutdown();
/* Shutdown transport level protocol subsystems */
TCPShutdown();
UNICODE_STRING strDeviceName;
STRING strNdisDeviceName;
NDIS_STATUS NdisStatus;
UNICODE_STRING strDeviceName;
STRING strNdisDeviceName;
NDIS_STATUS NdisStatus;
PLAN_ADAPTER Adapter;
NDIS_STRING DeviceName;
PLAN_ADAPTER Adapter;
NDIS_STRING DeviceName;
TI_DbgPrint(MAX_TRACE, ("Called.\n"));
TI_DbgPrint(MAX_TRACE, ("Called.\n"));
+ /* FIXME: Create symbolic links in Win32 namespace */
+
/* Create IP device object */
RtlInitUnicodeString(&strDeviceName, DD_IP_DEVICE_NAME);
Status = IoCreateDevice(DriverObject, 0, &strDeviceName,
/* Create IP device object */
RtlInitUnicodeString(&strDeviceName, DD_IP_DEVICE_NAME);
Status = IoCreateDevice(DriverObject, 0, &strDeviceName,
TiUnload(DriverObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
TiUnload(DriverObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Open underlying adapter(s) we are bound to */
/* FIXME: Get binding information from registry */
/* Put your own NDIS adapter device name here */
/* Open underlying adapter(s) we are bound to */
/* FIXME: Get binding information from registry */
/* Put your own NDIS adapter device name here */
+ /* ReactOS */
+ NdisInitUnicodeString(&DeviceName, L"\\Device\\ne2000");
+
- NdisInitUnicodeString(&DeviceName, L"\\Device\\El90x1");
-#else
+ //NdisInitUnicodeString(&DeviceName, L"\\Device\\El90x1");
+
- NdisInitUnicodeString(&DeviceName,
- L"\\Device\\{56388B49-67BB-4419-A3F4-28DF190B9149}");
-#endif
+ //NdisInitUnicodeString(&DeviceName, L"\\Device\\{56388B49-67BB-4419-A3F4-28DF190B9149}");
NdisStatus = LANRegisterAdapter(&DeviceName, &Adapter);
if (!NT_SUCCESS(NdisStatus)) {
NdisStatus = LANRegisterAdapter(&DeviceName, &Adapter);
if (!NT_SUCCESS(NdisStatus)) {
return STATUS_DEVICE_DOES_NOT_EXIST;
}
#endif
return STATUS_DEVICE_DOES_NOT_EXIST;
}
#endif
/* Setup network layer and transport layer entities */
EntityList = ExAllocatePool(NonPagedPool, sizeof(TDIEntityID) * 2);
if (!NT_SUCCESS(Status)) {
/* Setup network layer and transport layer entities */
EntityList = ExAllocatePool(NonPagedPool, sizeof(TDIEntityID) * 2);
if (!NT_SUCCESS(Status)) {
/* FIXME: IPv6 is not supported */
return;
/* FIXME: IPv6 is not supported */
return;
}
UDPHeader = (PUDP_HEADER)IPPacket->Data;
}
UDPHeader = (PUDP_HEADER)IPPacket->Data;
- /* Select the first address returned */
- *Address = DN2H(IpAddress->Addr);
+ if (SnmpInfo.NumAddr != 1) {
+ /* Skip loopback address */
+ *Address = DN2H(((PIPADDR_ENTRY)((ULONG)IpAddress + sizeof(IPADDR_ENTRY)))->Addr);
+ } else {
+ /* Select the first address returned */
+ *Address = DN2H(IpAddress->Addr);
+ }
+
ExFreePool(IpAddress);
} else {
Status = STATUS_UNSUCCESSFUL;
ExFreePool(IpAddress);
} else {
Status = STATUS_UNSUCCESSFUL;