/*

 * iproute_lwtunnel.c

 *

 *		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:	Roopa Prabhu, <roopa@cumulusnetworks.com>

 *		Thomas Graf <tgraf@suug.ch>

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <string.h>

#include <linux/ila.h>

#include <linux/lwtunnel.h>

#include <linux/mpls_iptunnel.h>

#include <errno.h>

#include "rt_names.h"

#include "bpf_util.h"

#include "utils.h"

#include "ip_common.h"

#include "ila_common.h"

#include <linux/seg6.h>

#include <linux/seg6_iptunnel.h>

#include <linux/rpl.h>

#include <linux/rpl_iptunnel.h>

#include <linux/seg6_hmac.h>

#include <linux/seg6_local.h>

#include <linux/if_tunnel.h>

static const char *format_encap_type(int type)

{

	switch (type) {

	case LWTUNNEL_ENCAP_MPLS:

		return "mpls";

	case LWTUNNEL_ENCAP_IP:

		return "ip";

	case LWTUNNEL_ENCAP_IP6:

		return "ip6";

	case LWTUNNEL_ENCAP_ILA:

		return "ila";

	case LWTUNNEL_ENCAP_BPF:

		return "bpf";

	case LWTUNNEL_ENCAP_SEG6:

		return "seg6";

	case LWTUNNEL_ENCAP_SEG6_LOCAL:

		return "seg6local";

	case LWTUNNEL_ENCAP_RPL:

		return "rpl";

	default:

		return "unknown";

	}

}

static void encap_type_usage(void)

{

	int i;

	fprintf(stderr, "Usage: ip route ... encap TYPE [ OPTIONS ] [...]\n");

	for (i = 1; i <= LWTUNNEL_ENCAP_MAX; i++)

		fprintf(stderr, "%s %s\n", format_encap_type(i),

			i == 1 ? "TYPE := " : "      ");

	exit(-1);

}

static int read_encap_type(const char *name)

{

	if (strcmp(name, "mpls") == 0)

		return LWTUNNEL_ENCAP_MPLS;

	else if (strcmp(name, "ip") == 0)

		return LWTUNNEL_ENCAP_IP;

	else if (strcmp(name, "ip6") == 0)

		return LWTUNNEL_ENCAP_IP6;

	else if (strcmp(name, "ila") == 0)

		return LWTUNNEL_ENCAP_ILA;

	else if (strcmp(name, "bpf") == 0)

		return LWTUNNEL_ENCAP_BPF;

	else if (strcmp(name, "seg6") == 0)

		return LWTUNNEL_ENCAP_SEG6;

	else if (strcmp(name, "seg6local") == 0)

		return LWTUNNEL_ENCAP_SEG6_LOCAL;

	else if (strcmp(name, "rpl") == 0)

		return LWTUNNEL_ENCAP_RPL;

	else if (strcmp(name, "help") == 0)

		encap_type_usage();

	return LWTUNNEL_ENCAP_NONE;

}

static void print_srh(FILE *fp, struct ipv6_sr_hdr *srh)

{

	int i;

	if (is_json_context())

		open_json_array(PRINT_JSON, "segs");

	else

		fprintf(fp, "segs %d [ ", srh->first_segment + 1);

	for (i = srh->first_segment; i >= 0; i--)

		print_color_string(PRINT_ANY, COLOR_INET6,

				   NULL, "%s ",

				   rt_addr_n2a(AF_INET6, 16, &srh->segments[i]));

	if (is_json_context())

		close_json_array(PRINT_JSON, NULL);

	else

		fprintf(fp, "] ");

	if (sr_has_hmac(srh)) {

		unsigned int offset = ((srh->hdrlen + 1) << 3) - 40;

		struct sr6_tlv_hmac *tlv;

		tlv = (struct sr6_tlv_hmac *)((char *)srh + offset);

		print_0xhex(PRINT_ANY, "hmac",

			    "hmac %llX ", ntohl(tlv->hmackeyid));

	}

}

static const char *seg6_mode_types[] = {

	[SEG6_IPTUN_MODE_INLINE]	= "inline",

	[SEG6_IPTUN_MODE_ENCAP]		= "encap",

	[SEG6_IPTUN_MODE_L2ENCAP]	= "l2encap",

};

static const char *format_seg6mode_type(int mode)

{

	if (mode < 0 || mode > ARRAY_SIZE(seg6_mode_types))

		return "<unknown>";

	return seg6_mode_types[mode];

}

static int read_seg6mode_type(const char *mode)

{

	int i;

	for (i = 0; i < ARRAY_SIZE(seg6_mode_types); i++) {

		if (strcmp(mode, seg6_mode_types[i]) == 0)

			return i;

	}

	return -1;

}

static void print_encap_seg6(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[SEG6_IPTUNNEL_MAX+1];

	struct seg6_iptunnel_encap *tuninfo;

	parse_rtattr_nested(tb, SEG6_IPTUNNEL_MAX, encap);

	if (!tb[SEG6_IPTUNNEL_SRH])

		return;

	tuninfo = RTA_DATA(tb[SEG6_IPTUNNEL_SRH]);

	print_string(PRINT_ANY, "mode",

		     "mode %s ", format_seg6mode_type(tuninfo->mode));

	print_srh(fp, tuninfo->srh);

}

static void print_rpl_srh(FILE *fp, struct ipv6_rpl_sr_hdr *srh)

{

	int i;

	if (is_json_context())

		open_json_array(PRINT_JSON, "segs");

	else

		fprintf(fp, "segs %d [ ", srh->segments_left);

	for (i = srh->segments_left - 1; i >= 0; i--) {

		print_color_string(PRINT_ANY, COLOR_INET6,

				   NULL, "%s ",

				   rt_addr_n2a(AF_INET6, 16, &srh->rpl_segaddr[i]));

	}

	if (is_json_context())

		close_json_array(PRINT_JSON, NULL);

	else

		fprintf(fp, "] ");

}

static void print_encap_rpl(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[RPL_IPTUNNEL_MAX + 1];

	struct ipv6_rpl_sr_hdr *srh;

	parse_rtattr_nested(tb, RPL_IPTUNNEL_MAX, encap);

	if (!tb[RPL_IPTUNNEL_SRH])

		return;

	srh = RTA_DATA(tb[RPL_IPTUNNEL_SRH]);

	print_rpl_srh(fp, srh);

}

static const char *seg6_action_names[SEG6_LOCAL_ACTION_MAX + 1] = {

	[SEG6_LOCAL_ACTION_END]			= "End",

	[SEG6_LOCAL_ACTION_END_X]		= "End.X",

	[SEG6_LOCAL_ACTION_END_T]		= "End.T",

	[SEG6_LOCAL_ACTION_END_DX2]		= "End.DX2",

	[SEG6_LOCAL_ACTION_END_DX6]		= "End.DX6",

	[SEG6_LOCAL_ACTION_END_DX4]		= "End.DX4",

	[SEG6_LOCAL_ACTION_END_DT6]		= "End.DT6",

	[SEG6_LOCAL_ACTION_END_DT4]		= "End.DT4",

	[SEG6_LOCAL_ACTION_END_B6]		= "End.B6",

	[SEG6_LOCAL_ACTION_END_B6_ENCAP]	= "End.B6.Encaps",

	[SEG6_LOCAL_ACTION_END_BM]		= "End.BM",

	[SEG6_LOCAL_ACTION_END_S]		= "End.S",

	[SEG6_LOCAL_ACTION_END_AS]		= "End.AS",

	[SEG6_LOCAL_ACTION_END_AM]		= "End.AM",

	[SEG6_LOCAL_ACTION_END_BPF]		= "End.BPF",

};

static const char *format_action_type(int action)

{

	if (action < 0 || action > SEG6_LOCAL_ACTION_MAX)

		return "<invalid>";

	return seg6_action_names[action] ?: "<unknown>";

}

static int read_action_type(const char *name)

{

	int i;

	for (i = 0; i < SEG6_LOCAL_ACTION_MAX + 1; i++) {

		if (!seg6_action_names[i])

			continue;

		if (strcmp(seg6_action_names[i], name) == 0)

			return i;

	}

	return SEG6_LOCAL_ACTION_UNSPEC;

}

static void print_encap_bpf_prog(FILE *fp, struct rtattr *encap,

				 const char *str)

{

	struct rtattr *tb[LWT_BPF_PROG_MAX+1];

	const char *progname = NULL;

	parse_rtattr_nested(tb, LWT_BPF_PROG_MAX, encap);

	if (tb[LWT_BPF_PROG_NAME])

		progname = rta_getattr_str(tb[LWT_BPF_PROG_NAME]);

	if (is_json_context())

		print_string(PRINT_JSON, str, NULL,

			     progname ? : "<unknown>");

	else {

		fprintf(fp, "%s ", str);

		if (progname)

			fprintf(fp, "%s ", progname);

	}

}

static void print_encap_seg6local(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[SEG6_LOCAL_MAX + 1];

	int action;

	SPRINT_BUF(b1);

	parse_rtattr_nested(tb, SEG6_LOCAL_MAX, encap);

	if (!tb[SEG6_LOCAL_ACTION])

		return;

	action = rta_getattr_u32(tb[SEG6_LOCAL_ACTION]);

	print_string(PRINT_ANY, "action",

		     "action %s ", format_action_type(action));

	if (tb[SEG6_LOCAL_SRH]) {

		open_json_object("srh");

		print_srh(fp, RTA_DATA(tb[SEG6_LOCAL_SRH]));

		close_json_object();

	}

	if (tb[SEG6_LOCAL_TABLE])

		print_string(PRINT_ANY, "table", "table %s ",

			     rtnl_rttable_n2a(rta_getattr_u32(tb[SEG6_LOCAL_TABLE]),

			     b1, sizeof(b1)));

	if (tb[SEG6_LOCAL_NH4]) {

		print_string(PRINT_ANY, "nh4",

			     "nh4 %s ", rt_addr_n2a_rta(AF_INET, tb[SEG6_LOCAL_NH4]));

	}

	if (tb[SEG6_LOCAL_NH6]) {

		print_string(PRINT_ANY, "nh6",

			     "nh6 %s ", rt_addr_n2a_rta(AF_INET6, tb[SEG6_LOCAL_NH6]));

	}

	if (tb[SEG6_LOCAL_IIF]) {

		int iif = rta_getattr_u32(tb[SEG6_LOCAL_IIF]);

		print_string(PRINT_ANY, "iif",

			     "iif %s ", ll_index_to_name(iif));

	}

	if (tb[SEG6_LOCAL_OIF]) {

		int oif = rta_getattr_u32(tb[SEG6_LOCAL_OIF]);

		print_string(PRINT_ANY, "oif",

			     "oif %s ", ll_index_to_name(oif));

	}

	if (tb[SEG6_LOCAL_BPF])

		print_encap_bpf_prog(fp, tb[SEG6_LOCAL_BPF], "endpoint");

}

static void print_encap_mpls(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[MPLS_IPTUNNEL_MAX+1];

	parse_rtattr_nested(tb, MPLS_IPTUNNEL_MAX, encap);

	if (tb[MPLS_IPTUNNEL_DST])

		print_string(PRINT_ANY, "dst", " %s ",

			format_host_rta(AF_MPLS, tb[MPLS_IPTUNNEL_DST]));

	if (tb[MPLS_IPTUNNEL_TTL])

		print_uint(PRINT_ANY, "ttl", "ttl %u ",

			rta_getattr_u8(tb[MPLS_IPTUNNEL_TTL]));

}

static void lwtunnel_print_geneve_opts(struct rtattr *attr)

{

	struct rtattr *tb[LWTUNNEL_IP_OPT_GENEVE_MAX + 1];

	struct rtattr *i = RTA_DATA(attr);

	int rem = RTA_PAYLOAD(attr);

	char *name = "geneve_opts";

	int data_len, offset = 0;

	char data[rem * 2 + 1];

	__u16 class;

	__u8 type;

	print_nl();

	print_string(PRINT_FP, name, "\t%s ", name);

	open_json_array(PRINT_JSON, name);

	while (rem) {

		parse_rtattr(tb, LWTUNNEL_IP_OPT_GENEVE_MAX, i, rem);

		class = rta_getattr_be16(tb[LWTUNNEL_IP_OPT_GENEVE_CLASS]);

		type = rta_getattr_u8(tb[LWTUNNEL_IP_OPT_GENEVE_TYPE]);

		data_len = RTA_PAYLOAD(tb[LWTUNNEL_IP_OPT_GENEVE_DATA]);

		hexstring_n2a(RTA_DATA(tb[LWTUNNEL_IP_OPT_GENEVE_DATA]),

			      data_len, data, sizeof(data));

		offset += data_len + 20;

		rem -= data_len + 20;

		i = RTA_DATA(attr) + offset;

		open_json_object(NULL);

		print_uint(PRINT_ANY, "class", "%u", class);

		print_uint(PRINT_ANY, "type", ":%u", type);

		if (rem)

			print_string(PRINT_ANY, "data", ":%s,", data);

		else

			print_string(PRINT_ANY, "data", ":%s ", data);

		close_json_object();

	}

	close_json_array(PRINT_JSON, name);

}

static void lwtunnel_print_vxlan_opts(struct rtattr *attr)

{

	struct rtattr *tb[LWTUNNEL_IP_OPT_VXLAN_MAX + 1];

	struct rtattr *i = RTA_DATA(attr);

	int rem = RTA_PAYLOAD(attr);

	char *name = "vxlan_opts";

	__u32 gbp;

	parse_rtattr(tb, LWTUNNEL_IP_OPT_VXLAN_MAX, i, rem);

	gbp = rta_getattr_u32(tb[LWTUNNEL_IP_OPT_VXLAN_GBP]);

	print_nl();

	print_string(PRINT_FP, name, "\t%s ", name);

	open_json_array(PRINT_JSON, name);

	open_json_object(NULL);

	print_uint(PRINT_ANY, "gbp", "%u ", gbp);

	close_json_object();

	close_json_array(PRINT_JSON, name);

}

static void lwtunnel_print_erspan_opts(struct rtattr *attr)

{

	struct rtattr *tb[LWTUNNEL_IP_OPT_ERSPAN_MAX + 1];

	struct rtattr *i = RTA_DATA(attr);

	char *name = "erspan_opts";

	__u8 ver, hwid, dir;

	__u32 idx;

	parse_rtattr(tb, LWTUNNEL_IP_OPT_ERSPAN_MAX, i, RTA_PAYLOAD(attr));

	ver = rta_getattr_u8(tb[LWTUNNEL_IP_OPT_ERSPAN_VER]);

	if (ver == 1) {

		idx = rta_getattr_be32(tb[LWTUNNEL_IP_OPT_ERSPAN_INDEX]);

		dir = 0;

		hwid = 0;

	} else {

		idx = 0;

		dir = rta_getattr_u8(tb[LWTUNNEL_IP_OPT_ERSPAN_DIR]);

		hwid = rta_getattr_u8(tb[LWTUNNEL_IP_OPT_ERSPAN_HWID]);

	}

	print_nl();

	print_string(PRINT_FP, name, "\t%s ", name);

	open_json_array(PRINT_JSON, name);

	open_json_object(NULL);

	print_uint(PRINT_ANY, "ver", "%u", ver);

	print_uint(PRINT_ANY, "index", ":%u", idx);

	print_uint(PRINT_ANY, "dir", ":%u", dir);

	print_uint(PRINT_ANY, "hwid", ":%u ", hwid);

	close_json_object();

	close_json_array(PRINT_JSON, name);

}

static void lwtunnel_print_opts(struct rtattr *attr)

{

	struct rtattr *tb_opt[LWTUNNEL_IP_OPTS_MAX + 1];

	parse_rtattr_nested(tb_opt, LWTUNNEL_IP_OPTS_MAX, attr);

	if (tb_opt[LWTUNNEL_IP_OPTS_GENEVE])

		lwtunnel_print_geneve_opts(tb_opt[LWTUNNEL_IP_OPTS_GENEVE]);

	else if (tb_opt[LWTUNNEL_IP_OPTS_VXLAN])

		lwtunnel_print_vxlan_opts(tb_opt[LWTUNNEL_IP_OPTS_VXLAN]);

	else if (tb_opt[LWTUNNEL_IP_OPTS_ERSPAN])

		lwtunnel_print_erspan_opts(tb_opt[LWTUNNEL_IP_OPTS_ERSPAN]);

}

static void print_encap_ip(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[LWTUNNEL_IP_MAX+1];

	__u16 flags;

	parse_rtattr_nested(tb, LWTUNNEL_IP_MAX, encap);

	if (tb[LWTUNNEL_IP_ID])

		print_u64(PRINT_ANY, "id", "id %llu ",

			   ntohll(rta_getattr_u64(tb[LWTUNNEL_IP_ID])));

	if (tb[LWTUNNEL_IP_SRC])

		print_color_string(PRINT_ANY, COLOR_INET,

				   "src", "src %s ",

				   rt_addr_n2a_rta(AF_INET, tb[LWTUNNEL_IP_SRC]));

	if (tb[LWTUNNEL_IP_DST])

		print_color_string(PRINT_ANY, COLOR_INET,

				   "dst", "dst %s ",

				   rt_addr_n2a_rta(AF_INET, tb[LWTUNNEL_IP_DST]));

	if (tb[LWTUNNEL_IP_TTL])

		print_uint(PRINT_ANY, "ttl",

			   "ttl %u ", rta_getattr_u8(tb[LWTUNNEL_IP_TTL]));

	if (tb[LWTUNNEL_IP_TOS])

		print_uint(PRINT_ANY, "tos",

			   "tos %d ", rta_getattr_u8(tb[LWTUNNEL_IP_TOS]));

	if (tb[LWTUNNEL_IP_FLAGS]) {

		flags = rta_getattr_u16(tb[LWTUNNEL_IP_FLAGS]);

		if (flags & TUNNEL_KEY)

			print_bool(PRINT_ANY, "key", "key ", true);

		if (flags & TUNNEL_CSUM)

			print_bool(PRINT_ANY, "csum", "csum ", true);

		if (flags & TUNNEL_SEQ)

			print_bool(PRINT_ANY, "seq", "seq ", true);

	}

	if (tb[LWTUNNEL_IP_OPTS])

		lwtunnel_print_opts(tb[LWTUNNEL_IP_OPTS]);

}

static void print_encap_ila(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[ILA_ATTR_MAX+1];

	parse_rtattr_nested(tb, ILA_ATTR_MAX, encap);

	if (tb[ILA_ATTR_LOCATOR]) {

		char abuf[ADDR64_BUF_SIZE];

		addr64_n2a(rta_getattr_u64(tb[ILA_ATTR_LOCATOR]),

			   abuf, sizeof(abuf));

		print_string(PRINT_ANY, "locator",

			     " %s ", abuf);

	}

	if (tb[ILA_ATTR_CSUM_MODE])

		print_string(PRINT_ANY, "csum_mode",

			     " csum-mode %s ",

			     ila_csum_mode2name(rta_getattr_u8(tb[ILA_ATTR_CSUM_MODE])));

	if (tb[ILA_ATTR_IDENT_TYPE])

		print_string(PRINT_ANY, "ident_type",

			     " ident-type %s ",

			     ila_ident_type2name(rta_getattr_u8(tb[ILA_ATTR_IDENT_TYPE])));

	if (tb[ILA_ATTR_HOOK_TYPE])

		print_string(PRINT_ANY, "hook_type",

			     " hook-type %s ",

			     ila_hook_type2name(rta_getattr_u8(tb[ILA_ATTR_HOOK_TYPE])));

}

static void print_encap_ip6(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[LWTUNNEL_IP6_MAX+1];

	__u16 flags;

	parse_rtattr_nested(tb, LWTUNNEL_IP6_MAX, encap);

	if (tb[LWTUNNEL_IP6_ID])

		print_u64(PRINT_ANY, "id", "id %llu ",

			    ntohll(rta_getattr_u64(tb[LWTUNNEL_IP6_ID])));

	if (tb[LWTUNNEL_IP6_SRC])

		print_color_string(PRINT_ANY, COLOR_INET6,

				   "src", "src %s ",

				   rt_addr_n2a_rta(AF_INET6, tb[LWTUNNEL_IP6_SRC]));

	if (tb[LWTUNNEL_IP6_DST])

		print_color_string(PRINT_ANY, COLOR_INET6,

				   "dst", "dst %s ",

				   rt_addr_n2a_rta(AF_INET6, tb[LWTUNNEL_IP6_DST]));

	if (tb[LWTUNNEL_IP6_HOPLIMIT])

		print_u64(PRINT_ANY, "hoplimit",

			   "hoplimit %u ",

			   rta_getattr_u8(tb[LWTUNNEL_IP6_HOPLIMIT]));

	if (tb[LWTUNNEL_IP6_TC])

		print_uint(PRINT_ANY, "tc",

			   "tc %u ", rta_getattr_u8(tb[LWTUNNEL_IP6_TC]));

	if (tb[LWTUNNEL_IP6_FLAGS]) {

		flags = rta_getattr_u16(tb[LWTUNNEL_IP6_FLAGS]);

		if (flags & TUNNEL_KEY)

			print_bool(PRINT_ANY, "key", "key ", true);

		if (flags & TUNNEL_CSUM)

			print_bool(PRINT_ANY, "csum", "csum ", true);

		if (flags & TUNNEL_SEQ)

			print_bool(PRINT_ANY, "seq", "seq ", true);

	}

	if (tb[LWTUNNEL_IP6_OPTS])

		lwtunnel_print_opts(tb[LWTUNNEL_IP6_OPTS]);

}

static void print_encap_bpf(FILE *fp, struct rtattr *encap)

{

	struct rtattr *tb[LWT_BPF_MAX+1];

	parse_rtattr_nested(tb, LWT_BPF_MAX, encap);

	if (tb[LWT_BPF_IN])

		print_encap_bpf_prog(fp, tb[LWT_BPF_IN], "in");

	if (tb[LWT_BPF_OUT])

		print_encap_bpf_prog(fp, tb[LWT_BPF_OUT], "out");

	if (tb[LWT_BPF_XMIT])

		print_encap_bpf_prog(fp, tb[LWT_BPF_XMIT], "xmit");

	if (tb[LWT_BPF_XMIT_HEADROOM])

		print_uint(PRINT_ANY, "headroom",

			   " %u ", rta_getattr_u32(tb[LWT_BPF_XMIT_HEADROOM]));

}

void lwt_print_encap(FILE *fp, struct rtattr *encap_type,

			  struct rtattr *encap)

{

	int et;

	if (!encap_type)

		return;

	et = rta_getattr_u16(encap_type);

	print_string(PRINT_ANY, "encap", " encap %s ", format_encap_type(et));

	switch (et) {

	case LWTUNNEL_ENCAP_MPLS:

		print_encap_mpls(fp, encap);

		break;

	case LWTUNNEL_ENCAP_IP:

		print_encap_ip(fp, encap);

		break;

	case LWTUNNEL_ENCAP_ILA:

		print_encap_ila(fp, encap);

		break;

	case LWTUNNEL_ENCAP_IP6:

		print_encap_ip6(fp, encap);

		break;

	case LWTUNNEL_ENCAP_BPF:

		print_encap_bpf(fp, encap);

		break;

	case LWTUNNEL_ENCAP_SEG6:

		print_encap_seg6(fp, encap);

		break;

	case LWTUNNEL_ENCAP_SEG6_LOCAL:

		print_encap_seg6local(fp, encap);

		break;

	case LWTUNNEL_ENCAP_RPL:

		print_encap_rpl(fp, encap);

		break;

	}

}

static struct ipv6_sr_hdr *parse_srh(char *segbuf, int hmac, bool encap)

{

	struct ipv6_sr_hdr *srh;

	int nsegs = 0;

	int srhlen;

	char *s;

	int i;

	s = segbuf;

	for (i = 0; *s; *s++ == ',' ? i++ : *s);

	nsegs = i + 1;

	if (!encap)

		nsegs++;

	srhlen = 8 + 16*nsegs;

	if (hmac)

		srhlen += 40;

	srh = malloc(srhlen);

	memset(srh, 0, srhlen);

	srh->hdrlen = (srhlen >> 3) - 1;

	srh->type = 4;

	srh->segments_left = nsegs - 1;

	srh->first_segment = nsegs - 1;

	if (hmac)

		srh->flags |= SR6_FLAG1_HMAC;

	i = srh->first_segment;

	for (s = strtok(segbuf, ","); s; s = strtok(NULL, ",")) {

		inet_prefix addr;

		get_addr(&addr, s, AF_INET6);

		memcpy(&srh->segments[i], addr.data, sizeof(struct in6_addr));

		i--;

	}

	if (hmac) {

		struct sr6_tlv_hmac *tlv;

		tlv = (struct sr6_tlv_hmac *)((char *)srh + srhlen - 40);

		tlv->tlvhdr.type = SR6_TLV_HMAC;

		tlv->tlvhdr.len = 38;

		tlv->hmackeyid = htonl(hmac);

	}

	return srh;

}

static int parse_encap_seg6(struct rtattr *rta, size_t len, int *argcp,

			    char ***argvp)

{

	int mode_ok = 0, segs_ok = 0, hmac_ok = 0;

	struct seg6_iptunnel_encap *tuninfo;

	struct ipv6_sr_hdr *srh;

	char **argv = *argvp;

	char segbuf[1024] = "";

	int argc = *argcp;

	int encap = -1;

	__u32 hmac = 0;

	int ret = 0;

	int srhlen;

	while (argc > 0) {

		if (strcmp(*argv, "mode") == 0) {

			NEXT_ARG();

			if (mode_ok++)

				duparg2("mode", *argv);

			encap = read_seg6mode_type(*argv);

			if (encap < 0)

				invarg("\"mode\" value is invalid\n", *argv);

		} else if (strcmp(*argv, "segs") == 0) {

			NEXT_ARG();

			if (segs_ok++)

				duparg2("segs", *argv);

			if (encap == -1)

				invarg("\"segs\" provided before \"mode\"\n",

				       *argv);

			strlcpy(segbuf, *argv, 1024);

		} else if (strcmp(*argv, "hmac") == 0) {

			NEXT_ARG();

			if (hmac_ok++)

				duparg2("hmac", *argv);

			get_u32(&hmac, *argv, 0);

		} else {

			break;

		}

		argc--; argv++;

	}

	srh = parse_srh(segbuf, hmac, encap);

	srhlen = (srh->hdrlen + 1) << 3;

	tuninfo = malloc(sizeof(*tuninfo) + srhlen);

	memset(tuninfo, 0, sizeof(*tuninfo) + srhlen);

	tuninfo->mode = encap;

	memcpy(tuninfo->srh, srh, srhlen);

	if (rta_addattr_l(rta, len, SEG6_IPTUNNEL_SRH, tuninfo,

			  sizeof(*tuninfo) + srhlen)) {

		ret = -1;

		goto out;

	}

	*argcp = argc + 1;

	*argvp = argv - 1;

out:

	free(tuninfo);

	free(srh);

	return ret;

}

static struct ipv6_rpl_sr_hdr *parse_rpl_srh(char *segbuf)

{

	struct ipv6_rpl_sr_hdr *srh;

	int nsegs = 0;

	int srhlen;

	char *s;

	int i;

	s = segbuf;

	for (i = 0; *s; *s++ == ',' ? i++ : *s);

	nsegs = i + 1;

	srhlen = 8 + 16 * nsegs;

	srh = calloc(1, srhlen);

	srh->hdrlen = (srhlen >> 3) - 1;

	srh->type = 3;

	srh->segments_left = nsegs;

	for (s = strtok(segbuf, ","); s; s = strtok(NULL, ",")) {

		inet_prefix addr;

		get_addr(&addr, s, AF_INET6);

		memcpy(&srh->rpl_segaddr[i], addr.data, sizeof(struct in6_addr));

		i--;

	}

	return srh;

}

static int parse_encap_rpl(struct rtattr *rta, size_t len, int *argcp,

			   char ***argvp)

{

	struct ipv6_rpl_sr_hdr *srh;

	char **argv = *argvp;

	char segbuf[1024] = "";

	int argc = *argcp;

	int segs_ok = 0;

	int ret = 0;

	int srhlen;

	while (argc > 0) {

		if (strcmp(*argv, "segs") == 0) {

			NEXT_ARG();

			if (segs_ok++)

				duparg2("segs", *argv);

			strlcpy(segbuf, *argv, 1024);

		} else {

			break;

		}

		argc--; argv++;

	}

	srh = parse_rpl_srh(segbuf);

	srhlen = (srh->hdrlen + 1) << 3;

	if (rta_addattr_l(rta, len, RPL_IPTUNNEL_SRH, srh,

			  srhlen)) {

		ret = -1;

		goto out;

	}

	*argcp = argc + 1;

	*argvp = argv - 1;

out:

	free(srh);

	return ret;

}

struct lwt_x {

	struct rtattr *rta;

	size_t len;

};

static void bpf_lwt_cb(void *lwt_ptr, int fd, const char *annotation)

{

	struct lwt_x *x = lwt_ptr;

	rta_addattr32(x->rta, x->len, LWT_BPF_PROG_FD, fd);

	rta_addattr_l(x->rta, x->len, LWT_BPF_PROG_NAME, annotation,

		      strlen(annotation) + 1);

}

static const struct bpf_cfg_ops bpf_cb_ops = {

	.ebpf_cb = bpf_lwt_cb,

};

static int lwt_parse_bpf(struct rtattr *rta, size_t len,

			 int *argcp, char ***argvp,

			 int attr, const enum bpf_prog_type bpf_type)

{

	struct bpf_cfg_in cfg = {

		.type = bpf_type,

		.argc = *argcp,

		.argv = *argvp,

	};

	struct lwt_x x = {

		.rta = rta,

		.len = len,

	};

	struct rtattr *nest;

	int err;

	nest = rta_nest(rta, len, attr);

	err = bpf_parse_and_load_common(&cfg, &bpf_cb_ops, &x);

	if (err < 0) {

		fprintf(stderr, "Failed to parse eBPF program: %s\n",

			strerror(-err));

		return -1;

	}

	rta_nest_end(rta, nest);

	*argcp = cfg.argc;

	*argvp = cfg.argv;

	return 0;

}

static int parse_encap_seg6local(struct rtattr *rta, size_t len, int *argcp,

				 char ***argvp)

{

	int segs_ok = 0, hmac_ok = 0, table_ok = 0, nh4_ok = 0, nh6_ok = 0;

	int iif_ok = 0, oif_ok = 0, action_ok = 0, srh_ok = 0, bpf_ok = 0;

	__u32 action = 0, table, iif, oif;

	struct ipv6_sr_hdr *srh;

	char **argv = *argvp;

	int argc = *argcp;

	char segbuf[1024];

	inet_prefix addr;

	__u32 hmac = 0;

	int ret = 0;

	while (argc > 0) {

		if (strcmp(*argv, "action") == 0) {

			NEXT_ARG();

			if (action_ok++)

				duparg2("action", *argv);

			action = read_action_type(*argv);

			if (!action)