1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * An implementation of the DCCP protocol
6 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
9 #include <linux/dccp.h>
10 #include <linux/kernel.h>
11 #include <linux/skbuff.h>
12 #include <linux/slab.h>
13 #include <linux/sched/signal.h>
15 #include <net/inet_sock.h>
22 static inline void dccp_event_ack_sent(struct sock
*sk
)
24 inet_csk_clear_xmit_timer(sk
, ICSK_TIME_DACK
);
27 /* enqueue @skb on sk_send_head for retransmission, return clone to send now */
28 static struct sk_buff
*dccp_skb_entail(struct sock
*sk
, struct sk_buff
*skb
)
30 skb_set_owner_w(skb
, sk
);
31 WARN_ON(sk
->sk_send_head
);
32 sk
->sk_send_head
= skb
;
33 return skb_clone(sk
->sk_send_head
, gfp_any());
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
42 static int dccp_transmit_skb(struct sock
*sk
, struct sk_buff
*skb
)
44 if (likely(skb
!= NULL
)) {
45 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
);
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
);
55 u64 ackno
= dp
->dccps_gsr
;
57 * Increment GSS here already in case the option code needs it.
58 * Update GSS for real only if option processing below succeeds.
60 dcb
->dccpd_seq
= ADD48(dp
->dccps_gss
, 1);
62 switch (dcb
->dccpd_type
) {
66 case DCCP_PKT_DATAACK
:
70 case DCCP_PKT_REQUEST
:
72 /* Use ISS on the first (non-retransmitted) Request. */
73 if (icsk
->icsk_retransmits
== 0)
74 dcb
->dccpd_seq
= dp
->dccps_iss
;
78 case DCCP_PKT_SYNCACK
:
79 ackno
= dcb
->dccpd_ack_seq
;
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.
89 skb_set_owner_w(skb
, sk
);
93 if (dccp_insert_options(sk
, skb
)) {
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
->inet_sport
;
103 dh
->dccph_dport
= inet
->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 */
110 dccp_update_gss(sk
, dcb
->dccpd_seq
);
111 dccp_hdr_set_seq(dh
, dp
->dccps_gss
);
113 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
), ackno
);
115 switch (dcb
->dccpd_type
) {
116 case DCCP_PKT_REQUEST
:
117 dccp_hdr_request(skb
)->dccph_req_service
=
120 * Limit Ack window to ISS <= P.ackno <= GSS, so that
121 * only Responses to Requests we sent are considered.
123 dp
->dccps_awl
= dp
->dccps_iss
;
126 dccp_hdr_reset(skb
)->dccph_reset_code
=
127 dcb
->dccpd_reset_code
;
131 icsk
->icsk_af_ops
->send_check(sk
, skb
);
134 dccp_event_ack_sent(sk
);
136 DCCP_INC_STATS(DCCP_MIB_OUTSEGS
);
138 err
= icsk
->icsk_af_ops
->queue_xmit(sk
, skb
, &inet
->cork
.fl
);
139 return net_xmit_eval(err
);
145 * dccp_determine_ccmps - Find out about CCID-specific packet-size limits
146 * @dp: socket to find packet size limits of
148 * We only consider the HC-sender CCID for setting the CCMPS (RFC 4340, 14.),
149 * since the RX CCID is restricted to feedback packets (Acks), which are small
150 * in comparison with the data traffic. A value of 0 means "no current CCMPS".
152 static u32
dccp_determine_ccmps(const struct dccp_sock
*dp
)
154 const struct ccid
*tx_ccid
= dp
->dccps_hc_tx_ccid
;
156 if (tx_ccid
== NULL
|| tx_ccid
->ccid_ops
== NULL
)
158 return tx_ccid
->ccid_ops
->ccid_ccmps
;
161 unsigned int dccp_sync_mss(struct sock
*sk
, u32 pmtu
)
163 struct inet_connection_sock
*icsk
= inet_csk(sk
);
164 struct dccp_sock
*dp
= dccp_sk(sk
);
165 u32 ccmps
= dccp_determine_ccmps(dp
);
166 u32 cur_mps
= ccmps
? min(pmtu
, ccmps
) : pmtu
;
168 /* Account for header lengths and IPv4/v6 option overhead */
169 cur_mps
-= (icsk
->icsk_af_ops
->net_header_len
+ icsk
->icsk_ext_hdr_len
+
170 sizeof(struct dccp_hdr
) + sizeof(struct dccp_hdr_ext
));
173 * Leave enough headroom for common DCCP header options.
174 * This only considers options which may appear on DCCP-Data packets, as
175 * per table 3 in RFC 4340, 5.8. When running out of space for other
176 * options (eg. Ack Vector which can take up to 255 bytes), it is better
177 * to schedule a separate Ack. Thus we leave headroom for the following:
178 * - 1 byte for Slow Receiver (11.6)
179 * - 6 bytes for Timestamp (13.1)
180 * - 10 bytes for Timestamp Echo (13.3)
181 * - 8 bytes for NDP count (7.7, when activated)
182 * - 6 bytes for Data Checksum (9.3)
183 * - %DCCPAV_MIN_OPTLEN bytes for Ack Vector size (11.4, when enabled)
185 cur_mps
-= roundup(1 + 6 + 10 + dp
->dccps_send_ndp_count
* 8 + 6 +
186 (dp
->dccps_hc_rx_ackvec
? DCCPAV_MIN_OPTLEN
: 0), 4);
188 /* And store cached results */
189 icsk
->icsk_pmtu_cookie
= pmtu
;
190 dp
->dccps_mss_cache
= cur_mps
;
195 EXPORT_SYMBOL_GPL(dccp_sync_mss
);
197 void dccp_write_space(struct sock
*sk
)
199 struct socket_wq
*wq
;
202 wq
= rcu_dereference(sk
->sk_wq
);
203 if (skwq_has_sleeper(wq
))
204 wake_up_interruptible(&wq
->wait
);
205 /* Should agree with poll, otherwise some programs break */
206 if (sock_writeable(sk
))
207 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
213 * dccp_wait_for_ccid - Await CCID send permission
214 * @sk: socket to wait for
215 * @delay: timeout in jiffies
217 * This is used by CCIDs which need to delay the send time in process context.
219 static int dccp_wait_for_ccid(struct sock
*sk
, unsigned long delay
)
224 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
225 sk
->sk_write_pending
++;
228 remaining
= schedule_timeout(delay
);
231 sk
->sk_write_pending
--;
232 finish_wait(sk_sleep(sk
), &wait
);
234 if (signal_pending(current
) || sk
->sk_err
)
240 * dccp_xmit_packet - Send data packet under control of CCID
241 * @sk: socket to send data packet on
243 * Transmits next-queued payload and informs CCID to account for the packet.
245 static void dccp_xmit_packet(struct sock
*sk
)
248 struct dccp_sock
*dp
= dccp_sk(sk
);
249 struct sk_buff
*skb
= dccp_qpolicy_pop(sk
);
251 if (unlikely(skb
== NULL
))
255 if (sk
->sk_state
== DCCP_PARTOPEN
) {
256 const u32 cur_mps
= dp
->dccps_mss_cache
- DCCP_FEATNEG_OVERHEAD
;
258 * See 8.1.5 - Handshake Completion.
260 * For robustness we resend Confirm options until the client has
261 * entered OPEN. During the initial feature negotiation, the MPS
262 * is smaller than usual, reduced by the Change/Confirm options.
264 if (!list_empty(&dp
->dccps_featneg
) && len
> cur_mps
) {
265 DCCP_WARN("Payload too large (%d) for featneg.\n", len
);
267 dccp_feat_list_purge(&dp
->dccps_featneg
);
270 inet_csk_schedule_ack(sk
);
271 inet_csk_reset_xmit_timer(sk
, ICSK_TIME_DACK
,
272 inet_csk(sk
)->icsk_rto
,
274 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_DATAACK
;
275 } else if (dccp_ack_pending(sk
)) {
276 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_DATAACK
;
278 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_DATA
;
281 err
= dccp_transmit_skb(sk
, skb
);
283 dccp_pr_debug("transmit_skb() returned err=%d\n", err
);
285 * Register this one as sent even if an error occurred. To the remote
286 * end a local packet drop is indistinguishable from network loss, i.e.
287 * any local drop will eventually be reported via receiver feedback.
289 ccid_hc_tx_packet_sent(dp
->dccps_hc_tx_ccid
, sk
, len
);
292 * If the CCID needs to transfer additional header options out-of-band
293 * (e.g. Ack Vectors or feature-negotiation options), it activates this
294 * flag to schedule a Sync. The Sync will automatically incorporate all
295 * currently pending header options, thus clearing the backlog.
297 if (dp
->dccps_sync_scheduled
)
298 dccp_send_sync(sk
, dp
->dccps_gsr
, DCCP_PKT_SYNC
);
302 * dccp_flush_write_queue - Drain queue at end of connection
303 * @sk: socket to be drained
304 * @time_budget: time allowed to drain the queue
306 * Since dccp_sendmsg queues packets without waiting for them to be sent, it may
307 * happen that the TX queue is not empty at the end of a connection. We give the
308 * HC-sender CCID a grace period of up to @time_budget jiffies. If this function
309 * returns with a non-empty write queue, it will be purged later.
311 void dccp_flush_write_queue(struct sock
*sk
, long *time_budget
)
313 struct dccp_sock
*dp
= dccp_sk(sk
);
317 while (*time_budget
> 0 && (skb
= skb_peek(&sk
->sk_write_queue
))) {
318 rc
= ccid_hc_tx_send_packet(dp
->dccps_hc_tx_ccid
, sk
, skb
);
320 switch (ccid_packet_dequeue_eval(rc
)) {
321 case CCID_PACKET_WILL_DEQUEUE_LATER
:
323 * If the CCID determines when to send, the next sending
324 * time is unknown or the CCID may not even send again
325 * (e.g. remote host crashes or lost Ack packets).
327 DCCP_WARN("CCID did not manage to send all packets\n");
329 case CCID_PACKET_DELAY
:
330 delay
= msecs_to_jiffies(rc
);
331 if (delay
> *time_budget
)
333 rc
= dccp_wait_for_ccid(sk
, delay
);
336 *time_budget
-= (delay
- rc
);
337 /* check again if we can send now */
339 case CCID_PACKET_SEND_AT_ONCE
:
340 dccp_xmit_packet(sk
);
342 case CCID_PACKET_ERR
:
343 skb_dequeue(&sk
->sk_write_queue
);
345 dccp_pr_debug("packet discarded due to err=%ld\n", rc
);
350 void dccp_write_xmit(struct sock
*sk
)
352 struct dccp_sock
*dp
= dccp_sk(sk
);
355 while ((skb
= dccp_qpolicy_top(sk
))) {
356 int rc
= ccid_hc_tx_send_packet(dp
->dccps_hc_tx_ccid
, sk
, skb
);
358 switch (ccid_packet_dequeue_eval(rc
)) {
359 case CCID_PACKET_WILL_DEQUEUE_LATER
:
361 case CCID_PACKET_DELAY
:
362 sk_reset_timer(sk
, &dp
->dccps_xmit_timer
,
363 jiffies
+ msecs_to_jiffies(rc
));
365 case CCID_PACKET_SEND_AT_ONCE
:
366 dccp_xmit_packet(sk
);
368 case CCID_PACKET_ERR
:
369 dccp_qpolicy_drop(sk
, skb
);
370 dccp_pr_debug("packet discarded due to err=%d\n", rc
);
376 * dccp_retransmit_skb - Retransmit Request, Close, or CloseReq packets
377 * @sk: socket to perform retransmit on
379 * There are only four retransmittable packet types in DCCP:
380 * - Request in client-REQUEST state (sec. 8.1.1),
381 * - CloseReq in server-CLOSEREQ state (sec. 8.3),
382 * - Close in node-CLOSING state (sec. 8.3),
383 * - Acks in client-PARTOPEN state (sec. 8.1.5, handled by dccp_delack_timer()).
384 * This function expects sk->sk_send_head to contain the original skb.
386 int dccp_retransmit_skb(struct sock
*sk
)
388 WARN_ON(sk
->sk_send_head
== NULL
);
390 if (inet_csk(sk
)->icsk_af_ops
->rebuild_header(sk
) != 0)
391 return -EHOSTUNREACH
; /* Routing failure or similar. */
393 /* this count is used to distinguish original and retransmitted skb */
394 inet_csk(sk
)->icsk_retransmits
++;
396 return dccp_transmit_skb(sk
, skb_clone(sk
->sk_send_head
, GFP_ATOMIC
));
399 struct sk_buff
*dccp_make_response(const struct sock
*sk
, struct dst_entry
*dst
,
400 struct request_sock
*req
)
403 struct dccp_request_sock
*dreq
;
404 const u32 dccp_header_size
= sizeof(struct dccp_hdr
) +
405 sizeof(struct dccp_hdr_ext
) +
406 sizeof(struct dccp_hdr_response
);
409 /* sk is marked const to clearly express we dont hold socket lock.
410 * sock_wmalloc() will atomically change sk->sk_wmem_alloc,
411 * it is safe to promote sk to non const.
413 skb
= sock_wmalloc((struct sock
*)sk
, MAX_DCCP_HEADER
, 1,
418 skb_reserve(skb
, MAX_DCCP_HEADER
);
420 skb_dst_set(skb
, dst_clone(dst
));
422 dreq
= dccp_rsk(req
);
423 if (inet_rsk(req
)->acked
) /* increase GSS upon retransmission */
424 dccp_inc_seqno(&dreq
->dreq_gss
);
425 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_RESPONSE
;
426 DCCP_SKB_CB(skb
)->dccpd_seq
= dreq
->dreq_gss
;
428 /* Resolve feature dependencies resulting from choice of CCID */
429 if (dccp_feat_server_ccid_dependencies(dreq
))
430 goto response_failed
;
432 if (dccp_insert_options_rsk(dreq
, skb
))
433 goto response_failed
;
435 /* Build and checksum header */
436 dh
= dccp_zeroed_hdr(skb
, dccp_header_size
);
438 dh
->dccph_sport
= htons(inet_rsk(req
)->ir_num
);
439 dh
->dccph_dport
= inet_rsk(req
)->ir_rmt_port
;
440 dh
->dccph_doff
= (dccp_header_size
+
441 DCCP_SKB_CB(skb
)->dccpd_opt_len
) / 4;
442 dh
->dccph_type
= DCCP_PKT_RESPONSE
;
444 dccp_hdr_set_seq(dh
, dreq
->dreq_gss
);
445 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
), dreq
->dreq_gsr
);
446 dccp_hdr_response(skb
)->dccph_resp_service
= dreq
->dreq_service
;
448 dccp_csum_outgoing(skb
);
450 /* We use `acked' to remember that a Response was already sent. */
451 inet_rsk(req
)->acked
= 1;
452 DCCP_INC_STATS(DCCP_MIB_OUTSEGS
);
459 EXPORT_SYMBOL_GPL(dccp_make_response
);
461 /* answer offending packet in @rcv_skb with Reset from control socket @ctl */
462 struct sk_buff
*dccp_ctl_make_reset(struct sock
*sk
, struct sk_buff
*rcv_skb
)
464 struct dccp_hdr
*rxdh
= dccp_hdr(rcv_skb
), *dh
;
465 struct dccp_skb_cb
*dcb
= DCCP_SKB_CB(rcv_skb
);
466 const u32 dccp_hdr_reset_len
= sizeof(struct dccp_hdr
) +
467 sizeof(struct dccp_hdr_ext
) +
468 sizeof(struct dccp_hdr_reset
);
469 struct dccp_hdr_reset
*dhr
;
472 skb
= alloc_skb(sk
->sk_prot
->max_header
, GFP_ATOMIC
);
476 skb_reserve(skb
, sk
->sk_prot
->max_header
);
478 /* Swap the send and the receive. */
479 dh
= dccp_zeroed_hdr(skb
, dccp_hdr_reset_len
);
480 dh
->dccph_type
= DCCP_PKT_RESET
;
481 dh
->dccph_sport
= rxdh
->dccph_dport
;
482 dh
->dccph_dport
= rxdh
->dccph_sport
;
483 dh
->dccph_doff
= dccp_hdr_reset_len
/ 4;
486 dhr
= dccp_hdr_reset(skb
);
487 dhr
->dccph_reset_code
= dcb
->dccpd_reset_code
;
489 switch (dcb
->dccpd_reset_code
) {
490 case DCCP_RESET_CODE_PACKET_ERROR
:
491 dhr
->dccph_reset_data
[0] = rxdh
->dccph_type
;
493 case DCCP_RESET_CODE_OPTION_ERROR
:
494 case DCCP_RESET_CODE_MANDATORY_ERROR
:
495 memcpy(dhr
->dccph_reset_data
, dcb
->dccpd_reset_data
, 3);
499 * From RFC 4340, 8.3.1:
500 * If P.ackno exists, set R.seqno := P.ackno + 1.
501 * Else set R.seqno := 0.
503 if (dcb
->dccpd_ack_seq
!= DCCP_PKT_WITHOUT_ACK_SEQ
)
504 dccp_hdr_set_seq(dh
, ADD48(dcb
->dccpd_ack_seq
, 1));
505 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
), dcb
->dccpd_seq
);
507 dccp_csum_outgoing(skb
);
511 EXPORT_SYMBOL_GPL(dccp_ctl_make_reset
);
513 /* send Reset on established socket, to close or abort the connection */
514 int dccp_send_reset(struct sock
*sk
, enum dccp_reset_codes code
)
518 * FIXME: what if rebuild_header fails?
519 * Should we be doing a rebuild_header here?
521 int err
= inet_csk(sk
)->icsk_af_ops
->rebuild_header(sk
);
526 skb
= sock_wmalloc(sk
, sk
->sk_prot
->max_header
, 1, GFP_ATOMIC
);
530 /* Reserve space for headers and prepare control bits. */
531 skb_reserve(skb
, sk
->sk_prot
->max_header
);
532 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_RESET
;
533 DCCP_SKB_CB(skb
)->dccpd_reset_code
= code
;
535 return dccp_transmit_skb(sk
, skb
);
539 * Do all connect socket setups that can be done AF independent.
541 int dccp_connect(struct sock
*sk
)
544 struct dccp_sock
*dp
= dccp_sk(sk
);
545 struct dst_entry
*dst
= __sk_dst_get(sk
);
546 struct inet_connection_sock
*icsk
= inet_csk(sk
);
549 sock_reset_flag(sk
, SOCK_DONE
);
551 dccp_sync_mss(sk
, dst_mtu(dst
));
553 /* do not connect if feature negotiation setup fails */
554 if (dccp_feat_finalise_settings(dccp_sk(sk
)))
557 /* Initialise GAR as per 8.5; AWL/AWH are set in dccp_transmit_skb() */
558 dp
->dccps_gar
= dp
->dccps_iss
;
560 skb
= alloc_skb(sk
->sk_prot
->max_header
, sk
->sk_allocation
);
561 if (unlikely(skb
== NULL
))
564 /* Reserve space for headers. */
565 skb_reserve(skb
, sk
->sk_prot
->max_header
);
567 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_REQUEST
;
569 dccp_transmit_skb(sk
, dccp_skb_entail(sk
, skb
));
570 DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS
);
572 /* Timer for repeating the REQUEST until an answer. */
573 icsk
->icsk_retransmits
= 0;
574 inet_csk_reset_xmit_timer(sk
, ICSK_TIME_RETRANS
,
575 icsk
->icsk_rto
, DCCP_RTO_MAX
);
579 EXPORT_SYMBOL_GPL(dccp_connect
);
581 void dccp_send_ack(struct sock
*sk
)
583 /* If we have been reset, we may not send again. */
584 if (sk
->sk_state
!= DCCP_CLOSED
) {
585 struct sk_buff
*skb
= alloc_skb(sk
->sk_prot
->max_header
,
589 inet_csk_schedule_ack(sk
);
590 inet_csk(sk
)->icsk_ack
.ato
= TCP_ATO_MIN
;
591 inet_csk_reset_xmit_timer(sk
, ICSK_TIME_DACK
,
597 /* Reserve space for headers */
598 skb_reserve(skb
, sk
->sk_prot
->max_header
);
599 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_ACK
;
600 dccp_transmit_skb(sk
, skb
);
604 EXPORT_SYMBOL_GPL(dccp_send_ack
);
607 /* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
608 void dccp_send_delayed_ack(struct sock
*sk
)
610 struct inet_connection_sock
*icsk
= inet_csk(sk
);
612 * FIXME: tune this timer. elapsed time fixes the skew, so no problem
613 * with using 2s, and active senders also piggyback the ACK into a
614 * DATAACK packet, so this is really for quiescent senders.
616 unsigned long timeout
= jiffies
+ 2 * HZ
;
618 /* Use new timeout only if there wasn't a older one earlier. */
619 if (icsk
->icsk_ack
.pending
& ICSK_ACK_TIMER
) {
620 /* If delack timer was blocked or is about to expire,
623 * FIXME: check the "about to expire" part
625 if (icsk
->icsk_ack
.blocked
) {
630 if (!time_before(timeout
, icsk
->icsk_ack
.timeout
))
631 timeout
= icsk
->icsk_ack
.timeout
;
633 icsk
->icsk_ack
.pending
|= ICSK_ACK_SCHED
| ICSK_ACK_TIMER
;
634 icsk
->icsk_ack
.timeout
= timeout
;
635 sk_reset_timer(sk
, &icsk
->icsk_delack_timer
, timeout
);
639 void dccp_send_sync(struct sock
*sk
, const u64 ackno
,
640 const enum dccp_pkt_type pkt_type
)
643 * We are not putting this on the write queue, so
644 * dccp_transmit_skb() will set the ownership to this
647 struct sk_buff
*skb
= alloc_skb(sk
->sk_prot
->max_header
, GFP_ATOMIC
);
650 /* FIXME: how to make sure the sync is sent? */
651 DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type
));
655 /* Reserve space for headers and prepare control bits. */
656 skb_reserve(skb
, sk
->sk_prot
->max_header
);
657 DCCP_SKB_CB(skb
)->dccpd_type
= pkt_type
;
658 DCCP_SKB_CB(skb
)->dccpd_ack_seq
= ackno
;
661 * Clear the flag in case the Sync was scheduled for out-of-band data,
662 * such as carrying a long Ack Vector.
664 dccp_sk(sk
)->dccps_sync_scheduled
= 0;
666 dccp_transmit_skb(sk
, skb
);
669 EXPORT_SYMBOL_GPL(dccp_send_sync
);
672 * Send a DCCP_PKT_CLOSE/CLOSEREQ. The caller locks the socket for us. This
673 * cannot be allowed to fail queueing a DCCP_PKT_CLOSE/CLOSEREQ frame under
676 void dccp_send_close(struct sock
*sk
, const int active
)
678 struct dccp_sock
*dp
= dccp_sk(sk
);
680 const gfp_t prio
= active
? GFP_KERNEL
: GFP_ATOMIC
;
682 skb
= alloc_skb(sk
->sk_prot
->max_header
, prio
);
686 /* Reserve space for headers and prepare control bits. */
687 skb_reserve(skb
, sk
->sk_prot
->max_header
);
688 if (dp
->dccps_role
== DCCP_ROLE_SERVER
&& !dp
->dccps_server_timewait
)
689 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_CLOSEREQ
;
691 DCCP_SKB_CB(skb
)->dccpd_type
= DCCP_PKT_CLOSE
;
694 skb
= dccp_skb_entail(sk
, skb
);
696 * Retransmission timer for active-close: RFC 4340, 8.3 requires
697 * to retransmit the Close/CloseReq until the CLOSING/CLOSEREQ
698 * state can be left. The initial timeout is 2 RTTs.
699 * Since RTT measurement is done by the CCIDs, there is no easy
700 * way to get an RTT sample. The fallback RTT from RFC 4340, 3.4
701 * is too low (200ms); we use a high value to avoid unnecessary
702 * retransmissions when the link RTT is > 0.2 seconds.
703 * FIXME: Let main module sample RTTs and use that instead.
705 inet_csk_reset_xmit_timer(sk
, ICSK_TIME_RETRANS
,
706 DCCP_TIMEOUT_INIT
, DCCP_RTO_MAX
);
708 dccp_transmit_skb(sk
, skb
);