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