X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/1c902dcdf37353a7967f69b53fe469e409eb4907..1a04b92e365f5ed01ca38619b41bcc4fc9cbd63c:/print-dccp.c diff --git a/print-dccp.c b/print-dccp.c index 24b12323..66d215fe 100644 --- a/print-dccp.c +++ b/print-dccp.c @@ -6,26 +6,159 @@ * This software may be distributed either under the terms of the * BSD-style license that accompanies tcpdump or the GNU GPL version 2 */ + +/* \summary: Datagram Congestion Control Protocol (DCCP) printer */ + #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include - -#include "dccp.h" +#include #include #include -#include "interface.h" +#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 #include "ipproto.h" +/* RFC4340: Datagram Congestion Control Protocol (DCCP) */ + +/** + * struct dccp_hdr - generic part of DCCP packet header, with a 24-bit + * sequence number + * + * @dccph_sport - Relevant port on the endpoint that sent this packet + * @dccph_dport - Relevant port on the other endpoint + * @dccph_doff - Data Offset from the start of the DCCP header, in 32-bit words + * @dccph_ccval - Used by the HC-Sender CCID + * @dccph_cscov - Parts of the packet that are covered by the Checksum field + * @dccph_checksum - Internet checksum, depends on dccph_cscov + * @dccph_x - 0 = 24 bit sequence number, 1 = 48 + * @dccph_type - packet type, see DCCP_PKT_ prefixed macros + * @dccph_seq - 24-bit sequence number + */ +struct dccp_hdr { + uint16_t dccph_sport, + dccph_dport; + uint8_t dccph_doff; + uint8_t dccph_ccval_cscov; + uint16_t dccph_checksum; + uint8_t dccph_xtr; + uint8_t dccph_seq[3]; +} UNALIGNED; + +/** + * struct dccp_hdr_ext - generic part of DCCP packet header, with a 48-bit + * sequence number + * + * @dccph_sport - Relevant port on the endpoint that sent this packet + * @dccph_dport - Relevant port on the other endpoint + * @dccph_doff - Data Offset from the start of the DCCP header, in 32-bit words + * @dccph_ccval - Used by the HC-Sender CCID + * @dccph_cscov - Parts of the packet that are covered by the Checksum field + * @dccph_checksum - Internet checksum, depends on dccph_cscov + * @dccph_x - 0 = 24 bit sequence number, 1 = 48 + * @dccph_type - packet type, see DCCP_PKT_ prefixed macros + * @dccph_seq - 48-bit sequence number + */ +struct dccp_hdr_ext { + uint16_t dccph_sport, + dccph_dport; + uint8_t dccph_doff; + uint8_t dccph_ccval_cscov; + uint16_t dccph_checksum; + uint8_t dccph_xtr; + uint8_t reserved; + uint8_t dccph_seq[6]; +} UNALIGNED; + +#define DCCPH_CCVAL(dh) (((dh)->dccph_ccval_cscov >> 4) & 0xF) +#define DCCPH_CSCOV(dh) (((dh)->dccph_ccval_cscov) & 0xF) + +#define DCCPH_X(dh) ((dh)->dccph_xtr & 1) +#define DCCPH_TYPE(dh) (((dh)->dccph_xtr >> 1) & 0xF) + +/** + * struct dccp_hdr_request - Conection initiation request header + * + * @dccph_req_service - Service to which the client app wants to connect + */ +struct dccp_hdr_request { + uint32_t dccph_req_service; +} UNALIGNED; + +/** + * struct dccp_hdr_response - Conection initiation response header + * + * @dccph_resp_ack - 48 bit ack number, contains GSR + * @dccph_resp_service - Echoes the Service Code on a received DCCP-Request + */ +struct dccp_hdr_response { + uint8_t dccph_resp_ack[8]; /* always 8 bytes */ + uint32_t dccph_resp_service; +} UNALIGNED; + +/** + * struct dccp_hdr_reset - Unconditionally shut down a connection + * + * @dccph_resp_ack - 48 bit ack number + * @dccph_reset_service - Echoes the Service Code on a received DCCP-Request + */ +struct dccp_hdr_reset { + uint8_t dccph_reset_ack[8]; /* always 8 bytes */ + uint8_t dccph_reset_code, + dccph_reset_data[3]; +} UNALIGNED; + +enum dccp_pkt_type { + DCCP_PKT_REQUEST = 0, + DCCP_PKT_RESPONSE, + DCCP_PKT_DATA, + DCCP_PKT_ACK, + DCCP_PKT_DATAACK, + DCCP_PKT_CLOSEREQ, + DCCP_PKT_CLOSE, + DCCP_PKT_RESET, + DCCP_PKT_SYNC, + DCCP_PKT_SYNCACK +}; + +static const struct tok dccp_pkt_type_str[] = { + { DCCP_PKT_REQUEST, "DCCP-Request" }, + { DCCP_PKT_RESPONSE, "DCCP-Response" }, + { DCCP_PKT_DATA, "DCCP-Data" }, + { DCCP_PKT_ACK, "DCCP-Ack" }, + { DCCP_PKT_DATAACK, "DCCP-DataAck" }, + { DCCP_PKT_CLOSEREQ, "DCCP-CloseReq" }, + { DCCP_PKT_CLOSE, "DCCP-Close" }, + { DCCP_PKT_RESET, "DCCP-Reset" }, + { DCCP_PKT_SYNC, "DCCP-Sync" }, + { DCCP_PKT_SYNCACK, "DCCP-SyncAck" }, + { 0, NULL} +}; + +enum dccp_reset_codes { + DCCP_RESET_CODE_UNSPECIFIED = 0, + DCCP_RESET_CODE_CLOSED, + DCCP_RESET_CODE_ABORTED, + DCCP_RESET_CODE_NO_CONNECTION, + DCCP_RESET_CODE_PACKET_ERROR, + DCCP_RESET_CODE_OPTION_ERROR, + DCCP_RESET_CODE_MANDATORY_ERROR, + DCCP_RESET_CODE_CONNECTION_REFUSED, + DCCP_RESET_CODE_BAD_SERVICE_CODE, + DCCP_RESET_CODE_TOO_BUSY, + DCCP_RESET_CODE_BAD_INIT_COOKIE, + DCCP_RESET_CODE_AGGRESSION_PENALTY, + __DCCP_RESET_CODE_LAST +}; + +static const char tstr[] = "[|dccp]"; + static const char *dccp_reset_codes[] = { "unspecified", "closed", @@ -42,479 +175,486 @@ static const char *dccp_reset_codes[] = { }; static const char *dccp_feature_nums[] = { - "reserved", + "reserved", "ccid", "allow_short_seqno", "sequence_window", - "ecn_incapable", - "ack_ratio", + "ecn_incapable", + "ack_ratio", "send_ack_vector", - "send_ndp_count", - "minimum checksum coverage", + "send_ndp_count", + "minimum checksum coverage", "check data checksum", }; -static int dccp_cksum(const struct ip *ip, - const struct dccp_hdr *dh, u_int len) +static inline u_int dccp_csum_coverage(const struct dccp_hdr* dh, u_int len) { - union phu { - struct phdr { - u_int32_t src; - u_int32_t dst; - u_char mbz; - u_char proto; - u_int16_t len; - } ph; - u_int16_t pa[6]; - } phu; - const u_int16_t *sp; - - /* pseudo-header.. */ - phu.ph.mbz = 0; - phu.ph.len = htons(len); - phu.ph.proto = IPPROTO_DCCP; - memcpy(&phu.ph.src, &ip->ip_src.s_addr, sizeof(u_int32_t)); - if (IP_HL(ip) == 5) - memcpy(&phu.ph.dst, &ip->ip_dst.s_addr, sizeof(u_int32_t)); - else - phu.ph.dst = ip_finddst(ip); + u_int cov; - sp = &phu.pa[0]; - return in_cksum((u_short *)dh, len, sp[0]+sp[1]+sp[2]+sp[3]+sp[4]+sp[5]); + if (DCCPH_CSCOV(dh) == 0) + return len; + cov = (dh->dccph_doff + DCCPH_CSCOV(dh) - 1) * sizeof(uint32_t); + return (cov > len)? len : cov; } -#ifdef INET6 -static int dccp6_cksum(const struct ip6_hdr *ip6, const struct dccp_hdr *dh, u_int len) +static int dccp_cksum(netdissect_options *ndo, const struct ip *ip, + const struct dccp_hdr *dh, u_int len) { - size_t i; - const u_int16_t *sp; - u_int32_t sum; - union { - struct { - struct in6_addr ph_src; - struct in6_addr ph_dst; - u_int32_t ph_len; - u_int8_t ph_zero[3]; - u_int8_t ph_nxt; - } ph; - u_int16_t pa[20]; - } phu; - - /* pseudo-header */ - memset(&phu, 0, sizeof(phu)); - phu.ph.ph_src = ip6->ip6_src; - phu.ph.ph_dst = ip6->ip6_dst; - phu.ph.ph_len = htonl(len); - phu.ph.ph_nxt = IPPROTO_DCCP; - - sum = 0; - for (i = 0; i < sizeof(phu.pa) / sizeof(phu.pa[0]); i++) - sum += phu.pa[i]; - - sp = (const u_int16_t *)dh; - - for (i = 0; i < (len & ~1); i += 2) - sum += *sp++; - - if (len & 1) - sum += htons((*(const u_int8_t *)sp) << 8); - - while (sum > 0xffff) - sum = (sum & 0xffff) + (sum >> 16); - sum = ~sum & 0xffff; - - return (sum); + return nextproto4_cksum(ndo, ip, (const uint8_t *)(const void *)dh, len, + dccp_csum_coverage(dh, len), IPPROTO_DCCP); } -#endif -static const char *dccp_reset_code(u_int8_t code) +static int dccp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6, + const struct dccp_hdr *dh, u_int len) +{ + return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)dh, len, + dccp_csum_coverage(dh, len), IPPROTO_DCCP); +} + +static const char *dccp_reset_code(uint8_t code) { if (code >= __DCCP_RESET_CODE_LAST) return "invalid"; return dccp_reset_codes[code]; } -static u_int64_t dccp_seqno(const struct dccp_hdr *dh) +static uint64_t dccp_seqno(const u_char *bp) { - u_int32_t seq_high = DCCPH_SEQ(dh); - u_int64_t seqno = EXTRACT_24BITS(&seq_high) & 0xFFFFFF; + const struct dccp_hdr *dh = (const struct dccp_hdr *)bp; + uint64_t seqno; if (DCCPH_X(dh) != 0) { - const struct dccp_hdr_ext *dhx = (void *)dh + sizeof(*dh); - u_int32_t seq_low = dhx->dccph_seq_low; - seqno &= 0x00FFFF; /* clear reserved field */ - seqno = (seqno << 32) + EXTRACT_32BITS(&seq_low); + const struct dccp_hdr_ext *dhx = (const struct dccp_hdr_ext *)bp; + seqno = EXTRACT_BE_U_6(dhx->dccph_seq); + } else { + seqno = EXTRACT_BE_U_3(dh->dccph_seq); } return seqno; } -static u_int64_t dccp_ack_no(const struct dccp_hdr *dh, - const struct dccp_hdr_ack_bits *dh_ack) -{ - u_int32_t ack_high = DCCPH_ACK(dh_ack); - u_int64_t ackno = EXTRACT_24BITS(&ack_high) & 0xFFFFFF; - - if (DCCPH_X(dh) != 0) { - u_int32_t ack_low = dh_ack->dccph_ack_nr_low; - - ackno &= 0x00FFFF; /* clear reserved field */ - ackno = (ackno << 32) + EXTRACT_32BITS(&ack_low); - } - - return ackno; -} - static inline unsigned int dccp_basic_hdr_len(const struct dccp_hdr *dh) { - return sizeof(*dh) + (DCCPH_X(dh) ? sizeof(struct dccp_hdr_ext) : 0); + return DCCPH_X(dh) ? sizeof(struct dccp_hdr_ext) : sizeof(struct dccp_hdr); } -static inline unsigned int dccp_packet_hdr_len(const u_int8_t type) +static void dccp_print_ack_no(netdissect_options *ndo, const u_char *bp) { - if (type == DCCP_PKT_DATA) - return 0; - if (type == DCCP_PKT_DATAACK || - type == DCCP_PKT_ACK || - type == DCCP_PKT_SYNC || - type == DCCP_PKT_SYNCACK || - type == DCCP_PKT_CLOSE || - type == DCCP_PKT_CLOSEREQ) - return sizeof(struct dccp_hdr_ack_bits); - if (type == DCCP_PKT_REQUEST) - return sizeof(struct dccp_hdr_request); - if (type == DCCP_PKT_RESPONSE) - return sizeof(struct dccp_hdr_response); - return sizeof(struct dccp_hdr_reset); + const struct dccp_hdr *dh = (const struct dccp_hdr *)bp; + const u_char *ackp = bp + dccp_basic_hdr_len(dh); + uint64_t ackno; + + if (DCCPH_X(dh) != 0) { + ND_TCHECK_8(ackp); + ackno = EXTRACT_BE_U_6(ackp + 2); + } else { + ND_TCHECK_4(ackp); + ackno = EXTRACT_BE_U_3(ackp + 1); + } + + ND_PRINT((ndo, "(ack=%" PRIu64 ") ", ackno)); +trunc: + return; } -static int dccp_print_option(const u_char *option); +static int dccp_print_option(netdissect_options *, const u_char *, u_int); /** * dccp_print - show dccp packet * @bp - beginning of dccp packet - * @data2 - beginning of enclosing + * @data2 - beginning of enclosing * @len - lenght of ip packet */ -void dccp_print(const u_char *bp, const u_char *data2, u_int len) +void +dccp_print(netdissect_options *ndo, const u_char *bp, const u_char *data2, + u_int len) { const struct dccp_hdr *dh; const struct ip *ip; -#ifdef INET6 const struct ip6_hdr *ip6; -#endif const u_char *cp; u_short sport, dport; u_int hlen; - u_int extlen = 0; + u_int fixed_hdrlen; + uint8_t dccph_type; dh = (const struct dccp_hdr *)bp; - ip = (struct ip *)data2; -#ifdef INET6 + ip = (const struct ip *)data2; if (IP_V(ip) == 6) ip6 = (const struct ip6_hdr *)data2; else ip6 = NULL; -#endif /*INET6*/ + + /* make sure we have enough data to look at the X bit */ cp = (const u_char *)(dh + 1); - if (cp > snapend) { - printf("[Invalid packet|dccp]"); + if (cp > ndo->ndo_snapend) { + ND_PRINT((ndo, "[Invalid packet|dccp]")); return; } - if (len < sizeof(struct dccp_hdr)) { - printf("truncated-dccp - %ld bytes missing!", - (long)len - sizeof(struct dccp_hdr)); + ND_PRINT((ndo, "truncated-dccp - %u bytes missing!", + len - (u_int)sizeof(struct dccp_hdr))); + return; + } + + /* get the length of the generic header */ + fixed_hdrlen = dccp_basic_hdr_len(dh); + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-dccp - %u bytes missing!", + len - fixed_hdrlen)); return; } + ND_TCHECK_LEN(dh, fixed_hdrlen); - sport = EXTRACT_16BITS(&dh->dccph_sport); - dport = EXTRACT_16BITS(&dh->dccph_dport); + sport = EXTRACT_BE_U_2(&dh->dccph_sport); + dport = EXTRACT_BE_U_2(&dh->dccph_dport); hlen = dh->dccph_doff * 4; -#ifdef INET6 if (ip6) { - (void)printf("%s.%d > %s.%d: ", - ip6addr_string(&ip6->ip6_src), sport, - ip6addr_string(&ip6->ip6_dst), dport); - } else -#endif /*INET6*/ - { - (void)printf("%s.%d > %s.%d: ", - ipaddr_string(&ip->ip_src), sport, - ipaddr_string(&ip->ip_dst), dport); + ND_PRINT((ndo, "%s.%d > %s.%d: ", + ip6addr_string(ndo, &ip6->ip6_src), sport, + ip6addr_string(ndo, &ip6->ip6_dst), dport)); + } else { + ND_PRINT((ndo, "%s.%d > %s.%d: ", + ipaddr_string(ndo, &ip->ip_src), sport, + ipaddr_string(ndo, &ip->ip_dst), dport)); } - fflush(stdout); - if (qflag) { - (void)printf(" %d", len - hlen); + ND_PRINT((ndo, "DCCP")); + + if (ndo->ndo_qflag) { + ND_PRINT((ndo, " %d", len - hlen)); if (hlen > len) { - (void)printf("dccp [bad hdr length %u - too long, > %u]", - hlen, len); + ND_PRINT((ndo, " [bad hdr length %u - too long, > %u]", + hlen, len)); } return; } /* other variables in generic header */ - if (vflag) { - (void)printf("CCVal %d, CsCov %d, ", DCCPH_CCVAL(dh), DCCPH_CSCOV(dh)); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, " (CCVal %d, CsCov %d, ", DCCPH_CCVAL(dh), DCCPH_CSCOV(dh))); } /* checksum calculation */ -#ifdef INET6 - if (ip6) { - if (ip6->ip6_plen && vflag) { - u_int16_t sum, dccp_sum; - - sum = dccp6_cksum(ip6, dh, len); - dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum); - printf("cksum 0x%04x", dccp_sum); - if (sum != 0) { - (void)printf(" (incorrect (-> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum)); - } else - (void)printf(" (correct), "); - } - } else -#endif /* INET6 */ - if (vflag) - { - u_int16_t sum, dccp_sum; - - sum = dccp_cksum(ip, dh, len); - dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum); - printf("cksum 0x%04x", dccp_sum); - if (sum != 0) { - (void)printf(" (incorrect (-> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum)); - } else - (void)printf(" (correct), "); + if (ndo->ndo_vflag && ND_TTEST_LEN(bp, len)) { + uint16_t sum = 0, dccp_sum; + + dccp_sum = EXTRACT_BE_U_2(&dh->dccph_checksum); + ND_PRINT((ndo, "cksum 0x%04x ", dccp_sum)); + if (IP_V(ip) == 4) + sum = dccp_cksum(ndo, ip, dh, len); + else if (IP_V(ip) == 6) + sum = dccp6_cksum(ndo, ip6, dh, len); + if (sum != 0) + ND_PRINT((ndo, "(incorrect -> 0x%04x)",in_cksum_shouldbe(dccp_sum, sum))); + else + ND_PRINT((ndo, "(correct)")); } - switch (DCCPH_TYPE(dh)) { + if (ndo->ndo_vflag) + ND_PRINT((ndo, ")")); + ND_PRINT((ndo, " ")); + + dccph_type = DCCPH_TYPE(dh); + switch (dccph_type) { case DCCP_PKT_REQUEST: { - struct dccp_hdr_request *dhr = - (struct dccp_hdr_request *)(bp + dccp_basic_hdr_len(dh)); - TCHECK(*dhr); - (void)printf("request (service=%d) ", dhr->dccph_req_service); - extlen += 4; + const struct dccp_hdr_request *dhr = + (const struct dccp_hdr_request *)(bp + fixed_hdrlen); + fixed_hdrlen += 4; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_TCHECK(*dhr); + ND_PRINT((ndo, "%s (service=%d) ", + tok2str(dccp_pkt_type_str, "", dccph_type), + EXTRACT_BE_U_4(&dhr->dccph_req_service))); break; } case DCCP_PKT_RESPONSE: { - struct dccp_hdr_response *dhr = - (struct dccp_hdr_response *)(bp + dccp_basic_hdr_len(dh)); - TCHECK(*dhr); - (void)printf("response (service=%d, ack=%" PRIu64 ") ", - dhr->dccph_resp_service, - dccp_ack_no(dh,&(dhr->dccph_resp_ack))); - extlen += 12; + const struct dccp_hdr_response *dhr = + (const struct dccp_hdr_response *)(bp + fixed_hdrlen); + fixed_hdrlen += 12; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_TCHECK(*dhr); + ND_PRINT((ndo, "%s (service=%d) ", + tok2str(dccp_pkt_type_str, "", dccph_type), + EXTRACT_BE_U_4(&dhr->dccph_resp_service))); break; } case DCCP_PKT_DATA: - (void)printf("data "); + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; case DCCP_PKT_ACK: { - struct dccp_hdr_ack_bits *dha = - (struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh)); - TCHECK(*dha); - (void)printf("ack (ack=%" PRIu64 ") ", - dccp_ack_no(dh,dha)); - extlen += 8; + fixed_hdrlen += 8; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; } case DCCP_PKT_DATAACK: { - struct dccp_hdr_ack_bits *dha = - (struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh)); - TCHECK(*dha); - (void)printf("dataack (ack=%" PRIu64 ") ", - dccp_ack_no(dh,dha)); - extlen += 8; + fixed_hdrlen += 8; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; } case DCCP_PKT_CLOSEREQ: - (void)printf("closereq "); - extlen += 8; + fixed_hdrlen += 8; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; case DCCP_PKT_CLOSE: - (void)printf("close "); - extlen += 8; + fixed_hdrlen += 8; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; case DCCP_PKT_RESET: { - struct dccp_hdr_reset *dhr = - (struct dccp_hdr_reset *)(bp + dccp_basic_hdr_len(dh)); - TCHECK(*dhr); - (void)printf("reset (code=%s) ", - dccp_reset_code(dhr->dccph_reset_code)); - extlen += 12; + const struct dccp_hdr_reset *dhr = + (const struct dccp_hdr_reset *)(bp + fixed_hdrlen); + fixed_hdrlen += 12; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_TCHECK(*dhr); + ND_PRINT((ndo, "%s (code=%s) ", + tok2str(dccp_pkt_type_str, "", dccph_type), + dccp_reset_code(dhr->dccph_reset_code))); break; } case DCCP_PKT_SYNC: - (void)printf("sync "); - extlen += 8; + fixed_hdrlen += 8; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; case DCCP_PKT_SYNCACK: - (void)printf("syncack "); - extlen += 8; + fixed_hdrlen += 8; + if (len < fixed_hdrlen) { + ND_PRINT((ndo, "truncated-%s - %u bytes missing!", + tok2str(dccp_pkt_type_str, "", dccph_type), + len - fixed_hdrlen)); + return; + } + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "", dccph_type))); break; default: - (void)printf("invalid "); + ND_PRINT((ndo, "%s ", tok2str(dccp_pkt_type_str, "unknown-type-%u", dccph_type))); break; } - if (vflag < 2) + if ((DCCPH_TYPE(dh) != DCCP_PKT_DATA) && + (DCCPH_TYPE(dh) != DCCP_PKT_REQUEST)) + dccp_print_ack_no(ndo, bp); + + if (ndo->ndo_vflag < 2) return; - (void)printf("seq %" PRIu64, dccp_seqno(dh)); + ND_PRINT((ndo, "seq %" PRIu64, dccp_seqno(bp))); /* process options */ - if (hlen > dccp_basic_hdr_len(dh) + extlen){ - const u_char *cp; + if (hlen > fixed_hdrlen){ u_int optlen; - cp = bp + dccp_basic_hdr_len(dh) + extlen; - printf(" <"); + cp = bp + fixed_hdrlen; + ND_PRINT((ndo, " <")); - hlen -= dccp_basic_hdr_len(dh) + extlen; + hlen -= fixed_hdrlen; while(1){ - TCHECK(*cp); - optlen = dccp_print_option(cp); - if (!optlen) goto trunc2; - if (hlen <= optlen) break; + optlen = dccp_print_option(ndo, cp, hlen); + if (!optlen) + break; + if (hlen <= optlen) + break; hlen -= optlen; cp += optlen; - printf(", "); + ND_PRINT((ndo, ", ")); } - printf(">"); + ND_PRINT((ndo, ">")); } return; trunc: - printf("[|dccp]"); -trunc2: + ND_PRINT((ndo, "%s", tstr)); return; } -static int dccp_print_option(const u_char *option) -{ - u_int8_t optlen, i; - u_int32_t *ts; - u_int16_t *var16; - u_int32_t *var32; +static const struct tok dccp_option_values[] = { + { 0, "nop" }, + { 1, "mandatory" }, + { 2, "slowreceiver" }, + { 32, "change_l" }, + { 33, "confirm_l" }, + { 34, "change_r" }, + { 35, "confirm_r" }, + { 36, "initcookie" }, + { 37, "ndp_count" }, + { 38, "ack_vector0" }, + { 39, "ack_vector1" }, + { 40, "data_dropped" }, + { 41, "timestamp" }, + { 42, "timestamp_echo" }, + { 43, "elapsed_time" }, + { 44, "data_checksum" }, + { 0, NULL } +}; + +static int dccp_print_option(netdissect_options *ndo, const u_char *option, u_int hlen) +{ + uint8_t optlen, i; - TCHECK(*option); + ND_TCHECK_1(option); - if (*option >= 32) { - TCHECK(*(option+1)); - optlen = *(option +1); + if (EXTRACT_U_1(option) >= 32) { + ND_TCHECK_1(option + 1); + optlen = EXTRACT_U_1(option + 1); if (optlen < 2) { - printf("Option %d optlen too short",*option); - return 1; + if (EXTRACT_U_1(option) >= 128) + ND_PRINT((ndo, "CCID option %u optlen too short", EXTRACT_U_1(option))); + else + ND_PRINT((ndo, "%s optlen too short", + tok2str(dccp_option_values, "Option %u", EXTRACT_U_1(option)))); + return 0; } - } else optlen = 1; - - TCHECK2(*option,optlen); - - switch (*option){ - case 0: - printf("nop"); - break; - case 1: - printf("mandatory"); - break; - case 2: - printf("slowreceiver"); - break; - case 32: - printf("change_l"); - if (*(option +2) < 10){ - printf(" %s", dccp_feature_nums[*(option +2)]); - for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i)); - } - break; - case 33: - printf("confirm_l"); - if (*(option +2) < 10){ - printf(" %s", dccp_feature_nums[*(option +2)]); - for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i)); - } - break; - case 34: - printf("change_r"); - if (*(option +2) < 10){ - printf(" %s", dccp_feature_nums[*(option +2)]); - for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i)); - } - break; - case 35: - printf("confirm_r"); - if (*(option +2) < 10){ - printf(" %s", dccp_feature_nums[*(option +2)]); - for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i)); + } else + optlen = 1; + + if (hlen < optlen) { + if (EXTRACT_U_1(option) >= 128) + ND_PRINT((ndo, "CCID option %u optlen goes past header length", + EXTRACT_U_1(option))); + else + ND_PRINT((ndo, "%s optlen goes past header length", + tok2str(dccp_option_values, "Option %u", EXTRACT_U_1(option)))); + return 0; + } + ND_TCHECK_LEN(option, optlen); + + if (EXTRACT_U_1(option) >= 128) { + ND_PRINT((ndo, "CCID option %d", EXTRACT_U_1(option))); + switch (optlen) { + case 4: + ND_PRINT((ndo, " %u", EXTRACT_BE_U_2(option + 2))); + break; + case 6: + ND_PRINT((ndo, " %u", EXTRACT_BE_U_4(option + 2))); + break; + default: + break; } - break; - case 36: - printf("initcookie 0x"); - for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); - break; - case 37: - printf("ndp_count"); - for (i = 0; i < optlen -2; i ++) printf(" %d", *(option +2 + i)); - break; - case 38: - printf("ack_vector0 0x"); - for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); - break; - case 39: - printf("ack_vector1 0x"); - for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); - break; - case 40: - printf("data_dropped 0x"); - for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); - break; - case 41: - ts = (u_int32_t *)(option + 2); - printf("timestamp %u", (u_int32_t)ntohl(*ts)); - break; - case 42: - ts = (u_int32_t *)(option + 2); - printf("timestamp_echo %u", (u_int32_t)ntohl(*ts)); - break; - case 43: - printf("elapsed_time "); - if (optlen == 6){ - ts = (u_int32_t *)(option + 2); - printf("%u", (u_int32_t)ntohl(*ts)); - } else { - var16 = (u_int16_t *)(option + 2); - printf("%u", ntohs(*var16)); - } - break; - case 44: - printf("data_checksum "); - for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); - break; - default : - if (*option >= 128) { - printf("CCID option %d",*option); - switch (optlen) { - case 4: - var16 = (u_int16_t *)(option + 2); - printf(" %u",ntohs(*var16)); - break; - case 6: - var32 = (u_int32_t *)(option + 2); - printf(" %u",(u_int32_t)ntohl(*var32)); - break; - default: - break; + } else { + ND_PRINT((ndo, "%s", tok2str(dccp_option_values, "Option %u", EXTRACT_U_1(option)))); + switch (EXTRACT_U_1(option)) { + case 32: + case 33: + case 34: + case 35: + if (optlen < 3) { + ND_PRINT((ndo, " optlen too short")); + return optlen; + } + if (EXTRACT_U_1(option + 2) < 10){ + ND_PRINT((ndo, " %s", dccp_feature_nums[EXTRACT_U_1(option + 2)])); + for (i = 0; i < optlen - 3; i++) + ND_PRINT((ndo, " %d", EXTRACT_U_1(option + 3 + i))); + } + break; + case 36: + if (optlen > 2) { + ND_PRINT((ndo, " 0x")); + for (i = 0; i < optlen - 2; i++) + ND_PRINT((ndo, "%02x", EXTRACT_U_1(option + 2 + i))); + } + break; + case 37: + for (i = 0; i < optlen - 2; i++) + ND_PRINT((ndo, " %d", EXTRACT_U_1(option + 2 + i))); + break; + case 38: + if (optlen > 2) { + ND_PRINT((ndo, " 0x")); + for (i = 0; i < optlen - 2; i++) + ND_PRINT((ndo, "%02x", EXTRACT_U_1(option + 2 + i))); + } + break; + case 39: + if (optlen > 2) { + ND_PRINT((ndo, " 0x")); + for (i = 0; i < optlen - 2; i++) + ND_PRINT((ndo, "%02x", EXTRACT_U_1(option + 2 + i))); + } + break; + case 40: + if (optlen > 2) { + ND_PRINT((ndo, " 0x")); + for (i = 0; i < optlen - 2; i++) + ND_PRINT((ndo, "%02x", EXTRACT_U_1(option + 2 + i))); + } + break; + case 41: + if (optlen == 4) + ND_PRINT((ndo, " %u", EXTRACT_BE_U_4(option + 2))); + else + ND_PRINT((ndo, " optlen != 4")); + break; + case 42: + if (optlen == 4) + ND_PRINT((ndo, " %u", EXTRACT_BE_U_4(option + 2))); + else + ND_PRINT((ndo, " optlen != 4")); + break; + case 43: + if (optlen == 6) + ND_PRINT((ndo, " %u", EXTRACT_BE_U_4(option + 2))); + else if (optlen == 4) + ND_PRINT((ndo, " %u", EXTRACT_BE_U_2(option + 2))); + else + ND_PRINT((ndo, " optlen != 4 or 6")); + break; + case 44: + if (optlen > 2) { + ND_PRINT((ndo, " ")); + for (i = 0; i < optlen - 2; i++) + ND_PRINT((ndo, "%02x", EXTRACT_U_1(option + 2 + i))); } break; } - - printf("unknown_opt %d", *option); - break; } return optlen; trunc: - printf("[|dccp]"); + ND_PRINT((ndo, "%s", tstr)); return 0; }