contrib/tcpdump-3.9/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.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 }