[mirror_iproute2.git] / ip / ipfou.c

/*
 * ipfou.c	FOU (foo over UDP) support
 *
 *              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:	Tom Herbert <therbert@google.com>
 */

#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <net/if.h>
#include <linux/fou.h>
#include <linux/genetlink.h>
#include <linux/ip.h>
#include <arpa/inet.h>

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

static void usage(void)
{
	fprintf(stderr,
		"Usage: ip fou add port PORT { ipproto PROTO  | gue } [ -6 ]\n"
		"       ip fou del port PORT [ -6 ]\n"
		"       ip fou show\n"
		"\n"
		"Where: PROTO { ipproto-name | 1..255 }\n"
		"       PORT { 1..65535 }\n");

	exit(-1);
}

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

#define FOU_REQUEST(_req, _bufsiz, _cmd, _flags)	\
	GENL_REQUEST(_req, _bufsiz, genl_family, 0,	\
		     FOU_GENL_VERSION, _cmd, _flags)

static int fou_parse_opt(int argc, char **argv, struct nlmsghdr *n,
			 bool adding)
{
	__u16 port;
	int port_set = 0;
	__u8 ipproto, type;
	bool gue_set = false;
	int ipproto_set = 0;
	__u8 family = AF_INET;

	while (argc > 0) {
		if (!matches(*argv, "port")) {
			NEXT_ARG();

			if (get_be16(&port, *argv, 0) || port == 0)
				invarg("invalid port", *argv);
			port_set = 1;
		} else if (!matches(*argv, "ipproto")) {
			struct protoent *servptr;

			NEXT_ARG();

			servptr = getprotobyname(*argv);
			if (servptr)
				ipproto = servptr->p_proto;
			else if (get_u8(&ipproto, *argv, 0) || ipproto == 0)
				invarg("invalid ipproto", *argv);
			ipproto_set = 1;
		} else if (!matches(*argv, "gue")) {
			gue_set = true;
		} else if (!matches(*argv, "-6")) {
			family = AF_INET6;
		} else {
			fprintf(stderr
				, "fou: unknown command \"%s\"?\n", *argv);
			usage();
			return -1;
		}
		argc--, argv++;
	}

	if (!port_set) {
		fprintf(stderr, "fou: missing port\n");
		return -1;
	}

	if (!ipproto_set && !gue_set && adding) {
		fprintf(stderr, "fou: must set ipproto or gue\n");
		return -1;
	}

	if (ipproto_set && gue_set) {
		fprintf(stderr, "fou: cannot set ipproto and gue\n");
		return -1;
	}

	type = gue_set ? FOU_ENCAP_GUE : FOU_ENCAP_DIRECT;

	addattr16(n, 1024, FOU_ATTR_PORT, port);
	addattr8(n, 1024, FOU_ATTR_TYPE, type);
	addattr8(n, 1024, FOU_ATTR_AF, family);

	if (ipproto_set)
		addattr8(n, 1024, FOU_ATTR_IPPROTO, ipproto);

	return 0;
}

static int do_add(int argc, char **argv)
{
	FOU_REQUEST(req, 1024, FOU_CMD_ADD, NLM_F_REQUEST);

	fou_parse_opt(argc, argv, &req.n, true);

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

	return 0;
}

static int do_del(int argc, char **argv)
{
	FOU_REQUEST(req, 1024, FOU_CMD_DEL, NLM_F_REQUEST);

	fou_parse_opt(argc, argv, &req.n, false);

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

	return 0;
}

static int print_fou_mapping(const struct sockaddr_nl *who,
				 struct nlmsghdr *n, void *arg)
{
	struct genlmsghdr *ghdr;
	struct rtattr *tb[FOU_ATTR_MAX + 1];
	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(tb, FOU_ATTR_MAX, (void *) ghdr + GENL_HDRLEN, len);

	open_json_object(NULL);
	if (tb[FOU_ATTR_PORT])
		print_uint(PRINT_ANY, "port", "port %u",
			   ntohs(rta_getattr_u16(tb[FOU_ATTR_PORT])));

	if (tb[FOU_ATTR_TYPE] &&
	    rta_getattr_u8(tb[FOU_ATTR_TYPE]) == FOU_ENCAP_GUE)
		print_null(PRINT_ANY, "gue", " gue", NULL);
	else if (tb[FOU_ATTR_IPPROTO])
		print_uint(PRINT_ANY, "ipproto",
			   " ipproto %u", rta_getattr_u8(tb[FOU_ATTR_IPPROTO]));

	if (tb[FOU_ATTR_AF]) {
		__u8 family = rta_getattr_u8(tb[FOU_ATTR_AF]);

		print_string(PRINT_JSON, "family", NULL,
			     family_name(family));

		if (family == AF_INET6)
			print_string(PRINT_FP, NULL,
				     " -6", NULL);
	}
	print_string(PRINT_FP, NULL, "\n", NULL);
	close_json_object();

	return 0;
}

static int do_show(int argc, char **argv)
{
	FOU_REQUEST(req, 4096, FOU_CMD_GET, NLM_F_REQUEST | NLM_F_DUMP);

	if (argc > 0) {
		fprintf(stderr,
			"\"ip fou show\" does not take any arguments.\n");
		return -1;
	}

	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_fou_mapping, stdout) < 0) {
		fprintf(stderr, "Dump terminated\n");
		return 1;
	}
	delete_json_obj();
	fflush(stdout);

	return 0;
}

int do_ipfou(int argc, char **argv)
{
	if (argc < 1)
		usage();

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

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

	if (matches(*argv, "add") == 0)
		return do_add(argc-1, argv+1);
	if (matches(*argv, "delete") == 0)
		return do_del(argc-1, argv+1);
	if (matches(*argv, "show") == 0)
		return do_show(argc-1, argv+1);

	fprintf(stderr,
		"Command \"%s\" is unknown, try \"ip fou help\".\n", *argv);
	exit(-1);
}
Commit	Line	Data
6928747b TH	1	/*
	2	* ipfou.c FOU (foo over UDP) support
	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: Tom Herbert <therbert@google.com>
	10	*/
	11
	12	#include <netdb.h>
	13	#include <stdio.h>
	14	#include <stdlib.h>
	15	#include <string.h>
	16	#include <net/if.h>
	17	#include <linux/fou.h>
	18	#include <linux/genetlink.h>
	19	#include <linux/ip.h>
	20	#include <arpa/inet.h>
	21
	22	#include "libgenl.h"
	23	#include "utils.h"
	24	#include "ip_common.h"
41b99db1	25	#include "json_print.h"
6928747b TH	26
	27	static void usage(void)
	28	{
5c92c2ee SH	29	fprintf(stderr,
	30	"Usage: ip fou add port PORT { ipproto PROTO \| gue } [ -6 ]\n"
	31	" ip fou del port PORT [ -6 ]\n"
	32	" ip fou show\n"
	33	"\n"
	34	"Where: PROTO { ipproto-name \| 1..255 }\n"
	35	" PORT { 1..65535 }\n");
6928747b TH	36
	37	exit(-1);
	38	}
	39
	40	/* netlink socket */
	41	static struct rtnl_handle genl_rth = { .fd = -1 };
	42	static int genl_family = -1;
	43
	44	#define FOU_REQUEST(_req, _bufsiz, _cmd, _flags) \
	45	GENL_REQUEST(_req, _bufsiz, genl_family, 0, \
	46	FOU_GENL_VERSION, _cmd, _flags)
	47
	48	static int fou_parse_opt(int argc, char *argv, struct nlmsghdr n,
	49	bool adding)
	50	{
	51	__u16 port;
	52	int port_set = 0;
	53	__u8 ipproto, type;
	54	bool gue_set = false;
	55	int ipproto_set = 0;
33f6dd23	56	__u8 family = AF_INET;
6928747b TH	57
	58	while (argc > 0) {
	59	if (!matches(*argv, "port")) {
	60	NEXT_ARG();
	61
9f7401fa	62	if (get_be16(&port, *argv, 0) \|\| port == 0)
6928747b	63	invarg("invalid port", *argv);
6928747b TH	64	port_set = 1;
	65	} else if (!matches(*argv, "ipproto")) {
	66	struct protoent *servptr;
	67
	68	NEXT_ARG();
	69
	70	servptr = getprotobyname(*argv);
	71	if (servptr)
	72	ipproto = servptr->p_proto;
	73	else if (get_u8(&ipproto, *argv, 0) \|\| ipproto == 0)
	74	invarg("invalid ipproto", *argv);
	75	ipproto_set = 1;
	76	} else if (!matches(*argv, "gue")) {
	77	gue_set = true;
8bd31d8d TH	78	} else if (!matches(*argv, "-6")) {
8bd31d8d TH	79	family = AF_INET6;
6928747b	80	} else {
5c92c2ee SH	81	fprintf(stderr
5c92c2ee SH	82	, "fou: unknown command \"%s\"?\n", *argv);
6928747b TH	83	usage();
	84	return -1;
	85	}
	86	argc--, argv++;
	87	}
	88
	89	if (!port_set) {
	90	fprintf(stderr, "fou: missing port\n");
	91	return -1;
	92	}
	93
	94	if (!ipproto_set && !gue_set && adding) {
	95	fprintf(stderr, "fou: must set ipproto or gue\n");
	96	return -1;
	97	}
	98
	99	if (ipproto_set && gue_set) {
	100	fprintf(stderr, "fou: cannot set ipproto and gue\n");
	101	return -1;
	102	}
	103
	104	type = gue_set ? FOU_ENCAP_GUE : FOU_ENCAP_DIRECT;
	105
	106	addattr16(n, 1024, FOU_ATTR_PORT, port);
	107	addattr8(n, 1024, FOU_ATTR_TYPE, type);
33f6dd23	108	addattr8(n, 1024, FOU_ATTR_AF, family);
6928747b TH	109
	110	if (ipproto_set)
	111	addattr8(n, 1024, FOU_ATTR_IPPROTO, ipproto);
	112
	113	return 0;
	114	}
	115
	116	static int do_add(int argc, char **argv)
	117	{
	118	FOU_REQUEST(req, 1024, FOU_CMD_ADD, NLM_F_REQUEST);
	119
	120	fou_parse_opt(argc, argv, &req.n, true);
	121
86bf43c7	122	if (rtnl_talk(&genl_rth, &req.n, NULL) < 0)
6928747b TH	123	return -2;
	124
	125	return 0;
	126	}
	127
	128	static int do_del(int argc, char **argv)
	129	{
	130	FOU_REQUEST(req, 1024, FOU_CMD_DEL, NLM_F_REQUEST);
	131
	132	fou_parse_opt(argc, argv, &req.n, false);
	133
86bf43c7	134	if (rtnl_talk(&genl_rth, &req.n, NULL) < 0)
6928747b TH	135	return -2;
	136
	137	return 0;
	138	}
	139
cf4caf33 GG	140	static int print_fou_mapping(const struct sockaddr_nl *who,
	141	struct nlmsghdr n, void arg)
	142	{
cf4caf33 GG	143	struct genlmsghdr *ghdr;
	144	struct rtattr *tb[FOU_ATTR_MAX + 1];
	145	int len = n->nlmsg_len;
cf4caf33 GG	146
	147	if (n->nlmsg_type != genl_family)
	148	return 0;
	149
	150	len -= NLMSG_LENGTH(GENL_HDRLEN);
	151	if (len < 0)
	152	return -1;
	153
	154	ghdr = NLMSG_DATA(n);
	155	parse_rtattr(tb, FOU_ATTR_MAX, (void *) ghdr + GENL_HDRLEN, len);
	156
41b99db1	157	open_json_object(NULL);
cf4caf33	158	if (tb[FOU_ATTR_PORT])
41b99db1 SH	159	print_uint(PRINT_ANY, "port", "port %u",
	160	ntohs(rta_getattr_u16(tb[FOU_ATTR_PORT])));
	161
	162	if (tb[FOU_ATTR_TYPE] &&
	163	rta_getattr_u8(tb[FOU_ATTR_TYPE]) == FOU_ENCAP_GUE)
	164	print_null(PRINT_ANY, "gue", " gue", NULL);
cf4caf33	165	else if (tb[FOU_ATTR_IPPROTO])
41b99db1 SH	166	print_uint(PRINT_ANY, "ipproto",
	167	" ipproto %u", rta_getattr_u8(tb[FOU_ATTR_IPPROTO]));
	168
cf4caf33	169	if (tb[FOU_ATTR_AF]) {
41b99db1 SH	170	__u8 family = rta_getattr_u8(tb[FOU_ATTR_AF]);
	171
	172	print_string(PRINT_JSON, "family", NULL,
	173	family_name(family));
	174
cf4caf33	175	if (family == AF_INET6)
41b99db1 SH	176	print_string(PRINT_FP, NULL,
41b99db1 SH	177	" -6", NULL);
cf4caf33	178	}
41b99db1 SH	179	print_string(PRINT_FP, NULL, "\n", NULL);
41b99db1 SH	180	close_json_object();
cf4caf33 GG	181
	182	return 0;
	183	}
	184
	185	static int do_show(int argc, char **argv)
	186	{
	187	FOU_REQUEST(req, 4096, FOU_CMD_GET, NLM_F_REQUEST \| NLM_F_DUMP);
	188
	189	if (argc > 0) {
5c92c2ee SH	190	fprintf(stderr,
5c92c2ee SH	191	"\"ip fou show\" does not take any arguments.\n");
cf4caf33 GG	192	return -1;
	193	}
	194
	195	if (rtnl_send(&genl_rth, &req.n, req.n.nlmsg_len) < 0) {
	196	perror("Cannot send show request");
	197	exit(1);
	198	}
	199
41b99db1	200	new_json_obj(json);
cf4caf33 GG	201	if (rtnl_dump_filter(&genl_rth, print_fou_mapping, stdout) < 0) {
	202	fprintf(stderr, "Dump terminated\n");
	203	return 1;
	204	}
41b99db1 SH	205	delete_json_obj();
41b99db1 SH	206	fflush(stdout);
cf4caf33 GG	207
	208	return 0;
	209	}
	210
6928747b TH	211	int do_ipfou(int argc, char **argv)
6928747b TH	212	{
6928747b TH	213	if (argc < 1)
	214	usage();
	215
d240a0e1 SD	216	if (matches(*argv, "help") == 0)
	217	usage();
	218
	219	if (genl_init_handle(&genl_rth, FOU_GENL_NAME, &genl_family))
	220	exit(1);
	221
6928747b TH	222	if (matches(*argv, "add") == 0)
	223	return do_add(argc-1, argv+1);
	224	if (matches(*argv, "delete") == 0)
	225	return do_del(argc-1, argv+1);
cf4caf33 GG	226	if (matches(*argv, "show") == 0)
cf4caf33 GG	227	return do_show(argc-1, argv+1);
5c92c2ee SH	228
	229	fprintf(stderr,
	230	"Command \"%s\" is unknown, try \"ip fou help\".\n", *argv);
6928747b TH	231	exit(-1);
6928747b TH	232	}