inet::GptpPacketSerializer Class Reference

Converts between GptpPacket and binary (network byte order) Gptp packet. More...

#include <GptpPacketSerializer.h>

Inheritance diagram for inet::GptpPacketSerializer:

Public Member Functions
	GptpPacketSerializer ()
Public Member Functions inherited from inet::FieldsChunkSerializer
virtual void	serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk, b offset, b length) const override
	Serializes a chunk into a stream by writing the bytes representing the chunk at the end of the stream. More...
virtual const Ptr< Chunk >	deserialize (MemoryInputStream &stream, const std::type_info &typeInfo) const override
	Deserializes a chunk from a stream by reading the bytes at the current position of the stream. More...

Protected Member Functions
virtual void	serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk) const override
	Serializes a chunk into a stream by writing all bytes representing the chunk at the end of the stream. More...
virtual const Ptr< Chunk >	deserialize (MemoryInputStream &stream) const override
	Deserializes a chunk from a stream by reading the bytes at the current position of the stream. More...
void	readGptpBase (MemoryInputStream &stream, GptpBase &gptpPacket) const
void	writeGptpBase (MemoryOutputStream &stream, const GptpBase &gptpPacket) const
void	readGptpFollowUpPart (MemoryInputStream &stream, GptpFollowUp &gptpPacket) const
void	writeGptpFollowUpPart (MemoryOutputStream &stream, const GptpFollowUp &gptpPacket) const
void	readGptpPdelayReqPart (MemoryInputStream &stream, GptpPdelayReq &gptpPacket) const
void	writeGptpPdelayReqPart (MemoryOutputStream &stream, const GptpPdelayReq &gptpPacket) const
void	readGptpPdelayRespPart (MemoryInputStream &stream, GptpPdelayResp &gptpPacket) const
void	writeGptpPdelayRespPart (MemoryOutputStream &stream, const GptpPdelayResp &gptpPacket) const
void	readGptpPdelayRespFollowUpPart (MemoryInputStream &stream, GptpPdelayRespFollowUp &gptpPacket) const
void	writeGptpPdelayRespFollowUpPart (MemoryOutputStream &stream, const GptpPdelayRespFollowUp &gptpPacket) const
void	readGptpSyncPart (MemoryInputStream &stream, GptpSync &gptpPacket) const
void	writeGptpSyncPart (MemoryOutputStream &stream, const GptpSync &gptpPacket) const
void	readGptpFollowUpInformationTlv (MemoryInputStream &stream, GptpFollowUpInformationTlv &gptpPacket) const
void	writeGptpFollowUpInformationTlv (MemoryOutputStream &stream, const GptpFollowUpInformationTlv &gptpPacket) const
clocktime_t	readClock8 (MemoryInputStream &stream) const
void	writeClock8 (MemoryOutputStream &stream, const clocktime_t &clock) const
clocktime_t	readTimestamp (MemoryInputStream &stream) const
void	writeTimestamp (MemoryOutputStream &stream, const clocktime_t &clock) const
clocktime_t	readScaledNS (MemoryInputStream &stream) const
void	writeScaledNS (MemoryOutputStream &stream, const clocktime_t &clock) const
PortIdentity	readPortIdentity (MemoryInputStream &stream) const
void	writePortIdentity (MemoryOutputStream &stream, const PortIdentity &portIdentity) const

Additional Inherited Members
Static Public Attributes inherited from inet::ChunkSerializer
static b	totalSerializedLength = b(0)
static b	totalDeserializedLength = b(0)

Detailed Description

Converts between GptpPacket and binary (network byte order) Gptp packet.

Constructor & Destructor Documentation

GptpPacketSerializer()

inet::GptpPacketSerializer::GptpPacketSerializer ( )

inline

: FieldsChunkSerializer() {}

Member Function Documentation

deserialize()

const Ptr< Chunk > inet::GptpPacketSerializer::deserialize ( MemoryInputStream &  stream ) const

overrideprotectedvirtual

Deserializes a chunk from a stream by reading the bytes at the current position of the stream.

The current stream position is updated according to the length of the returned chunk.

Implements inet::FieldsChunkSerializer.

{
    auto startPos = stream.getPosition();
    stream.readUint4();
    GptpMessageType type = static_cast<GptpMessageType>(stream.readUint4());
    stream.seek(startPos);
 
    switch(type) {
        case GPTPTYPE_FOLLOW_UP: {
            auto gptpPacket = makeShared<GptpFollowUp>();
            readGptpBase(stream, *gptpPacket.get());
            readGptpFollowUpPart(stream, *gptpPacket.get());
            return gptpPacket;
        }
        case GPTPTYPE_PDELAY_REQ: {
            auto gptpPacket = makeShared<GptpPdelayReq>();
            readGptpBase(stream, *gptpPacket.get());
            readGptpPdelayReqPart(stream, *gptpPacket.get());
            return gptpPacket;
        }
        case GPTPTYPE_PDELAY_RESP: {
            auto gptpPacket = makeShared<GptpPdelayResp>();
            readGptpBase(stream, *gptpPacket.get());
            readGptpPdelayRespPart(stream, *gptpPacket.get());
            return gptpPacket;
        }
        case GPTPTYPE_PDELAY_RESP_FOLLOW_UP: {
            auto gptpPacket = makeShared<GptpPdelayRespFollowUp>();
            readGptpBase(stream, *gptpPacket.get());
            readGptpPdelayRespFollowUpPart(stream, *gptpPacket.get());
            return gptpPacket;
        }
        case GPTPTYPE_SYNC: {
            auto gptpPacket = makeShared<GptpSync>();
            readGptpBase(stream, *gptpPacket.get());
            readGptpSyncPart(stream, *gptpPacket.get());
            return gptpPacket;
        }
        default:
            throw cRuntimeError("unknown GptpMessageType");
    }
}

readClock8()

clocktime_t inet::GptpPacketSerializer::readClock8 ( MemoryInputStream &  stream ) const

protected

{
    int64_t ns16 = stream.readUint64Be();
    simtime_t t1(ns16>>16, SIMTIME_NS);
    ns16 = (ns16 & 0xFFFF) * SimTime::getScale() / 1000000000LL;
    return SIMTIME_AS_CLOCKTIME(t1 + SimTime::fromRaw(ns16>>16));
}

Referenced by readGptpBase().

readGptpBase()

void inet::GptpPacketSerializer::readGptpBase ( MemoryInputStream &  stream, GptpBase &  gptpPacket  ) const

protected

{
    gptpPacket.setMajorSdoId(stream.readUint4());
    gptpPacket.setMessageType(static_cast<GptpMessageType>(stream.readUint4()));
    gptpPacket.setMinorVersionPTP(stream.readUint4());
    gptpPacket.setVersionPTP(stream.readUint4());
    gptpPacket.setMessageLengthField(stream.readUint16Be());
    gptpPacket.setDomainNumber(stream.readUint8());
    gptpPacket.setMinorSdoId(stream.readUint8());
    gptpPacket.setFlags(stream.readUint16Be());
    gptpPacket.setCorrectionField(readClock8(stream));
    gptpPacket.setMessageTypeSpecific(stream.readUint32Be());
    gptpPacket.setSourcePortIdentity(readPortIdentity(stream));
    gptpPacket.setSequenceId(stream.readUint16Be());
    gptpPacket.setControlField(stream.readUint8());
    gptpPacket.setLogMessageInterval(stream.readUint8());
}

Referenced by deserialize().

readGptpFollowUpInformationTlv()

void inet::GptpPacketSerializer::readGptpFollowUpInformationTlv ( MemoryInputStream &  stream, GptpFollowUpInformationTlv &  gptpPacket  ) const

protected

{
    tlv.setTlvType((GptpTlvType)stream.readUint16Be());
    tlv.setLengthField(stream.readUint16Be());
    tlv.setOrganizationId(stream.readUint24Be());
    tlv.setOrganizationSubType(stream.readUint24Be());
    tlv.setCumulativeScaledRateOffset(stream.readUint32Be());
    tlv.setGmTimeBaseIndicator(stream.readUint16Be());
    tlv.setLastGmPhaseChange(readScaledNS(stream));
    tlv.setScaledLastGmFreqChange(stream.readUint32Be());
}

Referenced by readGptpFollowUpPart().

readGptpFollowUpPart()

void inet::GptpPacketSerializer::readGptpFollowUpPart ( MemoryInputStream &  stream, GptpFollowUp &  gptpPacket  ) const

protected

{
    gptpPacket.setPreciseOriginTimestamp(readTimestamp(stream));
    readGptpFollowUpInformationTlv(stream, gptpPacket.getFollowUpInformationTLVForUpdate());
}

Referenced by deserialize().

readGptpPdelayReqPart()

void inet::GptpPacketSerializer::readGptpPdelayReqPart ( MemoryInputStream &  stream, GptpPdelayReq &  gptpPacket  ) const

protected

{
    stream.readByteRepeatedly(0, 10);
    stream.readByteRepeatedly(0, 10);
}

Referenced by deserialize().

readGptpPdelayRespFollowUpPart()

void inet::GptpPacketSerializer::readGptpPdelayRespFollowUpPart ( MemoryInputStream &  stream, GptpPdelayRespFollowUp &  gptpPacket  ) const

protected

{
    gptpPacket.setResponseOriginTimestamp(readTimestamp(stream));
    gptpPacket.setRequestingPortIdentity(readPortIdentity(stream));
}

Referenced by deserialize().

readGptpPdelayRespPart()

void inet::GptpPacketSerializer::readGptpPdelayRespPart ( MemoryInputStream &  stream, GptpPdelayResp &  gptpPacket  ) const

protected

{
    gptpPacket.setRequestReceiptTimestamp(readTimestamp(stream));
    gptpPacket.setRequestingPortIdentity(readPortIdentity(stream));
}

Referenced by deserialize().

readGptpSyncPart()

void inet::GptpPacketSerializer::readGptpSyncPart ( MemoryInputStream &  stream, GptpSync &  gptpPacket  ) const

protected

{
    if (gptpPacket.getFlags() & twoStepFlag)
        stream.readByteRepeatedly(0, 10); // read "reserved"
    else
        throw cRuntimeError("The GptpSync without twoStepFlag is unimplemented yet");
}

Referenced by deserialize().

readPortIdentity()

PortIdentity inet::GptpPacketSerializer::readPortIdentity ( MemoryInputStream &  stream ) const

protected

{
    PortIdentity portIdentity;
    portIdentity.clockIdentity = stream.readUint64Be();
    portIdentity.portNumber = stream.readUint16Be();
    return portIdentity;
}

Referenced by readGptpBase(), readGptpPdelayRespFollowUpPart(), and readGptpPdelayRespPart().

readScaledNS()

clocktime_t inet::GptpPacketSerializer::readScaledNS ( MemoryInputStream &  stream ) const

protected

{
    // The ScaledNs type represents signed values of time and time interval in units of 2^–16 ns.
    // 12 bytes
    int32_t x = stream.readUint32Be();
    int64_t ns16 = stream.readUint64Be();
    if ((ns16 < 0 && x != -1) || (ns16 >= 0 && x != 0))
        throw cRuntimeError("too big number");
    simtime_t t1(ns16>>16, SIMTIME_NS);
    ns16 = (ns16 & 0xFFFF) * SimTime::getScale() / 1000000000LL;
    return SIMTIME_AS_CLOCKTIME(t1 + SimTime::fromRaw(ns16>>16));
}

Referenced by readGptpFollowUpInformationTlv().

readTimestamp()

clocktime_t inet::GptpPacketSerializer::readTimestamp ( MemoryInputStream &  stream ) const

protected

{
    // 10 bytes
    int64_t s = stream.readUint48Be();
    int64_t ns = stream.readUint32Be();
    simtime_t t1(s, SIMTIME_S);
    simtime_t t2(ns, SIMTIME_NS);
    return SIMTIME_AS_CLOCKTIME(t1 + t2);
}

Referenced by readGptpFollowUpPart(), readGptpPdelayRespFollowUpPart(), and readGptpPdelayRespPart().

serialize()

void inet::GptpPacketSerializer::serialize ( MemoryOutputStream &  stream, const Ptr< const Chunk > &  chunk  ) const

overrideprotectedvirtual

Serializes a chunk into a stream by writing all bytes representing the chunk at the end of the stream.

Implements inet::FieldsChunkSerializer.

{
    const auto& gptpPacket = staticPtrCast<const GptpBase>(chunk);
    writeGptpBase(stream, *gptpPacket.get());
 
    // TODO Type-specific code:
    switch(gptpPacket->getMessageType()) {
        case GPTPTYPE_FOLLOW_UP: {
            const auto& gptp = CHK(dynamicPtrCast<const GptpFollowUp>(gptpPacket));
            writeGptpFollowUpPart(stream, *gptp.get());
            break;
        }
        case GPTPTYPE_PDELAY_REQ: {
            const auto& gptp = CHK(dynamicPtrCast<const GptpPdelayReq>(gptpPacket));
            writeGptpPdelayReqPart(stream, *gptp.get());
            break;
        }
        case GPTPTYPE_PDELAY_RESP: {
            const auto& gptp = CHK(dynamicPtrCast<const GptpPdelayResp>(gptpPacket));
            writeGptpPdelayRespPart(stream, *gptp.get());
            break;
        }
        case GPTPTYPE_PDELAY_RESP_FOLLOW_UP: {
            const auto& gptp = CHK(dynamicPtrCast<const GptpPdelayRespFollowUp>(gptpPacket));
            writeGptpPdelayRespFollowUpPart(stream, *gptp.get());
            break;
        }
        case GPTPTYPE_SYNC: {
            const auto& gptp = CHK(dynamicPtrCast<const GptpSync>(gptpPacket));
            writeGptpSyncPart(stream, *gptp.get());
            break;
        }
        default:
            throw cRuntimeError("unknown GptpMessageType");
    }
}

writeClock8()

void inet::GptpPacketSerializer::writeClock8 ( MemoryOutputStream &  stream, const clocktime_t &  clock  ) const

protected

{
    int64_t outValue;
    simtime_t outRemainder;
    simtime_t t = CLOCKTIME_AS_SIMTIME(clock);
    t.split(SIMTIME_NS, outValue, outRemainder);
    outValue <<= 16;
    int64_t ns16 = outRemainder.raw() * 1000000000LL / SimTime::getScale();
    stream.writeUint64Be(outValue + ns16);
}

Referenced by writeGptpBase().

writeGptpBase()

void inet::GptpPacketSerializer::writeGptpBase ( MemoryOutputStream &  stream, const GptpBase &  gptpPacket  ) const

protected

{
    stream.writeUint4(gptpPacket.getMajorSdoId());
    stream.writeUint4((int8_t)(gptpPacket.getMessageType()));
    stream.writeUint4(gptpPacket.getMinorVersionPTP());
    stream.writeUint4(gptpPacket.getVersionPTP());
    stream.writeUint16Be(gptpPacket.getMessageLengthField());
    stream.writeUint8(gptpPacket.getDomainNumber());
    stream.writeUint8(gptpPacket.getMinorSdoId());
    stream.writeUint16Be(gptpPacket.getFlags());
    writeClock8(stream, gptpPacket.getCorrectionField());
    stream.writeUint32Be(gptpPacket.getMessageTypeSpecific());
    writePortIdentity(stream, gptpPacket.getSourcePortIdentity());
    stream.writeUint16Be(gptpPacket.getSequenceId());
    stream.writeUint8(gptpPacket.getControlField());
    stream.writeUint8(gptpPacket.getLogMessageInterval());
}

Referenced by serialize().

writeGptpFollowUpInformationTlv()

void inet::GptpPacketSerializer::writeGptpFollowUpInformationTlv ( MemoryOutputStream &  stream, const GptpFollowUpInformationTlv &  gptpPacket  ) const

protected

{
    stream.writeUint16Be(tlv.getTlvType());
    stream.writeUint16Be(tlv.getLengthField());
    stream.writeUint24Be(tlv.getOrganizationId());
    stream.writeUint24Be(tlv.getOrganizationSubType());
    stream.writeUint32Be(tlv.getCumulativeScaledRateOffset());
    stream.writeUint16Be(tlv.getGmTimeBaseIndicator());
    writeScaledNS(stream, tlv.getLastGmPhaseChange());
    stream.writeUint32Be(tlv.getScaledLastGmFreqChange());
}

Referenced by writeGptpFollowUpPart().

writeGptpFollowUpPart()

void inet::GptpPacketSerializer::writeGptpFollowUpPart ( MemoryOutputStream &  stream, const GptpFollowUp &  gptpPacket  ) const

protected

{
    writeTimestamp(stream, gptpPacket.getPreciseOriginTimestamp());
    writeGptpFollowUpInformationTlv(stream, gptpPacket.getFollowUpInformationTLV());
}

Referenced by serialize().

writeGptpPdelayReqPart()

void inet::GptpPacketSerializer::writeGptpPdelayReqPart ( MemoryOutputStream &  stream, const GptpPdelayReq &  gptpPacket  ) const

protected

{
    stream.writeByteRepeatedly(0, 10);
    stream.writeByteRepeatedly(0, 10);
}

Referenced by serialize().

writeGptpPdelayRespFollowUpPart()

void inet::GptpPacketSerializer::writeGptpPdelayRespFollowUpPart ( MemoryOutputStream &  stream, const GptpPdelayRespFollowUp &  gptpPacket  ) const

protected

{
    writeTimestamp(stream, gptpPacket.getResponseOriginTimestamp());
    writePortIdentity(stream, gptpPacket.getRequestingPortIdentity());
}

Referenced by serialize().

writeGptpPdelayRespPart()

void inet::GptpPacketSerializer::writeGptpPdelayRespPart ( MemoryOutputStream &  stream, const GptpPdelayResp &  gptpPacket  ) const

protected

{
    writeTimestamp(stream, gptpPacket.getRequestReceiptTimestamp());
    writePortIdentity(stream, gptpPacket.getRequestingPortIdentity());
}

Referenced by serialize().

writeGptpSyncPart()

void inet::GptpPacketSerializer::writeGptpSyncPart ( MemoryOutputStream &  stream, const GptpSync &  gptpPacket  ) const

protected

{
    if (gptpPacket.getFlags() & twoStepFlag)
        stream.writeByteRepeatedly(0, 10); // write "reserved"
    else
        throw cRuntimeError("The GptpSync without twoStepFlag is unimplemented yet");
}

Referenced by serialize().

writePortIdentity()

void inet::GptpPacketSerializer::writePortIdentity ( MemoryOutputStream &  stream, const PortIdentity &  portIdentity  ) const

protected

{
    stream.writeUint64Be(portIdentity.clockIdentity);
    stream.writeUint16Be(portIdentity.portNumber);
}

Referenced by writeGptpBase(), writeGptpPdelayRespFollowUpPart(), and writeGptpPdelayRespPart().

writeScaledNS()

void inet::GptpPacketSerializer::writeScaledNS ( MemoryOutputStream &  stream, const clocktime_t &  clock  ) const

protected

{
    // The ScaledNs type represents signed values of time and time interval in units of 2^–16 ns.
    // 12 bytes
    simtime_t t = CLOCKTIME_AS_SIMTIME(clock);
    int64_t outValue;
    simtime_t outRemainder;
    t.split(SIMTIME_NS, outValue, outRemainder);
    outValue <<= 16;
    int64_t ns16 = outRemainder.raw() * 1000000000LL / SimTime::getScale();
    stream.writeUint32Be(clock >= CLOCKTIME_ZERO ? 0 : 0xFFFFFFFF);
    stream.writeUint64Be(outValue + ns16);
}

Referenced by writeGptpFollowUpInformationTlv().

writeTimestamp()

void inet::GptpPacketSerializer::writeTimestamp ( MemoryOutputStream &  stream, const clocktime_t &  clock  ) const

protected

{
    // 10 bytes
    simtime_t t = CLOCKTIME_AS_SIMTIME(clock);
    int64_t outValue;
    t.split(SIMTIME_S, outValue, t);
    stream.writeUint48Be(outValue);
    t.split(SIMTIME_NS, outValue, t);
    stream.writeUint32Be(outValue);
}

Referenced by writeGptpFollowUpPart(), writeGptpPdelayRespFollowUpPart(), and writeGptpPdelayRespPart().

---

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

• GptpPacketSerializer.h
• GptpPacketSerializer.cc