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