inet::IPv6FragBuf Class Reference

Reassembly buffer for fragmented IPv6 datagrams. More...

#include <IPv6FragBuf.h>

Classes
struct	DatagramBuffer
struct	Key

Public Member Functions
	IPv6FragBuf ()
	Ctor. More...
	~IPv6FragBuf ()
	Dtor. More...
void	init (ICMPv6 *icmp)
	Initialize fragmentation buffer. More...
IPv6Datagram *	addFragment (IPv6Datagram *datagram, IPv6FragmentHeader *fh, 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
ICMPv6 *	icmpModule = nullptr

Detailed Description

Reassembly buffer for fragmented IPv6 datagrams.

Member Typedef Documentation

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

protected

Constructor & Destructor Documentation

inet::IPv6FragBuf::IPv6FragBuf

(

)

Ctor.

{
    icmpModule = nullptr;
}

inet::IPv6FragBuf::~IPv6FragBuf

(

)

Dtor.

{
    for (auto & elem : bufs) {
        delete elem.second.datagram;
    }
}

Member Function Documentation

IPv6Datagram * inet::IPv6FragBuf::addFragment	(	IPv6Datagram *	datagram,
		IPv6FragmentHeader *	fh,
		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::IPv6::localDeliver().

{
    // find datagram buffer
    Key key;
    key.id = fh->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;
        buf->createdAt = now;
    }
    else {
        // use existing buffer
        buf = &(i->second);
    }

    int fragmentLength = datagram->calculateFragmentLength();
    unsigned short offset = fh->getFragmentOffset();
    bool moreFragments = fh->getMoreFragments();

    // RFC 2460 4.5:
    // If the length of a fragment, as derived from the fragment packet's
    // Payload Length field, is not a multiple of 8 octets and the M flag
    // of that fragment is 1, then that fragment must be discarded and an
    // ICMP Parameter Problem, Code 0, message should be sent to the
    // source of the fragment, pointing to the Payload Length field of
    // the fragment packet.
    if (moreFragments && (fragmentLength % 8) != 0) {
        icmpModule->sendErrorMessage(datagram, ICMPv6_PARAMETER_PROBLEM, ERROREOUS_HDR_FIELD);    // TODO set pointer
        return nullptr;
    }

    // RFC 2460 4.5:
    // If the length and offset of a fragment are such that the Payload
    // Length of the packet reassembled from that fragment would exceed
    // 65,535 octets, then that fragment must be discarded and an ICMP
    // Parameter Problem, Code 0, message should be sent to the source of
    // the fragment, pointing to the Fragment Offset field of the
    // fragment packet.
    if (offset + fragmentLength > 65535) {
        icmpModule->sendErrorMessage(datagram, ICMPv6_PARAMETER_PROBLEM, ERROREOUS_HDR_FIELD);    // TODO set pointer
        return nullptr;
    }

    // add fragment to buffer
    bool isComplete = buf->buf.addFragment(offset,
                offset + fragmentLength,
                !moreFragments);

    // Store the first fragment. The first fragment contains the whole
    // encapsulated payload, and extension headers of the
    // original datagram.
    if (offset == 0) {
        delete buf->datagram;
        buf->datagram = datagram;
    }
    else {
        delete datagram;
    }

    // do we have the complete datagram?
    if (isComplete) {
        // datagram complete: deallocate buffer and return complete datagram
        IPv6Datagram *ret = buf->datagram;
        if (!ret)
            throw cRuntimeError("Model error: completed datagram without datagram pointer.");
        ret->removeExtensionHeader(IP_PROT_IPv6EXT_FRAGMENT);
        ret->setByteLength(ret->calculateUnfragmentableHeaderByteLength() + buf->buf.getTotalLength());
        bufs.erase(i);
        return ret;
    }
    else {
        // there are still missing fragments
        return nullptr;
    }
}

void inet::IPv6FragBuf::init

(

ICMPv6 *

icmp

)

Initialize fragmentation buffer.

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

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

{
    icmpModule = icmp;
}

void inet::IPv6FragBuf::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::IPv6::localDeliver().

{
    // 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.createdAt < lastupdate) {
            if (buf.datagram) {
                // send ICMP error
                EV_INFO << "datagram fragment timed out in reassembly buffer, sending ICMP_TIME_EXCEEDED\n";
                icmpModule->sendErrorMessage(buf.datagram, ICMPv6_TIME_EXCEEDED, 0);
            }

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

Member Data Documentation

Buffers inet::IPv6FragBuf::bufs

protected

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

ICMPv6* inet::IPv6FragBuf::icmpModule = nullptr

protected

Referenced by addFragment(), init(), IPv6FragBuf(), and purgeStaleFragments().

---

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

• IPv6FragBuf.h
• IPv6FragBuf.cc