1 // SPDX-License-Identifier: GPL-2.0
2 /* Multipath TCP
3 *
4 * Copyright (c) 2017 - 2019, Intel Corporation.
5 */
6
7 #define pr_fmt(fmt) "MPTCP: " fmt
8
9 #include <linux/kernel.h>
10 #include <crypto/sha2.h>
11 #include <net/tcp.h>
12 #include <net/mptcp.h>
13 #include "protocol.h"
14 #include "mib.h"
15
16 #include <trace/events/mptcp.h>
17
mptcp_cap_flag_sha256(u8 flags)18 static bool mptcp_cap_flag_sha256(u8 flags)
19 {
20 return (flags & MPTCP_CAP_FLAG_MASK) == MPTCP_CAP_HMAC_SHA256;
21 }
22
mptcp_parse_option(const struct sk_buff * skb,const unsigned char * ptr,int opsize,struct mptcp_options_received * mp_opt)23 static void mptcp_parse_option(const struct sk_buff *skb,
24 const unsigned char *ptr, int opsize,
25 struct mptcp_options_received *mp_opt)
26 {
27 u8 subtype = *ptr >> 4;
28 int expected_opsize;
29 u16 subopt;
30 u8 version;
31 u8 flags;
32 u8 i;
33
34 switch (subtype) {
35 case MPTCPOPT_MP_CAPABLE:
36 /* strict size checking */
37 if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
38 if (skb->len > tcp_hdr(skb)->doff << 2)
39 expected_opsize = TCPOLEN_MPTCP_MPC_ACK_DATA;
40 else
41 expected_opsize = TCPOLEN_MPTCP_MPC_ACK;
42 subopt = OPTION_MPTCP_MPC_ACK;
43 } else {
44 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK) {
45 expected_opsize = TCPOLEN_MPTCP_MPC_SYNACK;
46 subopt = OPTION_MPTCP_MPC_SYNACK;
47 } else {
48 expected_opsize = TCPOLEN_MPTCP_MPC_SYN;
49 subopt = OPTION_MPTCP_MPC_SYN;
50 }
51 }
52
53 /* Only the MPC + ACK can be used with a RM_ADDR */
54 if (subopt == OPTION_MPTCP_MPC_ACK) {
55 if ((mp_opt->suboptions & ~OPTION_MPTCP_RM_ADDR) != 0)
56 break;
57 } else if (mp_opt->suboptions != 0) {
58 break;
59 }
60
61 /* Cfr RFC 8684 Section 3.3.0:
62 * If a checksum is present but its use had
63 * not been negotiated in the MP_CAPABLE handshake, the receiver MUST
64 * close the subflow with a RST, as it is not behaving as negotiated.
65 * If a checksum is not present when its use has been negotiated, the
66 * receiver MUST close the subflow with a RST, as it is considered
67 * broken
68 * We parse even option with mismatching csum presence, so that
69 * later in subflow_data_ready we can trigger the reset.
70 */
71 if (opsize != expected_opsize &&
72 (expected_opsize != TCPOLEN_MPTCP_MPC_ACK_DATA ||
73 opsize != TCPOLEN_MPTCP_MPC_ACK_DATA_CSUM))
74 break;
75
76 /* try to be gentle vs future versions on the initial syn */
77 version = *ptr++ & MPTCP_VERSION_MASK;
78 if (opsize != TCPOLEN_MPTCP_MPC_SYN) {
79 if (version != MPTCP_SUPPORTED_VERSION)
80 break;
81 } else if (version < MPTCP_SUPPORTED_VERSION) {
82 break;
83 }
84
85 flags = *ptr++;
86 if (!mptcp_cap_flag_sha256(flags) ||
87 (flags & MPTCP_CAP_EXTENSIBILITY))
88 break;
89
90 /* RFC 6824, Section 3.1:
91 * "For the Checksum Required bit (labeled "A"), if either
92 * host requires the use of checksums, checksums MUST be used.
93 * In other words, the only way for checksums not to be used
94 * is if both hosts in their SYNs set A=0."
95 */
96 if (flags & MPTCP_CAP_CHECKSUM_REQD)
97 mp_opt->suboptions |= OPTION_MPTCP_CSUMREQD;
98
99 mp_opt->deny_join_id0 = !!(flags & MPTCP_CAP_DENY_JOIN_ID0);
100
101 mp_opt->suboptions |= subopt;
102 if (opsize >= TCPOLEN_MPTCP_MPC_SYNACK) {
103 mp_opt->sndr_key = get_unaligned_be64(ptr);
104 ptr += 8;
105 }
106 if (opsize >= TCPOLEN_MPTCP_MPC_ACK) {
107 mp_opt->rcvr_key = get_unaligned_be64(ptr);
108 ptr += 8;
109 }
110 if (opsize >= TCPOLEN_MPTCP_MPC_ACK_DATA) {
111 /* Section 3.1.:
112 * "the data parameters in a MP_CAPABLE are semantically
113 * equivalent to those in a DSS option and can be used
114 * interchangeably."
115 */
116 mp_opt->suboptions |= OPTION_MPTCP_DSS;
117 mp_opt->use_map = 1;
118 mp_opt->mpc_map = 1;
119 mp_opt->data_len = get_unaligned_be16(ptr);
120 ptr += 2;
121 }
122 if (opsize == TCPOLEN_MPTCP_MPC_ACK_DATA_CSUM) {
123 mp_opt->csum = get_unaligned((__force __sum16 *)ptr);
124 mp_opt->suboptions |= OPTION_MPTCP_CSUMREQD;
125 ptr += 2;
126 }
127 pr_debug("MP_CAPABLE version=%x, flags=%x, optlen=%d sndr=%llu, rcvr=%llu len=%d csum=%u\n",
128 version, flags, opsize, mp_opt->sndr_key,
129 mp_opt->rcvr_key, mp_opt->data_len, mp_opt->csum);
130 break;
131
132 case MPTCPOPT_MP_JOIN:
133 /* Can be used with a restricted number of other options */
134 if ((mp_opt->suboptions & ~(OPTION_MPTCP_RM_ADDR |
135 OPTION_MPTCP_PRIO)) != 0)
136 break;
137
138 if (opsize == TCPOLEN_MPTCP_MPJ_SYN) {
139 mp_opt->suboptions |= OPTION_MPTCP_MPJ_SYN;
140 mp_opt->backup = *ptr++ & MPTCPOPT_BACKUP;
141 mp_opt->join_id = *ptr++;
142 mp_opt->token = get_unaligned_be32(ptr);
143 ptr += 4;
144 mp_opt->nonce = get_unaligned_be32(ptr);
145 ptr += 4;
146 pr_debug("MP_JOIN bkup=%u, id=%u, token=%u, nonce=%u\n",
147 mp_opt->backup, mp_opt->join_id,
148 mp_opt->token, mp_opt->nonce);
149 } else if (opsize == TCPOLEN_MPTCP_MPJ_SYNACK) {
150 mp_opt->suboptions |= OPTION_MPTCP_MPJ_SYNACK;
151 mp_opt->backup = *ptr++ & MPTCPOPT_BACKUP;
152 mp_opt->join_id = *ptr++;
153 mp_opt->thmac = get_unaligned_be64(ptr);
154 ptr += 8;
155 mp_opt->nonce = get_unaligned_be32(ptr);
156 ptr += 4;
157 pr_debug("MP_JOIN bkup=%u, id=%u, thmac=%llu, nonce=%u\n",
158 mp_opt->backup, mp_opt->join_id,
159 mp_opt->thmac, mp_opt->nonce);
160 } else if (opsize == TCPOLEN_MPTCP_MPJ_ACK) {
161 mp_opt->suboptions |= OPTION_MPTCP_MPJ_ACK;
162 ptr += 2;
163 memcpy(mp_opt->hmac, ptr, MPTCPOPT_HMAC_LEN);
164 pr_debug("MP_JOIN hmac\n");
165 }
166 break;
167
168 case MPTCPOPT_DSS:
169 /* Can be used with a restricted number of other options */
170 if ((mp_opt->suboptions & ~(OPTION_MPTCP_ADD_ADDR |
171 OPTION_MPTCP_RM_ADDR |
172 OPTION_MPTCP_PRIO |
173 OPTION_MPTCP_FASTCLOSE |
174 OPTION_MPTCP_FAIL)) != 0)
175 break;
176
177 pr_debug("DSS\n");
178 ptr++;
179
180 flags = (*ptr++) & MPTCP_DSS_FLAG_MASK;
181 mp_opt->dsn64 = (flags & MPTCP_DSS_DSN64) != 0;
182 mp_opt->use_map = (flags & MPTCP_DSS_HAS_MAP) != 0;
183 mp_opt->ack64 = (flags & MPTCP_DSS_ACK64) != 0;
184 mp_opt->use_ack = (flags & MPTCP_DSS_HAS_ACK);
185
186 expected_opsize = TCPOLEN_MPTCP_DSS_BASE;
187
188 if (mp_opt->use_ack) {
189 if (mp_opt->ack64)
190 expected_opsize += TCPOLEN_MPTCP_DSS_ACK64;
191 else
192 expected_opsize += TCPOLEN_MPTCP_DSS_ACK32;
193 }
194
195 if (mp_opt->use_map) {
196 mp_opt->data_fin = (flags & MPTCP_DSS_DATA_FIN) != 0;
197 if (mp_opt->dsn64)
198 expected_opsize += TCPOLEN_MPTCP_DSS_MAP64;
199 else
200 expected_opsize += TCPOLEN_MPTCP_DSS_MAP32;
201 }
202
203 pr_debug("data_fin=%d dsn64=%d use_map=%d ack64=%d use_ack=%d\n",
204 mp_opt->data_fin, mp_opt->dsn64,
205 mp_opt->use_map, mp_opt->ack64,
206 mp_opt->use_ack);
207
208 /* Always parse any csum presence combination, we will enforce
209 * RFC 8684 Section 3.3.0 checks later in subflow_data_ready
210 */
211 if (opsize != expected_opsize &&
212 opsize != expected_opsize + TCPOLEN_MPTCP_DSS_CHECKSUM) {
213 mp_opt->dsn64 = 0;
214 mp_opt->use_map = 0;
215 mp_opt->ack64 = 0;
216 mp_opt->use_ack = 0;
217 mp_opt->data_fin = 0;
218 break;
219 }
220
221 mp_opt->suboptions |= OPTION_MPTCP_DSS;
222 if (mp_opt->use_ack) {
223 if (mp_opt->ack64) {
224 mp_opt->data_ack = get_unaligned_be64(ptr);
225 ptr += 8;
226 } else {
227 mp_opt->data_ack = get_unaligned_be32(ptr);
228 ptr += 4;
229 }
230
231 pr_debug("data_ack=%llu\n", mp_opt->data_ack);
232 }
233
234 if (mp_opt->use_map) {
235 if (mp_opt->dsn64) {
236 mp_opt->data_seq = get_unaligned_be64(ptr);
237 ptr += 8;
238 } else {
239 mp_opt->data_seq = get_unaligned_be32(ptr);
240 ptr += 4;
241 }
242
243 mp_opt->subflow_seq = get_unaligned_be32(ptr);
244 ptr += 4;
245
246 mp_opt->data_len = get_unaligned_be16(ptr);
247 ptr += 2;
248
249 if (opsize == expected_opsize + TCPOLEN_MPTCP_DSS_CHECKSUM) {
250 mp_opt->suboptions |= OPTION_MPTCP_CSUMREQD;
251 mp_opt->csum = get_unaligned((__force __sum16 *)ptr);
252 ptr += 2;
253 }
254
255 pr_debug("data_seq=%llu subflow_seq=%u data_len=%u csum=%d:%u\n",
256 mp_opt->data_seq, mp_opt->subflow_seq,
257 mp_opt->data_len, !!(mp_opt->suboptions & OPTION_MPTCP_CSUMREQD),
258 mp_opt->csum);
259 }
260
261 break;
262
263 case MPTCPOPT_ADD_ADDR:
264 /* Can be used with a restricted number of other options */
265 if ((mp_opt->suboptions & ~(OPTIONS_MPTCP_DSS |
266 OPTION_MPTCP_RM_ADDR |
267 OPTION_MPTCP_PRIO)) != 0)
268 break;
269
270 mp_opt->echo = (*ptr++) & MPTCP_ADDR_ECHO;
271 if (!mp_opt->echo) {
272 if (opsize == TCPOLEN_MPTCP_ADD_ADDR ||
273 opsize == TCPOLEN_MPTCP_ADD_ADDR_PORT)
274 mp_opt->addr.family = AF_INET;
275 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
276 else if (opsize == TCPOLEN_MPTCP_ADD_ADDR6 ||
277 opsize == TCPOLEN_MPTCP_ADD_ADDR6_PORT)
278 mp_opt->addr.family = AF_INET6;
279 #endif
280 else
281 break;
282 } else {
283 if (opsize == TCPOLEN_MPTCP_ADD_ADDR_BASE ||
284 opsize == TCPOLEN_MPTCP_ADD_ADDR_BASE_PORT)
285 mp_opt->addr.family = AF_INET;
286 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
287 else if (opsize == TCPOLEN_MPTCP_ADD_ADDR6_BASE ||
288 opsize == TCPOLEN_MPTCP_ADD_ADDR6_BASE_PORT)
289 mp_opt->addr.family = AF_INET6;
290 #endif
291 else
292 break;
293 }
294
295 mp_opt->suboptions |= OPTION_MPTCP_ADD_ADDR;
296 mp_opt->addr.id = *ptr++;
297 mp_opt->addr.port = 0;
298 mp_opt->ahmac = 0;
299 if (mp_opt->addr.family == AF_INET) {
300 memcpy((u8 *)&mp_opt->addr.addr.s_addr, (u8 *)ptr, 4);
301 ptr += 4;
302 if (opsize == TCPOLEN_MPTCP_ADD_ADDR_PORT ||
303 opsize == TCPOLEN_MPTCP_ADD_ADDR_BASE_PORT) {
304 mp_opt->addr.port = htons(get_unaligned_be16(ptr));
305 ptr += 2;
306 }
307 }
308 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
309 else {
310 memcpy(mp_opt->addr.addr6.s6_addr, (u8 *)ptr, 16);
311 ptr += 16;
312 if (opsize == TCPOLEN_MPTCP_ADD_ADDR6_PORT ||
313 opsize == TCPOLEN_MPTCP_ADD_ADDR6_BASE_PORT) {
314 mp_opt->addr.port = htons(get_unaligned_be16(ptr));
315 ptr += 2;
316 }
317 }
318 #endif
319 if (!mp_opt->echo) {
320 mp_opt->ahmac = get_unaligned_be64(ptr);
321 ptr += 8;
322 }
323 pr_debug("ADD_ADDR%s: id=%d, ahmac=%llu, echo=%d, port=%d\n",
324 (mp_opt->addr.family == AF_INET6) ? "6" : "",
325 mp_opt->addr.id, mp_opt->ahmac, mp_opt->echo, ntohs(mp_opt->addr.port));
326 break;
327
328 case MPTCPOPT_RM_ADDR:
329 /* Can be used with a restricted number of other options */
330 if ((mp_opt->suboptions & ~(OPTION_MPTCP_MPC_ACK |
331 OPTIONS_MPTCP_MPJ |
332 OPTIONS_MPTCP_DSS |
333 OPTION_MPTCP_ADD_ADDR |
334 OPTION_MPTCP_PRIO)) != 0)
335 break;
336
337 if (opsize < TCPOLEN_MPTCP_RM_ADDR_BASE + 1 ||
338 opsize > TCPOLEN_MPTCP_RM_ADDR_BASE + MPTCP_RM_IDS_MAX)
339 break;
340
341 ptr++;
342
343 mp_opt->suboptions |= OPTION_MPTCP_RM_ADDR;
344 mp_opt->rm_list.nr = opsize - TCPOLEN_MPTCP_RM_ADDR_BASE;
345 for (i = 0; i < mp_opt->rm_list.nr; i++)
346 mp_opt->rm_list.ids[i] = *ptr++;
347 pr_debug("RM_ADDR: rm_list_nr=%d\n", mp_opt->rm_list.nr);
348 break;
349
350 case MPTCPOPT_MP_PRIO:
351 /* Can be used with a restricted number of other options */
352 if ((mp_opt->suboptions & ~(OPTIONS_MPTCP_MPJ |
353 OPTIONS_MPTCP_DSS |
354 OPTION_MPTCP_ADD_ADDR |
355 OPTION_MPTCP_RM_ADDR)) != 0)
356 break;
357
358 if (opsize != TCPOLEN_MPTCP_PRIO)
359 break;
360
361 mp_opt->suboptions |= OPTION_MPTCP_PRIO;
362 mp_opt->backup = *ptr++ & MPTCP_PRIO_BKUP;
363 pr_debug("MP_PRIO: prio=%d\n", mp_opt->backup);
364 break;
365
366 case MPTCPOPT_MP_FASTCLOSE:
367 /* Can be used with a restricted number of other options */
368 if ((mp_opt->suboptions & ~(OPTIONS_MPTCP_DSS |
369 OPTION_MPTCP_RST)) != 0)
370 break;
371
372 if (opsize != TCPOLEN_MPTCP_FASTCLOSE)
373 break;
374
375 ptr += 2;
376 mp_opt->rcvr_key = get_unaligned_be64(ptr);
377 ptr += 8;
378 mp_opt->suboptions |= OPTION_MPTCP_FASTCLOSE;
379 pr_debug("MP_FASTCLOSE: recv_key=%llu\n", mp_opt->rcvr_key);
380 break;
381
382 case MPTCPOPT_RST:
383 /* Can be used with a restricted number of other options */
384 if ((mp_opt->suboptions & ~(OPTION_MPTCP_FAIL |
385 OPTION_MPTCP_FASTCLOSE)) != 0)
386 break;
387
388 if (opsize != TCPOLEN_MPTCP_RST)
389 break;
390
391 if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_RST))
392 break;
393
394 mp_opt->suboptions |= OPTION_MPTCP_RST;
395 flags = *ptr++;
396 mp_opt->reset_transient = flags & MPTCP_RST_TRANSIENT;
397 mp_opt->reset_reason = *ptr;
398 pr_debug("MP_RST: transient=%u reason=%u\n",
399 mp_opt->reset_transient, mp_opt->reset_reason);
400 break;
401
402 case MPTCPOPT_MP_FAIL:
403 /* Can be used with a restricted number of other options */
404 if ((mp_opt->suboptions & ~(OPTIONS_MPTCP_DSS |
405 OPTION_MPTCP_RST)) != 0)
406 break;
407
408 if (opsize != TCPOLEN_MPTCP_FAIL)
409 break;
410
411 ptr += 2;
412 mp_opt->suboptions |= OPTION_MPTCP_FAIL;
413 mp_opt->fail_seq = get_unaligned_be64(ptr);
414 pr_debug("MP_FAIL: data_seq=%llu\n", mp_opt->fail_seq);
415 break;
416
417 default:
418 break;
419 }
420 }
421
mptcp_get_options(const struct sk_buff * skb,struct mptcp_options_received * mp_opt)422 void mptcp_get_options(const struct sk_buff *skb,
423 struct mptcp_options_received *mp_opt)
424 {
425 const struct tcphdr *th = tcp_hdr(skb);
426 const unsigned char *ptr;
427 int length;
428
429 /* Ensure that casting the whole status to u32 is efficient and safe */
430 BUILD_BUG_ON(sizeof_field(struct mptcp_options_received, status) != sizeof(u32));
431 BUILD_BUG_ON(!IS_ALIGNED(offsetof(struct mptcp_options_received, status),
432 sizeof(u32)));
433 *(u32 *)&mp_opt->status = 0;
434
435 length = (th->doff * 4) - sizeof(struct tcphdr);
436 ptr = (const unsigned char *)(th + 1);
437
438 while (length > 0) {
439 int opcode = *ptr++;
440 int opsize;
441
442 switch (opcode) {
443 case TCPOPT_EOL:
444 return;
445 case TCPOPT_NOP: /* Ref: RFC 793 section 3.1 */
446 length--;
447 continue;
448 default:
449 if (length < 2)
450 return;
451 opsize = *ptr++;
452 if (opsize < 2) /* "silly options" */
453 return;
454 if (opsize > length)
455 return; /* don't parse partial options */
456 if (opcode == TCPOPT_MPTCP)
457 mptcp_parse_option(skb, ptr, opsize, mp_opt);
458 ptr += opsize - 2;
459 length -= opsize;
460 }
461 }
462 }
463
mptcp_syn_options(struct sock * sk,const struct sk_buff * skb,unsigned int * size,struct mptcp_out_options * opts)464 bool mptcp_syn_options(struct sock *sk, const struct sk_buff *skb,
465 unsigned int *size, struct mptcp_out_options *opts)
466 {
467 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
468
469 /* we will use snd_isn to detect first pkt [re]transmission
470 * in mptcp_established_options_mp()
471 */
472 subflow->snd_isn = TCP_SKB_CB(skb)->end_seq;
473 if (subflow->request_mptcp) {
474 if (unlikely(subflow_simultaneous_connect(sk))) {
475 WARN_ON_ONCE(!mptcp_try_fallback(sk, MPTCP_MIB_SIMULTCONNFALLBACK));
476
477 /* Ensure mptcp_finish_connect() will not process the
478 * MPC handshake.
479 */
480 subflow->request_mptcp = 0;
481 return false;
482 }
483
484 opts->suboptions = OPTION_MPTCP_MPC_SYN;
485 opts->csum_reqd = mptcp_is_checksum_enabled(sock_net(sk));
486 opts->allow_join_id0 = mptcp_allow_join_id0(sock_net(sk));
487 *size = TCPOLEN_MPTCP_MPC_SYN;
488 return true;
489 } else if (subflow->request_join) {
490 pr_debug("remote_token=%u, nonce=%u\n", subflow->remote_token,
491 subflow->local_nonce);
492 opts->suboptions = OPTION_MPTCP_MPJ_SYN;
493 opts->join_id = subflow->local_id;
494 opts->token = subflow->remote_token;
495 opts->nonce = subflow->local_nonce;
496 opts->backup = subflow->request_bkup;
497 *size = TCPOLEN_MPTCP_MPJ_SYN;
498 return true;
499 }
500 return false;
501 }
502
clear_3rdack_retransmission(struct sock * sk)503 static void clear_3rdack_retransmission(struct sock *sk)
504 {
505 struct inet_connection_sock *icsk = inet_csk(sk);
506
507 sk_stop_timer(sk, &icsk->icsk_delack_timer);
508 icsk->icsk_ack.ato = 0;
509 icsk->icsk_ack.pending &= ~(ICSK_ACK_SCHED | ICSK_ACK_TIMER);
510 }
511
mptcp_established_options_mp(struct sock * sk,struct sk_buff * skb,bool snd_data_fin_enable,int * size,struct mptcp_out_options * opts)512 static bool mptcp_established_options_mp(struct sock *sk, struct sk_buff *skb,
513 bool snd_data_fin_enable, int *size,
514 struct mptcp_out_options *opts)
515 {
516 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
517 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
518 struct mptcp_ext *mpext;
519 unsigned int data_len;
520 u8 len;
521
522 /* When skb is not available, we better over-estimate the emitted
523 * options len. A full DSS option (28 bytes) is longer than
524 * TCPOLEN_MPTCP_MPC_ACK_DATA(22) or TCPOLEN_MPTCP_MPJ_ACK(24), so
525 * tell the caller to defer the estimate to
526 * mptcp_established_options_dss(), which will reserve enough space.
527 */
528 if (!skb)
529 return false;
530
531 /* MPC/MPJ needed only on 3rd ack packet, DATA_FIN and TCP shutdown take precedence */
532 if (READ_ONCE(subflow->fully_established) || snd_data_fin_enable ||
533 subflow->snd_isn != TCP_SKB_CB(skb)->seq ||
534 sk->sk_state != TCP_ESTABLISHED)
535 return false;
536
537 if (subflow->mp_capable) {
538 mpext = mptcp_get_ext(skb);
539 data_len = mpext ? mpext->data_len : 0;
540
541 /* we will check ops->data_len in mptcp_write_options() to
542 * discriminate between TCPOLEN_MPTCP_MPC_ACK_DATA and
543 * TCPOLEN_MPTCP_MPC_ACK
544 */
545 opts->data_len = data_len;
546 opts->suboptions = OPTION_MPTCP_MPC_ACK;
547 opts->sndr_key = subflow->local_key;
548 opts->rcvr_key = subflow->remote_key;
549 opts->csum_reqd = READ_ONCE(msk->csum_enabled);
550 opts->allow_join_id0 = mptcp_allow_join_id0(sock_net(sk));
551
552 /* Section 3.1.
553 * The MP_CAPABLE option is carried on the SYN, SYN/ACK, and ACK
554 * packets that start the first subflow of an MPTCP connection,
555 * as well as the first packet that carries data
556 */
557 if (data_len > 0) {
558 len = TCPOLEN_MPTCP_MPC_ACK_DATA;
559 if (opts->csum_reqd) {
560 /* we need to propagate more info to csum the pseudo hdr */
561 opts->data_seq = mpext->data_seq;
562 opts->subflow_seq = mpext->subflow_seq;
563 opts->csum = mpext->csum;
564 len += TCPOLEN_MPTCP_DSS_CHECKSUM;
565 }
566 *size = ALIGN(len, 4);
567 } else {
568 *size = TCPOLEN_MPTCP_MPC_ACK;
569 }
570
571 pr_debug("subflow=%p, local_key=%llu, remote_key=%llu map_len=%d\n",
572 subflow, subflow->local_key, subflow->remote_key,
573 data_len);
574
575 return true;
576 } else if (subflow->mp_join) {
577 opts->suboptions = OPTION_MPTCP_MPJ_ACK;
578 memcpy(opts->hmac, subflow->hmac, MPTCPOPT_HMAC_LEN);
579 *size = TCPOLEN_MPTCP_MPJ_ACK;
580 pr_debug("subflow=%p\n", subflow);
581
582 /* we can use the full delegate action helper only from BH context
583 * If we are in process context - sk is flushing the backlog at
584 * socket lock release time - just set the appropriate flag, will
585 * be handled by the release callback
586 */
587 if (sock_owned_by_user(sk))
588 set_bit(MPTCP_DELEGATE_ACK, &subflow->delegated_status);
589 else
590 mptcp_subflow_delegate(subflow, MPTCP_DELEGATE_ACK);
591 return true;
592 }
593 return false;
594 }
595
mptcp_write_data_fin(struct mptcp_subflow_context * subflow,struct sk_buff * skb,struct mptcp_ext * ext)596 static void mptcp_write_data_fin(struct mptcp_subflow_context *subflow,
597 struct sk_buff *skb, struct mptcp_ext *ext)
598 {
599 /* The write_seq value has already been incremented, so the actual
600 * sequence number for the DATA_FIN is one less.
601 */
602 u64 data_fin_tx_seq = READ_ONCE(mptcp_sk(subflow->conn)->write_seq) - 1;
603
604 if (!ext->use_map || !skb->len) {
605 /* RFC6824 requires a DSS mapping with specific values
606 * if DATA_FIN is set but no data payload is mapped
607 */
608 ext->data_fin = 1;
609 ext->use_map = 1;
610 ext->dsn64 = 1;
611 ext->data_seq = data_fin_tx_seq;
612 ext->subflow_seq = 0;
613 ext->data_len = 1;
614 } else if (ext->data_seq + ext->data_len == data_fin_tx_seq) {
615 /* If there's an existing DSS mapping and it is the
616 * final mapping, DATA_FIN consumes 1 additional byte of
617 * mapping space.
618 */
619 ext->data_fin = 1;
620 ext->data_len++;
621 }
622 }
623
mptcp_established_options_dss(struct sock * sk,struct sk_buff * skb,bool snd_data_fin_enable,int * size,struct mptcp_out_options * opts)624 static bool mptcp_established_options_dss(struct sock *sk, struct sk_buff *skb,
625 bool snd_data_fin_enable, int *size,
626 struct mptcp_out_options *opts)
627 {
628 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
629 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
630 struct tcp_sock *tp = tcp_sk(sk);
631 unsigned int dss_size = 0;
632 struct mptcp_ext *mpext;
633 unsigned int ack_size;
634 bool ret = false;
635
636 /* Zero `use_ack` and `use_map` flags with one shot. */
637 memset(&opts->ext_copy.flags, 0, sizeof(opts->ext_copy.flags));
638 opts->csum_reqd = READ_ONCE(msk->csum_enabled);
639 mpext = skb ? mptcp_get_ext(skb) : NULL;
640
641 if (!skb || (mpext && mpext->use_map) || snd_data_fin_enable) {
642 unsigned int map_size = TCPOLEN_MPTCP_DSS_BASE + TCPOLEN_MPTCP_DSS_MAP64;
643
644 if (mpext) {
645 if (opts->csum_reqd)
646 map_size += TCPOLEN_MPTCP_DSS_CHECKSUM;
647
648 opts->ext_copy = *mpext;
649 }
650
651 dss_size = map_size;
652 if (skb && snd_data_fin_enable)
653 mptcp_write_data_fin(subflow, skb, &opts->ext_copy);
654 opts->suboptions = OPTION_MPTCP_DSS;
655 ret = true;
656 }
657
658 /* passive sockets msk will set the 'can_ack' after accept(), even
659 * if the first subflow may have the already the remote key handy
660 */
661 if (!READ_ONCE(msk->can_ack)) {
662 *size = ALIGN(dss_size, 4);
663 return ret;
664 }
665
666 if (READ_ONCE(msk->use_64bit_ack)) {
667 ack_size = TCPOLEN_MPTCP_DSS_ACK64;
668 opts->ext_copy.ack64 = 1;
669 } else {
670 ack_size = TCPOLEN_MPTCP_DSS_ACK32;
671 opts->ext_copy.ack64 = 0;
672 }
673 opts->ext_copy.use_ack = 1;
674 opts->suboptions = OPTION_MPTCP_DSS;
675
676 /* Add kind/length/subtype/flag overhead if mapping is not populated */
677 if (dss_size == 0)
678 ack_size += TCPOLEN_MPTCP_DSS_BASE;
679
680 /* The caller is __tcp_transmit_skb(), and will compute the new rcv
681 * wnd soon: ensure that the window can shrink.
682 */
683 if (skb)
684 tp->rcv_wnd = tp->rcv_nxt - tp->rcv_wup;
685
686 dss_size += ack_size;
687
688 *size = ALIGN(dss_size, 4);
689 return true;
690 }
691
add_addr_generate_hmac(u64 key1,u64 key2,struct mptcp_addr_info * addr)692 static u64 add_addr_generate_hmac(u64 key1, u64 key2,
693 struct mptcp_addr_info *addr)
694 {
695 u16 port = ntohs(addr->port);
696 u8 hmac[SHA256_DIGEST_SIZE];
697 u8 msg[19];
698 int i = 0;
699
700 msg[i++] = addr->id;
701 if (addr->family == AF_INET) {
702 memcpy(&msg[i], &addr->addr.s_addr, 4);
703 i += 4;
704 }
705 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
706 else if (addr->family == AF_INET6) {
707 memcpy(&msg[i], &addr->addr6.s6_addr, 16);
708 i += 16;
709 }
710 #endif
711 msg[i++] = port >> 8;
712 msg[i++] = port & 0xFF;
713
714 mptcp_crypto_hmac_sha(key1, key2, msg, i, hmac);
715
716 return get_unaligned_be64(&hmac[SHA256_DIGEST_SIZE - sizeof(u64)]);
717 }
718
mptcp_established_options_add_addr(struct sock * sk,struct sk_buff * skb,int * size,unsigned int remaining,bool has_ts,struct mptcp_out_options * opts)719 static bool mptcp_established_options_add_addr(struct sock *sk,
720 struct sk_buff *skb, int *size,
721 unsigned int remaining,
722 bool has_ts,
723 struct mptcp_out_options *opts)
724 {
725 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
726 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
727 struct mptcp_addr_info addr;
728 bool drop_ts = has_ts;
729 bool echo;
730
731 /* add addr will strip the existing options, be sure to avoid breaking
732 * MPC/MPJ handshakes
733 */
734 if (!mptcp_pm_should_add_signal(msk) ||
735 (opts->suboptions & (OPTION_MPTCP_MPJ_ACK | OPTION_MPTCP_MPC_ACK)) ||
736 !skb || !skb_is_tcp_pure_ack(skb) ||
737 !mptcp_pm_add_addr_signal(msk, size, remaining, &addr, &echo,
738 &drop_ts))
739 return false;
740
741 pr_debug("drop other suboptions\n");
742 opts->suboptions = OPTION_MPTCP_ADD_ADDR;
743 opts->drop_ts = drop_ts;
744 opts->addr = addr;
745 if (!echo) {
746 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_ADDADDRTX);
747 opts->ahmac = add_addr_generate_hmac(READ_ONCE(msk->local_key),
748 READ_ONCE(msk->remote_key),
749 &opts->addr);
750 } else {
751 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_ECHOADDTX);
752 opts->ahmac = 0;
753 }
754 pr_debug("addr_id=%d, ahmac=%llu, echo=%d, port=%d\n",
755 opts->addr.id, opts->ahmac, echo, ntohs(opts->addr.port));
756
757 return true;
758 }
759
mptcp_established_options_rm_addr(struct sock * sk,int * size,unsigned int remaining,struct mptcp_out_options * opts)760 static bool mptcp_established_options_rm_addr(struct sock *sk, int *size,
761 unsigned int remaining,
762 struct mptcp_out_options *opts)
763 {
764 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
765 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
766 struct mptcp_rm_list rm_list;
767 int i;
768
769 if (!mptcp_pm_should_rm_signal(msk) ||
770 !(mptcp_pm_rm_addr_signal(msk, remaining, &rm_list, size)))
771 return false;
772
773 opts->suboptions |= OPTION_MPTCP_RM_ADDR;
774 opts->rm_list = rm_list;
775
776 for (i = 0; i < opts->rm_list.nr; i++)
777 pr_debug("rm_list_ids[%d]=%d\n", i, opts->rm_list.ids[i]);
778 MPTCP_ADD_STATS(sock_net(sk), MPTCP_MIB_RMADDRTX, opts->rm_list.nr);
779 return true;
780 }
781
mptcp_established_options_mp_prio(struct sock * sk,int * size,unsigned int remaining,struct mptcp_out_options * opts)782 static bool mptcp_established_options_mp_prio(struct sock *sk, int *size,
783 unsigned int remaining,
784 struct mptcp_out_options *opts)
785 {
786 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
787
788 /* can't send MP_PRIO with MPC, as they share the same option space:
789 * 'backup'. Also it makes no sense at all
790 */
791 if (!subflow->send_mp_prio || (opts->suboptions & OPTIONS_MPTCP_MPC))
792 return false;
793
794 /* account for the trailing 'nop' option */
795 if (remaining < TCPOLEN_MPTCP_PRIO_ALIGN)
796 return false;
797
798 *size = TCPOLEN_MPTCP_PRIO_ALIGN;
799 opts->suboptions |= OPTION_MPTCP_PRIO;
800 opts->backup = subflow->request_bkup;
801
802 pr_debug("prio=%d\n", opts->backup);
803
804 return true;
805 }
806
mptcp_established_options_rst(struct sock * sk,int * size,unsigned int remaining,struct mptcp_out_options * opts)807 static noinline bool mptcp_established_options_rst(struct sock *sk,
808 int *size,
809 unsigned int remaining,
810 struct mptcp_out_options *opts)
811 {
812 const struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
813
814 if (remaining < TCPOLEN_MPTCP_RST)
815 return false;
816
817 *size = TCPOLEN_MPTCP_RST;
818 opts->suboptions |= OPTION_MPTCP_RST;
819 opts->reset_transient = subflow->reset_transient;
820 opts->reset_reason = subflow->reset_reason;
821 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPRSTTX);
822
823 return true;
824 }
825
mptcp_established_options_fastclose(struct sock * sk,int * size,unsigned int remaining,struct mptcp_out_options * opts)826 static bool mptcp_established_options_fastclose(struct sock *sk, int *size,
827 unsigned int remaining,
828 struct mptcp_out_options *opts)
829 {
830 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
831 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
832
833 if (likely(!subflow->send_fastclose))
834 return false;
835
836 if (remaining < TCPOLEN_MPTCP_FASTCLOSE)
837 return false;
838
839 *size = TCPOLEN_MPTCP_FASTCLOSE;
840 opts->suboptions |= OPTION_MPTCP_FASTCLOSE;
841 opts->rcvr_key = READ_ONCE(msk->remote_key);
842
843 pr_debug("FASTCLOSE key=%llu\n", opts->rcvr_key);
844 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFASTCLOSETX);
845 return true;
846 }
847
mptcp_established_options_mp_fail(struct sock * sk,int * size,unsigned int remaining,struct mptcp_out_options * opts)848 static bool mptcp_established_options_mp_fail(struct sock *sk, int *size,
849 unsigned int remaining,
850 struct mptcp_out_options *opts)
851 {
852 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
853
854 if (likely(!subflow->send_mp_fail))
855 return false;
856
857 if (remaining < TCPOLEN_MPTCP_FAIL)
858 return false;
859
860 *size = TCPOLEN_MPTCP_FAIL;
861 opts->suboptions |= OPTION_MPTCP_FAIL;
862 opts->fail_seq = subflow->map_seq;
863
864 pr_debug("MP_FAIL fail_seq=%llu\n", opts->fail_seq);
865 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFAILTX);
866
867 return true;
868 }
869
mptcp_established_options(struct sock * sk,struct sk_buff * skb,unsigned int remaining,bool has_ts,struct mptcp_out_options * opts)870 int mptcp_established_options(struct sock *sk, struct sk_buff *skb,
871 unsigned int remaining, bool has_ts,
872 struct mptcp_out_options *opts)
873 {
874 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
875 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
876 int total_size = 0;
877 bool snd_data_fin;
878 bool ret = false;
879 int opt_size = 0;
880
881 opts->suboptions = 0;
882
883 /* Force later mptcp_write_options(), but do not use any actual
884 * option space.
885 */
886 if (unlikely(__mptcp_check_fallback(msk) && !mptcp_check_infinite_map(skb)))
887 return 0;
888
889 if (unlikely(skb && TCP_SKB_CB(skb)->tcp_flags & TCPHDR_RST)) {
890 if (mptcp_established_options_fastclose(sk, &opt_size, remaining, opts) ||
891 mptcp_established_options_mp_fail(sk, &opt_size, remaining, opts)) {
892 total_size += opt_size;
893 remaining -= opt_size;
894 }
895 /* MP_RST can be used with MP_FASTCLOSE and MP_FAIL if there is room */
896 if (mptcp_established_options_rst(sk, &opt_size, remaining, opts)) {
897 total_size += opt_size;
898 remaining -= opt_size;
899 }
900 return total_size;
901 }
902
903 snd_data_fin = mptcp_data_fin_enabled(msk);
904 if (mptcp_established_options_mp(sk, skb, snd_data_fin, &opt_size, opts))
905 ret = true;
906 else if (mptcp_established_options_dss(sk, skb, snd_data_fin, &opt_size, opts)) {
907 int mp_fail_size;
908
909 ret = true;
910 if (mptcp_established_options_mp_fail(sk, &mp_fail_size,
911 remaining - opt_size, opts)) {
912 total_size += opt_size + mp_fail_size;
913 remaining -= opt_size - mp_fail_size;
914 return total_size;
915 }
916 }
917
918 /* we reserved enough space for the above options, and exceeding the
919 * TCP option space would be fatal
920 */
921 if (WARN_ON_ONCE(opt_size > remaining))
922 return -1;
923
924 total_size += opt_size;
925 remaining -= opt_size;
926 if (mptcp_established_options_add_addr(sk, skb, &opt_size, remaining,
927 has_ts, opts)) {
928 total_size += opt_size;
929 remaining -= opt_size;
930 ret = true;
931 } else if (mptcp_established_options_rm_addr(sk, &opt_size, remaining, opts)) {
932 total_size += opt_size;
933 remaining -= opt_size;
934 ret = true;
935 }
936
937 if (mptcp_established_options_mp_prio(sk, &opt_size, remaining, opts)) {
938 total_size += opt_size;
939 remaining -= opt_size;
940 ret = true;
941 }
942
943 return ret ? total_size : -1;
944 }
945
mptcp_synack_options(const struct request_sock * req,unsigned int * size,struct mptcp_out_options * opts)946 bool mptcp_synack_options(const struct request_sock *req, unsigned int *size,
947 struct mptcp_out_options *opts)
948 {
949 struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
950
951 if (subflow_req->mp_capable) {
952 opts->suboptions = OPTION_MPTCP_MPC_SYNACK;
953 opts->sndr_key = subflow_req->local_key;
954 opts->csum_reqd = subflow_req->csum_reqd;
955 opts->allow_join_id0 = subflow_req->allow_join_id0;
956 *size = TCPOLEN_MPTCP_MPC_SYNACK;
957 pr_debug("subflow_req=%p, local_key=%llu\n",
958 subflow_req, subflow_req->local_key);
959 return true;
960 } else if (subflow_req->mp_join) {
961 opts->suboptions = OPTION_MPTCP_MPJ_SYNACK;
962 opts->backup = subflow_req->request_bkup;
963 opts->join_id = subflow_req->local_id;
964 opts->thmac = subflow_req->thmac;
965 opts->nonce = subflow_req->local_nonce;
966 pr_debug("req=%p, bkup=%u, id=%u, thmac=%llu, nonce=%u\n",
967 subflow_req, opts->backup, opts->join_id,
968 opts->thmac, opts->nonce);
969 *size = TCPOLEN_MPTCP_MPJ_SYNACK;
970 return true;
971 }
972 return false;
973 }
974
check_fully_established(struct mptcp_sock * msk,struct sock * ssk,struct mptcp_subflow_context * subflow,struct sk_buff * skb,struct mptcp_options_received * mp_opt)975 static bool check_fully_established(struct mptcp_sock *msk, struct sock *ssk,
976 struct mptcp_subflow_context *subflow,
977 struct sk_buff *skb,
978 struct mptcp_options_received *mp_opt)
979 {
980 /* here we can process OoO, in-window pkts, only in-sequence 4th ack
981 * will make the subflow fully established
982 */
983 if (likely(READ_ONCE(subflow->fully_established))) {
984 /* on passive sockets, check for 3rd ack retransmission
985 * note that msk is always set by subflow_syn_recv_sock()
986 * for mp_join subflows
987 */
988 if (TCP_SKB_CB(skb)->seq == subflow->ssn_offset + 1 &&
989 TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq &&
990 subflow->mp_join && (mp_opt->suboptions & OPTIONS_MPTCP_MPJ) &&
991 !subflow->request_join)
992 tcp_send_ack(ssk);
993 goto check_notify;
994 }
995
996 /* we must process OoO packets before the first subflow is fully
997 * established. OoO packets are instead a protocol violation
998 * for MP_JOIN subflows as the peer must not send any data
999 * before receiving the forth ack - cfr. RFC 8684 section 3.2.
1000 */
1001 if (TCP_SKB_CB(skb)->seq != subflow->ssn_offset + 1) {
1002 if (subflow->mp_join)
1003 goto reset;
1004 if (subflow->is_mptfo && mp_opt->suboptions & OPTION_MPTCP_MPC_ACK)
1005 goto set_fully_established;
1006 return subflow->mp_capable;
1007 }
1008
1009 if (subflow->remote_key_valid &&
1010 (((mp_opt->suboptions & OPTION_MPTCP_DSS) && mp_opt->use_ack) ||
1011 ((mp_opt->suboptions & OPTION_MPTCP_ADD_ADDR) &&
1012 (!mp_opt->echo || subflow->mp_join)))) {
1013 /* subflows are fully established as soon as we get any
1014 * additional ack, including ADD_ADDR.
1015 */
1016 goto set_fully_established;
1017 }
1018
1019 /* If the first established packet does not contain MP_CAPABLE + data
1020 * then fallback to TCP. Fallback scenarios requires a reset for
1021 * MP_JOIN subflows.
1022 */
1023 if (!(mp_opt->suboptions & OPTIONS_MPTCP_MPC)) {
1024 if (subflow->mp_join)
1025 goto reset;
1026 subflow->mp_capable = 0;
1027 if (!mptcp_try_fallback(ssk, MPTCP_MIB_MPCAPABLEDATAFALLBACK)) {
1028 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_FALLBACKFAILED);
1029 goto reset;
1030 }
1031 return false;
1032 }
1033
1034 if (unlikely(!READ_ONCE(msk->pm.server_side)))
1035 pr_warn_once("bogus mpc option on established client sk");
1036
1037 set_fully_established:
1038 if (mp_opt->deny_join_id0)
1039 WRITE_ONCE(msk->pm.remote_deny_join_id0, true);
1040
1041 mptcp_data_lock((struct sock *)msk);
1042 __mptcp_subflow_fully_established(msk, subflow, mp_opt);
1043 mptcp_data_unlock((struct sock *)msk);
1044
1045 check_notify:
1046 /* if the subflow is not already linked into the conn_list, we can't
1047 * notify the PM: this subflow is still on the listener queue
1048 * and the PM possibly acquiring the subflow lock could race with
1049 * the listener close
1050 */
1051 if (likely(subflow->pm_notified) || list_empty(&subflow->node))
1052 return true;
1053
1054 subflow->pm_notified = 1;
1055 if (subflow->mp_join) {
1056 clear_3rdack_retransmission(ssk);
1057 mptcp_pm_subflow_established(msk);
1058 } else {
1059 mptcp_pm_fully_established(msk, ssk);
1060 }
1061 return true;
1062
1063 reset:
1064 mptcp_subflow_reset(ssk);
1065 return false;
1066 }
1067
__mptcp_expand_seq(u64 old_seq,u64 cur_seq)1068 u64 __mptcp_expand_seq(u64 old_seq, u64 cur_seq)
1069 {
1070 u32 old_seq32, cur_seq32;
1071
1072 old_seq32 = (u32)old_seq;
1073 cur_seq32 = (u32)cur_seq;
1074 cur_seq = (old_seq & GENMASK_ULL(63, 32)) + cur_seq32;
1075 if (unlikely(cur_seq32 < old_seq32 && before(old_seq32, cur_seq32)))
1076 return cur_seq + (1LL << 32);
1077
1078 /* reverse wrap could happen, too */
1079 if (unlikely(cur_seq32 > old_seq32 && after(old_seq32, cur_seq32)))
1080 return cur_seq - (1LL << 32);
1081 return cur_seq;
1082 }
1083
__mptcp_snd_una_update(struct mptcp_sock * msk,u64 new_snd_una)1084 static void __mptcp_snd_una_update(struct mptcp_sock *msk, u64 new_snd_una)
1085 {
1086 msk->bytes_acked += new_snd_una - msk->snd_una;
1087 WRITE_ONCE(msk->snd_una, new_snd_una);
1088 }
1089
rwin_update(struct mptcp_sock * msk,struct sock * ssk,struct sk_buff * skb)1090 static void rwin_update(struct mptcp_sock *msk, struct sock *ssk,
1091 struct sk_buff *skb)
1092 {
1093 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1094 struct tcp_sock *tp = tcp_sk(ssk);
1095 u64 mptcp_rcv_wnd;
1096
1097 /* Avoid touching extra cachelines if TCP is going to accept this
1098 * skb without filling the TCP-level window even with a possibly
1099 * outdated mptcp-level rwin.
1100 */
1101 if (!skb->len || skb->len < tcp_receive_window(tp))
1102 return;
1103
1104 mptcp_rcv_wnd = atomic64_read(&msk->rcv_wnd_sent);
1105 if (!after64(mptcp_rcv_wnd, subflow->rcv_wnd_sent))
1106 return;
1107
1108 /* Some other subflow grew the mptcp-level rwin since rcv_wup,
1109 * resync.
1110 */
1111 tp->rcv_wnd += mptcp_rcv_wnd - subflow->rcv_wnd_sent;
1112 tcp_update_max_rcv_wnd_seq(tp);
1113 subflow->rcv_wnd_sent = mptcp_rcv_wnd;
1114 }
1115
ack_update_msk(struct mptcp_sock * msk,struct sock * ssk,struct mptcp_options_received * mp_opt)1116 static void ack_update_msk(struct mptcp_sock *msk,
1117 struct sock *ssk,
1118 struct mptcp_options_received *mp_opt)
1119 {
1120 u64 new_wnd_end, new_snd_una, snd_nxt = READ_ONCE(msk->snd_nxt);
1121 struct sock *sk = (struct sock *)msk;
1122 u64 old_snd_una;
1123
1124 mptcp_data_lock(sk);
1125
1126 /* avoid ack expansion on update conflict, to reduce the risk of
1127 * wrongly expanding to a future ack sequence number, which is way
1128 * more dangerous than missing an ack
1129 */
1130 old_snd_una = msk->snd_una;
1131 new_snd_una = mptcp_expand_seq(old_snd_una, mp_opt->data_ack, mp_opt->ack64);
1132
1133 /* ACK for data not even sent yet? Ignore.*/
1134 if (unlikely(after64(new_snd_una, snd_nxt)))
1135 new_snd_una = old_snd_una;
1136
1137 new_wnd_end = new_snd_una + tcp_sk(ssk)->snd_wnd;
1138
1139 if (after64(new_wnd_end, msk->wnd_end))
1140 WRITE_ONCE(msk->wnd_end, new_wnd_end);
1141
1142 /* this assumes mptcp_incoming_options() is invoked after tcp_ack() */
1143 if (after64(msk->wnd_end, snd_nxt))
1144 __mptcp_check_push(sk, ssk);
1145
1146 if (after64(new_snd_una, old_snd_una)) {
1147 __mptcp_snd_una_update(msk, new_snd_una);
1148 __mptcp_data_acked(sk);
1149 }
1150 msk->last_ack_recv = tcp_jiffies32;
1151 mptcp_data_unlock(sk);
1152
1153 trace_ack_update_msk(mp_opt->data_ack,
1154 old_snd_una, new_snd_una,
1155 new_wnd_end, READ_ONCE(msk->wnd_end));
1156 }
1157
mptcp_update_rcv_data_fin(struct mptcp_sock * msk,u64 data_fin_seq,bool use_64bit)1158 bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq, bool use_64bit)
1159 {
1160 /* Skip if DATA_FIN was already received.
1161 * If updating simultaneously with the recvmsg loop, values
1162 * should match. If they mismatch, the peer is misbehaving and
1163 * we will prefer the most recent information.
1164 */
1165 if (READ_ONCE(msk->rcv_data_fin))
1166 return false;
1167
1168 WRITE_ONCE(msk->rcv_data_fin_seq,
1169 mptcp_expand_seq(READ_ONCE(msk->ack_seq), data_fin_seq, use_64bit));
1170 WRITE_ONCE(msk->rcv_data_fin, 1);
1171
1172 return true;
1173 }
1174
add_addr_hmac_valid(struct mptcp_sock * msk,struct mptcp_options_received * mp_opt)1175 static bool add_addr_hmac_valid(struct mptcp_sock *msk,
1176 struct mptcp_options_received *mp_opt)
1177 {
1178 u64 hmac = 0;
1179
1180 if (mp_opt->echo)
1181 return true;
1182
1183 hmac = add_addr_generate_hmac(READ_ONCE(msk->remote_key),
1184 READ_ONCE(msk->local_key),
1185 &mp_opt->addr);
1186
1187 pr_debug("msk=%p, ahmac=%llu, mp_opt->ahmac=%llu\n",
1188 msk, hmac, mp_opt->ahmac);
1189
1190 return hmac == mp_opt->ahmac;
1191 }
1192
mptcp_over_limit(struct sock * sk,struct sock * ssk,const struct sk_buff * skb)1193 static bool mptcp_over_limit(struct sock *sk, struct sock *ssk,
1194 const struct sk_buff *skb)
1195 {
1196 struct mptcp_sock *msk = mptcp_sk(sk);
1197 u32 rcvbuf = READ_ONCE(sk->sk_rcvbuf);
1198
1199 if (likely((u32)sk_rmem_alloc_get(sk) <= rcvbuf &&
1200 READ_ONCE(msk->backlog_len) <= rcvbuf))
1201 return false;
1202
1203 /* Avoid silently dropping pure acks, fin, rst or already-acked segm. */
1204 if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq ||
1205 TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_FIN | TCPHDR_RST) ||
1206 !after(TCP_SKB_CB(skb)->end_seq, tcp_sk(ssk)->rcv_nxt))
1207 return false;
1208
1209 /* Dropped due to memory constraints, schedule an ack. */
1210 inet_csk(ssk)->icsk_ack.pending |= ICSK_ACK_NOMEM | ICSK_ACK_NOW;
1211 inet_csk_schedule_ack(ssk);
1212
1213 /* Plain TCP (fallback) and skb is dropped before the TCP recv queue. */
1214 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVQDROP);
1215
1216 return true;
1217 }
1218
1219 /* Return false when the caller must drop the packet, i.e. in case of error,
1220 * subflow has been reset, or over memory limits.
1221 */
mptcp_incoming_options(struct sock * sk,struct sk_buff * skb)1222 bool mptcp_incoming_options(struct sock *sk, struct sk_buff *skb)
1223 {
1224 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
1225 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
1226 struct mptcp_options_received mp_opt;
1227 struct mptcp_ext *mpext;
1228
1229 if (__mptcp_check_fallback(msk)) {
1230 /* Keep it simple and unconditionally trigger send data cleanup and
1231 * pending queue spooling. We will need to acquire the data lock
1232 * for more accurate checks, and once the lock is acquired, such
1233 * helpers are cheap.
1234 */
1235 mptcp_data_lock(subflow->conn);
1236 if (sk_stream_memory_free(sk))
1237 __mptcp_check_push(subflow->conn, sk);
1238
1239 /* on fallback we just need to ignore the msk-level snd_una, as
1240 * this is really plain TCP
1241 */
1242 __mptcp_snd_una_update(msk, READ_ONCE(msk->snd_nxt));
1243
1244 __mptcp_data_acked(subflow->conn);
1245 mptcp_data_unlock(subflow->conn);
1246 return !mptcp_over_limit(subflow->conn, sk, skb);
1247 }
1248
1249 mptcp_get_options(skb, &mp_opt);
1250
1251 /* The subflow can be in close state only if check_fully_established()
1252 * just sent a reset. If so, tell the caller to ignore the current packet.
1253 */
1254 if (!check_fully_established(msk, sk, subflow, skb, &mp_opt))
1255 return sk->sk_state != TCP_CLOSE;
1256
1257 if (unlikely(mp_opt.suboptions != OPTION_MPTCP_DSS)) {
1258 if ((mp_opt.suboptions & OPTION_MPTCP_FASTCLOSE) &&
1259 READ_ONCE(msk->local_key) == mp_opt.rcvr_key) {
1260 WRITE_ONCE(msk->rcv_fastclose, true);
1261 mptcp_schedule_work((struct sock *)msk);
1262 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFASTCLOSERX);
1263 }
1264
1265 if ((mp_opt.suboptions & OPTION_MPTCP_ADD_ADDR) &&
1266 add_addr_hmac_valid(msk, &mp_opt)) {
1267 if (!mp_opt.echo) {
1268 mptcp_pm_add_addr_received(sk, &mp_opt.addr);
1269 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_ADDADDR);
1270 } else {
1271 mptcp_pm_add_addr_echoed(msk, &mp_opt.addr);
1272 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_ECHOADD);
1273 }
1274
1275 if (mp_opt.addr.port)
1276 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_PORTADD);
1277 }
1278
1279 if (mp_opt.suboptions & OPTION_MPTCP_RM_ADDR)
1280 mptcp_pm_rm_addr_received(msk, &mp_opt.rm_list);
1281
1282 if (mp_opt.suboptions & OPTION_MPTCP_PRIO) {
1283 mptcp_pm_mp_prio_received(sk, mp_opt.backup);
1284 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPPRIORX);
1285 }
1286
1287 if (mp_opt.suboptions & OPTION_MPTCP_FAIL) {
1288 mptcp_pm_mp_fail_received(sk, mp_opt.fail_seq);
1289 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFAILRX);
1290 }
1291
1292 if (mp_opt.suboptions & OPTION_MPTCP_RST) {
1293 subflow->reset_seen = 1;
1294 subflow->reset_reason = mp_opt.reset_reason;
1295 subflow->reset_transient = mp_opt.reset_transient;
1296 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPRSTRX);
1297 }
1298
1299 if (!(mp_opt.suboptions & OPTION_MPTCP_DSS))
1300 return true;
1301 }
1302
1303 /* we can't wait for recvmsg() to update the ack_seq, otherwise
1304 * monodirectional flows will stuck
1305 */
1306 if (mp_opt.use_ack)
1307 ack_update_msk(msk, sk, &mp_opt);
1308 rwin_update(msk, sk, skb);
1309
1310 /* Zero-data-length packets are dropped by the caller and not
1311 * propagated to the MPTCP layer, so the skb extension does not
1312 * need to be allocated or populated. DATA_FIN information, if
1313 * present, needs to be updated here before the skb is freed.
1314 */
1315 if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
1316 if (mp_opt.data_fin && mp_opt.data_len == 1 &&
1317 mptcp_update_rcv_data_fin(msk, mp_opt.data_seq, mp_opt.dsn64))
1318 mptcp_schedule_work((struct sock *)msk);
1319
1320 return true;
1321 }
1322
1323 mpext = skb_ext_add(skb, SKB_EXT_MPTCP);
1324 if (!mpext)
1325 return false;
1326
1327 memset(mpext, 0, sizeof(*mpext));
1328
1329 if (likely(mp_opt.use_map)) {
1330 if (mp_opt.mpc_map) {
1331 /* this is an MP_CAPABLE carrying MPTCP data
1332 * we know this map the first chunk of data
1333 */
1334 mptcp_crypto_key_sha(subflow->remote_key, NULL,
1335 &mpext->data_seq);
1336 mpext->data_seq++;
1337 mpext->subflow_seq = 1;
1338 mpext->dsn64 = 1;
1339 mpext->mpc_map = 1;
1340 mpext->data_fin = 0;
1341 } else {
1342 mpext->data_seq = mp_opt.data_seq;
1343 mpext->subflow_seq = mp_opt.subflow_seq;
1344 mpext->dsn64 = mp_opt.dsn64;
1345 mpext->data_fin = mp_opt.data_fin;
1346 }
1347 mpext->data_len = mp_opt.data_len;
1348 mpext->use_map = 1;
1349 mpext->csum_reqd = !!(mp_opt.suboptions & OPTION_MPTCP_CSUMREQD);
1350
1351 if (mpext->csum_reqd)
1352 mpext->csum = mp_opt.csum;
1353 }
1354
1355 return true;
1356 }
1357
mptcp_set_rwin(struct mptcp_sock * msk,struct tcp_sock * tp,struct tcphdr * th,u64 ack_seq)1358 static u64 mptcp_set_rwin(struct mptcp_sock *msk, struct tcp_sock *tp,
1359 struct tcphdr *th, u64 ack_seq)
1360 {
1361 const struct sock *ssk = (const struct sock *)tp;
1362 u64 rcv_wnd_old, rcv_wnd_new;
1363 u32 new_win;
1364 u64 win;
1365
1366 rcv_wnd_new = ack_seq + tp->rcv_wnd;
1367
1368 rcv_wnd_old = atomic64_read(&msk->rcv_wnd_sent);
1369 if (after64(rcv_wnd_new, rcv_wnd_old)) {
1370 u64 rcv_wnd;
1371
1372 for (;;) {
1373 rcv_wnd = atomic64_cmpxchg(&msk->rcv_wnd_sent, rcv_wnd_old, rcv_wnd_new);
1374
1375 if (rcv_wnd == rcv_wnd_old)
1376 break;
1377
1378 rcv_wnd_old = rcv_wnd;
1379 if (before64(rcv_wnd_new, rcv_wnd_old)) {
1380 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_RCVWNDCONFLICTUPDATE);
1381 goto raise_win;
1382 }
1383 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_RCVWNDCONFLICT);
1384 }
1385 goto update_wspace;
1386 }
1387
1388 if (rcv_wnd_new != rcv_wnd_old) {
1389 raise_win:
1390 /* The msk-level rcv wnd is after the tcp level one,
1391 * sync the latter.
1392 */
1393 rcv_wnd_new = rcv_wnd_old;
1394 win = rcv_wnd_old - ack_seq;
1395 new_win = min_t(u64, win, U32_MAX);
1396 tp->rcv_wnd = new_win;
1397 tcp_update_max_rcv_wnd_seq(tp);
1398
1399 /* Make sure we do not exceed the maximum possible
1400 * scaled window.
1401 */
1402 if (unlikely(th->syn))
1403 new_win = min(new_win, 65535U) << tp->rx_opt.rcv_wscale;
1404 if (!tp->rx_opt.rcv_wscale &&
1405 READ_ONCE(sock_net(ssk)->ipv4.sysctl_tcp_workaround_signed_windows))
1406 new_win = min(new_win, MAX_TCP_WINDOW);
1407 else
1408 new_win = min(new_win, (65535U << tp->rx_opt.rcv_wscale));
1409
1410 /* RFC1323 scaling applied */
1411 new_win >>= tp->rx_opt.rcv_wscale;
1412 th->window = htons(new_win);
1413 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_RCVWNDSHARED);
1414 }
1415
1416 update_wspace:
1417 WRITE_ONCE(msk->old_wspace, tp->rcv_wnd);
1418 return rcv_wnd_new;
1419 }
1420
mptcp_track_rwin(struct tcp_sock * tp)1421 static void mptcp_track_rwin(struct tcp_sock *tp)
1422 {
1423 const struct sock *ssk = (const struct sock *)tp;
1424 struct mptcp_subflow_context *subflow;
1425 struct mptcp_sock *msk;
1426
1427 if (!ssk)
1428 return;
1429
1430 subflow = mptcp_subflow_ctx(ssk);
1431 msk = mptcp_sk(subflow->conn);
1432 WRITE_ONCE(msk->old_wspace, tp->rcv_wnd);
1433 }
1434
__mptcp_make_csum(u64 data_seq,u32 subflow_seq,u16 data_len,__wsum sum)1435 __sum16 __mptcp_make_csum(u64 data_seq, u32 subflow_seq, u16 data_len, __wsum sum)
1436 {
1437 struct csum_pseudo_header header;
1438 __wsum csum;
1439
1440 /* cfr RFC 8684 3.3.1.:
1441 * the data sequence number used in the pseudo-header is
1442 * always the 64-bit value, irrespective of what length is used in the
1443 * DSS option itself.
1444 */
1445 header.data_seq = cpu_to_be64(data_seq);
1446 header.subflow_seq = htonl(subflow_seq);
1447 header.data_len = htons(data_len);
1448 header.csum = 0;
1449
1450 csum = csum_partial(&header, sizeof(header), sum);
1451 return csum_fold(csum);
1452 }
1453
mptcp_make_csum(const struct mptcp_ext * mpext)1454 static __sum16 mptcp_make_csum(const struct mptcp_ext *mpext)
1455 {
1456 return __mptcp_make_csum(mpext->data_seq, mpext->subflow_seq, mpext->data_len,
1457 ~csum_unfold(mpext->csum));
1458 }
1459
put_len_csum(u16 len,__sum16 csum,void * data)1460 static void put_len_csum(u16 len, __sum16 csum, void *data)
1461 {
1462 __sum16 *sumptr = data + 2;
1463 __be16 *ptr = data;
1464
1465 put_unaligned_be16(len, ptr);
1466
1467 put_unaligned(csum, sumptr);
1468 }
1469
mptcp_write_options(struct tcphdr * th,__be32 * ptr,struct tcp_sock * tp,struct mptcp_out_options * opts)1470 void mptcp_write_options(struct tcphdr *th, __be32 *ptr, struct tcp_sock *tp,
1471 struct mptcp_out_options *opts)
1472 {
1473 const struct sock *ssk = (const struct sock *)tp;
1474 struct mptcp_subflow_context *subflow;
1475
1476 /* Which options can be used together?
1477 *
1478 * X: mutually exclusive
1479 * O: often used together
1480 * C: can be used together in some cases
1481 * P: could be used together but we prefer not to (optimisations)
1482 *
1483 * Opt: | MPC | MPJ | DSS | ADD | RM | PRIO | FAIL | FC |
1484 * ------|------|------|------|------|------|------|------|------|
1485 * MPC |------|------|------|------|------|------|------|------|
1486 * MPJ | X |------|------|------|------|------|------|------|
1487 * DSS | X | X |------|------|------|------|------|------|
1488 * ADD | X | X | P |------|------|------|------|------|
1489 * RM | C | C | C | P |------|------|------|------|
1490 * PRIO | X | C | C | C | C |------|------|------|
1491 * FAIL | X | X | C | X | X | X |------|------|
1492 * FC | X | X | P | X | X | X | X |------|
1493 * RST | X | X | X | X | X | X | O | O |
1494 * ------|------|------|------|------|------|------|------|------|
1495 *
1496 * The same applies in mptcp_established_options() function.
1497 */
1498 if (likely(OPTION_MPTCP_DSS & opts->suboptions)) {
1499 struct mptcp_ext *mpext = &opts->ext_copy;
1500 u8 len = TCPOLEN_MPTCP_DSS_BASE;
1501 u8 flags = 0;
1502
1503 if (mpext->use_ack) {
1504 flags = MPTCP_DSS_HAS_ACK;
1505 if (mpext->ack64) {
1506 len += TCPOLEN_MPTCP_DSS_ACK64;
1507 flags |= MPTCP_DSS_ACK64;
1508 } else {
1509 len += TCPOLEN_MPTCP_DSS_ACK32;
1510 }
1511 }
1512
1513 if (mpext->use_map) {
1514 len += TCPOLEN_MPTCP_DSS_MAP64;
1515
1516 /* Use only 64-bit mapping flags for now, add
1517 * support for optional 32-bit mappings later.
1518 */
1519 flags |= MPTCP_DSS_HAS_MAP | MPTCP_DSS_DSN64;
1520 if (mpext->data_fin)
1521 flags |= MPTCP_DSS_DATA_FIN;
1522
1523 if (opts->csum_reqd)
1524 len += TCPOLEN_MPTCP_DSS_CHECKSUM;
1525 }
1526
1527 *ptr++ = mptcp_option(MPTCPOPT_DSS, len, 0, flags);
1528
1529 if (mpext->use_ack) {
1530 struct mptcp_sock *msk;
1531 u64 ack_seq;
1532
1533 /* DSS option is set only by mptcp_established_options,
1534 * the caller is __tcp_transmit_skb() and ssk is always
1535 * not NULL.
1536 */
1537 subflow = mptcp_subflow_ctx(ssk);
1538 msk = mptcp_sk(subflow->conn);
1539 ack_seq = READ_ONCE(msk->ack_seq);
1540 if (mpext->ack64) {
1541 put_unaligned_be64(ack_seq, ptr);
1542 ptr += 2;
1543 } else {
1544 put_unaligned_be32(ack_seq, ptr);
1545 ptr += 1;
1546 }
1547 subflow->rcv_wnd_sent = mptcp_set_rwin(msk, tp, th,
1548 ack_seq);
1549 }
1550
1551 if (mpext->use_map) {
1552 put_unaligned_be64(mpext->data_seq, ptr);
1553 ptr += 2;
1554 put_unaligned_be32(mpext->subflow_seq, ptr);
1555 ptr += 1;
1556 if (opts->csum_reqd) {
1557 /* data_len == 0 is reserved for the infinite mapping,
1558 * the checksum will also be set to 0.
1559 */
1560 put_len_csum(mpext->data_len,
1561 (mpext->data_len ? mptcp_make_csum(mpext) : 0),
1562 ptr);
1563 } else {
1564 put_unaligned_be32(mpext->data_len << 16 |
1565 TCPOPT_NOP << 8 | TCPOPT_NOP, ptr);
1566 }
1567 ptr += 1;
1568 }
1569
1570 /* We might need to add MP_FAIL options in rare cases */
1571 if (unlikely(OPTION_MPTCP_FAIL & opts->suboptions))
1572 goto mp_fail;
1573 } else if (OPTIONS_MPTCP_MPC & opts->suboptions) {
1574 u8 len, flag = MPTCP_CAP_HMAC_SHA256;
1575
1576 if (OPTION_MPTCP_MPC_SYN & opts->suboptions) {
1577 len = TCPOLEN_MPTCP_MPC_SYN;
1578 } else if (OPTION_MPTCP_MPC_SYNACK & opts->suboptions) {
1579 len = TCPOLEN_MPTCP_MPC_SYNACK;
1580 } else if (opts->data_len) {
1581 len = TCPOLEN_MPTCP_MPC_ACK_DATA;
1582 if (opts->csum_reqd)
1583 len += TCPOLEN_MPTCP_DSS_CHECKSUM;
1584 } else {
1585 len = TCPOLEN_MPTCP_MPC_ACK;
1586 }
1587
1588 if (opts->csum_reqd)
1589 flag |= MPTCP_CAP_CHECKSUM_REQD;
1590
1591 if (!opts->allow_join_id0)
1592 flag |= MPTCP_CAP_DENY_JOIN_ID0;
1593
1594 *ptr++ = mptcp_option(MPTCPOPT_MP_CAPABLE, len,
1595 MPTCP_SUPPORTED_VERSION,
1596 flag);
1597
1598 if (!((OPTION_MPTCP_MPC_SYNACK | OPTION_MPTCP_MPC_ACK) &
1599 opts->suboptions))
1600 goto mp_capable_done;
1601
1602 put_unaligned_be64(opts->sndr_key, ptr);
1603 ptr += 2;
1604 if (!((OPTION_MPTCP_MPC_ACK) & opts->suboptions))
1605 goto mp_capable_done;
1606
1607 put_unaligned_be64(opts->rcvr_key, ptr);
1608 ptr += 2;
1609 if (!opts->data_len)
1610 goto mp_capable_done;
1611
1612 if (opts->csum_reqd) {
1613 put_len_csum(opts->data_len,
1614 __mptcp_make_csum(opts->data_seq,
1615 opts->subflow_seq,
1616 opts->data_len,
1617 ~csum_unfold(opts->csum)),
1618 ptr);
1619 } else {
1620 put_unaligned_be32(opts->data_len << 16 |
1621 TCPOPT_NOP << 8 | TCPOPT_NOP, ptr);
1622 }
1623 ptr += 1;
1624
1625 /* MPC is additionally mutually exclusive with MP_PRIO */
1626 goto mp_capable_done;
1627 } else if (OPTIONS_MPTCP_MPJ & opts->suboptions) {
1628 if (OPTION_MPTCP_MPJ_SYN & opts->suboptions) {
1629 *ptr++ = mptcp_option(MPTCPOPT_MP_JOIN,
1630 TCPOLEN_MPTCP_MPJ_SYN,
1631 opts->backup, opts->join_id);
1632 put_unaligned_be32(opts->token, ptr);
1633 ptr += 1;
1634 put_unaligned_be32(opts->nonce, ptr);
1635 ptr += 1;
1636 } else if (OPTION_MPTCP_MPJ_SYNACK & opts->suboptions) {
1637 *ptr++ = mptcp_option(MPTCPOPT_MP_JOIN,
1638 TCPOLEN_MPTCP_MPJ_SYNACK,
1639 opts->backup, opts->join_id);
1640 put_unaligned_be64(opts->thmac, ptr);
1641 ptr += 2;
1642 put_unaligned_be32(opts->nonce, ptr);
1643 ptr += 1;
1644 } else {
1645 *ptr++ = mptcp_option(MPTCPOPT_MP_JOIN,
1646 TCPOLEN_MPTCP_MPJ_ACK, 0, 0);
1647 memcpy(ptr, opts->hmac, MPTCPOPT_HMAC_LEN);
1648 ptr += 5;
1649 }
1650 } else if (OPTION_MPTCP_ADD_ADDR & opts->suboptions) {
1651 u8 len = TCPOLEN_MPTCP_ADD_ADDR_BASE;
1652 u8 echo = MPTCP_ADDR_ECHO;
1653
1654 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1655 if (opts->addr.family == AF_INET6)
1656 len = TCPOLEN_MPTCP_ADD_ADDR6_BASE;
1657 #endif
1658
1659 if (opts->addr.port)
1660 len += TCPOLEN_MPTCP_PORT_LEN;
1661
1662 if (opts->ahmac) {
1663 len += sizeof(opts->ahmac);
1664 echo = 0;
1665 }
1666
1667 *ptr++ = mptcp_option(MPTCPOPT_ADD_ADDR,
1668 len, echo, opts->addr.id);
1669 if (opts->addr.family == AF_INET) {
1670 memcpy((u8 *)ptr, (u8 *)&opts->addr.addr.s_addr, 4);
1671 ptr += 1;
1672 }
1673 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1674 else if (opts->addr.family == AF_INET6) {
1675 memcpy((u8 *)ptr, opts->addr.addr6.s6_addr, 16);
1676 ptr += 4;
1677 }
1678 #endif
1679
1680 if (!opts->addr.port) {
1681 if (opts->ahmac) {
1682 put_unaligned_be64(opts->ahmac, ptr);
1683 ptr += 2;
1684 }
1685 } else {
1686 u16 port = ntohs(opts->addr.port);
1687
1688 if (opts->ahmac) {
1689 u8 *bptr = (u8 *)ptr;
1690
1691 put_unaligned_be16(port, bptr);
1692 bptr += 2;
1693 put_unaligned_be64(opts->ahmac, bptr);
1694 bptr += 8;
1695 put_unaligned_be16(TCPOPT_NOP << 8 |
1696 TCPOPT_NOP, bptr);
1697
1698 ptr += 3;
1699 } else {
1700 put_unaligned_be32(port << 16 |
1701 TCPOPT_NOP << 8 |
1702 TCPOPT_NOP, ptr);
1703 ptr += 1;
1704 }
1705 }
1706 } else if (unlikely(OPTION_MPTCP_FASTCLOSE & opts->suboptions)) {
1707 /* FASTCLOSE is mutually exclusive with others except RST */
1708 *ptr++ = mptcp_option(MPTCPOPT_MP_FASTCLOSE,
1709 TCPOLEN_MPTCP_FASTCLOSE,
1710 0, 0);
1711 put_unaligned_be64(opts->rcvr_key, ptr);
1712 ptr += 2;
1713
1714 if (OPTION_MPTCP_RST & opts->suboptions)
1715 goto mp_rst;
1716 return;
1717 } else if (unlikely(OPTION_MPTCP_FAIL & opts->suboptions)) {
1718 mp_fail:
1719 /* MP_FAIL is mutually exclusive with others except RST */
1720 subflow = mptcp_subflow_ctx(ssk);
1721 subflow->send_mp_fail = 0;
1722
1723 *ptr++ = mptcp_option(MPTCPOPT_MP_FAIL,
1724 TCPOLEN_MPTCP_FAIL,
1725 0, 0);
1726 put_unaligned_be64(opts->fail_seq, ptr);
1727 ptr += 2;
1728
1729 if (OPTION_MPTCP_RST & opts->suboptions)
1730 goto mp_rst;
1731 return;
1732 } else if (unlikely(OPTION_MPTCP_RST & opts->suboptions)) {
1733 mp_rst:
1734 *ptr++ = mptcp_option(MPTCPOPT_RST,
1735 TCPOLEN_MPTCP_RST,
1736 opts->reset_transient,
1737 opts->reset_reason);
1738 return;
1739 } else if (unlikely(!opts->suboptions)) {
1740 /* Fallback to TCP */
1741 mptcp_track_rwin(tp);
1742 return;
1743 }
1744
1745 if (OPTION_MPTCP_PRIO & opts->suboptions) {
1746 subflow = mptcp_subflow_ctx(ssk);
1747 subflow->send_mp_prio = 0;
1748
1749 *ptr++ = mptcp_option(MPTCPOPT_MP_PRIO,
1750 TCPOLEN_MPTCP_PRIO,
1751 opts->backup, TCPOPT_NOP);
1752
1753 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_MPPRIOTX);
1754 }
1755
1756 mp_capable_done:
1757 if (OPTION_MPTCP_RM_ADDR & opts->suboptions) {
1758 u8 i = 1;
1759
1760 *ptr++ = mptcp_option(MPTCPOPT_RM_ADDR,
1761 TCPOLEN_MPTCP_RM_ADDR_BASE + opts->rm_list.nr,
1762 0, opts->rm_list.ids[0]);
1763
1764 while (i < opts->rm_list.nr) {
1765 u8 id1, id2, id3, id4;
1766
1767 id1 = opts->rm_list.ids[i];
1768 id2 = i + 1 < opts->rm_list.nr ? opts->rm_list.ids[i + 1] : TCPOPT_NOP;
1769 id3 = i + 2 < opts->rm_list.nr ? opts->rm_list.ids[i + 2] : TCPOPT_NOP;
1770 id4 = i + 3 < opts->rm_list.nr ? opts->rm_list.ids[i + 3] : TCPOPT_NOP;
1771 put_unaligned_be32(id1 << 24 | id2 << 16 | id3 << 8 | id4, ptr);
1772 ptr += 1;
1773 i += 4;
1774 }
1775 }
1776 }
1777
mptcp_get_reset_option(const struct sk_buff * skb)1778 __be32 mptcp_get_reset_option(const struct sk_buff *skb)
1779 {
1780 const struct mptcp_ext *ext = mptcp_get_ext(skb);
1781 u8 flags, reason;
1782
1783 if (ext) {
1784 flags = ext->reset_transient;
1785 reason = ext->reset_reason;
1786
1787 return mptcp_option(MPTCPOPT_RST, TCPOLEN_MPTCP_RST,
1788 flags, reason);
1789 }
1790
1791 return htonl(0u);
1792 }
1793 EXPORT_SYMBOL_GPL(mptcp_get_reset_option);
1794