Re: [PATCH v2] mesh: Added ImportLocalNode call with its API

["Gix, Brian" <brian.gix@intel.com>]

Hi Jakub,


On Tue, 2019-06-25 at 16:38 +0200, Jakub Witowski wrote:
> This implements ImportLocalNode() method on org.bluez.mesh.Network1
> interface. Invoking this method creates a self-provisioned node based on
> passed JSON definition. Also full functionality of import local node has
> been implemented
> ---
>  doc/mesh-api.txt |  22 ++++-
>  mesh/mesh.c      |  63 ++++++++++++--
>  mesh/node.c      | 212 +++++++++++++++++++++++++++++++++++++++++++----
>  mesh/node.h      |   2 +
>  4 files changed, 276 insertions(+), 23 deletions(-)
> 
> diff --git a/doc/mesh-api.txt b/doc/mesh-api.txt
> index 4e0a8bff1..539fc3e4f 100644
> --- a/doc/mesh-api.txt
> +++ b/doc/mesh-api.txt
> @@ -151,11 +151,21 @@ Methods:
>  			org.bluez.mesh.Error.InvalidArguments
>  			org.bluez.mesh.Error.AlreadyExists,
>  
> -	 uint64 token ImportLocalNode(string json_data)
> +	 uint64 token ImportLocalNode(object app_root, string json_data, array{byte}[16] uuid)
>  
>  		This method creates a local mesh node based on node
>  		configuration that has been generated outside bluetooth-meshd.
>  
> +		The app_root parameter is a D-Bus object root path of the
> +		application that implements org.bluez.mesh.Application1
> +		interface, and a org.bluez.mesh.Provisioner1 interface. The
> +		application represents a node where child mesh elements have
> +		their own objects that implement org.bluez.mesh.Element1
> +		interface. The application hierarchy also contains a provision
> +		agent object that implements org.bluez.mesh.ProvisionAgent1
> +		interface. The standard DBus.ObjectManager interface must be
> +		available on the app_root path.
> +
>  		The json_data parameter is a full JSON representation of a node
>  		configuration file. The format must conform to the schema
>  		defined in "Mesh Node Configuration Schema" section. Any
> @@ -1059,4 +1069,12 @@ Properties:
>  
>  Mesh Node Configuration Schema
>  ==============================
> -<TBD>
> +Example of Json format for ImportLocalNode():
> +{
> +  "IVindex":0,
> +  "IVupdate":0,
> +  "unicastAddress":"0012",
> +  "deviceKey":"7daa45cd1e9e11a4b86eeef7d01efa11",
> +  "netKey":"1234567890abcdef1234567890abcdef",
> +  "keyRefresh":0
> +}
> diff --git a/mesh/mesh.c b/mesh/mesh.c
> index 26acfd4dc..e0f0e4bf9 100644
> --- a/mesh/mesh.c
> +++ b/mesh/mesh.c
> @@ -22,6 +22,7 @@
>  #endif
>  
>  #define _GNU_SOURCE
> +#include <json-c/json.h>

We are trying to figure out a way to *isolate* JSON dependancies in the Mesh daemon, such that
if it needs to be ported to a platform that does not support the JSON library, it can be easily
pared out while minimizing impact to the rest of the system.

Inga and I have been having conversations about this.

* It should be possible to create a JSON-free daemon, if the internal JSON storage system is replaced with a
custom, more space-efficient node storage, or for any other reason.

* It should be possible to *remove* the ImportLocalNode() entirely if that functionality is not needed, and
with it the JSON dependancy.

* We may want to be able to support *other* formats for this DBUS facing interface (perhaps XML, perhaps
something vendor defined).


I don't think there is any question that the *location* for this method belongs exactly where you have it,
however I think we would like to see the JSON parsing moved to a file that already has the JSON dependancy.  We
may want to let the daemon auto-detect the format (returning an error if the format is not understood). 
However, then perhaps having a "Table of Parsers" that do not live within the mesh.c file...  but perhaps in a
format-parser.h file which can be easily customized to support other parsers.


>  #include <ell/ell.h>
>  
>  #include "mesh/mesh-io.h"
> @@ -60,7 +61,7 @@ struct bt_mesh {
>  	uint8_t max_filters;
>  };
>  
> -struct join_data{
> +struct join_data {
>  	struct l_dbus_message *msg;
>  	struct mesh_agent *agent;
>  	const char *sender;
> @@ -365,8 +366,8 @@ static void node_init_cb(struct mesh_node *node, struct mesh_agent *agent)
>  
>  	if (!acceptor_start(num_ele, join_pending->uuid, mesh.algorithms,
>  				mesh.prov_timeout, agent, prov_complete_cb,
> -				&mesh))
> -	{
> +				&mesh)) {
> +
>  		reply = dbus_error(join_pending->msg, MESH_ERROR_FAILED,
>  				"Failed to start provisioning acceptor");
>  		goto fail;
> @@ -536,7 +537,7 @@ static struct l_dbus_message *leave_call(struct l_dbus *dbus,
>  	return l_dbus_message_new_method_return(msg);
>  }
>  
> -static void create_network_ready_cb(void *user_data, int status,
> +static void create_node_ready_cb(void *user_data, int status,
>  							struct mesh_node *node)
>  {
>  	struct l_dbus_message *reply;
> @@ -593,12 +594,58 @@ static struct l_dbus_message *create_network_call(struct l_dbus *dbus,
>  
>  	l_queue_push_tail(pending_queue, pending_msg);
>  
> -	node_create(app_path, sender, uuid, create_network_ready_cb,
> +	node_create(app_path, sender, uuid, create_node_ready_cb,
>  								pending_msg);
>  
>  	return NULL;
>  }
>  
> +static struct l_dbus_message *import_local_node_call(struct l_dbus *dbus,
> +						struct l_dbus_message *msg,
> +						void *user_data)
> +{
> +	const char *app_path, *sender;
> +	struct l_dbus_message *pending_msg;
> +	struct l_dbus_message_iter iter_uuid;
> +	const char *json_data;
> +	uint8_t *uuid;
> +	uint32_t n;
> +	struct json_object *jnode;
> +
> +	l_debug("Import local node request");
> +
> +	if (!l_dbus_message_get_arguments(msg, "osay", &app_path,
> +							&json_data, &iter_uuid))
> +		return dbus_error(msg, MESH_ERROR_INVALID_ARGS, NULL);
> +
> +	if (!l_dbus_message_iter_get_fixed_array(&iter_uuid, &uuid, &n) ||
> +									n != 16)
> +		return dbus_error(msg, MESH_ERROR_INVALID_ARGS, "Bad dev UUID");
> +
> +	if (node_find_by_uuid(uuid))
> +		return dbus_error(msg, MESH_ERROR_ALREADY_EXISTS,
> +							"Node already exists");
> +
> +	jnode = json_tokener_parse(json_data);
> +
> +	sender = l_dbus_message_get_sender(msg);
> +	pending_msg = l_dbus_message_ref(msg);
> +
> +	if (!pending_queue)
> +		pending_queue = l_queue_new();
> +
> +	l_queue_push_tail(pending_queue, pending_msg);
> +
> +	if (!node_import(app_path, sender, jnode, uuid, create_node_ready_cb,
> +								pending_msg)) {
> +		l_dbus_message_unref(msg);
> +		return dbus_error(msg, MESH_ERROR_INVALID_ARGS,
> +							"Node import failed");
> +	}
> +
> +	return NULL;
> +}
> +
>  static void setup_network_interface(struct l_dbus_interface *iface)
>  {
>  	l_dbus_interface_method(iface, "Join", 0, join_network_call, "",
> @@ -612,8 +659,14 @@ static void setup_network_interface(struct l_dbus_interface *iface)
>  
>  	l_dbus_interface_method(iface, "Leave", 0, leave_call, "", "t",
>  								"token");
> +
>  	l_dbus_interface_method(iface, "CreateNetwork", 0, create_network_call,
>  					"t", "oay", "token", "app", "uuid");
> +
> +	l_dbus_interface_method(iface, "ImportLocalNode", 0,
> +					import_local_node_call,
> +					"t", "osay", "token",
> +					"app", "json_data", "uuid");
>  }
>  
>  bool mesh_dbus_init(struct l_dbus *dbus)
> diff --git a/mesh/node.c b/mesh/node.c
> index e99858623..991802a6f 100644
> --- a/mesh/node.c
> +++ b/mesh/node.c
> @@ -27,6 +27,7 @@
>  
>  #include <ell/ell.h>
>  #include <json-c/json.h>
> +#include <stdio.h>
>  
>  #include "mesh/mesh-defs.h"
>  #include "mesh/mesh.h"
> @@ -58,9 +59,12 @@
>  #define DEFAULT_CRPL 10
>  #define DEFAULT_SEQUENCE_NUMBER 0
>  
> -#define REQUEST_TYPE_JOIN 0
> -#define REQUEST_TYPE_ATTACH 1
> -#define REQUEST_TYPE_CREATE 2
> +enum request_type {
> +	REQUEST_TYPE_JOIN = 0,
> +	REQUEST_TYPE_ATTACH,
> +	REQUEST_TYPE_CREATE,
> +	REQUEST_TYPE_IMPORT,
> +};
>  
>  struct node_element {
>  	char *path;
> @@ -111,7 +115,18 @@ struct managed_obj_request {
>  	void *data;
>  	void *cb;
>  	void *user_data;
> -	uint8_t type;
> +	enum request_type type;
> +};
> +
> +struct node_import_request {
> +	uint8_t uuid[16];
> +	uint8_t dev_key[16];
> +	uint8_t net_key[16];
> +	bool kr;
> +	uint16_t unicast;
> +	uint32_t iv_idx;
> +	bool iv_update;
> +	void *user_data;
>  };
>  
>  static struct l_queue *nodes;
> @@ -851,7 +866,7 @@ element_done:
>  #define MIN_COMPOSITION_LEN 16
>  
>  bool node_parse_composition(struct mesh_node *node, uint8_t *data,
> -								uint16_t len)
> +			    uint16_t len)
>  {
>  	struct node_composition *comp;
>  	uint16_t features;
> @@ -946,7 +961,7 @@ bool node_parse_composition(struct mesh_node *node, uint8_t *data,
>  			vendor_id = l_get_le16(data);
>  			mod_id |= (vendor_id << 16);
>  			mod = mesh_model_vendor_new(ele->idx, vendor_id,
> -									mod_id);
> +						    mod_id);
>  			if (!mod) {
>  				element_free(ele);
>  				goto fail;
> @@ -977,7 +992,6 @@ fail:
>  
>  	return false;
>  }
> -
>  static void attach_io(void *a, void *b)
>  {
>  	struct mesh_node *node = a;
> @@ -1078,6 +1092,7 @@ static bool validate_model_property(struct node_element *ele,
>  		while (l_dbus_message_iter_next_entry(&ids, &vendor_id,
>  								&mod_id)) {
>  			struct mesh_model *mod;
> +
>  			mod = l_queue_find(ele->models, match_model_id,
>  				L_UINT_TO_PTR((vendor_id << 16) | mod_id));
>  			if (!mod)
> @@ -1366,17 +1381,92 @@ static bool get_app_properties(struct mesh_node *node, const char *path,
>  	return true;
>  }
>  
> -static bool add_local_node(struct mesh_node *node, uint16_t unicast, bool kr,
> -				bool ivu, uint32_t iv_idx, uint8_t dev_key[16],
> -				uint16_t net_key_idx, uint8_t net_key[16])
> +static bool parse_imported_iv_index(json_object *jobj, uint32_t *idx,
> +								bool *update)
>  {
> -	node->net = mesh_net_new(node);
> +	int tmp;
> +	json_object *jvalue;
>  
> -	if (!nodes)
> -		nodes = l_queue_new();
> +	if (!json_object_object_get_ex(jobj, "IVindex", &jvalue))
> +		return false;
>  
> -	l_queue_push_tail(nodes, node);
> +	tmp = json_object_get_int(jvalue);
> +	*idx = (uint32_t) tmp;
> +
> +	if (!json_object_object_get_ex(jobj, "IVupdate", &jvalue))
> +		return false;
> +
> +	tmp = json_object_get_int(jvalue);
> +	*update = (bool)tmp;
> +
> +	return true;
> +}
> +
> +static bool parse_imported_unicast_addr(json_object *jobj, uint16_t *unicast)
> +{
> +	json_object *jvalue;
> +	char *str;
> +
> +	if (!json_object_object_get_ex(jobj, "unicastAddress", &jvalue))
> +		return false;
> +
> +	str = (char *)json_object_get_string(jvalue);
> +
> +	if (sscanf(str, "%04hx", unicast) != 1)
> +		return false;
> +
> +	return true;
> +}
>  
> +static bool parse_imported_device_key(json_object *jobj, uint8_t key_buf[16])
> +{
> +	json_object *jvalue;
> +	char *str;
> +
> +	if (!key_buf)
> +		return false;
> +
> +	if (!json_object_object_get_ex(jobj, "deviceKey", &jvalue))
> +		return false;
> +
> +	str = (char *)json_object_get_string(jvalue);
> +
> +	if (!str2hex(str, strlen(str), key_buf, 16))
> +		return false;
> +
> +	return true;
> +}
> +
> +static bool parse_imported_net_key(json_object *jobj, uint8_t key_buf[16],
> +								bool *kr)
> +{
> +	json_object *jvalue;
> +	char *str;
> +
> +	if (!key_buf)
> +		return false;
> +
> +	if (!json_object_object_get_ex(jobj, "netKey", &jvalue))
> +		return false;
> +
> +	str = (char *)json_object_get_string(jvalue);
> +
> +	if (!str2hex(str, strlen(str), key_buf, 16))
> +		return false;
> +
> +	/* Get key refresh */
> +	if (!json_object_object_get_ex(jobj, "keyRefresh", &jvalue))
> +		return false;
> +
> +	*kr = (bool)json_object_get_boolean(jvalue);
> +	return true;
> +}
> +
> +
> +static bool add_local_node(struct mesh_node *node, uint16_t unicast, bool kr,
> +				bool ivu, uint32_t iv_idx, uint8_t dev_key[16],
> +				uint16_t net_key_idx, uint8_t net_key[16])
> +{
>  	if (!storage_set_iv_index(node->net, iv_idx, ivu))
>  		return false;
>  
> @@ -1444,14 +1534,13 @@ static void get_managed_objects_cb(struct l_dbus_message *msg, void *user_data)
>  	}
>  
>  	if (is_new) {
> -		node = l_new(struct mesh_node, 1);
> +		node = node_new(req->data);
>  		node->elements = l_queue_new();
>  	} else {
>  		node = req->data;
>  	}
>  
>  	num_ele = 0;
> -
>  	while (l_dbus_message_iter_next_entry(&objects, &path, &interfaces)) {
>  		struct l_dbus_message_iter properties;
>  		const char *interface;
> @@ -1547,6 +1636,44 @@ static void get_managed_objects_cb(struct l_dbus_message *msg, void *user_data)
>  
>  		cb(node, agent);
>  
> +	} else if (req->type == REQUEST_TYPE_IMPORT) {
> +
> +		node_ready_func_t cb = req->cb;
> +		struct node_import_request *import_data = req->user_data;
> +		struct keyring_net_key net_key;
> +
> +		if (!agent) {
> +			l_error("Interface %s not found",
> +						MESH_PROVISION_AGENT_INTERFACE);
> +			goto fail;
> +		}
> +
> +		node->num_ele = num_ele;
> +		set_defaults(node);
> +		memcpy(node->uuid, import_data->uuid, 16);
> +
> +		if (!create_node_config(node))
> +			goto fail;
> +
> +		if (!add_local_node(node, import_data->unicast, import_data->kr,
> +				import_data->iv_update, import_data->iv_idx,
> +				import_data->dev_key, PRIMARY_NET_IDX,
> +							import_data->net_key))
> +			goto fail;
> +
> +		memcpy(net_key.old_key, import_data->net_key, 16);
> +		net_key.net_idx = PRIMARY_NET_IDX;
> +		net_key.phase = KEY_REFRESH_PHASE_NONE;
> +
> +		if (!keyring_put_remote_dev_key(node, import_data->unicast,
> +						num_ele, import_data->dev_key))
> +			goto fail;
> +
> +		if (!keyring_put_net_key(node, PRIMARY_NET_IDX, &net_key))
> +			goto fail;
> +
> +		cb(import_data->user_data, MESH_ERROR_NONE, node);
> +
>  	} else {
>  		/* Callback for create node request */
>  		node_ready_func_t cb = req->cb;
> @@ -1672,6 +1799,59 @@ void node_join(const char *app_path, const char *sender, const uint8_t *uuid,
>  					req, l_free);
>  }
>  
> +
> +bool node_import(const char *app_path, const char *sender, void *json_data,
> +		const uint8_t *uuid, node_ready_func_t cb, void *user_data)
> +{
> +	struct managed_obj_request *req;
> +	struct node_import_request *node;
> +
> +	l_debug("");
> +	node = l_new(struct node_import_request, 1);
> +	req = l_new(struct managed_obj_request, 1);
> +
> +	if (!parse_imported_device_key(json_data, node->dev_key)) {
> +		l_error("Failed to parse imported device key");
> +		goto fail;
> +	}
> +
> +	if (!parse_imported_unicast_addr(json_data, &node->unicast)) {
> +		l_error("Failed to parse imported unicast address");
> +		goto fail;
> +	}
> +
> +	if (!parse_imported_iv_index(json_data, &node->iv_idx,
> +							&node->iv_update)) {
> +		l_error("Failed to parse imported iv idx");
> +		goto fail;
> +	}
> +
> +
> +	if (!parse_imported_net_key(json_data, node->net_key, &node->kr)) {
> +		l_error("Failed to parse imported network key");
> +		goto fail;
> +	}
> +
> +	node->user_data = user_data;
> +
> +	memcpy(node->uuid, uuid, 16);
> +	req->data = (void *) uuid;
> +	req->user_data = node;
> +	req->cb = cb;
> +	req->type = REQUEST_TYPE_IMPORT;
> +
> +	l_dbus_method_call(dbus_get_bus(), sender, app_path,
> +					L_DBUS_INTERFACE_OBJECT_MANAGER,
> +					"GetManagedObjects", NULL,
> +					get_managed_objects_cb,
> +					req, l_free);
> +	return true;
> +fail:
> +	json_object_put(json_data);
> +	l_free(node);
> +	return false;
> +}
> +
>  void node_create(const char *app_path, const char *sender, const uint8_t *uuid,
>  					node_ready_func_t cb, void *user_data)
>  {
> diff --git a/mesh/node.h b/mesh/node.h
> index 142527b30..9559f9178 100644
> --- a/mesh/node.h
> +++ b/mesh/node.h
> @@ -91,6 +91,8 @@ void node_build_attach_reply(struct mesh_node *node,
>  						struct l_dbus_message *reply);
>  void node_create(const char *app_path, const char *sender, const uint8_t *uuid,
>  					node_ready_func_t cb, void *user_data);
> +bool node_import(const char *app_path, const char *sender, void *jnode,
> +		const uint8_t *uuid, node_ready_func_t cb, void *user_data);
>  void node_id_set(struct mesh_node *node, uint16_t node_id);
>  uint16_t node_id_get(struct mesh_node *node);
>  bool node_dbus_init(struct l_dbus *bus);