inet::serializer::SCTPSerializer Class Reference

Converts between SCTPMessage and binary (network byte order) SCTP header. More...

#include <SCTPSerializer.h>

Inheritance diagram for inet::serializer::SCTPSerializer:

Public Member Functions
	SCTPSerializer (const char *name=nullptr)
int32	serialize (const sctp::SCTPMessage *msg, uint8 *buf, uint32 bufsize)
	Serializes an SCTPMessage for transmission on the wire. More...
void	parse (const uint8 *buf, uint32 bufsize, sctp::SCTPMessage *dest)
	Puts a packet sniffed from the wire into an SCTPMessage. More...
void	calculateSharedKey ()
bool	compareRandom ()
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)

Static Public Member Functions
static uint32	checksum (const uint8 *buf, register uint32 len)
static void	hmacSha1 (const uint8 *buf, uint32 buflen, const uint8 *key, uint32 keylen, uint8 *digest)
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))

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...

Static Private Attributes
static unsigned char	keyVector [512]
static unsigned int	sizeKeyVector = 0
static unsigned char	peerKeyVector [512]
static unsigned int	sizePeerKeyVector = 0
static unsigned char	sharedKey [512]

Detailed Description

Converts between SCTPMessage and binary (network byte order) SCTP header.

Constructor & Destructor Documentation

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

inline

: SerializerBase(name) {}

Member Function Documentation

void inet::serializer::SCTPSerializer::calculateSharedKey

(

)

{
    unsigned int i;
    bool peerFirst = false;

    peerFirst = compareRandom();

    if (peerFirst == false) {
        for (i = 0; i < sizeKeyVector; i++)
            sharedKey[i] = keyVector[i];
        for (i = 0; i < sizePeerKeyVector; i++)
            sharedKey[i + sizeKeyVector] = peerKeyVector[i];
    }
    else {
        for (i = 0; i < sizePeerKeyVector; i++)
            sharedKey[i] = peerKeyVector[i];
        for (i = 0; i < sizeKeyVector; i++)
            sharedKey[i + sizePeerKeyVector] = keyVector[i];
    }
}

uint32 inet::serializer::SCTPSerializer::checksum ( const uint8 *  buf, register uint32  len  )

static

{
    uint32 h;
    unsigned char byte0, byte1, byte2, byte3;
    uint32 crc32c;
    uint32 i;
    uint32 res = (~0L);
    for (i = 0; i < len; i++)
        CRC32C(res, buf[i]);
    h = ~res;
    byte0 = h & 0xff;
    byte1 = (h >> 8) & 0xff;
    byte2 = (h >> 16) & 0xff;
    byte3 = (h >> 24) & 0xff;
    crc32c = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
    return htonl(crc32c);
}

bool inet::serializer::SCTPSerializer::compareRandom

(

)

{
    unsigned int i, size;
    if (sizeKeyVector != sizePeerKeyVector) {
        if (sizePeerKeyVector > sizeKeyVector) {
            return false;
        }
        else {
            return true;
        }
    }
    else
        size = sizeKeyVector;
    for (i = 0; i < size; i++) {
        if (keyVector[i] < peerKeyVector[i])
            return false;
        if (keyVector[i] > peerKeyVector[i])
            return true;
    }
    return true;
}

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

overrideprotectedvirtual

Puts a packet sniffed from the wire into an EtherFrame.

Implements inet::serializer::SerializerBase.

{
    SCTPMessage *dest = new SCTPMessage("parsed-sctp");
    parse(static_cast<const uint8 *>(b.accessNBytes(0)), b.getRemainingSize(), dest);
    b.accessNBytes(b.getRemainingSize());
    return dest;
}

void inet::serializer::SCTPSerializer::hmacSha1 ( const uint8 *  buf, uint32  buflen, const uint8 *  key, uint32  keylen, uint8 *  digest  )

static

{
    /* XXX needs to be implemented */
    for (uint16 i = 0; i < SHA_LENGTH; i++) {
        digest[i] = 0;
    }
}

void inet::serializer::SCTPSerializer::parse	(	const uint8 *	buf,
		uint32	bufsize,
		sctp::SCTPMessage *	dest
	)

Puts a packet sniffed from the wire into an SCTPMessage.

{
    int32 size_common_header = sizeof(struct common_header);
    int32 size_init_chunk = sizeof(struct init_chunk);
    int32 size_init_ack_chunk = sizeof(struct init_ack_chunk);
    int32 size_data_chunk = sizeof(struct data_chunk);
    int32 size_sack_chunk = sizeof(struct sack_chunk);
    int32 size_heartbeat_chunk = sizeof(struct heartbeat_chunk);
    int32 size_heartbeat_ack_chunk = sizeof(struct heartbeat_ack_chunk);
    int32 size_abort_chunk = sizeof(struct abort_chunk);
    int32 size_cookie_echo_chunk = sizeof(struct cookie_echo_chunk);
    int size_error_chunk = sizeof(struct error_chunk);
    int size_forward_tsn_chunk = sizeof(struct forward_tsn_chunk);
    int size_asconf_chunk = sizeof(struct asconf_chunk);
    int size_addip_parameter = sizeof(struct add_ip_parameter);
    int size_asconf_ack_chunk = sizeof(struct asconf_ack_chunk);
    int size_auth_chunk = sizeof(struct auth_chunk);
    int size_stream_reset_chunk = sizeof(struct stream_reset_chunk);
    uint16 paramType;
    int32 parptr, chunklen, cLen, woPadding;
    struct common_header *common_header = (struct common_header *)(buf);
    int32 tempChecksum = common_header->checksum;
    common_header->checksum = 0;
    int32 chksum = checksum((unsigned char *)common_header, bufsize);
    common_header->checksum = tempChecksum;

    const unsigned char *chunks = (unsigned char *)(buf + size_common_header);
    EV_TRACE << "SCTPSerializer::parse SCTPMessage\n";
    if (tempChecksum == chksum)
        dest->setChecksumOk(true);
    else
        dest->setChecksumOk(false);
    EV_DETAIL << "checksumOK=" << dest->getChecksumOk() << "\n";
    dest->setSrcPort(ntohs(common_header->source_port));
    dest->setDestPort(ntohs(common_header->destination_port));
    dest->setTag(ntohl(common_header->verification_tag));
    dest->setBitLength(SCTP_COMMON_HEADER * 8);
    // chunks
    uint32 chunkPtr = 0;

    // catch ALL chunks - when a chunk is taken, the chunkPtr is set to the next chunk
    while (chunkPtr < (bufsize - size_common_header)) {
        const struct chunk *chunk = (struct chunk *)(chunks + chunkPtr);
        int32 chunkType = chunk->type;
        woPadding = ntohs(chunk->length);
        cLen = ADD_PADDING(woPadding);
        switch (chunkType) {
            case DATA: {
                EV_INFO << "Data received\n";
                const struct data_chunk *dc = (struct data_chunk *)(chunks + chunkPtr);
                EV_DETAIL << "cLen=" << cLen << "\n";
                if (cLen == 0)
                    throw new cRuntimeError("Incoming SCTP packet contains data chunk with length==0");
                SCTPDataChunk *chunk = new SCTPDataChunk("DATA");
                chunk->setChunkType(chunkType);
                chunk->setUBit(dc->flags & UNORDERED_BIT);
                chunk->setBBit(dc->flags & BEGIN_BIT);
                chunk->setEBit(dc->flags & END_BIT);
                chunk->setIBit(dc->flags & I_BIT);
                chunk->setTsn(ntohl(dc->tsn));
                chunk->setSid(ntohs(dc->sid));
                chunk->setSsn(ntohs(dc->ssn));
                chunk->setPpid(ntohl(dc->ppi));
                chunk->setByteLength(SCTP_DATA_CHUNK_LENGTH);
                EV_DETAIL << "parse data: woPadding=" << woPadding << " size_data_chunk=" << size_data_chunk << "\n";
                if (woPadding > size_data_chunk) {
                    SCTPSimpleMessage *msg = new SCTPSimpleMessage("data");
                    int32 datalen = (woPadding - size_data_chunk);
                    msg->setBitLength(datalen * 8);
                    msg->setDataLen(datalen);
                    msg->setDataArraySize(datalen);
                    for (int32 i = 0; i < datalen; i++)
                        msg->setData(i, dc->user_data[i]);

                    chunk->encapsulate(msg);
                }
                EV_DETAIL << "datachunkLength=" << chunk->getByteLength() << "\n";
                dest->addChunk(chunk);
                break;
            }

            case INIT: {
                EV << "parse INIT\n";
                const struct init_chunk *init_chunk = (struct init_chunk *)(chunks + chunkPtr);    // (recvBuffer + size_ip + size_common_header);
                struct tlv *cp;
                struct random_parameter *rp;
                struct hmac_algo *hp;
                unsigned int rplen = 0, hplen = 0, cplen = 0;
                chunklen = SCTP_INIT_CHUNK_LENGTH;
                SCTPInitChunk *chunk = new SCTPInitChunk("INIT");
                chunk->setChunkType(chunkType);
                chunk->setName("INIT");
                chunk->setInitTag(ntohl(init_chunk->initiate_tag));
                chunk->setA_rwnd(ntohl(init_chunk->a_rwnd));
                chunk->setNoOutStreams(ntohs(init_chunk->mos));
                chunk->setNoInStreams(ntohs(init_chunk->mis));
                chunk->setInitTSN(ntohl(init_chunk->initial_tsn));
                chunk->setAddressesArraySize(0);
                chunk->setUnrecognizedParametersArraySize(0);
                //sctpEV3<<"INIT arrived from wire\n";
                if (cLen > size_init_chunk) {
                    int32 parcounter = 0, addrcounter = 0;
                    parptr = 0;
                    int chkcounter = 0;
                    bool stopProcessing = false;
                    while (cLen > size_init_chunk + parptr && !stopProcessing) {
                        EV_INFO << "Process INIT parameters" << endl;
                        const struct tlv *parameter = (struct tlv *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                        paramType = ntohs(parameter->type);
                        EV_INFO << "search for param: " << paramType << " - current chunklen: " << chunklen << endl;
                        switch (paramType) {
                            case SUPPORTED_ADDRESS_TYPES: {
                                const struct supported_address_types_parameter *sup_addr = (struct supported_address_types_parameter *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                if (sup_addr->address_type_1 == ntohs(INIT_PARAM_IPV4) || sup_addr->address_type_2 == ntohs(INIT_PARAM_IPV4)) {
                                    chunk->setIpv4Supported(true);
                                } else {
                                    chunk->setIpv4Supported(false);
                                }
                                if (sup_addr->address_type_1 == ntohs(INIT_PARAM_IPV6) || sup_addr->address_type_2 == ntohs(INIT_PARAM_IPV6)) {
                                    chunk->setIpv6Supported(true);
                                } else {
                                    chunk->setIpv6Supported(false);
                                }
                                chunklen += 8;
                                break;
                            }

                            case INIT_PARAM_IPV4: {
                                // we supppose an ipv4 address parameter
                                EV_INFO << "IPv4\n";
                                const struct init_ipv4_address_parameter *v4addr;
                                v4addr = (struct init_ipv4_address_parameter *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                chunk->setAddressesArraySize(++addrcounter);
                                L3Address localv4Addr(IPv4Address(ntohl(v4addr->address)));
                                chunk->setAddresses(addrcounter - 1, localv4Addr);
                                chunklen += 8;
                                break;
                            }

                            case INIT_PARAM_IPV6: {
                                EV_INFO << "IPv6\n";
                                const struct init_ipv6_address_parameter *ipv6addr;
                                ipv6addr = (struct init_ipv6_address_parameter *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                IPv6Address ipv6Addr = IPv6Address(ipv6addr->address[0], ipv6addr->address[1],
                                            ipv6addr->address[2], ipv6addr->address[3]);
                                L3Address localv6Addr(ipv6Addr);
                                EV_INFO << "address" << ipv6Addr << "\n";
                                chunk->setAddressesArraySize(++addrcounter);
                                chunk->setAddresses(addrcounter - 1, localv6Addr);
                                chunklen += 20;
                                break;
                            }

                            case SUPPORTED_EXTENSIONS: {
                                EV_INFO << "Supported extensions\n";
                                const struct supported_extensions_parameter *supext;
                                supext = (struct supported_extensions_parameter *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                unsigned short chunkTypes;
                                int len = 4;
                                EV_INFO << "supext->len=" << ntohs(supext->length) << "\n";
                                while (ntohs(supext->length) > len) {
                                    chunkTypes = (int)*(chunks + chunkPtr + size_init_chunk + parptr + 4 + chkcounter);
                                    chunk->setSepChunksArraySize(++chkcounter);
                                    EV_INFO << "Extension " << chunkTypes << " added\n";
                                    chunk->setSepChunks(chkcounter - 1, chunkTypes);
                                    len++;
                                }
                                chunklen += ADD_PADDING(len);
                                break;
                            }

                            case FORWARD_TSN_SUPPORTED_PARAMETER: {
                                EV_INFO << "Forward TSN\n";
                                int size = chunk->getChunkTypesArraySize();
                                chunk->setChunkTypesArraySize(size + 1);
                                chunk->setChunkTypes(size, FORWARD_TSN_SUPPORTED_PARAMETER);
                                chunklen += ntohs(parameter->length);
                                break;
                            }

                            case RANDOM: {
                                EV_INFO << "random parameter received\n";
                                const struct random_parameter *rand;
                                rand = (struct random_parameter *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                unsigned char *rv = (unsigned char *)malloc(64);
                                rp = (struct random_parameter *)((unsigned char *)rv);
                                rp->type = rand->type;
                                rplen = ntohs(rand->length);
                                rp->length = rand->length;
                                int rlen = ntohs(rand->length) - 4;
                                chunk->setRandomArraySize(rlen);
                                for (int i = 0; i < rlen; i++) {
                                    chunk->setRandom(i, (unsigned char)(rand->random[i]));
                                    rp->random[i] = (unsigned char)(rand->random[i]);
                                }
                                EV_INFO << "adding " << ntohs(parameter->length) << " bytes" << endl;
                                chunklen += ntohs(parameter->length);
                                break;
                            }

                            case HMAC_ALGO: {
                                EV_INFO << "hmac_algo parameter received\n";
                                const struct hmac_algo *hmac;
                                hmac = (struct hmac_algo *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                int num = (ntohs(hmac->length) - 4) / 2;
                                chunk->setHmacTypesArraySize(num);
                                unsigned char *hv = (unsigned char *)malloc(64);
                                hp = (struct hmac_algo *)((unsigned char *)hv);
                                hp->type = hmac->type;
                                hplen = ntohs(hmac->length);
                                hp->length = hmac->length;
                                for (int i = 0; i < num; i++) {
                                    chunk->setHmacTypes(i, ntohs(hmac->ident[i]));
                                    hp->ident[i] = hmac->ident[i];
                                }
                                chunklen += 4 + 2 * num;
                                break;
                            }

                            case CHUNKS: {
                                EV_INFO << "chunks parameter received\n";
                                const struct tlv *chunks;
                                chunks = (struct tlv *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);
                                unsigned char *cv = (unsigned char *)malloc(64);
                                cp = (struct tlv *)((unsigned char *)cv);
                                cp->type = chunks->type;
                                cplen = ntohs(chunks->length);
                                cp->length = chunks->length;
                                int num = cplen - 4;
                                chunk->setChunkTypesArraySize(num);
                                for (int i = 0; i < num; i++) {
                                    chunk->setChunkTypes(i, (chunks->value[i]));
                                    cp->value[i] = chunks->value[i];
                                }
                                chunklen += ADD_PADDING(ntohs(parameter->length));
                                break;
                            }

                            default: {
                                EV_INFO << "ExtInterface: Unknown SCTP INIT parameter type " << paramType << "\n";
                                uint16 skip = (paramType & 0x8000) >> 15;
                                if (skip == 0)
                                    stopProcessing = true;
                                uint16 report = (paramType & 0x4000) >> 14;

                                const struct tlv *unknown;
                                unknown = (struct tlv *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);

                                if (report != 0) {
                                    uint32 unknownLen = chunk->getUnrecognizedParametersArraySize();
                                    chunk->setUnrecognizedParametersArraySize(unknownLen + ADD_PADDING(ntohs(unknown->length)));
                                    struct data_vector *dv = (struct data_vector *)(((unsigned char *)init_chunk) + size_init_chunk + parptr);

                                    for (uint32 i = unknownLen; i < unknownLen + ADD_PADDING(ntohs(unknown->length)); i++)
                                        chunk->setUnrecognizedParameters(i, dv->data[i - unknownLen]);
                                } else {
                                    chunklen += ADD_PADDING(ntohs(unknown->length));
                                }
                                EV_INFO << "stopProcessing=" << stopProcessing << " report=" << report << "\n";
                                break;
                            }
                        }
                        parptr += ADD_PADDING(ntohs(parameter->length));
                        parcounter++;
                    }
                }
                if (chunk->getHmacTypesArraySize() != 0) {
                    unsigned char *vector = (unsigned char *)malloc(64);
                    sizePeerKeyVector = rplen;
                    memcpy(vector, rp, rplen);
                    for (unsigned int k = 0; k < sizePeerKeyVector; k++) {
                        peerKeyVector[k] = vector[k];
                    }
                    memcpy(vector, cp, cplen);
                    for (unsigned int k = 0; k < cplen; k++) {
                        peerKeyVector[sizePeerKeyVector + k] = vector[k];
                    }
                    sizePeerKeyVector += cplen;
                    memcpy(vector, hp, hplen);
                    for (unsigned int k = 0; k < hplen; k++) {
                        peerKeyVector[sizePeerKeyVector + k] = vector[k];
                    }
                    sizePeerKeyVector += hplen;
                    free(vector);
                }
                chunk->setBitLength(chunklen * 8);
                EV_INFO << "chunklen: " << chunk->getByteLength() << endl;
                dest->addChunk(chunk);
                //chunkPtr += cLen;
                break;
            }

            case INIT_ACK: {
                const struct init_ack_chunk *iac = (struct init_ack_chunk *)(chunks + chunkPtr);
                struct tlv *cp = nullptr;
                struct random_parameter *rp = nullptr;
                struct hmac_algo *hp = nullptr;
                unsigned int rplen = 0, hplen = 0, cplen = 0;
                chunklen = SCTP_INIT_CHUNK_LENGTH;
                SCTPInitAckChunk *chunk = new SCTPInitAckChunk("INIT_ACK");
                chunk->setChunkType(chunkType);
                chunk->setInitTag(ntohl(iac->initiate_tag));
                chunk->setA_rwnd(ntohl(iac->a_rwnd));
                chunk->setNoOutStreams(ntohs(iac->mos));
                chunk->setNoInStreams(ntohs(iac->mis));
                chunk->setInitTSN(ntohl(iac->initial_tsn));
                chunk->setUnrecognizedParametersArraySize(0);
                if (cLen > size_init_ack_chunk) {
                    int32 parcounter = 0, addrcounter = 0;
                    parptr = 0;
                    int chkcounter = 0;
                    bool stopProcessing = false;
                    //sctpEV3<<"cLen="<<cLen<<"\n";
                    while (cLen > size_init_ack_chunk + parptr && !stopProcessing) {
                        const struct tlv *parameter = (struct tlv *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                        paramType = ntohs(parameter->type);
                        //sctpEV3<<"ParamType = "<<paramType<<" parameterLength="<<ntohs(parameter->length)<<"\n";

                        EV_INFO << "Chunklen before: " << chunklen << endl;
                        switch (paramType) {
                            case SUPPORTED_ADDRESS_TYPES: {
                                const struct supported_address_types_parameter *sup_addr = (struct supported_address_types_parameter *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                if (sup_addr->address_type_1 == ntohs(INIT_PARAM_IPV4) || sup_addr->address_type_2 == ntohs(INIT_PARAM_IPV4)) {
                                    chunk->setIpv4Supported(true);
                                } else {
                                    chunk->setIpv4Supported(false);
                                }
                                if (sup_addr->address_type_1 == ntohs(INIT_PARAM_IPV6) || sup_addr->address_type_2 == ntohs(INIT_PARAM_IPV6)) {
                                    chunk->setIpv6Supported(true);
                                } else {
                                    chunk->setIpv6Supported(false);
                                }
                                chunklen += 8;
                                break;
                            }

                            case INIT_PARAM_IPV4: {
                                EV_INFO << "parse IPv4\n";
                                const struct init_ipv4_address_parameter *v4addr;
                                v4addr = (struct init_ipv4_address_parameter *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                chunk->setAddressesArraySize(++addrcounter);
                                L3Address localv4Addr(IPv4Address(ntohl(v4addr->address)));
                                chunk->setAddresses(addrcounter - 1, localv4Addr);
                                chunklen += 8;
                                break;
                            }

                            case INIT_PARAM_IPV6: {
                                EV_INFO << "IPv6\n";
                                const struct init_ipv6_address_parameter *ipv6addr;
                                ipv6addr = (struct init_ipv6_address_parameter *)(((unsigned char *)iac) + size_init_chunk + parptr);
                                IPv6Address ipv6Addr = IPv6Address(ipv6addr->address[0], ipv6addr->address[1],
                                            ipv6addr->address[2], ipv6addr->address[3]);
                                EV_INFO << "address" << ipv6Addr << "\n";
                                L3Address localv6Addr(ipv6Addr);

                                chunk->setAddressesArraySize(++addrcounter);
                                chunk->setAddresses(addrcounter - 1, localv6Addr);
                                chunklen += 20;
                                break;
                            }

                            case RANDOM: {
                                const struct random_parameter *rand;
                                rand = (struct random_parameter *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                int rlen = ntohs(rand->length) - 4;
                                chunk->setRandomArraySize(rlen);
                                rp = (struct random_parameter *)((unsigned char *)malloc(64));
                                rp->type = rand->type;
                                rplen = ntohs(rand->length);
                                rp->length = rand->length;
                                for (int i = 0; i < rlen; i++) {
                                    chunk->setRandom(i, (unsigned char)(rand->random[i]));
                                    rp->random[i] = (unsigned char)(rand->random[i]);
                                }

                                chunklen += ntohs(parameter->length);
                                break;
                            }

                            case HMAC_ALGO: {
                                const struct hmac_algo *hmac;
                                hmac = (struct hmac_algo *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                int num = (ntohs(hmac->length) - 4) / 2;
                                chunk->setHmacTypesArraySize(num);
                                hp = (struct hmac_algo *)((unsigned char *)malloc(64));
                                hp->type = hmac->type;
                                hplen = ntohs(hmac->length);
                                hp->length = hmac->length;
                                for (int i = 0; i < num; i++) {
                                    chunk->setHmacTypes(i, ntohs(hmac->ident[i]));
                                    hp->ident[i] = hmac->ident[i];
                                }
                                chunklen += 4 + 2 * num;
                                break;
                            }

                            case CHUNKS: {
                                const struct tlv *chunks;
                                chunks = (struct tlv *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                int num = ntohs(chunks->length) - 4;
                                chunk->setChunkTypesArraySize(num);
                                cp = (struct tlv *)((unsigned char *)malloc(64));
                                cp->type = chunks->type;
                                cplen = ntohs(chunks->length);
                                cp->length = chunks->length;
                                for (int i = 0; i < num; i++) {
                                    chunk->setChunkTypes(i, chunks->value[i]);
                                    cp->value[i] = chunks->value[i];
                                }
                                chunklen += ADD_PADDING(ntohs(parameter->length));
                                break;
                            }

                            case INIT_PARAM_COOKIE: {
                                const struct tlv *cookie = (struct tlv *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                int32 cookieLen = ntohs(cookie->length) - 4;
                                // put cookie data into chunk (char array cookie)
                                chunk->setCookieArraySize(cookieLen);
                                for (int32 i = 0; i < cookieLen; i++)
                                    chunk->setCookie(i, cookie->value[i]);
                                chunklen += cookieLen + 4;
                                break;
                            }

                            case SUPPORTED_EXTENSIONS: {
                                const struct supported_extensions_parameter *supext;
                                supext = (struct supported_extensions_parameter *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);
                                unsigned short chunkTypes;
                                //chunklen += 4;
                                int len = 4;
                                while (ntohs(supext->length) > len) {
                                    chunkTypes = (int)*(chunks + chunkPtr + size_init_ack_chunk + parptr + 4 + chkcounter);
                                    chunk->setSepChunksArraySize(++chkcounter);
                                    chunk->setSepChunks(chkcounter - 1, chunkTypes);
                                    //chunklen++;
                                    len++;
                                }
                                chunklen += ADD_PADDING(len);
                                break;
                            }

                            case FORWARD_TSN_SUPPORTED_PARAMETER: {
                                int size = chunk->getChunkTypesArraySize();
                                chunk->setChunkTypesArraySize(size + 1);
                                chunk->setChunkTypes(size, FORWARD_TSN_SUPPORTED_PARAMETER);
                                chunklen++;
                                break;
                            }

                            default: {
                                EV_INFO << "ExtInterface: Unknown SCTP INIT-ACK parameter type " << paramType << "\n";
                                uint16 skip = (paramType & 0x8000) >> 15;
                                if (skip == 0)
                                    stopProcessing = true;
                                uint16 report = (paramType & 0x4000) >> 14;

                                const struct tlv *unknown;
                                unknown = (struct tlv *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);

                                if (report != 0) {
                                    uint32 unknownLen = chunk->getUnrecognizedParametersArraySize();
                                    chunk->setUnrecognizedParametersArraySize(unknownLen + ADD_PADDING(ntohs(unknown->length)));
                                    struct data_vector *dv = (struct data_vector *)(((unsigned char *)iac) + size_init_ack_chunk + parptr);

                                    for (uint32 i = unknownLen; i < unknownLen + ADD_PADDING(ntohs(unknown->length)); i++)
                                        chunk->setUnrecognizedParameters(i, dv->data[i - unknownLen]);
                                } else {
                                    chunklen += ADD_PADDING(ntohs(unknown->length));
                                }
                                EV_INFO << "stopProcessing=" << stopProcessing << "  report=" << report << "\n";

                                break;
                            }
                        }
                        EV_INFO << "Chunklen after: " << chunklen << endl;
                        parptr += ADD_PADDING(ntohs(parameter->length));
                        //sctpEV3<<"parptr="<<parptr<<"\n";
                        parcounter++;
                    }
                }
                if (chunk->getHmacTypesArraySize() != 0) {
                    unsigned char vector[64];
                    if (rplen > 64) {
                        EV_ERROR << "Random parameter too long. It will be truncated.\n";
                        rplen = 64;
                    }
                    sizePeerKeyVector = rplen;
                    memcpy(vector, rp, rplen);
                    for (unsigned int k = 0; k < sizePeerKeyVector; k++) {
                        peerKeyVector[k] = vector[k];
                    }
                    free(rp);
                    if (cplen > 64) {
                        EV_ERROR << "Chunks parameter too long. It will be truncated.\n";
                        cplen = 64;
                    }
                    memcpy(vector, cp, cplen);
                    for (unsigned int k = 0; k < cplen; k++) {
                        peerKeyVector[sizePeerKeyVector + k] = vector[k];
                    }
                    free(cp);
                    sizePeerKeyVector += cplen;
                    if (hplen > 64) {
                        EV_ERROR << "HMac parameter too long. It will be truncated.\n";
                        hplen = 64;
                    }
                    memcpy(vector, hp, hplen);
                    for (unsigned int k = 0; k < hplen; k++) {
                        peerKeyVector[sizePeerKeyVector + k] = vector[k];
                    }
                    free(hp);
                    sizePeerKeyVector += hplen;
                    calculateSharedKey();
                }
                chunk->setBitLength(chunklen * 8);
                dest->addChunk(chunk);
                break;
            }

            case SACK: {
                EV << "SCTPMessage: SACK received\n";
                const struct sack_chunk *sac = (struct sack_chunk *)(chunks + chunkPtr);
                SCTPSackChunk *chunk = new SCTPSackChunk("SACK");
                chunk->setChunkType(chunkType);
                uint32 cumtsnack = ntohl(sac->cum_tsn_ack);
                chunk->setCumTsnAck(cumtsnack);
                chunk->setA_rwnd(ntohl(sac->a_rwnd));

                int32 ngaps = ntohs(sac->nr_of_gaps);
                int32 ndups = ntohs(sac->nr_of_dups);
                chunk->setNumGaps(ngaps);
                chunk->setNumDupTsns(ndups);

                chunk->setGapStartArraySize(ngaps);
                chunk->setGapStopArraySize(ngaps);
                chunk->setDupTsnsArraySize(ndups);

                for (int32 i = 0; i < ngaps; i++) {
                    const struct sack_gap *gap = (struct sack_gap *)(((unsigned char *)sac) + size_sack_chunk + i * sizeof(sack_gap));
                    chunk->setGapStart(i, ntohs(gap->start) + cumtsnack);
                    chunk->setGapStop(i, ntohs(gap->stop) + cumtsnack);
                }
                for (int32 i = 0; i < ndups; i++) {
                    const struct sack_duptsn *dup = (struct sack_duptsn *)(((unsigned char *)sac) + size_sack_chunk + ngaps * sizeof(sack_gap) + i * sizeof(sack_duptsn));
                    chunk->setDupTsns(i, ntohl(dup->tsn));
                }

                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case HEARTBEAT: {
                //sctpEV3<<"SCTPMessage: Heartbeat received\n";
                const struct heartbeat_chunk *hbc = (struct heartbeat_chunk *)(chunks + chunkPtr);
                SCTPHeartbeatChunk *chunk = new SCTPHeartbeatChunk("HEARTBEAT");
                chunk->setChunkType(chunkType);
                if (cLen > size_heartbeat_chunk) {
                    int32 parcounter = 0;
                    parptr = 0;
                    while (cLen > size_heartbeat_chunk + parptr) {
                        // we supppose type 1 here
                        //sctpEV3<<"HB-chunk+parptr="<<size_heartbeat_chunk+parptr<<"\n";
                        const struct heartbeat_info *hbi = (struct heartbeat_info *)(((unsigned char *)hbc) + size_heartbeat_chunk + parptr);
                        if (ntohs(hbi->type) == 1) {    // sender specific hb info
                            //sctpEV3<<"HBInfo\n";
                            int32 infoLen = ntohs(hbi->length) - 4;
                            parptr += ADD_PADDING(infoLen) + 4;
                            parcounter++;
                            chunk->setInfoArraySize(infoLen);
                            for (int32 i = 0; i < infoLen; i++)
                                chunk->setInfo(i, HBI_INFO(hbi)[i]);
                        }
                        else {
                            parptr += ADD_PADDING(ntohs(hbi->length));    // set pointer forwards with count of bytes in length field of TLV
                            parcounter++;
                            continue;
                        }
                    }
                }
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case HEARTBEAT_ACK: {
                EV << "SCTPMessage: Heartbeat_Ack received\n";
                const struct heartbeat_ack_chunk *hbac = (struct heartbeat_ack_chunk *)(chunks + chunkPtr);
                SCTPHeartbeatAckChunk *chunk = new SCTPHeartbeatAckChunk("HEARTBEAT_ACK");
                chunk->setChunkType(chunkType);
                if (cLen > size_heartbeat_ack_chunk) {
                    int32 parcounter = 0;
                    parptr = 0;
                    while (cLen > size_heartbeat_ack_chunk + parptr) {
                        // we supppose type 1 here, the same provided in heartbeat chunks
                        const struct heartbeat_info *hbi = (struct heartbeat_info *)(((unsigned char *)hbac) + size_heartbeat_ack_chunk + parptr);
                        if (ntohs(hbi->type) == 1) {    // sender specific hb info
                            uint16 ilen = ntohs(hbi->length);
                            ASSERT(ilen >= 4 && ilen == cLen - size_heartbeat_ack_chunk);
                            uint16 infoLen = ilen - 4;
                            parptr += ADD_PADDING(infoLen) + 4;
                            parcounter++;
                            chunk->setRemoteAddr(L3Address(IPv4Address(ntohl(HBI_ADDR(hbi).v4addr.address))));
                            chunk->setTimeField(ntohl((uint32)HBI_TIME(hbi)));
                            chunk->setInfoArraySize(infoLen);
                            for (int32 i = 0; i < infoLen; i++)
                                chunk->setInfo(i, HBI_INFO(hbi)[i]);
                        }
                        else {
                            parptr += ntohs(hbi->length);    // set pointer forwards with count of bytes in length field of TLV
                            parcounter++;
                            continue;
                        }
                    }
                }
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case ABORT: {
                EV << "SCTPMessage: Abort received\n";
                const struct abort_chunk *ac = (struct abort_chunk *)(chunks + chunkPtr);
                cLen = ntohs(ac->length);
                SCTPAbortChunk *chunk = new SCTPAbortChunk("ABORT");
                chunk->setChunkType(chunkType);
                chunk->setT_Bit(ac->flags & T_BIT);
                if (cLen > size_abort_chunk) {
                    // TODO: handle attached error causes
                }
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case COOKIE_ECHO: {
                SCTPCookieEchoChunk *chunk = new SCTPCookieEchoChunk("COOKIE_ECHO");
                chunk->setChunkType(chunkType);
                EV_INFO << "Parse Cookie-Echo\n";
                if (cLen > size_cookie_echo_chunk) {
                    int32 cookieSize = woPadding - size_cookie_echo_chunk;
                    EV_DETAIL << "cookieSize=" << cookieSize << "\n";
                    const struct cookie_parameter *cookie = (struct cookie_parameter *)(chunks + chunkPtr + 4);
                    SCTPCookie *stateCookie = new SCTPCookie();
                    stateCookie->setCreationTime(ntohl(cookie->creationTime));
                    stateCookie->setLocalTag(ntohl(cookie->localTag));
                    stateCookie->setPeerTag(ntohl(cookie->peerTag));
                    stateCookie->setLocalTieTagArraySize(32);
                    stateCookie->setPeerTieTagArraySize(32);
                    for (int32 i = 0; i < 32; i++) {
                        stateCookie->setLocalTieTag(i, cookie->localTieTag[i]);
                        stateCookie->setPeerTieTag(i, cookie->peerTieTag[i]);
                    }
                    stateCookie->setBitLength(SCTP_COOKIE_LENGTH * 8);
                    chunk->setStateCookie(stateCookie);
                }
                chunk->setBitLength(woPadding * 8);
                dest->addChunk(chunk);
                break;
            }

            case COOKIE_ACK: {
                EV << "SCTPMessage: Cookie_Ack received\n";
                SCTPCookieAckChunk *chunk = new SCTPCookieAckChunk("COOKIE_ACK");
                chunk->setChunkType(chunkType);
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case SHUTDOWN: {
                EV << "SCTPMessage: Shutdown received\n";
                const struct shutdown_chunk *sc = (struct shutdown_chunk *)(chunks + chunkPtr);
                SCTPShutdownChunk *chunk = new SCTPShutdownChunk("SHUTDOWN");
                chunk->setChunkType(chunkType);
                uint32 cumtsnack = ntohl(sc->cumulative_tsn_ack);
                chunk->setCumTsnAck(cumtsnack);
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case SHUTDOWN_ACK: {
                EV << "SCTPMessage: ShutdownAck received\n";
                SCTPShutdownAckChunk *chunk = new SCTPShutdownAckChunk("SHUTDOWN_ACK");
                chunk->setChunkType(chunkType);
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case SHUTDOWN_COMPLETE: {
                EV << "SCTPMessage: ShutdownComplete received\n";
                const struct shutdown_complete_chunk *scc = (struct shutdown_complete_chunk *)(chunks + chunkPtr);
                SCTPShutdownCompleteChunk *chunk = new SCTPShutdownCompleteChunk("SHUTDOWN_COMPLETE");
                chunk->setChunkType(chunkType);
                chunk->setTBit(scc->flags & T_BIT);
                chunk->setBitLength(cLen * 8);
                dest->addChunk(chunk);
                break;
            }

            case ERRORTYPE: {
                const struct error_chunk *error;
                error = (struct error_chunk *)(chunks + chunkPtr);
                SCTPErrorChunk *errorchunk;
                errorchunk = new SCTPErrorChunk("ERROR");
                errorchunk->setChunkType(chunkType);
                errorchunk->setBitLength(SCTP_ERROR_CHUNK_LENGTH * 8);
                parptr = 0;
                const struct error_cause *err = (struct error_cause *)(((unsigned char *)error) + size_error_chunk + parptr);
                if (err->cause_code == UNSUPPORTED_HMAC) {
                    SCTPSimpleErrorCauseParameter *errParam;
                    errParam = new SCTPSimpleErrorCauseParameter();
                    errParam->setParameterType(err->cause_code);
                    errParam->setByteLength(err->length);
                    errorchunk->addParameters(errParam);
                }
                dest->addChunk(errorchunk);
                break;
            }

            case FORWARD_TSN: {
                EV << "SCTPMessage: ForwardTsn received" << endl;
                const struct forward_tsn_chunk *forward_tsn_chunk;
                forward_tsn_chunk = (struct forward_tsn_chunk *)(chunks + chunkPtr);
                SCTPForwardTsnChunk *chunk;
                chunk = new SCTPForwardTsnChunk("FORWARD_TSN");
                chunk->setChunkType(chunkType);
                chunk->setName("FORWARD_TSN");
                chunk->setNewCumTsn(ntohl(forward_tsn_chunk->cum_tsn));
                int streamNumber = 0, streamptr = 0;
                while (cLen > size_forward_tsn_chunk + streamptr) {
                    const struct forward_tsn_streams *forward = (struct forward_tsn_streams *)(((unsigned char *)forward_tsn_chunk) + size_forward_tsn_chunk + streamptr);
                    chunk->setSidArraySize(++streamNumber);
                    chunk->setSid(streamNumber - 1, ntohs(forward->sid));
                    chunk->setSsnArraySize(streamNumber);
                    chunk->setSsn(streamNumber - 1, ntohs(forward->ssn));
                    streamptr += sizeof(struct forward_tsn_streams);
                }
                chunk->setByteLength(cLen);
                dest->addChunk(chunk);
                break;
            }

            case AUTH: {
                int hmacSize;
                struct auth_chunk *ac = (struct auth_chunk *)(chunks + chunkPtr);
                SCTPAuthenticationChunk *chunk = new SCTPAuthenticationChunk("AUTH");
                chunk->setChunkType(chunkType);
                chunk->setSharedKey(ntohs(ac->shared_key));
                chunk->setHMacIdentifier(ntohs(ac->hmac_identifier));
                if (cLen > size_auth_chunk) {
                    hmacSize = woPadding - size_auth_chunk;
                    chunk->setHMACArraySize(hmacSize);
                    for (int i = 0; i < hmacSize; i++) {
                        chunk->setHMAC(i, ac->hmac[i]);
                        ac->hmac[i] = 0;
                    }
                }

                unsigned char result[SHA_LENGTH];
                unsigned int flen;
                flen = bufsize - (size_common_header + chunkPtr);

                const struct data_vector *sc = (struct data_vector *)(chunks + chunkPtr);
                hmacSha1((uint8 *)sc->data, flen, sharedKey, sizeKeyVector + sizePeerKeyVector, result);

                chunk->setHMacOk(true);
                for (unsigned int j = 0; j < SHA_LENGTH; j++) {
                    if (result[j] != chunk->getHMAC(j)) {
                        EV_DETAIL << "hmac falsch\n";
                        chunk->setHMacOk(false);
                        break;
                    }
                }
                chunk->setByteLength(woPadding);
                dest->addChunk(chunk);
                break;
            }

            case ASCONF: {
                const struct asconf_chunk *asconf_chunk = (struct asconf_chunk *)(chunks + chunkPtr);    // (recvBuffer + size_ip + size_common_header);
                int paramLength = 0;
                SCTPAsconfChunk *chunk = new SCTPAsconfChunk("ASCONF");
                chunk->setChunkType(chunkType);
                chunk->setName("ASCONF");
                chunk->setSerialNumber(ntohl(asconf_chunk->serial));
                if (cLen > size_asconf_chunk) {
                    int parcounter = 0;
                    parptr = 0;
                    // we supppose an ipv4 address parameter
                    const struct init_ipv4_address_parameter *ipv4addr = (struct init_ipv4_address_parameter *)(((unsigned char *)asconf_chunk) + size_asconf_chunk + parptr);
                    int parlen = ADD_PADDING(ntohs(ipv4addr->length));
                    parptr += parlen;
                    // set pointer forwards with count of bytes in length field of TLV
                    parcounter++;
                    if (ntohs(ipv4addr->type) != INIT_PARAM_IPV4) {
                        if (parlen == 0)
                            throw new cRuntimeError("ParamLen == 0.");
                        continue;
                    }
                    else {
                        L3Address localAddr(IPv4Address(ntohl(ipv4addr->address)));
                        chunk->setAddressParam(localAddr);
                    }
                    while (cLen > size_asconf_chunk + parptr) {
                        const struct add_ip_parameter *ipparam = (struct add_ip_parameter *)(((unsigned char *)asconf_chunk) + size_asconf_chunk + parptr);
                        paramType = ntohs(ipparam->type);
                        paramLength = ntohs(ipparam->length);
                        switch (paramType) {
                            case ADD_IP_ADDRESS: {
                                EV_INFO << "parse ADD_IP_ADDRESS\n";
                                SCTPAddIPParameter *addip;
                                addip = new SCTPAddIPParameter("ADD_IP");
                                addip->setParameterType(ntohs(ipparam->type));
                                addip->setRequestCorrelationId(ntohl(ipparam->correlation_id));
                                const struct init_ipv4_address_parameter *v4addr1;
                                v4addr1 = (struct init_ipv4_address_parameter *)(((unsigned char *)asconf_chunk) + size_asconf_chunk + parptr + size_addip_parameter);
                                L3Address localAddr(IPv4Address(ntohl(v4addr1->address)));
                                addip->setAddressParam(localAddr);
                                chunk->addAsconfParam(addip);
                                break;
                            }

                            case DELETE_IP_ADDRESS: {
                                EV_INFO << "parse DELETE_IP_ADDRESS\n";
                                SCTPDeleteIPParameter *deleteip;
                                deleteip = new SCTPDeleteIPParameter("DELETE_IP");
                                deleteip->setParameterType(ntohs(ipparam->type));
                                deleteip->setRequestCorrelationId(ntohl(ipparam->correlation_id));
                                const struct init_ipv4_address_parameter *v4addr2;
                                v4addr2 = (struct init_ipv4_address_parameter *)(((unsigned char *)asconf_chunk) + size_asconf_chunk + parptr + size_addip_parameter);
                                L3Address localAddr(IPv4Address(ntohl(v4addr2->address)));
                                deleteip->setAddressParam(localAddr);
                                chunk->addAsconfParam(deleteip);
                                break;
                            }

                            case SET_PRIMARY_ADDRESS: {
                                EV_INFO << "parse SET_PRIMARY_ADDRESS\n";
                                SCTPSetPrimaryIPParameter *priip;
                                priip = new SCTPSetPrimaryIPParameter("SET_PRI_IP");
                                priip->setParameterType(ntohs(ipparam->type));
                                priip->setRequestCorrelationId(ntohl(ipparam->correlation_id));
                                const struct init_ipv4_address_parameter *v4addr3;
                                v4addr3 = (struct init_ipv4_address_parameter *)(((unsigned char *)asconf_chunk) + size_asconf_chunk + parptr + size_addip_parameter);
                                L3Address localAddr(IPv4Address(ntohl(v4addr3->address)));
                                priip->setAddressParam(localAddr);
                                chunk->addAsconfParam(priip);
                                break;
                            }

                            default:
                                printf("TODO: Implement parameter type %d!\n", paramType);
                                EV << "ExtInterface: Unknown SCTP parameter type " << paramType;
                                /*throw new cRuntimeError("TODO: unknown parametertype in incoming packet from external interface! Implement it!");*/
                                break;
                        }
                        parptr += ADD_PADDING(paramLength);
                        parcounter++;
                    }
                }
                chunk->setByteLength(cLen);
                dest->addChunk(chunk);
                break;
            }

            case ASCONF_ACK: {
                const struct asconf_ack_chunk *asconf_ack_chunk = (struct asconf_ack_chunk *)(chunks + chunkPtr);    // (recvBuffer + size_ip + size_common_header);
                int paramLength = 0;
                SCTPAsconfAckChunk *chunk = new SCTPAsconfAckChunk("ASCONF_ACK");
                chunk->setChunkType(chunkType);
                chunk->setName("ASCONF_ACK");
                chunk->setSerialNumber(ntohl(asconf_ack_chunk->serial));
                if (cLen > size_asconf_ack_chunk) {
                    int parcounter = 0;
                    parptr = 0;

                    while (cLen > size_asconf_ack_chunk + parptr) {
                        const struct add_ip_parameter *ipparam = (struct add_ip_parameter *)(((unsigned char *)asconf_ack_chunk) + size_asconf_ack_chunk + parptr);
                        paramType = ntohs(ipparam->type);
                        paramLength = ntohs(ipparam->length);
                        switch (paramType) {
                            case ERROR_CAUSE_INDICATION: {
                                SCTPErrorCauseParameter *errorip;
                                errorip = new SCTPErrorCauseParameter("ERROR_CAUSE");
                                errorip->setParameterType(ntohs(ipparam->type));
                                errorip->setResponseCorrelationId(ntohl(ipparam->correlation_id));
                                const struct error_cause *errorcause;
                                errorcause = (struct error_cause *)(((unsigned char *)asconf_ack_chunk) + size_asconf_ack_chunk + parptr + size_addip_parameter);
                                errorip->setErrorCauseType(htons(errorcause->cause_code));
                                chunk->addAsconfResponse(errorip);
                                break;
                            }

                            case SUCCESS_INDICATION: {
                                SCTPSuccessIndication *success;
                                success = new SCTPSuccessIndication("SUCCESS");
                                success->setParameterType(ntohs(ipparam->type));
                                success->setResponseCorrelationId(ntohl(ipparam->correlation_id));
                                chunk->addAsconfResponse(success);
                                break;
                            }

                            default:
                                printf("TODO: Implement parameter type %d!\n", paramType);
                                EV << "ExtInterface: Unknown SCTP parameter type " << paramType;
                                break;
                        }
                        parptr += ADD_PADDING(paramLength);
                        parcounter++;
                    }
                }
                chunk->setByteLength(cLen);
                dest->addChunk(chunk);
                break;
            }

            case RE_CONFIG: {
                const struct stream_reset_chunk *stream_reset_chunk;
                stream_reset_chunk = (struct stream_reset_chunk *)(chunks + chunkPtr);
                SCTPStreamResetChunk *chunk;
                chunk = new SCTPStreamResetChunk("RE_CONFIG");
                chunk->setChunkType(chunkType);
                chunk->setName("RE_CONFIG");
                chunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
                chunklen = SCTP_STREAM_RESET_CHUNK_LENGTH;
                int len;
                if ((unsigned int)cLen > sizeof(struct stream_reset_chunk)) {
                    parptr = 0;
                    int parcounter = 0;
                    int snnumbers, sncounter;
                    while (cLen > size_stream_reset_chunk + parptr) {
                        const struct tlv *parameter = (struct tlv *)(((unsigned char *)stream_reset_chunk) + size_stream_reset_chunk + parptr);
                        paramType = ntohs(parameter->type);
                        int paramLength = ntohs(parameter->length);
                        switch (paramType) {
                            case OUTGOING_RESET_REQUEST_PARAMETER: {
                                const struct outgoing_reset_request_parameter *outrr;
                                outrr = (struct outgoing_reset_request_parameter *)(((unsigned char *)stream_reset_chunk) + size_stream_reset_chunk + parptr);
                                SCTPOutgoingSSNResetRequestParameter *outstrrst;
                                outstrrst = new SCTPOutgoingSSNResetRequestParameter("OUT_STR_RST");
                                outstrrst->setParameterType(OUTGOING_RESET_REQUEST_PARAMETER);
                                outstrrst->setSrReqSn(ntohl(outrr->srReqSn));    //Stream Reset Request Sequence Number
                                outstrrst->setSrResSn(ntohl(outrr->srResSn));    //Stream Reset Response Sequence Number
                                outstrrst->setLastTsn(ntohl(outrr->lastTsn));    //Senders last assigned TSN
                                chunklen += SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH;
                                len = SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH;
                                sncounter = 0;
                                while (ntohs(outrr->length) > len) {
                                    snnumbers = (int)*(chunks + chunkPtr + size_stream_reset_chunk + parptr + SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH + sncounter * 2);
                                    outstrrst->setStreamNumbersArraySize(++sncounter);
                                    outstrrst->setStreamNumbers(sncounter - 1, snnumbers);
                                    chunklen += 2;
                                    len += 2;
                                }
                                chunk->addParameter(outstrrst);
                                break;
                            }

                            case INCOMING_RESET_REQUEST_PARAMETER: {
                                const struct incoming_reset_request_parameter *inrr;
                                inrr = (struct incoming_reset_request_parameter *)(((unsigned char *)stream_reset_chunk) + size_stream_reset_chunk + parptr);
                                SCTPIncomingSSNResetRequestParameter *instrrst;
                                instrrst = new SCTPIncomingSSNResetRequestParameter("IN_STR_RST");
                                instrrst->setParameterType(INCOMING_RESET_REQUEST_PARAMETER);
                                instrrst->setSrReqSn(ntohl(inrr->srReqSn));    //Stream Reset Request Sequence Number
                                chunklen += SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH;
                                len = SCTP_INCOMING_RESET_REQUEST_PARAMETER_LENGTH;
                                sncounter = 0;
                                while (ntohs(inrr->length) > len) {
                                    snnumbers = (int)*(chunks + chunkPtr + size_stream_reset_chunk + parptr + SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH + sncounter * 2);
                                    instrrst->setStreamNumbersArraySize(++sncounter);
                                    instrrst->setStreamNumbers(sncounter - 1, snnumbers);
                                    chunklen += 2;
                                    len += 2;
                                }
                                chunk->addParameter(instrrst);
                                break;
                            }

                            case SSN_TSN_RESET_REQUEST_PARAMETER: {
                                const struct ssn_tsn_reset_request_parameter *ssnrr;
                                ssnrr = (struct ssn_tsn_reset_request_parameter *)(((unsigned char *)stream_reset_chunk) + size_stream_reset_chunk + parptr);
                                SCTPSSNTSNResetRequestParameter *ssnstrrst;
                                ssnstrrst = new SCTPSSNTSNResetRequestParameter("SSN_STR_RST");
                                ssnstrrst->setParameterType(SSN_TSN_RESET_REQUEST_PARAMETER);
                                ssnstrrst->setSrReqSn(ntohl(ssnrr->srReqSn));
                                chunklen += SCTP_SSN_TSN_RESET_REQUEST_PARAMETER_LENGTH;
                                chunk->addParameter(ssnstrrst);
                                break;
                            }

                            case STREAM_RESET_RESPONSE_PARAMETER: {
                                const struct stream_reset_response_parameter *resp;
                                resp = (struct stream_reset_response_parameter *)(((unsigned char *)stream_reset_chunk) + size_stream_reset_chunk + parptr);
                                SCTPStreamResetResponseParameter *strrst;
                                strrst = new SCTPStreamResetResponseParameter("STR_RST_RESPONSE");
                                strrst->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
                                strrst->setSrResSn(ntohl(resp->srResSn));
                                strrst->setResult(ntohl(resp->result));
                                int pLen = SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH;
                                if (cLen > size_stream_reset_chunk + parptr + SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH) {
                                    strrst->setSendersNextTsn(ntohl(resp->sendersNextTsn));
                                    strrst->setReceiversNextTsn(ntohl(resp->receiversNextTsn));
                                    pLen += 8;
                                }
                                strrst->setByteLength(pLen);
                                chunk->addParameter(strrst);
                                break;
                            }
                        }
                        parptr += ADD_PADDING(paramLength);
                        parcounter++;
                    }
                }
                chunk->setByteLength(cLen);
                dest->addChunk(chunk);
                break;
            }

            case PKTDROP: {
                const struct pktdrop_chunk *drop;
                drop = (struct pktdrop_chunk *)(chunks + chunkPtr);
                SCTPPacketDropChunk *dropChunk;
                dropChunk = new SCTPPacketDropChunk("PKTDROP");
                dropChunk->setChunkType(PKTDROP);
                dropChunk->setCFlag(drop->flags & C_FLAG);
                dropChunk->setTFlag(drop->flags & T_FLAG);
                dropChunk->setBFlag(drop->flags & B_FLAG);
                dropChunk->setMFlag(drop->flags & M_FLAG);
                dropChunk->setMaxRwnd(ntohl(drop->max_rwnd));
                dropChunk->setQueuedData(ntohl(drop->queued_data));
                dropChunk->setTruncLength(ntohs(drop->trunc_length));
                EV_INFO << "SCTPSerializer::pktdrop: parse SCTPMessage\n";
                SCTPMessage *msg;
                msg = new SCTPMessage();
                parse((unsigned char *)chunks + chunkPtr + 16, bufsize - size_common_header - chunkPtr - 16, msg);
                break;
            }

            default:
                //printf("TODO: Implement chunk type %d, found in chunk array on %d!\n", chunkType, ct);
                EV_ERROR << "Parser: Unknown SCTP chunk type " << chunkType;
                break;
        }    // end of switch(chunkType)
        chunkPtr += cLen;
    }    // end of while()
    EV_INFO << "SCTPSerializer - pkt info - " << dest->getByteLength() << " bytes" << endl;
}

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

Referenced by deserialize().

{
    int32 len = serialize(check_and_cast<const SCTPMessage *>(pkt), static_cast<unsigned char *>(b.accessNBytes(0)), b.getRemainingSize());
    b.accessNBytes(len);
}

int32 inet::serializer::SCTPSerializer::serialize	(	const sctp::SCTPMessage *	msg,
		uint8 *	buf,
		uint32	bufsize
	)

Serializes an SCTPMessage for transmission on the wire.

The checksum is NOT filled in. (The kernel does that when sending the frame over a raw socket.) Returns the length of data written into buffer.

Member Data Documentation

unsigned char inet::serializer::SCTPSerializer::keyVector

staticprivate

unsigned char inet::serializer::SCTPSerializer::peerKeyVector

staticprivate

unsigned char inet::serializer::SCTPSerializer::sharedKey

staticprivate

unsigned int inet::serializer::SCTPSerializer::sizeKeyVector = 0

staticprivate

unsigned int inet::serializer::SCTPSerializer::sizePeerKeyVector = 0

staticprivate

---

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

• SCTPSerializer.h
• SCTPSerializer.cc