added missing files

menuconfig MCTP

	depends on NET

	bool "MCTP core protocol support"

config MPTCP

	bool "MPTCP: Multipath TCP"

	depends on INET

	select SKB_EXTENSIONS

	select CRYPTO_LIB_SHA256

	select CRYPTO

	help

	  Management Component Transport Protocol (MCTP) is an in-system

	  protocol for communicating between management controllers and

	  their managed devices (peripherals, host processors, etc.). The

	  protocol is defined by DMTF specification DSP0236.

	  Multipath TCP (MPTCP) connections send and receive data over multiple

	  subflows in order to utilize multiple network paths. Each subflow

	  uses the TCP protocol, and TCP options carry header information for

	  MPTCP.

if MPTCP

config INET_MPTCP_DIAG

	depends on INET_DIAG

	def_tristate INET_DIAG

	  This option enables core MCTP support. For communicating with other

	  devices, you'll want to enable a driver for a specific hardware

	  channel.

config MPTCP_IPV6

	bool "MPTCP: IPv6 support for Multipath TCP"

	depends on IPV6=y

	default y

config MCTP_TEST

        bool "MCTP core tests" if !KUNIT_ALL_TESTS

        depends on MCTP=y && KUNIT=y

config MPTCP_KUNIT_TEST

	tristate "This builds the MPTCP KUnit tests" if !KUNIT_ALL_TESTS

	depends on KUNIT

	default KUNIT_ALL_TESTS

	help

	  Currently covers the MPTCP crypto and token helpers.

	  Only useful for kernel devs running KUnit test harness and are not

	  for inclusion into a production build.

config MCTP_FLOWS

	bool

	depends on MCTP

	select SKB_EXTENSIONS

	  For more information on KUnit and unit tests in general please refer

	  to the KUnit documentation in Documentation/dev-tools/kunit/.

	  If unsure, say N.

endif

// SPDX-License-Identifier: GPL-2.0

/* Multipath TCP

 *

 * Copyright (c) 2020, Tessares SA.

 * Copyright (c) 2022, SUSE.

 *

 * Author: Nicolas Rybowski <nicolas.rybowski@tessares.net>

 */

#define pr_fmt(fmt) "MPTCP: " fmt

#include <linux/bpf.h>

#include "protocol.h"

struct mptcp_sock *bpf_mptcp_sock_from_subflow(struct sock *sk)

{

	if (sk && sk_fullsock(sk) && sk->sk_protocol == IPPROTO_TCP && sk_is_mptcp(sk))

		return mptcp_sk(mptcp_subflow_ctx(sk)->conn);

	return NULL;

}

BTF_SET8_START(bpf_mptcp_fmodret_ids)

BTF_ID_FLAGS(func, update_socket_protocol)

BTF_SET8_END(bpf_mptcp_fmodret_ids)

static const struct btf_kfunc_id_set bpf_mptcp_fmodret_set = {

	.owner = THIS_MODULE,

	.set   = &bpf_mptcp_fmodret_ids,

};

static int __init bpf_mptcp_kfunc_init(void)

{

	return register_btf_fmodret_id_set(&bpf_mptcp_fmodret_set);

}

late_initcall(bpf_mptcp_kfunc_init);

// SPDX-License-Identifier: GPL-2.0

/* Multipath TCP cryptographic functions

 * Copyright (c) 2017 - 2019, Intel Corporation.

 *

 * Note: This code is based on mptcp_ctrl.c, mptcp_ipv4.c, and

 *       mptcp_ipv6 from multipath-tcp.org, authored by:

 *

 *       Sébastien Barré <sebastien.barre@uclouvain.be>

 *       Christoph Paasch <christoph.paasch@uclouvain.be>

 *       Jaakko Korkeaniemi <jaakko.korkeaniemi@aalto.fi>

 *       Gregory Detal <gregory.detal@uclouvain.be>

 *       Fabien Duchêne <fabien.duchene@uclouvain.be>

 *       Andreas Seelinger <Andreas.Seelinger@rwth-aachen.de>

 *       Lavkesh Lahngir <lavkesh51@gmail.com>

 *       Andreas Ripke <ripke@neclab.eu>

 *       Vlad Dogaru <vlad.dogaru@intel.com>

 *       Octavian Purdila <octavian.purdila@intel.com>

 *       John Ronan <jronan@tssg.org>

 *       Catalin Nicutar <catalin.nicutar@gmail.com>

 *       Brandon Heller <brandonh@stanford.edu>

 */

#include <linux/kernel.h>

#include <crypto/sha2.h>

#include <asm/unaligned.h>

#include "protocol.h"

#define SHA256_DIGEST_WORDS (SHA256_DIGEST_SIZE / 4)

void mptcp_crypto_key_sha(u64 key, u32 *token, u64 *idsn)

{

	__be32 mptcp_hashed_key[SHA256_DIGEST_WORDS];

	__be64 input = cpu_to_be64(key);

	sha256((__force u8 *)&input, sizeof(input), (u8 *)mptcp_hashed_key);

	if (token)

		*token = be32_to_cpu(mptcp_hashed_key[0]);

	if (idsn)

		*idsn = be64_to_cpu(*((__be64 *)&mptcp_hashed_key[6]));

}

void mptcp_crypto_hmac_sha(u64 key1, u64 key2, u8 *msg, int len, void *hmac)

{

	u8 input[SHA256_BLOCK_SIZE + SHA256_DIGEST_SIZE];

	u8 key1be[8];

	u8 key2be[8];

	int i;

	if (WARN_ON_ONCE(len > SHA256_DIGEST_SIZE))

		len = SHA256_DIGEST_SIZE;

	put_unaligned_be64(key1, key1be);

	put_unaligned_be64(key2, key2be);

	/* Generate key xored with ipad */

	memset(input, 0x36, SHA256_BLOCK_SIZE);

	for (i = 0; i < 8; i++)

		input[i] ^= key1be[i];

	for (i = 0; i < 8; i++)

		input[i + 8] ^= key2be[i];

	memcpy(&input[SHA256_BLOCK_SIZE], msg, len);

	/* emit sha256(K1 || msg) on the second input block, so we can

	 * reuse 'input' for the last hashing

	 */

	sha256(input, SHA256_BLOCK_SIZE + len, &input[SHA256_BLOCK_SIZE]);

	/* Prepare second part of hmac */

	memset(input, 0x5C, SHA256_BLOCK_SIZE);

	for (i = 0; i < 8; i++)

		input[i] ^= key1be[i];

	for (i = 0; i < 8; i++)

		input[i + 8] ^= key2be[i];

	sha256(input, SHA256_BLOCK_SIZE + SHA256_DIGEST_SIZE, hmac);

}

#if IS_MODULE(CONFIG_MPTCP_KUNIT_TEST)

EXPORT_SYMBOL_GPL(mptcp_crypto_hmac_sha);

#endif

// SPDX-License-Identifier: GPL-2.0

/* Multipath TCP

 *

 * Copyright (c) 2019, Tessares SA.

 */

#ifdef CONFIG_SYSCTL

#include <linux/sysctl.h>

#endif

#include <net/net_namespace.h>

#include <net/netns/generic.h>

#include "protocol.h"

#define MPTCP_SYSCTL_PATH "net/mptcp"

static int mptcp_pernet_id;

#ifdef CONFIG_SYSCTL

static int mptcp_pm_type_max = __MPTCP_PM_TYPE_MAX;

#endif

struct mptcp_pernet {

#ifdef CONFIG_SYSCTL

	struct ctl_table_header *ctl_table_hdr;

#endif

	unsigned int add_addr_timeout;

	unsigned int stale_loss_cnt;

	u8 mptcp_enabled;

	u8 checksum_enabled;

	u8 allow_join_initial_addr_port;

	u8 pm_type;

	char scheduler[MPTCP_SCHED_NAME_MAX];

};

static struct mptcp_pernet *mptcp_get_pernet(const struct net *net)

{

	return net_generic(net, mptcp_pernet_id);

}

int mptcp_is_enabled(const struct net *net)

{

	return mptcp_get_pernet(net)->mptcp_enabled;

}

unsigned int mptcp_get_add_addr_timeout(const struct net *net)

{

	return mptcp_get_pernet(net)->add_addr_timeout;

}

int mptcp_is_checksum_enabled(const struct net *net)

{

	return mptcp_get_pernet(net)->checksum_enabled;

}

int mptcp_allow_join_id0(const struct net *net)

{

	return mptcp_get_pernet(net)->allow_join_initial_addr_port;

}

unsigned int mptcp_stale_loss_cnt(const struct net *net)

{

	return mptcp_get_pernet(net)->stale_loss_cnt;

}

int mptcp_get_pm_type(const struct net *net)

{

	return mptcp_get_pernet(net)->pm_type;

}

const char *mptcp_get_scheduler(const struct net *net)

{

	return mptcp_get_pernet(net)->scheduler;

}

static void mptcp_pernet_set_defaults(struct mptcp_pernet *pernet)

{

	pernet->mptcp_enabled = 1;

	pernet->add_addr_timeout = TCP_RTO_MAX;

	pernet->checksum_enabled = 0;

	pernet->allow_join_initial_addr_port = 1;

	pernet->stale_loss_cnt = 4;

	pernet->pm_type = MPTCP_PM_TYPE_KERNEL;

	strcpy(pernet->scheduler, "default");

}

#ifdef CONFIG_SYSCTL

static struct ctl_table mptcp_sysctl_table[] = {

	{

		.procname = "enabled",

		.maxlen = sizeof(u8),

		.mode = 0644,

		/* users with CAP_NET_ADMIN or root (not and) can change this

		 * value, same as other sysctl or the 'net' tree.

		 */

		.proc_handler = proc_dou8vec_minmax,

		.extra1       = SYSCTL_ZERO,

		.extra2       = SYSCTL_ONE

	},

	{

		.procname = "add_addr_timeout",

		.maxlen = sizeof(unsigned int),

		.mode = 0644,

		.proc_handler = proc_dointvec_jiffies,

	},

	{

		.procname = "checksum_enabled",

		.maxlen = sizeof(u8),

		.mode = 0644,

		.proc_handler = proc_dou8vec_minmax,

		.extra1       = SYSCTL_ZERO,

		.extra2       = SYSCTL_ONE

	},

	{

		.procname = "allow_join_initial_addr_port",

		.maxlen = sizeof(u8),

		.mode = 0644,

		.proc_handler = proc_dou8vec_minmax,

		.extra1       = SYSCTL_ZERO,

		.extra2       = SYSCTL_ONE

	},

	{

		.procname = "stale_loss_cnt",

		.maxlen = sizeof(unsigned int),

		.mode = 0644,

		.proc_handler = proc_douintvec_minmax,

	},

	{

		.procname = "pm_type",

		.maxlen = sizeof(u8),

		.mode = 0644,

		.proc_handler = proc_dou8vec_minmax,

		.extra1       = SYSCTL_ZERO,

		.extra2       = &mptcp_pm_type_max

	},

	{

		.procname = "scheduler",

		.maxlen	= MPTCP_SCHED_NAME_MAX,

		.mode = 0644,

		.proc_handler = proc_dostring,

	},

	{}

};

static int mptcp_pernet_new_table(struct net *net, struct mptcp_pernet *pernet)

{

	struct ctl_table_header *hdr;

	struct ctl_table *table;

	table = mptcp_sysctl_table;

	if (!net_eq(net, &init_net)) {

		table = kmemdup(table, sizeof(mptcp_sysctl_table), GFP_KERNEL);

		if (!table)

			goto err_alloc;

	}

	table[0].data = &pernet->mptcp_enabled;

	table[1].data = &pernet->add_addr_timeout;

	table[2].data = &pernet->checksum_enabled;

	table[3].data = &pernet->allow_join_initial_addr_port;

	table[4].data = &pernet->stale_loss_cnt;

	table[5].data = &pernet->pm_type;

	table[6].data = &pernet->scheduler;

	hdr = register_net_sysctl_sz(net, MPTCP_SYSCTL_PATH, table,

				     ARRAY_SIZE(mptcp_sysctl_table));

	if (!hdr)

		goto err_reg;

	pernet->ctl_table_hdr = hdr;

	return 0;

err_reg:

	if (!net_eq(net, &init_net))

		kfree(table);

err_alloc:

	return -ENOMEM;

}

static void mptcp_pernet_del_table(struct mptcp_pernet *pernet)

{

	struct ctl_table *table = pernet->ctl_table_hdr->ctl_table_arg;

	unregister_net_sysctl_table(pernet->ctl_table_hdr);

	kfree(table);

}

#else

static int mptcp_pernet_new_table(struct net *net, struct mptcp_pernet *pernet)

{

	return 0;

}

static void mptcp_pernet_del_table(struct mptcp_pernet *pernet) {}

#endif /* CONFIG_SYSCTL */

static int __net_init mptcp_net_init(struct net *net)

{

	struct mptcp_pernet *pernet = mptcp_get_pernet(net);

	mptcp_pernet_set_defaults(pernet);

	return mptcp_pernet_new_table(net, pernet);

}

/* Note: the callback will only be called per extra netns */

static void __net_exit mptcp_net_exit(struct net *net)

{

	struct mptcp_pernet *pernet = mptcp_get_pernet(net);

	mptcp_pernet_del_table(pernet);

}

static struct pernet_operations mptcp_pernet_ops = {

	.init = mptcp_net_init,

	.exit = mptcp_net_exit,

	.id = &mptcp_pernet_id,

	.size = sizeof(struct mptcp_pernet),

};

void __init mptcp_init(void)

{

	mptcp_join_cookie_init();

	mptcp_proto_init();

	if (register_pernet_subsys(&mptcp_pernet_ops) < 0)

		panic("Failed to register MPTCP pernet subsystem.\n");

}

#if IS_ENABLED(CONFIG_MPTCP_IPV6)

int __init mptcpv6_init(void)

{

	int err;

	err = mptcp_proto_v6_init();

	return err;

}

#endif

// SPDX-License-Identifier: GPL-2.0

/* MPTCP socket monitoring support

 *

 * Copyright (c) 2019 Red Hat

 *

 * Author: Davide Caratti <dcaratti@redhat.com>

 */

#include <linux/kernel.h>

#include <linux/net.h>

#include <linux/inet_diag.h>

#include <net/netlink.h>

#include <uapi/linux/mptcp.h>

#include "protocol.h"

static int subflow_get_info(struct sock *sk, struct sk_buff *skb)

{

	struct mptcp_subflow_context *sf;

	struct nlattr *start;

	u32 flags = 0;

	bool slow;

	int err;

	start = nla_nest_start_noflag(skb, INET_ULP_INFO_MPTCP);

	if (!start)

		return -EMSGSIZE;

	slow = lock_sock_fast(sk);

	rcu_read_lock();

	sf = rcu_dereference(inet_csk(sk)->icsk_ulp_data);

	if (!sf) {

		err = 0;

		goto nla_failure;

	}

	if (sf->mp_capable)

		flags |= MPTCP_SUBFLOW_FLAG_MCAP_REM;

	if (sf->request_mptcp)

		flags |= MPTCP_SUBFLOW_FLAG_MCAP_LOC;

	if (sf->mp_join)

		flags |= MPTCP_SUBFLOW_FLAG_JOIN_REM;

	if (sf->request_join)

		flags |= MPTCP_SUBFLOW_FLAG_JOIN_LOC;

	if (sf->backup)

		flags |= MPTCP_SUBFLOW_FLAG_BKUP_REM;

	if (sf->request_bkup)

		flags |= MPTCP_SUBFLOW_FLAG_BKUP_LOC;

	if (sf->fully_established)

		flags |= MPTCP_SUBFLOW_FLAG_FULLY_ESTABLISHED;

	if (sf->conn_finished)

		flags |= MPTCP_SUBFLOW_FLAG_CONNECTED;

	if (sf->map_valid)

		flags |= MPTCP_SUBFLOW_FLAG_MAPVALID;

	if (nla_put_u32(skb, MPTCP_SUBFLOW_ATTR_TOKEN_REM, sf->remote_token) ||

	    nla_put_u32(skb, MPTCP_SUBFLOW_ATTR_TOKEN_LOC, sf->token) ||

	    nla_put_u32(skb, MPTCP_SUBFLOW_ATTR_RELWRITE_SEQ,

			sf->rel_write_seq) ||

	    nla_put_u64_64bit(skb, MPTCP_SUBFLOW_ATTR_MAP_SEQ, sf->map_seq,

			      MPTCP_SUBFLOW_ATTR_PAD) ||

	    nla_put_u32(skb, MPTCP_SUBFLOW_ATTR_MAP_SFSEQ,

			sf->map_subflow_seq) ||

	    nla_put_u32(skb, MPTCP_SUBFLOW_ATTR_SSN_OFFSET, sf->ssn_offset) ||

	    nla_put_u16(skb, MPTCP_SUBFLOW_ATTR_MAP_DATALEN,

			sf->map_data_len) ||

	    nla_put_u32(skb, MPTCP_SUBFLOW_ATTR_FLAGS, flags) ||

	    nla_put_u8(skb, MPTCP_SUBFLOW_ATTR_ID_REM, sf->remote_id) ||

	    nla_put_u8(skb, MPTCP_SUBFLOW_ATTR_ID_LOC, subflow_get_local_id(sf))) {

		err = -EMSGSIZE;

		goto nla_failure;

	}

	rcu_read_unlock();

	unlock_sock_fast(sk, slow);

	nla_nest_end(skb, start);

	return 0;

nla_failure:

	rcu_read_unlock();

	unlock_sock_fast(sk, slow);

	nla_nest_cancel(skb, start);

	return err;

}

static size_t subflow_get_info_size(const struct sock *sk)

{

	size_t size = 0;

	size += nla_total_size(0) +	/* INET_ULP_INFO_MPTCP */

		nla_total_size(4) +	/* MPTCP_SUBFLOW_ATTR_TOKEN_REM */

		nla_total_size(4) +	/* MPTCP_SUBFLOW_ATTR_TOKEN_LOC */

		nla_total_size(4) +	/* MPTCP_SUBFLOW_ATTR_RELWRITE_SEQ */

		nla_total_size_64bit(8) +	/* MPTCP_SUBFLOW_ATTR_MAP_SEQ */

		nla_total_size(4) +	/* MPTCP_SUBFLOW_ATTR_MAP_SFSEQ */

		nla_total_size(2) +	/* MPTCP_SUBFLOW_ATTR_SSN_OFFSET */

		nla_total_size(2) +	/* MPTCP_SUBFLOW_ATTR_MAP_DATALEN */

		nla_total_size(4) +	/* MPTCP_SUBFLOW_ATTR_FLAGS */

		nla_total_size(1) +	/* MPTCP_SUBFLOW_ATTR_ID_REM */

		nla_total_size(1) +	/* MPTCP_SUBFLOW_ATTR_ID_LOC */

		0;

	return size;

}

void mptcp_diag_subflow_init(struct tcp_ulp_ops *ops)

{

	ops->get_info = subflow_get_info;

	ops->get_info_size = s;

}