[mirror_iproute2.git] / ip / link_gre6.c

/*
 * link_gre6.c	gre driver 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:	Dmitry Kozlov <xeb@mail.ru>
 *
 */

#include <string.h>
#include <net/if.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#include <linux/ip.h>
#include <linux/if_tunnel.h>
#include <linux/ip6_tunnel.h>

#include "rt_names.h"
#include "utils.h"
#include "ip_common.h"
#include "tunnel.h"

#define IP6_FLOWINFO_TCLASS	htonl(0x0FF00000)
#define IP6_FLOWINFO_FLOWLABEL	htonl(0x000FFFFF)

#define DEFAULT_TNL_HOP_LIMIT	(64)

static void print_usage(FILE *f)
{
	fprintf(f,
		"Usage: ... { ip6gre | ip6gretap } [ remote ADDR ]\n"
		"                                  [ local ADDR ]\n"
		"                                  [ [i|o]seq ]\n"
		"                                  [ [i|o]key KEY ]\n"
		"                                  [ [i|o]csum ]\n"
		"                                  [ hoplimit TTL ]\n"
		"                                  [ encaplimit ELIM ]\n"
		"                                  [ tclass TCLASS ]\n"
		"                                  [ flowlabel FLOWLABEL ]\n"
		"                                  [ dscp inherit ]\n"
		"                                  [ dev PHYS_DEV ]\n"
		"                                  [ noencap ]\n"
		"                                  [ encap { fou | gue | none } ]\n"
		"                                  [ encap-sport PORT ]\n"
		"                                  [ encap-dport PORT ]\n"
		"                                  [ [no]encap-csum ]\n"
		"                                  [ [no]encap-csum6 ]\n"
		"                                  [ [no]encap-remcsum ]\n"
		"\n"
		"Where: ADDR      := IPV6_ADDRESS\n"
		"       TTL       := { 0..255 } (default=%d)\n"
		"       KEY       := { DOTTED_QUAD | NUMBER }\n"
		"       ELIM      := { none | 0..255 }(default=%d)\n"
		"       TCLASS    := { 0x0..0xff | inherit }\n"
		"       FLOWLABEL := { 0x0..0xfffff | inherit }\n",
		DEFAULT_TNL_HOP_LIMIT, IPV6_DEFAULT_TNL_ENCAP_LIMIT
	);
}

static void usage(void) __attribute__((noreturn));
static void usage(void)
{
	print_usage(stderr);
	exit(-1);
}

static int gre_parse_opt(struct link_util *lu, int argc, char **argv,
			 struct nlmsghdr *n)
{
	struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
	struct {
		struct nlmsghdr n;
		struct ifinfomsg i;
		char buf[1024];
	} req = {
		.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
		.n.nlmsg_flags = NLM_F_REQUEST,
		.n.nlmsg_type = RTM_GETLINK,
		.i.ifi_family = preferred_family,
		.i.ifi_index = ifi->ifi_index,
	};
	struct rtattr *tb[IFLA_MAX + 1];
	struct rtattr *linkinfo[IFLA_INFO_MAX+1];
	struct rtattr *greinfo[IFLA_GRE_MAX + 1];
	__u16 iflags = 0;
	__u16 oflags = 0;
	unsigned int ikey = 0;
	unsigned int okey = 0;
	struct in6_addr raddr = IN6ADDR_ANY_INIT;
	struct in6_addr laddr = IN6ADDR_ANY_INIT;
	unsigned int link = 0;
	unsigned int flowinfo = 0;
	unsigned int flags = 0;
	__u8 hop_limit = DEFAULT_TNL_HOP_LIMIT;
	__u8 encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
	__u16 encaptype = 0;
	__u16 encapflags = TUNNEL_ENCAP_FLAG_CSUM6;
	__u16 encapsport = 0;
	__u16 encapdport = 0;
	int len;

	if (!(n->nlmsg_flags & NLM_F_CREATE)) {
		if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
			fprintf(stderr,
				"Failed to get existing tunnel info.\n");
			return -1;
		}

		len = req.n.nlmsg_len;
		len -= NLMSG_LENGTH(sizeof(*ifi));
		if (len < 0)
			goto get_failed;

		parse_rtattr(tb, IFLA_MAX, IFLA_RTA(&req.i), len);

		if (!tb[IFLA_LINKINFO])
			goto get_failed;

		parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);

		if (!linkinfo[IFLA_INFO_DATA])
			goto get_failed;

		parse_rtattr_nested(greinfo, IFLA_GRE_MAX,
				    linkinfo[IFLA_INFO_DATA]);

		if (greinfo[IFLA_GRE_IKEY])
			ikey = rta_getattr_u32(greinfo[IFLA_GRE_IKEY]);

		if (greinfo[IFLA_GRE_OKEY])
			okey = rta_getattr_u32(greinfo[IFLA_GRE_OKEY]);

		if (greinfo[IFLA_GRE_IFLAGS])
			iflags = rta_getattr_u16(greinfo[IFLA_GRE_IFLAGS]);

		if (greinfo[IFLA_GRE_OFLAGS])
			oflags = rta_getattr_u16(greinfo[IFLA_GRE_OFLAGS]);

		if (greinfo[IFLA_GRE_LOCAL])
			memcpy(&laddr, RTA_DATA(greinfo[IFLA_GRE_LOCAL]), sizeof(laddr));

		if (greinfo[IFLA_GRE_REMOTE])
			memcpy(&raddr, RTA_DATA(greinfo[IFLA_GRE_REMOTE]), sizeof(raddr));

		if (greinfo[IFLA_GRE_TTL])
			hop_limit = rta_getattr_u8(greinfo[IFLA_GRE_TTL]);

		if (greinfo[IFLA_GRE_LINK])
			link = rta_getattr_u32(greinfo[IFLA_GRE_LINK]);

		if (greinfo[IFLA_GRE_ENCAP_LIMIT])
			encap_limit = rta_getattr_u8(greinfo[IFLA_GRE_ENCAP_LIMIT]);

		if (greinfo[IFLA_GRE_FLOWINFO])
			flowinfo = rta_getattr_u32(greinfo[IFLA_GRE_FLOWINFO]);

		if (greinfo[IFLA_GRE_FLAGS])
			flags = rta_getattr_u32(greinfo[IFLA_GRE_FLAGS]);

		if (greinfo[IFLA_GRE_ENCAP_TYPE])
			encaptype = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_TYPE]);

		if (greinfo[IFLA_GRE_ENCAP_FLAGS])
			encapflags = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_FLAGS]);

		if (greinfo[IFLA_GRE_ENCAP_SPORT])
			encapsport = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_SPORT]);

		if (greinfo[IFLA_GRE_ENCAP_DPORT])
			encapdport = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_DPORT]);
	}

	while (argc > 0) {
		if (!matches(*argv, "key")) {
			unsigned int uval;

			NEXT_ARG();
			iflags |= GRE_KEY;
			oflags |= GRE_KEY;
			if (strchr(*argv, '.'))
				uval = get_addr32(*argv);
			else {
				if (get_unsigned(&uval, *argv, 0) < 0) {
					fprintf(stderr,
						"Invalid value for \"key\"\n");
					exit(-1);
				}
				uval = htonl(uval);
			}

			ikey = okey = uval;
		} else if (!matches(*argv, "ikey")) {
			unsigned int uval;

			NEXT_ARG();
			iflags |= GRE_KEY;
			if (strchr(*argv, '.'))
				uval = get_addr32(*argv);
			else {
				if (get_unsigned(&uval, *argv, 0) < 0) {
					fprintf(stderr, "invalid value of \"ikey\"\n");
					exit(-1);
				}
				uval = htonl(uval);
			}
			ikey = uval;
		} else if (!matches(*argv, "okey")) {
			unsigned int uval;

			NEXT_ARG();
			oflags |= GRE_KEY;
			if (strchr(*argv, '.'))
				uval = get_addr32(*argv);
			else {
				if (get_unsigned(&uval, *argv, 0) < 0) {
					fprintf(stderr, "invalid value of \"okey\"\n");
					exit(-1);
				}
				uval = htonl(uval);
			}
			okey = uval;
		} else if (!matches(*argv, "seq")) {
			iflags |= GRE_SEQ;
			oflags |= GRE_SEQ;
		} else if (!matches(*argv, "iseq")) {
			iflags |= GRE_SEQ;
		} else if (!matches(*argv, "oseq")) {
			oflags |= GRE_SEQ;
		} else if (!matches(*argv, "csum")) {
			iflags |= GRE_CSUM;
			oflags |= GRE_CSUM;
		} else if (!matches(*argv, "icsum")) {
			iflags |= GRE_CSUM;
		} else if (!matches(*argv, "ocsum")) {
			oflags |= GRE_CSUM;
		} else if (!matches(*argv, "remote")) {
			inet_prefix addr;

			NEXT_ARG();
			get_prefix(&addr, *argv, preferred_family);
			if (addr.family == AF_UNSPEC)
				invarg("\"remote\" address family is AF_UNSPEC", *argv);
			memcpy(&raddr, &addr.data, sizeof(raddr));
		} else if (!matches(*argv, "local")) {
			inet_prefix addr;

			NEXT_ARG();
			get_prefix(&addr, *argv, preferred_family);
			if (addr.family == AF_UNSPEC)
				invarg("\"local\" address family is AF_UNSPEC", *argv);
			memcpy(&laddr, &addr.data, sizeof(laddr));
		} else if (!matches(*argv, "dev")) {
			NEXT_ARG();
			link = if_nametoindex(*argv);
			if (link == 0) {
				fprintf(stderr, "Cannot find device \"%s\"\n",
					*argv);
				exit(-1);
			}
		} else if (!matches(*argv, "ttl") ||
			   !matches(*argv, "hoplimit")) {
			__u8 uval;

			NEXT_ARG();
			if (get_u8(&uval, *argv, 0))
				invarg("invalid TTL", *argv);
			hop_limit = uval;
		} else if (!matches(*argv, "tos") ||
			   !matches(*argv, "tclass") ||
			   !matches(*argv, "dsfield")) {
			__u8 uval;

			NEXT_ARG();
			if (strcmp(*argv, "inherit") == 0)
				flags |= IP6_TNL_F_USE_ORIG_TCLASS;
			else {
				if (get_u8(&uval, *argv, 16))
					invarg("invalid TClass", *argv);
				flowinfo |= htonl((__u32)uval << 20) & IP6_FLOWINFO_TCLASS;
				flags &= ~IP6_TNL_F_USE_ORIG_TCLASS;
			}
		} else if (strcmp(*argv, "flowlabel") == 0 ||
			   strcmp(*argv, "fl") == 0) {
			__u32 uval;

			NEXT_ARG();
			if (strcmp(*argv, "inherit") == 0)
				flags |= IP6_TNL_F_USE_ORIG_FLOWLABEL;
			else {
				if (get_u32(&uval, *argv, 16))
					invarg("invalid Flowlabel", *argv);
				if (uval > 0xFFFFF)
					invarg("invalid Flowlabel", *argv);
				flowinfo |= htonl(uval) & IP6_FLOWINFO_FLOWLABEL;
				flags &= ~IP6_TNL_F_USE_ORIG_FLOWLABEL;
			}
		} else if (strcmp(*argv, "dscp") == 0) {
			NEXT_ARG();
			if (strcmp(*argv, "inherit") != 0)
				invarg("not inherit", *argv);
			flags |= IP6_TNL_F_RCV_DSCP_COPY;
		} else if (strcmp(*argv, "noencap") == 0) {
			encaptype = TUNNEL_ENCAP_NONE;
		} else if (strcmp(*argv, "encap") == 0) {
			NEXT_ARG();
			if (strcmp(*argv, "fou") == 0)
				encaptype = TUNNEL_ENCAP_FOU;
			else if (strcmp(*argv, "gue") == 0)
				encaptype = TUNNEL_ENCAP_GUE;
			else if (strcmp(*argv, "none") == 0)
				encaptype = TUNNEL_ENCAP_NONE;
			else
				invarg("Invalid encap type.", *argv);
		} else if (strcmp(*argv, "encap-sport") == 0) {
			NEXT_ARG();
			if (strcmp(*argv, "auto") == 0)
				encapsport = 0;
			else if (get_u16(&encapsport, *argv, 0))
				invarg("Invalid source port.", *argv);
		} else if (strcmp(*argv, "encap-dport") == 0) {
			NEXT_ARG();
			if (get_u16(&encapdport, *argv, 0))
				invarg("Invalid destination port.", *argv);
		} else if (strcmp(*argv, "encap-csum") == 0) {
			encapflags |= TUNNEL_ENCAP_FLAG_CSUM;
		} else if (strcmp(*argv, "noencap-csum") == 0) {
			encapflags &= ~TUNNEL_ENCAP_FLAG_CSUM;
		} else if (strcmp(*argv, "encap-udp6-csum") == 0) {
			encapflags |= TUNNEL_ENCAP_FLAG_CSUM6;
		} else if (strcmp(*argv, "noencap-udp6-csum") == 0) {
			encapflags &= ~TUNNEL_ENCAP_FLAG_CSUM6;
		} else if (strcmp(*argv, "encap-remcsum") == 0) {
			encapflags |= TUNNEL_ENCAP_FLAG_REMCSUM;
		} else if (strcmp(*argv, "noencap-remcsum") == 0) {
			encapflags &= ~TUNNEL_ENCAP_FLAG_REMCSUM;
		} else
			usage();
		argc--; argv++;
	}

	addattr32(n, 1024, IFLA_GRE_IKEY, ikey);
	addattr32(n, 1024, IFLA_GRE_OKEY, okey);
	addattr_l(n, 1024, IFLA_GRE_IFLAGS, &iflags, 2);
	addattr_l(n, 1024, IFLA_GRE_OFLAGS, &oflags, 2);
	addattr_l(n, 1024, IFLA_GRE_LOCAL, &laddr, sizeof(laddr));
	addattr_l(n, 1024, IFLA_GRE_REMOTE, &raddr, sizeof(raddr));
	if (link)
		addattr32(n, 1024, IFLA_GRE_LINK, link);
	addattr_l(n, 1024, IFLA_GRE_TTL, &hop_limit, 1);
	addattr_l(n, 1024, IFLA_GRE_ENCAP_LIMIT, &encap_limit, 1);
	addattr_l(n, 1024, IFLA_GRE_FLOWINFO, &flowinfo, 4);
	addattr_l(n, 1024, IFLA_GRE_FLAGS, &flowinfo, 4);

	addattr16(n, 1024, IFLA_GRE_ENCAP_TYPE, encaptype);
	addattr16(n, 1024, IFLA_GRE_ENCAP_FLAGS, encapflags);
	addattr16(n, 1024, IFLA_GRE_ENCAP_SPORT, htons(encapsport));
	addattr16(n, 1024, IFLA_GRE_ENCAP_DPORT, htons(encapdport));

	return 0;
}

static void gre_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
{
	char s2[64];
	const char *local = "any";
	const char *remote = "any";
	unsigned int iflags = 0;
	unsigned int oflags = 0;
	unsigned int flags = 0;
	unsigned int flowinfo = 0;
	struct in6_addr in6_addr_any = IN6ADDR_ANY_INIT;

	if (!tb)
		return;

	if (tb[IFLA_GRE_FLAGS])
		flags = rta_getattr_u32(tb[IFLA_GRE_FLAGS]);

	if (tb[IFLA_GRE_FLOWINFO])
		flags = rta_getattr_u32(tb[IFLA_GRE_FLOWINFO]);

	if (tb[IFLA_GRE_REMOTE]) {
		struct in6_addr addr;

		memcpy(&addr, RTA_DATA(tb[IFLA_GRE_REMOTE]), sizeof(addr));

		if (memcmp(&addr, &in6_addr_any, sizeof(addr)))
			remote = format_host(AF_INET6, sizeof(addr), &addr);
	}

	fprintf(f, "remote %s ", remote);

	if (tb[IFLA_GRE_LOCAL]) {
		struct in6_addr addr;

		memcpy(&addr, RTA_DATA(tb[IFLA_GRE_LOCAL]), sizeof(addr));

		if (memcmp(&addr, &in6_addr_any, sizeof(addr)))
			local = format_host(AF_INET6, sizeof(addr), &addr);
	}

	fprintf(f, "local %s ", local);

	if (tb[IFLA_GRE_LINK] && rta_getattr_u32(tb[IFLA_GRE_LINK])) {
		unsigned int link = rta_getattr_u32(tb[IFLA_GRE_LINK]);
		const char *n = if_indextoname(link, s2);

		if (n)
			fprintf(f, "dev %s ", n);
		else
			fprintf(f, "dev %u ", link);
	}

	if (tb[IFLA_GRE_TTL] && rta_getattr_u8(tb[IFLA_GRE_TTL]))
		fprintf(f, "hoplimit %d ", rta_getattr_u8(tb[IFLA_GRE_TTL]));

	if (flags & IP6_TNL_F_IGN_ENCAP_LIMIT)
		fprintf(f, "encaplimit none ");
	else if (tb[IFLA_GRE_ENCAP_LIMIT]) {
		int encap_limit = rta_getattr_u8(tb[IFLA_GRE_ENCAP_LIMIT]);

		fprintf(f, "encaplimit %d ", encap_limit);
	}

	if (flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
		fprintf(f, "flowlabel inherit ");
	else
		fprintf(f, "flowlabel 0x%05x ", ntohl(flowinfo & IP6_FLOWINFO_FLOWLABEL));

	if (flags & IP6_TNL_F_RCV_DSCP_COPY)
		fprintf(f, "dscp inherit ");

	if (tb[IFLA_GRE_IFLAGS])
		iflags = rta_getattr_u16(tb[IFLA_GRE_IFLAGS]);

	if (tb[IFLA_GRE_OFLAGS])
		oflags = rta_getattr_u16(tb[IFLA_GRE_OFLAGS]);

	if ((iflags & GRE_KEY) && tb[IFLA_GRE_IKEY]) {
		inet_ntop(AF_INET, RTA_DATA(tb[IFLA_GRE_IKEY]), s2, sizeof(s2));
		fprintf(f, "ikey %s ", s2);
	}

	if ((oflags & GRE_KEY) && tb[IFLA_GRE_OKEY]) {
		inet_ntop(AF_INET, RTA_DATA(tb[IFLA_GRE_OKEY]), s2, sizeof(s2));
		fprintf(f, "okey %s ", s2);
	}

	if (iflags & GRE_SEQ)
		fputs("iseq ", f);
	if (oflags & GRE_SEQ)
		fputs("oseq ", f);
	if (iflags & GRE_CSUM)
		fputs("icsum ", f);
	if (oflags & GRE_CSUM)
		fputs("ocsum ", f);

	if (tb[IFLA_GRE_ENCAP_TYPE] &&
	    rta_getattr_u16(tb[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE) {
		__u16 type = rta_getattr_u16(tb[IFLA_GRE_ENCAP_TYPE]);
		__u16 flags = rta_getattr_u16(tb[IFLA_GRE_ENCAP_FLAGS]);
		__u16 sport = rta_getattr_u16(tb[IFLA_GRE_ENCAP_SPORT]);
		__u16 dport = rta_getattr_u16(tb[IFLA_GRE_ENCAP_DPORT]);

		fputs("encap ", f);
		switch (type) {
		case TUNNEL_ENCAP_FOU:
			fputs("fou ", f);
			break;
		case TUNNEL_ENCAP_GUE:
			fputs("gue ", f);
			break;
		default:
			fputs("unknown ", f);
			break;
		}

		if (sport == 0)
			fputs("encap-sport auto ", f);
		else
			fprintf(f, "encap-sport %u", ntohs(sport));

		fprintf(f, "encap-dport %u ", ntohs(dport));

		if (flags & TUNNEL_ENCAP_FLAG_CSUM)
			fputs("encap-csum ", f);
		else
			fputs("noencap-csum ", f);

		if (flags & TUNNEL_ENCAP_FLAG_CSUM6)
			fputs("encap-csum6 ", f);
		else
			fputs("noencap-csum6 ", f);

		if (flags & TUNNEL_ENCAP_FLAG_REMCSUM)
			fputs("encap-remcsum ", f);
		else
			fputs("noencap-remcsum ", f);
	}
}

static void gre_print_help(struct link_util *lu, int argc, char **argv,
	FILE *f)
{
	print_usage(f);
}

struct link_util ip6gre_link_util = {
	.id = "ip6gre",
	.maxattr = IFLA_GRE_MAX,
	.parse_opt = gre_parse_opt,
	.print_opt = gre_print_opt,
	.print_help = gre_print_help,
};

struct link_util ip6gretap_link_util = {
	.id = "ip6gretap",
	.maxattr = IFLA_GRE_MAX,
	.parse_opt = gre_parse_opt,
	.print_opt = gre_print_opt,
	.print_help = gre_print_help,
};
Commit	Line	Data
af89576d	1	/*
	2	* link_gre6.c gre driver 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: Dmitry Kozlov <xeb@mail.ru>
	10	*
	11	*/
	12
	13	#include <string.h>
	14	#include <net/if.h>
	15	#include <sys/types.h>
	16	#include <sys/socket.h>
	17	#include <arpa/inet.h>
	18
	19	#include <linux/ip.h>
	20	#include <linux/if_tunnel.h>
	21	#include <linux/ip6_tunnel.h>
	22
	23	#include "rt_names.h"
	24	#include "utils.h"
	25	#include "ip_common.h"
	26	#include "tunnel.h"
	27
	28	#define IP6_FLOWINFO_TCLASS htonl(0x0FF00000)
	29	#define IP6_FLOWINFO_FLOWLABEL htonl(0x000FFFFF)
	30
	31	#define DEFAULT_TNL_HOP_LIMIT (64)
	32
561e650e	33	static void print_usage(FILE *f)
af89576d	34	{
8b471354 PS	35	fprintf(f,
	36	"Usage: ... { ip6gre \| ip6gretap } [ remote ADDR ]\n"
	37	" [ local ADDR ]\n"
	38	" [ [i\|o]seq ]\n"
	39	" [ [i\|o]key KEY ]\n"
	40	" [ [i\|o]csum ]\n"
	41	" [ hoplimit TTL ]\n"
	42	" [ encaplimit ELIM ]\n"
	43	" [ tclass TCLASS ]\n"
	44	" [ flowlabel FLOWLABEL ]\n"
	45	" [ dscp inherit ]\n"
	46	" [ dev PHYS_DEV ]\n"
	47	" [ noencap ]\n"
	48	" [ encap { fou \| gue \| none } ]\n"
	49	" [ encap-sport PORT ]\n"
	50	" [ encap-dport PORT ]\n"
	51	" [ [no]encap-csum ]\n"
	52	" [ [no]encap-csum6 ]\n"
	53	" [ [no]encap-remcsum ]\n"
	54	"\n"
	55	"Where: ADDR := IPV6_ADDRESS\n"
	56	" TTL := { 0..255 } (default=%d)\n"
	57	" KEY := { DOTTED_QUAD \| NUMBER }\n"
	58	" ELIM := { none \| 0..255 }(default=%d)\n"
	59	" TCLASS := { 0x0..0xff \| inherit }\n"
	60	" FLOWLABEL := { 0x0..0xfffff \| inherit }\n",
	61	DEFAULT_TNL_HOP_LIMIT, IPV6_DEFAULT_TNL_ENCAP_LIMIT
	62	);
561e650e	63	}
	64
	65	static void usage(void) __attribute__((noreturn));
	66	static void usage(void)
	67	{
	68	print_usage(stderr);
af89576d	69	exit(-1);
	70	}
	71
	72	static int gre_parse_opt(struct link_util lu, int argc, char *argv,
	73	struct nlmsghdr *n)
	74	{
d17b136f	75	struct ifinfomsg ifi = (struct ifinfomsg )(n + 1);
af89576d	76	struct {
	77	struct nlmsghdr n;
	78	struct ifinfomsg i;
	79	char buf[1024];
d17b136f PS	80	} req = {
	81	.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
	82	.n.nlmsg_flags = NLM_F_REQUEST,
	83	.n.nlmsg_type = RTM_GETLINK,
	84	.i.ifi_family = preferred_family,
	85	.i.ifi_index = ifi->ifi_index,
	86	};
af89576d	87	struct rtattr *tb[IFLA_MAX + 1];
	88	struct rtattr *linkinfo[IFLA_INFO_MAX+1];
	89	struct rtattr *greinfo[IFLA_GRE_MAX + 1];
	90	__u16 iflags = 0;
	91	__u16 oflags = 0;
56f5daac SH	92	unsigned int ikey = 0;
56f5daac SH	93	unsigned int okey = 0;
af89576d	94	struct in6_addr raddr = IN6ADDR_ANY_INIT;
af89576d	95	struct in6_addr laddr = IN6ADDR_ANY_INIT;
56f5daac SH	96	unsigned int link = 0;
	97	unsigned int flowinfo = 0;
	98	unsigned int flags = 0;
af89576d	99	__u8 hop_limit = DEFAULT_TNL_HOP_LIMIT;
af89576d	100	__u8 encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
0b2fbb73 TH	101	__u16 encaptype = 0;
	102	__u16 encapflags = TUNNEL_ENCAP_FLAG_CSUM6;
	103	__u16 encapsport = 0;
	104	__u16 encapdport = 0;
af89576d	105	int len;
	106
	107	if (!(n->nlmsg_flags & NLM_F_CREATE)) {
c079e121	108	if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
af89576d	109	get_failed:
	110	fprintf(stderr,
	111	"Failed to get existing tunnel info.\n");
	112	return -1;
	113	}
	114
	115	len = req.n.nlmsg_len;
	116	len -= NLMSG_LENGTH(sizeof(*ifi));
	117	if (len < 0)
	118	goto get_failed;
	119
	120	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(&req.i), len);
	121
	122	if (!tb[IFLA_LINKINFO])
	123	goto get_failed;
	124
	125	parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
	126
	127	if (!linkinfo[IFLA_INFO_DATA])
	128	goto get_failed;
	129
	130	parse_rtattr_nested(greinfo, IFLA_GRE_MAX,
	131	linkinfo[IFLA_INFO_DATA]);
	132
	133	if (greinfo[IFLA_GRE_IKEY])
	134	ikey = rta_getattr_u32(greinfo[IFLA_GRE_IKEY]);
	135
	136	if (greinfo[IFLA_GRE_OKEY])
	137	okey = rta_getattr_u32(greinfo[IFLA_GRE_OKEY]);
	138
	139	if (greinfo[IFLA_GRE_IFLAGS])
	140	iflags = rta_getattr_u16(greinfo[IFLA_GRE_IFLAGS]);
	141
	142	if (greinfo[IFLA_GRE_OFLAGS])
	143	oflags = rta_getattr_u16(greinfo[IFLA_GRE_OFLAGS]);
	144
	145	if (greinfo[IFLA_GRE_LOCAL])
	146	memcpy(&laddr, RTA_DATA(greinfo[IFLA_GRE_LOCAL]), sizeof(laddr));
	147
	148	if (greinfo[IFLA_GRE_REMOTE])
	149	memcpy(&raddr, RTA_DATA(greinfo[IFLA_GRE_REMOTE]), sizeof(raddr));
	150
	151	if (greinfo[IFLA_GRE_TTL])
	152	hop_limit = rta_getattr_u8(greinfo[IFLA_GRE_TTL]);
	153
	154	if (greinfo[IFLA_GRE_LINK])
	155	link = rta_getattr_u32(greinfo[IFLA_GRE_LINK]);
	156
	157	if (greinfo[IFLA_GRE_ENCAP_LIMIT])
	158	encap_limit = rta_getattr_u8(greinfo[IFLA_GRE_ENCAP_LIMIT]);
	159
	160	if (greinfo[IFLA_GRE_FLOWINFO])
	161	flowinfo = rta_getattr_u32(greinfo[IFLA_GRE_FLOWINFO]);
	162
	163	if (greinfo[IFLA_GRE_FLAGS])
	164	flags = rta_getattr_u32(greinfo[IFLA_GRE_FLAGS]);
0b2fbb73 TH	165
	166	if (greinfo[IFLA_GRE_ENCAP_TYPE])
	167	encaptype = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_TYPE]);
	168
	169	if (greinfo[IFLA_GRE_ENCAP_FLAGS])
	170	encapflags = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_FLAGS]);
	171
	172	if (greinfo[IFLA_GRE_ENCAP_SPORT])
	173	encapsport = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_SPORT]);
	174
	175	if (greinfo[IFLA_GRE_ENCAP_DPORT])
	176	encapdport = rta_getattr_u16(greinfo[IFLA_GRE_ENCAP_DPORT]);
af89576d	177	}
	178
	179	while (argc > 0) {
	180	if (!matches(*argv, "key")) {
56f5daac	181	unsigned int uval;
af89576d	182
	183	NEXT_ARG();
	184	iflags \|= GRE_KEY;
	185	oflags \|= GRE_KEY;
	186	if (strchr(*argv, '.'))
	187	uval = get_addr32(*argv);
	188	else {
	189	if (get_unsigned(&uval, *argv, 0) < 0) {
	190	fprintf(stderr,
	191	"Invalid value for \"key\"\n");
	192	exit(-1);
	193	}
	194	uval = htonl(uval);
	195	}
	196
	197	ikey = okey = uval;
	198	} else if (!matches(*argv, "ikey")) {
56f5daac	199	unsigned int uval;
af89576d	200
	201	NEXT_ARG();
	202	iflags \|= GRE_KEY;
	203	if (strchr(*argv, '.'))
	204	uval = get_addr32(*argv);
	205	else {
56f5daac	206	if (get_unsigned(&uval, *argv, 0) < 0) {
af89576d	207	fprintf(stderr, "invalid value of \"ikey\"\n");
	208	exit(-1);
	209	}
	210	uval = htonl(uval);
	211	}
	212	ikey = uval;
	213	} else if (!matches(*argv, "okey")) {
56f5daac	214	unsigned int uval;
af89576d	215
	216	NEXT_ARG();
	217	oflags \|= GRE_KEY;
	218	if (strchr(*argv, '.'))
	219	uval = get_addr32(*argv);
	220	else {
56f5daac	221	if (get_unsigned(&uval, *argv, 0) < 0) {
af89576d	222	fprintf(stderr, "invalid value of \"okey\"\n");
	223	exit(-1);
	224	}
	225	uval = htonl(uval);
	226	}
	227	okey = uval;
	228	} else if (!matches(*argv, "seq")) {
	229	iflags \|= GRE_SEQ;
	230	oflags \|= GRE_SEQ;
	231	} else if (!matches(*argv, "iseq")) {
	232	iflags \|= GRE_SEQ;
	233	} else if (!matches(*argv, "oseq")) {
	234	oflags \|= GRE_SEQ;
	235	} else if (!matches(*argv, "csum")) {
	236	iflags \|= GRE_CSUM;
	237	oflags \|= GRE_CSUM;
	238	} else if (!matches(*argv, "icsum")) {
	239	iflags \|= GRE_CSUM;
	240	} else if (!matches(*argv, "ocsum")) {
	241	oflags \|= GRE_CSUM;
	242	} else if (!matches(*argv, "remote")) {
	243	inet_prefix addr;
56f5daac	244
af89576d	245	NEXT_ARG();
	246	get_prefix(&addr, *argv, preferred_family);
	247	if (addr.family == AF_UNSPEC)
	248	invarg("\"remote\" address family is AF_UNSPEC", *argv);
	249	memcpy(&raddr, &addr.data, sizeof(raddr));
	250	} else if (!matches(*argv, "local")) {
	251	inet_prefix addr;
56f5daac	252
af89576d	253	NEXT_ARG();
	254	get_prefix(&addr, *argv, preferred_family);
	255	if (addr.family == AF_UNSPEC)
	256	invarg("\"local\" address family is AF_UNSPEC", *argv);
	257	memcpy(&laddr, &addr.data, sizeof(laddr));
	258	} else if (!matches(*argv, "dev")) {
	259	NEXT_ARG();
	260	link = if_nametoindex(*argv);
0cb6bb51 CW	261	if (link == 0) {
	262	fprintf(stderr, "Cannot find device \"%s\"\n",
	263	*argv);
af89576d	264	exit(-1);
0cb6bb51	265	}
af89576d	266	} else if (!matches(*argv, "ttl") \|\|
	267	!matches(*argv, "hoplimit")) {
	268	__u8 uval;
56f5daac	269
af89576d	270	NEXT_ARG();
	271	if (get_u8(&uval, *argv, 0))
	272	invarg("invalid TTL", *argv);
	273	hop_limit = uval;
	274	} else if (!matches(*argv, "tos") \|\|
	275	!matches(*argv, "tclass") \|\|
	276	!matches(*argv, "dsfield")) {
	277	__u8 uval;
56f5daac	278
af89576d	279	NEXT_ARG();
	280	if (strcmp(*argv, "inherit") == 0)
	281	flags \|= IP6_TNL_F_USE_ORIG_TCLASS;
	282	else {
	283	if (get_u8(&uval, *argv, 16))
	284	invarg("invalid TClass", *argv);
	285	flowinfo \|= htonl((__u32)uval << 20) & IP6_FLOWINFO_TCLASS;
	286	flags &= ~IP6_TNL_F_USE_ORIG_TCLASS;
	287	}
	288	} else if (strcmp(*argv, "flowlabel") == 0 \|\|
	289	strcmp(*argv, "fl") == 0) {
	290	__u32 uval;
56f5daac	291
af89576d	292	NEXT_ARG();
	293	if (strcmp(*argv, "inherit") == 0)
	294	flags \|= IP6_TNL_F_USE_ORIG_FLOWLABEL;
	295	else {
	296	if (get_u32(&uval, *argv, 16))
	297	invarg("invalid Flowlabel", *argv);
	298	if (uval > 0xFFFFF)
	299	invarg("invalid Flowlabel", *argv);
	300	flowinfo \|= htonl(uval) & IP6_FLOWINFO_FLOWLABEL;
	301	flags &= ~IP6_TNL_F_USE_ORIG_FLOWLABEL;
	302	}
	303	} else if (strcmp(*argv, "dscp") == 0) {
	304	NEXT_ARG();
	305	if (strcmp(*argv, "inherit") != 0)
	306	invarg("not inherit", *argv);
	307	flags \|= IP6_TNL_F_RCV_DSCP_COPY;
0b2fbb73 TH	308	} else if (strcmp(*argv, "noencap") == 0) {
	309	encaptype = TUNNEL_ENCAP_NONE;
	310	} else if (strcmp(*argv, "encap") == 0) {
	311	NEXT_ARG();
	312	if (strcmp(*argv, "fou") == 0)
	313	encaptype = TUNNEL_ENCAP_FOU;
	314	else if (strcmp(*argv, "gue") == 0)
	315	encaptype = TUNNEL_ENCAP_GUE;
	316	else if (strcmp(*argv, "none") == 0)
	317	encaptype = TUNNEL_ENCAP_NONE;
	318	else
	319	invarg("Invalid encap type.", *argv);
	320	} else if (strcmp(*argv, "encap-sport") == 0) {
	321	NEXT_ARG();
	322	if (strcmp(*argv, "auto") == 0)
	323	encapsport = 0;
	324	else if (get_u16(&encapsport, *argv, 0))
	325	invarg("Invalid source port.", *argv);
	326	} else if (strcmp(*argv, "encap-dport") == 0) {
	327	NEXT_ARG();
	328	if (get_u16(&encapdport, *argv, 0))
	329	invarg("Invalid destination port.", *argv);
	330	} else if (strcmp(*argv, "encap-csum") == 0) {
	331	encapflags \|= TUNNEL_ENCAP_FLAG_CSUM;
	332	} else if (strcmp(*argv, "noencap-csum") == 0) {
	333	encapflags &= ~TUNNEL_ENCAP_FLAG_CSUM;
	334	} else if (strcmp(*argv, "encap-udp6-csum") == 0) {
	335	encapflags \|= TUNNEL_ENCAP_FLAG_CSUM6;
	336	} else if (strcmp(*argv, "noencap-udp6-csum") == 0) {
	337	encapflags &= ~TUNNEL_ENCAP_FLAG_CSUM6;
	338	} else if (strcmp(*argv, "encap-remcsum") == 0) {
	339	encapflags \|= TUNNEL_ENCAP_FLAG_REMCSUM;
	340	} else if (strcmp(*argv, "noencap-remcsum") == 0) {
	341	encapflags &= ~TUNNEL_ENCAP_FLAG_REMCSUM;
af89576d	342	} else
	343	usage();
	344	argc--; argv++;
	345	}
	346
	347	addattr32(n, 1024, IFLA_GRE_IKEY, ikey);
	348	addattr32(n, 1024, IFLA_GRE_OKEY, okey);
	349	addattr_l(n, 1024, IFLA_GRE_IFLAGS, &iflags, 2);
	350	addattr_l(n, 1024, IFLA_GRE_OFLAGS, &oflags, 2);
	351	addattr_l(n, 1024, IFLA_GRE_LOCAL, &laddr, sizeof(laddr));
	352	addattr_l(n, 1024, IFLA_GRE_REMOTE, &raddr, sizeof(raddr));
	353	if (link)
	354	addattr32(n, 1024, IFLA_GRE_LINK, link);
	355	addattr_l(n, 1024, IFLA_GRE_TTL, &hop_limit, 1);
	356	addattr_l(n, 1024, IFLA_GRE_ENCAP_LIMIT, &encap_limit, 1);
	357	addattr_l(n, 1024, IFLA_GRE_FLOWINFO, &flowinfo, 4);
	358	addattr_l(n, 1024, IFLA_GRE_FLAGS, &flowinfo, 4);
	359
0b2fbb73 TH	360	addattr16(n, 1024, IFLA_GRE_ENCAP_TYPE, encaptype);
	361	addattr16(n, 1024, IFLA_GRE_ENCAP_FLAGS, encapflags);
	362	addattr16(n, 1024, IFLA_GRE_ENCAP_SPORT, htons(encapsport));
	363	addattr16(n, 1024, IFLA_GRE_ENCAP_DPORT, htons(encapdport));
	364
af89576d	365	return 0;
	366	}
	367
	368	static void gre_print_opt(struct link_util lu, FILE f, struct rtattr *tb[])
	369	{
af89576d	370	char s2[64];
	371	const char *local = "any";
	372	const char *remote = "any";
56f5daac SH	373	unsigned int iflags = 0;
	374	unsigned int oflags = 0;
	375	unsigned int flags = 0;
	376	unsigned int flowinfo = 0;
af89576d	377	struct in6_addr in6_addr_any = IN6ADDR_ANY_INIT;
	378
	379	if (!tb)
	380	return;
	381
	382	if (tb[IFLA_GRE_FLAGS])
	383	flags = rta_getattr_u32(tb[IFLA_GRE_FLAGS]);
	384
	385	if (tb[IFLA_GRE_FLOWINFO])
	386	flags = rta_getattr_u32(tb[IFLA_GRE_FLOWINFO]);
	387
	388	if (tb[IFLA_GRE_REMOTE]) {
	389	struct in6_addr addr;
56f5daac	390
af89576d	391	memcpy(&addr, RTA_DATA(tb[IFLA_GRE_REMOTE]), sizeof(addr));
	392
	393	if (memcmp(&addr, &in6_addr_any, sizeof(addr)))
a418e451	394	remote = format_host(AF_INET6, sizeof(addr), &addr);
af89576d	395	}
	396
	397	fprintf(f, "remote %s ", remote);
	398
	399	if (tb[IFLA_GRE_LOCAL]) {
	400	struct in6_addr addr;
56f5daac	401
af89576d	402	memcpy(&addr, RTA_DATA(tb[IFLA_GRE_LOCAL]), sizeof(addr));
	403
	404	if (memcmp(&addr, &in6_addr_any, sizeof(addr)))
a418e451	405	local = format_host(AF_INET6, sizeof(addr), &addr);
af89576d	406	}
	407
	408	fprintf(f, "local %s ", local);
	409
	410	if (tb[IFLA_GRE_LINK] && rta_getattr_u32(tb[IFLA_GRE_LINK])) {
56f5daac	411	unsigned int link = rta_getattr_u32(tb[IFLA_GRE_LINK]);
af89576d	412	const char *n = if_indextoname(link, s2);
	413
	414	if (n)
	415	fprintf(f, "dev %s ", n);
	416	else
	417	fprintf(f, "dev %u ", link);
	418	}
	419
	420	if (tb[IFLA_GRE_TTL] && rta_getattr_u8(tb[IFLA_GRE_TTL]))
	421	fprintf(f, "hoplimit %d ", rta_getattr_u8(tb[IFLA_GRE_TTL]));
	422
	423	if (flags & IP6_TNL_F_IGN_ENCAP_LIMIT)
	424	fprintf(f, "encaplimit none ");
	425	else if (tb[IFLA_GRE_ENCAP_LIMIT]) {
	426	int encap_limit = rta_getattr_u8(tb[IFLA_GRE_ENCAP_LIMIT]);
	427
	428	fprintf(f, "encaplimit %d ", encap_limit);
	429	}
	430
	431	if (flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
	432	fprintf(f, "flowlabel inherit ");
	433	else
	434	fprintf(f, "flowlabel 0x%05x ", ntohl(flowinfo & IP6_FLOWINFO_FLOWLABEL));
	435
	436	if (flags & IP6_TNL_F_RCV_DSCP_COPY)
	437	fprintf(f, "dscp inherit ");
	438
	439	if (tb[IFLA_GRE_IFLAGS])
	440	iflags = rta_getattr_u16(tb[IFLA_GRE_IFLAGS]);
	441
	442	if (tb[IFLA_GRE_OFLAGS])
	443	oflags = rta_getattr_u16(tb[IFLA_GRE_OFLAGS]);
	444
	445	if ((iflags & GRE_KEY) && tb[IFLA_GRE_IKEY]) {
	446	inet_ntop(AF_INET, RTA_DATA(tb[IFLA_GRE_IKEY]), s2, sizeof(s2));
	447	fprintf(f, "ikey %s ", s2);
	448	}
	449
	450	if ((oflags & GRE_KEY) && tb[IFLA_GRE_OKEY]) {
	451	inet_ntop(AF_INET, RTA_DATA(tb[IFLA_GRE_OKEY]), s2, sizeof(s2));
	452	fprintf(f, "okey %s ", s2);
	453	}
	454
	455	if (iflags & GRE_SEQ)
	456	fputs("iseq ", f);
	457	if (oflags & GRE_SEQ)
	458	fputs("oseq ", f);
	459	if (iflags & GRE_CSUM)
	460	fputs("icsum ", f);
	461	if (oflags & GRE_CSUM)
	462	fputs("ocsum ", f);
0b2fbb73 TH	463
	464	if (tb[IFLA_GRE_ENCAP_TYPE] &&
	465	rta_getattr_u16(tb[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE) {
	466	__u16 type = rta_getattr_u16(tb[IFLA_GRE_ENCAP_TYPE]);
	467	__u16 flags = rta_getattr_u16(tb[IFLA_GRE_ENCAP_FLAGS]);
	468	__u16 sport = rta_getattr_u16(tb[IFLA_GRE_ENCAP_SPORT]);
	469	__u16 dport = rta_getattr_u16(tb[IFLA_GRE_ENCAP_DPORT]);
	470
	471	fputs("encap ", f);
	472	switch (type) {
	473	case TUNNEL_ENCAP_FOU:
	474	fputs("fou ", f);
	475	break;
	476	case TUNNEL_ENCAP_GUE:
	477	fputs("gue ", f);
	478	break;
	479	default:
	480	fputs("unknown ", f);
	481	break;
	482	}
	483
	484	if (sport == 0)
	485	fputs("encap-sport auto ", f);
	486	else
	487	fprintf(f, "encap-sport %u", ntohs(sport));
	488
	489	fprintf(f, "encap-dport %u ", ntohs(dport));
	490
	491	if (flags & TUNNEL_ENCAP_FLAG_CSUM)
	492	fputs("encap-csum ", f);
	493	else
	494	fputs("noencap-csum ", f);
	495
	496	if (flags & TUNNEL_ENCAP_FLAG_CSUM6)
	497	fputs("encap-csum6 ", f);
	498	else
	499	fputs("noencap-csum6 ", f);
	500
	501	if (flags & TUNNEL_ENCAP_FLAG_REMCSUM)
	502	fputs("encap-remcsum ", f);
	503	else
	504	fputs("noencap-remcsum ", f);
	505	}
af89576d	506	}
af89576d	507
561e650e	508	static void gre_print_help(struct link_util lu, int argc, char *argv,
	509	FILE *f)
	510	{
	511	print_usage(f);
	512	}
	513
af89576d	514	struct link_util ip6gre_link_util = {
	515	.id = "ip6gre",
	516	.maxattr = IFLA_GRE_MAX,
	517	.parse_opt = gre_parse_opt,
	518	.print_opt = gre_print_opt,
561e650e	519	.print_help = gre_print_help,
af89576d	520	};
	521
	522	struct link_util ip6gretap_link_util = {
	523	.id = "ip6gretap",
	524	.maxattr = IFLA_GRE_MAX,
	525	.parse_opt = gre_parse_opt,
	526	.print_opt = gre_print_opt,
561e650e	527	.print_help = gre_print_help,
af89576d	528	};