src/network/networkd-netdev-tunnel.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4     This file is part of systemd.
   5
   6     Copyright 2014 Susant Sahani
   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
  22 #include <arpa/inet.h>
  23 #include <net/if.h>
  24 #include <linux/ip.h>
  25 #include <linux/if_tunnel.h>
  26 #include <linux/ip6_tunnel.h>
  27
  28 #include "sd-netlink.h"
  29 #include "networkd-netdev-tunnel.h"
  30 #include "networkd-link.h"
  31 #include "util.h"
  32 #include "missing.h"
  33 #include "conf-parser.h"
  34
  35 #define DEFAULT_TNL_HOP_LIMIT   64
  36 #define IP6_FLOWINFO_FLOWLABEL  htonl(0x000FFFFF)
  37
  38 static const char* const ip6tnl_mode_table[_NETDEV_IP6_TNL_MODE_MAX] = {
  39         [NETDEV_IP6_TNL_MODE_IP6IP6] = "ip6ip6",
  40         [NETDEV_IP6_TNL_MODE_IPIP6] = "ipip6",
  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
  47 static int netdev_ipip_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
  48         Tunnel *t = IPIP(netdev);
  49         int r;
  50
  51         assert(netdev);
  52         assert(link);
  53         assert(m);
  54         assert(t);
  55         assert(t->family == AF_INET);
  56
  57         r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
  58         if (r < 0)
  59                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
  60
  61         r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
  62         if (r < 0)
  63                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
  64
  65         r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
  66         if (r < 0)
  67                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
  68
  69         r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
  70         if (r < 0)
  71                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL  attribute: %m");
  72
  73         r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
  74         if (r < 0)
  75                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
  76
  77         return r;
  78 }
  79
  80 static int netdev_sit_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
  81         Tunnel *t = SIT(netdev);
  82         int r;
  83
  84         assert(netdev);
  85         assert(link);
  86         assert(m);
  87         assert(t);
  88         assert(t->family == AF_INET);
  89
  90         r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
  91         if (r < 0)
  92                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
  93
  94         r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
  95         if (r < 0)
  96                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
  97
  98         r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
  99         if (r < 0)
 100                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
 101
 102         r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
 103         if (r < 0)
 104                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
 105
 106         r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
 107         if (r < 0)
 108                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
 109
 110         return r;
 111 }
 112
 113 static int netdev_gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 114         Tunnel *t;
 115         int r;
 116
 117         assert(netdev);
 118
 119         if (netdev->kind == NETDEV_KIND_GRE)
 120                 t = GRE(netdev);
 121         else
 122                 t = GRETAP(netdev);
 123
 124         assert(t);
 125         assert(t->family == AF_INET);
 126         assert(link);
 127         assert(m);
 128
 129         r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
 130         if (r < 0)
 131                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
 132
 133         r = sd_netlink_message_append_in_addr(m, IFLA_GRE_LOCAL, &t->local.in);
 134         if (r < 0)
 135                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
 136
 137         r = sd_netlink_message_append_in_addr(m, IFLA_GRE_REMOTE, &t->remote.in);
 138         if (r < 0)
 139                 log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
 140
 141         r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
 142         if (r < 0)
 143                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
 144
 145         r = sd_netlink_message_append_u8(m, IFLA_GRE_TOS, t->tos);
 146         if (r < 0)
 147                 log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TOS attribute: %m");
 148
 149         r = sd_netlink_message_append_u8(m, IFLA_GRE_PMTUDISC, t->pmtudisc);
 150         if (r < 0)
 151                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_PMTUDISC attribute: %m");
 152
 153         return r;
 154 }
 155
 156 static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 157         Tunnel *t;
 158         int r;
 159
 160         assert(netdev);
 161
 162         if (netdev->kind == NETDEV_KIND_IP6GRE)
 163                 t = IP6GRE(netdev);
 164         else
 165                 t = IP6GRETAP(netdev);
 166
 167         assert(t);
 168         assert(t->family == AF_INET6);
 169         assert(link);
 170         assert(m);
 171
 172         r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
 173         if (r < 0)
 174                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
 175
 176         r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_LOCAL, &t->local.in6);
 177         if (r < 0)
 178                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
 179
 180         r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_REMOTE, &t->remote.in6);
 181         if (r < 0)
 182                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
 183
 184         r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
 185         if (r < 0)
 186                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
 187
 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
 198         return r;
 199 }
 200
 201 static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 202         Tunnel *t = VTI(netdev);
 203         int r;
 204
 205         assert(netdev);
 206         assert(link);
 207         assert(m);
 208         assert(t);
 209         assert(t->family == AF_INET);
 210
 211         r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
 212         if (r < 0)
 213                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
 214
 215         r = sd_netlink_message_append_in_addr(m, IFLA_VTI_LOCAL, &t->local.in);
 216         if (r < 0)
 217                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
 218
 219         r = sd_netlink_message_append_in_addr(m, IFLA_VTI_REMOTE, &t->remote.in);
 220         if (r < 0)
 221                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
 222
 223         return r;
 224 }
 225
 226 static int netdev_vti6_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 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
 236         r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
 237         if (r < 0)
 238                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
 239
 240         r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_LOCAL, &t->local.in6);
 241         if (r < 0)
 242                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
 243
 244         r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_REMOTE, &t->remote.in6);
 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
 251 static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 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
 262         r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
 263         if (r < 0)
 264                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
 265
 266         r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_LOCAL, &t->local.in6);
 267         if (r < 0)
 268                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
 269
 270         r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in6);
 271         if (r < 0)
 272                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
 273
 274         r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
 275         if (r < 0)
 276                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
 277
 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
 284         if (t->copy_dscp)
 285                 t->flags |= IP6_TNL_F_RCV_DSCP_COPY;
 286
 287         if (t->encap_limit != IPV6_DEFAULT_TNL_ENCAP_LIMIT) {
 288                 r = sd_netlink_message_append_u8(m, IFLA_IPTUN_ENCAP_LIMIT, t->encap_limit);
 289                 if (r < 0)
 290                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_ENCAP_LIMIT attribute: %m");
 291         }
 292
 293         r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLAGS, t->flags);
 294         if (r < 0)
 295                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLAGS attribute: %m");
 296
 297         switch (t->ip6tnl_mode) {
 298         case NETDEV_IP6_TNL_MODE_IP6IP6:
 299                 proto = IPPROTO_IPV6;
 300                 break;
 301         case NETDEV_IP6_TNL_MODE_IPIP6:
 302                 proto = IPPROTO_IPIP;
 303                 break;
 304         case NETDEV_IP6_TNL_MODE_ANYIP6:
 305         default:
 306                 proto = 0;
 307                 break;
 308         }
 309
 310         r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PROTO, proto);
 311         if (r < 0)
 312                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_MODE attribute: %m");
 313
 314         return r;
 315 }
 316
 317 static int netdev_tunnel_verify(NetDev *netdev, const char *filename) {
 318         Tunnel *t = NULL;
 319
 320         assert(netdev);
 321         assert(filename);
 322
 323         switch (netdev->kind) {
 324         case NETDEV_KIND_IPIP:
 325                 t = IPIP(netdev);
 326                 break;
 327         case NETDEV_KIND_SIT:
 328                 t = SIT(netdev);
 329                 break;
 330         case NETDEV_KIND_GRE:
 331                 t = GRE(netdev);
 332                 break;
 333         case NETDEV_KIND_GRETAP:
 334                 t = GRETAP(netdev);
 335                 break;
 336         case NETDEV_KIND_IP6GRE:
 337                 t = IP6GRE(netdev);
 338                 break;
 339         case NETDEV_KIND_IP6GRETAP:
 340                 t = IP6GRETAP(netdev);
 341                 break;
 342         case NETDEV_KIND_VTI:
 343                 t = VTI(netdev);
 344                 break;
 345         case NETDEV_KIND_VTI6:
 346                 t = VTI6(netdev);
 347                 break;
 348         case NETDEV_KIND_IP6TNL:
 349                 t = IP6TNL(netdev);
 350                 break;
 351         default:
 352                 assert_not_reached("Invalid tunnel kind");
 353         }
 354
 355         assert(t);
 356
 357         if (t->remote.in.s_addr == INADDR_ANY) {
 358                 log_warning("Tunnel without remote address configured in %s. Ignoring", filename);
 359                 return -EINVAL;
 360         }
 361
 362         if (t->family != AF_INET && t->family != AF_INET6) {
 363                 log_warning("Tunnel with invalid address family configured in %s. Ignoring", filename);
 364                 return -EINVAL;
 365         }
 366
 367         if (netdev->kind == NETDEV_KIND_IP6TNL) {
 368                 if (t->ip6tnl_mode == _NETDEV_IP6_TNL_MODE_INVALID) {
 369                         log_warning("IP6 Tunnel without mode configured in %s. Ignoring", filename);
 370                         return -EINVAL;
 371                 }
 372         }
 373
 374         return 0;
 375 }
 376
 377 int config_parse_tunnel_address(const char *unit,
 378                                 const char *filename,
 379                                 unsigned line,
 380                                 const char *section,
 381                                 unsigned section_line,
 382                                 const char *lvalue,
 383                                 int ltype,
 384                                 const char *rvalue,
 385                                 void *data,
 386                                 void *userdata) {
 387         Tunnel *t = userdata;
 388         union in_addr_union *addr = data, buffer;
 389         int r, f;
 390
 391         assert(filename);
 392         assert(lvalue);
 393         assert(rvalue);
 394         assert(data);
 395
 396         r = in_addr_from_string_auto(rvalue, &f, &buffer);
 397         if (r < 0) {
 398                 log_syntax(unit, LOG_ERR, filename, line, r, "Tunnel address is invalid, ignoring assignment: %s", rvalue);
 399                 return 0;
 400         }
 401
 402         if (t->family != AF_UNSPEC && t->family != f) {
 403                 log_syntax(unit, LOG_ERR, filename, line, 0, "Tunnel addresses incompatible, ignoring assignment: %s", rvalue);
 404                 return 0;
 405         }
 406
 407         t->family = f;
 408         *addr = buffer;
 409
 410         return 0;
 411 }
 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         int k = 0;
 426         int r;
 427
 428         assert(filename);
 429         assert(lvalue);
 430         assert(rvalue);
 431         assert(ipv6_flowlabel);
 432
 433         if (streq(rvalue, "inherit")) {
 434                 *ipv6_flowlabel = IP6_FLOWINFO_FLOWLABEL;
 435                 t->flags |= IP6_TNL_F_USE_ORIG_FLOWLABEL;
 436         } else {
 437                 r = config_parse_int(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &k, userdata);
 438                 if (r < 0)
 439                         return r;
 440
 441                 if (k > 0xFFFFF)
 442                         log_syntax(unit, LOG_ERR, filename, line, 0, "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         return 0;
 450 }
 451
 452 int config_parse_encap_limit(const char* unit,
 453                              const char *filename,
 454                              unsigned line,
 455                              const char *section,
 456                              unsigned section_line,
 457                              const char *lvalue,
 458                               int ltype,
 459                              const char *rvalue,
 460                              void *data,
 461                              void *userdata) {
 462         Tunnel *t = userdata;
 463         int k = 0;
 464         int r;
 465
 466         assert(filename);
 467         assert(lvalue);
 468         assert(rvalue);
 469
 470         if (streq(rvalue, "none"))
 471                 t->flags |= IP6_TNL_F_IGN_ENCAP_LIMIT;
 472         else {
 473                 r = safe_atoi(rvalue, &k);
 474                 if (r < 0) {
 475                         log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse Tunnel Encapsulation Limit option, ignoring: %s", rvalue);
 476                         return 0;
 477                 }
 478
 479                 if (k > 255 || k < 0)
 480                         log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid Tunnel Encapsulation value, ignoring: %d", k);
 481                 else {
 482                         t->encap_limit = k;
 483                         t->flags &= ~IP6_TNL_F_IGN_ENCAP_LIMIT;
 484                 }
 485         }
 486
 487         return 0;
 488 }
 489
 490 static void ipip_init(NetDev *n) {
 491         Tunnel *t = IPIP(n);
 492
 493         assert(n);
 494         assert(t);
 495
 496         t->pmtudisc = true;
 497 }
 498
 499 static void sit_init(NetDev *n) {
 500         Tunnel *t = SIT(n);
 501
 502         assert(n);
 503         assert(t);
 504
 505         t->pmtudisc = true;
 506 }
 507
 508 static void vti_init(NetDev *n) {
 509         Tunnel *t;
 510
 511         assert(n);
 512
 513         if (n->kind == NETDEV_KIND_VTI)
 514                 t = VTI(n);
 515         else
 516                 t = VTI6(n);
 517
 518         assert(t);
 519
 520         t->pmtudisc = true;
 521 }
 522
 523 static void gre_init(NetDev *n) {
 524         Tunnel *t;
 525
 526         assert(n);
 527
 528         if (n->kind == NETDEV_KIND_GRE)
 529                 t = GRE(n);
 530         else
 531                 t = GRETAP(n);
 532
 533         assert(t);
 534
 535         t->pmtudisc = true;
 536 }
 537
 538 static void ip6gre_init(NetDev *n) {
 539         Tunnel *t;
 540
 541         assert(n);
 542
 543         if (n->kind == NETDEV_KIND_IP6GRE)
 544                 t = IP6GRE(n);
 545         else
 546                 t = IP6GRETAP(n);
 547
 548         assert(t);
 549
 550         t->ttl = DEFAULT_TNL_HOP_LIMIT;
 551 }
 552
 553 static void ip6tnl_init(NetDev *n) {
 554         Tunnel *t = IP6TNL(n);
 555
 556         assert(n);
 557         assert(t);
 558
 559         t->ttl = DEFAULT_TNL_HOP_LIMIT;
 560         t->encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
 561         t->ip6tnl_mode = _NETDEV_IP6_TNL_MODE_INVALID;
 562         t->ipv6_flowlabel = _NETDEV_IPV6_FLOWLABEL_INVALID;
 563 }
 564
 565 const NetDevVTable ipip_vtable = {
 566         .object_size = sizeof(Tunnel),
 567         .init = ipip_init,
 568         .sections = "Match\0NetDev\0Tunnel\0",
 569         .fill_message_create = netdev_ipip_fill_message_create,
 570         .create_type = NETDEV_CREATE_STACKED,
 571         .config_verify = netdev_tunnel_verify,
 572 };
 573
 574 const NetDevVTable sit_vtable = {
 575         .object_size = sizeof(Tunnel),
 576         .init = sit_init,
 577         .sections = "Match\0NetDev\0Tunnel\0",
 578         .fill_message_create = netdev_sit_fill_message_create,
 579         .create_type = NETDEV_CREATE_STACKED,
 580         .config_verify = netdev_tunnel_verify,
 581 };
 582
 583 const NetDevVTable vti_vtable = {
 584         .object_size = sizeof(Tunnel),
 585         .init = vti_init,
 586         .sections = "Match\0NetDev\0Tunnel\0",
 587         .fill_message_create = netdev_vti_fill_message_create,
 588         .create_type = NETDEV_CREATE_STACKED,
 589         .config_verify = netdev_tunnel_verify,
 590 };
 591
 592 const NetDevVTable vti6_vtable = {
 593         .object_size = sizeof(Tunnel),
 594         .init = vti_init,
 595         .sections = "Match\0NetDev\0Tunnel\0",
 596         .fill_message_create = netdev_vti6_fill_message_create,
 597         .create_type = NETDEV_CREATE_STACKED,
 598         .config_verify = netdev_tunnel_verify,
 599 };
 600
 601 const NetDevVTable gre_vtable = {
 602         .object_size = sizeof(Tunnel),
 603         .init = gre_init,
 604         .sections = "Match\0NetDev\0Tunnel\0",
 605         .fill_message_create = netdev_gre_fill_message_create,
 606         .create_type = NETDEV_CREATE_STACKED,
 607         .config_verify = netdev_tunnel_verify,
 608 };
 609
 610 const NetDevVTable gretap_vtable = {
 611         .object_size = sizeof(Tunnel),
 612         .init = gre_init,
 613         .sections = "Match\0NetDev\0Tunnel\0",
 614         .fill_message_create = netdev_gre_fill_message_create,
 615         .create_type = NETDEV_CREATE_STACKED,
 616         .config_verify = netdev_tunnel_verify,
 617 };
 618
 619 const NetDevVTable ip6gre_vtable = {
 620         .object_size = sizeof(Tunnel),
 621         .init = ip6gre_init,
 622         .sections = "Match\0NetDev\0Tunnel\0",
 623         .fill_message_create = netdev_ip6gre_fill_message_create,
 624         .create_type = NETDEV_CREATE_STACKED,
 625         .config_verify = netdev_tunnel_verify,
 626 };
 627
 628 const NetDevVTable ip6gretap_vtable = {
 629         .object_size = sizeof(Tunnel),
 630         .init = ip6gre_init,
 631         .sections = "Match\0NetDev\0Tunnel\0",
 632         .fill_message_create = netdev_ip6gre_fill_message_create,
 633         .create_type = NETDEV_CREATE_STACKED,
 634         .config_verify = netdev_tunnel_verify,
 635 };
 636
 637 const NetDevVTable ip6tnl_vtable = {
 638         .object_size = sizeof(Tunnel),
 639         .init = ip6tnl_init,
 640         .sections = "Match\0NetDev\0Tunnel\0",
 641         .fill_message_create = netdev_ip6tnl_fill_message_create,
 642         .create_type = NETDEV_CREATE_STACKED,
 643         .config_verify = netdev_tunnel_verify,
 644 };