xref: /freebsd/contrib/tcpdump/print-dccp.c (revision f0a75d274af375d15b97b830966b99a02b7db911) 
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.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 
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 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
93 static 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 
136 static 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 
143 static 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 
158 static 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 
174 static 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 
179 static 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 
197 static 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  */
205 void 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;
394 trunc:
395 	printf("[|dccp]");
396 trunc2:
397 	return;
398 }
399 
400 static 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;
523 trunc:
524 	printf("[|dccp]");
525 	return 0;
526 }
527