bridge/mdb.c

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Get mdb table with netlink
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <unistd.h>
   9 #include <fcntl.h>
  10 #include <sys/socket.h>
  11 #include <net/if.h>
  12 #include <netinet/in.h>
  13 #include <linux/if_bridge.h>
  14 #include <linux/if_ether.h>
  15 #include <string.h>
  16 #include <arpa/inet.h>
  17
  18 #include "libnetlink.h"
  19 #include "br_common.h"
  20 #include "rt_names.h"
  21 #include "utils.h"
  22 #include "json_print.h"
  23
  24 #ifndef MDBA_RTA
  25 #define MDBA_RTA(r) \
  26         ((struct rtattr *)(((char *)(r)) + NLMSG_ALIGN(sizeof(struct br_port_msg))))
  27 #endif
  28
  29 static unsigned int filter_index, filter_vlan;
  30
  31 static void usage(void)
  32 {
  33         fprintf(stderr,
  34                 "Usage: bridge mdb { add | del } dev DEV port PORT grp GROUP [permanent | temp] [vid VID]\n"
  35                 "       bridge mdb {show} [ dev DEV ] [ vid VID ]\n");
  36         exit(-1);
  37 }
  38
  39 static bool is_temp_mcast_rtr(__u8 type)
  40 {
  41         return type == MDB_RTR_TYPE_TEMP_QUERY || type == MDB_RTR_TYPE_TEMP;
  42 }
  43
  44 static const char *format_timer(__u32 ticks)
  45 {
  46         struct timeval tv;
  47         static char tbuf[32];
  48
  49         __jiffies_to_tv(&tv, ticks);
  50         snprintf(tbuf, sizeof(tbuf), "%4lu.%.2lu",
  51                  (unsigned long)tv.tv_sec,
  52                  (unsigned long)tv.tv_usec / 10000);
  53
  54         return tbuf;
  55 }
  56
  57 static void __print_router_port_stats(FILE *f, struct rtattr *pattr)
  58 {
  59         struct rtattr *tb[MDBA_ROUTER_PATTR_MAX + 1];
  60
  61         parse_rtattr(tb, MDBA_ROUTER_PATTR_MAX, MDB_RTR_RTA(RTA_DATA(pattr)),
  62                      RTA_PAYLOAD(pattr) - RTA_ALIGN(sizeof(uint32_t)));
  63
  64         if (tb[MDBA_ROUTER_PATTR_TIMER]) {
  65                 __u32 timer = rta_getattr_u32(tb[MDBA_ROUTER_PATTR_TIMER]);
  66
  67                 print_string(PRINT_ANY, "timer", " %s",
  68                              format_timer(timer));
  69         }
  70
  71         if (tb[MDBA_ROUTER_PATTR_TYPE]) {
  72                 __u8 type = rta_getattr_u8(tb[MDBA_ROUTER_PATTR_TYPE]);
  73
  74                 print_string(PRINT_ANY, "type", " %s",
  75                              is_temp_mcast_rtr(type) ? "temp" : "permanent");
  76         }
  77 }
  78
  79 static void br_print_router_ports(FILE *f, struct rtattr *attr,
  80                                   const char *brifname)
  81 {
  82         int rem = RTA_PAYLOAD(attr);
  83         struct rtattr *i;
  84
  85         if (is_json_context())
  86                 open_json_array(PRINT_JSON, brifname);
  87         else if (!show_stats)
  88                 fprintf(f, "router ports on %s: ", brifname);
  89
  90         for (i = RTA_DATA(attr); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
  91                 uint32_t *port_ifindex = RTA_DATA(i);
  92                 const char *port_ifname = ll_index_to_name(*port_ifindex);
  93
  94                 if (is_json_context()) {
  95                         open_json_object(NULL);
  96                         print_string(PRINT_JSON, "port", NULL, port_ifname);
  97
  98                         if (show_stats)
  99                                 __print_router_port_stats(f, i);
 100                         close_json_object();
 101                 } else if (show_stats) {
 102                         fprintf(f, "router ports on %s: %s",
 103                                 brifname, port_ifname);
 104
 105                         __print_router_port_stats(f, i);
 106                         fprintf(f, "\n");
 107                 } else {
 108                         fprintf(f, "%s ", port_ifname);
 109                 }
 110         }
 111
 112         if (!show_stats)
 113                 print_nl();
 114
 115         close_json_array(PRINT_JSON, NULL);
 116 }
 117
 118 static void print_mdb_entry(FILE *f, int ifindex, const struct br_mdb_entry *e,
 119                             struct nlmsghdr *n, struct rtattr **tb)
 120 {
 121         SPRINT_BUF(abuf);
 122         const char *dev;
 123         const void *src;
 124         int af;
 125
 126         if (filter_vlan && e->vid != filter_vlan)
 127                 return;
 128
 129         af = e->addr.proto == htons(ETH_P_IP) ? AF_INET : AF_INET6;
 130         src = af == AF_INET ? (const void *)&e->addr.u.ip4 :
 131                               (const void *)&e->addr.u.ip6;
 132         dev = ll_index_to_name(ifindex);
 133
 134         open_json_object(NULL);
 135
 136         print_int(PRINT_JSON, "index", NULL, ifindex);
 137         print_color_string(PRINT_ANY, COLOR_IFNAME, "dev", "dev %s", dev);
 138         print_string(PRINT_ANY, "port", " port %s",
 139                      ll_index_to_name(e->ifindex));
 140
 141         print_color_string(PRINT_ANY, ifa_family_color(af),
 142                             "grp", " grp %s",
 143                             inet_ntop(af, src, abuf, sizeof(abuf)));
 144
 145         print_string(PRINT_ANY, "state", " %s",
 146                            (e->state & MDB_PERMANENT) ? "permanent" : "temp");
 147
 148         open_json_array(PRINT_JSON, "flags");
 149         if (e->flags & MDB_FLAGS_OFFLOAD)
 150                 print_string(PRINT_ANY, NULL, " %s", "offload");
 151         close_json_array(PRINT_JSON, NULL);
 152
 153         if (e->vid)
 154                 print_uint(PRINT_ANY, "vid", " vid %u", e->vid);
 155
 156         if (show_stats && tb && tb[MDBA_MDB_EATTR_TIMER]) {
 157                 __u32 timer = rta_getattr_u32(tb[MDBA_MDB_EATTR_TIMER]);
 158
 159                 print_string(PRINT_ANY, "timer", " %s",
 160                              format_timer(timer));
 161         }
 162
 163         print_nl();
 164         close_json_object();
 165 }
 166
 167 static void br_print_mdb_entry(FILE *f, int ifindex, struct rtattr *attr,
 168                                struct nlmsghdr *n)
 169 {
 170         struct rtattr *etb[MDBA_MDB_EATTR_MAX + 1];
 171         struct br_mdb_entry *e;
 172         struct rtattr *i;
 173         int rem;
 174
 175         rem = RTA_PAYLOAD(attr);
 176         for (i = RTA_DATA(attr); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
 177                 e = RTA_DATA(i);
 178                 parse_rtattr(etb, MDBA_MDB_EATTR_MAX, MDB_RTA(RTA_DATA(i)),
 179                              RTA_PAYLOAD(i) - RTA_ALIGN(sizeof(*e)));
 180                 print_mdb_entry(f, ifindex, e, n, etb);
 181         }
 182 }
 183
 184 static void print_mdb_entries(FILE *fp, struct nlmsghdr *n,
 185                               int ifindex,  struct rtattr *mdb)
 186 {
 187         int rem = RTA_PAYLOAD(mdb);
 188         struct rtattr *i;
 189
 190         for (i = RTA_DATA(mdb); RTA_OK(i, rem); i = RTA_NEXT(i, rem))
 191                 br_print_mdb_entry(fp, ifindex, i, n);
 192 }
 193
 194 static void print_router_entries(FILE *fp, struct nlmsghdr *n,
 195                                  int ifindex, struct rtattr *router)
 196 {
 197         const char *brifname = ll_index_to_name(ifindex);
 198
 199         if (n->nlmsg_type == RTM_GETMDB) {
 200                 if (show_details)
 201                         br_print_router_ports(fp, router, brifname);
 202         } else {
 203                 struct rtattr *i = RTA_DATA(router);
 204                 uint32_t *port_ifindex = RTA_DATA(i);
 205                 const char *port_name = ll_index_to_name(*port_ifindex);
 206
 207                 if (is_json_context()) {
 208                         open_json_array(PRINT_JSON, brifname);
 209                         open_json_object(NULL);
 210
 211                         print_string(PRINT_JSON, "port", NULL,
 212                                      port_name);
 213                         close_json_object();
 214                         close_json_array(PRINT_JSON, NULL);
 215                 } else {
 216                         fprintf(fp, "router port dev %s master %s\n",
 217                                 port_name, brifname);
 218                 }
 219         }
 220 }
 221
 222 static int __parse_mdb_nlmsg(struct nlmsghdr *n, struct rtattr **tb)
 223 {
 224         struct br_port_msg *r = NLMSG_DATA(n);
 225         int len = n->nlmsg_len;
 226
 227         if (n->nlmsg_type != RTM_GETMDB &&
 228             n->nlmsg_type != RTM_NEWMDB &&
 229             n->nlmsg_type != RTM_DELMDB) {
 230                 fprintf(stderr,
 231                         "Not RTM_GETMDB, RTM_NEWMDB or RTM_DELMDB: %08x %08x %08x\n",
 232                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
 233
 234                 return 0;
 235         }
 236
 237         len -= NLMSG_LENGTH(sizeof(*r));
 238         if (len < 0) {
 239                 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
 240                 return -1;
 241         }
 242
 243         if (filter_index && filter_index != r->ifindex)
 244                 return 0;
 245
 246         parse_rtattr(tb, MDBA_MAX, MDBA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
 247
 248         return 1;
 249 }
 250
 251 static int print_mdbs(struct nlmsghdr *n, void *arg)
 252 {
 253         struct br_port_msg *r = NLMSG_DATA(n);
 254         struct rtattr *tb[MDBA_MAX+1];
 255         FILE *fp = arg;
 256         int ret;
 257
 258         ret = __parse_mdb_nlmsg(n, tb);
 259         if (ret != 1)
 260                 return ret;
 261
 262         if (tb[MDBA_MDB])
 263                 print_mdb_entries(fp, n, r->ifindex, tb[MDBA_MDB]);
 264
 265         return 0;
 266 }
 267
 268 static int print_rtrs(struct nlmsghdr *n, void *arg)
 269 {
 270         struct br_port_msg *r = NLMSG_DATA(n);
 271         struct rtattr *tb[MDBA_MAX+1];
 272         FILE *fp = arg;
 273         int ret;
 274
 275         ret = __parse_mdb_nlmsg(n, tb);
 276         if (ret != 1)
 277                 return ret;
 278
 279         if (tb[MDBA_ROUTER])
 280                 print_router_entries(fp, n, r->ifindex, tb[MDBA_ROUTER]);
 281
 282         return 0;
 283 }
 284
 285 int print_mdb_mon(struct nlmsghdr *n, void *arg)
 286 {
 287         struct br_port_msg *r = NLMSG_DATA(n);
 288         struct rtattr *tb[MDBA_MAX+1];
 289         FILE *fp = arg;
 290         int ret;
 291
 292         ret = __parse_mdb_nlmsg(n, tb);
 293         if (ret != 1)
 294                 return ret;
 295
 296         if (n->nlmsg_type == RTM_DELMDB)
 297                 print_bool(PRINT_ANY, "deleted", "Deleted ", true);
 298
 299         if (tb[MDBA_MDB])
 300                 print_mdb_entries(fp, n, r->ifindex, tb[MDBA_MDB]);
 301
 302         if (tb[MDBA_ROUTER])
 303                 print_router_entries(fp, n, r->ifindex, tb[MDBA_ROUTER]);
 304
 305         return 0;
 306 }
 307
 308 static int mdb_show(int argc, char **argv)
 309 {
 310         char *filter_dev = NULL;
 311
 312         while (argc > 0) {
 313                 if (strcmp(*argv, "dev") == 0) {
 314                         NEXT_ARG();
 315                         if (filter_dev)
 316                                 duparg("dev", *argv);
 317                         filter_dev = *argv;
 318                 } else if (strcmp(*argv, "vid") == 0) {
 319                         NEXT_ARG();
 320                         if (filter_vlan)
 321                                 duparg("vid", *argv);
 322                         filter_vlan = atoi(*argv);
 323                 }
 324                 argc--; argv++;
 325         }
 326
 327         if (filter_dev) {
 328                 filter_index = ll_name_to_index(filter_dev);
 329                 if (!filter_index)
 330                         return nodev(filter_dev);
 331         }
 332
 333         new_json_obj(json);
 334         open_json_object(NULL);
 335
 336         /* get mdb entries */
 337         if (rtnl_mdbdump_req(&rth, PF_BRIDGE) < 0) {
 338                 perror("Cannot send dump request");
 339                 return -1;
 340         }
 341
 342         open_json_array(PRINT_JSON, "mdb");
 343         if (rtnl_dump_filter(&rth, print_mdbs, stdout) < 0) {
 344                 fprintf(stderr, "Dump terminated\n");
 345                 return -1;
 346         }
 347         close_json_array(PRINT_JSON, NULL);
 348
 349         /* get router ports */
 350         if (rtnl_mdbdump_req(&rth, PF_BRIDGE) < 0) {
 351                 perror("Cannot send dump request");
 352                 return -1;
 353         }
 354
 355         open_json_object("router");
 356         if (rtnl_dump_filter(&rth, print_rtrs, stdout) < 0) {
 357                 fprintf(stderr, "Dump terminated\n");
 358                 return -1;
 359         }
 360         close_json_object();
 361
 362         close_json_object();
 363         delete_json_obj();
 364         fflush(stdout);
 365
 366         return 0;
 367 }
 368
 369 static int mdb_modify(int cmd, int flags, int argc, char **argv)
 370 {
 371         struct {
 372                 struct nlmsghdr n;
 373                 struct br_port_msg      bpm;
 374                 char                    buf[1024];
 375         } req = {
 376                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct br_port_msg)),
 377                 .n.nlmsg_flags = NLM_F_REQUEST | flags,
 378                 .n.nlmsg_type = cmd,
 379                 .bpm.family = PF_BRIDGE,
 380         };
 381         struct br_mdb_entry entry = {};
 382         char *d = NULL, *p = NULL, *grp = NULL;
 383         short vid = 0;
 384
 385         while (argc > 0) {
 386                 if (strcmp(*argv, "dev") == 0) {
 387                         NEXT_ARG();
 388                         d = *argv;
 389                 } else if (strcmp(*argv, "grp") == 0) {
 390                         NEXT_ARG();
 391                         grp = *argv;
 392                 } else if (strcmp(*argv, "port") == 0) {
 393                         NEXT_ARG();
 394                         p = *argv;
 395                 } else if (strcmp(*argv, "permanent") == 0) {
 396                         if (cmd == RTM_NEWMDB)
 397                                 entry.state |= MDB_PERMANENT;
 398                 } else if (strcmp(*argv, "temp") == 0) {
 399                         ;/* nothing */
 400                 } else if (strcmp(*argv, "vid") == 0) {
 401                         NEXT_ARG();
 402                         vid = atoi(*argv);
 403                 } else {
 404                         if (matches(*argv, "help") == 0)
 405                                 usage();
 406                 }
 407                 argc--; argv++;
 408         }
 409
 410         if (d == NULL || grp == NULL || p == NULL) {
 411                 fprintf(stderr, "Device, group address and port name are required arguments.\n");
 412                 return -1;
 413         }
 414
 415         req.bpm.ifindex = ll_name_to_index(d);
 416         if (!req.bpm.ifindex)
 417                 return nodev(d);
 418
 419         entry.ifindex = ll_name_to_index(p);
 420         if (!entry.ifindex)
 421                 return nodev(p);
 422
 423         if (!inet_pton(AF_INET, grp, &entry.addr.u.ip4)) {
 424                 if (!inet_pton(AF_INET6, grp, &entry.addr.u.ip6)) {
 425                         fprintf(stderr, "Invalid address \"%s\"\n", grp);
 426                         return -1;
 427                 } else
 428                         entry.addr.proto = htons(ETH_P_IPV6);
 429         } else
 430                 entry.addr.proto = htons(ETH_P_IP);
 431
 432         entry.vid = vid;
 433         addattr_l(&req.n, sizeof(req), MDBA_SET_ENTRY, &entry, sizeof(entry));
 434
 435         if (rtnl_talk(&rth, &req.n, NULL) < 0)
 436                 return -1;
 437
 438         return 0;
 439 }
 440
 441 int do_mdb(int argc, char **argv)
 442 {
 443         ll_init_map(&rth);
 444
 445         if (argc > 0) {
 446                 if (matches(*argv, "add") == 0)
 447                         return mdb_modify(RTM_NEWMDB, NLM_F_CREATE|NLM_F_EXCL, argc-1, argv+1);
 448                 if (matches(*argv, "delete") == 0)
 449                         return mdb_modify(RTM_DELMDB, 0, argc-1, argv+1);
 450
 451                 if (matches(*argv, "show") == 0 ||
 452                     matches(*argv, "lst") == 0 ||
 453                     matches(*argv, "list") == 0)
 454                         return mdb_show(argc-1, argv+1);
 455                 if (matches(*argv, "help") == 0)
 456                         usage();
 457         } else
 458                 return mdb_show(0, NULL);
 459
 460         fprintf(stderr, "Command \"%s\" is unknown, try \"bridge mdb help\".\n", *argv);
 461         exit(-1);
 462 }