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