NDIS_HANDLE NdisProtocolHandle = (NDIS_HANDLE)NULL;
BOOLEAN ProtocolRegistered = FALSE;
-PLAN_ADAPTER Adapters = NULL;
+LIST_ENTRY AdapterListHead;
+KSPIN_LOCK AdapterListLock;
NDIS_STATUS NDISCall(
if (Adapter->State != LAN_STATE_RESETTING) {
NdisRequest(&NdisStatus, Adapter->NdisHandle, &Request);
- } else
+ } else {
NdisStatus = NDIS_STATUS_NOT_ACCEPTED;
+ }
/* 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;
}
return NULL;
}
- NdisAllocateBuffer(&NdisStatus, &Buffer, GlobalBufferPool, Data, Adapter->MTU);
+ NdisAllocateBuffer(&NdisStatus,
+ &Buffer,
+ GlobalBufferPool,
+ Data,
+ Adapter->MTU);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
NdisFreePacket(NdisPacket);
ExFreePool(Data);
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
KeSetEvent(&Adapter->Event, 0, FALSE);
}
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
Adapter->NdisStatus = Status;
{
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
/* Save status of request and signal an event */
Adapter->NdisStatus = Status;
* 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);
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;
- 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 */
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;
- 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;
+ }
+
+ 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
- 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 */
- 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;
- /* We use Ether-Type constants to destinguish packets */
+ }
+ /* We use EtherType constants to destinguish packet types */
PacketType = EType;
- } else
+ } else {
+ TI_DbgPrint(MIN_TRACE, ("Unsupported media.\n"));
/* 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);
+ return NDIS_STATUS_SUCCESS;
+ }
+ Adapter->TDPackets = PC(NdisPacket)->Context;
+
+ KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+
+ if (LookaheadBufferSize < PacketSize) {
+ NDIS_STATUS NdisStatus;
+ UINT BytesTransferred;
/* Get the data */
- 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,
- NdisPacket, NdisStatus, BytesTransferred);
+ NdisPacket,
+ NdisStatus,
+ BytesTransferred);
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:
break;
}
+ /* Release the packet descriptor */
+ KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+
+ PC(NdisPacket)->Context = Adapter->TDPackets;
+ Adapter->TDPackets = NdisPacket;
+
+ KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+
return NDIS_STATUS_SUCCESS;
}
* 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
*/
{
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
}
* 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;
- 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
switch (Adapter->Media) {
case NdisMedium802_3:
EHeader = (PETH_HEADER)Data;
-
- if (LinkAddress)
+
+ if (LinkAddress) {
/* Unicast address */
RtlCopyMemory(EHeader->DstAddr, LinkAddress, IEEE_802_ADDR_LENGTH);
- else
+ } else {
/* Broadcast address */
RtlFillMemory(EHeader->DstAddr, IEEE_802_ADDR_LENGTH, 0xFF);
+ }
RtlCopyMemory(EHeader->SrcAddr, Adapter->HWAddress, IEEE_802_ADDR_LENGTH);
EHeader->EType = ETYPE_IPv6;
break;
default:
-#if DBG
+#ifdef DBG
/* 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;
}
/* FIXME: Support other medias */
break;
}
-
+
NdisSend(&NdisStatus, Adapter->NdisHandle, NdisPacket);
if (NdisStatus != NDIS_STATUS_PENDING)
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NdisStatus);
- } else
+ } else {
ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NDIS_STATUS_CLOSED);
+ }
}
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;
- 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;
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;
}
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 */
- 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);
* 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;
UINT AddressOID;
UINT Speed;
- TI_DbgPrint(MAX_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
IF = ExAllocatePool(NonPagedPool, sizeof(LAN_ADAPTER));
- if (!IF)
+ if (!IF) {
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NDIS_STATUS_RESOURCES;
+ }
RtlZeroMemory(IF, sizeof(LAN_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)
}
/* 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 */
- 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);
}
/* 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 */
- 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);
}
/* 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);
*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);
- TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
+ TI_DbgPrint(DEBUG_DATALINK, ("Leaving.\n"));
return NDIS_STATUS_SUCCESS;
}
{
KIRQL OldIrql;
NDIS_HANDLE NdisHandle;
- PLAN_ADAPTER IF, PrevIF;
- BOOLEAN Found = FALSE;
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);
NdisCloseAdapter(&NdisStatus, NdisHandle);
if (NdisStatus == NDIS_STATUS_PENDING) {
KeWaitForSingleObject(&Adapter->Event,
- UserRequest, KernelMode, FALSE, NULL);
+ UserRequest,
+ KernelMode,
+ FALSE,
+ NULL);
NdisStatus = Adapter->NdisStatus;
}
} else
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));
- 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.ReceiveCompleteHandler = ProtocolReceiveComplete;
- ProtChars.StatusHandler = ProtocolStatus;
- ProtChars.StatusCompleteHandler = ProtocolStatusComplete;
+ ProtChars.ReceiveCompleteHandler = ProtocolReceiveComplete;
+ ProtChars.StatusHandler = ProtocolStatus;
+ ProtChars.StatusCompleteHandler = ProtocolStatusComplete;
/* 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;
* NOTES: Does not care wether we are already registered
*/
{
+ TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
+
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;
{
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);
- TI_DbgPrint(MAX_TRACE, ("Freeing IP packet at %X.\n", IPPacket));
+ TI_DbgPrint(DEBUG_ICMP, ("Freeing IP packet at %X.\n", IPPacket));
PoolFreeBuffer(IPPacket);
}
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;
- 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;
return NULL;
}
- 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);
return NULL;
}
- 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,
return NULL;
}
- 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);
PICMP_HEADER ICMPHeader;
PIP_PACKET NewPacket;
UINT DataSize;
- ULONG Checksum;
- TI_DbgPrint(MID_TRACE, ("Called.\n"));
+ TI_DbgPrint(DEBUG_ICMP, ("Called.\n"));
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;
}
/* Reply with an ICMP echo reply message */
DataSize = IPPacket->TotalSize - IPPacket->HeaderSize - sizeof(ICMP_HEADER);
NewPacket = PrepareICMPPacket(NTE, &IPPacket->SrcAddr, DataSize);
- if (!NewPacket)
+ if (!NewPacket) {
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return;
+ }
/* Copy ICMP header and data into new packet */
RtlCopyMemory(NewPacket->Data, IPPacket->Data, DataSize + sizeof(ICMP_HEADER));
ICMPTransmit(NTE, NewPacket);
- TI_DbgPrint(MID_TRACE, ("Echo reply sent.\n"));
+ TI_DbgPrint(DEBUG_ICMP, ("Echo reply sent.\n"));
return;
default:
- 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;
}
{
PROUTE_CACHE_NODE RCN;
- 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)
/* 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) */
- 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);
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);
- if (!NewPacket)
+ if (!NewPacket) {
+ TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return;
+ }
RtlCopyMemory((PVOID)((ULONG_PTR)NewPacket->Data + sizeof(ICMP_HEADER)),
IPPacket->Header, DataSize);