linux/net/dccp/output.c
<<
>>
Prefs
   1/*
   2 *  net/dccp/output.c
   3 *
   4 *  An implementation of the DCCP protocol
   5 *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   6 *
   7 *      This program is free software; you can redistribute it and/or
   8 *      modify it under the terms of the GNU General Public License
   9 *      as published by the Free Software Foundation; either version
  10 *      2 of the License, or (at your option) any later version.
  11 */
  12
  13#include <linux/dccp.h>
  14#include <linux/kernel.h>
  15#include <linux/skbuff.h>
  16
  17#include <net/inet_sock.h>
  18#include <net/sock.h>
  19
  20#include "ackvec.h"
  21#include "ccid.h"
  22#include "dccp.h"
  23
  24static inline void dccp_event_ack_sent(struct sock *sk)
  25{
  26        inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
  27}
  28
  29static void dccp_skb_entail(struct sock *sk, struct sk_buff *skb)
  30{
  31        skb_set_owner_w(skb, sk);
  32        WARN_ON(sk->sk_send_head);
  33        sk->sk_send_head = skb;
  34}
  35
  36/*
  37 * All SKB's seen here are completely headerless. It is our
  38 * job to build the DCCP header, and pass the packet down to
  39 * IP so it can do the same plus pass the packet off to the
  40 * device.
  41 */
  42static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb)
  43{
  44        if (likely(skb != NULL)) {
  45                const struct inet_sock *inet = inet_sk(sk);
  46                const struct inet_connection_sock *icsk = inet_csk(sk);
  47                struct dccp_sock *dp = dccp_sk(sk);
  48                struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
  49                struct dccp_hdr *dh;
  50                /* XXX For now we're using only 48 bits sequence numbers */
  51                const u32 dccp_header_size = sizeof(*dh) +
  52                                             sizeof(struct dccp_hdr_ext) +
  53                                          dccp_packet_hdr_len(dcb->dccpd_type);
  54                int err, set_ack = 1;
  55                u64 ackno = dp->dccps_gsr;
  56                /*
  57                 * Increment GSS here already in case the option code needs it.
  58                 * Update GSS for real only if option processing below succeeds.
  59                 */
  60                dcb->dccpd_seq = ADD48(dp->dccps_gss, 1);
  61
  62                switch (dcb->dccpd_type) {
  63                case DCCP_PKT_DATA:
  64                        set_ack = 0;
  65                        /* fall through */
  66                case DCCP_PKT_DATAACK:
  67                case DCCP_PKT_RESET:
  68                        break;
  69
  70                case DCCP_PKT_REQUEST:
  71                        set_ack = 0;
  72                        /* Use ISS on the first (non-retransmitted) Request. */
  73                        if (icsk->icsk_retransmits == 0)
  74                                dcb->dccpd_seq = dp->dccps_iss;
  75                        /* fall through */
  76
  77                case DCCP_PKT_SYNC:
  78                case DCCP_PKT_SYNCACK:
  79                        ackno = dcb->dccpd_ack_seq;
  80                        /* fall through */
  81                default:
  82                        /*
  83                         * Set owner/destructor: some skbs are allocated via
  84                         * alloc_skb (e.g. when retransmission may happen).
  85                         * Only Data, DataAck, and Reset packets should come
  86                         * through here with skb->sk set.
  87                         */
  88                        WARN_ON(skb->sk);
  89                        skb_set_owner_w(skb, sk);
  90                        break;
  91                }
  92
  93                if (dccp_insert_options(sk, skb)) {
  94                        kfree_skb(skb);
  95                        return -EPROTO;
  96                }
  97
  98
  99                /* Build DCCP header and checksum it. */
 100                dh = dccp_zeroed_hdr(skb, dccp_header_size);
 101                dh->dccph_type  = dcb->dccpd_type;
 102                dh->dccph_sport = inet->sport;
 103                dh->dccph_dport = inet->dport;
 104                dh->dccph_doff  = (dccp_header_size + dcb->dccpd_opt_len) / 4;
 105                dh->dccph_ccval = dcb->dccpd_ccval;
 106                dh->dccph_cscov = dp->dccps_pcslen;
 107                /* XXX For now we're using only 48 bits sequence numbers */
 108                dh->dccph_x     = 1;
 109
 110                dccp_update_gss(sk, dcb->dccpd_seq);
 111                dccp_hdr_set_seq(dh, dp->dccps_gss);
 112                if (set_ack)
 113                        dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), ackno);
 114
 115                switch (dcb->dccpd_type) {
 116                case DCCP_PKT_REQUEST:
 117                        dccp_hdr_request(skb)->dccph_req_service =
 118                                                        dp->dccps_service;
 119                        /*
 120                         * Limit Ack window to ISS <= P.ackno <= GSS, so that
 121                         * only Responses to Requests we sent are considered.
 122                         */
 123                        dp->dccps_awl = dp->dccps_iss;
 124                        break;
 125                case DCCP_PKT_RESET:
 126                        dccp_hdr_reset(skb)->dccph_reset_code =
 127                                                        dcb->dccpd_reset_code;
 128                        break;
 129                }
 130
 131                icsk->icsk_af_ops->send_check(sk, 0, skb);
 132
 133                if (set_ack)
 134                        dccp_event_ack_sent(sk);
 135
 136                DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
 137
 138                err = icsk->icsk_af_ops->queue_xmit(skb, 0);
 139                return net_xmit_eval(err);
 140        }
 141        return -ENOBUFS;
 142}
 143
 144/**
 145 * dccp_determine_ccmps  -  Find out about CCID-specfic packet-size limits
 146 * We only consider the HC-sender CCID for setting the CCMPS (RFC 4340, 14.),
 147 * since the RX CCID is restricted to feedback packets (Acks), which are small
 148 * in comparison with the data traffic. A value of 0 means "no current CCMPS".
 149 */
 150static u32 dccp_determine_ccmps(const struct dccp_sock *dp)
 151{
 152        const struct ccid *tx_ccid = dp->dccps_hc_tx_ccid;
 153
 154        if (tx_ccid == NULL || tx_ccid->ccid_ops == NULL)
 155                return 0;
 156        return tx_ccid->ccid_ops->ccid_ccmps;
 157}
 158
 159unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu)
 160{
 161        struct inet_connection_sock *icsk = inet_csk(sk);
 162        struct dccp_sock *dp = dccp_sk(sk);
 163        u32 ccmps = dccp_determine_ccmps(dp);
 164        u32 cur_mps = ccmps ? min(pmtu, ccmps) : pmtu;
 165
 166        /* Account for header lengths and IPv4/v6 option overhead */
 167        cur_mps -= (icsk->icsk_af_ops->net_header_len + icsk->icsk_ext_hdr_len +
 168                    sizeof(struct dccp_hdr) + sizeof(struct dccp_hdr_ext));
 169
 170        /*
 171         * Leave enough headroom for common DCCP header options.
 172         * This only considers options which may appear on DCCP-Data packets, as
 173         * per table 3 in RFC 4340, 5.8. When running out of space for other
 174         * options (eg. Ack Vector which can take up to 255 bytes), it is better
 175         * to schedule a separate Ack. Thus we leave headroom for the following:
 176         *  - 1 byte for Slow Receiver (11.6)
 177         *  - 6 bytes for Timestamp (13.1)
 178         *  - 10 bytes for Timestamp Echo (13.3)
 179         *  - 8 bytes for NDP count (7.7, when activated)
 180         *  - 6 bytes for Data Checksum (9.3)
 181         *  - %DCCPAV_MIN_OPTLEN bytes for Ack Vector size (11.4, when enabled)
 182         */
 183        cur_mps -= roundup(1 + 6 + 10 + dp->dccps_send_ndp_count * 8 + 6 +
 184                           (dp->dccps_hc_rx_ackvec ? DCCPAV_MIN_OPTLEN : 0), 4);
 185
 186        /* And store cached results */
 187        icsk->icsk_pmtu_cookie = pmtu;
 188        dp->dccps_mss_cache = cur_mps;
 189
 190        return cur_mps;
 191}
 192
 193EXPORT_SYMBOL_GPL(dccp_sync_mss);
 194
 195void dccp_write_space(struct sock *sk)
 196{
 197        read_lock(&sk->sk_callback_lock);
 198
 199        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
 200                wake_up_interruptible(sk->sk_sleep);
 201        /* Should agree with poll, otherwise some programs break */
 202        if (sock_writeable(sk))
 203                sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 204
 205        read_unlock(&sk->sk_callback_lock);
 206}
 207
 208/**
 209 * dccp_wait_for_ccid - Wait for ccid to tell us we can send a packet
 210 * @sk:    socket to wait for
 211 * @skb:   current skb to pass on for waiting
 212 * @delay: sleep timeout in milliseconds (> 0)
 213 * This function is called by default when the socket is closed, and
 214 * when a non-zero linger time is set on the socket. For consistency
 215 */
 216static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
 217{
 218        struct dccp_sock *dp = dccp_sk(sk);
 219        DEFINE_WAIT(wait);
 220        unsigned long jiffdelay;
 221        int rc;
 222
 223        do {
 224                dccp_pr_debug("delayed send by %d msec\n", delay);
 225                jiffdelay = msecs_to_jiffies(delay);
 226
 227                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
 228
 229                sk->sk_write_pending++;
 230                release_sock(sk);
 231                schedule_timeout(jiffdelay);
 232                lock_sock(sk);
 233                sk->sk_write_pending--;
 234
 235                if (sk->sk_err)
 236                        goto do_error;
 237                if (signal_pending(current))
 238                        goto do_interrupted;
 239
 240                rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
 241        } while ((delay = rc) > 0);
 242out:
 243        finish_wait(sk->sk_sleep, &wait);
 244        return rc;
 245
 246do_error:
 247        rc = -EPIPE;
 248        goto out;
 249do_interrupted:
 250        rc = -EINTR;
 251        goto out;
 252}
 253
 254void dccp_write_xmit(struct sock *sk, int block)
 255{
 256        struct dccp_sock *dp = dccp_sk(sk);
 257        struct sk_buff *skb;
 258
 259        while ((skb = skb_peek(&sk->sk_write_queue))) {
 260                int err = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
 261
 262                if (err > 0) {
 263                        if (!block) {
 264                                sk_reset_timer(sk, &dp->dccps_xmit_timer,
 265                                                msecs_to_jiffies(err)+jiffies);
 266                                break;
 267                        } else
 268                                err = dccp_wait_for_ccid(sk, skb, err);
 269                        if (err && err != -EINTR)
 270                                DCCP_BUG("err=%d after dccp_wait_for_ccid", err);
 271                }
 272
 273                skb_dequeue(&sk->sk_write_queue);
 274                if (err == 0) {
 275                        struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
 276                        const int len = skb->len;
 277
 278                        if (sk->sk_state == DCCP_PARTOPEN) {
 279                                const u32 cur_mps = dp->dccps_mss_cache - DCCP_FEATNEG_OVERHEAD;
 280                                /*
 281                                 * See 8.1.5 - Handshake Completion.
 282                                 *
 283                                 * For robustness we resend Confirm options until the client has
 284                                 * entered OPEN. During the initial feature negotiation, the MPS
 285                                 * is smaller than usual, reduced by the Change/Confirm options.
 286                                 */
 287                                if (!list_empty(&dp->dccps_featneg) && len > cur_mps) {
 288                                        DCCP_WARN("Payload too large (%d) for featneg.\n", len);
 289                                        dccp_send_ack(sk);
 290                                        dccp_feat_list_purge(&dp->dccps_featneg);
 291                                }
 292
 293                                inet_csk_schedule_ack(sk);
 294                                inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
 295                                                  inet_csk(sk)->icsk_rto,
 296                                                  DCCP_RTO_MAX);
 297                                dcb->dccpd_type = DCCP_PKT_DATAACK;
 298                        } else if (dccp_ack_pending(sk))
 299                                dcb->dccpd_type = DCCP_PKT_DATAACK;
 300                        else
 301                                dcb->dccpd_type = DCCP_PKT_DATA;
 302
 303                        err = dccp_transmit_skb(sk, skb);
 304                        ccid_hc_tx_packet_sent(dp->dccps_hc_tx_ccid, sk, 0, len);
 305                        if (err)
 306                                DCCP_BUG("err=%d after ccid_hc_tx_packet_sent",
 307                                         err);
 308                } else {
 309                        dccp_pr_debug("packet discarded due to err=%d\n", err);
 310                        kfree_skb(skb);
 311                }
 312        }
 313}
 314
 315/**
 316 * dccp_retransmit_skb  -  Retransmit Request, Close, or CloseReq packets
 317 * There are only four retransmittable packet types in DCCP:
 318 * - Request  in client-REQUEST  state (sec. 8.1.1),
 319 * - CloseReq in server-CLOSEREQ state (sec. 8.3),
 320 * - Close    in   node-CLOSING  state (sec. 8.3),
 321 * - Acks in client-PARTOPEN state (sec. 8.1.5, handled by dccp_delack_timer()).
 322 * This function expects sk->sk_send_head to contain the original skb.
 323 */
 324int dccp_retransmit_skb(struct sock *sk)
 325{
 326        WARN_ON(sk->sk_send_head == NULL);
 327
 328        if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
 329                return -EHOSTUNREACH; /* Routing failure or similar. */
 330
 331        /* this count is used to distinguish original and retransmitted skb */
 332        inet_csk(sk)->icsk_retransmits++;
 333
 334        return dccp_transmit_skb(sk, skb_clone(sk->sk_send_head, GFP_ATOMIC));
 335}
 336
 337struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
 338                                   struct request_sock *req)
 339{
 340        struct dccp_hdr *dh;
 341        struct dccp_request_sock *dreq;
 342        const u32 dccp_header_size = sizeof(struct dccp_hdr) +
 343                                     sizeof(struct dccp_hdr_ext) +
 344                                     sizeof(struct dccp_hdr_response);
 345        struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
 346                                           GFP_ATOMIC);
 347        if (skb == NULL)
 348                return NULL;
 349
 350        /* Reserve space for headers. */
 351        skb_reserve(skb, sk->sk_prot->max_header);
 352
 353        skb->dst = dst_clone(dst);
 354
 355        dreq = dccp_rsk(req);
 356        if (inet_rsk(req)->acked)       /* increase ISS upon retransmission */
 357                dccp_inc_seqno(&dreq->dreq_iss);
 358        DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE;
 359        DCCP_SKB_CB(skb)->dccpd_seq  = dreq->dreq_iss;
 360
 361        /* Resolve feature dependencies resulting from choice of CCID */
 362        if (dccp_feat_server_ccid_dependencies(dreq))
 363                goto response_failed;
 364
 365        if (dccp_insert_options_rsk(dreq, skb))
 366                goto response_failed;
 367
 368        /* Build and checksum header */
 369        dh = dccp_zeroed_hdr(skb, dccp_header_size);
 370
 371        dh->dccph_sport = inet_rsk(req)->loc_port;
 372        dh->dccph_dport = inet_rsk(req)->rmt_port;
 373        dh->dccph_doff  = (dccp_header_size +
 374                           DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
 375        dh->dccph_type  = DCCP_PKT_RESPONSE;
 376        dh->dccph_x     = 1;
 377        dccp_hdr_set_seq(dh, dreq->dreq_iss);
 378        dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), dreq->dreq_isr);
 379        dccp_hdr_response(skb)->dccph_resp_service = dreq->dreq_service;
 380
 381        dccp_csum_outgoing(skb);
 382
 383        /* We use `acked' to remember that a Response was already sent. */
 384        inet_rsk(req)->acked = 1;
 385        DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
 386        return skb;
 387response_failed:
 388        kfree_skb(skb);
 389        return NULL;
 390}
 391
 392EXPORT_SYMBOL_GPL(dccp_make_response);
 393
 394/* answer offending packet in @rcv_skb with Reset from control socket @ctl */
 395struct sk_buff *dccp_ctl_make_reset(struct sock *sk, struct sk_buff *rcv_skb)
 396{
 397        struct dccp_hdr *rxdh = dccp_hdr(rcv_skb), *dh;
 398        struct dccp_skb_cb *dcb = DCCP_SKB_CB(rcv_skb);
 399        const u32 dccp_hdr_reset_len = sizeof(struct dccp_hdr) +
 400                                       sizeof(struct dccp_hdr_ext) +
 401                                       sizeof(struct dccp_hdr_reset);
 402        struct dccp_hdr_reset *dhr;
 403        struct sk_buff *skb;
 404
 405        skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
 406        if (skb == NULL)
 407                return NULL;
 408
 409        skb_reserve(skb, sk->sk_prot->max_header);
 410
 411        /* Swap the send and the receive. */
 412        dh = dccp_zeroed_hdr(skb, dccp_hdr_reset_len);
 413        dh->dccph_type  = DCCP_PKT_RESET;
 414        dh->dccph_sport = rxdh->dccph_dport;
 415        dh->dccph_dport = rxdh->dccph_sport;
 416        dh->dccph_doff  = dccp_hdr_reset_len / 4;
 417        dh->dccph_x     = 1;
 418
 419        dhr = dccp_hdr_reset(skb);
 420        dhr->dccph_reset_code = dcb->dccpd_reset_code;
 421
 422        switch (dcb->dccpd_reset_code) {
 423        case DCCP_RESET_CODE_PACKET_ERROR:
 424                dhr->dccph_reset_data[0] = rxdh->dccph_type;
 425                break;
 426        case DCCP_RESET_CODE_OPTION_ERROR:      /* fall through */
 427        case DCCP_RESET_CODE_MANDATORY_ERROR:
 428                memcpy(dhr->dccph_reset_data, dcb->dccpd_reset_data, 3);
 429                break;
 430        }
 431        /*
 432         * From RFC 4340, 8.3.1:
 433         *   If P.ackno exists, set R.seqno := P.ackno + 1.
 434         *   Else set R.seqno := 0.
 435         */
 436        if (dcb->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
 437                dccp_hdr_set_seq(dh, ADD48(dcb->dccpd_ack_seq, 1));
 438        dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), dcb->dccpd_seq);
 439
 440        dccp_csum_outgoing(skb);
 441        return skb;
 442}
 443
 444EXPORT_SYMBOL_GPL(dccp_ctl_make_reset);
 445
 446/* send Reset on established socket, to close or abort the connection */
 447int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
 448{
 449        struct sk_buff *skb;
 450        /*
 451         * FIXME: what if rebuild_header fails?
 452         * Should we be doing a rebuild_header here?
 453         */
 454        int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk);
 455
 456        if (err != 0)
 457                return err;
 458
 459        skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1, GFP_ATOMIC);
 460        if (skb == NULL)
 461                return -ENOBUFS;
 462
 463        /* Reserve space for headers and prepare control bits. */
 464        skb_reserve(skb, sk->sk_prot->max_header);
 465        DCCP_SKB_CB(skb)->dccpd_type       = DCCP_PKT_RESET;
 466        DCCP_SKB_CB(skb)->dccpd_reset_code = code;
 467
 468        return dccp_transmit_skb(sk, skb);
 469}
 470
 471/*
 472 * Do all connect socket setups that can be done AF independent.
 473 */
 474static inline void dccp_connect_init(struct sock *sk)
 475{
 476        struct dccp_sock *dp = dccp_sk(sk);
 477        struct dst_entry *dst = __sk_dst_get(sk);
 478        struct inet_connection_sock *icsk = inet_csk(sk);
 479
 480        sk->sk_err = 0;
 481        sock_reset_flag(sk, SOCK_DONE);
 482
 483        dccp_sync_mss(sk, dst_mtu(dst));
 484
 485        /* Initialise GAR as per 8.5; AWL/AWH are set in dccp_transmit_skb() */
 486        dp->dccps_gar = dp->dccps_iss;
 487
 488        icsk->icsk_retransmits = 0;
 489}
 490
 491int dccp_connect(struct sock *sk)
 492{
 493        struct sk_buff *skb;
 494        struct inet_connection_sock *icsk = inet_csk(sk);
 495
 496        /* do not connect if feature negotiation setup fails */
 497        if (dccp_feat_finalise_settings(dccp_sk(sk)))
 498                return -EPROTO;
 499
 500        dccp_connect_init(sk);
 501
 502        skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
 503        if (unlikely(skb == NULL))
 504                return -ENOBUFS;
 505
 506        /* Reserve space for headers. */
 507        skb_reserve(skb, sk->sk_prot->max_header);
 508
 509        DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;
 510
 511        dccp_skb_entail(sk, skb);
 512        dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
 513        DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);
 514
 515        /* Timer for repeating the REQUEST until an answer. */
 516        inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
 517                                  icsk->icsk_rto, DCCP_RTO_MAX);
 518        return 0;
 519}
 520
 521EXPORT_SYMBOL_GPL(dccp_connect);
 522
 523void dccp_send_ack(struct sock *sk)
 524{
 525        /* If we have been reset, we may not send again. */
 526        if (sk->sk_state != DCCP_CLOSED) {
 527                struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
 528                                                GFP_ATOMIC);
 529
 530                if (skb == NULL) {
 531                        inet_csk_schedule_ack(sk);
 532                        inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
 533                        inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
 534                                                  TCP_DELACK_MAX,
 535                                                  DCCP_RTO_MAX);
 536                        return;
 537                }
 538
 539                /* Reserve space for headers */
 540                skb_reserve(skb, sk->sk_prot->max_header);
 541                DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
 542                dccp_transmit_skb(sk, skb);
 543        }
 544}
 545
 546EXPORT_SYMBOL_GPL(dccp_send_ack);
 547
 548#if 0
 549/* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
 550void dccp_send_delayed_ack(struct sock *sk)
 551{
 552        struct inet_connection_sock *icsk = inet_csk(sk);
 553        /*
 554         * FIXME: tune this timer. elapsed time fixes the skew, so no problem
 555         * with using 2s, and active senders also piggyback the ACK into a
 556         * DATAACK packet, so this is really for quiescent senders.
 557         */
 558        unsigned long timeout = jiffies + 2 * HZ;
 559
 560        /* Use new timeout only if there wasn't a older one earlier. */
 561        if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
 562                /* If delack timer was blocked or is about to expire,
 563                 * send ACK now.
 564                 *
 565                 * FIXME: check the "about to expire" part
 566                 */
 567                if (icsk->icsk_ack.blocked) {
 568                        dccp_send_ack(sk);
 569                        return;
 570                }
 571
 572                if (!time_before(timeout, icsk->icsk_ack.timeout))
 573                        timeout = icsk->icsk_ack.timeout;
 574        }
 575        icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
 576        icsk->icsk_ack.timeout = timeout;
 577        sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
 578}
 579#endif
 580
 581void dccp_send_sync(struct sock *sk, const u64 ackno,
 582                    const enum dccp_pkt_type pkt_type)
 583{
 584        /*
 585         * We are not putting this on the write queue, so
 586         * dccp_transmit_skb() will set the ownership to this
 587         * sock.
 588         */
 589        struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
 590
 591        if (skb == NULL) {
 592                /* FIXME: how to make sure the sync is sent? */
 593                DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
 594                return;
 595        }
 596
 597        /* Reserve space for headers and prepare control bits. */
 598        skb_reserve(skb, sk->sk_prot->max_header);
 599        DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
 600        DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
 601
 602        dccp_transmit_skb(sk, skb);
 603}
 604
 605EXPORT_SYMBOL_GPL(dccp_send_sync);
 606
 607/*
 608 * Send a DCCP_PKT_CLOSE/CLOSEREQ. The caller locks the socket for us. This
 609 * cannot be allowed to fail queueing a DCCP_PKT_CLOSE/CLOSEREQ frame under
 610 * any circumstances.
 611 */
 612void dccp_send_close(struct sock *sk, const int active)
 613{
 614        struct dccp_sock *dp = dccp_sk(sk);
 615        struct sk_buff *skb;
 616        const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
 617
 618        skb = alloc_skb(sk->sk_prot->max_header, prio);
 619        if (skb == NULL)
 620                return;
 621
 622        /* Reserve space for headers and prepare control bits. */
 623        skb_reserve(skb, sk->sk_prot->max_header);
 624        if (dp->dccps_role == DCCP_ROLE_SERVER && !dp->dccps_server_timewait)
 625                DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_CLOSEREQ;
 626        else
 627                DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_CLOSE;
 628
 629        if (active) {
 630                dccp_write_xmit(sk, 1);
 631                dccp_skb_entail(sk, skb);
 632                dccp_transmit_skb(sk, skb_clone(skb, prio));
 633                /*
 634                 * Retransmission timer for active-close: RFC 4340, 8.3 requires
 635                 * to retransmit the Close/CloseReq until the CLOSING/CLOSEREQ
 636                 * state can be left. The initial timeout is 2 RTTs.
 637                 * Since RTT measurement is done by the CCIDs, there is no easy
 638                 * way to get an RTT sample. The fallback RTT from RFC 4340, 3.4
 639                 * is too low (200ms); we use a high value to avoid unnecessary
 640                 * retransmissions when the link RTT is > 0.2 seconds.
 641                 * FIXME: Let main module sample RTTs and use that instead.
 642                 */
 643                inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
 644                                          DCCP_TIMEOUT_INIT, DCCP_RTO_MAX);
 645        } else
 646                dccp_transmit_skb(sk, skb);
 647}
 648