[mirror_iproute2.git] / tc / m_tunnel_key.c

/*
 * m_tunnel_key.c	ip tunnel manipulation module
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Authors:     Amir Vadai <amir@vadai.me>
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <linux/if_ether.h>
#include "utils.h"
#include "rt_names.h"
#include "tc_util.h"
#include <linux/tc_act/tc_tunnel_key.h>

static void explain(void)
{
	fprintf(stderr, "Usage: tunnel_key unset\n");
	fprintf(stderr, "       tunnel_key set <TUNNEL_KEY>\n");
	fprintf(stderr,
		"Where TUNNEL_KEY is a combination of:\n"
		"id <TUNNELID> (mandatory)\n"
		"src_ip <IP> (mandatory)\n"
		"dst_ip <IP> (mandatory)\n"
		"dst_port <UDP_PORT>\n"
		"geneve_opts <OPTIONS>\n"
		"csum | nocsum (default is \"csum\")\n");
}

static void usage(void)
{
	explain();
	exit(-1);
}

static int tunnel_key_parse_ip_addr(const char *str, int addr4_type,
				    int addr6_type, struct nlmsghdr *n)
{
	inet_prefix addr;
	int ret;

	ret = get_addr(&addr, str, AF_UNSPEC);
	if (ret)
		return ret;

	addattr_l(n, MAX_MSG, addr.family == AF_INET ? addr4_type : addr6_type,
		  addr.data, addr.bytelen);

	return 0;
}

static int tunnel_key_parse_key_id(const char *str, int type,
				   struct nlmsghdr *n)
{
	__be32 key_id;
	int ret;

	ret = get_be32(&key_id, str, 10);
	if (!ret)
		addattr32(n, MAX_MSG, type, key_id);

	return ret;
}

static int tunnel_key_parse_dst_port(char *str, int type, struct nlmsghdr *n)
{
	int ret;
	__be16 dst_port;

	ret = get_be16(&dst_port, str, 10);
	if (ret)
		return -1;

	addattr16(n, MAX_MSG, type, dst_port);

	return 0;
}

static int tunnel_key_parse_be16(char *str, int base, int type,
				 struct nlmsghdr *n)
{
	int ret;
	__be16 value;

	ret = get_be16(&value, str, base);
	if (ret)
		return ret;

	addattr16(n, MAX_MSG, type, value);

	return 0;
}

static int tunnel_key_parse_u8(char *str, int base, int type,
			       struct nlmsghdr *n)
{
	int ret;
	__u8 value;

	ret = get_u8(&value, str, base);
	if (ret)
		return ret;

	addattr8(n, MAX_MSG, type, value);

	return 0;
}

static int tunnel_key_parse_geneve_opt(char *str, struct nlmsghdr *n)
{
	char *token, *saveptr = NULL;
	struct rtattr *nest;
	int i, ret;

	nest = addattr_nest(n, MAX_MSG, TCA_TUNNEL_KEY_ENC_OPTS_GENEVE);

	token = strtok_r(str, ":", &saveptr);
	i = 1;
	while (token) {
		switch (i) {
		case TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS:
		{
			ret = tunnel_key_parse_be16(token, 16, i, n);
			if (ret)
				return ret;
			break;
		}
		case TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE:
		{
			ret = tunnel_key_parse_u8(token, 16, i, n);
			if (ret)
				return ret;
			break;
		}
		case TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA:
		{
			size_t token_len = strlen(token);
			uint8_t *opts;

			opts = malloc(token_len / 2);
			if (!opts)
				return -1;
			if (hex2mem(token, opts, token_len / 2) < 0) {
				free(opts);
				return -1;
			}
			addattr_l(n, MAX_MSG, i, opts, token_len / 2);
			free(opts);

			break;
		}
		default:
			return -1;
		}

		token = strtok_r(NULL, ":", &saveptr);
		i++;
	}

	addattr_nest_end(n, nest);

	return 0;
}

static int tunnel_key_parse_geneve_opts(char *str, struct nlmsghdr *n)
{
	char *token, *saveptr = NULL;
	struct rtattr *nest;
	int ret;

	nest = addattr_nest(n, MAX_MSG, TCA_TUNNEL_KEY_ENC_OPTS);

	token = strtok_r(str, ",", &saveptr);
	while (token) {
		ret = tunnel_key_parse_geneve_opt(token, n);
		if (ret)
			return ret;

		token = strtok_r(NULL, ",", &saveptr);
	}

	addattr_nest_end(n, nest);

	return 0;
}

static int tunnel_key_parse_tos_ttl(char *str, int type, struct nlmsghdr *n)
{
	int ret;
	__u8 val;

	ret = get_u8(&val, str, 10);
	if (ret)
		ret = get_u8(&val, str, 16);
	if (ret)
		return -1;

	addattr8(n, MAX_MSG, type, val);

	return 0;
}

static int parse_tunnel_key(struct action_util *a, int *argc_p, char ***argv_p,
			    int tca_id, struct nlmsghdr *n)
{
	struct tc_tunnel_key parm = {};
	char **argv = *argv_p;
	int argc = *argc_p;
	struct rtattr *tail;
	int action = 0;
	int ret;
	int has_src_ip = 0;
	int has_dst_ip = 0;
	int has_key_id = 0;
	int csum = 1;

	if (matches(*argv, "tunnel_key") != 0)
		return -1;

	tail = addattr_nest(n, MAX_MSG, tca_id);

	NEXT_ARG();

	while (argc > 0) {
		if (matches(*argv, "unset") == 0) {
			if (action) {
				fprintf(stderr, "unexpected \"%s\" - action already specified\n",
					*argv);
				explain();
				return -1;
			}
			action = TCA_TUNNEL_KEY_ACT_RELEASE;
		} else if (matches(*argv, "set") == 0) {
			if (action) {
				fprintf(stderr, "unexpected \"%s\" - action already specified\n",
					*argv);
				explain();
				return -1;
			}
			action = TCA_TUNNEL_KEY_ACT_SET;
		} else if (matches(*argv, "src_ip") == 0) {
			NEXT_ARG();
			ret = tunnel_key_parse_ip_addr(*argv,
						       TCA_TUNNEL_KEY_ENC_IPV4_SRC,
						       TCA_TUNNEL_KEY_ENC_IPV6_SRC,
						       n);
			if (ret < 0) {
				fprintf(stderr, "Illegal \"src_ip\"\n");
				return -1;
			}
			has_src_ip = 1;
		} else if (matches(*argv, "dst_ip") == 0) {
			NEXT_ARG();
			ret = tunnel_key_parse_ip_addr(*argv,
						       TCA_TUNNEL_KEY_ENC_IPV4_DST,
						       TCA_TUNNEL_KEY_ENC_IPV6_DST,
						       n);
			if (ret < 0) {
				fprintf(stderr, "Illegal \"dst_ip\"\n");
				return -1;
			}
			has_dst_ip = 1;
		} else if (matches(*argv, "id") == 0) {
			NEXT_ARG();
			ret = tunnel_key_parse_key_id(*argv, TCA_TUNNEL_KEY_ENC_KEY_ID, n);
			if (ret < 0) {
				fprintf(stderr, "Illegal \"id\"\n");
				return -1;
			}
			has_key_id = 1;
		} else if (matches(*argv, "dst_port") == 0) {
			NEXT_ARG();
			ret = tunnel_key_parse_dst_port(*argv,
							TCA_TUNNEL_KEY_ENC_DST_PORT, n);
			if (ret < 0) {
				fprintf(stderr, "Illegal \"dst port\"\n");
				return -1;
			}
		} else if (matches(*argv, "geneve_opts") == 0) {
			NEXT_ARG();

			if (tunnel_key_parse_geneve_opts(*argv, n)) {
				fprintf(stderr, "Illegal \"geneve_opts\"\n");
				return -1;
			}
		} else if (matches(*argv, "tos") == 0) {
			NEXT_ARG();
			ret = tunnel_key_parse_tos_ttl(*argv,
							TCA_TUNNEL_KEY_ENC_TOS, n);
			if (ret < 0) {
				fprintf(stderr, "Illegal \"tos\"\n");
				return -1;
			}
		} else if (matches(*argv, "ttl") == 0) {
			NEXT_ARG();
			ret = tunnel_key_parse_tos_ttl(*argv,
							TCA_TUNNEL_KEY_ENC_TTL, n);
			if (ret < 0) {
				fprintf(stderr, "Illegal \"ttl\"\n");
				return -1;
			}
		} else if (matches(*argv, "csum") == 0) {
			csum = 1;
		} else if (matches(*argv, "nocsum") == 0) {
			csum = 0;
		} else if (matches(*argv, "help") == 0) {
			usage();
		} else {
			break;
		}
		NEXT_ARG_FWD();
	}

	addattr8(n, MAX_MSG, TCA_TUNNEL_KEY_NO_CSUM, !csum);

	parse_action_control_dflt(&argc, &argv, &parm.action,
				  false, TC_ACT_PIPE);

	if (argc) {
		if (matches(*argv, "index") == 0) {
			NEXT_ARG();
			if (get_u32(&parm.index, *argv, 10)) {
				fprintf(stderr, "tunnel_key: Illegal \"index\"\n");
				return -1;
			}

			NEXT_ARG_FWD();
		}
	}

	if (action == TCA_TUNNEL_KEY_ACT_SET &&
	    (!has_src_ip || !has_dst_ip || !has_key_id)) {
		fprintf(stderr, "set needs tunnel_key parameters\n");
		explain();
		return -1;
	}

	parm.t_action = action;
	addattr_l(n, MAX_MSG, TCA_TUNNEL_KEY_PARMS, &parm, sizeof(parm));
	addattr_nest_end(n, tail);

	*argc_p = argc;
	*argv_p = argv;

	return 0;
}

static void tunnel_key_print_ip_addr(FILE *f, const char *name,
				     struct rtattr *attr)
{
	int family;
	size_t len;

	if (!attr)
		return;

	len = RTA_PAYLOAD(attr);

	if (len == 4)
		family = AF_INET;
	else if (len == 16)
		family = AF_INET6;
	else
		return;

	print_string(PRINT_FP, NULL, "%s", _SL_);
	if (matches(name, "src_ip") == 0)
		print_string(PRINT_ANY, "src_ip", "\tsrc_ip %s",
			     rt_addr_n2a_rta(family, attr));
	else if (matches(name, "dst_ip") == 0)
		print_string(PRINT_ANY, "dst_ip", "\tdst_ip %s",
			     rt_addr_n2a_rta(family, attr));
}

static void tunnel_key_print_key_id(FILE *f, const char *name,
				    struct rtattr *attr)
{
	if (!attr)
		return;
	print_string(PRINT_FP, NULL, "%s", _SL_);
	print_uint(PRINT_ANY, "key_id", "\tkey_id %u", rta_getattr_be32(attr));
}

static void tunnel_key_print_dst_port(FILE *f, char *name,
				      struct rtattr *attr)
{
	if (!attr)
		return;
	print_string(PRINT_FP, NULL, "%s", _SL_);
	print_uint(PRINT_ANY, "dst_port", "\tdst_port %u",
		   rta_getattr_be16(attr));
}

static void tunnel_key_print_flag(FILE *f, const char *name_on,
				  const char *name_off,
				  struct rtattr *attr)
{
	if (!attr)
		return;
	print_string(PRINT_FP, NULL, "%s", _SL_);
	print_string(PRINT_ANY, "flag", "\t%s",
		     rta_getattr_u8(attr) ? name_on : name_off);
}

static void tunnel_key_print_geneve_options(const char *name,
					    struct rtattr *attr)
{
	struct rtattr *tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1];
	struct rtattr *i = RTA_DATA(attr);
	int ii, data_len = 0, offset = 0;
	int rem = RTA_PAYLOAD(attr);
	char strbuf[rem * 2 + 1];
	char data[rem * 2 + 1];
	uint8_t data_r[rem];
	uint16_t clss;
	uint8_t type;

	open_json_array(PRINT_JSON, name);
	print_string(PRINT_FP, name, "\n\t%s ", "geneve_opt");

	while (rem) {
		parse_rtattr(tb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX, i, rem);
		clss = rta_getattr_be16(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS]);
		type = rta_getattr_u8(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE]);
		data_len = RTA_PAYLOAD(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]);
		hexstring_n2a(RTA_DATA(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]),
			      data_len, data, sizeof(data));
		hex2mem(data, data_r, data_len);
		offset += data_len + 20;
		rem -= data_len + 20;
		i = RTA_DATA(attr) + offset;

		open_json_object(NULL);
		print_uint(PRINT_JSON, "class", NULL, clss);
		print_uint(PRINT_JSON, "type", NULL, type);
		open_json_array(PRINT_JSON, "data");
		for (ii = 0; ii < data_len; ii++)
			print_uint(PRINT_JSON, NULL, NULL, data_r[ii]);
		close_json_array(PRINT_JSON, "data");
		close_json_object();

		sprintf(strbuf, "%04x:%02x:%s", clss, type, data);
		if (rem)
			print_string(PRINT_FP, NULL, "%s,", strbuf);
		else
			print_string(PRINT_FP, NULL, "%s", strbuf);
	}

	close_json_array(PRINT_JSON, name);
}

static void tunnel_key_print_key_opt(const char *name, struct rtattr *attr)
{
	struct rtattr *tb[TCA_TUNNEL_KEY_ENC_OPTS_MAX + 1];

	if (!attr)
		return;

	parse_rtattr_nested(tb, TCA_TUNNEL_KEY_ENC_OPTS_MAX, attr);
	tunnel_key_print_geneve_options(name,
					tb[TCA_TUNNEL_KEY_ENC_OPTS_GENEVE]);
}

static void tunnel_key_print_tos_ttl(FILE *f, char *name,
				     struct rtattr *attr)
{
	if (!attr)
		return;

	if (matches(name, "tos") == 0 && rta_getattr_u8(attr) != 0) {
		print_string(PRINT_FP, NULL, "%s", _SL_);
		print_uint(PRINT_ANY, "tos", "\ttos 0x%x",
			   rta_getattr_u8(attr));
	} else if (matches(name, "ttl") == 0 && rta_getattr_u8(attr) != 0) {
		print_string(PRINT_FP, NULL, "%s", _SL_);
		print_uint(PRINT_ANY, "ttl", "\tttl %u",
			   rta_getattr_u8(attr));
	}
}

static int print_tunnel_key(struct action_util *au, FILE *f, struct rtattr *arg)
{
	struct rtattr *tb[TCA_TUNNEL_KEY_MAX + 1];
	struct tc_tunnel_key *parm;

	if (!arg)
		return -1;

	parse_rtattr_nested(tb, TCA_TUNNEL_KEY_MAX, arg);

	if (!tb[TCA_TUNNEL_KEY_PARMS]) {
		print_string(PRINT_FP, NULL, "%s",
			     "[NULL tunnel_key parameters]");
		return -1;
	}
	parm = RTA_DATA(tb[TCA_TUNNEL_KEY_PARMS]);

	print_string(PRINT_ANY, "kind", "%s ", "tunnel_key");

	switch (parm->t_action) {
	case TCA_TUNNEL_KEY_ACT_RELEASE:
		print_string(PRINT_ANY, "mode", " %s", "unset");
		break;
	case TCA_TUNNEL_KEY_ACT_SET:
		print_string(PRINT_ANY, "mode", " %s", "set");
		tunnel_key_print_ip_addr(f, "src_ip",
					 tb[TCA_TUNNEL_KEY_ENC_IPV4_SRC]);
		tunnel_key_print_ip_addr(f, "dst_ip",
					 tb[TCA_TUNNEL_KEY_ENC_IPV4_DST]);
		tunnel_key_print_ip_addr(f, "src_ip",
					 tb[TCA_TUNNEL_KEY_ENC_IPV6_SRC]);
		tunnel_key_print_ip_addr(f, "dst_ip",
					 tb[TCA_TUNNEL_KEY_ENC_IPV6_DST]);
		tunnel_key_print_key_id(f, "key_id",
					tb[TCA_TUNNEL_KEY_ENC_KEY_ID]);
		tunnel_key_print_dst_port(f, "dst_port",
					  tb[TCA_TUNNEL_KEY_ENC_DST_PORT]);
		tunnel_key_print_key_opt("geneve_opts",
					 tb[TCA_TUNNEL_KEY_ENC_OPTS]);
		tunnel_key_print_flag(f, "nocsum", "csum",
				      tb[TCA_TUNNEL_KEY_NO_CSUM]);
		tunnel_key_print_tos_ttl(f, "tos",
					  tb[TCA_TUNNEL_KEY_ENC_TOS]);
		tunnel_key_print_tos_ttl(f, "ttl",
					  tb[TCA_TUNNEL_KEY_ENC_TTL]);
		break;
	}
	print_action_control(f, " ", parm->action, "");

	print_string(PRINT_FP, NULL, "%s", _SL_);
	print_uint(PRINT_ANY, "index", "\t index %u", parm->index);
	print_int(PRINT_ANY, "ref", " ref %d", parm->refcnt);
	print_int(PRINT_ANY, "bind", " bind %d", parm->bindcnt);

	if (show_stats) {
		if (tb[TCA_TUNNEL_KEY_TM]) {
			struct tcf_t *tm = RTA_DATA(tb[TCA_TUNNEL_KEY_TM]);

			print_tm(f, tm);
		}
	}

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

	return 0;
}

struct action_util tunnel_key_action_util = {
	.id = "tunnel_key",
	.parse_aopt = parse_tunnel_key,
	.print_aopt = print_tunnel_key,
};
Commit	Line	Data
d57639a4 AV	1	/*
	2	* m_tunnel_key.c ip tunnel manipulation module
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*
	9	* Authors: Amir Vadai <amir@vadai.me>
	10	*/
	11
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <unistd.h>
	15	#include <string.h>
	16	#include <linux/if_ether.h>
	17	#include "utils.h"
	18	#include "rt_names.h"
	19	#include "tc_util.h"
	20	#include <linux/tc_act/tc_tunnel_key.h>
	21
	22	static void explain(void)
	23	{
	24	fprintf(stderr, "Usage: tunnel_key unset\n");
50907a82 JB	25	fprintf(stderr, " tunnel_key set <TUNNEL_KEY>\n");
	26	fprintf(stderr,
	27	"Where TUNNEL_KEY is a combination of:\n"
	28	"id <TUNNELID> (mandatory)\n"
	29	"src_ip <IP> (mandatory)\n"
	30	"dst_ip <IP> (mandatory)\n"
59eb271d	31	"dst_port <UDP_PORT>\n"
6217917a	32	"geneve_opts <OPTIONS>\n"
59eb271d	33	"csum \| nocsum (default is \"csum\")\n");
d57639a4 AV	34	}
	35
	36	static void usage(void)
	37	{
	38	explain();
	39	exit(-1);
	40	}
	41
	42	static int tunnel_key_parse_ip_addr(const char *str, int addr4_type,
	43	int addr6_type, struct nlmsghdr *n)
	44	{
	45	inet_prefix addr;
	46	int ret;
	47
	48	ret = get_addr(&addr, str, AF_UNSPEC);
	49	if (ret)
	50	return ret;
	51
	52	addattr_l(n, MAX_MSG, addr.family == AF_INET ? addr4_type : addr6_type,
	53	addr.data, addr.bytelen);
	54
	55	return 0;
	56	}
	57
	58	static int tunnel_key_parse_key_id(const char *str, int type,
	59	struct nlmsghdr *n)
	60	{
	61	__be32 key_id;
	62	int ret;
	63
	64	ret = get_be32(&key_id, str, 10);
	65	if (!ret)
	66	addattr32(n, MAX_MSG, type, key_id);
	67
	68	return ret;
	69	}
	70
449c709c HHZ	71	static int tunnel_key_parse_dst_port(char str, int type, struct nlmsghdr n)
	72	{
	73	int ret;
	74	__be16 dst_port;
	75
	76	ret = get_be16(&dst_port, str, 10);
	77	if (ret)
	78	return -1;
	79
	80	addattr16(n, MAX_MSG, type, dst_port);
	81
	82	return 0;
	83	}
	84
6217917a SH	85	static int tunnel_key_parse_be16(char *str, int base, int type,
	86	struct nlmsghdr *n)
	87	{
	88	int ret;
	89	__be16 value;
	90
	91	ret = get_be16(&value, str, base);
	92	if (ret)
	93	return ret;
	94
	95	addattr16(n, MAX_MSG, type, value);
	96
	97	return 0;
	98	}
	99
	100	static int tunnel_key_parse_u8(char *str, int base, int type,
	101	struct nlmsghdr *n)
	102	{
	103	int ret;
	104	__u8 value;
	105
	106	ret = get_u8(&value, str, base);
	107	if (ret)
	108	return ret;
	109
	110	addattr8(n, MAX_MSG, type, value);
	111
	112	return 0;
	113	}
	114
	115	static int tunnel_key_parse_geneve_opt(char str, struct nlmsghdr n)
	116	{
	117	char token, saveptr = NULL;
	118	struct rtattr *nest;
	119	int i, ret;
	120
	121	nest = addattr_nest(n, MAX_MSG, TCA_TUNNEL_KEY_ENC_OPTS_GENEVE);
	122
	123	token = strtok_r(str, ":", &saveptr);
	124	i = 1;
	125	while (token) {
	126	switch (i) {
	127	case TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS:
	128	{
	129	ret = tunnel_key_parse_be16(token, 16, i, n);
	130	if (ret)
	131	return ret;
	132	break;
	133	}
	134	case TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE:
	135	{
	136	ret = tunnel_key_parse_u8(token, 16, i, n);
	137	if (ret)
	138	return ret;
	139	break;
	140	}
	141	case TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA:
	142	{
	143	size_t token_len = strlen(token);
	144	uint8_t *opts;
	145
	146	opts = malloc(token_len / 2);
	147	if (!opts)
	148	return -1;
149	if (hex2mem(token, opts, token_len / 2) < 0) {
150	free(opts);
151	return -1;
152	}
153	addattr_l(n, MAX_MSG, i, opts, token_len / 2);
154	free(opts);
155
156	break;
157	}
158	default:
159	return -1;
160	}
161
162	token = strtok_r(NULL, ":", &saveptr);
163	i++;
164	}
165
166	addattr_nest_end(n, nest);
167
168	return 0;
169	}
170
171	static int tunnel_key_parse_geneve_opts(char str, struct nlmsghdr n)
172	{
173	char token, saveptr = NULL;
174	struct rtattr *nest;
175	int ret;
176
177	nest = addattr_nest(n, MAX_MSG, TCA_TUNNEL_KEY_ENC_OPTS);
178
179	token = strtok_r(str, ",", &saveptr);
180	while (token) {
181	ret = tunnel_key_parse_geneve_opt(token, n);
182	if (ret)
183	return ret;
184
185	token = strtok_r(NULL, ",", &saveptr);
186	}
187
188	addattr_nest_end(n, nest);
189
190	return 0;
191	}
192
9f89b0cc OG	193	static int tunnel_key_parse_tos_ttl(char str, int type, struct nlmsghdr n)
	194	{
	195	int ret;
	196	__u8 val;
	197
	198	ret = get_u8(&val, str, 10);
	199	if (ret)
	200	ret = get_u8(&val, str, 16);
	201	if (ret)
	202	return -1;
	203
	204	addattr8(n, MAX_MSG, type, val);
	205
	206	return 0;
	207	}
	208
d57639a4 AV	209	static int parse_tunnel_key(struct action_util a, int argc_p, char ***argv_p,
	210	int tca_id, struct nlmsghdr *n)
	211	{
e67aba55	212	struct tc_tunnel_key parm = {};
d57639a4 AV	213	char *argv = argv_p;
	214	int argc = *argc_p;
	215	struct rtattr *tail;
	216	int action = 0;
	217	int ret;
	218	int has_src_ip = 0;
	219	int has_dst_ip = 0;
	220	int has_key_id = 0;
59eb271d	221	int csum = 1;
d57639a4 AV	222
	223	if (matches(*argv, "tunnel_key") != 0)
	224	return -1;
	225
c14f9d92	226	tail = addattr_nest(n, MAX_MSG, tca_id);
d57639a4 AV	227
	228	NEXT_ARG();
	229
	230	while (argc > 0) {
	231	if (matches(*argv, "unset") == 0) {
	232	if (action) {
	233	fprintf(stderr, "unexpected \"%s\" - action already specified\n",
	234	*argv);
	235	explain();
	236	return -1;
	237	}
	238	action = TCA_TUNNEL_KEY_ACT_RELEASE;
	239	} else if (matches(*argv, "set") == 0) {
	240	if (action) {
	241	fprintf(stderr, "unexpected \"%s\" - action already specified\n",
	242	*argv);
	243	explain();
	244	return -1;
	245	}
	246	action = TCA_TUNNEL_KEY_ACT_SET;
	247	} else if (matches(*argv, "src_ip") == 0) {
	248	NEXT_ARG();
	249	ret = tunnel_key_parse_ip_addr(*argv,
	250	TCA_TUNNEL_KEY_ENC_IPV4_SRC,
	251	TCA_TUNNEL_KEY_ENC_IPV6_SRC,
	252	n);
	253	if (ret < 0) {
	254	fprintf(stderr, "Illegal \"src_ip\"\n");
	255	return -1;
	256	}
	257	has_src_ip = 1;
	258	} else if (matches(*argv, "dst_ip") == 0) {
	259	NEXT_ARG();
	260	ret = tunnel_key_parse_ip_addr(*argv,
	261	TCA_TUNNEL_KEY_ENC_IPV4_DST,
	262	TCA_TUNNEL_KEY_ENC_IPV6_DST,
	263	n);
	264	if (ret < 0) {
	265	fprintf(stderr, "Illegal \"dst_ip\"\n");
	266	return -1;
	267	}
	268	has_dst_ip = 1;
	269	} else if (matches(*argv, "id") == 0) {
	270	NEXT_ARG();
	271	ret = tunnel_key_parse_key_id(*argv, TCA_TUNNEL_KEY_ENC_KEY_ID, n);
	272	if (ret < 0) {
	273	fprintf(stderr, "Illegal \"id\"\n");
	274	return -1;
	275	}
	276	has_key_id = 1;
449c709c HHZ	277	} else if (matches(*argv, "dst_port") == 0) {
	278	NEXT_ARG();
	279	ret = tunnel_key_parse_dst_port(*argv,
	280	TCA_TUNNEL_KEY_ENC_DST_PORT, n);
	281	if (ret < 0) {
	282	fprintf(stderr, "Illegal \"dst port\"\n");
	283	return -1;
	284	}
6217917a SH	285	} else if (matches(*argv, "geneve_opts") == 0) {
	286	NEXT_ARG();
	287
	288	if (tunnel_key_parse_geneve_opts(*argv, n)) {
	289	fprintf(stderr, "Illegal \"geneve_opts\"\n");
	290	return -1;
	291	}
9f89b0cc OG	292	} else if (matches(*argv, "tos") == 0) {
	293	NEXT_ARG();
	294	ret = tunnel_key_parse_tos_ttl(*argv,
	295	TCA_TUNNEL_KEY_ENC_TOS, n);
	296	if (ret < 0) {
	297	fprintf(stderr, "Illegal \"tos\"\n");
	298	return -1;
	299	}
	300	} else if (matches(*argv, "ttl") == 0) {
	301	NEXT_ARG();
	302	ret = tunnel_key_parse_tos_ttl(*argv,
	303	TCA_TUNNEL_KEY_ENC_TTL, n);
	304	if (ret < 0) {
	305	fprintf(stderr, "Illegal \"ttl\"\n");
	306	return -1;
	307	}
59eb271d JB	308	} else if (matches(*argv, "csum") == 0) {
	309	csum = 1;
	310	} else if (matches(*argv, "nocsum") == 0) {
	311	csum = 0;
d57639a4 AV	312	} else if (matches(*argv, "help") == 0) {
	313	usage();
	314	} else {
	315	break;
	316	}
	317	NEXT_ARG_FWD();
	318	}
	319
59eb271d JB	320	addattr8(n, MAX_MSG, TCA_TUNNEL_KEY_NO_CSUM, !csum);
59eb271d JB	321
e67aba55 JP	322	parse_action_control_dflt(&argc, &argv, &parm.action,
e67aba55 JP	323	false, TC_ACT_PIPE);
d57639a4 AV	324
	325	if (argc) {
	326	if (matches(*argv, "index") == 0) {
	327	NEXT_ARG();
	328	if (get_u32(&parm.index, *argv, 10)) {
	329	fprintf(stderr, "tunnel_key: Illegal \"index\"\n");
	330	return -1;
	331	}
	332
	333	NEXT_ARG_FWD();
	334	}
	335	}
	336
	337	if (action == TCA_TUNNEL_KEY_ACT_SET &&
	338	(!has_src_ip \|\| !has_dst_ip \|\| !has_key_id)) {
	339	fprintf(stderr, "set needs tunnel_key parameters\n");
	340	explain();
	341	return -1;
	342	}
	343
	344	parm.t_action = action;
	345	addattr_l(n, MAX_MSG, TCA_TUNNEL_KEY_PARMS, &parm, sizeof(parm));
c14f9d92	346	addattr_nest_end(n, tail);
d57639a4 AV	347
	348	*argc_p = argc;
	349	*argv_p = argv;
	350
	351	return 0;
	352	}
	353
	354	static void tunnel_key_print_ip_addr(FILE f, const char name,
	355	struct rtattr *attr)
	356	{
	357	int family;
	358	size_t len;
	359
	360	if (!attr)
	361	return;
	362
	363	len = RTA_PAYLOAD(attr);
	364
	365	if (len == 4)
	366	family = AF_INET;
	367	else if (len == 16)
	368	family = AF_INET6;
	369	else
	370	return;
	371
8feb516b RM	372	print_string(PRINT_FP, NULL, "%s", _SL_);
	373	if (matches(name, "src_ip") == 0)
	374	print_string(PRINT_ANY, "src_ip", "\tsrc_ip %s",
	375	rt_addr_n2a_rta(family, attr));
	376	else if (matches(name, "dst_ip") == 0)
	377	print_string(PRINT_ANY, "dst_ip", "\tdst_ip %s",
	378	rt_addr_n2a_rta(family, attr));
d57639a4 AV	379	}
	380
	381	static void tunnel_key_print_key_id(FILE f, const char name,
	382	struct rtattr *attr)
	383	{
	384	if (!attr)
	385	return;
8feb516b RM	386	print_string(PRINT_FP, NULL, "%s", _SL_);
8feb516b RM	387	print_uint(PRINT_ANY, "key_id", "\tkey_id %u", rta_getattr_be32(attr));
d57639a4 AV	388	}
d57639a4 AV	389
449c709c HHZ	390	static void tunnel_key_print_dst_port(FILE f, char name,
	391	struct rtattr *attr)
	392	{
	393	if (!attr)
	394	return;
8feb516b RM	395	print_string(PRINT_FP, NULL, "%s", _SL_);
	396	print_uint(PRINT_ANY, "dst_port", "\tdst_port %u",
	397	rta_getattr_be16(attr));
449c709c HHZ	398	}
449c709c HHZ	399
59eb271d JB	400	static void tunnel_key_print_flag(FILE f, const char name_on,
	401	const char *name_off,
	402	struct rtattr *attr)
	403	{
	404	if (!attr)
	405	return;
8feb516b RM	406	print_string(PRINT_FP, NULL, "%s", _SL_);
	407	print_string(PRINT_ANY, "flag", "\t%s",
	408	rta_getattr_u8(attr) ? name_on : name_off);
59eb271d JB	409	}
59eb271d JB	410
6217917a SH	411	static void tunnel_key_print_geneve_options(const char *name,
	412	struct rtattr *attr)
	413	{
	414	struct rtattr *tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1];
	415	struct rtattr *i = RTA_DATA(attr);
	416	int ii, data_len = 0, offset = 0;
	417	int rem = RTA_PAYLOAD(attr);
	418	char strbuf[rem * 2 + 1];
	419	char data[rem * 2 + 1];
	420	uint8_t data_r[rem];
	421	uint16_t clss;
	422	uint8_t type;
	423
	424	open_json_array(PRINT_JSON, name);
	425	print_string(PRINT_FP, name, "\n\t%s ", "geneve_opt");
	426
	427	while (rem) {
	428	parse_rtattr(tb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX, i, rem);
	429	clss = rta_getattr_be16(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS]);
	430	type = rta_getattr_u8(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE]);
	431	data_len = RTA_PAYLOAD(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]);
	432	hexstring_n2a(RTA_DATA(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]),
	433	data_len, data, sizeof(data));
	434	hex2mem(data, data_r, data_len);
	435	offset += data_len + 20;
	436	rem -= data_len + 20;
	437	i = RTA_DATA(attr) + offset;
	438
	439	open_json_object(NULL);
	440	print_uint(PRINT_JSON, "class", NULL, clss);
	441	print_uint(PRINT_JSON, "type", NULL, type);
	442	open_json_array(PRINT_JSON, "data");
	443	for (ii = 0; ii < data_len; ii++)
	444	print_uint(PRINT_JSON, NULL, NULL, data_r[ii]);
	445	close_json_array(PRINT_JSON, "data");
	446	close_json_object();
	447
	448	sprintf(strbuf, "%04x:%02x:%s", clss, type, data);
	449	if (rem)
	450	print_string(PRINT_FP, NULL, "%s,", strbuf);
	451	else
	452	print_string(PRINT_FP, NULL, "%s", strbuf);
	453	}
	454
	455	close_json_array(PRINT_JSON, name);
	456	}
	457
	458	static void tunnel_key_print_key_opt(const char name, struct rtattr attr)
	459	{
	460	struct rtattr *tb[TCA_TUNNEL_KEY_ENC_OPTS_MAX + 1];
	461
	462	if (!attr)
	463	return;
	464
	465	parse_rtattr_nested(tb, TCA_TUNNEL_KEY_ENC_OPTS_MAX, attr);
	466	tunnel_key_print_geneve_options(name,
	467	tb[TCA_TUNNEL_KEY_ENC_OPTS_GENEVE]);
	468	}
	469
9f89b0cc OG	470	static void tunnel_key_print_tos_ttl(FILE f, char name,
	471	struct rtattr *attr)
	472	{
	473	if (!attr)
	474	return;
	475
	476	if (matches(name, "tos") == 0 && rta_getattr_u8(attr) != 0) {
	477	print_string(PRINT_FP, NULL, "%s", _SL_);
	478	print_uint(PRINT_ANY, "tos", "\ttos 0x%x",
	479	rta_getattr_u8(attr));
	480	} else if (matches(name, "ttl") == 0 && rta_getattr_u8(attr) != 0) {
	481	print_string(PRINT_FP, NULL, "%s", _SL_);
	482	print_uint(PRINT_ANY, "ttl", "\tttl %u",
	483	rta_getattr_u8(attr));
	484	}
	485	}
	486
d57639a4 AV	487	static int print_tunnel_key(struct action_util au, FILE f, struct rtattr *arg)
	488	{
	489	struct rtattr *tb[TCA_TUNNEL_KEY_MAX + 1];
	490	struct tc_tunnel_key *parm;
	491
	492	if (!arg)
	493	return -1;
	494
	495	parse_rtattr_nested(tb, TCA_TUNNEL_KEY_MAX, arg);
	496
	497	if (!tb[TCA_TUNNEL_KEY_PARMS]) {
8feb516b RM	498	print_string(PRINT_FP, NULL, "%s",
8feb516b RM	499	"[NULL tunnel_key parameters]");
d57639a4 AV	500	return -1;
	501	}
	502	parm = RTA_DATA(tb[TCA_TUNNEL_KEY_PARMS]);
	503
8feb516b	504	print_string(PRINT_ANY, "kind", "%s ", "tunnel_key");
d57639a4 AV	505
	506	switch (parm->t_action) {
	507	case TCA_TUNNEL_KEY_ACT_RELEASE:
8feb516b	508	print_string(PRINT_ANY, "mode", " %s", "unset");
d57639a4 AV	509	break;
d57639a4 AV	510	case TCA_TUNNEL_KEY_ACT_SET:
8feb516b	511	print_string(PRINT_ANY, "mode", " %s", "set");
d57639a4 AV	512	tunnel_key_print_ip_addr(f, "src_ip",
	513	tb[TCA_TUNNEL_KEY_ENC_IPV4_SRC]);
	514	tunnel_key_print_ip_addr(f, "dst_ip",
	515	tb[TCA_TUNNEL_KEY_ENC_IPV4_DST]);
	516	tunnel_key_print_ip_addr(f, "src_ip",
	517	tb[TCA_TUNNEL_KEY_ENC_IPV6_SRC]);
	518	tunnel_key_print_ip_addr(f, "dst_ip",
	519	tb[TCA_TUNNEL_KEY_ENC_IPV6_DST]);
	520	tunnel_key_print_key_id(f, "key_id",
	521	tb[TCA_TUNNEL_KEY_ENC_KEY_ID]);
449c709c HHZ	522	tunnel_key_print_dst_port(f, "dst_port",
449c709c HHZ	523	tb[TCA_TUNNEL_KEY_ENC_DST_PORT]);
6217917a SH	524	tunnel_key_print_key_opt("geneve_opts",
6217917a SH	525	tb[TCA_TUNNEL_KEY_ENC_OPTS]);
59eb271d JB	526	tunnel_key_print_flag(f, "nocsum", "csum",
59eb271d JB	527	tb[TCA_TUNNEL_KEY_NO_CSUM]);
9f89b0cc OG	528	tunnel_key_print_tos_ttl(f, "tos",
	529	tb[TCA_TUNNEL_KEY_ENC_TOS]);
	530	tunnel_key_print_tos_ttl(f, "ttl",
	531	tb[TCA_TUNNEL_KEY_ENC_TTL]);
d57639a4 AV	532	break;
d57639a4 AV	533	}
e67aba55	534	print_action_control(f, " ", parm->action, "");
d57639a4	535
8feb516b RM	536	print_string(PRINT_FP, NULL, "%s", _SL_);
	537	print_uint(PRINT_ANY, "index", "\t index %u", parm->index);
	538	print_int(PRINT_ANY, "ref", " ref %d", parm->refcnt);
	539	print_int(PRINT_ANY, "bind", " bind %d", parm->bindcnt);
d57639a4 AV	540
	541	if (show_stats) {
	542	if (tb[TCA_TUNNEL_KEY_TM]) {
	543	struct tcf_t *tm = RTA_DATA(tb[TCA_TUNNEL_KEY_TM]);
	544
	545	print_tm(f, tm);
	546	}
	547	}
	548
8feb516b	549	print_string(PRINT_FP, NULL, "%s", _SL_);
d57639a4 AV	550
	551	return 0;
	552	}
	553
	554	struct action_util tunnel_key_action_util = {
	555	.id = "tunnel_key",
	556	.parse_aopt = parse_tunnel_key,
	557	.print_aopt = print_tunnel_key,
	558	};