ip/iplink_vxlan.c

   1 /*
   2  * iplink_vxlan.c       VXLAN 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:     Stephen Hemminger <shemminger@vyatta.com
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <net/if.h>
  16 #include <linux/ip.h>
  17 #include <linux/if_link.h>
  18 #include <arpa/inet.h>
  19
  20 #include "rt_names.h"
  21 #include "utils.h"
  22 #include "ip_common.h"
  23
  24 #define VXLAN_ATTRSET(attrs, type) (((attrs) & (1L << (type))) != 0)
  25
  26 static void print_explain(FILE *f)
  27 {
  28         fprintf(f,
  29                 "Usage: ... vxlan id VNI\n"
  30                 "                 [ { group | remote } IP_ADDRESS ]\n"
  31                 "                 [ local ADDR ]\n"
  32                 "                 [ ttl TTL ]\n"
  33                 "                 [ tos TOS ]\n"
  34                 "                 [ flowlabel LABEL ]\n"
  35                 "                 [ dev PHYS_DEV ]\n"
  36                 "                 [ dstport PORT ]\n"
  37                 "                 [ srcport MIN MAX ]\n"
  38                 "                 [ [no]learning ]\n"
  39                 "                 [ [no]proxy ]\n"
  40                 "                 [ [no]rsc ]\n"
  41                 "                 [ [no]l2miss ]\n"
  42                 "                 [ [no]l3miss ]\n"
  43                 "                 [ ageing SECONDS ]\n"
  44                 "                 [ maxaddress NUMBER ]\n"
  45                 "                 [ [no]udpcsum ]\n"
  46                 "                 [ [no]udp6zerocsumtx ]\n"
  47                 "                 [ [no]udp6zerocsumrx ]\n"
  48                 "                 [ [no]remcsumtx ] [ [no]remcsumrx ]\n"
  49                 "                 [ [no]external ] [ gbp ] [ gpe ]\n"
  50                 "\n"
  51                 "Where: VNI   := 0-16777215\n"
  52                 "       ADDR  := { IP_ADDRESS | any }\n"
  53                 "       TOS   := { NUMBER | inherit }\n"
  54                 "       TTL   := { 1..255 | inherit }\n"
  55                 "       LABEL := 0-1048575\n"
  56         );
  57 }
  58
  59 static void explain(void)
  60 {
  61         print_explain(stderr);
  62 }
  63
  64 static void check_duparg(__u64 *attrs, int type, const char *key,
  65                          const char *argv)
  66 {
  67         if (!VXLAN_ATTRSET(*attrs, type)) {
  68                 *attrs |= (1L << type);
  69                 return;
  70         }
  71         duparg2(key, argv);
  72 }
  73
  74 static int vxlan_parse_opt(struct link_util *lu, int argc, char **argv,
  75                           struct nlmsghdr *n)
  76 {
  77         inet_prefix saddr, daddr;
  78         __u32 vni = 0;
  79         __u8 learning = 1;
  80         __u16 dstport = 0;
  81         __u8 metadata = 0;
  82         __u64 attrs = 0;
  83         bool set_op = (n->nlmsg_type == RTM_NEWLINK &&
  84                        !(n->nlmsg_flags & NLM_F_CREATE));
  85
  86         saddr.family = daddr.family = AF_UNSPEC;
  87
  88         inet_prefix_reset(&saddr);
  89         inet_prefix_reset(&daddr);
  90
  91         while (argc > 0) {
  92                 if (!matches(*argv, "id") ||
  93                     !matches(*argv, "vni")) {
  94                         /* We will add ID attribute outside of the loop since we
  95                          * need to consider metadata information as well.
  96                          */
  97                         NEXT_ARG();
  98                         check_duparg(&attrs, IFLA_VXLAN_ID, "id", *argv);
  99                         if (get_u32(&vni, *argv, 0) ||
 100                             vni >= 1u << 24)
 101                                 invarg("invalid id", *argv);
 102                 } else if (!matches(*argv, "group")) {
 103                         if (is_addrtype_inet_not_multi(&daddr)) {
 104                                 fprintf(stderr, "vxlan: both group and remote");
 105                                 fprintf(stderr, " cannot be specified\n");
 106                                 return -1;
 107                         }
 108                         NEXT_ARG();
 109                         check_duparg(&attrs, IFLA_VXLAN_GROUP, "group", *argv);
 110                         get_addr(&daddr, *argv, saddr.family);
 111                         if (!is_addrtype_inet_multi(&daddr))
 112                                 invarg("invalid group address", *argv);
 113                 } else if (!matches(*argv, "remote")) {
 114                         if (is_addrtype_inet_multi(&daddr)) {
 115                                 fprintf(stderr, "vxlan: both group and remote");
 116                                 fprintf(stderr, " cannot be specified\n");
 117                                 return -1;
 118                         }
 119                         NEXT_ARG();
 120                         check_duparg(&attrs, IFLA_VXLAN_GROUP, "remote", *argv);
 121                         get_addr(&daddr, *argv, saddr.family);
 122                         if (!is_addrtype_inet_not_multi(&daddr))
 123                                 invarg("invalid remote address", *argv);
 124                 } else if (!matches(*argv, "local")) {
 125                         NEXT_ARG();
 126                         check_duparg(&attrs, IFLA_VXLAN_LOCAL, "local", *argv);
 127                         get_addr(&saddr, *argv, daddr.family);
 128                         if (!is_addrtype_inet_not_multi(&saddr))
 129                                 invarg("invalid local address", *argv);
 130                 } else if (!matches(*argv, "dev")) {
 131                         unsigned int link;
 132
 133                         NEXT_ARG();
 134                         check_duparg(&attrs, IFLA_VXLAN_LINK, "dev", *argv);
 135                         link = ll_name_to_index(*argv);
 136                         if (link == 0) {
 137                                 fprintf(stderr, "Cannot find device \"%s\"\n",
 138                                         *argv);
 139                                 exit(-1);
 140                         }
 141                         addattr32(n, 1024, IFLA_VXLAN_LINK, link);
 142                 } else if (!matches(*argv, "ttl") ||
 143                            !matches(*argv, "hoplimit")) {
 144                         unsigned int uval;
 145                         __u8 ttl = 0;
 146
 147                         NEXT_ARG();
 148                         check_duparg(&attrs, IFLA_VXLAN_TTL, "ttl", *argv);
 149                         if (strcmp(*argv, "inherit") != 0) {
 150                                 if (get_unsigned(&uval, *argv, 0))
 151                                         invarg("invalid TTL", *argv);
 152                                 if (uval > 255)
 153                                         invarg("TTL must be <= 255", *argv);
 154                                 ttl = uval;
 155                         }
 156                         addattr8(n, 1024, IFLA_VXLAN_TTL, ttl);
 157                 } else if (!matches(*argv, "tos") ||
 158                            !matches(*argv, "dsfield")) {
 159                         __u32 uval;
 160                         __u8 tos;
 161
 162                         NEXT_ARG();
 163                         check_duparg(&attrs, IFLA_VXLAN_TOS, "tos", *argv);
 164                         if (strcmp(*argv, "inherit") != 0) {
 165                                 if (rtnl_dsfield_a2n(&uval, *argv))
 166                                         invarg("bad TOS value", *argv);
 167                                 tos = uval;
 168                         } else
 169                                 tos = 1;
 170                         addattr8(n, 1024, IFLA_VXLAN_TOS, tos);
 171                 } else if (!matches(*argv, "label") ||
 172                            !matches(*argv, "flowlabel")) {
 173                         __u32 uval;
 174
 175                         NEXT_ARG();
 176                         check_duparg(&attrs, IFLA_VXLAN_LABEL, "flowlabel",
 177                                      *argv);
 178                         if (get_u32(&uval, *argv, 0) ||
 179                             (uval & ~LABEL_MAX_MASK))
 180                                 invarg("invalid flowlabel", *argv);
 181                         addattr32(n, 1024, IFLA_VXLAN_LABEL, htonl(uval));
 182                 } else if (!matches(*argv, "ageing")) {
 183                         __u32 age;
 184
 185                         NEXT_ARG();
 186                         check_duparg(&attrs, IFLA_VXLAN_AGEING, "ageing",
 187                                      *argv);
 188                         if (strcmp(*argv, "none") == 0)
 189                                 age = 0;
 190                         else if (get_u32(&age, *argv, 0))
 191                                 invarg("ageing timer", *argv);
 192                         addattr32(n, 1024, IFLA_VXLAN_AGEING, age);
 193                 } else if (!matches(*argv, "maxaddress")) {
 194                         __u32 maxaddr;
 195
 196                         NEXT_ARG();
 197                         check_duparg(&attrs, IFLA_VXLAN_LIMIT,
 198                                      "maxaddress", *argv);
 199                         if (strcmp(*argv, "unlimited") == 0)
 200                                 maxaddr = 0;
 201                         else if (get_u32(&maxaddr, *argv, 0))
 202                                 invarg("max addresses", *argv);
 203                         addattr32(n, 1024, IFLA_VXLAN_LIMIT, maxaddr);
 204                 } else if (!matches(*argv, "port") ||
 205                            !matches(*argv, "srcport")) {
 206                         struct ifla_vxlan_port_range range = { 0, 0 };
 207
 208                         NEXT_ARG();
 209                         check_duparg(&attrs, IFLA_VXLAN_PORT_RANGE, "srcport",
 210                                      *argv);
 211                         if (get_be16(&range.low, *argv, 0))
 212                                 invarg("min port", *argv);
 213                         NEXT_ARG();
 214                         if (get_be16(&range.high, *argv, 0))
 215                                 invarg("max port", *argv);
 216                         if (range.low || range.high) {
 217                                 addattr_l(n, 1024, IFLA_VXLAN_PORT_RANGE,
 218                                           &range, sizeof(range));
 219                         }
 220                 } else if (!matches(*argv, "dstport")) {
 221                         NEXT_ARG();
 222                         check_duparg(&attrs, IFLA_VXLAN_PORT, "dstport", *argv);
 223                         if (get_u16(&dstport, *argv, 0))
 224                                 invarg("dst port", *argv);
 225                 } else if (!matches(*argv, "nolearning")) {
 226                         check_duparg(&attrs, IFLA_VXLAN_LEARNING, *argv, *argv);
 227                         learning = 0;
 228                 } else if (!matches(*argv, "learning")) {
 229                         check_duparg(&attrs, IFLA_VXLAN_LEARNING, *argv, *argv);
 230                         learning = 1;
 231                 } else if (!matches(*argv, "noproxy")) {
 232                         check_duparg(&attrs, IFLA_VXLAN_PROXY, *argv, *argv);
 233                         addattr8(n, 1024, IFLA_VXLAN_PROXY, 0);
 234                 } else if (!matches(*argv, "proxy")) {
 235                         check_duparg(&attrs, IFLA_VXLAN_PROXY, *argv, *argv);
 236                         addattr8(n, 1024, IFLA_VXLAN_PROXY, 1);
 237                 } else if (!matches(*argv, "norsc")) {
 238                         check_duparg(&attrs, IFLA_VXLAN_RSC, *argv, *argv);
 239                         addattr8(n, 1024, IFLA_VXLAN_RSC, 0);
 240                 } else if (!matches(*argv, "rsc")) {
 241                         check_duparg(&attrs, IFLA_VXLAN_RSC, *argv, *argv);
 242                         addattr8(n, 1024, IFLA_VXLAN_RSC, 1);
 243                 } else if (!matches(*argv, "nol2miss")) {
 244                         check_duparg(&attrs, IFLA_VXLAN_L2MISS, *argv, *argv);
 245                         addattr8(n, 1024, IFLA_VXLAN_L2MISS, 0);
 246                 } else if (!matches(*argv, "l2miss")) {
 247                         check_duparg(&attrs, IFLA_VXLAN_L2MISS, *argv, *argv);
 248                         addattr8(n, 1024, IFLA_VXLAN_L2MISS, 1);
 249                 } else if (!matches(*argv, "nol3miss")) {
 250                         check_duparg(&attrs, IFLA_VXLAN_L3MISS, *argv, *argv);
 251                         addattr8(n, 1024, IFLA_VXLAN_L3MISS, 0);
 252                 } else if (!matches(*argv, "l3miss")) {
 253                         check_duparg(&attrs, IFLA_VXLAN_L3MISS, *argv, *argv);
 254                         addattr8(n, 1024, IFLA_VXLAN_L3MISS, 1);
 255                 } else if (!matches(*argv, "udpcsum")) {
 256                         check_duparg(&attrs, IFLA_VXLAN_UDP_CSUM, *argv, *argv);
 257                         addattr8(n, 1024, IFLA_VXLAN_UDP_CSUM, 1);
 258                 } else if (!matches(*argv, "noudpcsum")) {
 259                         check_duparg(&attrs, IFLA_VXLAN_UDP_CSUM, *argv, *argv);
 260                         addattr8(n, 1024, IFLA_VXLAN_UDP_CSUM, 0);
 261                 } else if (!matches(*argv, "udp6zerocsumtx")) {
 262                         check_duparg(&attrs, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,
 263                                      *argv, *argv);
 264                         addattr8(n, 1024, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, 1);
 265                 } else if (!matches(*argv, "noudp6zerocsumtx")) {
 266                         check_duparg(&attrs, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,
 267                                      *argv, *argv);
 268                         addattr8(n, 1024, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, 0);
 269                 } else if (!matches(*argv, "udp6zerocsumrx")) {
 270                         check_duparg(&attrs, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,
 271                                      *argv, *argv);
 272                         addattr8(n, 1024, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, 1);
 273                 } else if (!matches(*argv, "noudp6zerocsumrx")) {
 274                         check_duparg(&attrs, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,
 275                                      *argv, *argv);
 276                         addattr8(n, 1024, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, 0);
 277                 } else if (!matches(*argv, "remcsumtx")) {
 278                         check_duparg(&attrs, IFLA_VXLAN_REMCSUM_TX,
 279                                      *argv, *argv);
 280                         addattr8(n, 1024, IFLA_VXLAN_REMCSUM_TX, 1);
 281                 } else if (!matches(*argv, "noremcsumtx")) {
 282                         check_duparg(&attrs, IFLA_VXLAN_REMCSUM_TX,
 283                                      *argv, *argv);
 284                         addattr8(n, 1024, IFLA_VXLAN_REMCSUM_TX, 0);
 285                 } else if (!matches(*argv, "remcsumrx")) {
 286                         check_duparg(&attrs, IFLA_VXLAN_REMCSUM_RX,
 287                                      *argv, *argv);
 288                         addattr8(n, 1024, IFLA_VXLAN_REMCSUM_RX, 1);
 289                 } else if (!matches(*argv, "noremcsumrx")) {
 290                         check_duparg(&attrs, IFLA_VXLAN_REMCSUM_RX,
 291                                      *argv, *argv);
 292                         addattr8(n, 1024, IFLA_VXLAN_REMCSUM_RX, 0);
 293                 } else if (!matches(*argv, "external")) {
 294                         check_duparg(&attrs, IFLA_VXLAN_COLLECT_METADATA,
 295                                      *argv, *argv);
 296                         metadata = 1;
 297                         learning = 0;
 298                         /* we will add LEARNING attribute outside of the loop */
 299                         addattr8(n, 1024, IFLA_VXLAN_COLLECT_METADATA,
 300                                  metadata);
 301                 } else if (!matches(*argv, "noexternal")) {
 302                         check_duparg(&attrs, IFLA_VXLAN_COLLECT_METADATA,
 303                                      *argv, *argv);
 304                         metadata = 0;
 305                         addattr8(n, 1024, IFLA_VXLAN_COLLECT_METADATA,
 306                                  metadata);
 307                 } else if (!matches(*argv, "gbp")) {
 308                         check_duparg(&attrs, IFLA_VXLAN_GBP, *argv, *argv);
 309                         addattr_l(n, 1024, IFLA_VXLAN_GBP, NULL, 0);
 310                 } else if (!matches(*argv, "gpe")) {
 311                         check_duparg(&attrs, IFLA_VXLAN_GPE, *argv, *argv);
 312                         addattr_l(n, 1024, IFLA_VXLAN_GPE, NULL, 0);
 313                 } else if (matches(*argv, "help") == 0) {
 314                         explain();
 315                         return -1;
 316                 } else {
 317                         fprintf(stderr, "vxlan: unknown command \"%s\"?\n", *argv);
 318                         explain();
 319                         return -1;
 320                 }
 321                 argc--, argv++;
 322         }
 323
 324         if (metadata && VXLAN_ATTRSET(attrs, IFLA_VXLAN_ID)) {
 325                 fprintf(stderr, "vxlan: both 'external' and vni cannot be specified\n");
 326                 return -1;
 327         }
 328
 329         if (!metadata && !VXLAN_ATTRSET(attrs, IFLA_VXLAN_ID) && !set_op) {
 330                 fprintf(stderr, "vxlan: missing virtual network identifier\n");
 331                 return -1;
 332         }
 333
 334         if (is_addrtype_inet_multi(&daddr) &&
 335             !VXLAN_ATTRSET(attrs, IFLA_VXLAN_LINK)) {
 336                 fprintf(stderr, "vxlan: 'group' requires 'dev' to be specified\n");
 337                 return -1;
 338         }
 339
 340         if (!VXLAN_ATTRSET(attrs, IFLA_VXLAN_PORT) &&
 341             VXLAN_ATTRSET(attrs, IFLA_VXLAN_GPE)) {
 342                 dstport = 4790;
 343         } else if (!VXLAN_ATTRSET(attrs, IFLA_VXLAN_PORT) && !set_op) {
 344                 fprintf(stderr, "vxlan: destination port not specified\n"
 345                         "Will use Linux kernel default (non-standard value)\n");
 346                 fprintf(stderr,
 347                         "Use 'dstport 4789' to get the IANA assigned value\n"
 348                         "Use 'dstport 0' to get default and quiet this message\n");
 349         }
 350
 351         if (VXLAN_ATTRSET(attrs, IFLA_VXLAN_ID))
 352                 addattr32(n, 1024, IFLA_VXLAN_ID, vni);
 353
 354         if (is_addrtype_inet(&saddr)) {
 355                 int type = (saddr.family == AF_INET) ? IFLA_VXLAN_LOCAL
 356                                                      : IFLA_VXLAN_LOCAL6;
 357                 addattr_l(n, 1024, type, saddr.data, saddr.bytelen);
 358         }
 359
 360         if (is_addrtype_inet(&daddr)) {
 361                 int type = (daddr.family == AF_INET) ? IFLA_VXLAN_GROUP
 362                                                      : IFLA_VXLAN_GROUP6;
 363                 addattr_l(n, 1024, type, daddr.data, daddr.bytelen);
 364         }
 365
 366         if (!set_op || VXLAN_ATTRSET(attrs, IFLA_VXLAN_LEARNING))
 367                 addattr8(n, 1024, IFLA_VXLAN_LEARNING, learning);
 368
 369         if (dstport)
 370                 addattr16(n, 1024, IFLA_VXLAN_PORT, htons(dstport));
 371
 372         return 0;
 373 }
 374
 375 static void vxlan_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 376 {
 377         __u32 vni;
 378         __u8 ttl = 0;
 379         __u8 tos = 0;
 380         __u32 maxaddr;
 381
 382         if (!tb)
 383                 return;
 384
 385         if (tb[IFLA_VXLAN_COLLECT_METADATA] &&
 386             rta_getattr_u8(tb[IFLA_VXLAN_COLLECT_METADATA])) {
 387                 print_bool(PRINT_ANY, "external", "external", true);
 388                 return;
 389         }
 390
 391         if (!tb[IFLA_VXLAN_ID] ||
 392             RTA_PAYLOAD(tb[IFLA_VXLAN_ID]) < sizeof(__u32))
 393                 return;
 394
 395         vni = rta_getattr_u32(tb[IFLA_VXLAN_ID]);
 396         print_uint(PRINT_ANY, "id", "id %u ", vni);
 397
 398         if (tb[IFLA_VXLAN_GROUP]) {
 399                 __be32 addr = rta_getattr_u32(tb[IFLA_VXLAN_GROUP]);
 400
 401                 if (addr) {
 402                         if (IN_MULTICAST(ntohl(addr)))
 403                                 print_string(PRINT_ANY,
 404                                              "group",
 405                                              "group %s ",
 406                                              format_host(AF_INET, 4, &addr));
 407                         else
 408                                 print_string(PRINT_ANY,
 409                                              "remote",
 410                                              "remote %s ",
 411                                              format_host(AF_INET, 4, &addr));
 412                 }
 413         } else if (tb[IFLA_VXLAN_GROUP6]) {
 414                 struct in6_addr addr;
 415
 416                 memcpy(&addr, RTA_DATA(tb[IFLA_VXLAN_GROUP6]), sizeof(struct in6_addr));
 417                 if (!IN6_IS_ADDR_UNSPECIFIED(&addr)) {
 418                         if (IN6_IS_ADDR_MULTICAST(&addr))
 419                                 print_string(PRINT_ANY,
 420                                              "group6",
 421                                              "group %s ",
 422                                              format_host(AF_INET6,
 423                                                          sizeof(struct in6_addr),
 424                                                          &addr));
 425                         else
 426                                 print_string(PRINT_ANY,
 427                                              "remote6",
 428                                              "remote %s ",
 429                                              format_host(AF_INET6,
 430                                                          sizeof(struct in6_addr),
 431                                                          &addr));
 432                 }
 433         }
 434
 435         if (tb[IFLA_VXLAN_LOCAL]) {
 436                 __be32 addr = rta_getattr_u32(tb[IFLA_VXLAN_LOCAL]);
 437
 438                 if (addr)
 439                         print_string(PRINT_ANY,
 440                                      "local",
 441                                      "local %s ",
 442                                      format_host(AF_INET, 4, &addr));
 443         } else if (tb[IFLA_VXLAN_LOCAL6]) {
 444                 struct in6_addr addr;
 445
 446                 memcpy(&addr, RTA_DATA(tb[IFLA_VXLAN_LOCAL6]), sizeof(struct in6_addr));
 447                 if (!IN6_IS_ADDR_UNSPECIFIED(&addr))
 448                         print_string(PRINT_ANY,
 449                                      "local6",
 450                                      "local %s ",
 451                                      format_host(AF_INET6,
 452                                                  sizeof(struct in6_addr),
 453                                                  &addr));
 454         }
 455
 456         if (tb[IFLA_VXLAN_LINK]) {
 457                 unsigned int link = rta_getattr_u32(tb[IFLA_VXLAN_LINK]);
 458
 459                 if (link) {
 460                         print_string(PRINT_ANY, "link", "dev %s ",
 461                                      ll_index_to_name(link));
 462                 }
 463         }
 464
 465         if (tb[IFLA_VXLAN_PORT_RANGE]) {
 466                 const struct ifla_vxlan_port_range *r
 467                         = RTA_DATA(tb[IFLA_VXLAN_PORT_RANGE]);
 468                 if (is_json_context()) {
 469                         open_json_object("port_range");
 470                         print_uint(PRINT_JSON, "low", NULL, ntohs(r->low));
 471                         print_uint(PRINT_JSON, "high", NULL, ntohs(r->high));
 472                         close_json_object();
 473                 } else {
 474                         fprintf(f, "srcport %u %u ",
 475                                 ntohs(r->low), ntohs(r->high));
 476                 }
 477         }
 478
 479         if (tb[IFLA_VXLAN_PORT])
 480                 print_uint(PRINT_ANY,
 481                            "port",
 482                            "dstport %u ",
 483                            rta_getattr_be16(tb[IFLA_VXLAN_PORT]));
 484
 485         if (tb[IFLA_VXLAN_LEARNING]) {
 486                 __u8 learning = rta_getattr_u8(tb[IFLA_VXLAN_LEARNING]);
 487
 488                 print_bool(PRINT_JSON, "learning", NULL, learning);
 489                 if (!learning)
 490                         print_bool(PRINT_FP, NULL, "nolearning ", true);
 491         }
 492
 493         if (tb[IFLA_VXLAN_PROXY] && rta_getattr_u8(tb[IFLA_VXLAN_PROXY]))
 494                 print_bool(PRINT_ANY, "proxy", "proxy ", true);
 495
 496         if (tb[IFLA_VXLAN_RSC] && rta_getattr_u8(tb[IFLA_VXLAN_RSC]))
 497                 print_bool(PRINT_ANY, "rsc", "rsc ", true);
 498
 499         if (tb[IFLA_VXLAN_L2MISS] && rta_getattr_u8(tb[IFLA_VXLAN_L2MISS]))
 500                 print_bool(PRINT_ANY, "l2miss", "l2miss ", true);
 501
 502         if (tb[IFLA_VXLAN_L3MISS] && rta_getattr_u8(tb[IFLA_VXLAN_L3MISS]))
 503                 print_bool(PRINT_ANY, "l3miss", "l3miss ", true);
 504
 505         if (tb[IFLA_VXLAN_TOS])
 506                 tos = rta_getattr_u8(tb[IFLA_VXLAN_TOS]);
 507         if (tos) {
 508                 if (is_json_context() || tos != 1)
 509                         print_0xhex(PRINT_ANY, "tos", "tos 0x%x ", tos);
 510                 else
 511                         print_string(PRINT_FP, NULL, "tos %s ", "inherit");
 512         }
 513
 514         if (tb[IFLA_VXLAN_TTL])
 515                 ttl = rta_getattr_u8(tb[IFLA_VXLAN_TTL]);
 516         if (is_json_context() || ttl)
 517                 print_uint(PRINT_ANY, "ttl", "ttl %u ", ttl);
 518         else
 519                 print_string(PRINT_FP, NULL, "ttl %s ", "inherit");
 520
 521         if (tb[IFLA_VXLAN_LABEL]) {
 522                 __u32 label = rta_getattr_u32(tb[IFLA_VXLAN_LABEL]);
 523
 524                 if (label)
 525                         print_0xhex(PRINT_ANY,
 526                                     "label",
 527                                     "flowlabel %#x ",
 528                                     ntohl(label));
 529         }
 530
 531         if (tb[IFLA_VXLAN_AGEING]) {
 532                 __u32 age = rta_getattr_u32(tb[IFLA_VXLAN_AGEING]);
 533
 534                 if (age == 0)
 535                         print_uint(PRINT_ANY, "ageing", "ageing none ", 0);
 536                 else
 537                         print_uint(PRINT_ANY, "ageing", "ageing %u ", age);
 538         }
 539
 540         if (tb[IFLA_VXLAN_LIMIT] &&
 541             ((maxaddr = rta_getattr_u32(tb[IFLA_VXLAN_LIMIT])) != 0))
 542                 print_uint(PRINT_ANY, "limit", "maxaddr %u ", maxaddr);
 543
 544         if (tb[IFLA_VXLAN_UDP_CSUM]) {
 545                 __u8 udp_csum = rta_getattr_u8(tb[IFLA_VXLAN_UDP_CSUM]);
 546
 547                 if (is_json_context()) {
 548                         print_bool(PRINT_ANY, "udp_csum", NULL, udp_csum);
 549                 } else {
 550                         if (!udp_csum)
 551                                 fputs("no", f);
 552                         fputs("udpcsum ", f);
 553                 }
 554         }
 555
 556         if (tb[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]) {
 557                 __u8 csum6 = rta_getattr_u8(tb[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]);
 558
 559                 if (is_json_context()) {
 560                         print_bool(PRINT_ANY,
 561                                    "udp_zero_csum6_tx", NULL, csum6);
 562                 } else {
 563                         if (!csum6)
 564                                 fputs("no", f);
 565                         fputs("udp6zerocsumtx ", f);
 566                 }
 567         }
 568
 569         if (tb[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]) {
 570                 __u8 csum6 = rta_getattr_u8(tb[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]);
 571
 572                 if (is_json_context()) {
 573                         print_bool(PRINT_ANY,
 574                                    "udp_zero_csum6_rx",
 575                                    NULL,
 576                                    csum6);
 577                 } else {
 578                         if (!csum6)
 579                                 fputs("no", f);
 580                         fputs("udp6zerocsumrx ", f);
 581                 }
 582         }
 583
 584         if (tb[IFLA_VXLAN_REMCSUM_TX] &&
 585             rta_getattr_u8(tb[IFLA_VXLAN_REMCSUM_TX]))
 586                 print_bool(PRINT_ANY, "remcsum_tx", "remcsumtx ", true);
 587
 588         if (tb[IFLA_VXLAN_REMCSUM_RX] &&
 589             rta_getattr_u8(tb[IFLA_VXLAN_REMCSUM_RX]))
 590                 print_bool(PRINT_ANY, "remcsum_rx", "remcsumrx ", true);
 591
 592         if (tb[IFLA_VXLAN_GBP])
 593                 print_bool(PRINT_ANY, "gbp", "gbp ", true);
 594         if (tb[IFLA_VXLAN_GPE])
 595                 print_bool(PRINT_ANY, "gpe", "gpe ", true);
 596 }
 597
 598 static void vxlan_print_help(struct link_util *lu, int argc, char **argv,
 599                              FILE *f)
 600 {
 601         print_explain(f);
 602 }
 603
 604 struct link_util vxlan_link_util = {
 605         .id             = "vxlan",
 606         .maxattr        = IFLA_VXLAN_MAX,
 607         .parse_opt      = vxlan_parse_opt,
 608         .print_opt      = vxlan_print_opt,
 609         .print_help     = vxlan_print_help,
 610 };