Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /* Multipath TCP
3 : : *
4 : : * Copyright (c) 2021, Red Hat.
5 : : */
6 : :
7 : : #define pr_fmt(fmt) "MPTCP: " fmt
8 : :
9 : : #include <linux/kernel.h>
10 : : #include <linux/module.h>
11 : : #include <net/ipv6.h>
12 : : #include <net/sock.h>
13 : : #include <net/protocol.h>
14 : : #include <net/tcp.h>
15 : : #include <net/mptcp.h>
16 : : #include "protocol.h"
17 : :
18 : : #define MIN_INFO_OPTLEN_SIZE 16
19 : : #define MIN_FULL_INFO_OPTLEN_SIZE 40
20 : : #define MPTCP_INET_FLAGS_MASK \
21 : : (BIT(INET_FLAGS_TRANSPARENT) | \
22 : : BIT(INET_FLAGS_FREEBIND) | \
23 : : BIT(INET_FLAGS_BIND_ADDRESS_NO_PORT) | \
24 : : BIT(INET_FLAGS_RECVERR) | \
25 : : BIT(INET_FLAGS_RECVERR_RFC4884) | \
26 : : BIT(INET_FLAGS_RECVERR6) | \
27 : : BIT(INET_FLAGS_RECVERR6_RFC4884))
28 : :
29 : 10124 : static struct sock *__mptcp_tcp_fallback(struct mptcp_sock *msk)
30 : : {
31 : 10124 : msk_owned_by_me(msk);
32 : :
33 [ + + ]: 10124 : if (likely(!__mptcp_check_fallback(msk)))
34 : : return NULL;
35 : :
36 : 264 : return msk->first;
37 : : }
38 : :
39 : 0 : static u32 sockopt_seq_reset(const struct sock *sk)
40 : : {
41 : 88 : sock_owned_by_me(sk);
42 : :
43 : : /* Highbits contain state. Allows to distinguish sockopt_seq
44 : : * of listener and established:
45 : : * s0 = new_listener()
46 : : * sockopt(s0) - seq is 1
47 : : * s1 = accept(s0) - s1 inherits seq 1 if listener sk (s0)
48 : : * sockopt(s0) - seq increments to 2 on s0
49 : : * sockopt(s1) // seq increments to 2 on s1 (different option)
50 : : * new ssk completes join, inherits options from s0 // seq 2
51 : : * Needs sync from mptcp join logic, but ssk->seq == msk->seq
52 : : *
53 : : * Set High order bits to sk_state so ssk->seq == msk->seq test
54 : : * will fail.
55 : : */
56 : :
57 : 88 : return (u32)sk->sk_state << 24u;
58 : : }
59 : :
60 : 88 : static void sockopt_seq_inc(struct mptcp_sock *msk)
61 : : {
62 : 88 : u32 seq = (msk->setsockopt_seq + 1) & 0x00ffffff;
63 : :
64 : 88 : msk->setsockopt_seq = sockopt_seq_reset((struct sock *)msk) + seq;
65 : 107 : }
66 : :
67 : 121 : static int mptcp_get_int_option(struct mptcp_sock *msk, sockptr_t optval,
68 : : unsigned int optlen, int *val)
69 : : {
70 [ + - ]: 121 : if (optlen < sizeof(int))
71 : : return -EINVAL;
72 : :
73 [ - + ]: 121 : if (copy_from_sockptr(val, optval, sizeof(*val)))
74 : 0 : return -EFAULT;
75 : :
76 : : return 0;
77 : : }
78 : :
79 : 0 : static void __mptcp_subflow_set_rcvbuf(struct sock *ssk, int val)
80 : : {
81 : 0 : WRITE_ONCE(ssk->sk_rcvbuf, val);
82 : 0 : tcp_set_rcvbuf(ssk, val);
83 : 0 : }
84 : :
85 : 20 : static void mptcp_sol_socket_sync_intval(struct mptcp_sock *msk, int optname, int val)
86 : : {
87 : 20 : struct mptcp_subflow_context *subflow;
88 : 20 : struct sock *sk = (struct sock *)msk;
89 : :
90 : 20 : lock_sock(sk);
91 : 20 : sockopt_seq_inc(msk);
92 : :
93 [ + + ]: 40 : mptcp_for_each_subflow(msk, subflow) {
94 : 20 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
95 : 20 : bool slow = lock_sock_fast(ssk);
96 : :
97 [ - + - - : 20 : switch (optname) {
+ + - - ]
98 : 0 : case SO_DEBUG:
99 : 0 : sock_valbool_flag(ssk, SOCK_DBG, !!val);
100 : 0 : break;
101 : 6 : case SO_KEEPALIVE:
102 [ + - ]: 6 : if (ssk->sk_prot->keepalive)
103 : 6 : ssk->sk_prot->keepalive(ssk, !!val);
104 : 6 : sock_valbool_flag(ssk, SOCK_KEEPOPEN, !!val);
105 : 6 : break;
106 : : case SO_PRIORITY:
107 : 0 : WRITE_ONCE(ssk->sk_priority, val);
108 : 0 : break;
109 : 0 : case SO_SNDBUF:
110 : : case SO_SNDBUFFORCE:
111 : 0 : ssk->sk_userlocks |= SOCK_SNDBUF_LOCK;
112 : 0 : WRITE_ONCE(ssk->sk_sndbuf, sk->sk_sndbuf);
113 : 0 : mptcp_subflow_ctx(ssk)->cached_sndbuf = sk->sk_sndbuf;
114 : 0 : break;
115 : 6 : case SO_RCVBUF:
116 : : case SO_RCVBUFFORCE:
117 : 6 : ssk->sk_userlocks |= SOCK_RCVBUF_LOCK;
118 : 6 : __mptcp_subflow_set_rcvbuf(ssk, sk->sk_rcvbuf);
119 : 6 : break;
120 : : case SO_MARK:
121 [ + - ]: 8 : if (READ_ONCE(ssk->sk_mark) != sk->sk_mark) {
122 : 8 : WRITE_ONCE(ssk->sk_mark, sk->sk_mark);
123 : 8 : sk_dst_reset(ssk);
124 : : }
125 : : break;
126 : : case SO_INCOMING_CPU:
127 : 0 : WRITE_ONCE(ssk->sk_incoming_cpu, val);
128 : 0 : break;
129 : : }
130 : :
131 : 20 : subflow->setsockopt_seq = msk->setsockopt_seq;
132 : 20 : unlock_sock_fast(ssk, slow);
133 : : }
134 : :
135 : 20 : release_sock(sk);
136 : 20 : }
137 : :
138 : 20 : static int mptcp_sol_socket_intval(struct mptcp_sock *msk, int optname, int val)
139 : : {
140 : 20 : sockptr_t optval = KERNEL_SOCKPTR(&val);
141 : 20 : struct sock *sk = (struct sock *)msk;
142 : 20 : int ret;
143 : :
144 : 20 : ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
145 : : optval, sizeof(val));
146 [ + - ]: 20 : if (ret)
147 : : return ret;
148 : :
149 : 20 : mptcp_sol_socket_sync_intval(msk, optname, val);
150 : 20 : return 0;
151 : : }
152 : :
153 : 0 : static void mptcp_so_incoming_cpu(struct mptcp_sock *msk, int val)
154 : : {
155 : 0 : struct sock *sk = (struct sock *)msk;
156 : :
157 : 0 : WRITE_ONCE(sk->sk_incoming_cpu, val);
158 : :
159 : 0 : mptcp_sol_socket_sync_intval(msk, SO_INCOMING_CPU, val);
160 : : }
161 : :
162 : 8 : static int mptcp_setsockopt_sol_socket_tstamp(struct mptcp_sock *msk, int optname, int val)
163 : : {
164 : 8 : sockptr_t optval = KERNEL_SOCKPTR(&val);
165 : 8 : struct mptcp_subflow_context *subflow;
166 : 8 : struct sock *sk = (struct sock *)msk;
167 : 8 : int ret;
168 : :
169 : 8 : ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
170 : : optval, sizeof(val));
171 [ + - ]: 8 : if (ret)
172 : : return ret;
173 : :
174 : 8 : lock_sock(sk);
175 [ + + ]: 16 : mptcp_for_each_subflow(msk, subflow) {
176 : 8 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
177 : :
178 : 8 : lock_sock(ssk);
179 : 8 : sock_set_timestamp(ssk, optname, !!val);
180 : 8 : release_sock(ssk);
181 : : }
182 : :
183 : 8 : release_sock(sk);
184 : 8 : return 0;
185 : : }
186 : :
187 : 28 : static int mptcp_setsockopt_sol_socket_int(struct mptcp_sock *msk, int optname,
188 : : sockptr_t optval,
189 : : unsigned int optlen)
190 : : {
191 : 28 : int val, ret;
192 : :
193 : 28 : ret = mptcp_get_int_option(msk, optval, optlen, &val);
194 [ + - ]: 28 : if (ret)
195 : : return ret;
196 : :
197 [ + - + - ]: 28 : switch (optname) {
198 : 20 : case SO_KEEPALIVE:
199 : : case SO_DEBUG:
200 : : case SO_MARK:
201 : : case SO_PRIORITY:
202 : : case SO_SNDBUF:
203 : : case SO_SNDBUFFORCE:
204 : : case SO_RCVBUF:
205 : : case SO_RCVBUFFORCE:
206 : 20 : return mptcp_sol_socket_intval(msk, optname, val);
207 : 0 : case SO_INCOMING_CPU:
208 : 0 : mptcp_so_incoming_cpu(msk, val);
209 : 0 : return 0;
210 : 8 : case SO_TIMESTAMP_OLD:
211 : : case SO_TIMESTAMP_NEW:
212 : : case SO_TIMESTAMPNS_OLD:
213 : : case SO_TIMESTAMPNS_NEW:
214 : 8 : return mptcp_setsockopt_sol_socket_tstamp(msk, optname, val);
215 : : }
216 : :
217 : : return -ENOPROTOOPT;
218 : : }
219 : :
220 : 0 : static int mptcp_setsockopt_sol_socket_timestamping(struct mptcp_sock *msk,
221 : : int optname,
222 : : sockptr_t optval,
223 : : unsigned int optlen)
224 : : {
225 : 0 : struct mptcp_subflow_context *subflow;
226 : 0 : struct sock *sk = (struct sock *)msk;
227 : 0 : struct so_timestamping timestamping;
228 : 0 : int ret;
229 : :
230 [ # # ]: 0 : if (optlen == sizeof(timestamping)) {
231 [ # # ]: 0 : if (copy_from_sockptr(×tamping, optval,
232 : : sizeof(timestamping)))
233 : : return -EFAULT;
234 [ # # ]: 0 : } else if (optlen == sizeof(int)) {
235 : 0 : memset(×tamping, 0, sizeof(timestamping));
236 : :
237 [ # # ]: 0 : if (copy_from_sockptr(×tamping.flags, optval, sizeof(int)))
238 : : return -EFAULT;
239 : : } else {
240 : : return -EINVAL;
241 : : }
242 : :
243 : 0 : ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
244 : : KERNEL_SOCKPTR(×tamping),
245 : : sizeof(timestamping));
246 [ # # ]: 0 : if (ret)
247 : : return ret;
248 : :
249 : 0 : lock_sock(sk);
250 : :
251 [ # # ]: 0 : mptcp_for_each_subflow(msk, subflow) {
252 : 0 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
253 : 0 : int err;
254 : :
255 : 0 : lock_sock(ssk);
256 : 0 : err = sock_set_timestamping(ssk, optname, timestamping);
257 : 0 : release_sock(ssk);
258 : :
259 [ # # ]: 0 : if (err < 0 && ret == 0)
260 : 0 : ret = err;
261 : : }
262 : :
263 : 0 : release_sock(sk);
264 : :
265 : 0 : return ret;
266 : : }
267 : :
268 : 18 : static int mptcp_setsockopt_sol_socket_linger(struct mptcp_sock *msk, sockptr_t optval,
269 : : unsigned int optlen)
270 : : {
271 : 18 : struct mptcp_subflow_context *subflow;
272 : 18 : struct sock *sk = (struct sock *)msk;
273 : 18 : struct linger ling;
274 : 18 : sockptr_t kopt;
275 : 18 : int ret;
276 : :
277 [ + - ]: 18 : if (optlen < sizeof(ling))
278 : : return -EINVAL;
279 : :
280 [ + - ]: 18 : if (copy_from_sockptr(&ling, optval, sizeof(ling)))
281 : : return -EFAULT;
282 : :
283 : 18 : kopt = KERNEL_SOCKPTR(&ling);
284 : 18 : ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, SO_LINGER, kopt, sizeof(ling));
285 [ + - ]: 18 : if (ret)
286 : : return ret;
287 : :
288 : 18 : lock_sock(sk);
289 : 18 : sockopt_seq_inc(msk);
290 [ + + ]: 36 : mptcp_for_each_subflow(msk, subflow) {
291 : 18 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
292 : 18 : bool slow = lock_sock_fast(ssk);
293 : :
294 [ - + ]: 18 : if (!ling.l_onoff) {
295 : 0 : sock_reset_flag(ssk, SOCK_LINGER);
296 : : } else {
297 : 18 : ssk->sk_lingertime = sk->sk_lingertime;
298 : 18 : sock_set_flag(ssk, SOCK_LINGER);
299 : : }
300 : :
301 : 18 : subflow->setsockopt_seq = msk->setsockopt_seq;
302 : 18 : unlock_sock_fast(ssk, slow);
303 : : }
304 : :
305 : 18 : release_sock(sk);
306 : 18 : return 0;
307 : : }
308 : :
309 : 2374 : static int mptcp_setsockopt_sol_socket(struct mptcp_sock *msk, int optname,
310 : : sockptr_t optval, unsigned int optlen)
311 : : {
312 : 2374 : struct sock *sk = (struct sock *)msk;
313 : 2374 : struct sock *ssk;
314 : 2374 : int ret;
315 : :
316 [ + + - + : 2374 : switch (optname) {
+ - - ]
317 : : case SO_REUSEPORT:
318 : : case SO_REUSEADDR:
319 : : case SO_BINDTODEVICE:
320 : : case SO_BINDTOIFINDEX:
321 : 1998 : lock_sock(sk);
322 : 1998 : ssk = __mptcp_nmpc_sk(msk);
323 [ - + ]: 1998 : if (IS_ERR(ssk)) {
324 : 0 : release_sock(sk);
325 : 0 : return PTR_ERR(ssk);
326 : : }
327 : :
328 : 1998 : ret = sk_setsockopt(ssk, SOL_SOCKET, optname, optval, optlen);
329 [ + - ]: 1998 : if (ret == 0) {
330 [ - + ]: 1998 : if (optname == SO_REUSEPORT)
331 : 0 : sk->sk_reuseport = ssk->sk_reuseport;
332 [ + - ]: 1998 : else if (optname == SO_REUSEADDR)
333 : 1998 : sk->sk_reuse = ssk->sk_reuse;
334 [ # # ]: 0 : else if (optname == SO_BINDTODEVICE)
335 : 0 : sk->sk_bound_dev_if = ssk->sk_bound_dev_if;
336 : 0 : else if (optname == SO_BINDTOIFINDEX)
337 : 0 : sk->sk_bound_dev_if = ssk->sk_bound_dev_if;
338 : : }
339 : 1998 : release_sock(sk);
340 : 1998 : return ret;
341 : 28 : case SO_KEEPALIVE:
342 : : case SO_PRIORITY:
343 : : case SO_SNDBUF:
344 : : case SO_SNDBUFFORCE:
345 : : case SO_RCVBUF:
346 : : case SO_RCVBUFFORCE:
347 : : case SO_MARK:
348 : : case SO_INCOMING_CPU:
349 : : case SO_DEBUG:
350 : : case SO_TIMESTAMP_OLD:
351 : : case SO_TIMESTAMP_NEW:
352 : : case SO_TIMESTAMPNS_OLD:
353 : : case SO_TIMESTAMPNS_NEW:
354 : 28 : return mptcp_setsockopt_sol_socket_int(msk, optname, optval,
355 : : optlen);
356 : 0 : case SO_TIMESTAMPING_OLD:
357 : : case SO_TIMESTAMPING_NEW:
358 : 0 : return mptcp_setsockopt_sol_socket_timestamping(msk, optname,
359 : : optval, optlen);
360 : 18 : case SO_LINGER:
361 : 18 : return mptcp_setsockopt_sol_socket_linger(msk, optval, optlen);
362 : 330 : case SO_RCVLOWAT:
363 : : case SO_RCVTIMEO_OLD:
364 : : case SO_RCVTIMEO_NEW:
365 : : case SO_SNDTIMEO_OLD:
366 : : case SO_SNDTIMEO_NEW:
367 : : case SO_BUSY_POLL:
368 : : case SO_PREFER_BUSY_POLL:
369 : : case SO_BUSY_POLL_BUDGET:
370 : : /* No need to copy: only relevant for msk */
371 : 330 : return sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname, optval, optlen);
372 : : case SO_NO_CHECK:
373 : : case SO_DONTROUTE:
374 : : case SO_BROADCAST:
375 : : case SO_BSDCOMPAT:
376 : : case SO_PASSCRED:
377 : : case SO_PASSPIDFD:
378 : : case SO_PASSSEC:
379 : : case SO_RXQ_OVFL:
380 : : case SO_WIFI_STATUS:
381 : : case SO_NOFCS:
382 : : case SO_SELECT_ERR_QUEUE:
383 : : return 0;
384 : : }
385 : :
386 : : /* SO_OOBINLINE is not supported, let's avoid the related mess
387 : : * SO_ATTACH_FILTER, SO_ATTACH_BPF, SO_ATTACH_REUSEPORT_CBPF,
388 : : * SO_DETACH_REUSEPORT_BPF, SO_DETACH_FILTER, SO_LOCK_FILTER,
389 : : * we must be careful with subflows
390 : : *
391 : : * SO_ATTACH_REUSEPORT_EBPF is not supported, at it checks
392 : : * explicitly the sk_protocol field
393 : : *
394 : : * SO_PEEK_OFF is unsupported, as it is for plain TCP
395 : : * SO_MAX_PACING_RATE is unsupported, we must be careful with subflows
396 : : * SO_CNX_ADVICE is currently unsupported, could possibly be relevant,
397 : : * but likely needs careful design
398 : : *
399 : : * SO_ZEROCOPY is currently unsupported, TODO in sndmsg
400 : : * SO_TXTIME is currently unsupported
401 : : */
402 : :
403 : 0 : return -EOPNOTSUPP;
404 : : }
405 : :
406 : 20 : static int mptcp_setsockopt_all_sf(struct mptcp_sock *msk, int level,
407 : : int optname, sockptr_t optval,
408 : : unsigned int optlen)
409 : : {
410 : 20 : struct mptcp_subflow_context *subflow;
411 : 20 : int ret = 0;
412 : :
413 [ + + ]: 40 : mptcp_for_each_subflow(msk, subflow) {
414 [ + + ]: 20 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
415 : 20 : int err;
416 : :
417 : : /* SOL_IPV6 options on a v4 subflow (v4 MP_JOIN, or userspace PM
418 : : * grafting a v4 subflow onto an AF_INET6 msk) would otherwise
419 : : * abort the loop with -EAFNOSUPPORT from ipv6_setsockopt().
420 : : */
421 [ + + - + ]: 20 : if (level == SOL_IPV6 && ssk->sk_family != AF_INET6)
422 : 0 : continue;
423 : :
424 : 20 : err = tcp_setsockopt(ssk, level, optname, optval, optlen);
425 [ + - ]: 20 : if (err < 0 && ret == 0)
426 : 0 : ret = err;
427 : : }
428 : :
429 [ + - ]: 20 : if (!ret)
430 : 20 : sockopt_seq_inc(msk);
431 : :
432 : 20 : return ret;
433 : : }
434 : :
435 : 8 : static int mptcp_setsockopt_recverr(struct mptcp_sock *msk, int level,
436 : : int optname, sockptr_t optval,
437 : : unsigned int optlen)
438 : : {
439 : 8 : struct sock *sk = (struct sock *)msk;
440 : 8 : int val = 0, ret;
441 : :
442 : : /* Let ip_setsockopt() / ipv6_setsockopt() validate optval and optlen
443 : : * (so 1-byte boolean writes keep the same ABI as plain TCP) and update
444 : : * the parent's RECVERR bit. Re-read that bit under lock_sock() and
445 : : * push it to the subflows: concurrent setsockopt callers cannot leave
446 : : * parent and subflows desynchronized this way.
447 : : */
448 [ + + ]: 8 : if (level == SOL_IP)
449 : 4 : ret = ip_setsockopt(sk, level, optname, optval, optlen);
450 : : #if IS_ENABLED(CONFIG_IPV6)
451 [ + - ]: 4 : else if (level == SOL_IPV6) {
452 [ + - ]: 4 : if (sk->sk_family != AF_INET6)
453 : : return -ENOPROTOOPT;
454 : 4 : ret = ipv6_setsockopt(sk, level, optname, optval, optlen);
455 : : }
456 : : #endif
457 : : else
458 : : return -EOPNOTSUPP;
459 [ + - ]: 8 : if (ret)
460 : : return ret;
461 : :
462 : 8 : lock_sock(sk);
463 [ + - + - : 8 : switch (optname) {
- ]
464 : 4 : case IP_RECVERR:
465 : 4 : val = inet_test_bit(RECVERR, sk);
466 : 4 : break;
467 : 0 : case IP_RECVERR_RFC4884:
468 : 0 : val = inet_test_bit(RECVERR_RFC4884, sk);
469 : 0 : break;
470 : : #if IS_ENABLED(CONFIG_IPV6)
471 : 4 : case IPV6_RECVERR:
472 : 4 : val = inet6_test_bit(RECVERR6, sk);
473 : 4 : break;
474 : 0 : case IPV6_RECVERR_RFC4884:
475 : 0 : val = inet6_test_bit(RECVERR6_RFC4884, sk);
476 : 0 : break;
477 : : #endif
478 : : }
479 : :
480 : 8 : ret = mptcp_setsockopt_all_sf(msk, level, optname,
481 : : KERNEL_SOCKPTR(&val), sizeof(val));
482 : 8 : release_sock(sk);
483 : 8 : return ret;
484 : : }
485 : :
486 : 14 : static int mptcp_setsockopt_v6(struct mptcp_sock *msk, int optname,
487 : : sockptr_t optval, unsigned int optlen)
488 : : {
489 : 14 : struct sock *sk = (struct sock *)msk;
490 : 14 : int ret = -EOPNOTSUPP;
491 : 14 : struct sock *ssk;
492 : :
493 [ + + - ]: 14 : switch (optname) {
494 : : case IPV6_V6ONLY:
495 : : case IPV6_TRANSPARENT:
496 : : case IPV6_FREEBIND:
497 : 10 : lock_sock(sk);
498 : 10 : ssk = __mptcp_nmpc_sk(msk);
499 [ - + ]: 10 : if (IS_ERR(ssk)) {
500 : 0 : release_sock(sk);
501 : 0 : return PTR_ERR(ssk);
502 : : }
503 : :
504 : 10 : ret = tcp_setsockopt(ssk, SOL_IPV6, optname, optval, optlen);
505 [ - + ]: 10 : if (ret != 0) {
506 : 0 : release_sock(sk);
507 : 0 : return ret;
508 : : }
509 : :
510 : 10 : sockopt_seq_inc(msk);
511 : :
512 [ - + - - ]: 10 : switch (optname) {
513 : 0 : case IPV6_V6ONLY:
514 : 0 : sk->sk_ipv6only = ssk->sk_ipv6only;
515 : 0 : break;
516 : 10 : case IPV6_TRANSPARENT:
517 [ + - ]: 10 : inet_assign_bit(TRANSPARENT, sk,
518 : : inet_test_bit(TRANSPARENT, ssk));
519 : : break;
520 : 0 : case IPV6_FREEBIND:
521 [ # # ]: 0 : inet_assign_bit(FREEBIND, sk,
522 : : inet_test_bit(FREEBIND, ssk));
523 : : break;
524 : : }
525 : :
526 : 10 : release_sock(sk);
527 : 10 : break;
528 : 4 : case IPV6_RECVERR:
529 : : case IPV6_RECVERR_RFC4884:
530 : 4 : ret = mptcp_setsockopt_recverr(msk, SOL_IPV6, optname, optval,
531 : : optlen);
532 : 4 : break;
533 : : }
534 : :
535 : : return ret;
536 : : }
537 : :
538 : 18521 : static bool mptcp_supported_sockopt(int level, int optname)
539 : : {
540 [ + + ]: 18521 : if (level == SOL_IP) {
541 [ - + ]: 50 : switch (optname) {
542 : : /* should work fine */
543 : : case IP_FREEBIND:
544 : : case IP_TRANSPARENT:
545 : : case IP_BIND_ADDRESS_NO_PORT:
546 : : case IP_LOCAL_PORT_RANGE:
547 : :
548 : : /* the following are control cmsg related */
549 : : case IP_PKTINFO:
550 : : case IP_RECVTTL:
551 : : case IP_RECVTOS:
552 : : case IP_RECVOPTS:
553 : : case IP_RETOPTS:
554 : : case IP_PASSSEC:
555 : : case IP_RECVORIGDSTADDR:
556 : : case IP_CHECKSUM:
557 : : case IP_RECVFRAGSIZE:
558 : :
559 : : /* common stuff that need some love */
560 : : case IP_TOS:
561 : : case IP_TTL:
562 : : case IP_MTU_DISCOVER:
563 : : case IP_RECVERR:
564 : :
565 : : /* possibly less common may deserve some love */
566 : : case IP_MINTTL:
567 : :
568 : : /* the following is apparently a no-op for plain TCP */
569 : : case IP_RECVERR_RFC4884:
570 : : return true;
571 : : }
572 : :
573 : : /* IP_OPTIONS is not supported, needs subflow care */
574 : : /* IP_HDRINCL, IP_NODEFRAG are not supported, RAW specific */
575 : : /* IP_MULTICAST_TTL, IP_MULTICAST_LOOP, IP_UNICAST_IF,
576 : : * IP_ADD_MEMBERSHIP, IP_ADD_SOURCE_MEMBERSHIP, IP_DROP_MEMBERSHIP,
577 : : * IP_DROP_SOURCE_MEMBERSHIP, IP_BLOCK_SOURCE, IP_UNBLOCK_SOURCE,
578 : : * MCAST_JOIN_GROUP, MCAST_LEAVE_GROUP MCAST_JOIN_SOURCE_GROUP,
579 : : * MCAST_LEAVE_SOURCE_GROUP, MCAST_BLOCK_SOURCE, MCAST_UNBLOCK_SOURCE,
580 : : * MCAST_MSFILTER, IP_MULTICAST_ALL are not supported, better not deal
581 : : * with mcast stuff
582 : : */
583 : : /* IP_IPSEC_POLICY, IP_XFRM_POLICY are nut supported, unrelated here */
584 : 0 : return false;
585 : : }
586 [ + + ]: 18471 : if (level == SOL_IPV6) {
587 [ - + ]: 14 : switch (optname) {
588 : : case IPV6_V6ONLY:
589 : :
590 : : /* the following are control cmsg related */
591 : : case IPV6_RECVPKTINFO:
592 : : case IPV6_2292PKTINFO:
593 : : case IPV6_RECVHOPLIMIT:
594 : : case IPV6_2292HOPLIMIT:
595 : : case IPV6_RECVRTHDR:
596 : : case IPV6_2292RTHDR:
597 : : case IPV6_RECVHOPOPTS:
598 : : case IPV6_2292HOPOPTS:
599 : : case IPV6_RECVDSTOPTS:
600 : : case IPV6_2292DSTOPTS:
601 : : case IPV6_RECVTCLASS:
602 : : case IPV6_FLOWINFO:
603 : : case IPV6_RECVPATHMTU:
604 : : case IPV6_RECVORIGDSTADDR:
605 : : case IPV6_RECVFRAGSIZE:
606 : :
607 : : /* the following ones need some love but are quite common */
608 : : case IPV6_TCLASS:
609 : : case IPV6_TRANSPARENT:
610 : : case IPV6_FREEBIND:
611 : : case IPV6_PKTINFO:
612 : : case IPV6_2292PKTOPTIONS:
613 : : case IPV6_UNICAST_HOPS:
614 : : case IPV6_MTU_DISCOVER:
615 : : case IPV6_MTU:
616 : : case IPV6_RECVERR:
617 : : case IPV6_FLOWINFO_SEND:
618 : : case IPV6_FLOWLABEL_MGR:
619 : : case IPV6_MINHOPCOUNT:
620 : : case IPV6_DONTFRAG:
621 : : case IPV6_AUTOFLOWLABEL:
622 : :
623 : : /* the following one is a no-op for plain TCP */
624 : : case IPV6_RECVERR_RFC4884:
625 : : return true;
626 : : }
627 : :
628 : : /* IPV6_HOPOPTS, IPV6_RTHDRDSTOPTS, IPV6_RTHDR, IPV6_DSTOPTS are
629 : : * not supported
630 : : */
631 : : /* IPV6_MULTICAST_HOPS, IPV6_MULTICAST_LOOP, IPV6_UNICAST_IF,
632 : : * IPV6_MULTICAST_IF, IPV6_ADDRFORM,
633 : : * IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_JOIN_ANYCAST,
634 : : * IPV6_LEAVE_ANYCAST, IPV6_MULTICAST_ALL, MCAST_JOIN_GROUP, MCAST_LEAVE_GROUP,
635 : : * MCAST_JOIN_SOURCE_GROUP, MCAST_LEAVE_SOURCE_GROUP,
636 : : * MCAST_BLOCK_SOURCE, MCAST_UNBLOCK_SOURCE, MCAST_MSFILTER
637 : : * are not supported better not deal with mcast
638 : : */
639 : : /* IPV6_ROUTER_ALERT, IPV6_ROUTER_ALERT_ISOLATE are not supported, since are evil */
640 : :
641 : : /* IPV6_IPSEC_POLICY, IPV6_XFRM_POLICY are not supported */
642 : : /* IPV6_ADDR_PREFERENCES is not supported, we must be careful with subflows */
643 : 0 : return false;
644 : : }
645 [ + - ]: 18457 : if (level == SOL_TCP) {
646 [ + + ]: 18457 : switch (optname) {
647 : : /* the following are no-op or should work just fine */
648 : 247 : case TCP_THIN_DUPACK:
649 : : case TCP_DEFER_ACCEPT:
650 : :
651 : : /* the following need some love */
652 : : case TCP_MAXSEG:
653 : : case TCP_NODELAY:
654 : : case TCP_THIN_LINEAR_TIMEOUTS:
655 : : case TCP_CONGESTION:
656 : : case TCP_CORK:
657 : : case TCP_KEEPIDLE:
658 : : case TCP_KEEPINTVL:
659 : : case TCP_KEEPCNT:
660 : : case TCP_SYNCNT:
661 : : case TCP_SAVE_SYN:
662 : : case TCP_LINGER2:
663 : : case TCP_WINDOW_CLAMP:
664 : : case TCP_QUICKACK:
665 : : case TCP_USER_TIMEOUT:
666 : : case TCP_TIMESTAMP:
667 : : case TCP_NOTSENT_LOWAT:
668 : : case TCP_TX_DELAY:
669 : : case TCP_INQ:
670 : : case TCP_FASTOPEN:
671 : : case TCP_FASTOPEN_CONNECT:
672 : : case TCP_FASTOPEN_KEY:
673 : : case TCP_FASTOPEN_NO_COOKIE:
674 : 247 : return true;
675 : : }
676 : :
677 : : /* TCP_MD5SIG, TCP_MD5SIG_EXT are not supported, MD5 is not compatible with MPTCP */
678 : :
679 : : /* TCP_REPAIR, TCP_REPAIR_QUEUE, TCP_QUEUE_SEQ, TCP_REPAIR_OPTIONS,
680 : : * TCP_REPAIR_WINDOW are not supported, better avoid this mess
681 : : */
682 : : }
683 : : return false;
684 : : }
685 : :
686 : 0 : static int mptcp_setsockopt_sol_tcp_congestion(struct mptcp_sock *msk, sockptr_t optval,
687 : : unsigned int optlen)
688 : : {
689 : 0 : struct mptcp_subflow_context *subflow;
690 : 0 : struct sock *sk = (struct sock *)msk;
691 : 0 : char name[TCP_CA_NAME_MAX];
692 : 0 : bool cap_net_admin;
693 : 0 : int ret;
694 : :
695 [ # # ]: 0 : if (optlen < 1)
696 : : return -EINVAL;
697 : :
698 : 0 : ret = strncpy_from_sockptr(name, optval,
699 : 0 : min_t(long, TCP_CA_NAME_MAX - 1, optlen));
700 [ # # ]: 0 : if (ret < 0)
701 : : return -EFAULT;
702 : :
703 : 0 : name[ret] = 0;
704 : :
705 : 0 : cap_net_admin = ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN);
706 : :
707 : 0 : ret = 0;
708 : 0 : lock_sock(sk);
709 : 0 : sockopt_seq_inc(msk);
710 [ # # ]: 0 : mptcp_for_each_subflow(msk, subflow) {
711 : 0 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
712 : 0 : int err;
713 : :
714 : 0 : lock_sock(ssk);
715 : 0 : err = tcp_set_congestion_control(ssk, name, true, cap_net_admin);
716 [ # # ]: 0 : if (err < 0 && ret == 0)
717 : 0 : ret = err;
718 : 0 : subflow->setsockopt_seq = msk->setsockopt_seq;
719 : 0 : release_sock(ssk);
720 : : }
721 : :
722 [ # # ]: 0 : if (ret == 0)
723 : 0 : strscpy(msk->ca_name, name, sizeof(msk->ca_name));
724 : :
725 : 0 : release_sock(sk);
726 : 0 : return ret;
727 : : }
728 : :
729 : 18 : static int __mptcp_setsockopt_set_val(struct mptcp_sock *msk, int max,
730 : : int (*set_val)(struct sock *, int),
731 : : int *msk_val, int val)
732 : : {
733 : 18 : struct mptcp_subflow_context *subflow;
734 : 18 : int err = 0;
735 : :
736 [ + + ]: 36 : mptcp_for_each_subflow(msk, subflow) {
737 : 18 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
738 : 18 : int ret;
739 : :
740 : 18 : lock_sock(ssk);
741 : 18 : ret = set_val(ssk, val);
742 [ + - ]: 18 : err = err ? : ret;
743 : 18 : release_sock(ssk);
744 : : }
745 : :
746 [ + - ]: 18 : if (!err) {
747 : 18 : *msk_val = val;
748 : 18 : sockopt_seq_inc(msk);
749 : : }
750 : :
751 : 18 : return err;
752 : : }
753 : :
754 : 43 : static int __mptcp_setsockopt_sol_tcp_cork(struct mptcp_sock *msk, int val)
755 : : {
756 : 43 : struct mptcp_subflow_context *subflow;
757 : 43 : struct sock *sk = (struct sock *)msk;
758 : :
759 : 43 : sockopt_seq_inc(msk);
760 : 43 : msk->cork = !!val;
761 [ + + ]: 86 : mptcp_for_each_subflow(msk, subflow) {
762 : 43 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
763 : :
764 : 43 : lock_sock(ssk);
765 : 43 : __tcp_sock_set_cork(ssk, !!val);
766 : 43 : release_sock(ssk);
767 : : }
768 [ + + ]: 43 : if (!val)
769 : 21 : mptcp_check_and_set_pending(sk);
770 : :
771 : 43 : return 0;
772 : : }
773 : :
774 : 6 : static int __mptcp_setsockopt_sol_tcp_nodelay(struct mptcp_sock *msk, int val)
775 : : {
776 : 6 : struct mptcp_subflow_context *subflow;
777 : 6 : struct sock *sk = (struct sock *)msk;
778 : :
779 : 6 : sockopt_seq_inc(msk);
780 : 6 : msk->nodelay = !!val;
781 [ + + ]: 12 : mptcp_for_each_subflow(msk, subflow) {
782 : 6 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
783 : :
784 : 6 : lock_sock(ssk);
785 : 6 : __tcp_sock_set_nodelay(ssk, !!val);
786 : 6 : release_sock(ssk);
787 : : }
788 [ + - ]: 6 : if (val)
789 : 6 : mptcp_check_and_set_pending(sk);
790 : 6 : return 0;
791 : : }
792 : :
793 : 10 : static int mptcp_setsockopt_sol_ip_set(struct mptcp_sock *msk, int optname,
794 : : sockptr_t optval, unsigned int optlen)
795 : : {
796 : 10 : struct sock *sk = (struct sock *)msk;
797 : 10 : struct sock *ssk;
798 : 10 : int err;
799 : :
800 : 10 : err = ip_setsockopt(sk, SOL_IP, optname, optval, optlen);
801 [ + - ]: 10 : if (err != 0)
802 : : return err;
803 : :
804 : 10 : lock_sock(sk);
805 : :
806 : 10 : ssk = __mptcp_nmpc_sk(msk);
807 [ - + ]: 10 : if (IS_ERR(ssk)) {
808 : 0 : release_sock(sk);
809 : 0 : return PTR_ERR(ssk);
810 : : }
811 : :
812 [ - + - - : 10 : switch (optname) {
- ]
813 : 0 : case IP_FREEBIND:
814 [ # # ]: 0 : inet_assign_bit(FREEBIND, ssk, inet_test_bit(FREEBIND, sk));
815 : : break;
816 : 10 : case IP_TRANSPARENT:
817 [ + - ]: 10 : inet_assign_bit(TRANSPARENT, ssk,
818 : : inet_test_bit(TRANSPARENT, sk));
819 : : break;
820 : 0 : case IP_BIND_ADDRESS_NO_PORT:
821 [ # # ]: 0 : inet_assign_bit(BIND_ADDRESS_NO_PORT, ssk,
822 : : inet_test_bit(BIND_ADDRESS_NO_PORT, sk));
823 : : break;
824 : : case IP_LOCAL_PORT_RANGE:
825 : 0 : WRITE_ONCE(inet_sk(ssk)->local_port_range,
826 : : READ_ONCE(inet_sk(sk)->local_port_range));
827 : 0 : break;
828 : 0 : default:
829 : 0 : release_sock(sk);
830 : 0 : WARN_ON_ONCE(1);
831 : 0 : return -EOPNOTSUPP;
832 : : }
833 : :
834 : 10 : sockopt_seq_inc(msk);
835 : 10 : release_sock(sk);
836 : 10 : return 0;
837 : : }
838 : :
839 : 36 : static int mptcp_setsockopt_v4_set_tos(struct mptcp_sock *msk, int optname,
840 : : sockptr_t optval, unsigned int optlen)
841 : : {
842 : 36 : struct mptcp_subflow_context *subflow;
843 : 36 : struct sock *sk = (struct sock *)msk;
844 : 36 : int err, val;
845 : :
846 : 36 : err = ip_setsockopt(sk, SOL_IP, optname, optval, optlen);
847 : :
848 [ + - ]: 36 : if (err != 0)
849 : : return err;
850 : :
851 : 36 : lock_sock(sk);
852 : 36 : sockopt_seq_inc(msk);
853 : 36 : val = READ_ONCE(inet_sk(sk)->tos);
854 [ + + ]: 80 : mptcp_for_each_subflow(msk, subflow) {
855 : 44 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
856 : 44 : bool slow;
857 : :
858 : 44 : slow = lock_sock_fast(ssk);
859 : 44 : __ip_sock_set_tos(ssk, val);
860 : 44 : unlock_sock_fast(ssk, slow);
861 : : }
862 : 36 : release_sock(sk);
863 : :
864 : 36 : return 0;
865 : : }
866 : :
867 : 50 : static int mptcp_setsockopt_v4(struct mptcp_sock *msk, int optname,
868 : : sockptr_t optval, unsigned int optlen)
869 : : {
870 [ + + + - ]: 50 : switch (optname) {
871 : 10 : case IP_FREEBIND:
872 : : case IP_TRANSPARENT:
873 : : case IP_BIND_ADDRESS_NO_PORT:
874 : : case IP_LOCAL_PORT_RANGE:
875 : 10 : return mptcp_setsockopt_sol_ip_set(msk, optname, optval, optlen);
876 : 36 : case IP_TOS:
877 : 36 : return mptcp_setsockopt_v4_set_tos(msk, optname, optval, optlen);
878 : 4 : case IP_RECVERR:
879 : : case IP_RECVERR_RFC4884:
880 : 4 : return mptcp_setsockopt_recverr(msk, SOL_IP, optname, optval,
881 : : optlen);
882 : : }
883 : :
884 : : return -EOPNOTSUPP;
885 : : }
886 : :
887 : 154 : static int mptcp_setsockopt_first_sf_only(struct mptcp_sock *msk, int level, int optname,
888 : : sockptr_t optval, unsigned int optlen)
889 : : {
890 : 154 : struct sock *sk = (struct sock *)msk;
891 : 154 : struct sock *ssk;
892 : 154 : int ret;
893 : :
894 : : /* Limit to first subflow, before the connection establishment */
895 : 154 : lock_sock(sk);
896 : 154 : ssk = __mptcp_nmpc_sk(msk);
897 [ + + ]: 154 : if (IS_ERR(ssk)) {
898 : 12 : ret = PTR_ERR(ssk);
899 : 12 : goto unlock;
900 : : }
901 : :
902 : 142 : ret = tcp_setsockopt(ssk, level, optname, optval, optlen);
903 : :
904 : 154 : unlock:
905 : 154 : release_sock(sk);
906 : 154 : return ret;
907 : : }
908 : :
909 : 247 : static int mptcp_setsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
910 : : sockptr_t optval, unsigned int optlen)
911 : : {
912 : 247 : struct sock *sk = (void *)msk;
913 : 247 : int ret, val;
914 : :
915 [ - - + + : 247 : switch (optname) {
- ]
916 : : case TCP_ULP:
917 : : return -EOPNOTSUPP;
918 : 0 : case TCP_CONGESTION:
919 : 0 : return mptcp_setsockopt_sol_tcp_congestion(msk, optval, optlen);
920 : 0 : case TCP_DEFER_ACCEPT:
921 : : /* See tcp.c: TCP_DEFER_ACCEPT does not fail */
922 : 0 : mptcp_setsockopt_first_sf_only(msk, SOL_TCP, optname, optval, optlen);
923 : 0 : return 0;
924 : 154 : case TCP_FASTOPEN:
925 : : case TCP_FASTOPEN_CONNECT:
926 : : case TCP_FASTOPEN_KEY:
927 : : case TCP_FASTOPEN_NO_COOKIE:
928 : 154 : return mptcp_setsockopt_first_sf_only(msk, SOL_TCP, optname,
929 : : optval, optlen);
930 : : }
931 : :
932 : 93 : ret = mptcp_get_int_option(msk, optval, optlen, &val);
933 [ + - ]: 93 : if (ret)
934 : : return ret;
935 : :
936 : 93 : lock_sock(sk);
937 [ + + + + : 93 : switch (optname) {
+ + + +
- ]
938 : 8 : case TCP_INQ:
939 [ + - ]: 8 : if (val < 0 || val > 1)
940 : : ret = -EINVAL;
941 : : else
942 : 8 : msk->recvmsg_inq = !!val;
943 : : break;
944 : : case TCP_NOTSENT_LOWAT:
945 : 6 : WRITE_ONCE(msk->notsent_lowat, val);
946 : 6 : mptcp_write_space(sk);
947 : 6 : break;
948 : 43 : case TCP_CORK:
949 : 43 : ret = __mptcp_setsockopt_sol_tcp_cork(msk, val);
950 : 43 : break;
951 : 6 : case TCP_NODELAY:
952 : 6 : ret = __mptcp_setsockopt_sol_tcp_nodelay(msk, val);
953 : 6 : break;
954 : 6 : case TCP_KEEPIDLE:
955 : 6 : ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPIDLE,
956 : : &tcp_sock_set_keepidle_locked,
957 : : &msk->keepalive_idle, val);
958 : 6 : break;
959 : 6 : case TCP_KEEPINTVL:
960 : 6 : ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPINTVL,
961 : : &tcp_sock_set_keepintvl,
962 : : &msk->keepalive_intvl, val);
963 : 6 : break;
964 : 6 : case TCP_KEEPCNT:
965 : 6 : ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPCNT,
966 : : &tcp_sock_set_keepcnt,
967 : : &msk->keepalive_cnt,
968 : : val);
969 : 6 : break;
970 : 12 : case TCP_MAXSEG:
971 : 12 : msk->maxseg = val;
972 : 12 : ret = mptcp_setsockopt_all_sf(msk, SOL_TCP, optname, optval,
973 : : optlen);
974 : 12 : break;
975 : : default:
976 : : ret = -ENOPROTOOPT;
977 : : }
978 : :
979 : 93 : release_sock(sk);
980 : 93 : return ret;
981 : : }
982 : :
983 : 20895 : int mptcp_setsockopt(struct sock *sk, int level, int optname,
984 : : sockptr_t optval, unsigned int optlen)
985 : : {
986 [ - + ]: 20895 : struct mptcp_sock *msk = mptcp_sk(sk);
987 : 20895 : struct sock *ssk;
988 : :
989 [ - + - - ]: 20895 : pr_debug("msk=%p\n", msk);
990 : :
991 [ + + ]: 20895 : if (level == SOL_SOCKET)
992 : 2374 : return mptcp_setsockopt_sol_socket(msk, optname, optval, optlen);
993 : :
994 [ + + ]: 18521 : if (!mptcp_supported_sockopt(level, optname))
995 : : return -ENOPROTOOPT;
996 : :
997 : : /* @@ the meaning of setsockopt() when the socket is connected and
998 : : * there are multiple subflows is not yet defined. It is up to the
999 : : * MPTCP-level socket to configure the subflows until the subflow
1000 : : * is in TCP fallback, when TCP socket options are passed through
1001 : : * to the one remaining subflow.
1002 : : */
1003 : 311 : lock_sock(sk);
1004 : 311 : ssk = __mptcp_tcp_fallback(msk);
1005 : 311 : release_sock(sk);
1006 [ - + ]: 311 : if (ssk)
1007 : 0 : return tcp_setsockopt(ssk, level, optname, optval, optlen);
1008 : :
1009 [ + + ]: 311 : if (level == SOL_IP)
1010 : 50 : return mptcp_setsockopt_v4(msk, optname, optval, optlen);
1011 : :
1012 [ + + ]: 261 : if (level == SOL_IPV6)
1013 : 14 : return mptcp_setsockopt_v6(msk, optname, optval, optlen);
1014 : :
1015 [ + - ]: 247 : if (level == SOL_TCP)
1016 : 247 : return mptcp_setsockopt_sol_tcp(msk, optname, optval, optlen);
1017 : :
1018 : : return -EOPNOTSUPP;
1019 : : }
1020 : :
1021 : 9018 : static int mptcp_getsockopt_first_sf_only(struct mptcp_sock *msk, int level, int optname,
1022 : : char __user *optval, int __user *optlen)
1023 : : {
1024 : 9018 : struct sock *sk = (struct sock *)msk;
1025 : 9018 : struct sock *ssk;
1026 : 9018 : int ret;
1027 : :
1028 : 9018 : lock_sock(sk);
1029 : 9018 : ssk = msk->first;
1030 [ + + ]: 9018 : if (ssk)
1031 : 6420 : goto get;
1032 : :
1033 : 2598 : ssk = __mptcp_nmpc_sk(msk);
1034 [ - + ]: 2598 : if (IS_ERR(ssk)) {
1035 : 0 : ret = PTR_ERR(ssk);
1036 : 0 : goto out;
1037 : : }
1038 : :
1039 : 2598 : get:
1040 : 9018 : ret = tcp_getsockopt(ssk, level, optname, optval, optlen);
1041 : :
1042 : 9018 : out:
1043 : 9018 : release_sock(sk);
1044 : 9018 : return ret;
1045 : : }
1046 : :
1047 : 1068 : void mptcp_diag_fill_info(struct mptcp_sock *msk, struct mptcp_info *info)
1048 : : {
1049 : 1068 : struct sock *sk = (struct sock *)msk;
1050 : 1068 : u32 flags = 0;
1051 : 1068 : bool slow;
1052 : 1068 : u32 now;
1053 : :
1054 : 1068 : memset(info, 0, sizeof(*info));
1055 : :
1056 : 1068 : info->mptcpi_extra_subflows = READ_ONCE(msk->pm.extra_subflows);
1057 : 1068 : info->mptcpi_add_addr_signal = READ_ONCE(msk->pm.add_addr_signaled);
1058 : 1068 : info->mptcpi_add_addr_accepted = READ_ONCE(msk->pm.add_addr_accepted);
1059 : 1068 : info->mptcpi_local_addr_used = READ_ONCE(msk->pm.local_addr_used);
1060 : :
1061 [ + - ]: 1068 : if (inet_sk_state_load(sk) == TCP_LISTEN)
1062 : : return;
1063 : :
1064 : : /* The following limits only make sense for the in-kernel PM */
1065 [ + + ]: 1068 : if (mptcp_pm_is_kernel(msk)) {
1066 : 2012 : info->mptcpi_limit_extra_subflows =
1067 : 1006 : mptcp_pm_get_limit_extra_subflows(msk);
1068 : 2012 : info->mptcpi_endp_signal_max =
1069 : 1006 : mptcp_pm_get_endp_signal_max(msk);
1070 : 2012 : info->mptcpi_limit_add_addr_accepted =
1071 : 1006 : mptcp_pm_get_limit_add_addr_accepted(msk);
1072 : 2012 : info->mptcpi_endp_subflow_max =
1073 : 1006 : mptcp_pm_get_endp_subflow_max(msk);
1074 : 2012 : info->mptcpi_endp_laminar_max =
1075 : 1006 : mptcp_pm_get_endp_laminar_max(msk);
1076 : 1006 : info->mptcpi_endp_fullmesh_max =
1077 : 1006 : mptcp_pm_get_endp_fullmesh_max(msk);
1078 : : }
1079 : :
1080 [ + + ]: 1068 : if (__mptcp_check_fallback(msk))
1081 : 2 : flags |= MPTCP_INFO_FLAG_FALLBACK;
1082 [ + + ]: 1068 : if (READ_ONCE(msk->can_ack))
[ - + + + ]
1083 : 1066 : flags |= MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED;
1084 : 1068 : info->mptcpi_flags = flags;
1085 : :
1086 : 1068 : slow = lock_sock_fast(sk);
1087 [ - + ]: 1068 : info->mptcpi_csum_enabled = READ_ONCE(msk->csum_enabled);
1088 : 1068 : info->mptcpi_token = msk->token;
1089 : 1068 : info->mptcpi_write_seq = msk->write_seq;
1090 : 1068 : info->mptcpi_retransmits = inet_csk(sk)->icsk_retransmits;
1091 : 1068 : info->mptcpi_bytes_sent = msk->bytes_sent;
1092 : 1068 : info->mptcpi_bytes_received = msk->bytes_received;
1093 : 1068 : info->mptcpi_bytes_retrans = msk->bytes_retrans;
1094 : 2136 : info->mptcpi_subflows_total = info->mptcpi_extra_subflows +
1095 : 1068 : __mptcp_has_initial_subflow(msk);
1096 : 1068 : now = tcp_jiffies32;
1097 : 1068 : info->mptcpi_last_data_sent = jiffies_to_msecs(now - msk->last_data_sent);
1098 : 1068 : info->mptcpi_last_data_recv = jiffies_to_msecs(now - msk->last_data_recv);
1099 : 1068 : unlock_sock_fast(sk, slow);
1100 : :
1101 : 1068 : mptcp_data_lock(sk);
1102 : 1068 : info->mptcpi_last_ack_recv = jiffies_to_msecs(now - msk->last_ack_recv);
1103 : 1068 : info->mptcpi_snd_una = msk->snd_una;
1104 : 1068 : info->mptcpi_rcv_nxt = msk->ack_seq;
1105 : 1068 : info->mptcpi_bytes_acked = msk->bytes_acked;
1106 : 1068 : mptcp_data_unlock(sk);
1107 : : }
1108 : : EXPORT_SYMBOL_GPL(mptcp_diag_fill_info);
1109 : :
1110 : 33 : static int mptcp_getsockopt_info(struct mptcp_sock *msk, char __user *optval, int __user *optlen)
1111 : : {
1112 : 33 : struct mptcp_info m_info;
1113 : 33 : int len;
1114 : :
1115 [ - + ]: 33 : if (get_user(len, optlen))
1116 : : return -EFAULT;
1117 : :
1118 : : /* When used only to check if a fallback to TCP happened. */
1119 [ - + ]: 33 : if (len == 0)
1120 : : return 0;
1121 : :
1122 : 33 : len = min_t(unsigned int, len, sizeof(struct mptcp_info));
1123 : :
1124 : 33 : mptcp_diag_fill_info(msk, &m_info);
1125 : :
1126 [ - + ]: 33 : if (put_user(len, optlen))
1127 : : return -EFAULT;
1128 : :
1129 [ - + ]: 33 : if (copy_to_user(optval, &m_info, len))
1130 : : return -EFAULT;
1131 : :
1132 : : return 0;
1133 : : }
1134 : :
1135 : 144 : static int mptcp_put_subflow_data(struct mptcp_subflow_data *sfd,
1136 : : char __user *optval,
1137 : : u32 copied,
1138 : : int __user *optlen)
1139 : : {
1140 : 144 : u32 copylen = min_t(u32, sfd->size_subflow_data, sizeof(*sfd));
1141 : :
1142 [ + + ]: 144 : if (copied)
1143 : 80 : copied += sfd->size_subflow_data;
1144 : : else
1145 : : copied = copylen;
1146 : :
1147 [ - + ]: 144 : if (put_user(copied, optlen))
1148 : : return -EFAULT;
1149 : :
1150 [ - + - + ]: 288 : if (copy_to_user(optval, sfd, copylen))
1151 : : return -EFAULT;
1152 : :
1153 : : return 0;
1154 : : }
1155 : :
1156 : 272 : static int mptcp_get_subflow_data(struct mptcp_subflow_data *sfd,
1157 : : char __user *optval,
1158 : : int __user *optlen)
1159 : : {
1160 : 272 : int len, copylen;
1161 : :
1162 [ - + ]: 272 : if (get_user(len, optlen))
1163 : : return -EFAULT;
1164 : :
1165 : : /* if mptcp_subflow_data size is changed, need to adjust
1166 : : * this function to deal with programs using old version.
1167 : : */
1168 : 272 : BUILD_BUG_ON(sizeof(*sfd) != MIN_INFO_OPTLEN_SIZE);
1169 : :
1170 [ + + ]: 272 : if (len < MIN_INFO_OPTLEN_SIZE)
1171 : : return -EINVAL;
1172 : :
1173 : 240 : memset(sfd, 0, sizeof(*sfd));
1174 : :
1175 : 240 : copylen = min_t(unsigned int, len, sizeof(*sfd));
1176 [ - + - + ]: 480 : if (copy_from_user(sfd, optval, copylen))
1177 : : return -EFAULT;
1178 : :
1179 : : /* size_subflow_data is u32, but len is signed */
1180 [ - + ]: 240 : if (sfd->size_subflow_data > INT_MAX ||
1181 [ - + ]: 240 : sfd->size_user > INT_MAX)
1182 : : return -EINVAL;
1183 : :
1184 [ + + - + ]: 240 : if (sfd->size_subflow_data < MIN_INFO_OPTLEN_SIZE ||
1185 : : sfd->size_subflow_data > len)
1186 : : return -EINVAL;
1187 : :
1188 [ + + + + ]: 208 : if (sfd->num_subflows || sfd->size_kernel)
1189 : : return -EINVAL;
1190 : :
1191 : 144 : return len - sfd->size_subflow_data;
1192 : : }
1193 : :
1194 : 128 : static int mptcp_getsockopt_tcpinfo(struct mptcp_sock *msk, char __user *optval,
1195 : : int __user *optlen)
1196 : : {
1197 : 128 : struct mptcp_subflow_context *subflow;
1198 : 128 : struct sock *sk = (struct sock *)msk;
1199 : 128 : unsigned int sfcount = 0, copied = 0;
1200 : 128 : struct mptcp_subflow_data sfd;
1201 : 128 : char __user *infoptr;
1202 : 128 : int len;
1203 : :
1204 : 128 : len = mptcp_get_subflow_data(&sfd, optval, optlen);
1205 [ + + ]: 128 : if (len < 0)
1206 : : return len;
1207 : :
1208 : 64 : sfd.size_kernel = sizeof(struct tcp_info);
1209 : 64 : sfd.size_user = min_t(unsigned int, sfd.size_user,
1210 : : sizeof(struct tcp_info));
1211 : :
1212 : 64 : infoptr = optval + sfd.size_subflow_data;
1213 : :
1214 : 64 : lock_sock(sk);
1215 : :
1216 [ + + ]: 128 : mptcp_for_each_subflow(msk, subflow) {
1217 [ + + ]: 64 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1218 : :
1219 : 64 : ++sfcount;
1220 : :
1221 [ + + + - ]: 64 : if (len && len >= sfd.size_user) {
1222 : 32 : struct tcp_info info;
1223 : :
1224 : 32 : tcp_get_info(ssk, &info);
1225 : :
1226 [ - + - + ]: 64 : if (copy_to_user(infoptr, &info, sfd.size_user)) {
1227 : 0 : release_sock(sk);
1228 : 0 : return -EFAULT;
1229 : : }
1230 : :
1231 : 32 : infoptr += sfd.size_user;
1232 : 32 : copied += sfd.size_user;
1233 : 32 : len -= sfd.size_user;
1234 : : }
1235 : : }
1236 : :
1237 : 64 : release_sock(sk);
1238 : :
1239 : 64 : sfd.num_subflows = sfcount;
1240 : :
1241 [ - + ]: 64 : if (mptcp_put_subflow_data(&sfd, optval, copied, optlen))
1242 : : return -EFAULT;
1243 : :
1244 : : return 0;
1245 : : }
1246 : :
1247 : 56 : static void mptcp_get_sub_addrs(const struct sock *sk, struct mptcp_subflow_addrs *a)
1248 : : {
1249 : 56 : const struct inet_sock *inet = inet_sk(sk);
1250 : :
1251 : 56 : memset(a, 0, sizeof(*a));
1252 : :
1253 [ + + ]: 56 : if (sk->sk_family == AF_INET) {
1254 : 28 : a->sin_local.sin_family = AF_INET;
1255 : 28 : a->sin_local.sin_port = inet->inet_sport;
1256 : 28 : a->sin_local.sin_addr.s_addr = inet->inet_rcv_saddr;
1257 : :
1258 [ - + ]: 28 : if (!a->sin_local.sin_addr.s_addr)
1259 : 0 : a->sin_local.sin_addr.s_addr = inet->inet_saddr;
1260 : :
1261 : 28 : a->sin_remote.sin_family = AF_INET;
1262 : 28 : a->sin_remote.sin_port = inet->inet_dport;
1263 : 28 : a->sin_remote.sin_addr.s_addr = inet->inet_daddr;
1264 : : #if IS_ENABLED(CONFIG_IPV6)
1265 [ + - ]: 28 : } else if (sk->sk_family == AF_INET6) {
1266 [ + - ]: 28 : const struct ipv6_pinfo *np = inet6_sk(sk);
1267 : :
1268 [ - + ]: 28 : if (WARN_ON_ONCE(!np))
1269 : 0 : return;
1270 : :
1271 : 28 : a->sin6_local.sin6_family = AF_INET6;
1272 : 28 : a->sin6_local.sin6_port = inet->inet_sport;
1273 : :
1274 [ - + ]: 28 : if (ipv6_addr_any(&sk->sk_v6_rcv_saddr))
1275 : 0 : a->sin6_local.sin6_addr = np->saddr;
1276 : : else
1277 : 28 : a->sin6_local.sin6_addr = sk->sk_v6_rcv_saddr;
1278 : :
1279 : 28 : a->sin6_remote.sin6_family = AF_INET6;
1280 : 28 : a->sin6_remote.sin6_port = inet->inet_dport;
1281 : 28 : a->sin6_remote.sin6_addr = sk->sk_v6_daddr;
1282 : : #endif
1283 : : }
1284 : : }
1285 : :
1286 : 144 : static int mptcp_getsockopt_subflow_addrs(struct mptcp_sock *msk, char __user *optval,
1287 : : int __user *optlen)
1288 : : {
1289 : 144 : struct mptcp_subflow_context *subflow;
1290 : 144 : struct sock *sk = (struct sock *)msk;
1291 : 144 : unsigned int sfcount = 0, copied = 0;
1292 : 144 : struct mptcp_subflow_data sfd;
1293 : 144 : char __user *addrptr;
1294 : 144 : int len;
1295 : :
1296 : 144 : len = mptcp_get_subflow_data(&sfd, optval, optlen);
1297 [ + + ]: 144 : if (len < 0)
1298 : : return len;
1299 : :
1300 : 80 : sfd.size_kernel = sizeof(struct mptcp_subflow_addrs);
1301 : 80 : sfd.size_user = min_t(unsigned int, sfd.size_user,
1302 : : sizeof(struct mptcp_subflow_addrs));
1303 : :
1304 : 80 : addrptr = optval + sfd.size_subflow_data;
1305 : :
1306 : 80 : lock_sock(sk);
1307 : :
1308 [ + + ]: 160 : mptcp_for_each_subflow(msk, subflow) {
1309 [ + + ]: 80 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1310 : :
1311 : 80 : ++sfcount;
1312 : :
1313 [ + + + - ]: 80 : if (len && len >= sfd.size_user) {
1314 : 48 : struct mptcp_subflow_addrs a;
1315 : :
1316 : 48 : mptcp_get_sub_addrs(ssk, &a);
1317 : :
1318 [ - + - + ]: 96 : if (copy_to_user(addrptr, &a, sfd.size_user)) {
1319 : 0 : release_sock(sk);
1320 : 0 : return -EFAULT;
1321 : : }
1322 : :
1323 : 48 : addrptr += sfd.size_user;
1324 : 48 : copied += sfd.size_user;
1325 : 48 : len -= sfd.size_user;
1326 : : }
1327 : : }
1328 : :
1329 : 80 : release_sock(sk);
1330 : :
1331 : 80 : sfd.num_subflows = sfcount;
1332 : :
1333 [ - + ]: 80 : if (mptcp_put_subflow_data(&sfd, optval, copied, optlen))
1334 : : return -EFAULT;
1335 : :
1336 : : return 0;
1337 : : }
1338 : :
1339 : 8 : static int mptcp_get_full_info(struct mptcp_full_info *mfi,
1340 : : char __user *optval,
1341 : : int __user *optlen)
1342 : : {
1343 : 8 : int len;
1344 : :
1345 : 8 : BUILD_BUG_ON(offsetof(struct mptcp_full_info, mptcp_info) !=
1346 : : MIN_FULL_INFO_OPTLEN_SIZE);
1347 : :
1348 [ - + ]: 8 : if (get_user(len, optlen))
1349 : : return -EFAULT;
1350 : :
1351 [ - + ]: 8 : if (len < MIN_FULL_INFO_OPTLEN_SIZE)
1352 : : return -EINVAL;
1353 : :
1354 : 8 : memset(mfi, 0, sizeof(*mfi));
1355 [ + + - + ]: 16 : if (copy_from_user(mfi, optval, MIN_FULL_INFO_OPTLEN_SIZE))
1356 : 0 : return -EFAULT;
1357 : :
1358 [ - + ]: 8 : if (mfi->size_tcpinfo_kernel ||
1359 [ - + ]: 8 : mfi->size_sfinfo_kernel ||
1360 [ - + ]: 8 : mfi->num_subflows)
1361 : : return -EINVAL;
1362 : :
1363 [ - + ]: 8 : if (mfi->size_sfinfo_user > INT_MAX ||
1364 [ - + ]: 8 : mfi->size_tcpinfo_user > INT_MAX)
1365 : : return -EINVAL;
1366 : :
1367 : 8 : return len - MIN_FULL_INFO_OPTLEN_SIZE;
1368 : : }
1369 : :
1370 : 8 : static int mptcp_put_full_info(struct mptcp_full_info *mfi,
1371 : : char __user *optval,
1372 : : u32 copylen,
1373 : : int __user *optlen)
1374 : : {
1375 : 8 : copylen += MIN_FULL_INFO_OPTLEN_SIZE;
1376 [ - + ]: 8 : if (put_user(copylen, optlen))
1377 : : return -EFAULT;
1378 : :
1379 [ + - - + ]: 16 : if (copy_to_user(optval, mfi, copylen))
1380 : : return -EFAULT;
1381 : : return 0;
1382 : : }
1383 : :
1384 : 8 : static int mptcp_getsockopt_full_info(struct mptcp_sock *msk, char __user *optval,
1385 : : int __user *optlen)
1386 : : {
1387 : 8 : unsigned int sfcount = 0, copylen = 0;
1388 : 8 : struct mptcp_subflow_context *subflow;
1389 : 8 : struct sock *sk = (struct sock *)msk;
1390 : 8 : void __user *tcpinfoptr, *sfinfoptr;
1391 : 8 : struct mptcp_full_info mfi;
1392 : 8 : int len;
1393 : :
1394 : 8 : len = mptcp_get_full_info(&mfi, optval, optlen);
1395 [ + - ]: 8 : if (len < 0)
1396 : : return len;
1397 : :
1398 : : /* don't bother filling the mptcp info if there is not enough
1399 : : * user-space-provided storage
1400 : : */
1401 [ + - ]: 8 : if (len > 0) {
1402 : 8 : mptcp_diag_fill_info(msk, &mfi.mptcp_info);
1403 : 8 : copylen += min_t(unsigned int, len, sizeof(struct mptcp_info));
1404 : : }
1405 : :
1406 : 8 : mfi.size_tcpinfo_kernel = sizeof(struct tcp_info);
1407 : 8 : mfi.size_tcpinfo_user = min_t(unsigned int, mfi.size_tcpinfo_user,
1408 : : sizeof(struct tcp_info));
1409 : 8 : sfinfoptr = u64_to_user_ptr(mfi.subflow_info);
1410 : 8 : mfi.size_sfinfo_kernel = sizeof(struct mptcp_subflow_info);
1411 : 8 : mfi.size_sfinfo_user = min_t(unsigned int, mfi.size_sfinfo_user,
1412 : : sizeof(struct mptcp_subflow_info));
1413 : 8 : tcpinfoptr = u64_to_user_ptr(mfi.tcp_info);
1414 : :
1415 : 8 : lock_sock(sk);
1416 [ + + ]: 16 : mptcp_for_each_subflow(msk, subflow) {
1417 [ - + ]: 8 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1418 : 8 : struct mptcp_subflow_info sfinfo;
1419 : 8 : struct tcp_info tcp_info;
1420 : :
1421 [ - + ]: 8 : if (sfcount++ >= mfi.size_arrays_user)
1422 : 0 : continue;
1423 : :
1424 : : /* fetch addr/tcp_info only if the user space buffers
1425 : : * are wide enough
1426 : : */
1427 : 8 : memset(&sfinfo, 0, sizeof(sfinfo));
1428 : 8 : sfinfo.id = subflow->subflow_id;
1429 [ + - ]: 8 : if (mfi.size_sfinfo_user >
1430 : : offsetof(struct mptcp_subflow_info, addrs))
1431 : 8 : mptcp_get_sub_addrs(ssk, &sfinfo.addrs);
1432 [ - + - + ]: 16 : if (copy_to_user(sfinfoptr, &sfinfo, mfi.size_sfinfo_user))
1433 : 0 : goto fail_release;
1434 : :
1435 [ + - ]: 8 : if (mfi.size_tcpinfo_user) {
1436 : 8 : tcp_get_info(ssk, &tcp_info);
1437 [ - + ]: 8 : if (copy_to_user(tcpinfoptr, &tcp_info,
1438 [ - + ]: 8 : mfi.size_tcpinfo_user))
1439 : 0 : goto fail_release;
1440 : : }
1441 : :
1442 : 8 : tcpinfoptr += mfi.size_tcpinfo_user;
1443 : 8 : sfinfoptr += mfi.size_sfinfo_user;
1444 : : }
1445 : 8 : release_sock(sk);
1446 : :
1447 : 8 : mfi.num_subflows = sfcount;
1448 [ - + ]: 8 : if (mptcp_put_full_info(&mfi, optval, copylen, optlen))
1449 : : return -EFAULT;
1450 : :
1451 : : return 0;
1452 : :
1453 : 0 : fail_release:
1454 : 0 : release_sock(sk);
1455 : 0 : return -EFAULT;
1456 : : }
1457 : :
1458 : 212 : static int mptcp_put_int_option(struct mptcp_sock *msk, char __user *optval,
1459 : : int __user *optlen, int val)
1460 : : {
1461 : 212 : int len;
1462 : :
1463 [ - + ]: 212 : if (get_user(len, optlen))
1464 : : return -EFAULT;
1465 [ + + ]: 212 : if (len < 0)
1466 : : return -EINVAL;
1467 : :
1468 [ + + + - ]: 212 : if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
1469 : 4 : unsigned char ucval = (unsigned char)val;
1470 : :
1471 : 4 : len = 1;
1472 [ + - ]: 4 : if (put_user(len, optlen))
1473 : 0 : return -EFAULT;
1474 [ + - ]: 4 : if (copy_to_user(optval, &ucval, 1))
1475 : : return -EFAULT;
1476 : : } else {
1477 : 204 : len = min_t(unsigned int, len, sizeof(int));
1478 [ - + ]: 204 : if (put_user(len, optlen))
1479 : : return -EFAULT;
1480 [ - + ]: 204 : if (copy_to_user(optval, &val, len))
1481 : : return -EFAULT;
1482 : : }
1483 : :
1484 : : return 0;
1485 : : }
1486 : :
1487 : 9216 : static int mptcp_getsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
1488 : : char __user *optval, int __user *optlen)
1489 : : {
1490 : 9216 : struct sock *sk = (void *)msk;
1491 : :
1492 [ + - + - : 9216 : switch (optname) {
+ + + + +
+ + ]
1493 : 8994 : case TCP_ULP:
1494 : : case TCP_CONGESTION:
1495 : : case TCP_INFO:
1496 : : case TCP_CC_INFO:
1497 : : case TCP_DEFER_ACCEPT:
1498 : : case TCP_FASTOPEN:
1499 : : case TCP_FASTOPEN_CONNECT:
1500 : : case TCP_FASTOPEN_KEY:
1501 : : case TCP_FASTOPEN_NO_COOKIE:
1502 : 8994 : return mptcp_getsockopt_first_sf_only(msk, SOL_TCP, optname,
1503 : : optval, optlen);
1504 : 0 : case TCP_INQ:
1505 : 0 : return mptcp_put_int_option(msk, optval, optlen, msk->recvmsg_inq);
1506 : 6 : case TCP_CORK:
1507 : 6 : return mptcp_put_int_option(msk, optval, optlen, msk->cork);
1508 : 0 : case TCP_NODELAY:
1509 : 0 : return mptcp_put_int_option(msk, optval, optlen, msk->nodelay);
1510 : 18 : case TCP_KEEPIDLE:
1511 : 18 : return mptcp_put_int_option(msk, optval, optlen,
1512 [ + + ]: 18 : msk->keepalive_idle ? :
1513 : 6 : READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_time) / HZ);
1514 : 18 : case TCP_KEEPINTVL:
1515 : 18 : return mptcp_put_int_option(msk, optval, optlen,
1516 [ + + ]: 18 : msk->keepalive_intvl ? :
1517 : 6 : READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_intvl) / HZ);
1518 : 18 : case TCP_KEEPCNT:
1519 : 18 : return mptcp_put_int_option(msk, optval, optlen,
1520 [ + + ]: 18 : msk->keepalive_cnt ? :
1521 : 6 : READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_probes));
1522 : 12 : case TCP_NOTSENT_LOWAT:
1523 : 12 : return mptcp_put_int_option(msk, optval, optlen, msk->notsent_lowat);
1524 : 120 : case TCP_IS_MPTCP:
1525 : 120 : return mptcp_put_int_option(msk, optval, optlen, 1);
1526 : 24 : case TCP_MAXSEG:
1527 : 24 : return mptcp_getsockopt_first_sf_only(msk, SOL_TCP, optname,
1528 : : optval, optlen);
1529 : : }
1530 : : return -EOPNOTSUPP;
1531 : : }
1532 : :
1533 : 16 : static int mptcp_getsockopt_v4(struct mptcp_sock *msk, int optname,
1534 : : char __user *optval, int __user *optlen)
1535 : : {
1536 : 16 : struct sock *sk = (void *)msk;
1537 : :
1538 [ + - - - : 16 : switch (optname) {
- + - - ]
1539 : : case IP_TOS:
1540 : 12 : return mptcp_put_int_option(msk, optval, optlen, READ_ONCE(inet_sk(sk)->tos));
1541 : 0 : case IP_FREEBIND:
1542 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1543 : 0 : inet_test_bit(FREEBIND, sk));
1544 : 0 : case IP_TRANSPARENT:
1545 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1546 : 0 : inet_test_bit(TRANSPARENT, sk));
1547 : 0 : case IP_BIND_ADDRESS_NO_PORT:
1548 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1549 : 0 : inet_test_bit(BIND_ADDRESS_NO_PORT, sk));
1550 : : case IP_LOCAL_PORT_RANGE:
1551 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1552 : 0 : READ_ONCE(inet_sk(sk)->local_port_range));
1553 : 4 : case IP_RECVERR:
1554 : 4 : return mptcp_put_int_option(msk, optval, optlen,
1555 : 4 : inet_test_bit(RECVERR, sk));
1556 : 0 : case IP_RECVERR_RFC4884:
1557 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1558 : 0 : inet_test_bit(RECVERR_RFC4884, sk));
1559 : : }
1560 : :
1561 : : return -EOPNOTSUPP;
1562 : : }
1563 : :
1564 : 4 : static int mptcp_getsockopt_v6(struct mptcp_sock *msk, int optname,
1565 : : char __user *optval, int __user *optlen)
1566 : : {
1567 : 4 : struct sock *sk = (void *)msk;
1568 : :
1569 [ - - - + : 4 : switch (optname) {
- - ]
1570 : 0 : case IPV6_V6ONLY:
1571 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1572 : 0 : sk->sk_ipv6only);
1573 : 0 : case IPV6_TRANSPARENT:
1574 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1575 : 0 : inet_test_bit(TRANSPARENT, sk));
1576 : 0 : case IPV6_FREEBIND:
1577 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1578 : 0 : inet_test_bit(FREEBIND, sk));
1579 : 4 : case IPV6_RECVERR:
1580 [ + - ]: 4 : if (sk->sk_family != AF_INET6)
1581 : : return -ENOPROTOOPT;
1582 : 4 : return mptcp_put_int_option(msk, optval, optlen,
1583 : 4 : inet6_test_bit(RECVERR6, sk));
1584 : 0 : case IPV6_RECVERR_RFC4884:
1585 [ # # ]: 0 : if (sk->sk_family != AF_INET6)
1586 : : return -ENOPROTOOPT;
1587 : 0 : return mptcp_put_int_option(msk, optval, optlen,
1588 : 0 : inet6_test_bit(RECVERR6_RFC4884, sk));
1589 : : }
1590 : :
1591 : : return -EOPNOTSUPP;
1592 : : }
1593 : :
1594 : 313 : static int mptcp_getsockopt_sol_mptcp(struct mptcp_sock *msk, int optname,
1595 : : char __user *optval, int __user *optlen)
1596 : : {
1597 [ + + + + : 313 : switch (optname) {
- ]
1598 : 33 : case MPTCP_INFO:
1599 : 33 : return mptcp_getsockopt_info(msk, optval, optlen);
1600 : 8 : case MPTCP_FULL_INFO:
1601 : 8 : return mptcp_getsockopt_full_info(msk, optval, optlen);
1602 : 128 : case MPTCP_TCPINFO:
1603 : 128 : return mptcp_getsockopt_tcpinfo(msk, optval, optlen);
1604 : 144 : case MPTCP_SUBFLOW_ADDRS:
1605 : 144 : return mptcp_getsockopt_subflow_addrs(msk, optval, optlen);
1606 : : }
1607 : :
1608 : : return -EOPNOTSUPP;
1609 : : }
1610 : :
1611 : 9813 : int mptcp_getsockopt(struct sock *sk, int level, int optname,
1612 : : char __user *optval, int __user *option)
1613 : : {
1614 [ - + ]: 9813 : struct mptcp_sock *msk = mptcp_sk(sk);
1615 : 9813 : struct sock *ssk;
1616 : :
1617 [ - + - - ]: 9813 : pr_debug("msk=%p\n", msk);
1618 : :
1619 : : /* @@ the meaning of setsockopt() when the socket is connected and
1620 : : * there are multiple subflows is not yet defined. It is up to the
1621 : : * MPTCP-level socket to configure the subflows until the subflow
1622 : : * is in TCP fallback, when socket options are passed through
1623 : : * to the one remaining subflow.
1624 : : */
1625 : 9813 : lock_sock(sk);
1626 : 9813 : ssk = __mptcp_tcp_fallback(msk);
1627 : 9813 : release_sock(sk);
1628 [ + + ]: 9813 : if (ssk)
1629 : 264 : return tcp_getsockopt(ssk, level, optname, optval, option);
1630 : :
1631 [ + + ]: 9549 : if (level == SOL_IP)
1632 : 16 : return mptcp_getsockopt_v4(msk, optname, optval, option);
1633 [ + + ]: 9533 : if (level == SOL_IPV6)
1634 : 4 : return mptcp_getsockopt_v6(msk, optname, optval, option);
1635 [ + + ]: 9529 : if (level == SOL_TCP)
1636 : 9216 : return mptcp_getsockopt_sol_tcp(msk, optname, optval, option);
1637 [ + - ]: 313 : if (level == SOL_MPTCP)
1638 : 313 : return mptcp_getsockopt_sol_mptcp(msk, optname, optval, option);
1639 : : return -EOPNOTSUPP;
1640 : : }
1641 : :
1642 : 52 : static void sync_socket_options(struct mptcp_sock *msk, struct sock *ssk)
1643 : : {
1644 : 52 : static const unsigned int tx_rx_locks = SOCK_RCVBUF_LOCK | SOCK_SNDBUF_LOCK;
1645 : 52 : unsigned long mask = MPTCP_INET_FLAGS_MASK;
1646 : 52 : struct sock *sk = (struct sock *)msk;
1647 : 52 : unsigned long src;
1648 : 52 : bool keep_open;
1649 : 52 : int b;
1650 : :
1651 : 52 : keep_open = sock_flag(sk, SOCK_KEEPOPEN);
1652 [ + - ]: 52 : if (ssk->sk_prot->keepalive)
1653 : 52 : ssk->sk_prot->keepalive(ssk, keep_open);
1654 : 52 : sock_valbool_flag(ssk, SOCK_KEEPOPEN, keep_open);
1655 : :
1656 : 52 : ssk->sk_priority = sk->sk_priority;
1657 : 52 : ssk->sk_bound_dev_if = sk->sk_bound_dev_if;
1658 : 52 : ssk->sk_incoming_cpu = sk->sk_incoming_cpu;
1659 : 52 : ssk->sk_ipv6only = sk->sk_ipv6only;
1660 : 52 : __ip_sock_set_tos(ssk, inet_sk(sk)->tos);
1661 : :
1662 [ - + ]: 52 : if (sk->sk_userlocks & tx_rx_locks) {
1663 : 0 : ssk->sk_userlocks |= sk->sk_userlocks & tx_rx_locks;
1664 [ # # ]: 0 : if (sk->sk_userlocks & SOCK_SNDBUF_LOCK) {
1665 : 0 : WRITE_ONCE(ssk->sk_sndbuf, sk->sk_sndbuf);
1666 : 0 : mptcp_subflow_ctx(ssk)->cached_sndbuf = sk->sk_sndbuf;
1667 : : }
1668 [ # # ]: 0 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
1669 : 0 : __mptcp_subflow_set_rcvbuf(ssk, sk->sk_rcvbuf);
1670 : : }
1671 : :
1672 [ - + ]: 52 : if (sock_flag(sk, SOCK_LINGER)) {
1673 : 0 : ssk->sk_lingertime = sk->sk_lingertime;
1674 : 0 : sock_set_flag(ssk, SOCK_LINGER);
1675 : : } else {
1676 : 52 : sock_reset_flag(ssk, SOCK_LINGER);
1677 : : }
1678 : :
1679 [ + + ]: 52 : if (sk->sk_mark != ssk->sk_mark) {
1680 : 30 : ssk->sk_mark = sk->sk_mark;
1681 : 30 : sk_dst_reset(ssk);
1682 : : }
1683 : :
1684 : 52 : sock_valbool_flag(ssk, SOCK_DBG, sock_flag(sk, SOCK_DBG));
1685 : :
1686 [ + - ]: 52 : if (inet_csk(sk)->icsk_ca_ops != inet_csk(ssk)->icsk_ca_ops)
1687 : 52 : tcp_set_congestion_control(ssk, msk->ca_name, false, true);
1688 : 52 : __tcp_sock_set_cork(ssk, !!msk->cork);
1689 : 52 : __tcp_sock_set_nodelay(ssk, !!msk->nodelay);
1690 : 52 : tcp_sock_set_keepidle_locked(ssk, msk->keepalive_idle);
1691 : 52 : tcp_sock_set_keepintvl(ssk, msk->keepalive_intvl);
1692 : 52 : tcp_sock_set_keepcnt(ssk, msk->keepalive_cnt);
1693 : 52 : tcp_sock_set_maxseg(ssk, msk->maxseg);
1694 : :
1695 : 52 : src = READ_ONCE(inet_sk(sk)->inet_flags);
1696 : :
1697 : : /* RECVERR6 bits are only read on AF_INET6 sockets; copying them onto a
1698 : : * v4 subflow is dead state and diverges from the SOL_IPV6 skip in
1699 : : * mptcp_setsockopt_all_sf().
1700 : : */
1701 [ + + ]: 52 : if (ssk->sk_family != AF_INET6)
1702 : 32 : mask &= ~(BIT(INET_FLAGS_RECVERR6) |
1703 : : BIT(INET_FLAGS_RECVERR6_RFC4884));
1704 : :
1705 [ + - + - ]: 652 : for_each_set_bit(b, &mask, BITS_PER_LONG)
1706 [ - + - - : 300 : assign_bit(b, &inet_sk(ssk)->inet_flags, src & BIT(b));
- + ]
[ - + - + ]
1707 : :
1708 : 52 : WRITE_ONCE(inet_sk(ssk)->local_port_range, READ_ONCE(inet_sk(sk)->local_port_range));
1709 : 52 : }
1710 : :
1711 : 4886 : void mptcp_sockopt_sync_locked(struct mptcp_sock *msk, struct sock *ssk)
1712 : : {
1713 [ - + ]: 4886 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1714 : :
1715 : 4886 : msk_owned_by_me(msk);
1716 : :
1717 : 4886 : ssk->sk_rcvlowat = 0;
1718 : :
1719 : : /* subflows must ignore any latency-related settings: will not affect
1720 : : * the user-space - only the msk is relevant - but will foul the
1721 : : * mptcp scheduler
1722 : : */
1723 [ - + ]: 4886 : tcp_sk(ssk)->notsent_lowat = UINT_MAX;
1724 : :
1725 [ + + ]: 4886 : if (READ_ONCE(subflow->setsockopt_seq) != msk->setsockopt_seq) {
1726 : 52 : sync_socket_options(msk, ssk);
1727 : :
1728 : 52 : subflow->setsockopt_seq = msk->setsockopt_seq;
1729 : : }
1730 : 4886 : }
1731 : :
1732 : : /* unfortunately this is different enough from the tcp version so
1733 : : * that we can't factor it out
1734 : : */
1735 : 0 : int mptcp_set_rcvlowat(struct sock *sk, int val)
1736 : : {
1737 : 0 : struct mptcp_subflow_context *subflow;
1738 : 0 : int space, cap;
1739 : :
1740 : : /* bpf can land here with a wrong sk type */
1741 [ # # ]: 0 : if (sk->sk_protocol == IPPROTO_TCP)
1742 : : return -EINVAL;
1743 : :
1744 [ # # ]: 0 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
1745 : 0 : cap = sk->sk_rcvbuf >> 1;
1746 : : else
1747 : 0 : cap = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2]) >> 1;
1748 : 0 : val = min(val, cap);
1749 [ # # ]: 0 : WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
1750 : :
1751 : : /* Check if we need to signal EPOLLIN right now */
1752 [ # # ]: 0 : if (mptcp_epollin_ready(sk))
1753 : 0 : sk->sk_data_ready(sk);
1754 : :
1755 [ # # ]: 0 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
1756 : : return 0;
1757 : :
1758 : 0 : space = mptcp_space_from_win(sk, val);
1759 [ # # ]: 0 : if (space <= sk->sk_rcvbuf)
1760 : : return 0;
1761 : :
1762 : : /* propagate the rcvbuf changes to all the subflows */
1763 : 0 : WRITE_ONCE(sk->sk_rcvbuf, space);
1764 [ # # # # : 0 : mptcp_for_each_subflow(mptcp_sk(sk), subflow) {
# # ]
1765 : 0 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1766 : 0 : bool slow;
1767 : :
1768 : 0 : slow = lock_sock_fast(ssk);
1769 : 0 : WRITE_ONCE(ssk->sk_rcvbuf, space);
1770 [ # # ]: 0 : WRITE_ONCE(tcp_sk(ssk)->window_clamp, val);
1771 : 0 : unlock_sock_fast(ssk, slow);
1772 : : }
1773 : : return 0;
1774 : : }
|
