// SPDX-License-Identifier: GPL-2.0+

#include <inttypes.h>

#include <stdio.h>

#include <linux/dcbnl.h>

#include <libmnl/libmnl.h>

#include <getopt.h>

#include "dcb.h"

#include "mnl_utils.h"

#include "namespace.h"

#include "utils.h"

#include "version.h"

static int dcb_init(struct dcb *dcb)

{

	dcb->buf = malloc(MNL_SOCKET_BUFFER_SIZE);

	if (dcb->buf == NULL) {

		perror("Netlink buffer allocation");

		return -1;

	}

	dcb->nl = mnlu_socket_open(NETLINK_ROUTE);

	if (dcb->nl == NULL) {

		perror("Open netlink socket");

		goto err_socket_open;

	}

	new_json_obj_plain(dcb->json_output);

	return 0;

err_socket_open:

	free(dcb->buf);

	return -1;

}

static void dcb_fini(struct dcb *dcb)

{

	delete_json_obj_plain();

	mnl_socket_close(dcb->nl);

	free(dcb->buf);

}

static struct dcb *dcb_alloc(void)

{

	struct dcb *dcb;

	dcb = calloc(1, sizeof(*dcb));

	if (!dcb)

		return NULL;

	return dcb;

}

static void dcb_free(struct dcb *dcb)

{

	free(dcb);

}

struct dcb_get_attribute {

	struct dcb *dcb;

	int attr;

	void *payload;

	__u16 payload_len;

};

static int dcb_get_attribute_attr_ieee_cb(const struct nlattr *attr, void *data)

{

	struct dcb_get_attribute *ga = data;

	if (mnl_attr_get_type(attr) != ga->attr)

		return MNL_CB_OK;

	ga->payload = mnl_attr_get_payload(attr);

	ga->payload_len = mnl_attr_get_payload_len(attr);

	return MNL_CB_STOP;

}

static int dcb_get_attribute_attr_cb(const struct nlattr *attr, void *data)

{

	if (mnl_attr_get_type(attr) != DCB_ATTR_IEEE)

		return MNL_CB_OK;

	return mnl_attr_parse_nested(attr, dcb_get_attribute_attr_ieee_cb, data);

}

static int dcb_get_attribute_cb(const struct nlmsghdr *nlh, void *data)

{

	return mnl_attr_parse(nlh, sizeof(struct dcbmsg), dcb_get_attribute_attr_cb, data);

}

static int dcb_get_attribute_bare_cb(const struct nlmsghdr *nlh, void *data)

{

	/* Bare attributes (e.g. DCB_ATTR_DCBX) are not wrapped inside an IEEE

	 * container, so this does not have to go through unpacking in

	 * dcb_get_attribute_attr_cb().

	 */

	return mnl_attr_parse(nlh, sizeof(struct dcbmsg),

			      dcb_get_attribute_attr_ieee_cb, data);

}

struct dcb_set_attribute_response {

	int response_attr;

};

static int dcb_set_attribute_attr_cb(const struct nlattr *attr, void *data)

{

	struct dcb_set_attribute_response *resp = data;

	uint16_t len;

	uint8_t err;

	if (mnl_attr_get_type(attr) != resp->response_attr)

		return MNL_CB_OK;

	len = mnl_attr_get_payload_len(attr);

	if (len != 1) {

		fprintf(stderr, "Response attribute expected to have size 1, not %d\n", len);

		return MNL_CB_ERROR;

	}

	err = mnl_attr_get_u8(attr);

	if (err) {

		fprintf(stderr, "Error when attempting to set attribute: %s\n",

			strerror(err));

		return MNL_CB_ERROR;

	}

	return MNL_CB_STOP;

}

static int dcb_set_attribute_cb(const struct nlmsghdr *nlh, void *data)

{

	return mnl_attr_parse(nlh, sizeof(struct dcbmsg), dcb_set_attribute_attr_cb, data);

}

static int dcb_talk(struct dcb *dcb, struct nlmsghdr *nlh, mnl_cb_t cb, void *data)

{

	int ret;

	ret = mnl_socket_sendto(dcb->nl, nlh, nlh->nlmsg_len);

	if (ret < 0) {

		perror("mnl_socket_sendto");

		return -1;

	}

	return mnlu_socket_recv_run(dcb->nl, nlh->nlmsg_seq, dcb->buf, MNL_SOCKET_BUFFER_SIZE,

				    cb, data);

}

static struct nlmsghdr *dcb_prepare(struct dcb *dcb, const char *dev,

				    uint32_t nlmsg_type, uint8_t dcb_cmd)

{

	struct dcbmsg dcbm = {

		.cmd = dcb_cmd,

	};

	struct nlmsghdr *nlh;

	nlh = mnlu_msg_prepare(dcb->buf, nlmsg_type, NLM_F_REQUEST, &dcbm, sizeof(dcbm));

	mnl_attr_put_strz(nlh, DCB_ATTR_IFNAME, dev);

	return nlh;

}

static int __dcb_get_attribute(struct dcb *dcb, int command,

			       const char *dev, int attr,

			       void **payload_p, __u16 *payload_len_p,

			       int (*get_attribute_cb)(const struct nlmsghdr *nlh,

						       void *data))

{

	struct dcb_get_attribute ga;

	struct nlmsghdr *nlh;

	int ret;

	nlh = dcb_prepare(dcb, dev, RTM_GETDCB, command);

	ga = (struct dcb_get_attribute) {

		.dcb = dcb,

		.attr = attr,

		.payload = NULL,

	};

	ret = dcb_talk(dcb, nlh, get_attribute_cb, &ga);

	if (ret) {

		perror("Attribute read");

		return ret;

	}

	if (ga.payload == NULL) {

		perror("Attribute not found");

		return -ENOENT;

	}

	*payload_p = ga.payload;

	*payload_len_p = ga.payload_len;

	return 0;

}

int dcb_get_attribute_va(struct dcb *dcb, const char *dev, int attr,

			 void **payload_p, __u16 *payload_len_p)

{

	return __dcb_get_attribute(dcb, DCB_CMD_IEEE_GET, dev, attr,

				   payload_p, payload_len_p,

				   dcb_get_attribute_cb);

}

int dcb_get_attribute_bare(struct dcb *dcb, int cmd, const char *dev, int attr,

			   void **payload_p, __u16 *payload_len_p)

{

	return __dcb_get_attribute(dcb, cmd, dev, attr,

				   payload_p, payload_len_p,

				   dcb_get_attribute_bare_cb);

}

int dcb_get_attribute(struct dcb *dcb, const char *dev, int attr, void *data, size_t data_len)

{

	__u16 payload_len;

	void *payload;

	int ret;

	ret = dcb_get_attribute_va(dcb, dev, attr, &payload, &payload_len);

	if (ret)

		return ret;

	if (payload_len != data_len) {

		fprintf(stderr, "Wrong len %d, expected %zd\n", payload_len, data_len);

		return -EINVAL;

	}

	memcpy(data, payload, data_len);

	return 0;

}

static int __dcb_set_attribute(struct dcb *dcb, int command, const char *dev,

			       int (*cb)(struct dcb *, struct nlmsghdr *, void *),

			       void *data, int response_attr)

{

	struct dcb_set_attribute_response resp = {

		.response_attr = response_attr,

	};

	struct nlmsghdr *nlh;

	int ret;

	nlh = dcb_prepare(dcb, dev, RTM_SETDCB, command);

	ret = cb(dcb, nlh, data);

	if (ret)

		return ret;

	ret = dcb_talk(dcb, nlh, dcb_set_attribute_cb, &resp);

	if (ret) {

		perror("Attribute write");

		return ret;

	}

	return 0;

}

struct dcb_set_attribute_ieee_cb {

	int (*cb)(struct dcb *dcb, struct nlmsghdr *nlh, void *data);

	void *data;

};

static int dcb_set_attribute_ieee_cb(struct dcb *dcb, struct nlmsghdr *nlh, void *data)

{

	struct dcb_set_attribute_ieee_cb *ieee_data = data;

	struct nlattr *nest;

	int ret;

	nest = mnl_attr_nest_start(nlh, DCB_ATTR_IEEE);

	ret = ieee_data->cb(dcb, nlh, ieee_data->data);

	if (ret)

		return ret;

	mnl_attr_nest_end(nlh, nest);

	return 0;

}

int dcb_set_attribute_va(struct dcb *dcb, int command, const char *dev,

			 int (*cb)(struct dcb *dcb, struct nlmsghdr *nlh, void *data),

			 void *data)

{

	struct dcb_set_attribute_ieee_cb ieee_data = {

		.cb = cb,

		.data = data,

	};

	return __dcb_set_attribute(dcb, command, dev,

				   &dcb_set_attribute_ieee_cb, &ieee_data,

				   DCB_ATTR_IEEE);

}

struct dcb_set_attribute {

	int attr;

	const void *data;

	size_t data_len;

};

static int dcb_set_attribute_put(struct dcb *dcb, struct nlmsghdr *nlh, void *data)

{

	struct dcb_set_attribute *dsa = data;

	mnl_attr_put(nlh, dsa->attr, dsa->data_len, dsa->data);

	return 0;

}

int dcb_set_attribute(struct dcb *dcb, const char *dev, int attr, const void *data, size_t data_len)

{

	struct dcb_set_attribute dsa = {

		.attr = attr,

		.data = data,

		.data_len = data_len,

	};

	return dcb_set_attribute_va(dcb, DCB_CMD_IEEE_SET, dev,

				    &dcb_set_attribute_put, &dsa;;

}

int dcb_set_attribute_bare(struct dcb *dcb, int command, const char *dev,

			   int attr, const void *data, size_t data_len,

			   int response_attr)

{

	struct dcb_set_attribute dsa = {

		.attr = attr,

		.data = data,

		.data_len = data_len,

	};

	return __dcb_set_attribute(dcb, command, dev,

				   &dcb_set_attribute_put, &dsa, response_attr);

}

void dcb_print_array_u8(const __u8 *array, size_t size)

{

	SPRINT_BUF(b);

	size_t i;

	for (i = 0; i < size; i++) {

		snprintf(b, sizeof(b), "%zd:%%d ", i);

		print_uint(PRINT_ANY, NULL, b, array[i]);

	}

}

void dcb_print_array_u64(const __u64 *array, size_t size)

{

	SPRINT_BUF(b);

	size_t i;

	for (i = 0; i < size; i++) {

		snprintf(b, sizeof(b), "%zd:%%" PRIu64 " ", i);

		print_u64(PRINT_ANY, NULL, b, array[i]);

	}

}

void dcb_print_array_on_off(const __u8 *array, size_t size)

{

	SPRINT_BUF(b);

	size_t i;

	for (i = 0; i < size; i++) {

		snprintf(b, sizeof(b), "%zd:%%s ", i);

		print_on_off(PRINT_ANY, NULL, b, array[i]);

	}

}

void dcb_print_array_kw(const __u8 *array, size_t array_size,

			const char *const kw[], size_t kw_size)

{

	SPRINT_BUF(b);

	size_t i;

	for (i = 0; i < array_size; i++) {

		__u8 emt = array[i];

		snprintf(b, sizeof(b), "%zd:%%s ", i);

		if (emt < kw_size && kw[emt])

			print_string(PRINT_ANY, NULL, b, kw[emt]);

		else

			print_string(PRINT_ANY, NULL, b, "???");

	}

}

void dcb_print_named_array(const char *json_name, const char *fp_name,

			   const __u8 *array, size_t size,

			   void (*print_array)(const __u8 *, size_t))

{

	open_json_array(PRINT_JSON, json_name);

	print_string(PRINT_FP, NULL, "%s ", fp_name);

	print_array(array, size);

	close_json_array(PRINT_JSON, json_name);

}

int dcb_parse_mapping(const char *what_key, __u32 key, __u32 max_key,

		      const char *what_value, __u64 value, __u64 max_value,

		      void (*set_array)(__u32 index, __u64 value, void *data),

		      void *set_array_data)

{

	bool is_all = key == (__u32) -1;

	if (!is_all && key > max_key) {

		fprintf(stderr, "In %s:%s mapping, %s is expected to be 0..%d\n",

			what_key, what_value, what_key, max_key);

		return -EINVAL;

	}

	if (value > max_value) {

		fprintf(stderr, "In %s:%s mapping, %s is expected to be 0..%llu\n",

			what_key, what_value, what_value, max_value);

		return -EINVAL;

	}

	if (is_all) {

		for (key = 0; key <= max_key; key++)

			set_array(key, value, set_array_data);

	} else {

		set_array(key, value, set_array_data);

	}

	return 0;

}

void dcb_set_u8(__u32 key, __u64 value, void *data)

{

	__u8 *array = data;

	array[key] = value;

}

void dcb_set_u32(__u32 key, __u64 value, void *data)

{

	__u32 *array = data;

	array[key] = value;

}

void dcb_set_u64(__u32 key, __u64 value, void *data)

{

	__u64 *array = data;

	array[key] = value;

}

int dcb_cmd_parse_dev(struct dcb *dcb, int argc, char **argv,

		      int (*and_then)(struct dcb *dcb, const char *dev,

				      int argc, char **argv),

		      void (*help)(void))

{

	const char *dev;

	if (!argc || matches(*argv, "help") == 0) {

		help();

		return 0;

	} else if (matches(*argv, "dev") == 0) {

		NEXT_ARG();

		dev = *argv;

		if (check_ifname(dev)) {

			invarg("not a valid ifname", *argv);

			return -EINVAL;

		}

		NEXT_ARG_FWD();

		return and_then(dcb, dev, argc, argv);

	} else {

		fprintf(stderr, "Expected `dev DEV', not `%s'", *argv);

		help();

		return -EINVAL;

	}

}

static void dcb_help(void)

{

	fprintf(stderr,

		"Usage: dcb [ OPTIONS ] OBJECT { COMMAND | help }\n"

		"       dcb [ -f | --force ] { -b | --batch } filename [ -n | --netns ] netnsname\n"

		"where  OBJECT := { app | buffer | dcbx | ets | maxrate | pfc }\n"

		"       OPTIONS := [ -V | --Version | -i | --iec | -j | --json\n"

		"                  | -N | --Numeric | -p | --pretty\n"

		"                  | -s | --statistics | -v | --verbose]\n");

}

static int dcb_cmd(struct dcb *dcb, int argc, char **argv)

{

	if (!argc || matches(*argv, "help") == 0) {

		dcb_help();

		return 0;

	} else if (matches(*argv, "app") == 0) {

		return dcb_cmd_app(dcb, argc - 1, argv + 1);

	} else if (matches(*argv, "buffer") == 0) {

		return dcb_cmd_buffer(dcb, argc - 1, argv + 1);

	} else if (matches(*argv, "dcbx") == 0) {

		return dcb_cmd_dcbx(dcb, argc - 1, argv + 1);

	} else if (matches(*argv, "ets") == 0) {

		return dcb_cmd_ets(dcb, argc - 1, argv + 1);

	} else if (matches(*argv, "maxrate") == 0) {

		return dcb_cmd_maxrate(dcb, argc - 1, argv + 1);

	} else if (matches(*argv, "pfc") == 0) {

		return dcb_cmd_pfc(dcb, argc - 1, argv + 1);

	}

	fprintf(stderr, "Object \"%s\" is unknown\n", *argv);

	return -ENOENT;

}

static int dcb_batch_cmd(int argc, char *argv[], void *data)

{

	struct dcb *dcb = data;

	return dcb_cmd(dcb, argc, argv);

}

static int dcb_batch(struct dcb *dcb, const char *name, bool force)

{

	return do_batch(name, force, dcb_batch_cmd, dcb);

}

int main(int argc, char **argv)

{

	static const struct option long_options[] = {

		{ "Version",		no_argument,		NULL, 'V' },

		{ "force",		no_argument,		NULL, 'f' },

		{ "batch",		required_argument,	NULL, 'b' },

		{ "iec",		no_argument,		NULL, 'i' },

		{ "json",		no_argument,		NULL, 'j' },

		{ "Numeric",		no_argument,		NULL, 'N' },

		{ "pretty",		no_argument,		NULL, 'p' },

		{ "statistics",		no_argument,		NULL, 's' },

		{ "netns",		required_argument,	NULL, 'n' },

		{ "help",		no_argument,		NULL, 'h' },

		{ NULL, 0, NULL, 0 }

	};

	const char *batch_file = NULL;

	bool force = false;

	struct dcb *dcb;

	int opt;

	int err;

	int ret;

	dcb = dcb_alloc();

	if (!dcb) {

		fprintf(stderr, "Failed to allocate memory for dcb\n");

		return EXIT_FAILURE;

	}

	while ((opt = getopt_long(argc, argv, "b:fhijn:psvNV",

				  long_options, NULL)) >= 0) {

		switch (opt) {

		case 'V':

			printf("dcb utility, iproute2-%s\n", version);

			ret = EXIT_SUCCESS;

			goto dcb_free;

		case 'f':

			force = true;

			break;

		case 'b':

			batch_file = optarg;

			break;

		case 'j':

			dcb->json_output = true;

			break;

		case 'N':

			dcb->numeric = true;

			break;

		case 'p':

			pretty = true;

			break;

		case 's':

			dcb->stats = true;

			break;

		case 'n':

			if (netns_switch(optarg)) {

				ret = EXIT_FAILURE;

				goto dcb_free;

			}

			break;

		case 'i':

			dcb->use_iec = true;

			break;

		case 'h':

			dcb_help();

			return 0;

		default:

			fprintf(stderr, "Unknown option.\n");

			dcb_help();

			ret = EXIT_FAILURE;

			goto dcb_free;

		}

	}

	argc -= optind;

	argv += optind;

	err = dcb_init(dcb);

	if (err) {

		ret = EXIT_FAILURE;

		goto dcb_free;

	}

	if (batch_file)

		err = dcb_batch(dcb, batch_file, force);

	else

		err = dcb_cmd(dcb, argc, argv);

	if (err) {

		ret = EXIT_FAILURE;

		goto dcb_fini;

	}

	ret = EXIT_SUCCESS;

dcb_fini:

	dcb_fini(dcb);

dcb_free:

	dcb_free(dcb);

	return ret;

}