825 lines
21 KiB
C
825 lines
21 KiB
C
/*++
|
||
|
||
Copyright (c) 2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
iprecv.c
|
||
|
||
Abstract:
|
||
|
||
Handles IP datagram reception
|
||
|
||
Revision History:
|
||
|
||
05/17/2000 davidx
|
||
Created it.
|
||
|
||
--*/
|
||
|
||
#include "precomp.h"
|
||
|
||
|
||
//
|
||
// A singly-linked list of datagrams that're currently
|
||
// being reassembled. We're using a list rather than a
|
||
// hash table here for simplicity. We assume that fragmentation
|
||
// occurs very infrequently.
|
||
//
|
||
PRIVATE Packet* IpReassemblyPktList;
|
||
PRIVATE UINT IpReassemblyPktCount;
|
||
|
||
// Maximum number of actively reassembled datagrams
|
||
UINT cfgMaxReassemblyDgrams = 4;
|
||
|
||
// Maximum size for a reassembled datagram
|
||
UINT cfgMaxReassemblySize = 2048;
|
||
|
||
// Reassembly timeout period = 60sec
|
||
UINT cfgReassemblyTimeout = 60;
|
||
|
||
//
|
||
// Packet containing a datagram that's being reassembled:
|
||
// packet header
|
||
// reassembly information
|
||
// space to hold maximum IP header
|
||
// actual datagram data
|
||
//
|
||
typedef struct _ReassemblyHeader {
|
||
IPADDR srcaddr; // source IP address
|
||
IPADDR dstaddr; // destination IP address
|
||
UINT proto_id; // datagram ID and protocol
|
||
UINT timer; // reassembly timer
|
||
UINT origdatalen; // total length of the original IP datagram
|
||
DWORD bitFlags[1]; // which fragments have arrived?
|
||
} ReassemblyHeader;
|
||
|
||
|
||
VOID
|
||
IpCleanupReassemblyPkts(
|
||
IfInfo* ifp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Clean up all partially reassembly datagrams
|
||
|
||
Arguments:
|
||
|
||
ifp - Optional parameter: when present we only clean up
|
||
the partial datagrams from the specified interface;
|
||
otherwise, we clean up all partial datagrams.
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
|
||
{
|
||
Packet** link = &IpReassemblyPktList;
|
||
Packet* pkt;
|
||
|
||
while ((pkt = *link) != NULL) {
|
||
if (ifp == pkt->recvifp || ifp == NULL) {
|
||
*link = pkt->nextpkt;
|
||
IpReassemblyPktCount--;
|
||
XnetCompletePacket(pkt, NETERR_CANCELLED);
|
||
} else {
|
||
link = &pkt->nextpkt;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
VOID
|
||
IpReassemblyTimerProc()
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
IP datagram reassembly timer routine
|
||
|
||
Arguments:
|
||
|
||
NONE
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
|
||
{
|
||
Packet** link = &IpReassemblyPktList;
|
||
Packet* pkt;
|
||
ReassemblyHeader* rahdr;
|
||
|
||
while ((pkt = *link) != NULL) {
|
||
rahdr = GETPKTBUF(pkt, ReassemblyHeader);
|
||
if (rahdr->timer-- == 0) {
|
||
TRACE_("Reassembly timeout: src = %s", IPADDRSTR(rahdr->srcaddr));
|
||
*link = pkt->nextpkt;
|
||
IpReassemblyPktCount--;
|
||
|
||
// Send out an ICMP error message if fragment 0 has been received
|
||
if (pkt->iphdrOffset) {
|
||
pkt->data = (BYTE*) GETPKTIPHDR(pkt);
|
||
IcmpSendError(
|
||
pkt,
|
||
ICMPTYPE_TIME_EXECEEDED,
|
||
ICMPCODE_REASSEMBLY_TIMEOUT);
|
||
}
|
||
|
||
XnetCompletePacket(pkt, NETERR_REASSEMBLY);
|
||
} else
|
||
link = &pkt->nextpkt;
|
||
}
|
||
}
|
||
|
||
|
||
PRIVATE Packet**
|
||
IpFindReassemblyPkt(
|
||
IPADDR srcaddr,
|
||
IPADDR dstaddr,
|
||
UINT proto_id
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Check if we already have a partially assembled datagram
|
||
matching the specified identification information.
|
||
|
||
Arguments:
|
||
|
||
srcaddr - Specifies the source IP address
|
||
dstaddr - Specifies the destination IP address
|
||
proto_id - IP protocol number and datagram ID
|
||
|
||
Return Value:
|
||
|
||
Address of the link pointer to the specified datagram
|
||
|
||
--*/
|
||
|
||
{
|
||
Packet** link = &IpReassemblyPktList;
|
||
Packet* pkt;
|
||
ReassemblyHeader* rahdr;
|
||
|
||
while ((pkt = *link) != NULL) {
|
||
rahdr = GETPKTBUF(pkt, ReassemblyHeader);
|
||
if (rahdr->srcaddr == srcaddr &&
|
||
rahdr->dstaddr == dstaddr &&
|
||
rahdr->proto_id == proto_id)
|
||
break;
|
||
|
||
link = &pkt->nextpkt;
|
||
}
|
||
|
||
return link;
|
||
}
|
||
|
||
|
||
PRIVATE Packet*
|
||
IpAllocReassemblyPkt(
|
||
IPADDR srcaddr,
|
||
IPADDR dstaddr,
|
||
UINT proto_id,
|
||
IfInfo* ifp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Allocate buffer for assembling a datagram
|
||
|
||
Arguments:
|
||
|
||
srcaddr - Specifies the source IP address
|
||
dstaddr - Specifies the destination IP address
|
||
proto_id - IP protocol number and datagram ID
|
||
ifp - Points to the receiving interface
|
||
|
||
Return Value:
|
||
|
||
Pointer to the allocated packet
|
||
NULL if there is an error
|
||
|
||
--*/
|
||
|
||
{
|
||
Packet* pkt;
|
||
UINT hdrsize;
|
||
ReassemblyHeader* rahdr;
|
||
|
||
//
|
||
// We reserve some space in the head of the packet buffer
|
||
// for storing reassembly information.
|
||
//
|
||
|
||
hdrsize = offsetof(ReassemblyHeader, bitFlags) +
|
||
(((cfgMaxReassemblySize / 8) + 31) / 32) * 4 +
|
||
MAXIPHDRLEN;
|
||
|
||
pkt = XnetAllocPacket(hdrsize + cfgMaxReassemblySize, PKTFLAG_NETPOOL);
|
||
if (!pkt) return NULL;
|
||
pkt->iphdrOffset = 0;
|
||
|
||
rahdr = GETPKTBUF(pkt, ReassemblyHeader);
|
||
ZeroMem(rahdr, hdrsize);
|
||
rahdr->timer = cfgReassemblyTimeout;
|
||
rahdr->srcaddr = srcaddr;
|
||
rahdr->dstaddr = dstaddr;
|
||
rahdr->proto_id = proto_id;
|
||
|
||
pkt->data += hdrsize;
|
||
CACHE_IFP_REFERENCE(pkt->recvifp,ifp);
|
||
return pkt;
|
||
}
|
||
|
||
|
||
PRIVATE BOOL
|
||
IpUpdateFragmentFlags(
|
||
Packet* pkt,
|
||
UINT fragOffset,
|
||
UINT fragCount
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Update the bit flags to indicate which fragments have already arrived
|
||
|
||
Arguments:
|
||
|
||
pkt - Points to the packet contain partially assembled datagram
|
||
fragOffset - Starting chunk offset for the current fragment
|
||
fragCount - Number of 8 byte chunks in the current fragment
|
||
|
||
Return Value:
|
||
|
||
TRUE if the entire datagram has been completed
|
||
FALSE otherwise
|
||
|
||
--*/
|
||
|
||
{
|
||
UINT chunks, i;
|
||
ReassemblyHeader* rahdr = GETPKTBUF(pkt, ReassemblyHeader);
|
||
|
||
// Update flag bits
|
||
chunks = fragOffset % 32;
|
||
i = fragOffset / 32;
|
||
|
||
if (chunks) {
|
||
UINT bits = min(fragCount, 32-chunks);
|
||
rahdr->bitFlags[i++] |= (((1 << bits) - 1) << chunks);
|
||
fragCount -= bits;
|
||
}
|
||
|
||
while (fragCount >= 32) {
|
||
rahdr->bitFlags[i++] = 0xffffffff;
|
||
fragCount -= 32;
|
||
}
|
||
|
||
if (fragCount)
|
||
rahdr->bitFlags[i] |= (1 << fragCount) - 1;
|
||
|
||
// We don't know the total datagram length yet,
|
||
// which must mean we haven't finished reassembly.
|
||
if (rahdr->origdatalen == 0) return FALSE;
|
||
|
||
// Check if all bit flags are set
|
||
i = 0;
|
||
chunks = (rahdr->origdatalen + 7) / 8;
|
||
while (chunks >= 32) {
|
||
if (rahdr->bitFlags[i++] != 0xffffffff) return FALSE;
|
||
chunks -= 32;
|
||
}
|
||
|
||
return (chunks == 0 ||
|
||
rahdr->bitFlags[i] == (1u << chunks) - 1);
|
||
}
|
||
|
||
|
||
PRIVATE VOID
|
||
IpReassemblePkt(
|
||
Packet* pkt
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Handle IP datagram reassembly:
|
||
called when a datagram fragment is received
|
||
|
||
Arguments:
|
||
|
||
pkt - Points to the received packet (datagram fragment)
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
NOTE:
|
||
|
||
We assume that fragmented datagrams are rare. Consequently,
|
||
our priority here is implementation simplicity (over efficiency).
|
||
|
||
--*/
|
||
|
||
{
|
||
IpHeader* iphdr = GETPKTIPHDR(pkt);
|
||
UINT iphdrlen = GETIPHDRLEN(iphdr);
|
||
UINT iplen = GETIPLEN(iphdr);
|
||
UINT proto_id, fragOffset, lastbyte;
|
||
BOOL moreFlag;
|
||
Packet** link;
|
||
Packet* rapkt;
|
||
ReassemblyHeader* rahdr;
|
||
|
||
// Extract datagram header information
|
||
fragOffset = NTOHS(iphdr->fragoffset);
|
||
moreFlag = (fragOffset & MORE_FRAGMENTS) != 0;
|
||
fragOffset &= FRAGOFFSET_MASK;
|
||
|
||
proto_id = NTOHS(iphdr->id);
|
||
proto_id = (proto_id << 16) | iphdr->protocol;
|
||
link = IpFindReassemblyPkt(iphdr->srcaddr, iphdr->dstaddr, proto_id);
|
||
|
||
// Check if we already have fragments from the same datagram.
|
||
// If no existing fragments are found, then we need to
|
||
// allocate a new reassembly buffer
|
||
if ((rapkt = *link) == NULL) {
|
||
if (IpReassemblyPktCount >= cfgMaxReassemblyDgrams) {
|
||
WARNING_("Too many fragmented IP datagrams");
|
||
goto discard_fragment;
|
||
}
|
||
|
||
rapkt = IpAllocReassemblyPkt(iphdr->srcaddr, iphdr->dstaddr, proto_id, pkt->recvifp);
|
||
if (!rapkt) goto discard_fragment;
|
||
*link = rapkt;
|
||
IpReassemblyPktCount++;
|
||
}
|
||
|
||
if ((iplen -= iphdrlen) == 0) goto reassembly_failed;
|
||
lastbyte = fragOffset*8 + iplen;
|
||
if (lastbyte > cfgMaxReassemblySize) {
|
||
WARNING_("Exceeded max reassembly size");
|
||
goto reassembly_failed;
|
||
}
|
||
|
||
rahdr = GETPKTBUF(rapkt, ReassemblyHeader);
|
||
if (moreFlag) {
|
||
// Only the last fragment can have size that's not a multiple of 8.
|
||
if (iplen % 8 != 0) goto reassembly_failed;
|
||
} else {
|
||
// Update the total length field for the entire datagram
|
||
if (rahdr->origdatalen && rahdr->origdatalen != lastbyte)
|
||
goto reassembly_failed;
|
||
|
||
rahdr->origdatalen = lastbyte;
|
||
}
|
||
|
||
// Check if we got the first fragment.
|
||
// Remember the original IP datagram header if we did.
|
||
if (fragOffset == 0 && rapkt->iphdrOffset == 0) {
|
||
BYTE* hdr = rapkt->data - iphdrlen;
|
||
SETPKTIPHDR(rapkt, hdr);
|
||
CopyMem(hdr, pkt->data, iphdrlen);
|
||
rapkt->pktflags |= (pkt->pktflags & PKTFLAG_MCAST);
|
||
}
|
||
|
||
// Copy the fragment data into the reassembly buffer
|
||
CopyMem(rapkt->data + fragOffset*8, pkt->data + iphdrlen, iplen);
|
||
XnetCompletePacket(pkt, NETERR_OK);
|
||
|
||
// Update the flags to indicate which fragments have already arrived.
|
||
// If the datagram is complete, pass it upstream for processing.
|
||
if (IpUpdateFragmentFlags(rapkt, fragOffset, (iplen+7)/8)) {
|
||
*link = rapkt->nextpkt;
|
||
IpReassemblyPktCount--;
|
||
rapkt->nextpkt = NULL;
|
||
|
||
iphdr = GETPKTIPHDR(rapkt);
|
||
iphdrlen = GETIPHDRLEN(iphdr);
|
||
rapkt->data = (BYTE*) iphdr;
|
||
rapkt->datalen = iphdrlen + rahdr->origdatalen;
|
||
iphdr->length = (WORD) HTONS(rapkt->datalen);
|
||
iphdr->fragoffset &= ~HTONS(MORE_FRAGMENTS|FRAGOFFSET_MASK);
|
||
COMPUTE_CHECKSUM(iphdr->hdrxsum, iphdr, iphdrlen);
|
||
IpReceivePacket(rapkt);
|
||
}
|
||
return;
|
||
|
||
reassembly_failed:
|
||
// We detected an error during the reassembly process.
|
||
// Flush all associated fragments.
|
||
*link = rapkt->nextpkt;
|
||
IpReassemblyPktCount--;
|
||
|
||
TRACE_("Datagram reassembly failed");
|
||
XnetCompletePacket(rapkt, NETERR_REASSEMBLY);
|
||
|
||
discard_fragment:
|
||
// Discard this fragment and return
|
||
XnetCompletePacket(pkt, NETERR_DISCARDED);
|
||
}
|
||
|
||
|
||
|
||
PRIVATE BOOL
|
||
IpProcessRecvOptions(
|
||
BYTE* buf,
|
||
UINT buflen,
|
||
IfInfo* ifp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Process options in a received IP datagram
|
||
|
||
Arguments:
|
||
|
||
buf - Points to the option data buffer
|
||
buflen - Size of the buffer, in bytes
|
||
ifp - The interface that received the datagram
|
||
|
||
Return Value:
|
||
|
||
TRUE if the option data is valid
|
||
FALSE if there is an error and the datagram should be discarded
|
||
|
||
--*/
|
||
|
||
{
|
||
BYTE opt, optlen, ptr;
|
||
IPADDR* paddr;
|
||
|
||
while (buflen) {
|
||
// reached the end of option list?
|
||
if ((opt = *buf) == IPOPT_EOL) break;
|
||
|
||
// skip over the NOP option
|
||
if (opt == IPOPT_NOP) {
|
||
buf++; buflen--;
|
||
continue;
|
||
}
|
||
|
||
// check the option length field
|
||
if (buflen < 2 || (optlen = buf[1]) < 2 || optlen > buflen)
|
||
return FALSE;
|
||
|
||
switch (opt) {
|
||
case IPOPT_LOOSE_SRCROUTE:
|
||
case IPOPT_STRICT_SRCROUTE:
|
||
// loose or strict source and record route options
|
||
if (optlen % 4 != 3 || (ptr = buf[2]) < 4 || ptr % 4 != 0)
|
||
return FALSE;
|
||
|
||
// reached the end of the IP address list?
|
||
if (ptr > optlen) break;
|
||
|
||
// only one address left and it's ours
|
||
// this shouldn't happen but we handle it anyway
|
||
paddr = (IPADDR*) (buf+ptr-1);
|
||
if (optlen - ptr == 3 && ifp->ipaddr && ifp->ipaddr == *paddr) {
|
||
*paddr = 0;
|
||
break;
|
||
}
|
||
|
||
// otherwise, discard the datagram since we don't
|
||
// participate in source routing.
|
||
return FALSE;
|
||
|
||
case IPOPT_RECORD_ROUTE:
|
||
// record route
|
||
if (optlen % 4 != 3 || (ptr = buf[2]) < 4 || ptr % 4 != 0)
|
||
return FALSE;
|
||
break;
|
||
|
||
case IPOPT_TIMESTAMP:
|
||
// internet timestamp
|
||
if (optlen < 4 || optlen % 4 != 0 ||
|
||
(ptr = buf[2]) < 5 || ptr % 4 != 1)
|
||
return FALSE;
|
||
break;
|
||
}
|
||
|
||
// move on to the next option
|
||
buf += optlen;
|
||
buflen -= optlen;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
IPADDR
|
||
IpReflectIpOptions(
|
||
IfInfo* ifp,
|
||
IpHeader* iphdr,
|
||
IPADDR dstaddr
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Reflect any IP options in a received datagram
|
||
|
||
Arguments:
|
||
|
||
ifp - Specifies the outgoing interface
|
||
iphdr - Points to the received datagram header
|
||
dstaddr - Specifies the final destination address
|
||
|
||
Return Value:
|
||
|
||
New destination address
|
||
|
||
Note:
|
||
|
||
We assume the option data in the received datagram
|
||
has already been validated.
|
||
|
||
--*/
|
||
|
||
{
|
||
BYTE* buf;
|
||
BYTE opt, optlen, ptr;
|
||
UINT buflen;
|
||
IPADDR* paddr;
|
||
|
||
buf = (BYTE*) iphdr + IPHDRLEN;
|
||
buflen = GETIPHDRLEN(iphdr) - IPHDRLEN;
|
||
|
||
while (buflen) {
|
||
if ((opt = *buf) == IPOPT_EOL) break;
|
||
if (opt == IPOPT_NOP) {
|
||
buf++; buflen--;
|
||
continue;
|
||
}
|
||
|
||
optlen = buf[1];
|
||
|
||
switch (opt) {
|
||
case IPOPT_LOOSE_SRCROUTE:
|
||
case IPOPT_STRICT_SRCROUTE:
|
||
//
|
||
// We assume the record route option contains the following:
|
||
// G1 G2 ... Gn
|
||
// and we'll modify it to:
|
||
// Gn-1 ... G2 G1 D
|
||
// and return Gn as the new destination address
|
||
//
|
||
if ((ptr = buf[2]) > 4) {
|
||
IPADDR addr;
|
||
IPADDR* pend;
|
||
|
||
ASSERT(optlen % 4 == 3 && ptr % 4 == 0);
|
||
if (ptr > optlen) ptr = (BYTE) (optlen+1);
|
||
|
||
paddr = (IPADDR*) (buf+3);
|
||
pend = (IPADDR*) (buf+ptr-5);
|
||
|
||
// swap Gn and D
|
||
addr = *pend;
|
||
|
||
// simple sanity check
|
||
// if the gateway address is bad, we'll just
|
||
// leave the source route option alone
|
||
if (!XnetIsValidUnicastAddr(addr)) break;
|
||
|
||
*pend = dstaddr;
|
||
dstaddr = addr;
|
||
pend--;
|
||
|
||
// flip G1 ... Gn-1
|
||
while (pend > paddr) {
|
||
addr = *pend;
|
||
*pend = *paddr;
|
||
*paddr = addr;
|
||
paddr++;
|
||
pend--;
|
||
}
|
||
|
||
// reset ptr field
|
||
buf[2] = 4;
|
||
}
|
||
break;
|
||
|
||
case IPOPT_RECORD_ROUTE:
|
||
//
|
||
// If there is room left, record our own IP address
|
||
//
|
||
if ((ptr = buf[2]) > optlen) break;
|
||
ASSERT(optlen % 4 == 3 && ptr >= 4 && ptr % 4 == 0);
|
||
|
||
paddr = (IPADDR*) (buf+ptr-1);
|
||
*paddr = ifp->ipaddr;
|
||
buf[2] += 4;
|
||
break;
|
||
|
||
case IPOPT_TIMESTAMP:
|
||
if ((ptr = buf[2]) > optlen) {
|
||
// increment the overflow count if we don't have room
|
||
if ((buf[3] & 0xf0) < 0xf0) buf[3] += 0x10;
|
||
} else {
|
||
UINT timestamp;
|
||
DWORD* p;
|
||
|
||
ASSERT(optlen % 4 == 0 && optlen > 4 &&
|
||
ptr >= 5 && ptr % 4 == 1);
|
||
|
||
p = (DWORD*) (buf+ptr-1);
|
||
timestamp = IpGetMsecsSinceMidnightGMT();
|
||
|
||
switch (buf[3] & 0xf) {
|
||
case 3:
|
||
if (*p != ifp->ipaddr) break;
|
||
// fall through
|
||
|
||
case 1:
|
||
if (optlen-ptr < 7) break;
|
||
*p++ = ifp->ipaddr;
|
||
buf[2] += 4;
|
||
ptr += 4;
|
||
// fall through
|
||
|
||
case 0:
|
||
if (optlen-ptr < 3) break;
|
||
*p = HTONL(timestamp);
|
||
buf[2] += 4;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
buf += optlen;
|
||
buflen -= optlen;
|
||
}
|
||
|
||
return dstaddr;
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
IpReceivePacket(
|
||
Packet* pkt
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Receive an IP datagram
|
||
(called by the NIC interface driver)
|
||
|
||
Arguments:
|
||
|
||
pkt - Points to the received packet
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
|
||
{
|
||
IpHeader* iphdr;
|
||
IPADDR dstaddr, srcaddr;
|
||
UINT iphdrlen, iplen;
|
||
IfInfo* ifp;
|
||
|
||
ASSERT_DISPATCH_LEVEL();
|
||
|
||
//
|
||
// NOTE:
|
||
// 1. We assume the received packet is at least large enough
|
||
// to hold the default IP header.
|
||
// 2. It's more efficient if the interface driver can manage
|
||
// to place the IP header at DWORD-aligned boundary.
|
||
// This is NOT currently the case for EPRO100 interface driver:
|
||
// the Ethernet frame header starts at DWORD-aligned address;
|
||
// which causes the IP header to start at odd-WORD boundary.
|
||
//
|
||
ASSERT(pkt->datalen >= IPHDRLEN);
|
||
|
||
// verify header and packet length
|
||
iphdr = (IpHeader*) pkt->data;
|
||
SETPKTIPHDR(pkt, iphdr);
|
||
iphdrlen = VERIFY_IPVER_HDRLEN(iphdr->ver_hdrlen);
|
||
iplen = GETIPLEN(iphdr);
|
||
|
||
if (iphdrlen < IPHDRLEN || iphdrlen > iplen || iplen > pkt->datalen)
|
||
goto discard;
|
||
|
||
// if the received packet length is larger than the IP length,
|
||
// ignore the data at the end
|
||
pkt->datalen = iplen;
|
||
|
||
// verify header checksum
|
||
if (tcpipxsum(0, pkt->data, iphdrlen) != 0xffff)
|
||
goto discard;
|
||
|
||
//
|
||
// Determine if the packet is addressed to us.
|
||
//
|
||
// NOTE:
|
||
//
|
||
// 1. We reject a packet if the destination address doesn't
|
||
// match the address of the interface it's received on
|
||
// (i.e. we implement the strong ES model).
|
||
//
|
||
// 2. We don't check if a packet with an IP broadcast/multicast
|
||
// destination address was received as unicast on the link-layer
|
||
// interface. Converse, we don't check if a packet with a unicast
|
||
// IP destination address was received as broadcast/multicast
|
||
// on the link-layer interface.
|
||
//
|
||
// 3. We'll receive multicast packets even before the interface
|
||
// has a valid IP address.
|
||
//
|
||
// 4. We only support the all-1's form of broadcast address.
|
||
// Also, we only support limited broadcasts and subnet
|
||
// directed broadcasts (i.e. no special case for directed
|
||
// broadcasts and all-subnets directed broadcasts).
|
||
//
|
||
// 5. We discard all datagrams whose source address is
|
||
// a broadcast or multicast address.
|
||
//
|
||
ifp = pkt->recvifp;
|
||
dstaddr = iphdr->dstaddr;
|
||
|
||
if (dstaddr == ifp->ipaddr && ifp->ipaddr != 0 ||
|
||
IS_MCAST_IPADDR(dstaddr) && IfFindMcastGroup(ifp, dstaddr) ||
|
||
IfBcastAddr(ifp, dstaddr) ||
|
||
IfLoopback(ifp))
|
||
{
|
||
srcaddr = iphdr->srcaddr;
|
||
if (IfBcastAddr(ifp, srcaddr) ||
|
||
IS_MCAST_IPADDR(srcaddr) ||
|
||
IS_LOOPBACK_IPADDR(srcaddr) && !IfLoopback(ifp))
|
||
goto discard;
|
||
|
||
// Check if there is fragmentation involved
|
||
if (iphdr->fragoffset & HTONS(MORE_FRAGMENTS|FRAGOFFSET_MASK)) {
|
||
IpReassemblePkt(pkt);
|
||
return;
|
||
}
|
||
|
||
// Process options if needed
|
||
if (iphdrlen > IPHDRLEN &&
|
||
!IpProcessRecvOptions(pkt->data+IPHDRLEN, iphdrlen-IPHDRLEN, ifp)) {
|
||
// NOTE: we could send a parameter problem ICMP packet here.
|
||
TRACE_("IP datagram option error");
|
||
goto discard;
|
||
}
|
||
|
||
pkt->data += iphdrlen;
|
||
pkt->datalen -= iphdrlen;
|
||
|
||
switch (iphdr->protocol) {
|
||
case IPPROTOCOL_TCP:
|
||
TcpReceivePacket(pkt);
|
||
break;
|
||
|
||
case IPPROTOCOL_UDP:
|
||
UdpReceivePacket(pkt);
|
||
break;
|
||
|
||
case IPPROTOCOL_ICMP:
|
||
IcmpReceivePacket(pkt);
|
||
break;
|
||
|
||
case IPPROTOCOL_IGMP:
|
||
IgmpReceivePacket(pkt);
|
||
break;
|
||
|
||
default:
|
||
RawReceivePacket(pkt);
|
||
break;
|
||
}
|
||
return;
|
||
}
|
||
|
||
discard:
|
||
// Discard the packet and return
|
||
XnetCompletePacket(pkt, NETERR_DISCARDED);
|
||
}
|
||
|