inet::serializer::IPv6Serializer Class Reference

Converts between IPv6Datagram and binary (network byte order) IPv6 header. More...

#include <IPv6Serializer.h>

Inheritance diagram for inet::serializer::IPv6Serializer:

Public Member Functions
	IPv6Serializer (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...

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 IPv6Datagram and binary (network byte order) IPv6 header.

Constructor & Destructor Documentation

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

inline

: SerializerBase(name) {}

Member Function Documentation

cPacket * inet::serializer::IPv6Serializer::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);
    IPv6Datagram *dest = new IPv6Datagram("parsed-ipv6");
    const struct ip6_hdr *ip6h = (struct ip6_hdr *) b.accessNBytes(IPv6_HEADER_BYTES);
    uint32_t flowinfo = ntohl(ip6h->ip6_flow);
    dest->setFlowLabel(flowinfo & 0xFFFFF);
    flowinfo >>= 20;
    dest->setTrafficClass(flowinfo & 0xFF);

    unsigned int packetLength = ntohs(ip6h->ip6_plen);

    dest->setTransportProtocol(ip6h->ip6_nxt);
    dest->setHopLimit(ntohs(ip6h->ip6_hlim));

    IPv6Address temp;
    temp.set(ntohl(ip6h->ip6_src.__u6_addr.__u6_addr32[0]),
             ntohl(ip6h->ip6_src.__u6_addr.__u6_addr32[1]),
             ntohl(ip6h->ip6_src.__u6_addr.__u6_addr32[2]),
             ntohl(ip6h->ip6_src.__u6_addr.__u6_addr32[3]));
    dest->setSrcAddress(temp);

    temp.set(ntohl(ip6h->ip6_dst.__u6_addr.__u6_addr32[0]),
             ntohl(ip6h->ip6_dst.__u6_addr.__u6_addr32[1]),
             ntohl(ip6h->ip6_dst.__u6_addr.__u6_addr32[2]),
             ntohl(ip6h->ip6_dst.__u6_addr.__u6_addr32[3]));
    dest->setDestAddress(temp);

    c.l3AddressesPtr = &ip6h->ip6_src.__u6_addr.__u6_addr32[0];
    c.l3AddressesLength = 32;

    if (packetLength + IPv6_HEADER_BYTES > b._getBufSize()) {
        EV_ERROR << "Can not handle IPv6 packet of total length " << packetLength + IPv6_HEADER_BYTES << "(captured only " << b._getBufSize() << " bytes).\n";
        b.setError();
    }
    dest->setByteLength(b.getPos());    // set header size

    cPacket *encapPacket = SerializerBase::lookupAndDeserialize(b, c, IP_PROT, dest->getTransportProtocol(), packetLength);
    if (encapPacket) {
        dest->encapsulate(encapPacket);
        dest->setName(encapPacket->getName());
    }
    return dest;
}

void inet::serializer::IPv6Serializer::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.

{
    const IPv6Datagram *dgram = check_and_cast<const IPv6Datagram *>(pkt);
    unsigned int i;
    uint32_t flowinfo;

    EV << "Serialize IPv6 packet\n";

    unsigned int nextHdrCodePos = b.getPos() + 6;
    struct ip6_hdr *ip6h = (struct ip6_hdr *)b.accessNBytes(sizeof(struct ip6_hdr));

    flowinfo = 0x06;
    flowinfo <<= 8;
    flowinfo |= dgram->getTrafficClass();
    flowinfo <<= 20;
    flowinfo |= dgram->getFlowLabel();
    ip6h->ip6_flow = htonl(flowinfo);
    ip6h->ip6_hlim = htons(dgram->getHopLimit());

    ip6h->ip6_nxt = dgram->getTransportProtocol();

    for (i = 0; i < 4; i++) {
        ip6h->ip6_src.__u6_addr.__u6_addr32[i] = htonl(dgram->getSrcAddress().words()[i]);
    }
    for (i = 0; i < 4; i++) {
        ip6h->ip6_dst.__u6_addr.__u6_addr32[i] = htonl(dgram->getDestAddress().words()[i]);
    }
    c.l3AddressesPtr = &ip6h->ip6_src.__u6_addr.__u6_addr32[0];
    c.l3AddressesLength = 32;

    //FIXME serialize extension headers
    for (i = 0; i < dgram->getExtensionHeaderArraySize(); i++) {
        const IPv6ExtensionHeader *extHdr = dgram->getExtensionHeader(i);
        b.writeByteTo(nextHdrCodePos, extHdr->getExtensionType());
        nextHdrCodePos = b.getPos();
        b.writeByte(dgram->getTransportProtocol());
        ASSERT((extHdr->getByteLength() & 7) == 0);
        b.writeByte((extHdr->getByteLength() - 8) / 8);
        switch (extHdr->getExtensionType()) {
            case IP_PROT_IPv6EXT_HOP: {
                const IPv6HopByHopOptionsHeader *hdr = check_and_cast<const IPv6HopByHopOptionsHeader *>(extHdr);
                b.fillNBytes(hdr->getByteLength() - 2, '\0');    //TODO
                break;
            }
            case IP_PROT_IPv6EXT_DEST: {
                const IPv6DestinationOptionsHeader *hdr = check_and_cast<const IPv6DestinationOptionsHeader *>(extHdr);
                b.fillNBytes(hdr->getByteLength() - 2, '\0');    //TODO
                break;
            }
            case IP_PROT_IPv6EXT_ROUTING: {
                const IPv6RoutingHeader *hdr = check_and_cast<const IPv6RoutingHeader *>(extHdr);
                b.writeByte(hdr->getRoutingType());
                b.writeByte(hdr->getSegmentsLeft());
                for (unsigned int j = 0; j < hdr->getAddressArraySize(); j++) {
                    b.writeIPv6Address(hdr->getAddress(j));
                }
                b.fillNBytes(4, '\0');
                break;
            }
            case IP_PROT_IPv6EXT_FRAGMENT: {
                const IPv6FragmentHeader *hdr = check_and_cast<const IPv6FragmentHeader *>(extHdr);
                ASSERT((hdr->getFragmentOffset() & 7) == 0);
                b.writeUint16(hdr->getFragmentOffset() | (hdr->getMoreFragments() ? 1 : 0));
                b.writeUint32(hdr->getIdentification());
                break;
            }
            case IP_PROT_IPv6EXT_AUTH: {
                const IPv6AuthenticationHeader *hdr = check_and_cast<const IPv6AuthenticationHeader *>(extHdr);
                b.fillNBytes(hdr->getByteLength() - 2, '\0');    //TODO
                break;
            }
            case IP_PROT_IPv6EXT_ESP: {
                const IPv6EncapsulatingSecurityPayloadHeader *hdr = check_and_cast<const IPv6EncapsulatingSecurityPayloadHeader *>(extHdr);
                b.fillNBytes(hdr->getByteLength() - 2, '\0');    //TODO
                break;
            }
            default: {
                throw cRuntimeError("Unknown IPv6 extension header %d (%s)%s", extHdr->getExtensionType(), extHdr->getClassName(), extHdr->getFullName());
                break;
            }
        }
        ASSERT(nextHdrCodePos + extHdr->getByteLength() == b.getPos());
    }

    const cPacket *encapPacket = dgram->getEncapsulatedPacket();
    unsigned int encapStart = b.getPos();
    SerializerBase::lookupAndSerialize(encapPacket, b, c, IP_PROT, dgram->getTransportProtocol());
    unsigned int encapEnd = b.getPos();

    ip6h->ip6_plen = htons(encapEnd - encapStart);
}

---

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

• IPv6Serializer.h
• IPv6Serializer.cc