[thirdparty/systemd.git] / src / network / networkd-netdev-tunnel.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
    This file is part of systemd.

    Copyright 2014 Susant Sahani

    systemd is free software; you can redistribute it and/or modify it
    under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.

    systemd is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <arpa/inet.h>
#include <net/if.h>
#include <linux/ip.h>
#include <linux/if_tunnel.h>
#include <linux/ip6_tunnel.h>

#include "sd-netlink.h"
#include "networkd-netdev-tunnel.h"
#include "networkd-link.h"
#include "util.h"
#include "missing.h"
#include "conf-parser.h"

#define DEFAULT_TNL_HOP_LIMIT   64
#define IP6_FLOWINFO_FLOWLABEL  htonl(0x000FFFFF)

static const char* const ip6tnl_mode_table[_NETDEV_IP6_TNL_MODE_MAX] = {
        [NETDEV_IP6_TNL_MODE_IP6IP6] = "ip6ip6",
        [NETDEV_IP6_TNL_MODE_IPIP6] = "ipip6",
        [NETDEV_IP6_TNL_MODE_ANYIP6] = "any",
};

DEFINE_STRING_TABLE_LOOKUP(ip6tnl_mode, Ip6TnlMode);
DEFINE_CONFIG_PARSE_ENUM(config_parse_ip6tnl_mode, ip6tnl_mode, Ip6TnlMode, "Failed to parse ip6 tunnel Mode");

static int netdev_ipip_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t = IPIP(netdev);
        int r;

        assert(netdev);
        assert(link);
        assert(m);
        assert(t);
        assert(t->family == AF_INET);

        r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL  attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");

        return r;
}

static int netdev_sit_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t = SIT(netdev);
        int r;

        assert(netdev);
        assert(link);
        assert(m);
        assert(t);
        assert(t->family == AF_INET);

        r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");

        return r;
}

static int netdev_gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t;
        int r;

        assert(netdev);

        if (netdev->kind == NETDEV_KIND_GRE)
                t = GRE(netdev);
        else
                t = GRETAP(netdev);

        assert(t);
        assert(t->family == AF_INET);
        assert(link);
        assert(m);

        r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_GRE_LOCAL, &t->local.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_GRE_REMOTE, &t->remote.in);
        if (r < 0)
                log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_GRE_TOS, t->tos);
        if (r < 0)
                log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TOS attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_GRE_PMTUDISC, t->pmtudisc);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_PMTUDISC attribute: %m");

        return r;
}

static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t;
        int r;

        assert(netdev);

        if (netdev->kind == NETDEV_KIND_IP6GRE)
                t = IP6GRE(netdev);
        else
                t = IP6GRETAP(netdev);

        assert(t);
        assert(t->family == AF_INET6);
        assert(link);
        assert(m);

        r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");

        r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_LOCAL, &t->local.in6);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");

        r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_REMOTE, &t->remote.in6);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");

        if (t->ipv6_flowlabel != _NETDEV_IPV6_FLOWLABEL_INVALID) {
                r = sd_netlink_message_append_u32(m, IFLA_GRE_FLOWINFO, t->ipv6_flowlabel);
                if (r < 0)
                        return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_FLOWINFO attribute: %m");
        }

        r = sd_netlink_message_append_u32(m, IFLA_GRE_FLAGS, t->flags);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_FLAGS attribute: %m");

        return r;
}

static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t = VTI(netdev);
        int r;

        assert(netdev);
        assert(link);
        assert(m);
        assert(t);
        assert(t->family == AF_INET);

        r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_VTI_LOCAL, &t->local.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");

        r = sd_netlink_message_append_in_addr(m, IFLA_VTI_REMOTE, &t->remote.in);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");

        return r;
}

static int netdev_vti6_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t = VTI6(netdev);
        int r;

        assert(netdev);
        assert(link);
        assert(m);
        assert(t);
        assert(t->family == AF_INET6);

        r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");

        r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_LOCAL, &t->local.in6);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");

        r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_REMOTE, &t->remote.in6);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");

        return r;
}

static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
        Tunnel *t = IP6TNL(netdev);
        uint8_t proto;
        int r;

        assert(netdev);
        assert(link);
        assert(m);
        assert(t);
        assert(t->family == AF_INET6);

        r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");

        r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_LOCAL, &t->local.in6);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");

        r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in6);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");

        r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");

        if (t->ipv6_flowlabel != _NETDEV_IPV6_FLOWLABEL_INVALID) {
                r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLOWINFO, t->ipv6_flowlabel);
                if (r < 0)
                        return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLOWINFO attribute: %m");
        }

        if (t->copy_dscp)
                t->flags |= IP6_TNL_F_RCV_DSCP_COPY;

        r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLAGS, t->flags);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLAGS attribute: %m");

        switch (t->ip6tnl_mode) {
        case NETDEV_IP6_TNL_MODE_IP6IP6:
                proto = IPPROTO_IPV6;
                break;
        case NETDEV_IP6_TNL_MODE_IPIP6:
                proto = IPPROTO_IPIP;
                break;
        case NETDEV_IP6_TNL_MODE_ANYIP6:
        default:
                proto = 0;
                break;
        }

        r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PROTO, proto);
        if (r < 0)
                return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_MODE attribute: %m");

        return r;
}

static int netdev_tunnel_verify(NetDev *netdev, const char *filename) {
        Tunnel *t = NULL;

        assert(netdev);
        assert(filename);

        switch (netdev->kind) {
        case NETDEV_KIND_IPIP:
                t = IPIP(netdev);
                break;
        case NETDEV_KIND_SIT:
                t = SIT(netdev);
                break;
        case NETDEV_KIND_GRE:
                t = GRE(netdev);
                break;
        case NETDEV_KIND_GRETAP:
                t = GRETAP(netdev);
                break;
        case NETDEV_KIND_IP6GRE:
                t = IP6GRE(netdev);
                break;
        case NETDEV_KIND_IP6GRETAP:
                t = IP6GRETAP(netdev);
                break;
        case NETDEV_KIND_VTI:
                t = VTI(netdev);
                break;
        case NETDEV_KIND_VTI6:
                t = VTI6(netdev);
                break;
        case NETDEV_KIND_IP6TNL:
                t = IP6TNL(netdev);
                break;
        default:
                assert_not_reached("Invalid tunnel kind");
        }

        assert(t);

        if (t->remote.in.s_addr == INADDR_ANY) {
                log_warning("Tunnel without remote address configured in %s. Ignoring", filename);
                return -EINVAL;
        }

        if (t->family != AF_INET && t->family != AF_INET6) {
                log_warning("Tunnel with invalid address family configured in %s. Ignoring", filename);
                return -EINVAL;
        }

        if (netdev->kind == NETDEV_KIND_IP6TNL) {
                if (t->ip6tnl_mode == _NETDEV_IP6_TNL_MODE_INVALID) {
                        log_warning("IP6 Tunnel without mode configured in %s. Ignoring", filename);
                        return -EINVAL;
                }
        }

        return 0;
}

int config_parse_tunnel_address(const char *unit,
                                const char *filename,
                                unsigned line,
                                const char *section,
                                unsigned section_line,
                                const char *lvalue,
                                int ltype,
                                const char *rvalue,
                                void *data,
                                void *userdata) {
        Tunnel *t = userdata;
        union in_addr_union *addr = data, buffer;
        int r, f;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = in_addr_from_string_auto(rvalue, &f, &buffer);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel address is invalid, ignoring assignment: %s", rvalue);
                return 0;
        }

        if (t->family != AF_UNSPEC && t->family != f) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel addresses incompatible, ignoring assignment: %s", rvalue);
                return 0;
        }

        t->family = f;
        *addr = buffer;

        return 0;
}

static const char* const ipv6_flowlabel_table[_NETDEV_IPV6_FLOWLABEL_MAX] = {
        [NETDEV_IPV6_FLOWLABEL_INHERIT] = "inherit",
};

DEFINE_STRING_TABLE_LOOKUP(ipv6_flowlabel, IPv6FlowLabel);

int config_parse_ipv6_flowlabel(const char* unit,
                                const char *filename,
                                unsigned line,
                                const char *section,
                                unsigned section_line,
                                const char *lvalue,
                                int ltype,
                                const char *rvalue,
                                void *data,
                                void *userdata) {
        IPv6FlowLabel *ipv6_flowlabel = data;
        Tunnel *t = userdata;
        IPv6FlowLabel s;
        int k = 0;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(ipv6_flowlabel);

        s = ipv6_flowlabel_from_string(rvalue);
        if (s != _NETDEV_IPV6_FLOWLABEL_INVALID) {
                *ipv6_flowlabel = IP6_FLOWINFO_FLOWLABEL;
                t->flags |= IP6_TNL_F_USE_ORIG_FLOWLABEL;
        } else {
                r = config_parse_unsigned(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &k, userdata);
                if (r >= 0) {
                        if (k > 0xFFFFF)
                                log_syntax(unit, LOG_ERR, filename, line, k, "Failed to parse IPv6 flowlabel option, ignoring: %s", rvalue);
                        else {
                                *ipv6_flowlabel = htonl(k) & IP6_FLOWINFO_FLOWLABEL;
                                t->flags &= ~IP6_TNL_F_USE_ORIG_FLOWLABEL;
                        }
                }
        }

        return 0;
}

static void ipip_init(NetDev *n) {
        Tunnel *t = IPIP(n);

        assert(n);
        assert(t);

        t->pmtudisc = true;
}

static void sit_init(NetDev *n) {
        Tunnel *t = SIT(n);

        assert(n);
        assert(t);

        t->pmtudisc = true;
}

static void vti_init(NetDev *n) {
        Tunnel *t;

        assert(n);

        if (n->kind == NETDEV_KIND_VTI)
                t = VTI(n);
        else
                t = VTI6(n);

        assert(t);

        t->pmtudisc = true;
}

static void gre_init(NetDev *n) {
        Tunnel *t;

        assert(n);

        if (n->kind == NETDEV_KIND_GRE)
                t = GRE(n);
        else
                t = GRETAP(n);

        assert(t);

        t->pmtudisc = true;
}

static void ip6gre_init(NetDev *n) {
        Tunnel *t;

        assert(n);

        if (n->kind == NETDEV_KIND_IP6GRE)
                t = IP6GRE(n);
        else
                t = IP6GRETAP(n);

        assert(t);

        t->ttl = DEFAULT_TNL_HOP_LIMIT;
}

static void ip6tnl_init(NetDev *n) {
        Tunnel *t = IP6TNL(n);

        assert(n);
        assert(t);

        t->ttl = DEFAULT_TNL_HOP_LIMIT;
        t->encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
        t->ip6tnl_mode = _NETDEV_IP6_TNL_MODE_INVALID;
        t->ipv6_flowlabel = _NETDEV_IPV6_FLOWLABEL_INVALID;
}

const NetDevVTable ipip_vtable = {
        .object_size = sizeof(Tunnel),
        .init = ipip_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_ipip_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable sit_vtable = {
        .object_size = sizeof(Tunnel),
        .init = sit_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_sit_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable vti_vtable = {
        .object_size = sizeof(Tunnel),
        .init = vti_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_vti_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable vti6_vtable = {
        .object_size = sizeof(Tunnel),
        .init = vti_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_vti6_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable gre_vtable = {
        .object_size = sizeof(Tunnel),
        .init = gre_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_gre_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable gretap_vtable = {
        .object_size = sizeof(Tunnel),
        .init = gre_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_gre_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable ip6gre_vtable = {
        .object_size = sizeof(Tunnel),
        .init = ip6gre_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_ip6gre_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable ip6gretap_vtable = {
        .object_size = sizeof(Tunnel),
        .init = ip6gre_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_ip6gre_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};

const NetDevVTable ip6tnl_vtable = {
        .object_size = sizeof(Tunnel),
        .init = ip6tnl_init,
        .sections = "Match\0NetDev\0Tunnel\0",
        .fill_message_create = netdev_ip6tnl_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .config_verify = netdev_tunnel_verify,
};
Commit	Line	Data
7951dea2 SS	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
855ee1a1	6	Copyright 2014 Susant Sahani
7951dea2 SS	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
7951dea2 SS	22	#include <arpa/inet.h>
	23	#include <net/if.h>
	24	#include <linux/ip.h>
	25	#include <linux/if_tunnel.h>
855ee1a1	26	#include <linux/ip6_tunnel.h>
7951dea2	27
1c4baffc	28	#include "sd-netlink.h"
3be1d7e0	29	#include "networkd-netdev-tunnel.h"
0b1831c2	30	#include "networkd-link.h"
7951dea2	31	#include "util.h"
81577dc2	32	#include "missing.h"
6ef892fc	33	#include "conf-parser.h"
7951dea2	34
855ee1a1	35	#define DEFAULT_TNL_HOP_LIMIT 64
407af9dd	36	#define IP6_FLOWINFO_FLOWLABEL htonl(0x000FFFFF)
855ee1a1 SS	37
	38	static const char* const ip6tnl_mode_table[_NETDEV_IP6_TNL_MODE_MAX] = {
	39	[NETDEV_IP6_TNL_MODE_IP6IP6] = "ip6ip6",
73b23bea	40	[NETDEV_IP6_TNL_MODE_IPIP6] = "ipip6",
855ee1a1 SS	41	[NETDEV_IP6_TNL_MODE_ANYIP6] = "any",
	42	};
	43
	44	DEFINE_STRING_TABLE_LOOKUP(ip6tnl_mode, Ip6TnlMode);
	45	DEFINE_CONFIG_PARSE_ENUM(config_parse_ip6tnl_mode, ip6tnl_mode, Ip6TnlMode, "Failed to parse ip6 tunnel Mode");
	46
1c4baffc	47	static int netdev_ipip_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
aa9f1140	48	Tunnel *t = IPIP(netdev);
7951dea2 SS	49	int r;
7951dea2 SS	50
3be1d7e0	51	assert(netdev);
7951dea2	52	assert(link);
7951dea2	53	assert(m);
aa9f1140 TG	54	assert(t);
aa9f1140 TG	55	assert(t->family == AF_INET);
7951dea2	56
1c4baffc	57	r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
5289f3ff SS	58	if (r < 0)
5289f3ff SS	59	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
7951dea2	60
1c4baffc	61	r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
5289f3ff SS	62	if (r < 0)
5289f3ff SS	63	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
7951dea2	64
1c4baffc	65	r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
5289f3ff SS	66	if (r < 0)
5289f3ff SS	67	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
7951dea2	68
1c4baffc	69	r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
5289f3ff SS	70	if (r < 0)
5289f3ff SS	71	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
9ae70211	72
1c4baffc	73	r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
5289f3ff SS	74	if (r < 0)
5289f3ff SS	75	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
9243e967	76
7951dea2 SS	77	return r;
	78	}
	79
1c4baffc	80	static int netdev_sit_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
aa9f1140	81	Tunnel *t = SIT(netdev);
abf446af SS	82	int r;
abf446af SS	83
3be1d7e0	84	assert(netdev);
abf446af	85	assert(link);
abf446af	86	assert(m);
aa9f1140 TG	87	assert(t);
aa9f1140 TG	88	assert(t->family == AF_INET);
abf446af	89
1c4baffc	90	r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
5289f3ff SS	91	if (r < 0)
5289f3ff SS	92	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
abf446af	93
1c4baffc	94	r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
5289f3ff SS	95	if (r < 0)
5289f3ff SS	96	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
abf446af	97
1c4baffc	98	r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
5289f3ff SS	99	if (r < 0)
5289f3ff SS	100	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
abf446af	101
1c4baffc	102	r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
5289f3ff SS	103	if (r < 0)
5289f3ff SS	104	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
a9f434cf	105
1c4baffc	106	r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
5289f3ff SS	107	if (r < 0)
5289f3ff SS	108	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
436b910f	109
abf446af SS	110	return r;
	111	}
	112
1c4baffc	113	static int netdev_gre_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
1af2536a	114	Tunnel *t;
8bb088c5 SS	115	int r;
8bb088c5 SS	116
3be1d7e0	117	assert(netdev);
1af2536a SS	118
1af2536a SS	119	if (netdev->kind == NETDEV_KIND_GRE)
5289f3ff	120	t = GRE(netdev);
1af2536a	121	else
5289f3ff	122	t = GRETAP(netdev);
1af2536a	123
aa9f1140 TG	124	assert(t);
aa9f1140 TG	125	assert(t->family == AF_INET);
1af2536a SS	126	assert(link);
1af2536a SS	127	assert(m);
8bb088c5	128
1c4baffc	129	r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
5289f3ff SS	130	if (r < 0)
5289f3ff SS	131	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
8bb088c5	132
1c4baffc	133	r = sd_netlink_message_append_in_addr(m, IFLA_GRE_LOCAL, &t->local.in);
5289f3ff SS	134	if (r < 0)
5289f3ff SS	135	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
8bb088c5	136
1c4baffc	137	r = sd_netlink_message_append_in_addr(m, IFLA_GRE_REMOTE, &t->remote.in);
5289f3ff SS	138	if (r < 0)
5289f3ff SS	139	log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
8bb088c5	140
1c4baffc	141	r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
5289f3ff SS	142	if (r < 0)
5289f3ff SS	143	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
8bb088c5	144
1c4baffc	145	r = sd_netlink_message_append_u8(m, IFLA_GRE_TOS, t->tos);
5289f3ff SS	146	if (r < 0)
5289f3ff SS	147	log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TOS attribute: %m");
8bb088c5	148
1c4baffc	149	r = sd_netlink_message_append_u8(m, IFLA_GRE_PMTUDISC, t->pmtudisc);
5289f3ff SS	150	if (r < 0)
5289f3ff SS	151	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_PMTUDISC attribute: %m");
9243e967	152
8bb088c5 SS	153	return r;
	154	}
	155
1c4baffc	156	static int netdev_ip6gre_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
b16492f8 SS	157	Tunnel *t;
	158	int r;
	159
	160	assert(netdev);
	161
	162	if (netdev->kind == NETDEV_KIND_IP6GRE)
5289f3ff	163	t = IP6GRE(netdev);
b16492f8	164	else
5289f3ff	165	t = IP6GRETAP(netdev);
b16492f8 SS	166
	167	assert(t);
	168	assert(t->family == AF_INET6);
	169	assert(link);
	170	assert(m);
	171
1c4baffc	172	r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
5289f3ff SS	173	if (r < 0)
5289f3ff SS	174	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
b16492f8	175
1c4baffc	176	r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_LOCAL, &t->local.in6);
5289f3ff SS	177	if (r < 0)
5289f3ff SS	178	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
b16492f8	179
1c4baffc	180	r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_REMOTE, &t->remote.in6);
5289f3ff SS	181	if (r < 0)
5289f3ff SS	182	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
b16492f8	183
1c4baffc	184	r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
5289f3ff SS	185	if (r < 0)
5289f3ff SS	186	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
b16492f8	187
54a9d20c SS	188	if (t->ipv6_flowlabel != _NETDEV_IPV6_FLOWLABEL_INVALID) {
	189	r = sd_netlink_message_append_u32(m, IFLA_GRE_FLOWINFO, t->ipv6_flowlabel);
	190	if (r < 0)
	191	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_FLOWINFO attribute: %m");
	192	}
	193
	194	r = sd_netlink_message_append_u32(m, IFLA_GRE_FLAGS, t->flags);
	195	if (r < 0)
	196	return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_FLAGS attribute: %m");
	197
b16492f8 SS	198	return r;
	199	}
	200
1c4baffc	201	static int netdev_vti_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
aa9f1140	202	Tunnel *t = VTI(netdev);
a613382b SS	203	int r;
a613382b SS	204
3be1d7e0	205	assert(netdev);
a613382b	206	assert(link);
a613382b	207	assert(m);
aa9f1140 TG	208	assert(t);
aa9f1140 TG	209	assert(t->family == AF_INET);
a613382b	210
1c4baffc	211	r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
5289f3ff SS	212	if (r < 0)
5289f3ff SS	213	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
a613382b	214
1c4baffc	215	r = sd_netlink_message_append_in_addr(m, IFLA_VTI_LOCAL, &t->local.in);
5289f3ff SS	216	if (r < 0)
5289f3ff SS	217	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
a613382b	218
1c4baffc	219	r = sd_netlink_message_append_in_addr(m, IFLA_VTI_REMOTE, &t->remote.in);
5289f3ff SS	220	if (r < 0)
5289f3ff SS	221	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
a613382b	222
a613382b SS	223	return r;
a613382b SS	224	}
8bb088c5	225
1c4baffc	226	static int netdev_vti6_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
9011ce77 SS	227	Tunnel *t = VTI6(netdev);
	228	int r;
	229
	230	assert(netdev);
	231	assert(link);
	232	assert(m);
	233	assert(t);
	234	assert(t->family == AF_INET6);
	235
1c4baffc	236	r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
9011ce77 SS	237	if (r < 0)
	238	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
	239
1c4baffc	240	r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_LOCAL, &t->local.in6);
9011ce77 SS	241	if (r < 0)
	242	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
	243
1c4baffc	244	r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_REMOTE, &t->remote.in6);
9011ce77 SS	245	if (r < 0)
	246	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
	247
	248	return r;
	249	}
	250
1c4baffc	251	static int netdev_ip6tnl_fill_message_create(NetDev netdev, Link link, sd_netlink_message *m) {
855ee1a1 SS	252	Tunnel *t = IP6TNL(netdev);
	253	uint8_t proto;
	254	int r;
	255
	256	assert(netdev);
	257	assert(link);
	258	assert(m);
	259	assert(t);
	260	assert(t->family == AF_INET6);
	261
1c4baffc	262	r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
5289f3ff SS	263	if (r < 0)
5289f3ff SS	264	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
855ee1a1	265
1c4baffc	266	r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_LOCAL, &t->local.in6);
5289f3ff SS	267	if (r < 0)
5289f3ff SS	268	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
855ee1a1	269
1c4baffc	270	r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in6);
5289f3ff SS	271	if (r < 0)
5289f3ff SS	272	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
855ee1a1	273
1c4baffc	274	r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
5289f3ff SS	275	if (r < 0)
5289f3ff SS	276	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
855ee1a1	277
407af9dd SS	278	if (t->ipv6_flowlabel != _NETDEV_IPV6_FLOWLABEL_INVALID) {
	279	r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLOWINFO, t->ipv6_flowlabel);
	280	if (r < 0)
	281	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLOWINFO attribute: %m");
	282	}
	283
a9b70f9d	284	if (t->copy_dscp)
ec2a3e3a SS	285	t->flags \|= IP6_TNL_F_RCV_DSCP_COPY;
ec2a3e3a SS	286
407af9dd SS	287	r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLAGS, t->flags);
	288	if (r < 0)
	289	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLAGS attribute: %m");
	290
855ee1a1 SS	291	switch (t->ip6tnl_mode) {
	292	case NETDEV_IP6_TNL_MODE_IP6IP6:
	293	proto = IPPROTO_IPV6;
	294	break;
	295	case NETDEV_IP6_TNL_MODE_IPIP6:
	296	proto = IPPROTO_IPIP;
	297	break;
	298	case NETDEV_IP6_TNL_MODE_ANYIP6:
	299	default:
	300	proto = 0;
	301	break;
	302	}
	303
1c4baffc	304	r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PROTO, proto);
5289f3ff SS	305	if (r < 0)
5289f3ff SS	306	return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_MODE attribute: %m");
855ee1a1 SS	307
	308	return r;
	309	}
	310
3be1d7e0	311	static int netdev_tunnel_verify(NetDev netdev, const char filename) {
aa9f1140 TG	312	Tunnel *t = NULL;
aa9f1140 TG	313
7951dea2	314	assert(netdev);
3be1d7e0	315	assert(filename);
7951dea2	316
aa9f1140 TG	317	switch (netdev->kind) {
	318	case NETDEV_KIND_IPIP:
	319	t = IPIP(netdev);
	320	break;
	321	case NETDEV_KIND_SIT:
	322	t = SIT(netdev);
	323	break;
	324	case NETDEV_KIND_GRE:
	325	t = GRE(netdev);
	326	break;
1af2536a SS	327	case NETDEV_KIND_GRETAP:
	328	t = GRETAP(netdev);
	329	break;
b16492f8 SS	330	case NETDEV_KIND_IP6GRE:
	331	t = IP6GRE(netdev);
	332	break;
	333	case NETDEV_KIND_IP6GRETAP:
	334	t = IP6GRETAP(netdev);
	335	break;
aa9f1140 TG	336	case NETDEV_KIND_VTI:
	337	t = VTI(netdev);
	338	break;
9011ce77 SS	339	case NETDEV_KIND_VTI6:
	340	t = VTI6(netdev);
	341	break;
855ee1a1 SS	342	case NETDEV_KIND_IP6TNL:
	343	t = IP6TNL(netdev);
	344	break;
aa9f1140 TG	345	default:
	346	assert_not_reached("Invalid tunnel kind");
	347	}
	348
	349	assert(t);
	350
aa9f1140	351	if (t->remote.in.s_addr == INADDR_ANY) {
5289f3ff SS	352	log_warning("Tunnel without remote address configured in %s. Ignoring", filename);
5289f3ff SS	353	return -EINVAL;
7951dea2 SS	354	}
7951dea2 SS	355
855ee1a1	356	if (t->family != AF_INET && t->family != AF_INET6) {
5289f3ff SS	357	log_warning("Tunnel with invalid address family configured in %s. Ignoring", filename);
5289f3ff SS	358	return -EINVAL;
7951dea2 SS	359	}
7951dea2 SS	360
855ee1a1 SS	361	if (netdev->kind == NETDEV_KIND_IP6TNL) {
	362	if (t->ip6tnl_mode == _NETDEV_IP6_TNL_MODE_INVALID) {
	363	log_warning("IP6 Tunnel without mode configured in %s. Ignoring", filename);
	364	return -EINVAL;
	365	}
	366	}
	367
7951dea2 SS	368	return 0;
7951dea2 SS	369	}
6ef892fc TG	370
	371	int config_parse_tunnel_address(const char *unit,
	372	const char *filename,
	373	unsigned line,
	374	const char *section,
	375	unsigned section_line,
	376	const char *lvalue,
	377	int ltype,
	378	const char *rvalue,
	379	void *data,
	380	void *userdata) {
aa9f1140	381	Tunnel *t = userdata;
44e7b949 LP	382	union in_addr_union *addr = data, buffer;
44e7b949 LP	383	int r, f;
6ef892fc TG	384
	385	assert(filename);
	386	assert(lvalue);
	387	assert(rvalue);
	388	assert(data);
	389
44e7b949	390	r = in_addr_from_string_auto(rvalue, &f, &buffer);
6ef892fc	391	if (r < 0) {
44e7b949	392	log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel address is invalid, ignoring assignment: %s", rvalue);
6ef892fc TG	393	return 0;
	394	}
	395
44e7b949 LP	396	if (t->family != AF_UNSPEC && t->family != f) {
	397	log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel addresses incompatible, ignoring assignment: %s", rvalue);
	398	return 0;
	399	}
	400
	401	t->family = f;
	402	*addr = buffer;
	403
6ef892fc TG	404	return 0;
6ef892fc TG	405	}
3be1d7e0	406
407af9dd SS	407	static const char* const ipv6_flowlabel_table[_NETDEV_IPV6_FLOWLABEL_MAX] = {
	408	[NETDEV_IPV6_FLOWLABEL_INHERIT] = "inherit",
	409	};
	410
	411	DEFINE_STRING_TABLE_LOOKUP(ipv6_flowlabel, IPv6FlowLabel);
	412
	413	int config_parse_ipv6_flowlabel(const char* unit,
	414	const char *filename,
	415	unsigned line,
	416	const char *section,
	417	unsigned section_line,
	418	const char *lvalue,
	419	int ltype,
	420	const char *rvalue,
	421	void *data,
	422	void *userdata) {
	423	IPv6FlowLabel *ipv6_flowlabel = data;
	424	Tunnel *t = userdata;
	425	IPv6FlowLabel s;
	426	int k = 0;
	427	int r;
	428
	429	assert(filename);
	430	assert(lvalue);
	431	assert(rvalue);
	432	assert(ipv6_flowlabel);
	433
	434	s = ipv6_flowlabel_from_string(rvalue);
	435	if (s != _NETDEV_IPV6_FLOWLABEL_INVALID) {
	436	*ipv6_flowlabel = IP6_FLOWINFO_FLOWLABEL;
	437	t->flags \|= IP6_TNL_F_USE_ORIG_FLOWLABEL;
	438	} else {
	439	r = config_parse_unsigned(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &k, userdata);
	440	if (r >= 0) {
	441	if (k > 0xFFFFF)
	442	log_syntax(unit, LOG_ERR, filename, line, k, "Failed to parse IPv6 flowlabel option, ignoring: %s", rvalue);
	443	else {
	444	*ipv6_flowlabel = htonl(k) & IP6_FLOWINFO_FLOWLABEL;
	445	t->flags &= ~IP6_TNL_F_USE_ORIG_FLOWLABEL;
	446	}
	447	}
	448	}
	449
	450	return 0;
	451	}
	452
aa9f1140 TG	453	static void ipip_init(NetDev *n) {
	454	Tunnel *t = IPIP(n);
	455
	456	assert(n);
	457	assert(t);
	458
	459	t->pmtudisc = true;
	460	}
	461
	462	static void sit_init(NetDev *n) {
	463	Tunnel *t = SIT(n);
	464
	465	assert(n);
	466	assert(t);
	467
	468	t->pmtudisc = true;
	469	}
	470
	471	static void vti_init(NetDev *n) {
7185d805	472	Tunnel *t;
aa9f1140 TG	473
aa9f1140 TG	474	assert(n);
9011ce77 SS	475
9011ce77 SS	476	if (n->kind == NETDEV_KIND_VTI)
7185d805	477	t = VTI(n);
9011ce77 SS	478	else
	479	t = VTI6(n);
	480
aa9f1140 TG	481	assert(t);
	482
	483	t->pmtudisc = true;
	484	}
	485
	486	static void gre_init(NetDev *n) {
1af2536a	487	Tunnel *t;
aa9f1140 TG	488
aa9f1140 TG	489	assert(n);
1af2536a SS	490
	491	if (n->kind == NETDEV_KIND_GRE)
	492	t = GRE(n);
	493	else
	494	t = GRETAP(n);
	495
aa9f1140 TG	496	assert(t);
	497
	498	t->pmtudisc = true;
	499	}
	500
b16492f8 SS	501	static void ip6gre_init(NetDev *n) {
	502	Tunnel *t;
	503
	504	assert(n);
	505
	506	if (n->kind == NETDEV_KIND_IP6GRE)
	507	t = IP6GRE(n);
	508	else
	509	t = IP6GRETAP(n);
	510
	511	assert(t);
	512
	513	t->ttl = DEFAULT_TNL_HOP_LIMIT;
	514	}
	515
855ee1a1 SS	516	static void ip6tnl_init(NetDev *n) {
	517	Tunnel *t = IP6TNL(n);
	518
	519	assert(n);
	520	assert(t);
	521
	522	t->ttl = DEFAULT_TNL_HOP_LIMIT;
	523	t->encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
	524	t->ip6tnl_mode = _NETDEV_IP6_TNL_MODE_INVALID;
407af9dd	525	t->ipv6_flowlabel = _NETDEV_IPV6_FLOWLABEL_INVALID;
855ee1a1 SS	526	}
855ee1a1 SS	527
3be1d7e0	528	const NetDevVTable ipip_vtable = {
aa9f1140 TG	529	.object_size = sizeof(Tunnel),
	530	.init = ipip_init,
	531	.sections = "Match\0NetDev\0Tunnel\0",
	532	.fill_message_create = netdev_ipip_fill_message_create,
	533	.create_type = NETDEV_CREATE_STACKED,
3be1d7e0 TG	534	.config_verify = netdev_tunnel_verify,
	535	};
	536
	537	const NetDevVTable sit_vtable = {
aa9f1140 TG	538	.object_size = sizeof(Tunnel),
	539	.init = sit_init,
	540	.sections = "Match\0NetDev\0Tunnel\0",
	541	.fill_message_create = netdev_sit_fill_message_create,
	542	.create_type = NETDEV_CREATE_STACKED,
3be1d7e0 TG	543	.config_verify = netdev_tunnel_verify,
	544	};
	545
	546	const NetDevVTable vti_vtable = {
aa9f1140 TG	547	.object_size = sizeof(Tunnel),
	548	.init = vti_init,
	549	.sections = "Match\0NetDev\0Tunnel\0",
	550	.fill_message_create = netdev_vti_fill_message_create,
	551	.create_type = NETDEV_CREATE_STACKED,
3be1d7e0 TG	552	.config_verify = netdev_tunnel_verify,
	553	};
	554
9011ce77 SS	555	const NetDevVTable vti6_vtable = {
	556	.object_size = sizeof(Tunnel),
	557	.init = vti_init,
	558	.sections = "Match\0NetDev\0Tunnel\0",
	559	.fill_message_create = netdev_vti6_fill_message_create,
	560	.create_type = NETDEV_CREATE_STACKED,
	561	.config_verify = netdev_tunnel_verify,
	562	};
	563
3be1d7e0	564	const NetDevVTable gre_vtable = {
aa9f1140 TG	565	.object_size = sizeof(Tunnel),
	566	.init = gre_init,
	567	.sections = "Match\0NetDev\0Tunnel\0",
	568	.fill_message_create = netdev_gre_fill_message_create,
	569	.create_type = NETDEV_CREATE_STACKED,
3be1d7e0 TG	570	.config_verify = netdev_tunnel_verify,
3be1d7e0 TG	571	};
1af2536a SS	572
	573	const NetDevVTable gretap_vtable = {
	574	.object_size = sizeof(Tunnel),
	575	.init = gre_init,
	576	.sections = "Match\0NetDev\0Tunnel\0",
	577	.fill_message_create = netdev_gre_fill_message_create,
	578	.create_type = NETDEV_CREATE_STACKED,
	579	.config_verify = netdev_tunnel_verify,
	580	};
855ee1a1	581
b16492f8 SS	582	const NetDevVTable ip6gre_vtable = {
	583	.object_size = sizeof(Tunnel),
	584	.init = ip6gre_init,
	585	.sections = "Match\0NetDev\0Tunnel\0",
	586	.fill_message_create = netdev_ip6gre_fill_message_create,
	587	.create_type = NETDEV_CREATE_STACKED,
	588	.config_verify = netdev_tunnel_verify,
	589	};
	590
	591	const NetDevVTable ip6gretap_vtable = {
	592	.object_size = sizeof(Tunnel),
	593	.init = ip6gre_init,
	594	.sections = "Match\0NetDev\0Tunnel\0",
	595	.fill_message_create = netdev_ip6gre_fill_message_create,
	596	.create_type = NETDEV_CREATE_STACKED,
	597	.config_verify = netdev_tunnel_verify,
	598	};
	599
855ee1a1 SS	600	const NetDevVTable ip6tnl_vtable = {
	601	.object_size = sizeof(Tunnel),
	602	.init = ip6tnl_init,
	603	.sections = "Match\0NetDev\0Tunnel\0",
	604	.fill_message_create = netdev_ip6tnl_fill_message_create,
	605	.create_type = NETDEV_CREATE_STACKED,
	606	.config_verify = netdev_tunnel_verify,
	607	};