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