The Tcpdump Group git mirrors - tcpdump/blobdiff

* SUCH DAMAGE.

*/

* SUCH DAMAGE.

*/

-#ifndef lint

-static const char rcsid[] _U_ =

-"@(#) $Header: /tcpdump/master/tcpdump/print-sctp.c,v 1.21 2007-09-13 18:03:49 guy Exp $ (NETLAB/PEL)";

-#endif

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

#ifdef HAVE_CONFIG_H

-#include "config.h"

+#include <config.h>

#endif

-#include <tcpdump-stdinc.h>

-

-#include <assert.h>

+#include "netdissect-stdinc.h"

-#include <stdio.h>

-#include <string.h>

-

-#include "interface.h"

+#define ND_LONGJMP_FROM_TCHECK

+#include "netdissect.h"

#include "addrtoname.h"

-#include "extract.h" /* must come after interface.h */

+#include "extract.h"

#include "ip.h"

-#ifdef INET6

#include "ip6.h"

-#endif

/* Definitions from:

*

/* Definitions from:

*

* [email protected]

*

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

* [email protected]

*

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

- * be incorperated into the next SCTP release.

+ * be incorporated into the next SCTP release.

*/

/* The valid defines for all message

*/

/* The valid defines for all message

#define SCTP_RELIABLE_CNTL 0xc1

#define SCTP_RELIABLE_CNTL_ACK 0xc2

#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

/* Data Chuck Specific Flags */

#define SCTP_DATA_FRAG_MASK 0x03

#define SCTP_DATA_MIDDLE_FRAG 0x00

/* the sctp common header */

struct sctpHeader{

/* the sctp common header */

struct sctpHeader{

- u_int16_t source;

- u_int16_t destination;

- u_int32_t verificationTag;

- u_int32_t adler32;

+ nd_uint16_t source;

+ nd_uint16_t destination;

+ nd_uint32_t verificationTag;

+ nd_uint32_t adler32;

};

/* various descriptor parsers */

struct sctpChunkDesc{

};

/* various descriptor parsers */

struct sctpChunkDesc{

- u_int8_t chunkID;

- u_int8_t chunkFlg;

- u_int16_t chunkLength;

+ nd_uint8_t chunkID;

+ nd_uint8_t chunkFlg;

+ nd_uint16_t chunkLength;

};

struct sctpParamDesc{

};

struct sctpParamDesc{

- u_int16_t paramType;

- u_int16_t paramLength;

+ nd_uint16_t paramType;

+ nd_uint16_t paramLength;

};

struct sctpRelChunkDesc{

struct sctpChunkDesc chk;

};

struct sctpRelChunkDesc{

struct sctpChunkDesc chk;

- u_int32_t serialNumber;

+ nd_uint32_t serialNumber;

};

struct sctpVendorSpecificParam {

struct sctpParamDesc p; /* type must be 0xfffe */

};

struct sctpVendorSpecificParam {

struct sctpParamDesc p; /* type must be 0xfffe */

- u_int32_t vendorId; /* vendor ID from RFC 1700 */

- u_int16_t vendorSpecificType;

- u_int16_t vendorSpecificLen;

+ nd_uint32_t vendorId; /* vendor ID from RFC 1700 */

+ nd_uint16_t vendorSpecificType;

+ nd_uint16_t vendorSpecificLen;

};

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

struct sctpInitiation{

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

struct sctpInitiation{

- u_int32_t initTag; /* tag of mine */

- u_int32_t rcvWindowCredit; /* rwnd */

- u_int16_t NumPreopenStreams; /* OS */

- u_int16_t MaxInboundStreams; /* MIS */

- u_int32_t initialTSN;

+ nd_uint32_t initTag; /* tag of mine */

+ nd_uint32_t rcvWindowCredit; /* rwnd */

+ nd_uint16_t NumPreopenStreams; /* OS */

+ nd_uint16_t MaxInboundStreams; /* MIS */

+ nd_uint32_t initialTSN;

/* optional param's follow in sctpParamDesc form */

};

struct sctpV4IpAddress{

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

/* optional param's follow in sctpParamDesc form */

};

struct sctpV4IpAddress{

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

- u_int32_t ipAddress;

+ nd_ipv4 ipAddress;

};

struct sctpV6IpAddress{

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

};

struct sctpV6IpAddress{

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

- u_int8_t ipAddress[16];

+ nd_ipv6 ipAddress;

};

struct sctpDNSName{

struct sctpParamDesc param;

};

struct sctpDNSName{

struct sctpParamDesc param;

- u_int8_t name[1];

+ nd_byte name[1];

};

struct sctpCookiePreserve{

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

};

struct sctpCookiePreserve{

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

- u_int32_t extraTime;

+ nd_uint32_t extraTime;

};

struct sctpTimeStamp{

};

struct sctpTimeStamp{

- u_int32_t ts_sec;

- u_int32_t ts_usec;

-};

-

-/* wire structure of my cookie */

-struct cookieMessage{

- u_int32_t TieTag_curTag; /* copied from assoc if present */

- u_int32_t TieTag_hisTag; /* copied from assoc if present */

- int32_t cookieLife; /* life I will award this cookie */

- struct sctpTimeStamp timeEnteringState; /* the time I built cookie */

- struct sctpInitiation initAckISent; /* the INIT-ACK that I sent to my peer */

- u_int32_t addressWhereISent[4]; /* I make this 4 ints so I get 128bits for future */

- int32_t addrtype; /* address type */

- u_int16_t locScope; /* V6 local scope flag */

- u_int16_t siteScope; /* V6 site scope flag */

- /* at the end is tacked on the INIT chunk sent in

- * its entirety and of course our

- * signature.

- */

+ nd_uint32_t ts_sec;

+ nd_uint32_t ts_usec;

};

/* Selective Acknowledgement

* has the following structure with

/* Selective Acknowledgement

* has the following structure with

- * a optional ammount of trailing int's

+ * a optional amount of trailing int's

* on the last part (based on the numberOfDesc

* field).

*/

struct sctpSelectiveAck{

* on the last part (based on the numberOfDesc

* field).

*/

struct sctpSelectiveAck{

- u_int32_t highestConseqTSN;

- u_int32_t updatedRwnd;

- u_int16_t numberOfdesc;

- u_int16_t numDupTsns;

+ nd_uint32_t highestConseqTSN;

+ nd_uint32_t updatedRwnd;

+ nd_uint16_t numberOfdesc;

+ nd_uint16_t numDupTsns;

};

struct sctpSelectiveFrag{

};

struct sctpSelectiveFrag{

- u_int16_t fragmentStart;

- u_int16_t fragmentEnd;

+ nd_uint16_t fragmentStart;

+ nd_uint16_t fragmentEnd;

};

struct sctpSelectiveAck sack;

};

struct sctpSelectiveAck sack;

};

-/* for both RTT request/response the

- * following is sent

- */

-

-struct sctpHBrequest {

- u_int32_t time_value_1;

- u_int32_t time_value_2;

-};

-

-/* here is what I read and respond with to. */

-struct sctpHBunified{

- struct sctpChunkDesc hdr;

- struct sctpParamDesc hb;

-};

-

-/* here is what I send */

-struct sctpHBsender{

- struct sctpChunkDesc hdr;

- struct sctpParamDesc hb;

- struct sctpHBrequest rtt;

- int8_t addrFmt[SCTP_ADDRMAX];

- u_int16_t userreq;

-};

-

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

/* 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 sctpUnifiedAbortHeavy{

struct sctpHeader mh;

struct sctpChunkDesc uh;

struct sctpUnifiedAbortHeavy{

struct sctpHeader mh;

struct sctpChunkDesc uh;

- u_int16_t causeCode;

- u_int16_t causeLen;

+ nd_uint16_t causeCode;

+ nd_uint16_t causeLen;

};

/* For the graceful shutdown we must carry

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

*/

struct sctpShutdown {

};

/* For the graceful shutdown we must carry

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

*/

struct sctpShutdown {

- u_int32_t TSN_Seen;

+ nd_uint32_t TSN_Seen;

};

struct sctpUnifiedShutdown{

};

struct sctpUnifiedShutdown{

* that is defined as a operation error.

*/

struct sctpOpErrorCause{

* that is defined as a operation error.

*/

struct sctpOpErrorCause{

- u_int16_t cause;

- u_int16_t causeLen;

+ nd_uint16_t cause;

+ nd_uint16_t causeLen;

};

struct sctpUnifiedOpError{

};

struct sctpUnifiedOpError{

struct sctpHeader mh;

struct sctpChunkDesc uh;

struct sctpOpErrorCause c;

struct sctpHeader mh;

struct sctpChunkDesc uh;

struct sctpOpErrorCause c;

- u_int16_t strmNum;

- u_int16_t reserved;

+ nd_uint16_t strmNum;

+ nd_uint16_t reserved;

};

struct staleCookieMsg{

struct sctpHeader mh;

struct sctpChunkDesc uh;

struct sctpOpErrorCause c;

};

struct staleCookieMsg{

struct sctpHeader mh;

struct sctpChunkDesc uh;

struct sctpOpErrorCause c;

- u_int32_t moretime;

+ nd_uint32_t moretime;

};

/* the following is used in all sends

};

/* the following is used in all sends

};

struct sctpDataPart{

};

struct sctpDataPart{

- u_int32_t TSN;

- u_int16_t streamId;

- u_int16_t sequence;

- u_int32_t payloadtype;

+ nd_uint32_t TSN;

+ nd_uint16_t streamId;

+ nd_uint16_t sequence;

+ nd_uint32_t payloadtype;

};

struct sctpUnifiedDatagram{

};

struct sctpUnifiedDatagram{

struct sctpECN_echo{

struct sctpChunkDesc uh;

struct sctpECN_echo{

struct sctpChunkDesc uh;

- u_int32_t Lowest_TSN;

+ nd_uint32_t Lowest_TSN;

};

struct sctpCWR{

struct sctpChunkDesc uh;

};

struct sctpCWR{

struct sctpChunkDesc uh;

- u_int32_t TSN_reduced_at;

+ nd_uint32_t TSN_reduced_at;

};

static const struct tok ForCES_channels[] = {

};

static const struct tok ForCES_channels[] = {

{ 0, NULL }

};

{ 0, NULL }

};

-static inline int isForCES_port(u_short Port)

+/* 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_HP)

return 1;

return 0;

}

return 0;

}

-void sctp_print(const u_char *bp, /* beginning of sctp packet */

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

- u_int sctpPacketLength) /* ip packet */

+void

+sctp_print(netdissect_options *ndo,

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

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

+ u_int sctpPacketLength) /* sctp packet */

{

+ u_int sctpPacketLengthRemaining;

const struct sctpHeader *sctpPktHdr;

const struct ip *ip;

const struct sctpHeader *sctpPktHdr;

const struct ip *ip;

-#ifdef INET6

const struct ip6_hdr *ip6;

-#endif

- const void *endPacketPtr;

+ uint8_t chunkID;

u_short sourcePort, destPort;

- int chunkCount;

+ u_int chunkCount;

const struct sctpChunkDesc *chunkDescPtr;

- const void *nextChunk;

const char *sep;

int isforces = 0;

const char *sep;

int isforces = 0;

-

+ ndo->ndo_protocol = "sctp";

+ ND_ICHECKMSG_ZU("length", sctpPacketLength, <, sizeof(struct sctpHeader));

sctpPktHdr = (const struct sctpHeader*) bp;

- endPacketPtr = (const u_char*)sctpPktHdr+sctpPacketLength;

+ ND_TCHECK_SIZE(sctpPktHdr);

+ sctpPacketLengthRemaining = sctpPacketLength;

+

+ sourcePort = GET_BE_U_2(sctpPktHdr->source);

+ destPort = GET_BE_U_2(sctpPktHdr->destination);

- if( (u_long) endPacketPtr > (u_long) snapend)

- endPacketPtr = (const void *) snapend;

- ip = (struct ip *)bp2;

-#ifdef INET6

+ ip = (const struct ip *)bp2;

if (IP_V(ip) == 6)

ip6 = (const struct ip6_hdr *)bp2;

else

ip6 = NULL;

if (IP_V(ip) == 6)

ip6 = (const struct ip6_hdr *)bp2;

else

ip6 = NULL;

-#endif /*INET6*/

- TCHECK(*sctpPktHdr);

-

- if (sctpPacketLength < sizeof(struct sctpHeader))

- {

- (void)printf("truncated-sctp - %ld bytes missing!",

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

- return;

- }

-

- /* sctpPacketLength -= sizeof(struct sctpHeader); packet length */

- /* is now only as long as the payload */

- sourcePort = EXTRACT_16BITS(&sctpPktHdr->source);

- destPort = EXTRACT_16BITS(&sctpPktHdr->destination);

-

-#ifdef INET6

if (ip6) {

- (void)printf("%s.%d > %s.%d: sctp",

- ip6addr_string(&ip6->ip6_src),

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

+ GET_IP6ADDR_STRING(ip6->ip6_src),

sourcePort,

- ip6addr_string(&ip6->ip6_dst),

+ GET_IP6ADDR_STRING(ip6->ip6_dst),

destPort);

- } else

-#endif /*INET6*/

- {

- (void)printf("%s.%d > %s.%d: sctp",

- ipaddr_string(&ip->ip_src),

+ } else {

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

+ GET_IPADDR_STRING(ip->ip_src),

sourcePort,

- ipaddr_string(&ip->ip_dst),

+ GET_IPADDR_STRING(ip->ip_dst),

destPort);

}

destPort);

}

- fflush(stdout);

if (isForCES_port(sourcePort)) {

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

- isforces = 1;

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

+ isforces = 1;

}

if (isForCES_port(destPort)) {

}

if (isForCES_port(destPort)) {

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

- isforces = 1;

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

+ isforces = 1;

}

- if (vflag >= 2)

+ 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 */

sep = "\n\t";

else

sep = " (";

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

- for (chunkCount = 0,

- chunkDescPtr = (const struct sctpChunkDesc *)

- ((const u_char*) sctpPktHdr + sizeof(struct sctpHeader));

- chunkDescPtr != NULL &&

- ( (const void *)

- ((const u_char *) chunkDescPtr + sizeof(struct sctpChunkDesc))

- <= endPacketPtr);

-

- chunkDescPtr = (const struct sctpChunkDesc *) nextChunk, chunkCount++)

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

+ sctpPacketLengthRemaining != 0;

+ chunkCount++)

{

- u_int16_t chunkLength;

- const u_char *chunkEnd;

- u_int16_t align;

+ uint16_t chunkLength, chunkLengthRemaining;

+ uint16_t align;

- TCHECK(*chunkDescPtr);

- chunkLength = EXTRACT_16BITS(&chunkDescPtr->chunkLength);

+ 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 = GET_BE_U_2(chunkDescPtr->chunkLength);

if (chunkLength < sizeof(*chunkDescPtr)) {

- printf("%s%d) [Bad chunk length %u]", sep, chunkCount+1, chunkLength);

- break;

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

+ break;

}

+ chunkLengthRemaining = chunkLength;

- TCHECK2(*((u_int8_t *)chunkDescPtr), chunkLength);

- chunkEnd = ((const u_char*)chunkDescPtr + chunkLength);

-

- align=chunkLength % 4;

+ align = chunkLength % 4;

if (align != 0)

align = 4 - align;

if (align != 0)

align = 4 - align;

- nextChunk = (const void *) (chunkEnd + 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);

- printf("%s%d) ", sep, chunkCount+1);

- switch (chunkDescPtr->chunkID)

+ bp += sizeof(*chunkDescPtr);

+ sctpPacketLengthRemaining -= sizeof(*chunkDescPtr);

+ chunkLengthRemaining -= sizeof(*chunkDescPtr);

+

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

+ chunkID = GET_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;

{

case SCTP_DATA :

{

const struct sctpDataPart *dataHdrPtr;

+ uint8_t chunkFlg;

+ uint32_t ppid;

+ uint16_t payload_size;

+

+ chunkFlg = GET_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(" ");

+

+ ND_ICHECKMSG_ZU("chunk length", chunkLengthRemaining, <,

+ sizeof(*dataHdrPtr));

+ dataHdrPtr=(const struct sctpDataPart*)bp;

+

+ ppid = GET_BE_U_4(dataHdrPtr->payloadtype);

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

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

+ ND_PRINT("[SSEQ %u] ", GET_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);

+ ND_ICHECKMSG_U("chunk length", chunkLengthRemaining, ==, 0);

+ payload_size = chunkLengthRemaining;

- printf("[DATA] ");

-

- if ((chunkDescPtr->chunkFlg & SCTP_DATA_UNORDERED)

- == SCTP_DATA_UNORDERED)

- printf("(U)");

-

- if ((chunkDescPtr->chunkFlg & SCTP_DATA_FIRST_FRAG)

- == SCTP_DATA_FIRST_FRAG)

- printf("(B)");

-

- if ((chunkDescPtr->chunkFlg & SCTP_DATA_LAST_FRAG)

- == SCTP_DATA_LAST_FRAG)

- printf("(E)");

-

- if( ((chunkDescPtr->chunkFlg & SCTP_DATA_UNORDERED)

- == SCTP_DATA_UNORDERED)

- ||

- ((chunkDescPtr->chunkFlg & SCTP_DATA_FIRST_FRAG)

- == SCTP_DATA_FIRST_FRAG)

- ||

- ((chunkDescPtr->chunkFlg & SCTP_DATA_LAST_FRAG)

- == SCTP_DATA_LAST_FRAG) )

- printf(" ");

-

- dataHdrPtr=(const struct sctpDataPart*)(chunkDescPtr+1);

-

- printf("[TSN: %u] ", EXTRACT_32BITS(&dataHdrPtr->TSN));

- printf("[SID: %u] ", EXTRACT_16BITS(&dataHdrPtr->streamId));

- printf("[SSEQ %u] ", EXTRACT_16BITS(&dataHdrPtr->sequence));

- printf("[PPID 0x%x] ", EXTRACT_32BITS(&dataHdrPtr->payloadtype));

- fflush(stdout);

if (isforces) {

- const u_char *payloadPtr;

- u_int chunksize = sizeof(struct sctpDataPart)+

- sizeof(struct sctpChunkDesc);

- payloadPtr = (const u_char *) (dataHdrPtr + 1);

- if (EXTRACT_16BITS(&chunkDescPtr->chunkLength) <

- sizeof(struct sctpDataPart)+

- sizeof(struct sctpChunkDesc)+1) {

- /* Less than 1 byte of chunk payload */

- printf("bogus ForCES chunk length %u]",

- EXTRACT_16BITS(&chunkDescPtr->chunkLength));

- return;

- }

-

- forces_print(payloadPtr, EXTRACT_16BITS(&chunkDescPtr->chunkLength)- chunksize);

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

+ forces_print(ndo, bp, payload_size);

+ /* ndo_protocol reassignment after forces_print() call */

+ ndo->ndo_protocol = "sctp";

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

/* at the command line */

- const u_char *payloadPtr;

-

- printf("[Payload");

-

- if (!suppress_default_print) {

- payloadPtr = (const u_char *) (++dataHdrPtr);

- printf(":");

- if (EXTRACT_16BITS(&chunkDescPtr->chunkLength) <

- sizeof(struct sctpDataPart)+

- sizeof(struct sctpChunkDesc)+1) {

- /* Less than 1 byte of chunk payload */

- printf("bogus chunk length %u]",

- EXTRACT_16BITS(&chunkDescPtr->chunkLength));

- return;

+ switch (ppid) {

+ case SCTP_PPID_M3UA :

+ m3ua_print(ndo, bp, payload_size);

+ /* ndo_protocol reassignment after m3ua_print() call */

+ ndo->ndo_protocol = "sctp";

+ break;

+ default:

+ ND_PRINT("[Payload");

+ if (!ndo->ndo_suppress_default_print) {

+ ND_PRINT(":");

+ ND_DEFAULTPRINT(bp, payload_size);

}

- default_print(payloadPtr,

- EXTRACT_16BITS(&chunkDescPtr->chunkLength) -

- (sizeof(struct sctpDataPart)+

- sizeof(struct sctpChunkDesc)));

- } else

- printf("]");

- }

+ ND_PRINT("]");

+ break;

+ }

+ bp += payload_size;

+ sctpPacketLengthRemaining -= payload_size;

+ chunkLengthRemaining -= payload_size;

break;

}

case SCTP_INITIATION :

{

const struct sctpInitiation *init;

break;

}

case SCTP_INITIATION :

{

const struct sctpInitiation *init;

- printf("[INIT] ");

- init=(const struct sctpInitiation*)(chunkDescPtr+1);

- printf("[init tag: %u] ", EXTRACT_32BITS(&init->initTag));

- printf("[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit));

- printf("[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams));

- printf("[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams));

- printf("[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN));

-

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

- if( (init+1) < chunkEnd )

- printf(" @@@@@ UNFINISHED @@@@@@%s\n",

+ ND_ICHECKMSG_ZU("chunk length", chunkLengthRemaining, <,

+ sizeof(*init));

+ init=(const struct sctpInitiation*)bp;

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

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

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

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

+ ND_PRINT("[init TSN: %u] ", GET_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

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

#endif

+ bp += chunkLengthRemaining;

+ sctpPacketLengthRemaining -= chunkLengthRemaining;

+ chunkLengthRemaining = 0;

break;

}

case SCTP_INITIATION_ACK :

{

const struct sctpInitiation *init;

break;

}

case SCTP_INITIATION_ACK :

{

const struct sctpInitiation *init;

- printf("[INIT ACK] ");

- init=(const struct sctpInitiation*)(chunkDescPtr+1);

- printf("[init tag: %u] ", EXTRACT_32BITS(&init->initTag));

- printf("[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit));

- printf("[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams));

- printf("[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams));

- printf("[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN));

-

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

- if( (init+1) < chunkEnd )

- printf(" @@@@@ UNFINISHED @@@@@@%s\n",

+ ND_ICHECKMSG_ZU("chunk length", chunkLengthRemaining, <,

+ sizeof(*init));

+ init=(const struct sctpInitiation*)bp;

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

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

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

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

+ ND_PRINT("[init TSN: %u] ", GET_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

"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;

break;

}

case SCTP_SELECTIVE_ACK:

{

const struct sctpSelectiveAck *sack;

const struct sctpSelectiveFrag *frag;

- int fragNo, tsnNo;

+ u_int fragNo, tsnNo;

const u_char *dupTSN;

- printf("[SACK] ");

- sack=(const struct sctpSelectiveAck*)(chunkDescPtr+1);

- printf("[cum ack %u] ", EXTRACT_32BITS(&sack->highestConseqTSN));

- printf("[a_rwnd %u] ", EXTRACT_32BITS(&sack->updatedRwnd));

- printf("[#gap acks %u] ", EXTRACT_16BITS(&sack->numberOfdesc));

- printf("[#dup tsns %u] ", EXTRACT_16BITS(&sack->numDupTsns));

+ ND_ICHECKMSG_ZU("chunk length", chunkLengthRemaining, <,

+ sizeof(*sack));

+ sack=(const struct sctpSelectiveAck*)bp;

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

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

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

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

+ bp += sizeof(*sack);

+ sctpPacketLengthRemaining -= sizeof(*sack);

+ chunkLengthRemaining -= sizeof(*sack);

/* print gaps */

- for (frag = ( (const struct sctpSelectiveFrag *)

- ((const struct sctpSelectiveAck *) sack+1)),

- fragNo=0;

- (const void *)frag < nextChunk && fragNo < EXTRACT_16BITS(&sack->numberOfdesc);

- frag++, fragNo++)

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

+ for (fragNo=0;

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

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

+ ND_ICHECKMSG_ZU("chunk length", chunkLengthRemaining, <,

+ sizeof(*frag));

+ frag = (const struct sctpSelectiveFrag *)bp;

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

fragNo+1,

- EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentStart),

- EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentEnd));

-

+ GET_BE_U_4(sack->highestConseqTSN) + GET_BE_U_2(frag->fragmentStart),

+ GET_BE_U_4(sack->highestConseqTSN) + GET_BE_U_2(frag->fragmentEnd));

+ }

/* print duplicate TSNs */

- for (dupTSN = (const u_char *)frag, tsnNo=0;

- (const void *) dupTSN < nextChunk && tsnNo<EXTRACT_16BITS(&sack->numDupTsns);

- dupTSN += 4, tsnNo++)

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

- EXTRACT_32BITS(dupTSN));

-

+ for (tsnNo=0;

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

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

+ ND_ICHECKMSG_U("chunk length", chunkLengthRemaining, <, 4);

+ dupTSN = (const u_char *)bp;

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

+ GET_BE_U_4(dupTSN));

+ }

break;

}

break;

}

- case SCTP_HEARTBEAT_REQUEST :

- printf("[HB REQ] ");

- break;

- case SCTP_HEARTBEAT_ACK :

- printf("[HB ACK] ");

- break;

- case SCTP_ABORT_ASSOCIATION :

- printf("[ABORT] ");

- break;

- case SCTP_SHUTDOWN :

- printf("[SHUTDOWN] ");

- break;

- case SCTP_SHUTDOWN_ACK :

- printf("[SHUTDOWN ACK] ");

- break;

- case SCTP_OPERATION_ERR :

- printf("[OP ERR] ");

- break;

- case SCTP_COOKIE_ECHO :

- printf("[COOKIE ECHO] ");

- break;

- case SCTP_COOKIE_ACK :

- printf("[COOKIE ACK] ");

- break;

- case SCTP_ECN_ECHO :

- printf("[ECN ECHO] ");

- break;

- case SCTP_ECN_CWR :

- printf("[ECN CWR] ");

- break;

- case SCTP_SHUTDOWN_COMPLETE :

- printf("[SHUTDOWN COMPLETE] ");

- break;

- case SCTP_FORWARD_CUM_TSN :

- printf("[FOR CUM TSN] ");

- break;

- case SCTP_RELIABLE_CNTL :

- printf("[REL CTRL] ");

- break;

- case SCTP_RELIABLE_CNTL_ACK :

- printf("[REL CTRL ACK] ");

- break;

default :

- printf("[Unknown chunk type: 0x%x]", chunkDescPtr->chunkID);

- return;

+ {

+ bp += chunkLengthRemaining;

+ sctpPacketLengthRemaining -= chunkLengthRemaining;

+ chunkLengthRemaining = 0;

+ break;

+ }

}

- if (vflag < 2)

- sep = ", (";

+ /*

+ * 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;

}

return;

-

-trunc:

- printf("[|sctp]");

- return;

+invalid:

+ nd_print_invalid(ndo);

}