bridge.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <assert.h>
   5 #include <errno.h>
   6
   7 #include "netifd.h"
   8 #include "device.h"
   9 #include "interface.h"
  10 #include "system.h"
  11
  12 enum {
  13         BRIDGE_ATTR_IFNAME,
  14         BRIDGE_ATTR_STP,
  15         BRIDGE_ATTR_FORWARD_DELAY,
  16         BRIDGE_ATTR_IGMP_SNOOP,
  17         BRIDGE_ATTR_AGEING_TIME,
  18         BRIDGE_ATTR_HELLO_TIME,
  19         BRIDGE_ATTR_MAX_AGE,
  20         __BRIDGE_ATTR_MAX
  21 };
  22
  23 static const struct blobmsg_policy bridge_attrs[__BRIDGE_ATTR_MAX] = {
  24         [BRIDGE_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
  25         [BRIDGE_ATTR_STP] = { "stp", BLOBMSG_TYPE_BOOL },
  26         [BRIDGE_ATTR_FORWARD_DELAY] = { "forward_delay", BLOBMSG_TYPE_INT32 },
  27         [BRIDGE_ATTR_AGEING_TIME] = { "ageing_time", BLOBMSG_TYPE_INT32 },
  28         [BRIDGE_ATTR_HELLO_TIME] = { "hello_time", BLOBMSG_TYPE_INT32 },
  29         [BRIDGE_ATTR_MAX_AGE] = { "max_age", BLOBMSG_TYPE_INT32 },
  30         [BRIDGE_ATTR_IGMP_SNOOP] = { "igmp_snooping", BLOBMSG_TYPE_BOOL },
  31 };
  32
  33 static const union config_param_info bridge_attr_info[__BRIDGE_ATTR_MAX] = {
  34         [BRIDGE_ATTR_IFNAME] = { .type = BLOBMSG_TYPE_STRING },
  35 };
  36
  37 static const struct config_param_list bridge_attr_list = {
  38         .n_params = __BRIDGE_ATTR_MAX,
  39         .params = bridge_attrs,
  40         .info = bridge_attr_info,
  41
  42         .n_next = 1,
  43         .next = { &device_attr_list },
  44 };
  45
  46 static struct device *bridge_create(const char *name, struct blob_attr *attr);
  47 static void bridge_config_init(struct device *dev);
  48 static void bridge_free(struct device *dev);
  49 static void bridge_dump_info(struct device *dev, struct blob_buf *b);
  50
  51 const struct device_type bridge_device_type = {
  52         .name = "Bridge",
  53         .config_params = &bridge_attr_list,
  54
  55         .create = bridge_create,
  56         .config_init = bridge_config_init,
  57         .free = bridge_free,
  58         .dump_info = bridge_dump_info,
  59 };
  60
  61 struct bridge_state {
  62         struct device dev;
  63         device_state_cb set_state;
  64
  65         struct bridge_config config;
  66         struct blob_attr *ifnames;
  67         bool active;
  68
  69         struct list_head members;
  70         int n_present;
  71 };
  72
  73 struct bridge_member {
  74         struct list_head list;
  75         struct bridge_state *bst;
  76         struct device_user dev;
  77         bool present;
  78 };
  79
  80 static int
  81 bridge_disable_member(struct bridge_member *bm)
  82 {
  83         struct bridge_state *bst = bm->bst;
  84
  85         if (!bm->present)
  86                 return 0;
  87
  88         system_bridge_delif(&bst->dev, bm->dev.dev);
  89         device_release(&bm->dev);
  90
  91         return 0;
  92 }
  93
  94 static int
  95 bridge_enable_member(struct bridge_member *bm)
  96 {
  97         struct bridge_state *bst = bm->bst;
  98         int ret;
  99
 100         if (!bm->present)
 101                 return 0;
 102
 103         ret = device_claim(&bm->dev);
 104         if (ret < 0)
 105                 goto error;
 106
 107         ret = system_bridge_addif(&bst->dev, bm->dev.dev);
 108         if (ret < 0)
 109                 goto error;
 110
 111         return 0;
 112
 113 error:
 114         bm->present = false;
 115         bst->n_present--;
 116         return ret;
 117 }
 118
 119 static void
 120 bridge_member_cb(struct device_user *dev, enum device_event ev)
 121 {
 122         struct bridge_member *bm = container_of(dev, struct bridge_member, dev);
 123         struct bridge_state *bst = bm->bst;
 124
 125         switch (ev) {
 126         case DEV_EVENT_ADD:
 127                 assert(!bm->present);
 128
 129                 bm->present = true;
 130                 bst->n_present++;
 131
 132                 if (bst->dev.active)
 133                         bridge_enable_member(bm);
 134                 else if (bst->n_present == 1)
 135                         device_set_present(&bst->dev, true);
 136
 137                 break;
 138         case DEV_EVENT_REMOVE:
 139                 if (!bm->present)
 140                         return;
 141
 142                 if (bst->dev.active)
 143                         bridge_disable_member(bm);
 144
 145                 bm->present = false;
 146                 bm->bst->n_present--;
 147                 if (bst->n_present == 0)
 148                         device_set_present(&bst->dev, false);
 149
 150                 break;
 151         default:
 152                 return;
 153         }
 154 }
 155
 156 static int
 157 bridge_set_down(struct bridge_state *bst)
 158 {
 159         struct bridge_member *bm;
 160
 161         bst->set_state(&bst->dev, false);
 162
 163         list_for_each_entry(bm, &bst->members, list)
 164                 bridge_disable_member(bm);
 165
 166         system_bridge_delbr(&bst->dev);
 167
 168         return 0;
 169 }
 170
 171 static int
 172 bridge_set_up(struct bridge_state *bst)
 173 {
 174         struct bridge_member *bm;
 175         int ret;
 176
 177         if (!bst->n_present)
 178                 return -ENOENT;
 179
 180         ret = system_bridge_addbr(&bst->dev, &bst->config);
 181         if (ret < 0)
 182                 goto out;
 183
 184         list_for_each_entry(bm, &bst->members, list)
 185                 bridge_enable_member(bm);
 186
 187         if (!bst->n_present) {
 188                 /* initialization of all member interfaces failed */
 189                 system_bridge_delbr(&bst->dev);
 190                 device_set_present(&bst->dev, false);
 191                 return -ENOENT;
 192         }
 193
 194         ret = bst->set_state(&bst->dev, true);
 195         if (ret < 0)
 196                 bridge_set_down(bst);
 197
 198 out:
 199         return ret;
 200 }
 201
 202 static int
 203 bridge_set_state(struct device *dev, bool up)
 204 {
 205         struct bridge_state *bst;
 206
 207         bst = container_of(dev, struct bridge_state, dev);
 208
 209         if (up)
 210                 return bridge_set_up(bst);
 211         else
 212                 return bridge_set_down(bst);
 213 }
 214
 215 static struct bridge_member *
 216 bridge_create_member(struct bridge_state *bst, struct device *dev)
 217 {
 218         struct bridge_member *bm;
 219
 220         bm = calloc(1, sizeof(*bm));
 221         bm->bst = bst;
 222         bm->dev.cb = bridge_member_cb;
 223         device_add_user(&bm->dev, dev);
 224
 225         list_add_tail(&bm->list, &bst->members);
 226
 227         if (bst->dev.active)
 228                 bridge_enable_member(bm);
 229
 230         return bm;
 231 }
 232
 233 static void
 234 bridge_free_member(struct bridge_member *bm)
 235 {
 236         if (bm->present) {
 237                 bridge_member_cb(&bm->dev, DEV_EVENT_REMOVE);
 238                 bm->bst->n_present--;
 239                 if (bm->bst->dev.active)
 240                         bridge_disable_member(bm);
 241         }
 242
 243         list_del(&bm->list);
 244         device_remove_user(&bm->dev);
 245         free(bm);
 246 }
 247
 248 static void
 249 bridge_add_member(struct bridge_state *bst, const char *name)
 250 {
 251         struct device *dev;
 252
 253         dev = device_get(name, true);
 254         if (!dev)
 255                 return;
 256
 257         bridge_create_member(bst, dev);
 258 }
 259
 260 static int
 261 bridge_hotplug_add(struct device *dev, struct device *member)
 262 {
 263         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 264
 265         bridge_create_member(bst, member);
 266
 267         return 0;
 268 }
 269
 270 static int
 271 bridge_hotplug_del(struct device *dev, struct device *member)
 272 {
 273         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 274         struct bridge_member *bm;
 275
 276         list_for_each_entry(bm, &bst->members, list) {
 277                 if (bm->dev.dev != member)
 278                         continue;
 279
 280                 bridge_free_member(bm);
 281                 return 0;
 282         }
 283
 284         return -ENOENT;
 285 }
 286
 287 static const struct device_hotplug_ops bridge_ops = {
 288         .add = bridge_hotplug_add,
 289         .del = bridge_hotplug_del
 290 };
 291
 292 static void
 293 bridge_free(struct device *dev)
 294 {
 295         struct bridge_state *bst;
 296         struct bridge_member *bm;
 297
 298         device_cleanup(dev);
 299         bst = container_of(dev, struct bridge_state, dev);
 300         while (!list_empty(&bst->members)) {
 301                 bm = list_first_entry(&bst->members, struct bridge_member, list);
 302                 bridge_free_member(bm);
 303         }
 304         free(bst);
 305 }
 306
 307 static void
 308 bridge_dump_info(struct device *dev, struct blob_buf *b)
 309 {
 310         struct bridge_state *bst;
 311         struct bridge_member *bm;
 312         void *list;
 313
 314         bst = container_of(dev, struct bridge_state, dev);
 315
 316         list = blobmsg_open_array(b, "bridge-members");
 317         list_for_each_entry(bm, &bst->members, list) {
 318                 blobmsg_add_string(b, NULL, bm->dev.dev->ifname);
 319         }
 320         blobmsg_close_array(b, list);
 321 }
 322
 323 static void
 324 bridge_config_init(struct device *dev)
 325 {
 326         struct bridge_state *bst;
 327         struct blob_attr *cur;
 328         int rem;
 329
 330         bst = container_of(dev, struct bridge_state, dev);
 331         blobmsg_for_each_attr(cur, bst->ifnames, rem) {
 332                 bridge_add_member(bst, blobmsg_data(cur));
 333         }
 334 }
 335
 336 static void
 337 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb)
 338 {
 339         struct bridge_config *cfg = &bst->config;
 340         struct blob_attr *cur;
 341
 342         /* defaults */
 343         cfg->stp = true;
 344         cfg->forward_delay = 1;
 345         cfg->igmp_snoop = true;
 346
 347         if ((cur = tb[BRIDGE_ATTR_STP]))
 348                 cfg->stp = blobmsg_get_bool(cur);
 349
 350         if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY]))
 351                 cfg->forward_delay = blobmsg_get_u32(cur);
 352
 353         if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP]))
 354                 cfg->igmp_snoop = blobmsg_get_bool(cur);
 355
 356         if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) {
 357                 cfg->ageing_time = blobmsg_get_u32(cur);
 358                 cfg->flags |= BRIDGE_OPT_AGEING_TIME;
 359         }
 360
 361         if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) {
 362                 cfg->hello_time = blobmsg_get_u32(cur);
 363                 cfg->flags |= BRIDGE_OPT_HELLO_TIME;
 364         }
 365
 366         if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) {
 367                 cfg->max_age = blobmsg_get_u32(cur);
 368                 cfg->flags |= BRIDGE_OPT_MAX_AGE;
 369         }
 370 }
 371
 372 static struct device *
 373 bridge_create(const char *name, struct blob_attr *attr)
 374 {
 375         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 376         struct blob_attr *tb_br[__BRIDGE_ATTR_MAX];
 377         struct bridge_state *bst;
 378         struct device *dev = NULL;
 379
 380         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 381                 blob_data(attr), blob_len(attr));
 382         blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
 383                 blob_data(attr), blob_len(attr));
 384
 385         if (!tb_br[BRIDGE_ATTR_IFNAME])
 386                 return NULL;
 387
 388         bst = calloc(1, sizeof(*bst));
 389         if (!bst)
 390                 return NULL;
 391
 392         dev = &bst->dev;
 393         device_init(dev, &bridge_device_type, name);
 394         device_init_settings(dev, tb_dev);
 395         dev->config_pending = true;
 396         bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME];
 397         bridge_apply_settings(bst, tb_br);
 398
 399         bst->set_state = dev->set_state;
 400         dev->set_state = bridge_set_state;
 401
 402         dev->hotplug_ops = &bridge_ops;
 403
 404         INIT_LIST_HEAD(&bst->members);
 405
 406         return dev;
 407 }
 408
 409