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                 "                  [ mcast_hash_max HASH_MAX ]\n"
  42                 "                  [ mcast_last_member_count LAST_MEMBER_COUNT ]\n"
  43                 "                  [ mcast_startup_query_count STARTUP_QUERY_COUNT ]\n"
  44                 "                  [ mcast_last_member_interval LAST_MEMBER_INTERVAL ]\n"
  45                 "\n"
  46                 "Where: VLAN_PROTOCOL := { 802.1Q | 802.1ad }\n"
  47         );
  48 }
  49
  50 static void explain(void)
  51 {
  52         print_explain(stderr);
  53 }
  54
  55 static void br_dump_bridge_id(const struct ifla_bridge_id *id, char *buf,
  56                               size_t len)
  57 {
  58         char eaddr[32];
  59
  60         ether_ntoa_r((const struct ether_addr *)id->addr, eaddr);
  61         snprintf(buf, len, "%.2x%.2x.%s", id->prio[0], id->prio[1], eaddr);
  62 }
  63
  64 static int bridge_parse_opt(struct link_util *lu, int argc, char **argv,
  65                             struct nlmsghdr *n)
  66 {
  67         __u32 val;
  68
  69         while (argc > 0) {
  70                 if (matches(*argv, "forward_delay") == 0) {
  71                         NEXT_ARG();
  72                         if (get_u32(&val, *argv, 0))
  73                                 invarg("invalid forward_delay", *argv);
  74
  75                         addattr32(n, 1024, IFLA_BR_FORWARD_DELAY, val);
  76                 } else if (matches(*argv, "hello_time") == 0) {
  77                         NEXT_ARG();
  78                         if (get_u32(&val, *argv, 0))
  79                                 invarg("invalid hello_time", *argv);
  80
  81                         addattr32(n, 1024, IFLA_BR_HELLO_TIME, val);
  82                 } else if (matches(*argv, "max_age") == 0) {
  83                         NEXT_ARG();
  84                         if (get_u32(&val, *argv, 0))
  85                                 invarg("invalid max_age", *argv);
  86
  87                         addattr32(n, 1024, IFLA_BR_MAX_AGE, val);
  88                 } else if (matches(*argv, "ageing_time") == 0) {
  89                         NEXT_ARG();
  90                         if (get_u32(&val, *argv, 0))
  91                                 invarg("invalid ageing_time", *argv);
  92
  93                         addattr32(n, 1024, IFLA_BR_AGEING_TIME, val);
  94                 } else if (matches(*argv, "stp_state") == 0) {
  95                         NEXT_ARG();
  96                         if (get_u32(&val, *argv, 0))
  97                                 invarg("invalid stp_state", *argv);
  98
  99                         addattr32(n, 1024, IFLA_BR_STP_STATE, val);
 100                 } else if (matches(*argv, "priority") == 0) {
 101                         __u16 prio;
 102
 103                         NEXT_ARG();
 104                         if (get_u16(&prio, *argv, 0))
 105                                 invarg("invalid priority", *argv);
 106
 107                         addattr16(n, 1024, IFLA_BR_PRIORITY, prio);
 108                 } else if (matches(*argv, "vlan_filtering") == 0) {
 109                         __u8 vlan_filter;
 110
 111                         NEXT_ARG();
 112                         if (get_u8(&vlan_filter, *argv, 0)) {
 113                                 invarg("invalid vlan_filtering", *argv);
 114                                 return -1;
 115                         }
 116                         addattr8(n, 1024, IFLA_BR_VLAN_FILTERING, vlan_filter);
 117                 } else if (matches(*argv, "vlan_protocol") == 0) {
 118                         __u16 vlan_proto;
 119
 120                         NEXT_ARG();
 121                         if (ll_proto_a2n(&vlan_proto, *argv)) {
 122                                 invarg("invalid vlan_protocol", *argv);
 123                                 return -1;
 124                         }
 125                         addattr16(n, 1024, IFLA_BR_VLAN_PROTOCOL, vlan_proto);
 126                 } else if (matches(*argv, "group_fwd_mask") == 0) {
 127                         __u16 fwd_mask;
 128
 129                         NEXT_ARG();
 130                         if (get_u16(&fwd_mask, *argv, 0))
 131                                 invarg("invalid group_fwd_mask", *argv);
 132
 133                         addattr16(n, 1024, IFLA_BR_GROUP_FWD_MASK, fwd_mask);
 134                 } else if (matches(*argv, "group_address") == 0) {
 135                         char llabuf[32];
 136                         int len;
 137
 138                         NEXT_ARG();
 139                         len = ll_addr_a2n(llabuf, sizeof(llabuf), *argv);
 140                         if (len < 0)
 141                                 return -1;
 142                         addattr_l(n, 1024, IFLA_BR_GROUP_ADDR, llabuf, len);
 143                 } else if (matches(*argv, "vlan_default_pvid") == 0) {
 144                         __u16 default_pvid;
 145
 146                         NEXT_ARG();
 147                         if (get_u16(&default_pvid, *argv, 0))
 148                                 invarg("invalid vlan_default_pvid", *argv);
 149
 150                         addattr16(n, 1024, IFLA_BR_VLAN_DEFAULT_PVID,
 151                                   default_pvid);
 152                 } else if (matches(*argv, "mcast_router") == 0) {
 153                         __u8 mcast_router;
 154
 155                         NEXT_ARG();
 156                         if (get_u8(&mcast_router, *argv, 0))
 157                                 invarg("invalid mcast_router", *argv);
 158
 159                         addattr8(n, 1024, IFLA_BR_MCAST_ROUTER, mcast_router);
 160                 } else if (matches(*argv, "mcast_snooping") == 0) {
 161                         __u8 mcast_snoop;
 162
 163                         NEXT_ARG();
 164                         if (get_u8(&mcast_snoop, *argv, 0))
 165                                 invarg("invalid mcast_snooping", *argv);
 166
 167                         addattr8(n, 1024, IFLA_BR_MCAST_SNOOPING, mcast_snoop);
 168                 } else if (matches(*argv, "mcast_query_use_ifaddr") == 0) {
 169                         __u8 mcast_qui;
 170
 171                         NEXT_ARG();
 172                         if (get_u8(&mcast_qui, *argv, 0))
 173                                 invarg("invalid mcast_query_use_ifaddr",
 174                                        *argv);
 175
 176                         addattr8(n, 1024, IFLA_BR_MCAST_QUERY_USE_IFADDR,
 177                                  mcast_qui);
 178                 } else if (matches(*argv, "mcast_querier") == 0) {
 179                         __u8 mcast_querier;
 180
 181                         NEXT_ARG();
 182                         if (get_u8(&mcast_querier, *argv, 0))
 183                                 invarg("invalid mcast_querier", *argv);
 184
 185                         addattr8(n, 1024, IFLA_BR_MCAST_QUERIER, mcast_querier);
 186                 } else if (matches(*argv, "mcast_hash_elasticity") == 0) {
 187                         __u32 mcast_hash_el;
 188
 189                         NEXT_ARG();
 190                         if (get_u32(&mcast_hash_el, *argv, 0))
 191                                 invarg("invalid mcast_hash_elasticity",
 192                                        *argv);
 193
 194                         addattr32(n, 1024, IFLA_BR_MCAST_HASH_ELASTICITY,
 195                                   mcast_hash_el);
 196                 } else if (matches(*argv, "mcast_hash_max") == 0) {
 197                         __u32 mcast_hash_max;
 198
 199                         NEXT_ARG();
 200                         if (get_u32(&mcast_hash_max, *argv, 0))
 201                                 invarg("invalid mcast_hash_max", *argv);
 202
 203                         addattr32(n, 1024, IFLA_BR_MCAST_HASH_MAX,
 204                                   mcast_hash_max);
 205                 } else if (matches(*argv, "mcast_last_member_count") == 0) {
 206                         __u32 mcast_lmc;
 207
 208                         NEXT_ARG();
 209                         if (get_u32(&mcast_lmc, *argv, 0))
 210                                 invarg("invalid mcast_last_member_count",
 211                                        *argv);
 212
 213                         addattr32(n, 1024, IFLA_BR_MCAST_LAST_MEMBER_CNT,
 214                                   mcast_lmc);
 215                 } else if (matches(*argv, "mcast_startup_query_count") == 0) {
 216                         __u32 mcast_sqc;
 217
 218                         NEXT_ARG();
 219                         if (get_u32(&mcast_sqc, *argv, 0))
 220                                 invarg("invalid mcast_startup_query_count",
 221                                        *argv);
 222
 223                         addattr32(n, 1024, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
 224                                   mcast_sqc);
 225                 } else if (matches(*argv, "mcast_last_member_interval") == 0) {
 226                         __u64 mcast_last_member_intvl;
 227
 228                         NEXT_ARG();
 229                         if (get_u64(&mcast_last_member_intvl, *argv, 0))
 230                                 invarg("invalid mcast_last_member_interval",
 231                                        *argv);
 232
 233                         addattr64(n, 1024, IFLA_BR_MCAST_LAST_MEMBER_INTVL,
 234                                   mcast_last_member_intvl);
 235                 } else if (matches(*argv, "help") == 0) {
 236                         explain();
 237                         return -1;
 238                 } else {
 239                         fprintf(stderr, "bridge: unknown command \"%s\"?\n", *argv);
 240                         explain();
 241                         return -1;
 242                 }
 243                 argc--, argv++;
 244         }
 245
 246         return 0;
 247 }
 248
 249 static void bridge_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 250 {
 251         if (!tb)
 252                 return;
 253
 254         if (tb[IFLA_BR_FORWARD_DELAY])
 255                 fprintf(f, "forward_delay %u ",
 256                         rta_getattr_u32(tb[IFLA_BR_FORWARD_DELAY]));
 257
 258         if (tb[IFLA_BR_HELLO_TIME])
 259                 fprintf(f, "hello_time %u ",
 260                         rta_getattr_u32(tb[IFLA_BR_HELLO_TIME]));
 261
 262         if (tb[IFLA_BR_MAX_AGE])
 263                 fprintf(f, "max_age %u ",
 264                         rta_getattr_u32(tb[IFLA_BR_MAX_AGE]));
 265
 266         if (tb[IFLA_BR_AGEING_TIME])
 267                 fprintf(f, "ageing_time %u ",
 268                         rta_getattr_u32(tb[IFLA_BR_AGEING_TIME]));
 269
 270         if (tb[IFLA_BR_STP_STATE])
 271                 fprintf(f, "stp_state %u ",
 272                         rta_getattr_u32(tb[IFLA_BR_STP_STATE]));
 273
 274         if (tb[IFLA_BR_PRIORITY])
 275                 fprintf(f, "priority %u ",
 276                         rta_getattr_u16(tb[IFLA_BR_PRIORITY]));
 277
 278         if (tb[IFLA_BR_VLAN_FILTERING])
 279                 fprintf(f, "vlan_filtering %u ",
 280                         rta_getattr_u8(tb[IFLA_BR_VLAN_FILTERING]));
 281
 282         if (tb[IFLA_BR_VLAN_PROTOCOL]) {
 283                 SPRINT_BUF(b1);
 284
 285                 fprintf(f, "vlan_protocol %s ",
 286                         ll_proto_n2a(rta_getattr_u16(tb[IFLA_BR_VLAN_PROTOCOL]),
 287                                      b1, sizeof(b1)));
 288         }
 289
 290         if (tb[IFLA_BR_BRIDGE_ID]) {
 291                 char bridge_id[32];
 292
 293                 br_dump_bridge_id(RTA_DATA(tb[IFLA_BR_BRIDGE_ID]), bridge_id,
 294                                   sizeof(bridge_id));
 295                 fprintf(f, "bridge_id %s ", bridge_id);
 296         }
 297
 298         if (tb[IFLA_BR_ROOT_ID]) {
 299                 char root_id[32];
 300
 301                 br_dump_bridge_id(RTA_DATA(tb[IFLA_BR_BRIDGE_ID]), root_id,
 302                                   sizeof(root_id));
 303                 fprintf(f, "designated_root %s ", root_id);
 304         }
 305
 306         if (tb[IFLA_BR_ROOT_PORT])
 307                 fprintf(f, "root_port %u ",
 308                         rta_getattr_u16(tb[IFLA_BR_ROOT_PORT]));
 309
 310         if (tb[IFLA_BR_ROOT_PATH_COST])
 311                 fprintf(f, "root_path_cost %u ",
 312                         rta_getattr_u32(tb[IFLA_BR_ROOT_PATH_COST]));
 313
 314         if (tb[IFLA_BR_TOPOLOGY_CHANGE])
 315                 fprintf(f, "topology_change %u ",
 316                         rta_getattr_u8(tb[IFLA_BR_TOPOLOGY_CHANGE]));
 317
 318         if (tb[IFLA_BR_TOPOLOGY_CHANGE_DETECTED])
 319                 fprintf(f, "topology_change_detected %u ",
 320                         rta_getattr_u8(tb[IFLA_BR_TOPOLOGY_CHANGE_DETECTED]));
 321
 322         if (tb[IFLA_BR_HELLO_TIMER]) {
 323                 struct timeval tv;
 324
 325                 __jiffies_to_tv(&tv, rta_getattr_u64(tb[IFLA_BR_HELLO_TIMER]));
 326                 fprintf(f, "hello_timer %4i.%.2i ", (int)tv.tv_sec,
 327                         (int)tv.tv_usec/10000);
 328         }
 329
 330         if (tb[IFLA_BR_TCN_TIMER]) {
 331                 struct timeval tv;
 332
 333                 __jiffies_to_tv(&tv, rta_getattr_u64(tb[IFLA_BR_TCN_TIMER]));
 334                 fprintf(f, "tcn_timer %4i.%.2i ", (int)tv.tv_sec,
 335                         (int)tv.tv_usec/10000);
 336         }
 337
 338         if (tb[IFLA_BR_TOPOLOGY_CHANGE_TIMER]) {
 339                 unsigned long jiffies;
 340                 struct timeval tv;
 341
 342                 jiffies = rta_getattr_u64(tb[IFLA_BR_TOPOLOGY_CHANGE_TIMER]);
 343                 __jiffies_to_tv(&tv, jiffies);
 344                 fprintf(f, "topology_change_timer %4i.%.2i ", (int)tv.tv_sec,
 345                         (int)tv.tv_usec/10000);
 346         }
 347
 348         if (tb[IFLA_BR_GC_TIMER]) {
 349                 struct timeval tv;
 350
 351                 __jiffies_to_tv(&tv, rta_getattr_u64(tb[IFLA_BR_GC_TIMER]));
 352                 fprintf(f, "gc_timer %4i.%.2i ", (int)tv.tv_sec,
 353                         (int)tv.tv_usec/10000);
 354         }
 355
 356         if (tb[IFLA_BR_VLAN_DEFAULT_PVID])
 357                 fprintf(f, "vlan_default_pvid %u ",
 358                         rta_getattr_u16(tb[IFLA_BR_VLAN_DEFAULT_PVID]));
 359
 360         if (tb[IFLA_BR_GROUP_FWD_MASK])
 361                 fprintf(f, "group_fwd_mask %#x ",
 362                         rta_getattr_u16(tb[IFLA_BR_GROUP_FWD_MASK]));
 363
 364         if (tb[IFLA_BR_GROUP_ADDR]) {
 365                 SPRINT_BUF(mac);
 366
 367                 fprintf(f, "group_address %s ",
 368                         ll_addr_n2a(RTA_DATA(tb[IFLA_BR_GROUP_ADDR]),
 369                                     RTA_PAYLOAD(tb[IFLA_BR_GROUP_ADDR]),
 370                                     1 /*ARPHDR_ETHER*/, mac, sizeof(mac)));
 371         }
 372
 373         if (tb[IFLA_BR_MCAST_SNOOPING])
 374                 fprintf(f, "mcast_snooping %u ",
 375                         rta_getattr_u8(tb[IFLA_BR_MCAST_SNOOPING]));
 376
 377         if (tb[IFLA_BR_MCAST_ROUTER])
 378                 fprintf(f, "mcast_router %u ",
 379                         rta_getattr_u8(tb[IFLA_BR_MCAST_ROUTER]));
 380
 381         if (tb[IFLA_BR_MCAST_QUERY_USE_IFADDR])
 382                 fprintf(f, "mcast_query_use_ifaddr %u ",
 383                         rta_getattr_u8(tb[IFLA_BR_MCAST_QUERY_USE_IFADDR]));
 384
 385         if (tb[IFLA_BR_MCAST_QUERIER])
 386                 fprintf(f, "mcast_querier %u ",
 387                         rta_getattr_u8(tb[IFLA_BR_MCAST_QUERIER]));
 388
 389         if (tb[IFLA_BR_MCAST_HASH_ELASTICITY])
 390                 fprintf(f, "mcast_hash_elasticity %u ",
 391                         rta_getattr_u32(tb[IFLA_BR_MCAST_HASH_ELASTICITY]));
 392
 393         if (tb[IFLA_BR_MCAST_HASH_MAX])
 394                 fprintf(f, "mcast_hash_max %u ",
 395                         rta_getattr_u32(tb[IFLA_BR_MCAST_HASH_MAX]));
 396
 397         if (tb[IFLA_BR_MCAST_LAST_MEMBER_CNT])
 398                 fprintf(f, "mcast_last_member_count %u ",
 399                         rta_getattr_u32(tb[IFLA_BR_MCAST_LAST_MEMBER_CNT]));
 400
 401         if (tb[IFLA_BR_MCAST_STARTUP_QUERY_CNT])
 402                 fprintf(f, "mcast_startup_query_count %u ",
 403                         rta_getattr_u32(tb[IFLA_BR_MCAST_STARTUP_QUERY_CNT]));
 404
 405         if (tb[IFLA_BR_MCAST_LAST_MEMBER_INTVL])
 406                 fprintf(f, "mcast_last_member_interval %llu ",
 407                         rta_getattr_u64(tb[IFLA_BR_MCAST_LAST_MEMBER_INTVL]));
 408 }
 409
 410 static void bridge_print_help(struct link_util *lu, int argc, char **argv,
 411                 FILE *f)
 412 {
 413         print_explain(f);
 414 }
 415
 416 struct link_util bridge_link_util = {
 417         .id             = "bridge",
 418         .maxattr        = IFLA_BR_MAX,
 419         .parse_opt      = bridge_parse_opt,
 420         .print_opt      = bridge_print_opt,
 421         .print_help     = bridge_print_help,
 422 };