// SPDX-License-Identifier: GPL-2.0
/* Multipath TCP
 *
 * Copyright (c) 2021, Red Hat.
 */

#define pr_fmt(fmt) "MPTCP: " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <net/sock.h>
#include <net/protocol.h>
#include <net/tcp.h>
#include <net/mptcp.h>
#include "protocol.h"

#define MIN_INFO_OPTLEN_SIZE            16
#define MIN_FULL_INFO_OPTLEN_SIZE       40

static struct sock *__mptcp_tcp_fallback(struct mptcp_sock *msk)
{
        msk_owned_by_me(msk);

        if (likely(!__mptcp_check_fallback(msk)))
                return NULL;

        return msk->first;
}

static u32 sockopt_seq_reset(const struct sock *sk)
{
        sock_owned_by_me(sk);

        /* Highbits contain state.  Allows to distinguish sockopt_seq
         * of listener and established:
         * s0 = new_listener()
         * sockopt(s0) - seq is 1
         * s1 = accept(s0) - s1 inherits seq 1 if listener sk (s0)
         * sockopt(s0) - seq increments to 2 on s0
         * sockopt(s1) // seq increments to 2 on s1 (different option)
         * new ssk completes join, inherits options from s0 // seq 2
         * Needs sync from mptcp join logic, but ssk->seq == msk->seq
         *
         * Set High order bits to sk_state so ssk->seq == msk->seq test
         * will fail.
         */

        return (u32)sk->sk_state << 24u;
}

static void sockopt_seq_inc(struct mptcp_sock *msk)
{
        u32 seq = (msk->setsockopt_seq + 1) & 0x00ffffff;

        msk->setsockopt_seq = sockopt_seq_reset((struct sock *)msk) + seq;
}

static int mptcp_get_int_option(struct mptcp_sock *msk, sockptr_t optval,
                                unsigned int optlen, int *val)
{
        if (optlen < sizeof(int))
                return -EINVAL;

        if (copy_from_sockptr(val, optval, sizeof(*val)))
                return -EFAULT;

        return 0;
}

static void mptcp_sol_socket_sync_intval(struct mptcp_sock *msk, int optname, int val)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;

        lock_sock(sk);
        sockopt_seq_inc(msk);

        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                bool slow = lock_sock_fast(ssk);

                switch (optname) {
                case SO_DEBUG:
                        sock_valbool_flag(ssk, SOCK_DBG, !!val);
                        break;
                case SO_KEEPALIVE:
                        if (ssk->sk_prot->keepalive)
                                ssk->sk_prot->keepalive(ssk, !!val);
                        sock_valbool_flag(ssk, SOCK_KEEPOPEN, !!val);
                        break;
                case SO_PRIORITY:
                        WRITE_ONCE(ssk->sk_priority, val);
                        break;
                case SO_SNDBUF:
                case SO_SNDBUFFORCE:
                        ssk->sk_userlocks |= SOCK_SNDBUF_LOCK;
                        WRITE_ONCE(ssk->sk_sndbuf, sk->sk_sndbuf);
                        mptcp_subflow_ctx(ssk)->cached_sndbuf = sk->sk_sndbuf;
                        break;
                case SO_RCVBUF:
                case SO_RCVBUFFORCE:
                        ssk->sk_userlocks |= SOCK_RCVBUF_LOCK;
                        WRITE_ONCE(ssk->sk_rcvbuf, sk->sk_rcvbuf);
                        break;
                case SO_MARK:
                        if (READ_ONCE(ssk->sk_mark) != sk->sk_mark) {
                                WRITE_ONCE(ssk->sk_mark, sk->sk_mark);
                                sk_dst_reset(ssk);
                        }
                        break;
                case SO_INCOMING_CPU:
                        WRITE_ONCE(ssk->sk_incoming_cpu, val);
                        break;
                }

                subflow->setsockopt_seq = msk->setsockopt_seq;
                unlock_sock_fast(ssk, slow);
        }

        release_sock(sk);
}

static int mptcp_sol_socket_intval(struct mptcp_sock *msk, int optname, int val)
{
        sockptr_t optval = KERNEL_SOCKPTR(&val);
        struct sock *sk = (struct sock *)msk;
        int ret;

        ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
                              optval, sizeof(val));
        if (ret)
                return ret;

        mptcp_sol_socket_sync_intval(msk, optname, val);
        return 0;
}

static void mptcp_so_incoming_cpu(struct mptcp_sock *msk, int val)
{
        struct sock *sk = (struct sock *)msk;

        WRITE_ONCE(sk->sk_incoming_cpu, val);

        mptcp_sol_socket_sync_intval(msk, SO_INCOMING_CPU, val);
}

static int mptcp_setsockopt_sol_socket_tstamp(struct mptcp_sock *msk, int optname, int val)
{
        sockptr_t optval = KERNEL_SOCKPTR(&val);
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        int ret;

        ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
                              optval, sizeof(val));
        if (ret)
                return ret;

        lock_sock(sk);
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                bool slow = lock_sock_fast(ssk);

                sock_set_timestamp(sk, optname, !!val);
                unlock_sock_fast(ssk, slow);
        }

        release_sock(sk);
        return 0;
}

static int mptcp_setsockopt_sol_socket_int(struct mptcp_sock *msk, int optname,
                                           sockptr_t optval,
                                           unsigned int optlen)
{
        int val, ret;

        ret = mptcp_get_int_option(msk, optval, optlen, &val);
        if (ret)
                return ret;

        switch (optname) {
        case SO_KEEPALIVE:
        case SO_DEBUG:
        case SO_MARK:
        case SO_PRIORITY:
        case SO_SNDBUF:
        case SO_SNDBUFFORCE:
        case SO_RCVBUF:
        case SO_RCVBUFFORCE:
                return mptcp_sol_socket_intval(msk, optname, val);
        case SO_INCOMING_CPU:
                mptcp_so_incoming_cpu(msk, val);
                return 0;
        case SO_TIMESTAMP_OLD:
        case SO_TIMESTAMP_NEW:
        case SO_TIMESTAMPNS_OLD:
        case SO_TIMESTAMPNS_NEW:
                return mptcp_setsockopt_sol_socket_tstamp(msk, optname, val);
        }

        return -ENOPROTOOPT;
}

static int mptcp_setsockopt_sol_socket_timestamping(struct mptcp_sock *msk,
                                                    int optname,
                                                    sockptr_t optval,
                                                    unsigned int optlen)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        struct so_timestamping timestamping;
        int ret;

        if (optlen == sizeof(timestamping)) {
                if (copy_from_sockptr(&timestamping, optval,
                                      sizeof(timestamping)))
                        return -EFAULT;
        } else if (optlen == sizeof(int)) {
                memset(&timestamping, 0, sizeof(timestamping));

                if (copy_from_sockptr(&timestamping.flags, optval, sizeof(int)))
                        return -EFAULT;
        } else {
                return -EINVAL;
        }

        ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
                              KERNEL_SOCKPTR(&timestamping),
                              sizeof(timestamping));
        if (ret)
                return ret;

        lock_sock(sk);

        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                bool slow = lock_sock_fast(ssk);

                sock_set_timestamping(sk, optname, timestamping);
                unlock_sock_fast(ssk, slow);
        }

        release_sock(sk);

        return 0;
}

static int mptcp_setsockopt_sol_socket_linger(struct mptcp_sock *msk, sockptr_t optval,
                                              unsigned int optlen)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        struct linger ling;
        sockptr_t kopt;
        int ret;

        if (optlen < sizeof(ling))
                return -EINVAL;

        if (copy_from_sockptr(&ling, optval, sizeof(ling)))
                return -EFAULT;

        kopt = KERNEL_SOCKPTR(&ling);
        ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, SO_LINGER, kopt, sizeof(ling));
        if (ret)
                return ret;

        lock_sock(sk);
        sockopt_seq_inc(msk);
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                bool slow = lock_sock_fast(ssk);

                if (!ling.l_onoff) {
                        sock_reset_flag(ssk, SOCK_LINGER);
                } else {
                        ssk->sk_lingertime = sk->sk_lingertime;
                        sock_set_flag(ssk, SOCK_LINGER);
                }

                subflow->setsockopt_seq = msk->setsockopt_seq;
                unlock_sock_fast(ssk, slow);
        }

        release_sock(sk);
        return 0;
}

static int mptcp_setsockopt_sol_socket(struct mptcp_sock *msk, int optname,
                                       sockptr_t optval, unsigned int optlen)
{
        struct sock *sk = (struct sock *)msk;
        struct sock *ssk;
        int ret;

        switch (optname) {
        case SO_REUSEPORT:
        case SO_REUSEADDR:
        case SO_BINDTODEVICE:
        case SO_BINDTOIFINDEX:
                lock_sock(sk);
                ssk = __mptcp_nmpc_sk(msk);
                if (IS_ERR(ssk)) {
                        release_sock(sk);
                        return PTR_ERR(ssk);
                }

                ret = sk_setsockopt(ssk, SOL_SOCKET, optname, optval, optlen);
                if (ret == 0) {
                        if (optname == SO_REUSEPORT)
                                sk->sk_reuseport = ssk->sk_reuseport;
                        else if (optname == SO_REUSEADDR)
                                sk->sk_reuse = ssk->sk_reuse;
                        else if (optname == SO_BINDTODEVICE)
                                sk->sk_bound_dev_if = ssk->sk_bound_dev_if;
                        else if (optname == SO_BINDTOIFINDEX)
                                sk->sk_bound_dev_if = ssk->sk_bound_dev_if;
                }
                release_sock(sk);
                return ret;
        case SO_KEEPALIVE:
        case SO_PRIORITY:
        case SO_SNDBUF:
        case SO_SNDBUFFORCE:
        case SO_RCVBUF:
        case SO_RCVBUFFORCE:
        case SO_MARK:
        case SO_INCOMING_CPU:
        case SO_DEBUG:
        case SO_TIMESTAMP_OLD:
        case SO_TIMESTAMP_NEW:
        case SO_TIMESTAMPNS_OLD:
        case SO_TIMESTAMPNS_NEW:
                return mptcp_setsockopt_sol_socket_int(msk, optname, optval,
                                                       optlen);
        case SO_TIMESTAMPING_OLD:
        case SO_TIMESTAMPING_NEW:
                return mptcp_setsockopt_sol_socket_timestamping(msk, optname,
                                                                optval, optlen);
        case SO_LINGER:
                return mptcp_setsockopt_sol_socket_linger(msk, optval, optlen);
        case SO_RCVLOWAT:
        case SO_RCVTIMEO_OLD:
        case SO_RCVTIMEO_NEW:
        case SO_SNDTIMEO_OLD:
        case SO_SNDTIMEO_NEW:
        case SO_BUSY_POLL:
        case SO_PREFER_BUSY_POLL:
        case SO_BUSY_POLL_BUDGET:
                /* No need to copy: only relevant for msk */
                return sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname, optval, optlen);
        case SO_NO_CHECK:
        case SO_DONTROUTE:
        case SO_BROADCAST:
        case SO_BSDCOMPAT:
        case SO_PASSCRED:
        case SO_PASSPIDFD:
        case SO_PASSSEC:
        case SO_RXQ_OVFL:
        case SO_WIFI_STATUS:
        case SO_NOFCS:
        case SO_SELECT_ERR_QUEUE:
                return 0;
        }

        /* SO_OOBINLINE is not supported, let's avoid the related mess
         * SO_ATTACH_FILTER, SO_ATTACH_BPF, SO_ATTACH_REUSEPORT_CBPF,
         * SO_DETACH_REUSEPORT_BPF, SO_DETACH_FILTER, SO_LOCK_FILTER,
         * we must be careful with subflows
         *
         * SO_ATTACH_REUSEPORT_EBPF is not supported, at it checks
         * explicitly the sk_protocol field
         *
         * SO_PEEK_OFF is unsupported, as it is for plain TCP
         * SO_MAX_PACING_RATE is unsupported, we must be careful with subflows
         * SO_CNX_ADVICE is currently unsupported, could possibly be relevant,
         * but likely needs careful design
         *
         * SO_ZEROCOPY is currently unsupported, TODO in sndmsg
         * SO_TXTIME is currently unsupported
         */

        return -EOPNOTSUPP;
}

static int mptcp_setsockopt_v6(struct mptcp_sock *msk, int optname,
                               sockptr_t optval, unsigned int optlen)
{
        struct sock *sk = (struct sock *)msk;
        int ret = -EOPNOTSUPP;
        struct sock *ssk;

        switch (optname) {
        case IPV6_V6ONLY:
        case IPV6_TRANSPARENT:
        case IPV6_FREEBIND:
                lock_sock(sk);
                ssk = __mptcp_nmpc_sk(msk);
                if (IS_ERR(ssk)) {
                        release_sock(sk);
                        return PTR_ERR(ssk);
                }

                ret = tcp_setsockopt(ssk, SOL_IPV6, optname, optval, optlen);
                if (ret != 0) {
                        release_sock(sk);
                        return ret;
                }

                sockopt_seq_inc(msk);

                switch (optname) {
                case IPV6_V6ONLY:
                        sk->sk_ipv6only = ssk->sk_ipv6only;
                        break;
                case IPV6_TRANSPARENT:
                        inet_assign_bit(TRANSPARENT, sk,
                                        inet_test_bit(TRANSPARENT, ssk));
                        break;
                case IPV6_FREEBIND:
                        inet_assign_bit(FREEBIND, sk,
                                        inet_test_bit(FREEBIND, ssk));
                        break;
                }

                release_sock(sk);
                break;
        }

        return ret;
}

static bool mptcp_supported_sockopt(int level, int optname)
{
        if (level == SOL_IP) {
                switch (optname) {
                /* should work fine */
                case IP_FREEBIND:
                case IP_TRANSPARENT:
                case IP_BIND_ADDRESS_NO_PORT:
                case IP_LOCAL_PORT_RANGE:

                /* the following are control cmsg related */
                case IP_PKTINFO:
                case IP_RECVTTL:
                case IP_RECVTOS:
                case IP_RECVOPTS:
                case IP_RETOPTS:
                case IP_PASSSEC:
                case IP_RECVORIGDSTADDR:
                case IP_CHECKSUM:
                case IP_RECVFRAGSIZE:

                /* common stuff that need some love */
                case IP_TOS:
                case IP_TTL:
                case IP_MTU_DISCOVER:
                case IP_RECVERR:

                /* possibly less common may deserve some love */
                case IP_MINTTL:

                /* the following is apparently a no-op for plain TCP */
                case IP_RECVERR_RFC4884:
                        return true;
                }

                /* IP_OPTIONS is not supported, needs subflow care */
                /* IP_HDRINCL, IP_NODEFRAG are not supported, RAW specific */
                /* IP_MULTICAST_TTL, IP_MULTICAST_LOOP, IP_UNICAST_IF,
                 * IP_ADD_MEMBERSHIP, IP_ADD_SOURCE_MEMBERSHIP, IP_DROP_MEMBERSHIP,
                 * IP_DROP_SOURCE_MEMBERSHIP, IP_BLOCK_SOURCE, IP_UNBLOCK_SOURCE,
                 * MCAST_JOIN_GROUP, MCAST_LEAVE_GROUP MCAST_JOIN_SOURCE_GROUP,
                 * MCAST_LEAVE_SOURCE_GROUP, MCAST_BLOCK_SOURCE, MCAST_UNBLOCK_SOURCE,
                 * MCAST_MSFILTER, IP_MULTICAST_ALL are not supported, better not deal
                 * with mcast stuff
                 */
                /* IP_IPSEC_POLICY, IP_XFRM_POLICY are nut supported, unrelated here */
                return false;
        }
        if (level == SOL_IPV6) {
                switch (optname) {
                case IPV6_V6ONLY:

                /* the following are control cmsg related */
                case IPV6_RECVPKTINFO:
                case IPV6_2292PKTINFO:
                case IPV6_RECVHOPLIMIT:
                case IPV6_2292HOPLIMIT:
                case IPV6_RECVRTHDR:
                case IPV6_2292RTHDR:
                case IPV6_RECVHOPOPTS:
                case IPV6_2292HOPOPTS:
                case IPV6_RECVDSTOPTS:
                case IPV6_2292DSTOPTS:
                case IPV6_RECVTCLASS:
                case IPV6_FLOWINFO:
                case IPV6_RECVPATHMTU:
                case IPV6_RECVORIGDSTADDR:
                case IPV6_RECVFRAGSIZE:

                /* the following ones need some love but are quite common */
                case IPV6_TCLASS:
                case IPV6_TRANSPARENT:
                case IPV6_FREEBIND:
                case IPV6_PKTINFO:
                case IPV6_2292PKTOPTIONS:
                case IPV6_UNICAST_HOPS:
                case IPV6_MTU_DISCOVER:
                case IPV6_MTU:
                case IPV6_RECVERR:
                case IPV6_FLOWINFO_SEND:
                case IPV6_FLOWLABEL_MGR:
                case IPV6_MINHOPCOUNT:
                case IPV6_DONTFRAG:
                case IPV6_AUTOFLOWLABEL:

                /* the following one is a no-op for plain TCP */
                case IPV6_RECVERR_RFC4884:
                        return true;
                }

                /* IPV6_HOPOPTS, IPV6_RTHDRDSTOPTS, IPV6_RTHDR, IPV6_DSTOPTS are
                 * not supported
                 */
                /* IPV6_MULTICAST_HOPS, IPV6_MULTICAST_LOOP, IPV6_UNICAST_IF,
                 * IPV6_MULTICAST_IF, IPV6_ADDRFORM,
                 * IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_JOIN_ANYCAST,
                 * IPV6_LEAVE_ANYCAST, IPV6_MULTICAST_ALL, MCAST_JOIN_GROUP, MCAST_LEAVE_GROUP,
                 * MCAST_JOIN_SOURCE_GROUP, MCAST_LEAVE_SOURCE_GROUP,
                 * MCAST_BLOCK_SOURCE, MCAST_UNBLOCK_SOURCE, MCAST_MSFILTER
                 * are not supported better not deal with mcast
                 */
                /* IPV6_ROUTER_ALERT, IPV6_ROUTER_ALERT_ISOLATE are not supported, since are evil */

                /* IPV6_IPSEC_POLICY, IPV6_XFRM_POLICY are not supported */
                /* IPV6_ADDR_PREFERENCES is not supported, we must be careful with subflows */
                return false;
        }
        if (level == SOL_TCP) {
                switch (optname) {
                /* the following are no-op or should work just fine */
                case TCP_THIN_DUPACK:
                case TCP_DEFER_ACCEPT:

                /* the following need some love */
                case TCP_MAXSEG:
                case TCP_NODELAY:
                case TCP_THIN_LINEAR_TIMEOUTS:
                case TCP_CONGESTION:
                case TCP_CORK:
                case TCP_KEEPIDLE:
                case TCP_KEEPINTVL:
                case TCP_KEEPCNT:
                case TCP_SYNCNT:
                case TCP_SAVE_SYN:
                case TCP_LINGER2:
                case TCP_WINDOW_CLAMP:
                case TCP_QUICKACK:
                case TCP_USER_TIMEOUT:
                case TCP_TIMESTAMP:
                case TCP_NOTSENT_LOWAT:
                case TCP_TX_DELAY:
                case TCP_INQ:
                case TCP_FASTOPEN:
                case TCP_FASTOPEN_CONNECT:
                case TCP_FASTOPEN_KEY:
                case TCP_FASTOPEN_NO_COOKIE:
                        return true;
                }

                /* TCP_MD5SIG, TCP_MD5SIG_EXT are not supported, MD5 is not compatible with MPTCP */

                /* TCP_REPAIR, TCP_REPAIR_QUEUE, TCP_QUEUE_SEQ, TCP_REPAIR_OPTIONS,
                 * TCP_REPAIR_WINDOW are not supported, better avoid this mess
                 */
        }
        return false;
}

static int mptcp_setsockopt_sol_tcp_congestion(struct mptcp_sock *msk, sockptr_t optval,
                                               unsigned int optlen)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        char name[TCP_CA_NAME_MAX];
        bool cap_net_admin;
        int ret;

        if (optlen < 1)
                return -EINVAL;

        ret = strncpy_from_sockptr(name, optval,
                                   min_t(long, TCP_CA_NAME_MAX - 1, optlen));
        if (ret < 0)
                return -EFAULT;

        name[ret] = 0;

        cap_net_admin = ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN);

        ret = 0;
        lock_sock(sk);
        sockopt_seq_inc(msk);
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                int err;

                lock_sock(ssk);
                err = tcp_set_congestion_control(ssk, name, true, cap_net_admin);
                if (err < 0 && ret == 0)
                        ret = err;
                subflow->setsockopt_seq = msk->setsockopt_seq;
                release_sock(ssk);
        }

        if (ret == 0)
                strscpy(msk->ca_name, name, sizeof(msk->ca_name));

        release_sock(sk);
        return ret;
}

static int __mptcp_setsockopt_set_val(struct mptcp_sock *msk, int max,
                                      int (*set_val)(struct sock *, int),
                                      int *msk_val, int val)
{
        struct mptcp_subflow_context *subflow;
        int err = 0;

        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                int ret;

                lock_sock(ssk);
                ret = set_val(ssk, val);
                err = err ? : ret;
                release_sock(ssk);
        }

        if (!err) {
                *msk_val = val;
                sockopt_seq_inc(msk);
        }

        return err;
}

static int __mptcp_setsockopt_sol_tcp_cork(struct mptcp_sock *msk, int val)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;

        sockopt_seq_inc(msk);
        msk->cork = !!val;
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);

                lock_sock(ssk);
                __tcp_sock_set_cork(ssk, !!val);
                release_sock(ssk);
        }
        if (!val)
                mptcp_check_and_set_pending(sk);

        return 0;
}

static int __mptcp_setsockopt_sol_tcp_nodelay(struct mptcp_sock *msk, int val)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;

        sockopt_seq_inc(msk);
        msk->nodelay = !!val;
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);

                lock_sock(ssk);
                __tcp_sock_set_nodelay(ssk, !!val);
                release_sock(ssk);
        }
        if (val)
                mptcp_check_and_set_pending(sk);
        return 0;
}

static int mptcp_setsockopt_sol_ip_set(struct mptcp_sock *msk, int optname,
                                       sockptr_t optval, unsigned int optlen)
{
        struct sock *sk = (struct sock *)msk;
        struct sock *ssk;
        int err;

        err = ip_setsockopt(sk, SOL_IP, optname, optval, optlen);
        if (err != 0)
                return err;

        lock_sock(sk);

        ssk = __mptcp_nmpc_sk(msk);
        if (IS_ERR(ssk)) {
                release_sock(sk);
                return PTR_ERR(ssk);
        }

        switch (optname) {
        case IP_FREEBIND:
                inet_assign_bit(FREEBIND, ssk, inet_test_bit(FREEBIND, sk));
                break;
        case IP_TRANSPARENT:
                inet_assign_bit(TRANSPARENT, ssk,
                                inet_test_bit(TRANSPARENT, sk));
                break;
        case IP_BIND_ADDRESS_NO_PORT:
                inet_assign_bit(BIND_ADDRESS_NO_PORT, ssk,
                                inet_test_bit(BIND_ADDRESS_NO_PORT, sk));
                break;
        case IP_LOCAL_PORT_RANGE:
                WRITE_ONCE(inet_sk(ssk)->local_port_range,
                           READ_ONCE(inet_sk(sk)->local_port_range));
                break;
        default:
                release_sock(sk);
                WARN_ON_ONCE(1);
                return -EOPNOTSUPP;
        }

        sockopt_seq_inc(msk);
        release_sock(sk);
        return 0;
}

static int mptcp_setsockopt_v4_set_tos(struct mptcp_sock *msk, int optname,
                                       sockptr_t optval, unsigned int optlen)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        int err, val;

        err = ip_setsockopt(sk, SOL_IP, optname, optval, optlen);

        if (err != 0)
                return err;

        lock_sock(sk);
        sockopt_seq_inc(msk);
        val = READ_ONCE(inet_sk(sk)->tos);
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                bool slow;

                slow = lock_sock_fast(ssk);
                __ip_sock_set_tos(ssk, val);
                unlock_sock_fast(ssk, slow);
        }
        release_sock(sk);

        return 0;
}

static int mptcp_setsockopt_v4(struct mptcp_sock *msk, int optname,
                               sockptr_t optval, unsigned int optlen)
{
        switch (optname) {
        case IP_FREEBIND:
        case IP_TRANSPARENT:
        case IP_BIND_ADDRESS_NO_PORT:
        case IP_LOCAL_PORT_RANGE:
                return mptcp_setsockopt_sol_ip_set(msk, optname, optval, optlen);
        case IP_TOS:
                return mptcp_setsockopt_v4_set_tos(msk, optname, optval, optlen);
        }

        return -EOPNOTSUPP;
}

static int mptcp_setsockopt_first_sf_only(struct mptcp_sock *msk, int level, int optname,
                                          sockptr_t optval, unsigned int optlen)
{
        struct sock *sk = (struct sock *)msk;
        struct sock *ssk;
        int ret;

        /* Limit to first subflow, before the connection establishment */
        lock_sock(sk);
        ssk = __mptcp_nmpc_sk(msk);
        if (IS_ERR(ssk)) {
                ret = PTR_ERR(ssk);
                goto unlock;
        }

        ret = tcp_setsockopt(ssk, level, optname, optval, optlen);

unlock:
        release_sock(sk);
        return ret;
}

static int mptcp_setsockopt_all_sf(struct mptcp_sock *msk, int level,
                                   int optname, sockptr_t optval,
                                   unsigned int optlen)
{
        struct mptcp_subflow_context *subflow;
        int ret = 0;

        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);

                ret = tcp_setsockopt(ssk, level, optname, optval, optlen);
                if (ret)
                        break;
        }
        return ret;
}

static int mptcp_setsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
                                    sockptr_t optval, unsigned int optlen)
{
        struct sock *sk = (void *)msk;
        int ret, val;

        switch (optname) {
        case TCP_ULP:
                return -EOPNOTSUPP;
        case TCP_CONGESTION:
                return mptcp_setsockopt_sol_tcp_congestion(msk, optval, optlen);
        case TCP_DEFER_ACCEPT:
                /* See tcp.c: TCP_DEFER_ACCEPT does not fail */
                mptcp_setsockopt_first_sf_only(msk, SOL_TCP, optname, optval, optlen);
                return 0;
        case TCP_FASTOPEN:
        case TCP_FASTOPEN_CONNECT:
        case TCP_FASTOPEN_KEY:
        case TCP_FASTOPEN_NO_COOKIE:
                return mptcp_setsockopt_first_sf_only(msk, SOL_TCP, optname,
                                                      optval, optlen);
        }

        ret = mptcp_get_int_option(msk, optval, optlen, &val);
        if (ret)
                return ret;

        lock_sock(sk);
        switch (optname) {
        case TCP_INQ:
                if (val < 0 || val > 1)
                        ret = -EINVAL;
                else
                        msk->recvmsg_inq = !!val;
                break;
        case TCP_NOTSENT_LOWAT:
                WRITE_ONCE(msk->notsent_lowat, val);
                mptcp_write_space(sk);
                break;
        case TCP_CORK:
                ret = __mptcp_setsockopt_sol_tcp_cork(msk, val);
                break;
        case TCP_NODELAY:
                ret = __mptcp_setsockopt_sol_tcp_nodelay(msk, val);
                break;
        case TCP_KEEPIDLE:
                ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPIDLE,
                                                 &tcp_sock_set_keepidle_locked,
                                                 &msk->keepalive_idle, val);
                break;
        case TCP_KEEPINTVL:
                ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPINTVL,
                                                 &tcp_sock_set_keepintvl,
                                                 &msk->keepalive_intvl, val);
                break;
        case TCP_KEEPCNT:
                ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPCNT,
                                                 &tcp_sock_set_keepcnt,
                                                 &msk->keepalive_cnt,
                                                 val);
                break;
        case TCP_MAXSEG:
                msk->maxseg = val;
                ret = mptcp_setsockopt_all_sf(msk, SOL_TCP, optname, optval,
                                              optlen);
                break;
        default:
                ret = -ENOPROTOOPT;
        }

        release_sock(sk);
        return ret;
}

int mptcp_setsockopt(struct sock *sk, int level, int optname,
                     sockptr_t optval, unsigned int optlen)
{
        struct mptcp_sock *msk = mptcp_sk(sk);
        struct sock *ssk;

        pr_debug("msk=%p\n", msk);

        if (level == SOL_SOCKET)
                return mptcp_setsockopt_sol_socket(msk, optname, optval, optlen);

        if (!mptcp_supported_sockopt(level, optname))
                return -ENOPROTOOPT;

        /* @@ the meaning of setsockopt() when the socket is connected and
         * there are multiple subflows is not yet defined. It is up to the
         * MPTCP-level socket to configure the subflows until the subflow
         * is in TCP fallback, when TCP socket options are passed through
         * to the one remaining subflow.
         */
        lock_sock(sk);
        ssk = __mptcp_tcp_fallback(msk);
        release_sock(sk);
        if (ssk)
                return tcp_setsockopt(ssk, level, optname, optval, optlen);

        if (level == SOL_IP)
                return mptcp_setsockopt_v4(msk, optname, optval, optlen);

        if (level == SOL_IPV6)
                return mptcp_setsockopt_v6(msk, optname, optval, optlen);

        if (level == SOL_TCP)
                return mptcp_setsockopt_sol_tcp(msk, optname, optval, optlen);

        return -EOPNOTSUPP;
}

static int mptcp_getsockopt_first_sf_only(struct mptcp_sock *msk, int level, int optname,
                                          char __user *optval, int __user *optlen)
{
        struct sock *sk = (struct sock *)msk;
        struct sock *ssk;
        int ret;

        lock_sock(sk);
        ssk = msk->first;
        if (ssk)
                goto get;

        ssk = __mptcp_nmpc_sk(msk);
        if (IS_ERR(ssk)) {
                ret = PTR_ERR(ssk);
                goto out;
        }

get:
        ret = tcp_getsockopt(ssk, level, optname, optval, optlen);

out:
        release_sock(sk);
        return ret;
}

void mptcp_diag_fill_info(struct mptcp_sock *msk, struct mptcp_info *info)
{
        struct sock *sk = (struct sock *)msk;
        u32 flags = 0;
        bool slow;
        u32 now;

        memset(info, 0, sizeof(*info));

        info->mptcpi_extra_subflows = READ_ONCE(msk->pm.extra_subflows);
        info->mptcpi_add_addr_signal = READ_ONCE(msk->pm.add_addr_signaled);
        info->mptcpi_add_addr_accepted = READ_ONCE(msk->pm.add_addr_accepted);
        info->mptcpi_local_addr_used = READ_ONCE(msk->pm.local_addr_used);

        if (inet_sk_state_load(sk) == TCP_LISTEN)
                return;

        /* The following limits only make sense for the in-kernel PM */
        if (mptcp_pm_is_kernel(msk)) {
                info->mptcpi_limit_extra_subflows =
                        mptcp_pm_get_limit_extra_subflows(msk);
                info->mptcpi_endp_signal_max =
                        mptcp_pm_get_endp_signal_max(msk);
                info->mptcpi_limit_add_addr_accepted =
                        mptcp_pm_get_limit_add_addr_accepted(msk);
                info->mptcpi_endp_subflow_max =
                        mptcp_pm_get_endp_subflow_max(msk);
                info->mptcpi_endp_laminar_max =
                        mptcp_pm_get_endp_laminar_max(msk);
                info->mptcpi_endp_fullmesh_max =
                        mptcp_pm_get_endp_fullmesh_max(msk);
        }

        if (__mptcp_check_fallback(msk))
                flags |= MPTCP_INFO_FLAG_FALLBACK;
        if (READ_ONCE(msk->can_ack))
                flags |= MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED;
        info->mptcpi_flags = flags;

        slow = lock_sock_fast(sk);
        info->mptcpi_csum_enabled = READ_ONCE(msk->csum_enabled);
        info->mptcpi_token = msk->token;
        info->mptcpi_write_seq = msk->write_seq;
        info->mptcpi_retransmits = inet_csk(sk)->icsk_retransmits;
        info->mptcpi_bytes_sent = msk->bytes_sent;
        info->mptcpi_bytes_received = msk->bytes_received;
        info->mptcpi_bytes_retrans = msk->bytes_retrans;
        info->mptcpi_subflows_total = info->mptcpi_extra_subflows +
                __mptcp_has_initial_subflow(msk);
        now = tcp_jiffies32;
        info->mptcpi_last_data_sent = jiffies_to_msecs(now - msk->last_data_sent);
        info->mptcpi_last_data_recv = jiffies_to_msecs(now - msk->last_data_recv);
        unlock_sock_fast(sk, slow);

        mptcp_data_lock(sk);
        info->mptcpi_last_ack_recv = jiffies_to_msecs(now - msk->last_ack_recv);
        info->mptcpi_snd_una = msk->snd_una;
        info->mptcpi_rcv_nxt = msk->ack_seq;
        info->mptcpi_bytes_acked = msk->bytes_acked;
        mptcp_data_unlock(sk);
}
EXPORT_SYMBOL_GPL(mptcp_diag_fill_info);

static int mptcp_getsockopt_info(struct mptcp_sock *msk, char __user *optval, int __user *optlen)
{
        struct mptcp_info m_info;
        int len;

        if (get_user(len, optlen))
                return -EFAULT;

        /* When used only to check if a fallback to TCP happened. */
        if (len == 0)
                return 0;

        len = min_t(unsigned int, len, sizeof(struct mptcp_info));

        mptcp_diag_fill_info(msk, &m_info);

        if (put_user(len, optlen))
                return -EFAULT;

        if (copy_to_user(optval, &m_info, len))
                return -EFAULT;

        return 0;
}

static int mptcp_put_subflow_data(struct mptcp_subflow_data *sfd,
                                  char __user *optval,
                                  u32 copied,
                                  int __user *optlen)
{
        u32 copylen = min_t(u32, sfd->size_subflow_data, sizeof(*sfd));

        if (copied)
                copied += sfd->size_subflow_data;
        else
                copied = copylen;

        if (put_user(copied, optlen))
                return -EFAULT;

        if (copy_to_user(optval, sfd, copylen))
                return -EFAULT;

        return 0;
}

static int mptcp_get_subflow_data(struct mptcp_subflow_data *sfd,
                                  char __user *optval,
                                  int __user *optlen)
{
        int len, copylen;

        if (get_user(len, optlen))
                return -EFAULT;

        /* if mptcp_subflow_data size is changed, need to adjust
         * this function to deal with programs using old version.
         */
        BUILD_BUG_ON(sizeof(*sfd) != MIN_INFO_OPTLEN_SIZE);

        if (len < MIN_INFO_OPTLEN_SIZE)
                return -EINVAL;

        memset(sfd, 0, sizeof(*sfd));

        copylen = min_t(unsigned int, len, sizeof(*sfd));
        if (copy_from_user(sfd, optval, copylen))
                return -EFAULT;

        /* size_subflow_data is u32, but len is signed */
        if (sfd->size_subflow_data > INT_MAX ||
            sfd->size_user > INT_MAX)
                return -EINVAL;

        if (sfd->size_subflow_data < MIN_INFO_OPTLEN_SIZE ||
            sfd->size_subflow_data > len)
                return -EINVAL;

        if (sfd->num_subflows || sfd->size_kernel)
                return -EINVAL;

        return len - sfd->size_subflow_data;
}

static int mptcp_getsockopt_tcpinfo(struct mptcp_sock *msk, char __user *optval,
                                    int __user *optlen)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        unsigned int sfcount = 0, copied = 0;
        struct mptcp_subflow_data sfd;
        char __user *infoptr;
        int len;

        len = mptcp_get_subflow_data(&sfd, optval, optlen);
        if (len < 0)
                return len;

        sfd.size_kernel = sizeof(struct tcp_info);
        sfd.size_user = min_t(unsigned int, sfd.size_user,
                              sizeof(struct tcp_info));

        infoptr = optval + sfd.size_subflow_data;

        lock_sock(sk);

        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);

                ++sfcount;

                if (len && len >= sfd.size_user) {
                        struct tcp_info info;

                        tcp_get_info(ssk, &info);

                        if (copy_to_user(infoptr, &info, sfd.size_user)) {
                                release_sock(sk);
                                return -EFAULT;
                        }

                        infoptr += sfd.size_user;
                        copied += sfd.size_user;
                        len -= sfd.size_user;
                }
        }

        release_sock(sk);

        sfd.num_subflows = sfcount;

        if (mptcp_put_subflow_data(&sfd, optval, copied, optlen))
                return -EFAULT;

        return 0;
}

static void mptcp_get_sub_addrs(const struct sock *sk, struct mptcp_subflow_addrs *a)
{
        const struct inet_sock *inet = inet_sk(sk);

        memset(a, 0, sizeof(*a));

        if (sk->sk_family == AF_INET) {
                a->sin_local.sin_family = AF_INET;
                a->sin_local.sin_port = inet->inet_sport;
                a->sin_local.sin_addr.s_addr = inet->inet_rcv_saddr;

                if (!a->sin_local.sin_addr.s_addr)
                        a->sin_local.sin_addr.s_addr = inet->inet_saddr;

                a->sin_remote.sin_family = AF_INET;
                a->sin_remote.sin_port = inet->inet_dport;
                a->sin_remote.sin_addr.s_addr = inet->inet_daddr;
#if IS_ENABLED(CONFIG_IPV6)
        } else if (sk->sk_family == AF_INET6) {
                const struct ipv6_pinfo *np = inet6_sk(sk);

                if (WARN_ON_ONCE(!np))
                        return;

                a->sin6_local.sin6_family = AF_INET6;
                a->sin6_local.sin6_port = inet->inet_sport;

                if (ipv6_addr_any(&sk->sk_v6_rcv_saddr))
                        a->sin6_local.sin6_addr = np->saddr;
                else
                        a->sin6_local.sin6_addr = sk->sk_v6_rcv_saddr;

                a->sin6_remote.sin6_family = AF_INET6;
                a->sin6_remote.sin6_port = inet->inet_dport;
                a->sin6_remote.sin6_addr = sk->sk_v6_daddr;
#endif
        }
}

static int mptcp_getsockopt_subflow_addrs(struct mptcp_sock *msk, char __user *optval,
                                          int __user *optlen)
{
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        unsigned int sfcount = 0, copied = 0;
        struct mptcp_subflow_data sfd;
        char __user *addrptr;
        int len;

        len = mptcp_get_subflow_data(&sfd, optval, optlen);
        if (len < 0)
                return len;

        sfd.size_kernel = sizeof(struct mptcp_subflow_addrs);
        sfd.size_user = min_t(unsigned int, sfd.size_user,
                              sizeof(struct mptcp_subflow_addrs));

        addrptr = optval + sfd.size_subflow_data;

        lock_sock(sk);

        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);

                ++sfcount;

                if (len && len >= sfd.size_user) {
                        struct mptcp_subflow_addrs a;

                        mptcp_get_sub_addrs(ssk, &a);

                        if (copy_to_user(addrptr, &a, sfd.size_user)) {
                                release_sock(sk);
                                return -EFAULT;
                        }

                        addrptr += sfd.size_user;
                        copied += sfd.size_user;
                        len -= sfd.size_user;
                }
        }

        release_sock(sk);

        sfd.num_subflows = sfcount;

        if (mptcp_put_subflow_data(&sfd, optval, copied, optlen))
                return -EFAULT;

        return 0;
}

static int mptcp_get_full_info(struct mptcp_full_info *mfi,
                               char __user *optval,
                               int __user *optlen)
{
        int len;

        BUILD_BUG_ON(offsetof(struct mptcp_full_info, mptcp_info) !=
                     MIN_FULL_INFO_OPTLEN_SIZE);

        if (get_user(len, optlen))
                return -EFAULT;

        if (len < MIN_FULL_INFO_OPTLEN_SIZE)
                return -EINVAL;

        memset(mfi, 0, sizeof(*mfi));
        if (copy_from_user(mfi, optval, MIN_FULL_INFO_OPTLEN_SIZE))
                return -EFAULT;

        if (mfi->size_tcpinfo_kernel ||
            mfi->size_sfinfo_kernel ||
            mfi->num_subflows)
                return -EINVAL;

        if (mfi->size_sfinfo_user > INT_MAX ||
            mfi->size_tcpinfo_user > INT_MAX)
                return -EINVAL;

        return len - MIN_FULL_INFO_OPTLEN_SIZE;
}

static int mptcp_put_full_info(struct mptcp_full_info *mfi,
                               char __user *optval,
                               u32 copylen,
                               int __user *optlen)
{
        copylen += MIN_FULL_INFO_OPTLEN_SIZE;
        if (put_user(copylen, optlen))
                return -EFAULT;

        if (copy_to_user(optval, mfi, copylen))
                return -EFAULT;
        return 0;
}

static int mptcp_getsockopt_full_info(struct mptcp_sock *msk, char __user *optval,
                                      int __user *optlen)
{
        unsigned int sfcount = 0, copylen = 0;
        struct mptcp_subflow_context *subflow;
        struct sock *sk = (struct sock *)msk;
        void __user *tcpinfoptr, *sfinfoptr;
        struct mptcp_full_info mfi;
        int len;

        len = mptcp_get_full_info(&mfi, optval, optlen);
        if (len < 0)
                return len;

        /* don't bother filling the mptcp info if there is not enough
         * user-space-provided storage
         */
        if (len > 0) {
                mptcp_diag_fill_info(msk, &mfi.mptcp_info);
                copylen += min_t(unsigned int, len, sizeof(struct mptcp_info));
        }

        mfi.size_tcpinfo_kernel = sizeof(struct tcp_info);
        mfi.size_tcpinfo_user = min_t(unsigned int, mfi.size_tcpinfo_user,
                                      sizeof(struct tcp_info));
        sfinfoptr = u64_to_user_ptr(mfi.subflow_info);
        mfi.size_sfinfo_kernel = sizeof(struct mptcp_subflow_info);
        mfi.size_sfinfo_user = min_t(unsigned int, mfi.size_sfinfo_user,
                                     sizeof(struct mptcp_subflow_info));
        tcpinfoptr = u64_to_user_ptr(mfi.tcp_info);

        lock_sock(sk);
        mptcp_for_each_subflow(msk, subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                struct mptcp_subflow_info sfinfo;
                struct tcp_info tcp_info;

                if (sfcount++ >= mfi.size_arrays_user)
                        continue;

                /* fetch addr/tcp_info only if the user space buffers
                 * are wide enough
                 */
                memset(&sfinfo, 0, sizeof(sfinfo));
                sfinfo.id = subflow->subflow_id;
                if (mfi.size_sfinfo_user >
                    offsetof(struct mptcp_subflow_info, addrs))
                        mptcp_get_sub_addrs(ssk, &sfinfo.addrs);
                if (copy_to_user(sfinfoptr, &sfinfo, mfi.size_sfinfo_user))
                        goto fail_release;

                if (mfi.size_tcpinfo_user) {
                        tcp_get_info(ssk, &tcp_info);
                        if (copy_to_user(tcpinfoptr, &tcp_info,
                                         mfi.size_tcpinfo_user))
                                goto fail_release;
                }

                tcpinfoptr += mfi.size_tcpinfo_user;
                sfinfoptr += mfi.size_sfinfo_user;
        }
        release_sock(sk);

        mfi.num_subflows = sfcount;
        if (mptcp_put_full_info(&mfi, optval, copylen, optlen))
                return -EFAULT;

        return 0;

fail_release:
        release_sock(sk);
        return -EFAULT;
}

static int mptcp_put_int_option(struct mptcp_sock *msk, char __user *optval,
                                int __user *optlen, int val)
{
        int len;

        if (get_user(len, optlen))
                return -EFAULT;
        if (len < 0)
                return -EINVAL;

        if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
                unsigned char ucval = (unsigned char)val;

                len = 1;
                if (put_user(len, optlen))
                        return -EFAULT;
                if (copy_to_user(optval, &ucval, 1))
                        return -EFAULT;
        } else {
                len = min_t(unsigned int, len, sizeof(int));
                if (put_user(len, optlen))
                        return -EFAULT;
                if (copy_to_user(optval, &val, len))
                        return -EFAULT;
        }

        return 0;
}

static int mptcp_getsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
                                    char __user *optval, int __user *optlen)
{
        struct sock *sk = (void *)msk;

        switch (optname) {
        case TCP_ULP:
        case TCP_CONGESTION:
        case TCP_INFO:
        case TCP_CC_INFO:
        case TCP_DEFER_ACCEPT:
        case TCP_FASTOPEN:
        case TCP_FASTOPEN_CONNECT:
        case TCP_FASTOPEN_KEY:
        case TCP_FASTOPEN_NO_COOKIE:
                return mptcp_getsockopt_first_sf_only(msk, SOL_TCP, optname,
                                                      optval, optlen);
        case TCP_INQ:
                return mptcp_put_int_option(msk, optval, optlen, msk->recvmsg_inq);
        case TCP_CORK:
                return mptcp_put_int_option(msk, optval, optlen, msk->cork);
        case TCP_NODELAY:
                return mptcp_put_int_option(msk, optval, optlen, msk->nodelay);
        case TCP_KEEPIDLE:
                return mptcp_put_int_option(msk, optval, optlen,
                                            msk->keepalive_idle ? :
                                            READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_time) / HZ);
        case TCP_KEEPINTVL:
                return mptcp_put_int_option(msk, optval, optlen,
                                            msk->keepalive_intvl ? :
                                            READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_intvl) / HZ);
        case TCP_KEEPCNT:
                return mptcp_put_int_option(msk, optval, optlen,
                                            msk->keepalive_cnt ? :
                                            READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_probes));
        case TCP_NOTSENT_LOWAT:
                return mptcp_put_int_option(msk, optval, optlen, msk->notsent_lowat);
        case TCP_IS_MPTCP:
                return mptcp_put_int_option(msk, optval, optlen, 1);
        case TCP_MAXSEG:
                return mptcp_getsockopt_first_sf_only(msk, SOL_TCP, optname,
                                                      optval, optlen);
        }
        return -EOPNOTSUPP;
}

static int mptcp_getsockopt_v4(struct mptcp_sock *msk, int optname,
                               char __user *optval, int __user *optlen)
{
        struct sock *sk = (void *)msk;

        switch (optname) {
        case IP_TOS:
                return mptcp_put_int_option(msk, optval, optlen, READ_ONCE(inet_sk(sk)->tos));
        case IP_FREEBIND:
                return mptcp_put_int_option(msk, optval, optlen,
                                inet_test_bit(FREEBIND, sk));
        case IP_TRANSPARENT:
                return mptcp_put_int_option(msk, optval, optlen,
                                inet_test_bit(TRANSPARENT, sk));
        case IP_BIND_ADDRESS_NO_PORT:
                return mptcp_put_int_option(msk, optval, optlen,
                                inet_test_bit(BIND_ADDRESS_NO_PORT, sk));
        case IP_LOCAL_PORT_RANGE:
                return mptcp_put_int_option(msk, optval, optlen,
                                READ_ONCE(inet_sk(sk)->local_port_range));
        }

        return -EOPNOTSUPP;
}

static int mptcp_getsockopt_v6(struct mptcp_sock *msk, int optname,
                               char __user *optval, int __user *optlen)
{
        struct sock *sk = (void *)msk;

        switch (optname) {
        case IPV6_V6ONLY:
                return mptcp_put_int_option(msk, optval, optlen,
                                            sk->sk_ipv6only);
        case IPV6_TRANSPARENT:
                return mptcp_put_int_option(msk, optval, optlen,
                                            inet_test_bit(TRANSPARENT, sk));
        case IPV6_FREEBIND:
                return mptcp_put_int_option(msk, optval, optlen,
                                            inet_test_bit(FREEBIND, sk));
        }

        return -EOPNOTSUPP;
}

static int mptcp_getsockopt_sol_mptcp(struct mptcp_sock *msk, int optname,
                                      char __user *optval, int __user *optlen)
{
        switch (optname) {
        case MPTCP_INFO:
                return mptcp_getsockopt_info(msk, optval, optlen);
        case MPTCP_FULL_INFO:
                return mptcp_getsockopt_full_info(msk, optval, optlen);
        case MPTCP_TCPINFO:
                return mptcp_getsockopt_tcpinfo(msk, optval, optlen);
        case MPTCP_SUBFLOW_ADDRS:
                return mptcp_getsockopt_subflow_addrs(msk, optval, optlen);
        }

        return -EOPNOTSUPP;
}

int mptcp_getsockopt(struct sock *sk, int level, int optname,
                     char __user *optval, int __user *option)
{
        struct mptcp_sock *msk = mptcp_sk(sk);
        struct sock *ssk;

        pr_debug("msk=%p\n", msk);

        /* @@ the meaning of setsockopt() when the socket is connected and
         * there are multiple subflows is not yet defined. It is up to the
         * MPTCP-level socket to configure the subflows until the subflow
         * is in TCP fallback, when socket options are passed through
         * to the one remaining subflow.
         */
        lock_sock(sk);
        ssk = __mptcp_tcp_fallback(msk);
        release_sock(sk);
        if (ssk)
                return tcp_getsockopt(ssk, level, optname, optval, option);

        if (level == SOL_IP)
                return mptcp_getsockopt_v4(msk, optname, optval, option);
        if (level == SOL_IPV6)
                return mptcp_getsockopt_v6(msk, optname, optval, option);
        if (level == SOL_TCP)
                return mptcp_getsockopt_sol_tcp(msk, optname, optval, option);
        if (level == SOL_MPTCP)
                return mptcp_getsockopt_sol_mptcp(msk, optname, optval, option);
        return -EOPNOTSUPP;
}

static void sync_socket_options(struct mptcp_sock *msk, struct sock *ssk)
{
        static const unsigned int tx_rx_locks = SOCK_RCVBUF_LOCK | SOCK_SNDBUF_LOCK;
        struct sock *sk = (struct sock *)msk;
        bool keep_open;

        keep_open = sock_flag(sk, SOCK_KEEPOPEN);
        if (ssk->sk_prot->keepalive)
                ssk->sk_prot->keepalive(ssk, keep_open);
        sock_valbool_flag(ssk, SOCK_KEEPOPEN, keep_open);

        ssk->sk_priority = sk->sk_priority;
        ssk->sk_bound_dev_if = sk->sk_bound_dev_if;
        ssk->sk_incoming_cpu = sk->sk_incoming_cpu;
        ssk->sk_ipv6only = sk->sk_ipv6only;
        __ip_sock_set_tos(ssk, inet_sk(sk)->tos);

        if (sk->sk_userlocks & tx_rx_locks) {
                ssk->sk_userlocks |= sk->sk_userlocks & tx_rx_locks;
                if (sk->sk_userlocks & SOCK_SNDBUF_LOCK) {
                        WRITE_ONCE(ssk->sk_sndbuf, sk->sk_sndbuf);
                        mptcp_subflow_ctx(ssk)->cached_sndbuf = sk->sk_sndbuf;
                }
                if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
                        WRITE_ONCE(ssk->sk_rcvbuf, sk->sk_rcvbuf);
        }

        if (sock_flag(sk, SOCK_LINGER)) {
                ssk->sk_lingertime = sk->sk_lingertime;
                sock_set_flag(ssk, SOCK_LINGER);
        } else {
                sock_reset_flag(ssk, SOCK_LINGER);
        }

        if (sk->sk_mark != ssk->sk_mark) {
                ssk->sk_mark = sk->sk_mark;
                sk_dst_reset(ssk);
        }

        sock_valbool_flag(ssk, SOCK_DBG, sock_flag(sk, SOCK_DBG));

        if (inet_csk(sk)->icsk_ca_ops != inet_csk(ssk)->icsk_ca_ops)
                tcp_set_congestion_control(ssk, msk->ca_name, false, true);
        __tcp_sock_set_cork(ssk, !!msk->cork);
        __tcp_sock_set_nodelay(ssk, !!msk->nodelay);
        tcp_sock_set_keepidle_locked(ssk, msk->keepalive_idle);
        tcp_sock_set_keepintvl(ssk, msk->keepalive_intvl);
        tcp_sock_set_keepcnt(ssk, msk->keepalive_cnt);
        tcp_sock_set_maxseg(ssk, msk->maxseg);

        inet_assign_bit(TRANSPARENT, ssk, inet_test_bit(TRANSPARENT, sk));
        inet_assign_bit(FREEBIND, ssk, inet_test_bit(FREEBIND, sk));
        inet_assign_bit(BIND_ADDRESS_NO_PORT, ssk, inet_test_bit(BIND_ADDRESS_NO_PORT, sk));
        WRITE_ONCE(inet_sk(ssk)->local_port_range, READ_ONCE(inet_sk(sk)->local_port_range));
}

void mptcp_sockopt_sync_locked(struct mptcp_sock *msk, struct sock *ssk)
{
        struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);

        msk_owned_by_me(msk);

        ssk->sk_rcvlowat = 0;

        /* subflows must ignore any latency-related settings: will not affect
         * the user-space - only the msk is relevant - but will foul the
         * mptcp scheduler
         */
        tcp_sk(ssk)->notsent_lowat = UINT_MAX;

        if (READ_ONCE(subflow->setsockopt_seq) != msk->setsockopt_seq) {
                sync_socket_options(msk, ssk);

                subflow->setsockopt_seq = msk->setsockopt_seq;
        }
}

/* unfortunately this is different enough from the tcp version so
 * that we can't factor it out
 */
int mptcp_set_rcvlowat(struct sock *sk, int val)
{
        struct mptcp_subflow_context *subflow;
        int space, cap;

        /* bpf can land here with a wrong sk type */
        if (sk->sk_protocol == IPPROTO_TCP)
                return -EINVAL;

        if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
                cap = sk->sk_rcvbuf >> 1;
        else
                cap = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2]) >> 1;
        val = min(val, cap);
        WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);

        /* Check if we need to signal EPOLLIN right now */
        if (mptcp_epollin_ready(sk))
                sk->sk_data_ready(sk);

        if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
                return 0;

        space = mptcp_space_from_win(sk, val);
        if (space <= sk->sk_rcvbuf)
                return 0;

        /* propagate the rcvbuf changes to all the subflows */
        WRITE_ONCE(sk->sk_rcvbuf, space);
        mptcp_for_each_subflow(mptcp_sk(sk), subflow) {
                struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
                bool slow;

                slow = lock_sock_fast(ssk);
                WRITE_ONCE(ssk->sk_rcvbuf, space);
                WRITE_ONCE(tcp_sk(ssk)->window_clamp, val);
                unlock_sock_fast(ssk, slow);
        }
        return 0;
}