attrib/interactive.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2011  Nokia Corporation
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <glib.h>
  28
  29 #include <bluetooth/uuid.h>
  30
  31 #include <readline/readline.h>
  32 #include <readline/history.h>
  33
  34 #include "att.h"
  35 #include "btio.h"
  36 #include "gattrib.h"
  37 #include "gatt.h"
  38 #include "gatttool.h"
  39
  40 static GIOChannel *iochannel = NULL;
  41 static GAttrib *attrib = NULL;
  42 static GMainLoop *event_loop;
  43 static GString *prompt;
  44
  45 static gchar *opt_src = NULL;
  46 static gchar *opt_dst = NULL;
  47 static gchar *opt_dst_type = NULL;
  48 static gchar *opt_sec_level = NULL;
  49 static int opt_psm = 0;
  50 static int opt_mtu = 0;
  51
  52 struct characteristic_data {
  53         uint16_t orig_start;
  54         uint16_t start;
  55         uint16_t end;
  56         bt_uuid_t uuid;
  57 };
  58
  59 static void cmd_help(int argcp, char **argvp);
  60
  61 enum state {
  62         STATE_DISCONNECTED,
  63         STATE_CONNECTING,
  64         STATE_CONNECTED
  65 } conn_state;
  66
  67 static char *get_prompt(void)
  68 {
  69         if (conn_state == STATE_CONNECTING) {
  70                 g_string_assign(prompt, "Connecting... ");
  71                 return prompt->str;
  72         }
  73
  74         if (conn_state == STATE_CONNECTED)
  75                 g_string_assign(prompt, "[CON]");
  76         else
  77                 g_string_assign(prompt, "[   ]");
  78
  79         if (opt_dst)
  80                 g_string_append_printf(prompt, "[%17s]", opt_dst);
  81         else
  82                 g_string_append_printf(prompt, "[%17s]", "");
  83
  84         if (opt_psm)
  85                 g_string_append(prompt, "[BR]");
  86         else
  87                 g_string_append(prompt, "[LE]");
  88
  89         g_string_append(prompt, "> ");
  90
  91         return prompt->str;
  92 }
  93
  94
  95 static void set_state(enum state st)
  96 {
  97         conn_state = st;
  98         rl_set_prompt(get_prompt());
  99         rl_redisplay();
 100 }
 101
 102 static void events_handler(const uint8_t *pdu, uint16_t len, gpointer user_data)
 103 {
 104         uint8_t opdu[ATT_MAX_MTU];
 105         uint16_t handle, i, olen;
 106
 107         handle = att_get_u16(&pdu[1]);
 108
 109         printf("\n");
 110         switch (pdu[0]) {
 111         case ATT_OP_HANDLE_NOTIFY:
 112                 printf("Notification handle = 0x%04x value: ", handle);
 113                 break;
 114         case ATT_OP_HANDLE_IND:
 115                 printf("Indication   handle = 0x%04x value: ", handle);
 116                 break;
 117         default:
 118                 printf("Invalid opcode\n");
 119                 return;
 120         }
 121
 122         for (i = 3; i < len; i++)
 123                 printf("%02x ", pdu[i]);
 124
 125         printf("\n");
 126         rl_forced_update_display();
 127
 128         if (pdu[0] == ATT_OP_HANDLE_NOTIFY)
 129                 return;
 130
 131         olen = enc_confirmation(opdu, sizeof(opdu));
 132
 133         if (olen > 0)
 134                 g_attrib_send(attrib, 0, opdu[0], opdu, olen, NULL, NULL, NULL);
 135 }
 136
 137 static void connect_cb(GIOChannel *io, GError *err, gpointer user_data)
 138 {
 139         if (err) {
 140                 printf("connect error: %s\n", err->message);
 141                 set_state(STATE_DISCONNECTED);
 142                 return;
 143         }
 144
 145         attrib = g_attrib_new(iochannel);
 146         g_attrib_register(attrib, ATT_OP_HANDLE_NOTIFY, events_handler,
 147                                                         attrib, NULL);
 148         g_attrib_register(attrib, ATT_OP_HANDLE_IND, events_handler,
 149                                                         attrib, NULL);
 150         set_state(STATE_CONNECTED);
 151 }
 152
 153 static void disconnect_io()
 154 {
 155         if (conn_state == STATE_DISCONNECTED)
 156                 return;
 157
 158         g_attrib_unref(attrib);
 159         attrib = NULL;
 160         opt_mtu = 0;
 161
 162         g_io_channel_shutdown(iochannel, FALSE, NULL);
 163         g_io_channel_unref(iochannel);
 164         iochannel = NULL;
 165
 166         set_state(STATE_DISCONNECTED);
 167 }
 168
 169 static void primary_all_cb(GSList *services, guint8 status, gpointer user_data)
 170 {
 171         GSList *l;
 172
 173         if (status) {
 174                 printf("Discover all primary services failed: %s\n",
 175                                                         att_ecode2str(status));
 176                 return;
 177         }
 178
 179         printf("\n");
 180         for (l = services; l; l = l->next) {
 181                 struct gatt_primary *prim = l->data;
 182                 printf("attr handle: 0x%04x, end grp handle: 0x%04x "
 183                         "uuid: %s\n", prim->range.start, prim->range.end, prim->uuid);
 184         }
 185
 186         rl_forced_update_display();
 187 }
 188
 189 static void primary_by_uuid_cb(GSList *ranges, guint8 status,
 190                                                         gpointer user_data)
 191 {
 192         GSList *l;
 193
 194         if (status) {
 195                 printf("Discover primary services by UUID failed: %s\n",
 196                                                         att_ecode2str(status));
 197                 return;
 198         }
 199
 200         printf("\n");
 201         for (l = ranges; l; l = l->next) {
 202                 struct att_range *range = l->data;
 203                 g_print("Starting handle: 0x%04x Ending handle: 0x%04x\n",
 204                                                 range->start, range->end);
 205         }
 206
 207         rl_forced_update_display();
 208 }
 209
 210 static void char_cb(GSList *characteristics, guint8 status, gpointer user_data)
 211 {
 212         GSList *l;
 213
 214         if (status) {
 215                 printf("Discover all characteristics failed: %s\n",
 216                                                         att_ecode2str(status));
 217                 return;
 218         }
 219
 220         printf("\n");
 221         for (l = characteristics; l; l = l->next) {
 222                 struct gatt_char *chars = l->data;
 223
 224                 printf("handle: 0x%04x, char properties: 0x%02x, char value "
 225                                 "handle: 0x%04x, uuid: %s\n", chars->handle,
 226                                 chars->properties, chars->value_handle,
 227                                 chars->uuid);
 228         }
 229
 230         rl_forced_update_display();
 231 }
 232
 233 static void char_desc_cb(guint8 status, const guint8 *pdu, guint16 plen,
 234                                                         gpointer user_data)
 235 {
 236         struct att_data_list *list;
 237         guint8 format;
 238         int i;
 239
 240         if (status != 0) {
 241                 printf("Discover all characteristic descriptors failed: "
 242                                                 "%s\n", att_ecode2str(status));
 243                 return;
 244         }
 245
 246         list = dec_find_info_resp(pdu, plen, &format);
 247         if (list == NULL)
 248                 return;
 249
 250         printf("\n");
 251         for (i = 0; i < list->num; i++) {
 252                 char uuidstr[MAX_LEN_UUID_STR];
 253                 uint16_t handle;
 254                 uint8_t *value;
 255                 bt_uuid_t uuid;
 256
 257                 value = list->data[i];
 258                 handle = att_get_u16(value);
 259
 260                 if (format == 0x01)
 261                         uuid = att_get_uuid16(&value[2]);
 262                 else
 263                         uuid = att_get_uuid128(&value[2]);
 264
 265                 bt_uuid_to_string(&uuid, uuidstr, MAX_LEN_UUID_STR);
 266                 printf("handle: 0x%04x, uuid: %s\n", handle, uuidstr);
 267         }
 268
 269         att_data_list_free(list);
 270
 271         rl_forced_update_display();
 272 }
 273
 274 static void char_read_cb(guint8 status, const guint8 *pdu, guint16 plen,
 275                                                         gpointer user_data)
 276 {
 277         uint8_t value[ATT_MAX_MTU];
 278         int i, vlen;
 279
 280         if (status != 0) {
 281                 printf("Characteristic value/descriptor read failed: %s\n",
 282                                                         att_ecode2str(status));
 283                 return;
 284         }
 285
 286         if (!dec_read_resp(pdu, plen, value, &vlen)) {
 287                 printf("Protocol error\n");
 288                 return;
 289         }
 290
 291         printf("\nCharacteristic value/descriptor: ");
 292         for (i = 0; i < vlen; i++)
 293                 printf("%02x ", value[i]);
 294         printf("\n");
 295
 296         rl_forced_update_display();
 297 }
 298
 299 static void char_read_by_uuid_cb(guint8 status, const guint8 *pdu,
 300                                         guint16 plen, gpointer user_data)
 301 {
 302         struct characteristic_data *char_data = user_data;
 303         struct att_data_list *list;
 304         int i;
 305
 306         if (status == ATT_ECODE_ATTR_NOT_FOUND &&
 307                                 char_data->start != char_data->orig_start)
 308                 goto done;
 309
 310         if (status != 0) {
 311                 printf("Read characteristics by UUID failed: %s\n",
 312                                                         att_ecode2str(status));
 313                 goto done;
 314         }
 315
 316         list = dec_read_by_type_resp(pdu, plen);
 317         if (list == NULL)
 318                 goto done;
 319
 320         for (i = 0; i < list->num; i++) {
 321                 uint8_t *value = list->data[i];
 322                 int j;
 323
 324                 char_data->start = att_get_u16(value) + 1;
 325
 326                 printf("\nhandle: 0x%04x \t value: ", att_get_u16(value));
 327                 value += 2;
 328                 for (j = 0; j < list->len - 2; j++, value++)
 329                         printf("%02x ", *value);
 330                 printf("\n");
 331         }
 332
 333         att_data_list_free(list);
 334
 335         rl_forced_update_display();
 336
 337 done:
 338         g_free(char_data);
 339 }
 340
 341 static void cmd_exit(int argcp, char **argvp)
 342 {
 343         rl_callback_handler_remove();
 344         g_main_loop_quit(event_loop);
 345 }
 346
 347 static gboolean channel_watcher(GIOChannel *chan, GIOCondition cond,
 348                                 gpointer user_data)
 349 {
 350         disconnect_io();
 351
 352         return FALSE;
 353 }
 354
 355 static void cmd_connect(int argcp, char **argvp)
 356 {
 357         if (conn_state != STATE_DISCONNECTED)
 358                 return;
 359
 360         if (argcp > 1) {
 361                 g_free(opt_dst);
 362                 opt_dst = g_strdup(argvp[1]);
 363
 364                 g_free(opt_dst_type);
 365                 if (argcp > 2)
 366                         opt_dst_type = g_strdup(argvp[2]);
 367                 else
 368                         opt_dst_type = g_strdup("public");
 369         }
 370
 371         if (opt_dst == NULL) {
 372                 printf("Remote Bluetooth address required\n");
 373                 return;
 374         }
 375
 376         set_state(STATE_CONNECTING);
 377         iochannel = gatt_connect(opt_src, opt_dst, opt_dst_type, opt_sec_level,
 378                                                 opt_psm, opt_mtu, connect_cb);
 379         if (iochannel == NULL)
 380                 set_state(STATE_DISCONNECTED);
 381         else
 382                 g_io_add_watch(iochannel, G_IO_HUP, channel_watcher, NULL);
 383 }
 384
 385 static void cmd_disconnect(int argcp, char **argvp)
 386 {
 387         disconnect_io();
 388 }
 389
 390 static void cmd_primary(int argcp, char **argvp)
 391 {
 392         bt_uuid_t uuid;
 393
 394         if (conn_state != STATE_CONNECTED) {
 395                 printf("Command failed: disconnected\n");
 396                 return;
 397         }
 398
 399         if (argcp == 1) {
 400                 gatt_discover_primary(attrib, NULL, primary_all_cb, NULL);
 401                 return;
 402         }
 403
 404         if (bt_string_to_uuid(&uuid, argvp[1]) < 0) {
 405                 printf("Invalid UUID\n");
 406                 return;
 407         }
 408
 409         gatt_discover_primary(attrib, &uuid, primary_by_uuid_cb, NULL);
 410 }
 411
 412 static int strtohandle(const char *src)
 413 {
 414         char *e;
 415         int dst;
 416
 417         errno = 0;
 418         dst = strtoll(src, &e, 16);
 419         if (errno != 0 || *e != '\0')
 420                 return -EINVAL;
 421
 422         return dst;
 423 }
 424
 425 static void cmd_char(int argcp, char **argvp)
 426 {
 427         int start = 0x0001;
 428         int end = 0xffff;
 429
 430         if (conn_state != STATE_CONNECTED) {
 431                 printf("Command failed: disconnected\n");
 432                 return;
 433         }
 434
 435         if (argcp > 1) {
 436                 start = strtohandle(argvp[1]);
 437                 if (start < 0) {
 438                         printf("Invalid start handle: %s\n", argvp[1]);
 439                         return;
 440                 }
 441         }
 442
 443         if (argcp > 2) {
 444                 end = strtohandle(argvp[2]);
 445                 if (end < 0) {
 446                         printf("Invalid end handle: %s\n", argvp[2]);
 447                         return;
 448                 }
 449         }
 450
 451         if (argcp > 3) {
 452                 bt_uuid_t uuid;
 453
 454                 if (bt_string_to_uuid(&uuid, argvp[3]) < 0) {
 455                         printf("Invalid UUID\n");
 456                         return;
 457                 }
 458
 459                 gatt_discover_char(attrib, start, end, &uuid, char_cb, NULL);
 460                 return;
 461         }
 462
 463         gatt_discover_char(attrib, start, end, NULL, char_cb, NULL);
 464 }
 465
 466 static void cmd_char_desc(int argcp, char **argvp)
 467 {
 468         int start = 0x0001;
 469         int end = 0xffff;
 470
 471         if (conn_state != STATE_CONNECTED) {
 472                 printf("Command failed: disconnected\n");
 473                 return;
 474         }
 475
 476         if (argcp > 1) {
 477                 start = strtohandle(argvp[1]);
 478                 if (start < 0) {
 479                         printf("Invalid start handle: %s\n", argvp[1]);
 480                         return;
 481                 }
 482         }
 483
 484         if (argcp > 2) {
 485                 end = strtohandle(argvp[2]);
 486                 if (end < 0) {
 487                         printf("Invalid end handle: %s\n", argvp[2]);
 488                         return;
 489                 }
 490         }
 491
 492         gatt_find_info(attrib, start, end, char_desc_cb, NULL);
 493 }
 494
 495 static void cmd_read_hnd(int argcp, char **argvp)
 496 {
 497         int handle;
 498         int offset = 0;
 499
 500         if (conn_state != STATE_CONNECTED) {
 501                 printf("Command failed: disconnected\n");
 502                 return;
 503         }
 504
 505         if (argcp < 2) {
 506                 printf("Missing argument: handle\n");
 507                 return;
 508         }
 509
 510         handle = strtohandle(argvp[1]);
 511         if (handle < 0) {
 512                 printf("Invalid handle: %s\n", argvp[1]);
 513                 return;
 514         }
 515
 516         if (argcp > 2) {
 517                 char *e;
 518
 519                 errno = 0;
 520                 offset = strtol(argvp[2], &e, 0);
 521                 if (errno != 0 || *e != '\0') {
 522                         printf("Invalid offset: %s\n", argvp[2]);
 523                         return;
 524                 }
 525         }
 526
 527         gatt_read_char(attrib, handle, offset, char_read_cb, attrib);
 528 }
 529
 530 static void cmd_read_uuid(int argcp, char **argvp)
 531 {
 532         struct characteristic_data *char_data;
 533         int start = 0x0001;
 534         int end = 0xffff;
 535         bt_uuid_t uuid;
 536
 537         if (conn_state != STATE_CONNECTED) {
 538                 printf("Command failed: disconnected\n");
 539                 return;
 540         }
 541
 542         if (argcp < 2) {
 543                 printf("Missing argument: UUID\n");
 544                 return;
 545         }
 546
 547         if (bt_string_to_uuid(&uuid, argvp[1]) < 0) {
 548                 printf("Invalid UUID\n");
 549                 return;
 550         }
 551
 552         if (argcp > 2) {
 553                 start = strtohandle(argvp[2]);
 554                 if (start < 0) {
 555                         printf("Invalid start handle: %s\n", argvp[1]);
 556                         return;
 557                 }
 558         }
 559
 560         if (argcp > 3) {
 561                 end = strtohandle(argvp[3]);
 562                 if (end < 0) {
 563                         printf("Invalid end handle: %s\n", argvp[2]);
 564                         return;
 565                 }
 566         }
 567
 568         char_data = g_new(struct characteristic_data, 1);
 569         char_data->orig_start = start;
 570         char_data->start = start;
 571         char_data->end = end;
 572         char_data->uuid = uuid;
 573
 574         gatt_read_char_by_uuid(attrib, start, end, &char_data->uuid,
 575                                         char_read_by_uuid_cb, char_data);
 576 }
 577
 578 static void char_write_req_cb(guint8 status, const guint8 *pdu, guint16 plen,
 579                                                         gpointer user_data)
 580 {
 581         if (status != 0) {
 582                 printf("Characteristic Write Request failed: "
 583                                                 "%s\n", att_ecode2str(status));
 584                 return;
 585         }
 586
 587         if (!dec_write_resp(pdu, plen)) {
 588                 printf("Protocol error\n");
 589                 return;
 590         }
 591
 592         printf("Characteristic value was written successfully\n");
 593 }
 594
 595 static void cmd_char_write(int argcp, char **argvp)
 596 {
 597         uint8_t *value;
 598         size_t plen;
 599         int handle;
 600
 601         if (conn_state != STATE_CONNECTED) {
 602                 printf("Command failed: disconnected\n");
 603                 return;
 604         }
 605
 606         if (argcp < 3) {
 607                 printf("Usage: %s <handle> <new value>\n", argvp[0]);
 608                 return;
 609         }
 610
 611         handle = strtohandle(argvp[1]);
 612         if (handle <= 0) {
 613                 printf("A valid handle is required\n");
 614                 return;
 615         }
 616
 617         plen = gatt_attr_data_from_string(argvp[2], &value);
 618         if (plen == 0) {
 619                 g_printerr("Invalid value\n");
 620                 return;
 621         }
 622
 623         if (g_strcmp0("char-write-req", argvp[0]) == 0)
 624                 gatt_write_char(attrib, handle, value, plen,
 625                                         char_write_req_cb, NULL);
 626         else
 627                 gatt_write_char(attrib, handle, value, plen, NULL, NULL);
 628
 629         g_free(value);
 630 }
 631
 632 static void cmd_sec_level(int argcp, char **argvp)
 633 {
 634         GError *gerr = NULL;
 635         BtIOSecLevel sec_level;
 636
 637         if (argcp < 2) {
 638                 printf("sec-level: %s\n", opt_sec_level);
 639                 return;
 640         }
 641
 642         if (strcasecmp(argvp[1], "medium") == 0)
 643                 sec_level = BT_IO_SEC_MEDIUM;
 644         else if (strcasecmp(argvp[1], "high") == 0)
 645                 sec_level = BT_IO_SEC_HIGH;
 646         else if (strcasecmp(argvp[1], "low") == 0)
 647                 sec_level = BT_IO_SEC_LOW;
 648         else {
 649                 printf("Allowed values: low | medium | high\n");
 650                 return;
 651         }
 652
 653         g_free(opt_sec_level);
 654         opt_sec_level = g_strdup(argvp[1]);
 655
 656         if (conn_state != STATE_CONNECTED)
 657                 return;
 658
 659         if (opt_psm) {
 660                 printf("It must be reconnected to this change take effect\n");
 661                 return;
 662         }
 663
 664         bt_io_set(iochannel, BT_IO_L2CAP, &gerr,
 665                         BT_IO_OPT_SEC_LEVEL, sec_level,
 666                         BT_IO_OPT_INVALID);
 667
 668         if (gerr) {
 669                 printf("Error: %s\n", gerr->message);
 670                 g_error_free(gerr);
 671         }
 672 }
 673
 674 static void exchange_mtu_cb(guint8 status, const guint8 *pdu, guint16 plen,
 675                                                         gpointer user_data)
 676 {
 677         uint16_t mtu;
 678
 679         if (status != 0) {
 680                 printf("Exchange MTU Request failed: %s\n",
 681                                                         att_ecode2str(status));
 682                 return;
 683         }
 684
 685         if (!dec_mtu_resp(pdu, plen, &mtu)) {
 686                 printf("Protocol error\n");
 687                 return;
 688         }
 689
 690         mtu = MIN(mtu, opt_mtu);
 691         /* Set new value for MTU in client */
 692         if (g_attrib_set_mtu(attrib, mtu))
 693                 printf("MTU was exchanged successfully: %d\n", mtu);
 694         else
 695                 printf("Error exchanging MTU\n");
 696 }
 697
 698 static void cmd_mtu(int argcp, char **argvp)
 699 {
 700         if (conn_state != STATE_CONNECTED) {
 701                 printf("Command failed: not connected.\n");
 702                 return;
 703         }
 704
 705         if (opt_psm) {
 706                 printf("Command failed: operation is only available for LE"
 707                                                         " transport.\n");
 708                 return;
 709         }
 710
 711         if (argcp < 2) {
 712                 printf("Usage: mtu <value>\n");
 713                 return;
 714         }
 715
 716         if (opt_mtu) {
 717                 printf("Command failed: MTU exchange can only occur once per"
 718                                                         " connection.\n");
 719                 return;
 720         }
 721
 722         errno = 0;
 723         opt_mtu = strtoll(argvp[1], NULL, 0);
 724         if (errno != 0 || opt_mtu < ATT_DEFAULT_LE_MTU) {
 725                 printf("Invalid value. Minimum MTU size is %d\n",
 726                                                         ATT_DEFAULT_LE_MTU);
 727                 return;
 728         }
 729
 730         gatt_exchange_mtu(attrib, opt_mtu, exchange_mtu_cb, NULL);
 731 }
 732
 733 static struct {
 734         const char *cmd;
 735         void (*func)(int argcp, char **argvp);
 736         const char *params;
 737         const char *desc;
 738 } commands[] = {
 739         { "help",               cmd_help,       "",
 740                 "Show this help"},
 741         { "exit",               cmd_exit,       "",
 742                 "Exit interactive mode" },
 743         { "quit",               cmd_exit,       "",
 744                 "Exit interactive mode" },
 745         { "connect",            cmd_connect,    "[address [address type]]",
 746                 "Connect to a remote device" },
 747         { "disconnect",         cmd_disconnect, "",
 748                 "Disconnect from a remote device" },
 749         { "primary",            cmd_primary,    "[UUID]",
 750                 "Primary Service Discovery" },
 751         { "characteristics",    cmd_char,       "[start hnd [end hnd [UUID]]]",
 752                 "Characteristics Discovery" },
 753         { "char-desc",          cmd_char_desc,  "[start hnd] [end hnd]",
 754                 "Characteristics Descriptor Discovery" },
 755         { "char-read-hnd",      cmd_read_hnd,   "<handle> [offset]",
 756                 "Characteristics Value/Descriptor Read by handle" },
 757         { "char-read-uuid",     cmd_read_uuid,  "<UUID> [start hnd] [end hnd]",
 758                 "Characteristics Value/Descriptor Read by UUID" },
 759         { "char-write-req",     cmd_char_write, "<handle> <new value>",
 760                 "Characteristic Value Write (Write Request)" },
 761         { "char-write-cmd",     cmd_char_write, "<handle> <new value>",
 762                 "Characteristic Value Write (No response)" },
 763         { "sec-level",          cmd_sec_level,  "[low | medium | high]",
 764                 "Set security level. Default: low" },
 765         { "mtu",                cmd_mtu,        "<value>",
 766                 "Exchange MTU for GATT/ATT" },
 767         { NULL, NULL, NULL}
 768 };
 769
 770 static void cmd_help(int argcp, char **argvp)
 771 {
 772         int i;
 773
 774         for (i = 0; commands[i].cmd; i++)
 775                 printf("%-15s %-30s %s\n", commands[i].cmd,
 776                                 commands[i].params, commands[i].desc);
 777 }
 778
 779 static void parse_line(char *line_read)
 780 {
 781         gchar **argvp;
 782         int argcp;
 783         int i;
 784
 785         if (line_read == NULL) {
 786                 printf("\n");
 787                 cmd_exit(0, NULL);
 788                 return;
 789         }
 790
 791         line_read = g_strstrip(line_read);
 792
 793         if (*line_read == '\0')
 794                 return;
 795
 796         add_history(line_read);
 797
 798         g_shell_parse_argv(line_read, &argcp, &argvp, NULL);
 799
 800         for (i = 0; commands[i].cmd; i++)
 801                 if (strcasecmp(commands[i].cmd, argvp[0]) == 0)
 802                         break;
 803
 804         if (commands[i].cmd)
 805                 commands[i].func(argcp, argvp);
 806         else
 807                 printf("%s: command not found\n", argvp[0]);
 808
 809         g_strfreev(argvp);
 810 }
 811
 812 static gboolean prompt_read(GIOChannel *chan, GIOCondition cond,
 813                                                         gpointer user_data)
 814 {
 815         if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
 816                 g_io_channel_unref(chan);
 817                 return FALSE;
 818         }
 819
 820         rl_callback_read_char();
 821
 822         return TRUE;
 823 }
 824
 825 static char *completion_generator(const char *text, int state)
 826 {
 827         static int index = 0, len = 0;
 828         const char *cmd = NULL;
 829
 830         if (state == 0) {
 831                 index = 0;
 832                 len = strlen(text);
 833         }
 834
 835         while ((cmd = commands[index].cmd) != NULL) {
 836                 index++;
 837                 if (strncmp(cmd, text, len) == 0)
 838                         return strdup(cmd);
 839         }
 840
 841         return NULL;
 842 }
 843
 844 static char **commands_completion(const char *text, int start, int end)
 845 {
 846         if (start == 0)
 847                 return rl_completion_matches(text, &completion_generator);
 848         else
 849                 return NULL;
 850 }
 851
 852 int interactive(const gchar *src, const gchar *dst,
 853                 const gchar *dst_type, int psm)
 854 {
 855         GIOChannel *pchan;
 856         gint events;
 857
 858         opt_sec_level = g_strdup("low");
 859
 860         opt_src = g_strdup(src);
 861         opt_dst = g_strdup(dst);
 862         opt_dst_type = g_strdup(dst_type);
 863         opt_psm = psm;
 864
 865         prompt = g_string_new(NULL);
 866
 867         event_loop = g_main_loop_new(NULL, FALSE);
 868
 869         pchan = g_io_channel_unix_new(fileno(stdin));
 870         g_io_channel_set_close_on_unref(pchan, TRUE);
 871         events = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
 872         g_io_add_watch(pchan, events, prompt_read, NULL);
 873
 874         rl_attempted_completion_function = commands_completion;
 875         rl_callback_handler_install(get_prompt(), parse_line);
 876
 877         g_main_loop_run(event_loop);
 878
 879         rl_callback_handler_remove();
 880         cmd_disconnect(0, NULL);
 881         g_io_channel_unref(pchan);
 882         g_main_loop_unref(event_loop);
 883         g_string_free(prompt, TRUE);
 884
 885         g_free(opt_src);
 886         g_free(opt_dst);
 887         g_free(opt_sec_level);
 888
 889         return 0;
 890 }