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