1 /* 2 * netifd - network interface daemon 3 * Copyright (C) 2013 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 15 /* The wireless configuration is projected on the following objects 16 * 17 * 1. wireless device 18 * 2. wireless interface 19 * 3. wireless vlan 20 * 4. wireless station 21 * 22 * A wireless device is a phy or simplified a wireless card. 23 * A wireless interface is a SSID on a phy. 24 * A wireless vlan can be assigned to a wireless interface. A wireless interface can 25 * have multiple vlans. 26 * A wireless station is a client connected to an wireless interface. 27 */ 28 29 #include <signal.h> 30 #include "netifd.h" 31 #include "wireless.h" 32 #include "handler.h" 33 #include "ubus.h" 34 35 #define WIRELESS_SETUP_RETRY 3 36 37 struct vlist_tree wireless_devices; 38 struct avl_tree wireless_drivers; 39 static struct blob_buf b; 40 static int drv_fd; 41 static LIST_HEAD(handlers); 42 static bool handler_pending; 43 44 enum { 45 WDEV_ATTR_DISABLED, 46 WDEV_ATTR_RECONF, 47 WDEV_ATTR_SERIALIZE, 48 __WDEV_ATTR_MAX, 49 }; 50 51 static const struct blobmsg_policy wdev_policy[__WDEV_ATTR_MAX] = { 52 [WDEV_ATTR_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL }, 53 [WDEV_ATTR_RECONF] = { .name = "reconf", .type = BLOBMSG_TYPE_BOOL }, 54 [WDEV_ATTR_SERIALIZE] = { .name = "serialize", .type = BLOBMSG_TYPE_BOOL }, 55 }; 56 57 static const struct uci_blob_param_list wdev_param = { 58 .n_params = ARRAY_SIZE(wdev_policy), 59 .params = wdev_policy, 60 }; 61 62 enum { 63 VIF_ATTR_DISABLED, 64 VIF_ATTR_NETWORK, 65 VIF_ATTR_NETWORK_VLAN, 66 VIF_ATTR_BRIDGE_ISOLATE, 67 VIF_ATTR_ISOLATE, 68 VIF_ATTR_MODE, 69 VIF_ATTR_PROXYARP, 70 VIF_ATTR_MCAST_TO_UCAST, 71 __VIF_ATTR_MAX, 72 }; 73 74 static const struct blobmsg_policy vif_policy[__VIF_ATTR_MAX] = { 75 [VIF_ATTR_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL }, 76 [VIF_ATTR_NETWORK] = { .name = "network", .type = BLOBMSG_TYPE_ARRAY }, 77 [VIF_ATTR_NETWORK_VLAN] = { .name = "network_vlan", .type = BLOBMSG_TYPE_ARRAY }, 78 [VIF_ATTR_BRIDGE_ISOLATE] = { .name = "bridge_isolate", .type = BLOBMSG_TYPE_BOOL }, 79 [VIF_ATTR_ISOLATE] = { .name = "isolate", .type = BLOBMSG_TYPE_BOOL }, 80 [VIF_ATTR_MODE] = { .name = "mode", .type = BLOBMSG_TYPE_STRING }, 81 [VIF_ATTR_PROXYARP] = { .name = "proxy_arp", .type = BLOBMSG_TYPE_BOOL }, 82 [VIF_ATTR_MCAST_TO_UCAST] = { .name = "multicast_to_unicast", .type = BLOBMSG_TYPE_BOOL }, 83 }; 84 85 static const struct uci_blob_param_list vif_param = { 86 .n_params = ARRAY_SIZE(vif_policy), 87 .params = vif_policy, 88 }; 89 90 enum { 91 VLAN_ATTR_DISABLED, 92 VLAN_ATTR_NETWORK, 93 VLAN_ATTR_NETWORK_VLAN, 94 VLAN_ATTR_BRIDGE_ISOLATE, 95 VLAN_ATTR_ISOLATE, 96 VLAN_ATTR_MCAST_TO_UCAST, 97 __VLAN_ATTR_MAX, 98 }; 99 100 static const struct blobmsg_policy vlan_policy[__VLAN_ATTR_MAX] = { 101 [VLAN_ATTR_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL }, 102 [VLAN_ATTR_NETWORK] = { .name = "network", .type = BLOBMSG_TYPE_ARRAY }, 103 [VLAN_ATTR_NETWORK_VLAN] = { .name = "network_vlan", .type = BLOBMSG_TYPE_ARRAY }, 104 [VLAN_ATTR_BRIDGE_ISOLATE] = { .name = "bridge_isolate", .type = BLOBMSG_TYPE_BOOL }, 105 [VLAN_ATTR_ISOLATE] = { .name = "isolate", .type = BLOBMSG_TYPE_BOOL }, 106 [VLAN_ATTR_MCAST_TO_UCAST] = { .name = "multicast_to_unicast", .type = BLOBMSG_TYPE_BOOL }, 107 }; 108 109 static const struct uci_blob_param_list vlan_param = { 110 .n_params = ARRAY_SIZE(vlan_policy), 111 .params = vlan_policy, 112 }; 113 114 enum { 115 STA_ATTR_DISABLED, 116 __STA_ATTR_MAX, 117 }; 118 119 static const struct blobmsg_policy sta_policy[__STA_ATTR_MAX] = { 120 [STA_ATTR_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL }, 121 }; 122 123 static const struct uci_blob_param_list station_param = { 124 .n_params = ARRAY_SIZE(sta_policy), 125 .params = sta_policy, 126 }; 127 128 static void 129 wireless_handler_stop(struct wireless_device *wdev) 130 { 131 if (wdev->handler_pending) { 132 wdev->handler_pending = false; 133 list_del(&wdev->handler); 134 } 135 } 136 137 static void 138 put_container(struct blob_buf *buf, struct blob_attr *attr, const char *name) 139 { 140 void *c = blobmsg_open_table(buf, name); 141 blob_put_raw(buf, blobmsg_data(attr), blobmsg_len(attr)); 142 blobmsg_close_table(buf, c); 143 } 144 145 static void 146 vif_config_add_bridge(struct blob_buf *buf, struct blob_attr *networks, bool prepare) 147 { 148 struct interface *iface; 149 struct device *dev = NULL, *orig_dev; 150 struct blob_attr *cur; 151 const char *network; 152 size_t rem; 153 154 if (!networks) 155 return; 156 157 blobmsg_for_each_attr(cur, networks, rem) { 158 network = blobmsg_data(cur); 159 160 iface = vlist_find(&interfaces, network, iface, node); 161 if (!iface) 162 continue; 163 164 dev = iface->main_dev.dev; 165 if (!dev) 166 return; 167 168 if (!dev->hotplug_ops) 169 return; 170 } 171 172 if (!dev) 173 return; 174 175 orig_dev = dev; 176 if (dev->hotplug_ops && dev->hotplug_ops->prepare) 177 dev->hotplug_ops->prepare(dev, &dev); 178 179 if (!dev || !dev->type->bridge_capability) 180 return; 181 182 blobmsg_add_string(buf, "bridge", dev->ifname); 183 blobmsg_add_string(buf, "bridge-ifname", orig_dev->ifname); 184 185 if (dev->settings.flags & DEV_OPT_MULTICAST_TO_UNICAST) 186 blobmsg_add_u8(buf, "multicast_to_unicast", 187 dev->settings.multicast_to_unicast); 188 } 189 190 static void 191 prepare_config(struct wireless_device *wdev, struct blob_buf *buf, bool up) 192 { 193 struct wireless_interface *vif; 194 struct wireless_vlan *vlan; 195 struct wireless_station *sta; 196 void *l, *i, *j, *k; 197 198 blob_buf_init(&b, 0); 199 put_container(&b, wdev->config, "config"); 200 if (wdev->data) 201 blobmsg_add_blob(&b, wdev->data); 202 203 l = blobmsg_open_table(&b, "interfaces"); 204 vlist_for_each_element(&wdev->interfaces, vif, node) { 205 if (vif->disabled) 206 continue; 207 208 i = blobmsg_open_table(&b, vif->name); 209 vif_config_add_bridge(&b, vif->network, up); 210 put_container(&b, vif->config, "config"); 211 if (vif->data) 212 blobmsg_add_blob(&b, vif->data); 213 214 j = blobmsg_open_table(&b, "vlans"); 215 vlist_for_each_element(&vif->vlans, vlan, node) { 216 k = blobmsg_open_table(&b, vlan->name); 217 vif_config_add_bridge(&b, vlan->network, up); 218 put_container(&b, vlan->config, "config"); 219 if (vlan->data) 220 blobmsg_add_blob(&b, vlan->data); 221 blobmsg_close_table(&b, k); 222 } 223 blobmsg_close_table(&b, j); 224 225 j = blobmsg_open_table(&b, "stas"); 226 vlist_for_each_element(&vif->stations, sta, node) { 227 k = blobmsg_open_table(&b, sta->name); 228 put_container(&b, sta->config, "config"); 229 if (sta->data) 230 blobmsg_add_blob(&b, sta->data); 231 blobmsg_close_table(&b, k); 232 } 233 blobmsg_close_table(&b, j); 234 blobmsg_close_table(&b, i); 235 } 236 blobmsg_close_table(&b, l); 237 238 } 239 240 static bool 241 wireless_process_check(struct wireless_process *proc) 242 { 243 return check_pid_path(proc->pid, proc->exe); 244 } 245 246 static void 247 wireless_complete_kill_request(struct wireless_device *wdev) 248 { 249 if (!wdev->kill_request) 250 return; 251 252 ubus_complete_deferred_request(ubus_ctx, wdev->kill_request, 0); 253 free(wdev->kill_request); 254 wdev->kill_request = NULL; 255 } 256 257 static void 258 wireless_process_free(struct wireless_device *wdev, struct wireless_process *proc) 259 { 260 D(WIRELESS, "Wireless device '%s' free pid %d", wdev->name, proc->pid); 261 list_del(&proc->list); 262 free(proc); 263 264 if (list_empty(&wdev->script_proc)) 265 wireless_complete_kill_request(wdev); 266 } 267 268 static void 269 wireless_close_script_proc_fd(struct wireless_device *wdev) 270 { 271 if (wdev->script_proc_fd.fd < 0) 272 return; 273 274 uloop_fd_delete(&wdev->script_proc_fd); 275 close(wdev->script_proc_fd.fd); 276 wdev->script_proc_fd.fd = -1; 277 } 278 279 static void 280 wireless_process_kill_all(struct wireless_device *wdev, int signal, bool free) 281 { 282 struct wireless_process *proc, *tmp; 283 284 list_for_each_entry_safe(proc, tmp, &wdev->script_proc, list) { 285 bool check = wireless_process_check(proc); 286 287 if (check && !proc->keep) { 288 D(WIRELESS, "Wireless device '%s' kill pid %d", wdev->name, proc->pid); 289 kill(proc->pid, signal); 290 } 291 292 if (free || !check) 293 wireless_process_free(wdev, proc); 294 } 295 296 if (free) 297 wireless_close_script_proc_fd(wdev); 298 } 299 300 static void 301 wireless_device_free_state(struct wireless_device *wdev) 302 { 303 struct wireless_interface *vif; 304 struct wireless_vlan *vlan; 305 struct wireless_station *sta; 306 307 wireless_handler_stop(wdev); 308 uloop_timeout_cancel(&wdev->script_check); 309 uloop_timeout_cancel(&wdev->timeout); 310 wireless_complete_kill_request(wdev); 311 free(wdev->data); 312 wdev->data = NULL; 313 vlist_for_each_element(&wdev->interfaces, vif, node) { 314 free(vif->data); 315 vif->data = NULL; 316 vif->ifname = NULL; 317 vlist_for_each_element(&vif->vlans, vlan, node) { 318 free(vlan->data); 319 vlan->data = NULL; 320 vlan->ifname = NULL; 321 } 322 vlist_for_each_element(&vif->stations, sta, node) { 323 free(sta->data); 324 sta->data = NULL; 325 } 326 } 327 } 328 329 static void wireless_device_set_mcast_to_unicast(struct device *dev, int val) 330 { 331 if (val < 0) { 332 dev->settings.flags &= ~DEV_OPT_MULTICAST_TO_UNICAST; 333 return; 334 } 335 336 dev->settings.multicast_to_unicast = !!val; 337 dev->settings.flags |= DEV_OPT_MULTICAST_TO_UNICAST; 338 } 339 340 static void wireless_check_interface(struct blob_attr *list, int *enabled, int *ifindex) 341 { 342 struct interface *iface; 343 struct blob_attr *cur; 344 size_t rem; 345 346 blobmsg_for_each_attr(cur, list, rem) { 347 struct device *mdev; 348 349 iface = vlist_find(&interfaces, blobmsg_get_string(cur), iface, node); 350 if (!iface) 351 continue; 352 353 if (iface->autostart) 354 *enabled = 1; 355 else if (*enabled != 1) 356 *enabled = 0; 357 358 mdev = iface->main_dev.dev; 359 if (!mdev || !mdev->hotplug_ops) 360 continue; 361 362 *ifindex = mdev->ifindex; 363 } 364 } 365 366 static void wireless_interface_handle_link(struct wireless_interface *vif, const char *ifname, bool up) 367 { 368 struct interface *iface; 369 struct blob_attr *cur; 370 const char *network; 371 struct device *dev; 372 int enabled = -1; 373 size_t rem; 374 375 if (!vif->network || !vif->ifname) 376 return; 377 378 if (!ifname) 379 ifname = vif->ifname; 380 381 if (!up) 382 goto out; 383 384 dev = __device_get(ifname, 2, false); 385 if (!dev) 386 goto out; 387 388 dev->wireless = true; 389 dev->settings.flags |= DEV_OPT_ISOLATE; 390 dev->settings.isolate = vif->bridge_isolate; 391 392 if (strcmp(ifname, vif->ifname) != 0) 393 goto out; 394 395 dev->wireless_isolate = vif->isolate; 396 dev->wireless_proxyarp = vif->proxyarp; 397 dev->wireless_ap = vif->ap_mode; 398 wireless_device_set_mcast_to_unicast(dev, vif->multicast_to_unicast); 399 dev->bpdu_filter = dev->wireless_ap; 400 401 out: 402 wireless_check_interface(vif->network, &enabled, &vif->network_ifindex); 403 blobmsg_for_each_attr(cur, vif->network, rem) { 404 network = blobmsg_data(cur); 405 406 iface = vlist_find(&interfaces, network, iface, node); 407 if (!iface) 408 continue; 409 410 interface_handle_link(iface, ifname, vif->network_vlan, up, true); 411 } 412 } 413 414 static void wireless_vlan_handle_link(struct wireless_vlan *vlan, bool up) 415 { 416 struct interface *iface; 417 struct blob_attr *cur; 418 const char *network; 419 int enabled = -1; 420 size_t rem; 421 422 if (!vlan->network || !vlan->ifname) 423 return; 424 425 if (up) { 426 struct device *dev = device_get(vlan->ifname, 2); 427 if (dev) { 428 dev->wireless_isolate = vlan->isolate; 429 dev->wireless = true; 430 dev->wireless_ap = true; 431 dev->bpdu_filter = true; 432 dev->settings.flags |= DEV_OPT_ISOLATE; 433 dev->settings.isolate = vlan->bridge_isolate; 434 wireless_device_set_mcast_to_unicast(dev, vlan->multicast_to_unicast); 435 } 436 } 437 438 wireless_check_interface(vlan->network, &enabled, &vlan->network_ifindex); 439 blobmsg_for_each_attr(cur, vlan->network, rem) { 440 network = blobmsg_data(cur); 441 442 iface = vlist_find(&interfaces, network, iface, node); 443 if (!iface) 444 continue; 445 446 interface_handle_link(iface, vlan->ifname, vlan->network_vlan, up, true); 447 } 448 } 449 450 static void 451 wireless_device_setup_cancel(struct wireless_device *wdev) 452 { 453 if (wdev->cancel) 454 return; 455 456 wireless_handler_stop(wdev); 457 D(WIRELESS, "Cancel wireless device '%s' setup", wdev->name); 458 wdev->cancel = true; 459 uloop_timeout_set(&wdev->timeout, 10 * 1000); 460 } 461 462 static void 463 wireless_device_run_handler(struct wireless_device *wdev, bool up) 464 { 465 const char *action = up ? "setup" : "teardown"; 466 const char *argv[6]; 467 char *config; 468 int i = 0; 469 int fds[2] = { -1, -1 }; 470 471 wireless_handler_stop(wdev); 472 473 if (handler_pending && wdev->serialize) { 474 wdev->handler_action = up; 475 wdev->handler_pending = true; 476 list_add_tail(&wdev->handler, &handlers); 477 return; 478 } 479 if (wdev->serialize) 480 handler_pending = true; 481 482 D(WIRELESS, "Wireless device '%s' run %s handler", wdev->name, action); 483 if (!up && wdev->prev_config) { 484 config = blobmsg_format_json(wdev->prev_config, true); 485 free(wdev->prev_config); 486 wdev->prev_config = NULL; 487 } else { 488 prepare_config(wdev, &b, up); 489 free(wdev->prev_config); 490 wdev->prev_config = up ? blob_memdup(b.head) : NULL; 491 config = blobmsg_format_json(b.head, true); 492 } 493 494 argv[i++] = wdev->drv->script; 495 argv[i++] = wdev->drv->name; 496 argv[i++] = action; 497 argv[i++] = wdev->name; 498 argv[i++] = config; 499 argv[i] = NULL; 500 501 if (up && pipe(fds) == 0) { 502 if (wdev->script_proc_fd.fd >= 0) 503 wireless_close_script_proc_fd(wdev); 504 505 wdev->script_proc_fd.fd = fds[0]; 506 uloop_fd_add(&wdev->script_proc_fd, 507 ULOOP_READ | ULOOP_EDGE_TRIGGER); 508 } 509 510 netifd_start_process(argv, NULL, &wdev->script_task); 511 512 if (fds[1] >= 0) 513 close(fds[1]); 514 515 free(config); 516 } 517 518 static void 519 wireless_handler_next(void) 520 { 521 struct wireless_device *wdev; 522 523 if (handler_pending) 524 return; 525 if (list_empty(&handlers)) 526 return; 527 wdev = list_first_entry(&handlers, struct wireless_device, handler); 528 list_del(&wdev->handler); 529 wdev->handler_pending = false; 530 wireless_device_run_handler(wdev, wdev->handler_action); 531 } 532 533 static void 534 __wireless_device_set_up(struct wireless_device *wdev, int force) 535 { 536 if (wdev->disabled) 537 return; 538 539 if (wdev->retry_setup_failed) 540 return; 541 542 if (!wdev->autostart) 543 return; 544 545 if ((!force && wdev->state != IFS_DOWN) || config_init) 546 return; 547 548 wdev->state = IFS_SETUP; 549 wireless_device_run_handler(wdev, true); 550 } 551 552 static void 553 wireless_device_free(struct wireless_device *wdev) 554 { 555 wireless_handler_stop(wdev); 556 vlist_flush_all(&wdev->interfaces); 557 avl_delete(&wireless_devices.avl, &wdev->node.avl); 558 free(wdev->config); 559 free(wdev->prev_config); 560 free(wdev); 561 } 562 563 static void 564 wdev_handle_config_change(struct wireless_device *wdev) 565 { 566 enum interface_config_state state = wdev->config_state; 567 568 switch(state) { 569 case IFC_RELOAD: 570 wdev->retry = WIRELESS_SETUP_RETRY; 571 wdev->retry_setup_failed = false; 572 fallthrough; 573 case IFC_NORMAL: 574 __wireless_device_set_up(wdev, 0); 575 576 wdev->config_state = IFC_NORMAL; 577 break; 578 case IFC_REMOVE: 579 wireless_device_free(wdev); 580 break; 581 } 582 } 583 584 static void 585 wireless_device_mark_down(struct wireless_device *wdev) 586 { 587 struct wireless_interface *vif; 588 struct wireless_vlan *vlan; 589 590 netifd_log_message(L_NOTICE, "Wireless device '%s' is now down\n", wdev->name); 591 592 593 vlist_for_each_element(&wdev->interfaces, vif, node) { 594 wireless_interface_handle_link(vif, NULL, false); 595 vlist_for_each_element(&vif->vlans, vlan, node) 596 wireless_vlan_handle_link(vlan, false); 597 } 598 599 wireless_process_kill_all(wdev, SIGTERM, true); 600 601 wdev->cancel = false; 602 wdev->state = IFS_DOWN; 603 wireless_device_free_state(wdev); 604 wdev_handle_config_change(wdev); 605 netifd_ubus_wireless_notify(wdev, false); 606 } 607 608 /* timeout callback to protect the tear down */ 609 static void 610 wireless_device_setup_timeout(struct uloop_timeout *timeout) 611 { 612 struct wireless_device *wdev = container_of(timeout, struct wireless_device, timeout); 613 614 if (wdev->handler_pending) { 615 wdev->handler_pending = false; 616 list_del(&wdev->handler); 617 } 618 netifd_kill_process(&wdev->script_task); 619 wdev->script_task.cb(&wdev->script_task, -1); 620 wireless_device_mark_down(wdev); 621 } 622 623 void 624 wireless_device_set_up(struct wireless_device *wdev) 625 { 626 wdev->retry = WIRELESS_SETUP_RETRY; 627 wdev->autostart = true; 628 __wireless_device_set_up(wdev, 0); 629 } 630 631 void 632 wireless_device_reconf(struct wireless_device *wdev) 633 { 634 wdev->retry = WIRELESS_SETUP_RETRY; 635 wdev->autostart = true; 636 __wireless_device_set_up(wdev, wdev->reconf && (wdev->state == IFS_UP)); 637 } 638 639 static void 640 __wireless_device_set_down(struct wireless_device *wdev) 641 { 642 if (wdev->state == IFS_TEARDOWN || wdev->state == IFS_DOWN) 643 return; 644 645 if (wdev->script_task.uloop.pending) { 646 wireless_device_setup_cancel(wdev); 647 return; 648 } 649 650 wdev->state = IFS_TEARDOWN; 651 wireless_device_run_handler(wdev, false); 652 } 653 654 /* ubus callback network.wireless.notify, command = up */ 655 static void 656 wireless_device_mark_up(struct wireless_device *wdev) 657 { 658 struct wireless_interface *vif; 659 struct wireless_vlan *vlan; 660 661 if (wdev->cancel) { 662 wdev->cancel = false; 663 __wireless_device_set_down(wdev); 664 return; 665 } 666 667 netifd_log_message(L_NOTICE, "Wireless device '%s' is now up\n", wdev->name); 668 wdev->retry = WIRELESS_SETUP_RETRY; 669 wdev->state = IFS_UP; 670 vlist_for_each_element(&wdev->interfaces, vif, node) { 671 wireless_interface_handle_link(vif, NULL, true); 672 vlist_for_each_element(&vif->vlans, vlan, node) 673 wireless_vlan_handle_link(vlan, true); 674 } 675 netifd_ubus_wireless_notify(wdev, true); 676 } 677 678 static void 679 wireless_device_retry_setup(struct wireless_device *wdev) 680 { 681 if (wdev->state == IFS_TEARDOWN || wdev->state == IFS_DOWN || wdev->cancel) 682 return; 683 684 netifd_log_message(wdev->retry ? L_WARNING : L_CRIT, 685 "Wireless device '%s' setup failed, retry=%d\n", 686 wdev->name, wdev->retry); 687 if (--wdev->retry < 0) 688 wdev->retry_setup_failed = true; 689 690 __wireless_device_set_down(wdev); 691 } 692 693 static void 694 wireless_device_script_task_cb(struct netifd_process *proc, int ret) 695 { 696 struct wireless_device *wdev = container_of(proc, struct wireless_device, script_task); 697 698 switch (wdev->state) { 699 case IFS_SETUP: 700 wireless_device_retry_setup(wdev); 701 break; 702 case IFS_TEARDOWN: 703 wireless_device_mark_down(wdev); 704 break; 705 default: 706 break; 707 } 708 709 if (wdev->serialize) { 710 handler_pending = false; 711 wireless_handler_next(); 712 } 713 } 714 715 void 716 wireless_device_set_down(struct wireless_device *wdev) 717 { 718 wdev->retry_setup_failed = false; 719 wdev->autostart = false; 720 __wireless_device_set_down(wdev); 721 } 722 723 static void 724 wdev_set_config_state(struct wireless_device *wdev, enum interface_config_state s) 725 { 726 if (wdev->config_state != IFC_NORMAL) 727 return; 728 729 wdev->config_update = false; 730 if (!wdev->disabled && s == IFC_RELOAD && wdev->reconf && wdev->state == IFS_UP) { 731 wireless_device_reconf(wdev); 732 return; 733 } 734 735 wdev->config_state = s; 736 if (wdev->state == IFS_DOWN) 737 wdev_handle_config_change(wdev); 738 else 739 __wireless_device_set_down(wdev); 740 } 741 742 static void 743 wdev_prepare_prev_config(struct wireless_device *wdev) 744 { 745 prepare_config(wdev, &b, false); 746 free(wdev->prev_config); 747 wdev->prev_config = blob_memdup(b.head); 748 } 749 750 static void 751 wdev_change_config(struct wireless_device *wdev, struct wireless_device *wd_new) 752 { 753 struct blob_attr *new_config = wd_new->config; 754 bool disabled = wd_new->disabled; 755 756 wdev->reconf = wd_new->reconf; 757 wdev->serialize = wd_new->serialize; 758 free(wd_new); 759 760 if (blob_attr_equal(wdev->config, new_config) && wdev->disabled == disabled) 761 return; 762 763 D(WIRELESS, "Update configuration of wireless device '%s'", wdev->name); 764 free(wdev->config); 765 wdev->config = blob_memdup(new_config); 766 wdev->disabled = disabled; 767 wdev->config_update = true; 768 } 769 770 static void 771 wdev_create(struct wireless_device *wdev) 772 { 773 wdev->retry = WIRELESS_SETUP_RETRY; 774 wdev->config = blob_memdup(wdev->config); 775 } 776 777 /* vlist update call for wireless device list */ 778 static void 779 wdev_update(struct vlist_tree *tree, struct vlist_node *node_new, 780 struct vlist_node *node_old) 781 { 782 struct wireless_device *wd_old = container_of(node_old, struct wireless_device, node); 783 struct wireless_device *wd_new = container_of(node_new, struct wireless_device, node); 784 785 if (wd_old && wd_new) { 786 D(WIRELESS, "Update wireless device '%s'", wd_old->name); 787 wdev_change_config(wd_old, wd_new); 788 } else if (wd_old) { 789 D(WIRELESS, "Delete wireless device '%s'", wd_old->name); 790 wdev_set_config_state(wd_old, IFC_REMOVE); 791 } else if (wd_new) { 792 D(WIRELESS, "Create wireless device '%s'", wd_new->name); 793 wdev_create(wd_new); 794 } 795 } 796 797 /* wireless netifd script handler */ 798 static void 799 wireless_add_handler(const char *script, const char *name, json_object *obj) 800 { 801 struct wireless_driver *drv; 802 char *name_str, *script_str; 803 json_object *dev_config_obj, *iface_config_obj, *vlan_config_obj, *station_config_obj; 804 struct uci_blob_param_list *dev_config, *iface_config, *vlan_config, *station_config; 805 806 dev_config_obj = json_get_field(obj, "device", json_type_array); 807 iface_config_obj = json_get_field(obj, "iface", json_type_array); 808 vlan_config_obj = json_get_field(obj, "vlan", json_type_array); 809 station_config_obj = json_get_field(obj, "station", json_type_array); 810 811 if (!dev_config_obj || !iface_config_obj || !vlan_config_obj || !station_config_obj) 812 return; 813 814 drv = calloc_a(sizeof(*drv), 815 &dev_config, sizeof(*dev_config) + sizeof(void *), 816 &iface_config, sizeof(*iface_config) + sizeof(void *), 817 &vlan_config, sizeof(*vlan_config) + sizeof(void *), 818 &station_config, sizeof(*station_config) + sizeof(void *), 819 &name_str, strlen(name) + 1, 820 &script_str, strlen(script) + 1); 821 822 drv->name = strcpy(name_str, name); 823 drv->script = strcpy(script_str, script); 824 825 dev_config->n_next = 1; 826 dev_config->next[0] = &wdev_param; 827 drv->device.config = dev_config; 828 829 iface_config->n_next = 1; 830 iface_config->next[0] = &vif_param; 831 drv->interface.config = iface_config; 832 833 vlan_config->n_next = 1; 834 vlan_config->next[0] = &vlan_param; 835 drv->vlan.config = vlan_config; 836 837 station_config->n_next = 1; 838 station_config->next[0] = &station_param; 839 drv->station.config = station_config; 840 841 drv->device.buf = netifd_handler_parse_config(drv->device.config, dev_config_obj); 842 drv->interface.buf = netifd_handler_parse_config(drv->interface.config, iface_config_obj); 843 drv->vlan.buf = netifd_handler_parse_config(drv->vlan.config, vlan_config_obj); 844 drv->station.buf = netifd_handler_parse_config(drv->station.config, station_config_obj); 845 846 drv->node.key = drv->name; 847 avl_insert(&wireless_drivers, &drv->node); 848 D(WIRELESS, "Add handler for script %s: %s", script, name); 849 } 850 851 void wireless_init(void) 852 { 853 vlist_init(&wireless_devices, avl_strcmp, wdev_update); 854 wireless_devices.keep_old = true; 855 wireless_devices.no_delete = true; 856 857 avl_init(&wireless_drivers, avl_strcmp, false, NULL); 858 drv_fd = netifd_open_subdir("wireless"); 859 if (drv_fd < 0) 860 return; 861 862 netifd_init_script_handlers(drv_fd, wireless_add_handler); 863 } 864 865 /* parse blob config into the wireless interface object */ 866 static void 867 wireless_interface_init_config(struct wireless_interface *vif) 868 { 869 struct blob_attr *tb[__VIF_ATTR_MAX]; 870 struct blob_attr *cur; 871 872 vif->network = NULL; 873 blobmsg_parse_attr(vif_policy, __VIF_ATTR_MAX, tb, vif->config); 874 875 if ((cur = tb[VIF_ATTR_NETWORK])) 876 vif->network = cur; 877 878 if ((cur = tb[VIF_ATTR_NETWORK_VLAN])) 879 vif->network_vlan = cur; 880 881 cur = tb[VIF_ATTR_MODE]; 882 vif->ap_mode = cur && !strcmp(blobmsg_get_string(cur), "ap"); 883 884 cur = tb[VIF_ATTR_BRIDGE_ISOLATE]; 885 vif->bridge_isolate = cur && blobmsg_get_bool(cur); 886 887 cur = tb[VIF_ATTR_ISOLATE]; 888 vif->isolate = cur && blobmsg_get_bool(cur); 889 890 cur = tb[VIF_ATTR_PROXYARP]; 891 vif->proxyarp = vif->ap_mode && cur && blobmsg_get_bool(cur); 892 893 cur = tb[VIF_ATTR_MCAST_TO_UCAST]; 894 vif->multicast_to_unicast = cur ? blobmsg_get_bool(cur) : -1; 895 } 896 897 static void 898 vif_free(struct wireless_interface *vif) 899 { 900 vlist_flush_all(&vif->vlans); 901 vlist_flush_all(&vif->stations); 902 free((void *) vif->section); 903 free(vif->config); 904 free(vif); 905 } 906 907 /* vlist update call for wireless interface list */ 908 static void 909 vif_update(struct vlist_tree *tree, struct vlist_node *node_new, 910 struct vlist_node *node_old) 911 { 912 struct wireless_interface *vif_old = container_of(node_old, struct wireless_interface, node); 913 struct wireless_interface *vif_new = container_of(node_new, struct wireless_interface, node); 914 struct wireless_device *wdev; 915 916 if (vif_old) 917 wdev = vif_old->wdev; 918 else 919 wdev = vif_new->wdev; 920 921 if (vif_old && vif_new) { 922 free((void *) vif_old->section); 923 vif_old->section = strdup(vif_new->section); 924 if (blob_attr_equal(vif_old->config, vif_new->config)) { 925 free(vif_new); 926 return; 927 } 928 929 D(WIRELESS, "Update wireless interface %s on device %s", vif_new->name, wdev->name); 930 wireless_interface_handle_link(vif_old, NULL, false); 931 free(vif_old->config); 932 vif_old->config = blob_memdup(vif_new->config); 933 wireless_interface_init_config(vif_old); 934 free(vif_new); 935 } else if (vif_new) { 936 D(WIRELESS, "Create new wireless interface %s on device %s", vif_new->name, wdev->name); 937 vif_new->section = strdup(vif_new->section); 938 vif_new->config = blob_memdup(vif_new->config); 939 wireless_interface_init_config(vif_new); 940 } else if (vif_old) { 941 D(WIRELESS, "Delete wireless interface %s on device %s", vif_old->name, wdev->name); 942 wireless_interface_handle_link(vif_old, NULL, false); 943 vif_free(vif_old); 944 } 945 946 wdev->config_update = true; 947 } 948 949 /* parse blob config into the vlan object */ 950 static void 951 wireless_vlan_init_config(struct wireless_vlan *vlan) 952 { 953 struct blob_attr *tb[__VLAN_ATTR_MAX]; 954 struct blob_attr *cur; 955 956 vlan->network = NULL; 957 blobmsg_parse_attr(vlan_policy, __VLAN_ATTR_MAX, tb, vlan->config); 958 959 if ((cur = tb[VLAN_ATTR_NETWORK])) 960 vlan->network = cur; 961 962 if ((cur = tb[VLAN_ATTR_NETWORK_VLAN])) 963 vlan->network_vlan = cur; 964 965 cur = tb[VLAN_ATTR_BRIDGE_ISOLATE]; 966 vlan->bridge_isolate = cur && blobmsg_get_bool(cur); 967 968 cur = tb[VLAN_ATTR_ISOLATE]; 969 vlan->isolate = cur && blobmsg_get_bool(cur); 970 971 cur = tb[VLAN_ATTR_MCAST_TO_UCAST]; 972 vlan->multicast_to_unicast = cur ? blobmsg_get_bool(cur) : -1; 973 } 974 975 /* vlist update call for vlan list */ 976 static void 977 vlan_update(struct vlist_tree *tree, struct vlist_node *node_new, 978 struct vlist_node *node_old) 979 { 980 struct wireless_vlan *vlan_old = container_of_safe(node_old, struct wireless_vlan, node); 981 struct wireless_vlan *vlan_new = container_of_safe(node_new, struct wireless_vlan, node); 982 struct wireless_interface *vif = container_of(tree, struct wireless_interface, vlans); 983 struct wireless_device *wdev = vif->wdev; 984 985 if (vlan_old && vlan_new) { 986 free((void *) vlan_old->section); 987 vlan_old->section = strdup(vlan_new->section); 988 if (blob_attr_equal(vlan_old->config, vlan_new->config)) { 989 free(vlan_new); 990 return; 991 } 992 993 D(WIRELESS, "Update wireless vlan %s on device %s", vlan_new->name, wdev->name); 994 wireless_vlan_handle_link(vlan_old, false); 995 free(vlan_old->config); 996 vlan_old->config = blob_memdup(vlan_new->config); 997 vlan_old->isolate = vlan_new->isolate; 998 wireless_vlan_init_config(vlan_old); 999 free(vlan_new); 1000 } else if (vlan_new) { 1001 D(WIRELESS, "Create new wireless vlan %s on device %s", vlan_new->name, wdev->name); 1002 vlan_new->section = strdup(vlan_new->section); 1003 vlan_new->config = blob_memdup(vlan_new->config); 1004 wireless_vlan_init_config(vlan_new); 1005 } else if (vlan_old) { 1006 D(WIRELESS, "Delete wireless vlan %s on device %s", vlan_old->name, wdev->name); 1007 wireless_vlan_handle_link(vlan_old, false); 1008 free((void *) vlan_old->section); 1009 free(vlan_old->config); 1010 free(vlan_old); 1011 } 1012 1013 wdev->config_update = true; 1014 } 1015 1016 /* vlist update call for station list */ 1017 static void 1018 station_update(struct vlist_tree *tree, struct vlist_node *node_new, 1019 struct vlist_node *node_old) 1020 { 1021 struct wireless_station *sta_old = container_of_safe(node_old, struct wireless_station, node); 1022 struct wireless_station *sta_new = container_of_safe(node_new, struct wireless_station, node); 1023 struct wireless_interface *vif = container_of(tree, struct wireless_interface, stations); 1024 struct wireless_device *wdev = vif->wdev; 1025 1026 if (sta_old && sta_new) { 1027 free((void *) sta_old->section); 1028 sta_old->section = strdup(sta_new->section); 1029 if (blob_attr_equal(sta_old->config, sta_new->config)) { 1030 free(sta_new); 1031 return; 1032 } 1033 1034 D(WIRELESS, "Update wireless station %s on device %s", sta_new->name, wdev->name); 1035 free(sta_old->config); 1036 sta_old->config = blob_memdup(sta_new->config); 1037 free(sta_new); 1038 } else if (sta_new) { 1039 D(WIRELESS, "Create new wireless station %s on device %s", sta_new->name, wdev->name); 1040 sta_new->section = strdup(sta_new->section); 1041 sta_new->config = blob_memdup(sta_new->config); 1042 } else if (sta_old) { 1043 D(WIRELESS, "Delete wireless station %s on device %s", sta_old->name, wdev->name); 1044 free((void *) sta_old->section); 1045 free(sta_old->config); 1046 free(sta_old); 1047 } 1048 1049 wdev->config_update = true; 1050 } 1051 1052 static void 1053 wireless_proc_poll_fd(struct uloop_fd *fd, unsigned int events) 1054 { 1055 struct wireless_device *wdev = container_of(fd, struct wireless_device, script_proc_fd); 1056 char buf[128]; 1057 1058 while (1) { 1059 int b = read(fd->fd, buf, sizeof(buf)); 1060 if (b < 0) { 1061 if (errno == EINTR) 1062 continue; 1063 1064 if (errno == EAGAIN) 1065 return; 1066 1067 goto done; 1068 } 1069 1070 if (!b) 1071 goto done; 1072 } 1073 1074 done: 1075 uloop_timeout_set(&wdev->script_check, 0); 1076 wireless_close_script_proc_fd(wdev); 1077 } 1078 1079 /* watchdog and garbage collector for wireless processes. 1080 * It cleans up terminated processes. If a process is a requirement for the wireless device, it retries the setup */ 1081 static void 1082 wireless_device_check_script_tasks(struct uloop_timeout *timeout) 1083 { 1084 struct wireless_device *wdev = container_of(timeout, struct wireless_device, script_check); 1085 struct wireless_process *proc, *tmp; 1086 bool restart = false; 1087 1088 list_for_each_entry_safe(proc, tmp, &wdev->script_proc, list) { 1089 if (wireless_process_check(proc)) 1090 continue; 1091 1092 D(WIRELESS, "Wireless device '%s' pid %d has terminated", wdev->name, proc->pid); 1093 if (proc->required) 1094 restart = true; 1095 1096 wireless_process_free(wdev, proc); 1097 } 1098 1099 if (restart) 1100 wireless_device_retry_setup(wdev); 1101 else 1102 uloop_timeout_set(&wdev->script_check, 1000); 1103 } 1104 1105 /* creates a wireless device object. Called by config */ 1106 void 1107 wireless_device_create(struct wireless_driver *drv, const char *name, struct blob_attr *data) 1108 { 1109 struct wireless_device *wdev; 1110 char *name_buf; 1111 struct blob_attr *tb[__WDEV_ATTR_MAX]; 1112 struct blob_attr *cur; 1113 1114 blobmsg_parse_attr(wdev_policy, __WDEV_ATTR_MAX, tb, data); 1115 1116 wdev = calloc_a(sizeof(*wdev), &name_buf, strlen(name) + 1); 1117 1118 cur = tb[WDEV_ATTR_DISABLED]; 1119 wdev->disabled = cur && blobmsg_get_bool(cur); 1120 1121 wdev->drv = drv; 1122 wdev->state = IFS_DOWN; 1123 wdev->config_state = IFC_NORMAL; 1124 wdev->name = strcpy(name_buf, name); 1125 wdev->config = data; 1126 wdev->handler_pending = false; 1127 1128 cur = tb[WDEV_ATTR_SERIALIZE]; 1129 wdev->serialize = cur && blobmsg_get_bool(cur); 1130 1131 cur = tb[WDEV_ATTR_RECONF]; 1132 wdev->reconf = !cur || blobmsg_get_bool(cur); 1133 1134 wdev->retry_setup_failed = false; 1135 wdev->autostart = true; 1136 INIT_LIST_HEAD(&wdev->script_proc); 1137 vlist_init(&wdev->interfaces, avl_strcmp, vif_update); 1138 wdev->interfaces.keep_old = true; 1139 1140 wdev->timeout.cb = wireless_device_setup_timeout; 1141 wdev->script_task.cb = wireless_device_script_task_cb; 1142 wdev->script_task.dir_fd = drv_fd; 1143 wdev->script_task.log_prefix = wdev->name; 1144 1145 wdev->script_proc_fd.fd = -1; 1146 wdev->script_proc_fd.cb = wireless_proc_poll_fd; 1147 1148 wdev->script_check.cb = wireless_device_check_script_tasks; 1149 1150 vlist_add(&wireless_devices, &wdev->node, wdev->name); 1151 } 1152 1153 /* creates a wireless station object. Called by config */ 1154 void 1155 wireless_station_create(struct wireless_interface *vif, struct blob_attr *data, const char *section) 1156 { 1157 struct wireless_station *sta; 1158 struct blob_attr *tb[__STA_ATTR_MAX]; 1159 struct blob_attr *cur; 1160 char *name_buf; 1161 char name[8]; 1162 1163 blobmsg_parse_attr(sta_policy, __STA_ATTR_MAX, tb, data); 1164 1165 cur = tb[STA_ATTR_DISABLED]; 1166 if (cur && blobmsg_get_bool(cur)) 1167 return; 1168 1169 sprintf(name, "%d", vif->sta_idx++); 1170 1171 sta = calloc_a(sizeof(*sta), 1172 &name_buf, strlen(name) + 1); 1173 sta->name = strcpy(name_buf, name); 1174 sta->config = data; 1175 sta->section = section; 1176 1177 vlist_add(&vif->stations, &sta->node, sta->name); 1178 } 1179 1180 /* ubus callback network.wireless.status, runs for every interface, encode the station */ 1181 static void 1182 wireless_station_status(struct wireless_station *sta, struct blob_buf *b) 1183 { 1184 void *i; 1185 1186 i = blobmsg_open_table(b, NULL); 1187 if (sta->section) 1188 blobmsg_add_string(b, "section", sta->section); 1189 put_container(b, sta->config, "config"); 1190 blobmsg_close_table(b, i); 1191 } 1192 1193 /* create a vlan object. Called by config */ 1194 void 1195 wireless_vlan_create(struct wireless_interface *vif, struct blob_attr *data, const char *section) 1196 { 1197 struct wireless_vlan *vlan; 1198 struct blob_attr *tb[__VLAN_ATTR_MAX]; 1199 struct blob_attr *cur; 1200 char *name_buf; 1201 char name[8]; 1202 1203 blobmsg_parse_attr(vlan_policy, __VLAN_ATTR_MAX, tb, data); 1204 1205 cur = tb[VLAN_ATTR_DISABLED]; 1206 if (cur && blobmsg_get_bool(cur)) 1207 return; 1208 1209 sprintf(name, "%d", vif->vlan_idx++); 1210 1211 vlan = calloc_a(sizeof(*vlan), &name_buf, strlen(name) + 1); 1212 vlan->name = strcpy(name_buf, name); 1213 vlan->config = data; 1214 vlan->section = section; 1215 1216 vlist_add(&vif->vlans, &vlan->node, vlan->name); 1217 } 1218 1219 /* ubus callback network.wireless.status, runs for every interface, encode the vlan informations */ 1220 static void 1221 wireless_vlan_status(struct wireless_vlan *vlan, struct blob_buf *b) 1222 { 1223 void *i; 1224 1225 i = blobmsg_open_table(b, NULL); 1226 if (vlan->section) 1227 blobmsg_add_string(b, "section", vlan->section); 1228 if (vlan->ifname) 1229 blobmsg_add_string(b, "ifname", vlan->ifname); 1230 put_container(b, vlan->config, "config"); 1231 blobmsg_close_table(b, i); 1232 } 1233 1234 /* create a wireless interface object. Called by config */ 1235 struct wireless_interface* wireless_interface_create(struct wireless_device *wdev, struct blob_attr *data, const char *section) 1236 { 1237 struct wireless_interface *vif; 1238 struct blob_attr *tb[__VIF_ATTR_MAX]; 1239 struct blob_attr *cur; 1240 char *name_buf; 1241 char name[8]; 1242 1243 blobmsg_parse_attr(vif_policy, __VIF_ATTR_MAX, tb, data); 1244 1245 cur = tb[VIF_ATTR_DISABLED]; 1246 if (cur && blobmsg_get_bool(cur)) 1247 return NULL; 1248 1249 sprintf(name, "%d", wdev->vif_idx++); 1250 1251 vif = calloc_a(sizeof(*vif), 1252 &name_buf, strlen(name) + 1); 1253 vif->name = strcpy(name_buf, name); 1254 vif->wdev = wdev; 1255 vif->config = data; 1256 vif->section = section; 1257 vif->isolate = false; 1258 1259 vlist_init(&vif->vlans, avl_strcmp, vlan_update); 1260 vif->vlans.keep_old = true; 1261 1262 vlist_init(&vif->stations, avl_strcmp, station_update); 1263 vif->stations.keep_old = true; 1264 1265 vlist_add(&wdev->interfaces, &vif->node, vif->name); 1266 1267 vif = vlist_find(&wdev->interfaces, name, vif, node); 1268 if (!vif) 1269 return NULL; 1270 1271 vif->vlan_idx = vif->sta_idx = 0; 1272 vlist_update(&vif->vlans); 1273 vlist_update(&vif->stations); 1274 1275 return vif; 1276 } 1277 1278 /* ubus callback network.wireless.status, runs for every interface */ 1279 static void 1280 wireless_interface_status(struct wireless_interface *iface, struct blob_buf *b) 1281 { 1282 struct wireless_vlan *vlan; 1283 struct wireless_station *sta; 1284 void *i, *j; 1285 1286 i = blobmsg_open_table(b, NULL); 1287 if (iface->section) 1288 blobmsg_add_string(b, "section", iface->section); 1289 if (iface->ifname) 1290 blobmsg_add_string(b, "ifname", iface->ifname); 1291 put_container(b, iface->config, "config"); 1292 j = blobmsg_open_array(b, "vlans"); 1293 vlist_for_each_element(&iface->vlans, vlan, node) 1294 wireless_vlan_status(vlan, b); 1295 blobmsg_close_array(b, j); 1296 j = blobmsg_open_array(b, "stations"); 1297 vlist_for_each_element(&iface->stations, sta, node) 1298 wireless_station_status(sta, b); 1299 blobmsg_close_array(b, j); 1300 blobmsg_close_table(b, i); 1301 } 1302 1303 /* ubus callback network.wireless.status */ 1304 void 1305 wireless_device_status(struct wireless_device *wdev, struct blob_buf *b) 1306 { 1307 struct wireless_interface *iface; 1308 void *c, *i; 1309 1310 c = blobmsg_open_table(b, wdev->name); 1311 blobmsg_add_u8(b, "up", wdev->state == IFS_UP); 1312 blobmsg_add_u8(b, "pending", wdev->state == IFS_SETUP || wdev->state == IFS_TEARDOWN); 1313 blobmsg_add_u8(b, "autostart", wdev->autostart); 1314 blobmsg_add_u8(b, "disabled", wdev->disabled); 1315 blobmsg_add_u8(b, "retry_setup_failed", wdev->retry_setup_failed); 1316 put_container(b, wdev->config, "config"); 1317 1318 i = blobmsg_open_array(b, "interfaces"); 1319 vlist_for_each_element(&wdev->interfaces, iface, node) 1320 wireless_interface_status(iface, b); 1321 blobmsg_close_array(b, i); 1322 blobmsg_close_table(b, c); 1323 } 1324 1325 /* ubus callback network.wireless.get_validate */ 1326 void 1327 wireless_device_get_validate(struct wireless_device *wdev, struct blob_buf *b) 1328 { 1329 struct uci_blob_param_list *p; 1330 void *c, *d; 1331 int i; 1332 1333 c = blobmsg_open_table(b, wdev->name); 1334 1335 d = blobmsg_open_table(b, "device"); 1336 p = wdev->drv->device.config; 1337 for (i = 0; i < p->n_params; i++) 1338 blobmsg_add_string(b, p->params[i].name, uci_get_validate_string(p, i)); 1339 blobmsg_close_table(b, d); 1340 1341 d = blobmsg_open_table(b, "interface"); 1342 p = wdev->drv->interface.config; 1343 for (i = 0; i < p->n_params; i++) 1344 blobmsg_add_string(b, p->params[i].name, uci_get_validate_string(p, i)); 1345 blobmsg_close_table(b, d); 1346 1347 blobmsg_close_table(b, c); 1348 } 1349 1350 /* ubus callback network.wireless.notify, command = set data, for vif */ 1351 static void 1352 wireless_interface_set_data(struct wireless_interface *vif) 1353 { 1354 enum { 1355 VIF_DATA_IFNAME, 1356 __VIF_DATA_MAX, 1357 }; 1358 static const struct blobmsg_policy data_policy[__VIF_DATA_MAX] = { 1359 [VIF_DATA_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING }, 1360 }; 1361 struct blob_attr *tb[__VIF_DATA_MAX]; 1362 struct blob_attr *cur; 1363 1364 blobmsg_parse_attr(data_policy, __VIF_DATA_MAX, tb, vif->data); 1365 1366 if ((cur = tb[VIF_DATA_IFNAME])) 1367 vif->ifname = blobmsg_data(cur); 1368 } 1369 1370 /* ubus callback network.wireless.notify, command = set data, for vlan */ 1371 static void 1372 wireless_vlan_set_data(struct wireless_vlan *vlan) 1373 { 1374 enum { 1375 VLAN_DATA_IFNAME, 1376 __VLAN_DATA_MAX, 1377 }; 1378 static const struct blobmsg_policy data_policy[__VLAN_DATA_MAX] = { 1379 [VLAN_DATA_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING }, 1380 }; 1381 struct blob_attr *tb[__VLAN_DATA_MAX]; 1382 struct blob_attr *cur; 1383 1384 blobmsg_parse_attr(data_policy, __VLAN_DATA_MAX, tb, vlan->data); 1385 1386 if ((cur = tb[VLAN_DATA_IFNAME])) 1387 vlan->ifname = blobmsg_data(cur); 1388 } 1389 1390 /* ubus callback network.wireless.notify, command = process add */ 1391 static int 1392 wireless_device_add_process(struct wireless_device *wdev, struct blob_attr *data) 1393 { 1394 enum { 1395 PROC_ATTR_PID, 1396 PROC_ATTR_EXE, 1397 PROC_ATTR_REQUIRED, 1398 PROC_ATTR_KEEP, 1399 __PROC_ATTR_MAX 1400 }; 1401 static const struct blobmsg_policy proc_policy[__PROC_ATTR_MAX] = { 1402 [PROC_ATTR_PID] = { .name = "pid", .type = BLOBMSG_TYPE_INT32 }, 1403 [PROC_ATTR_EXE] = { .name = "exe", .type = BLOBMSG_TYPE_STRING }, 1404 [PROC_ATTR_REQUIRED] = { .name = "required", .type = BLOBMSG_TYPE_BOOL }, 1405 [PROC_ATTR_KEEP] = { .name = "keep", .type = BLOBMSG_TYPE_BOOL }, 1406 }; 1407 struct blob_attr *tb[__PROC_ATTR_MAX]; 1408 struct wireless_process *proc; 1409 char *name; 1410 int pid; 1411 1412 if (!data) 1413 return UBUS_STATUS_INVALID_ARGUMENT; 1414 1415 blobmsg_parse_attr(proc_policy, __PROC_ATTR_MAX, tb, data); 1416 if (!tb[PROC_ATTR_PID] || !tb[PROC_ATTR_EXE]) 1417 return UBUS_STATUS_INVALID_ARGUMENT; 1418 1419 pid = blobmsg_get_u32(tb[PROC_ATTR_PID]); 1420 if (pid < 2) 1421 return UBUS_STATUS_INVALID_ARGUMENT; 1422 1423 proc = calloc_a(sizeof(*proc), 1424 &name, strlen(blobmsg_data(tb[PROC_ATTR_EXE])) + 1); 1425 1426 proc->pid = pid; 1427 proc->exe = strcpy(name, blobmsg_data(tb[PROC_ATTR_EXE])); 1428 1429 if (tb[PROC_ATTR_REQUIRED]) 1430 proc->required = blobmsg_get_bool(tb[PROC_ATTR_REQUIRED]); 1431 1432 if (tb[PROC_ATTR_KEEP]) 1433 proc->keep = blobmsg_get_bool(tb[PROC_ATTR_KEEP]); 1434 1435 D(WIRELESS, "Wireless device '%s' add pid %d", wdev->name, proc->pid); 1436 list_add(&proc->list, &wdev->script_proc); 1437 uloop_timeout_set(&wdev->script_check, 0); 1438 1439 return 0; 1440 } 1441 1442 /* ubus callback network.wireless.notify, command = process kill all */ 1443 static int 1444 wireless_device_process_kill_all(struct wireless_device *wdev, struct blob_attr *data, 1445 struct ubus_request_data *req) 1446 { 1447 enum { 1448 KILL_ATTR_SIGNAL, 1449 KILL_ATTR_IMMEDIATE, 1450 __KILL_ATTR_MAX 1451 }; 1452 static const struct blobmsg_policy kill_policy[__KILL_ATTR_MAX] = { 1453 [KILL_ATTR_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 }, 1454 [KILL_ATTR_IMMEDIATE] = { .name = "immediate", .type = BLOBMSG_TYPE_BOOL }, 1455 }; 1456 struct blob_attr *tb[__KILL_ATTR_MAX]; 1457 struct blob_attr *cur; 1458 bool immediate = false; 1459 int signal = SIGTERM; 1460 1461 blobmsg_parse_attr(kill_policy, __KILL_ATTR_MAX, tb, data); 1462 1463 if ((cur = tb[KILL_ATTR_SIGNAL])) 1464 signal = blobmsg_get_u32(cur); 1465 1466 if ((cur = tb[KILL_ATTR_IMMEDIATE])) 1467 immediate = blobmsg_get_bool(cur); 1468 1469 if (wdev->state != IFS_TEARDOWN || wdev->kill_request) 1470 return UBUS_STATUS_PERMISSION_DENIED; 1471 1472 wireless_process_kill_all(wdev, signal, immediate); 1473 1474 if (list_empty(&wdev->script_proc)) 1475 return 0; 1476 1477 wdev->kill_request = calloc(1, sizeof(*wdev->kill_request)); 1478 ubus_defer_request(ubus_ctx, req, wdev->kill_request); 1479 1480 return 0; 1481 } 1482 1483 /* ubus callback network.wireless.notify, command = set_retry */ 1484 static int 1485 wireless_device_set_retry(struct wireless_device *wdev, struct blob_attr *data) 1486 { 1487 static const struct blobmsg_policy retry_policy = { 1488 .name = "retry", .type = BLOBMSG_TYPE_INT32 1489 }; 1490 struct blob_attr *val; 1491 1492 blobmsg_parse_attr(&retry_policy, 1, &val, data); 1493 if (val) 1494 wdev->retry = blobmsg_get_u32(val); 1495 else 1496 wdev->retry = WIRELESS_SETUP_RETRY; 1497 __wireless_device_set_up(wdev, 0); 1498 netifd_log_message(L_NOTICE, "Wireless device '%s' set retry=%d\n", wdev->name, wdev->retry); 1499 return 0; 1500 } 1501 1502 enum { 1503 NOTIFY_CMD_UP = 0, 1504 NOTIFY_CMD_SET_DATA = 1, 1505 NOTIFY_CMD_PROCESS_ADD = 2, 1506 NOTIFY_CMD_PROCESS_KILL_ALL = 3, 1507 NOTIFY_CMD_SET_RETRY = 4, 1508 }; 1509 1510 /* ubus callback network.wireless.notify */ 1511 int 1512 wireless_device_notify(struct wireless_device *wdev, struct blob_attr *data, 1513 struct ubus_request_data *req) 1514 { 1515 enum { 1516 NOTIFY_ATTR_COMMAND, 1517 NOTIFY_ATTR_VIF, 1518 NOTIFY_ATTR_VLAN, 1519 NOTIFY_ATTR_DATA, 1520 __NOTIFY_MAX, 1521 }; 1522 static const struct blobmsg_policy notify_policy[__NOTIFY_MAX] = { 1523 [NOTIFY_ATTR_COMMAND] = { .name = "command", .type = BLOBMSG_TYPE_INT32 }, 1524 [NOTIFY_ATTR_VIF] = { .name = "interface", .type = BLOBMSG_TYPE_STRING }, 1525 [NOTIFY_ATTR_VLAN] = { .name = "vlan", .type = BLOBMSG_TYPE_STRING }, 1526 [NOTIFY_ATTR_DATA] = { .name = "data", .type = BLOBMSG_TYPE_TABLE }, 1527 }; 1528 struct wireless_interface *vif = NULL; 1529 struct wireless_vlan *vlan = NULL; 1530 struct blob_attr *tb[__NOTIFY_MAX]; 1531 struct blob_attr *cur, **pdata; 1532 1533 blobmsg_parse_attr(notify_policy, __NOTIFY_MAX, tb, data); 1534 1535 if (!tb[NOTIFY_ATTR_COMMAND]) 1536 return UBUS_STATUS_INVALID_ARGUMENT; 1537 1538 if ((cur = tb[NOTIFY_ATTR_VIF]) != NULL) { 1539 vif = vlist_find(&wdev->interfaces, blobmsg_data(cur), vif, node); 1540 if (!vif) 1541 return UBUS_STATUS_NOT_FOUND; 1542 } 1543 1544 if ((cur = tb[NOTIFY_ATTR_VLAN]) != NULL) { 1545 if (!vif) 1546 return UBUS_STATUS_NOT_FOUND; 1547 vlan = vlist_find(&vif->vlans, blobmsg_data(cur), vlan, node); 1548 if (!vlan) 1549 return UBUS_STATUS_NOT_FOUND; 1550 } 1551 1552 cur = tb[NOTIFY_ATTR_DATA]; 1553 if (!cur) 1554 return UBUS_STATUS_INVALID_ARGUMENT; 1555 1556 switch (blobmsg_get_u32(tb[NOTIFY_ATTR_COMMAND])) { 1557 case NOTIFY_CMD_UP: 1558 if (vif || vlan) 1559 return UBUS_STATUS_INVALID_ARGUMENT; 1560 1561 if (wdev->state != IFS_SETUP) 1562 return UBUS_STATUS_PERMISSION_DENIED; 1563 1564 wireless_device_mark_up(wdev); 1565 break; 1566 case NOTIFY_CMD_SET_DATA: 1567 if (vlan) 1568 pdata = &vlan->data; 1569 else if (vif) 1570 pdata = &vif->data; 1571 else 1572 pdata = &wdev->data; 1573 1574 free(*pdata); 1575 *pdata = blob_memdup(cur); 1576 if (vlan) 1577 wireless_vlan_set_data(vlan); 1578 else if (vif) 1579 wireless_interface_set_data(vif); 1580 wdev_prepare_prev_config(wdev); 1581 break; 1582 case NOTIFY_CMD_PROCESS_ADD: 1583 return wireless_device_add_process(wdev, cur); 1584 case NOTIFY_CMD_PROCESS_KILL_ALL: 1585 return wireless_device_process_kill_all(wdev, cur, req); 1586 case NOTIFY_CMD_SET_RETRY: 1587 return wireless_device_set_retry(wdev, cur); 1588 default: 1589 return UBUS_STATUS_INVALID_ARGUMENT; 1590 } 1591 1592 return 0; 1593 } 1594 1595 static void 1596 wdev_vlan_check_network_enabled(struct wireless_device *wdev, 1597 struct wireless_interface *vif) 1598 { 1599 struct wireless_vlan *vlan; 1600 1601 vlist_for_each_element(&vif->vlans, vlan, node) { 1602 int enabled = -1, ifindex = -1; 1603 1604 wireless_check_interface(vlan->network, &enabled, &ifindex); 1605 1606 if (wdev->state != IFS_UP || vlan->network_ifindex == ifindex) 1607 continue; 1608 1609 vlan->network_ifindex = ifindex; 1610 wdev->config_update = true; 1611 } 1612 } 1613 1614 static void 1615 wdev_check_network_enabled(struct wireless_device *wdev) 1616 { 1617 struct wireless_interface *vif; 1618 1619 vlist_for_each_element(&wdev->interfaces, vif, node) { 1620 int enabled = -1, ifindex = -1; 1621 1622 wireless_check_interface(vif->network, &enabled, &ifindex); 1623 wdev_vlan_check_network_enabled(wdev, vif); 1624 1625 if (vif->disabled == !enabled && 1626 (wdev->state != IFS_UP || vif->network_ifindex == ifindex)) 1627 continue; 1628 1629 vif->disabled = !enabled; 1630 vif->network_ifindex = ifindex; 1631 wdev->config_update = true; 1632 } 1633 } 1634 1635 static void 1636 __wireless_start_pending(struct uloop_timeout *t) 1637 { 1638 struct wireless_device *wdev; 1639 1640 vlist_for_each_element(&wireless_devices, wdev, node) { 1641 wdev_check_network_enabled(wdev); 1642 if (wdev->config_update) 1643 wdev_set_config_state(wdev, IFC_RELOAD); 1644 __wireless_device_set_up(wdev, 0); 1645 } 1646 } 1647 1648 void wireless_start_pending(int timeout) 1649 { 1650 static struct uloop_timeout timer = { 1651 .cb = __wireless_start_pending 1652 }; 1653 1654 if (timeout) { 1655 uloop_timeout_set(&timer, timeout); 1656 return; 1657 } 1658 1659 uloop_timeout_cancel(&timer); 1660 timer.cb(&timer); 1661 } 1662 1663 void wireless_check_network_enabled(void) 1664 { 1665 struct wireless_device *wdev; 1666 1667 vlist_for_each_element(&wireless_devices, wdev, node) { 1668 wdev_check_network_enabled(wdev); 1669 1670 if (wdev->config_update) 1671 wireless_start_pending(1000); 1672 } 1673 } 1674 1675 void wireless_device_hotplug_event(const char *name, bool add) 1676 { 1677 struct wireless_interface *vif; 1678 struct wireless_device *wdev; 1679 const char *s; 1680 size_t len; 1681 1682 s = strstr(name, ".sta"); 1683 if (s) { 1684 if (strchr(s + 4, '.')) 1685 return; 1686 1687 len = s - name; 1688 } else { 1689 len = strlen(name); 1690 } 1691 1692 vlist_for_each_element(&wireless_devices, wdev, node) { 1693 vlist_for_each_element(&wdev->interfaces, vif, node) { 1694 if (!vif->ifname) 1695 continue; 1696 1697 if (strlen(vif->ifname) != len || 1698 strncmp(vif->ifname, name, len) != 0) 1699 continue; 1700 1701 wireless_interface_handle_link(vif, name, add); 1702 } 1703 } 1704 } 1705
This page was automatically generated by LXR 0.3.1. • OpenWrt