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 <susant@redhat.com>
   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 <netinet/ether.h>
  23 #include <arpa/inet.h>
  24 #include <net/if.h>
  25 #include <linux/ip.h>
  26 #include <linux/if_tunnel.h>
  27
  28 #include "sd-rtnl.h"
  29 #include "networkd-netdev-tunnel.h"
  30 #include "network-internal.h"
  31 #include "util.h"
  32 #include "missing.h"
  33 #include "conf-parser.h"
  34
  35 static int netdev_ipip_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
  36         int r;
  37
  38         assert(netdev);
  39         assert(netdev->kind == NETDEV_KIND_IPIP);
  40         assert(netdev->ifname);
  41         assert(netdev->manager);
  42         assert(netdev->manager->rtnl);
  43         assert(link);
  44         assert(m);
  45         assert(netdev->family == AF_INET);
  46
  47         r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
  48         if (r < 0) {
  49                 log_error_netdev(netdev,
  50                                  "Could not append IFLA_IFNAME, attribute: %s",
  51                                  strerror(-r));
  52                 return r;
  53         }
  54
  55         if(netdev->mtu) {
  56                 r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
  57                 if (r < 0) {
  58                         log_error_netdev(netdev,
  59                                          "Could not append IFLA_MTU attribute: %s",
  60                                          strerror(-r));
  61                         return r;
  62                 }
  63         }
  64
  65         if (netdev->mac) {
  66                 r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
  67                 if (r < 0) {
  68                         log_error_netdev(netdev,
  69                                          "Could not append IFLA_ADDRESS attribute: %s",
  70                                          strerror(-r));
  71                     return r;
  72                 }
  73         }
  74
  75         r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
  76         if (r < 0) {
  77                 log_error_netdev(netdev,
  78                                  "Could not append IFLA_LINKINFO attribute: %s",
  79                                  strerror(-r));
  80                 return r;
  81         }
  82
  83         r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
  84                                                  netdev_kind_to_string(netdev->kind));
  85         if (r < 0) {
  86                 log_error_netdev(netdev,
  87                                  "Could not append IFLA_INFO_DATA attribute: %s",
  88                                  strerror(-r));
  89                 return r;
  90         }
  91
  92         r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
  93         if (r < 0) {
  94                 log_error_netdev(netdev,
  95                                  "Could not append IFLA_IPTUN_LINK attribute: %s",
  96                                  strerror(-r));
  97                 return r;
  98         }
  99
 100         r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &netdev->local.in);
 101         if (r < 0) {
 102                 log_error_netdev(netdev,
 103                                  "Could not append IFLA_IPTUN_LOCAL attribute: %s",
 104                                  strerror(-r));
 105                 return r;
 106         }
 107
 108         r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &netdev->remote.in);
 109         if (r < 0) {
 110                 log_error_netdev(netdev,
 111                                  "Could not append IFLA_IPTUN_REMOTE attribute: %s",
 112                                  strerror(-r));
 113                 return r;
 114         }
 115
 116         r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, netdev->ttl);
 117         if (r < 0) {
 118                 log_error_netdev(netdev,
 119                                  "Could not append IFLA_IPTUN_TTL  attribute: %s",
 120                                  strerror(-r));
 121                 return r;
 122         }
 123
 124         r = sd_rtnl_message_close_container(m);
 125         if (r < 0) {
 126                 log_error_netdev(netdev,
 127                                  "Could not append IFLA_INFO_DATA attribute: %s",
 128                                  strerror(-r));
 129                 return r;
 130         }
 131
 132         r = sd_rtnl_message_close_container(m);
 133         if (r < 0) {
 134                 log_error_netdev(netdev,
 135                                  "Could not append IFLA_LINKINFO attribute: %s",
 136                                  strerror(-r));
 137                 return r;
 138         }
 139
 140         return r;
 141 }
 142
 143 static int netdev_sit_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
 144         int r;
 145
 146         assert(netdev);
 147         assert(netdev->kind == NETDEV_KIND_SIT);
 148         assert(netdev->ifname);
 149         assert(netdev->manager);
 150         assert(netdev->manager->rtnl);
 151         assert(link);
 152         assert(m);
 153         assert(netdev->family == AF_INET);
 154
 155         r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
 156         if (r < 0) {
 157                 log_error_netdev(netdev,
 158                                  "Could not append IFLA_IFNAME, attribute: %s",
 159                                  strerror(-r));
 160                 return r;
 161         }
 162
 163         if(netdev->mtu) {
 164                 r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
 165                 if (r < 0) {
 166                         log_error_netdev(netdev,
 167                                          "Could not append IFLA_MTU attribute: %s",
 168                                          strerror(-r));
 169                         return r;
 170                 }
 171         }
 172
 173         if (netdev->mac) {
 174                 r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
 175                 if (r < 0) {
 176                         log_error_netdev(netdev,
 177                                          "Could not append IFLA_ADDRESS attribute: %s",
 178                                          strerror(-r));
 179                     return r;
 180                 }
 181         }
 182
 183         r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
 184         if (r < 0) {
 185                 log_error_netdev(netdev,
 186                                  "Could not append IFLA_LINKINFO attribute: %s",
 187                                  strerror(-r));
 188                 return r;
 189         }
 190
 191         r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
 192                                                  netdev_kind_to_string(netdev->kind));
 193         if (r < 0) {
 194                 log_error_netdev(netdev,
 195                                  "Could not append IFLA_INFO_DATA attribute: %s",
 196                                  strerror(-r));
 197                 return r;
 198         }
 199
 200         r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
 201         if (r < 0) {
 202                 log_error_netdev(netdev,
 203                                  "Could not append IFLA_IPTUN_LINK attribute: %s",
 204                                  strerror(-r));
 205                 return r;
 206         }
 207
 208         r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &netdev->local.in);
 209         if (r < 0) {
 210                 log_error_netdev(netdev,
 211                                  "Could not append IFLA_IPTUN_LOCAL attribute: %s",
 212                                  strerror(-r));
 213                 return r;
 214         }
 215
 216         r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &netdev->remote.in);
 217         if (r < 0) {
 218                 log_error_netdev(netdev,
 219                                  "Could not append IFLA_IPTUN_REMOTE attribute: %s",
 220                                  strerror(-r));
 221                 return r;
 222         }
 223
 224         r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, netdev->ttl);
 225         if (r < 0) {
 226                 log_error_netdev(netdev,
 227                                  "Could not append IFLA_IPTUN_TTL  attribute: %s",
 228                                  strerror(-r));
 229                 return r;
 230         }
 231
 232         r = sd_rtnl_message_close_container(m);
 233         if (r < 0) {
 234                 log_error_netdev(netdev,
 235                                  "Could not append IFLA_INFO_DATA attribute: %s",
 236                                  strerror(-r));
 237                 return r;
 238         }
 239
 240         r = sd_rtnl_message_close_container(m);
 241         if (r < 0) {
 242                 log_error_netdev(netdev,
 243                                  "Could not append IFLA_LINKINFO attribute: %s",
 244                                  strerror(-r));
 245                 return r;
 246         }
 247
 248         return r;
 249 }
 250
 251 static int netdev_gre_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
 252         int r;
 253
 254         assert(netdev);
 255         assert(netdev->kind == NETDEV_KIND_GRE);
 256         assert(netdev->ifname);
 257         assert(netdev->manager);
 258         assert(netdev->manager->rtnl);
 259         assert(link);
 260         assert(m);
 261         assert(netdev->family == AF_INET);
 262
 263         r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
 264         if (r < 0) {
 265                 log_error_netdev(netdev,
 266                                  "Could not append IFLA_IFNAME, attribute: %s",
 267                                  strerror(-r));
 268                 return r;
 269         }
 270
 271         if(netdev->mtu) {
 272                 r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
 273                 if (r < 0) {
 274                         log_error_netdev(netdev,
 275                                          "Could not append IFLA_MTU attribute: %s",
 276                                          strerror(-r));
 277                         return r;
 278                 }
 279         }
 280
 281         if (netdev->mac) {
 282                 r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
 283                 if (r < 0) {
 284                         log_error_netdev(netdev,
 285                                          "Could not append IFLA_ADDRESS attribute: %s",
 286                                          strerror(-r));
 287                     return r;
 288                 }
 289         }
 290
 291         r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
 292         if (r < 0) {
 293                 log_error_netdev(netdev,
 294                                  "Could not append IFLA_LINKINFO attribute: %s",
 295                                  strerror(-r));
 296                 return r;
 297         }
 298
 299         r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
 300                                                  netdev_kind_to_string(netdev->kind));
 301         if (r < 0) {
 302                 log_error_netdev(netdev,
 303                                  "Could not append IFLA_INFO_DATA attribute: %s",
 304                                  strerror(-r));
 305                 return r;
 306         }
 307
 308         r = sd_rtnl_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
 309         if (r < 0) {
 310                 log_error_netdev(netdev,
 311                                  "Could not append IFLA_GRE_LINK attribute: %s",
 312                                  strerror(-r));
 313                 return r;
 314         }
 315
 316         r = sd_rtnl_message_append_in_addr(m, IFLA_GRE_LOCAL, &netdev->local.in);
 317         if (r < 0) {
 318                 log_error_netdev(netdev,
 319                                  "Could not append IFLA_GRE_LOCAL attribute: %s",
 320                                  strerror(-r));
 321                 return r;
 322         }
 323
 324         r = sd_rtnl_message_append_in_addr(m, IFLA_GRE_REMOTE, &netdev->remote.in);
 325         if (r < 0) {
 326                 log_error_netdev(netdev,
 327                                  "Could not append IFLA_GRE_REMOTE attribute: %s",
 328                                  strerror(-r));
 329                 return r;
 330         }
 331
 332         r = sd_rtnl_message_append_u8(m, IFLA_GRE_TTL, netdev->ttl);
 333         if (r < 0) {
 334                 log_error_netdev(netdev,
 335                                  "Could not append IFLA_GRE_TTL attribute: %s",
 336                                  strerror(-r));
 337                 return r;
 338         }
 339
 340         r = sd_rtnl_message_append_u8(m, IFLA_GRE_TOS, netdev->tos);
 341         if (r < 0) {
 342                 log_error_netdev(netdev,
 343                                  "Could not append IFLA_GRE_TOS attribute: %s",
 344                                  strerror(-r));
 345                 return r;
 346         }
 347
 348         r = sd_rtnl_message_close_container(m);
 349         if (r < 0) {
 350                 log_error_netdev(netdev,
 351                                  "Could not append IFLA_INFO_DATA attribute: %s",
 352                                  strerror(-r));
 353                 return r;
 354         }
 355
 356         r = sd_rtnl_message_close_container(m);
 357         if (r < 0) {
 358                 log_error_netdev(netdev,
 359                                  "Could not append IFLA_LINKINFO attribute: %s",
 360                                  strerror(-r));
 361                 return r;
 362         }
 363
 364         return r;
 365 }
 366
 367 static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
 368         int r;
 369
 370         assert(netdev);
 371         assert(netdev->kind == NETDEV_KIND_VTI);
 372         assert(netdev->ifname);
 373         assert(netdev->manager);
 374         assert(netdev->manager->rtnl);
 375         assert(link);
 376         assert(m);
 377         assert(netdev->family == AF_INET);
 378
 379         r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
 380         if (r < 0) {
 381                 log_error_netdev(netdev,
 382                                  "Could not append IFLA_IFNAME, attribute: %s",
 383                                  strerror(-r));
 384                 return r;
 385         }
 386
 387         if(netdev->mtu) {
 388                 r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
 389                 if (r < 0) {
 390                         log_error_netdev(netdev,
 391                                          "Could not append IFLA_MTU attribute: %s",
 392                                          strerror(-r));
 393                         return r;
 394                 }
 395         }
 396
 397         if (netdev->mac) {
 398                 r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
 399                 if (r < 0) {
 400                         log_error_netdev(netdev,
 401                                          "Could not append IFLA_ADDRESS attribute: %s",
 402                                          strerror(-r));
 403                     return r;
 404                 }
 405         }
 406
 407         r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
 408         if (r < 0) {
 409                 log_error_netdev(netdev,
 410                                  "Could not append IFLA_LINKINFO attribute: %s",
 411                                  strerror(-r));
 412                 return r;
 413         }
 414
 415         r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
 416                                                  netdev_kind_to_string(netdev->kind));
 417         if (r < 0) {
 418                 log_error_netdev(netdev,
 419                                  "Could not append IFLA_INFO_DATA attribute: %s",
 420                                  strerror(-r));
 421                 return r;
 422         }
 423
 424         r = sd_rtnl_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
 425         if (r < 0) {
 426                 log_error_netdev(netdev,
 427                                  "Could not append IFLA_IPTUN_LINK attribute: %s",
 428                                  strerror(-r));
 429                 return r;
 430         }
 431
 432         r = sd_rtnl_message_append_in_addr(m, IFLA_VTI_LOCAL, &netdev->local.in);
 433         if (r < 0) {
 434                 log_error_netdev(netdev,
 435                                  "Could not append IFLA_IPTUN_LOCAL attribute: %s",
 436                                  strerror(-r));
 437                 return r;
 438         }
 439
 440         r = sd_rtnl_message_append_in_addr(m, IFLA_VTI_REMOTE, &netdev->remote.in);
 441         if (r < 0) {
 442                 log_error_netdev(netdev,
 443                                  "Could not append IFLA_IPTUN_REMOTE attribute: %s",
 444                                  strerror(-r));
 445                 return r;
 446         }
 447
 448         r = sd_rtnl_message_close_container(m);
 449         if (r < 0) {
 450                 log_error_netdev(netdev,
 451                                  "Could not append IFLA_INFO_DATA attribute: %s",
 452                                  strerror(-r));
 453                 return r;
 454         }
 455
 456         r = sd_rtnl_message_close_container(m);
 457         if (r < 0) {
 458                 log_error_netdev(netdev,
 459                                  "Could not append IFLA_LINKINFO attribute: %s",
 460                                  strerror(-r));
 461                 return r;
 462         }
 463
 464         return r;
 465 }
 466
 467 static int netdev_tunnel_verify(NetDev *netdev, const char *filename) {
 468         assert(netdev);
 469         assert(filename);
 470
 471         if (netdev->local.in.s_addr == INADDR_ANY) {
 472                log_warning("Tunnel without local address configured in %s. Ignoring", filename);
 473                return -EINVAL;
 474         }
 475
 476         if (netdev->remote.in.s_addr == INADDR_ANY) {
 477                log_warning("Tunnel without remote address configured in %s. Ignoring", filename);
 478                return -EINVAL;
 479         }
 480
 481         if (netdev->family != AF_INET) {
 482               log_warning("Tunnel with invalid address family configured in %s. Ignoring", filename);
 483               return -EINVAL;
 484         }
 485
 486         return 0;
 487 }
 488
 489 int config_parse_tunnel_address(const char *unit,
 490                                 const char *filename,
 491                                 unsigned line,
 492                                 const char *section,
 493                                 unsigned section_line,
 494                                 const char *lvalue,
 495                                 int ltype,
 496                                 const char *rvalue,
 497                                 void *data,
 498                                 void *userdata) {
 499         NetDev *n = userdata;
 500         union in_addr_union *addr = data;
 501         int r;
 502
 503         assert(filename);
 504         assert(lvalue);
 505         assert(rvalue);
 506         assert(data);
 507
 508         r = net_parse_inaddr(rvalue, &n->family, addr);
 509         if (r < 0) {
 510                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 511                            "Tunnel address is invalid, ignoring assignment: %s", rvalue);
 512                 return 0;
 513         }
 514
 515         return 0;
 516 }
 517
 518 const NetDevVTable ipip_vtable = {
 519         .fill_message_create_on_link = netdev_ipip_fill_message_create,
 520         .config_verify = netdev_tunnel_verify,
 521 };
 522
 523 const NetDevVTable sit_vtable = {
 524         .fill_message_create_on_link = netdev_sit_fill_message_create,
 525         .config_verify = netdev_tunnel_verify,
 526 };
 527
 528 const NetDevVTable vti_vtable = {
 529         .fill_message_create_on_link = netdev_vti_fill_message_create,
 530         .config_verify = netdev_tunnel_verify,
 531 };
 532
 533 const NetDevVTable gre_vtable = {
 534         .fill_message_create_on_link = netdev_gre_fill_message_create,
 535         .config_verify = netdev_tunnel_verify,
 536 };