ip/iplink_bridge.c

   1 /*
   2  * iplink_bridge.c      Bridge 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:     Jiri Pirko <jiri@resnulli.us>
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <linux/if_link.h>
  16 #include <netinet/ether.h>
  17
  18 #include "rt_names.h"
  19 #include "utils.h"
  20 #include "ip_common.h"
  21
  22 static void print_explain(FILE *f)
  23 {
  24         fprintf(f,
  25                 "Usage: ... bridge [ forward_delay FORWARD_DELAY ]\n"
  26                 "                  [ hello_time HELLO_TIME ]\n"
  27                 "                  [ max_age MAX_AGE ]\n"
  28                 "                  [ ageing_time AGEING_TIME ]\n"
  29                 "                  [ stp_state STP_STATE ]\n"
  30                 "                  [ priority PRIORITY ]\n"
  31                 "                  [ group_fwd_mask MASK ]\n"
  32                 "                  [ group_address ADDRESS ]\n"
  33                 "                  [ vlan_filtering VLAN_FILTERING ]\n"
  34                 "                  [ vlan_protocol VLAN_PROTOCOL ]\n"
  35                 "                  [ vlan_default_pvid VLAN_DEFAULT_PVID ]\n"
  36                 "                  [ mcast_snooping MULTICAST_SNOOPING ]\n"
  37                 "                  [ mcast_router MULTICAST_ROUTER ]\n"
  38                 "                  [ mcast_query_use_ifaddr MCAST_QUERY_USE_IFADDR ]\n"
  39                 "                  [ mcast_querier MULTICAST_QUERIER ]\n"
  40                 "                  [ mcast_hash_elasticity HASH_ELASTICITY ]\n"
  41                 "\n"
  42                 "Where: VLAN_PROTOCOL := { 802.1Q | 802.1ad }\n"
  43         );
  44 }
  45
  46 static void explain(void)
  47 {
  48         print_explain(stderr);
  49 }
  50
  51 static void br_dump_bridge_id(const struct ifla_bridge_id *id, char *buf,
  52                               size_t len)
  53 {
  54         char eaddr[32];
  55
  56         ether_ntoa_r((const struct ether_addr *)id->addr, eaddr);
  57         snprintf(buf, len, "%.2x%.2x.%s", id->prio[0], id->prio[1], eaddr);
  58 }
  59
  60 static int bridge_parse_opt(struct link_util *lu, int argc, char **argv,
  61                             struct nlmsghdr *n)
  62 {
  63         __u32 val;
  64
  65         while (argc > 0) {
  66                 if (matches(*argv, "forward_delay") == 0) {
  67                         NEXT_ARG();
  68                         if (get_u32(&val, *argv, 0))
  69                                 invarg("invalid forward_delay", *argv);
  70
  71                         addattr32(n, 1024, IFLA_BR_FORWARD_DELAY, val);
  72                 } else if (matches(*argv, "hello_time") == 0) {
  73                         NEXT_ARG();
  74                         if (get_u32(&val, *argv, 0))
  75                                 invarg("invalid hello_time", *argv);
  76
  77                         addattr32(n, 1024, IFLA_BR_HELLO_TIME, val);
  78                 } else if (matches(*argv, "max_age") == 0) {
  79                         NEXT_ARG();
  80                         if (get_u32(&val, *argv, 0))
  81                                 invarg("invalid max_age", *argv);
  82
  83                         addattr32(n, 1024, IFLA_BR_MAX_AGE, val);
  84                 } else if (matches(*argv, "ageing_time") == 0) {
  85                         NEXT_ARG();
  86                         if (get_u32(&val, *argv, 0))
  87                                 invarg("invalid ageing_time", *argv);
  88
  89                         addattr32(n, 1024, IFLA_BR_AGEING_TIME, val);
  90                 } else if (matches(*argv, "stp_state") == 0) {
  91                         NEXT_ARG();
  92                         if (get_u32(&val, *argv, 0))
  93                                 invarg("invalid stp_state", *argv);
  94
  95                         addattr32(n, 1024, IFLA_BR_STP_STATE, val);
  96                 } else if (matches(*argv, "priority") == 0) {
  97                         __u16 prio;
  98
  99                         NEXT_ARG();
 100                         if (get_u16(&prio, *argv, 0))
 101                                 invarg("invalid priority", *argv);
 102
 103                         addattr16(n, 1024, IFLA_BR_PRIORITY, prio);
 104                 } else if (matches(*argv, "vlan_filtering") == 0) {
 105                         __u8 vlan_filter;
 106
 107                         NEXT_ARG();
 108                         if (get_u8(&vlan_filter, *argv, 0)) {
 109                                 invarg("invalid vlan_filtering", *argv);
 110                                 return -1;
 111                         }
 112                         addattr8(n, 1024, IFLA_BR_VLAN_FILTERING, vlan_filter);
 113                 } else if (matches(*argv, "vlan_protocol") == 0) {
 114                         __u16 vlan_proto;
 115
 116                         NEXT_ARG();
 117                         if (ll_proto_a2n(&vlan_proto, *argv)) {
 118                                 invarg("invalid vlan_protocol", *argv);
 119                                 return -1;
 120                         }
 121                         addattr16(n, 1024, IFLA_BR_VLAN_PROTOCOL, vlan_proto);
 122                 } else if (matches(*argv, "group_fwd_mask") == 0) {
 123                         __u16 fwd_mask;
 124
 125                         NEXT_ARG();
 126                         if (get_u16(&fwd_mask, *argv, 0))
 127                                 invarg("invalid group_fwd_mask", *argv);
 128
 129                         addattr16(n, 1024, IFLA_BR_GROUP_FWD_MASK, fwd_mask);
 130                 } else if (matches(*argv, "group_address") == 0) {
 131                         char llabuf[32];
 132                         int len;
 133
 134                         NEXT_ARG();
 135                         len = ll_addr_a2n(llabuf, sizeof(llabuf), *argv);
 136                         if (len < 0)
 137                                 return -1;
 138                         addattr_l(n, 1024, IFLA_BR_GROUP_ADDR, llabuf, len);
 139                 } else if (matches(*argv, "vlan_default_pvid") == 0) {
 140                         __u16 default_pvid;
 141
 142                         NEXT_ARG();
 143                         if (get_u16(&default_pvid, *argv, 0))
 144                                 invarg("invalid vlan_default_pvid", *argv);
 145
 146                         addattr16(n, 1024, IFLA_BR_VLAN_DEFAULT_PVID,
 147                                   default_pvid);
 148                 } else if (matches(*argv, "mcast_router") == 0) {
 149                         __u8 mcast_router;
 150
 151                         NEXT_ARG();
 152                         if (get_u8(&mcast_router, *argv, 0))
 153                                 invarg("invalid mcast_router", *argv);
 154
 155                         addattr8(n, 1024, IFLA_BR_MCAST_ROUTER, mcast_router);
 156                 } else if (matches(*argv, "mcast_snooping") == 0) {
 157                         __u8 mcast_snoop;
 158
 159                         NEXT_ARG();
 160                         if (get_u8(&mcast_snoop, *argv, 0))
 161                                 invarg("invalid mcast_snooping", *argv);
 162
 163                         addattr8(n, 1024, IFLA_BR_MCAST_SNOOPING, mcast_snoop);
 164                 } else if (matches(*argv, "mcast_query_use_ifaddr") == 0) {
 165                         __u8 mcast_qui;
 166
 167                         NEXT_ARG();
 168                         if (get_u8(&mcast_qui, *argv, 0))
 169                                 invarg("invalid mcast_query_use_ifaddr",
 170                                        *argv);
 171
 172                         addattr8(n, 1024, IFLA_BR_MCAST_QUERY_USE_IFADDR,
 173                                  mcast_qui);
 174                 } else if (matches(*argv, "mcast_querier") == 0) {
 175                         __u8 mcast_querier;
 176
 177                         NEXT_ARG();
 178                         if (get_u8(&mcast_querier, *argv, 0))
 179                                 invarg("invalid mcast_querier", *argv);
 180
 181                         addattr8(n, 1024, IFLA_BR_MCAST_QUERIER, mcast_querier);
 182                 } else if (matches(*argv, "mcast_hash_elasticity") == 0) {
 183                         __u32 mcast_hash_el;
 184
 185                         NEXT_ARG();
 186                         if (get_u32(&mcast_hash_el, *argv, 0))
 187                                 invarg("invalid mcast_hash_elasticity",
 188                                        *argv);
 189
 190                         addattr32(n, 1024, IFLA_BR_MCAST_HASH_ELASTICITY,
 191                                   mcast_hash_el);
 192                 } else if (matches(*argv, "help") == 0) {
 193                         explain();
 194                         return -1;
 195                 } else {
 196                         fprintf(stderr, "bridge: unknown command \"%s\"?\n", *argv);
 197                         explain();
 198                         return -1;
 199                 }
 200                 argc--, argv++;
 201         }
 202
 203         return 0;
 204 }
 205
 206 static void bridge_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 207 {
 208         if (!tb)
 209                 return;
 210
 211         if (tb[IFLA_BR_FORWARD_DELAY])
 212                 fprintf(f, "forward_delay %u ",
 213                         rta_getattr_u32(tb[IFLA_BR_FORWARD_DELAY]));
 214
 215         if (tb[IFLA_BR_HELLO_TIME])
 216                 fprintf(f, "hello_time %u ",
 217                         rta_getattr_u32(tb[IFLA_BR_HELLO_TIME]));
 218
 219         if (tb[IFLA_BR_MAX_AGE])
 220                 fprintf(f, "max_age %u ",
 221                         rta_getattr_u32(tb[IFLA_BR_MAX_AGE]));
 222
 223         if (tb[IFLA_BR_AGEING_TIME])
 224                 fprintf(f, "ageing_time %u ",
 225                         rta_getattr_u32(tb[IFLA_BR_AGEING_TIME]));
 226
 227         if (tb[IFLA_BR_STP_STATE])
 228                 fprintf(f, "stp_state %u ",
 229                         rta_getattr_u32(tb[IFLA_BR_STP_STATE]));
 230
 231         if (tb[IFLA_BR_PRIORITY])
 232                 fprintf(f, "priority %u ",
 233                         rta_getattr_u16(tb[IFLA_BR_PRIORITY]));
 234
 235         if (tb[IFLA_BR_VLAN_FILTERING])
 236                 fprintf(f, "vlan_filtering %u ",
 237                         rta_getattr_u8(tb[IFLA_BR_VLAN_FILTERING]));
 238
 239         if (tb[IFLA_BR_VLAN_PROTOCOL]) {
 240                 SPRINT_BUF(b1);
 241
 242                 fprintf(f, "vlan_protocol %s ",
 243                         ll_proto_n2a(rta_getattr_u16(tb[IFLA_BR_VLAN_PROTOCOL]),
 244                                      b1, sizeof(b1)));
 245         }
 246
 247         if (tb[IFLA_BR_BRIDGE_ID]) {
 248                 char bridge_id[32];
 249
 250                 br_dump_bridge_id(RTA_DATA(tb[IFLA_BR_BRIDGE_ID]), bridge_id,
 251                                   sizeof(bridge_id));
 252                 fprintf(f, "bridge_id %s ", bridge_id);
 253         }
 254
 255         if (tb[IFLA_BR_ROOT_ID]) {
 256                 char root_id[32];
 257
 258                 br_dump_bridge_id(RTA_DATA(tb[IFLA_BR_BRIDGE_ID]), root_id,
 259                                   sizeof(root_id));
 260                 fprintf(f, "designated_root %s ", root_id);
 261         }
 262
 263         if (tb[IFLA_BR_ROOT_PORT])
 264                 fprintf(f, "root_port %u ",
 265                         rta_getattr_u16(tb[IFLA_BR_ROOT_PORT]));
 266
 267         if (tb[IFLA_BR_ROOT_PATH_COST])
 268                 fprintf(f, "root_path_cost %u ",
 269                         rta_getattr_u32(tb[IFLA_BR_ROOT_PATH_COST]));
 270
 271         if (tb[IFLA_BR_TOPOLOGY_CHANGE])
 272                 fprintf(f, "topology_change %u ",
 273                         rta_getattr_u8(tb[IFLA_BR_TOPOLOGY_CHANGE]));
 274
 275         if (tb[IFLA_BR_TOPOLOGY_CHANGE_DETECTED])
 276                 fprintf(f, "topology_change_detected %u ",
 277                         rta_getattr_u8(tb[IFLA_BR_TOPOLOGY_CHANGE_DETECTED]));
 278
 279         if (tb[IFLA_BR_HELLO_TIMER]) {
 280                 struct timeval tv;
 281
 282                 __jiffies_to_tv(&tv, rta_getattr_u64(tb[IFLA_BR_HELLO_TIMER]));
 283                 fprintf(f, "hello_timer %4i.%.2i ", (int)tv.tv_sec,
 284                         (int)tv.tv_usec/10000);
 285         }
 286
 287         if (tb[IFLA_BR_TCN_TIMER]) {
 288                 struct timeval tv;
 289
 290                 __jiffies_to_tv(&tv, rta_getattr_u64(tb[IFLA_BR_TCN_TIMER]));
 291                 fprintf(f, "tcn_timer %4i.%.2i ", (int)tv.tv_sec,
 292                         (int)tv.tv_usec/10000);
 293         }
 294
 295         if (tb[IFLA_BR_TOPOLOGY_CHANGE_TIMER]) {
 296                 unsigned long jiffies;
 297                 struct timeval tv;
 298
 299                 jiffies = rta_getattr_u64(tb[IFLA_BR_TOPOLOGY_CHANGE_TIMER]);
 300                 __jiffies_to_tv(&tv, jiffies);
 301                 fprintf(f, "topology_change_timer %4i.%.2i ", (int)tv.tv_sec,
 302                         (int)tv.tv_usec/10000);
 303         }
 304
 305         if (tb[IFLA_BR_GC_TIMER]) {
 306                 struct timeval tv;
 307
 308                 __jiffies_to_tv(&tv, rta_getattr_u64(tb[IFLA_BR_GC_TIMER]));
 309                 fprintf(f, "gc_timer %4i.%.2i ", (int)tv.tv_sec,
 310                         (int)tv.tv_usec/10000);
 311         }
 312
 313         if (tb[IFLA_BR_VLAN_DEFAULT_PVID])
 314                 fprintf(f, "vlan_default_pvid %u ",
 315                         rta_getattr_u16(tb[IFLA_BR_VLAN_DEFAULT_PVID]));
 316
 317         if (tb[IFLA_BR_GROUP_FWD_MASK])
 318                 fprintf(f, "group_fwd_mask %#x ",
 319                         rta_getattr_u16(tb[IFLA_BR_GROUP_FWD_MASK]));
 320
 321         if (tb[IFLA_BR_GROUP_ADDR]) {
 322                 SPRINT_BUF(mac);
 323
 324                 fprintf(f, "group_address %s ",
 325                         ll_addr_n2a(RTA_DATA(tb[IFLA_BR_GROUP_ADDR]),
 326                                     RTA_PAYLOAD(tb[IFLA_BR_GROUP_ADDR]),
 327                                     1 /*ARPHDR_ETHER*/, mac, sizeof(mac)));
 328         }
 329
 330         if (tb[IFLA_BR_MCAST_SNOOPING])
 331                 fprintf(f, "mcast_snooping %u ",
 332                         rta_getattr_u8(tb[IFLA_BR_MCAST_SNOOPING]));
 333
 334         if (tb[IFLA_BR_MCAST_ROUTER])
 335                 fprintf(f, "mcast_router %u ",
 336                         rta_getattr_u8(tb[IFLA_BR_MCAST_ROUTER]));
 337
 338         if (tb[IFLA_BR_MCAST_QUERY_USE_IFADDR])
 339                 fprintf(f, "mcast_query_use_ifaddr %u ",
 340                         rta_getattr_u8(tb[IFLA_BR_MCAST_QUERY_USE_IFADDR]));
 341
 342         if (tb[IFLA_BR_MCAST_QUERIER])
 343                 fprintf(f, "mcast_querier %u ",
 344                         rta_getattr_u8(tb[IFLA_BR_MCAST_QUERIER]));
 345
 346         if (tb[IFLA_BR_MCAST_HASH_ELASTICITY])
 347                 fprintf(f, "mcast_hash_elasticity %u ",
 348                         rta_getattr_u32(tb[IFLA_BR_MCAST_HASH_ELASTICITY]));
 349 }
 350
 351 static void bridge_print_help(struct link_util *lu, int argc, char **argv,
 352                 FILE *f)
 353 {
 354         print_explain(f);
 355 }
 356
 357 struct link_util bridge_link_util = {
 358         .id             = "bridge",
 359         .maxattr        = IFLA_BR_MAX,
 360         .parse_opt      = bridge_parse_opt,
 361         .print_opt      = bridge_print_opt,
 362         .print_help     = bridge_print_help,
 363 };