1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * net/dccp/output.c |
4 | * |
5 | * An implementation of the DCCP protocol |
6 | * Arnaldo Carvalho de Melo <acme@conectiva.com.br> |
7 | */ |
8 | |
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> |
14 | |
15 | #include <net/inet_sock.h> |
16 | #include <net/sock.h> |
17 | |
18 | #include "ackvec.h" |
19 | #include "ccid.h" |
20 | #include "dccp.h" |
21 | |
22 | static inline void dccp_event_ack_sent(struct sock *sk) |
23 | { |
24 | inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK); |
25 | } |
26 | |
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) |
29 | { |
30 | skb_set_owner_w(skb, sk); |
31 | WARN_ON(sk->sk_send_head); |
32 | sk->sk_send_head = skb; |
33 | return skb_clone(skb: sk->sk_send_head, priority: gfp_any()); |
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 | */ |
42 | static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb) |
43 | { |
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); |
49 | struct dccp_hdr *dh; |
50 | /* XXX For now we're using only 48 bits sequence numbers */ |
51 | const u32 = sizeof(*dh) + |
52 | sizeof(struct dccp_hdr_ext) + |
53 | dccp_packet_hdr_len(type: 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 | fallthrough; |
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 | fallthrough; |
76 | |
77 | case DCCP_PKT_SYNC: |
78 | case DCCP_PKT_SYNCACK: |
79 | ackno = dcb->dccpd_ack_seq; |
80 | fallthrough; |
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, headlen: 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 */ |
108 | dh->dccph_x = 1; |
109 | |
110 | dccp_update_gss(sk, seq: dcb->dccpd_seq); |
111 | dccp_hdr_set_seq(dh, gss: dp->dccps_gss); |
112 | if (set_ack) |
113 | dccp_hdr_set_ack(dhack: dccp_hdr_ack_bits(skb), gsr: 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, 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(sk, skb, &inet->cork.fl); |
139 | return net_xmit_eval(err); |
140 | } |
141 | return -ENOBUFS; |
142 | } |
143 | |
144 | /** |
145 | * dccp_determine_ccmps - Find out about CCID-specific packet-size limits |
146 | * @dp: socket to find packet size limits of |
147 | * |
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". |
151 | */ |
152 | static u32 dccp_determine_ccmps(const struct dccp_sock *dp) |
153 | { |
154 | const struct ccid *tx_ccid = dp->dccps_hc_tx_ccid; |
155 | |
156 | if (tx_ccid == NULL || tx_ccid->ccid_ops == NULL) |
157 | return 0; |
158 | return tx_ccid->ccid_ops->ccid_ccmps; |
159 | } |
160 | |
161 | unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu) |
162 | { |
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; |
167 | |
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)); |
171 | |
172 | /* |
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) |
184 | */ |
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); |
187 | |
188 | /* And store cached results */ |
189 | icsk->icsk_pmtu_cookie = pmtu; |
190 | WRITE_ONCE(dp->dccps_mss_cache, cur_mps); |
191 | |
192 | return cur_mps; |
193 | } |
194 | |
195 | EXPORT_SYMBOL_GPL(dccp_sync_mss); |
196 | |
197 | void dccp_write_space(struct sock *sk) |
198 | { |
199 | struct socket_wq *wq; |
200 | |
201 | rcu_read_lock(); |
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, how: SOCK_WAKE_SPACE, POLL_OUT); |
208 | |
209 | rcu_read_unlock(); |
210 | } |
211 | |
212 | /** |
213 | * dccp_wait_for_ccid - Await CCID send permission |
214 | * @sk: socket to wait for |
215 | * @delay: timeout in jiffies |
216 | * |
217 | * This is used by CCIDs which need to delay the send time in process context. |
218 | */ |
219 | static int dccp_wait_for_ccid(struct sock *sk, unsigned long delay) |
220 | { |
221 | DEFINE_WAIT(wait); |
222 | long remaining; |
223 | |
224 | prepare_to_wait(wq_head: sk_sleep(sk), wq_entry: &wait, TASK_INTERRUPTIBLE); |
225 | sk->sk_write_pending++; |
226 | release_sock(sk); |
227 | |
228 | remaining = schedule_timeout(timeout: delay); |
229 | |
230 | lock_sock(sk); |
231 | sk->sk_write_pending--; |
232 | finish_wait(wq_head: sk_sleep(sk), wq_entry: &wait); |
233 | |
234 | if (signal_pending(current) || sk->sk_err) |
235 | return -1; |
236 | return remaining; |
237 | } |
238 | |
239 | /** |
240 | * dccp_xmit_packet - Send data packet under control of CCID |
241 | * @sk: socket to send data packet on |
242 | * |
243 | * Transmits next-queued payload and informs CCID to account for the packet. |
244 | */ |
245 | static void dccp_xmit_packet(struct sock *sk) |
246 | { |
247 | int err, len; |
248 | struct dccp_sock *dp = dccp_sk(sk); |
249 | struct sk_buff *skb = dccp_qpolicy_pop(sk); |
250 | |
251 | if (unlikely(skb == NULL)) |
252 | return; |
253 | len = skb->len; |
254 | |
255 | if (sk->sk_state == DCCP_PARTOPEN) { |
256 | const u32 cur_mps = dp->dccps_mss_cache - DCCP_FEATNEG_OVERHEAD; |
257 | /* |
258 | * See 8.1.5 - Handshake Completion. |
259 | * |
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. |
263 | */ |
264 | if (!list_empty(head: &dp->dccps_featneg) && len > cur_mps) { |
265 | DCCP_WARN("Payload too large (%d) for featneg.\n" , len); |
266 | dccp_send_ack(sk); |
267 | dccp_feat_list_purge(fn_list: &dp->dccps_featneg); |
268 | } |
269 | |
270 | inet_csk_schedule_ack(sk); |
271 | inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, |
272 | when: inet_csk(sk)->icsk_rto, |
273 | DCCP_RTO_MAX); |
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; |
277 | } else { |
278 | DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_DATA; |
279 | } |
280 | |
281 | err = dccp_transmit_skb(sk, skb); |
282 | if (err) |
283 | dccp_pr_debug("transmit_skb() returned err=%d\n" , err); |
284 | /* |
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. |
288 | */ |
289 | ccid_hc_tx_packet_sent(ccid: dp->dccps_hc_tx_ccid, sk, len); |
290 | |
291 | /* |
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. |
296 | */ |
297 | if (dp->dccps_sync_scheduled) |
298 | dccp_send_sync(sk, seq: dp->dccps_gsr, pkt_type: DCCP_PKT_SYNC); |
299 | } |
300 | |
301 | /** |
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 |
305 | * |
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. |
310 | */ |
311 | void dccp_flush_write_queue(struct sock *sk, long *time_budget) |
312 | { |
313 | struct dccp_sock *dp = dccp_sk(sk); |
314 | struct sk_buff *skb; |
315 | long delay, rc; |
316 | |
317 | while (*time_budget > 0 && (skb = skb_peek(list_: &sk->sk_write_queue))) { |
318 | rc = ccid_hc_tx_send_packet(ccid: dp->dccps_hc_tx_ccid, sk, skb); |
319 | |
320 | switch (ccid_packet_dequeue_eval(return_code: rc)) { |
321 | case CCID_PACKET_WILL_DEQUEUE_LATER: |
322 | /* |
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). |
326 | */ |
327 | DCCP_WARN("CCID did not manage to send all packets\n" ); |
328 | return; |
329 | case CCID_PACKET_DELAY: |
330 | delay = msecs_to_jiffies(m: rc); |
331 | if (delay > *time_budget) |
332 | return; |
333 | rc = dccp_wait_for_ccid(sk, delay); |
334 | if (rc < 0) |
335 | return; |
336 | *time_budget -= (delay - rc); |
337 | /* check again if we can send now */ |
338 | break; |
339 | case CCID_PACKET_SEND_AT_ONCE: |
340 | dccp_xmit_packet(sk); |
341 | break; |
342 | case CCID_PACKET_ERR: |
343 | skb_dequeue(list: &sk->sk_write_queue); |
344 | kfree_skb(skb); |
345 | dccp_pr_debug("packet discarded due to err=%ld\n" , rc); |
346 | } |
347 | } |
348 | } |
349 | |
350 | void dccp_write_xmit(struct sock *sk) |
351 | { |
352 | struct dccp_sock *dp = dccp_sk(sk); |
353 | struct sk_buff *skb; |
354 | |
355 | while ((skb = dccp_qpolicy_top(sk))) { |
356 | int rc = ccid_hc_tx_send_packet(ccid: dp->dccps_hc_tx_ccid, sk, skb); |
357 | |
358 | switch (ccid_packet_dequeue_eval(return_code: rc)) { |
359 | case CCID_PACKET_WILL_DEQUEUE_LATER: |
360 | return; |
361 | case CCID_PACKET_DELAY: |
362 | sk_reset_timer(sk, timer: &dp->dccps_xmit_timer, |
363 | expires: jiffies + msecs_to_jiffies(m: rc)); |
364 | return; |
365 | case CCID_PACKET_SEND_AT_ONCE: |
366 | dccp_xmit_packet(sk); |
367 | break; |
368 | case CCID_PACKET_ERR: |
369 | dccp_qpolicy_drop(sk, skb); |
370 | dccp_pr_debug("packet discarded due to err=%d\n" , rc); |
371 | } |
372 | } |
373 | } |
374 | |
375 | /** |
376 | * dccp_retransmit_skb - Retransmit Request, Close, or CloseReq packets |
377 | * @sk: socket to perform retransmit on |
378 | * |
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. |
385 | */ |
386 | int dccp_retransmit_skb(struct sock *sk) |
387 | { |
388 | WARN_ON(sk->sk_send_head == NULL); |
389 | |
390 | if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0) |
391 | return -EHOSTUNREACH; /* Routing failure or similar. */ |
392 | |
393 | /* this count is used to distinguish original and retransmitted skb */ |
394 | inet_csk(sk)->icsk_retransmits++; |
395 | |
396 | return dccp_transmit_skb(sk, skb: skb_clone(skb: sk->sk_send_head, GFP_ATOMIC)); |
397 | } |
398 | |
399 | struct sk_buff *dccp_make_response(const struct sock *sk, struct dst_entry *dst, |
400 | struct request_sock *req) |
401 | { |
402 | struct dccp_hdr *dh; |
403 | struct dccp_request_sock *dreq; |
404 | const u32 = sizeof(struct dccp_hdr) + |
405 | sizeof(struct dccp_hdr_ext) + |
406 | sizeof(struct dccp_hdr_response); |
407 | struct sk_buff *skb; |
408 | |
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. |
412 | */ |
413 | skb = sock_wmalloc(sk: (struct sock *)sk, MAX_DCCP_HEADER, force: 1, |
414 | GFP_ATOMIC); |
415 | if (!skb) |
416 | return NULL; |
417 | |
418 | skb_reserve(skb, MAX_DCCP_HEADER); |
419 | |
420 | skb_dst_set(skb, dst: dst_clone(dst)); |
421 | |
422 | dreq = dccp_rsk(req); |
423 | if (inet_rsk(sk: req)->acked) /* increase GSS upon retransmission */ |
424 | dccp_inc_seqno(seqno: &dreq->dreq_gss); |
425 | DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE; |
426 | DCCP_SKB_CB(skb)->dccpd_seq = dreq->dreq_gss; |
427 | |
428 | /* Resolve feature dependencies resulting from choice of CCID */ |
429 | if (dccp_feat_server_ccid_dependencies(dreq)) |
430 | goto response_failed; |
431 | |
432 | if (dccp_insert_options_rsk(dreq, skb)) |
433 | goto response_failed; |
434 | |
435 | /* Build and checksum header */ |
436 | dh = dccp_zeroed_hdr(skb, headlen: dccp_header_size); |
437 | |
438 | dh->dccph_sport = htons(inet_rsk(req)->ir_num); |
439 | dh->dccph_dport = inet_rsk(sk: 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; |
443 | dh->dccph_x = 1; |
444 | dccp_hdr_set_seq(dh, gss: dreq->dreq_gss); |
445 | dccp_hdr_set_ack(dhack: dccp_hdr_ack_bits(skb), gsr: dreq->dreq_gsr); |
446 | dccp_hdr_response(skb)->dccph_resp_service = dreq->dreq_service; |
447 | |
448 | dccp_csum_outgoing(skb); |
449 | |
450 | /* We use `acked' to remember that a Response was already sent. */ |
451 | inet_rsk(sk: req)->acked = 1; |
452 | DCCP_INC_STATS(DCCP_MIB_OUTSEGS); |
453 | return skb; |
454 | response_failed: |
455 | kfree_skb(skb); |
456 | return NULL; |
457 | } |
458 | |
459 | EXPORT_SYMBOL_GPL(dccp_make_response); |
460 | |
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) |
463 | { |
464 | struct dccp_hdr *rxdh = dccp_hdr(skb: 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; |
470 | struct sk_buff *skb; |
471 | |
472 | skb = alloc_skb(size: sk->sk_prot->max_header, GFP_ATOMIC); |
473 | if (skb == NULL) |
474 | return NULL; |
475 | |
476 | skb_reserve(skb, len: sk->sk_prot->max_header); |
477 | |
478 | /* Swap the send and the receive. */ |
479 | dh = dccp_zeroed_hdr(skb, headlen: 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; |
484 | dh->dccph_x = 1; |
485 | |
486 | dhr = dccp_hdr_reset(skb); |
487 | dhr->dccph_reset_code = dcb->dccpd_reset_code; |
488 | |
489 | switch (dcb->dccpd_reset_code) { |
490 | case DCCP_RESET_CODE_PACKET_ERROR: |
491 | dhr->dccph_reset_data[0] = rxdh->dccph_type; |
492 | break; |
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); |
496 | break; |
497 | } |
498 | /* |
499 | * From RFC 4340, 8.3.1: |
500 | * If P.ackno exists, set R.seqno := P.ackno + 1. |
501 | * Else set R.seqno := 0. |
502 | */ |
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(dhack: dccp_hdr_ack_bits(skb), gsr: dcb->dccpd_seq); |
506 | |
507 | dccp_csum_outgoing(skb); |
508 | return skb; |
509 | } |
510 | |
511 | EXPORT_SYMBOL_GPL(dccp_ctl_make_reset); |
512 | |
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) |
515 | { |
516 | struct sk_buff *skb; |
517 | /* |
518 | * FIXME: what if rebuild_header fails? |
519 | * Should we be doing a rebuild_header here? |
520 | */ |
521 | int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk); |
522 | |
523 | if (err != 0) |
524 | return err; |
525 | |
526 | skb = sock_wmalloc(sk, size: sk->sk_prot->max_header, force: 1, GFP_ATOMIC); |
527 | if (skb == NULL) |
528 | return -ENOBUFS; |
529 | |
530 | /* Reserve space for headers and prepare control bits. */ |
531 | skb_reserve(skb, len: sk->sk_prot->max_header); |
532 | DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESET; |
533 | DCCP_SKB_CB(skb)->dccpd_reset_code = code; |
534 | |
535 | return dccp_transmit_skb(sk, skb); |
536 | } |
537 | |
538 | /* |
539 | * Do all connect socket setups that can be done AF independent. |
540 | */ |
541 | int dccp_connect(struct sock *sk) |
542 | { |
543 | struct sk_buff *skb; |
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); |
547 | |
548 | sk->sk_err = 0; |
549 | sock_reset_flag(sk, flag: SOCK_DONE); |
550 | |
551 | dccp_sync_mss(sk, dst_mtu(dst)); |
552 | |
553 | /* do not connect if feature negotiation setup fails */ |
554 | if (dccp_feat_finalise_settings(dccp_sk(sk))) |
555 | return -EPROTO; |
556 | |
557 | /* Initialise GAR as per 8.5; AWL/AWH are set in dccp_transmit_skb() */ |
558 | dp->dccps_gar = dp->dccps_iss; |
559 | |
560 | skb = alloc_skb(size: sk->sk_prot->max_header, priority: sk->sk_allocation); |
561 | if (unlikely(skb == NULL)) |
562 | return -ENOBUFS; |
563 | |
564 | /* Reserve space for headers. */ |
565 | skb_reserve(skb, len: sk->sk_prot->max_header); |
566 | |
567 | DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST; |
568 | |
569 | dccp_transmit_skb(sk, skb: dccp_skb_entail(sk, skb)); |
570 | DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS); |
571 | |
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 | when: icsk->icsk_rto, DCCP_RTO_MAX); |
576 | return 0; |
577 | } |
578 | |
579 | EXPORT_SYMBOL_GPL(dccp_connect); |
580 | |
581 | void dccp_send_ack(struct sock *sk) |
582 | { |
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(size: sk->sk_prot->max_header, |
586 | GFP_ATOMIC); |
587 | |
588 | if (skb == NULL) { |
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, |
592 | TCP_DELACK_MAX, |
593 | DCCP_RTO_MAX); |
594 | return; |
595 | } |
596 | |
597 | /* Reserve space for headers */ |
598 | skb_reserve(skb, len: sk->sk_prot->max_header); |
599 | DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK; |
600 | dccp_transmit_skb(sk, skb); |
601 | } |
602 | } |
603 | |
604 | EXPORT_SYMBOL_GPL(dccp_send_ack); |
605 | |
606 | #if 0 |
607 | /* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */ |
608 | void dccp_send_delayed_ack(struct sock *sk) |
609 | { |
610 | struct inet_connection_sock *icsk = inet_csk(sk); |
611 | /* |
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. |
615 | */ |
616 | unsigned long timeout = jiffies + 2 * HZ; |
617 | |
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, |
621 | * send ACK now. |
622 | * |
623 | * FIXME: check the "about to expire" part |
624 | */ |
625 | if (icsk->icsk_ack.blocked) { |
626 | dccp_send_ack(sk); |
627 | return; |
628 | } |
629 | |
630 | if (!time_before(timeout, icsk->icsk_ack.timeout)) |
631 | timeout = icsk->icsk_ack.timeout; |
632 | } |
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); |
636 | } |
637 | #endif |
638 | |
639 | void dccp_send_sync(struct sock *sk, const u64 ackno, |
640 | const enum dccp_pkt_type pkt_type) |
641 | { |
642 | /* |
643 | * We are not putting this on the write queue, so |
644 | * dccp_transmit_skb() will set the ownership to this |
645 | * sock. |
646 | */ |
647 | struct sk_buff *skb = alloc_skb(size: sk->sk_prot->max_header, GFP_ATOMIC); |
648 | |
649 | if (skb == NULL) { |
650 | /* FIXME: how to make sure the sync is sent? */ |
651 | DCCP_CRIT("could not send %s" , dccp_packet_name(pkt_type)); |
652 | return; |
653 | } |
654 | |
655 | /* Reserve space for headers and prepare control bits. */ |
656 | skb_reserve(skb, len: sk->sk_prot->max_header); |
657 | DCCP_SKB_CB(skb)->dccpd_type = pkt_type; |
658 | DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno; |
659 | |
660 | /* |
661 | * Clear the flag in case the Sync was scheduled for out-of-band data, |
662 | * such as carrying a long Ack Vector. |
663 | */ |
664 | dccp_sk(sk)->dccps_sync_scheduled = 0; |
665 | |
666 | dccp_transmit_skb(sk, skb); |
667 | } |
668 | |
669 | EXPORT_SYMBOL_GPL(dccp_send_sync); |
670 | |
671 | /* |
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 |
674 | * any circumstances. |
675 | */ |
676 | void dccp_send_close(struct sock *sk, const int active) |
677 | { |
678 | struct dccp_sock *dp = dccp_sk(sk); |
679 | struct sk_buff *skb; |
680 | const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC; |
681 | |
682 | skb = alloc_skb(size: sk->sk_prot->max_header, priority: prio); |
683 | if (skb == NULL) |
684 | return; |
685 | |
686 | /* Reserve space for headers and prepare control bits. */ |
687 | skb_reserve(skb, len: 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; |
690 | else |
691 | DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_CLOSE; |
692 | |
693 | if (active) { |
694 | skb = dccp_skb_entail(sk, skb); |
695 | /* |
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. |
704 | */ |
705 | inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, |
706 | DCCP_TIMEOUT_INIT, DCCP_RTO_MAX); |
707 | } |
708 | dccp_transmit_skb(sk, skb); |
709 | } |
710 | |