bridge/fdb.c

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Get/set/delete fdb table with netlink
   4  *
   5  * TODO: merge/replace this with ip neighbour
   6  *
   7  * Authors:     Stephen Hemminger <shemminger@vyatta.com>
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <netdb.h>
  14 #include <time.h>
  15 #include <fcntl.h>
  16 #include <sys/socket.h>
  17 #include <sys/time.h>
  18 #include <net/if.h>
  19 #include <netinet/in.h>
  20 #include <linux/if_bridge.h>
  21 #include <linux/if_ether.h>
  22 #include <linux/neighbour.h>
  23 #include <string.h>
  24 #include <limits.h>
  25 #include <stdbool.h>
  26
  27 #include "json_print.h"
  28 #include "libnetlink.h"
  29 #include "br_common.h"
  30 #include "rt_names.h"
  31 #include "utils.h"
  32
  33 static unsigned int filter_index, filter_vlan, filter_state, filter_master;
  34
  35 static void usage(void)
  36 {
  37         fprintf(stderr,
  38                 "Usage: bridge fdb { add | append | del | replace } ADDR dev DEV\n"
  39                 "              [ self ] [ master ] [ use ] [ router ] [ extern_learn ]\n"
  40                 "              [ sticky ] [ local | static | dynamic ] [ dst IPADDR ]\n"
  41                 "              [ vlan VID ] [ port PORT] [ vni VNI ] [ via DEV ]\n"
  42                 "              [ src_vni VNI ]\n"
  43                 "       bridge fdb [ show [ br BRDEV ] [ brport DEV ] [ vlan VID ] [ state STATE ] ]\n");
  44         exit(-1);
  45 }
  46
  47 static const char *state_n2a(unsigned int s)
  48 {
  49         static char buf[32];
  50
  51         if (s & NUD_PERMANENT)
  52                 return "permanent";
  53
  54         if (s & NUD_NOARP)
  55                 return "static";
  56
  57         if (s & NUD_STALE)
  58                 return "stale";
  59
  60         if (s & NUD_REACHABLE)
  61                 return "";
  62
  63         sprintf(buf, "state=%#x", s);
  64         return buf;
  65 }
  66
  67 static int state_a2n(unsigned int *s, const char *arg)
  68 {
  69         if (matches(arg, "permanent") == 0)
  70                 *s = NUD_PERMANENT;
  71         else if (matches(arg, "static") == 0 || matches(arg, "temp") == 0)
  72                 *s = NUD_NOARP;
  73         else if (matches(arg, "stale") == 0)
  74                 *s = NUD_STALE;
  75         else if (matches(arg, "reachable") == 0 || matches(arg, "dynamic") == 0)
  76                 *s = NUD_REACHABLE;
  77         else if (strcmp(arg, "all") == 0)
  78                 *s = ~0;
  79         else if (get_unsigned(s, arg, 0))
  80                 return -1;
  81
  82         return 0;
  83 }
  84
  85 static void fdb_print_flags(FILE *fp, unsigned int flags)
  86 {
  87         open_json_array(PRINT_JSON,
  88                         is_json_context() ?  "flags" : "");
  89
  90         if (flags & NTF_SELF)
  91                 print_string(PRINT_ANY, NULL, "%s ", "self");
  92
  93         if (flags & NTF_ROUTER)
  94                 print_string(PRINT_ANY, NULL, "%s ", "router");
  95
  96         if (flags & NTF_EXT_LEARNED)
  97                 print_string(PRINT_ANY, NULL, "%s ", "extern_learn");
  98
  99         if (flags & NTF_OFFLOADED)
 100                 print_string(PRINT_ANY, NULL, "%s ", "offload");
 101
 102         if (flags & NTF_MASTER)
 103                 print_string(PRINT_ANY, NULL, "%s ", "master");
 104
 105         if (flags & NTF_STICKY)
 106                 print_string(PRINT_ANY, NULL, "%s ", "sticky");
 107
 108         close_json_array(PRINT_JSON, NULL);
 109 }
 110
 111 static void fdb_print_stats(FILE *fp, const struct nda_cacheinfo *ci)
 112 {
 113         static int hz;
 114
 115         if (!hz)
 116                 hz = get_user_hz();
 117
 118         if (is_json_context()) {
 119                 print_uint(PRINT_JSON, "used", NULL,
 120                                  ci->ndm_used / hz);
 121                 print_uint(PRINT_JSON, "updated", NULL,
 122                                 ci->ndm_updated / hz);
 123         } else {
 124                 fprintf(fp, "used %d/%d ", ci->ndm_used / hz,
 125                                         ci->ndm_updated / hz);
 126
 127         }
 128 }
 129
 130 int print_fdb(struct nlmsghdr *n, void *arg)
 131 {
 132         FILE *fp = arg;
 133         struct ndmsg *r = NLMSG_DATA(n);
 134         int len = n->nlmsg_len;
 135         struct rtattr *tb[NDA_MAX+1];
 136         __u16 vid = 0;
 137
 138         if (n->nlmsg_type != RTM_NEWNEIGH && n->nlmsg_type != RTM_DELNEIGH) {
 139                 fprintf(stderr, "Not RTM_NEWNEIGH: %08x %08x %08x\n",
 140                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
 141                 return 0;
 142         }
 143
 144         len -= NLMSG_LENGTH(sizeof(*r));
 145         if (len < 0) {
 146                 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
 147                 return -1;
 148         }
 149
 150         if (r->ndm_family != AF_BRIDGE)
 151                 return 0;
 152
 153         if (filter_index && filter_index != r->ndm_ifindex)
 154                 return 0;
 155
 156         if (filter_state && !(r->ndm_state & filter_state))
 157                 return 0;
 158
 159         parse_rtattr(tb, NDA_MAX, NDA_RTA(r),
 160                      n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
 161
 162         if (tb[NDA_VLAN])
 163                 vid = rta_getattr_u16(tb[NDA_VLAN]);
 164
 165         if (filter_vlan && filter_vlan != vid)
 166                 return 0;
 167
 168         open_json_object(NULL);
 169         if (n->nlmsg_type == RTM_DELNEIGH)
 170                 print_bool(PRINT_ANY, "deleted", "Deleted ", true);
 171
 172         if (tb[NDA_LLADDR]) {
 173                 const char *lladdr;
 174                 SPRINT_BUF(b1);
 175
 176                 lladdr = ll_addr_n2a(RTA_DATA(tb[NDA_LLADDR]),
 177                                      RTA_PAYLOAD(tb[NDA_LLADDR]),
 178                                      ll_index_to_type(r->ndm_ifindex),
 179                                      b1, sizeof(b1));
 180
 181                 print_color_string(PRINT_ANY, COLOR_MAC,
 182                                    "mac", "%s ", lladdr);
 183         }
 184
 185         if (!filter_index && r->ndm_ifindex)
 186                 print_color_string(PRINT_ANY, COLOR_IFNAME,
 187                                    "ifname", "dev %s ",
 188                                    ll_index_to_name(r->ndm_ifindex));
 189
 190         if (tb[NDA_DST]) {
 191                 int family = AF_INET;
 192                 const char *dst;
 193
 194                 if (RTA_PAYLOAD(tb[NDA_DST]) == sizeof(struct in6_addr))
 195                         family = AF_INET6;
 196
 197                 dst = format_host(family,
 198                                   RTA_PAYLOAD(tb[NDA_DST]),
 199                                   RTA_DATA(tb[NDA_DST]));
 200
 201                 print_color_string(PRINT_ANY,
 202                                    ifa_family_color(family),
 203                                     "dst", "dst %s ", dst);
 204         }
 205
 206         if (vid)
 207                 print_uint(PRINT_ANY,
 208                                  "vlan", "vlan %hu ", vid);
 209
 210         if (tb[NDA_PORT])
 211                 print_uint(PRINT_ANY,
 212                                  "port", "port %u ",
 213                                  rta_getattr_be16(tb[NDA_PORT]));
 214
 215         if (tb[NDA_VNI])
 216                 print_uint(PRINT_ANY,
 217                                  "vni", "vni %u ",
 218                                  rta_getattr_u32(tb[NDA_VNI]));
 219
 220         if (tb[NDA_SRC_VNI])
 221                 print_uint(PRINT_ANY,
 222                                  "src_vni", "src_vni %u ",
 223                                 rta_getattr_u32(tb[NDA_SRC_VNI]));
 224
 225         if (tb[NDA_IFINDEX]) {
 226                 unsigned int ifindex = rta_getattr_u32(tb[NDA_IFINDEX]);
 227
 228                 if (tb[NDA_LINK_NETNSID])
 229                         print_uint(PRINT_ANY,
 230                                          "viaIfIndex", "via ifindex %u ",
 231                                          ifindex);
 232                 else
 233                         print_string(PRINT_ANY,
 234                                            "viaIf", "via %s ",
 235                                            ll_index_to_name(ifindex));
 236         }
 237
 238         if (tb[NDA_LINK_NETNSID])
 239                 print_uint(PRINT_ANY,
 240                                  "linkNetNsId", "link-netnsid %d ",
 241                                  rta_getattr_u32(tb[NDA_LINK_NETNSID]));
 242
 243         if (show_stats && tb[NDA_CACHEINFO])
 244                 fdb_print_stats(fp, RTA_DATA(tb[NDA_CACHEINFO]));
 245
 246         fdb_print_flags(fp, r->ndm_flags);
 247
 248
 249         if (tb[NDA_MASTER])
 250                 print_string(PRINT_ANY, "master", "master %s ",
 251                              ll_index_to_name(rta_getattr_u32(tb[NDA_MASTER])));
 252
 253         print_string(PRINT_ANY, "state", "%s\n",
 254                            state_n2a(r->ndm_state));
 255         close_json_object();
 256         fflush(fp);
 257         return 0;
 258 }
 259
 260 static int fdb_linkdump_filter(struct nlmsghdr *nlh, int reqlen)
 261 {
 262         int err;
 263
 264         if (filter_index) {
 265                 struct ifinfomsg *ifm = NLMSG_DATA(nlh);
 266
 267                 ifm->ifi_index = filter_index;
 268         }
 269
 270         if (filter_master) {
 271                 err = addattr32(nlh, reqlen, IFLA_MASTER, filter_master);
 272                 if (err)
 273                         return err;
 274         }
 275
 276         return 0;
 277 }
 278
 279 static int fdb_dump_filter(struct nlmsghdr *nlh, int reqlen)
 280 {
 281         int err;
 282
 283         if (filter_index) {
 284                 struct ndmsg *ndm = NLMSG_DATA(nlh);
 285
 286                 ndm->ndm_ifindex = filter_index;
 287         }
 288
 289         if (filter_master) {
 290                 err = addattr32(nlh, reqlen, NDA_MASTER, filter_master);
 291                 if (err)
 292                         return err;
 293         }
 294
 295         return 0;
 296 }
 297
 298 static int fdb_show(int argc, char **argv)
 299 {
 300         char *filter_dev = NULL;
 301         char *br = NULL;
 302         int rc;
 303
 304         while (argc > 0) {
 305                 if ((strcmp(*argv, "brport") == 0) || strcmp(*argv, "dev") == 0) {
 306                         NEXT_ARG();
 307                         filter_dev = *argv;
 308                 } else if (strcmp(*argv, "br") == 0) {
 309                         NEXT_ARG();
 310                         br = *argv;
 311                 } else if (strcmp(*argv, "vlan") == 0) {
 312                         NEXT_ARG();
 313                         if (filter_vlan)
 314                                 duparg("vlan", *argv);
 315                         filter_vlan = atoi(*argv);
 316                 } else if (strcmp(*argv, "state") == 0) {
 317                         unsigned int state;
 318
 319                         NEXT_ARG();
 320                         if (state_a2n(&state, *argv))
 321                                 invarg("invalid state", *argv);
 322                         filter_state |= state;
 323                 } else {
 324                         if (matches(*argv, "help") == 0)
 325                                 usage();
 326                 }
 327                 argc--; argv++;
 328         }
 329
 330         if (br) {
 331                 int br_ifindex = ll_name_to_index(br);
 332
 333                 if (br_ifindex == 0) {
 334                         fprintf(stderr, "Cannot find bridge device \"%s\"\n", br);
 335                         return -1;
 336                 }
 337                 filter_master = br_ifindex;
 338         }
 339
 340         /*we'll keep around filter_dev for older kernels */
 341         if (filter_dev) {
 342                 filter_index = ll_name_to_index(filter_dev);
 343                 if (!filter_index)
 344                         return nodev(filter_dev);
 345         }
 346
 347         if (rth.flags & RTNL_HANDLE_F_STRICT_CHK)
 348                 rc = rtnl_neighdump_req(&rth, PF_BRIDGE, fdb_dump_filter);
 349         else
 350                 rc = rtnl_fdb_linkdump_req_filter_fn(&rth, fdb_linkdump_filter);
 351         if (rc < 0) {
 352                 perror("Cannot send dump request");
 353                 exit(1);
 354         }
 355
 356         new_json_obj(json);
 357         if (rtnl_dump_filter(&rth, print_fdb, stdout) < 0) {
 358                 fprintf(stderr, "Dump terminated\n");
 359                 exit(1);
 360         }
 361         delete_json_obj();
 362         fflush(stdout);
 363
 364         return 0;
 365 }
 366
 367 static int fdb_modify(int cmd, int flags, int argc, char **argv)
 368 {
 369         struct {
 370                 struct nlmsghdr n;
 371                 struct ndmsg            ndm;
 372                 char                    buf[256];
 373         } req = {
 374                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
 375                 .n.nlmsg_flags = NLM_F_REQUEST | flags,
 376                 .n.nlmsg_type = cmd,
 377                 .ndm.ndm_family = PF_BRIDGE,
 378                 .ndm.ndm_state = NUD_NOARP,
 379         };
 380         char *addr = NULL;
 381         char *d = NULL;
 382         char abuf[ETH_ALEN];
 383         int dst_ok = 0;
 384         inet_prefix dst;
 385         unsigned long port = 0;
 386         unsigned long vni = ~0;
 387         unsigned long src_vni = ~0;
 388         unsigned int via = 0;
 389         char *endptr;
 390         short vid = -1;
 391
 392         while (argc > 0) {
 393                 if (strcmp(*argv, "dev") == 0) {
 394                         NEXT_ARG();
 395                         d = *argv;
 396                 } else if (strcmp(*argv, "dst") == 0) {
 397                         NEXT_ARG();
 398                         if (dst_ok)
 399                                 duparg2("dst", *argv);
 400                         get_addr(&dst, *argv, preferred_family);
 401                         dst_ok = 1;
 402                 } else if (strcmp(*argv, "port") == 0) {
 403
 404                         NEXT_ARG();
 405                         port = strtoul(*argv, &endptr, 0);
 406                         if (endptr && *endptr) {
 407                                 struct servent *pse;
 408
 409                                 pse = getservbyname(*argv, "udp");
 410                                 if (!pse)
 411                                         invarg("invalid port\n", *argv);
 412                                 port = ntohs(pse->s_port);
 413                         } else if (port > 0xffff)
 414                                 invarg("invalid port\n", *argv);
 415                 } else if (strcmp(*argv, "vni") == 0) {
 416                         NEXT_ARG();
 417                         vni = strtoul(*argv, &endptr, 0);
 418                         if ((endptr && *endptr) ||
 419                             (vni >> 24) || vni == ULONG_MAX)
 420                                 invarg("invalid VNI\n", *argv);
 421                 } else if (strcmp(*argv, "src_vni") == 0) {
 422                         NEXT_ARG();
 423                         src_vni = strtoul(*argv, &endptr, 0);
 424                         if ((endptr && *endptr) ||
 425                             (src_vni >> 24) || src_vni == ULONG_MAX)
 426                                 invarg("invalid src VNI\n", *argv);
 427                 } else if (strcmp(*argv, "via") == 0) {
 428                         NEXT_ARG();
 429                         via = ll_name_to_index(*argv);
 430                         if (!via)
 431                                 exit(nodev(*argv));
 432                 } else if (strcmp(*argv, "self") == 0) {
 433                         req.ndm.ndm_flags |= NTF_SELF;
 434                 } else if (matches(*argv, "master") == 0) {
 435                         req.ndm.ndm_flags |= NTF_MASTER;
 436                 } else if (matches(*argv, "router") == 0) {
 437                         req.ndm.ndm_flags |= NTF_ROUTER;
 438                 } else if (matches(*argv, "local") == 0 ||
 439                            matches(*argv, "permanent") == 0) {
 440                         req.ndm.ndm_state |= NUD_PERMANENT;
 441                 } else if (matches(*argv, "temp") == 0 ||
 442                            matches(*argv, "static") == 0) {
 443                         req.ndm.ndm_state |= NUD_REACHABLE;
 444                 } else if (matches(*argv, "dynamic") == 0) {
 445                         req.ndm.ndm_state |= NUD_REACHABLE;
 446                         req.ndm.ndm_state &= ~NUD_NOARP;
 447                 } else if (matches(*argv, "vlan") == 0) {
 448                         if (vid >= 0)
 449                                 duparg2("vlan", *argv);
 450                         NEXT_ARG();
 451                         vid = atoi(*argv);
 452                 } else if (matches(*argv, "use") == 0) {
 453                         req.ndm.ndm_flags |= NTF_USE;
 454                 } else if (matches(*argv, "extern_learn") == 0) {
 455                         req.ndm.ndm_flags |= NTF_EXT_LEARNED;
 456                 } else if (matches(*argv, "sticky") == 0) {
 457                         req.ndm.ndm_flags |= NTF_STICKY;
 458                 } else {
 459                         if (strcmp(*argv, "to") == 0)
 460                                 NEXT_ARG();
 461
 462                         if (matches(*argv, "help") == 0)
 463                                 usage();
 464                         if (addr)
 465                                 duparg2("to", *argv);
 466                         addr = *argv;
 467                 }
 468                 argc--; argv++;
 469         }
 470
 471         if (d == NULL || addr == NULL) {
 472                 fprintf(stderr, "Device and address are required arguments.\n");
 473                 return -1;
 474         }
 475
 476         /* Assume self */
 477         if (!(req.ndm.ndm_flags&(NTF_SELF|NTF_MASTER)))
 478                 req.ndm.ndm_flags |= NTF_SELF;
 479
 480         /* Assume permanent */
 481         if (!(req.ndm.ndm_state&(NUD_PERMANENT|NUD_REACHABLE)))
 482                 req.ndm.ndm_state |= NUD_PERMANENT;
 483
 484         if (sscanf(addr, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
 485                    abuf, abuf+1, abuf+2,
 486                    abuf+3, abuf+4, abuf+5) != 6) {
 487                 fprintf(stderr, "Invalid mac address %s\n", addr);
 488                 return -1;
 489         }
 490
 491         addattr_l(&req.n, sizeof(req), NDA_LLADDR, abuf, ETH_ALEN);
 492         if (dst_ok)
 493                 addattr_l(&req.n, sizeof(req), NDA_DST, &dst.data, dst.bytelen);
 494
 495         if (vid >= 0)
 496                 addattr16(&req.n, sizeof(req), NDA_VLAN, vid);
 497
 498         if (port) {
 499                 unsigned short dport;
 500
 501                 dport = htons((unsigned short)port);
 502                 addattr16(&req.n, sizeof(req), NDA_PORT, dport);
 503         }
 504         if (vni != ~0)
 505                 addattr32(&req.n, sizeof(req), NDA_VNI, vni);
 506         if (src_vni != ~0)
 507                 addattr32(&req.n, sizeof(req), NDA_SRC_VNI, src_vni);
 508         if (via)
 509                 addattr32(&req.n, sizeof(req), NDA_IFINDEX, via);
 510
 511         req.ndm.ndm_ifindex = ll_name_to_index(d);
 512         if (!req.ndm.ndm_ifindex)
 513                 return nodev(d);
 514
 515         if (rtnl_talk(&rth, &req.n, NULL) < 0)
 516                 return -1;
 517
 518         return 0;
 519 }
 520
 521 int do_fdb(int argc, char **argv)
 522 {
 523         ll_init_map(&rth);
 524
 525         if (argc > 0) {
 526                 if (matches(*argv, "add") == 0)
 527                         return fdb_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_EXCL, argc-1, argv+1);
 528                 if (matches(*argv, "append") == 0)
 529                         return fdb_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_APPEND, argc-1, argv+1);
 530                 if (matches(*argv, "replace") == 0)
 531                         return fdb_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_REPLACE, argc-1, argv+1);
 532                 if (matches(*argv, "delete") == 0)
 533                         return fdb_modify(RTM_DELNEIGH, 0, argc-1, argv+1);
 534                 if (matches(*argv, "show") == 0 ||
 535                     matches(*argv, "lst") == 0 ||
 536                     matches(*argv, "list") == 0)
 537                         return fdb_show(argc-1, argv+1);
 538                 if (matches(*argv, "help") == 0)
 539                         usage();
 540         } else
 541                 return fdb_show(0, NULL);
 542
 543         fprintf(stderr, "Command \"%s\" is unknown, try \"bridge fdb help\".\n", *argv);
 544         exit(-1);
 545 }