mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1250 lines
29 KiB
1250 lines
29 KiB
/*++
|
|
|
|
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"
|
|
|
|
IP_STATUS
|
|
SendICMPErr(IPAddr Src, IPHeader UNALIGNED *Header, uchar Type, uchar Code,
|
|
ulong Pointer);
|
|
|
|
VOID
|
|
SendIcmpError(
|
|
DWORD dwLocalAddress,
|
|
PNDIS_BUFFER pnbFirstBuff,
|
|
PVOID pvFirstData,
|
|
ULONG ulFirstLen,
|
|
BYTE byType,
|
|
BYTE byCode
|
|
);
|
|
|
|
NDIS_STATUS
|
|
IpIpSend(
|
|
PVOID pvContext,
|
|
NDIS_PACKET **ppPacketArray,
|
|
UINT uiNumPackets,
|
|
DWORD dwDestAddr,
|
|
RouteCacheEntry *pRce,
|
|
PVOID pvLinkContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Function called by IP to send a packet
|
|
|
|
Locks
|
|
|
|
The TUNNEL is refcounted (by virtue of being in IP)
|
|
|
|
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.
|
|
pvLinkContext Only for P2MP interfaces
|
|
|
|
Return Value
|
|
|
|
NDIS_STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
PTUNNEL pTunnel;
|
|
PWORK_QUEUE_ITEM pWorkItem;
|
|
PQUEUE_NODE pQueueNode;
|
|
KIRQL kiIrql;
|
|
DWORD dwLastAddr;
|
|
|
|
#if PROFILE
|
|
|
|
LONGLONG llTime, llNow;
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&llTime);
|
|
|
|
#endif
|
|
|
|
TraceEnter(SEND, "IpIpSend");
|
|
|
|
pTunnel = (PTUNNEL)pvContext;
|
|
|
|
//
|
|
// TODO: No one has a clue as to how to deal with multi-packet
|
|
// sends. Right now we assume we get one packet. Later we can fix this
|
|
//
|
|
|
|
RtAssert(uiNumPackets is 1);
|
|
|
|
//
|
|
// All our packets are queued onto the TUNNEL before the transmit
|
|
// routine is called. Allocate a link in the queue
|
|
//
|
|
|
|
pQueueNode = AllocateQueueNode();
|
|
|
|
if(pQueueNode is NULL)
|
|
{
|
|
//
|
|
// Running out of memory
|
|
//
|
|
|
|
Trace(SEND, INFO,
|
|
("IpIpSend: Couldnt allocate queue node\n"));
|
|
|
|
TraceLeave(SEND, "IpIpSend");
|
|
|
|
return NDIS_STATUS_RESOURCES;
|
|
}
|
|
|
|
pWorkItem = &(pQueueNode->WorkItem);
|
|
|
|
pQueueNode->ppPacketArray = &(pQueueNode->pnpPacket);
|
|
pQueueNode->pnpPacket = ppPacketArray[0];
|
|
pQueueNode->uiNumPackets = uiNumPackets;
|
|
pQueueNode->dwDestAddr = dwDestAddr;
|
|
|
|
//
|
|
// If we are not at PASSIVE, just schedule a worker to come back and
|
|
// handle this
|
|
//
|
|
|
|
if(KeGetCurrentIrql() > PASSIVE_LEVEL)
|
|
{
|
|
Trace(SEND, INFO,
|
|
("IpIpSend: Irql too high, queueing packet\n"));
|
|
|
|
//
|
|
// We dont need to reference the TUNNEL because IP has a reference
|
|
// to the INTERFACE
|
|
//
|
|
|
|
RtAcquireSpinLockAtDpcLevel(&(pTunnel->rlLock));
|
|
|
|
//
|
|
// Hack for quenching ICMP errors to the same destination
|
|
//
|
|
|
|
dwLastAddr = 0;
|
|
|
|
if(pTunnel->dwOperState isnot IF_OPER_STATUS_OPERATIONAL)
|
|
{
|
|
ULONG i, ulFirstLen, ulTotalLen;
|
|
PNDIS_PACKET pnpPacket;
|
|
PNDIS_BUFFER pnbFirstBuff, pnbNewBuffer;
|
|
PVOID pvFirstData;
|
|
PIP_HEADER pHeader;
|
|
|
|
//
|
|
// Cant transmit on this, either because we are deleting this
|
|
// interface, or because the admin has shut us down
|
|
//
|
|
|
|
for(i = 0; i < uiNumPackets; i++)
|
|
{
|
|
pnpPacket = ppPacketArray[i];
|
|
|
|
//
|
|
// Get the information about the packet and buffer
|
|
//
|
|
|
|
NdisGetFirstBufferFromPacket(pnpPacket,
|
|
&pnbFirstBuff,
|
|
&pvFirstData,
|
|
&ulFirstLen,
|
|
&ulTotalLen);
|
|
|
|
RtAssert(pvFirstData isnot NULL);
|
|
|
|
RtAssert(ulFirstLen >= sizeof(IP_HEADER));
|
|
|
|
pHeader = (PIP_HEADER)pvFirstData;
|
|
|
|
if(IsUnicastAddr(pHeader->dwDest))
|
|
{
|
|
pTunnel->ulOutUniPkts++;
|
|
}
|
|
else
|
|
{
|
|
pTunnel->ulOutNonUniPkts++;
|
|
}
|
|
|
|
pTunnel->ulOutDiscards++;
|
|
|
|
//
|
|
// Send an ICMP error
|
|
//
|
|
|
|
if(dwLastAddr isnot pHeader->dwSrc)
|
|
{
|
|
SendIcmpError(pTunnel->LOCALADDR,
|
|
pnbFirstBuff,
|
|
pvFirstData,
|
|
ulFirstLen,
|
|
ICMP_TYPE_DEST_UNREACHABLE,
|
|
ICMP_CODE_HOST_UNREACHABLE);
|
|
|
|
dwLastAddr = pHeader->dwSrc;
|
|
}
|
|
|
|
}
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
|
|
FreeQueueNode(pQueueNode);
|
|
|
|
Trace(SEND, INFO,
|
|
("IpIpSend: Tunnel %x has admin state %d so not sending\n",
|
|
pTunnel,
|
|
pTunnel->dwAdminState));
|
|
|
|
|
|
TraceLeave(SEND, "IpIpSend");
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Insert at the end of the queue
|
|
//
|
|
|
|
InsertTailList(&(pTunnel->lePacketQueueHead),
|
|
&(pQueueNode->leQueueItemLink));
|
|
|
|
#if PROFILE
|
|
|
|
//
|
|
// The time at which IP called us for these packets
|
|
//
|
|
|
|
pQueueNode->llSendTime = llTime;
|
|
|
|
#endif
|
|
if(pTunnel->bWorkItemQueued is FALSE)
|
|
{
|
|
//
|
|
// Need to schedule a work item since one is not already scheduled
|
|
//
|
|
|
|
ExInitializeWorkItem(pWorkItem,
|
|
IpIpDelayedSend,
|
|
pTunnel);
|
|
|
|
|
|
//
|
|
// TODO: For delayed sends we ref the tunnel. Do we need to?
|
|
//
|
|
|
|
ReferenceTunnel(pTunnel);
|
|
|
|
//
|
|
// Reference the driver since the worker has to be scheduled
|
|
//
|
|
|
|
RtAcquireSpinLockAtDpcLevel(&g_rlStateLock);
|
|
|
|
g_ulNumThreads++;
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&g_rlStateLock);
|
|
|
|
pTunnel->bWorkItemQueued = TRUE;
|
|
|
|
|
|
ExQueueWorkItem(pWorkItem,
|
|
CriticalWorkQueue);
|
|
|
|
}
|
|
|
|
#if PROFILE
|
|
|
|
//
|
|
// We update this field after queing the work item, but it is
|
|
// still safe since the field is protected by the tunnel lock
|
|
// This is the time at which the work item was queued
|
|
//
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&(pQueueNode->llCallTime));
|
|
|
|
#endif
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
|
|
|
|
TraceLeave(SEND, "IpIpSend");
|
|
|
|
return NDIS_STATUS_PENDING;
|
|
}
|
|
|
|
//
|
|
// We dont need to reference the TUNNEL because IP has a reference to
|
|
// the INTERFACE
|
|
//
|
|
|
|
//
|
|
// If we are here, it is because we are at passive
|
|
//
|
|
|
|
|
|
//
|
|
// Just hook the queue item to the end of the list and call the
|
|
// transmit routine
|
|
//
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&kiIrql);
|
|
|
|
InsertTailList(&(pTunnel->lePacketQueueHead),
|
|
&(pQueueNode->leQueueItemLink));
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
kiIrql);
|
|
|
|
#if PROFILE
|
|
|
|
pQueueNode->llSendTime = llTime;
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&llNow);
|
|
|
|
pQueueNode->llCallTime = llNow;
|
|
|
|
#endif
|
|
|
|
IpIpTransmit(pTunnel,
|
|
FALSE);
|
|
|
|
return NDIS_STATUS_PENDING;
|
|
}
|
|
|
|
|
|
VOID
|
|
IpIpDelayedSend(
|
|
PVOID pvContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
The worker function called when we find that the send from IP was
|
|
not at PASSIVE
|
|
|
|
Locks
|
|
|
|
None
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
PTUNNEL pTunnel;
|
|
ULONG i;
|
|
KIRQL irql;
|
|
NDIS_STATUS nsStatus;
|
|
|
|
|
|
TraceEnter(SEND, "IpIpDelayedSend");
|
|
|
|
pTunnel = (PTUNNEL)pvContext;
|
|
|
|
RtAssert(pTunnel);
|
|
|
|
IpIpTransmit(pTunnel,
|
|
TRUE);
|
|
|
|
//
|
|
// Either IpIpTransmit or TdixSendComplete will do the SendComplete
|
|
//
|
|
|
|
|
|
//
|
|
// We referenced the tunnel if we put it on the work queue
|
|
// Deref it now
|
|
//
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
RtAcquireSpinLock(&g_rlStateLock,
|
|
&irql);
|
|
|
|
g_ulNumThreads--;
|
|
|
|
if((g_dwDriverState is DRIVER_STOPPED) and
|
|
(g_ulNumThreads is 0))
|
|
{
|
|
KeSetEvent(&g_keStateEvent,
|
|
0,
|
|
FALSE);
|
|
}
|
|
|
|
RtReleaseSpinLock(&g_rlStateLock,
|
|
irql);
|
|
|
|
TraceLeave(SEND, "IpIpDelayedSend");
|
|
}
|
|
|
|
VOID
|
|
IpIpTransmit(
|
|
PTUNNEL pTunnel,
|
|
BOOLEAN bFromWorker
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Called to transmit any queued packets on the tunnel
|
|
|
|
Locks
|
|
|
|
This MUST be called at passive
|
|
|
|
Arguments
|
|
|
|
pTunnel The tunnel whose queue needs to be transmitted
|
|
bFromWorker TRUE if called off a worker
|
|
|
|
Return Value
|
|
|
|
None
|
|
This is an implicit asynchronous call
|
|
|
|
--*/
|
|
|
|
{
|
|
PIP_HEADER pHeader, pNewHeader;
|
|
USHORT usLength;
|
|
KIRQL irql;
|
|
UINT i;
|
|
ULONG ulFirstLen, ulTotalLen;
|
|
PNDIS_PACKET pnpPacket;
|
|
PNDIS_BUFFER pnbFirstBuff, pnbNewBuffer;
|
|
PVOID pvFirstData;
|
|
NTSTATUS nStatus;
|
|
PLIST_ENTRY pleNode;
|
|
PQUEUE_NODE pQueueNode;
|
|
|
|
#if PROFILE
|
|
|
|
LONGLONG llCurrentTime;
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&llCurrentTime);
|
|
|
|
#endif
|
|
|
|
TraceEnter(SEND, "IpIpTransmit");
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
|
|
if(pTunnel->dwOperState isnot IF_OPER_STATUS_OPERATIONAL)
|
|
{
|
|
//
|
|
// Cant transmit on this, either because we are deleting this
|
|
// interface, or because the admin has shut us down
|
|
// Just walk all the packets, increment the stats and then
|
|
// call SendComplete for the packet
|
|
//
|
|
|
|
while(!IsListEmpty(&(pTunnel->lePacketQueueHead)))
|
|
{
|
|
DWORD dwLastAddr;
|
|
|
|
pleNode = RemoveHeadList(&(pTunnel->lePacketQueueHead));
|
|
|
|
pQueueNode = CONTAINING_RECORD(pleNode,
|
|
QUEUE_NODE,
|
|
leQueueItemLink);
|
|
|
|
dwLastAddr = 0;
|
|
|
|
for(i = 0; i < pQueueNode->uiNumPackets; i++)
|
|
{
|
|
|
|
pnpPacket = pQueueNode->ppPacketArray[i];
|
|
|
|
//
|
|
// Get the information about the packet and buffer
|
|
//
|
|
|
|
NdisGetFirstBufferFromPacket(pnpPacket,
|
|
&pnbFirstBuff,
|
|
&pvFirstData,
|
|
&ulFirstLen,
|
|
&ulTotalLen);
|
|
|
|
RtAssert(pvFirstData isnot NULL);
|
|
|
|
RtAssert(ulFirstLen >= sizeof(IP_HEADER));
|
|
|
|
pHeader = (PIP_HEADER)pvFirstData;
|
|
|
|
if(IsUnicastAddr(pHeader->dwDest))
|
|
{
|
|
pTunnel->ulOutUniPkts++;
|
|
}
|
|
else
|
|
{
|
|
pTunnel->ulOutNonUniPkts++;
|
|
}
|
|
|
|
pTunnel->ulOutDiscards++;
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
//
|
|
// Send an ICMP error
|
|
//
|
|
|
|
if(dwLastAddr isnot pHeader->dwSrc)
|
|
{
|
|
SendIcmpError(pTunnel->LOCALADDR,
|
|
pnbFirstBuff,
|
|
pvFirstData,
|
|
ulFirstLen,
|
|
ICMP_TYPE_DEST_UNREACHABLE,
|
|
ICMP_CODE_HOST_UNREACHABLE);
|
|
|
|
dwLastAddr = pHeader->dwSrc;
|
|
}
|
|
|
|
g_pfnIpSendComplete(pTunnel->pvIpContext,
|
|
pnpPacket,
|
|
NDIS_STATUS_ADAPTER_NOT_READY);
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
}
|
|
|
|
FreeQueueNode(pQueueNode);
|
|
|
|
}
|
|
|
|
if(bFromWorker)
|
|
{
|
|
pTunnel->bWorkItemQueued = FALSE;
|
|
}
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
TraceLeave(SEND, "IpIpTransmit");
|
|
|
|
return;
|
|
}
|
|
|
|
while(!IsListEmpty(&(pTunnel->lePacketQueueHead)))
|
|
{
|
|
pleNode = RemoveHeadList(&(pTunnel->lePacketQueueHead));
|
|
|
|
pQueueNode = CONTAINING_RECORD(pleNode,
|
|
QUEUE_NODE,
|
|
leQueueItemLink);
|
|
|
|
for(i = 0; i < pQueueNode->uiNumPackets; i++)
|
|
{
|
|
|
|
pnpPacket = pQueueNode->ppPacketArray[i];
|
|
|
|
//
|
|
// Get the information about the packet and buffer
|
|
//
|
|
|
|
NdisGetFirstBufferFromPacket(pnpPacket,
|
|
&pnbFirstBuff,
|
|
&pvFirstData,
|
|
&ulFirstLen,
|
|
&ulTotalLen);
|
|
|
|
RtAssert(pvFirstData isnot NULL);
|
|
|
|
//
|
|
// Remove this till NK fixes the bug in IPTransmit
|
|
// NB:
|
|
//RtAssert(ulFirstLen >= sizeof(IP_HEADER));
|
|
|
|
pHeader = (PIP_HEADER)pvFirstData;
|
|
|
|
if(IsUnicastAddr(pHeader->dwDest))
|
|
{
|
|
pTunnel->ulOutUniPkts++;
|
|
}
|
|
else
|
|
{
|
|
pTunnel->ulOutNonUniPkts++;
|
|
|
|
if(IsClassEAddr(pHeader->dwDest))
|
|
{
|
|
//
|
|
// Bad address - throw it away
|
|
//
|
|
|
|
pTunnel->ulOutErrors++;
|
|
|
|
//
|
|
// Release the spinlock, call IP's SendComplete,
|
|
// reacquire the spinlock and continue processing the
|
|
// array
|
|
//
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
g_pfnIpSendComplete(pTunnel->pvIpContext,
|
|
pnpPacket,
|
|
NDIS_STATUS_INVALID_PACKET);
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// We dont need to muck with the TTL, since the IP stack would have
|
|
// decremented it
|
|
//
|
|
|
|
//
|
|
// RFC 2003 pg 6:
|
|
// If the IP Source Address of the datagram matches router's own
|
|
// IP Address, on any of its network interfaces, the router MUST NOT
|
|
// tunnel the datagram; instead the datagram SHOULD be discarded
|
|
//
|
|
|
|
// TODO: This means comparing it against all the addresses that we
|
|
// have
|
|
|
|
|
|
//
|
|
// RFC 2003 pg 6:
|
|
// If the IP Source Address of the datagram matches the IP Address
|
|
// of the Tunnel Destination, the router MUST NOT tunnel the
|
|
// datagram; instead the datagram SHOULD be discarded
|
|
//
|
|
|
|
if(pHeader->dwDest is pTunnel->REMADDR)
|
|
{
|
|
Trace(SEND, ERROR,
|
|
("IpIpTransmit: Packet # %d had dest of %d.%d.%d.%d which matches the remote endpoint\n",
|
|
i, PRINT_IPADDR(pHeader->dwDest)));
|
|
|
|
pTunnel->ulOutErrors++;
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
g_pfnIpSendComplete(pTunnel->pvIpContext,
|
|
pnpPacket,
|
|
NDIS_STATUS_INVALID_PACKET);
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Slap on an IP header
|
|
//
|
|
|
|
pNewHeader = GetIpHeader(pTunnel);
|
|
|
|
if(pNewHeader is NULL)
|
|
{
|
|
pTunnel->ulOutDiscards++;
|
|
|
|
//
|
|
// Not enough resources
|
|
//
|
|
|
|
Trace(SEND, ERROR,
|
|
("IpIpTransmit: Could not get buffer for header\n"));
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
g_pfnIpSendComplete(pTunnel->pvIpContext,
|
|
pnpPacket,
|
|
NDIS_STATUS_RESOURCES);
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
|
|
continue;
|
|
}
|
|
|
|
pNewHeader->byVerLen = IP_VERSION_LEN;
|
|
pNewHeader->byTos = pHeader->byTos;
|
|
|
|
//
|
|
// Currently we dont have any options, so all we do
|
|
// is add 20 bytes to the length
|
|
//
|
|
|
|
usLength = RtlUshortByteSwap(pHeader->wLength) + MIN_IP_HEADER_LENGTH;
|
|
|
|
pNewHeader->wLength = RtlUshortByteSwap(usLength);
|
|
|
|
//
|
|
// Id is set up by IP stack
|
|
// If the DF flag is set, copy that out
|
|
//
|
|
|
|
pNewHeader->wFlagOff = (pHeader->wFlagOff & IP_DF_FLAG);
|
|
pNewHeader->byTtl = pTunnel->byTtl;
|
|
pNewHeader->byProtocol = PROTO_IPINIP;
|
|
|
|
//
|
|
// XSum is done by IP, but we need to zero it out
|
|
//
|
|
|
|
pNewHeader->wXSum = 0x0000;
|
|
pNewHeader->dwSrc = pTunnel->LOCALADDR;
|
|
pNewHeader->dwDest = pTunnel->REMADDR;
|
|
|
|
//
|
|
// Slap on the buffer in front of the current packet
|
|
// and we are done
|
|
//
|
|
|
|
pnbNewBuffer = GetNdisBufferFromBuffer((PBYTE)pNewHeader);
|
|
|
|
RtAssert(pnbNewBuffer);
|
|
|
|
#if DBG
|
|
|
|
//
|
|
// Query the buffer to see that everything is setup OK
|
|
//
|
|
|
|
#endif
|
|
|
|
NdisChainBufferAtFront(pnpPacket,
|
|
pnbNewBuffer);
|
|
|
|
//
|
|
// Reference the tunnel, once for every send
|
|
// ulOutDiscards, ulOutOctets are incremented in
|
|
// SendComplete handler.
|
|
//
|
|
|
|
pTunnel->ulOutQLen++;
|
|
|
|
ReferenceTunnel(pTunnel);
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
//
|
|
// Dont really care about the return code from here.
|
|
// Even if it is an error, TdixSendDatagram will call our send
|
|
// complete handler
|
|
//
|
|
|
|
#if PROFILE
|
|
|
|
TdixSendDatagram(pTunnel,
|
|
pnpPacket,
|
|
pnbNewBuffer,
|
|
usLength,
|
|
pQueueNode->llSendTime,
|
|
pQueueNode->llCallTime,
|
|
llCurrentTime);
|
|
|
|
#else
|
|
|
|
TdixSendDatagram(pTunnel,
|
|
pnpPacket,
|
|
pnbNewBuffer,
|
|
usLength);
|
|
|
|
#endif
|
|
|
|
//
|
|
// If we come till here, we will always have our SendComplete called
|
|
// The DereferenceTunnel() will be done there
|
|
//
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
}
|
|
|
|
FreeQueueNode(pQueueNode);
|
|
}
|
|
|
|
//
|
|
// Dont have a work item queued
|
|
//
|
|
|
|
if(bFromWorker)
|
|
{
|
|
pTunnel->bWorkItemQueued = FALSE;
|
|
}
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
|
|
TraceLeave(SEND, "IpIpTransmit");
|
|
}
|
|
|
|
VOID
|
|
IpIpInvalidateRce(
|
|
PVOID pvContext,
|
|
RouteCacheEntry *pRce
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Called by IP when an RCE is closed or otherwise invalidated.
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
|
|
}
|
|
|
|
|
|
UINT
|
|
IpIpReturnPacket(
|
|
PVOID pARPInterfaceContext,
|
|
PNDIS_PACKET pPacket
|
|
)
|
|
{
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
IpIpSendComplete(
|
|
NTSTATUS nSendStatus,
|
|
PTUNNEL pTunnel,
|
|
PNDIS_PACKET pnpPacket,
|
|
ULONG ulPktLength
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
|
|
Locks
|
|
|
|
We acquire the TUNNEL lock
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
KIRQL irql;
|
|
PNDIS_BUFFER pnbFirstBuffer;
|
|
UINT uiFirstLength;
|
|
PVOID pvFirstData;
|
|
|
|
TraceEnter(SEND, "IpIpSendComplete");
|
|
|
|
//
|
|
// The tunnel was refcounted, so could not have gone away
|
|
// Lock it
|
|
//
|
|
|
|
RtAcquireSpinLock(&(pTunnel->rlLock),
|
|
&irql);
|
|
|
|
//
|
|
// If the status was success, increment the bytes sent
|
|
// otherwise increment the bytes
|
|
//
|
|
|
|
if(nSendStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(SEND, ERROR,
|
|
("IpIpSendComplete: Status %x sending data\n",
|
|
nSendStatus));
|
|
|
|
pTunnel->ulOutDiscards++;
|
|
}
|
|
else
|
|
{
|
|
pTunnel->ulOutOctets += ulPktLength;
|
|
}
|
|
|
|
//
|
|
// Decrement the Qlen
|
|
//
|
|
|
|
pTunnel->ulOutQLen--;
|
|
|
|
RtReleaseSpinLock(&(pTunnel->rlLock),
|
|
irql);
|
|
|
|
//
|
|
// Free the IP header we slapped on
|
|
//
|
|
|
|
NdisUnchainBufferAtFront(pnpPacket,
|
|
&pnbFirstBuffer);
|
|
|
|
NdisQueryBuffer(pnbFirstBuffer,
|
|
&pvFirstData,
|
|
&uiFirstLength);
|
|
|
|
RtAssert(uiFirstLength is MIN_IP_HEADER_LENGTH);
|
|
|
|
FreeIpHeader(pTunnel,
|
|
pvFirstData);
|
|
|
|
//
|
|
// We are done. Just indicate everything back up to IP
|
|
//
|
|
|
|
g_pfnIpSendComplete(pTunnel->pvIpContext,
|
|
pnpPacket,
|
|
nSendStatus);
|
|
|
|
//
|
|
// Done with the tunnel, deref it
|
|
//
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
TraceEnter(SEND, "IpIpSendComplete");
|
|
}
|
|
|
|
#if 0
|
|
NDIS_STATUS
|
|
IpIpTransferData(
|
|
PVOID pvContext,
|
|
NDIS_HANDLE nhMacContext,
|
|
UINT uiProtoOffset,
|
|
UINT uiTransferOffset,
|
|
UINT uiTransferLength,
|
|
PNDIS_PACKET pnpPacket,
|
|
PUINT puiTransferred
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS nStatus;
|
|
PNDIS_PACKET pnpOriginalPacket;
|
|
ULONG ulTotalSrcLen, ulTotalDestLen;
|
|
ULONG ulDestOffset, ulSrcOffset;
|
|
ULONG ulCopyLength, ulBytesCopied;
|
|
PNDIS_BUFFER pnbSrcBuffer, pnbDestBuffer;
|
|
PVOID pvDataToCopy;
|
|
|
|
//
|
|
// The TD context we gave IP was just a pointer to the NDIS_PACKET
|
|
//
|
|
|
|
pnpOriginalPacket = (PNDIS_PACKET)nhMacContext;
|
|
|
|
//
|
|
// Get info about the first buffer in the src packet
|
|
//
|
|
|
|
NdisQueryPacket(pnpOriginalPacket,
|
|
NULL,
|
|
NULL,
|
|
&pnbSrcBuffer,
|
|
&ulTotalSrcLen);
|
|
|
|
|
|
//
|
|
// Query the given packet to get the Destination buffer
|
|
// and the Total length
|
|
//
|
|
|
|
NdisQueryPacket(pnpPacket,
|
|
NULL,
|
|
NULL,
|
|
&pnbDestBuffer,
|
|
&ulTotalDestLen);
|
|
|
|
|
|
ulSrcOffset = uiTransferOffset + uiProtoOffset;
|
|
|
|
//
|
|
// Make sure that we have enough data to fulfil the request
|
|
//
|
|
|
|
|
|
RtAssert((ulTotalSrcLen - ulSrcOffset) >= uiTransferLength);
|
|
|
|
RtAssert(pnbDestBuffer);
|
|
|
|
|
|
//
|
|
// ulDestOffset is also a count of the bytes copied till now
|
|
//
|
|
|
|
ulDestOffset = 0;
|
|
|
|
while(pnbSrcBuffer)
|
|
{
|
|
|
|
NdisQueryBuffer(pnbSrcBuffer,
|
|
&pvDataToCopy,
|
|
&ulCopyLength);
|
|
|
|
//
|
|
// See if we need to copy the whole buffer or only part
|
|
// of it. ulDestOffset is also a count of he bytes copied
|
|
// up till this point
|
|
//
|
|
|
|
if(uiTransferLength - ulDestOffset < ulCopyLength)
|
|
{
|
|
//
|
|
// Need to copy less than this buffer
|
|
//
|
|
|
|
ulCopyLength = uiTransferLength - ulDestOffset;
|
|
}
|
|
|
|
#if NDISBUFFERISMDL
|
|
|
|
nStatus = TdiCopyBufferToMdl(pvDataToCopy,
|
|
ulSrcOffset,
|
|
ulCopyLength,
|
|
pnbDestBuffer,
|
|
ulDestOffset,
|
|
&ulBytesCopied);
|
|
|
|
#else
|
|
#error "Fix this"
|
|
#endif
|
|
|
|
if((nStatus isnot STATUS_SUCCESS) and
|
|
(ulBytesCopied isnot ulCopyLength))
|
|
{
|
|
//
|
|
// something bad happened in the copy
|
|
//
|
|
|
|
}
|
|
|
|
ulSrcOffset = 0;
|
|
ulDestOffset += ulBytesCopied;
|
|
|
|
NdisGetNextBuffer(pnbSrcBuffer, &pnbSrcBuffer);
|
|
}
|
|
|
|
*puiTransferred = ulDestOffset;
|
|
}
|
|
#endif
|
|
|
|
NDIS_STATUS
|
|
IpIpTransferData(
|
|
PVOID pvContext,
|
|
NDIS_HANDLE nhMacContext,
|
|
UINT uiProtoOffset,
|
|
UINT uiTransferOffset,
|
|
UINT uiTransferLength,
|
|
PNDIS_PACKET pnpPacket,
|
|
PUINT puiTransferred
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
PTRANSFER_CONTEXT pXferCtxt;
|
|
|
|
TraceEnter(SEND, "IpIpTransferData");
|
|
|
|
pXferCtxt = (PTRANSFER_CONTEXT)nhMacContext;
|
|
|
|
pXferCtxt->pvContext = pvContext;
|
|
pXferCtxt->uiProtoOffset = uiProtoOffset;
|
|
pXferCtxt->uiTransferOffset = uiTransferOffset;
|
|
pXferCtxt->uiTransferLength = uiTransferLength;
|
|
pXferCtxt->pnpTransferPacket = pnpPacket;
|
|
|
|
*puiTransferred = 0;
|
|
|
|
pXferCtxt->bRequestTransfer = TRUE;
|
|
|
|
TraceLeave(SEND, "IpIpTransferData");
|
|
|
|
return NDIS_STATUS_PENDING;
|
|
}
|
|
|
|
VOID
|
|
SendIcmpError(
|
|
DWORD dwLocalAddress,
|
|
PNDIS_BUFFER pnbFirstBuff,
|
|
PVOID pvFirstData,
|
|
ULONG ulFirstLen,
|
|
BYTE byType,
|
|
BYTE byCode
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Internal routine called to send an icmp error message
|
|
|
|
Locks:
|
|
|
|
None needed, the buffers shouldnt be modified while the function is
|
|
in progress
|
|
|
|
Arguments:
|
|
|
|
dwLocalAddress NTE on which this packet was received
|
|
pnbFirstBuffer The buffer that has the IP Header
|
|
pvFirstData Pointer to the data in the buffer
|
|
ulFirstLen Size of the buffer
|
|
byType ICMP type to return
|
|
byCode ICMP code to return
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
struct IPHeader *pErrorHeader;
|
|
BYTE FlatHeader[MAX_IP_HEADER_LENGTH + ICMP_HEADER_LENGTH];
|
|
ULONG ulSecondLen, ulLeft;
|
|
PVOID pvSecondBuff;
|
|
|
|
//
|
|
// If the error is being sent in response to an ICMP
|
|
// packet, tcpip will touch the icmp header also
|
|
// So we copy it into a flat buffer
|
|
//
|
|
|
|
pErrorHeader = NULL;
|
|
|
|
if((ulFirstLen < MAX_IP_HEADER_LENGTH + ICMP_HEADER_LENGTH) and
|
|
(ulFirstLen < (ULONG)RtlUshortByteSwap(((PIP_HEADER)pvFirstData)->wLength)))
|
|
{
|
|
NdisQueryBufferSafe(NDIS_BUFFER_LINKAGE(pnbFirstBuff),
|
|
&pvSecondBuff,
|
|
&ulSecondLen,
|
|
LowPagePriority);
|
|
|
|
if(pvSecondBuff isnot NULL)
|
|
{
|
|
//
|
|
// First copy out what's in the first buffer
|
|
//
|
|
|
|
RtlCopyMemory(FlatHeader,
|
|
pvFirstData,
|
|
ulFirstLen);
|
|
|
|
//
|
|
// How much is left in the flat buffer?
|
|
//
|
|
|
|
ulLeft = (MAX_IP_HEADER_LENGTH + ICMP_HEADER_LENGTH) - ulFirstLen;
|
|
|
|
//
|
|
// Copy out MIN(SecondBuffer, What's Left)
|
|
//
|
|
|
|
ulLeft = (ulSecondLen < ulLeft) ? ulSecondLen: ulLeft;
|
|
|
|
RtlCopyMemory(FlatHeader + ulFirstLen,
|
|
pvSecondBuff,
|
|
ulLeft);
|
|
|
|
pErrorHeader = (struct IPHeader *)&FlatHeader;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pErrorHeader = (struct IPHeader *)pvFirstData;
|
|
}
|
|
|
|
if(pErrorHeader isnot NULL)
|
|
{
|
|
SendICMPErr(dwLocalAddress,
|
|
pErrorHeader,
|
|
ICMP_TYPE_DEST_UNREACHABLE,
|
|
ICMP_CODE_HOST_UNREACHABLE,
|
|
0);
|
|
}
|
|
}
|