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 struct bridge_vlan_hotplug_port *
 710 bridge_hotplug_get_vlan_port(struct bridge_vlan *vlan, const char *ifname)
 711 {
 712         struct bridge_vlan_hotplug_port *port;
 713
 714         list_for_each_entry(port, &vlan->hotplug_ports, list)
 715                 if (!strcmp(port->port.ifname, ifname))
 716                         return port;
 717
 718         return NULL;
 719 }
 720
 721 static void
 722 bridge_hotplug_set_member_vlans(struct bridge_state *bst, struct blob_attr *vlans,
 723                                 const char *ifname, struct bridge_member *bm, bool add)
 724 {
 725         struct bridge_vlan *vlan;
 726         struct blob_attr *cur;
 727         int rem;
 728
 729         if (!vlans)
 730                 return;
 731
 732         blobmsg_for_each_attr(cur, vlans, rem) {
 733                 struct bridge_vlan_hotplug_port *port;
 734                 uint16_t flags = BRVLAN_F_UNTAGGED;
 735                 char *name_buf;
 736                 unsigned int vid;
 737                 char *end;
 738
 739                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 740                         continue;
 741
 742                 vid = strtoul(blobmsg_get_string(cur), &end, 0);
 743                 if (!vid || vid > 4095)
 744                         continue;
 745
 746                 vlan = bridge_hotplug_get_vlan(bst, vid);
 747                 if (!vlan)
 748                         continue;
 749
 750                 if (end && *end) {
 751                         if (*end != ':')
 752                                 continue;
 753
 754                         for (end++; *end; end++) {
 755                                 switch (*end) {
 756                                 case 't':
 757                                         flags &= ~BRVLAN_F_UNTAGGED;
 758                                         break;
 759                                 case '*':
 760                                         flags |= BRVLAN_F_PVID;
 761                                         break;
 762                                 }
 763                         }
 764                 }
 765
 766                 port = bridge_hotplug_get_vlan_port(vlan, ifname);
 767                 if (!add) {
 768                         if (!port)
 769                                 continue;
 770
 771                         __bridge_set_member_vlan(bm, vlan, &port->port, false);
 772                         list_del(&port->list);
 773                         free(port);
 774                         continue;
 775                 }
 776
 777                 if (port) {
 778                         if (port->port.flags == flags)
 779                                 continue;
 780
 781                         __bridge_set_member_vlan(bm, vlan, &port->port, false);
 782                         port->port.flags = flags;
 783                         __bridge_set_member_vlan(bm, vlan, &port->port, true);
 784                         continue;
 785                 }
 786
 787                 port = calloc_a(sizeof(*port), &name_buf, strlen(ifname) + 1);
 788                 if (!port)
 789                         continue;
 790
 791                 port->port.flags = flags;
 792                 port->port.ifname = strcpy(name_buf, ifname);
 793                 list_add_tail(&port->list, &vlan->hotplug_ports);
 794
 795                 if (!bm)
 796                         continue;
 797
 798                 __bridge_set_member_vlan(bm, vlan, &port->port, true);
 799         }
 800 }
 801
 802 static int
 803 bridge_hotplug_add(struct device *dev, struct device *member, struct blob_attr *vlan)
 804 {
 805         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 806         struct bridge_member *bm;
 807
 808         bm = vlist_find(&bst->members, member->ifname, bm, node);
 809         bridge_hotplug_set_member_vlans(bst, vlan, member->ifname, bm, true);
 810         if (!bm)
 811                 bridge_create_member(bst, member->ifname, member, true);
 812
 813         return 0;
 814 }
 815
 816 static int
 817 bridge_hotplug_del(struct device *dev, struct device *member, struct blob_attr *vlan)
 818 {
 819         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 820         struct bridge_member *bm;
 821
 822         bm = vlist_find(&bst->members, member->ifname, bm, node);
 823         if (!bm)
 824                 return UBUS_STATUS_NOT_FOUND;
 825
 826         bridge_hotplug_set_member_vlans(bst, vlan, member->ifname, bm, false);
 827         if (!bm->dev.hotplug)
 828                 return 0;
 829
 830         vlist_delete(&bst->members, &bm->node);
 831         return 0;
 832 }
 833
 834 static int
 835 bridge_hotplug_prepare(struct device *dev, struct device **bridge_dev)
 836 {
 837         struct bridge_state *bst;
 838
 839         if (bridge_dev)
 840                 *bridge_dev = dev;
 841
 842         bst = container_of(dev, struct bridge_state, dev);
 843         bst->force_active = true;
 844         device_set_present(&bst->dev, true);
 845
 846         return 0;
 847 }
 848
 849 static const struct device_hotplug_ops bridge_ops = {
 850         .prepare = bridge_hotplug_prepare,
 851         .add = bridge_hotplug_add,
 852         .del = bridge_hotplug_del
 853 };
 854
 855 static void
 856 bridge_free(struct device *dev)
 857 {
 858         struct bridge_state *bst;
 859
 860         bst = container_of(dev, struct bridge_state, dev);
 861         vlist_flush_all(&bst->members);
 862         vlist_flush_all(&dev->vlans);
 863         kvlist_free(&dev->vlan_aliases);
 864         free(bst->config_data);
 865         free(bst);
 866 }
 867
 868 static void
 869 bridge_dump_port(struct blob_buf *b, struct bridge_vlan_port *port)
 870 {
 871         bool tagged = !(port->flags & BRVLAN_F_UNTAGGED);
 872         bool pvid = (port->flags & BRVLAN_F_PVID);
 873
 874         blobmsg_printf(b, "%s%s%s%s\n", port->ifname,
 875                 tagged || pvid ? ":" : "",
 876                 tagged ? "t" : "",
 877                 pvid ? "*" : "");
 878 }
 879
 880 static void
 881 bridge_dump_vlan(struct blob_buf *b, struct bridge_vlan *vlan)
 882 {
 883         struct bridge_vlan_hotplug_port *port;
 884         void *c, *p;
 885         int i;
 886
 887         c = blobmsg_open_table(b, NULL);
 888
 889         blobmsg_add_u32(b, "id", vlan->vid);
 890         blobmsg_add_u8(b, "local", vlan->local);
 891
 892         p = blobmsg_open_array(b, "ports");
 893
 894         for (i = 0; i < vlan->n_ports; i++)
 895             bridge_dump_port(b, &vlan->ports[i]);
 896
 897         list_for_each_entry(port, &vlan->hotplug_ports, list)
 898                 bridge_dump_port(b, &port->port);
 899
 900         blobmsg_close_array(b, p);
 901
 902         blobmsg_close_table(b, c);
 903 }
 904
 905 static void
 906 bridge_dump_info(struct device *dev, struct blob_buf *b)
 907 {
 908         struct bridge_state *bst;
 909         struct bridge_member *bm;
 910         struct bridge_vlan *vlan;
 911         void *list;
 912
 913         bst = container_of(dev, struct bridge_state, dev);
 914
 915         system_if_dump_info(dev, b);
 916         list = blobmsg_open_array(b, "bridge-members");
 917
 918         vlist_for_each_element(&bst->members, bm, node) {
 919                 if (bm->dev.dev->hidden)
 920                         continue;
 921
 922                 blobmsg_add_string(b, NULL, bm->dev.dev->ifname);
 923         }
 924
 925         blobmsg_close_array(b, list);
 926
 927         if (avl_is_empty(&dev->vlans.avl))
 928                 return;
 929
 930         list = blobmsg_open_array(b, "bridge-vlans");
 931
 932         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 933                 bridge_dump_vlan(b, vlan);
 934
 935         blobmsg_close_array(b, list);
 936 }
 937
 938 static void
 939 bridge_config_init(struct device *dev)
 940 {
 941         struct bridge_state *bst;
 942         struct bridge_vlan *vlan;
 943         struct blob_attr *cur;
 944         int i, rem;
 945
 946         bst = container_of(dev, struct bridge_state, dev);
 947
 948         if (bst->config.bridge_empty) {
 949                 bst->force_active = true;
 950                 device_set_present(&bst->dev, true);
 951         }
 952
 953         bst->n_failed = 0;
 954         vlist_update(&bst->members);
 955         if (bst->ports) {
 956                 blobmsg_for_each_attr(cur, bst->ports, rem) {
 957                         bridge_add_member(bst, blobmsg_data(cur));
 958                 }
 959         }
 960
 961         vlist_for_each_element(&bst->dev.vlans, vlan, node)
 962                 for (i = 0; i < vlan->n_ports; i++)
 963                         bridge_add_member(bst, vlan->ports[i].ifname);
 964
 965         vlist_flush(&bst->members);
 966         bridge_check_retry(bst);
 967 }
 968
 969 static void
 970 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb)
 971 {
 972         struct bridge_config *cfg = &bst->config;
 973         struct blob_attr *cur;
 974
 975         /* defaults */
 976         cfg->stp = false;
 977         cfg->forward_delay = 2;
 978         cfg->robustness = 2;
 979         cfg->igmp_snoop = false;
 980         cfg->multicast_querier = false;
 981         cfg->query_interval = 12500;
 982         cfg->query_response_interval = 1000;
 983         cfg->last_member_interval = 100;
 984         cfg->hash_max = 512;
 985         cfg->bridge_empty = false;
 986         cfg->priority = 0x7FFF;
 987         cfg->vlan_filtering = false;
 988
 989         if ((cur = tb[BRIDGE_ATTR_STP]))
 990                 cfg->stp = blobmsg_get_bool(cur);
 991
 992         if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY]))
 993                 cfg->forward_delay = blobmsg_get_u32(cur);
 994
 995         if ((cur = tb[BRIDGE_ATTR_PRIORITY]))
 996                 cfg->priority = blobmsg_get_u32(cur);
 997
 998         if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP]))
 999                 cfg->multicast_querier = cfg->igmp_snoop = blobmsg_get_bool(cur);
1000
1001         if ((cur = tb[BRIDGE_ATTR_MULTICAST_QUERIER]))
1002                 cfg->multicast_querier = blobmsg_get_bool(cur);
1003
1004         if ((cur = tb[BRIDGE_ATTR_HASH_MAX]))
1005                 cfg->hash_max = blobmsg_get_u32(cur);
1006
1007         if ((cur = tb[BRIDGE_ATTR_ROBUSTNESS])) {
1008                 cfg->robustness = blobmsg_get_u32(cur);
1009                 cfg->flags |= BRIDGE_OPT_ROBUSTNESS;
1010         }
1011
1012         if ((cur = tb[BRIDGE_ATTR_QUERY_INTERVAL])) {
1013                 cfg->query_interval = blobmsg_get_u32(cur);
1014                 cfg->flags |= BRIDGE_OPT_QUERY_INTERVAL;
1015         }
1016
1017         if ((cur = tb[BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL])) {
1018                 cfg->query_response_interval = blobmsg_get_u32(cur);
1019                 cfg->flags |= BRIDGE_OPT_QUERY_RESPONSE_INTERVAL;
1020         }
1021
1022         if ((cur = tb[BRIDGE_ATTR_LAST_MEMBER_INTERVAL])) {
1023                 cfg->last_member_interval = blobmsg_get_u32(cur);
1024                 cfg->flags |= BRIDGE_OPT_LAST_MEMBER_INTERVAL;
1025         }
1026
1027         if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) {
1028                 cfg->ageing_time = blobmsg_get_u32(cur);
1029                 cfg->flags |= BRIDGE_OPT_AGEING_TIME;
1030         }
1031
1032         if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) {
1033                 cfg->hello_time = blobmsg_get_u32(cur);
1034                 cfg->flags |= BRIDGE_OPT_HELLO_TIME;
1035         }
1036
1037         if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) {
1038                 cfg->max_age = blobmsg_get_u32(cur);
1039                 cfg->flags |= BRIDGE_OPT_MAX_AGE;
1040         }
1041
1042         if ((cur = tb[BRIDGE_ATTR_BRIDGE_EMPTY]))
1043                 cfg->bridge_empty = blobmsg_get_bool(cur);
1044
1045         if ((cur = tb[BRIDGE_ATTR_VLAN_FILTERING]))
1046                 cfg->vlan_filtering = blobmsg_get_bool(cur);
1047 }
1048
1049 static enum dev_change_type
1050 bridge_reload(struct device *dev, struct blob_attr *attr)
1051 {
1052         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
1053         struct blob_attr *tb_br[__BRIDGE_ATTR_MAX];
1054         enum dev_change_type ret = DEV_CONFIG_APPLIED;
1055         unsigned long diff;
1056         struct bridge_state *bst;
1057
1058         BUILD_BUG_ON(sizeof(diff) < __BRIDGE_ATTR_MAX / 8);
1059         BUILD_BUG_ON(sizeof(diff) < __DEV_ATTR_MAX / 8);
1060
1061         bst = container_of(dev, struct bridge_state, dev);
1062         attr = blob_memdup(attr);
1063
1064         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
1065                 blob_data(attr), blob_len(attr));
1066         blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
1067                 blob_data(attr), blob_len(attr));
1068
1069         if (tb_dev[DEV_ATTR_MACADDR])
1070                 bst->primary_port = NULL;
1071
1072         bst->ports = tb_br[BRIDGE_ATTR_PORTS];
1073         device_init_settings(dev, tb_dev);
1074         bridge_apply_settings(bst, tb_br);
1075
1076         if (bst->config_data) {
1077                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
1078                 struct blob_attr *otb_br[__BRIDGE_ATTR_MAX];
1079
1080                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
1081                         blob_data(bst->config_data), blob_len(bst->config_data));
1082
1083                 diff = 0;
1084                 uci_blob_diff(tb_dev, otb_dev, &device_attr_list, &diff);
1085                 if (diff)
1086                     ret = DEV_CONFIG_RESTART;
1087
1088                 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br,
1089                         blob_data(bst->config_data), blob_len(bst->config_data));
1090
1091                 diff = 0;
1092                 uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff);
1093                 if (diff & ~(1 << BRIDGE_ATTR_PORTS))
1094                     ret = DEV_CONFIG_RESTART;
1095
1096                 bridge_config_init(dev);
1097         }
1098
1099         free(bst->config_data);
1100         bst->config_data = attr;
1101         return ret;
1102 }
1103
1104 static void
1105 bridge_retry_members(struct uloop_timeout *timeout)
1106 {
1107         struct bridge_state *bst = container_of(timeout, struct bridge_state, retry);
1108         struct bridge_member *bm;
1109
1110         bst->n_failed = 0;
1111         vlist_for_each_element(&bst->members, bm, node) {
1112                 if (bm->present)
1113                         continue;
1114
1115                 if (!bm->dev.dev->present)
1116                         continue;
1117
1118                 bm->present = true;
1119                 bst->n_present++;
1120                 bridge_enable_member(bm);
1121         }
1122 }
1123
1124 static int bridge_avl_cmp_u16(const void *k1, const void *k2, void *ptr)
1125 {
1126         const uint16_t *i1 = k1, *i2 = k2;
1127
1128         return *i1 - *i2;
1129 }
1130
1131 static bool
1132 bridge_vlan_equal(struct bridge_vlan *v1, struct bridge_vlan *v2)
1133 {
1134         int i;
1135
1136         if (v1->n_ports != v2->n_ports)
1137                 return false;
1138
1139         for (i = 0; i < v1->n_ports; i++)
1140                 if (v1->ports[i].flags != v2->ports[i].flags ||
1141                     strcmp(v1->ports[i].ifname, v2->ports[i].ifname) != 0)
1142                         return false;
1143
1144         return true;
1145 }
1146
1147 static void
1148 bridge_vlan_free(struct bridge_vlan *vlan)
1149 {
1150         struct bridge_vlan_hotplug_port *port, *tmp;
1151
1152         if (!vlan)
1153                 return;
1154
1155         list_for_each_entry_safe(port, tmp, &vlan->hotplug_ports, list)
1156                 free(port);
1157
1158         free(vlan);
1159 }
1160
1161 static void
1162 bridge_vlan_update(struct vlist_tree *tree, struct vlist_node *node_new,
1163                    struct vlist_node *node_old)
1164 {
1165         struct bridge_state *bst = container_of(tree, struct bridge_state, dev.vlans);
1166         struct bridge_vlan *vlan_new = NULL, *vlan_old = NULL;
1167
1168         if (!bst->has_vlans || !bst->active)
1169                 goto out;
1170
1171         if (node_old)
1172                 vlan_old = container_of(node_old, struct bridge_vlan, node);
1173         if (node_new)
1174                 vlan_new = container_of(node_new, struct bridge_vlan, node);
1175
1176         if (node_new && node_old && bridge_vlan_equal(vlan_old, vlan_new)) {
1177                 list_splice_init(&vlan_old->hotplug_ports, &vlan_new->hotplug_ports);
1178                 goto out;
1179         }
1180
1181         if (node_old)
1182                 bridge_set_vlan_state(bst, vlan_old, false);
1183
1184         if (node_old && node_new)
1185                 list_splice_init(&vlan_old->hotplug_ports, &vlan_new->hotplug_ports);
1186
1187         if (node_new)
1188                 bridge_set_vlan_state(bst, vlan_new, true);
1189
1190         bst->dev.config_pending = true;
1191
1192 out:
1193         bridge_vlan_free(vlan_old);
1194 }
1195
1196 static struct device *
1197 bridge_create(const char *name, struct device_type *devtype,
1198         struct blob_attr *attr)
1199 {
1200         struct bridge_state *bst;
1201         struct device *dev = NULL;
1202
1203         bst = calloc(1, sizeof(*bst));
1204         if (!bst)
1205                 return NULL;
1206
1207         dev = &bst->dev;
1208
1209         if (device_init(dev, devtype, name) < 0) {
1210                 device_cleanup(dev);
1211                 free(bst);
1212                 return NULL;
1213         }
1214
1215         dev->config_pending = true;
1216         bst->retry.cb = bridge_retry_members;
1217
1218         bst->set_state = dev->set_state;
1219         dev->set_state = bridge_set_state;
1220
1221         dev->hotplug_ops = &bridge_ops;
1222
1223         vlist_init(&bst->members, avl_strcmp, bridge_member_update);
1224         bst->members.keep_old = true;
1225
1226         vlist_init(&dev->vlans, bridge_avl_cmp_u16, bridge_vlan_update);
1227
1228         bridge_reload(dev, attr);
1229
1230         return dev;
1231 }
1232
1233 static void __init bridge_device_type_init(void)
1234 {
1235         device_type_add(&bridge_device_type);
1236 }