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...
Packet *	addFragment (Packet *packet, simtime_t now)
	Takes a fragment and inserts it into the reassembly buffer. More...
void	purgeStaleFragments (Icmp *icmpModule, 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...
void	flush ()
	Clear all state. More...

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

Protected Attributes
Buffers	bufs

Detailed Description

Reassembly buffer for fragmented Ipv4 datagrams.

Member Typedef Documentation

Buffers

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

protected

Constructor & Destructor Documentation

Ipv4FragBuf()

inet::Ipv4FragBuf::Ipv4FragBuf

(

)

Ctor.

{
}

~Ipv4FragBuf()

inet::Ipv4FragBuf::~Ipv4FragBuf

(

)

Dtor.

{
    flush();
}

Member Function Documentation

addFragment()

Packet * inet::Ipv4FragBuf::addFragment	(	Packet *	packet,
		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.

{
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    // find datagram buffer
    Key key;
    key.id = ipv4Header->getIdentification();
    key.src = ipv4Header->getSrcAddress();
    key.dest = ipv4Header->getDestAddress();
 
    auto i = bufs.find(key);
 
    DatagramBuffer *curBuf = nullptr;
 
    if (i == bufs.end()) {
        // this is the first fragment of that datagram, create reassembly buffer for it
        curBuf = &bufs[key];
        i = bufs.find(key);
    }
    else {
        // use existing buffer
        curBuf = &(i->second);
    }
 
    // add fragment into reassembly buffer
    ASSERT(ipv4Header->getTotalLengthField() > ipv4Header->getHeaderLength());
    B bytes = ipv4Header->getTotalLengthField() - ipv4Header->getHeaderLength();
    curBuf->buf.replace(B(ipv4Header->getFragmentOffset()), packet->peekDataAt(B(ipv4Header->getHeaderLength()), bytes));
    if (!ipv4Header->getMoreFragments()) {
        curBuf->buf.setExpectedLength(B(ipv4Header->getFragmentOffset()) + bytes);
    }
    if (ipv4Header->getFragmentOffset() == 0 || curBuf->packet == nullptr) {
        delete curBuf->packet;
        curBuf->packet = packet;
    }
    else {
        delete packet;
    }
 
    // do we have the complete datagram?
    if (curBuf->buf.isComplete()) {
        // datagram complete: deallocate buffer and return complete datagram
        std::string pkName(curBuf->packet->getName());
        std::size_t found = pkName.find("-frag-");
        if (found != std::string::npos)
            pkName.resize(found);
        auto hdr = Ptr<Ipv4Header>(curBuf->packet->peekAtFront<Ipv4Header>()->dup());
        Packet *pk = curBuf->packet;
        pk->setName(pkName.c_str());
        pk->removeAll();
        const auto& payload = curBuf->buf.getReassembledData();
        hdr->setTotalLengthField(hdr->getHeaderLength() + payload->getChunkLength());
        hdr->setFragmentOffset(0);
        hdr->setMoreFragments(false);
        pk->insertAtFront(hdr);
        pk->insertAtBack(payload);
        bufs.erase(i);
        return pk;
    }
    else {
        // there are still missing fragments
        curBuf->lastupdate = now;
        return nullptr;
    }
}

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

flush()

void inet::Ipv4FragBuf::flush

(

)

Clear all state.

{
    for (auto i = bufs.begin(); i != bufs.end(); ++i)
        delete i->second.packet;
    bufs.clear();
}

Referenced by inet::Ipv4::flush(), and ~Ipv4FragBuf().

purgeStaleFragments()

void inet::Ipv4FragBuf::purgeStaleFragments	(	Icmp *	icmpModule,
		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.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";
            if (buf.packet != nullptr) {
                icmpModule->sendErrorMessage(buf.packet, -1 /*TODO*/, ICMP_TIME_EXCEEDED, 0);
                delete buf.packet;
            }
 
            // delete
            auto oldi = i++;
            bufs.erase(oldi);
        }
        else {
            ++i;
        }
    }
}

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

Member Data Documentation

bufs

Buffers inet::Ipv4FragBuf::bufs

protected

Referenced by addFragment(), flush(), and purgeStaleFragments().

---

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

• Ipv4FragBuf.h
• Ipv4FragBuf.cc