The Tcpdump Group git mirrors - tcpdump/blob - print-dccp.c

   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 }