// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 *
 *  BlueZ - Bluetooth protocol stack for Linux
 *
 *  Copyright (C) 2019  Intel Corporation. All rights reserved.
 *
 *
 */

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

#define _GNU_SOURCE
#include <assert.h>
#include <ctype.h>
#include <dbus/dbus.h>
#include <errno.h>
#include <libgen.h>
#include <stdio.h>
#include <time.h>

#include <sys/stat.h>

#include <ell/ell.h>

#include "src/shared/shell.h"
#include "src/shared/util.h"

#include "mesh/mesh.h"
#include "mesh/mesh-defs.h"

#include "tools/mesh/agent.h"
#include "tools/mesh/cfgcli.h"
#include "tools/mesh/keys.h"
#include "tools/mesh/mesh-db.h"
#include "tools/mesh/model.h"
#include "tools/mesh/remote.h"

#define PROMPT_ON	COLOR_BLUE "[mesh-cfgclient]" COLOR_OFF "# "
#define PROMPT_OFF	"Waiting to connect to bluetooth-meshd..."

#define CFG_SRV_MODEL	0x0000
#define CFG_CLI_MODEL	0x0001
#define RPR_SVR_MODEL	0x0004
#define RPR_CLI_MODEL	0x0005
#define PRV_BEACON_SVR	0x0008
#define PRV_BEACON_CLI	0x0009

#define UNPROV_SCAN_MAX_SECS	300

#define DEFAULT_START_ADDRESS	0x00aa
#define DEFAULT_MAX_ADDRESS	(VIRTUAL_ADDRESS_LOW - 1)
#define DEFAULT_NET_INDEX	0x0000
#define MAX_CRPL_SIZE		0x7fff

#define DEFAULT_CFG_FILE	"config_db.json"
#define DEFAULT_EXPORT_FILE	"export_db.json"

struct meshcfg_el {
	const char *path;
	uint8_t index;
	uint16_t mods[4];
};

struct meshcfg_app {
	const char *path;
	const char *agent_path;
	struct meshcfg_el ele;
	uint16_t cid;
	uint16_t pid;
	uint16_t vid;
	uint16_t crpl;
	uint8_t uuid[16];
};

struct meshcfg_node {
	const char *path;
	struct l_dbus_proxy *proxy;
	struct l_dbus_proxy *mgmt_proxy;
	union {
		uint64_t u64;
		uint8_t u8[8];
	} token;
};

struct unprov_device {
	time_t last_seen;
	int id;
	uint32_t uri_hash;
	uint8_t uuid[16];
	int16_t rssi;
	uint16_t server;
	uint16_t oob_info;
};

struct generic_request {
	uint32_t arg1;
	uint32_t arg2;
	uint32_t arg3;
	uint8_t *data1;
	uint8_t *data2;
	const char *str;
};

struct scan_data {
	uint16_t dst;
	uint16_t secs;
};

static void *finalized = L_UINT_TO_PTR(-1);

static struct l_dbus *dbus;

static struct l_timeout *scan_timeout;
static struct l_queue *node_proxies;
static struct l_dbus_proxy *net_proxy;
static struct meshcfg_node *local;
static struct model_info *cfgcli;

static struct l_queue *devices;

static bool prov_in_progress;
static const char * const caps[] = {"static-oob",
				"push",
				"twist",
				"blink",
				"beep",
				"vibrate",
				"public-oob",
				"out-alpha",
				"in-alpha",
				"out-numeric",
				"in-numeric"};

static bool have_config;

static struct meshcfg_app app = {
	.path = "/mesh/cfgclient",
	.agent_path = "/mesh/cfgclient/agent",
	.cid = 0x05f1,
	.pid = 0x0002,
	.vid = 0x0001,
	.crpl = MAX_CRPL_SIZE,
	.ele = {
		.path = "/mesh/cfgclient/ele0",
		.index = 0,
		.mods = {CFG_SRV_MODEL, CFG_CLI_MODEL,
					PRV_BEACON_SVR, PRV_BEACON_CLI}
	}
};

static const struct option options[] = {
	{ "config",		required_argument, 0, 'c' },
	{ "address-start",	required_argument, 0, 'a' },
	{ "address-range",	required_argument, 0, 'r' },
	{ "net-index",		required_argument, 0, 'n' },
	{ 0, 0, 0, 0 }
};

static const char *address_opt;
static const char *range_opt;
static const char *net_idx_opt;
static const char *config_opt;

static uint32_t iv_index;
static uint16_t low_addr;
static uint16_t high_addr;
static uint16_t prov_net_idx;
static const char *cfg_fname;

static const char **optargs[] = {
	&config_opt,
	&address_opt,
	&range_opt,
	&net_idx_opt,
};

static const char *help[] = {
	"Configuration file",
	"Starting unicast address for remote nodes",
	"Net index for provisioning subnet"
};

static const struct bt_shell_opt opt = {
	.options = options,
	.optno = sizeof(options) / sizeof(struct option),
	.optstr = "c:a:n:",
	.optarg = optargs,
	.help = help,
};

static const char *dbus_err_args = "org.freedesktop.DBus.Error.InvalidArgs";
static const char *dbus_err_fail = "org.freedesktop.DBus.Error.Failed";
static const char *dbus_err_support = "org.freedesktop.DBus.Error.NotSupported";

static bool parse_argument_on_off(int argc, char *argv[], bool *value)
{
	if (!strcmp(argv[1], "on") || !strcmp(argv[1], "yes")) {
		*value = TRUE;
		return TRUE;
	}

	if (!strcmp(argv[1], "off") || !strcmp(argv[1], "no")) {
		*value = FALSE;
		return TRUE;
	}

	bt_shell_printf("Invalid argument %s\n", argv[1]);
	return FALSE;
}

static bool match_device_uuid(const void *a, const void *b)
{
	const struct unprov_device *dev = a;

	if (a == finalized)
		return false;

	return memcmp(dev->uuid, b, 16) == 0;
}

static bool match_by_id(const void *a, const void *b)
{
	const struct unprov_device *dev = a;
	int id = L_PTR_TO_UINT(b);

	if (a == finalized)
		return false;

	l_info("test %d %d", dev->id, id);
	return dev->id == id;
}

static bool match_by_srv_uuid(const void *a, const void *b)
{
	const struct unprov_device *dev = a;
	const struct unprov_device *new_dev = b;

	if (a == finalized)
		return false;

	return (dev->server == new_dev->server) &&
				(memcmp(dev->uuid, new_dev->uuid, 16) == 0);
}

static void print_device(void *a, void *b)
{
	struct unprov_device *dev = a;
	int *cnt = b;
	struct tm *tm;
	char buf[80];
	char *str;

	if (a == finalized)
		return;

	tm = localtime(&dev->last_seen);
	assert(strftime(buf, sizeof(buf), "%c", tm));
	(*cnt)++;

	dev->id = *cnt;
	str = l_util_hexstring_upper(dev->uuid, sizeof(dev->uuid));
	bt_shell_printf(COLOR_YELLOW "#%d" COLOR_OFF
			" UUID: %s, RSSI %d, Server: %4.4x\n Seen: %s\n",
			*cnt, str, dev->rssi, dev->server, buf);

	l_free(str);
}

struct send_data {
	const char *ele_path;
	bool rmt;
	bool is_dev_key;
	uint16_t dst;
	uint16_t idx;
	uint8_t *data;
	uint16_t len;
};

struct key_data {
	const char *ele_path;
	uint16_t dst;
	uint16_t idx;
	uint16_t net_idx;
	bool update;
};

static void append_dict_entry_basic(struct l_dbus_message_builder *builder,
					const char *key, const char *signature,
					const void *data)
{
	if (!builder)
		return;

	l_dbus_message_builder_enter_dict(builder, "sv");
	l_dbus_message_builder_append_basic(builder, 's', key);
	l_dbus_message_builder_enter_variant(builder, signature);
	l_dbus_message_builder_append_basic(builder, signature[0], data);
	l_dbus_message_builder_leave_variant(builder);
	l_dbus_message_builder_leave_dict(builder);
}

static void append_byte_array(struct l_dbus_message_builder *builder,
					unsigned char *data, unsigned int len)
{
	unsigned int i;

	l_dbus_message_builder_enter_array(builder, "y");

	for (i = 0; i < len; i++)
		l_dbus_message_builder_append_basic(builder, 'y', &(data[i]));

	l_dbus_message_builder_leave_array(builder);
}

static void send_msg_setup(struct l_dbus_message *msg, void *user_data)
{
	struct send_data *req = user_data;
	struct l_dbus_message_builder *builder;

	builder = l_dbus_message_builder_new(msg);

	l_dbus_message_builder_append_basic(builder, 'o', req->ele_path);
	l_dbus_message_builder_append_basic(builder, 'q', &req->dst);
	if (req->is_dev_key)
		l_dbus_message_builder_append_basic(builder, 'b', &req->rmt);

	l_dbus_message_builder_append_basic(builder, 'q', &req->idx);

	/* Options */
	l_dbus_message_builder_enter_array(builder, "{sv}");
	l_dbus_message_builder_enter_dict(builder, "sv");
	l_dbus_message_builder_leave_dict(builder);
	l_dbus_message_builder_leave_array(builder);

	/* Data */
	append_byte_array(builder, req->data, req->len);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static bool send_msg(void *user_data, uint16_t dst, uint16_t idx,
						uint8_t *data, uint16_t len)
{
	struct send_data *req;
	uint16_t net_idx_tx = idx;
	bool is_dev_key;
	const char *method_name;

	is_dev_key = (idx == APP_IDX_DEV_REMOTE || idx == APP_IDX_DEV_LOCAL);
	method_name = is_dev_key ? "DevKeySend" : "Send";

	if (is_dev_key) {
		net_idx_tx = remote_get_subnet_idx(dst);
		if (net_idx_tx == NET_IDX_INVALID)
			return false;
	}

	req = l_new(struct send_data, 1);
	req->ele_path = user_data;
	req->dst = dst;
	req->idx = net_idx_tx;
	req->data = data;
	req->len = len;
	req->rmt = (idx == APP_IDX_DEV_REMOTE);
	req->is_dev_key = is_dev_key;

	return l_dbus_proxy_method_call(local->proxy, method_name,
					send_msg_setup, NULL, req, l_free) != 0;
}

static void send_key_setup(struct l_dbus_message *msg, void *user_data)
{
	struct key_data *req = user_data;
	struct l_dbus_message_builder *builder;

	builder = l_dbus_message_builder_new(msg);

	l_dbus_message_builder_append_basic(builder, 'o', req->ele_path);
	l_dbus_message_builder_append_basic(builder, 'q', &req->dst);
	l_dbus_message_builder_append_basic(builder, 'q', &req->idx);
	l_dbus_message_builder_append_basic(builder, 'q', &req->net_idx);
	l_dbus_message_builder_append_basic(builder, 'b', &req->update);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static bool send_key(void *user_data, uint16_t dst, uint16_t key_idx,
						bool is_appkey, bool update)
{
	struct key_data *req;
	uint16_t net_idx;
	const char *method_name = (!is_appkey) ? "AddNetKey" : "AddAppKey";

	net_idx = remote_get_subnet_idx(dst);
	if (net_idx == NET_IDX_INVALID) {
		bt_shell_printf("Node %4.4x not found\n", dst);
		return false;
	}

	if (!is_appkey && !keys_subnet_exists(key_idx)) {
		bt_shell_printf("Local NetKey %u (0x%3.3x) not found\n",
							key_idx, key_idx);
		return false;
	}

	if (is_appkey && (keys_get_bound_key(key_idx) == NET_IDX_INVALID)) {
		bt_shell_printf("Local AppKey %u (0x%3.3x) not found\n",
							key_idx, key_idx);
		return false;
	}

	req = l_new(struct key_data, 1);
	req->ele_path = user_data;
	req->dst = dst;
	req->idx = key_idx;
	req->net_idx = net_idx;
	req->update = update;

	return l_dbus_proxy_method_call(local->proxy, method_name,
				send_key_setup, NULL, req, l_free) != 0;
}

static void delete_node_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t primary;
	uint8_t ele_cnt;

	primary = (uint16_t) req->arg1;
	ele_cnt = (uint8_t) req->arg2;

	l_dbus_message_set_arguments(msg, "qy", primary, ele_cnt);
}

static void delete_node(uint16_t primary, uint8_t ele_cnt)
{
	struct generic_request *req;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	req = l_new(struct generic_request, 1);
	req->arg1 = primary;
	req->arg2 = ele_cnt;

	l_dbus_proxy_method_call(local->mgmt_proxy, "DeleteRemoteNode",
				delete_node_setup, NULL, req, l_free);
}

static void client_init(void)
{
	cfgcli = cfgcli_init(send_key, delete_node, (void *) app.ele.path);
	cfgcli->ops.set_send_func(send_msg, (void *) app.ele.path);
}

static bool caps_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	uint32_t i;

	if (!l_dbus_message_builder_enter_array(builder, "s"))
		return false;
	for (i = 0; i < L_ARRAY_SIZE(caps); i++)
		l_dbus_message_builder_append_basic(builder, 's', caps[i]);

	l_dbus_message_builder_leave_array(builder);

	return true;
}

static void agent_input_done(oob_type_t type, void *buf, uint16_t len,
								void *user_data)
{
	struct l_dbus_message *msg = user_data;
	struct l_dbus_message *reply = NULL;
	struct l_dbus_message_builder *builder;
	uint32_t val_u32;
	uint8_t oob_data[64];

	switch (type) {
	case NONE:
	case OUTPUT:
	default:
		break;

	case ASCII:
		if (len > 8) {
			bt_shell_printf("Bad input length\n");
			break;
		}
		/* Fall Through */

	case HEXADECIMAL:
		if (len > sizeof(oob_data)) {
			bt_shell_printf("Bad input length\n");
			break;
		}
		memset(oob_data, 0, sizeof(oob_data));
		memcpy(oob_data, buf, len);
		reply = l_dbus_message_new_method_return(msg);
		builder = l_dbus_message_builder_new(reply);
		append_byte_array(builder, oob_data, len);
		l_dbus_message_builder_finalize(builder);
		l_dbus_message_builder_destroy(builder);
		break;

	case DECIMAL:
		if (len > 8) {
			bt_shell_printf("Bad input length\n");
			break;
		}

		val_u32 = l_get_be32(buf);
		reply = l_dbus_message_new_method_return(msg);
		l_dbus_message_set_arguments(reply, "u", val_u32);
		break;
	}

	if (!reply)
		reply = l_dbus_message_new_error(msg, dbus_err_fail, NULL);

	l_dbus_send(dbus, reply);
}

struct requested_action {
	const char *action;
	const char *description;
};

static struct requested_action display_numeric_table[] = {
	{ "push", "Push remote button %d times"},
	{ "twist", "Twist remote nob %d times"},
	{ "in-numeric", "Enter %d on remote device"},
	{ "out-numeric", "Enter %d on remote device"}
};

static struct requested_action prompt_numeric_table[] = {
	{ "blink", "Enter the number of times remote LED blinked"},
	{ "beep", "Enter the number of times remote device beeped"},
	{ "vibrate", "Enter the number of times remote device vibrated"},
	{ "in-numeric", "Enter the number displayed on remote device"},
	{ "out-numeric", "Enter the number displayed on remote device"}
};

static int get_action(char *str, bool prompt)
{
	struct requested_action *action_table;
	size_t len;
	int i, sz;

	if (!str)
		return -1;

	if (prompt) {
		len = strlen(str);
		sz = L_ARRAY_SIZE(prompt_numeric_table);
		action_table = prompt_numeric_table;
	} else {
		len = strlen(str);
		sz = L_ARRAY_SIZE(display_numeric_table);
		action_table = display_numeric_table;
	}

	for (i = 0; i < sz; ++i)
		if (len == strlen(action_table[i].action) &&
			!strcmp(str, action_table[i].action))
			return i;

	return -1;
}

static struct l_dbus_message *disp_numeric_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	char *str;
	uint32_t n;
	int action_index;

	if (!l_dbus_message_get_arguments(msg, "su", &str, &n)) {
		l_error("Cannot parse \"DisplayNumeric\" arguments");
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);
	}

	action_index = get_action(str, false);
	if (action_index < 0)
		return l_dbus_message_new_error(msg, dbus_err_support, NULL);

	str = l_strdup_printf(display_numeric_table[action_index].description,
									n);
	bt_shell_printf(COLOR_YELLOW "%s\n" COLOR_OFF, str);
	l_free(str);

	return l_dbus_message_new_method_return(msg);
}

static struct l_dbus_message *disp_string_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	const char *prompt = "Enter AlphaNumeric code on remote device:";
	char *str;

	if (!l_dbus_message_get_arguments(msg, "s", &str)) {
		l_error("Cannot parse \"DisplayString\" arguments");
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);
	}

	bt_shell_printf(COLOR_YELLOW "%s %s\n" COLOR_OFF, prompt, str);

	return l_dbus_message_new_method_return(msg);
}

static struct l_dbus_message *prompt_numeric_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	char *str;
	int action_index;
	const char *desc;

	if (!l_dbus_message_get_arguments(msg, "s", &str)) {
		l_error("Cannot parse \"PromptNumeric\" arguments");
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);
	}

	action_index = get_action(str, true);
	if (action_index < 0)
		return l_dbus_message_new_error(msg, dbus_err_support, NULL);

	desc = prompt_numeric_table[action_index].description;

	l_dbus_message_ref(msg);
	agent_input_request(DECIMAL, 8, desc, agent_input_done, msg);

	return NULL;
}

static struct l_dbus_message *prompt_public_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	l_dbus_message_ref(msg);
	agent_input_request(HEXADECIMAL, 64, "Enter 512 bit Public Key",
			agent_input_done, msg);
	return NULL;
}

static struct l_dbus_message *prompt_static_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	char *str;

	if (!l_dbus_message_get_arguments(msg, "s", &str) || !str) {
		l_error("Cannot parse \"PromptStatic\" arguments");
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);
	}

	if (!strcmp(str, "in-alpha") || !strcmp(str, "out-alpha")) {
		l_dbus_message_ref(msg);
		agent_input_request(ASCII, 8, "Enter displayed Ascii code",
							agent_input_done, msg);
	} else if (!strcmp(str, "static-oob")) {
		l_dbus_message_ref(msg);
		agent_input_request(HEXADECIMAL, 16, "Enter Static Key",
							agent_input_done, msg);
	} else
		return l_dbus_message_new_error(msg, dbus_err_support, NULL);

	return NULL;
}

static void setup_agent_iface(struct l_dbus_interface *iface)
{
	l_dbus_interface_property(iface, "Capabilities", 0, "as", caps_getter,
								NULL);
	/* TODO: Other properties */
	l_dbus_interface_method(iface, "DisplayString", 0, disp_string_call,
							"", "s", "value");
	l_dbus_interface_method(iface, "DisplayNumeric", 0, disp_numeric_call,
						"", "su", "type", "number");
	l_dbus_interface_method(iface, "PromptNumeric", 0, prompt_numeric_call,
						"u", "s", "number", "type");
	l_dbus_interface_method(iface, "PromptStatic", 0, prompt_static_call,
						"ay", "s", "data", "type");
	l_dbus_interface_method(iface, "PublicKey", 0, prompt_public_call,
							"ay", "", "data");
}

static bool register_agent(void)
{
	if (!l_dbus_register_interface(dbus, MESH_PROVISION_AGENT_INTERFACE,
					setup_agent_iface, NULL, false)) {
		l_error("Unable to register agent interface");
		return false;
	}

	if (!l_dbus_register_object(dbus, app.agent_path, NULL, NULL,
				MESH_PROVISION_AGENT_INTERFACE, NULL, NULL)) {
		l_error("Failed to register object %s", app.agent_path);
		return false;
	}

	if (!l_dbus_object_add_interface(dbus, app.agent_path,
					 L_DBUS_INTERFACE_PROPERTIES, NULL)) {
		l_error("Failed to add interface %s",
					L_DBUS_INTERFACE_PROPERTIES);
		return false;
	}

	return true;
}

static void try_set_node_proxy(void *a, void *b)
{
	struct l_dbus_proxy *proxy = a;
	const char *interface = l_dbus_proxy_get_interface(proxy);
	const char *path = l_dbus_proxy_get_path(proxy);

	if (strcmp(local->path, path))
		return;

	if (!strcmp(interface, MESH_MANAGEMENT_INTERFACE))
		local->mgmt_proxy = proxy;
	else if (!strcmp(interface, MESH_NODE_INTERFACE))
		local->proxy = proxy;
}

static void attach_node_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	struct meshcfg_node *node = user_data;
	struct l_dbus_message_iter iter_cfg;
	uint32_t ivi;

	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to attach node: %s", name);
		goto fail;

	}

	if (!l_dbus_message_get_arguments(msg, "oa(ya(qa{sv}))",
						&local->path, &iter_cfg))
		goto fail;

	bt_shell_printf("Attached with path %s\n", local->path);

	/* Populate node's proxies */
	l_queue_foreach(node_proxies, try_set_node_proxy, node);

	/* Remove from orphaned proxies list */
	if (local->proxy)
		l_queue_remove(node_proxies, local->proxy);

	if (local->mgmt_proxy)
		l_queue_remove(node_proxies, local->mgmt_proxy);

	/* Inititalize config client model */
	client_init();

	if (l_dbus_proxy_get_property(local->proxy, "IvIndex", "u", &ivi) &&
							ivi != iv_index) {
		iv_index = ivi;
		mesh_db_set_iv_index(ivi);
		remote_clear_rejected_addresses(ivi);
	}

	/* Read own node composition */
	if (!cfgcli_get_comp(0x0001, 128))
		l_error("Failed to read own composition");

	return;

fail:
	l_free(node);
	node = NULL;
}

static void attach_node_setup(struct l_dbus_message *msg, void *user_data)
{
	l_dbus_message_set_arguments(msg, "ot", app.path,
						l_get_be64(local->token.u8));
}

static void create_net_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to create network: %s", name);
		return;
	}
}

static void create_net_setup(struct l_dbus_message *msg, void *user_data)
{
	struct l_dbus_message_builder *builder;

	/* Generate random UUID */
	l_uuid_v4(app.uuid);

	builder = l_dbus_message_builder_new(msg);

	l_dbus_message_builder_append_basic(builder, 'o', app.path);
	append_byte_array(builder, app.uuid, 16);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static void cmd_create_network(int argc, char *argv[])
{
	if (have_config) {
		l_error("Mesh network configuration exists (%s)", cfg_fname);
		return;
	}

	l_dbus_proxy_method_call(net_proxy, "CreateNetwork", create_net_setup,
						create_net_reply, NULL,
						NULL);

}

static void scan_reply(struct l_dbus_proxy *proxy, struct l_dbus_message *msg,
								void *user_data)
{
	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to start unprovisioned scan: %s", name);
		return;
	}

	bt_shell_printf("Unprovisioned scan started\n");
}

static void scan_setup(struct l_dbus_message *msg, void *user_data)
{
	struct scan_data *data = user_data;
	struct l_dbus_message_builder *builder;

	builder = l_dbus_message_builder_new(msg);
	l_dbus_message_builder_enter_array(builder, "{sv}");
	append_dict_entry_basic(builder, "Seconds", "q", &data->secs);
	append_dict_entry_basic(builder, "Server", "q", &data->dst);
	l_dbus_message_builder_leave_array(builder);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);

	/* Destination info not needed after call */
	l_free(data);
}

static void scan_start(void *user_data, uint16_t dst, uint32_t model)
{
	struct scan_data *data;

	if (model != (0xffff0000 | RPR_SVR_MODEL))
		return;

	data = l_malloc(sizeof(struct scan_data));
	data->secs = L_PTR_TO_UINT(user_data);
	data->dst = dst;

	if (!l_dbus_proxy_method_call(local->mgmt_proxy, "UnprovisionedScan",
					scan_setup, scan_reply, data, NULL))
		l_free(data);
}

static void scan_to(struct l_timeout *timeout, void *user_data)
{
	int cnt = 0;

	if (l_queue_peek_head(devices) != finalized)
		l_queue_push_head(devices, finalized);

	l_timeout_remove(timeout);
	scan_timeout = NULL;
	bt_shell_printf(COLOR_YELLOW "Unprovisioned devices:\n" COLOR_OFF);
	l_queue_foreach(devices, print_device, &cnt);
}

static void free_devices(void *a)
{
	if (a == finalized)
		return;

	l_free(a);
}

static void cmd_scan_unprov(int argc, char *argv[])
{
	uint32_t secs = 0;
	bool enable;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (parse_argument_on_off(argc, argv, &enable) == FALSE) {
		bt_shell_printf("Failed to parse input\n");
		return bt_shell_noninteractive_quit(EXIT_FAILURE);
	}

	if (argc == 3) {
		sscanf(argv[2], "%u", &secs);

		if (secs > UNPROV_SCAN_MAX_SECS)
			secs = UNPROV_SCAN_MAX_SECS;
	} else
		secs = 60;

	l_timeout_remove(scan_timeout);
	scan_timeout = NULL;

	if (enable) {
		l_queue_clear(devices, free_devices);
		remote_foreach_model(scan_start, L_UINT_TO_PTR(secs));
		scan_timeout = l_timeout_create(secs, scan_to, NULL, NULL);
	} else {
		/* Mark devices queue as finalized */
		l_queue_push_head(devices, finalized);
		l_dbus_proxy_method_call(local->mgmt_proxy,
						"UnprovisionedScanCancel",
						NULL, NULL, NULL, NULL);
	}
}

static uint8_t *parse_key(struct l_dbus_message_iter *iter, uint16_t id,
							const char *name)
{
	uint8_t *val;
	uint32_t len;

	if (!l_dbus_message_iter_get_fixed_array(iter, &val, &len)
								|| len != 16) {
		bt_shell_printf("Failed to parse %s %4.4x\n", name, id);
		return NULL;
	}

	return val;
}

static bool parse_app_keys(struct l_dbus_message_iter *iter, uint16_t net_idx,
								void *user_data)
{
	struct l_dbus_message_iter app_keys, app_key, opts;
	uint16_t app_idx;

	if (!l_dbus_message_iter_get_variant(iter, "a(qaya{sv})", &app_keys))
		return false;

	while (l_dbus_message_iter_next_entry(&app_keys, &app_idx, &app_key,
								&opts)) {
		struct l_dbus_message_iter var;
		uint8_t *val, *old_val = NULL;
		const char *key;

		val = parse_key(&app_key, app_idx, "AppKey");
		if (!val)
			return false;

		while (l_dbus_message_iter_next_entry(&opts, &key, &var)) {
			if (!strcmp(key, "OldKey")) {
				if (!l_dbus_message_iter_get_variant(&var, "ay",
								&app_key))
					return false;

				old_val = parse_key(&app_key, app_idx,
								"old NetKey");

				if (!old_val)
					return false;
			}
		}

		mesh_db_set_app_key(user_data, net_idx, app_idx, val, old_val);
	}

	return true;
}

static bool parse_net_keys(struct l_dbus_message_iter *iter, void *user_data)
{
	struct l_dbus_message_iter net_keys, net_key, opts;
	uint16_t idx;

	if (!l_dbus_message_iter_get_variant(iter, "a(qaya{sv})", &net_keys))
		return false;

	while (l_dbus_message_iter_next_entry(&net_keys, &idx, &net_key,
								&opts)) {
		struct l_dbus_message_iter var;
		uint8_t *val, *old_val = NULL;
		uint8_t phase = KEY_REFRESH_PHASE_NONE;
		const char *key;

		val = parse_key(&net_key, idx, "NetKey");
		if (!val)
			return false;

		while (l_dbus_message_iter_next_entry(&opts, &key, &var)) {
			if (!strcmp(key, "AppKeys")) {
				if (!parse_app_keys(&var, idx, user_data))
					return false;
			} else if (!strcmp(key, "Phase")) {
				if (!l_dbus_message_iter_get_variant(&var, "y",
									&phase))
					return false;
			} else if (!strcmp(key, "OldKey")) {
				if (!l_dbus_message_iter_get_variant(&var, "ay",
								&net_key))
					return false;

				old_val = parse_key(&net_key, idx,
								"old NetKey");

				if (!old_val)
					return false;
			}
		}

		mesh_db_set_net_key(user_data, idx, val, old_val, phase);
	}

	return true;
}

static bool parse_dev_keys(struct l_dbus_message_iter *iter, void *user_data)
{
	struct l_dbus_message_iter keys, dev_key;
	uint16_t unicast;

	if (!l_dbus_message_iter_get_variant(iter, "a(qay)", &keys))
		return false;

	while (l_dbus_message_iter_next_entry(&keys, &unicast, &dev_key)) {
		uint8_t *data;

		data = parse_key(&dev_key, unicast, "Device Key");
		if (!data)
			return false;

		mesh_db_set_device_key(user_data, unicast, data);
	}

	return true;
}

static void export_keys_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	struct l_dbus_message_iter iter, var;
	char *cfg_dir = NULL, *fname = NULL;
	const char *key;
	bool is_error = true;

	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		bt_shell_printf("Failed to export keys: %s", name);
		goto done;

	}

	if (!l_dbus_message_get_arguments(msg, "a{sv}", &iter)) {
		bt_shell_printf("Malformed ExportKeys reply");
		goto done;
	}

	while (l_dbus_message_iter_next_entry(&iter, &key, &var)) {
		if (!strcmp(key, "NetKeys")) {
			if (!parse_net_keys(&var, user_data))
				goto done;
		} else if (!strcmp(key, "DevKeys")) {
			if (!parse_dev_keys(&var, user_data))
				goto done;
		}
	}

	is_error = false;

	cfg_dir = l_strdup(cfg_fname);
	cfg_dir = dirname(cfg_dir);

	fname = l_strdup_printf("%s/%s", cfg_dir, DEFAULT_EXPORT_FILE);

done:
	if (mesh_db_finish_export(is_error, user_data, fname)) {
		if (!is_error)
			bt_shell_printf("Config DB is exported to %s\n", fname);
	}

	l_free(cfg_dir);
	l_free(fname);
}

static void cmd_export_db(int argc, char *argv[])
{
	void *cfg_export;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	/* Generate a properly formatted DB from the local config */
	cfg_export = mesh_db_prepare_export();
	if (!cfg_export) {
		bt_shell_printf("Failed to prepare config db\n");
		return;
	}

	/* Export the keys from the daemon */
	l_dbus_proxy_method_call(local->mgmt_proxy, "ExportKeys", NULL,
					export_keys_reply, cfg_export, NULL);
}

static void cmd_list_unprov(int argc, char *argv[])
{
	int cnt = 0;

	bt_shell_printf(COLOR_YELLOW "Unprovisioned devices:\n" COLOR_OFF);
	l_queue_foreach(devices, print_device, &cnt);
}

static void cmd_list_nodes(int argc, char *argv[])
{
	remote_print_all();
}

static void cmd_keys(int argc, char *argv[])
{
	keys_print_keys();
}

static void free_generic_request(void *data)
{
	struct generic_request *req = data;

	l_free(req->data1);
	l_free(req->data2);
	l_free(req);
}

static void import_node_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t primary, net_idx;
	uint8_t ele_cnt;

	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to import remote node: %s", name);
		return;
	}

	net_idx = (uint16_t) req->arg1;
	primary = (uint16_t) req->arg2;
	ele_cnt = (uint8_t) req->arg3;

	remote_add_node(req->data1, primary, ele_cnt, net_idx);
}

static void import_node_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t primary;
	uint8_t ele_cnt;
	struct l_dbus_message_builder *builder;

	primary = (uint16_t) req->arg2;
	ele_cnt = (uint8_t) req->arg3;

	builder = l_dbus_message_builder_new(msg);
	l_dbus_message_builder_append_basic(builder, 'q', &primary);
	l_dbus_message_builder_append_basic(builder, 'y', &ele_cnt);
	append_byte_array(builder, req->data2, 16);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static void cmd_import_node(int argc, char *argv[])
{
	struct generic_request *req;
	size_t sz;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (argc < 6) {
		bt_shell_printf("UUID, element count and device key");
		bt_shell_printf("Unicast, element count and device key");
		bt_shell_printf("are required\n");
		return;
	}

	req = l_new(struct generic_request, 1);

	/* Device UUID */
	req->data1 = l_util_from_hexstring(argv[1], &sz);
	if (!req->data1 || sz != 16 || !l_uuid_is_valid(req->data1)) {
		l_error("Failed to generate UUID array from %s", argv[1]);
		goto fail;
	}

	/* NetKey Index*/
	if (sscanf(argv[2], "%04x", &req->arg1) != 1)
		goto fail;

	/* Unicast of the primary element */
	if (sscanf(argv[3], "%04x", &req->arg2) != 1)
		goto fail;

	/* Number of elements */
	if (sscanf(argv[4], "%u", &req->arg3) != 1)
		goto fail;

	/* DevKey */
	req->data2 = l_util_from_hexstring(argv[5], &sz);
	if (!req->data2 || sz != 16) {
		l_error("Failed to generate DevKey array from %s", argv[5]);
		goto fail;
	}

	l_dbus_proxy_method_call(local->mgmt_proxy, "ImportRemoteNode",
					import_node_setup, import_node_reply,
					req, free_generic_request);

	return;

fail:
	free_generic_request(req);
}

static void subnet_set_phase_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t net_idx;
	uint8_t phase;

	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to set subnet phase: %s", name);
		return;
	}

	net_idx = (uint16_t) req->arg1;
	phase = (uint8_t) req->arg2;

	if (phase == KEY_REFRESH_PHASE_THREE)
		phase = KEY_REFRESH_PHASE_NONE;

	keys_set_net_key_phase(net_idx, phase, true);
}

static void subnet_set_phase_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t net_idx;
	uint8_t phase;

	net_idx = (uint16_t) req->arg1;
	phase = (uint8_t) req->arg2;

	l_dbus_message_set_arguments(msg, "qy", net_idx, phase);
}

static void cmd_subnet_set_phase(int argc, char *argv[])
{
	struct generic_request *req;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (argc < 3) {
		bt_shell_printf("NetKey index and phase are required\n");
		return;
	}

	req = l_new(struct generic_request, 1);

	if (sscanf(argv[1], "%04x", &req->arg1) != 1)
		goto fail;

	if (sscanf(argv[2], "%d", &req->arg2) != 1)
		goto fail;

	l_dbus_proxy_method_call(local->mgmt_proxy, "SetKeyPhase",
					subnet_set_phase_setup,
					subnet_set_phase_reply, req, l_free);

	return;

fail:
	l_free(req);
}

static void mgr_key_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t idx = (uint16_t) req->arg1;
	const char *method = req->str;

	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Method %s returned error: %s", method, name);
		bt_shell_printf("Method %s returned error: %s\n", method, name);
		return;
	}

	if (!strcmp("CreateSubnet", method)) {
		keys_add_net_key(idx);
		mesh_db_add_net_key(idx);
	} else if (!strcmp("DeleteSubnet", method)) {
		keys_del_net_key(idx);
		mesh_db_del_net_key(idx);
	} else if (!strcmp("UpdateSubnet", method)) {
		keys_set_net_key_phase(idx, KEY_REFRESH_PHASE_ONE, true);
	} else if (!strcmp("DeleteAppKey", method)) {
		keys_del_app_key(idx);
		mesh_db_del_app_key(idx);
	}
}

static void mgr_key_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t idx = (uint16_t) req->arg1;

	l_dbus_message_set_arguments(msg, "q", idx);
}

static void mgr_key_cmd(int argc, char *argv[], const char *method_name)
{
	struct generic_request *req;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (argc < 2) {
		bt_shell_printf("Missing required arguments\n");
		return;
	}

	req = l_new(struct generic_request, 1);

	if (sscanf(argv[1], "%04x", &req->arg1) != 1) {
		l_free(req);
		return;
	}

	req->str = method_name;

	l_dbus_proxy_method_call(local->mgmt_proxy, method_name,
					mgr_key_setup, mgr_key_reply,
					req, l_free);
}

static void cmd_delete_appkey(int argc, char *argv[])
{
	mgr_key_cmd(argc, argv, "DeleteAppKey");
}

static void cmd_update_appkey(int argc, char *argv[])
{
	mgr_key_cmd(argc, argv, "UpdateAppKey");
}

static void cmd_delete_subnet(int argc, char *argv[])
{
	mgr_key_cmd(argc, argv, "DeleteSubnet");
}

static void cmd_update_subnet(int argc, char *argv[])
{
	mgr_key_cmd(argc, argv, "UpdateSubnet");
}

static void cmd_create_subnet(int argc, char *argv[])
{
	mgr_key_cmd(argc, argv, "CreateSubnet");
}

static void add_key_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t net_idx, app_idx;
	const char *method = req->str;

	if (l_dbus_message_is_error(msg)) {
		const char *name;

		l_dbus_message_get_error(msg, &name, NULL);
		l_error("%s failed: %s", method, name);
		return;
	}

	net_idx = (uint16_t) req->arg1;

	if (!strcmp(method, "ImportSubnet")) {
		keys_add_net_key(net_idx);
		mesh_db_add_net_key(net_idx);
		return;
	}

	app_idx = (uint16_t) req->arg2;
	keys_add_app_key(net_idx, app_idx);
	mesh_db_add_app_key(net_idx, app_idx);
}

static void import_appkey_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t net_idx, app_idx;
	struct l_dbus_message_builder *builder;

	net_idx = (uint16_t) req->arg1;
	app_idx = (uint16_t) req->arg2;

	builder = l_dbus_message_builder_new(msg);
	l_dbus_message_builder_append_basic(builder, 'q', &net_idx);
	l_dbus_message_builder_append_basic(builder, 'q', &app_idx);
	append_byte_array(builder, req->data1, 16);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static void cmd_import_appkey(int argc, char *argv[])
{
	struct generic_request *req;
	size_t sz;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (argc < 4) {
		bt_shell_printf("Netkey and AppKey indices and");
		bt_shell_printf("key value are required\n");
		return;
	}

	req = l_new(struct generic_request, 1);

	if (sscanf(argv[1], "%04x", &req->arg1) != 1)
		goto fail;

	if (sscanf(argv[2], "%04x", &req->arg2) != 1)
		goto fail;

	req->data1 = l_util_from_hexstring(argv[3], &sz);
	if (!req->data1 || sz != 16) {
		l_error("Failed to generate key array from %s", argv[3]);
		goto fail;
	}

	req->str = "ImportAppKey";

	l_dbus_proxy_method_call(local->mgmt_proxy, "ImportAppKey",
					import_appkey_setup, add_key_reply,
					req, free_generic_request);

	return;

fail:
	free_generic_request(req);
}

static void import_subnet_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t net_idx;
	struct l_dbus_message_builder *builder;

	net_idx = (uint16_t) req->arg1;

	builder = l_dbus_message_builder_new(msg);
	l_dbus_message_builder_append_basic(builder, 'q', &net_idx);
	append_byte_array(builder, req->data1, 16);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static void cmd_import_subnet(int argc, char *argv[])
{
	struct generic_request *req;
	size_t sz;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (argc < 3) {
		bt_shell_printf("NetKey index and value are required\n");
		return;
	}

	req = l_new(struct generic_request, 1);

	if (sscanf(argv[1], "%04x", &req->arg1) != 1)
		goto fail;

	req->data1 = l_util_from_hexstring(argv[2], &sz);
	if (!req->data1 || sz != 16) {
		l_error("Failed to generate key array from %s", argv[2]);
		goto fail;
	}

	req->str = "ImportSubnet";

	l_dbus_proxy_method_call(local->mgmt_proxy, "ImportSubnet",
					import_subnet_setup, add_key_reply,
					req, free_generic_request);
	return;

fail:
	free_generic_request(req);
}

static void create_appkey_setup(struct l_dbus_message *msg, void *user_data)
{
	struct generic_request *req = user_data;
	uint16_t net_idx, app_idx;

	net_idx = (uint16_t) req->arg1;
	app_idx = (uint16_t) req->arg2;

	l_dbus_message_set_arguments(msg, "qq", net_idx, app_idx);
}

static void cmd_create_appkey(int argc, char *argv[])
{
	struct generic_request *req;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (argc < 3) {
		bt_shell_printf("AppKey index is required\n");
		return;
	}

	req = l_new(struct generic_request, 1);

	if (sscanf(argv[1], "%04x", &req->arg1) != 1)
		goto fail;

	if (sscanf(argv[2], "%04x", &req->arg2) != 1)
		goto fail;

	req->str = "CreateAppKey";

	l_dbus_proxy_method_call(local->mgmt_proxy, "CreateAppKey",
					create_appkey_setup, add_key_reply,
					req, l_free);
	return;

fail:
	l_free(req);
}

static void add_node_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	if (l_dbus_message_is_error(msg)) {
		const char *name;

		prov_in_progress = false;
		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to start provisioning: %s", name);
		return;
	}

	bt_shell_printf("Provisioning started\n");
}

static void reprov_reply(struct l_dbus_proxy *proxy,
				struct l_dbus_message *msg, void *user_data)
{
	if (l_dbus_message_is_error(msg)) {
		const char *name;

		prov_in_progress = false;
		l_dbus_message_get_error(msg, &name, NULL);
		l_error("Failed to start provisioning: %s", name);
		return;
	}

	bt_shell_printf("Reprovisioning started\n");
}

static void reprovision_setup(struct l_dbus_message *msg, void *user_data)
{
	uint16_t target = L_PTR_TO_UINT(user_data);
	uint8_t nppi = L_PTR_TO_UINT(user_data) >> 16;
	struct l_dbus_message_builder *builder;

	builder = l_dbus_message_builder_new(msg);
	l_dbus_message_builder_append_basic(builder, 'q', &target);
	l_dbus_message_builder_enter_array(builder, "{sv}");
	/* TODO: populate with options when defined */
	append_dict_entry_basic(builder, "NPPI", "y", &nppi);
	l_dbus_message_builder_leave_array(builder);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static void add_node_setup(struct l_dbus_message *msg, void *user_data)
{
	struct unprov_device *dev = user_data;
	struct l_dbus_message_builder *builder;

	builder = l_dbus_message_builder_new(msg);
	append_byte_array(builder, dev->uuid, 16);
	l_dbus_message_builder_enter_array(builder, "{sv}");
	/* TODO: populate with options when defined */
	l_dbus_message_builder_leave_array(builder);
	l_dbus_message_builder_finalize(builder);
	l_dbus_message_builder_destroy(builder);
}

static void cmd_start_prov(int argc, char *argv[])
{
	struct unprov_device *dev = NULL;
	int id;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (prov_in_progress) {
		bt_shell_printf("Provisioning is already in progress\n");
		return;
	}

	if (!argv[1]) {
		bt_shell_printf(COLOR_RED "Requires UUID\n" COLOR_RED);
		return;
	}

	if (*(argv[1]) == '#') {
		if (sscanf(argv[1] + 1, "%d", &id) == 1)
			dev = l_queue_find(devices, match_by_id,
							L_UINT_TO_PTR(id));

		if (!dev) {
			bt_shell_printf(COLOR_RED "unknown id\n" COLOR_RED);
			return;
		}
	} else if (strlen(argv[1]) == 32) {
		size_t sz;
		uint8_t *uuid = l_util_from_hexstring(argv[1], &sz);

		if (sz != 16) {
			bt_shell_printf(COLOR_RED "Invalid UUID\n" COLOR_RED);
			return;
		}

		dev = l_queue_find(devices, match_device_uuid, uuid);

		if (!dev) {
			dev = l_new(struct unprov_device, 1);
			memcpy(dev->uuid, uuid, 16);
			l_queue_push_tail(devices, dev);
		}

		l_free(uuid);

	} else {
		bt_shell_printf(COLOR_RED "Requires UUID\n" COLOR_RED);
		return;
	}

	if (l_dbus_proxy_method_call(local->mgmt_proxy, "AddNode",
						add_node_setup, add_node_reply,
						dev, NULL))
		prov_in_progress = true;
}

static void cmd_start_reprov(int argc, char *argv[])
{
	uint16_t target = 0;
	uint8_t nppi = 0;

	if (!local || !local->proxy || !local->mgmt_proxy) {
		bt_shell_printf("Node is not attached\n");
		return;
	}

	if (prov_in_progress) {
		bt_shell_printf("Provisioning is already in progress\n");
		return;
	}

	if (!argv[1]) {
		bt_shell_printf(COLOR_RED "Requires Unicast\n" COLOR_RED);
		return;
	}

	if (argv[2]) {
		char *end;

		nppi = strtol(argv[2], &end, 16);
	}

	if (strlen(argv[1]) == 4) {
		char *end;

		target = strtol(argv[1], &end, 16);

		if (end != (argv[1] + 4)) {
			bt_shell_printf(COLOR_RED "Invalid Unicast\n"
								COLOR_RED);
			return;
		}

	} else {
		bt_shell_printf(COLOR_RED "Requires Unicast\n" COLOR_RED);
		return;
	}

	if (l_dbus_proxy_method_call(local->mgmt_proxy, "Reprovision",
					reprovision_setup, reprov_reply,
					L_UINT_TO_PTR(target + (nppi << 16)),
					NULL))
		prov_in_progress = true;
}

static const struct bt_shell_menu main_menu = {
	.name = "main",
	.entries = {
	{ "create", "[unicast_range_low]", cmd_create_network,
			"Create new mesh network with one initial node" },
	{ "discover-unprovisioned", "<on/off> [seconds]", cmd_scan_unprov,
			"Look for devices to provision" },
	{ "appkey-create", "<net_idx> <app_idx>", cmd_create_appkey,
			"Create a new local AppKey" },
	{ "appkey-import", "<net_idx> <app_idx> <key>", cmd_import_appkey,
			"Import a new local AppKey" },
	{ "appkey-update", "<app_idx>", cmd_update_appkey,
			"Update local AppKey" },
	{ "appkey-delete", "<app_idx>", cmd_delete_appkey,
			"Delete local AppKey" },
	{ "subnet-create", "<net_idx>", cmd_create_subnet,
			"Create a new local subnet (NetKey)" },
	{ "subnet-import", "<net_idx> <key>", cmd_import_subnet,
			"Import a new local subnet (NetKey)" },
	{ "subnet-update", "<net_idx>", cmd_update_subnet,
			"Update local subnet (NetKey)" },
	{ "subnet-delete", "<net_idx>", cmd_delete_subnet,
			"Delete local subnet (NetKey)" },
	{ "subnet-set-phase", "<net_idx> <phase>", cmd_subnet_set_phase,
			"Set subnet (NetKey) phase" },
	{ "list-unprovisioned", NULL, cmd_list_unprov,
			"List unprovisioned devices" },
	{ "provision", "<uuid>", cmd_start_prov,
			"Initiate provisioning"},
	{ "reprovision", "<unicast> [0|1|2]", cmd_start_reprov,
			"Refresh Device Key"},
	{ "node-import", "<uuid> <net_idx> <primary> <ele_count> <dev_key>",
			cmd_import_node,
			"Import an externally provisioned remote node"},
	{ "list-nodes", NULL, cmd_list_nodes,
			"List remote mesh nodes"},
	{ "keys", NULL, cmd_keys,
			"List available keys"},
	{ "export-db", NULL, cmd_export_db,
			"Export mesh configuration database"},
	{ } },
};

static void proxy_added(struct l_dbus_proxy *proxy, void *user_data)
{
	const char *interface = l_dbus_proxy_get_interface(proxy);
	const char *path = l_dbus_proxy_get_path(proxy);

	bt_shell_printf("Proxy added: %s (%s)\n", interface, path);

	if (!strcmp(interface, MESH_NETWORK_INTERFACE)) {
		net_proxy = proxy;

		/*
		 * If mesh network configuration has been read from
		 * storage, attach the provisioner/config-client node.
		 */
		if (local)
			l_dbus_proxy_method_call(net_proxy, "Attach",
						attach_node_setup,
						attach_node_reply, NULL,
						NULL);
		return;
	}

	if (!strcmp(interface, MESH_MANAGEMENT_INTERFACE)) {

		if (local && local->path) {
			if (!strcmp(local->path, path))
				local->mgmt_proxy = proxy;
		} else
			l_queue_push_tail(node_proxies, proxy);
		return;
	}

	if (!strcmp(interface, MESH_NODE_INTERFACE)) {

		if (local && local->path) {
			if (!strcmp(local->path, path))
				local->proxy = proxy;
		} else
			l_queue_push_tail(node_proxies, proxy);
	}
}

static void proxy_removed(struct l_dbus_proxy *proxy, void *user_data)
{
	const char *interface = l_dbus_proxy_get_interface(proxy);
	const char *path = l_dbus_proxy_get_path(proxy);

	bt_shell_printf("Proxy removed: %s (%s)\n", interface, path);

	if (!strcmp(interface, MESH_NETWORK_INTERFACE)) {
		bt_shell_printf("Mesh removed, terminating.\n");
		l_main_quit();
		return;
	}

	if (!strcmp(interface, MESH_NODE_INTERFACE)) {
		if (local && local->path && !strcmp(local->path, path))
			local->proxy = NULL;

		l_queue_remove(node_proxies, proxy);
		return;
	}

	if (!strcmp(interface, MESH_MANAGEMENT_INTERFACE)) {
		if (local && local->path && !strcmp(local->path, path))
			local->mgmt_proxy = NULL;

		l_queue_remove(node_proxies, proxy);
	}
}

static void build_model(struct l_dbus_message_builder *builder, uint16_t mod_id,
					bool pub_enable, bool sub_enable)
{
	l_dbus_message_builder_enter_struct(builder, "qa{sv}");
	l_dbus_message_builder_append_basic(builder, 'q', &mod_id);
	l_dbus_message_builder_enter_array(builder, "{sv}");
	append_dict_entry_basic(builder, "Subscribe", "b", &sub_enable);
	append_dict_entry_basic(builder, "Publish", "b", &pub_enable);
	l_dbus_message_builder_leave_array(builder);
	l_dbus_message_builder_leave_struct(builder);
}

static bool mod_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_enter_array(builder, "(qa{sv})");
	build_model(builder, app.ele.mods[0], false, false);
	build_model(builder, app.ele.mods[1], false, false);
	build_model(builder, app.ele.mods[2], false, false);
	build_model(builder, app.ele.mods[3], false, false);
	l_dbus_message_builder_leave_array(builder);

	return true;
}

static bool vmod_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_enter_array(builder, "(qqa{sv})");
	l_dbus_message_builder_leave_array(builder);

	return true;
}

static bool ele_idx_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_append_basic(builder, 'y', &app.ele.index);

	return true;
}

static struct l_dbus_message *dev_msg_recv_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	struct l_dbus_message_iter iter;
	uint16_t src, idx;
	uint8_t *data;
	uint32_t n;
	bool rmt;

	if (!l_dbus_message_get_arguments(msg, "qbqay", &src, &rmt, &idx,
								&iter)) {
		l_error("Cannot parse received message");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	if (!l_dbus_message_iter_get_fixed_array(&iter, &data, &n)) {
		l_error("Cannot parse received message: data");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	bt_shell_printf("Received dev key message (len %u):", n);

	/* Pass to the configuration client */
	if (cfgcli && cfgcli->ops.recv)
		cfgcli->ops.recv(src, APP_IDX_DEV_REMOTE, data, n);

	return l_dbus_message_new_method_return(msg);
}

static void setup_ele_iface(struct l_dbus_interface *iface)
{
	/* Properties */
	l_dbus_interface_property(iface, "Index", 0, "y", ele_idx_getter,
									NULL);
	l_dbus_interface_property(iface, "VendorModels", 0, "a(qqa{sv})",
							vmod_getter, NULL);
	l_dbus_interface_property(iface, "Models", 0, "a(qa{sv})", mod_getter,
									NULL);

	/* Methods */
	l_dbus_interface_method(iface, "DevKeyMessageReceived", 0,
				dev_msg_recv_call, "", "qbqay", "source",
				"remote", "net_index", "data");

	/* TODO: Other methods */
}

static int sort_rssi(const void *a, const void *b, void *user_data)
{
	const struct unprov_device *new_dev = a;
	const struct unprov_device *dev = b;

	if (b == finalized)
		return 1;

	return dev->rssi - new_dev->rssi;
}

static struct l_dbus_message *scan_result_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	struct l_dbus_message_iter iter, opts, var;
	struct unprov_device result, *dev;
	int16_t rssi;
	uint16_t server = 0;
	uint32_t n;
	uint8_t *prov_data;
	const char *key;
	const char *sig = "naya{sv}";

	if (finalized == l_queue_peek_head(devices))
		goto done;


	if (!l_dbus_message_get_arguments(msg, sig, &rssi, &iter, &opts)) {
		l_error("Cannot parse scan results");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	if (!l_dbus_message_iter_get_fixed_array(&iter, &prov_data, &n) ||
								n < 16) {
		l_error("Cannot parse scan result: data");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	while (l_dbus_message_iter_next_entry(&opts, &key, &var)) {
		if (!strcmp(key, "Server"))
			l_dbus_message_iter_get_variant(&var, "q", &server);
	}

	memcpy(result.uuid, prov_data, 16);
	result.server = server;
	result.rssi = rssi;
	result.id = 0;

	if (n > 16 && n <= 18)
		result.oob_info = l_get_be16(prov_data + 16);
	else
		result.oob_info = 0;

	if (n > 18 && n <= 22)
		result.uri_hash = l_get_be32(prov_data + 18);
	else
		result.uri_hash = 0;

	dev = l_queue_remove_if(devices, match_by_srv_uuid, &result);

	if (!dev) {
		bt_shell_printf("\r" COLOR_YELLOW "Results = %d\n" COLOR_OFF,
						l_queue_length(devices) + 1);
		dev = l_malloc(sizeof(struct unprov_device));
		*dev = result;

	} else if (dev->rssi < result.rssi)
		*dev = result;

	dev->last_seen = time(NULL);

	l_queue_insert(devices, dev, sort_rssi, NULL);

done:
	return l_dbus_message_new_method_return(msg);
}

static struct l_dbus_message *req_reprov_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	uint8_t cnt;
	uint16_t unicast, original;
	struct l_dbus_message *reply;


	if (!l_dbus_message_get_arguments(msg, "qy", &original, &cnt) ||
							!IS_UNICAST(original)) {
		l_error("Cannot parse request for reprov data");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);

	}

	unicast = remote_get_next_unicast(low_addr, high_addr, cnt);

	bt_shell_printf("Assign addresses for %u elements\n", cnt);
	bt_shell_printf("Original: %4.4x New: %4.4x\n", original, unicast);

	reply = l_dbus_message_new_method_return(msg);
	l_dbus_message_set_arguments(reply, "q", unicast);

	return reply;
}

static struct l_dbus_message *req_prov_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	uint8_t cnt;
	uint16_t unicast;
	struct l_dbus_message *reply;

	/* Both calls handled identicaly except for parameter list */
	if (!l_dbus_message_get_arguments(msg, "y", &cnt)) {
		l_error("Cannot parse request for prov data");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);

	}

	unicast = remote_get_next_unicast(low_addr, high_addr, cnt);

	if (!IS_UNICAST(unicast)) {
		l_error("Failed to allocate addresses for %u elements\n", cnt);
		return l_dbus_message_new_error(msg,
					"org.freedesktop.DBus.Error."
					"Failed to allocate address", NULL);
	}

	bt_shell_printf("Assign addresses: %4.4x (cnt: %d)\n", unicast, cnt);

	reply = l_dbus_message_new_method_return(msg);
	l_dbus_message_set_arguments(reply, "qq", prov_net_idx, unicast);

	return reply;
}

static void remove_device(uint8_t *uuid)
{
	struct unprov_device *dev;

	do {
		dev = l_queue_remove_if(devices, match_device_uuid, uuid);
		l_free(dev);
	} while (dev);
}

static struct l_dbus_message *prov_cmplt_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	struct l_dbus_message_iter iter;
	int16_t unicast;
	uint8_t cnt;
	uint32_t n;
	uint8_t *uuid;

	l_debug("ProvComplete");
	if (!prov_in_progress)
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);

	prov_in_progress = false;

	if (!l_dbus_message_get_arguments(msg, "ayqy", &iter, &unicast, &cnt)) {
		l_error("Cannot parse add node complete message");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);

	}

	if (!l_dbus_message_iter_get_fixed_array(&iter, &uuid, &n) ||
								n != 16) {
		l_error("Cannot parse add node complete message: uuid");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	remote_add_node(uuid, unicast, cnt, prov_net_idx);

	bt_shell_printf("Provisioning done:\n");
	remote_print_node(unicast);

	remove_device(uuid);

	if (!mesh_db_add_node(uuid, cnt, unicast, prov_net_idx))
		l_error("Failed to store new remote node");

	return l_dbus_message_new_method_return(msg);
}

static struct l_dbus_message *reprov_cmplt_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	uint16_t unicast, original;
	uint8_t old_cnt, cnt, nppi;

	l_debug("ReprovComplete");
	if (!prov_in_progress)
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);

	prov_in_progress = false;

	if (!l_dbus_message_get_arguments(msg, "qyqy", &original, &nppi,
							&unicast, &cnt)) {
		l_error("Cannot parse reprov complete message");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);

	}

	l_debug("ReprovComplete org: %4.4x, nppi: %d, new: %4.4x, cnt: %d",
						original, nppi, unicast, cnt);
	old_cnt = remote_ele_cnt(original);

	if (nppi != 1 && (original != unicast || cnt != old_cnt)) {
		l_error("Invalid reprov complete message (NPPI == %d)", nppi);
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	if (nppi)
		remote_reset_node(original, unicast, cnt,
						mesh_db_get_iv_index());

	bt_shell_printf("Reprovisioning done (nppi: %d):\n", nppi);
	remote_print_node(unicast);

	if (!mesh_db_reset_node(original, unicast, cnt))
		l_error("Failed to reset remote node");

	return l_dbus_message_new_method_return(msg);
}

static struct l_dbus_message *prov_fail_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	struct l_dbus_message_iter iter;
	uint32_t n;
	uint8_t *uuid;
	char *str, *reason;

	if (!prov_in_progress)
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);

	prov_in_progress = false;

	if (!l_dbus_message_get_arguments(msg, "ays", &iter, &reason)) {
		l_error("Cannot parse failed message");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	if (!l_dbus_message_iter_get_fixed_array(&iter, &uuid, &n) || n != 16) {
		l_error("Cannot parse failed message: uuid");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	bt_shell_printf("Provisioning failed:\n");

	str = l_util_hexstring_upper(uuid, 16);
	bt_shell_printf("\t" COLOR_RED "UUID = %s\n" COLOR_OFF, str);
	l_free(str);
	remove_device(uuid);
	bt_shell_printf("\t" COLOR_RED "%s\n" COLOR_OFF, reason);

	return l_dbus_message_new_method_return(msg);
}

static struct l_dbus_message *reprov_fail_call(struct l_dbus *dbus,
						struct l_dbus_message *msg,
						void *user_data)
{
	struct l_dbus_message_iter iter;
	uint16_t original = UNASSIGNED_ADDRESS;
	char *reason;

	if (!prov_in_progress)
		return l_dbus_message_new_error(msg, dbus_err_fail, NULL);

	prov_in_progress = false;

	if (!l_dbus_message_get_arguments(msg, "qs", &iter, &reason) ||
							!IS_UNICAST(original)) {

		l_error("Cannot parse Reprov failed message");
		return l_dbus_message_new_error(msg, dbus_err_args, NULL);
	}

	bt_shell_printf("Reprovisioning failed:\n");
	bt_shell_printf("\t" COLOR_RED "UNICAST = %4.4x\n" COLOR_OFF, original);
	bt_shell_printf("\t" COLOR_RED "%s\n" COLOR_OFF, reason);

	return l_dbus_message_new_method_return(msg);
}

static void setup_prov_iface(struct l_dbus_interface *iface)
{
	l_dbus_interface_method(iface, "ScanResult", 0, scan_result_call, "",
					"naya{sv}", "rssi", "data", "options");

	l_dbus_interface_method(iface, "RequestProvData", 0, req_prov_call,
				"qq", "y", "net_index", "unicast", "count");

	l_dbus_interface_method(iface, "RequestReprovData", 0, req_reprov_call,
					"q", "qy", "unicast",
					"original", "count");

	l_dbus_interface_method(iface, "AddNodeComplete", 0,
					prov_cmplt_call, "", "ayqy",
					"uuid", "unicast", "count");

	l_dbus_interface_method(iface, "ReprovComplete", 0,
					reprov_cmplt_call, "", "qyqy",
					"original", "nppi", "unicast", "count");

	l_dbus_interface_method(iface, "AddNodeFailed", 0, prov_fail_call,
					"", "ays", "uuid", "reason");

	l_dbus_interface_method(iface, "ReprovFailed", 0, reprov_fail_call,
					"", "qs", "unicast", "reason");
}

static bool cid_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_append_basic(builder, 'q', &app.cid);

	return true;
}

static bool pid_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_append_basic(builder, 'q', &app.pid);

	return true;
}

static bool vid_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_append_basic(builder, 'q', &app.vid);

	return true;
}
static bool crpl_getter(struct l_dbus *dbus,
				struct l_dbus_message *message,
				struct l_dbus_message_builder *builder,
				void *user_data)
{
	l_dbus_message_builder_append_basic(builder, 'q', &app.crpl);

	return true;
}

static void attach_node(void *user_data)
{
	l_dbus_proxy_method_call(net_proxy, "Attach", attach_node_setup,
						attach_node_reply, NULL,
						NULL);
}

static struct l_dbus_message *join_complete(struct l_dbus *dbus,
						struct l_dbus_message *message,
						void *user_data)
{
	char *str;
	uint64_t tmp;

	if (!l_dbus_message_get_arguments(message, "t", &tmp))
		return l_dbus_message_new_error(message, dbus_err_args, NULL);

	local = l_new(struct meshcfg_node, 1);
	local->token.u64 = l_get_be64(&tmp);
	str = l_util_hexstring(&local->token.u8[0], 8);
	bt_shell_printf("Created new node with token %s\n", str);
	l_free(str);

	if (!mesh_db_create(cfg_fname, local->token.u8,
					"Mesh Config Client Network")) {
		l_free(local);
		local = NULL;
		return l_dbus_message_new_error(message, dbus_err_fail, NULL);
	}

	keys_add_net_key(PRIMARY_NET_IDX);
	mesh_db_add_net_key(PRIMARY_NET_IDX);

	remote_add_node(app.uuid, 0x0001, 1, PRIMARY_NET_IDX);
	mesh_db_add_node(app.uuid, 0x0001, 1, PRIMARY_NET_IDX);

	mesh_db_add_provisioner("BlueZ mesh-cfgclient", app.uuid,
					low_addr, high_addr,
					GROUP_ADDRESS_LOW, GROUP_ADDRESS_HIGH);

	l_idle_oneshot(attach_node, NULL, NULL);

	return l_dbus_message_new_method_return(message);
}

static void property_changed(struct l_dbus_proxy *proxy, const char *name,
				struct l_dbus_message *msg, void *user_data)
{
	const char *interface = l_dbus_proxy_get_interface(proxy);
	const char *path = l_dbus_proxy_get_path(proxy);

	if (strcmp(path, local->path))
		return;

	bt_shell_printf("Property changed: %s %s %s\n", name, path, interface);

	if (!strcmp(interface, "org.bluez.mesh.Node1")) {

		if (!strcmp(name, "IvIndex")) {
			uint32_t ivi;

			if (!l_dbus_message_get_arguments(msg, "u", &ivi))
				return;

			bt_shell_printf("New IV Index: %u\n", ivi);

			iv_index = ivi;
			mesh_db_set_iv_index(ivi);
			remote_clear_rejected_addresses(ivi);
		}
	}
}

static void setup_app_iface(struct l_dbus_interface *iface)
{
	l_dbus_interface_property(iface, "CompanyID", 0, "q", cid_getter,
									NULL);
	l_dbus_interface_property(iface, "VersionID", 0, "q", vid_getter,
									NULL);
	l_dbus_interface_property(iface, "ProductID", 0, "q", pid_getter,
									NULL);
	l_dbus_interface_property(iface, "CRPL", 0, "q", crpl_getter, NULL);

	l_dbus_interface_method(iface, "JoinComplete", 0, join_complete,
							"", "t", "token");

	/* TODO: Methods */
}

static bool register_app(void)
{
	if (!l_dbus_register_interface(dbus, MESH_APPLICATION_INTERFACE,
						setup_app_iface, NULL, false)) {
		l_error("Failed to register interface %s",
						MESH_APPLICATION_INTERFACE);
		return false;
	}

	if (!l_dbus_register_interface(dbus, MESH_PROVISIONER_INTERFACE,
					setup_prov_iface, NULL, false)) {
		l_error("Failed to register interface %s",
						MESH_PROVISIONER_INTERFACE);
		return false;
	}

	if (!l_dbus_register_object(dbus, app.path, NULL, NULL,
					MESH_APPLICATION_INTERFACE, NULL,
					MESH_PROVISIONER_INTERFACE, NULL,
									NULL)) {
		l_error("Failed to register object %s", app.path);
		return false;
	}

	if (!register_agent())
		return false;

	if (!l_dbus_register_interface(dbus, MESH_ELEMENT_INTERFACE,
						setup_ele_iface, NULL, false)) {
		l_error("Failed to register interface %s",
						MESH_ELEMENT_INTERFACE);
		return false;
	}

	if (!l_dbus_register_object(dbus, app.ele.path, NULL, NULL,
				    MESH_ELEMENT_INTERFACE, NULL, NULL)) {
		l_error("Failed to register object %s", app.ele.path);
		return false;
	}

	if (!l_dbus_object_add_interface(dbus, app.path,
					 L_DBUS_INTERFACE_OBJECT_MANAGER,
									NULL)) {
		l_error("Failed to add interface %s",
					L_DBUS_INTERFACE_OBJECT_MANAGER);
		return false;
	}

	return true;
}

static void client_ready(struct l_dbus_client *client, void *user_data)
{
	bt_shell_printf("D-Bus client ready\n");
	if (!register_app())
		bt_shell_quit(EXIT_FAILURE);

	bt_shell_attach(fileno(stdin));
}

static void client_connected(struct l_dbus *dbus, void *user_data)
{
	bt_shell_printf("D-Bus client connected\n");
	bt_shell_set_prompt(PROMPT_ON);
}

static void client_disconnected(struct l_dbus *dbus, void *user_data)
{
	bt_shell_printf("D-Bus client disconnected, exit\n");
	bt_shell_quit(EXIT_SUCCESS);
}

static void ready_callback(void *user_data)
{
	bt_shell_printf("Connected to D-Bus\n");
	if (!l_dbus_object_manager_enable(dbus, "/"))
		bt_shell_printf("Failed to register the ObjectManager\n");
}

static bool setup_cfg_storage(void)
{
	struct stat st;

	if (!config_opt) {
		char *home;
		char *mesh_dir;

		home = getenv("XDG_CONFIG_HOME");

		if (home) {
			mesh_dir = l_strdup_printf("%s/meshcfg", home);
		} else {
			home = getenv("HOME");
			if (!home) {
				l_error("\"HOME\" not set\n");
				return false;
			}

			mesh_dir = l_strdup_printf("%s/.config/meshcfg", home);
		}

		if (!mesh_dir)
			return false;

		if (stat(mesh_dir, &st) == 0) {
			if (!S_ISDIR(st.st_mode)) {
				l_error("%s not a directory", mesh_dir);
				return false;
			}
		} else if (errno == ENOENT) {
			if (mkdir(mesh_dir, 0700) != 0)
				return false;
		} else {
			perror("Cannot open config directory");
			return false;
		}

		cfg_fname = l_strdup_printf("%s/%s", mesh_dir,
							DEFAULT_CFG_FILE);
		l_free(mesh_dir);

	} else {
		cfg_fname = l_strdup_printf("%s", config_opt);
	}

	if (stat(cfg_fname, &st) == -1) {
		if (errno == ENOENT) {
			l_warn("\nWarning: config file \"%s\" not found",
								cfg_fname);
			return true;
		}

		perror("\nFailed to open config file");
		return false;
	}

	have_config = true;
	return true;
}

static bool read_mesh_config(void)
{
	uint16_t range_l, range_h;

	if (!mesh_db_load(cfg_fname)) {
		l_error("Failed to load config from %s", cfg_fname);
		return false;
	}

	local = l_new(struct meshcfg_node, 1);

	if (!mesh_db_get_token(local->token.u8)) {
		l_error("Failed to read the provisioner's token ID");
		l_error("Check config file %s", cfg_fname);
		l_free(local);
		local = NULL;

		return false;
	}

	l_info("Mesh configuration loaded from %s", cfg_fname);
	if (mesh_db_get_addr_range(&range_l, &range_h)) {
		low_addr = range_l;
		high_addr = range_h;
	}

	iv_index = mesh_db_get_iv_index();

	return true;
}

int main(int argc, char *argv[])
{
	struct l_dbus_client *client;
	uint32_t val;
	int status;

	bt_shell_init(argc, argv, &opt);
	bt_shell_set_menu(&main_menu);

	l_log_set_stderr();

	if (address_opt && sscanf(address_opt, "%04x", &val) == 1)
		low_addr = (uint16_t) val;

	if (low_addr > DEFAULT_MAX_ADDRESS) {
		l_error("Invalid start address");
			bt_shell_cleanup();
			return EXIT_FAILURE;
	}

	if (!low_addr)
		low_addr = DEFAULT_START_ADDRESS;

	if (range_opt && sscanf(address_opt, "%04x", &val) == 1) {
		if (val == 0) {
			l_error("Invalid address range");
			bt_shell_cleanup();
			return EXIT_FAILURE;
		}

		/* Inclusive */
		high_addr = low_addr + val - 1;
	}

	if (!high_addr || high_addr > DEFAULT_MAX_ADDRESS)
		high_addr = DEFAULT_MAX_ADDRESS;

	if (net_idx_opt && sscanf(net_idx_opt, "%04x", &val) == 1)
		prov_net_idx = (uint16_t) val;
	else
		prov_net_idx = DEFAULT_NET_INDEX;

	if (!setup_cfg_storage()) {
		bt_shell_cleanup();
		return EXIT_FAILURE;
	}

	if (have_config && !read_mesh_config()) {
		bt_shell_cleanup();
		return EXIT_FAILURE;
	}

	bt_shell_set_prompt(PROMPT_OFF);

	dbus = l_dbus_new_default(L_DBUS_SYSTEM_BUS);

	l_dbus_set_ready_handler(dbus, ready_callback, NULL, NULL);
	client = l_dbus_client_new(dbus, BLUEZ_MESH_NAME, "/org/bluez/mesh");

	l_dbus_client_set_connect_handler(client, client_connected, NULL, NULL);
	l_dbus_client_set_disconnect_handler(client, client_disconnected, NULL,
									NULL);
	l_dbus_client_set_proxy_handlers(client, proxy_added, proxy_removed,
						property_changed, NULL, NULL);
	l_dbus_client_set_ready_handler(client, client_ready, NULL, NULL);

	node_proxies = l_queue_new();
	devices = l_queue_new();

	status = bt_shell_run();

	l_dbus_client_destroy(client);
	l_dbus_destroy(dbus);

	cfgcli_cleanup();

	return status;
}
