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.6 2006/02/19 05:08:44 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 + 1); 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 inline unsigned int dccp_basic_hdr_len(const struct dccp_hdr *dh) 159 { 160 return sizeof(*dh) + (DCCPH_X(dh) ? sizeof(struct dccp_hdr_ext) : 0); 161 } 162 163 static void dccp_print_ack_no(const u_char *bp) 164 { 165 const struct dccp_hdr *dh = (const struct dccp_hdr *)bp; 166 const struct dccp_hdr_ack_bits *dh_ack = 167 (struct dccp_hdr_ack_bits *)(bp + dccp_basic_hdr_len(dh)); 168 u_int32_t ack_high; 169 u_int64_t ackno; 170 171 TCHECK2(*dh_ack,4); 172 ack_high = DCCPH_ACK(dh_ack); 173 ackno = EXTRACT_24BITS(&ack_high) & 0xFFFFFF; 174 175 if (DCCPH_X(dh) != 0) { 176 u_int32_t ack_low; 177 178 TCHECK2(*dh_ack,8); 179 ack_low = dh_ack->dccph_ack_nr_low; 180 181 ackno &= 0x00FFFF; /* clear reserved field */ 182 ackno = (ackno << 32) + EXTRACT_32BITS(&ack_low); 183 } 184 185 (void)printf("(ack=%" PRIu64 ") ", ackno); 186 trunc: 187 return; 188 } 189 190 static inline unsigned int dccp_packet_hdr_len(const u_int8_t type) 191 { 192 if (type == DCCP_PKT_DATA) 193 return 0; 194 if (type == DCCP_PKT_DATAACK || 195 type == DCCP_PKT_ACK || 196 type == DCCP_PKT_SYNC || 197 type == DCCP_PKT_SYNCACK || 198 type == DCCP_PKT_CLOSE || 199 type == DCCP_PKT_CLOSEREQ) 200 return sizeof(struct dccp_hdr_ack_bits); 201 if (type == DCCP_PKT_REQUEST) 202 return sizeof(struct dccp_hdr_request); 203 if (type == DCCP_PKT_RESPONSE) 204 return sizeof(struct dccp_hdr_response); 205 return sizeof(struct dccp_hdr_reset); 206 } 207 208 static int dccp_print_option(const u_char *option); 209 210 /** 211 * dccp_print - show dccp packet 212 * @bp - beginning of dccp packet 213 * @data2 - beginning of enclosing 214 * @len - lenght of ip packet 215 */ 216 void dccp_print(const u_char *bp, const u_char *data2, u_int len) 217 { 218 const struct dccp_hdr *dh; 219 const struct ip *ip; 220 #ifdef INET6 221 const struct ip6_hdr *ip6; 222 #endif 223 const u_char *cp; 224 u_short sport, dport; 225 u_int hlen; 226 u_int extlen = 0; 227 228 dh = (const struct dccp_hdr *)bp; 229 230 ip = (struct ip *)data2; 231 #ifdef INET6 232 if (IP_V(ip) == 6) 233 ip6 = (const struct ip6_hdr *)data2; 234 else 235 ip6 = NULL; 236 #endif /*INET6*/ 237 cp = (const u_char *)(dh + 1); 238 if (cp > snapend) { 239 printf("[Invalid packet|dccp]"); 240 return; 241 } 242 243 if (len < sizeof(struct dccp_hdr)) { 244 printf("truncated-dccp - %ld bytes missing!", 245 (long)len - sizeof(struct dccp_hdr)); 246 return; 247 } 248 249 sport = EXTRACT_16BITS(&dh->dccph_sport); 250 dport = EXTRACT_16BITS(&dh->dccph_dport); 251 hlen = dh->dccph_doff * 4; 252 253 #ifdef INET6 254 if (ip6) { 255 (void)printf("%s.%d > %s.%d: ", 256 ip6addr_string(&ip6->ip6_src), sport, 257 ip6addr_string(&ip6->ip6_dst), dport); 258 } else 259 #endif /*INET6*/ 260 { 261 (void)printf("%s.%d > %s.%d: ", 262 ipaddr_string(&ip->ip_src), sport, 263 ipaddr_string(&ip->ip_dst), dport); 264 } 265 fflush(stdout); 266 267 if (qflag) { 268 (void)printf(" %d", len - hlen); 269 if (hlen > len) { 270 (void)printf("dccp [bad hdr length %u - too long, > %u]", 271 hlen, len); 272 } 273 return; 274 } 275 276 /* other variables in generic header */ 277 if (vflag) { 278 (void)printf("CCVal %d, CsCov %d, ", DCCPH_CCVAL(dh), DCCPH_CSCOV(dh)); 279 } 280 281 /* checksum calculation */ 282 #ifdef INET6 283 if (ip6) { 284 if (ip6->ip6_plen && vflag) { 285 u_int16_t sum, dccp_sum; 286 287 sum = dccp6_cksum(ip6, dh, len); 288 dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum); 289 printf("cksum 0x%04x", dccp_sum); 290 if (sum != 0) { 291 (void)printf(" (incorrect (-> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum)); 292 } else 293 (void)printf(" (correct), "); 294 } 295 } else 296 #endif /* INET6 */ 297 if (vflag) 298 { 299 u_int16_t sum, dccp_sum; 300 301 sum = dccp_cksum(ip, dh, len); 302 dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum); 303 printf("cksum 0x%04x", dccp_sum); 304 if (sum != 0) { 305 (void)printf(" (incorrect (-> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum)); 306 } else 307 (void)printf(" (correct), "); 308 } 309 310 switch (DCCPH_TYPE(dh)) { 311 case DCCP_PKT_REQUEST: { 312 struct dccp_hdr_request *dhr = 313 (struct dccp_hdr_request *)(bp + dccp_basic_hdr_len(dh)); 314 TCHECK(*dhr); 315 (void)printf("request (service=%d) ", 316 EXTRACT_32BITS(&dhr->dccph_req_service)); 317 extlen += 4; 318 break; 319 } 320 case DCCP_PKT_RESPONSE: { 321 struct dccp_hdr_response *dhr = 322 (struct dccp_hdr_response *)(bp + dccp_basic_hdr_len(dh)); 323 TCHECK(*dhr); 324 (void)printf("response (service=%d) ", 325 EXTRACT_32BITS(&dhr->dccph_resp_service)); 326 extlen += 12; 327 break; 328 } 329 case DCCP_PKT_DATA: 330 (void)printf("data "); 331 break; 332 case DCCP_PKT_ACK: { 333 (void)printf("ack "); 334 extlen += 8; 335 break; 336 } 337 case DCCP_PKT_DATAACK: { 338 (void)printf("dataack "); 339 extlen += 8; 340 break; 341 } 342 case DCCP_PKT_CLOSEREQ: 343 (void)printf("closereq "); 344 extlen += 8; 345 break; 346 case DCCP_PKT_CLOSE: 347 (void)printf("close "); 348 extlen += 8; 349 break; 350 case DCCP_PKT_RESET: { 351 struct dccp_hdr_reset *dhr = 352 (struct dccp_hdr_reset *)(bp + dccp_basic_hdr_len(dh)); 353 TCHECK(*dhr); 354 (void)printf("reset (code=%s) ", 355 dccp_reset_code(dhr->dccph_reset_code)); 356 extlen += 12; 357 break; 358 } 359 case DCCP_PKT_SYNC: 360 (void)printf("sync "); 361 extlen += 8; 362 break; 363 case DCCP_PKT_SYNCACK: 364 (void)printf("syncack "); 365 extlen += 8; 366 break; 367 default: 368 (void)printf("invalid "); 369 break; 370 } 371 372 if ((DCCPH_TYPE(dh) != DCCP_PKT_DATA) && 373 (DCCPH_TYPE(dh) != DCCP_PKT_REQUEST)) 374 dccp_print_ack_no(bp); 375 376 if (vflag < 2) 377 return; 378 379 (void)printf("seq %" PRIu64, dccp_seqno(dh)); 380 381 /* process options */ 382 if (hlen > dccp_basic_hdr_len(dh) + extlen){ 383 const u_char *cp; 384 u_int optlen; 385 cp = bp + dccp_basic_hdr_len(dh) + extlen; 386 printf(" <"); 387 388 hlen -= dccp_basic_hdr_len(dh) + extlen; 389 while(1){ 390 TCHECK(*cp); 391 optlen = dccp_print_option(cp); 392 if (!optlen) goto trunc2; 393 if (hlen <= optlen) break; 394 hlen -= optlen; 395 cp += optlen; 396 printf(", "); 397 } 398 printf(">"); 399 } 400 return; 401 trunc: 402 printf("[|dccp]"); 403 trunc2: 404 return; 405 } 406 407 static int dccp_print_option(const u_char *option) 408 { 409 u_int8_t optlen, i; 410 u_int32_t *ts; 411 u_int16_t *var16; 412 u_int32_t *var32; 413 414 TCHECK(*option); 415 416 if (*option >= 32) { 417 TCHECK(*(option+1)); 418 optlen = *(option +1); 419 if (optlen < 2) { 420 printf("Option %d optlen too short",*option); 421 return 1; 422 } 423 } else optlen = 1; 424 425 TCHECK2(*option,optlen); 426 427 switch (*option){ 428 case 0: 429 printf("nop"); 430 break; 431 case 1: 432 printf("mandatory"); 433 break; 434 case 2: 435 printf("slowreceiver"); 436 break; 437 case 32: 438 printf("change_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 33: 445 printf("confirm_l"); 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 34: 452 printf("change_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 35: 459 printf("confirm_r"); 460 if (*(option +2) < 10){ 461 printf(" %s", dccp_feature_nums[*(option +2)]); 462 for (i = 0; i < optlen -3; i ++) printf(" %d", *(option +3 + i)); 463 } 464 break; 465 case 36: 466 printf("initcookie 0x"); 467 for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); 468 break; 469 case 37: 470 printf("ndp_count"); 471 for (i = 0; i < optlen -2; i ++) printf(" %d", *(option +2 + i)); 472 break; 473 case 38: 474 printf("ack_vector0 0x"); 475 for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); 476 break; 477 case 39: 478 printf("ack_vector1 0x"); 479 for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); 480 break; 481 case 40: 482 printf("data_dropped 0x"); 483 for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); 484 break; 485 case 41: 486 ts = (u_int32_t *)(option + 2); 487 printf("timestamp %u", (u_int32_t)ntohl(*ts)); 488 break; 489 case 42: 490 ts = (u_int32_t *)(option + 2); 491 printf("timestamp_echo %u", (u_int32_t)ntohl(*ts)); 492 break; 493 case 43: 494 printf("elapsed_time "); 495 if (optlen == 6){ 496 ts = (u_int32_t *)(option + 2); 497 printf("%u", (u_int32_t)ntohl(*ts)); 498 } else { 499 var16 = (u_int16_t *)(option + 2); 500 printf("%u", ntohs(*var16)); 501 } 502 break; 503 case 44: 504 printf("data_checksum "); 505 for (i = 0; i < optlen -2; i ++) printf("%02x", *(option +2 + i)); 506 break; 507 default : 508 if (*option >= 128) { 509 printf("CCID option %d",*option); 510 switch (optlen) { 511 case 4: 512 var16 = (u_int16_t *)(option + 2); 513 printf(" %u",ntohs(*var16)); 514 break; 515 case 6: 516 var32 = (u_int32_t *)(option + 2); 517 printf(" %u",(u_int32_t)ntohl(*var32)); 518 break; 519 default: 520 break; 521 } 522 break; 523 } 524 525 printf("unknown_opt %d", *option); 526 break; 527 } 528 529 return optlen; 530 trunc: 531 printf("[|dccp]"); 532 return 0; 533 } 534
