bridge.c

   1 /*
   2  * netifd - network interface daemon
   3  * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <assert.h>
  18 #include <errno.h>
  19
  20 #include "netifd.h"
  21 #include "device.h"
  22 #include "interface.h"
  23 #include "system.h"
  24
  25 enum {
  26         BRIDGE_ATTR_IFNAME,
  27         BRIDGE_ATTR_STP,
  28         BRIDGE_ATTR_FORWARD_DELAY,
  29         BRIDGE_ATTR_PRIORITY,
  30         BRIDGE_ATTR_IGMP_SNOOP,
  31         BRIDGE_ATTR_AGEING_TIME,
  32         BRIDGE_ATTR_HELLO_TIME,
  33         BRIDGE_ATTR_MAX_AGE,
  34         BRIDGE_ATTR_BRIDGE_EMPTY,
  35         BRIDGE_ATTR_MULTICAST_QUERIER,
  36         BRIDGE_ATTR_HASH_MAX,
  37         BRIDGE_ATTR_ROBUSTNESS,
  38         BRIDGE_ATTR_QUERY_INTERVAL,
  39         BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL,
  40         BRIDGE_ATTR_LAST_MEMBER_INTERVAL,
  41         BRIDGE_ATTR_VLAN_FILTERING,
  42         __BRIDGE_ATTR_MAX
  43 };
  44
  45 static const struct blobmsg_policy bridge_attrs[__BRIDGE_ATTR_MAX] = {
  46         [BRIDGE_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
  47         [BRIDGE_ATTR_STP] = { "stp", BLOBMSG_TYPE_BOOL },
  48         [BRIDGE_ATTR_FORWARD_DELAY] = { "forward_delay", BLOBMSG_TYPE_INT32 },
  49         [BRIDGE_ATTR_PRIORITY] = { "priority", BLOBMSG_TYPE_INT32 },
  50         [BRIDGE_ATTR_AGEING_TIME] = { "ageing_time", BLOBMSG_TYPE_INT32 },
  51         [BRIDGE_ATTR_HELLO_TIME] = { "hello_time", BLOBMSG_TYPE_INT32 },
  52         [BRIDGE_ATTR_MAX_AGE] = { "max_age", BLOBMSG_TYPE_INT32 },
  53         [BRIDGE_ATTR_IGMP_SNOOP] = { "igmp_snooping", BLOBMSG_TYPE_BOOL },
  54         [BRIDGE_ATTR_BRIDGE_EMPTY] = { "bridge_empty", BLOBMSG_TYPE_BOOL },
  55         [BRIDGE_ATTR_MULTICAST_QUERIER] = { "multicast_querier", BLOBMSG_TYPE_BOOL },
  56         [BRIDGE_ATTR_HASH_MAX] = { "hash_max", BLOBMSG_TYPE_INT32 },
  57         [BRIDGE_ATTR_ROBUSTNESS] = { "robustness", BLOBMSG_TYPE_INT32 },
  58         [BRIDGE_ATTR_QUERY_INTERVAL] = { "query_interval", BLOBMSG_TYPE_INT32 },
  59         [BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL] = { "query_response_interval", BLOBMSG_TYPE_INT32 },
  60         [BRIDGE_ATTR_LAST_MEMBER_INTERVAL] = { "last_member_interval", BLOBMSG_TYPE_INT32 },
  61         [BRIDGE_ATTR_VLAN_FILTERING] = { "vlan_filtering", BLOBMSG_TYPE_BOOL },
  62 };
  63
  64 static const struct uci_blob_param_info bridge_attr_info[__BRIDGE_ATTR_MAX] = {
  65         [BRIDGE_ATTR_IFNAME] = { .type = BLOBMSG_TYPE_STRING },
  66 };
  67
  68 static const struct uci_blob_param_list bridge_attr_list = {
  69         .n_params = __BRIDGE_ATTR_MAX,
  70         .params = bridge_attrs,
  71         .info = bridge_attr_info,
  72
  73         .n_next = 1,
  74         .next = { &device_attr_list },
  75 };
  76
  77 static struct device *bridge_create(const char *name, struct device_type *devtype,
  78         struct blob_attr *attr);
  79 static void bridge_config_init(struct device *dev);
  80 static void bridge_free(struct device *dev);
  81 static void bridge_dump_info(struct device *dev, struct blob_buf *b);
  82 static enum dev_change_type
  83 bridge_reload(struct device *dev, struct blob_attr *attr);
  84
  85 static struct device_type bridge_device_type = {
  86         .name = "bridge",
  87         .config_params = &bridge_attr_list,
  88
  89         .bridge_capability = true,
  90         .name_prefix = "br",
  91
  92         .create = bridge_create,
  93         .config_init = bridge_config_init,
  94         .reload = bridge_reload,
  95         .free = bridge_free,
  96         .dump_info = bridge_dump_info,
  97 };
  98
  99 struct bridge_state {
 100         struct device dev;
 101         device_state_cb set_state;
 102
 103         struct blob_attr *config_data;
 104         struct bridge_config config;
 105         struct blob_attr *ifnames;
 106         bool active;
 107         bool force_active;
 108
 109         struct uloop_timeout retry;
 110         struct bridge_member *primary_port;
 111         struct vlist_tree members;
 112         int n_present;
 113         int n_failed;
 114 };
 115
 116 struct bridge_member {
 117         struct vlist_node node;
 118         struct bridge_state *bst;
 119         struct device_user dev;
 120         uint16_t pvid;
 121         bool present;
 122         char name[];
 123 };
 124
 125 struct bridge_vlan_hotplug_port {
 126         struct list_head list;
 127         struct bridge_vlan_port port;
 128 };
 129
 130 static void
 131 bridge_reset_primary(struct bridge_state *bst)
 132 {
 133         struct bridge_member *bm;
 134
 135         if (!bst->primary_port &&
 136             (bst->dev.settings.flags & DEV_OPT_MACADDR))
 137                 return;
 138
 139         bst->primary_port = NULL;
 140         bst->dev.settings.flags &= ~DEV_OPT_MACADDR;
 141         vlist_for_each_element(&bst->members, bm, node) {
 142                 uint8_t *macaddr;
 143
 144                 if (!bm->present)
 145                         continue;
 146
 147                 bst->primary_port = bm;
 148                 if (bm->dev.dev->settings.flags & DEV_OPT_MACADDR)
 149                         macaddr = bm->dev.dev->settings.macaddr;
 150                 else
 151                         macaddr = bm->dev.dev->orig_settings.macaddr;
 152                 memcpy(bst->dev.settings.macaddr, macaddr, 6);
 153                 bst->dev.settings.flags |= DEV_OPT_MACADDR;
 154                 return;
 155         }
 156 }
 157
 158 static struct bridge_vlan_port *
 159 bridge_find_vlan_member_port(struct bridge_member *bm, struct bridge_vlan *vlan)
 160 {
 161         struct bridge_vlan_hotplug_port *port;
 162         const char *ifname = bm->dev.dev->ifname;
 163         int i;
 164
 165         for (i = 0; i < vlan->n_ports; i++) {
 166                 if (strcmp(vlan->ports[i].ifname, ifname) != 0)
 167                         continue;
 168
 169                 return &vlan->ports[i];
 170         }
 171
 172         list_for_each_entry(port, &vlan->hotplug_ports, list) {
 173                 if (strcmp(port->port.ifname, ifname) != 0)
 174                         continue;
 175
 176                 return &port->port;
 177         }
 178
 179         return NULL;
 180 }
 181
 182 static bool
 183 bridge_member_vlan_is_pvid(struct bridge_member *bm, struct bridge_vlan_port *port)
 184 {
 185         return (!bm->pvid && (port->flags & BRVLAN_F_UNTAGGED)) ||
 186                (port->flags & BRVLAN_F_PVID);
 187 }
 188
 189 static void
 190 __bridge_set_member_vlan(struct bridge_member *bm, struct bridge_vlan *vlan,
 191                          struct bridge_vlan_port *port, bool add)
 192 {
 193         uint16_t flags;
 194
 195         flags = port->flags;
 196         if (bm->pvid == vlan->vid)
 197                 flags |= BRVLAN_F_PVID;
 198
 199         system_bridge_vlan(port->ifname, vlan->vid, add, flags);
 200 }
 201
 202 static void
 203 bridge_set_member_vlan(struct bridge_member *bm, struct bridge_vlan *vlan, bool add)
 204 {
 205         struct bridge_vlan_port *port;
 206
 207         if (!bm->present)
 208                 return;
 209
 210         port = bridge_find_vlan_member_port(bm, vlan);
 211         if (!port)
 212                 return;
 213
 214         if (bridge_member_vlan_is_pvid(bm, port))
 215                 bm->pvid = vlan->vid;
 216
 217         __bridge_set_member_vlan(bm, vlan, port, add);
 218 }
 219
 220 static void
 221 bridge_set_local_vlan(struct bridge_state *bst, struct bridge_vlan *vlan, bool add)
 222 {
 223         if (!vlan->local && add)
 224                 return;
 225
 226         system_bridge_vlan(bst->dev.ifname, vlan->vid, add, BRVLAN_F_SELF);
 227 }
 228
 229 static void
 230 bridge_set_local_vlans(struct bridge_state *bst, bool add)
 231 {
 232         struct bridge_vlan *vlan;
 233
 234         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 235                 bridge_set_local_vlan(bst, vlan, add);
 236 }
 237
 238 static struct bridge_vlan *
 239 bridge_recalc_member_pvid(struct bridge_member *bm)
 240 {
 241         struct bridge_state *bst = bm->bst;
 242         struct bridge_vlan_port *port;
 243         struct bridge_vlan *vlan, *ret = NULL;
 244
 245         vlist_for_each_element(&bst->dev.vlans, vlan, node) {
 246                 port = bridge_find_vlan_member_port(bm, vlan);
 247                 if (!port)
 248                         continue;
 249
 250                 if (!bridge_member_vlan_is_pvid(bm, port))
 251                         continue;
 252
 253                 ret = vlan;
 254                 if (port->flags & BRVLAN_F_PVID)
 255                         break;
 256         }
 257
 258         return ret;
 259 }
 260
 261 static void
 262 bridge_set_vlan_state(struct bridge_state *bst, struct bridge_vlan *vlan, bool add)
 263 {
 264         struct bridge_member *bm;
 265         struct bridge_vlan *vlan2;
 266
 267         bridge_set_local_vlan(bst, vlan, add);
 268
 269         vlist_for_each_element(&bst->members, bm, node) {
 270                 struct bridge_vlan_port *port;
 271                 int new_pvid = -1;
 272
 273                 port = bridge_find_vlan_member_port(bm, vlan);
 274                 if (!port)
 275                         continue;
 276
 277                 if (add) {
 278                         if (bridge_member_vlan_is_pvid(bm, port))
 279                                 bm->pvid = vlan->vid;
 280                 } else if (bm->pvid == vlan->vid) {
 281                         vlan2 = bridge_recalc_member_pvid(bm);
 282                         if (vlan2 && vlan2->vid != vlan->vid) {
 283                                 bridge_set_member_vlan(bm, vlan2, false);
 284                                 bridge_set_member_vlan(bm, vlan2, true);
 285                         }
 286                         new_pvid = vlan2 ? vlan2->vid : 0;
 287                 }
 288
 289                 if (!bm->present)
 290                         continue;
 291
 292                 __bridge_set_member_vlan(bm, vlan, port, add);
 293                 if (new_pvid >= 0)
 294                         bm->pvid = new_pvid;
 295         }
 296 }
 297
 298 static int
 299 bridge_disable_member(struct bridge_member *bm)
 300 {
 301         struct bridge_state *bst = bm->bst;
 302         struct bridge_vlan *vlan;
 303
 304         if (!bm->present)
 305                 return 0;
 306
 307         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 308                 bridge_set_member_vlan(bm, vlan, false);
 309
 310         system_bridge_delif(&bst->dev, bm->dev.dev);
 311         device_release(&bm->dev);
 312
 313         device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE);
 314
 315         return 0;
 316 }
 317
 318 static int
 319 bridge_enable_interface(struct bridge_state *bst)
 320 {
 321         int ret;
 322
 323         if (bst->active)
 324                 return 0;
 325
 326         ret = system_bridge_addbr(&bst->dev, &bst->config);
 327         if (ret < 0)
 328                 return ret;
 329
 330         if (bst->config.vlan_filtering) {
 331                 /* delete default VLAN 1 */
 332                 system_bridge_vlan(bst->dev.ifname, 1, false, BRVLAN_F_SELF);
 333
 334                 bridge_set_local_vlans(bst, true);
 335         }
 336
 337         bst->active = true;
 338         return 0;
 339 }
 340
 341 static void
 342 bridge_disable_interface(struct bridge_state *bst)
 343 {
 344         if (!bst->active)
 345                 return;
 346
 347         system_bridge_delbr(&bst->dev);
 348         bst->active = false;
 349 }
 350
 351 static int
 352 bridge_enable_member(struct bridge_member *bm)
 353 {
 354         struct bridge_state *bst = bm->bst;
 355         struct bridge_vlan *vlan;
 356         int ret;
 357
 358         if (!bm->present)
 359                 return 0;
 360
 361         ret = bridge_enable_interface(bst);
 362         if (ret)
 363                 goto error;
 364
 365         /* Disable IPv6 for bridge members */
 366         if (!(bm->dev.dev->settings.flags & DEV_OPT_IPV6)) {
 367                 bm->dev.dev->settings.ipv6 = 0;
 368                 bm->dev.dev->settings.flags |= DEV_OPT_IPV6;
 369         }
 370
 371         ret = device_claim(&bm->dev);
 372         if (ret < 0)
 373                 goto error;
 374
 375         ret = system_bridge_addif(&bst->dev, bm->dev.dev);
 376         if (ret < 0) {
 377                 D(DEVICE, "Bridge device %s could not be added\n", bm->dev.dev->ifname);
 378                 goto error;
 379         }
 380
 381         if (bst->config.vlan_filtering) {
 382                 /* delete default VLAN 1 */
 383                 system_bridge_vlan(bm->dev.dev->ifname, 1, false, 0);
 384
 385                 vlist_for_each_element(&bst->dev.vlans, vlan, node)
 386                         bridge_set_member_vlan(bm, vlan, true);
 387         }
 388
 389         device_set_present(&bst->dev, true);
 390         device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE);
 391
 392         return 0;
 393
 394 error:
 395         bst->n_failed++;
 396         bm->present = false;
 397         bst->n_present--;
 398         device_release(&bm->dev);
 399
 400         return ret;
 401 }
 402
 403 static void
 404 bridge_remove_member(struct bridge_member *bm)
 405 {
 406         struct bridge_state *bst = bm->bst;
 407
 408         if (!bm->present)
 409                 return;
 410
 411         if (bst->dev.active)
 412                 bridge_disable_member(bm);
 413
 414         bm->present = false;
 415         bm->bst->n_present--;
 416
 417         if (bm == bst->primary_port)
 418                 bridge_reset_primary(bst);
 419
 420         if (bst->config.bridge_empty)
 421                 return;
 422
 423         bst->force_active = false;
 424         if (bst->n_present == 0)
 425                 device_set_present(&bst->dev, false);
 426 }
 427
 428 static void
 429 bridge_free_member(struct bridge_member *bm)
 430 {
 431         struct bridge_state *bst = bm->bst;
 432         struct device *dev = bm->dev.dev;
 433         const char *ifname = dev->ifname;
 434         struct bridge_vlan *vlan;
 435
 436         bridge_remove_member(bm);
 437
 438         vlist_for_each_element(&bst->dev.vlans, vlan, node) {
 439                 struct bridge_vlan_hotplug_port *port, *tmp;
 440
 441                 list_for_each_entry_safe(port, tmp, &vlan->hotplug_ports, list) {
 442                         if (strcmp(port->port.ifname, ifname) != 0)
 443                                 continue;
 444
 445                         list_del(&port->list);
 446                         free(port);
 447                 }
 448         }
 449
 450         device_remove_user(&bm->dev);
 451
 452         /*
 453          * When reloading the config and moving a device from one bridge to
 454          * another, the other bridge may have tried to claim this device
 455          * before it was removed here.
 456          * Ensure that claiming the device is retried by toggling its present
 457          * state
 458          */
 459         if (dev->present) {
 460                 device_set_present(dev, false);
 461                 device_set_present(dev, true);
 462         }
 463
 464         free(bm);
 465 }
 466
 467 static void
 468 bridge_check_retry(struct bridge_state *bst)
 469 {
 470         if (!bst->n_failed)
 471                 return;
 472
 473         uloop_timeout_set(&bst->retry, 100);
 474 }
 475
 476 static void
 477 bridge_member_cb(struct device_user *dev, enum device_event ev)
 478 {
 479         struct bridge_member *bm = container_of(dev, struct bridge_member, dev);
 480         struct bridge_state *bst = bm->bst;
 481
 482         switch (ev) {
 483         case DEV_EVENT_ADD:
 484                 assert(!bm->present);
 485
 486                 bm->present = true;
 487                 bst->n_present++;
 488
 489                 if (bst->n_present == 1)
 490                         device_set_present(&bst->dev, true);
 491                 if (bst->dev.active && !bridge_enable_member(bm)) {
 492                         /*
 493                          * Adding a bridge member can overwrite the bridge mtu
 494                          * in the kernel, apply the bridge settings in case the
 495                          * bridge mtu is set
 496                          */
 497                         system_if_apply_settings(&bst->dev, &bst->dev.settings,
 498                                                  DEV_OPT_MTU | DEV_OPT_MTU6);
 499                 }
 500
 501                 break;
 502         case DEV_EVENT_REMOVE:
 503                 if (dev->hotplug) {
 504                         vlist_delete(&bst->members, &bm->node);
 505                         return;
 506                 }
 507
 508                 if (bm->present)
 509                         bridge_remove_member(bm);
 510
 511                 break;
 512         default:
 513                 return;
 514         }
 515 }
 516
 517 static int
 518 bridge_set_down(struct bridge_state *bst)
 519 {
 520         struct bridge_member *bm;
 521
 522         bst->set_state(&bst->dev, false);
 523
 524         vlist_for_each_element(&bst->members, bm, node)
 525                 bridge_disable_member(bm);
 526
 527         bridge_disable_interface(bst);
 528
 529         return 0;
 530 }
 531
 532 static int
 533 bridge_set_up(struct bridge_state *bst)
 534 {
 535         struct bridge_member *bm;
 536         int ret;
 537
 538         if (!bst->n_present) {
 539                 if (!bst->force_active)
 540                         return -ENOENT;
 541
 542                 ret = bridge_enable_interface(bst);
 543                 if (ret)
 544                         return ret;
 545         }
 546
 547         bst->n_failed = 0;
 548         vlist_for_each_element(&bst->members, bm, node)
 549                 bridge_enable_member(bm);
 550         bridge_check_retry(bst);
 551
 552         if (!bst->force_active && !bst->n_present) {
 553                 /* initialization of all member interfaces failed */
 554                 bridge_disable_interface(bst);
 555                 device_set_present(&bst->dev, false);
 556                 return -ENOENT;
 557         }
 558
 559         bridge_reset_primary(bst);
 560         ret = bst->set_state(&bst->dev, true);
 561         if (ret < 0)
 562                 bridge_set_down(bst);
 563
 564         return ret;
 565 }
 566
 567 static int
 568 bridge_set_state(struct device *dev, bool up)
 569 {
 570         struct bridge_state *bst;
 571
 572         bst = container_of(dev, struct bridge_state, dev);
 573
 574         if (up)
 575                 return bridge_set_up(bst);
 576         else
 577                 return bridge_set_down(bst);
 578 }
 579
 580 static struct bridge_member *
 581 bridge_create_member(struct bridge_state *bst, const char *name,
 582                      struct device *dev, bool hotplug)
 583 {
 584         struct bridge_member *bm;
 585
 586         bm = calloc(1, sizeof(*bm) + strlen(name) + 1);
 587         if (!bm)
 588                 return NULL;
 589
 590         bm->bst = bst;
 591         bm->dev.cb = bridge_member_cb;
 592         bm->dev.hotplug = hotplug;
 593         strcpy(bm->name, name);
 594         bm->dev.dev = dev;
 595         vlist_add(&bst->members, &bm->node, bm->name);
 596         /*
 597          * Need to look up the bridge member again as the above
 598          * created pointer will be freed in case the bridge member
 599          * already existed
 600          */
 601         bm = vlist_find(&bst->members, name, bm, node);
 602         if (hotplug && bm)
 603                 bm->node.version = -1;
 604
 605         return bm;
 606 }
 607
 608 static void
 609 bridge_member_update(struct vlist_tree *tree, struct vlist_node *node_new,
 610                      struct vlist_node *node_old)
 611 {
 612         struct bridge_member *bm;
 613         struct device *dev;
 614
 615         if (node_new) {
 616                 bm = container_of(node_new, struct bridge_member, node);
 617
 618                 if (node_old) {
 619                         free(bm);
 620                         return;
 621                 }
 622
 623                 dev = bm->dev.dev;
 624                 bm->dev.dev = NULL;
 625                 device_add_user(&bm->dev, dev);
 626         }
 627
 628
 629         if (node_old) {
 630                 bm = container_of(node_old, struct bridge_member, node);
 631                 bridge_free_member(bm);
 632         }
 633 }
 634
 635
 636 static void
 637 bridge_add_member(struct bridge_state *bst, const char *name)
 638 {
 639         struct device *dev;
 640
 641         dev = device_get(name, true);
 642         if (!dev)
 643                 return;
 644
 645         bridge_create_member(bst, name, dev, false);
 646 }
 647
 648 static void
 649 bridge_hotplug_create_member_vlans(struct bridge_state *bst, struct blob_attr *vlans, const char *ifname)
 650 {
 651         struct bridge_vlan *vlan;
 652         struct blob_attr *cur;
 653         int rem;
 654
 655         if (!vlans)
 656                 return;
 657
 658         blobmsg_for_each_attr(cur, vlans, rem) {
 659                 struct bridge_vlan_hotplug_port *port;
 660                 uint16_t flags = BRVLAN_F_UNTAGGED;
 661                 char *name_buf;
 662                 unsigned int vid;
 663                 char *end;
 664
 665                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 666                         continue;
 667
 668                 vid = strtoul(blobmsg_get_string(cur), &end, 0);
 669                 if (!vid || vid > 4095)
 670                         continue;
 671
 672                 vlan = vlist_find(&bst->dev.vlans, &vid, vlan, node);
 673                 if (!vlan)
 674                         continue;
 675
 676                 if (end && *end) {
 677                         if (*end != ':')
 678                                 continue;
 679
 680                         for (end++; *end; end++) {
 681                                 switch (*end) {
 682                                 case 't':
 683                                         flags &= ~BRVLAN_F_UNTAGGED;
 684                                         break;
 685                                 case '*':
 686                                         flags |= BRVLAN_F_PVID;
 687                                         break;
 688                                 }
 689                         }
 690                 }
 691
 692                 port = calloc_a(sizeof(*port), &name_buf, strlen(ifname) + 1);
 693                 if (!port)
 694                         continue;
 695
 696                 port->port.flags = flags;
 697                 port->port.ifname = strcpy(name_buf, ifname);
 698                 list_add_tail(&port->list, &vlan->hotplug_ports);
 699         }
 700 }
 701
 702 static int
 703 bridge_hotplug_add(struct device *dev, struct device *member, struct blob_attr *vlan)
 704 {
 705         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 706
 707         bridge_hotplug_create_member_vlans(bst, vlan, member->ifname);
 708         bridge_create_member(bst, member->ifname, member, true);
 709
 710         return 0;
 711 }
 712
 713 static int
 714 bridge_hotplug_del(struct device *dev, struct device *member)
 715 {
 716         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 717         struct bridge_member *bm;
 718
 719         bm = vlist_find(&bst->members, member->ifname, bm, node);
 720         if (!bm)
 721                 return UBUS_STATUS_NOT_FOUND;
 722
 723         vlist_delete(&bst->members, &bm->node);
 724         return 0;
 725 }
 726
 727 static int
 728 bridge_hotplug_prepare(struct device *dev)
 729 {
 730         struct bridge_state *bst;
 731
 732         bst = container_of(dev, struct bridge_state, dev);
 733         bst->force_active = true;
 734         device_set_present(&bst->dev, true);
 735
 736         return 0;
 737 }
 738
 739 static const struct device_hotplug_ops bridge_ops = {
 740         .prepare = bridge_hotplug_prepare,
 741         .add = bridge_hotplug_add,
 742         .del = bridge_hotplug_del
 743 };
 744
 745 static void
 746 bridge_free(struct device *dev)
 747 {
 748         struct bridge_state *bst;
 749
 750         bst = container_of(dev, struct bridge_state, dev);
 751         vlist_flush_all(&bst->members);
 752         vlist_flush_all(&dev->vlans);
 753         free(bst->config_data);
 754         free(bst);
 755 }
 756
 757 static void
 758 bridge_dump_port(struct blob_buf *b, struct bridge_vlan_port *port)
 759 {
 760         bool tagged = !(port->flags & BRVLAN_F_UNTAGGED);
 761         bool pvid = (port->flags & BRVLAN_F_PVID);
 762
 763         blobmsg_printf(b, "%s%s%s%s\n", port->ifname,
 764                 tagged || pvid ? ":" : "",
 765                 tagged ? "t" : "",
 766                 pvid ? "*" : "");
 767 }
 768
 769 static void
 770 bridge_dump_vlan(struct blob_buf *b, struct bridge_vlan *vlan)
 771 {
 772         struct bridge_vlan_hotplug_port *port;
 773         void *c, *p;
 774         int i;
 775
 776         c = blobmsg_open_table(b, NULL);
 777
 778         blobmsg_add_u32(b, "id", vlan->vid);
 779         blobmsg_add_u8(b, "local", vlan->local);
 780
 781         p = blobmsg_open_array(b, "ports");
 782
 783         for (i = 0; i < vlan->n_ports; i++)
 784             bridge_dump_port(b, &vlan->ports[i]);
 785
 786         list_for_each_entry(port, &vlan->hotplug_ports, list)
 787                 bridge_dump_port(b, &port->port);
 788
 789         blobmsg_close_array(b, p);
 790
 791         blobmsg_close_table(b, c);
 792 }
 793
 794 static void
 795 bridge_dump_info(struct device *dev, struct blob_buf *b)
 796 {
 797         struct bridge_state *bst;
 798         struct bridge_member *bm;
 799         struct bridge_vlan *vlan;
 800         void *list;
 801
 802         bst = container_of(dev, struct bridge_state, dev);
 803
 804         system_if_dump_info(dev, b);
 805         list = blobmsg_open_array(b, "bridge-members");
 806
 807         vlist_for_each_element(&bst->members, bm, node) {
 808                 if (bm->dev.dev->hidden)
 809                         continue;
 810
 811                 blobmsg_add_string(b, NULL, bm->dev.dev->ifname);
 812         }
 813
 814         blobmsg_close_array(b, list);
 815
 816         if (avl_is_empty(&dev->vlans.avl))
 817                 return;
 818
 819         list = blobmsg_open_array(b, "bridge-vlans");
 820
 821         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 822                 bridge_dump_vlan(b, vlan);
 823
 824         blobmsg_close_array(b, list);
 825 }
 826
 827 static void
 828 bridge_config_init(struct device *dev)
 829 {
 830         struct bridge_state *bst;
 831         struct bridge_vlan *vlan;
 832         struct blob_attr *cur;
 833         int i, rem;
 834
 835         bst = container_of(dev, struct bridge_state, dev);
 836
 837         if (bst->config.bridge_empty) {
 838                 bst->force_active = true;
 839                 device_set_present(&bst->dev, true);
 840         }
 841
 842         bst->n_failed = 0;
 843         vlist_update(&bst->members);
 844         if (bst->ifnames) {
 845                 blobmsg_for_each_attr(cur, bst->ifnames, rem) {
 846                         bridge_add_member(bst, blobmsg_data(cur));
 847                 }
 848         }
 849
 850         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 851                 for (i = 0; i < vlan->n_ports; i++)
 852                         bridge_add_member(bst, vlan->ports[i].ifname);
 853
 854         vlist_flush(&bst->members);
 855         bridge_check_retry(bst);
 856 }
 857
 858 static void
 859 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb)
 860 {
 861         struct bridge_config *cfg = &bst->config;
 862         struct blob_attr *cur;
 863
 864         /* defaults */
 865         cfg->stp = false;
 866         cfg->forward_delay = 2;
 867         cfg->robustness = 2;
 868         cfg->query_interval = 12500;
 869         cfg->query_response_interval = 1000;
 870         cfg->last_member_interval = 100;
 871         cfg->hash_max = 512;
 872         cfg->bridge_empty = false;
 873         cfg->priority = 0x7FFF;
 874         cfg->vlan_filtering = false;
 875
 876         if ((cur = tb[BRIDGE_ATTR_STP]))
 877                 cfg->stp = blobmsg_get_bool(cur);
 878
 879         if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY]))
 880                 cfg->forward_delay = blobmsg_get_u32(cur);
 881
 882         if ((cur = tb[BRIDGE_ATTR_PRIORITY]))
 883                 cfg->priority = blobmsg_get_u32(cur);
 884
 885         if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP]))
 886                 cfg->multicast_querier = cfg->igmp_snoop = blobmsg_get_bool(cur);
 887
 888         if ((cur = tb[BRIDGE_ATTR_MULTICAST_QUERIER]))
 889                 cfg->multicast_querier = blobmsg_get_bool(cur);
 890
 891         if ((cur = tb[BRIDGE_ATTR_HASH_MAX]))
 892                 cfg->hash_max = blobmsg_get_u32(cur);
 893
 894         if ((cur = tb[BRIDGE_ATTR_ROBUSTNESS])) {
 895                 cfg->robustness = blobmsg_get_u32(cur);
 896                 cfg->flags |= BRIDGE_OPT_ROBUSTNESS;
 897         }
 898
 899         if ((cur = tb[BRIDGE_ATTR_QUERY_INTERVAL])) {
 900                 cfg->query_interval = blobmsg_get_u32(cur);
 901                 cfg->flags |= BRIDGE_OPT_QUERY_INTERVAL;
 902         }
 903
 904         if ((cur = tb[BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL])) {
 905                 cfg->query_response_interval = blobmsg_get_u32(cur);
 906                 cfg->flags |= BRIDGE_OPT_QUERY_RESPONSE_INTERVAL;
 907         }
 908
 909         if ((cur = tb[BRIDGE_ATTR_LAST_MEMBER_INTERVAL])) {
 910                 cfg->last_member_interval = blobmsg_get_u32(cur);
 911                 cfg->flags |= BRIDGE_OPT_LAST_MEMBER_INTERVAL;
 912         }
 913
 914         if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) {
 915                 cfg->ageing_time = blobmsg_get_u32(cur);
 916                 cfg->flags |= BRIDGE_OPT_AGEING_TIME;
 917         }
 918
 919         if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) {
 920                 cfg->hello_time = blobmsg_get_u32(cur);
 921                 cfg->flags |= BRIDGE_OPT_HELLO_TIME;
 922         }
 923
 924         if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) {
 925                 cfg->max_age = blobmsg_get_u32(cur);
 926                 cfg->flags |= BRIDGE_OPT_MAX_AGE;
 927         }
 928
 929         if ((cur = tb[BRIDGE_ATTR_BRIDGE_EMPTY]))
 930                 cfg->bridge_empty = blobmsg_get_bool(cur);
 931
 932         if ((cur = tb[BRIDGE_ATTR_VLAN_FILTERING]))
 933                 cfg->vlan_filtering = blobmsg_get_bool(cur);
 934 }
 935
 936 static enum dev_change_type
 937 bridge_reload(struct device *dev, struct blob_attr *attr)
 938 {
 939         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 940         struct blob_attr *tb_br[__BRIDGE_ATTR_MAX];
 941         enum dev_change_type ret = DEV_CONFIG_APPLIED;
 942         unsigned long diff;
 943         struct bridge_state *bst;
 944
 945         BUILD_BUG_ON(sizeof(diff) < __BRIDGE_ATTR_MAX / 8);
 946         BUILD_BUG_ON(sizeof(diff) < __DEV_ATTR_MAX / 8);
 947
 948         bst = container_of(dev, struct bridge_state, dev);
 949         attr = blob_memdup(attr);
 950
 951         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 952                 blob_data(attr), blob_len(attr));
 953         blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
 954                 blob_data(attr), blob_len(attr));
 955
 956         if (tb_dev[DEV_ATTR_MACADDR])
 957                 bst->primary_port = NULL;
 958
 959         bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME];
 960         device_init_settings(dev, tb_dev);
 961         bridge_apply_settings(bst, tb_br);
 962
 963         if (bst->config_data) {
 964                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
 965                 struct blob_attr *otb_br[__BRIDGE_ATTR_MAX];
 966
 967                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
 968                         blob_data(bst->config_data), blob_len(bst->config_data));
 969
 970                 diff = 0;
 971                 uci_blob_diff(tb_dev, otb_dev, &device_attr_list, &diff);
 972                 if (diff)
 973                     ret = DEV_CONFIG_RESTART;
 974
 975                 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br,
 976                         blob_data(bst->config_data), blob_len(bst->config_data));
 977
 978                 diff = 0;
 979                 uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff);
 980                 if (diff & ~(1 << BRIDGE_ATTR_IFNAME))
 981                     ret = DEV_CONFIG_RESTART;
 982
 983                 bridge_config_init(dev);
 984         }
 985
 986         free(bst->config_data);
 987         bst->config_data = attr;
 988         return ret;
 989 }
 990
 991 static void
 992 bridge_retry_members(struct uloop_timeout *timeout)
 993 {
 994         struct bridge_state *bst = container_of(timeout, struct bridge_state, retry);
 995         struct bridge_member *bm;
 996
 997         bst->n_failed = 0;
 998         vlist_for_each_element(&bst->members, bm, node) {
 999                 if (bm->present)
1000                         continue;
1001
1002                 if (!bm->dev.dev->present)
1003                         continue;
1004
1005                 bm->present = true;
1006                 bst->n_present++;
1007                 bridge_enable_member(bm);
1008         }
1009 }
1010
1011 static int bridge_avl_cmp_u16(const void *k1, const void *k2, void *ptr)
1012 {
1013         const uint16_t *i1 = k1, *i2 = k2;
1014
1015         return *i1 - *i2;
1016 }
1017
1018 static bool
1019 bridge_vlan_equal(struct bridge_vlan *v1, struct bridge_vlan *v2)
1020 {
1021         int i;
1022
1023         if (v1->n_ports != v2->n_ports)
1024                 return false;
1025
1026         for (i = 0; i < v1->n_ports; i++)
1027                 if (v1->ports[i].flags != v2->ports[i].flags ||
1028                     strcmp(v1->ports[i].ifname, v2->ports[i].ifname) != 0)
1029                         return false;
1030
1031         return true;
1032 }
1033
1034 static void
1035 bridge_vlan_free(struct bridge_vlan *vlan)
1036 {
1037         struct bridge_vlan_hotplug_port *port, *tmp;
1038
1039         if (!vlan)
1040                 return;
1041
1042         list_for_each_entry_safe(port, tmp, &vlan->hotplug_ports, list)
1043                 free(port);
1044
1045         free(vlan);
1046 }
1047
1048 static void
1049 bridge_vlan_update(struct vlist_tree *tree, struct vlist_node *node_new,
1050                    struct vlist_node *node_old)
1051 {
1052         struct bridge_state *bst = container_of(tree, struct bridge_state, dev.vlans);
1053         struct bridge_vlan *vlan_new = NULL, *vlan_old = NULL;
1054
1055         if (!bst->config.vlan_filtering || !bst->active)
1056                 goto out;
1057
1058         if (node_old)
1059                 vlan_old = container_of(node_old, struct bridge_vlan, node);
1060         if (node_new)
1061                 vlan_new = container_of(node_new, struct bridge_vlan, node);
1062
1063         if (node_new && node_old && bridge_vlan_equal(vlan_old, vlan_new))
1064                 goto out;
1065
1066         if (node_old)
1067                 bridge_set_vlan_state(bst, vlan_old, false);
1068
1069         if (node_old && node_new)
1070                 list_splice_init(&vlan_old->hotplug_ports, &vlan_new->hotplug_ports);
1071
1072         if (node_new)
1073                 bridge_set_vlan_state(bst, vlan_new, true);
1074
1075         bst->dev.config_pending = true;
1076
1077 out:
1078         bridge_vlan_free(vlan_old);
1079 }
1080
1081 static struct device *
1082 bridge_create(const char *name, struct device_type *devtype,
1083         struct blob_attr *attr)
1084 {
1085         struct bridge_state *bst;
1086         struct device *dev = NULL;
1087
1088         bst = calloc(1, sizeof(*bst));
1089         if (!bst)
1090                 return NULL;
1091
1092         dev = &bst->dev;
1093
1094         if (device_init(dev, devtype, name) < 0) {
1095                 device_cleanup(dev);
1096                 free(bst);
1097                 return NULL;
1098         }
1099
1100         dev->config_pending = true;
1101         bst->retry.cb = bridge_retry_members;
1102
1103         bst->set_state = dev->set_state;
1104         dev->set_state = bridge_set_state;
1105
1106         dev->hotplug_ops = &bridge_ops;
1107
1108         vlist_init(&bst->members, avl_strcmp, bridge_member_update);
1109         bst->members.keep_old = true;
1110
1111         vlist_init(&dev->vlans, bridge_avl_cmp_u16, bridge_vlan_update);
1112
1113         bridge_reload(dev, attr);
1114
1115         return dev;
1116 }
1117
1118 static void __init bridge_device_type_init(void)
1119 {
1120         device_type_add(&bridge_device_type);
1121 }