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