inet::serializer::EthernetSerializer Class Reference

Converts between EtherFrame and binary (network byte order) Ethernet header. More...

#include <EthernetSerializer.h>

Inheritance diagram for inet::serializer::EthernetSerializer:

Public Member Functions
	EthernetSerializer (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 an EtherFrame 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 EtherFrame and binary (network byte order) Ethernet header.

Constructor & Destructor Documentation

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

inline

: SerializerBase(name) {}

Member Function Documentation

cPacket * inet::serializer::EthernetSerializer::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);
    EtherFrame *etherPacket = nullptr;
    ProtocolGroup protocolGroup = UNKNOWN;
    int protocolType = -1;

    int frameLength = b.getRemainingSize();
    unsigned int payloadLength = 0;
    MACAddress destAddr = b.readMACAddress();
    MACAddress srcAddr = b.readMACAddress();
    uint16_t typeOrLength = b.readUint16();

    // detect and create the real packet type.
    if (typeOrLength >= 0x0600 || typeOrLength == 0) {
        EthernetIIFrame *ethernetIIPacket = new EthernetIIFrame();
        ethernetIIPacket->setEtherType(typeOrLength);
        protocolGroup = ETHERTYPE;
        protocolType = typeOrLength;
        etherPacket = ethernetIIPacket;
        payloadLength = b.getRemainingSize(4);
    }
    else {
        payloadLength = typeOrLength;
        EtherFrameWithLLC *ethLLC = nullptr;
        uint8_t ssap = b.readByte();
        uint8_t dsap = b.readByte();
        uint8_t ctrl = b.readByte();
        if (dsap == 0xAA && ssap == 0xAA) { // snap frame
            EtherFrameWithSNAP *ethSnap = new EtherFrameWithSNAP();
            ethSnap->setOrgCode(((uint32_t)b.readByte() << 16) + b.readUint16());
            protocolGroup = ETHERTYPE;
            protocolType = b.readUint16();
            ethSnap->setLocalcode(protocolType);
            ethLLC = ethSnap;
        }
        else
            ethLLC = new EtherFrameWithLLC();
        ethLLC->setDsap(dsap);
        ethLLC->setSsap(ssap);
        ethLLC->setControl(ctrl);
        etherPacket = ethLLC;
    }

    etherPacket->setDest(destAddr);
    etherPacket->setSrc(srcAddr);
    etherPacket->setByteLength(b.getPos() + 4); // +4 for trailing crc

    cPacket *encapPacket = SerializerBase::lookupAndDeserialize(b, c, protocolGroup, protocolType, payloadLength);
    ASSERT(encapPacket);
    etherPacket->encapsulate(encapPacket);
    etherPacket->setName(encapPacket->getName());
    if (b.getRemainingSize() > 4) { // padding
        etherPacket->addByteLength(b.getRemainingSize() - 4);
        b.accessNBytes(b.getRemainingSize() - 4);
    }
    uint32_t calculatedFcs = ethernetCRC(b._getBuf(), b.getPos());
    uint32_t receivedFcs = b.readUint32();
    EV_DEBUG << "Calculated FCS: " << calculatedFcs << ", received FCS: " << receivedFcs << endl;
    if (receivedFcs != calculatedFcs)
        etherPacket->setBitError(true);
    if (etherPacket->getByteLength() != frameLength)
        etherPacket->setBitError(true);
    return etherPacket;
}

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

overrideprotectedvirtual

Serializes an EtherFrame for transmission on the wire.

Implements inet::serializer::SerializerBase.

{
    ASSERT(b.getPos() == 0);
    const EtherFrame *ethPkt = check_and_cast<const EtherFrame *>(pkt);
    b.writeMACAddress(ethPkt->getDest());
    b.writeMACAddress(ethPkt->getSrc());
    if (dynamic_cast<const EthernetIIFrame *>(pkt)) {
        const EthernetIIFrame *frame = static_cast<const EthernetIIFrame *>(pkt);
        uint16_t ethType = frame->getEtherType();
        b.writeUint16(ethType);
        cPacket *encapPkt = frame->getEncapsulatedPacket();
        SerializerBase::lookupAndSerialize(encapPkt, b, c, ETHERTYPE, ethType, b.getRemainingSize(4));
    }
    else if (dynamic_cast<const EtherFrameWithLLC *>(pkt)) {
        const EtherFrameWithLLC *frame = static_cast<const EtherFrameWithLLC *>(pkt);
        cPacket *encapPkt = frame->getEncapsulatedPacket();
        unsigned int payloadLengthPos = b.getPos();
        b.writeUint16(0xFFFF);
        b.writeByte(frame->getSsap());
        b.writeByte(frame->getDsap());
        b.writeByte(frame->getControl());
        if (dynamic_cast<const EtherFrameWithSNAP *>(pkt)) {
            const EtherFrameWithSNAP *frame = static_cast<const EtherFrameWithSNAP *>(pkt);
            b.writeByte(frame->getOrgCode() >> 16);
            b.writeByte(frame->getOrgCode() >> 8);
            b.writeByte(frame->getOrgCode());
            b.writeUint16(frame->getLocalcode());
            unsigned int payloadLength = b.getRemainingSize(4);
            if (frame->getOrgCode() == 0) {
                b.writeUint16To(payloadLengthPos, payloadLength);
                SerializerBase::lookupAndSerialize(encapPkt, b, c, ETHERTYPE, frame->getLocalcode(), payloadLength);
            }
            else {
                //TODO
                b.writeUint16To(payloadLengthPos, payloadLength);
                SerializerBase::lookupAndSerialize(encapPkt, b, c, UNKNOWN, frame->getLocalcode(), payloadLength);
            }
        }
        else if (typeid(*frame) == typeid(EtherFrameWithLLC)) {
            unsigned int payloadLength = b.getRemainingSize(4);
            b.writeUint16To(payloadLengthPos, payloadLength);
            SerializerBase::lookupAndSerialize(encapPkt, b, c, UNKNOWN, 0, payloadLength);
        }
        else {
            throw cRuntimeError("Serializer not found for '%s'", pkt->getClassName());
        }
    }
    else if (dynamic_cast<const EtherPauseFrame *>(pkt)) {
        const EtherPauseFrame *frame = static_cast<const EtherPauseFrame *>(pkt);
        b.writeUint16(0x8808);
        b.writeUint16(0x0001);
        b.writeUint16(frame->getPauseTime());
    }
    else {
        throw cRuntimeError("Serializer not found for '%s'", pkt->getClassName());
    }
    if (b.getPos() + 4 < pkt->getByteLength())
        b.fillNBytes((pkt->getByteLength() - 4) - b.getPos(), 0);
    uint32_t fcs = ethernetCRC(b._getBuf(), b.getPos());
    b.writeUint32(fcs);
}

---

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

• EthernetSerializer.h
• EthernetSerializer.cc