print-dccp.c revision 162017 
1/*
2 * Copyright (C) Arnaldo Carvalho de Melo 2004
3 * Copyright (C) Ian McDonald 2005
4 * Copyright (C) Yoshifumi Nishida 2005
5 *
6 * This software may be distributed either under the terms of the
7 * BSD-style license that accompanies tcpdump or the GNU GPL version 2
8 */
9
10#ifndef lint
11static const char rcsid[] _U_ =
12    "@(#) $Header: /tcpdump/master/tcpdump/print-dccp.c,v 1.1.2.2 2005/09/20 06:25:45 guy Exp $ (LBL)";
13#endif
14
15#ifdef HAVE_CONFIG_H
16#include "config.h"
17#endif
18
19#include <tcpdump-stdinc.h>
20
21#include "dccp.h"
22
23#include <stdio.h>
24#include <string.h>
25
26#include "interface.h"
27#include "addrtoname.h"
28#include "extract.h"			/* must come after interface.h */
29#include "ip.h"
30#ifdef INET6
31#include "ip6.h"
32#endif
33#include "ipproto.h"
34
35static const char *dccp_reset_codes[] = {
36	"unspecified",
37	"closed",
38	"aborted",
39	"no_connection",
40	"packet_error",
41	"option_error",
42	"mandatory_error",
43	"connection_refused",
44	"bad_service_code",
45	"too_busy",
46	"bad_init_cookie",
47	"aggression_penalty",
48};
49
50static const char *dccp_feature_nums[] = {
51	"reserved",
52	"ccid",
53	"allow_short_seqno",
54	"sequence_window",
55	"ecn_incapable",
56	"ack_ratio",
57	"send_ack_vector",
58	"send_ndp_count",
59	"minimum checksum coverage",
60	"check data checksum",
61};
62
63static int dccp_cksum(const struct ip *ip,
64	const struct dccp_hdr *dh, u_int len)
65{
66	union phu {
67		struct phdr {
68			u_int32_t src;
69			u_int32_t dst;
70			u_char mbz;
71			u_char proto;
72			u_int16_t len;
73		} ph;
74		u_int16_t pa[6];
75	} phu;
76	const u_int16_t *sp;
77
78	/* pseudo-header.. */
79	phu.ph.mbz = 0;
80	phu.ph.len = htons(len);
81	phu.ph.proto = IPPROTO_DCCP;
82	memcpy(&phu.ph.src, &ip->ip_src.s_addr, sizeof(u_int32_t));
83	if (IP_HL(ip) == 5)
84		memcpy(&phu.ph.dst, &ip->ip_dst.s_addr, sizeof(u_int32_t));
85	else
86		phu.ph.dst = ip_finddst(ip);
87
88	sp = &phu.pa[0];
89	return in_cksum((u_short *)dh, len, sp[0]+sp[1]+sp[2]+sp[3]+sp[4]+sp[5]);
90}
91
92#ifdef INET6
93static int dccp6_cksum(const struct ip6_hdr *ip6, const struct dccp_hdr *dh, u_int len)
94{
95	size_t i;
96	const u_int16_t *sp;
97	u_int32_t sum;
98	union {
99		struct {
100			struct in6_addr ph_src;
101			struct in6_addr ph_dst;
102			u_int32_t   ph_len;
103			u_int8_t    ph_zero[3];
104			u_int8_t    ph_nxt;
105		} ph;
106		u_int16_t pa[20];
107	} phu;
108
109	/* pseudo-header */
110	memset(&phu, 0, sizeof(phu));
111	phu.ph.ph_src = ip6->ip6_src;
112	phu.ph.ph_dst = ip6->ip6_dst;
113	phu.ph.ph_len = htonl(len);
114	phu.ph.ph_nxt = IPPROTO_DCCP;
115
116	sum = 0;
117	for (i = 0; i < sizeof(phu.pa) / sizeof(phu.pa[0]); i++)
118		sum += phu.pa[i];
119
120	sp = (const u_int16_t *)dh;
121
122	for (i = 0; i < (len & ~1); i += 2)
123		sum += *sp++;
124
125	if (len & 1)
126		sum += htons((*(const u_int8_t *)sp) << 8);
127
128	while (sum > 0xffff)
129		sum = (sum & 0xffff) + (sum >> 16);
130	sum = ~sum & 0xffff;
131
132	return (sum);
133}
134#endif
135
136static const char *dccp_reset_code(u_int8_t code)
137{
138	if (code >= __DCCP_RESET_CODE_LAST)
139		return "invalid";
140	return dccp_reset_codes[code];
141}
142
143static u_int64_t dccp_seqno(const struct dccp_hdr *dh)
144{
145	u_int32_t seq_high = DCCPH_SEQ(dh);
146	u_int64_t seqno = EXTRACT_24BITS(&seq_high) & 0xFFFFFF;
147
148	if (DCCPH_X(dh) != 0) {
149		const struct dccp_hdr_ext *dhx = (void *)dh + sizeof(*dh);
150		u_int32_t seq_low = dhx->dccph_seq_low;
151		seqno &= 0x00FFFF;  /* clear reserved field */
152		seqno = (seqno << 32) + EXTRACT_32BITS(&seq_low);
153	}
154
155	return seqno;
156}
157
158static u_int64_t dccp_ack_no(const struct dccp_hdr *dh,
159		const struct dccp_hdr_ack_bits *dh_ack)
160{
161	u_int32_t ack_high = DCCPH_ACK(dh_ack);
162	u_int64_t ackno = EXTRACT_24BITS(&ack_high) & 0xFFFFFF;
163
164	if (DCCPH_X(dh) != 0) {
165		u_int32_t ack_low = dh_ack->dccph_ack_nr_low;
166
167		ackno &= 0x00FFFF;  /* clear reserved field */
168		ackno = (ackno << 32) + EXTRACT_32BITS(&ack_low);
169	}
170
171	return ackno;
172}
173
174static inline unsigned int dccp_basic_hdr_len(const struct dccp_hdr *dh)
175{
176	return sizeof(*dh) + (DCCPH_X(dh) ? sizeof(struct dccp_hdr_ext) : 0);
177}
178
179static inline unsigned int dccp_packet_hdr_len(const u_int8_t type)
180{
181	if (type == DCCP_PKT_DATA)
182		return 0;
183	if (type == DCCP_PKT_DATAACK	||
184	    type == DCCP_PKT_ACK	||
185	    type == DCCP_PKT_SYNC	||
186	    type == DCCP_PKT_SYNCACK	||
187	    type == DCCP_PKT_CLOSE	||
188	    type == DCCP_PKT_CLOSEREQ)
189		return sizeof(struct dccp_hdr_ack_bits);
190	if (type == DCCP_PKT_REQUEST)
191		return sizeof(struct dccp_hdr_request);
192	if (type == DCCP_PKT_RESPONSE)
193		return sizeof(struct dccp_hdr_response);
194	return sizeof(struct dccp_hdr_reset);
195}
196
197static int dccp_print_option(const u_char *option);
198
199/**
200 * dccp_print - show dccp packet
201 * @bp - beginning of dccp packet
202 * @data2 - beginning of enclosing
203 * @len - lenght of ip packet
204 */
205void dccp_print(const u_char *bp, const u_char *data2, u_int len)
206{
207	const struct dccp_hdr *dh;
208	const struct ip *ip;
209#ifdef INET6
210	const struct ip6_hdr *ip6;
211#endif
212	const u_char *cp;
213	u_short sport, dport;
214	u_int hlen;
215	u_int extlen = 0;
216
217	dh = (const struct dccp_hdr *)bp;
218
219	ip = (struct ip *)data2;
220#ifdef INET6
221	if (IP_V(ip) == 6)
222		ip6 = (const struct ip6_hdr *)data2;
223	else
224		ip6 = NULL;
225#endif /*INET6*/
226	cp = (const u_char *)(dh + 1);
227	if (cp > snapend) {
228		printf("[Invalid packet|dccp]");
229		return;
230	}
231
232	if (len < sizeof(struct dccp_hdr)) {
233		printf("truncated-dccp - %ld bytes missing!",
234			     (long)len - sizeof(struct dccp_hdr));
235		return;
236	}
237
238	sport = EXTRACT_16BITS(&dh->dccph_sport);
239	dport = EXTRACT_16BITS(&dh->dccph_dport);
240	hlen = dh->dccph_doff * 4;
241
242#ifdef INET6
243	if (ip6) {
244		(void)printf("%s.%d > %s.%d: ",
245			     ip6addr_string(&ip6->ip6_src), sport,
246			     ip6addr_string(&ip6->ip6_dst), dport);
247	} else
248#endif /*INET6*/
249	{
250		(void)printf("%s.%d > %s.%d: ",
251			     ipaddr_string(&ip->ip_src), sport,
252			     ipaddr_string(&ip->ip_dst), dport);
253	}
254	fflush(stdout);
255
256	if (qflag) {
257		(void)printf(" %d", len - hlen);
258		if (hlen > len) {
259			(void)printf("dccp [bad hdr length %u - too long, > %u]",
260			    hlen, len);
261		}
262		return;
263	}
264
265	/* other variables in generic header */
266	if (vflag) {
267		(void)printf("CCVal %d, CsCov %d, ", DCCPH_CCVAL(dh), DCCPH_CSCOV(dh));
268	}
269
270	/* checksum calculation */
271#ifdef INET6
272	if (ip6) {
273		if (ip6->ip6_plen && vflag) {
274			u_int16_t sum, dccp_sum;
275
276			sum = dccp6_cksum(ip6, dh, len);
277			dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum);
278			printf("cksum 0x%04x", dccp_sum);
279			if (sum != 0) {
280				(void)printf(" (incorrect (-> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum));
281			} else
282				(void)printf(" (correct), ");
283		}
284	} else
285#endif /* INET6 */
286	if (vflag)
287	{
288		u_int16_t sum, dccp_sum;
289
290		sum = dccp_cksum(ip, dh, len);
291		dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum);
292		printf("cksum 0x%04x", dccp_sum);
293		if (sum != 0) {
294			(void)printf(" (incorrect (-> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum));
295		} else
296			(void)printf(" (correct), ");
297	}
298
299	switch (DCCPH_TYPE(dh)) {
300	case DCCP_PKT_REQUEST: {
301		struct dccp_hdr_request *dhr =
302			(struct dccp_hdr_request *)(bp + dccp_basic_hdr_len(dh));
303		TCHECK(*dhr);
304		(void)printf("request (service=%d) ", dhr->dccph_req_service);
305		extlen += 4;
306		break;
307	}
308	case DCCP_PKT_RESPONSE: {
309		struct dccp_hdr_response *dhr =
310			(struct dccp_hdr_response *)(bp + dccp_basic_hdr_len(dh));
311		TCHECK(*dhr);
312		(void)printf("response (service=%d, ack=%" PRIu64 ") ",
313			     dhr->dccph_resp_service,
314			     dccp_ack_no(dh,&(dhr->dccph_resp_ack)));
315		extlen += 12;
316		break;
317	}
318	case DCCP_PKT_DATA:
319		(void)printf("data ");
320		break;
321	case DCCP_PKT_ACK: {
322		struct dccp_hdr_ack_bits *dha =
323			(struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh));
324		TCHECK(*dha);
325		(void)printf("ack (ack=%" PRIu64 ") ",
326			     dccp_ack_no(dh,dha));
327		extlen += 8;
328		break;
329	}
330	case DCCP_PKT_DATAACK: {
331		struct dccp_hdr_ack_bits *dha =
332			(struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh));
333		TCHECK(*dha);
334		(void)printf("dataack (ack=%" PRIu64 ") ",
335			     dccp_ack_no(dh,dha));
336		extlen += 8;
337		break;
338	}
339	case DCCP_PKT_CLOSEREQ:
340		(void)printf("closereq ");
341		extlen += 8;
342		break;
343	case DCCP_PKT_CLOSE:
344		(void)printf("close ");
345		extlen += 8;
346		break;
347	case DCCP_PKT_RESET: {
348		struct dccp_hdr_reset *dhr =
349			(struct dccp_hdr_reset *)(bp + dccp_basic_hdr_len(dh));
350		TCHECK(*dhr);
351		(void)printf("reset (code=%s) ",
352			     dccp_reset_code(dhr->dccph_reset_code));
353		extlen += 12;
354		break;
355	}
356	case DCCP_PKT_SYNC:
357		(void)printf("sync ");
358		extlen += 8;
359		break;
360	case DCCP_PKT_SYNCACK:
361		(void)printf("syncack ");
362		extlen += 8;
363		break;
364	default:
365		(void)printf("invalid ");
366		break;
367	}
368
369	if (vflag < 2)
370		return;
371
372	(void)printf("seq %" PRIu64, dccp_seqno(dh));
373
374	/* process options */
375	if (hlen > dccp_basic_hdr_len(dh) + extlen){
376		const u_char *cp;
377		u_int optlen;
378		cp = bp + dccp_basic_hdr_len(dh) + extlen;
379		printf(" <");
380
381		hlen -= dccp_basic_hdr_len(dh) + extlen;
382		while(1){
383			TCHECK(*cp);
384			optlen = dccp_print_option(cp);
385			if (!optlen) goto trunc2;
386			if (hlen <= optlen) break;
387			hlen -= optlen;
388			cp += optlen;
389			printf(", ");
390		}
391		printf(">");
392	}
393	return;
394trunc:
395	printf("[|dccp]");
396trunc2:
397	return;
398}
399
400static int dccp_print_option(const u_char *option)
401{
402	u_int8_t optlen, i;
403	u_int32_t *ts;
404	u_int16_t *var16;
405	u_int32_t *var32;
406
407	TCHECK(*option);
408
409	if (*option >= 32) {
410		TCHECK(*(option+1));
411		optlen = *(option +1);
412		if (optlen < 2) {
413			printf("Option %d optlen too short",*option);
414			return 1;
415		}
416	} else optlen = 1;
417
418	TCHECK2(*option,optlen);
419
420	switch (*option){
421	case 0:
422		printf("nop");
423		break;
424	case 1:
425		printf("mandatory");
426		break;
427	case 2:
428		printf("slowreceiver");
429		break;
430	case 32:
431		printf("change_l");
432		if (*(option +2) < 10){
433			printf(" %s", dccp_feature_nums[*(option +2)]);
434			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
435		}
436		break;
437	case 33:
438		printf("confirm_l");
439		if (*(option +2) < 10){
440			printf(" %s", dccp_feature_nums[*(option +2)]);
441			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
442		}
443		break;
444	case 34:
445	        printf("change_r");
446		if (*(option +2) < 10){
447			printf(" %s", dccp_feature_nums[*(option +2)]);
448			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
449		}
450		break;
451	case 35:
452		printf("confirm_r");
453		if (*(option +2) < 10){
454			printf(" %s", dccp_feature_nums[*(option +2)]);
455			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
456		}
457		break;
458	case 36:
459		printf("initcookie 0x");
460		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
461		break;
462	case 37:
463		printf("ndp_count");
464		for (i = 0; i < optlen -2; i ++) printf(" %d", *(option +2 + i));
465		break;
466	case 38:
467		printf("ack_vector0 0x");
468		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
469		break;
470	case 39:
471		printf("ack_vector1 0x");
472		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
473		break;
474	case 40:
475		printf("data_dropped 0x");
476		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
477		break;
478	case 41:
479		ts = (u_int32_t *)(option + 2);
480		printf("timestamp %u", (u_int32_t)ntohl(*ts));
481		break;
482	case 42:
483		ts = (u_int32_t *)(option + 2);
484		printf("timestamp_echo %u", (u_int32_t)ntohl(*ts));
485		break;
486	case 43:
487		printf("elapsed_time ");
488		if (optlen == 6){
489			ts = (u_int32_t *)(option + 2);
490			printf("%u", (u_int32_t)ntohl(*ts));
491		} else {
492			var16 = (u_int16_t *)(option + 2);
493			printf("%u", ntohs(*var16));
494		}
495		break;
496	case 44:
497		printf("data_checksum ");
498		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
499		break;
500	default :
501		if (*option >= 128) {
502			printf("CCID option %d",*option);
503			switch (optlen) {
504				case 4:
505					var16 = (u_int16_t *)(option + 2);
506					printf(" %u",ntohs(*var16));
507					break;
508				case 6:
509					var32 = (u_int32_t *)(option + 2);
510					printf(" %u",(u_int32_t)ntohl(*var32));
511					break;
512				default:
513					break;
514			}
515			break;
516		}
517
518		printf("unknown_opt %d", *option);
519		break;
520	}
521
522	return optlen;
523trunc:
524	printf("[|dccp]");
525	return 0;
526}
527