1 /* 2 * netifd - network interface daemon 3 * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 7 * as published by the Free Software Foundation 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 #include <string.h> 15 #include <stdlib.h> 16 #include <stdio.h> 17 #include <assert.h> 18 #include <errno.h> 19 20 #include "netifd.h" 21 #include "device.h" 22 #include "interface.h" 23 #include "system.h" 24 25 enum { 26 BRIDGE_ATTR_IFNAME, 27 BRIDGE_ATTR_STP, 28 BRIDGE_ATTR_FORWARD_DELAY, 29 BRIDGE_ATTR_PRIORITY, 30 BRIDGE_ATTR_IGMP_SNOOP, 31 BRIDGE_ATTR_AGEING_TIME, 32 BRIDGE_ATTR_HELLO_TIME, 33 BRIDGE_ATTR_MAX_AGE, 34 BRIDGE_ATTR_BRIDGE_EMPTY, 35 BRIDGE_ATTR_MULTICAST_QUERIER, 36 BRIDGE_ATTR_HASH_MAX, 37 BRIDGE_ATTR_ROBUSTNESS, 38 BRIDGE_ATTR_QUERY_INTERVAL, 39 BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL, 40 BRIDGE_ATTR_LAST_MEMBER_INTERVAL, 41 __BRIDGE_ATTR_MAX 42 }; 43 44 static const struct blobmsg_policy bridge_attrs[__BRIDGE_ATTR_MAX] = { 45 [BRIDGE_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY }, 46 [BRIDGE_ATTR_STP] = { "stp", BLOBMSG_TYPE_BOOL }, 47 [BRIDGE_ATTR_FORWARD_DELAY] = { "forward_delay", BLOBMSG_TYPE_INT32 }, 48 [BRIDGE_ATTR_PRIORITY] = { "priority", BLOBMSG_TYPE_INT32 }, 49 [BRIDGE_ATTR_AGEING_TIME] = { "ageing_time", BLOBMSG_TYPE_INT32 }, 50 [BRIDGE_ATTR_HELLO_TIME] = { "hello_time", BLOBMSG_TYPE_INT32 }, 51 [BRIDGE_ATTR_MAX_AGE] = { "max_age", BLOBMSG_TYPE_INT32 }, 52 [BRIDGE_ATTR_IGMP_SNOOP] = { "igmp_snooping", BLOBMSG_TYPE_BOOL }, 53 [BRIDGE_ATTR_BRIDGE_EMPTY] = { "bridge_empty", BLOBMSG_TYPE_BOOL }, 54 [BRIDGE_ATTR_MULTICAST_QUERIER] = { "multicast_querier", BLOBMSG_TYPE_BOOL }, 55 [BRIDGE_ATTR_HASH_MAX] = { "hash_max", BLOBMSG_TYPE_INT32 }, 56 [BRIDGE_ATTR_ROBUSTNESS] = { "robustness", BLOBMSG_TYPE_INT32 }, 57 [BRIDGE_ATTR_QUERY_INTERVAL] = { "query_interval", BLOBMSG_TYPE_INT32 }, 58 [BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL] = { "query_response_interval", BLOBMSG_TYPE_INT32 }, 59 [BRIDGE_ATTR_LAST_MEMBER_INTERVAL] = { "last_member_interval", BLOBMSG_TYPE_INT32 }, 60 }; 61 62 static const struct uci_blob_param_info bridge_attr_info[__BRIDGE_ATTR_MAX] = { 63 [BRIDGE_ATTR_IFNAME] = { .type = BLOBMSG_TYPE_STRING }, 64 }; 65 66 static const struct uci_blob_param_list bridge_attr_list = { 67 .n_params = __BRIDGE_ATTR_MAX, 68 .params = bridge_attrs, 69 .info = bridge_attr_info, 70 71 .n_next = 1, 72 .next = { &device_attr_list }, 73 }; 74 75 static struct device *bridge_create(const char *name, struct device_type *devtype, 76 struct blob_attr *attr); 77 static void bridge_config_init(struct device *dev); 78 static void bridge_free(struct device *dev); 79 static void bridge_dump_info(struct device *dev, struct blob_buf *b); 80 static enum dev_change_type 81 bridge_reload(struct device *dev, struct blob_attr *attr); 82 83 static struct device_type bridge_device_type = { 84 .name = "bridge", 85 .config_params = &bridge_attr_list, 86 87 .bridge_capability = true, 88 .name_prefix = "br", 89 90 .create = bridge_create, 91 .config_init = bridge_config_init, 92 .reload = bridge_reload, 93 .free = bridge_free, 94 .dump_info = bridge_dump_info, 95 }; 96 97 struct bridge_state { 98 struct device dev; 99 device_state_cb set_state; 100 101 struct blob_attr *config_data; 102 struct bridge_config config; 103 struct blob_attr *ifnames; 104 bool active; 105 bool force_active; 106 107 struct uloop_timeout retry; 108 struct bridge_member *primary_port; 109 struct vlist_tree members; 110 int n_present; 111 int n_failed; 112 }; 113 114 struct bridge_member { 115 struct vlist_node node; 116 struct bridge_state *bst; 117 struct device_user dev; 118 bool present; 119 char name[]; 120 }; 121 122 static void 123 bridge_reset_primary(struct bridge_state *bst) 124 { 125 struct bridge_member *bm; 126 127 if (!bst->primary_port && 128 (bst->dev.settings.flags & DEV_OPT_MACADDR)) 129 return; 130 131 bst->primary_port = NULL; 132 bst->dev.settings.flags &= ~DEV_OPT_MACADDR; 133 vlist_for_each_element(&bst->members, bm, node) { 134 uint8_t *macaddr; 135 136 if (!bm->present) 137 continue; 138 139 bst->primary_port = bm; 140 if (bm->dev.dev->settings.flags & DEV_OPT_MACADDR) 141 macaddr = bm->dev.dev->settings.macaddr; 142 else 143 macaddr = bm->dev.dev->orig_settings.macaddr; 144 memcpy(bst->dev.settings.macaddr, macaddr, 6); 145 bst->dev.settings.flags |= DEV_OPT_MACADDR; 146 return; 147 } 148 } 149 150 static int 151 bridge_disable_member(struct bridge_member *bm) 152 { 153 struct bridge_state *bst = bm->bst; 154 155 if (!bm->present) 156 return 0; 157 158 system_bridge_delif(&bst->dev, bm->dev.dev); 159 device_release(&bm->dev); 160 161 device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE); 162 163 return 0; 164 } 165 166 static int 167 bridge_enable_interface(struct bridge_state *bst) 168 { 169 int ret; 170 171 if (bst->active) 172 return 0; 173 174 ret = system_bridge_addbr(&bst->dev, &bst->config); 175 if (ret < 0) 176 return ret; 177 178 bst->active = true; 179 return 0; 180 } 181 182 static void 183 bridge_disable_interface(struct bridge_state *bst) 184 { 185 if (!bst->active) 186 return; 187 188 system_bridge_delbr(&bst->dev); 189 bst->active = false; 190 } 191 192 static int 193 bridge_enable_member(struct bridge_member *bm) 194 { 195 struct bridge_state *bst = bm->bst; 196 int ret; 197 198 if (!bm->present) 199 return 0; 200 201 ret = bridge_enable_interface(bst); 202 if (ret) 203 goto error; 204 205 /* Disable IPv6 for bridge members */ 206 if (!(bm->dev.dev->settings.flags & DEV_OPT_IPV6)) { 207 bm->dev.dev->settings.ipv6 = 0; 208 bm->dev.dev->settings.flags |= DEV_OPT_IPV6; 209 } 210 211 ret = device_claim(&bm->dev); 212 if (ret < 0) 213 goto error; 214 215 ret = system_bridge_addif(&bst->dev, bm->dev.dev); 216 if (ret < 0) { 217 D(DEVICE, "Bridge device %s could not be added\n", bm->dev.dev->ifname); 218 goto error; 219 } 220 221 device_set_present(&bst->dev, true); 222 device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE); 223 224 return 0; 225 226 error: 227 bst->n_failed++; 228 bm->present = false; 229 bst->n_present--; 230 device_release(&bm->dev); 231 232 return ret; 233 } 234 235 static void 236 bridge_remove_member(struct bridge_member *bm) 237 { 238 struct bridge_state *bst = bm->bst; 239 240 if (!bm->present) 241 return; 242 243 if (bst->dev.active) 244 bridge_disable_member(bm); 245 246 bm->present = false; 247 bm->bst->n_present--; 248 249 if (bm == bst->primary_port) 250 bridge_reset_primary(bst); 251 252 if (bst->config.bridge_empty) 253 return; 254 255 bst->force_active = false; 256 if (bst->n_present == 0) 257 device_set_present(&bst->dev, false); 258 } 259 260 static void 261 bridge_free_member(struct bridge_member *bm) 262 { 263 struct device *dev = bm->dev.dev; 264 265 bridge_remove_member(bm); 266 device_remove_user(&bm->dev); 267 268 /* 269 * When reloading the config and moving a device from one bridge to 270 * another, the other bridge may have tried to claim this device 271 * before it was removed here. 272 * Ensure that claiming the device is retried by toggling its present 273 * state 274 */ 275 if (dev->present) { 276 device_set_present(dev, false); 277 device_set_present(dev, true); 278 } 279 280 free(bm); 281 } 282 283 static void 284 bridge_check_retry(struct bridge_state *bst) 285 { 286 if (!bst->n_failed) 287 return; 288 289 uloop_timeout_set(&bst->retry, 100); 290 } 291 292 static void 293 bridge_member_cb(struct device_user *dev, enum device_event ev) 294 { 295 struct bridge_member *bm = container_of(dev, struct bridge_member, dev); 296 struct bridge_state *bst = bm->bst; 297 298 switch (ev) { 299 case DEV_EVENT_ADD: 300 assert(!bm->present); 301 302 bm->present = true; 303 bst->n_present++; 304 305 if (bst->n_present == 1) 306 device_set_present(&bst->dev, true); 307 if (bst->dev.active && !bridge_enable_member(bm)) { 308 /* 309 * Adding a bridge member can overwrite the bridge mtu 310 * in the kernel, apply the bridge settings in case the 311 * bridge mtu is set 312 */ 313 system_if_apply_settings(&bst->dev, &bst->dev.settings, 314 DEV_OPT_MTU | DEV_OPT_MTU6); 315 } 316 317 break; 318 case DEV_EVENT_REMOVE: 319 if (dev->hotplug) { 320 vlist_delete(&bst->members, &bm->node); 321 return; 322 } 323 324 if (bm->present) 325 bridge_remove_member(bm); 326 327 break; 328 default: 329 return; 330 } 331 } 332 333 static int 334 bridge_set_down(struct bridge_state *bst) 335 { 336 struct bridge_member *bm; 337 338 bst->set_state(&bst->dev, false); 339 340 vlist_for_each_element(&bst->members, bm, node) 341 bridge_disable_member(bm); 342 343 bridge_disable_interface(bst); 344 345 return 0; 346 } 347 348 static int 349 bridge_set_up(struct bridge_state *bst) 350 { 351 struct bridge_member *bm; 352 int ret; 353 354 if (!bst->n_present) { 355 if (!bst->force_active) 356 return -ENOENT; 357 358 ret = bridge_enable_interface(bst); 359 if (ret) 360 return ret; 361 } 362 363 bst->n_failed = 0; 364 vlist_for_each_element(&bst->members, bm, node) 365 bridge_enable_member(bm); 366 bridge_check_retry(bst); 367 368 if (!bst->force_active && !bst->n_present) { 369 /* initialization of all member interfaces failed */ 370 bridge_disable_interface(bst); 371 device_set_present(&bst->dev, false); 372 return -ENOENT; 373 } 374 375 bridge_reset_primary(bst); 376 ret = bst->set_state(&bst->dev, true); 377 if (ret < 0) 378 bridge_set_down(bst); 379 380 return ret; 381 } 382 383 static int 384 bridge_set_state(struct device *dev, bool up) 385 { 386 struct bridge_state *bst; 387 388 bst = container_of(dev, struct bridge_state, dev); 389 390 if (up) 391 return bridge_set_up(bst); 392 else 393 return bridge_set_down(bst); 394 } 395 396 static struct bridge_member * 397 bridge_create_member(struct bridge_state *bst, const char *name, 398 struct device *dev, bool hotplug) 399 { 400 struct bridge_member *bm; 401 402 bm = calloc(1, sizeof(*bm) + strlen(name) + 1); 403 if (!bm) 404 return NULL; 405 406 bm->bst = bst; 407 bm->dev.cb = bridge_member_cb; 408 bm->dev.hotplug = hotplug; 409 strcpy(bm->name, name); 410 bm->dev.dev = dev; 411 vlist_add(&bst->members, &bm->node, bm->name); 412 /* 413 * Need to look up the bridge member again as the above 414 * created pointer will be freed in case the bridge member 415 * already existed 416 */ 417 bm = vlist_find(&bst->members, name, bm, node); 418 if (hotplug && bm) 419 bm->node.version = -1; 420 421 return bm; 422 } 423 424 static void 425 bridge_member_update(struct vlist_tree *tree, struct vlist_node *node_new, 426 struct vlist_node *node_old) 427 { 428 struct bridge_member *bm; 429 struct device *dev; 430 431 if (node_new) { 432 bm = container_of(node_new, struct bridge_member, node); 433 434 if (node_old) { 435 free(bm); 436 return; 437 } 438 439 dev = bm->dev.dev; 440 bm->dev.dev = NULL; 441 device_add_user(&bm->dev, dev); 442 } 443 444 445 if (node_old) { 446 bm = container_of(node_old, struct bridge_member, node); 447 bridge_free_member(bm); 448 } 449 } 450 451 452 static void 453 bridge_add_member(struct bridge_state *bst, const char *name) 454 { 455 struct device *dev; 456 457 dev = device_get(name, true); 458 if (!dev) 459 return; 460 461 bridge_create_member(bst, name, dev, false); 462 } 463 464 static int 465 bridge_hotplug_add(struct device *dev, struct device *member) 466 { 467 struct bridge_state *bst = container_of(dev, struct bridge_state, dev); 468 469 bridge_create_member(bst, member->ifname, member, true); 470 471 return 0; 472 } 473 474 static int 475 bridge_hotplug_del(struct device *dev, struct device *member) 476 { 477 struct bridge_state *bst = container_of(dev, struct bridge_state, dev); 478 struct bridge_member *bm; 479 480 bm = vlist_find(&bst->members, member->ifname, bm, node); 481 if (!bm) 482 return UBUS_STATUS_NOT_FOUND; 483 484 vlist_delete(&bst->members, &bm->node); 485 return 0; 486 } 487 488 static int 489 bridge_hotplug_prepare(struct device *dev) 490 { 491 struct bridge_state *bst; 492 493 bst = container_of(dev, struct bridge_state, dev); 494 bst->force_active = true; 495 device_set_present(&bst->dev, true); 496 497 return 0; 498 } 499 500 static const struct device_hotplug_ops bridge_ops = { 501 .prepare = bridge_hotplug_prepare, 502 .add = bridge_hotplug_add, 503 .del = bridge_hotplug_del 504 }; 505 506 static void 507 bridge_free(struct device *dev) 508 { 509 struct bridge_state *bst; 510 511 bst = container_of(dev, struct bridge_state, dev); 512 vlist_flush_all(&bst->members); 513 free(bst->config_data); 514 free(bst); 515 } 516 517 static void 518 bridge_dump_info(struct device *dev, struct blob_buf *b) 519 { 520 struct bridge_state *bst; 521 struct bridge_member *bm; 522 void *list; 523 524 bst = container_of(dev, struct bridge_state, dev); 525 526 system_if_dump_info(dev, b); 527 list = blobmsg_open_array(b, "bridge-members"); 528 529 vlist_for_each_element(&bst->members, bm, node) { 530 if (bm->dev.dev->hidden) 531 continue; 532 533 blobmsg_add_string(b, NULL, bm->dev.dev->ifname); 534 } 535 536 blobmsg_close_array(b, list); 537 } 538 539 static void 540 bridge_config_init(struct device *dev) 541 { 542 struct bridge_state *bst; 543 struct blob_attr *cur; 544 int rem; 545 546 bst = container_of(dev, struct bridge_state, dev); 547 548 if (bst->config.bridge_empty) { 549 bst->force_active = true; 550 device_set_present(&bst->dev, true); 551 } 552 553 bst->n_failed = 0; 554 vlist_update(&bst->members); 555 if (bst->ifnames) { 556 blobmsg_for_each_attr(cur, bst->ifnames, rem) { 557 bridge_add_member(bst, blobmsg_data(cur)); 558 } 559 } 560 vlist_flush(&bst->members); 561 bridge_check_retry(bst); 562 } 563 564 static void 565 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb) 566 { 567 struct bridge_config *cfg = &bst->config; 568 struct blob_attr *cur; 569 570 /* defaults */ 571 cfg->stp = false; 572 cfg->forward_delay = 2; 573 cfg->robustness = 2; 574 cfg->query_interval = 12500; 575 cfg->query_response_interval = 1000; 576 cfg->last_member_interval = 100; 577 cfg->hash_max = 512; 578 cfg->bridge_empty = false; 579 cfg->priority = 0x7FFF; 580 581 if ((cur = tb[BRIDGE_ATTR_STP])) 582 cfg->stp = blobmsg_get_bool(cur); 583 584 if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY])) 585 cfg->forward_delay = blobmsg_get_u32(cur); 586 587 if ((cur = tb[BRIDGE_ATTR_PRIORITY])) 588 cfg->priority = blobmsg_get_u32(cur); 589 590 if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP])) 591 cfg->multicast_querier = cfg->igmp_snoop = blobmsg_get_bool(cur); 592 593 if ((cur = tb[BRIDGE_ATTR_MULTICAST_QUERIER])) 594 cfg->multicast_querier = blobmsg_get_bool(cur); 595 596 if ((cur = tb[BRIDGE_ATTR_HASH_MAX])) 597 cfg->hash_max = blobmsg_get_u32(cur); 598 599 if ((cur = tb[BRIDGE_ATTR_ROBUSTNESS])) { 600 cfg->robustness = blobmsg_get_u32(cur); 601 cfg->flags |= BRIDGE_OPT_ROBUSTNESS; 602 } 603 604 if ((cur = tb[BRIDGE_ATTR_QUERY_INTERVAL])) { 605 cfg->query_interval = blobmsg_get_u32(cur); 606 cfg->flags |= BRIDGE_OPT_QUERY_INTERVAL; 607 } 608 609 if ((cur = tb[BRIDGE_ATTR_QUERY_RESPONSE_INTERVAL])) { 610 cfg->query_response_interval = blobmsg_get_u32(cur); 611 cfg->flags |= BRIDGE_OPT_QUERY_RESPONSE_INTERVAL; 612 } 613 614 if ((cur = tb[BRIDGE_ATTR_LAST_MEMBER_INTERVAL])) { 615 cfg->last_member_interval = blobmsg_get_u32(cur); 616 cfg->flags |= BRIDGE_OPT_LAST_MEMBER_INTERVAL; 617 } 618 619 if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) { 620 cfg->ageing_time = blobmsg_get_u32(cur); 621 cfg->flags |= BRIDGE_OPT_AGEING_TIME; 622 } 623 624 if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) { 625 cfg->hello_time = blobmsg_get_u32(cur); 626 cfg->flags |= BRIDGE_OPT_HELLO_TIME; 627 } 628 629 if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) { 630 cfg->max_age = blobmsg_get_u32(cur); 631 cfg->flags |= BRIDGE_OPT_MAX_AGE; 632 } 633 634 if ((cur = tb[BRIDGE_ATTR_BRIDGE_EMPTY])) 635 cfg->bridge_empty = blobmsg_get_bool(cur); 636 } 637 638 static enum dev_change_type 639 bridge_reload(struct device *dev, struct blob_attr *attr) 640 { 641 struct blob_attr *tb_dev[__DEV_ATTR_MAX]; 642 struct blob_attr *tb_br[__BRIDGE_ATTR_MAX]; 643 enum dev_change_type ret = DEV_CONFIG_APPLIED; 644 unsigned long diff; 645 struct bridge_state *bst; 646 647 BUILD_BUG_ON(sizeof(diff) < __BRIDGE_ATTR_MAX / 8); 648 BUILD_BUG_ON(sizeof(diff) < __DEV_ATTR_MAX / 8); 649 650 bst = container_of(dev, struct bridge_state, dev); 651 attr = blob_memdup(attr); 652 653 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, 654 blob_data(attr), blob_len(attr)); 655 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br, 656 blob_data(attr), blob_len(attr)); 657 658 if (tb_dev[DEV_ATTR_MACADDR]) 659 bst->primary_port = NULL; 660 661 bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME]; 662 device_init_settings(dev, tb_dev); 663 bridge_apply_settings(bst, tb_br); 664 665 if (bst->config_data) { 666 struct blob_attr *otb_dev[__DEV_ATTR_MAX]; 667 struct blob_attr *otb_br[__BRIDGE_ATTR_MAX]; 668 669 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev, 670 blob_data(bst->config_data), blob_len(bst->config_data)); 671 672 diff = 0; 673 uci_blob_diff(tb_dev, otb_dev, &device_attr_list, &diff); 674 if (diff) 675 ret = DEV_CONFIG_RESTART; 676 677 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br, 678 blob_data(bst->config_data), blob_len(bst->config_data)); 679 680 diff = 0; 681 uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff); 682 if (diff & ~(1 << BRIDGE_ATTR_IFNAME)) 683 ret = DEV_CONFIG_RESTART; 684 685 bridge_config_init(dev); 686 } 687 688 free(bst->config_data); 689 bst->config_data = attr; 690 return ret; 691 } 692 693 static void 694 bridge_retry_members(struct uloop_timeout *timeout) 695 { 696 struct bridge_state *bst = container_of(timeout, struct bridge_state, retry); 697 struct bridge_member *bm; 698 699 bst->n_failed = 0; 700 vlist_for_each_element(&bst->members, bm, node) { 701 if (bm->present) 702 continue; 703 704 if (!bm->dev.dev->present) 705 continue; 706 707 bm->present = true; 708 bst->n_present++; 709 bridge_enable_member(bm); 710 } 711 } 712 713 static struct device * 714 bridge_create(const char *name, struct device_type *devtype, 715 struct blob_attr *attr) 716 { 717 struct bridge_state *bst; 718 struct device *dev = NULL; 719 720 bst = calloc(1, sizeof(*bst)); 721 if (!bst) 722 return NULL; 723 724 dev = &bst->dev; 725 726 if (device_init(dev, devtype, name) < 0) { 727 device_cleanup(dev); 728 free(bst); 729 return NULL; 730 } 731 732 dev->config_pending = true; 733 bst->retry.cb = bridge_retry_members; 734 735 bst->set_state = dev->set_state; 736 dev->set_state = bridge_set_state; 737 738 dev->hotplug_ops = &bridge_ops; 739 740 vlist_init(&bst->members, avl_strcmp, bridge_member_update); 741 bst->members.keep_old = true; 742 bridge_reload(dev, attr); 743 744 return dev; 745 } 746 747 static void __init bridge_device_type_init(void) 748 { 749 device_type_add(&bridge_device_type); 750 } 751
This page was automatically generated by LXR 0.3.1. • OpenWrt