1309 lines
31 KiB
C
1309 lines
31 KiB
C
/*++
|
|
|
|
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;
|
|
}
|