wireless: add support for defining wifi interfaces via procd service data

[project/netifd.git] / wireless.c

diff --git a/wireless.c b/wireless.c
index 91663e8579946db188320ec8fabe78f71482d9ce..3a03988506f9dee699ebbe221b050015fb561ac7 100644 (file)
--- a/wireless.c
+++ b/wireless.c
@@ -63,6 +63,7 @@ enum {
        VIF_ATTR_DISABLED,
        VIF_ATTR_NETWORK,
        VIF_ATTR_NETWORK_VLAN,
+       VIF_ATTR_BRIDGE_ISOLATE,
        VIF_ATTR_ISOLATE,
        VIF_ATTR_MODE,
        VIF_ATTR_PROXYARP,
@@ -74,6 +75,7 @@ static const struct blobmsg_policy vif_policy[__VIF_ATTR_MAX] = {
        [VIF_ATTR_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL },
        [VIF_ATTR_NETWORK] = { .name = "network", .type = BLOBMSG_TYPE_ARRAY },
        [VIF_ATTR_NETWORK_VLAN] = { .name = "network_vlan", .type = BLOBMSG_TYPE_ARRAY },
+       [VIF_ATTR_BRIDGE_ISOLATE] = { .name = "bridge_isolate", .type = BLOBMSG_TYPE_BOOL },
        [VIF_ATTR_ISOLATE] = { .name = "isolate", .type = BLOBMSG_TYPE_BOOL },
        [VIF_ATTR_MODE] = { .name = "mode", .type = BLOBMSG_TYPE_STRING },
        [VIF_ATTR_PROXYARP] = { .name = "proxy_arp", .type = BLOBMSG_TYPE_BOOL },
@@ -89,6 +91,7 @@ enum {
        VLAN_ATTR_DISABLED,
        VLAN_ATTR_NETWORK,
        VLAN_ATTR_NETWORK_VLAN,
+       VLAN_ATTR_BRIDGE_ISOLATE,
        VLAN_ATTR_ISOLATE,
        VLAN_ATTR_MCAST_TO_UCAST,
        __VLAN_ATTR_MAX,
@@ -98,6 +101,7 @@ static const struct blobmsg_policy vlan_policy[__VLAN_ATTR_MAX] = {
        [VLAN_ATTR_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL },
        [VLAN_ATTR_NETWORK] = { .name = "network", .type = BLOBMSG_TYPE_ARRAY },
        [VLAN_ATTR_NETWORK_VLAN] = { .name = "network_vlan", .type = BLOBMSG_TYPE_ARRAY },
+       [VLAN_ATTR_BRIDGE_ISOLATE] = { .name = "bridge_isolate", .type = BLOBMSG_TYPE_BOOL },
        [VLAN_ATTR_ISOLATE] = { .name = "isolate", .type = BLOBMSG_TYPE_BOOL },
        [VLAN_ATTR_MCAST_TO_UCAST] = { .name = "multicast_to_unicast", .type = BLOBMSG_TYPE_BOOL },
 };
@@ -134,7 +138,7 @@ static void
 put_container(struct blob_buf *buf, struct blob_attr *attr, const char *name)
 {
        void *c = blobmsg_open_table(buf, name);
-       blob_put_raw(buf, blob_data(attr), blob_len(attr));
+       blob_put_raw(buf, blobmsg_data(attr), blobmsg_len(attr));
        blobmsg_close_table(buf, c);
 }
 
@@ -253,7 +257,7 @@ wireless_complete_kill_request(struct wireless_device *wdev)
 static void
 wireless_process_free(struct wireless_device *wdev, struct wireless_process *proc)
 {
-       D(WIRELESS, "Wireless device '%s' free pid %d\n", wdev->name, proc->pid);
+       D(WIRELESS, "Wireless device '%s' free pid %d", wdev->name, proc->pid);
        list_del(&proc->list);
        free(proc);
 
@@ -281,7 +285,7 @@ wireless_process_kill_all(struct wireless_device *wdev, int signal, bool free)
                bool check = wireless_process_check(proc);
 
                if (check && !proc->keep) {
-                       D(WIRELESS, "Wireless device '%s' kill pid %d\n", wdev->name, proc->pid);
+                       D(WIRELESS, "Wireless device '%s' kill pid %d", wdev->name, proc->pid);
                        kill(proc->pid, signal);
                }
 
@@ -338,6 +342,7 @@ static void wireless_interface_handle_link(struct wireless_interface *vif, const
        struct interface *iface;
        struct blob_attr *cur;
        const char *network;
+       struct device *dev;
        size_t rem;
 
        if (!vif->network || !vif->ifname)
@@ -346,19 +351,27 @@ static void wireless_interface_handle_link(struct wireless_interface *vif, const
        if (!ifname)
                ifname = vif->ifname;
 
-       if (up) {
-               struct device *dev = __device_get(ifname, 2, false);
+       if (!up)
+               goto out;
 
-               if (dev && !strcmp(ifname, vif->ifname)) {
-                       dev->wireless_isolate = vif->isolate;
-                       dev->wireless_proxyarp = vif->proxyarp;
-                       dev->wireless = true;
-                       dev->wireless_ap = vif->ap_mode;
-                       wireless_device_set_mcast_to_unicast(dev, vif->multicast_to_unicast);
-                       dev->bpdu_filter = dev->wireless_ap;
-               }
-       }
+       dev = __device_get(ifname, 2, false);
+       if (!dev)
+               goto out;
+
+       dev->wireless = true;
+       dev->settings.flags |= DEV_OPT_ISOLATE;
+       dev->settings.isolate = vif->bridge_isolate;
+
+       if (strcmp(ifname, vif->ifname) != 0)
+               goto out;
 
+       dev->wireless_isolate = vif->isolate;
+       dev->wireless_proxyarp = vif->proxyarp;
+       dev->wireless_ap = vif->ap_mode;
+       wireless_device_set_mcast_to_unicast(dev, vif->multicast_to_unicast);
+       dev->bpdu_filter = dev->wireless_ap;
+
+out:
        blobmsg_for_each_attr(cur, vif->network, rem) {
                network = blobmsg_data(cur);
 
@@ -387,6 +400,8 @@ static void wireless_vlan_handle_link(struct wireless_vlan *vlan, bool up)
                        dev->wireless = true;
                        dev->wireless_ap = true;
                        dev->bpdu_filter = true;
+                       dev->settings.flags |= DEV_OPT_ISOLATE;
+                       dev->settings.isolate = vlan->bridge_isolate;
                        wireless_device_set_mcast_to_unicast(dev, vlan->multicast_to_unicast);
                }
        }
@@ -409,7 +424,7 @@ wireless_device_setup_cancel(struct wireless_device *wdev)
                return;
 
        wireless_handler_stop(wdev);
-       D(WIRELESS, "Cancel wireless device '%s' setup\n", wdev->name);
+       D(WIRELESS, "Cancel wireless device '%s' setup", wdev->name);
        wdev->cancel = true;
        uloop_timeout_set(&wdev->timeout, 10 * 1000);
 }
@@ -434,7 +449,7 @@ wireless_device_run_handler(struct wireless_device *wdev, bool up)
        if (wdev->serialize)
                handler_pending = true;
 
-       D(WIRELESS, "Wireless device '%s' run %s handler\n", wdev->name, action);
+       D(WIRELESS, "Wireless device '%s' run %s handler", wdev->name, action);
        if (!up && wdev->prev_config) {
                config = blobmsg_format_json(wdev->prev_config, true);
                free(wdev->prev_config);
@@ -713,7 +728,7 @@ wdev_change_config(struct wireless_device *wdev, struct wireless_device *wd_new)
        if (blob_attr_equal(wdev->config, new_config) && wdev->disabled == disabled)
                return;
 
-       D(WIRELESS, "Update configuration of wireless device '%s'\n", wdev->name);
+       D(WIRELESS, "Update configuration of wireless device '%s'", wdev->name);
        free(wdev->config);
        wdev->config = blob_memdup(new_config);
        wdev->disabled = disabled;
@@ -736,13 +751,13 @@ wdev_update(struct vlist_tree *tree, struct vlist_node *node_new,
        struct wireless_device *wd_new = container_of(node_new, struct wireless_device, node);
 
        if (wd_old && wd_new) {
-               D(WIRELESS, "Update wireless device '%s'\n", wd_old->name);
+               D(WIRELESS, "Update wireless device '%s'", wd_old->name);
                wdev_change_config(wd_old, wd_new);
        } else if (wd_old) {
-               D(WIRELESS, "Delete wireless device '%s'\n", wd_old->name);
+               D(WIRELESS, "Delete wireless device '%s'", wd_old->name);
                wdev_set_config_state(wd_old, IFC_REMOVE);
        } else if (wd_new) {
-               D(WIRELESS, "Create wireless device '%s'\n", wd_new->name);
+               D(WIRELESS, "Create wireless device '%s'", wd_new->name);
                wdev_create(wd_new);
        }
 }
@@ -798,7 +813,7 @@ wireless_add_handler(const char *script, const char *name, json_object *obj)
 
        drv->node.key = drv->name;
        avl_insert(&wireless_drivers, &drv->node);
-       D(WIRELESS, "Add handler for script %s: %s\n", script, name);
+       D(WIRELESS, "Add handler for script %s: %s", script, name);
 }
 
 void wireless_init(void)
@@ -823,7 +838,7 @@ wireless_interface_init_config(struct wireless_interface *vif)
        struct blob_attr *cur;
 
        vif->network = NULL;
-       blobmsg_parse(vif_policy, __VIF_ATTR_MAX, tb, blob_data(vif->config), blob_len(vif->config));
+       blobmsg_parse_attr(vif_policy, __VIF_ATTR_MAX, tb, vif->config);
 
        if ((cur = tb[VIF_ATTR_NETWORK]))
                vif->network = cur;
@@ -834,8 +849,11 @@ wireless_interface_init_config(struct wireless_interface *vif)
        cur = tb[VIF_ATTR_MODE];
        vif->ap_mode = cur && !strcmp(blobmsg_get_string(cur), "ap");
 
+       cur = tb[VIF_ATTR_BRIDGE_ISOLATE];
+       vif->bridge_isolate = cur && blobmsg_get_bool(cur);
+
        cur = tb[VIF_ATTR_ISOLATE];
-       vif->isolate = vif->ap_mode && cur && blobmsg_get_bool(cur);
+       vif->isolate = cur && blobmsg_get_bool(cur);
 
        cur = tb[VIF_ATTR_PROXYARP];
        vif->proxyarp = vif->ap_mode && cur && blobmsg_get_bool(cur);
@@ -876,19 +894,19 @@ vif_update(struct vlist_tree *tree, struct vlist_node *node_new,
                        return;
                }
 
-               D(WIRELESS, "Update wireless interface %s on device %s\n", vif_new->name, wdev->name);
+               D(WIRELESS, "Update wireless interface %s on device %s", vif_new->name, wdev->name);
                wireless_interface_handle_link(vif_old, NULL, false);
                free(vif_old->config);
                vif_old->config = blob_memdup(vif_new->config);
                wireless_interface_init_config(vif_old);
                free(vif_new);
        } else if (vif_new) {
-               D(WIRELESS, "Create new wireless interface %s on device %s\n", vif_new->name, wdev->name);
+               D(WIRELESS, "Create new wireless interface %s on device %s", vif_new->name, wdev->name);
                vif_new->section = strdup(vif_new->section);
                vif_new->config = blob_memdup(vif_new->config);
                wireless_interface_init_config(vif_new);
        } else if (vif_old) {
-               D(WIRELESS, "Delete wireless interface %s on device %s\n", vif_old->name, wdev->name);
+               D(WIRELESS, "Delete wireless interface %s on device %s", vif_old->name, wdev->name);
                wireless_interface_handle_link(vif_old, NULL, false);
                vif_free(vif_old);
        }
@@ -904,7 +922,7 @@ wireless_vlan_init_config(struct wireless_vlan *vlan)
        struct blob_attr *cur;
 
        vlan->network = NULL;
-       blobmsg_parse(vlan_policy, __VLAN_ATTR_MAX, tb, blob_data(vlan->config), blob_len(vlan->config));
+       blobmsg_parse_attr(vlan_policy, __VLAN_ATTR_MAX, tb, vlan->config);
 
        if ((cur = tb[VLAN_ATTR_NETWORK]))
                vlan->network = cur;
@@ -912,9 +930,11 @@ wireless_vlan_init_config(struct wireless_vlan *vlan)
        if ((cur = tb[VLAN_ATTR_NETWORK_VLAN]))
                vlan->network_vlan = cur;
 
+       cur = tb[VLAN_ATTR_BRIDGE_ISOLATE];
+       vlan->bridge_isolate = cur && blobmsg_get_bool(cur);
+
        cur = tb[VLAN_ATTR_ISOLATE];
-       if (cur)
-               vlan->isolate = blobmsg_get_bool(cur);
+       vlan->isolate = cur && blobmsg_get_bool(cur);
 
        cur = tb[VLAN_ATTR_MCAST_TO_UCAST];
        vlan->multicast_to_unicast = cur ? blobmsg_get_bool(cur) : -1;
@@ -938,7 +958,7 @@ vlan_update(struct vlist_tree *tree, struct vlist_node *node_new,
                        return;
                }
 
-               D(WIRELESS, "Update wireless vlan %s on device %s\n", vlan_new->name, wdev->name);
+               D(WIRELESS, "Update wireless vlan %s on device %s", vlan_new->name, wdev->name);
                wireless_vlan_handle_link(vlan_old, false);
                free(vlan_old->config);
                vlan_old->config = blob_memdup(vlan_new->config);
@@ -946,12 +966,12 @@ vlan_update(struct vlist_tree *tree, struct vlist_node *node_new,
                wireless_vlan_init_config(vlan_old);
                free(vlan_new);
        } else if (vlan_new) {
-               D(WIRELESS, "Create new wireless vlan %s on device %s\n", vlan_new->name, wdev->name);
+               D(WIRELESS, "Create new wireless vlan %s on device %s", vlan_new->name, wdev->name);
                vlan_new->section = strdup(vlan_new->section);
                vlan_new->config = blob_memdup(vlan_new->config);
                wireless_vlan_init_config(vlan_new);
        } else if (vlan_old) {
-               D(WIRELESS, "Delete wireless vlan %s on device %s\n", vlan_old->name, wdev->name);
+               D(WIRELESS, "Delete wireless vlan %s on device %s", vlan_old->name, wdev->name);
                wireless_vlan_handle_link(vlan_old, false);
                free((void *) vlan_old->section);
                free(vlan_old->config);
@@ -979,16 +999,16 @@ station_update(struct vlist_tree *tree, struct vlist_node *node_new,
                        return;
                }
 
-               D(WIRELESS, "Update wireless station %s on device %s\n", sta_new->name, wdev->name);
+               D(WIRELESS, "Update wireless station %s on device %s", sta_new->name, wdev->name);
                free(sta_old->config);
                sta_old->config = blob_memdup(sta_new->config);
                free(sta_new);
        } else if (sta_new) {
-               D(WIRELESS, "Create new wireless station %s on device %s\n", sta_new->name, wdev->name);
+               D(WIRELESS, "Create new wireless station %s on device %s", sta_new->name, wdev->name);
                sta_new->section = strdup(sta_new->section);
                sta_new->config = blob_memdup(sta_new->config);
        } else if (sta_old) {
-               D(WIRELESS, "Delete wireless station %s on device %s\n", sta_old->name, wdev->name);
+               D(WIRELESS, "Delete wireless station %s on device %s", sta_old->name, wdev->name);
                free((void *) sta_old->section);
                free(sta_old->config);
                free(sta_old);
@@ -1037,7 +1057,7 @@ wireless_device_check_script_tasks(struct uloop_timeout *timeout)
                if (wireless_process_check(proc))
                        continue;
 
-               D(WIRELESS, "Wireless device '%s' pid %d has terminated\n", wdev->name, proc->pid);
+               D(WIRELESS, "Wireless device '%s' pid %d has terminated", wdev->name, proc->pid);
                if (proc->required)
                        restart = true;
 
@@ -1059,7 +1079,7 @@ wireless_device_create(struct wireless_driver *drv, const char *name, struct blo
        struct blob_attr *tb[__WDEV_ATTR_MAX];
        struct blob_attr *cur;
 
-       blobmsg_parse(wdev_policy, __WDEV_ATTR_MAX, tb, blob_data(data), blob_len(data));
+       blobmsg_parse_attr(wdev_policy, __WDEV_ATTR_MAX, tb, data);
 
        wdev = calloc_a(sizeof(*wdev), &name_buf, strlen(name) + 1);
 
@@ -1108,7 +1128,7 @@ wireless_station_create(struct wireless_interface *vif, struct blob_attr *data,
        char *name_buf;
        char name[8];
 
-       blobmsg_parse(sta_policy, __STA_ATTR_MAX, tb, blob_data(data), blob_len(data));
+       blobmsg_parse_attr(sta_policy, __STA_ATTR_MAX, tb, data);
 
        cur = tb[STA_ATTR_DISABLED];
        if (cur && blobmsg_get_bool(cur))
@@ -1148,7 +1168,7 @@ wireless_vlan_create(struct wireless_interface *vif, struct blob_attr *data, con
        char *name_buf;
        char name[8];
 
-       blobmsg_parse(vlan_policy, __VLAN_ATTR_MAX, tb, blob_data(data), blob_len(data));
+       blobmsg_parse_attr(vlan_policy, __VLAN_ATTR_MAX, tb, data);
 
        cur = tb[VLAN_ATTR_DISABLED];
        if (cur && blobmsg_get_bool(cur))
@@ -1188,7 +1208,7 @@ struct wireless_interface* wireless_interface_create(struct wireless_device *wde
        char *name_buf;
        char name[8];
 
-       blobmsg_parse(vif_policy, __VIF_ATTR_MAX, tb, blob_data(data), blob_len(data));
+       blobmsg_parse_attr(vif_policy, __VIF_ATTR_MAX, tb, data);
 
        cur = tb[VIF_ATTR_DISABLED];
        if (cur && blobmsg_get_bool(cur))
@@ -1212,7 +1232,15 @@ struct wireless_interface* wireless_interface_create(struct wireless_device *wde
 
        vlist_add(&wdev->interfaces, &vif->node, vif->name);
 
-       return vlist_find(&wdev->interfaces, name, vif, node);
+       vif = vlist_find(&wdev->interfaces, name, vif, node);
+       if (!vif)
+               return NULL;
+
+       vif->vlan_idx = vif->sta_idx = 0;
+       vlist_update(&vif->vlans);
+       vlist_update(&vif->stations);
+
+       return vif;
 }
 
 /* ubus callback network.wireless.status, runs for every interface */
@@ -1301,8 +1329,7 @@ wireless_interface_set_data(struct wireless_interface *vif)
        struct blob_attr *tb[__VIF_DATA_MAX];
        struct blob_attr *cur;
 
-       blobmsg_parse(data_policy, __VIF_DATA_MAX, tb,
-                     blobmsg_data(vif->data), blobmsg_data_len(vif->data));
+       blobmsg_parse_attr(data_policy, __VIF_DATA_MAX, tb, vif->data);
 
        if ((cur = tb[VIF_DATA_IFNAME]))
                vif->ifname = blobmsg_data(cur);
@@ -1322,8 +1349,7 @@ wireless_vlan_set_data(struct wireless_vlan *vlan)
        struct blob_attr *tb[__VLAN_DATA_MAX];
        struct blob_attr *cur;
 
-       blobmsg_parse(data_policy, __VLAN_DATA_MAX, tb,
-                     blobmsg_data(vlan->data), blobmsg_data_len(vlan->data));
+       blobmsg_parse_attr(data_policy, __VLAN_DATA_MAX, tb, vlan->data);
 
        if ((cur = tb[VLAN_DATA_IFNAME]))
                vlan->ifname = blobmsg_data(cur);
@@ -1354,7 +1380,7 @@ wireless_device_add_process(struct wireless_device *wdev, struct blob_attr *data
        if (!data)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
-       blobmsg_parse(proc_policy, __PROC_ATTR_MAX, tb, blobmsg_data(data), blobmsg_data_len(data));
+       blobmsg_parse_attr(proc_policy, __PROC_ATTR_MAX, tb, data);
        if (!tb[PROC_ATTR_PID] || !tb[PROC_ATTR_EXE])
                return UBUS_STATUS_INVALID_ARGUMENT;
 
@@ -1374,7 +1400,7 @@ wireless_device_add_process(struct wireless_device *wdev, struct blob_attr *data
        if (tb[PROC_ATTR_KEEP])
                proc->keep = blobmsg_get_bool(tb[PROC_ATTR_KEEP]);
 
-       D(WIRELESS, "Wireless device '%s' add pid %d\n", wdev->name, proc->pid);
+       D(WIRELESS, "Wireless device '%s' add pid %d", wdev->name, proc->pid);
        list_add(&proc->list, &wdev->script_proc);
        uloop_timeout_set(&wdev->script_check, 0);
 
@@ -1400,7 +1426,7 @@ wireless_device_process_kill_all(struct wireless_device *wdev, struct blob_attr
        bool immediate = false;
        int signal = SIGTERM;
 
-       blobmsg_parse(kill_policy, __KILL_ATTR_MAX, tb, blobmsg_data(data), blobmsg_data_len(data));
+       blobmsg_parse_attr(kill_policy, __KILL_ATTR_MAX, tb, data);
 
        if ((cur = tb[KILL_ATTR_SIGNAL]))
                signal = blobmsg_get_u32(cur);
@@ -1431,7 +1457,7 @@ wireless_device_set_retry(struct wireless_device *wdev, struct blob_attr *data)
        };
        struct blob_attr *val;
 
-       blobmsg_parse(&retry_policy, 1, &val, blobmsg_data(data), blobmsg_data_len(data));
+       blobmsg_parse_attr(&retry_policy, 1, &val, data);
        if (val)
                wdev->retry = blobmsg_get_u32(val);
        else
@@ -1472,7 +1498,7 @@ wireless_device_notify(struct wireless_device *wdev, struct blob_attr *data,
        struct blob_attr *tb[__NOTIFY_MAX];
        struct blob_attr *cur, **pdata;
 
-       blobmsg_parse(notify_policy, __NOTIFY_MAX, tb, blob_data(data), blob_len(data));
+       blobmsg_parse_attr(notify_policy, __NOTIFY_MAX, tb, data);
 
        if (!tb[NOTIFY_ATTR_COMMAND])
                return UBUS_STATUS_INVALID_ARGUMENT;