xref: /openbmc/linux/net/mptcp/options.c (revision 29c37341)
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/sha.h>
11 #include <net/tcp.h>
12 #include <net/mptcp.h>
13 #include "protocol.h"
14 
15 static bool mptcp_cap_flag_sha256(u8 flags)
16 {
17 	return (flags & MPTCP_CAP_FLAG_MASK) == MPTCP_CAP_HMAC_SHA256;
18 }
19 
20 static void mptcp_parse_option(const struct sk_buff *skb,
21 			       const unsigned char *ptr, int opsize,
22 			       struct mptcp_options_received *mp_opt)
23 {
24 	u8 subtype = *ptr >> 4;
25 	int expected_opsize;
26 	u8 version;
27 	u8 flags;
28 
29 	switch (subtype) {
30 	case MPTCPOPT_MP_CAPABLE:
31 		/* strict size checking */
32 		if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
33 			if (skb->len > tcp_hdr(skb)->doff << 2)
34 				expected_opsize = TCPOLEN_MPTCP_MPC_ACK_DATA;
35 			else
36 				expected_opsize = TCPOLEN_MPTCP_MPC_ACK;
37 		} else {
38 			if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)
39 				expected_opsize = TCPOLEN_MPTCP_MPC_SYNACK;
40 			else
41 				expected_opsize = TCPOLEN_MPTCP_MPC_SYN;
42 		}
43 		if (opsize != expected_opsize)
44 			break;
45 
46 		/* try to be gentle vs future versions on the initial syn */
47 		version = *ptr++ & MPTCP_VERSION_MASK;
48 		if (opsize != TCPOLEN_MPTCP_MPC_SYN) {
49 			if (version != MPTCP_SUPPORTED_VERSION)
50 				break;
51 		} else if (version < MPTCP_SUPPORTED_VERSION) {
52 			break;
53 		}
54 
55 		flags = *ptr++;
56 		if (!mptcp_cap_flag_sha256(flags) ||
57 		    (flags & MPTCP_CAP_EXTENSIBILITY))
58 			break;
59 
60 		/* RFC 6824, Section 3.1:
61 		 * "For the Checksum Required bit (labeled "A"), if either
62 		 * host requires the use of checksums, checksums MUST be used.
63 		 * In other words, the only way for checksums not to be used
64 		 * is if both hosts in their SYNs set A=0."
65 		 *
66 		 * Section 3.3.0:
67 		 * "If a checksum is not present when its use has been
68 		 * negotiated, the receiver MUST close the subflow with a RST as
69 		 * it is considered broken."
70 		 *
71 		 * We don't implement DSS checksum - fall back to TCP.
72 		 */
73 		if (flags & MPTCP_CAP_CHECKSUM_REQD)
74 			break;
75 
76 		mp_opt->mp_capable = 1;
77 		if (opsize >= TCPOLEN_MPTCP_MPC_SYNACK) {
78 			mp_opt->sndr_key = get_unaligned_be64(ptr);
79 			ptr += 8;
80 		}
81 		if (opsize >= TCPOLEN_MPTCP_MPC_ACK) {
82 			mp_opt->rcvr_key = get_unaligned_be64(ptr);
83 			ptr += 8;
84 		}
85 		if (opsize == TCPOLEN_MPTCP_MPC_ACK_DATA) {
86 			/* Section 3.1.:
87 			 * "the data parameters in a MP_CAPABLE are semantically
88 			 * equivalent to those in a DSS option and can be used
89 			 * interchangeably."
90 			 */
91 			mp_opt->dss = 1;
92 			mp_opt->use_map = 1;
93 			mp_opt->mpc_map = 1;
94 			mp_opt->data_len = get_unaligned_be16(ptr);
95 			ptr += 2;
96 		}
97 		pr_debug("MP_CAPABLE version=%x, flags=%x, optlen=%d sndr=%llu, rcvr=%llu len=%d",
98 			 version, flags, opsize, mp_opt->sndr_key,
99 			 mp_opt->rcvr_key, mp_opt->data_len);
100 		break;
101 
102 	case MPTCPOPT_MP_JOIN:
103 		mp_opt->mp_join = 1;
104 		if (opsize == TCPOLEN_MPTCP_MPJ_SYN) {
105 			mp_opt->backup = *ptr++ & MPTCPOPT_BACKUP;
106 			mp_opt->join_id = *ptr++;
107 			mp_opt->token = get_unaligned_be32(ptr);
108 			ptr += 4;
109 			mp_opt->nonce = get_unaligned_be32(ptr);
110 			ptr += 4;
111 			pr_debug("MP_JOIN bkup=%u, id=%u, token=%u, nonce=%u",
112 				 mp_opt->backup, mp_opt->join_id,
113 				 mp_opt->token, mp_opt->nonce);
114 		} else if (opsize == TCPOLEN_MPTCP_MPJ_SYNACK) {
115 			mp_opt->backup = *ptr++ & MPTCPOPT_BACKUP;
116 			mp_opt->join_id = *ptr++;
117 			mp_opt->thmac = get_unaligned_be64(ptr);
118 			ptr += 8;
119 			mp_opt->nonce = get_unaligned_be32(ptr);
120 			ptr += 4;
121 			pr_debug("MP_JOIN bkup=%u, id=%u, thmac=%llu, nonce=%u",
122 				 mp_opt->backup, mp_opt->join_id,
123 				 mp_opt->thmac, mp_opt->nonce);
124 		} else if (opsize == TCPOLEN_MPTCP_MPJ_ACK) {
125 			ptr += 2;
126 			memcpy(mp_opt->hmac, ptr, MPTCPOPT_HMAC_LEN);
127 			pr_debug("MP_JOIN hmac");
128 		} else {
129 			pr_warn("MP_JOIN bad option size");
130 			mp_opt->mp_join = 0;
131 		}
132 		break;
133 
134 	case MPTCPOPT_DSS:
135 		pr_debug("DSS");
136 		ptr++;
137 
138 		/* we must clear 'mpc_map' be able to detect MP_CAPABLE
139 		 * map vs DSS map in mptcp_incoming_options(), and reconstruct
140 		 * map info accordingly
141 		 */
142 		mp_opt->mpc_map = 0;
143 		flags = (*ptr++) & MPTCP_DSS_FLAG_MASK;
144 		mp_opt->data_fin = (flags & MPTCP_DSS_DATA_FIN) != 0;
145 		mp_opt->dsn64 = (flags & MPTCP_DSS_DSN64) != 0;
146 		mp_opt->use_map = (flags & MPTCP_DSS_HAS_MAP) != 0;
147 		mp_opt->ack64 = (flags & MPTCP_DSS_ACK64) != 0;
148 		mp_opt->use_ack = (flags & MPTCP_DSS_HAS_ACK);
149 
150 		pr_debug("data_fin=%d dsn64=%d use_map=%d ack64=%d use_ack=%d",
151 			 mp_opt->data_fin, mp_opt->dsn64,
152 			 mp_opt->use_map, mp_opt->ack64,
153 			 mp_opt->use_ack);
154 
155 		expected_opsize = TCPOLEN_MPTCP_DSS_BASE;
156 
157 		if (mp_opt->use_ack) {
158 			if (mp_opt->ack64)
159 				expected_opsize += TCPOLEN_MPTCP_DSS_ACK64;
160 			else
161 				expected_opsize += TCPOLEN_MPTCP_DSS_ACK32;
162 		}
163 
164 		if (mp_opt->use_map) {
165 			if (mp_opt->dsn64)
166 				expected_opsize += TCPOLEN_MPTCP_DSS_MAP64;
167 			else
168 				expected_opsize += TCPOLEN_MPTCP_DSS_MAP32;
169 		}
170 
171 		/* RFC 6824, Section 3.3:
172 		 * If a checksum is present, but its use had
173 		 * not been negotiated in the MP_CAPABLE handshake,
174 		 * the checksum field MUST be ignored.
175 		 */
176 		if (opsize != expected_opsize &&
177 		    opsize != expected_opsize + TCPOLEN_MPTCP_DSS_CHECKSUM)
178 			break;
179 
180 		mp_opt->dss = 1;
181 
182 		if (mp_opt->use_ack) {
183 			if (mp_opt->ack64) {
184 				mp_opt->data_ack = get_unaligned_be64(ptr);
185 				ptr += 8;
186 			} else {
187 				mp_opt->data_ack = get_unaligned_be32(ptr);
188 				ptr += 4;
189 			}
190 
191 			pr_debug("data_ack=%llu", mp_opt->data_ack);
192 		}
193 
194 		if (mp_opt->use_map) {
195 			if (mp_opt->dsn64) {
196 				mp_opt->data_seq = get_unaligned_be64(ptr);
197 				ptr += 8;
198 			} else {
199 				mp_opt->data_seq = get_unaligned_be32(ptr);
200 				ptr += 4;
201 			}
202 
203 			mp_opt->subflow_seq = get_unaligned_be32(ptr);
204 			ptr += 4;
205 
206 			mp_opt->data_len = get_unaligned_be16(ptr);
207 			ptr += 2;
208 
209 			pr_debug("data_seq=%llu subflow_seq=%u data_len=%u",
210 				 mp_opt->data_seq, mp_opt->subflow_seq,
211 				 mp_opt->data_len);
212 		}
213 
214 		break;
215 
216 	case MPTCPOPT_ADD_ADDR:
217 		mp_opt->echo = (*ptr++) & MPTCP_ADDR_ECHO;
218 		if (!mp_opt->echo) {
219 			if (opsize == TCPOLEN_MPTCP_ADD_ADDR ||
220 			    opsize == TCPOLEN_MPTCP_ADD_ADDR_PORT)
221 				mp_opt->family = MPTCP_ADDR_IPVERSION_4;
222 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
223 			else if (opsize == TCPOLEN_MPTCP_ADD_ADDR6 ||
224 				 opsize == TCPOLEN_MPTCP_ADD_ADDR6_PORT)
225 				mp_opt->family = MPTCP_ADDR_IPVERSION_6;
226 #endif
227 			else
228 				break;
229 		} else {
230 			if (opsize == TCPOLEN_MPTCP_ADD_ADDR_BASE ||
231 			    opsize == TCPOLEN_MPTCP_ADD_ADDR_BASE_PORT)
232 				mp_opt->family = MPTCP_ADDR_IPVERSION_4;
233 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
234 			else if (opsize == TCPOLEN_MPTCP_ADD_ADDR6_BASE ||
235 				 opsize == TCPOLEN_MPTCP_ADD_ADDR6_BASE_PORT)
236 				mp_opt->family = MPTCP_ADDR_IPVERSION_6;
237 #endif
238 			else
239 				break;
240 		}
241 
242 		mp_opt->add_addr = 1;
243 		mp_opt->port = 0;
244 		mp_opt->addr_id = *ptr++;
245 		pr_debug("ADD_ADDR: id=%d", mp_opt->addr_id);
246 		if (mp_opt->family == MPTCP_ADDR_IPVERSION_4) {
247 			memcpy((u8 *)&mp_opt->addr.s_addr, (u8 *)ptr, 4);
248 			ptr += 4;
249 			if (opsize == TCPOLEN_MPTCP_ADD_ADDR_PORT ||
250 			    opsize == TCPOLEN_MPTCP_ADD_ADDR_BASE_PORT) {
251 				mp_opt->port = get_unaligned_be16(ptr);
252 				ptr += 2;
253 			}
254 		}
255 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
256 		else {
257 			memcpy(mp_opt->addr6.s6_addr, (u8 *)ptr, 16);
258 			ptr += 16;
259 			if (opsize == TCPOLEN_MPTCP_ADD_ADDR6_PORT ||
260 			    opsize == TCPOLEN_MPTCP_ADD_ADDR6_BASE_PORT) {
261 				mp_opt->port = get_unaligned_be16(ptr);
262 				ptr += 2;
263 			}
264 		}
265 #endif
266 		if (!mp_opt->echo) {
267 			mp_opt->ahmac = get_unaligned_be64(ptr);
268 			ptr += 8;
269 		}
270 		break;
271 
272 	case MPTCPOPT_RM_ADDR:
273 		if (opsize != TCPOLEN_MPTCP_RM_ADDR_BASE)
274 			break;
275 
276 		ptr++;
277 
278 		mp_opt->rm_addr = 1;
279 		mp_opt->rm_id = *ptr++;
280 		pr_debug("RM_ADDR: id=%d", mp_opt->rm_id);
281 		break;
282 
283 	default:
284 		break;
285 	}
286 }
287 
288 void mptcp_get_options(const struct sk_buff *skb,
289 		       struct mptcp_options_received *mp_opt)
290 {
291 	const struct tcphdr *th = tcp_hdr(skb);
292 	const unsigned char *ptr;
293 	int length;
294 
295 	/* initialize option status */
296 	mp_opt->mp_capable = 0;
297 	mp_opt->mp_join = 0;
298 	mp_opt->add_addr = 0;
299 	mp_opt->rm_addr = 0;
300 	mp_opt->dss = 0;
301 
302 	length = (th->doff * 4) - sizeof(struct tcphdr);
303 	ptr = (const unsigned char *)(th + 1);
304 
305 	while (length > 0) {
306 		int opcode = *ptr++;
307 		int opsize;
308 
309 		switch (opcode) {
310 		case TCPOPT_EOL:
311 			return;
312 		case TCPOPT_NOP:	/* Ref: RFC 793 section 3.1 */
313 			length--;
314 			continue;
315 		default:
316 			opsize = *ptr++;
317 			if (opsize < 2) /* "silly options" */
318 				return;
319 			if (opsize > length)
320 				return;	/* don't parse partial options */
321 			if (opcode == TCPOPT_MPTCP)
322 				mptcp_parse_option(skb, ptr, opsize, mp_opt);
323 			ptr += opsize - 2;
324 			length -= opsize;
325 		}
326 	}
327 }
328 
329 bool mptcp_syn_options(struct sock *sk, const struct sk_buff *skb,
330 		       unsigned int *size, struct mptcp_out_options *opts)
331 {
332 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
333 
334 	/* we will use snd_isn to detect first pkt [re]transmission
335 	 * in mptcp_established_options_mp()
336 	 */
337 	subflow->snd_isn = TCP_SKB_CB(skb)->end_seq;
338 	if (subflow->request_mptcp) {
339 		opts->suboptions = OPTION_MPTCP_MPC_SYN;
340 		*size = TCPOLEN_MPTCP_MPC_SYN;
341 		return true;
342 	} else if (subflow->request_join) {
343 		pr_debug("remote_token=%u, nonce=%u", subflow->remote_token,
344 			 subflow->local_nonce);
345 		opts->suboptions = OPTION_MPTCP_MPJ_SYN;
346 		opts->join_id = subflow->local_id;
347 		opts->token = subflow->remote_token;
348 		opts->nonce = subflow->local_nonce;
349 		opts->backup = subflow->request_bkup;
350 		*size = TCPOLEN_MPTCP_MPJ_SYN;
351 		return true;
352 	}
353 	return false;
354 }
355 
356 /* MP_JOIN client subflow must wait for 4th ack before sending any data:
357  * TCP can't schedule delack timer before the subflow is fully established.
358  * MPTCP uses the delack timer to do 3rd ack retransmissions
359  */
360 static void schedule_3rdack_retransmission(struct sock *sk)
361 {
362 	struct inet_connection_sock *icsk = inet_csk(sk);
363 	struct tcp_sock *tp = tcp_sk(sk);
364 	unsigned long timeout;
365 
366 	/* reschedule with a timeout above RTT, as we must look only for drop */
367 	if (tp->srtt_us)
368 		timeout = tp->srtt_us << 1;
369 	else
370 		timeout = TCP_TIMEOUT_INIT;
371 
372 	WARN_ON_ONCE(icsk->icsk_ack.pending & ICSK_ACK_TIMER);
373 	icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
374 	icsk->icsk_ack.timeout = timeout;
375 	sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
376 }
377 
378 static void clear_3rdack_retransmission(struct sock *sk)
379 {
380 	struct inet_connection_sock *icsk = inet_csk(sk);
381 
382 	sk_stop_timer(sk, &icsk->icsk_delack_timer);
383 	icsk->icsk_ack.timeout = 0;
384 	icsk->icsk_ack.ato = 0;
385 	icsk->icsk_ack.pending &= ~(ICSK_ACK_SCHED | ICSK_ACK_TIMER);
386 }
387 
388 static bool mptcp_established_options_mp(struct sock *sk, struct sk_buff *skb,
389 					 unsigned int *size,
390 					 unsigned int remaining,
391 					 struct mptcp_out_options *opts)
392 {
393 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
394 	struct mptcp_ext *mpext;
395 	unsigned int data_len;
396 
397 	/* When skb is not available, we better over-estimate the emitted
398 	 * options len. A full DSS option (28 bytes) is longer than
399 	 * TCPOLEN_MPTCP_MPC_ACK_DATA(22) or TCPOLEN_MPTCP_MPJ_ACK(24), so
400 	 * tell the caller to defer the estimate to
401 	 * mptcp_established_options_dss(), which will reserve enough space.
402 	 */
403 	if (!skb)
404 		return false;
405 
406 	/* MPC/MPJ needed only on 3rd ack packet */
407 	if (subflow->fully_established ||
408 	    subflow->snd_isn != TCP_SKB_CB(skb)->seq)
409 		return false;
410 
411 	if (subflow->mp_capable) {
412 		mpext = mptcp_get_ext(skb);
413 		data_len = mpext ? mpext->data_len : 0;
414 
415 		/* we will check ext_copy.data_len in mptcp_write_options() to
416 		 * discriminate between TCPOLEN_MPTCP_MPC_ACK_DATA and
417 		 * TCPOLEN_MPTCP_MPC_ACK
418 		 */
419 		opts->ext_copy.data_len = data_len;
420 		opts->suboptions = OPTION_MPTCP_MPC_ACK;
421 		opts->sndr_key = subflow->local_key;
422 		opts->rcvr_key = subflow->remote_key;
423 
424 		/* Section 3.1.
425 		 * The MP_CAPABLE option is carried on the SYN, SYN/ACK, and ACK
426 		 * packets that start the first subflow of an MPTCP connection,
427 		 * as well as the first packet that carries data
428 		 */
429 		if (data_len > 0)
430 			*size = ALIGN(TCPOLEN_MPTCP_MPC_ACK_DATA, 4);
431 		else
432 			*size = TCPOLEN_MPTCP_MPC_ACK;
433 
434 		pr_debug("subflow=%p, local_key=%llu, remote_key=%llu map_len=%d",
435 			 subflow, subflow->local_key, subflow->remote_key,
436 			 data_len);
437 
438 		return true;
439 	} else if (subflow->mp_join) {
440 		opts->suboptions = OPTION_MPTCP_MPJ_ACK;
441 		memcpy(opts->hmac, subflow->hmac, MPTCPOPT_HMAC_LEN);
442 		*size = TCPOLEN_MPTCP_MPJ_ACK;
443 		pr_debug("subflow=%p", subflow);
444 
445 		schedule_3rdack_retransmission(sk);
446 		return true;
447 	}
448 	return false;
449 }
450 
451 static void mptcp_write_data_fin(struct mptcp_subflow_context *subflow,
452 				 struct sk_buff *skb, struct mptcp_ext *ext)
453 {
454 	u64 data_fin_tx_seq = READ_ONCE(mptcp_sk(subflow->conn)->write_seq);
455 
456 	if (!ext->use_map || !skb->len) {
457 		/* RFC6824 requires a DSS mapping with specific values
458 		 * if DATA_FIN is set but no data payload is mapped
459 		 */
460 		ext->data_fin = 1;
461 		ext->use_map = 1;
462 		ext->dsn64 = 1;
463 		/* The write_seq value has already been incremented, so
464 		 * the actual sequence number for the DATA_FIN is one less.
465 		 */
466 		ext->data_seq = data_fin_tx_seq - 1;
467 		ext->subflow_seq = 0;
468 		ext->data_len = 1;
469 	} else if (ext->data_seq + ext->data_len == data_fin_tx_seq) {
470 		/* If there's an existing DSS mapping and it is the
471 		 * final mapping, DATA_FIN consumes 1 additional byte of
472 		 * mapping space.
473 		 */
474 		ext->data_fin = 1;
475 		ext->data_len++;
476 	}
477 }
478 
479 static bool mptcp_established_options_dss(struct sock *sk, struct sk_buff *skb,
480 					  unsigned int *size,
481 					  unsigned int remaining,
482 					  struct mptcp_out_options *opts)
483 {
484 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
485 	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
486 	unsigned int dss_size = 0;
487 	u64 snd_data_fin_enable;
488 	struct mptcp_ext *mpext;
489 	unsigned int ack_size;
490 	bool ret = false;
491 
492 	mpext = skb ? mptcp_get_ext(skb) : NULL;
493 	snd_data_fin_enable = READ_ONCE(msk->snd_data_fin_enable);
494 
495 	if (!skb || (mpext && mpext->use_map) || snd_data_fin_enable) {
496 		unsigned int map_size;
497 
498 		map_size = TCPOLEN_MPTCP_DSS_BASE + TCPOLEN_MPTCP_DSS_MAP64;
499 
500 		remaining -= map_size;
501 		dss_size = map_size;
502 		if (mpext)
503 			opts->ext_copy = *mpext;
504 
505 		if (skb && snd_data_fin_enable)
506 			mptcp_write_data_fin(subflow, skb, &opts->ext_copy);
507 		ret = true;
508 	}
509 
510 	/* passive sockets msk will set the 'can_ack' after accept(), even
511 	 * if the first subflow may have the already the remote key handy
512 	 */
513 	opts->ext_copy.use_ack = 0;
514 	if (!READ_ONCE(msk->can_ack)) {
515 		*size = ALIGN(dss_size, 4);
516 		return ret;
517 	}
518 
519 	if (subflow->use_64bit_ack) {
520 		ack_size = TCPOLEN_MPTCP_DSS_ACK64;
521 		opts->ext_copy.data_ack = msk->ack_seq;
522 		opts->ext_copy.ack64 = 1;
523 	} else {
524 		ack_size = TCPOLEN_MPTCP_DSS_ACK32;
525 		opts->ext_copy.data_ack32 = (uint32_t)(msk->ack_seq);
526 		opts->ext_copy.ack64 = 0;
527 	}
528 	opts->ext_copy.use_ack = 1;
529 
530 	/* Add kind/length/subtype/flag overhead if mapping is not populated */
531 	if (dss_size == 0)
532 		ack_size += TCPOLEN_MPTCP_DSS_BASE;
533 
534 	dss_size += ack_size;
535 
536 	*size = ALIGN(dss_size, 4);
537 	return true;
538 }
539 
540 static u64 add_addr_generate_hmac(u64 key1, u64 key2, u8 addr_id,
541 				  struct in_addr *addr)
542 {
543 	u8 hmac[SHA256_DIGEST_SIZE];
544 	u8 msg[7];
545 
546 	msg[0] = addr_id;
547 	memcpy(&msg[1], &addr->s_addr, 4);
548 	msg[5] = 0;
549 	msg[6] = 0;
550 
551 	mptcp_crypto_hmac_sha(key1, key2, msg, 7, hmac);
552 
553 	return get_unaligned_be64(&hmac[SHA256_DIGEST_SIZE - sizeof(u64)]);
554 }
555 
556 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
557 static u64 add_addr6_generate_hmac(u64 key1, u64 key2, u8 addr_id,
558 				   struct in6_addr *addr)
559 {
560 	u8 hmac[SHA256_DIGEST_SIZE];
561 	u8 msg[19];
562 
563 	msg[0] = addr_id;
564 	memcpy(&msg[1], &addr->s6_addr, 16);
565 	msg[17] = 0;
566 	msg[18] = 0;
567 
568 	mptcp_crypto_hmac_sha(key1, key2, msg, 19, hmac);
569 
570 	return get_unaligned_be64(&hmac[SHA256_DIGEST_SIZE - sizeof(u64)]);
571 }
572 #endif
573 
574 static bool mptcp_established_options_addr(struct sock *sk,
575 					   unsigned int *size,
576 					   unsigned int remaining,
577 					   struct mptcp_out_options *opts)
578 {
579 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
580 	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
581 	struct mptcp_addr_info saddr;
582 	int len;
583 
584 	if (!mptcp_pm_should_signal(msk) ||
585 	    !(mptcp_pm_addr_signal(msk, remaining, &saddr)))
586 		return false;
587 
588 	len = mptcp_add_addr_len(saddr.family);
589 	if (remaining < len)
590 		return false;
591 
592 	*size = len;
593 	opts->addr_id = saddr.id;
594 	if (saddr.family == AF_INET) {
595 		opts->suboptions |= OPTION_MPTCP_ADD_ADDR;
596 		opts->addr = saddr.addr;
597 		opts->ahmac = add_addr_generate_hmac(msk->local_key,
598 						     msk->remote_key,
599 						     opts->addr_id,
600 						     &opts->addr);
601 	}
602 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
603 	else if (saddr.family == AF_INET6) {
604 		opts->suboptions |= OPTION_MPTCP_ADD_ADDR6;
605 		opts->addr6 = saddr.addr6;
606 		opts->ahmac = add_addr6_generate_hmac(msk->local_key,
607 						      msk->remote_key,
608 						      opts->addr_id,
609 						      &opts->addr6);
610 	}
611 #endif
612 	pr_debug("addr_id=%d, ahmac=%llu", opts->addr_id, opts->ahmac);
613 
614 	return true;
615 }
616 
617 bool mptcp_established_options(struct sock *sk, struct sk_buff *skb,
618 			       unsigned int *size, unsigned int remaining,
619 			       struct mptcp_out_options *opts)
620 {
621 	unsigned int opt_size = 0;
622 	bool ret = false;
623 
624 	opts->suboptions = 0;
625 
626 	if (unlikely(mptcp_check_fallback(sk)))
627 		return false;
628 
629 	if (mptcp_established_options_mp(sk, skb, &opt_size, remaining, opts))
630 		ret = true;
631 	else if (mptcp_established_options_dss(sk, skb, &opt_size, remaining,
632 					       opts))
633 		ret = true;
634 
635 	/* we reserved enough space for the above options, and exceeding the
636 	 * TCP option space would be fatal
637 	 */
638 	if (WARN_ON_ONCE(opt_size > remaining))
639 		return false;
640 
641 	*size += opt_size;
642 	remaining -= opt_size;
643 	if (mptcp_established_options_addr(sk, &opt_size, remaining, opts)) {
644 		*size += opt_size;
645 		remaining -= opt_size;
646 		ret = true;
647 	}
648 
649 	return ret;
650 }
651 
652 bool mptcp_synack_options(const struct request_sock *req, unsigned int *size,
653 			  struct mptcp_out_options *opts)
654 {
655 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
656 
657 	if (subflow_req->mp_capable) {
658 		opts->suboptions = OPTION_MPTCP_MPC_SYNACK;
659 		opts->sndr_key = subflow_req->local_key;
660 		*size = TCPOLEN_MPTCP_MPC_SYNACK;
661 		pr_debug("subflow_req=%p, local_key=%llu",
662 			 subflow_req, subflow_req->local_key);
663 		return true;
664 	} else if (subflow_req->mp_join) {
665 		opts->suboptions = OPTION_MPTCP_MPJ_SYNACK;
666 		opts->backup = subflow_req->backup;
667 		opts->join_id = subflow_req->local_id;
668 		opts->thmac = subflow_req->thmac;
669 		opts->nonce = subflow_req->local_nonce;
670 		pr_debug("req=%p, bkup=%u, id=%u, thmac=%llu, nonce=%u",
671 			 subflow_req, opts->backup, opts->join_id,
672 			 opts->thmac, opts->nonce);
673 		*size = TCPOLEN_MPTCP_MPJ_SYNACK;
674 		return true;
675 	}
676 	return false;
677 }
678 
679 static bool check_fully_established(struct mptcp_sock *msk, struct sock *sk,
680 				    struct mptcp_subflow_context *subflow,
681 				    struct sk_buff *skb,
682 				    struct mptcp_options_received *mp_opt)
683 {
684 	/* here we can process OoO, in-window pkts, only in-sequence 4th ack
685 	 * will make the subflow fully established
686 	 */
687 	if (likely(subflow->fully_established)) {
688 		/* on passive sockets, check for 3rd ack retransmission
689 		 * note that msk is always set by subflow_syn_recv_sock()
690 		 * for mp_join subflows
691 		 */
692 		if (TCP_SKB_CB(skb)->seq == subflow->ssn_offset + 1 &&
693 		    TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq &&
694 		    subflow->mp_join && mp_opt->mp_join &&
695 		    READ_ONCE(msk->pm.server_side))
696 			tcp_send_ack(sk);
697 		goto fully_established;
698 	}
699 
700 	/* we should process OoO packets before the first subflow is fully
701 	 * established, but not expected for MP_JOIN subflows
702 	 */
703 	if (TCP_SKB_CB(skb)->seq != subflow->ssn_offset + 1)
704 		return subflow->mp_capable;
705 
706 	if (mp_opt->dss && mp_opt->use_ack) {
707 		/* subflows are fully established as soon as we get any
708 		 * additional ack.
709 		 */
710 		subflow->fully_established = 1;
711 		WRITE_ONCE(msk->fully_established, true);
712 		goto fully_established;
713 	}
714 
715 	/* If the first established packet does not contain MP_CAPABLE + data
716 	 * then fallback to TCP
717 	 */
718 	if (!mp_opt->mp_capable) {
719 		subflow->mp_capable = 0;
720 		pr_fallback(msk);
721 		__mptcp_do_fallback(msk);
722 		return false;
723 	}
724 
725 	if (unlikely(!READ_ONCE(msk->pm.server_side)))
726 		pr_warn_once("bogus mpc option on established client sk");
727 	mptcp_subflow_fully_established(subflow, mp_opt);
728 
729 fully_established:
730 	if (likely(subflow->pm_notified))
731 		return true;
732 
733 	subflow->pm_notified = 1;
734 	if (subflow->mp_join) {
735 		clear_3rdack_retransmission(sk);
736 		mptcp_pm_subflow_established(msk, subflow);
737 	} else {
738 		mptcp_pm_fully_established(msk);
739 	}
740 	return true;
741 }
742 
743 static u64 expand_ack(u64 old_ack, u64 cur_ack, bool use_64bit)
744 {
745 	u32 old_ack32, cur_ack32;
746 
747 	if (use_64bit)
748 		return cur_ack;
749 
750 	old_ack32 = (u32)old_ack;
751 	cur_ack32 = (u32)cur_ack;
752 	cur_ack = (old_ack & GENMASK_ULL(63, 32)) + cur_ack32;
753 	if (unlikely(before(cur_ack32, old_ack32)))
754 		return cur_ack + (1LL << 32);
755 	return cur_ack;
756 }
757 
758 static void update_una(struct mptcp_sock *msk,
759 		       struct mptcp_options_received *mp_opt)
760 {
761 	u64 new_snd_una, snd_una, old_snd_una = atomic64_read(&msk->snd_una);
762 	u64 write_seq = READ_ONCE(msk->write_seq);
763 
764 	/* avoid ack expansion on update conflict, to reduce the risk of
765 	 * wrongly expanding to a future ack sequence number, which is way
766 	 * more dangerous than missing an ack
767 	 */
768 	new_snd_una = expand_ack(old_snd_una, mp_opt->data_ack, mp_opt->ack64);
769 
770 	/* ACK for data not even sent yet? Ignore. */
771 	if (after64(new_snd_una, write_seq))
772 		new_snd_una = old_snd_una;
773 
774 	while (after64(new_snd_una, old_snd_una)) {
775 		snd_una = old_snd_una;
776 		old_snd_una = atomic64_cmpxchg(&msk->snd_una, snd_una,
777 					       new_snd_una);
778 		if (old_snd_una == snd_una) {
779 			mptcp_data_acked((struct sock *)msk);
780 			break;
781 		}
782 	}
783 }
784 
785 bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq)
786 {
787 	/* Skip if DATA_FIN was already received.
788 	 * If updating simultaneously with the recvmsg loop, values
789 	 * should match. If they mismatch, the peer is misbehaving and
790 	 * we will prefer the most recent information.
791 	 */
792 	if (READ_ONCE(msk->rcv_data_fin) || !READ_ONCE(msk->first))
793 		return false;
794 
795 	WRITE_ONCE(msk->rcv_data_fin_seq, data_fin_seq);
796 	WRITE_ONCE(msk->rcv_data_fin, 1);
797 
798 	return true;
799 }
800 
801 static bool add_addr_hmac_valid(struct mptcp_sock *msk,
802 				struct mptcp_options_received *mp_opt)
803 {
804 	u64 hmac = 0;
805 
806 	if (mp_opt->echo)
807 		return true;
808 
809 	if (mp_opt->family == MPTCP_ADDR_IPVERSION_4)
810 		hmac = add_addr_generate_hmac(msk->remote_key,
811 					      msk->local_key,
812 					      mp_opt->addr_id, &mp_opt->addr);
813 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
814 	else
815 		hmac = add_addr6_generate_hmac(msk->remote_key,
816 					       msk->local_key,
817 					       mp_opt->addr_id, &mp_opt->addr6);
818 #endif
819 
820 	pr_debug("msk=%p, ahmac=%llu, mp_opt->ahmac=%llu\n",
821 		 msk, (unsigned long long)hmac,
822 		 (unsigned long long)mp_opt->ahmac);
823 
824 	return hmac == mp_opt->ahmac;
825 }
826 
827 void mptcp_incoming_options(struct sock *sk, struct sk_buff *skb,
828 			    struct tcp_options_received *opt_rx)
829 {
830 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
831 	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
832 	struct mptcp_options_received mp_opt;
833 	struct mptcp_ext *mpext;
834 
835 	if (__mptcp_check_fallback(msk))
836 		return;
837 
838 	mptcp_get_options(skb, &mp_opt);
839 	if (!check_fully_established(msk, sk, subflow, skb, &mp_opt))
840 		return;
841 
842 	if (mp_opt.add_addr && add_addr_hmac_valid(msk, &mp_opt)) {
843 		struct mptcp_addr_info addr;
844 
845 		addr.port = htons(mp_opt.port);
846 		addr.id = mp_opt.addr_id;
847 		if (mp_opt.family == MPTCP_ADDR_IPVERSION_4) {
848 			addr.family = AF_INET;
849 			addr.addr = mp_opt.addr;
850 		}
851 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
852 		else if (mp_opt.family == MPTCP_ADDR_IPVERSION_6) {
853 			addr.family = AF_INET6;
854 			addr.addr6 = mp_opt.addr6;
855 		}
856 #endif
857 		if (!mp_opt.echo)
858 			mptcp_pm_add_addr_received(msk, &addr);
859 		mp_opt.add_addr = 0;
860 	}
861 
862 	if (!mp_opt.dss)
863 		return;
864 
865 	/* we can't wait for recvmsg() to update the ack_seq, otherwise
866 	 * monodirectional flows will stuck
867 	 */
868 	if (mp_opt.use_ack)
869 		update_una(msk, &mp_opt);
870 
871 	/* Zero-data-length packets are dropped by the caller and not
872 	 * propagated to the MPTCP layer, so the skb extension does not
873 	 * need to be allocated or populated. DATA_FIN information, if
874 	 * present, needs to be updated here before the skb is freed.
875 	 */
876 	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
877 		if (mp_opt.data_fin && mp_opt.data_len == 1 &&
878 		    mptcp_update_rcv_data_fin(msk, mp_opt.data_seq) &&
879 		    schedule_work(&msk->work))
880 			sock_hold(subflow->conn);
881 
882 		return;
883 	}
884 
885 	mpext = skb_ext_add(skb, SKB_EXT_MPTCP);
886 	if (!mpext)
887 		return;
888 
889 	memset(mpext, 0, sizeof(*mpext));
890 
891 	if (mp_opt.use_map) {
892 		if (mp_opt.mpc_map) {
893 			/* this is an MP_CAPABLE carrying MPTCP data
894 			 * we know this map the first chunk of data
895 			 */
896 			mptcp_crypto_key_sha(subflow->remote_key, NULL,
897 					     &mpext->data_seq);
898 			mpext->data_seq++;
899 			mpext->subflow_seq = 1;
900 			mpext->dsn64 = 1;
901 			mpext->mpc_map = 1;
902 			mpext->data_fin = 0;
903 		} else {
904 			mpext->data_seq = mp_opt.data_seq;
905 			mpext->subflow_seq = mp_opt.subflow_seq;
906 			mpext->dsn64 = mp_opt.dsn64;
907 			mpext->data_fin = mp_opt.data_fin;
908 		}
909 		mpext->data_len = mp_opt.data_len;
910 		mpext->use_map = 1;
911 	}
912 }
913 
914 void mptcp_write_options(__be32 *ptr, struct mptcp_out_options *opts)
915 {
916 	if ((OPTION_MPTCP_MPC_SYN | OPTION_MPTCP_MPC_SYNACK |
917 	     OPTION_MPTCP_MPC_ACK) & opts->suboptions) {
918 		u8 len;
919 
920 		if (OPTION_MPTCP_MPC_SYN & opts->suboptions)
921 			len = TCPOLEN_MPTCP_MPC_SYN;
922 		else if (OPTION_MPTCP_MPC_SYNACK & opts->suboptions)
923 			len = TCPOLEN_MPTCP_MPC_SYNACK;
924 		else if (opts->ext_copy.data_len)
925 			len = TCPOLEN_MPTCP_MPC_ACK_DATA;
926 		else
927 			len = TCPOLEN_MPTCP_MPC_ACK;
928 
929 		*ptr++ = mptcp_option(MPTCPOPT_MP_CAPABLE, len,
930 				      MPTCP_SUPPORTED_VERSION,
931 				      MPTCP_CAP_HMAC_SHA256);
932 
933 		if (!((OPTION_MPTCP_MPC_SYNACK | OPTION_MPTCP_MPC_ACK) &
934 		    opts->suboptions))
935 			goto mp_capable_done;
936 
937 		put_unaligned_be64(opts->sndr_key, ptr);
938 		ptr += 2;
939 		if (!((OPTION_MPTCP_MPC_ACK) & opts->suboptions))
940 			goto mp_capable_done;
941 
942 		put_unaligned_be64(opts->rcvr_key, ptr);
943 		ptr += 2;
944 		if (!opts->ext_copy.data_len)
945 			goto mp_capable_done;
946 
947 		put_unaligned_be32(opts->ext_copy.data_len << 16 |
948 				   TCPOPT_NOP << 8 | TCPOPT_NOP, ptr);
949 		ptr += 1;
950 	}
951 
952 mp_capable_done:
953 	if (OPTION_MPTCP_ADD_ADDR & opts->suboptions) {
954 		if (opts->ahmac)
955 			*ptr++ = mptcp_option(MPTCPOPT_ADD_ADDR,
956 					      TCPOLEN_MPTCP_ADD_ADDR, 0,
957 					      opts->addr_id);
958 		else
959 			*ptr++ = mptcp_option(MPTCPOPT_ADD_ADDR,
960 					      TCPOLEN_MPTCP_ADD_ADDR_BASE,
961 					      MPTCP_ADDR_ECHO,
962 					      opts->addr_id);
963 		memcpy((u8 *)ptr, (u8 *)&opts->addr.s_addr, 4);
964 		ptr += 1;
965 		if (opts->ahmac) {
966 			put_unaligned_be64(opts->ahmac, ptr);
967 			ptr += 2;
968 		}
969 	}
970 
971 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
972 	if (OPTION_MPTCP_ADD_ADDR6 & opts->suboptions) {
973 		if (opts->ahmac)
974 			*ptr++ = mptcp_option(MPTCPOPT_ADD_ADDR,
975 					      TCPOLEN_MPTCP_ADD_ADDR6, 0,
976 					      opts->addr_id);
977 		else
978 			*ptr++ = mptcp_option(MPTCPOPT_ADD_ADDR,
979 					      TCPOLEN_MPTCP_ADD_ADDR6_BASE,
980 					      MPTCP_ADDR_ECHO,
981 					      opts->addr_id);
982 		memcpy((u8 *)ptr, opts->addr6.s6_addr, 16);
983 		ptr += 4;
984 		if (opts->ahmac) {
985 			put_unaligned_be64(opts->ahmac, ptr);
986 			ptr += 2;
987 		}
988 	}
989 #endif
990 
991 	if (OPTION_MPTCP_RM_ADDR & opts->suboptions) {
992 		*ptr++ = mptcp_option(MPTCPOPT_RM_ADDR,
993 				      TCPOLEN_MPTCP_RM_ADDR_BASE,
994 				      0, opts->rm_id);
995 	}
996 
997 	if (OPTION_MPTCP_MPJ_SYN & opts->suboptions) {
998 		*ptr++ = mptcp_option(MPTCPOPT_MP_JOIN,
999 				      TCPOLEN_MPTCP_MPJ_SYN,
1000 				      opts->backup, opts->join_id);
1001 		put_unaligned_be32(opts->token, ptr);
1002 		ptr += 1;
1003 		put_unaligned_be32(opts->nonce, ptr);
1004 		ptr += 1;
1005 	}
1006 
1007 	if (OPTION_MPTCP_MPJ_SYNACK & opts->suboptions) {
1008 		*ptr++ = mptcp_option(MPTCPOPT_MP_JOIN,
1009 				      TCPOLEN_MPTCP_MPJ_SYNACK,
1010 				      opts->backup, opts->join_id);
1011 		put_unaligned_be64(opts->thmac, ptr);
1012 		ptr += 2;
1013 		put_unaligned_be32(opts->nonce, ptr);
1014 		ptr += 1;
1015 	}
1016 
1017 	if (OPTION_MPTCP_MPJ_ACK & opts->suboptions) {
1018 		*ptr++ = mptcp_option(MPTCPOPT_MP_JOIN,
1019 				      TCPOLEN_MPTCP_MPJ_ACK, 0, 0);
1020 		memcpy(ptr, opts->hmac, MPTCPOPT_HMAC_LEN);
1021 		ptr += 5;
1022 	}
1023 
1024 	if (opts->ext_copy.use_ack || opts->ext_copy.use_map) {
1025 		struct mptcp_ext *mpext = &opts->ext_copy;
1026 		u8 len = TCPOLEN_MPTCP_DSS_BASE;
1027 		u8 flags = 0;
1028 
1029 		if (mpext->use_ack) {
1030 			flags = MPTCP_DSS_HAS_ACK;
1031 			if (mpext->ack64) {
1032 				len += TCPOLEN_MPTCP_DSS_ACK64;
1033 				flags |= MPTCP_DSS_ACK64;
1034 			} else {
1035 				len += TCPOLEN_MPTCP_DSS_ACK32;
1036 			}
1037 		}
1038 
1039 		if (mpext->use_map) {
1040 			len += TCPOLEN_MPTCP_DSS_MAP64;
1041 
1042 			/* Use only 64-bit mapping flags for now, add
1043 			 * support for optional 32-bit mappings later.
1044 			 */
1045 			flags |= MPTCP_DSS_HAS_MAP | MPTCP_DSS_DSN64;
1046 			if (mpext->data_fin)
1047 				flags |= MPTCP_DSS_DATA_FIN;
1048 		}
1049 
1050 		*ptr++ = mptcp_option(MPTCPOPT_DSS, len, 0, flags);
1051 
1052 		if (mpext->use_ack) {
1053 			if (mpext->ack64) {
1054 				put_unaligned_be64(mpext->data_ack, ptr);
1055 				ptr += 2;
1056 			} else {
1057 				put_unaligned_be32(mpext->data_ack32, ptr);
1058 				ptr += 1;
1059 			}
1060 		}
1061 
1062 		if (mpext->use_map) {
1063 			put_unaligned_be64(mpext->data_seq, ptr);
1064 			ptr += 2;
1065 			put_unaligned_be32(mpext->subflow_seq, ptr);
1066 			ptr += 1;
1067 			put_unaligned_be32(mpext->data_len << 16 |
1068 					   TCPOPT_NOP << 8 | TCPOPT_NOP, ptr);
1069 		}
1070 	}
1071 }
1072