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