|
|
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
net\routing\ip\ipinip\rcv.c
Abstract:
Revision History:
--*/
#define __FILE_SIG__ RCV_SIG
#include "inc.h"
IP_STATUSIpIpRcvDatagram( IN PVOID pvIpContext, IN DWORD dwDestAddr, IN DWORD dwSrcAddr, IN DWORD dwAcceptAddr, IN DWORD dwRcvAddr, IN IPHeader UNALIGNED pHeader, IN UINT uiHdrLen, IN IPRcvBuf *pRcvBuf, IN UINT uiTotalLen, IN BOOLEAN bIsBCast, IN BYTE byProtocol, IN IPOptInfo *pOptInfo )
/*++
Routine Description
This
Locks
Arguments
pvIpContext IP's context for the receive indication. Currently this is a pointer to the source NTE dwDestAddr The Destination address in the header dwSrcAddr The Source Address in the header dwAcceptAddr The address of the NTE which "accepted" this packet dwRcvAddr The address of the NTE on which the packet was received pHeader Pointer to the IP Header uiHdrLen The header length pRcvBuf The COMPLETE packet in an IPRcvBuf structure uiRcvdDataLen The size of the received datagram bIsBCast Whether the packet was a link layer broadcast byProtocol The Protocol ID in the header pOptInfo Pointer to Option info
Return Value
IP_SUCCESS
--*/
{ PTRANSFER_CONTEXT pXferCtxt; PNDIS_BUFFER pnbFirstBuffer; PVOID pvData; PIRP pIrp; IP_HEADER UNALIGNED *pInHeader, *pOutHeader; ULARGE_INTEGER uliTunnelId; PTUNNEL pTunnel; ULONG ulOutHdrLen, ulDataLen; BOOLEAN bNonUnicast; TraceEnter(RCV, "TdixReceiveIpIp");
//
// Get a pointer to the first buffer
//
pvData = (PVOID)(pRcvBuf->ipr_buffer);
RtAssert(pvData); //
// Figure out the tunnel for this receive
// Since the transport indicates atleast 128 bytes, we can safely read out
// the IP Header
//
RtAssert(uiTotalLen > sizeof(IP_HEADER));
pOutHeader = pHeader; RtAssert(pOutHeader->byProtocol is PROTO_IPINIP); RtAssert(pOutHeader->byVerLen >> 4 is IP_VERSION_4);
//
// These defines depend upon a variable being named "uliTunnelId"
//
REMADDR = dwSrcAddr; LOCALADDR = dwDestAddr;
//
// Bunch of checks to make sure the packet and the handler
// are telling us the same thing
//
RtAssert(pOutHeader->dwSrc is dwSrcAddr); RtAssert(pOutHeader->dwDest is dwDestAddr);
//
// Get a pointer to the inside header
//
ulOutHdrLen = LengthOfIPHeader(pOutHeader); pInHeader = (IP_HEADER UNALIGNED *)((PBYTE)pOutHeader + ulOutHdrLen);
#if DBG
//
// The size of the inner data must be total bytes - outer header
//
ulDataLen = ntohs(pInHeader->wLength);
RtAssert((ulDataLen + ulOutHdrLen) is uiTotalLen);
//
// The outer header should also give a good length
//
ulDataLen = ntohs(pOutHeader->wLength);
//
// Data length and bytes available must match
//
RtAssert(ulDataLen is uiTotalLen); #endif
//
// Find the TUNNEL. We need to acquire the tunnel list lock
//
EnterReaderAtDpcLevel(&g_rwlTunnelLock); pTunnel = FindTunnel(&uliTunnelId);
ExitReaderFromDpcLevel(&g_rwlTunnelLock); if(pTunnel is NULL) { Trace(RCV, WARN, ("TdixReceiveIpIp: Couldnt find tunnel for %d.%d.%d.%d/%d.%d.%d.%d\n", PRINT_IPADDR(REMADDR), PRINT_IPADDR(LOCALADDR)));
//
// Could not find a matching tunnel
//
TraceLeave(RCV, "TdixReceiveIpIp");
//
// Return a code that will cause IP to send the right ICMP message
//
return IP_DEST_PROT_UNREACHABLE;; }
//
// Ok, so we have the tunnel and it is ref counted and locked
//
//
// The number of octets received
//
pTunnel->ulInOctets += ulBytesAvailable;
//
// Check the actual (inside) destination
//
if(IsUnicastAddr(pInHeader->dwDest)) { //
// TODO: should we check to see that the address is not 0.0.0.0?
//
pTunnel->ulInUniPkts++;
bNonUnicast = FALSE; } else { pTunnel->ulInNonUniPkts++; if(IsClassEAddr(pInHeader->dwDest)) { //
// Bad address - throw it away
//
pTunnel->ulInErrors++;
//
// Releaselock, free buffer chain
//
} bNonUnicast = TRUE; }
//
// If the tunnel is non operational yet we are getting packets, means
// it probably should be made operational
//
RtAssert(pTunnel->dwOperState is MIB_IF_OPER_STATUS_OPERATIONAL);
if((pTunnel->dwAdminState isnot MIB_IF_ADMIN_STATUS_UP) or (pTunnel->dwOperState isnot MIB_IF_OPER_STATUS_OPERATIONAL)) { Trace(RCV, WARN, ("TdixReceiveIpIp: Tunnel %x is not up\n", pTunnel));
pTunnel->ulInDiscards++;
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
DereferenceTunnel(pTunnel);
TraceLeave(RCV, "TdixReceiveIpIp");
return STATUS_DATA_NOT_ACCEPTED; }
//
// Allocate a transfer context
//
pXferCtxt = AllocateTransferContext();
if(pXferCtxt is NULL) { Trace(RCV, ERROR, ("TdixReceiveIpIp: Couldnt allocate transfer context\n"));
//
// Could not allocate context, free the data, unlock and deref
// the tunnel
//
pTunnel->ulInDiscards++;
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock)); DereferenceTunnel(pTunnel);
TraceLeave(RCV, "TdixReceiveIpIp");
return STATUS_DATA_NOT_ACCEPTED; }
//
// Ok, all statistics are done.
// Release the lock on the tunnel
//
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
//
// Fill in the read-datagram context with the information that won't
// otherwise be available in the completion routine.
//
pXferCtxt->pTunnel = pTunnel; pXferCtxt->pRcvBuf = pRcvBuf; pXferCtxt->uiTotalLen = uiTotalLen; pXferCtxt->ulProtoOffset = ulOutHdrLen; //
// The data starts at pInHeader
// We indicate the only the first buffer to IP which means
// (ulFirstBufLen - outer header length) bytes
// The total data is the (ulTotalLen - outer header)
// We associate a TRANSFER_CONTEXT with this indication,
// The Protocol Offset is just our outer header
//
g_pfnIPRcv(pTunnel->pvIpContext, pInHeader, ulFirstBufLen - ulOutHdrLen, ulTotalLen - ulOutHdrLen, pXferCtxt, ulOutHdrLen, bNonUnicast);
//
// Deref the tunnel (finally)
//
DereferenceTunnel(pTunnel); TraceLeave(RCV, "TdixReceiveIpIp");
return STATUS_SUCCESS;}
NDIS_STATUSIpIpTransferData( 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; RtAssert(pXferCtxt->pTunnel is pvContext); RtAssert(pXferCtxt->ulProtoOffset is uiProtoOffset); //
// Should not be asking to transfer more than was indicated
// Since the transfer will start at and offset of
// uiProtoOffset + uiTransferOffset, the following should hold
//
RtAssert((pXferContext->uiTotalLen - uiProtoOffset - uiTransferOffset) >= uiTransferLength);
//
// Copy the data from the RCV buffer to the given NDIS_BUFFER
//
*puiTransferred = CopyRcvBufferToNdisBuffer(pXferCtxt->pRcvBuf, pnbFirstBuffer, uiTransferLength, uiProtoOffset + uiTransferOffset, uiTransferOffset);
TraceLeave(SEND, "IpIpTransferData");
return NDIS_STATUS_PENDING;}
uintCopyRcvBufferToNdisBuffer( IN IPRcvBuf *pRcvBuffer, IN OUT PNDIS_BUFFER pnbNdisBuffer, IN uint Size, IN uint RcvBufferOffset, IN uint NdisBufferOffset ){ uint TotalBytesCopied = 0; // Bytes we've copied so far.
uint BytesCopied = 0; // Bytes copied out of each buffer.
uint DestSize, RcvSize; // Size left in current destination and
// recv. buffers, respectively.
uint BytesToCopy; // How many bytes to copy this time.
NTSTATUS Status;
RtAssert(RcvBuf != NULL);
RtAssert(RcvOffset <= RcvBuf->ipr_size);
//
// The destination buffer can be NULL - this is valid, if odd.
//
if(pnbDestBuf != NULL) { } RcvSize = RcvBuf->ipr_size - RcvOffset; DestSize = NdisBufferLength(DestBuf); if (Size < DestSize) { DestSize = Size; } do { //
// Compute the amount to copy, and then copy from the
// appropriate offsets.
BytesToCopy = MIN(DestSize, RcvSize); Status = TdiCopyBufferToMdl(RcvBuf->ipr_buffer, RcvOffset, BytesToCopy, DestBuf, DestOffset, &BytesCopied);
if (!NT_SUCCESS(Status)) { break; }
RtAssert(BytesCopied == BytesToCopy);
TotalBytesCopied += BytesCopied; DestSize -= BytesCopied; DestOffset += BytesCopied; RcvSize -= BytesToCopy;
if (!RcvSize) { //
// Exhausted this buffer.
RcvBuf = RcvBuf->ipr_next;
//
// If we have another one, use it.
//
if (RcvBuf != NULL) { RcvOffset = 0; RcvSize = RcvBuf->ipr_size; } else { break; } } else { //
// Buffer not exhausted, update offset.
//
RcvOffset += BytesToCopy; }
}while (DestSize);
return TotalBytesCopied;}
|
