global: use blobmsg_parse_attr

Avoids mismatch in blob vs blobmsg parsing, simplifies code.

Signed-off-by: Felix Fietkau <[email protected]>

diff --git a/bonding.c b/bonding.c
index fef18f3c7954b36cbc31e5f93ff0630300bb94ad..8303633606d507e601b90755d01714cdf4ce42df 100644 (file)
--- a/bonding.c
+++ b/bonding.c
@@ -468,10 +468,8 @@ bonding_reload(struct device *dev, struct blob_attr *attr)
        bdev = container_of(dev, struct bonding_device, dev);
        attr = blob_memdup(attr);
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-               blob_data(attr), blob_len(attr));
-       blobmsg_parse(bonding_attrs, __BOND_ATTR_MAX, tb_b,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
+       blobmsg_parse_attr(bonding_attrs, __BOND_ATTR_MAX, tb_b, attr);
 
        bdev->has_macaddr = tb_dev[DEV_ATTR_MACADDR];
        if (bdev->primary_port && !bdev->primary_port->set_primary &&
@@ -486,15 +484,15 @@ bonding_reload(struct device *dev, struct blob_attr *attr)
                struct blob_attr *otb_dev[__DEV_ATTR_MAX];
                struct blob_attr *otb_b[__BOND_ATTR_MAX];
 
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
-                       blob_data(bdev->config_data), blob_len(bdev->config_data));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
+                                  bdev->config_data);
 
                uci_blob_diff(tb_dev, otb_dev, &device_attr_list, diff);
                if (diff[0] | diff[1])
                    ret = DEV_CONFIG_RESTART;
 
-               blobmsg_parse(bonding_attrs, __BOND_ATTR_MAX, otb_b,
-                       blob_data(bdev->config_data), blob_len(bdev->config_data));
+               blobmsg_parse_attr(bonding_attrs, __BOND_ATTR_MAX, otb_b,
+                                  bdev->config_data);
 
                diff[0] = 0;
                uci_blob_diff(tb_b, otb_b, &bonding_attr_list, diff);

diff --git a/bridge.c b/bridge.c
index 70ece78180cd62e6f4ad99df24e7c13d138bee7c..3555ddef41a1b016959ccb37e85403b9d9433d36 100644 (file)
--- a/bridge.c
+++ b/bridge.c
@@ -1268,10 +1268,8 @@ bridge_reload(struct device *dev, struct blob_attr *attr)
        bst = container_of(dev, struct bridge_state, dev);
        attr = blob_memdup(attr);
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-               blob_data(attr), blob_len(attr));
-       blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
+       blobmsg_parse_attr(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br, attr);
 
        if (tb_dev[DEV_ATTR_MACADDR])
                bst->primary_port = NULL;
@@ -1284,8 +1282,8 @@ bridge_reload(struct device *dev, struct blob_attr *attr)
                struct blob_attr *otb_dev[__DEV_ATTR_MAX];
                struct blob_attr *otb_br[__BRIDGE_ATTR_MAX];
 
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
-                       blob_data(bst->config_data), blob_len(bst->config_data));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
+                                  bst->config_data);
 
                uci_blob_diff(tb_dev, otb_dev, &device_attr_list, diff);
                if (diff[0] | diff[1]) {
@@ -1294,8 +1292,7 @@ bridge_reload(struct device *dev, struct blob_attr *attr)
                          dev->ifname, diff[1], diff[0]);
                }
 
-               blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br,
-                       blob_data(bst->config_data), blob_len(bst->config_data));
+               blobmsg_parse_attr(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br, bst->config_data);
 
                diff[0] = diff[1] = 0;
                uci_blob_diff(tb_br, otb_br, &bridge_attr_list, diff);

diff --git a/config.c b/config.c
index 56943a3d1018c559048f02718ade72fff9d48d58..eedfa7fafeaa0264bb52d67abe9c31eb8e667071 100644 (file)
--- a/config.c
+++ b/config.c
@@ -536,7 +536,7 @@ config_find_blobmsg_attr(struct blob_attr *attr, const char *name, int type)
        struct blobmsg_policy policy = { .name = name, .type = type };
        struct blob_attr *cur;
 
-       blobmsg_parse(&policy, 1, &cur, blobmsg_data(attr), blobmsg_len(attr));
+       blobmsg_parse_attr(&policy, 1, &cur, attr);
 
        return cur;
 }

diff --git a/device.c b/device.c
index e07a817485fd282305e754a157152634ec9a178d..174d115203f441605567ef7f4d2d3ee8d04ef6b8 100644 (file)
--- a/device.c
+++ b/device.c
@@ -220,7 +220,7 @@ simple_device_create(const char *name, struct device_type *devtype,
        /* device type is unused for simple devices */
        devtype = NULL;
 
-       blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(dev_attrs, __DEV_ATTR_MAX, tb, attr);
        dev = device_get(name, true);
        if (!dev)
                return NULL;
@@ -1185,8 +1185,7 @@ device_set_config(struct device *dev, struct device_type *type,
                memset(tb, 0, sizeof(tb));
 
                if (attr)
-                       blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb,
-                               blob_data(attr), blob_len(attr));
+                       blobmsg_parse_attr(dev_attrs, __DEV_ATTR_MAX, tb, attr);
 
                device_init_settings(dev, tb);
                return DEV_CONFIG_RESTART;

diff --git a/extdev.c b/extdev.c
index e2e3a91b8303dfc0c9bb2777259846d7db11c6f0..bc08f0a9b75128a63b2a8c35117153ea2e1f7068 100644 (file)
--- a/extdev.c
+++ b/extdev.c
@@ -258,7 +258,7 @@ extdev_wait_ev_cb(struct ubus_context *ctx, struct ubus_event_handler *ev_handle
        if (strcmp(type, "ubus.object.add"))
                return;
 
-       blobmsg_parse(&wait_policy, 1, &attr, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(&wait_policy, 1, &attr, msg);
        if (!attr)
                return;
 
@@ -813,7 +813,7 @@ __bridge_reload(struct extdev_bridge *ebr, struct blob_attr *config)
 
        if (config) {
                config = blob_memdup(config);
-               blobmsg_parse(brpol, __BRIDGE_MAX, tb, blobmsg_data(config), blobmsg_len(config));
+               blobmsg_parse_attr(brpol, __BRIDGE_MAX, tb, config);
                ebr->edev.dep_name = blobmsg_get_string(tb[BRIDGE_DEPENDS_ON]);
 
                if (tb[BRIDGE_EMPTY] && blobmsg_get_bool(tb[BRIDGE_EMPTY]))
@@ -823,10 +823,8 @@ __bridge_reload(struct extdev_bridge *ebr, struct blob_attr *config)
                        config_params = ebr->edev.dev.type->config_params;
                        pol = config_params->params;
 
-                       blobmsg_parse(pol, n_params, old_tb, blobmsg_data(ebr->config),
-                               blobmsg_len(ebr->config));
-                       blobmsg_parse(pol, n_params, brtb, blobmsg_data(config), blobmsg_len
-                       (config));
+                       blobmsg_parse_attr(pol, n_params, old_tb, ebr->config);
+                       blobmsg_parse_attr(pol, n_params, brtb, config);
 
                        diff = 0;
                        uci_blob_diff(brtb, old_tb, config_params, &diff);
@@ -874,10 +872,8 @@ __reload(struct extdev_device *edev, struct blob_attr *config)
        struct blob_attr *tb[params->n_params];
        struct blob_attr *old_tb[params->n_params];
 
-       blobmsg_parse(params->params, params->n_params, tb, blobmsg_data(config),
-               blobmsg_len(config));
-       blobmsg_parse(params->params, params->n_params, old_tb, blobmsg_data(edev->dev.config),
-               blobmsg_len(edev->dev.config));
+       blobmsg_parse_attr(params->params, params->n_params, tb, config);
+       blobmsg_parse_attr(params->params, params->n_params, old_tb, edev->dev.config);
 
        uci_blob_diff(tb, old_tb, edev->etype->config_params, &diff);
        if (!diff)
@@ -1207,7 +1203,7 @@ dump_cb(struct ubus_request *req, int type, struct blob_attr *reply)
 
        struct blob_attr *tb[n_params];
 
-       blobmsg_parse(info_policy, n_params, tb, blobmsg_data(reply), blobmsg_len(reply));
+       blobmsg_parse_attr(info_policy, n_params, tb, reply);
        add_parsed_data(tb, info_policy, n_params, buf);
 }
 

diff --git a/interface-ip.c b/interface-ip.c
index 7e60f64990cc6815c5c16d3a1e618152b98a571e..4bc6d875bff66be8a86f4822c305dceee4fd5238 100644 (file)
--- a/interface-ip.c
+++ b/interface-ip.c
@@ -349,7 +349,7 @@ interface_ip_add_neighbor(struct interface *iface, struct blob_attr *attr, bool
        int af = v6 ? AF_INET6: AF_INET;
        struct ether_addr *ea;
 
-       blobmsg_parse(neighbor_attr, __NEIGHBOR_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
+       blobmsg_parse_attr(neighbor_attr, __NEIGHBOR_MAX, tb, attr);
 
        if (!iface) {
                if ((cur = tb[NEIGHBOR_INTERFACE]) == NULL)
@@ -407,7 +407,7 @@ interface_ip_add_route(struct interface *iface, struct blob_attr *attr, bool v6)
        int af = v6 ? AF_INET6 : AF_INET;
        bool no_device = false;
 
-       blobmsg_parse(route_attr, __ROUTE_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
+       blobmsg_parse_attr(route_attr, __ROUTE_MAX, tb, attr);
 
        if ((cur = tb[ROUTE_DISABLED]) != NULL && blobmsg_get_bool(cur))
                return;

diff --git a/interface.c b/interface.c
index 3c9556a29b1baced7ee92b588e0426d9d1a4e5ce..44052e3fbbb2df192ee89aa1a90be71cdbada639 100644 (file)
--- a/interface.c
+++ b/interface.c
@@ -842,8 +842,7 @@ interface_alloc(const char *name, struct blob_attr *config, bool dynamic)
        iface->l3_dev.cb = interface_l3_dev_cb;
        iface->ext_dev.cb = interface_ext_dev_cb;
 
-       blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb,
-                     blob_data(config), blob_len(config));
+       blobmsg_parse_attr(iface_attrs, IFACE_ATTR_MAX, tb, config);
 
        iface->zone = NULL;
        if ((cur = tb[IFACE_ATTR_ZONE]))
@@ -957,8 +956,7 @@ static bool __interface_add(struct interface *iface, struct blob_attr *config, b
        struct blob_attr *cur;
        char *name = NULL;
 
-       blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb,
-                     blob_data(config), blob_len(config));
+       blobmsg_parse_attr(iface_attrs, IFACE_ATTR_MAX, tb, config);
 
        if (alias) {
                if ((cur = tb[IFACE_ATTR_INTERFACE]))
@@ -1277,11 +1275,8 @@ interface_device_config_changed(struct interface *if_old, struct interface *if_n
        if (!if_new->device_config)
                return false;
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb,
-               blob_data(if_old->config), blob_len(if_old->config));
-
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, ntb,
-               blob_data(if_new->config), blob_len(if_new->config));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb, if_old->config);
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, ntb, if_new->config);
 
        uci_blob_diff(ntb, otb, &device_attr_list, diff);
 

diff --git a/iprule.c b/iprule.c
index c2009c877f1b1cbf3272c61011a529fae715b468..1fedac66bd83b8ea5a52c5db40e04cf8bc3d5714 100644 (file)
--- a/iprule.c
+++ b/iprule.c
@@ -211,7 +211,7 @@ iprule_add(struct blob_attr *attr, bool v6)
        char *iface_name;
        int af = v6 ? AF_INET6 : AF_INET;
 
-       blobmsg_parse(rule_attr, __RULE_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
+       blobmsg_parse_attr(rule_attr, __RULE_MAX, tb, attr);
 
        if ((cur = tb[RULE_DISABLED]) != NULL && blobmsg_get_bool(cur))
                return;

diff --git a/macvlan.c b/macvlan.c
index cdc924f3107da106db0081fc0aabbbb719a29caf..a0bdeed2774600d9ff9c90c3c13097a8846f2820 100644 (file)
--- a/macvlan.c
+++ b/macvlan.c
@@ -189,10 +189,8 @@ macvlan_reload(struct device *dev, struct blob_attr *attr)
        mvdev = container_of(dev, struct macvlan_device, dev);
        attr = blob_memdup(attr);
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-               blob_data(attr), blob_len(attr));
-       blobmsg_parse(macvlan_attrs, __MACVLAN_ATTR_MAX, tb_mv,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
+       blobmsg_parse_attr(macvlan_attrs, __MACVLAN_ATTR_MAX, tb_mv, attr);
 
        device_init_settings(dev, tb_dev);
        macvlan_apply_settings(mvdev, tb_mv);
@@ -202,14 +200,14 @@ macvlan_reload(struct device *dev, struct blob_attr *attr)
                struct blob_attr *otb_dev[__DEV_ATTR_MAX];
                struct blob_attr *otb_mv[__MACVLAN_ATTR_MAX];
 
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
-                       blob_data(mvdev->config_data), blob_len(mvdev->config_data));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
+                                  mvdev->config_data);
 
                if (uci_blob_diff(tb_dev, otb_dev, &device_attr_list, NULL))
                    ret = DEV_CONFIG_RESTART;
 
-               blobmsg_parse(macvlan_attrs, __MACVLAN_ATTR_MAX, otb_mv,
-                       blob_data(mvdev->config_data), blob_len(mvdev->config_data));
+               blobmsg_parse_attr(macvlan_attrs, __MACVLAN_ATTR_MAX, otb_mv,
+                                  mvdev->config_data);
 
                if (uci_blob_diff(tb_mv, otb_mv, &macvlan_attr_list, NULL))
                    ret = DEV_CONFIG_RESTART;

diff --git a/proto-shell.c b/proto-shell.c
index 931a59ea61116ef032339d713a1b53a1b15e7a20..c9e5e45ac22258409e051d687338fbb74b91b389 100644 (file)
--- a/proto-shell.c
+++ b/proto-shell.c
@@ -785,7 +785,7 @@ proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr)
 
        state = container_of(proto, struct proto_shell_state, proto);
 
-       blobmsg_parse(notify_attr, __NOTIFY_LAST, tb, blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(notify_attr, __NOTIFY_LAST, tb, attr);
        if (!tb[NOTIFY_ACTION])
                return UBUS_STATUS_INVALID_ARGUMENT;
 
@@ -840,7 +840,7 @@ proto_shell_checkup_attach(struct proto_shell_state *state,
                .type = BLOBMSG_TYPE_INT32
        };
 
-       blobmsg_parse(&checkup_policy, 1, &tb, blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(&checkup_policy, 1, &tb, (struct blob_attr *)attr);
        if (!tb) {
                state->checkup_interval = -1;
                state->checkup_timeout.cb = NULL;

diff --git a/proto.c b/proto.c
index 63f461db255c61c08edcc57bb78fa3e25b35e317..c338ff27368273d3988e4bb7309f0d5b1ba6cc6b 100644 (file)
--- a/proto.c
+++ b/proto.c
@@ -194,7 +194,7 @@ parse_address_item(struct blob_attr *attr, bool v6, bool ext)
        if (!addr)
                return NULL;
 
-       blobmsg_parse(proto_ip_addr, __ADDR_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
+       blobmsg_parse_attr(proto_ip_addr, __ADDR_MAX, tb, attr);
 
        addr->mask = v6 ? 128 : 32;
        if ((cur = tb[ADDR_MASK])) {
@@ -418,7 +418,7 @@ proto_apply_static_ip_settings(struct interface *iface, struct blob_attr *attr)
        int n_v4 = 0, n_v6 = 0;
        struct in_addr bcast = {0,}, ptp = {0,};
 
-       blobmsg_parse(proto_ip_attributes, __OPT_MAX, tb, blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(proto_ip_attributes, __OPT_MAX, tb, attr);
 
        if ((cur = tb[OPT_NETMASK])) {
                netmask = parse_netmask_string(blobmsg_data(cur), false);
@@ -484,7 +484,7 @@ proto_apply_ip_settings(struct interface *iface, struct blob_attr *attr, bool ex
        struct blob_attr *cur;
        int n_v4 = 0, n_v6 = 0;
 
-       blobmsg_parse(proto_ip_attributes, __OPT_MAX, tb, blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(proto_ip_attributes, __OPT_MAX, tb, attr);
 
        if ((cur = tb[OPT_IPADDR]))
                n_v4 = parse_address_list(iface, cur, false, ext);

diff --git a/system-linux.c b/system-linux.c
index 7f6df9e0195c8652e499f93c9bdedd5f39255f47..2303cba4ab13da80c4fc15dec0ad9fab6dfbca06 100644 (file)
--- a/system-linux.c
+++ b/system-linux.c
@@ -3876,8 +3876,8 @@ static int system_add_ip6_tunnel(const char *name, const unsigned int link,
                struct blob_attr *tb_data[__IPIP6_DATA_ATTR_MAX];
                uint32_t tun_flags = IP6_TNL_F_IGN_ENCAP_LIMIT;
 
-               blobmsg_parse(ipip6_data_attr_list.params, __IPIP6_DATA_ATTR_MAX, tb_data,
-                       blobmsg_data(cur), blobmsg_len(cur));
+               blobmsg_parse_attr(ipip6_data_attr_list.params, __IPIP6_DATA_ATTR_MAX,
+                                  tb_data, cur);
 
                if ((cur = tb_data[IPIP6_DATA_ENCAPLIMIT])) {
                        char *str = blobmsg_get_string(cur);
@@ -3913,8 +3913,8 @@ static int system_add_ip6_tunnel(const char *name, const unsigned int link,
                                struct in_addr ip4prefix;
                                unsigned ip4len, ip6len, ealen, offset;
 
-                               blobmsg_parse(fmr_data_attr_list.params, __FMR_DATA_ATTR_MAX, tb_fmr,
-                                               blobmsg_data(rcur), blobmsg_len(rcur));
+                               blobmsg_parse_attr(fmr_data_attr_list.params, __FMR_DATA_ATTR_MAX,
+                                                  tb_fmr, rcur);
 
                                if (!(tb_cur = tb_fmr[FMR_DATA_PREFIX6]) ||
                                                !parse_ip_and_netmask(AF_INET6,
@@ -4043,8 +4043,8 @@ static int system_add_gre_tunnel(const char *name, const char *kind,
        if ((cur = tb[TUNNEL_ATTR_DATA])) {
                struct blob_attr *tb_data[__GRE_DATA_ATTR_MAX];
 
-               blobmsg_parse(gre_data_attr_list.params, __GRE_DATA_ATTR_MAX, tb_data,
-                       blobmsg_data(cur), blobmsg_len(cur));
+               blobmsg_parse_attr(gre_data_attr_list.params, __GRE_DATA_ATTR_MAX,
+                                  tb_data, cur);
 
                if ((cur = tb_data[GRE_DATA_IKEY])) {
                        if ((ikey = blobmsg_get_u32(cur)))
@@ -4273,8 +4273,8 @@ static int system_add_vti_tunnel(const char *name, const char *kind,
                struct blob_attr *tb_data[__VTI_DATA_ATTR_MAX];
                uint32_t ikey = 0, okey = 0;
 
-               blobmsg_parse(vti_data_attr_list.params, __VTI_DATA_ATTR_MAX, tb_data,
-                       blobmsg_data(cur), blobmsg_len(cur));
+               blobmsg_parse_attr(vti_data_attr_list.params, __VTI_DATA_ATTR_MAX,
+                                  tb_data, cur);
 
                if ((cur = tb_data[VTI_DATA_IKEY])) {
                        if ((ikey = blobmsg_get_u32(cur)))
@@ -4334,8 +4334,8 @@ static int system_add_xfrm_tunnel(const char *name, const char *kind,
                struct blob_attr *tb_data[__XFRM_DATA_ATTR_MAX];
                uint32_t if_id = 0;
 
-               blobmsg_parse(xfrm_data_attr_list.params, __XFRM_DATA_ATTR_MAX, tb_data,
-                       blobmsg_data(cur), blobmsg_len(cur));
+               blobmsg_parse_attr(xfrm_data_attr_list.params, __XFRM_DATA_ATTR_MAX,
+                                  tb_data, cur);
 
                if ((cur = tb_data[XFRM_DATA_IF_ID])) {
                        if ((if_id = blobmsg_get_u32(cur)))
@@ -4381,8 +4381,8 @@ static int system_add_vxlan(const char *name, const unsigned int link, struct bl
        int ret = 0;
 
        if ((cur = tb[TUNNEL_ATTR_DATA]))
-               blobmsg_parse(vxlan_data_attr_list.params, __VXLAN_DATA_ATTR_MAX, tb_data,
-                       blobmsg_data(cur), blobmsg_len(cur));
+               blobmsg_parse_attr(vxlan_data_attr_list.params, __VXLAN_DATA_ATTR_MAX,
+                                  tb_data, cur);
        else
                return -EINVAL;
 
@@ -4581,8 +4581,8 @@ static int system_add_sit_tunnel(const char *name, const unsigned int link, stru
                unsigned int mask;
                struct ip_tunnel_6rd p6;
 
-               blobmsg_parse(sixrd_data_attr_list.params, __SIXRD_DATA_ATTR_MAX, tb_data,
-                       blobmsg_data(cur), blobmsg_len(cur));
+               blobmsg_parse_attr(sixrd_data_attr_list.params, __SIXRD_DATA_ATTR_MAX,
+                                  tb_data, cur);
 
                memset(&p6, 0, sizeof(p6));
 
@@ -4716,8 +4716,7 @@ int system_add_ip_tunnel(const struct device *dev, struct blob_attr *attr)
        struct blob_attr *cur;
        const char *str;
 
-       blobmsg_parse(tunnel_attr_list.params, __TUNNEL_ATTR_MAX, tb,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(tunnel_attr_list.params, __TUNNEL_ATTR_MAX, tb, attr);
 
        system_link_del(dev->ifname);
 

diff --git a/tunnel.c b/tunnel.c
index 6d192ac8509423f4b4ac23a38295c0079880d154..a8386d755ecb7cba2dcb9cbb8cc60e240b7c2527 100644 (file)
--- a/tunnel.c
+++ b/tunnel.c
@@ -52,8 +52,7 @@ tunnel_reload(struct device *dev, struct blob_attr *attr)
        memset(tb_dev, 0, sizeof(tb_dev));
 
        if (attr)
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-                       blob_data(attr), blob_len(attr));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
 
        device_init_settings(dev, tb_dev);
 

diff --git a/ubus.c b/ubus.c
index 7a489239e344280aab0cb2f3baaa7a50168e6867..64bd87465dd71c7428ad410e2a37a660dd6d45fc 100644 (file)
--- a/ubus.c
+++ b/ubus.c
@@ -76,7 +76,7 @@ netifd_add_host_route(struct ubus_context *ctx, struct ubus_object *obj,
        bool v6 = false;
        bool exclude = false;
 
-       blobmsg_parse(route_policy, __HR_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(route_policy, __HR_MAX, tb, msg);
        if (!tb[HR_TARGET])
                return UBUS_STATUS_INVALID_ARGUMENT;
 
@@ -135,7 +135,7 @@ netifd_add_dynamic(struct ubus_context *ctx, struct ubus_object *obj,
        struct interface *iface;
        struct blob_attr *config;
 
-       blobmsg_parse(dynamic_policy, __DI_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(dynamic_policy, __DI_MAX, tb, msg);
 
        if (!tb[DI_NAME])
                return UBUS_STATUS_INVALID_ARGUMENT;
@@ -185,7 +185,7 @@ netifd_netns_updown(struct ubus_context *ctx, struct ubus_object *obj,
        if (target_netns_fd < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
-       blobmsg_parse(netns_updown_policy, __NETNS_UPDOWN_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(netns_updown_policy, __NETNS_UPDOWN_MAX, tb, msg);
 
        start = tb[NETNS_UPDOWN_START] && blobmsg_get_bool(tb[NETNS_UPDOWN_START]);
 
@@ -238,7 +238,7 @@ netifd_dev_status(struct ubus_context *ctx, struct ubus_object *obj,
        struct device *dev = NULL;
        struct blob_attr *tb[__DEV_MAX];
 
-       blobmsg_parse(dev_policy, __DEV_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(dev_policy, __DEV_MAX, tb, msg);
 
        if (tb[DEV_NAME]) {
                dev = device_find(blobmsg_data(tb[DEV_NAME]));
@@ -274,7 +274,7 @@ netifd_handle_alias(struct ubus_context *ctx, struct ubus_object *obj,
        struct blob_attr *cur;
        size_t rem;
 
-       blobmsg_parse(alias_attrs, __ALIAS_ATTR_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(alias_attrs, __ALIAS_ATTR_MAX, tb, msg);
 
        if (!tb[ALIAS_ATTR_ALIAS])
                return UBUS_STATUS_INVALID_ARGUMENT;
@@ -326,7 +326,7 @@ netifd_handle_set_state(struct ubus_context *ctx, struct ubus_object *obj,
        struct blob_attr *cur;
        bool auth_status;
 
-       blobmsg_parse(dev_state_policy, __DEV_STATE_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(dev_state_policy, __DEV_STATE_MAX, tb, msg);
 
        cur = tb[DEV_STATE_NAME];
        if (!cur)
@@ -370,8 +370,7 @@ netifd_handle_dev_hotplug(struct ubus_context *ctx, struct ubus_object *obj,
        struct blob_attr *tb[__DEV_HOTPLUG_ATTR_MAX];
        const char *name;
 
-       blobmsg_parse(dev_hotplug_policy, __DEV_HOTPLUG_ATTR_MAX, tb,
-                     blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(dev_hotplug_policy, __DEV_HOTPLUG_ATTR_MAX, tb, msg);
 
        if (!tb[DEV_HOTPLUG_ATTR_NAME] || !tb[DEV_HOTPLUG_ATTR_ADD])
                return UBUS_STATUS_INVALID_ARGUMENT;
@@ -1001,7 +1000,7 @@ netifd_iface_handle_device(struct ubus_context *ctx, struct ubus_object *obj,
 
        iface = container_of(obj, struct interface, ubus);
 
-       blobmsg_parse(dev_link_policy, __DEV_LINK_MAX, tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(dev_link_policy, __DEV_LINK_MAX, tb, msg);
 
        if (!tb[DEV_LINK_NAME])
                return UBUS_STATUS_INVALID_ARGUMENT;
@@ -1142,7 +1141,7 @@ netifd_handle_iface(struct ubus_context *ctx, struct ubus_object *obj,
        struct blob_attr *tb;
        size_t i;
 
-       blobmsg_parse(&iface_policy, 1, &tb, blob_data(msg), blob_len(msg));
+       blobmsg_parse_attr(&iface_policy, 1, &tb, msg);
        if (!tb)
                return UBUS_STATUS_INVALID_ARGUMENT;
 

diff --git a/veth.c b/veth.c
index 8d37dd365a72d5fc488ec05f88d1b0306170a37b..46b6eff646a70f4b306f5e0aa1246b5e50eb8b40 100644 (file)
--- a/veth.c
+++ b/veth.c
@@ -169,10 +169,8 @@ veth_reload(struct device *dev, struct blob_attr *attr)
        veth = container_of(dev, struct veth, dev);
        attr = blob_memdup(attr);
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-               blob_data(attr), blob_len(attr));
-       blobmsg_parse(veth_attrs, __VETH_ATTR_MAX, tb_mv,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
+       blobmsg_parse_attr(veth_attrs, __VETH_ATTR_MAX, tb_mv, attr);
 
        device_init_settings(dev, tb_dev);
        veth_apply_settings(veth, tb_mv);
@@ -181,14 +179,14 @@ veth_reload(struct device *dev, struct blob_attr *attr)
                struct blob_attr *otb_dev[__DEV_ATTR_MAX];
                struct blob_attr *otb_mv[__VETH_ATTR_MAX];
 
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
-                       blob_data(veth->config_data), blob_len(veth->config_data));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
+                                  veth->config_data);
 
                if (uci_blob_diff(tb_dev, otb_dev, &device_attr_list, NULL))
                    ret = DEV_CONFIG_RESTART;
 
-               blobmsg_parse(veth_attrs, __VETH_ATTR_MAX, otb_mv,
-                       blob_data(veth->config_data), blob_len(veth->config_data));
+               blobmsg_parse_attr(veth_attrs, __VETH_ATTR_MAX, otb_mv,
+                                  veth->config_data);
 
                if (uci_blob_diff(tb_mv, otb_mv, &veth_attr_list, NULL))
                    ret = DEV_CONFIG_RESTART;

diff --git a/vlandev.c b/vlandev.c
index 4d6e76a75e43230f646170eb0dd7b19b069412ec..d23e9610d88b88d5c3bf04fced0f4baa82a30f1b 100644 (file)
--- a/vlandev.c
+++ b/vlandev.c
@@ -346,10 +346,8 @@ vlandev_reload(struct device *dev, struct blob_attr *attr)
        mvdev = container_of(dev, struct vlandev_device, dev);
        attr = blob_memdup(attr);
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-               blob_data(attr), blob_len(attr));
-       blobmsg_parse(vlandev_attrs, __VLANDEV_ATTR_MAX, tb_mv,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
+       blobmsg_parse_attr(vlandev_attrs, __VLANDEV_ATTR_MAX, tb_mv, attr);
 
        device_init_settings(dev, tb_dev);
        vlandev_apply_settings(mvdev, tb_mv);
@@ -360,14 +358,14 @@ vlandev_reload(struct device *dev, struct blob_attr *attr)
                struct blob_attr *otb_dev[__DEV_ATTR_MAX];
                struct blob_attr *otb_mv[__VLANDEV_ATTR_MAX];
 
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
-                       blob_data(mvdev->config_data), blob_len(mvdev->config_data));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
+                                  mvdev->config_data);
 
                if (uci_blob_diff(tb_dev, otb_dev, &device_attr_list, NULL))
                    ret = DEV_CONFIG_RESTART;
 
-               blobmsg_parse(vlandev_attrs, __VLANDEV_ATTR_MAX, otb_mv,
-                       blob_data(mvdev->config_data), blob_len(mvdev->config_data));
+               blobmsg_parse_attr(vlandev_attrs, __VLANDEV_ATTR_MAX, otb_mv,
+                                  mvdev->config_data);
 
                if (uci_blob_diff(tb_mv, otb_mv, &vlandev_attr_list, NULL))
                    ret = DEV_CONFIG_RESTART;

diff --git a/vrf.c b/vrf.c
index d27d5c39d954e63244eeadbdb06c502600fb2e46..757ed6018287c5d67cc3206b9658c4f2ffee2bb6 100644 (file)
--- a/vrf.c
+++ b/vrf.c
@@ -580,10 +580,8 @@ vrf_reload(struct device *dev, struct blob_attr *attr)
        vst = container_of(dev, struct vrf_state, dev);
        attr = blob_memdup(attr);
 
-       blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
-               blob_data(attr), blob_len(attr));
-       blobmsg_parse(vrf_attrs, __VRF_ATTR_MAX, tb_v,
-               blob_data(attr), blob_len(attr));
+       blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, tb_dev, attr);
+       blobmsg_parse_attr(vrf_attrs, __VRF_ATTR_MAX, tb_v, attr);
 
        if (tb_dev[DEV_ATTR_MACADDR])
                vst->primary_port = NULL;
@@ -596,8 +594,8 @@ vrf_reload(struct device *dev, struct blob_attr *attr)
                struct blob_attr *otb_dev[__DEV_ATTR_MAX];
                struct blob_attr *otb_v[__VRF_ATTR_MAX];
 
-               blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
-                       blob_data(vst->config_data), blob_len(vst->config_data));
+               blobmsg_parse_attr(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
+                                  vst->config_data);
 
                diff[0] = diff[1] = 0;
                uci_blob_diff(tb_dev, otb_dev, &device_attr_list, diff);
@@ -607,8 +605,8 @@ vrf_reload(struct device *dev, struct blob_attr *attr)
                          dev->ifname, diff[1], diff[0]);
                }
 
-               blobmsg_parse(vrf_attrs, __VRF_ATTR_MAX, otb_v,
-                       blob_data(vst->config_data), blob_len(vst->config_data));
+               blobmsg_parse_attr(vrf_attrs, __VRF_ATTR_MAX, otb_v,
+                                  vst->config_data);
 
                diff[0] = diff[1] = 0;
                uci_blob_diff(tb_v, otb_v, &vrf_attr_list, diff);