ip/link_ip6tnl.c

   1 /*
   2  * link_ip6tnl.c        ip6tnl driver module
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Nicolas Dichtel <nicolas.dichtel@6wind.com>
  10  *
  11  */
  12
  13 #include <string.h>
  14 #include <net/if.h>
  15 #include <sys/types.h>
  16 #include <sys/socket.h>
  17 #include <arpa/inet.h>
  18
  19 #include <linux/ip.h>
  20 #include <linux/if_tunnel.h>
  21 #include <linux/ip6_tunnel.h>
  22 #include "rt_names.h"
  23 #include "utils.h"
  24 #include "ip_common.h"
  25 #include "tunnel.h"
  26
  27 #define IP6_FLOWINFO_TCLASS     htonl(0x0FF00000)
  28 #define IP6_FLOWINFO_FLOWLABEL  htonl(0x000FFFFF)
  29
  30 #define DEFAULT_TNL_HOP_LIMIT   (64)
  31
  32 static void print_usage(FILE *f)
  33 {
  34         fprintf(f,
  35                 "Usage: ... ip6tnl [ mode { ip6ip6 | ipip6 | any } ]\n"
  36                 "                  [ remote ADDR ]\n"
  37                 "                  [ local ADDR ]\n"
  38                 "                  [ dev PHYS_DEV ]\n"
  39                 "                  [ encaplimit ELIM ]\n"
  40                 "                  [ hoplimit HLIM ]\n"
  41                 "                  [ tclass TCLASS ]\n"
  42                 "                  [ flowlabel FLOWLABEL ]\n"
  43                 "                  [ dscp inherit ]\n"
  44                 "                  [ fwmark MARK ]\n"
  45                 "                  [ [no]allow-localremote ]\n"
  46                 "                  [ noencap ]\n"
  47                 "                  [ encap { fou | gue | none } ]\n"
  48                 "                  [ encap-sport PORT ]\n"
  49                 "                  [ encap-dport PORT ]\n"
  50                 "                  [ [no]encap-csum ]\n"
  51                 "                  [ [no]encap-csum6 ]\n"
  52                 "                  [ [no]encap-remcsum ]\n"
  53                 "                  [ external ]\n"
  54                 "\n"
  55                 "Where: ADDR      := IPV6_ADDRESS\n"
  56                 "       ELIM      := { none | 0..255 }(default=%d)\n"
  57                 "       HLIM      := 0..255 (default=%d)\n"
  58                 "       TCLASS    := { 0x0..0xff | inherit }\n"
  59                 "       FLOWLABEL := { 0x0..0xfffff | inherit }\n"
  60                 "       MARK      := { 0x0..0xffffffff | inherit }\n",
  61                 IPV6_DEFAULT_TNL_ENCAP_LIMIT, DEFAULT_TNL_HOP_LIMIT
  62         );
  63 }
  64
  65 static void usage(void) __attribute__((noreturn));
  66 static void usage(void)
  67 {
  68         print_usage(stderr);
  69         exit(-1);
  70 }
  71
  72 static int ip6tunnel_parse_opt(struct link_util *lu, int argc, char **argv,
  73                                struct nlmsghdr *n)
  74 {
  75         struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
  76         struct {
  77                 struct nlmsghdr n;
  78                 struct ifinfomsg i;
  79         } req = {
  80                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
  81                 .n.nlmsg_flags = NLM_F_REQUEST,
  82                 .n.nlmsg_type = RTM_GETLINK,
  83                 .i.ifi_family = preferred_family,
  84                 .i.ifi_index = ifi->ifi_index,
  85         };
  86         struct nlmsghdr *answer;
  87         struct rtattr *tb[IFLA_MAX + 1];
  88         struct rtattr *linkinfo[IFLA_INFO_MAX+1];
  89         struct rtattr *iptuninfo[IFLA_IPTUN_MAX + 1];
  90         int len;
  91         struct in6_addr laddr = IN6ADDR_ANY_INIT;
  92         struct in6_addr raddr = IN6ADDR_ANY_INIT;
  93         __u8 hop_limit = DEFAULT_TNL_HOP_LIMIT;
  94         __u8 encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
  95         __u32 flowinfo = 0;
  96         __u32 flags = 0;
  97         __u32 link = 0;
  98         __u8 proto = 0;
  99         __u16 encaptype = 0;
 100         __u16 encapflags = TUNNEL_ENCAP_FLAG_CSUM6;
 101         __u16 encapsport = 0;
 102         __u16 encapdport = 0;
 103         __u8 metadata = 0;
 104         __u32 fwmark = 0;
 105
 106         if (!(n->nlmsg_flags & NLM_F_CREATE)) {
 107                 if (rtnl_talk(&rth, &req.n, &answer) < 0) {
 108 get_failed:
 109                         fprintf(stderr,
 110                                 "Failed to get existing tunnel info.\n");
 111                         return -1;
 112                 }
 113
 114                 len = answer->nlmsg_len;
 115                 len -= NLMSG_LENGTH(sizeof(*ifi));
 116                 if (len < 0)
 117                         goto get_failed;
 118
 119                 parse_rtattr(tb, IFLA_MAX, IFLA_RTA(NLMSG_DATA(answer)), len);
 120
 121                 if (!tb[IFLA_LINKINFO])
 122                         goto get_failed;
 123
 124                 parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
 125
 126                 if (!linkinfo[IFLA_INFO_DATA])
 127                         goto get_failed;
 128
 129                 parse_rtattr_nested(iptuninfo, IFLA_IPTUN_MAX,
 130                                     linkinfo[IFLA_INFO_DATA]);
 131
 132                 if (iptuninfo[IFLA_IPTUN_LOCAL])
 133                         memcpy(&laddr, RTA_DATA(iptuninfo[IFLA_IPTUN_LOCAL]),
 134                                sizeof(laddr));
 135
 136                 if (iptuninfo[IFLA_IPTUN_REMOTE])
 137                         memcpy(&raddr, RTA_DATA(iptuninfo[IFLA_IPTUN_REMOTE]),
 138                                sizeof(raddr));
 139
 140                 if (iptuninfo[IFLA_IPTUN_TTL])
 141                         hop_limit = rta_getattr_u8(iptuninfo[IFLA_IPTUN_TTL]);
 142
 143                 if (iptuninfo[IFLA_IPTUN_ENCAP_LIMIT])
 144                         encap_limit = rta_getattr_u8(iptuninfo[IFLA_IPTUN_ENCAP_LIMIT]);
 145
 146                 if (iptuninfo[IFLA_IPTUN_FLOWINFO])
 147                         flowinfo = rta_getattr_u32(iptuninfo[IFLA_IPTUN_FLOWINFO]);
 148
 149                 if (iptuninfo[IFLA_IPTUN_FLAGS])
 150                         flags = rta_getattr_u32(iptuninfo[IFLA_IPTUN_FLAGS]);
 151
 152                 if (iptuninfo[IFLA_IPTUN_LINK])
 153                         link = rta_getattr_u32(iptuninfo[IFLA_IPTUN_LINK]);
 154
 155                 if (iptuninfo[IFLA_IPTUN_PROTO])
 156                         proto = rta_getattr_u8(iptuninfo[IFLA_IPTUN_PROTO]);
 157                 if (iptuninfo[IFLA_IPTUN_COLLECT_METADATA])
 158                         metadata = 1;
 159
 160                 if (iptuninfo[IFLA_IPTUN_FWMARK])
 161                         fwmark = rta_getattr_u32(iptuninfo[IFLA_IPTUN_FWMARK]);
 162
 163                 free(answer);
 164         }
 165
 166         while (argc > 0) {
 167                 if (matches(*argv, "mode") == 0) {
 168                         NEXT_ARG();
 169                         if (strcmp(*argv, "ipv6/ipv6") == 0 ||
 170                             strcmp(*argv, "ip6ip6") == 0)
 171                                 proto = IPPROTO_IPV6;
 172                         else if (strcmp(*argv, "ip/ipv6") == 0 ||
 173                                  strcmp(*argv, "ipv4/ipv6") == 0 ||
 174                                  strcmp(*argv, "ipip6") == 0 ||
 175                                  strcmp(*argv, "ip4ip6") == 0)
 176                                 proto = IPPROTO_IPIP;
 177                         else if (strcmp(*argv, "any/ipv6") == 0 ||
 178                                  strcmp(*argv, "any") == 0)
 179                                 proto = 0;
 180                         else
 181                                 invarg("Cannot guess tunnel mode.", *argv);
 182                 } else if (strcmp(*argv, "remote") == 0) {
 183                         inet_prefix addr;
 184
 185                         NEXT_ARG();
 186                         get_addr(&addr, *argv, AF_INET6);
 187                         memcpy(&raddr, addr.data, sizeof(raddr));
 188                 } else if (strcmp(*argv, "local") == 0) {
 189                         inet_prefix addr;
 190
 191                         NEXT_ARG();
 192                         get_addr(&addr, *argv, AF_INET6);
 193                         memcpy(&laddr, addr.data, sizeof(laddr));
 194                 } else if (matches(*argv, "dev") == 0) {
 195                         NEXT_ARG();
 196                         link = if_nametoindex(*argv);
 197                         if (link == 0)
 198                                 invarg("\"dev\" is invalid", *argv);
 199                 } else if (strcmp(*argv, "hoplimit") == 0 ||
 200                            strcmp(*argv, "ttl") == 0 ||
 201                            strcmp(*argv, "hlim") == 0) {
 202                         __u8 uval;
 203
 204                         NEXT_ARG();
 205                         if (get_u8(&uval, *argv, 0))
 206                                 invarg("invalid HLIM", *argv);
 207                         hop_limit = uval;
 208                 } else if (strcmp(*argv, "encaplimit") == 0) {
 209                         NEXT_ARG();
 210                         if (strcmp(*argv, "none") == 0) {
 211                                 flags |= IP6_TNL_F_IGN_ENCAP_LIMIT;
 212                         } else {
 213                                 __u8 uval;
 214
 215                                 if (get_u8(&uval, *argv, 0) < -1)
 216                                         invarg("invalid ELIM", *argv);
 217                                 encap_limit = uval;
 218                                 flags &= ~IP6_TNL_F_IGN_ENCAP_LIMIT;
 219                         }
 220                 } else if (strcmp(*argv, "tclass") == 0 ||
 221                            strcmp(*argv, "tc") == 0 ||
 222                            strcmp(*argv, "tos") == 0 ||
 223                            matches(*argv, "dsfield") == 0) {
 224                         __u8 uval;
 225
 226                         NEXT_ARG();
 227                         flowinfo &= ~IP6_FLOWINFO_TCLASS;
 228                         if (strcmp(*argv, "inherit") == 0)
 229                                 flags |= IP6_TNL_F_USE_ORIG_TCLASS;
 230                         else {
 231                                 if (get_u8(&uval, *argv, 16))
 232                                         invarg("invalid TClass", *argv);
 233                                 flowinfo |= htonl((__u32)uval << 20) & IP6_FLOWINFO_TCLASS;
 234                                 flags &= ~IP6_TNL_F_USE_ORIG_TCLASS;
 235                         }
 236                 } else if (strcmp(*argv, "flowlabel") == 0 ||
 237                            strcmp(*argv, "fl") == 0) {
 238                         __u32 uval;
 239
 240                         NEXT_ARG();
 241                         flowinfo &= ~IP6_FLOWINFO_FLOWLABEL;
 242                         if (strcmp(*argv, "inherit") == 0)
 243                                 flags |= IP6_TNL_F_USE_ORIG_FLOWLABEL;
 244                         else {
 245                                 if (get_u32(&uval, *argv, 16))
 246                                         invarg("invalid Flowlabel", *argv);
 247                                 if (uval > 0xFFFFF)
 248                                         invarg("invalid Flowlabel", *argv);
 249                                 flowinfo |= htonl(uval) & IP6_FLOWINFO_FLOWLABEL;
 250                                 flags &= ~IP6_TNL_F_USE_ORIG_FLOWLABEL;
 251                         }
 252                 } else if (strcmp(*argv, "dscp") == 0) {
 253                         NEXT_ARG();
 254                         if (strcmp(*argv, "inherit") != 0)
 255                                 invarg("not inherit", *argv);
 256                         flags |= IP6_TNL_F_RCV_DSCP_COPY;
 257                 } else if (strcmp(*argv, "fwmark") == 0) {
 258                         NEXT_ARG();
 259                         if (strcmp(*argv, "inherit") == 0) {
 260                                 flags |= IP6_TNL_F_USE_ORIG_FWMARK;
 261                                 fwmark = 0;
 262                         } else {
 263                                 if (get_u32(&fwmark, *argv, 0))
 264                                         invarg("invalid fwmark\n", *argv);
 265                                 flags &= ~IP6_TNL_F_USE_ORIG_FWMARK;
 266                         }
 267                 } else if (strcmp(*argv, "allow-localremote") == 0) {
 268                         flags |= IP6_TNL_F_ALLOW_LOCAL_REMOTE;
 269                 } else if (strcmp(*argv, "noallow-localremote") == 0) {
 270                         flags &= ~IP6_TNL_F_ALLOW_LOCAL_REMOTE;
 271                 } else if (strcmp(*argv, "noencap") == 0) {
 272                         encaptype = TUNNEL_ENCAP_NONE;
 273                 } else if (strcmp(*argv, "encap") == 0) {
 274                         NEXT_ARG();
 275                         if (strcmp(*argv, "fou") == 0)
 276                                 encaptype = TUNNEL_ENCAP_FOU;
 277                         else if (strcmp(*argv, "gue") == 0)
 278                                 encaptype = TUNNEL_ENCAP_GUE;
 279                         else if (strcmp(*argv, "none") == 0)
 280                                 encaptype = TUNNEL_ENCAP_NONE;
 281                         else
 282                                 invarg("Invalid encap type.", *argv);
 283                 } else if (strcmp(*argv, "encap-sport") == 0) {
 284                         NEXT_ARG();
 285                         if (strcmp(*argv, "auto") == 0)
 286                                 encapsport = 0;
 287                         else if (get_u16(&encapsport, *argv, 0))
 288                                 invarg("Invalid source port.", *argv);
 289                 } else if (strcmp(*argv, "encap-dport") == 0) {
 290                         NEXT_ARG();
 291                         if (get_u16(&encapdport, *argv, 0))
 292                                 invarg("Invalid destination port.", *argv);
 293                 } else if (strcmp(*argv, "encap-csum") == 0) {
 294                         encapflags |= TUNNEL_ENCAP_FLAG_CSUM;
 295                 } else if (strcmp(*argv, "noencap-csum") == 0) {
 296                         encapflags &= ~TUNNEL_ENCAP_FLAG_CSUM;
 297                 } else if (strcmp(*argv, "encap-udp6-csum") == 0) {
 298                         encapflags |= TUNNEL_ENCAP_FLAG_CSUM6;
 299                 } else if (strcmp(*argv, "noencap-udp6-csum") == 0) {
 300                         encapflags &= ~TUNNEL_ENCAP_FLAG_CSUM6;
 301                 } else if (strcmp(*argv, "encap-remcsum") == 0) {
 302                         encapflags |= TUNNEL_ENCAP_FLAG_REMCSUM;
 303                 } else if (strcmp(*argv, "noencap-remcsum") == 0) {
 304                         encapflags &= ~TUNNEL_ENCAP_FLAG_REMCSUM;
 305                 } else if (strcmp(*argv, "external") == 0) {
 306                         metadata = 1;
 307                 } else
 308                         usage();
 309                 argc--, argv++;
 310         }
 311
 312         addattr8(n, 1024, IFLA_IPTUN_PROTO, proto);
 313         if (metadata) {
 314                 addattr_l(n, 1024, IFLA_IPTUN_COLLECT_METADATA, NULL, 0);
 315                 return 0;
 316         }
 317         addattr_l(n, 1024, IFLA_IPTUN_LOCAL, &laddr, sizeof(laddr));
 318         addattr_l(n, 1024, IFLA_IPTUN_REMOTE, &raddr, sizeof(raddr));
 319         addattr8(n, 1024, IFLA_IPTUN_TTL, hop_limit);
 320         addattr8(n, 1024, IFLA_IPTUN_ENCAP_LIMIT, encap_limit);
 321         addattr32(n, 1024, IFLA_IPTUN_FLOWINFO, flowinfo);
 322         addattr32(n, 1024, IFLA_IPTUN_FLAGS, flags);
 323         addattr32(n, 1024, IFLA_IPTUN_LINK, link);
 324         addattr32(n, 1024, IFLA_IPTUN_FWMARK, fwmark);
 325
 326         addattr16(n, 1024, IFLA_IPTUN_ENCAP_TYPE, encaptype);
 327         addattr16(n, 1024, IFLA_IPTUN_ENCAP_FLAGS, encapflags);
 328         addattr16(n, 1024, IFLA_IPTUN_ENCAP_SPORT, htons(encapsport));
 329         addattr16(n, 1024, IFLA_IPTUN_ENCAP_DPORT, htons(encapdport));
 330
 331         return 0;
 332 }
 333
 334 static void ip6tunnel_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 335 {
 336         char s2[64];
 337         int flags = 0;
 338         __u32 flowinfo = 0;
 339         __u8 ttl = 0;
 340
 341         if (!tb)
 342                 return;
 343
 344         if (tb[IFLA_IPTUN_COLLECT_METADATA])
 345                 print_bool(PRINT_ANY, "external", "external ", true);
 346
 347         if (tb[IFLA_IPTUN_FLAGS])
 348                 flags = rta_getattr_u32(tb[IFLA_IPTUN_FLAGS]);
 349
 350         if (tb[IFLA_IPTUN_FLOWINFO])
 351                 flowinfo = rta_getattr_u32(tb[IFLA_IPTUN_FLOWINFO]);
 352
 353         if (tb[IFLA_IPTUN_PROTO]) {
 354                 switch (rta_getattr_u8(tb[IFLA_IPTUN_PROTO])) {
 355                 case IPPROTO_IPIP:
 356                         print_string(PRINT_ANY, "proto", "%s ", "ipip6");
 357                         break;
 358                 case IPPROTO_IPV6:
 359                         print_string(PRINT_ANY, "proto", "%s ", "ip6ip6");
 360                         break;
 361                 case 0:
 362                         print_string(PRINT_ANY, "proto", "%s ", "any");
 363                         break;
 364                 }
 365         }
 366
 367         if (tb[IFLA_IPTUN_REMOTE]) {
 368                 print_string(PRINT_ANY,
 369                              "remote",
 370                              "remote %s ",
 371                              rt_addr_n2a_rta(AF_INET6, tb[IFLA_IPTUN_REMOTE]));
 372         }
 373
 374         if (tb[IFLA_IPTUN_LOCAL]) {
 375                 print_string(PRINT_ANY,
 376                              "local",
 377                              "local %s ",
 378                              rt_addr_n2a_rta(AF_INET6, tb[IFLA_IPTUN_LOCAL]));
 379         }
 380
 381         if (tb[IFLA_IPTUN_LINK]) {
 382                 unsigned int link = rta_getattr_u32(tb[IFLA_IPTUN_LINK]);
 383
 384                 if (link) {
 385                         print_string(PRINT_ANY, "link", "dev %s ",
 386                                      ll_index_to_name(link));
 387                 }
 388         }
 389
 390         if (tb[IFLA_IPTUN_TTL])
 391                 ttl = rta_getattr_u8(tb[IFLA_IPTUN_TTL]);
 392         if (is_json_context() || ttl)
 393                 print_uint(PRINT_ANY, "ttl", "hoplimit %u ", ttl);
 394         else
 395                 print_string(PRINT_FP, NULL, "hoplimit %s ", "inherit");
 396
 397         if (flags & IP6_TNL_F_IGN_ENCAP_LIMIT) {
 398                 print_bool(PRINT_ANY,
 399                            "ip6_tnl_f_ign_encap_limit",
 400                            "encaplimit none ",
 401                            true);
 402         } else if (tb[IFLA_IPTUN_ENCAP_LIMIT]) {
 403                 __u8 val = rta_getattr_u8(tb[IFLA_IPTUN_ENCAP_LIMIT]);
 404
 405                 print_uint(PRINT_ANY, "encap_limit", "encaplimit %u ", val);
 406         }
 407
 408         if (flags & IP6_TNL_F_USE_ORIG_TCLASS) {
 409                 print_bool(PRINT_ANY,
 410                            "ip6_tnl_f_use_orig_tclass",
 411                            "tclass inherit ",
 412                            true);
 413         } else if (tb[IFLA_IPTUN_FLOWINFO]) {
 414                 __u32 val = ntohl(flowinfo & IP6_FLOWINFO_TCLASS) >> 20;
 415
 416                 snprintf(s2, sizeof(s2), "0x%02x", val);
 417                 print_string(PRINT_ANY, "tclass", "tclass %s ", s2);
 418         }
 419
 420         if (flags & IP6_TNL_F_USE_ORIG_FLOWLABEL) {
 421                 print_bool(PRINT_ANY,
 422                            "ip6_tnl_f_use_orig_flowlabel",
 423                            "flowlabel inherit ",
 424                            true);
 425         } else if (tb[IFLA_IPTUN_FLOWINFO]) {
 426                 __u32 val = ntohl(flowinfo & IP6_FLOWINFO_FLOWLABEL);
 427
 428                 snprintf(s2, sizeof(s2), "0x%05x", val);
 429                 print_string(PRINT_ANY, "flowlabel", "flowlabel %s ", s2);
 430         }
 431
 432         if (flags & IP6_TNL_F_RCV_DSCP_COPY)
 433                 print_bool(PRINT_ANY,
 434                            "ip6_tnl_f_rcv_dscp_copy",
 435                            "dscp inherit ",
 436                            true);
 437
 438         if (flags & IP6_TNL_F_MIP6_DEV)
 439                 print_bool(PRINT_ANY, "ip6_tnl_f_mip6_dev", "mip6 ", true);
 440
 441         if (flags & IP6_TNL_F_ALLOW_LOCAL_REMOTE)
 442                 print_bool(PRINT_ANY,
 443                            "ip6_tnl_f_allow_local_remote",
 444                            "allow-localremote ",
 445                            true);
 446
 447         if (flags & IP6_TNL_F_USE_ORIG_FWMARK) {
 448                 print_bool(PRINT_ANY,
 449                            "ip6_tnl_f_use_orig_fwmark",
 450                            "fwmark inherit ",
 451                            true);
 452         } else if (tb[IFLA_IPTUN_FWMARK]) {
 453                 __u32 fwmark = rta_getattr_u32(tb[IFLA_IPTUN_FWMARK]);
 454
 455                 if (fwmark) {
 456                         print_0xhex(PRINT_ANY,
 457                                     "fwmark", "fwmark 0x%x ", fwmark);
 458                 }
 459         }
 460
 461         tnl_print_encap(tb,
 462                         IFLA_IPTUN_ENCAP_TYPE,
 463                         IFLA_IPTUN_ENCAP_FLAGS,
 464                         IFLA_IPTUN_ENCAP_SPORT,
 465                         IFLA_IPTUN_ENCAP_DPORT);
 466 }
 467
 468 static void ip6tunnel_print_help(struct link_util *lu, int argc, char **argv,
 469                                  FILE *f)
 470 {
 471         print_usage(f);
 472 }
 473
 474 struct link_util ip6tnl_link_util = {
 475         .id = "ip6tnl",
 476         .maxattr = IFLA_IPTUN_MAX,
 477         .parse_opt = ip6tunnel_parse_opt,
 478         .print_opt = ip6tunnel_print_opt,
 479         .print_help = ip6tunnel_print_help,
 480 };