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