inet::serializer::IPv4Serializer Class Reference

Converts between IPv4Datagram and binary (network byte order) IPv4 header. More...

#include <IPv4Serializer.h>

Inheritance diagram for inet::serializer::IPv4Serializer:

Public Member Functions
	IPv4Serializer (const char *name=nullptr)
Public Member Functions inherited from inet::serializer::SerializerBase
	SerializerBase (const char *name=nullptr)
void	serializePacket (const cPacket *pkt, Buffer &b, Context &context)
cPacket *	deserializePacket (const Buffer &b, Context &context)

Protected Member Functions
virtual void	serialize (const cPacket *pkt, Buffer &b, Context &context) override
	Serializes a cPacket for transmission on the wire. More...
virtual cPacket *	deserialize (const Buffer &b, Context &context) override
	Puts a packet sniffed from the wire into an EtherFrame. More...
void	serializeOptions (const IPv4Datagram *dgram, Buffer &b, Context &c)
void	deserializeOptions (IPv4Datagram *dgram, Buffer &b, Context &c)

Additional Inherited Members
Static Public Member Functions inherited from inet::serializer::SerializerBase
static SerializerBase &	lookupSerializer (const cPacket *pkt, Context &context, ProtocolGroup group, int id)
static void	lookupAndSerialize (const cPacket *pkt, Buffer &b, Context &context, ProtocolGroup group, int id, unsigned int maxLength=(unsigned int)(-1))
static SerializerBase &	lookupDeserializer (Context &context, ProtocolGroup group, int id)
static cPacket *	lookupAndDeserialize (const Buffer &b, Context &context, ProtocolGroup group, int id, unsigned int maxLength=(unsigned int)(-1))

Detailed Description

Converts between IPv4Datagram and binary (network byte order) IPv4 header.

Constructor & Destructor Documentation

inet::serializer::IPv4Serializer::IPv4Serializer ( const char *  name = nullptr )

inline

: SerializerBase(name) {}

Member Function Documentation

cPacket * inet::serializer::IPv4Serializer::deserialize ( const Buffer &  b, Context &  context  )

overrideprotectedvirtual

Puts a packet sniffed from the wire into an EtherFrame.

Implements inet::serializer::SerializerBase.

{
    ASSERT(b.getPos() == 0);

    IPv4Datagram *dest = new IPv4Datagram("parsed-ipv4");
    unsigned int bufsize = b.getRemainingSize();
    const struct ip *ip = static_cast<const struct ip *>(b.accessNBytes(IP_HEADER_BYTES));
    if (!ip ) {
        delete dest;
        return nullptr;
    }
    unsigned int totalLength, headerLength;
    c.l3AddressesPtr = &ip->ip_src.s_addr;
    c.l3AddressesLength = sizeof(ip->ip_src.s_addr) + sizeof(ip->ip_dst.s_addr);

    dest->setVersion(ip->ip_v);
    dest->setHeaderLength(IP_HEADER_BYTES);
    dest->setSrcAddress(IPv4Address(ntohl(ip->ip_src.s_addr)));
    dest->setDestAddress(IPv4Address(ntohl(ip->ip_dst.s_addr)));
    dest->setTransportProtocol(ip->ip_p);
    dest->setTimeToLive(ip->ip_ttl);
    dest->setIdentification(ntohs(ip->ip_id));
    uint16_t ip_off = ntohs(ip->ip_off);
    dest->setMoreFragments((ip_off & IP_MF) != 0);
    dest->setDontFragment((ip_off & IP_DF) != 0);
    dest->setFragmentOffset((ntohs(ip->ip_off) & IP_OFFMASK) * 8);
    dest->setTypeOfService(ip->ip_tos);
    totalLength = ntohs(ip->ip_len);
    dest->setTotalLengthField(totalLength);
    headerLength = ip->ip_hl << 2;

    if (headerLength < IP_HEADER_BYTES) {
        dest->setBitError(true);
        headerLength = IP_HEADER_BYTES;
    }

    dest->setHeaderLength(headerLength);

    if (headerLength > b._getBufSize() || TCPIPchecksum::checksum(ip, headerLength) != 0)
        dest->setBitError(true);

    if (headerLength > IP_HEADER_BYTES) {    // options present?
        unsigned short optionBytes = headerLength - IP_HEADER_BYTES;
        Buffer sb(b, optionBytes);
        deserializeOptions(dest, sb, c);
        if (sb.hasError())
            b.setError();
    }
    b.seek(headerLength);

    if (totalLength > bufsize)
        EV_ERROR << "Can not handle IPv4 packet of total length " << totalLength << "(captured only " << bufsize << " bytes).\n";

    dest->setByteLength(headerLength);
    unsigned int payloadLength = totalLength - headerLength;
    cPacket *encapPacket = nullptr;
    if (dest->getMoreFragments() || dest->getFragmentOffset() != 0) {  // IP fragment
        Buffer subBuffer(b, payloadLength);
        encapPacket = serializers.byteArraySerializer.deserialize(subBuffer, c);
        b.accessNBytes(subBuffer.getPos());
    }
    else
        encapPacket = SerializerBase::lookupAndDeserialize(b, c, IP_PROT, dest->getTransportProtocol(), payloadLength);

    if (encapPacket) {
        dest->encapsulate(encapPacket);
        dest->setName(encapPacket->getName());
    }
    return dest;
}

void inet::serializer::IPv4Serializer::deserializeOptions ( IPv4Datagram *  dgram, Buffer &  b, Context &  c  )

protected

{
    while (b.getRemainingSize()) {
        unsigned int pos = b.getPos();
        unsigned char type = b.readByte();
        b.seek(pos);
        TLVOptionBase *option = ipv4OptionSerializers.lookup(type)->deserializeOption(b, c);
        dgram->addOption(option);
    }
}

void inet::serializer::IPv4Serializer::serialize ( const cPacket *  pkt, Buffer &  b, Context &  context  )

overrideprotectedvirtual

Serializes a cPacket for transmission on the wire.

Returns the length of data written into buffer.

Implements inet::serializer::SerializerBase.

{
    ASSERT(b.getPos() == 0);

    if (typeid(*pkt) != typeid(IPv4Datagram)) {
        if (c.throwOnSerializerNotFound)
            throw cRuntimeError("IPv4Serializer: class '%s' not accepted", pkt->getClassName());
        EV_ERROR << "IPv4Serializer: class '" << pkt->getClassName() << "' not accepted.\n";
        b.fillNBytes(pkt->getByteLength(), '?');
        return;
    }

    struct ip *ip = (struct ip *)b.accessNBytes(IP_HEADER_BYTES);
    if (!ip) {
        EV_ERROR << "IPv4Serializer: not enough space for IPv4 header.\n";
        return;
    }
    const IPv4Datagram *dgram = check_and_cast<const IPv4Datagram *>(pkt);
    unsigned int headerLength = dgram->getHeaderLength();
    ASSERT((headerLength & 3) == 0);
    ip->ip_hl = headerLength >> 2;
    ip->ip_v = dgram->getVersion();
    ip->ip_tos = dgram->getTypeOfService();
    ip->ip_id = htons(dgram->getIdentification());
    ASSERT((dgram->getFragmentOffset() & 7) == 0);
    uint16_t ip_off = dgram->getFragmentOffset() / 8;
    if (dgram->getMoreFragments())
        ip_off |= IP_MF;
    if (dgram->getDontFragment())
        ip_off |= IP_DF;
    ip->ip_off = htons(ip_off);
    ip->ip_ttl = dgram->getTimeToLive();
    ip->ip_p = dgram->getTransportProtocol();
    ip->ip_src.s_addr = htonl(dgram->getSrcAddress().getInt());
    ip->ip_dst.s_addr = htonl(dgram->getDestAddress().getInt());
    ip->ip_len = htons(dgram->getTotalLengthField());
    ip->ip_sum = 0;
    c.l3AddressesPtr = &ip->ip_src.s_addr;
    c.l3AddressesLength = sizeof(ip->ip_src.s_addr) + sizeof(ip->ip_dst.s_addr);

    if (headerLength > IP_HEADER_BYTES) {
        Buffer sb(b, headerLength - IP_HEADER_BYTES);
        serializeOptions(dgram, sb, c);
        b.accessNBytes(sb.getPos());
        if (sb.hasError())
            b.setError();
    }

    const cPacket *encapPacket = dgram->getEncapsulatedPacket();
    unsigned int payloadLength = dgram->getByteLength() - b.getPos();

    if (encapPacket) {
        unsigned int totalLength = encapPacket->getByteLength();
        int fragmentOffset = dgram->getFragmentOffset();
        if ((dgram->getMoreFragments() || fragmentOffset != 0) && (payloadLength < totalLength)) {  // IP fragment  //FIXME hack: encapsulated packet contains entire packet if payloadLength < totalLength
            char *buf = new char[totalLength];
            Buffer tmpBuffer(buf, totalLength);
            SerializerBase::lookupAndSerialize(encapPacket, tmpBuffer, c, IP_PROT, dgram->getTransportProtocol());
            tmpBuffer.seek(fragmentOffset);
            b.writeNBytes(tmpBuffer, payloadLength);
            delete [] buf;
        }
        else    // no fragmentation, or the encapsulated packet is represents only the fragment
            SerializerBase::lookupAndSerialize(encapPacket, b, c, IP_PROT, dgram->getTransportProtocol());
    }
    else {
        b.fillNBytes(payloadLength, '?');
    }

    ip->ip_sum = htons(TCPIPchecksum::checksum(ip, IP_HEADER_BYTES));
}

void inet::serializer::IPv4Serializer::serializeOptions ( const IPv4Datagram *  dgram, Buffer &  b, Context &  c  )

protected

{
    unsigned short numOptions = dgram->getOptionArraySize();
    unsigned int optionsLength = 0;
    if (numOptions > 0) {    // options present?
        for (unsigned short i = 0; i < numOptions; i++) {
            const TLVOptionBase *option = &dgram->getOption(i);
            ipv4OptionSerializers.lookup(option->getType())->serializeOption(option, b, c);
            optionsLength += option->getLength();
        }
    }    // if options present
    if (dgram->getHeaderLength() < (int)(IP_HEADER_BYTES + optionsLength))
        throw cRuntimeError("Serializing an IPv4 packet with wrong headerLength value: not enough for store options.\n");
    //padding:
    if (b.getRemainingSize()) {
        b.fillNBytes(b.getRemainingSize(), IPOPTION_END_OF_OPTIONS);
    }
}

---

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

• IPv4Serializer.h
• IPv4Serializer.cc