/*

 *

 *  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

#define _GNU_SOURCE

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdbool.h>

#include <wordexp.h>

#include <inttypes.h>

#include <ctype.h>

#include <sys/file.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include "bluetooth/bluetooth.h"

#include <glib.h>

#include "lib/bluetooth.h"

#include "lib/uuid.h"

#include "src/shared/shell.h"

#include "src/shared/util.h"

#include "gdbus/gdbus.h"

#include "mesh/mesh-net.h"

#include "mesh/gatt.h"

#include "mesh/crypto.h"

#include "mesh/node.h"

#include "mesh/net.h"

#include "mesh/keys.h"

#include "mesh/prov.h"

#include "mesh/util.h"

#include "mesh/agent.h"

#include "mesh/prov-db.h"

#include "mesh/config-model.h"

#include "mesh/onoff-model.h"

/* String display constants */

#define COLORED_NEW	COLOR_GREEN "NEW" COLOR_OFF

#define COLORED_CHG	COLOR_YELLOW "CHG" COLOR_OFF

#define COLORED_DEL	COLOR_RED "DEL" COLOR_OFF

#define PROMPT_ON	COLOR_BLUE "[meshctl]" COLOR_OFF "# "

#define PROMPT_OFF	"Waiting to connect to bluetoothd..."

#define MESH_PROV_DATA_IN_UUID_STR	"00002adb-0000-1000-8000-00805f9b34fb"

#define MESH_PROV_DATA_OUT_UUID_STR	"00002adc-0000-1000-8000-00805f9b34fb"

#define MESH_PROXY_DATA_IN_UUID_STR	"00002add-0000-1000-8000-00805f9b34fb"

#define MESH_PROXY_DATA_OUT_UUID_STR	"00002ade-0000-1000-8000-00805f9b34fb"

static DBusConnection *dbus_conn;

struct adapter {

GDBusProxy *proxy;

	GList *mesh_devices;

};

struct mesh_device {

	GDBusProxy *proxy;

	uint8_t dev_uuid[16];

	gboolean hide;

};

GList *service_list;

GList *char_list;

static GList *ctrl_list;

static struct adapter *default_ctrl;

static char *mesh_prov_db_filename;

static char *mesh_local_config_filename;

static bool discovering = false;

static bool discover_mesh;

static uint16_t prov_net_key_index = NET_IDX_PRIMARY;

static const struct bt_shell_menu main_menu;

#define CONN_TYPE_NETWORK	0x00

#define CONN_TYPE_IDENTITY	0x01

#define CONN_TYPE_PROVISION	0x02

#define CONN_TYPE_INVALID	0xff

#define NET_IDX_INVALID		0xffff

struct {

	GDBusProxy *device;

	GDBusProxy *service;

	GDBusProxy *data_in;

	GDBusProxy *data_out;

	bool session_open;

	uint16_t unicast;

	uint16_t net_idx;

	uint8_t dev_uuid[16];

	uint8_t type;

} connection;

static bool service_is_mesh(GDBusProxy *proxy, const char *target_uuid)

{

	DBusMessageIter iter;

	const char *uuid;

	if (g_dbus_proxy_get_property(proxy, "UUID", &iter) == FALSE)

		return false;

	dbus_message_iter_get_basic(&iter, &uuid);

	if (target_uuid)

		return (!bt_uuid_strcmp(uuid, target_uuid));

	else if (bt_uuid_strcmp(uuid, MESH_PROV_SVC_UUID) ||

				bt_uuid_strcmp(uuid, MESH_PROXY_SVC_UUID))

		return true;

	else

		return false;

}

static bool char_is_mesh(GDBusProxy *proxy, const char *target_uuid)

{

	DBusMessageIter iter;

	const char *uuid;

	if (g_dbus_proxy_get_property(proxy, "UUID", &iter) == FALSE)

		return false;

	dbus_message_iter_get_basic(&iter, &uuid);

	if (target_uuid)

		return (!bt_uuid_strcmp(uuid, target_uuid));

	if (!bt_uuid_strcmp(uuid, MESH_PROV_DATA_IN_UUID_STR))

		return true;

	if (!bt_uuid_strcmp(uuid, MESH_PROV_DATA_OUT_UUID_STR))

		return true;

	if (!bt_uuid_strcmp(uuid, MESH_PROXY_DATA_IN_UUID_STR))

		return true;

	if (!bt_uuid_strcmp(uuid, MESH_PROXY_DATA_OUT_UUID_STR))

		return true;

	return false;

}

static gboolean check_default_ctrl(void)

{

	if (!default_ctrl) {

		bt_shell_printf("No default controller available\n");

		return FALSE;

	}

	return TRUE;

}

static void proxy_leak(gpointer data)

{

	bt_shell_printf("Leaking proxy %p\n", data);

}

static void connect_handler(DBusConnection *connection, void *user_data)

{

	bt_shell_set_prompt(PROMPT_ON);

}

static void disconnect_handler(DBusConnection *connection, void *user_data)

{

	bt_shell_detach();

	bt_shell_set_prompt(PROMPT_OFF);

	g_list_free_full(ctrl_list, proxy_leak);

	ctrl_list = NULL;

	default_ctrl = NULL;

}

static void print_adapter(GDBusProxy *proxy, const char *description)

{

	DBusMessageIter iter;

	const char *address, *name;

	if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)

		return;

	dbus_message_iter_get_basic(&iter, &address);

	if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == TRUE)

		dbus_message_iter_get_basic(&iter, &name);

	else

		name = "<unknown>";

	bt_shell_printf("%s%s%sController %s %s %s\n",

				description ? "[" : "",

				description ? : "",

				description ? "] " : "",

				address, name,

				default_ctrl &&

				default_ctrl->proxy == proxy ?

				"[default]" : "");

}

static void print_device(GDBusProxy *proxy, const char *description)

{

	DBusMessageIter iter;

	const char *address, *name;

	if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)

		return;

	dbus_message_iter_get_basic(&iter, &address);

	if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == TRUE)

		dbus_message_iter_get_basic(&iter, &name);

	else

		name = "<unknown>";

	bt_shell_printf("%s%s%sDevice %s %s\n",

				description ? "[" : "",

				description ? : "",

				description ? "] " : "",

				address, name);

}

static void print_iter(const char *label, const char *name,

						DBusMessageIter *iter)

{

	dbus_bool_t valbool;

	dbus_uint32_t valu32;

	dbus_uint16_t valu16;

	dbus_int16_t vals16;

	unsigned char byte;

	const char *valstr;

	DBusMessageIter subiter;

	char *entry;

	if (iter == NULL) {

		bt_shell_printf("%s%s is nil\n", label, name);

		return;

	}

	switch (dbus_message_iter_get_arg_type(iter)) {

	case DBUS_TYPE_INVALID:

		bt_shell_printf("%s%s is invalid\n", label, name);

		break;

	case DBUS_TYPE_STRING:

	case DBUS_TYPE_OBJECT_PATH:

		dbus_message_iter_get_basic(iter, &valstr);

		bt_shell_printf("%s%s: %s\n", label, name, valstr);

		break;

	case DBUS_TYPE_BOOLEAN:

		dbus_message_iter_get_basic(iter, &valbool);

		bt_shell_printf("%s%s: %s\n", label, name,

					valbool == TRUE ? "yes" : "no");

		break;

	case DBUS_TYPE_UINT32:

		dbus_message_iter_get_basic(iter, &valu32);

		bt_shell_printf("%s%s: 0x%06x\n", label, name, valu32);

		break;

	case DBUS_TYPE_UINT16:

		dbus_message_iter_get_basic(iter, &valu16);

		bt_shell_printf("%s%s: 0x%04x\n", label, name, valu16);

		break;

	case DBUS_TYPE_INT16:

		dbus_message_iter_get_basic(iter, &vals16);

		bt_shell_printf("%s%s: %d\n", label, name, vals16);

		break;

	case DBUS_TYPE_BYTE:

		dbus_message_iter_get_basic(iter, &byte);

		bt_shell_printf("%s%s: 0x%02x\n", label, name, byte);

		break;

	case DBUS_TYPE_VARIANT:

		dbus_message_iter_recurse(iter, &subiter);

		print_iter(label, name, &subiter);

		break;

	case DBUS_TYPE_ARRAY:

		dbus_message_iter_recurse(iter, &subiter);

		while (dbus_message_iter_get_arg_type(&subiter) !=

							DBUS_TYPE_INVALID) {

			print_iter(label, name, &subiter);

			dbus_message_iter_next(&subiter);

		}

		break;

	case DBUS_TYPE_DICT_ENTRY:

		dbus_message_iter_recurse(iter, &subiter);

		entry = g_strconcat(name, "Key", NULL);

		print_iter(label, entry, &subiter);

		g_free(entry);

		entry = g_strconcat(name, " Value", NULL);

		dbus_message_iter_next(&subiter);

		print_iter(label, entry, &subiter);

		g_free(entry);

		break;

	default:

		bt_shell_printf("%s%s has unsupported type\n", label, name);

		break;

	}

}

static void print_property(GDBusProxy *proxy, const char *name)

{

	DBusMessageIter iter;

	if (g_dbus_proxy_get_property(proxy, name, &iter) == FALSE)

		return;

	print_iter("\t", name, &iter);

}

static void forget_mesh_devices()

{

	g_list_free_full(default_ctrl->mesh_devices, g_free);

	default_ctrl->mesh_devices = NULL;

}

static struct mesh_device *find_device_by_uuid(GList *source, uint8_t uuid[16])

{

	GList *list;

	for (list = g_list_first(source); list; list = g_list_next(list)) {

		struct mesh_device *dev = list->data;

		if (!memcmp(dev->dev_uuid, uuid, 16))

			return dev;

	}

	return NULL;

}

static void print_prov_service(struct prov_svc_data *prov_data)

{

	const char *prefix = "\t\t";

	char txt_uuid[16 * 2 + 1];

	int i;

	bt_shell_printf("%sMesh Provisioning Service (%s)\n", prefix,

							MESH_PROV_SVC_UUID);

	for (i = 0; i < 16; ++i) {

		sprintf(txt_uuid + (i * 2), "%2.2x", prov_data->dev_uuid[i]);

	}

	bt_shell_printf("%s\tDevice UUID: %s\n", prefix, txt_uuid);

	bt_shell_printf("%s\tOOB: %4.4x\n", prefix, prov_data->oob);

}

static bool parse_prov_service_data(const char *uuid, uint8_t *data, int len,

								void *data_out)

{

	struct prov_svc_data *prov_data = data_out;

	int i;

	if (len < 18)

		return false;

	for (i = 0; i < 16; ++i) {

		prov_data->dev_uuid[i] = data[i];

	}

	prov_data->oob = get_be16(&data[16]);

	return true;

}

static bool parse_mesh_service_data(const char *uuid, uint8_t *data, int len,

								void *data_out)

{

	const char *prefix = "\t\t";

	if (!(len == 9 && data[0] == 0x00) && !(len == 17 && data[0] == 0x01)) {

		bt_shell_printf("Unexpected mesh proxy service data length %d\n",

									len);

		return false;

	}

	if (data[0] != connection.type)

		return false;

	if (data[0] == CONN_TYPE_IDENTITY) {

		uint8_t *key;

		if (IS_UNASSIGNED(connection.unicast)) {

			/* This would be a bug */

			bt_shell_printf("Error: Searching identity with "

							"unicast 0000\n");

			return false;

		}

		key = keys_net_key_get(prov_net_key_index, true);

		if (!key)

			return false;

		if (!mesh_crypto_identity_check(key, connection.unicast,

					       &data[1]))

			return false;

		if (discovering) {

			bt_shell_printf("\n%sMesh Proxy Service (%s)\n", prefix,

									uuid);

			bt_shell_printf("%sIdentity for node %4.4x\n", prefix,

							connection.unicast);

		}

	} else if (data[0] == CONN_TYPE_NETWORK) {

		uint16_t net_idx = net_validate_proxy_beacon(data + 1);

		if (net_idx == NET_IDX_INVALID || net_idx != connection.net_idx)

			return false;

		if (discovering) {

			bt_shell_printf("\n%sMesh Proxy Service (%s)\n", prefix,

									uuid);

			bt_shell_printf("%sNetwork Beacon for net index %4.4x\n",

							prefix, net_idx);

		}

	}

	return true;

}

static bool parse_service_data(GDBusProxy *proxy, const char *target_uuid,

					void *data_out)

{

	DBusMessageIter iter, entries;

	bool mesh_prov = false;

	bool mesh_proxy = false;

	if (target_uuid) {

		mesh_prov = !strcmp(target_uuid, MESH_PROV_SVC_UUID);

		mesh_proxy = !strcmp(target_uuid, MESH_PROXY_SVC_UUID);

	}

	if (!g_dbus_proxy_get_property(proxy, "ServiceData", &iter))

		return false;

	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)

		return false;

	dbus_message_iter_recurse(&iter, &entries);

	while (dbus_message_iter_get_arg_type(&entries)

						== DBUS_TYPE_DICT_ENTRY) {

		DBusMessageIter value, entry, array;

		const char *uuid_str;

		bt_uuid_t uuid;

		uint8_t *service_data;

		int len;

		dbus_message_iter_recurse(&entries, &entry);

		dbus_message_iter_get_basic(&entry, &uuid_str);

		if (bt_string_to_uuid(&uuid, uuid_str) < 0)

			goto fail;

		dbus_message_iter_next(&entry);

		if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)

			goto fail;

		dbus_message_iter_recurse(&entry, &value);

		if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_ARRAY)

			goto fail;

		dbus_message_iter_recurse(&value, &array);

		if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_BYTE)

			goto fail;

		dbus_message_iter_get_fixed_array(&array, &service_data, &len;;

		if (mesh_prov && !strcmp(uuid_str, MESH_PROV_SVC_UUID)) {

			return parse_prov_service_data(uuid_str, service_data,

								len, data_out);

		} else if (mesh_proxy &&

				!strcmp(uuid_str, MESH_PROXY_SVC_UUID)) {

			return parse_mesh_service_data(uuid_str, service_data,

								len, data_out);

		}

		dbus_message_iter_next(&entries);

	}

	if (!target_uuid)

		return true;

fail:

	return false;

}

static void print_uuids(GDBusProxy *proxy)

{

	DBusMessageIter iter, value;

	if (g_dbus_proxy_get_property(proxy, "UUIDs", &iter) == FALSE)

		return;

	dbus_message_iter_recurse(&iter, &value);

	while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {

		const char *uuid, *text;

		dbus_message_iter_get_basic(&value, &uuid);

		text = bt_uuidstr_to_str(uuid);

		if (text) {

			char str[26];

			unsigned int n;

			str[sizeof(str) - 1] = '\0';

			n = snprintf(str, sizeof(str), "%s", text);

			if (n > sizeof(str) - 1) {

				str[sizeof(str) - 2] = '.';

				str[sizeof(str) - 3] = '.';

				if (str[sizeof(str) - 4] == ' ')

					str[sizeof(str) - 4] = '.';

				n = sizeof(str) - 1;

			}

			bt_shell_printf("\tUUID: %s%*c(%s)\n",

						str, 26 - n, ' ', uuid);

		} else

			bt_shell_printf("\tUUID: %*c(%s)\n", 26, ' ', uuid);

		dbus_message_iter_next(&value);

	}

}

static gboolean device_is_child(GDBusProxy *device, GDBusProxy *master)

{

	DBusMessageIter iter;

	const char *adapter, *path;

	if (!master)

		return FALSE;

	if (g_dbus_proxy_get_property(device, "Adapter", &iter) == FALSE)

		return FALSE;

	dbus_message_iter_get_basic(&iter, &adapter);

	path = g_dbus_proxy_get_path(master);

	if (!strcmp(path, adapter))

		return TRUE;

	return FALSE;

}

static struct adapter *find_parent(GDBusProxy *device)

{

	GList *list;

	for (list = g_list_first(ctrl_list); list; list = g_list_next(list)) {

		struct adapter *adapter = list->data;

		if (device_is_child(device, adapter->proxy) == TRUE)

			return adapter;

	}

	return NULL;

}

static void set_connected_device(GDBusProxy *proxy)

{

	char *desc = NULL;

	DBusMessageIter iter;

	char buf[10];

	bool mesh;

	connection.device = proxy;

	if (proxy == NULL) {

		memset(&connection, 0, sizeof(connection));

		connection.type = CONN_TYPE_INVALID;

		goto done;

	}

	if (connection.type == CONN_TYPE_IDENTITY) {

		mesh = true;

		snprintf(buf, 10, "Node-%4.4x", connection.unicast);

	} else if (connection.type == CONN_TYPE_NETWORK) {

		mesh = true;

		snprintf(buf, 9, "Net-%4.4x", connection.net_idx);

	} else {

		mesh = false;

	}

	if (!g_dbus_proxy_get_property(proxy, "Alias", &iter) && !mesh)

			goto done;

	dbus_message_iter_get_basic(&iter, &desc);

	desc = g_strdup_printf(COLOR_BLUE "[%s%s%s]" COLOR_OFF "# ", desc,

			       (desc && mesh) ? "-" : "",

				mesh ? buf : "");

done:

	bt_shell_set_prompt(desc ? desc : PROMPT_ON);

	g_free(desc);

	/* If disconnected, return to main menu */

	if (proxy == NULL)

		bt_shell_set_menu(&main_menu);

}

static void connect_reply(DBusMessage *message, void *user_data)

{

	GDBusProxy *proxy = user_data;

	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {

		bt_shell_printf("Failed to connect: %s\n", error.name);

		dbus_error_free(&error);

		set_connected_device(NULL);

		return bt_shell_noninteractive_quit(EXIT_FAILURE);

	}

	bt_shell_printf("Connection successful\n");

	set_connected_device(proxy);

	return bt_shell_noninteractive_quit(EXIT_SUCCESS);

}

static void update_device_info(GDBusProxy *proxy)

{

	struct adapter *adapter = find_parent(proxy);

	DBusMessageIter iter;

	struct prov_svc_data prov_data;

	if (!adapter) {

		/* TODO: Error */

		return;

	}

	if (adapter != default_ctrl)

		return;

	if (!g_dbus_proxy_get_property(proxy, "Address", &iter))

		return;

	if (parse_service_data(proxy, MESH_PROV_SVC_UUID, &prov_data)) {

		struct mesh_device *dev;

		dev = find_device_by_uuid(adapter->mesh_devices,

							prov_data.dev_uuid);

		/* Display provisioning service once per discovery session */

		if (discovering && (!dev || !dev->hide))

						print_prov_service(&prov_data);

		if (dev) {

			dev->proxy = proxy;

			dev->hide = discovering;

			return;

		}

		dev = g_malloc0(sizeof(struct mesh_device));

		if (!dev)

			return;

		dev->proxy = proxy;

		dev->hide = discovering;

		memcpy(dev->dev_uuid, prov_data.dev_uuid, 16);

		adapter->mesh_devices = g_list_append(adapter->mesh_devices,

							dev);

		print_device(proxy, COLORED_NEW);

		node_create_new(&prov_data);

	} else if (parse_service_data(proxy, MESH_PROXY_SVC_UUID, NULL) &&

								discover_mesh) {

		bool res;

		g_dbus_proxy_method_call(default_ctrl->proxy, "StopDiscovery",

						NULL, NULL, NULL, NULL);

		discover_mesh = false;

		forget_mesh_devices();

		res = g_dbus_proxy_method_call(proxy, "Connect", NULL,

						connect_reply, proxy, NULL);

		if (!res)

			bt_shell_printf("Failed to connect to mesh\n");

		else

			bt_shell_printf("Trying to connect to mesh\n");

	}

}

static void adapter_added(GDBusProxy *proxy)

{

	struct adapter *adapter = g_malloc0(sizeof(struct adapter));

	adapter->proxy = proxy;

	ctrl_list = g_list_append(ctrl_list, adapter);

	if (!default_ctrl)

		default_ctrl = adapter;

	print_adapter(proxy, COLORED_NEW);

}

static void data_out_notify(GDBusProxy *proxy, bool enable,

				GDBusReturnFunction cb)

{

	struct mesh_node *node;

	node = node_find_by_uuid(connection.dev_uuid);

	if (!mesh_gatt_notify(proxy, enable, cb, node))

		bt_shell_printf("Failed to %s notification on %s\n", enable ?

				"start" : "stop", g_dbus_proxy_get_path(proxy));

	else

		bt_shell_printf("%s notification on %s\n", enable ?

			  "Start" : "Stop", g_dbus_proxy_get_path(proxy));

}

struct disconnect_data {

	GDBusReturnFunction cb;

	void *data;

};

static void disconnect(GDBusReturnFunction cb, void *user_data)

{

	GDBusProxy *proxy;

	DBusMessageIter iter;

	const char *addr;

	proxy = connection.device;

	if (!proxy)

		return;

	if (g_dbus_proxy_method_call(proxy, "Disconnect", NULL, cb, user_data,

							NULL) == FALSE) {

		bt_shell_printf("Failed to disconnect\n");

		return;

	}

	if (g_dbus_proxy_get_property(proxy, "Address", &iter) == TRUE)

			dbus_message_iter_get_basic(&iter, &addr);

	bt_shell_printf("Attempting to disconnect from %s\n", addr);

}

static void disc_notify_cb(DBusMessage *message, void *user_data)

{

	struct disconnect_data *disc_data = user_data;

	disconnect(disc_data->cb, disc_data->data);

	g_free(user_data);

}

static void disconnect_device(GDBusReturnFunction cb, void *user_data)

{

	DBusMessageIter iter;

	net_session_close(connection.data_in);

	/* Stop notificiation on prov_out or proxy out characteristics */

	if (connection.data_out) {

		if (g_dbus_proxy_get_property(connection.data_out, "Notifying",

							&iter) == TRUE) {

			struct disconnect_data *disc_data;

			disc_data = g_malloc(sizeof(struct disconnect_data));

			disc_data->cb = cb;

			disc_data->data = user_data;

			if (mesh_gatt_notify(connection.data_out, false,

						disc_notify_cb, disc_data))

				return;

		}

	}

	disconnect(cb, user_data);

}

static void mesh_prov_done(void *user_data, int status);

static void notify_prov_out_cb(DBusMessage *message, void *user_data)

{

	struct mesh_node *node = user_data;

	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {

		bt_shell_printf("Failed to start notify: %s\n", error.name);

		dbus_error_free(&error);

		return;

	}

	bt_shell_printf("Notify for Mesh Provisioning Out Data started\n");

	if (connection.type != CONN_TYPE_PROVISION) {

		bt_shell_printf("Error: wrong connection type %d (expected %d)\n",

			connection.type, CONN_TYPE_PROVISION);

		return;

	}

	if (!connection.data_in) {

		bt_shell_printf("Error: don't have mesh provisioning data in\n");

		return;

	}

	if (!node) {

		bt_shell_printf("Error: provisioning node not present\n");

		return;

	}

	if(!prov_open(node, connection.data_in, prov_net_key_index,

			mesh_prov_done, node))

	{

		bt_shell_printf("Failed to start provisioning\n");

		node_free(node);

		disconnect_device(NULL, NULL);

	} else

		bt_shell_printf("Initiated provisioning\n");

}

static void session_open_cb (int status)

{

	if (status) {

		bt_shell_printf("Failed to open Mesh session\n");

		disconnect_device(NULL, NULL);

		return;

	}

	bt_shell_printf("Mesh session is open\n");

	/* Get composition data for a newly provisioned node */

	if (connection.type == CONN_TYPE_IDENTITY)

		config_client_get_composition(connection.unicast);

}

static void notify_proxy_out_cb(DBusMessage *message, void *user_data)

{

	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {

		bt_shell_printf("Failed to start notify: %s\n", error.name);

		dbus_error_free(&error);

		return;

	}

	bt_shell_printf("Notify for Mesh Proxy Out Data started\n");