inet::serializer::TCPSerializer Class Reference

Converts between TCPSegment and binary (network byte order) TCP header. More...

#include <TCPSerializer.h>

Inheritance diagram for inet::serializer::TCPSerializer:

Public Member Functions
	TCPSerializer (const char *name=nullptr)
tcp::TCPSegment *	deserialize (const unsigned char *srcbuf, unsigned int bufsize, bool withBytes)
	Puts a packet sniffed from the wire into a TCPSegment. More...
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	serializeOption (const tcp::TCPOption *option, Buffer &b, Context &c)
tcp::TCPOption *	deserializeOption (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 TCPSegment and binary (network byte order) TCP header.

Constructor & Destructor Documentation

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

inline

: SerializerBase(name) {}

Member Function Documentation

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

overrideprotectedvirtual

Puts a packet sniffed from the wire into an EtherFrame.

Implements inet::serializer::SerializerBase.

Referenced by inet::tcp::TCP_NSC_VirtualDataSendQueue::createSegmentWithBytes(), inet::tcp::TcpLwipVirtualDataSendQueue::createSegmentWithBytes(), inet::tcp::TCP_NSC_ByteStreamSendQueue::createSegmentWithBytes(), inet::tcp::TcpLwipByteStreamSendQueue::createSegmentWithBytes(), inet::tcp::TcpLwipMsgBasedSendQueue::createSegmentWithBytes(), inet::tcp::TCP_lwIP::ip_output(), and inet::tcp::TCP_NSC::sendToIP().

{
    struct tcphdr tcp;
    memset(&tcp, 0, sizeof(tcp));
    ASSERT(sizeof(tcp) == TCP_HEADER_OCTETS);
    b.readNBytes(TCP_HEADER_OCTETS, &tcp);

    TCPSegment *tcpseg = new TCPSegment("parsed-tcp");

    // fill TCP header structure
    tcpseg->setSrcPort(ntohs(tcp.th_sport));
    tcpseg->setDestPort(ntohs(tcp.th_dport));
    tcpseg->setSequenceNo(ntohl(tcp.th_seq));
    tcpseg->setAckNo(ntohl(tcp.th_ack));
    unsigned short hdrLength = tcp.th_offs * 4;
    tcpseg->setHeaderLength(hdrLength);

    // set flags
    unsigned char flags = tcp.th_flags;
    tcpseg->setFinBit((flags & TH_FIN) == TH_FIN);
    tcpseg->setSynBit((flags & TH_SYN) == TH_SYN);
    tcpseg->setRstBit((flags & TH_RST) == TH_RST);
    tcpseg->setPshBit((flags & TH_PUSH) == TH_PUSH);
    tcpseg->setAckBit((flags & TH_ACK) == TH_ACK);
    tcpseg->setUrgBit((flags & TH_URG) == TH_URG);

    tcpseg->setWindow(ntohs(tcp.th_win));

    tcpseg->setUrgentPointer(ntohs(tcp.th_urp));

    if (hdrLength > TCP_HEADER_OCTETS) {    // options present?
        unsigned short optionBytes = hdrLength - TCP_HEADER_OCTETS;    // TCP_HEADER_OCTETS = 20
        Buffer sb(b, optionBytes);

        while (sb.getRemainingSize()) {
            TCPOption *option = deserializeOption(sb, c);
            tcpseg->addHeaderOption(option);
        }
        if (sb.hasError())
            b.setError();
    }    // if options present
    b.seek(hdrLength);
    tcpseg->setByteLength(b._getBufSize());
    unsigned int payloadLength = b.getRemainingSize();
    tcpseg->setPayloadLength(payloadLength);
    tcpseg->getByteArray().setDataFromBuffer(b.accessNBytes(payloadLength), payloadLength);

    if (b.hasError())
        tcpseg->setBitError(true);
    // Checksum: modeled by cPacket::hasBitError()
    if (tcp.th_sum != 0 && c.l3AddressesPtr && c.l3AddressesLength && TCPIPchecksum::checksum(IP_PROT_TCP, b._getBuf(), b._getBufSize(), c.l3AddressesPtr, c.l3AddressesLength))
        tcpseg->setBitError(true);
    return tcpseg;
}

TCPSegment * inet::TCPSerializer::deserialize	(	const unsigned char *	srcbuf,
		unsigned int	bufsize,
		bool	withBytes
	)

Puts a packet sniffed from the wire into a TCPSegment.

{
    Buffer b(const_cast<unsigned char *>(buf), bufsize);
    Context c;
    return check_and_cast_nullable<TCPSegment *>(deserialize(b, c));
}

TCPOption * inet::TCPSerializer::deserializeOption ( Buffer &  b, Context &  c  )

protected

{
    unsigned char kind = b.readByte();
    unsigned char length = 0;

    switch (kind) {
        case TCPOPTION_END_OF_OPTION_LIST:    // EOL
            return new TCPOptionEnd();

        case TCPOPTION_NO_OPERATION:    // NOP
            return new TCPOptionNop();

        case TCPOPTION_MAXIMUM_SEGMENT_SIZE:
            length = b.readByte();
            if (length == 4) {
                auto *option = new TCPOptionMaxSegmentSize();
                option->setLength(length);
                option->setMaxSegmentSize(b.readUint16());
                return option;
            }
            break;

        case TCPOPTION_WINDOW_SCALE:
            length = b.readByte();
            if (length == 3) {
                auto *option = new TCPOptionWindowScale();
                option->setLength(length);
                option->setWindowScale(b.readByte());
                return option;
            }
            break;

        case TCPOPTION_SACK_PERMITTED:
            length = b.readByte();
            if (length == 2) {
                auto *option = new TCPOptionSackPermitted();
                option->setLength(length);
                return option;
            }
            break;

        case TCPOPTION_SACK:
            length = b.readByte();
            if (length > 2 && (length % 8) == 2) {
                auto *option = new TCPOptionSack();
                option->setLength(length);
                option->setSackItemArraySize(length / 8);
                unsigned int count = 0;
                for (unsigned int i = 2; i < length; i += 8) {
                    SackItem si;
                    si.setStart(b.readUint32());
                    si.setEnd(b.readUint32());
                    option->setSackItem(count++, si);
                }
                return option;
            }
            break;

        case TCPOPTION_TIMESTAMP:
            length = b.readByte();
            if (length == 10) {
                auto *option = new TCPOptionTimestamp();
                option->setLength(length);
                option->setSenderTimestamp(b.readUint32());
                option->setEchoedTimestamp(b.readUint32());
                return option;
            }
            break;

        default:
            length = b.readByte();
            break;
    }    // switch

    auto *option = new TCPOptionUnknown();
    option->setKind(kind);
    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::TCPSerializer::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);
    const TCPSegment *tcpseg = check_and_cast<const TCPSegment *>(pkt);
    struct tcphdr tcp;  // = (struct tcphdr *)(b.accessNBytes(sizeof(struct tcphdr)))

    int writtenbytes = tcpseg->getByteLength();

    // fill TCP header structure
    tcp.th_sum = 0;
    tcp.th_sport = htons(tcpseg->getSrcPort());
    tcp.th_dport = htons(tcpseg->getDestPort());
    tcp.th_seq = htonl(tcpseg->getSequenceNo());
    tcp.th_ack = htonl(tcpseg->getAckNo());
    tcp.th_offs = TCP_HEADER_OCTETS / 4;
    tcp.th_x2 = 0;     // unused

    // set flags
    unsigned char flags = 0;
    if (tcpseg->getFinBit())
        flags |= TH_FIN;
    if (tcpseg->getSynBit())
        flags |= TH_SYN;
    if (tcpseg->getRstBit())
        flags |= TH_RST;
    if (tcpseg->getPshBit())
        flags |= TH_PUSH;
    if (tcpseg->getAckBit())
        flags |= TH_ACK;
    if (tcpseg->getUrgBit())
        flags |= TH_URG;
    tcp.th_flags = (TH_FLAGS & flags);
    tcp.th_win = htons(tcpseg->getWindow());
    tcp.th_urp = htons(tcpseg->getUrgentPointer());
    if (tcpseg->getHeaderLength() % 4 != 0)
        throw cRuntimeError("invalid TCP header length=%u: must be dividable by 4", tcpseg->getHeaderLength());
    tcp.th_offs = tcpseg->getHeaderLength() / 4;
    b.writeNBytes(TCP_HEADER_OCTETS, &tcp);
    unsigned short numOptions = tcpseg->getHeaderOptionArraySize();
    unsigned int optionsLength = 0;
    if (numOptions > 0) {    // options present?
        for (unsigned short i = 0; i < numOptions; i++) {
            const TCPOption *option = tcpseg->getHeaderOption(i);
            serializeOption(option, b, c);
            optionsLength += option->getLength();
        }    // for
        //padding:
        optionsLength %= 4;
        if (optionsLength)
            b.fillNBytes(4 - optionsLength, 0);
    }    // if options present

    // write data
    if (tcpseg->getByteLength() > tcpseg->getHeaderLength()) {    // data present? FIXME TODO: || tcpseg->getEncapsulatedPacket()!=nullptr
        unsigned int dataLength = tcpseg->getByteLength() - tcpseg->getHeaderLength();

        if (tcpseg->getByteArray().getDataArraySize() > 0) {
            ASSERT(tcpseg->getByteArray().getDataArraySize() == dataLength);
            tcpseg->getByteArray().copyDataToBuffer(b.accessNBytes(0), b.getRemainingSize());
            b.accessNBytes(dataLength);
        }
        else
            b.fillNBytes(dataLength, 't'); // fill data part with 't'
    }
    writtenbytes = b.getPos();
    b.writeUint16To(16, TCPIPchecksum::checksum(IP_PROT_TCP, b._getBuf(), writtenbytes, c.l3AddressesPtr, c.l3AddressesLength));
}

void inet::TCPSerializer::serializeOption ( const tcp::TCPOption *  option, Buffer &  b, Context &  c  )

protected

{
    unsigned short kind = option->getKind();
    unsigned short length = option->getLength();    // length >= 1

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

    auto *opt = dynamic_cast<const TCPOptionUnknown *>(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 (kind) {
        case TCPOPTION_END_OF_OPTION_LIST:    // EOL
            check_and_cast<const TCPOptionEnd *>(option);
            ASSERT(length == 1);
            break;

        case TCPOPTION_NO_OPERATION:    // NOP
            check_and_cast<const TCPOptionNop *>(option);
            ASSERT(length == 1);
            break;

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

        case TCPOPTION_WINDOW_SCALE: {
            auto *opt = check_and_cast<const TCPOptionWindowScale *>(option);
            ASSERT(length == 3);
            b.writeByte(opt->getWindowScale());
            break;
        }

        case TCPOPTION_SACK_PERMITTED: {
            auto *opt = check_and_cast<const TCPOptionSackPermitted *>(option); (void)opt; // UNUSED
            ASSERT(length == 2);
            break;
        }

        case TCPOPTION_SACK: {
            auto *opt = check_and_cast<const TCPOptionSack *>(option);
            ASSERT(length == 2 + opt->getSackItemArraySize() * 8);
            for (unsigned int i = 0; i < opt->getSackItemArraySize(); i++) {
                SackItem si = opt->getSackItem(i);
                b.writeUint32(si.getStart());
                b.writeUint32(si.getEnd());
            }
            break;
        }

        case TCPOPTION_TIMESTAMP: {
            auto *opt = check_and_cast<const TCPOptionTimestamp *>(option);
            ASSERT(length == 10);
            b.writeUint32(opt->getSenderTimestamp());
            b.writeUint32(opt->getEchoedTimestamp());
            break;
        }

        default: {
            throw cRuntimeError("Unknown TCPOption kind=%d (not in a TCPOptionUnknown option)", kind);
            break;
        }
    }    // switch
}

---

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

• TCPSerializer.h
• TCPSerializer.cc