able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/ip/wanarp2/send.c

1309 lines
31 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
ipinip\send.c
Abstract:
The file contains the part of interface of the IP in IP tunnel driver
to the TCP/IP stack that deals with sending data
The code is a cleaned up version of wanarp\ipif.c which in turn
was derived from HenrySa's ip\arp.c
Revision History:
AmritanR
--*/
#define __FILE_SIG__ SEND_SIG
#include "inc.h"
NDIS_STATUS
WanIpTransmit(
PVOID pvContext,
NDIS_PACKET **ppPacketArray,
UINT uiNumPackets,
DWORD dwDestAddr,
RouteCacheEntry *pRce,
PVOID pvLinkContext
)
/*++
Routine Description:
Function called by IP to send an array of packets. We allocate
one ETH_HEADER for each packet. The adapter (which is the pvContext)
is locked. If the adapter is not mapped, we fail the send, otherwise
we lock the interface. If
Locks:
Arguments:
pvContext Our context to IP for the interface - the PTUNNEL
ppPacketArray The array of NDIS_PACKETs to send
uiNumPackets The number of packets in the array
dwDestAddr The destination (next hop) address
pRce Pointer to RCE.
Return Value:
NDIS_STATUS_SUCCESS
--*/
{
PADAPTER pAdapter;
PUMODE_INTERFACE pInterface;
PADDRESS_CONTEXT pAddrContext;
PCONN_ENTRY pConnEntry;
KIRQL kiIrql;
NDIS_STATUS nsResult;
UINT i;
LIST_ENTRY leBufferList;
TraceEnter(SEND, "IpTransmit");
Trace(SEND,TRACE,
("IpTransmit: %d packet(s) over %p/%p to %d.%d.%d.%d\n",
uiNumPackets,
pvContext,
pvLinkContext,
PRINT_IPADDR(dwDestAddr)));
if(g_nhNdiswanBinding is NULL)
{
//
// In the process of shutting down, return
//
return NDIS_STATUS_ADAPTER_NOT_READY;
}
//
// Get the ethernet headers for each packet
//
if(!GetBufferListFromPool(&g_bpHeaderBufferPool,
uiNumPackets,
&leBufferList))
{
//
// Couldnt get headers for all the buffers
//
Trace(SEND, ERROR,
("IpTransmit: couldnt allocate %d header buffers\n",
uiNumPackets));
return NDIS_STATUS_RESOURCES;
}
//
// This function is not guaranteed to be at dispatch
// The context given to us is a pointer to our adapter
//
pConnEntry = NULL;
pAdapter = (PADAPTER)pvContext;
RtAcquireSpinLock(&(pAdapter->rlLock),
&kiIrql);
if(pAdapter->byState isnot AS_MAPPED)
{
//
// If the adapter is unmapped, the connection is disconnected
//
RtReleaseSpinLock(&(pAdapter->rlLock),
kiIrql);
FreeBufferListToPool(&g_bpHeaderBufferPool,
&leBufferList);
Trace(SEND, INFO,
("IpTransmit: Send on %x which is unmapped\n",
pAdapter));
//
// Cant increment stats because we dont have an interface
//
return NDIS_STATUS_ADAPTER_NOT_READY;
}
//
// Since the adapter is mapped, it must have an interface
//
pInterface = pAdapter->pInterface;
RtAssert(pInterface);
RtAcquireSpinLockAtDpcLevel(&(pInterface->rlLock));
//
// If interface is not yet connected (for demand dial case) the copy the
// packet and succeed the send.
//
if(pInterface->dwOperState isnot IF_OPER_STATUS_CONNECTED)
{
if(pInterface->duUsage isnot DU_ROUTER)
{
//
// Just a race condition
//
RtReleaseSpinLockFromDpcLevel(&(pInterface->rlLock));
RtReleaseSpinLock(&(pAdapter->rlLock),
kiIrql);
FreeBufferListToPool(&g_bpHeaderBufferPool,
&leBufferList);
return NDIS_STATUS_ADAPTER_NOT_READY;
}
//
// If IP is transmitting on us, he must have called out to
// connect
//
RtAssert(pInterface->dwOperState is IF_OPER_STATUS_CONNECTING);
Trace(SEND, INFO,
("IpTransmit: I/F not connected, queueing packet\n"));
//
// New function which queues the whole packet array
//
nsResult = WanpCopyAndQueuePackets(pAdapter,
ppPacketArray,
&leBufferList,
uiNumPackets);
RtReleaseSpinLockFromDpcLevel(&(pInterface->rlLock));
RtReleaseSpinLock(&(pAdapter->rlLock),
kiIrql);
if(nsResult isnot STATUS_SUCCESS)
{
FreeBufferListToPool(&g_bpHeaderBufferPool,
&leBufferList);
}
return nsResult;
}
//
// Find the connection entry for this send
//
if(pAdapter is g_pServerAdapter)
{
pConnEntry = (PCONN_ENTRY)pvLinkContext;
//RtAssert(pConnEntry);
//
// Hack for multicast
//
if(pConnEntry is NULL)
{
pConnEntry = WanpGetConnEntryGivenAddress(dwDestAddr);
}
//
// We are dont with the adapter lock. All we need is to lock down
// the connection entry
// It is important that we release the locks since for dial-in
// clients the locking hierarchy is CONN_ENTRY->ADAPTER->INTERFACE
//
if(pConnEntry)
{
ReferenceConnEntry(pConnEntry);
}
RtReleaseSpinLockFromDpcLevel(&(pAdapter->rlLock));
RtReleaseSpinLockFromDpcLevel(&(pInterface->rlLock));
//
// NOTE: The state of the connection can change in this window
//
if(pConnEntry)
{
RtAcquireSpinLockAtDpcLevel(&(pConnEntry->rlLock));
//
// Not a useful assert because (i) we add static routes to clients
// and (ii) we have that hack for netbt broadcasts
//
// RtAssert((pConnEntry->dwRemoteAddr is dwDestAddr) or
// (dwAddress is 0xFFFFFFFF));
}
}
else
{
//
// This send is on some adapter other than the server adapter
// Such an adapter has only one connection. For these sends we
// lock the adapter instead of the connection
//
pConnEntry = pAdapter->pConnEntry;
if(pConnEntry)
{
ReferenceConnEntry(pConnEntry);
RtAssert(pConnEntry->pAdapter is pAdapter);
}
}
//
// So now we have a locked connection entry (if client)
// or a locked adapter (for dial out and router)
//
if((pConnEntry is NULL) or
(pConnEntry->byState isnot CS_CONNECTED))
{
if((ULONG)(dwDestAddr & 0x000000FF) < (ULONG) 0x000000E0)
{
Trace(SEND, ERROR,
("IpTransmit: Could not find conn entry for %d.%d.%d.%d\n",
PRINT_IPADDR(dwDestAddr)));
}
for(i = 0; i < uiNumPackets; i++)
{
PLIST_ENTRY pleNode;
PNDIS_BUFFER pnbBuffer;
PVOID pvFirstBuffer;
UINT uiFirstBufLen, uiTotalLen;
PIP_HEADER pIpHeader;
NdisGetFirstBufferFromPacket(ppPacketArray[i],
&pnbBuffer,
&pvFirstBuffer,
&uiFirstBufLen,
&uiTotalLen);
pIpHeader = (PIP_HEADER)pvFirstBuffer;
RtAssert(pIpHeader);
RtAssert(uiFirstBufLen >= sizeof(IP_HEADER));
if(IsUnicastAddr(pIpHeader->dwDest))
{
pInterface->ulOutUniPkts++;
}
else
{
pInterface->ulOutNonUniPkts++;
}
}
//
// The entry has been disconnected.
// This is just a window in the timing
//
pInterface->ulOutDiscards += uiNumPackets;
if(pAdapter is g_pServerAdapter)
{
if(pConnEntry isnot NULL)
{
RtReleaseSpinLock(&(pConnEntry->rlLock),
kiIrql);
}
else
{
KeLowerIrql(kiIrql);
}
}
else
{
RtReleaseSpinLockFromDpcLevel(&(pAdapter->rlLock));
RtReleaseSpinLock(&(pInterface->rlLock),
kiIrql);
}
FreeBufferListToPool(&g_bpHeaderBufferPool,
&leBufferList);
if(pConnEntry)
{
DereferenceConnEntry(pConnEntry);
}
return NDIS_STATUS_ADAPTER_NOT_READY;
}
#if DBG
Trace(SEND, TRACE,
("IpTransmit: Send on %s\n",
pAdapter->asDeviceNameA.Buffer));
for(i = 0; i < uiNumPackets; i++)
{
PacketContext *pPC;
pPC = (PacketContext *)((ppPacketArray[i])->ProtocolReserved);
RtAssert(pPC->pc_common.pc_owner isnot PACKET_OWNER_LINK);
}
#endif
//
// This function will free the locks
//
nsResult = WanpSendPackets(pAdapter,
pInterface,
pConnEntry,
ppPacketArray,
&leBufferList,
uiNumPackets,
kiIrql);
if(nsResult isnot STATUS_SUCCESS)
{
Trace(SEND,TRACE,
("IpTransmit: SendPackets returned status %x\n",nsResult));
}
DereferenceConnEntry(pConnEntry);
return nsResult;
}
NDIS_STATUS
WanpSendPackets(
PADAPTER pAdapter,
PUMODE_INTERFACE pInterface,
PCONN_ENTRY pConnEntry,
NDIS_PACKET **ppPacketArray,
PLIST_ENTRY pleBufferList,
UINT uiNumPackets,
KIRQL kiIrql
)
/*++
Routine Description:
Main routine to send an array of packets
Locks:
Called with the connection entry (for dial in) or the adapter+interface
(all others) locked
Arguments:
pAdapter The adapter for the connection
pInterface The interface the adapter is mapped to
pConnEntry The connection entry for the send
ppPacketArray The array of packets to send
pBuffHead A list of buffers for the link layer header
uiNumPackets Number of packets (and ll header buffers)
kiIrql Irql at which the adapter or conn entry was locked
Return Value:
NDIS_STATUS_PENDING
--*/
{
NDIS_STATUS nsStatus;
PBYTE pbyHeader;
ULONG i;
#if DBG
Trace(SEND, TRACE,
("SendPackets: %s\n",
pAdapter->asDeviceNameA.Buffer));
#endif
for(i = 0; i < uiNumPackets; i++)
{
PNDIS_BUFFER pnbBuffer, pnbTempBuffer;
PLIST_ENTRY pleNode;
PVOID pvFirstBuffer;
UINT uiFirstBufLen, uiTotalBufLen, uiIpHdrLen;
PIP_HEADER pIpHeader;
PBUFFER_HEAD pBufferHead;
NdisGetFirstBufferFromPacket(ppPacketArray[i],
&pnbTempBuffer,
&pvFirstBuffer,
&uiFirstBufLen,
&uiTotalBufLen);
pIpHeader = (PIP_HEADER)pvFirstBuffer;
RtAssert(pIpHeader);
//
// ToDo: remove till NK fixes the bug in IP transmit
// with header inc
//
// RtAssert(uiFirstBufLen >= sizeof(IP_HEADER));
#if L2TP_DBG
#define L2TP_PORT_NBO 0xA506 // 1701 == 06A5
//
// If this is a l2tp packet, break
//
if(pIpHeader->byProtocol is 17)
{
WORD UNALIGNED *pwPort;
//
// See if we have enough data to get to the UDP header in
// the first buffer
//
uiIpHdrLen = LengthOfIpHeader(pIpHeader);
if(uiFirstBufLen >= uiIpHdrLen + sizeof(ULONG))
{
pwPort = (WORD UNALIGNED *)((ULONG_PTR)pIpHeader + uiIpHdrLen);
}
else
{
PNDIS_BUFFER pNextBuf;
//
// Get the next buffer and look into its
//
pNextBuf = pnbTempBuffer->Next;
pwPort = (WORD UNALIGNED *)(pnbTempBuffer->MappedSystemVa);
}
if((pwPort[0] is L2TP_PORT_NBO) or
(pwPort[1] is L2TP_PORT_NBO))
{
Trace(SEND, ERROR,
("SendPackets: %x buffer %x header %x port %d.%d\n",
pnbTempBuffer, pIpHeader, pwPort,
pwPort[0], pwPort[1]));
RtAssert(FALSE);
}
}
#endif
//
// NOTE: If this is a client send, the server interface is not
// locked. Hence the stats can be inconsistent for the server
// interface
//
if(IsUnicastAddr(pIpHeader->dwDest))
{
pInterface->ulOutUniPkts++;
}
else
{
pInterface->ulOutNonUniPkts++;
}
pleNode = RemoveHeadList(pleBufferList);
#if LIST_DBG
pBufferHead = CONTAINING_RECORD(pleNode,
BUFFER_HEAD,
leListLink);
RtAssert(IsListEmpty(&(pBufferHead->leFreeBufferLink)));
RtAssert(pBufferHead->bBusy);
pBufferHead->leListLink.Flink = NULL;
pBufferHead->leListLink.Blink = NULL;
#else
pBufferHead = CONTAINING_RECORD(pleNode,
BUFFER_HEAD,
leFreeBufferLink);
#endif
//
// Get a pointer to the data and to the buffer
//
pbyHeader = BUFFER_FROM_HEAD(pBufferHead);
pnbBuffer = pBufferHead->pNdisBuffer;
//
// Copy our prebuilt header into each buffer
//
RtlCopyMemory(pbyHeader,
&(pConnEntry->ehHeader),
sizeof(ETH_HEADER));
//
// Put the ethernet header in the front of the packet
//
NdisChainBufferAtFront(ppPacketArray[i],
pnbBuffer);
//
// Reference the entry once for each packet
//
ReferenceConnEntry(pConnEntry);
#if PKT_DBG
Trace(SEND, ERROR,
("SendPackets: Pkt %x Eth buff %x (%x) Header %x (%x)\n",
ppPacketArray[1],
pnbBuffer,
pbyHeader,
pnbTempBuffer,
pvFirstBuffer));
#endif // PKT_DBG
}
//
// Increment the output queue length. This will be decremented
// in the send complete handler
//
pAdapter->ulQueueLen++;
//
// Let go of the locks
//
if(pConnEntry->duUsage isnot DU_CALLIN)
{
RtReleaseSpinLockFromDpcLevel(&(pInterface->rlLock));
}
RtReleaseSpinLock(pConnEntry->prlLock,
kiIrql);
NdisSendPackets(g_nhNdiswanBinding,
ppPacketArray,
uiNumPackets);
//
// Dont dereference the connection entry. We will deref it in
// the send complete handler
//
return NDIS_STATUS_PENDING;
}
VOID
WanNdisSendComplete(
NDIS_HANDLE nhHandle,
PNDIS_PACKET pnpPacket,
NDIS_STATUS nsStatus
)
/*++
Routine Description:
Our send complete handler called by NDIS once for each packet that was
pending after a send.
Locks:
Arguments:
Return Value:
--*/
{
PacketContext *pPC;
PNDIS_BUFFER pnbBuffer, pnbEthBuffer;
KIRQL kiIrql;
PADAPTER pAdapter;
PUMODE_INTERFACE pInterface;
PCONN_ENTRY pConnEntry;
PETH_HEADER pEthHeader;
ULONG ulIndex;
PVOID pvFirstBuffer;
UINT uiFirstBufLen, uiTotalLen;
TraceEnter(SEND, "NdisSendComplete");
//
// Get first buffer on packet. This is our ethernet header buffer
//
NdisUnchainBufferAtFront(pnpPacket,
&pnbEthBuffer);
//
// Get the fake ethernet header
//
pEthHeader = NdisBufferVirtualAddress(pnbEthBuffer);
#if DBG
//
// The buffer head should say the same thing
//
RtAssert(pnbEthBuffer is ((HEAD_FROM_BUFFER(pEthHeader))->pNdisBuffer));
#endif
ulIndex = GetConnIndexFromAddr(pEthHeader->rgbySourceAddr);
//
// Done with our buffer
//
FreeBufferToPool(&g_bpHeaderBufferPool,
(PBYTE)pEthHeader);
//
// Get the connection entry
//
RtAcquireSpinLock(&g_rlConnTableLock,
&kiIrql);
pConnEntry = GetConnEntryGivenIndex(ulIndex);
if(pConnEntry is NULL)
{
RtAssert(FALSE);
RtReleaseSpinLock(&g_rlConnTableLock,
kiIrql);
Trace(SEND, ERROR,
("NdisSendComplete: Couldnt find entry for connection %d\n",
ulIndex));
TraceLeave(RCV, "NdisSendComplete");
return;
}
RtAcquireSpinLockAtDpcLevel(pConnEntry->prlLock);
RtReleaseSpinLockFromDpcLevel(&g_rlConnTableLock);
pAdapter = pConnEntry->pAdapter;
#if DBG
Trace(SEND, INFO,
("NdisSendComplete: Extracted adapter %x with name %s\n",
pAdapter,
pAdapter->asDeviceNameA.Buffer));
#endif
pAdapter->ulQueueLen--;
if(pConnEntry->duUsage is DU_CALLIN)
{
pInterface = g_pServerInterface;
RtAssert(pAdapter is g_pServerAdapter);
}
else
{
//
// See if we are still mapped to an interface, if so lock it
//
pInterface = pAdapter->pInterface;
if(pInterface isnot NULL)
{
RtAcquireSpinLockAtDpcLevel(&(pInterface->rlLock));
}
}
//
// Right now we have the adapter + interface or the connection entry
// locked.
//
if(nsStatus is NDIS_STATUS_SUCCESS)
{
NdisGetFirstBufferFromPacket(pnpPacket,
&pnbBuffer,
&pvFirstBuffer,
&uiFirstBufLen,
&uiTotalLen);
if(pInterface)
{
pInterface->ulOutOctets += uiTotalLen;
}
#if PKT_DBG
Trace(SEND, ERROR,
("NdisSendComplete: Pkt %x Eth buff %x (%x) Header %x (%x)\n",
pnpPacket,
pnbEthBuffer,
pEthHeader,
pnbBuffer,
pvFirstBuffer));
#endif PKT_DBG
}
else
{
Trace(SEND, INFO,
("NdisSendComplete: Failed %x\n",
nsStatus));
if(pInterface)
{
pInterface->ulOutDiscards++;
}
}
//
// If this is not our packet return it to the protocol
//
pPC = (PacketContext *)pnpPacket->ProtocolReserved;
//
// Unlock
//
if(pConnEntry->duUsage isnot DU_CALLIN)
{
if(pInterface isnot NULL)
{
RtReleaseSpinLockFromDpcLevel(&(pInterface->rlLock));
}
}
RtReleaseSpinLock(pConnEntry->prlLock,
kiIrql);
if(pPC->pc_common.pc_owner isnot PACKET_OWNER_LINK)
{
Trace(SEND, TRACE,
("NdisSendComplete: Calling IPSendComplete for %p over %p(%p)\n",
pnpPacket,
pAdapter,
pAdapter->pvIpContext));
g_pfnIpSendComplete(pAdapter->pvIpContext,
pnpPacket,
nsStatus);
}
else
{
//
// Free all buffers from our packet and then the packet itself
//
Trace(SEND, TRACE,
("NdisSendComplete: Not calling IPSendComplete for %p\n",
pnpPacket));
WanpFreePacketAndBuffers(pnpPacket);
}
//
// Deref the conn entry for the send and for the fact that
// GetConnEntry.. put a ref on it
//
DereferenceConnEntry(pConnEntry);
DereferenceConnEntry(pConnEntry);
return;
}
VOID
WanpTransmitQueuedPackets(
IN PADAPTER pAdapter,
IN PUMODE_INTERFACE pInterface,
IN PCONN_ENTRY pConnEntry,
IN KIRQL kiIrql
)
{
ULONG i;
PNDIS_PACKET rgPacketArray[64];
NDIS_PACKET **ppPacketArray;
LIST_ENTRY leBufferList, *pleNode;
//
// This is only called for ROUTER interfaces
//
RtAssert(pConnEntry->duUsage is DU_ROUTER);
RtAssert(pInterface->duUsage is DU_ROUTER);
//
// If there are no packets to transmit, just release the
// locks
//
if(pInterface->ulPacketsPending is 0)
{
RtAssert(IsListEmpty(&(pAdapter->lePendingPktList)));
RtAssert(IsListEmpty(&(pAdapter->lePendingHdrList)));
RtReleaseSpinLockFromDpcLevel(&(pInterface->rlLock));
RtReleaseSpinLock(&(pAdapter->rlLock),
kiIrql);
return;
}
if(pInterface->ulPacketsPending <= 64)
{
//
// Just use the stack array
//
ppPacketArray = rgPacketArray;
}
else
{
//
// Allocate a packet array
//
ppPacketArray =
RtAllocate(NonPagedPool,
sizeof(PNDIS_PACKET) * pInterface->ulPacketsPending,
WAN_CONN_TAG);
if(ppPacketArray is NULL)
{
Trace(SEND, ERROR,
("TransmitQueuedPackets: Unable to allocate %d pointers\n",
pInterface->ulPacketsPending));
while(!IsListEmpty(&(pAdapter->lePendingPktList)))
{
PNDIS_PACKET pnpPacket;
pleNode = RemoveHeadList(&(pAdapter->lePendingPktList));
//
// get to the packet structure in which LIST_ENTRY is embedded
//
pnpPacket = CONTAINING_RECORD(pleNode,
NDIS_PACKET,
MacReserved);
WanpFreePacketAndBuffers(pnpPacket);
}
while(!IsListEmpty(&(pAdapter->lePendingHdrList)))
{
PBYTE pbyHeader;
PBUFFER_HEAD pBuffHead;
pleNode = RemoveHeadList(&(pAdapter->lePendingHdrList));
#if LIST_DBG
pBuffHead = CONTAINING_RECORD(pleNode,
BUFFER_HEAD,
leListLink);
RtAssert(IsListEmpty(&(pBuffHead->leFreeBufferLink)));
RtAssert(pBuffHead->bBusy);
pBuffHead->leListLink.Flink = NULL;
pBuffHead->leListLink.Blink = NULL;
#else
pBuffHead = CONTAINING_RECORD(pleNode,
BUFFER_HEAD,
leFreeBufferLink);
#endif
pbyHeader = BUFFER_FROM_HEAD(pBuffHead);
FreeBufferToPool(&g_bpHeaderBufferPool,
pbyHeader);
}
}
}
for(i = 0, pleNode = pAdapter->lePendingPktList.Flink;
pleNode isnot &(pAdapter->lePendingPktList);
pleNode = pleNode->Flink, i++)
{
PNDIS_PACKET pnpPacket;
pnpPacket = CONTAINING_RECORD(pleNode,
NDIS_PACKET,
MacReserved);
ppPacketArray[i] = pnpPacket;
}
RtAssert(i is pInterface->ulPacketsPending);
#if DBG
for(i = 0, pleNode = pAdapter->lePendingHdrList.Flink;
pleNode isnot &(pAdapter->lePendingHdrList);
pleNode = pleNode->Flink, i++);
RtAssert(i is pInterface->ulPacketsPending);
#endif
//
// copy out the pending hdr list to leBufferList.
//
leBufferList = pAdapter->lePendingHdrList;
pAdapter->lePendingHdrList.Flink->Blink = &leBufferList;
pAdapter->lePendingHdrList.Blink->Flink = &leBufferList;
pInterface->ulPacketsPending = 0;
InitializeListHead(&(pAdapter->lePendingPktList));
InitializeListHead(&(pAdapter->lePendingHdrList));
WanpSendPackets(pAdapter,
pInterface,
pConnEntry,
ppPacketArray,
&leBufferList,
pInterface->ulPacketsPending,
kiIrql);
if(rgPacketArray isnot ppPacketArray)
{
RtFree(ppPacketArray);
}
}
NDIS_STATUS
WanpCopyAndQueuePackets(
PADAPTER pAdapter,
NDIS_PACKET **ppPacketArray,
PLIST_ENTRY pleBufferList,
UINT uiNumPackets
)
/*++
Routine Description:
This routine queues the packet to the adapter
Once this routine is called, the caller can not touch the pleListHead
Locks:
The ADAPTER must be locked and mapped
The interface the adapter is mapped to must also be locked
Arguments:
pAdapter
ppPacketArray
pBuffHead
uiNumPackets
Return Value:
NDIS_STATUS_SUCCESS
STATUS_QUOTA_EXCEEDED
NDIS_STATUS_RESOURCES
--*/
{
PacketContext *pPC;
NDIS_STATUS nsStatus;
PLIST_ENTRY pleNode;
ULONG i;
#if DBG
ULONG ulPended = 0, ulHdrs = 0;
#endif
TraceEnter(SEND, "CopyAndQueuePackets");
if(pAdapter->pInterface->ulPacketsPending >= WANARP_MAX_PENDING_PACKETS)
{
Trace(SEND, WARN,
("CopyAndQueuePackets: Dropping packets since cap exceeded\n"));
return STATUS_QUOTA_EXCEEDED;
}
for(i = 0; i < uiNumPackets; i++)
{
PNDIS_PACKET pnpPacket;
UINT uiTotalLen, uiBytesCopied;
//
// Get size of buffers required
//
NdisQueryPacket(ppPacketArray[i],
NULL,
NULL,
NULL,
&uiTotalLen);
//
// Allocate a packet.
//
pnpPacket = NULL;
NdisAllocatePacket(&nsStatus,
&pnpPacket,
g_nhPacketPool);
if(nsStatus isnot NDIS_STATUS_SUCCESS)
{
Trace(SEND, ERROR,
("CopyAndQueuePackets: Cant allocate packet. %x\n",
nsStatus));
}
else
{
//
// Allocate buffers for the packet
//
nsStatus = GetBufferChainFromPool(&g_bpDataBufferPool,
pnpPacket,
uiTotalLen,
NULL,
NULL);
}
if(nsStatus is STATUS_SUCCESS)
{
//
// If we got a packet and the buffers, then copy from TCP/IP's
// packet into ours
//
NdisCopyFromPacketToPacket(pnpPacket,
0,
uiTotalLen,
ppPacketArray[i],
0,
&uiBytesCopied);
RtAssert(uiBytesCopied is uiTotalLen);
//
// This is now our packet, so set its context
//
pPC = (PacketContext *)pnpPacket->ProtocolReserved;
pPC->pc_common.pc_owner = PACKET_OWNER_LINK;
//
// Attach Packet to pending packet list
// We use the MacReserved portion as the list entry
//
InsertTailList(&pAdapter->lePendingPktList,
(PLIST_ENTRY)&(pnpPacket->MacReserved));
pAdapter->pInterface->ulPacketsPending++;
#if DBG
ulPended++;
#endif
}
else
{
PBUFFER_HEAD pBufferHead;
PBYTE pbyHeader;
//
// We either have no packet, or couldnt get a buffer.
// Nasty Nasty: Side effect of such a failure is that we free
// one of the header buffers
//
RtAssert(!IsListEmpty(pleBufferList));
pleNode = RemoveHeadList(pleBufferList);
#if LIST_DBG
pBufferHead = CONTAINING_RECORD(pleNode,
BUFFER_HEAD,
leListLink);
RtAssert(IsListEmpty(&(pBufferHead->leFreeBufferLink)));
RtAssert(pBufferHead->bBusy);
pBufferHead->leListLink.Flink = NULL;
pBufferHead->leListLink.Blink = NULL;
#else
pBufferHead = CONTAINING_RECORD(pleNode,
BUFFER_HEAD,
leFreeBufferLink);
#endif
//
// Get a pointer to the data and to the buffer
//
pbyHeader = BUFFER_FROM_HEAD(pBufferHead);
FreeBufferToPool(&g_bpHeaderBufferPool,
pbyHeader);
if(pnpPacket)
{
NdisFreePacket(pnpPacket);
}
}
}
//
// we have queued all the packets we could, and for the ones we
// failed, we freed the corresponding ethernet header.
// So the number of headers left on pleBufferList should be the number of
// packets queued
//
if(!IsListEmpty(pleBufferList))
{
#if DBG
for(pleNode = pleBufferList->Flink;
pleNode isnot pleBufferList;
pleNode = pleNode->Flink)
{
ulHdrs++;
}
#endif
//
// Add the headers to the front of the adapter chain
//
pleBufferList->Blink->Flink = pAdapter->lePendingHdrList.Flink;
pleBufferList->Flink->Blink = &(pAdapter->lePendingHdrList);
pAdapter->lePendingHdrList.Flink->Blink = pleBufferList->Blink;
pAdapter->lePendingHdrList.Flink = pleBufferList->Flink;
}
#if DBG
RtAssert(ulPended is ulHdrs);
#endif
return NDIS_STATUS_SUCCESS;
}
VOID
WanpFreePacketAndBuffers(
PNDIS_PACKET pnpPacket
)
{
PNDIS_BUFFER pnbFirstBuffer;
FreeBufferChainToPool(&g_bpDataBufferPool,
pnpPacket);
NdisFreePacket(pnpPacket);
}
VOID
WanIpInvalidateRce(
PVOID pvContext,
RouteCacheEntry *pRce
)
{
return;
}
Reference in a new issue Copy permalink