xref: /dragonfly/contrib/tcpdump/print-dccp.c (revision 279dd846) 
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
11 static const char rcsid[] _U_ =
12     "@(#) $Header: /tcpdump/master/tcpdump/print-dccp.c,v 1.8 2007-11-09 00:44:09 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 
35 static 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 
50 static 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 
63 static inline u_int dccp_csum_coverage(const struct dccp_hdr* dh, u_int len)
64 {
65 	u_int cov;
66 
67 	if (DCCPH_CSCOV(dh) == 0)
68 		return len;
69 	cov = (dh->dccph_doff + DCCPH_CSCOV(dh) - 1) * sizeof(u_int32_t);
70 	return (cov > len)? len : cov;
71 }
72 
73 static int dccp_cksum(const struct ip *ip,
74 	const struct dccp_hdr *dh, u_int len)
75 {
76 	return nextproto4_cksum(ip, (const u_int8_t *)(void *)dh,
77 	    dccp_csum_coverage(dh, len), IPPROTO_DCCP);
78 }
79 
80 #ifdef INET6
81 static int dccp6_cksum(const struct ip6_hdr *ip6, const struct dccp_hdr *dh, u_int len)
82 {
83 	return nextproto6_cksum(ip6, (const u_int8_t *)(void *)dh,
84 	    dccp_csum_coverage(dh, len), IPPROTO_DCCP);
85 }
86 #endif
87 
88 static const char *dccp_reset_code(u_int8_t code)
89 {
90 	if (code >= __DCCP_RESET_CODE_LAST)
91 		return "invalid";
92 	return dccp_reset_codes[code];
93 }
94 
95 static u_int64_t dccp_seqno(const struct dccp_hdr *dh)
96 {
97 	u_int32_t seq_high = DCCPH_SEQ(dh);
98 	u_int64_t seqno = EXTRACT_24BITS(&seq_high) & 0xFFFFFF;
99 
100 	if (DCCPH_X(dh) != 0) {
101 		const struct dccp_hdr_ext *dhx = (void *)(dh + 1);
102 		u_int32_t seq_low = dhx->dccph_seq_low;
103 		seqno &= 0x00FFFF;  /* clear reserved field */
104 		seqno = (seqno << 32) + EXTRACT_32BITS(&seq_low);
105 	}
106 
107 	return seqno;
108 }
109 
110 static inline unsigned int dccp_basic_hdr_len(const struct dccp_hdr *dh)
111 {
112 	return sizeof(*dh) + (DCCPH_X(dh) ? sizeof(struct dccp_hdr_ext) : 0);
113 }
114 
115 static void dccp_print_ack_no(const u_char *bp)
116 {
117 	const struct dccp_hdr *dh = (const struct dccp_hdr *)bp;
118 	const struct dccp_hdr_ack_bits *dh_ack =
119 		(struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh));
120 	u_int32_t ack_high;
121 	u_int64_t ackno;
122 
123 	TCHECK2(*dh_ack,4);
124 	ack_high = DCCPH_ACK(dh_ack);
125 	ackno = EXTRACT_24BITS(&ack_high) & 0xFFFFFF;
126 
127 	if (DCCPH_X(dh) != 0) {
128 		u_int32_t ack_low;
129 
130 		TCHECK2(*dh_ack,8);
131 		ack_low = dh_ack->dccph_ack_nr_low;
132 
133 		ackno &= 0x00FFFF;  /* clear reserved field */
134 		ackno = (ackno << 32) + EXTRACT_32BITS(&ack_low);
135 	}
136 
137 	(void)printf("(ack=%" PRIu64 ") ", ackno);
138 trunc:
139 	return;
140 }
141 
142 static inline unsigned int dccp_packet_hdr_len(const u_int8_t type)
143 {
144 	if (type == DCCP_PKT_DATA)
145 		return 0;
146 	if (type == DCCP_PKT_DATAACK	||
147 	    type == DCCP_PKT_ACK	||
148 	    type == DCCP_PKT_SYNC	||
149 	    type == DCCP_PKT_SYNCACK	||
150 	    type == DCCP_PKT_CLOSE	||
151 	    type == DCCP_PKT_CLOSEREQ)
152 		return sizeof(struct dccp_hdr_ack_bits);
153 	if (type == DCCP_PKT_REQUEST)
154 		return sizeof(struct dccp_hdr_request);
155 	if (type == DCCP_PKT_RESPONSE)
156 		return sizeof(struct dccp_hdr_response);
157 	return sizeof(struct dccp_hdr_reset);
158 }
159 
160 static int dccp_print_option(const u_char *option);
161 
162 /**
163  * dccp_print - show dccp packet
164  * @bp - beginning of dccp packet
165  * @data2 - beginning of enclosing
166  * @len - lenght of ip packet
167  */
168 void dccp_print(const u_char *bp, const u_char *data2, u_int len)
169 {
170 	const struct dccp_hdr *dh;
171 	const struct ip *ip;
172 #ifdef INET6
173 	const struct ip6_hdr *ip6;
174 #endif
175 	const u_char *cp;
176 	u_short sport, dport;
177 	u_int hlen;
178 	u_int extlen = 0;
179 
180 	dh = (const struct dccp_hdr *)bp;
181 
182 	ip = (struct ip *)data2;
183 #ifdef INET6
184 	if (IP_V(ip) == 6)
185 		ip6 = (const struct ip6_hdr *)data2;
186 	else
187 		ip6 = NULL;
188 #endif /*INET6*/
189 	cp = (const u_char *)(dh + 1);
190 	if (cp > snapend) {
191 		printf("[Invalid packet|dccp]");
192 		return;
193 	}
194 
195 	if (len < sizeof(struct dccp_hdr)) {
196 		printf("truncated-dccp - %ld bytes missing!",
197 			     (long)len - sizeof(struct dccp_hdr));
198 		return;
199 	}
200 
201 	sport = EXTRACT_16BITS(&dh->dccph_sport);
202 	dport = EXTRACT_16BITS(&dh->dccph_dport);
203 	hlen = dh->dccph_doff * 4;
204 
205 #ifdef INET6
206 	if (ip6) {
207 		(void)printf("%s.%d > %s.%d: ",
208 			     ip6addr_string(&ip6->ip6_src), sport,
209 			     ip6addr_string(&ip6->ip6_dst), dport);
210 	} else
211 #endif /*INET6*/
212 	{
213 		(void)printf("%s.%d > %s.%d: ",
214 			     ipaddr_string(&ip->ip_src), sport,
215 			     ipaddr_string(&ip->ip_dst), dport);
216 	}
217 	fflush(stdout);
218 
219 	if (qflag) {
220 		(void)printf(" %d", len - hlen);
221 		if (hlen > len) {
222 			(void)printf("dccp [bad hdr length %u - too long, > %u]",
223 			    hlen, len);
224 		}
225 		return;
226 	}
227 
228 	/* other variables in generic header */
229 	if (vflag) {
230 		(void)printf("CCVal %d, CsCov %d, ", DCCPH_CCVAL(dh), DCCPH_CSCOV(dh));
231 	}
232 
233 	/* checksum calculation */
234 	if (vflag && TTEST2(bp[0], len)) {
235 		u_int16_t sum = 0, dccp_sum;
236 
237 		dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum);
238 		(void)printf("cksum 0x%04x ", dccp_sum);
239 		if (IP_V(ip) == 4)
240 			sum = dccp_cksum(ip, dh, len);
241 #ifdef INET6
242 		else if (IP_V(ip) == 6)
243 			sum = dccp6_cksum(ip6, dh, len);
244 #endif
245 		if (sum != 0)
246 			(void)printf("(incorrect -> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum));
247 		else
248 			(void)printf("(correct), ");
249 	}
250 
251 	switch (DCCPH_TYPE(dh)) {
252 	case DCCP_PKT_REQUEST: {
253 		struct dccp_hdr_request *dhr =
254 			(struct dccp_hdr_request *)(bp + dccp_basic_hdr_len(dh));
255 		TCHECK(*dhr);
256 		(void)printf("request (service=%d) ",
257 			     EXTRACT_32BITS(&dhr->dccph_req_service));
258 		extlen += 4;
259 		break;
260 	}
261 	case DCCP_PKT_RESPONSE: {
262 		struct dccp_hdr_response *dhr =
263 			(struct dccp_hdr_response *)(bp + dccp_basic_hdr_len(dh));
264 		TCHECK(*dhr);
265 		(void)printf("response (service=%d) ",
266 			     EXTRACT_32BITS(&dhr->dccph_resp_service));
267 		extlen += 12;
268 		break;
269 	}
270 	case DCCP_PKT_DATA:
271 		(void)printf("data ");
272 		break;
273 	case DCCP_PKT_ACK: {
274 		(void)printf("ack ");
275 		extlen += 8;
276 		break;
277 	}
278 	case DCCP_PKT_DATAACK: {
279 		(void)printf("dataack ");
280 		extlen += 8;
281 		break;
282 	}
283 	case DCCP_PKT_CLOSEREQ:
284 		(void)printf("closereq ");
285 		extlen += 8;
286 		break;
287 	case DCCP_PKT_CLOSE:
288 		(void)printf("close ");
289 		extlen += 8;
290 		break;
291 	case DCCP_PKT_RESET: {
292 		struct dccp_hdr_reset *dhr =
293 			(struct dccp_hdr_reset *)(bp + dccp_basic_hdr_len(dh));
294 		TCHECK(*dhr);
295 		(void)printf("reset (code=%s) ",
296 			     dccp_reset_code(dhr->dccph_reset_code));
297 		extlen += 12;
298 		break;
299 	}
300 	case DCCP_PKT_SYNC:
301 		(void)printf("sync ");
302 		extlen += 8;
303 		break;
304 	case DCCP_PKT_SYNCACK:
305 		(void)printf("syncack ");
306 		extlen += 8;
307 		break;
308 	default:
309 		(void)printf("invalid ");
310 		break;
311 	}
312 
313 	if ((DCCPH_TYPE(dh) != DCCP_PKT_DATA) &&
314 			(DCCPH_TYPE(dh) != DCCP_PKT_REQUEST))
315 		dccp_print_ack_no(bp);
316 
317 	if (vflag < 2)
318 		return;
319 
320 	(void)printf("seq %" PRIu64, dccp_seqno(dh));
321 
322 	/* process options */
323 	if (hlen > dccp_basic_hdr_len(dh) + extlen){
324 		const u_char *cp;
325 		u_int optlen;
326 		cp = bp + dccp_basic_hdr_len(dh) + extlen;
327 		printf(" <");
328 
329 		hlen -= dccp_basic_hdr_len(dh) + extlen;
330 		while(1){
331 			TCHECK(*cp);
332 			optlen = dccp_print_option(cp);
333 			if (!optlen) goto trunc2;
334 			if (hlen <= optlen) break;
335 			hlen -= optlen;
336 			cp += optlen;
337 			printf(", ");
338 		}
339 		printf(">");
340 	}
341 	return;
342 trunc:
343 	printf("[|dccp]");
344 trunc2:
345 	return;
346 }
347 
348 static int dccp_print_option(const u_char *option)
349 {
350 	u_int8_t optlen, i;
351 
352 	TCHECK(*option);
353 
354 	if (*option >= 32) {
355 		TCHECK(*(option+1));
356 		optlen = *(option +1);
357 		if (optlen < 2) {
358 			printf("Option %d optlen too short",*option);
359 			return 1;
360 		}
361 	} else optlen = 1;
362 
363 	TCHECK2(*option,optlen);
364 
365 	switch (*option){
366 	case 0:
367 		printf("nop");
368 		break;
369 	case 1:
370 		printf("mandatory");
371 		break;
372 	case 2:
373 		printf("slowreceiver");
374 		break;
375 	case 32:
376 		printf("change_l");
377 		if (*(option +2) < 10){
378 			printf(" %s", dccp_feature_nums[*(option +2)]);
379 			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
380 		}
381 		break;
382 	case 33:
383 		printf("confirm_l");
384 		if (*(option +2) < 10){
385 			printf(" %s", dccp_feature_nums[*(option +2)]);
386 			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
387 		}
388 		break;
389 	case 34:
390 	        printf("change_r");
391 		if (*(option +2) < 10){
392 			printf(" %s", dccp_feature_nums[*(option +2)]);
393 			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
394 		}
395 		break;
396 	case 35:
397 		printf("confirm_r");
398 		if (*(option +2) < 10){
399 			printf(" %s", dccp_feature_nums[*(option +2)]);
400 			for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i));
401 		}
402 		break;
403 	case 36:
404 		printf("initcookie 0x");
405 		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
406 		break;
407 	case 37:
408 		printf("ndp_count");
409 		for (i = 0; i < optlen -2; i ++) printf(" %d", *(option +2 + i));
410 		break;
411 	case 38:
412 		printf("ack_vector0 0x");
413 		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
414 		break;
415 	case 39:
416 		printf("ack_vector1 0x");
417 		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
418 		break;
419 	case 40:
420 		printf("data_dropped 0x");
421 		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
422 		break;
423 	case 41:
424 		printf("timestamp %u", EXTRACT_32BITS(option + 2));
425 		break;
426 	case 42:
427 		printf("timestamp_echo %u", EXTRACT_32BITS(option + 2));
428 		break;
429 	case 43:
430 		printf("elapsed_time ");
431 		if (optlen == 6)
432 			printf("%u", EXTRACT_32BITS(option + 2));
433 		else
434 			printf("%u", EXTRACT_16BITS(option + 2));
435 		break;
436 	case 44:
437 		printf("data_checksum ");
438 		for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i));
439 		break;
440 	default :
441 		if (*option >= 128) {
442 			printf("CCID option %d",*option);
443 			switch (optlen) {
444 				case 4:
445 					printf(" %u", EXTRACT_16BITS(option + 2));
446 					break;
447 				case 6:
448 					printf(" %u", EXTRACT_32BITS(option + 2));
449 					break;
450 				default:
451 					break;
452 			}
453 			break;
454 		}
455 
456 		printf("unknown_opt %d", *option);
457 		break;
458 	}
459 
460 	return optlen;
461 trunc:
462 	printf("[|dccp]");
463 	return 0;
464 }
465