From: Felix Fietkau <nbd@nbd.name>
Date: Tue, 12 Aug 2025 18:13:48 +0000 (+0200)
Subject: global: use blobmsg_parse_attr
X-Git-Url: http://git.openwrt.org/?a=commitdiff_plain;h=6ead304877adb2b2dfb8db735ee4e6e08ccc05ba;p=project%2Fnetifd.git

global: use blobmsg_parse_attr

Avoids mismatch in blob vs blobmsg parsing, simplifies code.

Signed-off-by: Felix Fietkau <nbd@nbd.name>
---

diff --git a/bonding.c b/bonding.c
index fef18f3..8303633 100644
--- 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 70ece78..3555dde 100644
--- 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 56943a3..eedfa7f 100644
--- 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 e07a817..174d115 100644
--- 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 e2e3a91..bc08f0a 100644
--- 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 7e60f64..4bc6d87 100644
--- 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 3c9556a..44052e3 100644
--- 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 c2009c8..1fedac6 100644
--- 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 cdc924f..a0bdeed 100644
--- 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 931a59e..c9e5e45 100644
--- 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 63f461d..c338ff2 100644
--- 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 7f6df9e..2303cba 100644
--- 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 6d192ac..a8386d7 100644
--- 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 7a48923..64bd874 100644
--- 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 8d37dd3..46b6eff 100644
--- 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 4d6e76a..d23e961 100644
--- 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 d27d5c3..757ed60 100644
--- 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);