inet::IPv4FragBuf Class Reference

Reassembly buffer for fragmented IPv4 datagrams. More...

#include <IPv4FragBuf.h>

Classes
struct	DatagramBuffer
struct	Key

Public Member Functions
	IPv4FragBuf ()
	Ctor. More...
	~IPv4FragBuf ()
	Dtor. More...
void	init (ICMP *icmp)
	Initialize fragmentation buffer. More...
IPv4Datagram *	addFragment (IPv4Datagram *datagram, simtime_t now)
	Takes a fragment and inserts it into the reassembly buffer. More...
void	purgeStaleFragments (simtime_t lastupdate)
	Throws out all fragments which are incomplete and their last update (last fragment arrival) was before "lastupdate", and sends ICMP TIME EXCEEDED message about them. More...

Protected Types
typedef std::map< Key, DatagramBuffer >	Buffers

Protected Attributes
Buffers	bufs
ICMP *	icmpModule

Detailed Description

Reassembly buffer for fragmented IPv4 datagrams.

Member Typedef Documentation

typedef std::map<Key, DatagramBuffer> inet::IPv4FragBuf::Buffers

protected

Constructor & Destructor Documentation

inet::IPv4FragBuf::IPv4FragBuf

(

)

Ctor.

{
    icmpModule = nullptr;
}

inet::IPv4FragBuf::~IPv4FragBuf

(

)

Dtor.

{
    while (!bufs.empty()) {
        if (bufs.begin()->second.datagram)
            delete bufs.begin()->second.datagram;

        bufs.erase(bufs.begin());
    }
}

Member Function Documentation

IPv4Datagram * inet::IPv4FragBuf::addFragment	(	IPv4Datagram *	datagram,
		simtime_t	now
	)

Takes a fragment and inserts it into the reassembly buffer.

If this fragment completes a datagram, the full reassembled datagram is returned, otherwise nullptr.

Referenced by inet::IPv4::reassembleAndDeliver().

{
    // find datagram buffer
    Key key;
    key.id = datagram->getIdentification();
    key.src = datagram->getSrcAddress();
    key.dest = datagram->getDestAddress();

    auto i = bufs.find(key);

    DatagramBuffer *buf = nullptr;

    if (i == bufs.end()) {
        // this is the first fragment of that datagram, create reassembly buffer for it
        buf = &bufs[key];
        buf->datagram = nullptr;
    }
    else {
        // use existing buffer
        buf = &(i->second);
    }

    // add fragment into reassembly buffer
    int bytes = datagram->getByteLength() - datagram->getHeaderLength();
    bool isComplete = buf->buf.addFragment(datagram->getFragmentOffset(),
                datagram->getFragmentOffset() + bytes,
                !datagram->getMoreFragments());

    // store datagram. Only one fragment carries the actual modelled
    // content (getEncapsulatedPacket()), other (empty) ones are only
    // preserved so that we can send them in ICMP if reassembly times out.
    if (buf->datagram == nullptr) {
        if (dynamic_cast<RawPacket *>(datagram->getEncapsulatedPacket())) {
            RawPacket * rp = static_cast<RawPacket *>(datagram->getEncapsulatedPacket());
            // move raw bytes to its offset in RawPacket
            if (datagram->getFragmentOffset()) {
                rp->getByteArray().expandData(datagram->getFragmentOffset(), 0);
                rp->addByteLength(datagram->getFragmentOffset());
            }
        }

        buf->datagram = datagram;
    }
    else if (buf->datagram->getEncapsulatedPacket() == nullptr && datagram->getEncapsulatedPacket() != nullptr) {
        delete buf->datagram;

        if (dynamic_cast<RawPacket *>(datagram->getEncapsulatedPacket())) {
            RawPacket *rp = static_cast<RawPacket *>(datagram->getEncapsulatedPacket());
            // move raw bytes to its offset in RawPacket
            if (datagram->getFragmentOffset()) {
                rp->getByteArray().expandData(datagram->getFragmentOffset(), 0);
                rp->setByteLength(rp->getByteArray().getDataArraySize());
            }
        }

        buf->datagram = datagram;
    }
    else {
        RawPacket *brp = dynamic_cast<RawPacket *>(buf->datagram->getEncapsulatedPacket());
        RawPacket *rp = dynamic_cast<RawPacket *>(datagram->getEncapsulatedPacket());
        if (brp && rp) {
            // merge encapsulated raw data
            brp->getByteArray().copyDataFromBuffer(datagram->getFragmentOffset(), rp->getByteArray().getDataPtr(), rp->getByteArray().getDataArraySize());
            brp->setByteLength(rp->getByteArray().getDataArraySize());
        }
        delete datagram;
    }

    // do we have the complete datagram?
    if (isComplete) {
        // datagram complete: deallocate buffer and return complete datagram
        IPv4Datagram *ret = buf->datagram;
        ret->setByteLength(ret->getHeaderLength() + buf->buf.getTotalLength());
        ret->setFragmentOffset(0);
        ret->setMoreFragments(false);
        bufs.erase(i);
        if (dynamic_cast<RawPacket *>(ret->getEncapsulatedPacket())) {
            using namespace serializer;
            RawPacket *rp = static_cast<RawPacket *>(ret->getEncapsulatedPacket());
            char ipv4addresses[8];    // 2 * 4 bytes for 2 IPv4 addresses
            Buffer hdr(ipv4addresses, sizeof(ipv4addresses));
            hdr.writeIPv4Address(ret->getSrcAddress());
            hdr.writeIPv4Address(ret->getDestAddress());
            Buffer b(rp->getByteArray().getDataPtr(), rp->getByteArray().getDataArraySize());
            Context c;
            c.l3AddressesPtr = ipv4addresses;
            c.l3AddressesLength = sizeof(ipv4addresses);
            cPacket *enc = SerializerBase::lookupAndDeserialize(b, c, IP_PROT, ret->getTransportProtocol());
            if (enc) {
                delete ret->decapsulate();
                ret->encapsulate(enc);
            }
        }
        return ret;
    }
    else {
        // there are still missing fragments
        buf->lastupdate = now;
        return nullptr;
    }
}

void inet::IPv4FragBuf::init

(

ICMP *

icmp

)

Initialize fragmentation buffer.

ICMP module is needed for sending TIME_EXCEEDED ICMP message in purgeStaleFragments().

Referenced by inet::IPv4::initialize().

{
    icmpModule = icmp;
}

void inet::IPv4FragBuf::purgeStaleFragments

(

simtime_t

lastupdate

)

Throws out all fragments which are incomplete and their last update (last fragment arrival) was before "lastupdate", and sends ICMP TIME EXCEEDED message about them.

Timeout should be between 60 seconds and 120 seconds (RFC1122). This method should be called more frequently, maybe every 10..30 seconds or so.

Referenced by inet::IPv4::reassembleAndDeliver().

{
    // this method shouldn't be called too often because iteration on
    // an std::map is *very* slow...

    ASSERT(icmpModule);

    for (auto i = bufs.begin(); i != bufs.end(); ) {
        // if too old, remove it
        DatagramBuffer& buf = i->second;
        if (buf.lastupdate < lastupdate) {
            // send ICMP error.
            // Note: receiver MUST NOT call decapsulate() on the datagram fragment,
            // because its length (being a fragment) is smaller than the encapsulated
            // packet, resulting in "length became negative" error. Use getEncapsulatedPacket().
            EV_WARN << "datagram fragment timed out in reassembly buffer, sending ICMP_TIME_EXCEEDED\n";
            icmpModule->sendErrorMessage(buf.datagram, -1    /*TODO*/, ICMP_TIME_EXCEEDED, 0);

            // delete
            auto oldi = i++;
            bufs.erase(oldi);
        }
        else {
            ++i;
        }
    }
}

Member Data Documentation

Buffers inet::IPv4FragBuf::bufs

protected

Referenced by addFragment(), purgeStaleFragments(), and ~IPv4FragBuf().

ICMP* inet::IPv4FragBuf::icmpModule

protected

Referenced by init(), IPv4FragBuf(), and purgeStaleFragments().

---

The documentation for this class was generated from the following files:

• IPv4FragBuf.h
• IPv4FragBuf.cc