mesh/config-client.c - nest-learning-thermostat/6.0/bluez - Git at Google

 /*
  *
  *  BlueZ - Bluetooth protocol stack for Linux
  *
  *  Copyright (C) 2017  Intel Corporation. All rights reserved.
  *
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */

 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif

 #include <stdio.h>
 #include <errno.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <inttypes.h>
 #include <stdbool.h>
 #include <sys/uio.h>
 #include <wordexp.h>
 #include <readline/readline.h>
 #include <readline/history.h>
 #include <glib.h>

 #include "src/shared/util.h"
 #include "client/display.h"
 #include "mesh/mesh-net.h"
 #include "mesh/keys.h"
 #include "mesh/net.h"
 #include "mesh/node.h"
 #include "mesh/prov-db.h"
 #include "mesh/util.h"
 #include "mesh/config-model.h"

 #define MIN_COMPOSITION_LEN 16

 static bool client_msg_recvd(uint16_t src, uint8_t *data,
 				uint16_t len, void *user_data)
 {
 	uint32_t opcode;
 	struct mesh_node *node;
 	uint16_t app_idx, net_idx, addr;
 	uint32_t mod_id;
 	uint16_t primary;
 	uint16_t ele_addr;
 	uint8_t ele_idx;
 	struct mesh_publication pub;
 	int n;

 	if (mesh_opcode_get(data, len, &opcode, &n)) {
 		len -= n;
 		data += n;
 	} else
 		return false;

 	if (IS_UNICAST(src)) {
 		node = node_find_by_addr(src);
 	} else
 		node = NULL;

 	if (!node)
 		return false;

 	primary = node_get_primary(node);
 	if (primary != src)
 		return false;

 	switch (opcode & ~OP_UNRELIABLE) {
 	default:
 		return false;

 	case OP_DEV_COMP_STATUS:
 		if (len < MIN_COMPOSITION_LEN || !node)
 			break;
 		if (node_parse_composition(node, data, len)) {
 			if (!prov_db_add_node_composition(node, data, len))
 				break;
 		}

 		if (node_get_composition(node))
 			prov_db_print_node_composition(node);
 		break;

 	case OP_APPKEY_STATUS:
 		if (len != 4)
 			break;

 		rl_printf("Node %4.4x AppKey Status %s\n", src,
 						mesh_status_str(data[0]));
 		net_idx = get_le16(data + 1) & 0xfff;
 		app_idx = get_le16(data + 2) >> 4;

 		rl_printf("\tNetKey %3.3x, AppKey %3.3x\n", net_idx, app_idx);

 		if (data[0] != MESH_STATUS_SUCCESS &&
 				data[0] != MESH_STATUS_IDX_ALREADY_STORED &&
 				node_app_key_delete(node, net_idx, app_idx))
 			prov_db_node_keys(node, node_get_app_keys(node),
 								"appKeys");
 		break;

 	case OP_NETKEY_STATUS:
 		if (len != 3)
 			break;

 		rl_printf("Node %4.4x NetKey Status %s\n", src,
 						mesh_status_str(data[0]));
 		net_idx = get_le16(data + 1) & 0xfff;

 		rl_printf("\tNetKey %3.3x\n", net_idx);

 		if (data[0] != MESH_STATUS_SUCCESS &&
 				data[0] != MESH_STATUS_IDX_ALREADY_STORED &&
 					node_net_key_delete(node, net_idx))
 			prov_db_node_keys(node, node_get_net_keys(node),
 								"netKeys");
 		break;

 	case OP_MODEL_APP_STATUS:
 		if (len != 7 && len != 9)
 			break;

 		rl_printf("Node %4.4x Model App Status %s\n", src,
 						mesh_status_str(data[0]));
 		addr = get_le16(data + 1);
 		app_idx = get_le16(data + 3);

 		rl_printf("\tElement %4.4x AppIdx %3.3x\n ", addr, app_idx);

 		if (len == 7) {
 			mod_id = get_le16(data + 5);
 			rl_printf("ModelId %4.4x\n", mod_id);
 			mod_id = 0xffff0000 | mod_id;
 		} else {
 			mod_id = get_le16(data + 7);
 			rl_printf("ModelId %4.4x %4.4x\n", get_le16(data + 5),
 									mod_id);
 			mod_id = get_le16(data + 5) << 16 | mod_id;
 		}

 		if (data[0] == MESH_STATUS_SUCCESS &&
 			node_add_binding(node, addr - src, mod_id, app_idx))
 			prov_db_add_binding(node, addr - src, mod_id, app_idx);
 		break;

 	case OP_CONFIG_DEFAULT_TTL_STATUS:
 		if (len != 1)
 			return true;
 		rl_printf("Node %4.4x Default TTL %d\n", src, data[0]);
 		if (node_set_default_ttl (node, data[0]))
 			prov_db_node_set_ttl(node, data[0]);
 		break;

 	case OP_CONFIG_MODEL_PUB_STATUS:
 		if (len != 12 && len != 14)
 			return true;

 		rl_printf("\nSet publication for node %4.4x status: %s\n", src,
 				data[0] == MESH_STATUS_SUCCESS ? "Success" :
 						mesh_status_str(data[0]));

 		if (data[0] != MESH_STATUS_SUCCESS)
 			return true;

 		ele_addr = get_le16(data + 1);
 		mod_id = get_le16(data + 10);
 		if (len == 14)
 			mod_id = (mod_id << 16)  | get_le16(data + 12);
 		else
 			mod_id |= 0xffff0000;

 		pub.u.addr16 = get_le16(data + 3);
 		pub.app_idx = get_le16(data + 5);
 		pub.ttl = data[7];
 		pub.period = data[8];
 		n = (data[8] & 0x3f);
 		switch (data[8] >> 6) {
 		case 0:
 			rl_printf("Period: %d ms\n", n * 100);
 			break;
 		case 2:
 			n *= 10;
 			/* fall through */
 		case 1:
 			rl_printf("Period: %d sec\n", n);
 			break;
 		case 3:
 			rl_printf("Period: %d min\n", n * 10);
 			break;
 		}

 		pub.retransmit = data[9];
 		rl_printf("Retransmit count: %d\n", data[9] >> 5);
 		rl_printf("Retransmit Interval Steps: %d\n", data[9] & 0x1f);

 		ele_idx = ele_addr - node_get_primary(node);

 		/* Local configuration is saved by server */
 		if (node == node_get_local_node())
 			break;

 		if (node_model_pub_set(node, ele_idx, mod_id, &pub))
 			prov_db_node_set_model_pub(node, ele_idx, mod_id,
 				     node_model_pub_get(node, ele_idx, mod_id));
 		break;
 	}
 	return true;
 }

 static uint32_t target;
 static uint32_t parms[8];

 static uint32_t read_input_parameters(const char *args)
 {
 	uint32_t i;

 	if (!args)
 		return 0;

 	memset(parms, 0xff, sizeof(parms));

 	for (i = 0; i < sizeof(parms)/sizeof(parms[0]); i++) {
 		int n;

 		sscanf(args, "%x", &parms[i]);
 		if (parms[i] == 0xffffffff)
 			break;

 		n = strcspn(args, " \t");
 		args = args + n + strspn(args + n, " \t");
 	}

 	return i;
 }

 static void cmd_set_node(const char *args)
 {
 	uint32_t dst;
 	char *end;

 	dst = strtol(args, &end, 16);
 	if (end != (args + 4)) {
 		rl_printf("Bad unicast address %s: "
 					"expected format 4 digit hex\n", args);
 		target = UNASSIGNED_ADDRESS;
 	} else {
 		rl_printf("Configuring node %4.4x\n", dst);
 		target = dst;
 		set_menu_prompt("config", args);
 	}

 }

 static bool config_send(uint8_t *buf, uint16_t len)
 {
 	struct mesh_node *node = node_get_local_node();
 	uint16_t primary;

 	if(!node)
 		return false;

 	primary = node_get_primary(node);
 	if (target != primary)
 		return net_access_layer_send(DEFAULT_TTL, primary,
 						target, APP_IDX_DEV, buf, len);

 	node_local_data_handler(primary, target, node_get_iv_index(node),
 				node_get_sequence_number(node), APP_IDX_DEV,
 				buf, len);
 	return true;

 }

 static void cmd_get_composition(const char *args)
 {
 	uint16_t n;
 	uint8_t msg[32];
 	struct mesh_node *node;

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	node = node_find_by_addr(target);

 	if (!node)
 		return;

 	n = mesh_opcode_set(OP_DEV_COMP_GET, msg);

 	/* By default, use page 0 */
 	msg[n++] = (read_input_parameters(args) == 1) ? parms[0] : 0;

 	if (!config_send(msg, n))
 		rl_printf("Failed to send \"GET NODE COMPOSITION\"\n");
 }

 static void cmd_net_key(const char *args, uint32_t opcode)
 {
 	uint16_t n;
 	uint8_t msg[32];
 	uint16_t net_idx;
 	uint8_t *key;
 	struct mesh_node *node;

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	n = mesh_opcode_set(opcode, msg);

 	if (read_input_parameters(args) != 1) {
 		rl_printf("Bad arguments %s\n", args);
 		return;
 	}

 	node = node_find_by_addr(target);
 	if (!node) {
 		rl_printf("Node %4.4x\n not found", target);
 		return;
 	}

 	net_idx = parms[0];

 	if (opcode != OP_NETKEY_DELETE) {

 		key = keys_net_key_get(net_idx, true);
 		if (!key) {
 			rl_printf("Network key with index %4.4x not found\n",
 								net_idx);
 			return;
 		}

 		put_le16(net_idx, &msg[n]);
 		n += 2;

 		memcpy(msg + n, key, 16);
 		n += 16;
 	}

 	if (!config_send(msg, n)) {
 		rl_printf("Failed to send \"%s NET KEY\"\n",
 				opcode == OP_NETKEY_ADD ? "ADD" : "DEL");
 		return;
 	}

 	if (opcode != OP_NETKEY_DELETE) {
 		if (node_net_key_add(node, net_idx))
 			prov_db_node_keys(node, node_get_net_keys(node),
 								"netKeys");
 	} else {
 		if (node_net_key_delete(node, net_idx))
 			prov_db_node_keys(node, node_get_net_keys(node),
 								"netKeys");
 	}

 }

 static void cmd_add_net_key(const char *args)
 {
 	cmd_net_key(args, OP_NETKEY_ADD);
 }

 static void cmd_del_net_key(const char *args)
 {
 	cmd_net_key(args, OP_NETKEY_DELETE);
 }

 static void cmd_app_key(const char *args, uint32_t opcode)
 {
 	uint16_t n;
 	uint8_t msg[32];
 	uint16_t net_idx;
 	uint16_t app_idx;
 	uint8_t *key;
 	struct mesh_node *node;

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	if (read_input_parameters(args) != 1) {
 		rl_printf("Bad arguments %s\n", args);
 		return;
 	}

 	node = node_find_by_addr(target);
 	if (!node) {
 		rl_printf("Node %4.4x\n not found", target);
 		return;
 	}

 	n = mesh_opcode_set(opcode, msg);

 	app_idx = parms[0];
 	net_idx = keys_app_key_get_bound(app_idx);
 	if (net_idx == NET_IDX_INVALID) {
 		rl_printf("App key with index %4.4x not found\n", app_idx);
 		return;
 	}

 	msg[n++] = net_idx & 0xf;
 	msg[n++] = ((net_idx >> 8) & 0xf) |
 		((app_idx << 4) & 0xf0);
 	msg[n++] = app_idx >> 4;

 	if (opcode != OP_APPKEY_DELETE) {
 		key = keys_app_key_get(app_idx, true);
 		if (!key) {
 			rl_printf("App key %4.4x not found\n", net_idx);
 			return;
 		}

 		memcpy(msg + n, key, 16);
 		n += 16;
 	}

 	if (!config_send(msg, n)) {
 		rl_printf("Failed to send \"ADD %s KEY\"\n",
 				opcode == OP_APPKEY_ADD ? "ADD" : "DEL");
 		return;
 	}

 	if (opcode != OP_APPKEY_DELETE) {
 		if (node_app_key_add(node, app_idx))
 			prov_db_node_keys(node, node_get_app_keys(node),
 								"appKeys");
 	} else {
 		if (node_app_key_delete(node, net_idx, app_idx))
 			prov_db_node_keys(node, node_get_app_keys(node),
 								"appKeys");
 	}
 }

 static void cmd_add_app_key(const char *args)
 {
 	cmd_app_key(args, OP_APPKEY_ADD);
 }

 static void cmd_del_app_key(const char *args)
 {
 	cmd_app_key(args, OP_APPKEY_DELETE);
 }

 static void cmd_bind(const char *args)
 {
 	uint16_t n;
 	uint8_t msg[32];
 	int parm_cnt;

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	parm_cnt = read_input_parameters(args);
 	if (parm_cnt != 3 && parm_cnt != 4) {
 		rl_printf("Bad arguments %s\n", args);
 		return;
 	}

 	n = mesh_opcode_set(OP_MODEL_APP_BIND, msg);

 	put_le16(target + parms[0], msg + n);
 	n += 2;
 	put_le16(parms[1], msg + n);
 	n += 2;
 	if (parm_cnt == 4) {
 		put_le16(parms[3], msg + n);
 		put_le16(parms[2], msg + n + 2);
 		n += 4;
 	} else {
 		put_le16(parms[2], msg + n);
 		n += 2;
 	}

 	if (!config_send(msg, n))
 		rl_printf("Failed to send \"MODEL APP BIND\"\n");
 }

 static void cmd_set_ttl(const char *args)
 {
 	uint16_t n;
 	uint8_t msg[32];
 	int parm_cnt;
 	uint8_t ttl;

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	n = mesh_opcode_set(OP_CONFIG_DEFAULT_TTL_SET, msg);

 	parm_cnt = read_input_parameters(args);
 	if (parm_cnt) {
 		ttl = parms[0] & TTL_MASK;
 	} else
 		ttl = node_get_default_ttl(node_get_local_node());

 	msg[n++] = ttl;

 	if (!config_send(msg, n))
 		rl_printf("Failed to send \"SET_DEFAULT TTL\"\n");
 }

 static void cmd_set_pub(const char *args)
 {
 	uint16_t n;
 	uint8_t msg[32];
 	int parm_cnt;

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	n = mesh_opcode_set(OP_CONFIG_MODEL_PUB_SET, msg);

 	parm_cnt = read_input_parameters(args);
 	if (parm_cnt != 5) {
 		rl_printf("Bad arguments: %s\n", args);
 		return;
 	}

 	put_le16(parms[0], msg + n);
 	n += 2;
 	/* Publish address */
 	put_le16(parms[1], msg + n);
 	n += 2;
 	/* App key index + credential (set to 0) */
 	put_le16(parms[2], msg + n);
 	n += 2;
 	/* TTL */
 	msg[n++] = DEFAULT_TTL;
 	/* Publish period  step count and step resolution */
 	msg[n++] = parms[3];
 	/* Publish retransmit count & interval steps */
 	msg[n++] = (1 << 5) + 2;
 	/* Model Id */
 	if (parms[4] > 0xffff) {
 		put_le16(parms[4] >> 16, msg + n);
 		put_le16(parms[4], msg + n + 2);
 		n += 4;
 	} else {
 		put_le16(parms[4], msg + n);
 		n += 2;
 	}

 	if (!config_send(msg, n))
 		rl_printf("Failed to send \"SET MODEL PUBLICATION\"\n");
 }

 static void cmd_default(uint32_t opcode)
 {
 	uint16_t n;
 	uint8_t msg[32];

 	if (IS_UNASSIGNED(target)) {
 		rl_printf("Destination not set\n");
 		return;
 	}

 	n = mesh_opcode_set(opcode, msg);

 	if (!config_send(msg, n))
 		rl_printf("Failed to send command (opcode 0x%x)\n", opcode);
 }

 static void cmd_get_ttl(const char *args)
 {
 	cmd_default(OP_CONFIG_DEFAULT_TTL_GET);
 }

 static void cmd_back(const char *args)
 {
 	cmd_menu_main(false);
 }

 static void cmd_help(const char *args);

 static const struct menu_entry cfg_menu[] = {
 	{"target",		"<unicast>",			cmd_set_node,
 						"Set target node to configure"},
 	{"get-composition",	"[<page_num>]",		cmd_get_composition,
 						"Get Composition Data"},
 	{"add-netkey",		"<net_idx>",			cmd_add_net_key,
 						"Add network key"},
 	{"del-netkey",		"<net_idx>",			cmd_del_net_key,
 						"Delete network key"},
 	{"add-appkey",		"<app_idx>",			cmd_add_app_key,
 						"Add application key"},
 	{"del-appkey",		"<app_idx>",			cmd_del_app_key,
 						"Delete application key"},
 	{"bind",		"<ele_idx> <app_idx> <mod_id> [cid]",
 				cmd_bind,	"Bind app key to a model"},
 	{"set-ttl",		"<ttl>",			cmd_set_ttl,
 						"Set default TTL"},
 	{"get-ttl",		NULL,			cmd_get_ttl,
 						"Get default TTL"},
 	{"set-pub", "<ele_addr> <pub_addr> <app_idx> "
 						"<period (step|res)> <model>",
 				cmd_set_pub,	"Set publication"},
 	{"back",		NULL,				cmd_back,
 						"Back to main menu"},
 	{"help",		NULL,				cmd_help,
 						"Config Commands"},
 	{}
 };

 static void cmd_help(const char *args)
 {
 	rl_printf("Client Configuration Menu\n");
 	print_cmd_menu(cfg_menu);
 }

 void config_set_node(const char *args)
 {
 	cmd_set_node(args);
 }

 void config_client_get_composition(uint32_t dst)
 {
 	uint32_t tmp = target;

 	target = dst;
 	cmd_get_composition("");
 	target = tmp;
 }

 static struct mesh_model_ops client_cbs = {
 	client_msg_recvd,
 		NULL,
 		NULL,
 		NULL
 };

 bool config_client_init(void)
 {
 	if (!node_local_model_register(PRIMARY_ELEMENT_IDX,
 						CONFIG_CLIENT_MODEL_ID,
 						&client_cbs, NULL))
 		return false;

 	add_cmd_menu("configure", cfg_menu);

 	return true;
 }
	/*
	*
	* BlueZ - Bluetooth protocol stack for Linux
	*
	* Copyright (C) 2017 Intel Corporation. All rights reserved.
	*
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*
	*/

	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif

	#include <stdio.h>
	#include <errno.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <stdbool.h>
	#include <inttypes.h>
	#include <stdbool.h>
	#include <sys/uio.h>
	#include <wordexp.h>
	#include <readline/readline.h>
	#include <readline/history.h>
	#include <glib.h>

	#include "src/shared/util.h"
	#include "client/display.h"
	#include "mesh/mesh-net.h"
	#include "mesh/keys.h"
	#include "mesh/net.h"
	#include "mesh/node.h"
	#include "mesh/prov-db.h"
	#include "mesh/util.h"
	#include "mesh/config-model.h"

	#define MIN_COMPOSITION_LEN 16

	static bool client_msg_recvd(uint16_t src, uint8_t *data,
	uint16_t len, void *user_data)
	{
	uint32_t opcode;
	struct mesh_node *node;
	uint16_t app_idx, net_idx, addr;
	uint32_t mod_id;
	uint16_t primary;
	uint16_t ele_addr;
	uint8_t ele_idx;
	struct mesh_publication pub;
	int n;

	if (mesh_opcode_get(data, len, &opcode, &n)) {
	len -= n;
	data += n;
	} else
	return false;

	if (IS_UNICAST(src)) {
	node = node_find_by_addr(src);
	} else
	node = NULL;

	if (!node)
	return false;

	primary = node_get_primary(node);
	if (primary != src)
	return false;

	switch (opcode & ~OP_UNRELIABLE) {
	default:
	return false;

	case OP_DEV_COMP_STATUS:
	if (len < MIN_COMPOSITION_LEN \|\| !node)
	break;
	if (node_parse_composition(node, data, len)) {
	if (!prov_db_add_node_composition(node, data, len))
	break;
	}

	if (node_get_composition(node))
	prov_db_print_node_composition(node);
	break;

	case OP_APPKEY_STATUS:
	if (len != 4)
	break;

	rl_printf("Node %4.4x AppKey Status %s\n", src,
	mesh_status_str(data[0]));
	net_idx = get_le16(data + 1) & 0xfff;
	app_idx = get_le16(data + 2) >> 4;

	rl_printf("\tNetKey %3.3x, AppKey %3.3x\n", net_idx, app_idx);

	if (data[0] != MESH_STATUS_SUCCESS &&
	data[0] != MESH_STATUS_IDX_ALREADY_STORED &&
	node_app_key_delete(node, net_idx, app_idx))
	prov_db_node_keys(node, node_get_app_keys(node),
	"appKeys");
	break;

	case OP_NETKEY_STATUS:
	if (len != 3)
	break;

	rl_printf("Node %4.4x NetKey Status %s\n", src,
	mesh_status_str(data[0]));
	net_idx = get_le16(data + 1) & 0xfff;

	rl_printf("\tNetKey %3.3x\n", net_idx);

	if (data[0] != MESH_STATUS_SUCCESS &&
	data[0] != MESH_STATUS_IDX_ALREADY_STORED &&
	node_net_key_delete(node, net_idx))
	prov_db_node_keys(node, node_get_net_keys(node),
	"netKeys");
	break;

	case OP_MODEL_APP_STATUS:
	if (len != 7 && len != 9)
	break;

	rl_printf("Node %4.4x Model App Status %s\n", src,
	mesh_status_str(data[0]));
	addr = get_le16(data + 1);
	app_idx = get_le16(data + 3);

	rl_printf("\tElement %4.4x AppIdx %3.3x\n ", addr, app_idx);

	if (len == 7) {
	mod_id = get_le16(data + 5);
	rl_printf("ModelId %4.4x\n", mod_id);
	mod_id = 0xffff0000 \| mod_id;
	} else {
	mod_id = get_le16(data + 7);
	rl_printf("ModelId %4.4x %4.4x\n", get_le16(data + 5),
	mod_id);
	mod_id = get_le16(data + 5) << 16 \| mod_id;
	}

	if (data[0] == MESH_STATUS_SUCCESS &&
	node_add_binding(node, addr - src, mod_id, app_idx))
	prov_db_add_binding(node, addr - src, mod_id, app_idx);
	break;

	case OP_CONFIG_DEFAULT_TTL_STATUS:
	if (len != 1)
	return true;
	rl_printf("Node %4.4x Default TTL %d\n", src, data[0]);
	if (node_set_default_ttl (node, data[0]))
	prov_db_node_set_ttl(node, data[0]);
	break;

	case OP_CONFIG_MODEL_PUB_STATUS:
	if (len != 12 && len != 14)
	return true;

	rl_printf("\nSet publication for node %4.4x status: %s\n", src,
	data[0] == MESH_STATUS_SUCCESS ? "Success" :
	mesh_status_str(data[0]));

	if (data[0] != MESH_STATUS_SUCCESS)
	return true;

	ele_addr = get_le16(data + 1);
	mod_id = get_le16(data + 10);
	if (len == 14)
	mod_id = (mod_id << 16) \| get_le16(data + 12);
	else
	mod_id \|= 0xffff0000;

	pub.u.addr16 = get_le16(data + 3);
	pub.app_idx = get_le16(data + 5);
	pub.ttl = data[7];
	pub.period = data[8];
	n = (data[8] & 0x3f);
	switch (data[8] >> 6) {
	case 0:
	rl_printf("Period: %d ms\n", n * 100);
	break;
	case 2:
	n *= 10;
	/* fall through */
	case 1:
	rl_printf("Period: %d sec\n", n);
	break;
	case 3:
	rl_printf("Period: %d min\n", n * 10);
	break;
	}

	pub.retransmit = data[9];
	rl_printf("Retransmit count: %d\n", data[9] >> 5);
	rl_printf("Retransmit Interval Steps: %d\n", data[9] & 0x1f);

	ele_idx = ele_addr - node_get_primary(node);

	/* Local configuration is saved by server */
	if (node == node_get_local_node())
	break;

	if (node_model_pub_set(node, ele_idx, mod_id, &pub))
	prov_db_node_set_model_pub(node, ele_idx, mod_id,
	node_model_pub_get(node, ele_idx, mod_id));
	break;
	}
	return true;
	}

	static uint32_t target;
	static uint32_t parms[8];

	static uint32_t read_input_parameters(const char *args)
	{
	uint32_t i;

	if (!args)
	return 0;

	memset(parms, 0xff, sizeof(parms));

	for (i = 0; i < sizeof(parms)/sizeof(parms[0]); i++) {
	int n;

	sscanf(args, "%x", &parms[i]);
	if (parms[i] == 0xffffffff)
	break;

	n = strcspn(args, " \t");
	args = args + n + strspn(args + n, " \t");
	}

	return i;
	}

	static void cmd_set_node(const char *args)
	{
	uint32_t dst;
	char *end;

	dst = strtol(args, &end, 16);
	if (end != (args + 4)) {
	rl_printf("Bad unicast address %s: "
	"expected format 4 digit hex\n", args);
	target = UNASSIGNED_ADDRESS;
	} else {
	rl_printf("Configuring node %4.4x\n", dst);
	target = dst;
	set_menu_prompt("config", args);
	}

	}

	static bool config_send(uint8_t *buf, uint16_t len)
	{
	struct mesh_node *node = node_get_local_node();
	uint16_t primary;

	if(!node)
	return false;

	primary = node_get_primary(node);
	if (target != primary)
	return net_access_layer_send(DEFAULT_TTL, primary,
	target, APP_IDX_DEV, buf, len);

	node_local_data_handler(primary, target, node_get_iv_index(node),
	node_get_sequence_number(node), APP_IDX_DEV,
	buf, len);
	return true;

	}

	static void cmd_get_composition(const char *args)
	{
	uint16_t n;
	uint8_t msg[32];
	struct mesh_node *node;

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	node = node_find_by_addr(target);

	if (!node)
	return;

	n = mesh_opcode_set(OP_DEV_COMP_GET, msg);

	/* By default, use page 0 */
	msg[n++] = (read_input_parameters(args) == 1) ? parms[0] : 0;

	if (!config_send(msg, n))
	rl_printf("Failed to send \"GET NODE COMPOSITION\"\n");
	}

	static void cmd_net_key(const char *args, uint32_t opcode)
	{
	uint16_t n;
	uint8_t msg[32];
	uint16_t net_idx;
	uint8_t *key;
	struct mesh_node *node;

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	n = mesh_opcode_set(opcode, msg);

	if (read_input_parameters(args) != 1) {
	rl_printf("Bad arguments %s\n", args);
	return;
	}

	node = node_find_by_addr(target);
	if (!node) {
	rl_printf("Node %4.4x\n not found", target);
	return;
	}

	net_idx = parms[0];

	if (opcode != OP_NETKEY_DELETE) {

	key = keys_net_key_get(net_idx, true);
	if (!key) {
	rl_printf("Network key with index %4.4x not found\n",
	net_idx);
	return;
	}

	put_le16(net_idx, &msg[n]);
	n += 2;

	memcpy(msg + n, key, 16);
	n += 16;
	}

	if (!config_send(msg, n)) {
	rl_printf("Failed to send \"%s NET KEY\"\n",
	opcode == OP_NETKEY_ADD ? "ADD" : "DEL");
	return;
	}

	if (opcode != OP_NETKEY_DELETE) {
	if (node_net_key_add(node, net_idx))
	prov_db_node_keys(node, node_get_net_keys(node),
	"netKeys");
	} else {
	if (node_net_key_delete(node, net_idx))
	prov_db_node_keys(node, node_get_net_keys(node),
	"netKeys");
	}

	}

	static void cmd_add_net_key(const char *args)
	{
	cmd_net_key(args, OP_NETKEY_ADD);
	}

	static void cmd_del_net_key(const char *args)
	{
	cmd_net_key(args, OP_NETKEY_DELETE);
	}

	static void cmd_app_key(const char *args, uint32_t opcode)
	{
	uint16_t n;
	uint8_t msg[32];
	uint16_t net_idx;
	uint16_t app_idx;
	uint8_t *key;
	struct mesh_node *node;

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	if (read_input_parameters(args) != 1) {
	rl_printf("Bad arguments %s\n", args);
	return;
	}

	node = node_find_by_addr(target);
	if (!node) {
	rl_printf("Node %4.4x\n not found", target);
	return;
	}

	n = mesh_opcode_set(opcode, msg);

	app_idx = parms[0];
	net_idx = keys_app_key_get_bound(app_idx);
	if (net_idx == NET_IDX_INVALID) {
	rl_printf("App key with index %4.4x not found\n", app_idx);
	return;
	}

	msg[n++] = net_idx & 0xf;
	msg[n++] = ((net_idx >> 8) & 0xf) \|
	((app_idx << 4) & 0xf0);
	msg[n++] = app_idx >> 4;

	if (opcode != OP_APPKEY_DELETE) {
	key = keys_app_key_get(app_idx, true);
	if (!key) {
	rl_printf("App key %4.4x not found\n", net_idx);
	return;
	}

	memcpy(msg + n, key, 16);
	n += 16;
	}

	if (!config_send(msg, n)) {
	rl_printf("Failed to send \"ADD %s KEY\"\n",
	opcode == OP_APPKEY_ADD ? "ADD" : "DEL");
	return;
	}

	if (opcode != OP_APPKEY_DELETE) {
	if (node_app_key_add(node, app_idx))
	prov_db_node_keys(node, node_get_app_keys(node),
	"appKeys");
	} else {
	if (node_app_key_delete(node, net_idx, app_idx))
	prov_db_node_keys(node, node_get_app_keys(node),
	"appKeys");
	}
	}

	static void cmd_add_app_key(const char *args)
	{
	cmd_app_key(args, OP_APPKEY_ADD);
	}

	static void cmd_del_app_key(const char *args)
	{
	cmd_app_key(args, OP_APPKEY_DELETE);
	}

	static void cmd_bind(const char *args)
	{
	uint16_t n;
	uint8_t msg[32];
	int parm_cnt;

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	parm_cnt = read_input_parameters(args);
	if (parm_cnt != 3 && parm_cnt != 4) {
	rl_printf("Bad arguments %s\n", args);
	return;
	}

	n = mesh_opcode_set(OP_MODEL_APP_BIND, msg);

	put_le16(target + parms[0], msg + n);
	n += 2;
	put_le16(parms[1], msg + n);
	n += 2;
	if (parm_cnt == 4) {
	put_le16(parms[3], msg + n);
	put_le16(parms[2], msg + n + 2);
	n += 4;
	} else {
	put_le16(parms[2], msg + n);
	n += 2;
	}

	if (!config_send(msg, n))
	rl_printf("Failed to send \"MODEL APP BIND\"\n");
	}

	static void cmd_set_ttl(const char *args)
	{
	uint16_t n;
	uint8_t msg[32];
	int parm_cnt;
	uint8_t ttl;

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	n = mesh_opcode_set(OP_CONFIG_DEFAULT_TTL_SET, msg);

	parm_cnt = read_input_parameters(args);
	if (parm_cnt) {
	ttl = parms[0] & TTL_MASK;
	} else
	ttl = node_get_default_ttl(node_get_local_node());

	msg[n++] = ttl;

	if (!config_send(msg, n))
	rl_printf("Failed to send \"SET_DEFAULT TTL\"\n");
	}

	static void cmd_set_pub(const char *args)
	{
	uint16_t n;
	uint8_t msg[32];
	int parm_cnt;

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	n = mesh_opcode_set(OP_CONFIG_MODEL_PUB_SET, msg);

	parm_cnt = read_input_parameters(args);
	if (parm_cnt != 5) {
	rl_printf("Bad arguments: %s\n", args);
	return;
	}

	put_le16(parms[0], msg + n);
	n += 2;
	/* Publish address */
	put_le16(parms[1], msg + n);
	n += 2;
	/* App key index + credential (set to 0) */
	put_le16(parms[2], msg + n);
	n += 2;
	/* TTL */
	msg[n++] = DEFAULT_TTL;
	/* Publish period step count and step resolution */
	msg[n++] = parms[3];
	/* Publish retransmit count & interval steps */
	msg[n++] = (1 << 5) + 2;
	/* Model Id */
	if (parms[4] > 0xffff) {
	put_le16(parms[4] >> 16, msg + n);
	put_le16(parms[4], msg + n + 2);
	n += 4;
	} else {
	put_le16(parms[4], msg + n);
	n += 2;
	}

	if (!config_send(msg, n))
	rl_printf("Failed to send \"SET MODEL PUBLICATION\"\n");
	}

	static void cmd_default(uint32_t opcode)
	{
	uint16_t n;
	uint8_t msg[32];

	if (IS_UNASSIGNED(target)) {
	rl_printf("Destination not set\n");
	return;
	}

	n = mesh_opcode_set(opcode, msg);

	if (!config_send(msg, n))
	rl_printf("Failed to send command (opcode 0x%x)\n", opcode);
	}

	static void cmd_get_ttl(const char *args)
	{
	cmd_default(OP_CONFIG_DEFAULT_TTL_GET);
	}

	static void cmd_back(const char *args)
	{
	cmd_menu_main(false);
	}

	static void cmd_help(const char *args);

	static const struct menu_entry cfg_menu[] = {
	{"target", "<unicast>", cmd_set_node,
	"Set target node to configure"},
	{"get-composition", "[<page_num>]", cmd_get_composition,
	"Get Composition Data"},
	{"add-netkey", "<net_idx>", cmd_add_net_key,
	"Add network key"},
	{"del-netkey", "<net_idx>", cmd_del_net_key,
	"Delete network key"},
	{"add-appkey", "<app_idx>", cmd_add_app_key,
	"Add application key"},
	{"del-appkey", "<app_idx>", cmd_del_app_key,
	"Delete application key"},
	{"bind", "<ele_idx> <app_idx> <mod_id> [cid]",
	cmd_bind, "Bind app key to a model"},
	{"set-ttl", "<ttl>", cmd_set_ttl,
	"Set default TTL"},
	{"get-ttl", NULL, cmd_get_ttl,
	"Get default TTL"},
	{"set-pub", "<ele_addr> <pub_addr> <app_idx> "
	"<period (step\|res)> <model>",
	cmd_set_pub, "Set publication"},
	{"back", NULL, cmd_back,
	"Back to main menu"},
	{"help", NULL, cmd_help,
	"Config Commands"},
	{}
	};

	static void cmd_help(const char *args)
	{
	rl_printf("Client Configuration Menu\n");
	print_cmd_menu(cfg_menu);
	}

	void config_set_node(const char *args)
	{
	cmd_set_node(args);
	}

	void config_client_get_composition(uint32_t dst)
	{
	uint32_t tmp = target;

	target = dst;
	cmd_get_composition("");
	target = tmp;
	}

	static struct mesh_model_ops client_cbs = {
	client_msg_recvd,
	NULL,
	NULL,
	NULL
	};

	bool config_client_init(void)
	{
	if (!node_local_model_register(PRIMARY_ELEMENT_IDX,
	CONFIG_CLIENT_MODEL_ID,
	&client_cbs, NULL))
	return false;

	add_cmd_menu("configure", cfg_menu);

	return true;
	}