ip/iplink_bridge_slave.c

   1 /*
   2  * iplink_bridge_slave.c        Bridge slave 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 <sys/socket.h>
  14 #include <netinet/in.h>
  15 #include <linux/if_link.h>
  16 #include <linux/if_bridge.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_slave [ state STATE ] [ priority PRIO ] [cost COST ]\n"
  26                 "                        [ guard {on | off} ]\n"
  27                 "                        [ hairpin {on | off} ] \n"
  28                 "                        [ fastleave {on | off} ]\n"
  29                 "                        [ root_block {on | off} ]\n"
  30                 "                        [ learning {on | off} ]\n"
  31                 "                        [ flood {on | off} ]\n"
  32                 "                        [ proxy_arp {on | off} ]\n"
  33                 "                        [ proxy_arp_wifi {on | off} ]\n"
  34                 "                        [ mcast_router MULTICAST_ROUTER ]\n"
  35         );
  36 }
  37
  38 static void explain(void)
  39 {
  40         print_explain(stderr);
  41 }
  42
  43 static const char *port_states[] = {
  44         [BR_STATE_DISABLED] = "disabled",
  45         [BR_STATE_LISTENING] = "listening",
  46         [BR_STATE_LEARNING] = "learning",
  47         [BR_STATE_FORWARDING] = "forwarding",
  48         [BR_STATE_BLOCKING] = "blocking",
  49 };
  50
  51 static void print_portstate(FILE *f, __u8 state)
  52 {
  53         if (state <= BR_STATE_BLOCKING)
  54                 fprintf(f, "state %s ", port_states[state]);
  55         else
  56                 fprintf(f, "state (%d) ", state);
  57 }
  58
  59 static void print_onoff(FILE *f, char *flag, __u8 val)
  60 {
  61         fprintf(f, "%s %s ", flag, val ? "on" : "off");
  62 }
  63
  64 static void bridge_slave_print_opt(struct link_util *lu, FILE *f,
  65                                    struct rtattr *tb[])
  66 {
  67         if (!tb)
  68                 return;
  69
  70         if (tb[IFLA_BRPORT_STATE])
  71                 print_portstate(f, rta_getattr_u8(tb[IFLA_BRPORT_STATE]));
  72
  73         if (tb[IFLA_BRPORT_PRIORITY])
  74                 fprintf(f, "priority %d ",
  75                         rta_getattr_u16(tb[IFLA_BRPORT_PRIORITY]));
  76
  77         if (tb[IFLA_BRPORT_COST])
  78                 fprintf(f, "cost %d ",
  79                         rta_getattr_u32(tb[IFLA_BRPORT_COST]));
  80
  81         if (tb[IFLA_BRPORT_MODE])
  82                 print_onoff(f, "hairpin",
  83                             rta_getattr_u8(tb[IFLA_BRPORT_MODE]));
  84
  85         if (tb[IFLA_BRPORT_GUARD])
  86                 print_onoff(f, "guard",
  87                             rta_getattr_u8(tb[IFLA_BRPORT_GUARD]));
  88
  89         if (tb[IFLA_BRPORT_PROTECT])
  90                 print_onoff(f, "root_block",
  91                             rta_getattr_u8(tb[IFLA_BRPORT_PROTECT]));
  92
  93         if (tb[IFLA_BRPORT_FAST_LEAVE])
  94                 print_onoff(f, "fastleave",
  95                             rta_getattr_u8(tb[IFLA_BRPORT_FAST_LEAVE]));
  96
  97         if (tb[IFLA_BRPORT_LEARNING])
  98                 print_onoff(f, "learning",
  99                         rta_getattr_u8(tb[IFLA_BRPORT_LEARNING]));
 100
 101         if (tb[IFLA_BRPORT_UNICAST_FLOOD])
 102                 print_onoff(f, "flood",
 103                         rta_getattr_u8(tb[IFLA_BRPORT_UNICAST_FLOOD]));
 104
 105         if (tb[IFLA_BRPORT_ID])
 106                 fprintf(f, "port_id 0x%x ",
 107                         rta_getattr_u16(tb[IFLA_BRPORT_ID]));
 108
 109         if (tb[IFLA_BRPORT_NO])
 110                 fprintf(f, "port_no 0x%x ",
 111                         rta_getattr_u16(tb[IFLA_BRPORT_NO]));
 112
 113         if (tb[IFLA_BRPORT_DESIGNATED_PORT])
 114                 fprintf(f, "designated_port %u ",
 115                         rta_getattr_u16(tb[IFLA_BRPORT_DESIGNATED_PORT]));
 116
 117         if (tb[IFLA_BRPORT_DESIGNATED_COST])
 118                 fprintf(f, "designated_cost %u ",
 119                         rta_getattr_u16(tb[IFLA_BRPORT_DESIGNATED_COST]));
 120
 121         if (tb[IFLA_BRPORT_BRIDGE_ID]) {
 122                 char bridge_id[32];
 123
 124                 br_dump_bridge_id(RTA_DATA(tb[IFLA_BRPORT_BRIDGE_ID]),
 125                                   bridge_id, sizeof(bridge_id));
 126                 fprintf(f, "designated_bridge %s ", bridge_id);
 127         }
 128
 129         if (tb[IFLA_BRPORT_ROOT_ID]) {
 130                 char root_id[32];
 131
 132                 br_dump_bridge_id(RTA_DATA(tb[IFLA_BRPORT_ROOT_ID]),
 133                                   root_id, sizeof(root_id));
 134                 fprintf(f, "designated_root %s ", root_id);
 135         }
 136
 137         if (tb[IFLA_BRPORT_HOLD_TIMER]) {
 138                 struct timeval tv;
 139                 __u64 htimer;
 140
 141                 htimer = rta_getattr_u64(tb[IFLA_BRPORT_HOLD_TIMER]);
 142                 __jiffies_to_tv(&tv, htimer);
 143                 fprintf(f, "hold_timer %4i.%.2i ", (int)tv.tv_sec,
 144                         (int)tv.tv_usec/10000);
 145         }
 146
 147         if (tb[IFLA_BRPORT_MESSAGE_AGE_TIMER]) {
 148                 struct timeval tv;
 149                 __u64 agetimer;
 150
 151                 agetimer = rta_getattr_u64(tb[IFLA_BRPORT_MESSAGE_AGE_TIMER]);
 152                 __jiffies_to_tv(&tv, agetimer);
 153                 fprintf(f, "message_age_timer %4i.%.2i ", (int)tv.tv_sec,
 154                         (int)tv.tv_usec/10000);
 155         }
 156
 157         if (tb[IFLA_BRPORT_FORWARD_DELAY_TIMER]) {
 158                 struct timeval tv;
 159                 __u64 fwdtimer;
 160
 161                 fwdtimer = rta_getattr_u64(tb[IFLA_BRPORT_FORWARD_DELAY_TIMER]);
 162                 __jiffies_to_tv(&tv, fwdtimer);
 163                 fprintf(f, "forward_delay_timer %4i.%.2i ", (int)tv.tv_sec,
 164                         (int)tv.tv_usec/10000);
 165         }
 166
 167         if (tb[IFLA_BRPORT_TOPOLOGY_CHANGE_ACK])
 168                 fprintf(f, "topology_change_ack %u ",
 169                         rta_getattr_u8(tb[IFLA_BRPORT_TOPOLOGY_CHANGE_ACK]));
 170
 171         if (tb[IFLA_BRPORT_CONFIG_PENDING])
 172                 fprintf(f, "config_pending %u ",
 173                         rta_getattr_u8(tb[IFLA_BRPORT_CONFIG_PENDING]));
 174         if (tb[IFLA_BRPORT_PROXYARP])
 175                 print_onoff(f, "proxy_arp",
 176                             rta_getattr_u8(tb[IFLA_BRPORT_PROXYARP]));
 177
 178         if (tb[IFLA_BRPORT_PROXYARP_WIFI])
 179                 print_onoff(f, "proxy_arp_wifi",
 180                             rta_getattr_u8(tb[IFLA_BRPORT_PROXYARP_WIFI]));
 181
 182         if (tb[IFLA_BRPORT_MULTICAST_ROUTER])
 183                 fprintf(f, "mcast_router %u ",
 184                         rta_getattr_u8(tb[IFLA_BRPORT_MULTICAST_ROUTER]));
 185 }
 186
 187 static void bridge_slave_parse_on_off(char *arg_name, char *arg_val,
 188                                       struct nlmsghdr *n, int type)
 189 {
 190         __u8 val;
 191
 192         if (strcmp(arg_val, "on") == 0)
 193                 val = 1;
 194         else if (strcmp(arg_val, "off") == 0)
 195                 val = 0;
 196         else
 197                 invarg("should be \"on\" or \"off\"", arg_name);
 198
 199         addattr8(n, 1024, type, val);
 200 }
 201
 202 static int bridge_slave_parse_opt(struct link_util *lu, int argc, char **argv,
 203                                   struct nlmsghdr *n)
 204 {
 205         __u8 state;
 206         __u16 priority;
 207         __u32 cost;
 208
 209         while (argc > 0) {
 210                 if (matches(*argv, "state") == 0) {
 211                         NEXT_ARG();
 212                         if (get_u8(&state, *argv, 0))
 213                                 invarg("state is invalid", *argv);
 214                         addattr8(n, 1024, IFLA_BRPORT_STATE, state);
 215                 } else if (matches(*argv, "priority") == 0) {
 216                         NEXT_ARG();
 217                         if (get_u16(&priority, *argv, 0))
 218                                 invarg("priority is invalid", *argv);
 219                         addattr16(n, 1024, IFLA_BRPORT_PRIORITY, priority);
 220                 } else if (matches(*argv, "cost") == 0) {
 221                         NEXT_ARG();
 222                         if (get_u32(&cost, *argv, 0))
 223                                 invarg("cost is invalid", *argv);
 224                         addattr32(n, 1024, IFLA_BRPORT_COST, cost);
 225                 } else if (matches(*argv, "hairpin") == 0) {
 226                         NEXT_ARG();
 227                         bridge_slave_parse_on_off("hairpin", *argv, n,
 228                                                   IFLA_BRPORT_MODE);
 229                 } else if (matches(*argv, "guard") == 0) {
 230                         NEXT_ARG();
 231                         bridge_slave_parse_on_off("guard", *argv, n,
 232                                                   IFLA_BRPORT_GUARD);
 233                 } else if (matches(*argv, "root_block") == 0) {
 234                         NEXT_ARG();
 235                         bridge_slave_parse_on_off("root_block", *argv, n,
 236                                                   IFLA_BRPORT_PROTECT);
 237                 } else if (matches(*argv, "fastleave") == 0) {
 238                         NEXT_ARG();
 239                         bridge_slave_parse_on_off("fastleave", *argv, n,
 240                                                   IFLA_BRPORT_FAST_LEAVE);
 241                 } else if (matches(*argv, "learning") == 0) {
 242                         NEXT_ARG();
 243                         bridge_slave_parse_on_off("learning", *argv, n,
 244                                                   IFLA_BRPORT_LEARNING);
 245                 } else if (matches(*argv, "flood") == 0) {
 246                         NEXT_ARG();
 247                         bridge_slave_parse_on_off("flood", *argv, n,
 248                                                   IFLA_BRPORT_UNICAST_FLOOD);
 249                 } else if (matches(*argv, "proxy_arp") == 0) {
 250                         NEXT_ARG();
 251                         bridge_slave_parse_on_off("proxy_arp", *argv, n,
 252                                                   IFLA_BRPORT_PROXYARP);
 253                 } else if (matches(*argv, "proxy_arp_wifi") == 0) {
 254                         NEXT_ARG();
 255                         bridge_slave_parse_on_off("proxy_arp_wifi", *argv, n,
 256                                                   IFLA_BRPORT_PROXYARP_WIFI);
 257                 } else if (matches(*argv, "mcast_router") == 0) {
 258                         __u8 mcast_router;
 259
 260                         NEXT_ARG();
 261                         if (get_u8(&mcast_router, *argv, 0))
 262                                 invarg("invalid mcast_router", *argv);
 263                         addattr8(n, 1024, IFLA_BRPORT_MULTICAST_ROUTER,
 264                                  mcast_router);
 265                 } else if (matches(*argv, "help") == 0) {
 266                         explain();
 267                         return -1;
 268                 } else {
 269                         fprintf(stderr, "bridge_slave: unknown option \"%s\"?\n",
 270                                 *argv);
 271                         explain();
 272                         return -1;
 273                 }
 274                 argc--, argv++;
 275         }
 276
 277         return 0;
 278 }
 279
 280 static void bridge_slave_print_help(struct link_util *lu, int argc, char **argv,
 281                 FILE *f)
 282 {
 283         print_explain(f);
 284 }
 285
 286 struct link_util bridge_slave_link_util = {
 287         .id             = "bridge",
 288         .maxattr        = IFLA_BRPORT_MAX,
 289         .print_opt      = bridge_slave_print_opt,
 290         .parse_opt      = bridge_slave_parse_opt,
 291         .print_help     = bridge_slave_print_help,
 292         .slave          = true,
 293 };