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