ip/iplink_geneve.c

   1 /*
   2  * iplink_geneve.c      GENEVE device support
   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:     John W. Linville <linville@tuxdriver.com>
  10  */
  11
  12 #include <stdio.h>
  13
  14 #include "rt_names.h"
  15 #include "utils.h"
  16 #include "ip_common.h"
  17
  18 #define GENEVE_ATTRSET(attrs, type) (((attrs) & (1L << (type))) != 0)
  19
  20 static void print_explain(FILE *f)
  21 {
  22         fprintf(f,
  23                 "Usage: ... geneve id VNI\n"
  24                 "                  remote ADDR\n"
  25                 "                  [ ttl TTL ]\n"
  26                 "                  [ tos TOS ]\n"
  27                 "                  [ flowlabel LABEL ]\n"
  28                 "                  [ dstport PORT ]\n"
  29                 "                  [ [no]external ]\n"
  30                 "                  [ [no]udpcsum ]\n"
  31                 "                  [ [no]udp6zerocsumtx ]\n"
  32                 "                  [ [no]udp6zerocsumrx ]\n"
  33                 "\n"
  34                 "Where: VNI   := 0-16777215\n"
  35                 "       ADDR  := IP_ADDRESS\n"
  36                 "       TOS   := { NUMBER | inherit }\n"
  37                 "       TTL   := { 1..255 | inherit }\n"
  38                 "       LABEL := 0-1048575\n"
  39         );
  40 }
  41
  42 static void explain(void)
  43 {
  44         print_explain(stderr);
  45 }
  46
  47 static void check_duparg(__u64 *attrs, int type, const char *key,
  48                          const char *argv)
  49 {
  50         if (!GENEVE_ATTRSET(*attrs, type)) {
  51                 *attrs |= (1L << type);
  52                 return;
  53         }
  54         duparg2(key, argv);
  55 }
  56
  57 static int geneve_parse_opt(struct link_util *lu, int argc, char **argv,
  58                           struct nlmsghdr *n)
  59 {
  60         __u32 vni = 0;
  61         __u32 daddr = 0;
  62         struct in6_addr daddr6 = IN6ADDR_ANY_INIT;
  63         __u32 label = 0;
  64         __u8 ttl = 0;
  65         __u8 tos = 0;
  66         __u16 dstport = 0;
  67         bool metadata = 0;
  68         __u8 udpcsum = 0;
  69         __u8 udp6zerocsumtx = 0;
  70         __u8 udp6zerocsumrx = 0;
  71         __u64 attrs = 0;
  72         bool set_op = (n->nlmsg_type == RTM_NEWLINK &&
  73                        !(n->nlmsg_flags & NLM_F_CREATE));
  74
  75         while (argc > 0) {
  76                 if (!matches(*argv, "id") ||
  77                     !matches(*argv, "vni")) {
  78                         NEXT_ARG();
  79                         check_duparg(&attrs, IFLA_GENEVE_ID, "id", *argv);
  80                         if (get_u32(&vni, *argv, 0) ||
  81                             vni >= 1u << 24)
  82                                 invarg("invalid id", *argv);
  83                 } else if (!matches(*argv, "remote")) {
  84                         NEXT_ARG();
  85                         check_duparg(&attrs, IFLA_GENEVE_REMOTE, "remote",
  86                                      *argv);
  87                         if (!inet_get_addr(*argv, &daddr, &daddr6)) {
  88                                 fprintf(stderr, "Invalid address \"%s\"\n", *argv);
  89                                 return -1;
  90                         }
  91                         if (IN6_IS_ADDR_MULTICAST(&daddr6) || IN_MULTICAST(ntohl(daddr)))
  92                                 invarg("invalid remote address", *argv);
  93                 } else if (!matches(*argv, "ttl") ||
  94                            !matches(*argv, "hoplimit")) {
  95                         unsigned int uval;
  96
  97                         NEXT_ARG();
  98                         check_duparg(&attrs, IFLA_GENEVE_TTL, "ttl", *argv);
  99                         if (strcmp(*argv, "inherit") != 0) {
 100                                 if (get_unsigned(&uval, *argv, 0))
 101                                         invarg("invalid TTL", *argv);
 102                                 if (uval > 255)
 103                                         invarg("TTL must be <= 255", *argv);
 104                                 ttl = uval;
 105                         }
 106                 } else if (!matches(*argv, "tos") ||
 107                            !matches(*argv, "dsfield")) {
 108                         __u32 uval;
 109
 110                         NEXT_ARG();
 111                         check_duparg(&attrs, IFLA_GENEVE_TOS, "tos", *argv);
 112                         if (strcmp(*argv, "inherit") != 0) {
 113                                 if (rtnl_dsfield_a2n(&uval, *argv))
 114                                         invarg("bad TOS value", *argv);
 115                                 tos = uval;
 116                         } else
 117                                 tos = 1;
 118                 } else if (!matches(*argv, "label") ||
 119                            !matches(*argv, "flowlabel")) {
 120                         __u32 uval;
 121
 122                         NEXT_ARG();
 123                         check_duparg(&attrs, IFLA_GENEVE_LABEL, "flowlabel",
 124                                      *argv);
 125                         if (get_u32(&uval, *argv, 0) ||
 126                             (uval & ~LABEL_MAX_MASK))
 127                                 invarg("invalid flowlabel", *argv);
 128                         label = htonl(uval);
 129                 } else if (!matches(*argv, "dstport")) {
 130                         NEXT_ARG();
 131                         check_duparg(&attrs, IFLA_GENEVE_PORT, "dstport",
 132                                      *argv);
 133                         if (get_u16(&dstport, *argv, 0))
 134                                 invarg("dstport", *argv);
 135                 } else if (!matches(*argv, "external")) {
 136                         check_duparg(&attrs, IFLA_GENEVE_COLLECT_METADATA,
 137                                      *argv, *argv);
 138                         metadata = true;
 139                 } else if (!matches(*argv, "noexternal")) {
 140                         check_duparg(&attrs, IFLA_GENEVE_COLLECT_METADATA,
 141                                      *argv, *argv);
 142                         metadata = false;
 143                 } else if (!matches(*argv, "udpcsum")) {
 144                         check_duparg(&attrs, IFLA_GENEVE_UDP_CSUM, *argv,
 145                                      *argv);
 146                         udpcsum = 1;
 147                 } else if (!matches(*argv, "noudpcsum")) {
 148                         check_duparg(&attrs, IFLA_GENEVE_UDP_CSUM, *argv,
 149                                      *argv);
 150                         udpcsum = 0;
 151                 } else if (!matches(*argv, "udp6zerocsumtx")) {
 152                         check_duparg(&attrs, IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
 153                                      *argv, *argv);
 154                         udp6zerocsumtx = 1;
 155                 } else if (!matches(*argv, "noudp6zerocsumtx")) {
 156                         check_duparg(&attrs, IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
 157                                      *argv, *argv);
 158                         udp6zerocsumtx = 0;
 159                 } else if (!matches(*argv, "udp6zerocsumrx")) {
 160                         check_duparg(&attrs, IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
 161                                      *argv, *argv);
 162                         udp6zerocsumrx = 1;
 163                 } else if (!matches(*argv, "noudp6zerocsumrx")) {
 164                         check_duparg(&attrs, IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
 165                                      *argv, *argv);
 166                         udp6zerocsumrx = 0;
 167                 } else if (matches(*argv, "help") == 0) {
 168                         explain();
 169                         return -1;
 170                 } else {
 171                         fprintf(stderr, "geneve: unknown command \"%s\"?\n", *argv);
 172                         explain();
 173                         return -1;
 174                 }
 175                 argc--, argv++;
 176         }
 177
 178         if (metadata && GENEVE_ATTRSET(attrs, IFLA_GENEVE_ID)) {
 179                 fprintf(stderr, "geneve: both 'external' and vni cannot be specified\n");
 180                 return -1;
 181         }
 182
 183         if (!metadata) {
 184                 /* parameter checking make sense only for full geneve tunnels */
 185                 if (!GENEVE_ATTRSET(attrs, IFLA_GENEVE_ID)) {
 186                         fprintf(stderr, "geneve: missing virtual network identifier\n");
 187                         return -1;
 188                 }
 189
 190                 /* If we are modifying the geneve device, then we only need the
 191                  * ID (VNI) to identify the geneve device, and we do not need
 192                  * the remote IP.
 193                  */
 194                 if (!set_op && !daddr && IN6_IS_ADDR_UNSPECIFIED(&daddr6)) {
 195                         fprintf(stderr, "geneve: remote link partner not specified\n");
 196                         return -1;
 197                 }
 198         }
 199
 200         addattr32(n, 1024, IFLA_GENEVE_ID, vni);
 201         if (daddr)
 202                 addattr_l(n, 1024, IFLA_GENEVE_REMOTE, &daddr, 4);
 203         if (!IN6_IS_ADDR_UNSPECIFIED(&daddr6)) {
 204                 addattr_l(n, 1024, IFLA_GENEVE_REMOTE6, &daddr6,
 205                           sizeof(struct in6_addr));
 206         }
 207         if (!set_op || GENEVE_ATTRSET(attrs, IFLA_GENEVE_LABEL))
 208                 addattr32(n, 1024, IFLA_GENEVE_LABEL, label);
 209         if (!set_op || GENEVE_ATTRSET(attrs, IFLA_GENEVE_TTL))
 210                 addattr8(n, 1024, IFLA_GENEVE_TTL, ttl);
 211         if (!set_op || GENEVE_ATTRSET(attrs, IFLA_GENEVE_TOS))
 212                 addattr8(n, 1024, IFLA_GENEVE_TOS, tos);
 213         if (dstport)
 214                 addattr16(n, 1024, IFLA_GENEVE_PORT, htons(dstport));
 215         if (metadata)
 216                 addattr(n, 1024, IFLA_GENEVE_COLLECT_METADATA);
 217         if (GENEVE_ATTRSET(attrs, IFLA_GENEVE_UDP_CSUM))
 218                 addattr8(n, 1024, IFLA_GENEVE_UDP_CSUM, udpcsum);
 219         if (GENEVE_ATTRSET(attrs, IFLA_GENEVE_UDP_ZERO_CSUM6_TX))
 220                 addattr8(n, 1024, IFLA_GENEVE_UDP_ZERO_CSUM6_TX, udp6zerocsumtx);
 221         if (GENEVE_ATTRSET(attrs, IFLA_GENEVE_UDP_ZERO_CSUM6_RX))
 222                 addattr8(n, 1024, IFLA_GENEVE_UDP_ZERO_CSUM6_RX, udp6zerocsumrx);
 223
 224         return 0;
 225 }
 226
 227 static void geneve_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 228 {
 229         __u32 vni;
 230         __u8 ttl = 0;
 231         __u8 tos = 0;
 232
 233         if (!tb)
 234                 return;
 235
 236         if (!tb[IFLA_GENEVE_ID] ||
 237             RTA_PAYLOAD(tb[IFLA_GENEVE_ID]) < sizeof(__u32))
 238                 return;
 239
 240         vni = rta_getattr_u32(tb[IFLA_GENEVE_ID]);
 241         print_uint(PRINT_ANY, "id", "id %u ", vni);
 242
 243         if (tb[IFLA_GENEVE_REMOTE]) {
 244                 __be32 addr = rta_getattr_u32(tb[IFLA_GENEVE_REMOTE]);
 245
 246                 if (addr)
 247                         print_string(PRINT_ANY,
 248                                      "remote",
 249                                      "remote %s ",
 250                                      format_host(AF_INET, 4, &addr));
 251         } else if (tb[IFLA_GENEVE_REMOTE6]) {
 252                 struct in6_addr addr;
 253
 254                 memcpy(&addr, RTA_DATA(tb[IFLA_GENEVE_REMOTE6]), sizeof(struct in6_addr));
 255                 if (!IN6_IS_ADDR_UNSPECIFIED(&addr)) {
 256                         if (!IN6_IS_ADDR_MULTICAST(&addr))
 257                                 print_string(PRINT_ANY,
 258                                              "remote6",
 259                                              "remote %s ",
 260                                              format_host(AF_INET6,
 261                                                          sizeof(struct in6_addr),
 262                                                          &addr));
 263                 }
 264         }
 265
 266         if (tb[IFLA_GENEVE_TTL])
 267                 ttl = rta_getattr_u8(tb[IFLA_GENEVE_TTL]);
 268         if (is_json_context() || ttl)
 269                 print_uint(PRINT_ANY, "ttl", "ttl %u ", ttl);
 270         else
 271                 print_string(PRINT_FP, NULL, "ttl %s ", "inherit");
 272
 273         if (tb[IFLA_GENEVE_TOS])
 274                 tos = rta_getattr_u8(tb[IFLA_GENEVE_TOS]);
 275         if (tos) {
 276                 if (is_json_context() || tos != 1)
 277                         print_0xhex(PRINT_ANY, "tos", "tos 0x%x ", tos);
 278                 else
 279                         print_string(PRINT_FP, NULL, "tos %s ", "inherit");
 280         }
 281
 282         if (tb[IFLA_GENEVE_LABEL]) {
 283                 __u32 label = rta_getattr_u32(tb[IFLA_GENEVE_LABEL]);
 284
 285                 if (label)
 286                         print_0xhex(PRINT_ANY,
 287                                     "label",
 288                                     "flowlabel %#x ",
 289                                     ntohl(label));
 290         }
 291
 292         if (tb[IFLA_GENEVE_PORT])
 293                 print_uint(PRINT_ANY,
 294                            "port",
 295                            "dstport %u ",
 296                            rta_getattr_be16(tb[IFLA_GENEVE_PORT]));
 297
 298         if (tb[IFLA_GENEVE_COLLECT_METADATA])
 299                 print_bool(PRINT_ANY, "collect_metadata", "external ", true);
 300
 301         if (tb[IFLA_GENEVE_UDP_CSUM]) {
 302                 if (is_json_context()) {
 303                         print_bool(PRINT_JSON,
 304                                    "udp_csum",
 305                                    NULL,
 306                                    rta_getattr_u8(tb[IFLA_GENEVE_UDP_CSUM]));
 307                 } else {
 308                         if (!rta_getattr_u8(tb[IFLA_GENEVE_UDP_CSUM]))
 309                                 fputs("no", f);
 310                         fputs("udpcsum ", f);
 311                 }
 312         }
 313
 314         if (tb[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]) {
 315                 if (is_json_context()) {
 316                         print_bool(PRINT_JSON,
 317                                    "udp_zero_csum6_tx",
 318                                    NULL,
 319                                    rta_getattr_u8(tb[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]));
 320                 } else {
 321                         if (!rta_getattr_u8(tb[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]))
 322                                 fputs("no", f);
 323                         fputs("udp6zerocsumtx ", f);
 324                 }
 325         }
 326
 327         if (tb[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]) {
 328                 if (is_json_context()) {
 329                         print_bool(PRINT_JSON,
 330                                    "udp_zero_csum6_rx",
 331                                    NULL,
 332                                    rta_getattr_u8(tb[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]));
 333                 } else {
 334                         if (!rta_getattr_u8(tb[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]))
 335                                 fputs("no", f);
 336                         fputs("udp6zerocsumrx ", f);
 337                 }
 338         }
 339 }
 340
 341 static void geneve_print_help(struct link_util *lu, int argc, char **argv,
 342         FILE *f)
 343 {
 344         print_explain(f);
 345 }
 346
 347 struct link_util geneve_link_util = {
 348         .id             = "geneve",
 349         .maxattr        = IFLA_GENEVE_MAX,
 350         .parse_opt      = geneve_parse_opt,
 351         .print_opt      = geneve_print_opt,
 352         .print_help     = geneve_print_help,
 353 };