/* Copyright (c) 2001 NETLAB, Temple University

* Copyright (c) 2001 Protocol Engineering Lab, University of Delaware

*

* Jerry Heinz <gheinz@astro.temple.edu>

* John Fiore <jfiore@joda.cis.temple.edu>

* Armando L. Caro Jr. <acaro@cis.udel.edu>

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

*

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

*

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* 3. Neither the name of the University nor of the Laboratory may be used

* to endorse or promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*/

/* \summary: Stream Control Transmission Protocol (SCTP) printer */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "netdissect-stdinc.h"

#include "netdissect.h"

#include "addrtoname.h"

#include "extract.h"

#include "ip.h"

#include "ip6.h"

/* Definitions from:

*

* SCTP reference Implementation Copyright (C) 1999 Cisco And Motorola

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

*

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

*

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* 3. Neither the name of Cisco nor of Motorola may be used

* to endorse or promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

* This file is part of the SCTP reference Implementation

*

*

* Please send any bug reports or fixes you make to one of the following email

* addresses:

*

* rstewar1@email.mot.com

* kmorneau@cisco.com

* qxie1@email.mot.com

*

* Any bugs reported given to us we will try to fix... any fixes shared will

* be incorperated into the next SCTP release.

*/

/* The valid defines for all message

* types know to SCTP. 0 is reserved

*/

#define SCTP_DATA 0x00

#define SCTP_INITIATION 0x01

#define SCTP_INITIATION_ACK 0x02

#define SCTP_SELECTIVE_ACK 0x03

#define SCTP_HEARTBEAT_REQUEST 0x04

#define SCTP_HEARTBEAT_ACK 0x05

#define SCTP_ABORT_ASSOCIATION 0x06

#define SCTP_SHUTDOWN 0x07

#define SCTP_SHUTDOWN_ACK 0x08

#define SCTP_OPERATION_ERR 0x09

#define SCTP_COOKIE_ECHO 0x0a

#define SCTP_COOKIE_ACK 0x0b

#define SCTP_ECN_ECHO 0x0c

#define SCTP_ECN_CWR 0x0d

#define SCTP_SHUTDOWN_COMPLETE 0x0e

#define SCTP_FORWARD_CUM_TSN 0xc0

#define SCTP_RELIABLE_CNTL 0xc1

#define SCTP_RELIABLE_CNTL_ACK 0xc2

static const struct tok sctp_chunkid_str[] = {

{ SCTP_DATA, "DATA" },

{ SCTP_INITIATION, "INIT" },

{ SCTP_INITIATION_ACK, "INIT ACK" },

{ SCTP_SELECTIVE_ACK, "SACK" },

{ SCTP_HEARTBEAT_REQUEST, "HB REQ" },

{ SCTP_HEARTBEAT_ACK, "HB ACK" },

{ SCTP_ABORT_ASSOCIATION, "ABORT" },

{ SCTP_SHUTDOWN, "SHUTDOWN" },

{ SCTP_SHUTDOWN_ACK, "SHUTDOWN ACK" },

{ SCTP_OPERATION_ERR, "OP ERR" },

{ SCTP_COOKIE_ECHO, "COOKIE ECHO" },

{ SCTP_COOKIE_ACK, "COOKIE ACK" },

{ SCTP_ECN_ECHO, "ECN ECHO" },

{ SCTP_ECN_CWR, "ECN CWR" },

{ SCTP_SHUTDOWN_COMPLETE, "SHUTDOWN COMPLETE" },

{ SCTP_FORWARD_CUM_TSN, "FOR CUM TSN" },

{ SCTP_RELIABLE_CNTL, "REL CTRL" },

{ SCTP_RELIABLE_CNTL_ACK, "REL CTRL ACK" },

{ 0, NULL }

};

/* Data Chuck Specific Flags */

#define SCTP_DATA_FRAG_MASK 0x03

#define SCTP_DATA_MIDDLE_FRAG 0x00

#define SCTP_DATA_LAST_FRAG 0x01

#define SCTP_DATA_FIRST_FRAG 0x02

#define SCTP_DATA_NOT_FRAG 0x03

#define SCTP_DATA_UNORDERED 0x04

#define SCTP_ADDRMAX 60

#define CHAN_HP 6704

#define CHAN_MP 6705

#define CHAN_LP 6706

/* the sctp common header */

struct sctpHeader{

};

/* various descriptor parsers */

struct sctpChunkDesc{

};

struct sctpParamDesc{

nd_uint16_t paramType;

nd_uint16_t paramLength;

};

struct sctpRelChunkDesc{

struct sctpChunkDesc chk;

nd_uint32_t serialNumber;

};

struct sctpVendorSpecificParam {

};

/* Structures for the control parts */

/* Sctp association init request/ack */

/* this is used for init ack, too */

struct sctpInitiation{

};

struct sctpV4IpAddress{

struct sctpParamDesc p; /* type is set to SCTP_IPV4_PARAM_TYPE, len=10 */

nd_ipv4 ipAddress;

};

struct sctpV6IpAddress{

struct sctpParamDesc p; /* type is set to SCTP_IPV6_PARAM_TYPE, len=22 */

nd_ipv6 ipAddress;

};

struct sctpDNSName{

struct sctpParamDesc param;

nd_byte name[1];

};

struct sctpCookiePreserve{

struct sctpParamDesc p; /* type is set to SCTP_COOKIE_PRESERVE, len=8 */

nd_uint32_t extraTime;

};

struct sctpTimeStamp{

nd_uint32_t ts_sec;

nd_uint32_t ts_usec;

};

/* this guy is for use when

* I have a initiate message gloming the

* things together.

*/

struct sctpUnifiedInit{

struct sctpChunkDesc uh;

struct sctpInitiation initm;

};

struct sctpSendableInit{

struct sctpHeader mh;

struct sctpUnifiedInit msg;

};

/* Selective Acknowledgement

* has the following structure with

* a optional ammount of trailing int's

* on the last part (based on the numberOfDesc

* field).

*/

struct sctpSelectiveAck{

};

struct sctpSelectiveFrag{

nd_uint16_t fragmentStart;

nd_uint16_t fragmentEnd;

};

struct sctpUnifiedSack{

struct sctpChunkDesc uh;

struct sctpSelectiveAck sack;

};

/* for the abort and shutdown ACK

* we must carry the init tag in the common header. Just the

* common header is all that is needed with a chunk descriptor.

*/

struct sctpUnifiedAbort{

struct sctpChunkDesc uh;

};

struct sctpUnifiedAbortLight{

struct sctpHeader mh;

struct sctpChunkDesc uh;

};

struct sctpUnifiedAbortHeavy{

};

/* For the graceful shutdown we must carry

* the tag (in common header) and the highest consequitive acking value

*/

struct sctpShutdown {

nd_uint32_t TSN_Seen;

};

struct sctpUnifiedShutdown{

struct sctpChunkDesc uh;

struct sctpShutdown shut;

};

/* in the unified message we add the trailing

* stream id since it is the only message

* that is defined as a operation error.

*/

struct sctpOpErrorCause{

nd_uint16_t cause;

nd_uint16_t causeLen;

};

struct sctpUnifiedOpError{

struct sctpChunkDesc uh;

struct sctpOpErrorCause c;

};

struct sctpUnifiedStreamError{

};

struct staleCookieMsg{

};

/* the following is used in all sends

* where nothing is needed except the

* chunk/type i.e. shutdownAck Abort */

struct sctpUnifiedSingleMsg{

struct sctpHeader mh;

struct sctpChunkDesc uh;

};

struct sctpDataPart{

};

struct sctpUnifiedDatagram{

struct sctpChunkDesc uh;

struct sctpDataPart dp;

};

struct sctpECN_echo{

struct sctpChunkDesc uh;

nd_uint32_t Lowest_TSN;

};

struct sctpCWR{

struct sctpChunkDesc uh;

nd_uint32_t TSN_reduced_at;

};

static const struct tok ForCES_channels[] = {

{ CHAN_HP, "ForCES HP" },

{ CHAN_MP, "ForCES MP" },

{ CHAN_LP, "ForCES LP" },

{ 0, NULL }

};

/* data chunk's payload protocol identifiers */

#define SCTP_PPID_IUA 1

#define SCTP_PPID_M2UA 2

#define SCTP_PPID_M3UA 3

#define SCTP_PPID_SUA 4

#define SCTP_PPID_M2PA 5

#define SCTP_PPID_V5UA 6

#define SCTP_PPID_H248 7

#define SCTP_PPID_BICC 8

#define SCTP_PPID_TALI 9

#define SCTP_PPID_DUA 10

#define SCTP_PPID_ASAP 11

#define SCTP_PPID_ENRP 12

#define SCTP_PPID_H323 13

#define SCTP_PPID_QIPC 14

#define SCTP_PPID_SIMCO 15

#define SCTP_PPID_DDPSC 16

#define SCTP_PPID_DDPSSC 17

#define SCTP_PPID_S1AP 18

#define SCTP_PPID_RUA 19

#define SCTP_PPID_HNBAP 20

#define SCTP_PPID_FORCES_HP 21

#define SCTP_PPID_FORCES_MP 22

#define SCTP_PPID_FORCES_LP 23

#define SCTP_PPID_SBC_AP 24

#define SCTP_PPID_NBAP 25

/* 26 */

#define SCTP_PPID_X2AP 27

static const struct tok PayloadProto_idents[] = {

{ SCTP_PPID_IUA, "ISDN Q.921" },

{ SCTP_PPID_M2UA, "M2UA" },

{ SCTP_PPID_M3UA, "M3UA" },

{ SCTP_PPID_SUA, "SUA" },

{ SCTP_PPID_M2PA, "M2PA" },

{ SCTP_PPID_V5UA, "V5.2" },

{ SCTP_PPID_H248, "H.248" },

{ SCTP_PPID_BICC, "BICC" },

{ SCTP_PPID_TALI, "TALI" },

{ SCTP_PPID_DUA, "DUA" },

{ SCTP_PPID_ASAP, "ASAP" },

{ SCTP_PPID_ENRP, "ENRP" },

{ SCTP_PPID_H323, "H.323" },

{ SCTP_PPID_QIPC, "Q.IPC" },

{ SCTP_PPID_SIMCO, "SIMCO" },

{ SCTP_PPID_DDPSC, "DDPSC" },

{ SCTP_PPID_DDPSSC, "DDPSSC" },

{ SCTP_PPID_S1AP, "S1AP" },

{ SCTP_PPID_RUA, "RUA" },

{ SCTP_PPID_HNBAP, "HNBAP" },

{ SCTP_PPID_FORCES_HP, "ForCES HP" },

{ SCTP_PPID_FORCES_MP, "ForCES MP" },

{ SCTP_PPID_FORCES_LP, "ForCES LP" },

{ SCTP_PPID_SBC_AP, "SBc-AP" },

{ SCTP_PPID_NBAP, "NBAP" },

/* 26 */

{ SCTP_PPID_X2AP, "X2AP" },

{ 0, NULL }

};

static int

isForCES_port(u_short Port)

{

if (Port == CHAN_HP)

return 1;

if (Port == CHAN_MP)

return 1;

if (Port == CHAN_LP)

return 1;

return 0;

}

void

sctp_print(netdissect_options *ndo,

const u_char *bp, /* beginning of sctp packet */

const u_char *bp2, /* beginning of enclosing */

u_int sctpPacketLength) /* ip packet */

{

u_int sctpPacketLengthRemaining;

const struct sctpHeader *sctpPktHdr;

const struct ip *ip;

const struct ip6_hdr *ip6;

uint8_t chunkID;

u_short sourcePort, destPort;

u_int chunkCount;

const struct sctpChunkDesc *chunkDescPtr;

const char *sep;

int isforces = 0;

ndo->ndo_protocol = "sctp";

if (sctpPacketLength < sizeof(struct sctpHeader))

{

ND_PRINT("truncated-sctp - %ld bytes missing!",

(long)(sizeof(struct sctpHeader) - sctpPacketLength));

return;

}

sctpPktHdr = (const struct sctpHeader*) bp;

ND_TCHECK_SIZE(sctpPktHdr);

sctpPacketLengthRemaining = sctpPacketLength;

sourcePort = EXTRACT_BE_U_2(sctpPktHdr->source);

destPort = EXTRACT_BE_U_2(sctpPktHdr->destination);

ip = (const struct ip *)bp2;

if (IP_V(ip) == 6)

ip6 = (const struct ip6_hdr *)bp2;

else

ip6 = NULL;

if (ip6) {

ND_PRINT("%s.%u > %s.%u: sctp",

ip6addr_string(ndo, ip6->ip6_src),

sourcePort,

ip6addr_string(ndo, ip6->ip6_dst),

destPort);

} else

{

ND_PRINT("%s.%u > %s.%u: sctp",

ipaddr_string(ndo, ip->ip_src),

sourcePort,

ipaddr_string(ndo, ip->ip_dst),

destPort);

}

if (isForCES_port(sourcePort)) {

ND_PRINT("[%s]", tok2str(ForCES_channels, NULL, sourcePort));

isforces = 1;

}

if (isForCES_port(destPort)) {

ND_PRINT("[%s]", tok2str(ForCES_channels, NULL, destPort));

isforces = 1;

}

bp += sizeof(struct sctpHeader);

sctpPacketLengthRemaining -= sizeof(struct sctpHeader);

if (ndo->ndo_vflag >= 2)

sep = "\n\t";

else

sep = " (";

/* cycle through all chunks, printing information on each one */

for (chunkCount = 0, chunkDescPtr = (const struct sctpChunkDesc *)bp;

sctpPacketLengthRemaining != 0;

chunkCount++)

{

uint16_t chunkLength, chunkLengthRemaining;

uint16_t align;

chunkDescPtr = (const struct sctpChunkDesc *)bp;

if (sctpPacketLengthRemaining < sizeof(*chunkDescPtr)) {

ND_PRINT("%s%u) [chunk descriptor cut off at end of packet]", sep, chunkCount+1);

break;

}

ND_TCHECK_SIZE(chunkDescPtr);

chunkLength = EXTRACT_BE_U_2(chunkDescPtr->chunkLength);

if (chunkLength < sizeof(*chunkDescPtr)) {

ND_PRINT("%s%u) [Bad chunk length %u, < size of chunk descriptor]", sep, chunkCount+1, chunkLength);

break;

}

chunkLengthRemaining = chunkLength;

align = chunkLength % 4;

if (align != 0)

align = 4 - align;

if (sctpPacketLengthRemaining < align) {

ND_PRINT("%s%u) [Bad chunk length %u, > remaining data in packet]", sep, chunkCount+1, chunkLength);

break;

}

ND_TCHECK_LEN(bp, chunkLength);

bp += sizeof(*chunkDescPtr);

sctpPacketLengthRemaining -= sizeof(*chunkDescPtr);

chunkLengthRemaining -= sizeof(*chunkDescPtr);

ND_PRINT("%s%u) ", sep, chunkCount+1);

chunkID = EXTRACT_U_1(chunkDescPtr->chunkID);

ND_PRINT("[%s] ", tok2str(sctp_chunkid_str, "Unknown chunk type: 0x%x",

chunkID));

switch (chunkID)

{

case SCTP_DATA :

{

const struct sctpDataPart *dataHdrPtr;

uint8_t chunkFlg;

uint32_t ppid;

u_int payload_size;

chunkFlg = EXTRACT_U_1(chunkDescPtr->chunkFlg);

if ((chunkFlg & SCTP_DATA_UNORDERED) == SCTP_DATA_UNORDERED)

ND_PRINT("(U)");

if ((chunkFlg & SCTP_DATA_FIRST_FRAG) == SCTP_DATA_FIRST_FRAG)

ND_PRINT("(B)");

if ((chunkFlg & SCTP_DATA_LAST_FRAG) == SCTP_DATA_LAST_FRAG)

ND_PRINT("(E)");

if( ((chunkFlg & SCTP_DATA_UNORDERED) == SCTP_DATA_UNORDERED) ||

((chunkFlg & SCTP_DATA_FIRST_FRAG) == SCTP_DATA_FIRST_FRAG) ||

((chunkFlg & SCTP_DATA_LAST_FRAG) == SCTP_DATA_LAST_FRAG) )

ND_PRINT(" ");

if (chunkLengthRemaining < sizeof(*dataHdrPtr)) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

dataHdrPtr=(const struct sctpDataPart*)bp;

ppid = EXTRACT_BE_U_4(dataHdrPtr->payloadtype);

ND_PRINT("[TSN: %u] ", EXTRACT_BE_U_4(dataHdrPtr->TSN));

ND_PRINT("[SID: %u] ", EXTRACT_BE_U_2(dataHdrPtr->streamId));

ND_PRINT("[SSEQ %u] ", EXTRACT_BE_U_2(dataHdrPtr->sequence));

ND_PRINT("[PPID %s] ",

tok2str(PayloadProto_idents, "0x%x", ppid));

if (!isforces) {

isforces = (ppid == SCTP_PPID_FORCES_HP) ||

(ppid == SCTP_PPID_FORCES_MP) ||

(ppid == SCTP_PPID_FORCES_LP);

}

bp += sizeof(*dataHdrPtr);

sctpPacketLengthRemaining -= sizeof(*dataHdrPtr);

chunkLengthRemaining -= sizeof(*dataHdrPtr);

payload_size = chunkLengthRemaining;

if (payload_size == 0) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

if (isforces) {

forces_print(ndo, bp, payload_size);

} else if (ndo->ndo_vflag >= 2) { /* if verbose output is specified */

/* at the command line */

switch (ppid) {

case SCTP_PPID_M3UA :

m3ua_print(ndo, bp, payload_size);

break;

default:

ND_PRINT("[Payload");

if (!ndo->ndo_suppress_default_print) {

ND_PRINT(":");

ND_DEFAULTPRINT(bp, payload_size);

}

ND_PRINT("]");

break;

}

}

bp += payload_size;

sctpPacketLengthRemaining -= payload_size;

chunkLengthRemaining -= payload_size;

break;

}

case SCTP_INITIATION :

{

const struct sctpInitiation *init;

if (chunkLengthRemaining < sizeof(*init)) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

init=(const struct sctpInitiation*)bp;

ND_PRINT("[init tag: %u] ", EXTRACT_BE_U_4(init->initTag));

ND_PRINT("[rwnd: %u] ", EXTRACT_BE_U_4(init->rcvWindowCredit));

ND_PRINT("[OS: %u] ", EXTRACT_BE_U_2(init->NumPreopenStreams));

ND_PRINT("[MIS: %u] ", EXTRACT_BE_U_2(init->MaxInboundStreams));

ND_PRINT("[init TSN: %u] ", EXTRACT_BE_U_4(init->initialTSN));

bp += sizeof(*init);

sctpPacketLengthRemaining -= sizeof(*init);

chunkLengthRemaining -= sizeof(*init);

#if 0 /* ALC you can add code for optional params here */

if( chunkLengthRemaining != 0 )

ND_PRINT(" @@@@@ UNFINISHED @@@@@@%s\n",

"Optional params present, but not printed.");

#endif

bp += chunkLengthRemaining;

sctpPacketLengthRemaining -= chunkLengthRemaining;

chunkLengthRemaining = 0;

break;

}

case SCTP_INITIATION_ACK :

{

const struct sctpInitiation *init;

if (chunkLengthRemaining < sizeof(*init)) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

init=(const struct sctpInitiation*)bp;

ND_PRINT("[init tag: %u] ", EXTRACT_BE_U_4(init->initTag));

ND_PRINT("[rwnd: %u] ", EXTRACT_BE_U_4(init->rcvWindowCredit));

ND_PRINT("[OS: %u] ", EXTRACT_BE_U_2(init->NumPreopenStreams));

ND_PRINT("[MIS: %u] ", EXTRACT_BE_U_2(init->MaxInboundStreams));

ND_PRINT("[init TSN: %u] ", EXTRACT_BE_U_4(init->initialTSN));

bp += sizeof(*init);

sctpPacketLengthRemaining -= sizeof(*init);

chunkLengthRemaining -= sizeof(*init);

#if 0 /* ALC you can add code for optional params here */

if( chunkLengthRemaining != 0 )

ND_PRINT(" @@@@@ UNFINISHED @@@@@@%s\n",

"Optional params present, but not printed.");

#endif

bp += chunkLengthRemaining;

sctpPacketLengthRemaining -= chunkLengthRemaining;

chunkLengthRemaining = 0;

break;

}

case SCTP_SELECTIVE_ACK:

{

const struct sctpSelectiveAck *sack;

const struct sctpSelectiveFrag *frag;

u_int fragNo, tsnNo;

const u_char *dupTSN;

if (chunkLengthRemaining < sizeof(*sack)) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

sack=(const struct sctpSelectiveAck*)bp;

ND_PRINT("[cum ack %u] ", EXTRACT_BE_U_4(sack->highestConseqTSN));

ND_PRINT("[a_rwnd %u] ", EXTRACT_BE_U_4(sack->updatedRwnd));

ND_PRINT("[#gap acks %u] ", EXTRACT_BE_U_2(sack->numberOfdesc));

ND_PRINT("[#dup tsns %u] ", EXTRACT_BE_U_2(sack->numDupTsns));

bp += sizeof(*sack);

sctpPacketLengthRemaining -= sizeof(*sack);

chunkLengthRemaining -= sizeof(*sack);

/* print gaps */

for (fragNo=0;

chunkLengthRemaining != 0 && fragNo < EXTRACT_BE_U_2(sack->numberOfdesc);

bp += sizeof(*frag), sctpPacketLengthRemaining -= sizeof(*frag), chunkLengthRemaining -= sizeof(*frag), fragNo++) {

if (chunkLengthRemaining < sizeof(*frag)) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

frag = (const struct sctpSelectiveFrag *)bp;

ND_PRINT("\n\t\t[gap ack block #%u: start = %u, end = %u] ",

fragNo+1,

EXTRACT_BE_U_4(sack->highestConseqTSN) + EXTRACT_BE_U_2(frag->fragmentStart),

EXTRACT_BE_U_4(sack->highestConseqTSN) + EXTRACT_BE_U_2(frag->fragmentEnd));

}

/* print duplicate TSNs */

for (tsnNo=0;

chunkLengthRemaining != 0 && tsnNo<EXTRACT_BE_U_2(sack->numDupTsns);

bp += 4, sctpPacketLengthRemaining -= 4, chunkLengthRemaining -= 4, tsnNo++) {

if (chunkLengthRemaining < 4) {

ND_PRINT("bogus chunk length %u]", chunkLength);

return;

}

dupTSN = (const u_char *)bp;

ND_PRINT("\n\t\t[dup TSN #%u: %u] ", tsnNo+1,

EXTRACT_BE_U_4(dupTSN));

}

break;

}

default :

{

bp += chunkLengthRemaining;

sctpPacketLengthRemaining -= chunkLengthRemaining;

chunkLengthRemaining = 0;

break;

}

}

/*

* Any extra stuff at the end of the chunk?

* XXX - report this?

*/

bp += chunkLengthRemaining;

sctpPacketLengthRemaining -= chunkLengthRemaining;

if (ndo->ndo_vflag < 2)

sep = ", (";

if (align != 0) {

/*

* Fail if the alignment padding isn't in the captured data.

* Otherwise, skip it.

*/

ND_TCHECK_LEN(bp, align);

bp += align;

sctpPacketLengthRemaining -= align;

}

}

return;

trunc:

ND_PRINT("[|sctp]");

}