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_lock();
 451
 452         device_remove_user(&bm->dev);
 453
 454         /*
 455          * When reloading the config and moving a device from one bridge to
 456          * another, the other bridge may have tried to claim this device
 457          * before it was removed here.
 458          * Ensure that claiming the device is retried by toggling its present
 459          * state
 460          */
 461         if (dev->present) {
 462                 device_set_present(dev, false);
 463                 device_set_present(dev, true);
 464         }
 465
 466         device_unlock();
 467
 468         free(bm);
 469 }
 470
 471 static void
 472 bridge_check_retry(struct bridge_state *bst)
 473 {
 474         if (!bst->n_failed)
 475                 return;
 476
 477         uloop_timeout_set(&bst->retry, 100);
 478 }
 479
 480 static void
 481 bridge_member_cb(struct device_user *dev, enum device_event ev)
 482 {
 483         struct bridge_member *bm = container_of(dev, struct bridge_member, dev);
 484         struct bridge_state *bst = bm->bst;
 485
 486         switch (ev) {
 487         case DEV_EVENT_ADD:
 488                 assert(!bm->present);
 489
 490                 bm->present = true;
 491                 bst->n_present++;
 492
 493                 if (bst->n_present == 1)
 494                         device_set_present(&bst->dev, true);
 495                 if (bst->dev.active && !bridge_enable_member(bm)) {
 496                         /*
 497                          * Adding a bridge member can overwrite the bridge mtu
 498                          * in the kernel, apply the bridge settings in case the
 499                          * bridge mtu is set
 500                          */
 501                         system_if_apply_settings(&bst->dev, &bst->dev.settings,
 502                                                  DEV_OPT_MTU | DEV_OPT_MTU6);
 503                 }
 504
 505                 break;
 506         case DEV_EVENT_REMOVE:
 507                 if (dev->hotplug) {
 508                         vlist_delete(&bst->members, &bm->node);
 509                         return;
 510                 }
 511
 512                 if (bm->present)
 513                         bridge_remove_member(bm);
 514
 515                 break;
 516         default:
 517                 return;
 518         }
 519 }
 520
 521 static int
 522 bridge_set_down(struct bridge_state *bst)
 523 {
 524         struct bridge_member *bm;
 525
 526         bst->set_state(&bst->dev, false);
 527
 528         vlist_for_each_element(&bst->members, bm, node)
 529                 bridge_disable_member(bm);
 530
 531         bridge_disable_interface(bst);
 532
 533         return 0;
 534 }
 535
 536 static int
 537 bridge_set_up(struct bridge_state *bst)
 538 {
 539         struct bridge_member *bm;
 540         int ret;
 541
 542         if (!bst->n_present) {
 543                 if (!bst->force_active)
 544                         return -ENOENT;
 545
 546                 ret = bridge_enable_interface(bst);
 547                 if (ret)
 548                         return ret;
 549         }
 550
 551         bst->n_failed = 0;
 552         vlist_for_each_element(&bst->members, bm, node)
 553                 bridge_enable_member(bm);
 554         bridge_check_retry(bst);
 555
 556         if (!bst->force_active && !bst->n_present) {
 557                 /* initialization of all member interfaces failed */
 558                 bridge_disable_interface(bst);
 559                 device_set_present(&bst->dev, false);
 560                 return -ENOENT;
 561         }
 562
 563         bridge_reset_primary(bst);
 564         ret = bst->set_state(&bst->dev, true);
 565         if (ret < 0)
 566                 bridge_set_down(bst);
 567
 568         return ret;
 569 }
 570
 571 static int
 572 bridge_set_state(struct device *dev, bool up)
 573 {
 574         struct bridge_state *bst;
 575
 576         bst = container_of(dev, struct bridge_state, dev);
 577
 578         if (up)
 579                 return bridge_set_up(bst);
 580         else
 581                 return bridge_set_down(bst);
 582 }
 583
 584 static struct bridge_member *
 585 bridge_create_member(struct bridge_state *bst, const char *name,
 586                      struct device *dev, bool hotplug)
 587 {
 588         struct bridge_member *bm;
 589
 590         bm = calloc(1, sizeof(*bm) + strlen(name) + 1);
 591         if (!bm)
 592                 return NULL;
 593
 594         bm->bst = bst;
 595         bm->dev.cb = bridge_member_cb;
 596         bm->dev.hotplug = hotplug;
 597         strcpy(bm->name, name);
 598         bm->dev.dev = dev;
 599         vlist_add(&bst->members, &bm->node, bm->name);
 600         /*
 601          * Need to look up the bridge member again as the above
 602          * created pointer will be freed in case the bridge member
 603          * already existed
 604          */
 605         bm = vlist_find(&bst->members, name, bm, node);
 606         if (hotplug && bm)
 607                 bm->node.version = -1;
 608
 609         return bm;
 610 }
 611
 612 static void
 613 bridge_member_update(struct vlist_tree *tree, struct vlist_node *node_new,
 614                      struct vlist_node *node_old)
 615 {
 616         struct bridge_member *bm;
 617         struct device *dev;
 618
 619         if (node_new) {
 620                 bm = container_of(node_new, struct bridge_member, node);
 621
 622                 if (node_old) {
 623                         free(bm);
 624                         return;
 625                 }
 626
 627                 dev = bm->dev.dev;
 628                 bm->dev.dev = NULL;
 629                 device_add_user(&bm->dev, dev);
 630         }
 631
 632
 633         if (node_old) {
 634                 bm = container_of(node_old, struct bridge_member, node);
 635                 bridge_free_member(bm);
 636         }
 637 }
 638
 639
 640 static void
 641 bridge_add_member(struct bridge_state *bst, const char *name)
 642 {
 643         struct device *dev;
 644
 645         dev = device_get(name, true);
 646         if (!dev)
 647                 return;
 648
 649         bridge_create_member(bst, name, dev, false);
 650 }
 651
 652 static void
 653 bridge_hotplug_create_member_vlans(struct bridge_state *bst, struct blob_attr *vlans, const char *ifname)
 654 {
 655         struct bridge_vlan *vlan;
 656         struct blob_attr *cur;
 657         int rem;
 658
 659         if (!vlans)
 660                 return;
 661
 662         blobmsg_for_each_attr(cur, vlans, rem) {
 663                 struct bridge_vlan_hotplug_port *port;
 664                 uint16_t flags = BRVLAN_F_UNTAGGED;
 665                 char *name_buf;
 666                 unsigned int vid;
 667                 char *end;
 668
 669                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 670                         continue;
 671
 672                 vid = strtoul(blobmsg_get_string(cur), &end, 0);
 673                 if (!vid || vid > 4095)
 674                         continue;
 675
 676                 vlan = vlist_find(&bst->dev.vlans, &vid, vlan, node);
 677                 if (!vlan)
 678                         continue;
 679
 680                 if (end && *end) {
 681                         if (*end != ':')
 682                                 continue;
 683
 684                         for (end++; *end; end++) {
 685                                 switch (*end) {
 686                                 case 't':
 687                                         flags &= ~BRVLAN_F_UNTAGGED;
 688                                         break;
 689                                 case '*':
 690                                         flags |= BRVLAN_F_PVID;
 691                                         break;
 692                                 }
 693                         }
 694                 }
 695
 696                 port = calloc_a(sizeof(*port), &name_buf, strlen(ifname) + 1);
 697                 if (!port)
 698                         continue;
 699
 700                 port->port.flags = flags;
 701                 port->port.ifname = strcpy(name_buf, ifname);
 702                 list_add_tail(&port->list, &vlan->hotplug_ports);
 703         }
 704 }
 705
 706 static int
 707 bridge_hotplug_add(struct device *dev, struct device *member, struct blob_attr *vlan)
 708 {
 709         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 710
 711         bridge_hotplug_create_member_vlans(bst, vlan, member->ifname);
 712         bridge_create_member(bst, member->ifname, member, true);
 713
 714         return 0;
 715 }
 716
 717 static int
 718 bridge_hotplug_del(struct device *dev, struct device *member)
 719 {
 720         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 721         struct bridge_member *bm;
 722
 723         bm = vlist_find(&bst->members, member->ifname, bm, node);
 724         if (!bm)
 725                 return UBUS_STATUS_NOT_FOUND;
 726
 727         vlist_delete(&bst->members, &bm->node);
 728         return 0;
 729 }
 730
 731 static int
 732 bridge_hotplug_prepare(struct device *dev)
 733 {
 734         struct bridge_state *bst;
 735
 736         bst = container_of(dev, struct bridge_state, dev);
 737         bst->force_active = true;
 738         device_set_present(&bst->dev, true);
 739
 740         return 0;
 741 }
 742
 743 static const struct device_hotplug_ops bridge_ops = {
 744         .prepare = bridge_hotplug_prepare,
 745         .add = bridge_hotplug_add,
 746         .del = bridge_hotplug_del
 747 };
 748
 749 static void
 750 bridge_free(struct device *dev)
 751 {
 752         struct bridge_state *bst;
 753
 754         bst = container_of(dev, struct bridge_state, dev);
 755         vlist_flush_all(&bst->members);
 756         vlist_flush_all(&dev->vlans);
 757         free(bst->config_data);
 758         free(bst);
 759 }
 760
 761 static void
 762 bridge_dump_port(struct blob_buf *b, struct bridge_vlan_port *port)
 763 {
 764         bool tagged = !(port->flags & BRVLAN_F_UNTAGGED);
 765         bool pvid = (port->flags & BRVLAN_F_PVID);
 766
 767         blobmsg_printf(b, "%s%s%s%s\n", port->ifname,
 768                 tagged || pvid ? ":" : "",
 769                 tagged ? "t" : "",
 770                 pvid ? "*" : "");
 771 }
 772
 773 static void
 774 bridge_dump_vlan(struct blob_buf *b, struct bridge_vlan *vlan)
 775 {
 776         struct bridge_vlan_hotplug_port *port;
 777         void *c, *p;
 778         int i;
 779
 780         c = blobmsg_open_table(b, NULL);
 781
 782         blobmsg_add_u32(b, "id", vlan->vid);
 783         blobmsg_add_u8(b, "local", vlan->local);
 784
 785         p = blobmsg_open_array(b, "ports");
 786
 787         for (i = 0; i < vlan->n_ports; i++)
 788             bridge_dump_port(b, &vlan->ports[i]);
 789
 790         list_for_each_entry(port, &vlan->hotplug_ports, list)
 791                 bridge_dump_port(b, &port->port);
 792
 793         blobmsg_close_array(b, p);
 794
 795         blobmsg_close_table(b, c);
 796 }
 797
 798 static void
 799 bridge_dump_info(struct device *dev, struct blob_buf *b)
 800 {
 801         struct bridge_state *bst;
 802         struct bridge_member *bm;
 803         struct bridge_vlan *vlan;
 804         void *list;
 805
 806         bst = container_of(dev, struct bridge_state, dev);
 807
 808         system_if_dump_info(dev, b);
 809         list = blobmsg_open_array(b, "bridge-members");
 810
 811         vlist_for_each_element(&bst->members, bm, node) {
 812                 if (bm->dev.dev->hidden)
 813                         continue;
 814
 815                 blobmsg_add_string(b, NULL, bm->dev.dev->ifname);
 816         }
 817
 818         blobmsg_close_array(b, list);
 819
 820         if (avl_is_empty(&dev->vlans.avl))
 821                 return;
 822
 823         list = blobmsg_open_array(b, "bridge-vlans");
 824
 825         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 826                 bridge_dump_vlan(b, vlan);
 827
 828         blobmsg_close_array(b, list);
 829 }
 830
 831 static void
 832 bridge_config_init(struct device *dev)
 833 {
 834         struct bridge_state *bst;
 835         struct bridge_vlan *vlan;
 836         struct blob_attr *cur;
 837         int i, rem;
 838
 839         bst = container_of(dev, struct bridge_state, dev);
 840
 841         if (bst->config.bridge_empty) {
 842                 bst->force_active = true;
 843                 device_set_present(&bst->dev, true);
 844         }
 845
 846         bst->n_failed = 0;
 847         vlist_update(&bst->members);
 848         if (bst->ifnames) {
 849                 blobmsg_for_each_attr(cur, bst->ifnames, rem) {
 850                         bridge_add_member(bst, blobmsg_data(cur));
 851                 }
 852         }
 853
 854         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 855                 for (i = 0; i < vlan->n_ports; i++)
 856                         bridge_add_member(bst, vlan->ports[i].ifname);
 857
 858         vlist_flush(&bst->members);
 859         bridge_check_retry(bst);
 860 }
 861
 862 static void
 863 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb)
 864 {
 865         struct bridge_config *cfg = &bst->config;
 866         struct blob_attr *cur;
 867
 868         /* defaults */
 869         cfg->stp = false;
 870         cfg->forward_delay = 2;
 871         cfg->robustness = 2;
 872         cfg->query_interval = 12500;
 873         cfg->query_response_interval = 1000;
 874         cfg->last_member_interval = 100;
 875         cfg->hash_max = 512;
 876         cfg->bridge_empty = false;
 877         cfg->priority = 0x7FFF;
 878         cfg->vlan_filtering = false;
 879
 880         if ((cur = tb[BRIDGE_ATTR_STP]))
 881                 cfg->stp = blobmsg_get_bool(cur);
 882
 883         if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY]))
 884                 cfg->forward_delay = blobmsg_get_u32(cur);
 885
 886         if ((cur = tb[BRIDGE_ATTR_PRIORITY]))
 887                 cfg->priority = blobmsg_get_u32(cur);
 888
 889         if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP]))
 890                 cfg->multicast_querier = cfg->igmp_snoop = blobmsg_get_bool(cur);
 891
 892         if ((cur = tb[BRIDGE_ATTR_MULTICAST_QUERIER]))
 893                 cfg->multicast_querier = blobmsg_get_bool(cur);
 894
 895         if ((cur = tb[BRIDGE_ATTR_HASH_MAX]))
 896                 cfg->hash_max = blobmsg_get_u32(cur);
 897
 898         if ((cur = tb[BRIDGE_ATTR_ROBUSTNESS])) {
 899                 cfg->robustness = blobmsg_get_u32(cur);
 900                 cfg->flags |= BRIDGE_OPT_ROBUSTNESS;
 901         }
 902
 903         if ((cur = tb[BRIDGE_ATTR_QUERY_INTERVAL])) {
 904                 cfg->query_interval = blobmsg_get_u32(cur);
 905                 cfg->flags |= BRIDGE_OPT_QUERY_INTERVAL;
 906         }
 907
 908         if ((cur = tb[BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL])) {
 909                 cfg->query_response_interval = blobmsg_get_u32(cur);
 910                 cfg->flags |= BRIDGE_OPT_QUERY_RESPONSE_INTERVAL;
 911         }
 912
 913         if ((cur = tb[BRIDGE_ATTR_LAST_MEMBER_INTERVAL])) {
 914                 cfg->last_member_interval = blobmsg_get_u32(cur);
 915                 cfg->flags |= BRIDGE_OPT_LAST_MEMBER_INTERVAL;
 916         }
 917
 918         if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) {
 919                 cfg->ageing_time = blobmsg_get_u32(cur);
 920                 cfg->flags |= BRIDGE_OPT_AGEING_TIME;
 921         }
 922
 923         if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) {
 924                 cfg->hello_time = blobmsg_get_u32(cur);
 925                 cfg->flags |= BRIDGE_OPT_HELLO_TIME;
 926         }
 927
 928         if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) {
 929                 cfg->max_age = blobmsg_get_u32(cur);
 930                 cfg->flags |= BRIDGE_OPT_MAX_AGE;
 931         }
 932
 933         if ((cur = tb[BRIDGE_ATTR_BRIDGE_EMPTY]))
 934                 cfg->bridge_empty = blobmsg_get_bool(cur);
 935
 936         if ((cur = tb[BRIDGE_ATTR_VLAN_FILTERING]))
 937                 cfg->vlan_filtering = blobmsg_get_bool(cur);
 938 }
 939
 940 static enum dev_change_type
 941 bridge_reload(struct device *dev, struct blob_attr *attr)
 942 {
 943         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 944         struct blob_attr *tb_br[__BRIDGE_ATTR_MAX];
 945         enum dev_change_type ret = DEV_CONFIG_APPLIED;
 946         unsigned long diff;
 947         struct bridge_state *bst;
 948
 949         BUILD_BUG_ON(sizeof(diff) < __BRIDGE_ATTR_MAX / 8);
 950         BUILD_BUG_ON(sizeof(diff) < __DEV_ATTR_MAX / 8);
 951
 952         bst = container_of(dev, struct bridge_state, dev);
 953         attr = blob_memdup(attr);
 954
 955         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 956                 blob_data(attr), blob_len(attr));
 957         blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
 958                 blob_data(attr), blob_len(attr));
 959
 960         if (tb_dev[DEV_ATTR_MACADDR])
 961                 bst->primary_port = NULL;
 962
 963         bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME];
 964         device_init_settings(dev, tb_dev);
 965         bridge_apply_settings(bst, tb_br);
 966
 967         if (bst->config_data) {
 968                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
 969                 struct blob_attr *otb_br[__BRIDGE_ATTR_MAX];
 970
 971                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
 972                         blob_data(bst->config_data), blob_len(bst->config_data));
 973
 974                 diff = 0;
 975                 uci_blob_diff(tb_dev, otb_dev, &device_attr_list, &diff);
 976                 if (diff)
 977                     ret = DEV_CONFIG_RESTART;
 978
 979                 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br,
 980                         blob_data(bst->config_data), blob_len(bst->config_data));
 981
 982                 diff = 0;
 983                 uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff);
 984                 if (diff & ~(1 << BRIDGE_ATTR_IFNAME))
 985                     ret = DEV_CONFIG_RESTART;
 986
 987                 bridge_config_init(dev);
 988         }
 989
 990         free(bst->config_data);
 991         bst->config_data = attr;
 992         return ret;
 993 }
 994
 995 static void
 996 bridge_retry_members(struct uloop_timeout *timeout)
 997 {
 998         struct bridge_state *bst = container_of(timeout, struct bridge_state, retry);
 999         struct bridge_member *bm;
1000
1001         bst->n_failed = 0;
1002         vlist_for_each_element(&bst->members, bm, node) {
1003                 if (bm->present)
1004                         continue;
1005
1006                 if (!bm->dev.dev->present)
1007                         continue;
1008
1009                 bm->present = true;
1010                 bst->n_present++;
1011                 bridge_enable_member(bm);
1012         }
1013 }
1014
1015 static int bridge_avl_cmp_u16(const void *k1, const void *k2, void *ptr)
1016 {
1017         const uint16_t *i1 = k1, *i2 = k2;
1018
1019         return *i1 - *i2;
1020 }
1021
1022 static bool
1023 bridge_vlan_equal(struct bridge_vlan *v1, struct bridge_vlan *v2)
1024 {
1025         int i;
1026
1027         if (v1->n_ports != v2->n_ports)
1028                 return false;
1029
1030         for (i = 0; i < v1->n_ports; i++)
1031                 if (v1->ports[i].flags != v2->ports[i].flags ||
1032                     strcmp(v1->ports[i].ifname, v2->ports[i].ifname) != 0)
1033                         return false;
1034
1035         return true;
1036 }
1037
1038 static void
1039 bridge_vlan_free(struct bridge_vlan *vlan)
1040 {
1041         struct bridge_vlan_hotplug_port *port, *tmp;
1042
1043         if (!vlan)
1044                 return;
1045
1046         list_for_each_entry_safe(port, tmp, &vlan->hotplug_ports, list)
1047                 free(port);
1048
1049         free(vlan);
1050 }
1051
1052 static void
1053 bridge_vlan_update(struct vlist_tree *tree, struct vlist_node *node_new,
1054                    struct vlist_node *node_old)
1055 {
1056         struct bridge_state *bst = container_of(tree, struct bridge_state, dev.vlans);
1057         struct bridge_vlan *vlan_new = NULL, *vlan_old = NULL;
1058
1059         if (!bst->config.vlan_filtering || !bst->active)
1060                 goto out;
1061
1062         if (node_old)
1063                 vlan_old = container_of(node_old, struct bridge_vlan, node);
1064         if (node_new)
1065                 vlan_new = container_of(node_new, struct bridge_vlan, node);
1066
1067         if (node_new && node_old && bridge_vlan_equal(vlan_old, vlan_new)) {
1068                 list_splice_init(&vlan_old->hotplug_ports, &vlan_new->hotplug_ports);
1069                 goto out;
1070         }
1071
1072         if (node_old)
1073                 bridge_set_vlan_state(bst, vlan_old, false);
1074
1075         if (node_old && node_new)
1076                 list_splice_init(&vlan_old->hotplug_ports, &vlan_new->hotplug_ports);
1077
1078         if (node_new)
1079                 bridge_set_vlan_state(bst, vlan_new, true);
1080
1081         bst->dev.config_pending = true;
1082
1083 out:
1084         bridge_vlan_free(vlan_old);
1085 }
1086
1087 static struct device *
1088 bridge_create(const char *name, struct device_type *devtype,
1089         struct blob_attr *attr)
1090 {
1091         struct bridge_state *bst;
1092         struct device *dev = NULL;
1093
1094         bst = calloc(1, sizeof(*bst));
1095         if (!bst)
1096                 return NULL;
1097
1098         dev = &bst->dev;
1099
1100         if (device_init(dev, devtype, name) < 0) {
1101                 device_cleanup(dev);
1102                 free(bst);
1103                 return NULL;
1104         }
1105
1106         dev->config_pending = true;
1107         bst->retry.cb = bridge_retry_members;
1108
1109         bst->set_state = dev->set_state;
1110         dev->set_state = bridge_set_state;
1111
1112         dev->hotplug_ops = &bridge_ops;
1113
1114         vlist_init(&bst->members, avl_strcmp, bridge_member_update);
1115         bst->members.keep_old = true;
1116
1117         vlist_init(&dev->vlans, bridge_avl_cmp_u16, bridge_vlan_update);
1118
1119         bridge_reload(dev, attr);
1120
1121         return dev;
1122 }
1123
1124 static void __init bridge_device_type_init(void)
1125 {
1126         device_type_add(&bridge_device_type);
1127 }