linux/net/dccp/options.c
<<
>>
Prefs
   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 <ian.mcdonald@jandi.co.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/dccp.h>
  15#include <linux/module.h>
  16#include <linux/types.h>
  17#include <asm/unaligned.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
  26u64 dccp_decode_value_var(const u8 *bf, const u8 len)
  27{
  28        u64 value = 0;
  29
  30        if (len >= DCCP_OPTVAL_MAXLEN)
  31                value += ((u64)*bf++) << 40;
  32        if (len > 4)
  33                value += ((u64)*bf++) << 32;
  34        if (len > 3)
  35                value += ((u64)*bf++) << 24;
  36        if (len > 2)
  37                value += ((u64)*bf++) << 16;
  38        if (len > 1)
  39                value += ((u64)*bf++) << 8;
  40        if (len > 0)
  41                value += *bf;
  42
  43        return value;
  44}
  45
  46/**
  47 * dccp_parse_options  -  Parse DCCP options present in @skb
  48 * @sk: client|server|listening dccp socket (when @dreq != NULL)
  49 * @dreq: request socket to use during connection setup, or NULL
  50 */
  51int dccp_parse_options(struct sock *sk, struct dccp_request_sock *dreq,
  52                       struct sk_buff *skb)
  53{
  54        struct dccp_sock *dp = dccp_sk(sk);
  55        const struct dccp_hdr *dh = dccp_hdr(skb);
  56        const u8 pkt_type = DCCP_SKB_CB(skb)->dccpd_type;
  57        unsigned char *options = (unsigned char *)dh + dccp_hdr_len(skb);
  58        unsigned char *opt_ptr = options;
  59        const unsigned char *opt_end = (unsigned char *)dh +
  60                                        (dh->dccph_doff * 4);
  61        struct dccp_options_received *opt_recv = &dp->dccps_options_received;
  62        unsigned char opt, len;
  63        unsigned char *uninitialized_var(value);
  64        u32 elapsed_time;
  65        __be32 opt_val;
  66        int rc;
  67        int mandatory = 0;
  68
  69        memset(opt_recv, 0, sizeof(*opt_recv));
  70
  71        opt = len = 0;
  72        while (opt_ptr != opt_end) {
  73                opt   = *opt_ptr++;
  74                len   = 0;
  75                value = NULL;
  76
  77                /* Check if this isn't a single byte option */
  78                if (opt > DCCPO_MAX_RESERVED) {
  79                        if (opt_ptr == opt_end)
  80                                goto out_nonsensical_length;
  81
  82                        len = *opt_ptr++;
  83                        if (len < 2)
  84                                goto out_nonsensical_length;
  85                        /*
  86                         * Remove the type and len fields, leaving
  87                         * just the value size
  88                         */
  89                        len     -= 2;
  90                        value   = opt_ptr;
  91                        opt_ptr += len;
  92
  93                        if (opt_ptr > opt_end)
  94                                goto out_nonsensical_length;
  95                }
  96
  97                /*
  98                 * CCID-specific options are ignored during connection setup, as
  99                 * negotiation may still be in progress (see RFC 4340, 10.3).
 100                 * The same applies to Ack Vectors, as these depend on the CCID.
 101                 */
 102                if (dreq != NULL && (opt >= DCCPO_MIN_RX_CCID_SPECIFIC ||
 103                    opt == DCCPO_ACK_VECTOR_0 || opt == DCCPO_ACK_VECTOR_1))
 104                        goto ignore_option;
 105
 106                switch (opt) {
 107                case DCCPO_PADDING:
 108                        break;
 109                case DCCPO_MANDATORY:
 110                        if (mandatory)
 111                                goto out_invalid_option;
 112                        if (pkt_type != DCCP_PKT_DATA)
 113                                mandatory = 1;
 114                        break;
 115                case DCCPO_NDP_COUNT:
 116                        if (len > 6)
 117                                goto out_invalid_option;
 118
 119                        opt_recv->dccpor_ndp = dccp_decode_value_var(value, len);
 120                        dccp_pr_debug("%s opt: NDP count=%llu\n", dccp_role(sk),
 121                                      (unsigned long long)opt_recv->dccpor_ndp);
 122                        break;
 123                case DCCPO_CHANGE_L ... DCCPO_CONFIRM_R:
 124                        if (pkt_type == DCCP_PKT_DATA)      /* RFC 4340, 6 */
 125                                break;
 126                        if (len == 0)
 127                                goto out_invalid_option;
 128                        rc = dccp_feat_parse_options(sk, dreq, mandatory, opt,
 129                                                    *value, value + 1, len - 1);
 130                        if (rc)
 131                                goto out_featneg_failed;
 132                        break;
 133                case DCCPO_TIMESTAMP:
 134                        if (len != 4)
 135                                goto out_invalid_option;
 136                        /*
 137                         * RFC 4340 13.1: "The precise time corresponding to
 138                         * Timestamp Value zero is not specified". We use
 139                         * zero to indicate absence of a meaningful timestamp.
 140                         */
 141                        opt_val = get_unaligned((__be32 *)value);
 142                        if (unlikely(opt_val == 0)) {
 143                                DCCP_WARN("Timestamp with zero value\n");
 144                                break;
 145                        }
 146
 147                        if (dreq != NULL) {
 148                                dreq->dreq_timestamp_echo = ntohl(opt_val);
 149                                dreq->dreq_timestamp_time = dccp_timestamp();
 150                        } else {
 151                                opt_recv->dccpor_timestamp =
 152                                        dp->dccps_timestamp_echo = ntohl(opt_val);
 153                                dp->dccps_timestamp_time = dccp_timestamp();
 154                        }
 155                        dccp_pr_debug("%s rx opt: TIMESTAMP=%u, ackno=%llu\n",
 156                                      dccp_role(sk), ntohl(opt_val),
 157                                      (unsigned long long)
 158                                      DCCP_SKB_CB(skb)->dccpd_ack_seq);
 159                        /* schedule an Ack in case this sender is quiescent */
 160                        inet_csk_schedule_ack(sk);
 161                        break;
 162                case DCCPO_TIMESTAMP_ECHO:
 163                        if (len != 4 && len != 6 && len != 8)
 164                                goto out_invalid_option;
 165
 166                        opt_val = get_unaligned((__be32 *)value);
 167                        opt_recv->dccpor_timestamp_echo = ntohl(opt_val);
 168
 169                        dccp_pr_debug("%s rx opt: TIMESTAMP_ECHO=%u, len=%d, "
 170                                      "ackno=%llu", dccp_role(sk),
 171                                      opt_recv->dccpor_timestamp_echo,
 172                                      len + 2,
 173                                      (unsigned long long)
 174                                      DCCP_SKB_CB(skb)->dccpd_ack_seq);
 175
 176                        value += 4;
 177
 178                        if (len == 4) {         /* no elapsed time included */
 179                                dccp_pr_debug_cat("\n");
 180                                break;
 181                        }
 182
 183                        if (len == 6) {         /* 2-byte elapsed time */
 184                                __be16 opt_val2 = get_unaligned((__be16 *)value);
 185                                elapsed_time = ntohs(opt_val2);
 186                        } else {                /* 4-byte elapsed time */
 187                                opt_val = get_unaligned((__be32 *)value);
 188                                elapsed_time = ntohl(opt_val);
 189                        }
 190
 191                        dccp_pr_debug_cat(", ELAPSED_TIME=%u\n", elapsed_time);
 192
 193                        /* Give precedence to the biggest ELAPSED_TIME */
 194                        if (elapsed_time > opt_recv->dccpor_elapsed_time)
 195                                opt_recv->dccpor_elapsed_time = elapsed_time;
 196                        break;
 197                case DCCPO_ELAPSED_TIME:
 198                        if (dccp_packet_without_ack(skb))   /* RFC 4340, 13.2 */
 199                                break;
 200
 201                        if (len == 2) {
 202                                __be16 opt_val2 = get_unaligned((__be16 *)value);
 203                                elapsed_time = ntohs(opt_val2);
 204                        } else if (len == 4) {
 205                                opt_val = get_unaligned((__be32 *)value);
 206                                elapsed_time = ntohl(opt_val);
 207                        } else {
 208                                goto out_invalid_option;
 209                        }
 210
 211                        if (elapsed_time > opt_recv->dccpor_elapsed_time)
 212                                opt_recv->dccpor_elapsed_time = elapsed_time;
 213
 214                        dccp_pr_debug("%s rx opt: ELAPSED_TIME=%d\n",
 215                                      dccp_role(sk), elapsed_time);
 216                        break;
 217                case DCCPO_MIN_RX_CCID_SPECIFIC ... DCCPO_MAX_RX_CCID_SPECIFIC:
 218                        if (ccid_hc_rx_parse_options(dp->dccps_hc_rx_ccid, sk,
 219                                                     pkt_type, opt, value, len))
 220                                goto out_invalid_option;
 221                        break;
 222                case DCCPO_ACK_VECTOR_0:
 223                case DCCPO_ACK_VECTOR_1:
 224                        if (dccp_packet_without_ack(skb))   /* RFC 4340, 11.4 */
 225                                break;
 226                        /*
 227                         * Ack vectors are processed by the TX CCID if it is
 228                         * interested. The RX CCID need not parse Ack Vectors,
 229                         * since it is only interested in clearing old state.
 230                         * Fall through.
 231                         */
 232                case DCCPO_MIN_TX_CCID_SPECIFIC ... DCCPO_MAX_TX_CCID_SPECIFIC:
 233                        if (ccid_hc_tx_parse_options(dp->dccps_hc_tx_ccid, sk,
 234                                                     pkt_type, opt, value, len))
 235                                goto out_invalid_option;
 236                        break;
 237                default:
 238                        DCCP_CRIT("DCCP(%p): option %d(len=%d) not "
 239                                  "implemented, ignoring", sk, opt, len);
 240                        break;
 241                }
 242ignore_option:
 243                if (opt != DCCPO_MANDATORY)
 244                        mandatory = 0;
 245        }
 246
 247        /* mandatory was the last byte in option list -> reset connection */
 248        if (mandatory)
 249                goto out_invalid_option;
 250
 251out_nonsensical_length:
 252        /* RFC 4340, 5.8: ignore option and all remaining option space */
 253        return 0;
 254
 255out_invalid_option:
 256        DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT);
 257        rc = DCCP_RESET_CODE_OPTION_ERROR;
 258out_featneg_failed:
 259        DCCP_WARN("DCCP(%p): Option %d (len=%d) error=%u\n", sk, opt, len, rc);
 260        DCCP_SKB_CB(skb)->dccpd_reset_code = rc;
 261        DCCP_SKB_CB(skb)->dccpd_reset_data[0] = opt;
 262        DCCP_SKB_CB(skb)->dccpd_reset_data[1] = len > 0 ? value[0] : 0;
 263        DCCP_SKB_CB(skb)->dccpd_reset_data[2] = len > 1 ? value[1] : 0;
 264        return -1;
 265}
 266
 267EXPORT_SYMBOL_GPL(dccp_parse_options);
 268
 269void dccp_encode_value_var(const u64 value, u8 *to, const u8 len)
 270{
 271        if (len >= DCCP_OPTVAL_MAXLEN)
 272                *to++ = (value & 0xFF0000000000ull) >> 40;
 273        if (len > 4)
 274                *to++ = (value & 0xFF00000000ull) >> 32;
 275        if (len > 3)
 276                *to++ = (value & 0xFF000000) >> 24;
 277        if (len > 2)
 278                *to++ = (value & 0xFF0000) >> 16;
 279        if (len > 1)
 280                *to++ = (value & 0xFF00) >> 8;
 281        if (len > 0)
 282                *to++ = (value & 0xFF);
 283}
 284
 285static inline u8 dccp_ndp_len(const u64 ndp)
 286{
 287        if (likely(ndp <= 0xFF))
 288                return 1;
 289        return likely(ndp <= USHRT_MAX) ? 2 : (ndp <= UINT_MAX ? 4 : 6);
 290}
 291
 292int dccp_insert_option(struct sk_buff *skb, const unsigned char option,
 293                       const void *value, const unsigned char len)
 294{
 295        unsigned char *to;
 296
 297        if (DCCP_SKB_CB(skb)->dccpd_opt_len + len + 2 > DCCP_MAX_OPT_LEN)
 298                return -1;
 299
 300        DCCP_SKB_CB(skb)->dccpd_opt_len += len + 2;
 301
 302        to    = skb_push(skb, len + 2);
 303        *to++ = option;
 304        *to++ = len + 2;
 305
 306        memcpy(to, value, len);
 307        return 0;
 308}
 309
 310EXPORT_SYMBOL_GPL(dccp_insert_option);
 311
 312static int dccp_insert_option_ndp(struct sock *sk, struct sk_buff *skb)
 313{
 314        struct dccp_sock *dp = dccp_sk(sk);
 315        u64 ndp = dp->dccps_ndp_count;
 316
 317        if (dccp_non_data_packet(skb))
 318                ++dp->dccps_ndp_count;
 319        else
 320                dp->dccps_ndp_count = 0;
 321
 322        if (ndp > 0) {
 323                unsigned char *ptr;
 324                const int ndp_len = dccp_ndp_len(ndp);
 325                const int len = ndp_len + 2;
 326
 327                if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)
 328                        return -1;
 329
 330                DCCP_SKB_CB(skb)->dccpd_opt_len += len;
 331
 332                ptr = skb_push(skb, len);
 333                *ptr++ = DCCPO_NDP_COUNT;
 334                *ptr++ = len;
 335                dccp_encode_value_var(ndp, ptr, ndp_len);
 336        }
 337
 338        return 0;
 339}
 340
 341static inline int dccp_elapsed_time_len(const u32 elapsed_time)
 342{
 343        return elapsed_time == 0 ? 0 : elapsed_time <= 0xFFFF ? 2 : 4;
 344}
 345
 346/* FIXME: This function is currently not used anywhere */
 347int dccp_insert_option_elapsed_time(struct sk_buff *skb, u32 elapsed_time)
 348{
 349        const int elapsed_time_len = dccp_elapsed_time_len(elapsed_time);
 350        const int len = 2 + elapsed_time_len;
 351        unsigned char *to;
 352
 353        if (elapsed_time_len == 0)
 354                return 0;
 355
 356        if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)
 357                return -1;
 358
 359        DCCP_SKB_CB(skb)->dccpd_opt_len += len;
 360
 361        to    = skb_push(skb, len);
 362        *to++ = DCCPO_ELAPSED_TIME;
 363        *to++ = len;
 364
 365        if (elapsed_time_len == 2) {
 366                const __be16 var16 = htons((u16)elapsed_time);
 367                memcpy(to, &var16, 2);
 368        } else {
 369                const __be32 var32 = htonl(elapsed_time);
 370                memcpy(to, &var32, 4);
 371        }
 372
 373        return 0;
 374}
 375
 376EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time);
 377
 378static int dccp_insert_option_timestamp(struct sk_buff *skb)
 379{
 380        __be32 now = htonl(dccp_timestamp());
 381        /* yes this will overflow but that is the point as we want a
 382         * 10 usec 32 bit timer which mean it wraps every 11.9 hours */
 383
 384        return dccp_insert_option(skb, DCCPO_TIMESTAMP, &now, sizeof(now));
 385}
 386
 387static int dccp_insert_option_timestamp_echo(struct dccp_sock *dp,
 388                                             struct dccp_request_sock *dreq,
 389                                             struct sk_buff *skb)
 390{
 391        __be32 tstamp_echo;
 392        unsigned char *to;
 393        u32 elapsed_time, elapsed_time_len, len;
 394
 395        if (dreq != NULL) {
 396                elapsed_time = dccp_timestamp() - dreq->dreq_timestamp_time;
 397                tstamp_echo  = htonl(dreq->dreq_timestamp_echo);
 398                dreq->dreq_timestamp_echo = 0;
 399        } else {
 400                elapsed_time = dccp_timestamp() - dp->dccps_timestamp_time;
 401                tstamp_echo  = htonl(dp->dccps_timestamp_echo);
 402                dp->dccps_timestamp_echo = 0;
 403        }
 404
 405        elapsed_time_len = dccp_elapsed_time_len(elapsed_time);
 406        len = 6 + elapsed_time_len;
 407
 408        if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)
 409                return -1;
 410
 411        DCCP_SKB_CB(skb)->dccpd_opt_len += len;
 412
 413        to    = skb_push(skb, len);
 414        *to++ = DCCPO_TIMESTAMP_ECHO;
 415        *to++ = len;
 416
 417        memcpy(to, &tstamp_echo, 4);
 418        to += 4;
 419
 420        if (elapsed_time_len == 2) {
 421                const __be16 var16 = htons((u16)elapsed_time);
 422                memcpy(to, &var16, 2);
 423        } else if (elapsed_time_len == 4) {
 424                const __be32 var32 = htonl(elapsed_time);
 425                memcpy(to, &var32, 4);
 426        }
 427
 428        return 0;
 429}
 430
 431static int dccp_insert_option_ackvec(struct sock *sk, struct sk_buff *skb)
 432{
 433        struct dccp_sock *dp = dccp_sk(sk);
 434        struct dccp_ackvec *av = dp->dccps_hc_rx_ackvec;
 435        struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
 436        const u16 buflen = dccp_ackvec_buflen(av);
 437        /* Figure out how many options do we need to represent the ackvec */
 438        const u8 nr_opts = DIV_ROUND_UP(buflen, DCCP_SINGLE_OPT_MAXLEN);
 439        u16 len = buflen + 2 * nr_opts;
 440        u8 i, nonce = 0;
 441        const unsigned char *tail, *from;
 442        unsigned char *to;
 443
 444        if (dcb->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) {
 445                DCCP_WARN("Lacking space for %u bytes on %s packet\n", len,
 446                          dccp_packet_name(dcb->dccpd_type));
 447                return -1;
 448        }
 449        /*
 450         * Since Ack Vectors are variable-length, we can not always predict
 451         * their size. To catch exception cases where the space is running out
 452         * on the skb, a separate Sync is scheduled to carry the Ack Vector.
 453         */
 454        if (len > DCCPAV_MIN_OPTLEN &&
 455            len + dcb->dccpd_opt_len + skb->len > dp->dccps_mss_cache) {
 456                DCCP_WARN("No space left for Ack Vector (%u) on skb (%u+%u), "
 457                          "MPS=%u ==> reduce payload size?\n", len, skb->len,
 458                          dcb->dccpd_opt_len, dp->dccps_mss_cache);
 459                dp->dccps_sync_scheduled = 1;
 460                return 0;
 461        }
 462        dcb->dccpd_opt_len += len;
 463
 464        to   = skb_push(skb, len);
 465        len  = buflen;
 466        from = av->av_buf + av->av_buf_head;
 467        tail = av->av_buf + DCCPAV_MAX_ACKVEC_LEN;
 468
 469        for (i = 0; i < nr_opts; ++i) {
 470                int copylen = len;
 471
 472                if (len > DCCP_SINGLE_OPT_MAXLEN)
 473                        copylen = DCCP_SINGLE_OPT_MAXLEN;
 474
 475                /*
 476                 * RFC 4340, 12.2: Encode the Nonce Echo for this Ack Vector via
 477                 * its type; ack_nonce is the sum of all individual buf_nonce's.
 478                 */
 479                nonce ^= av->av_buf_nonce[i];
 480
 481                *to++ = DCCPO_ACK_VECTOR_0 + av->av_buf_nonce[i];
 482                *to++ = copylen + 2;
 483
 484                /* Check if buf_head wraps */
 485                if (from + copylen > tail) {
 486                        const u16 tailsize = tail - from;
 487
 488                        memcpy(to, from, tailsize);
 489                        to      += tailsize;
 490                        len     -= tailsize;
 491                        copylen -= tailsize;
 492                        from    = av->av_buf;
 493                }
 494
 495                memcpy(to, from, copylen);
 496                from += copylen;
 497                to   += copylen;
 498                len  -= copylen;
 499        }
 500        /*
 501         * Each sent Ack Vector is recorded in the list, as per A.2 of RFC 4340.
 502         */
 503        if (dccp_ackvec_update_records(av, dcb->dccpd_seq, nonce))
 504                return -ENOBUFS;
 505        return 0;
 506}
 507
 508/**
 509 * dccp_insert_option_mandatory  -  Mandatory option (5.8.2)
 510 * Note that since we are using skb_push, this function needs to be called
 511 * _after_ inserting the option it is supposed to influence (stack order).
 512 */
 513int dccp_insert_option_mandatory(struct sk_buff *skb)
 514{
 515        if (DCCP_SKB_CB(skb)->dccpd_opt_len >= DCCP_MAX_OPT_LEN)
 516                return -1;
 517
 518        DCCP_SKB_CB(skb)->dccpd_opt_len++;
 519        *skb_push(skb, 1) = DCCPO_MANDATORY;
 520        return 0;
 521}
 522
 523/**
 524 * dccp_insert_fn_opt  -  Insert single Feature-Negotiation option into @skb
 525 * @type: %DCCPO_CHANGE_L, %DCCPO_CHANGE_R, %DCCPO_CONFIRM_L, %DCCPO_CONFIRM_R
 526 * @feat: one out of %dccp_feature_numbers
 527 * @val: NN value or SP array (preferred element first) to copy
 528 * @len: true length of @val in bytes (excluding first element repetition)
 529 * @repeat_first: whether to copy the first element of @val twice
 530 *
 531 * The last argument is used to construct Confirm options, where the preferred
 532 * value and the preference list appear separately (RFC 4340, 6.3.1). Preference
 533 * lists are kept such that the preferred entry is always first, so we only need
 534 * to copy twice, and avoid the overhead of cloning into a bigger array.
 535 */
 536int dccp_insert_fn_opt(struct sk_buff *skb, u8 type, u8 feat,
 537                       u8 *val, u8 len, bool repeat_first)
 538{
 539        u8 tot_len, *to;
 540
 541        /* take the `Feature' field and possible repetition into account */
 542        if (len > (DCCP_SINGLE_OPT_MAXLEN - 2)) {
 543                DCCP_WARN("length %u for feature %u too large\n", len, feat);
 544                return -1;
 545        }
 546
 547        if (unlikely(val == NULL || len == 0))
 548                len = repeat_first = false;
 549        tot_len = 3 + repeat_first + len;
 550
 551        if (DCCP_SKB_CB(skb)->dccpd_opt_len + tot_len > DCCP_MAX_OPT_LEN) {
 552                DCCP_WARN("packet too small for feature %d option!\n", feat);
 553                return -1;
 554        }
 555        DCCP_SKB_CB(skb)->dccpd_opt_len += tot_len;
 556
 557        to    = skb_push(skb, tot_len);
 558        *to++ = type;
 559        *to++ = tot_len;
 560        *to++ = feat;
 561
 562        if (repeat_first)
 563                *to++ = *val;
 564        if (len)
 565                memcpy(to, val, len);
 566        return 0;
 567}
 568
 569/* The length of all options needs to be a multiple of 4 (5.8) */
 570static void dccp_insert_option_padding(struct sk_buff *skb)
 571{
 572        int padding = DCCP_SKB_CB(skb)->dccpd_opt_len % 4;
 573
 574        if (padding != 0) {
 575                padding = 4 - padding;
 576                memset(skb_push(skb, padding), 0, padding);
 577                DCCP_SKB_CB(skb)->dccpd_opt_len += padding;
 578        }
 579}
 580
 581int dccp_insert_options(struct sock *sk, struct sk_buff *skb)
 582{
 583        struct dccp_sock *dp = dccp_sk(sk);
 584
 585        DCCP_SKB_CB(skb)->dccpd_opt_len = 0;
 586
 587        if (dp->dccps_send_ndp_count && dccp_insert_option_ndp(sk, skb))
 588                return -1;
 589
 590        if (DCCP_SKB_CB(skb)->dccpd_type != DCCP_PKT_DATA) {
 591
 592                /* Feature Negotiation */
 593                if (dccp_feat_insert_opts(dp, NULL, skb))
 594                        return -1;
 595
 596                if (DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_REQUEST) {
 597                        /*
 598                         * Obtain RTT sample from Request/Response exchange.
 599                         * This is currently used for TFRC initialisation.
 600                         */
 601                        if (dccp_insert_option_timestamp(skb))
 602                                return -1;
 603
 604                } else if (dccp_ackvec_pending(sk) &&
 605                           dccp_insert_option_ackvec(sk, skb)) {
 606                                return -1;
 607                }
 608        }
 609
 610        if (dp->dccps_hc_rx_insert_options) {
 611                if (ccid_hc_rx_insert_options(dp->dccps_hc_rx_ccid, sk, skb))
 612                        return -1;
 613                dp->dccps_hc_rx_insert_options = 0;
 614        }
 615
 616        if (dp->dccps_timestamp_echo != 0 &&
 617            dccp_insert_option_timestamp_echo(dp, NULL, skb))
 618                return -1;
 619
 620        dccp_insert_option_padding(skb);
 621        return 0;
 622}
 623
 624int dccp_insert_options_rsk(struct dccp_request_sock *dreq, struct sk_buff *skb)
 625{
 626        DCCP_SKB_CB(skb)->dccpd_opt_len = 0;
 627
 628        if (dccp_feat_insert_opts(NULL, dreq, skb))
 629                return -1;
 630
 631        /* Obtain RTT sample from Response/Ack exchange (used by TFRC). */
 632        if (dccp_insert_option_timestamp(skb))
 633                return -1;
 634
 635        if (dreq->dreq_timestamp_echo != 0 &&
 636            dccp_insert_option_timestamp_echo(NULL, dreq, skb))
 637                return -1;
 638
 639        dccp_insert_option_padding(skb);
 640        return 0;
 641}
 642
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.