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
 111         if (!show_stats)
 112                 print_nl();
 113
 114         close_json_array(PRINT_JSON, NULL);
 115 }
 116
 117 static void print_mdb_entry(FILE *f, int ifindex, const struct br_mdb_entry *e,
 118                             struct nlmsghdr *n, struct rtattr **tb)
 119 {
 120         SPRINT_BUF(abuf);
 121         const char *dev;
 122         const void *src;
 123         int af;
 124
 125         if (filter_vlan && e->vid != filter_vlan)
 126                 return;
 127
 128         af = e->addr.proto == htons(ETH_P_IP) ? AF_INET : AF_INET6;
 129         src = af == AF_INET ? (const void *)&e->addr.u.ip4 :
 130                               (const void *)&e->addr.u.ip6;
 131         dev = ll_index_to_name(ifindex);
 132
 133         open_json_object(NULL);
 134
 135         if (n->nlmsg_type == RTM_DELMDB)
 136                 print_bool(PRINT_ANY, "deleted", "Deleted ", true);
 137
 138         print_int(PRINT_ANY, "index", "%u: ", ifindex);
 139         print_color_string(PRINT_ANY, COLOR_IFNAME, "dev", "%s ", dev);
 140         print_string(PRINT_ANY, "port", " %s ",
 141                      ll_index_to_name(e->ifindex));
 142
 143         print_color_string(PRINT_ANY, ifa_family_color(af),
 144                             "grp", " %s ",
 145                             inet_ntop(af, src, abuf, sizeof(abuf)));
 146
 147         print_string(PRINT_ANY, "state", " %s ",
 148                            (e->state & MDB_PERMANENT) ? "permanent" : "temp");
 149
 150         open_json_array(PRINT_JSON, "flags");
 151         if (e->flags & MDB_FLAGS_OFFLOAD)
 152                 print_string(PRINT_ANY, NULL, "%s ", "offload");
 153         close_json_array(PRINT_JSON, NULL);
 154
 155         if (e->vid)
 156                 print_uint(PRINT_ANY, "vid", " vid %u", e->vid);
 157
 158         if (show_stats && tb && tb[MDBA_MDB_EATTR_TIMER]) {
 159                 __u32 timer = rta_getattr_u32(tb[MDBA_MDB_EATTR_TIMER]);
 160
 161                 print_string(PRINT_ANY, "timer", " %s",
 162                              format_timer(timer));
 163         }
 164
 165         print_nl();
 166         close_json_object();
 167 }
 168
 169 static void br_print_mdb_entry(FILE *f, int ifindex, struct rtattr *attr,
 170                                struct nlmsghdr *n)
 171 {
 172         struct rtattr *etb[MDBA_MDB_EATTR_MAX + 1];
 173         struct br_mdb_entry *e;
 174         struct rtattr *i;
 175         int rem;
 176
 177         rem = RTA_PAYLOAD(attr);
 178         for (i = RTA_DATA(attr); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
 179                 e = RTA_DATA(i);
 180                 parse_rtattr(etb, MDBA_MDB_EATTR_MAX, MDB_RTA(RTA_DATA(i)),
 181                              RTA_PAYLOAD(i) - RTA_ALIGN(sizeof(*e)));
 182                 print_mdb_entry(f, ifindex, e, n, etb);
 183         }
 184 }
 185
 186 static void print_mdb_entries(FILE *fp, struct nlmsghdr *n,
 187                               int ifindex,  struct rtattr *mdb)
 188 {
 189         int rem = RTA_PAYLOAD(mdb);
 190         struct rtattr *i;
 191
 192         open_json_array(PRINT_JSON, "mdb");
 193         for (i = RTA_DATA(mdb); RTA_OK(i, rem); i = RTA_NEXT(i, rem))
 194                 br_print_mdb_entry(fp, ifindex, i, n);
 195         close_json_array(PRINT_JSON, NULL);
 196 }
 197
 198 static void print_router_entries(FILE *fp, struct nlmsghdr *n,
 199                                  int ifindex, struct rtattr *router)
 200 {
 201         const char *brifname = ll_index_to_name(ifindex);
 202
 203         open_json_array(PRINT_JSON, "router");
 204         if (n->nlmsg_type == RTM_GETMDB) {
 205                 if (show_details)
 206                         br_print_router_ports(fp, router, brifname);
 207         } else {
 208                 struct rtattr *i = RTA_DATA(router);
 209                 uint32_t *port_ifindex = RTA_DATA(i);
 210                 const char *port_name = ll_index_to_name(*port_ifindex);
 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                                      port_name);
 218                         close_json_object();
 219                         close_json_array(PRINT_JSON, NULL);
 220                 } else {
 221                         fprintf(fp, "router port dev %s master %s\n",
 222                                 port_name, brifname);
 223                 }
 224         }
 225         close_json_array(PRINT_JSON, NULL);
 226 }
 227
 228 int print_mdb(struct nlmsghdr *n, void *arg)
 229 {
 230         FILE *fp = arg;
 231         struct br_port_msg *r = NLMSG_DATA(n);
 232         int len = n->nlmsg_len;
 233         struct rtattr *tb[MDBA_MAX+1];
 234
 235         if (n->nlmsg_type != RTM_GETMDB &&
 236             n->nlmsg_type != RTM_NEWMDB &&
 237             n->nlmsg_type != RTM_DELMDB) {
 238                 fprintf(stderr,
 239                         "Not RTM_GETMDB, RTM_NEWMDB or RTM_DELMDB: %08x %08x %08x\n",
 240                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
 241
 242                 return 0;
 243         }
 244
 245         len -= NLMSG_LENGTH(sizeof(*r));
 246         if (len < 0) {
 247                 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
 248                 return -1;
 249         }
 250
 251         if (filter_index && filter_index != r->ifindex)
 252                 return 0;
 253
 254         parse_rtattr(tb, MDBA_MAX, MDBA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
 255
 256         if (n->nlmsg_type == RTM_DELMDB)
 257                 print_bool(PRINT_ANY, "deleted", "Deleted ", true);
 258
 259         if (tb[MDBA_MDB])
 260                 print_mdb_entries(fp, n, r->ifindex, tb[MDBA_MDB]);
 261
 262         if (tb[MDBA_ROUTER])
 263                 print_router_entries(fp, n, r->ifindex, tb[MDBA_ROUTER]);
 264
 265         return 0;
 266 }
 267
 268 static int mdb_show(int argc, char **argv)
 269 {
 270         char *filter_dev = NULL;
 271
 272         while (argc > 0) {
 273                 if (strcmp(*argv, "dev") == 0) {
 274                         NEXT_ARG();
 275                         if (filter_dev)
 276                                 duparg("dev", *argv);
 277                         filter_dev = *argv;
 278                 } else if (strcmp(*argv, "vid") == 0) {
 279                         NEXT_ARG();
 280                         if (filter_vlan)
 281                                 duparg("vid", *argv);
 282                         filter_vlan = atoi(*argv);
 283                 }
 284                 argc--; argv++;
 285         }
 286
 287         if (filter_dev) {
 288                 filter_index = ll_name_to_index(filter_dev);
 289                 if (!filter_index)
 290                         return nodev(filter_dev);
 291         }
 292
 293         new_json_obj(json);
 294
 295         /* get mdb entries*/
 296         if (rtnl_mdbdump_req(&rth, PF_BRIDGE) < 0) {
 297                 perror("Cannot send dump request");
 298                 return -1;
 299         }
 300
 301         if (rtnl_dump_filter(&rth, print_mdb, stdout) < 0) {
 302                 fprintf(stderr, "Dump terminated\n");
 303                 return -1;
 304         }
 305
 306         delete_json_obj();
 307         fflush(stdout);
 308
 309         return 0;
 310 }
 311
 312 static int mdb_modify(int cmd, int flags, int argc, char **argv)
 313 {
 314         struct {
 315                 struct nlmsghdr n;
 316                 struct br_port_msg      bpm;
 317                 char                    buf[1024];
 318         } req = {
 319                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct br_port_msg)),
 320                 .n.nlmsg_flags = NLM_F_REQUEST | flags,
 321                 .n.nlmsg_type = cmd,
 322                 .bpm.family = PF_BRIDGE,
 323         };
 324         struct br_mdb_entry entry = {};
 325         char *d = NULL, *p = NULL, *grp = NULL;
 326         short vid = 0;
 327
 328         while (argc > 0) {
 329                 if (strcmp(*argv, "dev") == 0) {
 330                         NEXT_ARG();
 331                         d = *argv;
 332                 } else if (strcmp(*argv, "grp") == 0) {
 333                         NEXT_ARG();
 334                         grp = *argv;
 335                 } else if (strcmp(*argv, "port") == 0) {
 336                         NEXT_ARG();
 337                         p = *argv;
 338                 } else if (strcmp(*argv, "permanent") == 0) {
 339                         if (cmd == RTM_NEWMDB)
 340                                 entry.state |= MDB_PERMANENT;
 341                 } else if (strcmp(*argv, "temp") == 0) {
 342                         ;/* nothing */
 343                 } else if (strcmp(*argv, "vid") == 0) {
 344                         NEXT_ARG();
 345                         vid = atoi(*argv);
 346                 } else {
 347                         if (matches(*argv, "help") == 0)
 348                                 usage();
 349                 }
 350                 argc--; argv++;
 351         }
 352
 353         if (d == NULL || grp == NULL || p == NULL) {
 354                 fprintf(stderr, "Device, group address and port name are required arguments.\n");
 355                 return -1;
 356         }
 357
 358         req.bpm.ifindex = ll_name_to_index(d);
 359         if (!req.bpm.ifindex)
 360                 return nodev(d);
 361
 362         entry.ifindex = ll_name_to_index(p);
 363         if (!entry.ifindex)
 364                 return nodev(p);
 365
 366         if (!inet_pton(AF_INET, grp, &entry.addr.u.ip4)) {
 367                 if (!inet_pton(AF_INET6, grp, &entry.addr.u.ip6)) {
 368                         fprintf(stderr, "Invalid address \"%s\"\n", grp);
 369                         return -1;
 370                 } else
 371                         entry.addr.proto = htons(ETH_P_IPV6);
 372         } else
 373                 entry.addr.proto = htons(ETH_P_IP);
 374
 375         entry.vid = vid;
 376         addattr_l(&req.n, sizeof(req), MDBA_SET_ENTRY, &entry, sizeof(entry));
 377
 378         if (rtnl_talk(&rth, &req.n, NULL) < 0)
 379                 return -1;
 380
 381         return 0;
 382 }
 383
 384 int do_mdb(int argc, char **argv)
 385 {
 386         ll_init_map(&rth);
 387
 388         if (argc > 0) {
 389                 if (matches(*argv, "add") == 0)
 390                         return mdb_modify(RTM_NEWMDB, NLM_F_CREATE|NLM_F_EXCL, argc-1, argv+1);
 391                 if (matches(*argv, "delete") == 0)
 392                         return mdb_modify(RTM_DELMDB, 0, argc-1, argv+1);
 393
 394                 if (matches(*argv, "show") == 0 ||
 395                     matches(*argv, "lst") == 0 ||
 396                     matches(*argv, "list") == 0)
 397                         return mdb_show(argc-1, argv+1);
 398                 if (matches(*argv, "help") == 0)
 399                         usage();
 400         } else
 401                 return mdb_show(0, NULL);
 402
 403         fprintf(stderr, "Command \"%s\" is unknown, try \"bridge mdb help\".\n", *argv);
 404         exit(-1);
 405 }