inet::serializer::IPv4OptionDefaultSerializer Class Reference

#include <IPv4Serializer.h>

Inheritance diagram for inet::serializer::IPv4OptionDefaultSerializer:

Public Member Functions
	IPv4OptionDefaultSerializer (const char *name=nullptr)
void	serializeOption (const TLVOptionBase *option, Buffer &b, Context &c) override
TLVOptionBase *	deserializeOption (Buffer &b, Context &c) override
Public Member Functions inherited from inet::serializer::IPv4OptionSerializerBase
	IPv4OptionSerializerBase (const char *name=nullptr)

Constructor & Destructor Documentation

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

inline

: IPv4OptionSerializerBase(name) {}

Member Function Documentation

TLVOptionBase * inet::serializer::IPv4OptionDefaultSerializer::deserializeOption ( Buffer &  b, Context &  c  )

overridevirtual

Implements inet::serializer::IPv4OptionSerializerBase.

{
    unsigned int pos = b.getPos();
    unsigned char type = b.readByte();
    unsigned char length = 1;

    switch (type) {
        case IPOPTION_END_OF_OPTIONS:    // EOL
            return new IPv4OptionEnd();

        case IPOPTION_NO_OPTION:    // NOP
            return new IPv4OptionNop();

        case IPOPTION_STREAM_ID:
            length = b.readByte();
            if (length == 4) {
                auto *option = new IPv4OptionStreamId();
                option->setType(type);
                option->setLength(length);
                option->setStreamId(b.readUint16());
                return option;
            }
            break;

        case IPOPTION_TIMESTAMP: {
            length = b.readByte();
            uint8_t pointer = b.readByte();
            uint8_t flagbyte = b.readByte();
            uint8_t overflow = flagbyte >> 4;
            int flag = -1;
            int bytes = 0;
            switch (flagbyte & 0x0f) {
                case 0: flag = IP_TIMESTAMP_TIMESTAMP_ONLY; bytes = 4; break;
                case 1: flag = IP_TIMESTAMP_WITH_ADDRESS; bytes = 8; break;
                case 3: flag = IP_TIMESTAMP_SENDER_INIT_ADDRESS; bytes = 8; break;
                default: break;
            }
            if (flag != -1 && length > 4 && bytes && ((length-4) % bytes) == 0 && pointer >= 5 && ((pointer-5) % bytes) == 0) {
                auto *option = new IPv4OptionTimestamp();
                option->setType(type);
                option->setLength(length);
                option->setFlag(flag);
                option->setOverflow(overflow);
                option->setRecordTimestampArraySize((length - 4) / bytes);
                if (bytes == 8)
                    option->setRecordAddressArraySize((length - 4) / bytes);
                option->setNextIdx((pointer-5) / bytes);
                for (unsigned int count = 0; count < option->getRecordAddressArraySize(); count++) {
                    if (bytes == 8)
                        option->setRecordAddress(count, b.readIPv4Address());
                    option->setRecordTimestamp(count, SimTime(b.readUint32(), SIMTIME_MS));
                }
                return option;
            }
            break;
        }

        case IPOPTION_RECORD_ROUTE:
        case IPOPTION_LOOSE_SOURCE_ROUTING:
        case IPOPTION_STRICT_SOURCE_ROUTING: {
            length = b.readByte();
            uint8_t pointer = b.readByte();
            if (length > 3 && (length % 4) == 3 && pointer >= 4 && (pointer % 4) == 0) {
                auto *option = new IPv4OptionRecordRoute();
                option->setType(type);
                option->setLength(length);
                option->setRecordAddressArraySize((length - 3) / 4);
                option->setNextAddressIdx((pointer-4) / 4);
                for (unsigned int count = 0; count < option->getRecordAddressArraySize(); count++) {
                    option->setRecordAddress(count, b.readIPv4Address());
                }
                return option;
            }
            break;
        }

        case IPOPTION_ROUTER_ALERT:
        case IPOPTION_SECURITY:
        default:
            break;
    }    // switch

    auto *option = new TLVOptionRaw();
    b.seek(pos);
    type = b.readByte();
    length = b.readByte();
    option->setType(type);
    option->setLength(length);
    if (length > 2)
        option->setBytesArraySize(length - 2);
    for (unsigned int i = 2; i < length; i++)
        option->setBytes(i-2, b.readByte());
    return option;
}

void inet::serializer::IPv4OptionDefaultSerializer::serializeOption ( const TLVOptionBase *  option, Buffer &  b, Context &  c  )

overridevirtual

Implements inet::serializer::IPv4OptionSerializerBase.

Referenced by inet::serializer::IPv4Serializer::serializeOptions().

{
    unsigned short type = option->getType();
    unsigned short length = option->getLength();    // length >= 1

    b.writeByte(type);
    if (length > 1)
        b.writeByte(length);

    auto *opt = dynamic_cast<const TLVOptionRaw *>(option);
    if (opt) {
        unsigned int datalen = opt->getBytesArraySize();
        ASSERT(length == 2 + datalen);
        for (unsigned int i = 0; i < datalen; i++)
            b.writeByte(opt->getBytes(i));
        return;
    }

    switch (type) {
        case IPOPTION_END_OF_OPTIONS:
            check_and_cast<const IPv4OptionEnd *>(option);
            ASSERT(length == 1);
            break;

        case IPOPTION_NO_OPTION:
            check_and_cast<const IPv4OptionNop *>(option);
            ASSERT(length == 1);
            break;

        case IPOPTION_STREAM_ID: {
            auto *opt = check_and_cast<const IPv4OptionStreamId *>(option);
            ASSERT(length == 4);
            b.writeUint16(opt->getStreamId());
            break;
        }

        case IPOPTION_TIMESTAMP: {
            auto *opt = check_and_cast<const IPv4OptionTimestamp *>(option);
            int bytes = (opt->getFlag() == IP_TIMESTAMP_TIMESTAMP_ONLY) ? 4 : 8;
            ASSERT(length == 4 + bytes * opt->getRecordTimestampArraySize());
            uint8_t pointer = 5 + opt->getNextIdx() * bytes;
            b.writeByte(pointer);
            uint8_t flagbyte = opt->getOverflow() << 4 | opt->getFlag();
            b.writeByte(flagbyte);
            for (unsigned int count = 0; count < opt->getRecordTimestampArraySize(); count++) {
                if (bytes == 8)
                    b.writeIPv4Address(opt->getRecordAddress(count));
                b.writeUint32(opt->getRecordTimestamp(count).inUnit(SIMTIME_MS));
            }
            break;
        }

        case IPOPTION_RECORD_ROUTE:
        case IPOPTION_LOOSE_SOURCE_ROUTING:
        case IPOPTION_STRICT_SOURCE_ROUTING: {
            auto *opt = check_and_cast<const IPv4OptionRecordRoute *>(option);
            ASSERT(length == 3 + 4 * opt->getRecordAddressArraySize());
            uint8_t pointer = 4 + opt->getNextAddressIdx() * 4;
            b.writeByte(pointer);
            for (unsigned int count = 0; count < opt->getRecordAddressArraySize(); count++) {
                b.writeIPv4Address(opt->getRecordAddress(count));
            }
            break;
        }
        case IPOPTION_ROUTER_ALERT:
        case IPOPTION_SECURITY:
        default: {
            throw cRuntimeError("Unknown IPv4Option type=%d (not in an TLVOptionRaw option)", type);
            break;
        }
    }
}

---

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

• IPv4Serializer.h
• IPv4Serializer.cc