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...
Packet *	addFragment (Packet *packet, const Ipv6Header *dg, const 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

Buffers

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

protected

Constructor & Destructor Documentation

Ipv6FragBuf()

inet::Ipv6FragBuf::Ipv6FragBuf

(

)

Ctor.

{
    icmpModule = nullptr;
}

~Ipv6FragBuf()

inet::Ipv6FragBuf::~Ipv6FragBuf

(

)

Dtor.

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

Member Function Documentation

addFragment()

Packet * inet::Ipv6FragBuf::addFragment	(	Packet *	packet,
		const Ipv6Header *	dg,
		const 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.

{
    // find datagram buffer
    Key key;
    key.id = fh->getIdentification();
    key.src = ipv6Header->getSrcAddress();
    key.dest = ipv6Header->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->packet = nullptr;
        buf->createdAt = now;
    }
    else {
        // use existing buffer
        buf = &(i->second);
    }
 
    int fragmentLength = pk->getByteLength() - B(ipv6Header->getChunkLength()).get(); // 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(pk, ICMPv6_PARAMETER_PROBLEM, ERROREOUS_HDR_FIELD); // TODO set pointer
        delete pk;
        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(pk, ICMPv6_PARAMETER_PROBLEM, ERROREOUS_HDR_FIELD); // TODO set pointer
        delete pk;
        return nullptr;
    }
 
    // add fragment to buffer
    buf->buf.replace(B(offset), pk->peekDataAt(ipv6Header->getChunkLength(), B(fragmentLength)));
 
    if (!moreFragments) {
        buf->buf.setExpectedLength(B(offset + fragmentLength));
    }
 
    // Store the first fragment. The first fragment contains the whole
    // encapsulated payload, and extension headers of the
    // original datagram.
    if (offset == 0) {
        delete buf->packet;
        buf->packet = pk;
    }
    else {
        delete pk;
    }
 
    // do we have the complete datagram?
    if (buf->buf.isComplete()) {
        // datagram complete: deallocate buffer and return complete datagram
        std::string pkName(buf->packet->getName());
        std::size_t found = pkName.find("-frag-");
        if (found != std::string::npos)
            pkName.resize(found);
        Packet *pk = new Packet(pkName.c_str());
        pk->copyTags(*buf->packet);
        auto hdr = Ptr<Ipv6Header>(buf->packet->peekAtFront<Ipv6Header>()->dup());
        const auto& payload = buf->buf.getReassembledData();
        hdr->removeExtensionHeader(IP_PROT_IPv6EXT_FRAGMENT);
        hdr->setChunkLength(B(hdr->calculateUnfragmentableHeaderByteLength()));
        pk->insertAtFront(hdr);
        pk->insertAtBack(payload);
        delete buf->packet;
        bufs.erase(i);
        return pk;
    }
    else {
        // there are still missing fragments
        return nullptr;
    }
}

Referenced by inet::Ipv6::localDeliver().

init()

void inet::Ipv6FragBuf::init

(

Icmpv6 *

icmp

)

Initialize fragmentation buffer.

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

{
    icmpModule = icmp;
}

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

purgeStaleFragments()

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.

{
    // 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.packet) {
                // send ICMP error
                EV_INFO << "datagram fragment timed out in reassembly buffer, sending ICMP_TIME_EXCEEDED\n";
                icmpModule->sendErrorMessage(buf.packet, ICMPv6_TIME_EXCEEDED, 0);
                delete buf.packet;
            }
 
            // delete
            auto oldi = i++;
            bufs.erase(oldi);
        }
        else {
            ++i;
        }
    }
}

Referenced by inet::Ipv6::localDeliver().

Member Data Documentation

bufs

Buffers inet::Ipv6FragBuf::bufs

protected

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

icmpModule

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