// SPDX-License-Identifier: GPL-2.0

#include <stdio.h>
#include <string.h>
#include <rt_names.h>
#include <errno.h>

#include <linux/genetlink.h>
#include <linux/mptcp.h>

#include "utils.h"
#include "ip_common.h"
#include "libgenl.h"
#include "json_print.h"

static void usage(void)
{
	fprintf(stderr,
		"Usage:	ip mptcp endpoint add ADDRESS [ dev NAME ] [ id ID ]\n"
		"				      [ FLAG-LIST ]\n"
		"	ip mptcp endpoint delete id ID\n"
		"	ip mptcp endpoint show [ id ID ]\n"
		"	ip mptcp endpoint flush\n"
		"	ip mptcp limits set [ subflows NR ] [ add_addr_accepted NR ]\n"
		"	ip mptcp limits show\n"
		"FLAG-LIST := [ FLAG-LIST ] FLAG\n"
		"FLAG  := [ signal | subflow | backup ]\n");

	exit(-1);
}

/* netlink socket */
static struct rtnl_handle genl_rth = { .fd = -1 };
static int genl_family = -1;

#define MPTCP_BUFLEN	4096
#define MPTCP_REQUEST(_req,  _cmd, _flags)	\
	GENL_REQUEST(_req, MPTCP_BUFLEN, genl_family, 0,	\
		     MPTCP_PM_VER, _cmd, _flags)

/* Mapping from argument to address flag mask */
static const struct {
	const char *name;
	unsigned long value;
} mptcp_addr_flag_names[] = {
	{ "signal",		MPTCP_PM_ADDR_FLAG_SIGNAL },
	{ "subflow",		MPTCP_PM_ADDR_FLAG_SUBFLOW },
	{ "backup",		MPTCP_PM_ADDR_FLAG_BACKUP },
};

static void print_mptcp_addr_flags(unsigned int flags)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(mptcp_addr_flag_names); i++) {
		unsigned long mask = mptcp_addr_flag_names[i].value;

		if (flags & mask) {
			print_string(PRINT_FP, NULL, "%s ",
				     mptcp_addr_flag_names[i].name);
			print_bool(PRINT_JSON,
				   mptcp_addr_flag_names[i].name, NULL, true);
		}

		flags &= ~mask;
	}

	if (flags) {
		/* unknown flags */
		SPRINT_BUF(b1);

		snprintf(b1, sizeof(b1), "%02x", flags);
		print_string(PRINT_ANY, "rawflags", "rawflags %s ", b1);
	}
}

static int get_flags(const char *arg, __u32 *flags)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(mptcp_addr_flag_names); i++) {
		if (strcmp(arg, mptcp_addr_flag_names[i].name))
			continue;

		*flags |= mptcp_addr_flag_names[i].value;
		return 0;
	}
	return -1;
}

static int mptcp_parse_opt(int argc, char **argv, struct nlmsghdr *n,
			 bool adding)
{
	struct rtattr *attr_addr;
	bool addr_set = false;
	inet_prefix address;
	bool id_set = false;
	__u32 index = 0;
	__u32 flags = 0;
	__u8 id = 0;

	ll_init_map(&rth);
	while (argc > 0) {
		if (get_flags(*argv, &flags) == 0) {
		} else if (matches(*argv, "id") == 0) {
			NEXT_ARG();

			if (get_u8(&id, *argv, 0))
				invarg("invalid ID\n", *argv);
			id_set = true;
		} else if (matches(*argv, "dev") == 0) {
			const char *ifname;

			NEXT_ARG();

			ifname = *argv;

			if (check_ifname(ifname))
				invarg("invalid interface name\n", ifname);

			index = ll_name_to_index(ifname);

			if (!index)
				invarg("device does not exist\n", ifname);

		} else if (get_addr(&address, *argv, AF_UNSPEC) == 0) {
			addr_set = true;
		} else {
			invarg("unknown argument", *argv);
		}
		NEXT_ARG_FWD();
	}

	if (!addr_set && adding)
		missarg("ADDRESS");

	if (!id_set && !adding)
		missarg("ID");

	attr_addr = addattr_nest(n, MPTCP_BUFLEN,
				 MPTCP_PM_ATTR_ADDR | NLA_F_NESTED);
	if (id_set)
		addattr8(n, MPTCP_BUFLEN, MPTCP_PM_ADDR_ATTR_ID, id);
	if (flags)
		addattr32(n, MPTCP_BUFLEN, MPTCP_PM_ADDR_ATTR_FLAGS, flags);
	if (index)
		addattr32(n, MPTCP_BUFLEN, MPTCP_PM_ADDR_ATTR_IF_IDX, index);
	if (addr_set) {
		int type;

		addattr16(n, MPTCP_BUFLEN, MPTCP_PM_ADDR_ATTR_FAMILY,
			  address.family);
		type = address.family == AF_INET ? MPTCP_PM_ADDR_ATTR_ADDR4 :
						   MPTCP_PM_ADDR_ATTR_ADDR6;
		addattr_l(n, MPTCP_BUFLEN, type, &address.data,
			  address.bytelen);
	}

	addattr_nest_end(n, attr_addr);
	return 0;
}

static int mptcp_addr_modify(int argc, char **argv, int cmd)
{
	MPTCP_REQUEST(req, cmd, NLM_F_REQUEST);
	int ret;

	ret = mptcp_parse_opt(argc, argv, &req.n, cmd == MPTCP_PM_CMD_ADD_ADDR);
	if (ret)
		return ret;

	if (rtnl_talk(&genl_rth, &req.n, NULL) < 0)
		return -2;

	return 0;
}

static int print_mptcp_addrinfo(struct rtattr *addrinfo)
{
	struct rtattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
	__u8 family = AF_UNSPEC, addr_attr_type;
	const char *ifname;
	unsigned int flags;
	int index;
	__u16 id;

	parse_rtattr_nested(tb, MPTCP_PM_ADDR_ATTR_MAX, addrinfo);

	open_json_object(NULL);
	if (tb[MPTCP_PM_ADDR_ATTR_FAMILY])
		family = rta_getattr_u8(tb[MPTCP_PM_ADDR_ATTR_FAMILY]);

	addr_attr_type = family == AF_INET ? MPTCP_PM_ADDR_ATTR_ADDR4 :
					     MPTCP_PM_ADDR_ATTR_ADDR6;
	if (tb[addr_attr_type]) {
		print_string(PRINT_ANY, "address", "%s ",
			     format_host_rta(family, tb[addr_attr_type]));
	}
	if (tb[MPTCP_PM_ADDR_ATTR_ID]) {
		id = rta_getattr_u8(tb[MPTCP_PM_ADDR_ATTR_ID]);
		print_uint(PRINT_ANY, "id", "id %u ", id);
	}
	if (tb[MPTCP_PM_ADDR_ATTR_FLAGS]) {
		flags = rta_getattr_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]);
		print_mptcp_addr_flags(flags);
	}
	if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) {
		index = rta_getattr_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]);
		ifname = index ? ll_index_to_name(index) : NULL;

		if (ifname)
			print_string(PRINT_ANY, "dev", "dev %s ", ifname);
	}

	close_json_object();
	print_string(PRINT_FP, NULL, "\n", NULL);
	fflush(stdout);

	return 0;
}

static int print_mptcp_addr(struct nlmsghdr *n, void *arg)
{
	struct rtattr *tb[MPTCP_PM_ATTR_MAX + 1];
	struct genlmsghdr *ghdr;
	struct rtattr *addrinfo;
	int len = n->nlmsg_len;

	if (n->nlmsg_type != genl_family)
		return 0;

	len -= NLMSG_LENGTH(GENL_HDRLEN);
	if (len < 0)
		return -1;

	ghdr = NLMSG_DATA(n);
	parse_rtattr_flags(tb, MPTCP_PM_ATTR_MAX, (void *) ghdr + GENL_HDRLEN,
			   len, NLA_F_NESTED);
	addrinfo = tb[MPTCP_PM_ATTR_ADDR];
	if (!addrinfo)
		return -1;

	ll_init_map(&rth);
	return print_mptcp_addrinfo(addrinfo);
}

static int mptcp_addr_dump(void)
{
	MPTCP_REQUEST(req, MPTCP_PM_CMD_GET_ADDR, NLM_F_REQUEST | NLM_F_DUMP);

	if (rtnl_send(&genl_rth, &req.n, req.n.nlmsg_len) < 0) {
		perror("Cannot send show request");
		exit(1);
	}

	new_json_obj(json);

	if (rtnl_dump_filter(&genl_rth, print_mptcp_addr, stdout) < 0) {
		fprintf(stderr, "Dump terminated\n");
		delete_json_obj();
		fflush(stdout);
		return -2;
	}

	close_json_object();
	fflush(stdout);
	return 0;
}

static int mptcp_addr_show(int argc, char **argv)
{
	MPTCP_REQUEST(req, MPTCP_PM_CMD_GET_ADDR, NLM_F_REQUEST);
	struct nlmsghdr *answer;
	int ret;

	if (argc <= 0)
		return mptcp_addr_dump();

	ret = mptcp_parse_opt(argc, argv, &req.n, false);
	if (ret)
		return ret;

	if (rtnl_talk(&genl_rth, &req.n, &answer) < 0)
		return -2;

	return print_mptcp_addr(answer, stdout);
}

static int mptcp_addr_flush(int argc, char **argv)
{
	MPTCP_REQUEST(req, MPTCP_PM_CMD_FLUSH_ADDRS, NLM_F_REQUEST);

	if (rtnl_talk(&genl_rth, &req.n, NULL) < 0)
		return -2;

	return 0;
}

static int mptcp_parse_limit(int argc, char **argv, struct nlmsghdr *n)
{
	bool set_rcv_add_addrs = false;
	bool set_subflows = false;
	__u32 rcv_add_addrs = 0;
	__u32 subflows = 0;

	while (argc > 0) {
		if (matches(*argv, "subflows") == 0) {
			NEXT_ARG();

			if (get_u32(&subflows, *argv, 0))
				invarg("invalid subflows\n", *argv);
			set_subflows = true;
		} else if (matches(*argv, "add_addr_accepted") == 0) {
			NEXT_ARG();

			if (get_u32(&rcv_add_addrs, *argv, 0))
				invarg("invalid add_addr_accepted\n", *argv);
			set_rcv_add_addrs = true;
		} else {
			invarg("unknown limit", *argv);
		}
		NEXT_ARG_FWD();
	}

	if (set_rcv_add_addrs)
		addattr32(n, MPTCP_BUFLEN, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
			  rcv_add_addrs);
	if (set_subflows)
		addattr32(n, MPTCP_BUFLEN, MPTCP_PM_ATTR_SUBFLOWS, subflows);
	return set_rcv_add_addrs || set_subflows;
}

static int print_mptcp_limit(struct nlmsghdr *n, void *arg)
{
	struct rtattr *tb[MPTCP_PM_ATTR_MAX + 1];
	struct genlmsghdr *ghdr;
	int len = n->nlmsg_len;
	__u32 val;

	if (n->nlmsg_type != genl_family)
		return 0;

	len -= NLMSG_LENGTH(GENL_HDRLEN);
	if (len < 0)
		return -1;

	ghdr = NLMSG_DATA(n);
	parse_rtattr(tb, MPTCP_PM_ATTR_MAX, (void *) ghdr + GENL_HDRLEN, len);

	open_json_object(NULL);
	if (tb[MPTCP_PM_ATTR_RCV_ADD_ADDRS]) {
		val = rta_getattr_u32(tb[MPTCP_PM_ATTR_RCV_ADD_ADDRS]);

		print_uint(PRINT_ANY, "add_addr_accepted",
			   "add_addr_accepted %d ", val);
	}

	if (tb[MPTCP_PM_ATTR_SUBFLOWS]) {
		val = rta_getattr_u32(tb[MPTCP_PM_ATTR_SUBFLOWS]);

		print_uint(PRINT_ANY, "subflows", "subflows %d ", val);
	}
	print_string(PRINT_FP, NULL, "%s", "\n");
	fflush(stdout);
	close_json_object();
	return 0;
}

static int mptcp_limit_get_set(int argc, char **argv, int cmd)
{
	bool do_get = cmd == MPTCP_PM_CMD_GET_LIMITS;
	MPTCP_REQUEST(req, cmd, NLM_F_REQUEST);
	struct nlmsghdr *answer;
	int ret;

	ret = mptcp_parse_limit(argc, argv, &req.n);
	if (ret < 0)
		return -1;

	if (rtnl_talk(&genl_rth, &req.n, do_get ? &answer : NULL) < 0)
		return -2;

	if (do_get)
		return print_mptcp_limit(answer, stdout);
	return 0;
}

int do_mptcp(int argc, char **argv)
{
	if (argc == 0)
		usage();

	if (matches(*argv, "help") == 0)
		usage();

	if (genl_init_handle(&genl_rth, MPTCP_PM_NAME, &genl_family))
		exit(1);

	if (matches(*argv, "endpoint") == 0) {
		NEXT_ARG_FWD();
		if (argc == 0)
			return mptcp_addr_show(0, NULL);

		if (matches(*argv, "add") == 0)
			return mptcp_addr_modify(argc-1, argv+1,
						 MPTCP_PM_CMD_ADD_ADDR);
		if (matches(*argv, "delete") == 0)
			return mptcp_addr_modify(argc-1, argv+1,
						 MPTCP_PM_CMD_DEL_ADDR);
		if (matches(*argv, "show") == 0)
			return mptcp_addr_show(argc-1, argv+1);
		if (matches(*argv, "flush") == 0)
			return mptcp_addr_flush(argc-1, argv+1);

		goto unknown;
	}

	if (matches(*argv, "limits") == 0) {
		NEXT_ARG_FWD();
		if (argc == 0)
			return mptcp_limit_get_set(0, NULL,
						   MPTCP_PM_CMD_GET_LIMITS);

		if (matches(*argv, "set") == 0)
			return mptcp_limit_get_set(argc-1, argv+1,
						   MPTCP_PM_CMD_SET_LIMITS);
		if (matches(*argv, "show") == 0)
			return mptcp_limit_get_set(argc-1, argv+1,
						   MPTCP_PM_CMD_GET_LIMITS);
	}

unknown:
	fprintf(stderr, "Command \"%s\" is unknown, try \"ip mptcp help\".\n",
		*argv);
	exit(-1);
}