projects / project / netifd.git / blob
? search:


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