/*

 *

 *  BlueZ - Bluetooth protocol stack for Linux

 *

 *  Copyright (C) 2011  Nokia Corporation

 *

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program 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 General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; 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 <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <errno.h>

#include <stdio.h>

#include <unistd.h>

#include <signal.h>

#include <sys/signalfd.h>

#include <glib.h>

#include <readline/readline.h>

#include <readline/history.h>

#include "lib/bluetooth.h"

#include "lib/sdp.h"

#include "lib/uuid.h"

#include "src/shared/util.h"

#include "btio/btio.h"

#include "att.h"

#include "gattrib.h"

#include "gatt.h"

#include "gatttool.h"

#include "client/display.h"

static GIOChannel *iochannel = NULL;

static GAttrib *attrib = NULL;

static GMainLoop *event_loop;

static GString *prompt;

static char *opt_src = NULL;

static char *opt_dst = NULL;

static char *opt_dst_type = NULL;

static char *opt_sec_level = NULL;

static int opt_psm = 0;

static int opt_mtu = 0;

static int start;

static int end;

static void cmd_help(int argcp, char **argvp);

static enum state {

	STATE_DISCONNECTED,

	STATE_CONNECTING,

	STATE_CONNECTED

} conn_state;

#define error(fmt, arg...) \

	rl_printf(COLOR_RED "Error: " COLOR_OFF fmt, ## arg)

#define failed(fmt, arg...) \

	rl_printf(COLOR_RED "Command Failed: " COLOR_OFF fmt, ## arg)

static char *get_prompt(void)

{

	if (conn_state == STATE_CONNECTED)

		g_string_assign(prompt, COLOR_BLUE);

	else

		g_string_assign(prompt, "");

	if (opt_dst)

		g_string_append_printf(prompt, "[%17s]", opt_dst);

	else

		g_string_append_printf(prompt, "[%17s]", "");

	if (conn_state == STATE_CONNECTED)

		g_string_append(prompt, COLOR_OFF);

	if (opt_psm)

		g_string_append(prompt, "[BR]");

	else

		g_string_append(prompt, "[LE]");

	g_string_append(prompt, "> ");

	return prompt->str;

}

static void set_state(enum state st)

{

	conn_state = st;

	rl_set_prompt(get_prompt());

}

static void events_handler(const uint8_t *pdu, uint16_t len, gpointer user_data)

{

	uint8_t *opdu;

	uint16_t handle, i, olen;

	size_t plen;

	GString *s;

	handle = get_le16(&pdu[1]);

	switch (pdu[0]) {

	case ATT_OP_HANDLE_NOTIFY:

		s = g_string_new(NULL);

		g_string_printf(s, "Notification handle = 0x%04x value: ",

									handle);

		break;

	case ATT_OP_HANDLE_IND:

		s = g_string_new(NULL);

		g_string_printf(s, "Indication   handle = 0x%04x value: ",

									handle);

		break;

	default:

		error("Invalid opcode\n");

		return;

	}

	for (i = 3; i < len; i++)

		g_string_append_printf(s, "%02x ", pdu[i]);

	rl_printf("%s\n", s->str);

	g_string_free(s, TRUE);

	if (pdu[0] == ATT_OP_HANDLE_NOTIFY)

		return;

	opdu = g_attrib_get_buffer(attrib, &plen);

	olen = enc_confirmation(opdu, plen);

	if (olen > 0)

		g_attrib_send(attrib, 0, opdu, olen, NULL, NULL, NULL);

}

static void connect_cb(GIOChannel *io, GError *err, gpointer user_data)

{

	uint16_t mtu;

	uint16_t cid;

	if (err) {

		set_state(STATE_DISCONNECTED);

		error("%s\n", err->message);

		return;

	}

	bt_io_get(io, &err, BT_IO_OPT_IMTU, &mtu,

				BT_IO_OPT_CID, &cid, BT_IO_OPT_INVALID);

	if (err) {

		g_printerr("Can't detect MTU, using default: %s", err->message);

		g_error_free(err);

		mtu = ATT_DEFAULT_LE_MTU;

	}

	if (cid == ATT_CID)

		mtu = ATT_DEFAULT_LE_MTU;

	attrib = g_attrib_new(iochannel, mtu, false);

	g_attrib_register(attrib, ATT_OP_HANDLE_NOTIFY, GATTRIB_ALL_HANDLES,

						events_handler, attrib, NULL);

	g_attrib_register(attrib, ATT_OP_HANDLE_IND, GATTRIB_ALL_HANDLES,

						events_handler, attrib, NULL);

	set_state(STATE_CONNECTED);

	rl_printf("Connection successful\n");

}

static void disconnect_io()

{

	if (conn_state == STATE_DISCONNECTED)

		return;

	g_attrib_unref(attrib);

	attrib = NULL;

	opt_mtu = 0;

	g_io_channel_shutdown(iochannel, FALSE, NULL);

	g_io_channel_unref(iochannel);

	iochannel = NULL;

	set_state(STATE_DISCONNECTED);

}

static void primary_all_cb(uint8_t status, GSList *services, void *user_data)

{

	GSList *l;

	if (status) {

		error("Discover all primary services failed: %s\n",

						att_ecode2str(status));

		return;

	}

	if (services == NULL) {

		error("No primary service found\n");

		return;

	}

	for (l = services; l; l = l->next) {

		struct gatt_primary *prim = l->data;

		rl_printf("attr handle: 0x%04x, end grp handle: 0x%04x uuid: %s\n",

				prim->range.start, prim->range.end, prim->uuid);

	}

}

static void primary_by_uuid_cb(uint8_t status, GSList *ranges, void *user_data)

{

	GSList *l;

	if (status) {

		error("Discover primary services by UUID failed: %s\n",

							att_ecode2str(status));

		return;

	}

	if (ranges == NULL) {

		error("No service UUID found\n");

		return;

	}

	for (l = ranges; l; l = l->next) {

		struct att_range *range = l->data;

		rl_printf("Starting handle: 0x%04x Ending handle: 0x%04x\n",

						range->start, range->end);

	}

}

static void included_cb(uint8_t status, GSList *includes, void *user_data)

{

	GSList *l;

	if (status) {

		error("Find included services failed: %s\n",

							att_ecode2str(status));

		return;

	}

	if (includes == NULL) {

		rl_printf("No included services found for this range\n");

		return;

	}

	for (l = includes; l; l = l->next) {

		struct gatt_included *incl = l->data;

		rl_printf("handle: 0x%04x, start handle: 0x%04x, "

					"end handle: 0x%04x uuid: %s\n",

					incl->handle, incl->range.start,

					incl->range.end, incl->uuid);

	}

}

static void char_cb(uint8_t status, GSList *characteristics, void *user_data)

{

	GSList *l;

	if (status) {

		error("Discover all characteristics failed: %s\n",

							att_ecode2str(status));

		return;

	}

	for (l = characteristics; l; l = l->next) {

		struct gatt_char *chars = l->data;

		rl_printf("handle: 0x%04x, char properties: 0x%02x, char value "

				"handle: 0x%04x, uuid: %s\n", chars->handle,

				chars->properties, chars->value_handle,

				chars->uuid);

	}

}

static void char_desc_cb(uint8_t status, GSList *descriptors, void *user_data)

{

	GSList *l;

	if (status) {

		error("Discover descriptors failed: %s\n",

							att_ecode2str(status));

		return;

	}

	for (l = descriptors; l; l = l->next) {

		struct gatt_desc *desc = l->data;

		rl_printf("handle: 0x%04x, uuid: %s\n", desc->handle,

								desc->uuid);

	}

}

static void char_read_cb(guint8 status, const guint8 *pdu, guint16 plen,

							gpointer user_data)

{

	uint8_t value[plen];

	ssize_t vlen;

	int i;

	GString *s;

	if (status != 0) {

		error("Characteristic value/descriptor read failed: %s\n",

							att_ecode2str(status));

		return;

	}

	vlen = dec_read_resp(pdu, plen, value, sizeof(value));

	if (vlen < 0) {

		error("Protocol error\n");

		return;

	}

	s = g_string_new("Characteristic value/descriptor: ");

	for (i = 0; i < vlen; i++)

		g_string_append_printf(s, "%02x ", value[i]);

	rl_printf("%s\n", s->str);

	g_string_free(s, TRUE);

}

static void char_read_by_uuid_cb(guint8 status, const guint8 *pdu,

					guint16 plen, gpointer user_data)

{

	struct att_data_list *list;

	int i;

	GString *s;

	if (status != 0) {

		error("Read characteristics by UUID failed: %s\n",

							att_ecode2str(status));

		return;

	}

	list = dec_read_by_type_resp(pdu, plen);

	if (list == NULL)

		return;

	s = g_string_new(NULL);

	for (i = 0; i < list->num; i++) {

		uint8_t *value = list->data[i];

		int j;

		g_string_printf(s, "handle: 0x%04x \t value: ",

							get_le16(value));

		value += 2;

		for (j = 0; j < list->len - 2; j++, value++)

			g_string_append_printf(s, "%02x ", *value);

		rl_printf("%s\n", s->str);

	}

	att_data_list_free(list);

	g_string_free(s, TRUE);

}

static void cmd_exit(int argcp, char **argvp)

{

	rl_callback_handler_remove();

	g_main_loop_quit(event_loop);

}

static gboolean channel_watcher(GIOChannel *chan, GIOCondition cond,

				gpointer user_data)

{

	disconnect_io();

	return FALSE;

}

static void cmd_connect(int argcp, char **argvp)

{

	GError *gerr = NULL;

	if (conn_state != STATE_DISCONNECTED)

		return;

	if (argcp > 1) {

		g_free(opt_dst);

		opt_dst = g_strdup(argvp[1]);

		g_free(opt_dst_type);

		if (argcp > 2)

			opt_dst_type = g_strdup(argvp[2]);

		else

			opt_dst_type = g_strdup("public");

	}

	if (opt_dst == NULL) {

		error("Remote Bluetooth address required\n");

		return;

	}

	rl_printf("Attempting to connect to %s\n", opt_dst);

	set_state(STATE_CONNECTING);

	iochannel = gatt_connect(opt_src, opt_dst, opt_dst_type, opt_sec_level,

					opt_psm, opt_mtu, connect_cb, &gerr);

	if (iochannel == NULL) {

		set_state(STATE_DISCONNECTED);

		error("%s\n", gerr->message);

		g_error_free(gerr);

	} else

		g_io_add_watch(iochannel, G_IO_HUP, channel_watcher, NULL);

}

static void cmd_disconnect(int argcp, char **argvp)

{

	disconnect_io();

}

static void cmd_primary(int argcp, char **argvp)

{

	bt_uuid_t uuid;

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp == 1) {

		gatt_discover_primary(attrib, NULL, primary_all_cb, NULL);

		return;

	}

	if (bt_string_to_uuid(&uuid, argvp[1]) < 0) {

		error("Invalid UUID\n");

		return;

	}

	gatt_discover_primary(attrib, &uuid, primary_by_uuid_cb, NULL);

}

static int strtohandle(const char *src)

{

	char *e;

	int dst;

	errno = 0;

	dst = strtoll(src, &e, 16);

	if (errno != 0 || *e != '\0')

		return -EINVAL;

	return dst;

}

static void cmd_included(int argcp, char **argvp)

{

	int start = 0x0001;

	int end = 0xffff;

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp > 1) {

		start = strtohandle(argvp[1]);

		if (start < 0) {

			error("Invalid start handle: %s\n", argvp[1]);

			return;

		}

		end = start;

	}

	if (argcp > 2) {

		end = strtohandle(argvp[2]);

		if (end < 0) {

			error("Invalid end handle: %s\n", argvp[2]);

			return;

		}

	}

	gatt_find_included(attrib, start, end, included_cb, NULL);

}

static void cmd_char(int argcp, char **argvp)

{

	int start = 0x0001;

	int end = 0xffff;

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp > 1) {

		start = strtohandle(argvp[1]);

		if (start < 0) {

			error("Invalid start handle: %s\n", argvp[1]);

			return;

		}

	}

	if (argcp > 2) {

		end = strtohandle(argvp[2]);

		if (end < 0) {

			error("Invalid end handle: %s\n", argvp[2]);

			return;

		}

	}

	if (argcp > 3) {

		bt_uuid_t uuid;

		if (bt_string_to_uuid(&uuid, argvp[3]) < 0) {

			error("Invalid UUID\n");

			return;

		}

		gatt_discover_char(attrib, start, end, &uuid, char_cb, NULL);

		return;

	}

	gatt_discover_char(attrib, start, end, NULL, char_cb, NULL);

}

static void cmd_char_desc(int argcp, char **argvp)

{

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp > 1) {

		start = strtohandle(argvp[1]);

		if (start < 0) {

			error("Invalid start handle: %s\n", argvp[1]);

			return;

		}

	} else

		start = 0x0001;

	if (argcp > 2) {

		end = strtohandle(argvp[2]);

		if (end < 0) {

			error("Invalid end handle: %s\n", argvp[2]);

			return;

		}

	} else

		end = 0xffff;

	gatt_discover_desc(attrib, start, end, NULL, char_desc_cb, NULL);

}

static void cmd_read_hnd(int argcp, char **argvp)

{

	int handle;

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp < 2) {

		error("Missing argument: handle\n");

		return;

	}

	handle = strtohandle(argvp[1]);

	if (handle < 0) {

		error("Invalid handle: %s\n", argvp[1]);

		return;

	}

	gatt_read_char(attrib, handle, char_read_cb, attrib);

}

static void cmd_read_uuid(int argcp, char **argvp)

{

	int start = 0x0001;

	int end = 0xffff;

	bt_uuid_t uuid;

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp < 2) {

		error("Missing argument: UUID\n");

		return;

	}

	if (bt_string_to_uuid(&uuid, argvp[1]) < 0) {

		error("Invalid UUID\n");

		return;

	}

	if (argcp > 2) {

		start = strtohandle(argvp[2]);

		if (start < 0) {

			error("Invalid start handle: %s\n", argvp[1]);

			return;

		}

	}

	if (argcp > 3) {

		end = strtohandle(argvp[3]);

		if (end < 0) {

			error("Invalid end handle: %s\n", argvp[2]);

			return;

		}

	}

	gatt_read_char_by_uuid(attrib, start, end, &uuid, char_read_by_uuid_cb,

									NULL);

}

static void char_write_req_cb(guint8 status, const guint8 *pdu, guint16 plen,

							gpointer user_data)

{

	if (status != 0) {

		error("Characteristic Write Request failed: "

						"%s\n", att_ecode2str(status));

		return;

	}

	if (!dec_write_resp(pdu, plen) && !dec_exec_write_resp(pdu, plen)) {

		error("Protocol error\n");

		return;

	}

	rl_printf("Characteristic value was written successfully\n");

}

static void cmd_char_write(int argcp, char **argvp)

{

	uint8_t *value;

	size_t plen;

	int handle;

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (argcp < 3) {

		rl_printf("Usage: %s <handle> <new value>\n", argvp[0]);

		return;

	}

	handle = strtohandle(argvp[1]);

	if (handle <= 0) {

		error("A valid handle is required\n");

		return;

	}

	plen = gatt_attr_data_from_string(argvp[2], &value);

	if (plen == 0) {

		error("Invalid value\n");

		return;

	}

	if (g_strcmp0("char-write-req", argvp[0]) == 0)

		gatt_write_char(attrib, handle, value, plen,

					char_write_req_cb, NULL);

	else

		gatt_write_cmd(attrib, handle, value, plen, NULL, NULL);

	g_free(value);

}

static void cmd_sec_level(int argcp, char **argvp)

{

	GError *gerr = NULL;

	BtIOSecLevel sec_level;

	if (argcp < 2) {

		rl_printf("sec-level: %s\n", opt_sec_level);

		return;

	}

	if (strcasecmp(argvp[1], "medium") == 0)

		sec_level = BT_IO_SEC_MEDIUM;

	else if (strcasecmp(argvp[1], "high") == 0)

		sec_level = BT_IO_SEC_HIGH;

	else if (strcasecmp(argvp[1], "low") == 0)

		sec_level = BT_IO_SEC_LOW;

	else {

		rl_printf("Allowed values: low | medium | high\n");

		return;

	}

	g_free(opt_sec_level);

	opt_sec_level = g_strdup(argvp[1]);

	if (conn_state != STATE_CONNECTED)

		return;

	if (opt_psm) {

		rl_printf("Change will take effect on reconnection\n");

		return;

	}

	bt_io_set(iochannel, &gerr,

			BT_IO_OPT_SEC_LEVEL, sec_level,

			BT_IO_OPT_INVALID);

	if (gerr) {

		error("%s\n", gerr->message);

		g_error_free(gerr);

	}

}

static void exchange_mtu_cb(guint8 status, const guint8 *pdu, guint16 plen,

							gpointer user_data)

{

	uint16_t mtu;

	if (status != 0) {

		error("Exchange MTU Request failed: %s\n",

						att_ecode2str(status));

		return;

	}

	if (!dec_mtu_resp(pdu, plen, &mtu)) {

		error("Protocol error\n");

		return;

	}

	mtu = MIN(mtu, opt_mtu);

	/* Set new value for MTU in client */

	if (g_attrib_set_mtu(attrib, mtu))

		rl_printf("MTU was exchanged successfully: %d\n", mtu);

	else

		error("Error exchanging MTU\n");

}

static void cmd_mtu(int argcp, char **argvp)

{

	if (conn_state != STATE_CONNECTED) {

		failed("Disconnected\n");

		return;

	}

	if (opt_psm) {

		failed("Operation is only available for LE transport.\n");

		return;

	}

	if (argcp < 2) {

		rl_printf("Usage: mtu <value>\n");

		return;

	}

	if (opt_mtu) {

		failed("MTU exchange can only occur once per connection.\n");

		return;

	}

	errno = 0;

	opt_mtu = strtoll(argvp[1], NULL, 0);

	if (errno != 0 || opt_mtu < ATT_DEFAULT_LE_MTU) {

		error("Invalid value. Minimum MTU size is %d\n",

							ATT_DEFAULT_LE_MTU);

		return;

	}

	gatt_exchange_mtu(attrib, opt_mtu, exchange_mtu_cb, NULL);

}

static struct {

	const char *cmd;

	void (*func)(int argcp, char **argvp);

	const char *params;

	const char *desc;

} commands[] = {

	{ "help",		cmd_help,	"",

		"Show this help"},

	{ "exit",		cmd_exit,	"",

		"Exit interactive mode" },

	{ "quit",		cmd_exit,	"",

		"Exit interactive mode" },

	{ "connect",		cmd_connect,	"[address [address type]]",

		"Connect to a remote device" },

	{ "disconnect",		cmd_disconnect,	"",

		"Disconnect from a remote device" },

	{ "primary",		cmd_primary,	"[UUID]",

		"Primary Service Discovery" },

	{ "included",		cmd_included,	"[start hnd [end hnd]]",

		"Find Included Services" },

	{ "characteristics",	cmd_char,	"[start hnd [end hnd [UUID]]]",

		"Characteristics Discovery" },

	{ "char-desc",		cmd_char_desc,	"[start hnd] [end hnd]",

		"Characteristics Descriptor Discovery" },

	{ "char-read-hnd",	cmd_read_hnd,	"<handle>",

		"Characteristics Value/Descriptor Read by handle" },

	{ "char-read-uuid",	cmd_read_uuid,	"<UUID> [start hnd] [end hnd]",

		"Characteristics Value/Descriptor Read by UUID" },

	{ "char-write-req",	cmd_char_write,	"<handle> <new value>",

		"Characteristic Value Write (Write Request)" },

	{ "char-write-cmd",	cmd_char_write,	"<handle> <new value>",

		"Characteristic Value Write (No response)" },

	{ "sec-level",		cmd_sec_level,	"[low | medium | high]",

		"Set security level. Default: low" },

	{ "mtu",		cmd_mtu,	"<value>",

		"Exchange MTU for GATT/ATT" },

	{ NULL, NULL, NULL}

};

static void cmd_help(int argcp, char **argvp)

{

	int i;

	for (i = 0; commands[i].cmd; i++)

		rl_printf("%-15s %-30s %s\n", commands[i].cmd,

				commands[i].params, commands[i].desc);

}

static void parse_line(char *line_read)

{

	char **argvp;

	int argcp;

	int i;

	if (line_read == NULL) {

		rl_printf("\n");

		cmd_exit(0, NULL);

		return;

	}

	line_read = g_strstrip(line_read);

	if (*line_read == '\0')

		goto done;

	add_history(line_read);

	if (g_shell_parse_argv(line_read, &argcp, &argvp, NULL) == FALSE)

		goto done;

	for (i = 0; commands[i].cmd; i++)

		if (strcasecmp(commands[i].cmd, argvp[0]) == 0)

			break;

	if (commands[i].cmd)

		commands[i].func(argcp, argvp);

	else

		error("%s: command not found\n", argvp[0]);

	g_strfreev(argvp);

done:

	free(line_read);

}

static gboolean prompt_read(GIOChannel *chan, GIOCondition cond,

							gpointer user_data)

{

	if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {

		g_io_channel_unref(chan);

		return FALSE;

	}

	rl_callback_read_char();

	return TRUE;

}

static char *completion_generator(const char *text, int state)

{

	static int index = 0, len = 0;

	const char *cmd = NULL;

	if (state == 0) {

		index = 0;