err.no Git - linux-2.6/blob - net/dccp/options.c

   1 /*
   2  *  net/dccp/options.c
   3  *
   4  *  An implementation of the DCCP protocol
   5  *  Copyright (c) 2005 Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
   6  *  Copyright (c) 2005 Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
   7  *  Copyright (c) 2005 Ian McDonald <iam4@cs.waikato.ac.nz>
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License
  11  *      as published by the Free Software Foundation; either version
  12  *      2 of the License, or (at your option) any later version.
  13  */
  14 #include <linux/config.h>
  15 #include <linux/dccp.h>
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/skbuff.h>
  20
  21 #include "ackvec.h"
  22 #include "ccid.h"
  23 #include "dccp.h"
  24 #include "feat.h"
  25
  26 /* stores the default values for new connection. may be changed with sysctl */
  27 static const struct dccp_options dccpo_default_values = {
  28         .dccpo_sequence_window    = DCCPF_INITIAL_SEQUENCE_WINDOW,
  29         .dccpo_rx_ccid            = DCCPF_INITIAL_CCID,
  30         .dccpo_tx_ccid            = DCCPF_INITIAL_CCID,
  31         .dccpo_ack_ratio          = DCCPF_INITIAL_ACK_RATIO,
  32         .dccpo_send_ack_vector    = DCCPF_INITIAL_SEND_ACK_VECTOR,
  33         .dccpo_send_ndp_count     = DCCPF_INITIAL_SEND_NDP_COUNT,
  34 };
  35
  36 void dccp_options_init(struct dccp_options *dccpo)
  37 {
  38         memcpy(dccpo, &dccpo_default_values, sizeof(*dccpo));
  39 }
  40
  41 static u32 dccp_decode_value_var(const unsigned char *bf, const u8 len)
  42 {
  43         u32 value = 0;
  44
  45         if (len > 3)
  46                 value += *bf++ << 24;
  47         if (len > 2)
  48                 value += *bf++ << 16;
  49         if (len > 1)
  50                 value += *bf++ << 8;
  51         if (len > 0)
  52                 value += *bf;
  53
  54         return value;
  55 }
  56
  57 int dccp_parse_options(struct sock *sk, struct sk_buff *skb)
  58 {
  59         struct dccp_sock *dp = dccp_sk(sk);
  60 #ifdef CONFIG_IP_DCCP_DEBUG
  61         const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
  62                                         "CLIENT rx opt: " : "server rx opt: ";
  63 #endif
  64         const struct dccp_hdr *dh = dccp_hdr(skb);
  65         const u8 pkt_type = DCCP_SKB_CB(skb)->dccpd_type;
  66         unsigned char *options = (unsigned char *)dh + dccp_hdr_len(skb);
  67         unsigned char *opt_ptr = options;
  68         const unsigned char *opt_end = (unsigned char *)dh +
  69                                         (dh->dccph_doff * 4);
  70         struct dccp_options_received *opt_recv = &dp->dccps_options_received;
  71         unsigned char opt, len;
  72         unsigned char *value;
  73         u32 elapsed_time;
  74         int rc;
  75         int mandatory = 0;
  76
  77         memset(opt_recv, 0, sizeof(*opt_recv));
  78
  79         while (opt_ptr != opt_end) {
  80                 opt   = *opt_ptr++;
  81                 len   = 0;
  82                 value = NULL;
  83
  84                 /* Check if this isn't a single byte option */
  85                 if (opt > DCCPO_MAX_RESERVED) {
  86                         if (opt_ptr == opt_end)
  87                                 goto out_invalid_option;
  88
  89                         len = *opt_ptr++;
  90                         if (len < 3)
  91                                 goto out_invalid_option;
  92                         /*
  93                          * Remove the type and len fields, leaving
  94                          * just the value size
  95                          */
  96                         len     -= 2;
  97                         value   = opt_ptr;
  98                         opt_ptr += len;
  99
 100                         if (opt_ptr > opt_end)
 101                                 goto out_invalid_option;
 102                 }
 103
 104                 switch (opt) {
 105                 case DCCPO_PADDING:
 106                         break;
 107                 case DCCPO_MANDATORY:
 108                         if (mandatory)
 109                                 goto out_invalid_option;
 110                         mandatory = 1;
 111                         break;
 112                 case DCCPO_NDP_COUNT:
 113                         if (len > 3)
 114                                 goto out_invalid_option;
 115
 116                         opt_recv->dccpor_ndp = dccp_decode_value_var(value, len);
 117                         dccp_pr_debug("%sNDP count=%d\n", debug_prefix,
 118                                       opt_recv->dccpor_ndp);
 119                         break;
 120                 case DCCPO_CHANGE_L:
 121                         /* fall through */
 122                 case DCCPO_CHANGE_R:
 123                         if (len < 2)
 124                                 goto out_invalid_option;
 125                         rc = dccp_feat_change_recv(sk, opt, *value, value + 1,
 126                                                    len - 1);
 127                         /*
 128                          * When there is a change error, change_recv is
 129                          * responsible for dealing with it.  i.e. reply with an
 130                          * empty confirm.
 131                          * If the change was mandatory, then we need to die.
 132                          */
 133                         if (rc && mandatory)
 134                                 goto out_invalid_option;
 135                         break;
 136                 case DCCPO_CONFIRM_L:
 137                         /* fall through */
 138                 case DCCPO_CONFIRM_R:
 139                         if (len < 2)
 140                                 goto out_invalid_option;
 141                         if (dccp_feat_confirm_recv(sk, opt, *value,
 142                                                    value + 1, len - 1))
 143                                 goto out_invalid_option;
 144                         break;
 145                 case DCCPO_ACK_VECTOR_0:
 146                 case DCCPO_ACK_VECTOR_1:
 147                         if (pkt_type == DCCP_PKT_DATA)
 148                                 continue;
 149
 150                         if (dp->dccps_options.dccpo_send_ack_vector &&
 151                             dccp_ackvec_parse(sk, skb, opt, value, len))
 152                                 goto out_invalid_option;
 153                         break;
 154                 case DCCPO_TIMESTAMP:
 155                         if (len != 4)
 156                                 goto out_invalid_option;
 157
 158                         opt_recv->dccpor_timestamp = ntohl(*(__be32 *)value);
 159
 160                         dp->dccps_timestamp_echo = opt_recv->dccpor_timestamp;
 161                         dccp_timestamp(sk, &dp->dccps_timestamp_time);
 162
 163                         dccp_pr_debug("%sTIMESTAMP=%u, ackno=%llu\n",
 164                                       debug_prefix, opt_recv->dccpor_timestamp,
 165                                       (unsigned long long)
 166                                       DCCP_SKB_CB(skb)->dccpd_ack_seq);
 167                         break;
 168                 case DCCPO_TIMESTAMP_ECHO:
 169                         if (len != 4 && len != 6 && len != 8)
 170                                 goto out_invalid_option;
 171
 172                         opt_recv->dccpor_timestamp_echo = ntohl(*(__be32 *)value);
 173
 174                         dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, ackno=%llu, ",
 175                                       debug_prefix,
 176                                       opt_recv->dccpor_timestamp_echo,
 177                                       len + 2,
 178                                       (unsigned long long)
 179                                       DCCP_SKB_CB(skb)->dccpd_ack_seq);
 180
 181
 182                         if (len == 4)
 183                                 break;
 184
 185                         if (len == 6)
 186                                 elapsed_time = ntohs(*(__be16 *)(value + 4));
 187                         else
 188                                 elapsed_time = ntohl(*(__be32 *)(value + 4));
 189
 190                         /* Give precedence to the biggest ELAPSED_TIME */
 191                         if (elapsed_time > opt_recv->dccpor_elapsed_time)
 192                                 opt_recv->dccpor_elapsed_time = elapsed_time;
 193                         break;
 194                 case DCCPO_ELAPSED_TIME:
 195                         if (len != 2 && len != 4)
 196                                 goto out_invalid_option;
 197
 198                         if (pkt_type == DCCP_PKT_DATA)
 199                                 continue;
 200
 201                         if (len == 2)
 202                                 elapsed_time = ntohs(*(__be16 *)value);
 203                         else
 204                                 elapsed_time = ntohl(*(__be32 *)value);
 205
 206                         if (elapsed_time > opt_recv->dccpor_elapsed_time)
 207                                 opt_recv->dccpor_elapsed_time = elapsed_time;
 208
 209                         dccp_pr_debug("%sELAPSED_TIME=%d\n", debug_prefix,
 210                                       elapsed_time);
 211                         break;
 212                         /*
 213                          * From draft-ietf-dccp-spec-11.txt:
 214                          *
 215                          *      Option numbers 128 through 191 are for
 216                          *      options sent from the HC-Sender to the
 217                          *      HC-Receiver; option numbers 192 through 255
 218                          *      are for options sent from the HC-Receiver to
 219                          *      the HC-Sender.
 220                          */
 221                 case 128 ... 191: {
 222                         const u16 idx = value - options;
 223
 224                         if (ccid_hc_rx_parse_options(dp->dccps_hc_rx_ccid, sk,
 225                                                      opt, len, idx,
 226                                                      value) != 0)
 227                                 goto out_invalid_option;
 228                 }
 229                         break;
 230                 case 192 ... 255: {
 231                         const u16 idx = value - options;
 232
 233                         if (ccid_hc_tx_parse_options(dp->dccps_hc_tx_ccid, sk,
 234                                                      opt, len, idx,
 235                                                      value) != 0)
 236                                 goto out_invalid_option;
 237                 }
 238                         break;
 239                 default:
 240                         pr_info("DCCP(%p): option %d(len=%d) not "
 241                                 "implemented, ignoring\n",
 242                                 sk, opt, len);
 243                         break;
 244                 }
 245
 246                 if (opt != DCCPO_MANDATORY)
 247                         mandatory = 0;
 248         }
 249
 250         return 0;
 251
 252 out_invalid_option:
 253         DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT);
 254         DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_OPTION_ERROR;
 255         pr_info("DCCP(%p): invalid option %d, len=%d\n", sk, opt, len);
 256         return -1;
 257 }
 258
 259 static void dccp_encode_value_var(const u32 value, unsigned char *to,
 260                                   const unsigned int len)
 261 {
 262         if (len > 3)
 263                 *to++ = (value & 0xFF000000) >> 24;
 264         if (len > 2)
 265                 *to++ = (value & 0xFF0000) >> 16;
 266         if (len > 1)
 267                 *to++ = (value & 0xFF00) >> 8;
 268         if (len > 0)
 269                 *to++ = (value & 0xFF);
 270 }
 271
 272 static inline int dccp_ndp_len(const int ndp)
 273 {
 274         return likely(ndp <= 0xFF) ? 1 : ndp <= 0xFFFF ? 2 : 3;
 275 }
 276
 277 void dccp_insert_option(struct sock *sk, struct sk_buff *skb,
 278                         const unsigned char option,
 279                         const void *value, const unsigned char len)
 280 {
 281         unsigned char *to;
 282
 283         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len + 2 > DCCP_MAX_OPT_LEN) {
 284                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to insert "
 285                                "%d option!\n", option);
 286                 return;
 287         }
 288
 289         DCCP_SKB_CB(skb)->dccpd_opt_len += len + 2;
 290
 291         to    = skb_push(skb, len + 2);
 292         *to++ = option;
 293         *to++ = len + 2;
 294
 295         memcpy(to, value, len);
 296 }
 297
 298 EXPORT_SYMBOL_GPL(dccp_insert_option);
 299
 300 static void dccp_insert_option_ndp(struct sock *sk, struct sk_buff *skb)
 301 {
 302         struct dccp_sock *dp = dccp_sk(sk);
 303         int ndp = dp->dccps_ndp_count;
 304
 305         if (dccp_non_data_packet(skb))
 306                 ++dp->dccps_ndp_count;
 307         else
 308                 dp->dccps_ndp_count = 0;
 309
 310         if (ndp > 0) {
 311                 unsigned char *ptr;
 312                 const int ndp_len = dccp_ndp_len(ndp);
 313                 const int len = ndp_len + 2;
 314
 315                 if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)
 316                         return;
 317
 318                 DCCP_SKB_CB(skb)->dccpd_opt_len += len;
 319
 320                 ptr = skb_push(skb, len);
 321                 *ptr++ = DCCPO_NDP_COUNT;
 322                 *ptr++ = len;
 323                 dccp_encode_value_var(ndp, ptr, ndp_len);
 324         }
 325 }
 326
 327 static inline int dccp_elapsed_time_len(const u32 elapsed_time)
 328 {
 329         return elapsed_time == 0 ? 0 : elapsed_time <= 0xFFFF ? 2 : 4;
 330 }
 331
 332 void dccp_insert_option_elapsed_time(struct sock *sk,
 333                                      struct sk_buff *skb,
 334                                      u32 elapsed_time)
 335 {
 336 #ifdef CONFIG_IP_DCCP_DEBUG
 337         struct dccp_sock *dp = dccp_sk(sk);
 338         const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
 339                                         "CLIENT TX opt: " : "server TX opt: ";
 340 #endif
 341         const int elapsed_time_len = dccp_elapsed_time_len(elapsed_time);
 342         const int len = 2 + elapsed_time_len;
 343         unsigned char *to;
 344
 345         if (elapsed_time_len == 0)
 346                 return;
 347
 348         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) {
 349                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to "
 350                                          "insert elapsed time!\n");
 351                 return;
 352         }
 353
 354         DCCP_SKB_CB(skb)->dccpd_opt_len += len;
 355
 356         to    = skb_push(skb, len);
 357         *to++ = DCCPO_ELAPSED_TIME;
 358         *to++ = len;
 359
 360         if (elapsed_time_len == 2) {
 361                 const __be16 var16 = htons((u16)elapsed_time);
 362                 memcpy(to, &var16, 2);
 363         } else {
 364                 const __be32 var32 = htonl(elapsed_time);
 365                 memcpy(to, &var32, 4);
 366         }
 367
 368         dccp_pr_debug("%sELAPSED_TIME=%u, len=%d, seqno=%llu\n",
 369                       debug_prefix, elapsed_time,
 370                       len,
 371                       (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq);
 372 }
 373
 374 EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time);
 375
 376 void dccp_timestamp(const struct sock *sk, struct timeval *tv)
 377 {
 378         const struct dccp_sock *dp = dccp_sk(sk);
 379
 380         do_gettimeofday(tv);
 381         tv->tv_sec  -= dp->dccps_epoch.tv_sec;
 382         tv->tv_usec -= dp->dccps_epoch.tv_usec;
 383
 384         while (tv->tv_usec < 0) {
 385                 tv->tv_sec--;
 386                 tv->tv_usec += USEC_PER_SEC;
 387         }
 388 }
 389
 390 EXPORT_SYMBOL_GPL(dccp_timestamp);
 391
 392 void dccp_insert_option_timestamp(struct sock *sk, struct sk_buff *skb)
 393 {
 394         struct timeval tv;
 395         __be32 now;
 396
 397         dccp_timestamp(sk, &tv);
 398         now = htonl(timeval_usecs(&tv) / 10);
 399         /* yes this will overflow but that is the point as we want a
 400          * 10 usec 32 bit timer which mean it wraps every 11.9 hours */
 401
 402         dccp_insert_option(sk, skb, DCCPO_TIMESTAMP, &now, sizeof(now));
 403 }
 404
 405 EXPORT_SYMBOL_GPL(dccp_insert_option_timestamp);
 406
 407 static void dccp_insert_option_timestamp_echo(struct sock *sk,
 408                                               struct sk_buff *skb)
 409 {
 410         struct dccp_sock *dp = dccp_sk(sk);
 411 #ifdef CONFIG_IP_DCCP_DEBUG
 412         const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
 413                                         "CLIENT TX opt: " : "server TX opt: ";
 414 #endif
 415         struct timeval now;
 416         __be32 tstamp_echo;
 417         u32 elapsed_time;
 418         int len, elapsed_time_len;
 419         unsigned char *to;
 420
 421         dccp_timestamp(sk, &now);
 422         elapsed_time = timeval_delta(&now, &dp->dccps_timestamp_time) / 10;
 423         elapsed_time_len = dccp_elapsed_time_len(elapsed_time);
 424         len = 6 + elapsed_time_len;
 425
 426         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) {
 427                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to insert "
 428                                          "timestamp echo!\n");
 429                 return;
 430         }
 431
 432         DCCP_SKB_CB(skb)->dccpd_opt_len += len;
 433
 434         to    = skb_push(skb, len);
 435         *to++ = DCCPO_TIMESTAMP_ECHO;
 436         *to++ = len;
 437
 438         tstamp_echo = htonl(dp->dccps_timestamp_echo);
 439         memcpy(to, &tstamp_echo, 4);
 440         to += 4;
 441
 442         if (elapsed_time_len == 2) {
 443                 const __be16 var16 = htons((u16)elapsed_time);
 444                 memcpy(to, &var16, 2);
 445         } else if (elapsed_time_len == 4) {
 446                 const __be32 var32 = htonl(elapsed_time);
 447                 memcpy(to, &var32, 4);
 448         }
 449
 450         dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, seqno=%llu\n",
 451                       debug_prefix, dp->dccps_timestamp_echo,
 452                       len,
 453                       (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq);
 454
 455         dp->dccps_timestamp_echo = 0;
 456         dp->dccps_timestamp_time.tv_sec = 0;
 457         dp->dccps_timestamp_time.tv_usec = 0;
 458 }
 459
 460 static int dccp_insert_feat_opt(struct sk_buff *skb, u8 type, u8 feat,
 461                                 u8 *val, u8 len)
 462 {
 463         u8 *to;
 464
 465         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len + 3 > DCCP_MAX_OPT_LEN) {
 466                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small"
 467                                " to insert feature %d option!\n", feat);
 468                 return -1;
 469         }
 470
 471         DCCP_SKB_CB(skb)->dccpd_opt_len += len + 3;
 472
 473         to    = skb_push(skb, len + 3);
 474         *to++ = type;
 475         *to++ = len + 3;
 476         *to++ = feat;
 477
 478         if (len)
 479                 memcpy(to, val, len);
 480         dccp_pr_debug("option %d feat %d len %d\n", type, feat, len);
 481
 482         return 0;
 483 }
 484
 485 static void dccp_insert_feat(struct sock *sk, struct sk_buff *skb)
 486 {
 487         struct dccp_sock *dp = dccp_sk(sk);
 488         struct dccp_opt_pend *opt, *next;
 489         int change = 0;
 490
 491         /* confirm any options [NN opts] */
 492         list_for_each_entry_safe(opt, next, &dp->dccps_options.dccpo_conf,
 493                                  dccpop_node) {
 494                 dccp_insert_feat_opt(skb, opt->dccpop_type,
 495                                      opt->dccpop_feat, opt->dccpop_val,
 496                                      opt->dccpop_len);
 497                 /* fear empty confirms */
 498                 if (opt->dccpop_val)
 499                         kfree(opt->dccpop_val);
 500                 kfree(opt);
 501         }
 502         INIT_LIST_HEAD(&dp->dccps_options.dccpo_conf);
 503
 504         /* see which features we need to send */
 505         list_for_each_entry(opt, &dp->dccps_options.dccpo_pending,
 506                             dccpop_node) {
 507                 /* see if we need to send any confirm */
 508                 if (opt->dccpop_sc) {
 509                         dccp_insert_feat_opt(skb, opt->dccpop_type + 1,
 510                                              opt->dccpop_feat,
 511                                              opt->dccpop_sc->dccpoc_val,
 512                                              opt->dccpop_sc->dccpoc_len);
 513
 514                         BUG_ON(!opt->dccpop_sc->dccpoc_val);
 515                         kfree(opt->dccpop_sc->dccpoc_val);
 516                         kfree(opt->dccpop_sc);
 517                         opt->dccpop_sc = NULL;
 518                 }
 519
 520                 /* any option not confirmed, re-send it */
 521                 if (!opt->dccpop_conf) {
 522                         dccp_insert_feat_opt(skb, opt->dccpop_type,
 523                                              opt->dccpop_feat, opt->dccpop_val,
 524                                              opt->dccpop_len);
 525                         change++;
 526                 }
 527         }
 528
 529         /* Retransmit timer.
 530          * If this is the master listening sock, we don't set a timer on it.  It
 531          * should be fine because if the dude doesn't receive our RESPONSE
 532          * [which will contain the CHANGE] he will send another REQUEST which
 533          * will "retrnasmit" the change.
 534          */
 535         if (change && dp->dccps_role != DCCP_ROLE_LISTEN) {
 536                 dccp_pr_debug("reset feat negotiation timer %p\n", sk);
 537
 538                 /* XXX don't reset the timer on re-transmissions.  I.e. reset it
 539                  * only when sending new stuff i guess.  Currently the timer
 540                  * never backs off because on re-transmission it just resets it!
 541                  */
 542                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
 543                                           inet_csk(sk)->icsk_rto, DCCP_RTO_MAX);
 544         }
 545 }
 546
 547 void dccp_insert_options(struct sock *sk, struct sk_buff *skb)
 548 {
 549         struct dccp_sock *dp = dccp_sk(sk);
 550
 551         DCCP_SKB_CB(skb)->dccpd_opt_len = 0;
 552
 553         if (dp->dccps_options.dccpo_send_ndp_count)
 554                 dccp_insert_option_ndp(sk, skb);
 555
 556         if (!dccp_packet_without_ack(skb)) {
 557                 if (dp->dccps_options.dccpo_send_ack_vector &&
 558                     dccp_ackvec_pending(dp->dccps_hc_rx_ackvec))
 559                         dccp_insert_option_ackvec(sk, skb);
 560                 if (dp->dccps_timestamp_echo != 0)
 561                         dccp_insert_option_timestamp_echo(sk, skb);
 562         }
 563
 564         if (dp->dccps_hc_rx_insert_options) {
 565                 ccid_hc_rx_insert_options(dp->dccps_hc_rx_ccid, sk, skb);
 566                 dp->dccps_hc_rx_insert_options = 0;
 567         }
 568         if (dp->dccps_hc_tx_insert_options) {
 569                 ccid_hc_tx_insert_options(dp->dccps_hc_tx_ccid, sk, skb);
 570                 dp->dccps_hc_tx_insert_options = 0;
 571         }
 572
 573         /* Feature negotiation */
 574         switch(DCCP_SKB_CB(skb)->dccpd_type) {
 575                 /* Data packets can't do feat negotiation */
 576         case DCCP_PKT_DATA:
 577         case DCCP_PKT_DATAACK:
 578                 break;
 579         default:
 580                 dccp_insert_feat(sk, skb);
 581                 break;
 582         }
 583
 584         /* XXX: insert other options when appropriate */
 585
 586         if (DCCP_SKB_CB(skb)->dccpd_opt_len != 0) {
 587                 /* The length of all options has to be a multiple of 4 */
 588                 int padding = DCCP_SKB_CB(skb)->dccpd_opt_len % 4;
 589
 590                 if (padding != 0) {
 591                         padding = 4 - padding;
 592                         memset(skb_push(skb, padding), 0, padding);
 593                         DCCP_SKB_CB(skb)->dccpd_opt_len += padding;
 594                 }
 595         }
 596 }