1 files changed, 466 insertions, 0 deletions

diff --git a/freebsd/contrib/tcpdump/print-dccp.c b/freebsd/contrib/tcpdump/print-dccp.c
new file mode 100644
index 00000000..59417c58
--- /dev/null
+++ b/freebsd/contrib/tcpdump/print-dccp.c
@@ -0,0 +1,466 @@
+#include <machine/rtems-bsd-user-space.h>
+
+/*
+ * Copyright (C) Arnaldo Carvalho de Melo 2004
+ * Copyright (C) Ian McDonald 2005
+ * Copyright (C) Yoshifumi Nishida 2005
+ *
+ * This software may be distributed either under the terms of the
+ * BSD-style license that accompanies tcpdump or the GNU GPL version 2
+ */
+
+#ifndef lint
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-dccp.c,v 1.8 2007-11-09 00:44:09 guy Exp $ (LBL)";
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <tcpdump-stdinc.h>
+
+#include "dccp.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "interface.h"
+#include "addrtoname.h"
+#include "extract.h"			/* must come after interface.h */
+#include "ip.h"
+#ifdef INET6
+#include "ip6.h"
+#endif
+#include "ipproto.h"
+
+static const char *dccp_reset_codes[] = {
+	"unspecified",
+	"closed",
+	"aborted",
+	"no_connection",
+	"packet_error",
+	"option_error",
+	"mandatory_error",
+	"connection_refused",
+	"bad_service_code",
+	"too_busy",
+	"bad_init_cookie",
+	"aggression_penalty",
+};
+
+static const char *dccp_feature_nums[] = {
+	"reserved", 
+	"ccid",
+	"allow_short_seqno",
+	"sequence_window",
+	"ecn_incapable", 
+	"ack_ratio",     
+	"send_ack_vector",
+	"send_ndp_count", 
+	"minimum checksum coverage", 
+	"check data checksum",
+};
+
+static inline u_int dccp_csum_coverage(const struct dccp_hdr* dh, u_int len)
+{
+	u_int cov;
+	
+	if (DCCPH_CSCOV(dh) == 0)
+		return len;
+	cov = (dh->dccph_doff + DCCPH_CSCOV(dh) - 1) * sizeof(u_int32_t);
+	return (cov > len)? len : cov;
+}
+
+static int dccp_cksum(const struct ip *ip,
+	const struct dccp_hdr *dh, u_int len)
+{
+	return nextproto4_cksum(ip, (const u_int8_t *)(void *)dh,
+	    dccp_csum_coverage(dh, len), IPPROTO_DCCP);
+}
+
+#ifdef INET6
+static int dccp6_cksum(const struct ip6_hdr *ip6, const struct dccp_hdr *dh, u_int len)
+{
+	return nextproto6_cksum(ip6, (const u_int8_t *)(void *)dh,
+	    dccp_csum_coverage(dh, len), IPPROTO_DCCP);
+}
+#endif
+
+static const char *dccp_reset_code(u_int8_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)
+{
+	u_int32_t seq_high = DCCPH_SEQ(dh);
+	u_int64_t seqno = EXTRACT_24BITS(&seq_high) & 0xFFFFFF;
+
+	if (DCCPH_X(dh) != 0) {
+		const struct dccp_hdr_ext *dhx = (void *)(dh + 1);
+		u_int32_t seq_low = dhx->dccph_seq_low;
+		seqno &= 0x00FFFF;  /* clear reserved field */
+		seqno = (seqno << 32) + EXTRACT_32BITS(&seq_low);
+	}
+
+	return seqno;
+}
+
+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);
+}
+
+static void dccp_print_ack_no(const u_char *bp)
+{
+	const struct dccp_hdr *dh = (const struct dccp_hdr *)bp;
+	const struct dccp_hdr_ack_bits *dh_ack =
+		(struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh));
+	u_int32_t ack_high;
+	u_int64_t ackno;
+
+	TCHECK2(*dh_ack,4);
+	ack_high = DCCPH_ACK(dh_ack);
+	ackno = EXTRACT_24BITS(&ack_high) & 0xFFFFFF;
+
+	if (DCCPH_X(dh) != 0) {
+		u_int32_t ack_low;
+
+		TCHECK2(*dh_ack,8);
+		ack_low = dh_ack->dccph_ack_nr_low;
+
+		ackno &= 0x00FFFF;  /* clear reserved field */
+		ackno = (ackno << 32) + EXTRACT_32BITS(&ack_low);
+	}
+
+	(void)printf("(ack=%" PRIu64 ") ", ackno);
+trunc:
+	return;
+}
+
+static inline unsigned int dccp_packet_hdr_len(const u_int8_t type)
+{
+	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);
+}
+
+static int dccp_print_option(const u_char *option);
+
+/**
+ * dccp_print - show dccp packet
+ * @bp - beginning of dccp packet
+ * @data2 - beginning of enclosing 
+ * @len - lenght of ip packet
+ */
+void dccp_print(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;
+
+	dh = (const struct dccp_hdr *)bp;
+
+	ip = (struct ip *)data2;
+#ifdef INET6
+	if (IP_V(ip) == 6)
+		ip6 = (const struct ip6_hdr *)data2;
+	else
+		ip6 = NULL;
+#endif /*INET6*/
+	cp = (const u_char *)(dh + 1);
+	if (cp > snapend) {
+		printf("[Invalid packet|dccp]");
+		return;
+	}
+
+	if (len < sizeof(struct dccp_hdr)) {
+		printf("truncated-dccp - %ld bytes missing!",
+			     (long)len - sizeof(struct dccp_hdr));
+		return;
+	}
+
+	sport = EXTRACT_16BITS(&dh->dccph_sport);
+	dport = EXTRACT_16BITS(&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);
+	}
+	fflush(stdout);
+
+	if (qflag) {
+		(void)printf(" %d", len - hlen);
+		if (hlen > len) {
+			(void)printf("dccp [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));
+	}
+
+	/* checksum calculation */
+	if (vflag && TTEST2(bp[0], len)) {
+		u_int16_t sum = 0, dccp_sum;
+
+		dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum);
+		(void)printf("cksum 0x%04x ", dccp_sum);
+		if (IP_V(ip) == 4)
+			sum = dccp_cksum(ip, dh, len);
+#ifdef INET6
+		else if (IP_V(ip) == 6)
+			sum = dccp6_cksum(ip6, dh, len);
+#endif
+		if (sum != 0)
+			(void)printf("(incorrect -> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum));
+		else
+			(void)printf("(correct), ");
+	}
+
+	switch (DCCPH_TYPE(dh)) {
+	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) ",
+			     EXTRACT_32BITS(&dhr->dccph_req_service));
+		extlen += 4;
+		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) ",
+			     EXTRACT_32BITS(&dhr->dccph_resp_service));
+		extlen += 12;
+		break;
+	}
+	case DCCP_PKT_DATA:
+		(void)printf("data ");
+		break;
+	case DCCP_PKT_ACK: {
+		(void)printf("ack ");
+		extlen += 8;
+		break;
+	}
+	case DCCP_PKT_DATAACK: {
+		(void)printf("dataack ");
+		extlen += 8;
+		break;
+	}
+	case DCCP_PKT_CLOSEREQ:
+		(void)printf("closereq ");
+		extlen += 8;
+		break;
+	case DCCP_PKT_CLOSE:
+		(void)printf("close ");
+		extlen += 8;
+		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;
+		break;
+	}
+	case DCCP_PKT_SYNC:
+		(void)printf("sync ");
+		extlen += 8;
+		break;
+	case DCCP_PKT_SYNCACK:
+		(void)printf("syncack ");
+		extlen += 8;
+		break;
+	default:
+		(void)printf("invalid ");
+		break;
+	}
+
+	if ((DCCPH_TYPE(dh) != DCCP_PKT_DATA) && 
+			(DCCPH_TYPE(dh) != DCCP_PKT_REQUEST))
+		dccp_print_ack_no(bp);
+
+	if (vflag < 2)
+		return;
+
+	(void)printf("seq %" PRIu64, dccp_seqno(dh));
+
+	/* process options */
+	if (hlen > dccp_basic_hdr_len(dh) + extlen){
+		const u_char *cp;
+		u_int optlen;
+		cp = bp + dccp_basic_hdr_len(dh) + extlen;
+		printf(" <");	
+
+		hlen -= dccp_basic_hdr_len(dh) + extlen;
+		while(1){
+			TCHECK(*cp);
+			optlen = dccp_print_option(cp);
+			if (!optlen) goto trunc2;
+			if (hlen <= optlen) break; 
+			hlen -= optlen;
+			cp += optlen;
+			printf(", ");
+		}
+		printf(">");	
+	}
+	return;
+trunc:
+	printf("[|dccp]");
+trunc2:
+	return;
+}
+
+static int dccp_print_option(const u_char *option)
+{	
+	u_int8_t optlen, i;
+
+	TCHECK(*option);
+
+	if (*option >= 32) {
+		TCHECK(*(option+1));
+		optlen = *(option +1);
+		if (optlen < 2) {
+			printf("Option %d optlen too short",*option);
+			return 1;
+		}
+	} 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));	
+		}
+		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:
+		printf("timestamp %u", EXTRACT_32BITS(option + 2));
+		break;
+	case 42:
+		printf("timestamp_echo %u", EXTRACT_32BITS(option + 2));
+		break;
+	case 43:
+		printf("elapsed_time ");
+		if (optlen == 6)
+			printf("%u", EXTRACT_32BITS(option + 2));
+		else
+			printf("%u", EXTRACT_16BITS(option + 2));
+		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:
+					printf(" %u", EXTRACT_16BITS(option + 2));
+					break;
+				case 6:
+					printf(" %u", EXTRACT_32BITS(option + 2));
+					break;
+				default:
+					break;
+			}
+			break;
+		}
+			
+		printf("unknown_opt %d", *option);
+		break;
+	}
+
+	return optlen;
+trunc:
+	printf("[|dccp]");
+	return 0;
+}