monitor/control.c

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 /*
   3  *
   4  *  BlueZ - Bluetooth protocol stack for Linux
   5  *
   6  *  Copyright (C) 2011-2014  Intel Corporation
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *
   9  *
  10  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 #include <config.h>
  14 #endif
  15
  16 #include <stdio.h>
  17 #include <stdbool.h>
  18 #include <stddef.h>
  19 #include <errno.h>
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/time.h>
  24 #include <sys/socket.h>
  25 #include <sys/un.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <termios.h>
  29 #include <fcntl.h>
  30 #include <linux/filter.h>
  31
  32 #include "lib/bluetooth.h"
  33 #include "lib/hci.h"
  34 #include "lib/mgmt.h"
  35
  36 #include "src/shared/util.h"
  37 #include "src/shared/btsnoop.h"
  38 #include "src/shared/mainloop.h"
  39
  40 #include "display.h"
  41 #include "packet.h"
  42 #include "hcidump.h"
  43 #include "ellisys.h"
  44 #include "tty.h"
  45 #include "control.h"
  46 #include "jlink.h"
  47
  48 static struct btsnoop *btsnoop_file = NULL;
  49 static bool hcidump_fallback = false;
  50 static bool decode_control = true;
  51 static uint16_t filter_index = HCI_DEV_NONE;
  52
  53 struct control_data {
  54         uint16_t channel;
  55         int fd;
  56         unsigned char buf[BTSNOOP_MAX_PACKET_SIZE];
  57         uint16_t offset;
  58 };
  59
  60 static void free_data(void *user_data)
  61 {
  62         struct control_data *data = user_data;
  63
  64         close(data->fd);
  65
  66         free(data);
  67 }
  68
  69 static void mgmt_index_added(uint16_t len, const void *buf)
  70 {
  71         printf("@ Index Added\n");
  72
  73         packet_hexdump(buf, len);
  74 }
  75
  76 static void mgmt_index_removed(uint16_t len, const void *buf)
  77 {
  78         printf("@ Index Removed\n");
  79
  80         packet_hexdump(buf, len);
  81 }
  82
  83 static void mgmt_unconf_index_added(uint16_t len, const void *buf)
  84 {
  85         printf("@ Unconfigured Index Added\n");
  86
  87         packet_hexdump(buf, len);
  88 }
  89
  90 static void mgmt_unconf_index_removed(uint16_t len, const void *buf)
  91 {
  92         printf("@ Unconfigured Index Removed\n");
  93
  94         packet_hexdump(buf, len);
  95 }
  96
  97 static void mgmt_ext_index_added(uint16_t len, const void *buf)
  98 {
  99         const struct mgmt_ev_ext_index_added *ev = buf;
 100
 101         if (len < sizeof(*ev)) {
 102                 printf("* Malformed Extended Index Added control\n");
 103                 return;
 104         }
 105
 106         printf("@ Extended Index Added: %u (%u)\n", ev->type, ev->bus);
 107
 108         buf += sizeof(*ev);
 109         len -= sizeof(*ev);
 110
 111         packet_hexdump(buf, len);
 112 }
 113
 114 static void mgmt_ext_index_removed(uint16_t len, const void *buf)
 115 {
 116         const struct mgmt_ev_ext_index_removed *ev = buf;
 117
 118         if (len < sizeof(*ev)) {
 119                 printf("* Malformed Extended Index Removed control\n");
 120                 return;
 121         }
 122
 123         printf("@ Extended Index Removed: %u (%u)\n", ev->type, ev->bus);
 124
 125         buf += sizeof(*ev);
 126         len -= sizeof(*ev);
 127
 128         packet_hexdump(buf, len);
 129 }
 130
 131 static void mgmt_controller_error(uint16_t len, const void *buf)
 132 {
 133         const struct mgmt_ev_controller_error *ev = buf;
 134
 135         if (len < sizeof(*ev)) {
 136                 printf("* Malformed Controller Error control\n");
 137                 return;
 138         }
 139
 140         printf("@ Controller Error: 0x%2.2x\n", ev->error_code);
 141
 142         buf += sizeof(*ev);
 143         len -= sizeof(*ev);
 144
 145         packet_hexdump(buf, len);
 146 }
 147
 148 #ifndef NELEM
 149 #define NELEM(x) (sizeof(x) / sizeof((x)[0]))
 150 #endif
 151
 152 static const char *config_options_str[] = {
 153         "external", "public-address",
 154 };
 155
 156 static void mgmt_new_config_options(uint16_t len, const void *buf)
 157 {
 158         uint32_t options;
 159         unsigned int i;
 160
 161         if (len < 4) {
 162                 printf("* Malformed New Configuration Options control\n");
 163                 return;
 164         }
 165
 166         options = get_le32(buf);
 167
 168         printf("@ New Configuration Options: 0x%4.4x\n", options);
 169
 170         if (options) {
 171                 printf("%-12c", ' ');
 172                 for (i = 0; i < NELEM(config_options_str); i++) {
 173                         if (options & (1 << i))
 174                                 printf("%s ", config_options_str[i]);
 175                 }
 176                 printf("\n");
 177         }
 178
 179         buf += 4;
 180         len -= 4;
 181
 182         packet_hexdump(buf, len);
 183 }
 184
 185 static const char *settings_str[] = {
 186         "powered", "connectable", "fast-connectable", "discoverable",
 187         "bondable", "link-security", "ssp", "br/edr", "hs", "le",
 188         "advertising", "secure-conn", "debug-keys", "privacy",
 189         "configuration", "static-addr", "phy", "wbs"
 190 };
 191
 192 static void mgmt_new_settings(uint16_t len, const void *buf)
 193 {
 194         uint32_t settings;
 195         unsigned int i;
 196
 197         if (len < 4) {
 198                 printf("* Malformed New Settings control\n");
 199                 return;
 200         }
 201
 202         settings = get_le32(buf);
 203
 204         printf("@ New Settings: 0x%4.4x\n", settings);
 205
 206         if (settings) {
 207                 printf("%-12c", ' ');
 208                 for (i = 0; i < NELEM(settings_str); i++) {
 209                         if (settings & (1 << i))
 210                                 printf("%s ", settings_str[i]);
 211                 }
 212                 printf("\n");
 213         }
 214
 215         buf += 4;
 216         len -= 4;
 217
 218         packet_hexdump(buf, len);
 219 }
 220
 221 static void mgmt_class_of_dev_changed(uint16_t len, const void *buf)
 222 {
 223         const struct mgmt_ev_class_of_dev_changed *ev = buf;
 224
 225         if (len < sizeof(*ev)) {
 226                 printf("* Malformed Class of Device Changed control\n");
 227                 return;
 228         }
 229
 230         printf("@ Class of Device Changed: 0x%2.2x%2.2x%2.2x\n",
 231                                                 ev->dev_class[2],
 232                                                 ev->dev_class[1],
 233                                                 ev->dev_class[0]);
 234
 235         buf += sizeof(*ev);
 236         len -= sizeof(*ev);
 237
 238         packet_hexdump(buf, len);
 239 }
 240
 241 static void mgmt_local_name_changed(uint16_t len, const void *buf)
 242 {
 243         const struct mgmt_ev_local_name_changed *ev = buf;
 244
 245         if (len < sizeof(*ev)) {
 246                 printf("* Malformed Local Name Changed control\n");
 247                 return;
 248         }
 249
 250         printf("@ Local Name Changed: %s (%s)\n", ev->name, ev->short_name);
 251
 252         buf += sizeof(*ev);
 253         len -= sizeof(*ev);
 254
 255         packet_hexdump(buf, len);
 256 }
 257
 258 static void mgmt_new_link_key(uint16_t len, const void *buf)
 259 {
 260         const struct mgmt_ev_new_link_key *ev = buf;
 261         const char *type;
 262         char str[18];
 263         static const char *types[] = {
 264                 "Combination key",
 265                 "Local Unit key",
 266                 "Remote Unit key",
 267                 "Debug Combination key",
 268                 "Unauthenticated Combination key from P-192",
 269                 "Authenticated Combination key from P-192",
 270                 "Changed Combination key",
 271                 "Unauthenticated Combination key from P-256",
 272                 "Authenticated Combination key from P-256",
 273         };
 274
 275         if (len < sizeof(*ev)) {
 276                 printf("* Malformed New Link Key control\n");
 277                 return;
 278         }
 279
 280         if (ev->key.type < NELEM(types))
 281                 type = types[ev->key.type];
 282         else
 283                 type = "Reserved";
 284
 285         ba2str(&ev->key.addr.bdaddr, str);
 286
 287         printf("@ New Link Key: %s (%d) %s (%u)\n", str,
 288                                 ev->key.addr.type, type, ev->key.type);
 289
 290         buf += sizeof(*ev);
 291         len -= sizeof(*ev);
 292
 293         packet_hexdump(buf, len);
 294 }
 295
 296 static void mgmt_new_long_term_key(uint16_t len, const void *buf)
 297 {
 298         const struct mgmt_ev_new_long_term_key *ev = buf;
 299         const char *type;
 300         char str[18];
 301
 302         if (len < sizeof(*ev)) {
 303                 printf("* Malformed New Long Term Key control\n");
 304                 return;
 305         }
 306
 307         /* LE SC keys are both for central and peripheral */
 308         switch (ev->key.type) {
 309         case 0x00:
 310                 if (ev->key.central)
 311                         type = "Central (Unauthenticated)";
 312                 else
 313                         type = "Peripheral (Unauthenticated)";
 314                 break;
 315         case 0x01:
 316                 if (ev->key.central)
 317                         type = "Central (Authenticated)";
 318                 else
 319                         type = "Peripheral (Authenticated)";
 320                 break;
 321         case 0x02:
 322                 type = "SC (Unauthenticated)";
 323                 break;
 324         case 0x03:
 325                 type = "SC (Authenticated)";
 326                 break;
 327         case 0x04:
 328                 type = "SC (Debug)";
 329                 break;
 330         default:
 331                 type = "<unknown>";
 332                 break;
 333         }
 334
 335         ba2str(&ev->key.addr.bdaddr, str);
 336
 337         printf("@ New Long Term Key: %s (%d) %s 0x%02x\n", str,
 338                         ev->key.addr.type, type, ev->key.type);
 339
 340         buf += sizeof(*ev);
 341         len -= sizeof(*ev);
 342
 343         packet_hexdump(buf, len);
 344 }
 345
 346 static void mgmt_device_connected(uint16_t len, const void *buf)
 347 {
 348         const struct mgmt_ev_device_connected *ev = buf;
 349         uint32_t flags;
 350         char str[18];
 351
 352         if (len < sizeof(*ev)) {
 353                 printf("* Malformed Device Connected control\n");
 354                 return;
 355         }
 356
 357         flags = le32_to_cpu(ev->flags);
 358         ba2str(&ev->addr.bdaddr, str);
 359
 360         printf("@ Device Connected: %s (%d) flags 0x%4.4x\n",
 361                                                 str, ev->addr.type, flags);
 362
 363         buf += sizeof(*ev);
 364         len -= sizeof(*ev);
 365
 366         packet_hexdump(buf, len);
 367 }
 368
 369 static void mgmt_device_disconnected(uint16_t len, const void *buf)
 370 {
 371         const struct mgmt_ev_device_disconnected *ev = buf;
 372         char str[18];
 373         uint8_t reason;
 374         uint16_t consumed_len;
 375
 376         if (len < sizeof(struct mgmt_addr_info)) {
 377                 printf("* Malformed Device Disconnected control\n");
 378                 return;
 379         }
 380
 381         if (len < sizeof(*ev)) {
 382                 reason = MGMT_DEV_DISCONN_UNKNOWN;
 383                 consumed_len = len;
 384         } else {
 385                 reason = ev->reason;
 386                 consumed_len = sizeof(*ev);
 387         }
 388
 389         ba2str(&ev->addr.bdaddr, str);
 390
 391         printf("@ Device Disconnected: %s (%d) reason %u\n", str, ev->addr.type,
 392                                                                         reason);
 393
 394         buf += consumed_len;
 395         len -= consumed_len;
 396
 397         packet_hexdump(buf, len);
 398 }
 399
 400 static void mgmt_connect_failed(uint16_t len, const void *buf)
 401 {
 402         const struct mgmt_ev_connect_failed *ev = buf;
 403         char str[18];
 404
 405         if (len < sizeof(*ev)) {
 406                 printf("* Malformed Connect Failed control\n");
 407                 return;
 408         }
 409
 410         ba2str(&ev->addr.bdaddr, str);
 411
 412         printf("@ Connect Failed: %s (%d) status 0x%2.2x\n",
 413                                         str, ev->addr.type, ev->status);
 414
 415         buf += sizeof(*ev);
 416         len -= sizeof(*ev);
 417
 418         packet_hexdump(buf, len);
 419 }
 420
 421 static void mgmt_pin_code_request(uint16_t len, const void *buf)
 422 {
 423         const struct mgmt_ev_pin_code_request *ev = buf;
 424         char str[18];
 425
 426         if (len < sizeof(*ev)) {
 427                 printf("* Malformed PIN Code Request control\n");
 428                 return;
 429         }
 430
 431         ba2str(&ev->addr.bdaddr, str);
 432
 433         printf("@ PIN Code Request: %s (%d) secure 0x%2.2x\n",
 434                                         str, ev->addr.type, ev->secure);
 435
 436         buf += sizeof(*ev);
 437         len -= sizeof(*ev);
 438
 439         packet_hexdump(buf, len);
 440 }
 441
 442 static void mgmt_user_confirm_request(uint16_t len, const void *buf)
 443 {
 444         const struct mgmt_ev_user_confirm_request *ev = buf;
 445         char str[18];
 446
 447         if (len < sizeof(*ev)) {
 448                 printf("* Malformed User Confirmation Request control\n");
 449                 return;
 450         }
 451
 452         ba2str(&ev->addr.bdaddr, str);
 453
 454         printf("@ User Confirmation Request: %s (%d) hint %d value %d\n",
 455                         str, ev->addr.type, ev->confirm_hint, ev->value);
 456
 457         buf += sizeof(*ev);
 458         len -= sizeof(*ev);
 459
 460         packet_hexdump(buf, len);
 461 }
 462
 463 static void mgmt_user_passkey_request(uint16_t len, const void *buf)
 464 {
 465         const struct mgmt_ev_user_passkey_request *ev = buf;
 466         char str[18];
 467
 468         if (len < sizeof(*ev)) {
 469                 printf("* Malformed User Passkey Request control\n");
 470                 return;
 471         }
 472
 473         ba2str(&ev->addr.bdaddr, str);
 474
 475         printf("@ User Passkey Request: %s (%d)\n", str, ev->addr.type);
 476
 477         buf += sizeof(*ev);
 478         len -= sizeof(*ev);
 479
 480         packet_hexdump(buf, len);
 481 }
 482
 483 static void mgmt_auth_failed(uint16_t len, const void *buf)
 484 {
 485         const struct mgmt_ev_auth_failed *ev = buf;
 486         char str[18];
 487
 488         if (len < sizeof(*ev)) {
 489                 printf("* Malformed Authentication Failed control\n");
 490                 return;
 491         }
 492
 493         ba2str(&ev->addr.bdaddr, str);
 494
 495         printf("@ Authentication Failed: %s (%d) status 0x%2.2x\n",
 496                                         str, ev->addr.type, ev->status);
 497
 498         buf += sizeof(*ev);
 499         len -= sizeof(*ev);
 500
 501         packet_hexdump(buf, len);
 502 }
 503
 504 static void mgmt_device_found(uint16_t len, const void *buf)
 505 {
 506         const struct mgmt_ev_device_found *ev = buf;
 507         uint32_t flags;
 508         char str[18];
 509
 510         if (len < sizeof(*ev)) {
 511                 printf("* Malformed Device Found control\n");
 512                 return;
 513         }
 514
 515         flags = le32_to_cpu(ev->flags);
 516         ba2str(&ev->addr.bdaddr, str);
 517
 518         printf("@ Device Found: %s (%d) rssi %d flags 0x%4.4x\n",
 519                                         str, ev->addr.type, ev->rssi, flags);
 520
 521         buf += sizeof(*ev);
 522         len -= sizeof(*ev);
 523
 524         packet_hexdump(buf, len);
 525 }
 526
 527 static void mgmt_discovering(uint16_t len, const void *buf)
 528 {
 529         const struct mgmt_ev_discovering *ev = buf;
 530
 531         if (len < sizeof(*ev)) {
 532                 printf("* Malformed Discovering control\n");
 533                 return;
 534         }
 535
 536         printf("@ Discovering: 0x%2.2x (%d)\n", ev->discovering, ev->type);
 537
 538         buf += sizeof(*ev);
 539         len -= sizeof(*ev);
 540
 541         packet_hexdump(buf, len);
 542 }
 543
 544 static void mgmt_device_blocked(uint16_t len, const void *buf)
 545 {
 546         const struct mgmt_ev_device_blocked *ev = buf;
 547         char str[18];
 548
 549         if (len < sizeof(*ev)) {
 550                 printf("* Malformed Device Blocked control\n");
 551                 return;
 552         }
 553
 554         ba2str(&ev->addr.bdaddr, str);
 555
 556         printf("@ Device Blocked: %s (%d)\n", str, ev->addr.type);
 557
 558         buf += sizeof(*ev);
 559         len -= sizeof(*ev);
 560
 561         packet_hexdump(buf, len);
 562 }
 563
 564 static void mgmt_device_unblocked(uint16_t len, const void *buf)
 565 {
 566         const struct mgmt_ev_device_unblocked *ev = buf;
 567         char str[18];
 568
 569         if (len < sizeof(*ev)) {
 570                 printf("* Malformed Device Unblocked control\n");
 571                 return;
 572         }
 573
 574         ba2str(&ev->addr.bdaddr, str);
 575
 576         printf("@ Device Unblocked: %s (%d)\n", str, ev->addr.type);
 577
 578         buf += sizeof(*ev);
 579         len -= sizeof(*ev);
 580
 581         packet_hexdump(buf, len);
 582 }
 583
 584 static void mgmt_device_unpaired(uint16_t len, const void *buf)
 585 {
 586         const struct mgmt_ev_device_unpaired *ev = buf;
 587         char str[18];
 588
 589         if (len < sizeof(*ev)) {
 590                 printf("* Malformed Device Unpaired control\n");
 591                 return;
 592         }
 593
 594         ba2str(&ev->addr.bdaddr, str);
 595
 596         printf("@ Device Unpaired: %s (%d)\n", str, ev->addr.type);
 597
 598         buf += sizeof(*ev);
 599         len -= sizeof(*ev);
 600
 601         packet_hexdump(buf, len);
 602 }
 603
 604 static void mgmt_passkey_notify(uint16_t len, const void *buf)
 605 {
 606         const struct mgmt_ev_passkey_notify *ev = buf;
 607         uint32_t passkey;
 608         char str[18];
 609
 610         if (len < sizeof(*ev)) {
 611                 printf("* Malformed Passkey Notify control\n");
 612                 return;
 613         }
 614
 615         ba2str(&ev->addr.bdaddr, str);
 616
 617         passkey = le32_to_cpu(ev->passkey);
 618
 619         printf("@ Passkey Notify: %s (%d) passkey %06u entered %u\n",
 620                                 str, ev->addr.type, passkey, ev->entered);
 621
 622         buf += sizeof(*ev);
 623         len -= sizeof(*ev);
 624
 625         packet_hexdump(buf, len);
 626 }
 627
 628 static void mgmt_new_irk(uint16_t len, const void *buf)
 629 {
 630         const struct mgmt_ev_new_irk *ev = buf;
 631         char addr[18], rpa[18];
 632
 633         if (len < sizeof(*ev)) {
 634                 printf("* Malformed New IRK control\n");
 635                 return;
 636         }
 637
 638         ba2str(&ev->rpa, rpa);
 639         ba2str(&ev->key.addr.bdaddr, addr);
 640
 641         printf("@ New IRK: %s (%d) %s\n", addr, ev->key.addr.type, rpa);
 642
 643         buf += sizeof(*ev);
 644         len -= sizeof(*ev);
 645
 646         packet_hexdump(buf, len);
 647 }
 648
 649 static void mgmt_new_csrk(uint16_t len, const void *buf)
 650 {
 651         const struct mgmt_ev_new_csrk *ev = buf;
 652         const char *type;
 653         char addr[18];
 654
 655         if (len < sizeof(*ev)) {
 656                 printf("* Malformed New CSRK control\n");
 657                 return;
 658         }
 659
 660         ba2str(&ev->key.addr.bdaddr, addr);
 661
 662         switch (ev->key.type) {
 663         case 0x00:
 664                 type = "Local Unauthenticated";
 665                 break;
 666         case 0x01:
 667                 type = "Remote Unauthenticated";
 668                 break;
 669         case 0x02:
 670                 type = "Local Authenticated";
 671                 break;
 672         case 0x03:
 673                 type = "Remote Authenticated";
 674                 break;
 675         default:
 676                 type = "<unknown>";
 677                 break;
 678         }
 679
 680         printf("@ New CSRK: %s (%d) %s (%u)\n", addr, ev->key.addr.type,
 681                                                         type, ev->key.type);
 682
 683         buf += sizeof(*ev);
 684         len -= sizeof(*ev);
 685
 686         packet_hexdump(buf, len);
 687 }
 688
 689 static void mgmt_device_added(uint16_t len, const void *buf)
 690 {
 691         const struct mgmt_ev_device_added *ev = buf;
 692         char str[18];
 693
 694         if (len < sizeof(*ev)) {
 695                 printf("* Malformed Device Added control\n");
 696                 return;
 697         }
 698
 699         ba2str(&ev->addr.bdaddr, str);
 700
 701         printf("@ Device Added: %s (%d) %d\n", str, ev->addr.type, ev->action);
 702
 703         buf += sizeof(*ev);
 704         len -= sizeof(*ev);
 705
 706         packet_hexdump(buf, len);
 707 }
 708
 709 static void mgmt_device_removed(uint16_t len, const void *buf)
 710 {
 711         const struct mgmt_ev_device_removed *ev = buf;
 712         char str[18];
 713
 714         if (len < sizeof(*ev)) {
 715                 printf("* Malformed Device Removed control\n");
 716                 return;
 717         }
 718
 719         ba2str(&ev->addr.bdaddr, str);
 720
 721         printf("@ Device Removed: %s (%d)\n", str, ev->addr.type);
 722
 723         buf += sizeof(*ev);
 724         len -= sizeof(*ev);
 725
 726         packet_hexdump(buf, len);
 727 }
 728
 729 static void mgmt_new_conn_param(uint16_t len, const void *buf)
 730 {
 731         const struct mgmt_ev_new_conn_param *ev = buf;
 732         char addr[18];
 733         uint16_t min, max, latency, timeout;
 734
 735         if (len < sizeof(*ev)) {
 736                 printf("* Malformed New Connection Parameter control\n");
 737                 return;
 738         }
 739
 740         ba2str(&ev->addr.bdaddr, addr);
 741         min = le16_to_cpu(ev->min_interval);
 742         max = le16_to_cpu(ev->max_interval);
 743         latency = le16_to_cpu(ev->latency);
 744         timeout = le16_to_cpu(ev->timeout);
 745
 746         printf("@ New Conn Param: %s (%d) hint %d min 0x%4.4x max 0x%4.4x "
 747                 "latency 0x%4.4x timeout 0x%4.4x\n", addr, ev->addr.type,
 748                 ev->store_hint, min, max, latency, timeout);
 749
 750         buf += sizeof(*ev);
 751         len -= sizeof(*ev);
 752
 753         packet_hexdump(buf, len);
 754 }
 755
 756 static void mgmt_advertising_added(uint16_t len, const void *buf)
 757 {
 758         const struct mgmt_ev_advertising_added *ev = buf;
 759
 760         if (len < sizeof(*ev)) {
 761                 printf("* Malformed Advertising Added control\n");
 762                 return;
 763         }
 764
 765         printf("@ Advertising Added: %u\n", ev->instance);
 766
 767         buf += sizeof(*ev);
 768         len -= sizeof(*ev);
 769
 770         packet_hexdump(buf, len);
 771 }
 772
 773 static void mgmt_advertising_removed(uint16_t len, const void *buf)
 774 {
 775         const struct mgmt_ev_advertising_removed *ev = buf;
 776
 777         if (len < sizeof(*ev)) {
 778                 printf("* Malformed Advertising Removed control\n");
 779                 return;
 780         }
 781
 782         printf("@ Advertising Removed: %u\n", ev->instance);
 783
 784         buf += sizeof(*ev);
 785         len -= sizeof(*ev);
 786
 787         packet_hexdump(buf, len);
 788 }
 789
 790 void control_message(uint16_t opcode, const void *data, uint16_t size)
 791 {
 792         if (!decode_control)
 793                 return;
 794
 795         switch (opcode) {
 796         case MGMT_EV_INDEX_ADDED:
 797                 mgmt_index_added(size, data);
 798                 break;
 799         case MGMT_EV_INDEX_REMOVED:
 800                 mgmt_index_removed(size, data);
 801                 break;
 802         case MGMT_EV_CONTROLLER_ERROR:
 803                 mgmt_controller_error(size, data);
 804                 break;
 805         case MGMT_EV_NEW_SETTINGS:
 806                 mgmt_new_settings(size, data);
 807                 break;
 808         case MGMT_EV_CLASS_OF_DEV_CHANGED:
 809                 mgmt_class_of_dev_changed(size, data);
 810                 break;
 811         case MGMT_EV_LOCAL_NAME_CHANGED:
 812                 mgmt_local_name_changed(size, data);
 813                 break;
 814         case MGMT_EV_NEW_LINK_KEY:
 815                 mgmt_new_link_key(size, data);
 816                 break;
 817         case MGMT_EV_NEW_LONG_TERM_KEY:
 818                 mgmt_new_long_term_key(size, data);
 819                 break;
 820         case MGMT_EV_DEVICE_CONNECTED:
 821                 mgmt_device_connected(size, data);
 822                 break;
 823         case MGMT_EV_DEVICE_DISCONNECTED:
 824                 mgmt_device_disconnected(size, data);
 825                 break;
 826         case MGMT_EV_CONNECT_FAILED:
 827                 mgmt_connect_failed(size, data);
 828                 break;
 829         case MGMT_EV_PIN_CODE_REQUEST:
 830                 mgmt_pin_code_request(size, data);
 831                 break;
 832         case MGMT_EV_USER_CONFIRM_REQUEST:
 833                 mgmt_user_confirm_request(size, data);
 834                 break;
 835         case MGMT_EV_USER_PASSKEY_REQUEST:
 836                 mgmt_user_passkey_request(size, data);
 837                 break;
 838         case MGMT_EV_AUTH_FAILED:
 839                 mgmt_auth_failed(size, data);
 840                 break;
 841         case MGMT_EV_DEVICE_FOUND:
 842                 mgmt_device_found(size, data);
 843                 break;
 844         case MGMT_EV_DISCOVERING:
 845                 mgmt_discovering(size, data);
 846                 break;
 847         case MGMT_EV_DEVICE_BLOCKED:
 848                 mgmt_device_blocked(size, data);
 849                 break;
 850         case MGMT_EV_DEVICE_UNBLOCKED:
 851                 mgmt_device_unblocked(size, data);
 852                 break;
 853         case MGMT_EV_DEVICE_UNPAIRED:
 854                 mgmt_device_unpaired(size, data);
 855                 break;
 856         case MGMT_EV_PASSKEY_NOTIFY:
 857                 mgmt_passkey_notify(size, data);
 858                 break;
 859         case MGMT_EV_NEW_IRK:
 860                 mgmt_new_irk(size, data);
 861                 break;
 862         case MGMT_EV_NEW_CSRK:
 863                 mgmt_new_csrk(size, data);
 864                 break;
 865         case MGMT_EV_DEVICE_ADDED:
 866                 mgmt_device_added(size, data);
 867                 break;
 868         case MGMT_EV_DEVICE_REMOVED:
 869                 mgmt_device_removed(size, data);
 870                 break;
 871         case MGMT_EV_NEW_CONN_PARAM:
 872                 mgmt_new_conn_param(size, data);
 873                 break;
 874         case MGMT_EV_UNCONF_INDEX_ADDED:
 875                 mgmt_unconf_index_added(size, data);
 876                 break;
 877         case MGMT_EV_UNCONF_INDEX_REMOVED:
 878                 mgmt_unconf_index_removed(size, data);
 879                 break;
 880         case MGMT_EV_NEW_CONFIG_OPTIONS:
 881                 mgmt_new_config_options(size, data);
 882                 break;
 883         case MGMT_EV_EXT_INDEX_ADDED:
 884                 mgmt_ext_index_added(size, data);
 885                 break;
 886         case MGMT_EV_EXT_INDEX_REMOVED:
 887                 mgmt_ext_index_removed(size, data);
 888                 break;
 889         case MGMT_EV_ADVERTISING_ADDED:
 890                 mgmt_advertising_added(size, data);
 891                 break;
 892         case MGMT_EV_ADVERTISING_REMOVED:
 893                 mgmt_advertising_removed(size, data);
 894                 break;
 895         default:
 896                 printf("* Unknown control (code %d len %d)\n", opcode, size);
 897                 packet_hexdump(data, size);
 898                 break;
 899         }
 900 }
 901
 902 static void data_callback(int fd, uint32_t events, void *user_data)
 903 {
 904         struct control_data *data = user_data;
 905         unsigned char control[64];
 906         struct mgmt_hdr hdr;
 907         struct msghdr msg;
 908         struct iovec iov[2];
 909
 910         if (events & (EPOLLERR | EPOLLHUP)) {
 911                 mainloop_remove_fd(data->fd);
 912                 return;
 913         }
 914
 915         iov[0].iov_base = &hdr;
 916         iov[0].iov_len = MGMT_HDR_SIZE;
 917         iov[1].iov_base = data->buf;
 918         iov[1].iov_len = sizeof(data->buf);
 919
 920         memset(&msg, 0, sizeof(msg));
 921         msg.msg_iov = iov;
 922         msg.msg_iovlen = 2;
 923         msg.msg_control = control;
 924         msg.msg_controllen = sizeof(control);
 925
 926         while (1) {
 927                 struct cmsghdr *cmsg;
 928                 struct timeval *tv = NULL;
 929                 struct timeval ctv;
 930                 struct ucred *cred = NULL;
 931                 struct ucred ccred;
 932                 uint16_t opcode, index, pktlen;
 933                 ssize_t len;
 934
 935                 len = recvmsg(data->fd, &msg, MSG_DONTWAIT);
 936                 if (len < 0)
 937                         break;
 938
 939                 if (len < MGMT_HDR_SIZE)
 940                         break;
 941
 942                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
 943                                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 944                         if (cmsg->cmsg_level != SOL_SOCKET)
 945                                 continue;
 946
 947                         if (cmsg->cmsg_type == SCM_TIMESTAMP) {
 948                                 memcpy(&ctv, CMSG_DATA(cmsg), sizeof(ctv));
 949                                 tv = &ctv;
 950                         }
 951
 952                         if (cmsg->cmsg_type == SCM_CREDENTIALS) {
 953                                 memcpy(&ccred, CMSG_DATA(cmsg), sizeof(ccred));
 954                                 cred = &ccred;
 955                         }
 956                 }
 957
 958                 opcode = le16_to_cpu(hdr.opcode);
 959                 index  = le16_to_cpu(hdr.index);
 960                 pktlen = le16_to_cpu(hdr.len);
 961
 962                 switch (data->channel) {
 963                 case HCI_CHANNEL_CONTROL:
 964                         packet_control(tv, cred, index, opcode,
 965                                                         data->buf, pktlen);
 966                         break;
 967                 case HCI_CHANNEL_MONITOR:
 968                         btsnoop_write_hci(btsnoop_file, tv, index, opcode, 0,
 969                                                         data->buf, pktlen);
 970                         ellisys_inject_hci(tv, index, opcode,
 971                                                         data->buf, pktlen);
 972                         packet_monitor(tv, cred, index, opcode,
 973                                                         data->buf, pktlen);
 974                         break;
 975                 }
 976         }
 977 }
 978
 979 static int open_socket(uint16_t channel)
 980 {
 981         struct sockaddr_hci addr;
 982         int fd, opt = 1;
 983
 984         fd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
 985         if (fd < 0) {
 986                 perror("Failed to open channel");
 987                 return -1;
 988         }
 989
 990         memset(&addr, 0, sizeof(addr));
 991         addr.hci_family = AF_BLUETOOTH;
 992         addr.hci_dev = HCI_DEV_NONE;
 993         addr.hci_channel = channel;
 994
 995         if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 996                 if (errno == EINVAL) {
 997                         /* Fallback to hcidump support */
 998                         hcidump_fallback = true;
 999                         close(fd);
1000                         return -1;
1001                 }
1002                 perror("Failed to bind channel");
1003                 close(fd);
1004                 return -1;
1005         }
1006
1007         if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP, &opt, sizeof(opt)) < 0) {
1008                 perror("Failed to enable timestamps");
1009                 close(fd);
1010                 return -1;
1011         }
1012
1013         if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt)) < 0) {
1014                 perror("Failed to enable credentials");
1015                 close(fd);
1016                 return -1;
1017         }
1018
1019         return fd;
1020 }
1021
1022 static void attach_index_filter(int fd, uint16_t index)
1023 {
1024         struct sock_filter filters[] = {
1025                 /* Load MGMT index:
1026                  * A <- MGMT index
1027                  */
1028                 BPF_STMT(BPF_LD + BPF_B + BPF_ABS,
1029                                         offsetof(struct mgmt_hdr, index)),
1030                 /* Accept if index is HCI_DEV_NONE:
1031                  * A == HCI_DEV_NONE
1032                  */
1033                 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, HCI_DEV_NONE, 0, 1),
1034                 /* return */
1035                 BPF_STMT(BPF_RET|BPF_K, 0x0fffffff), /* pass */
1036                 /* Accept if index match:
1037                  * A == index
1038                  */
1039                 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, index, 0, 1),
1040                 /* returns */
1041                 BPF_STMT(BPF_RET|BPF_K, 0x0fffffff), /* pass */
1042                 BPF_STMT(BPF_RET|BPF_K, 0), /* reject */
1043         };
1044         struct sock_fprog fprog = {
1045                 .len = sizeof(filters) / sizeof(filters[0]),
1046                 /* casting const away: */
1047                 .filter = filters,
1048         };
1049
1050         setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &fprog, sizeof(fprog));
1051 }
1052
1053 static int open_channel(uint16_t channel)
1054 {
1055         struct control_data *data;
1056
1057         data = malloc(sizeof(*data));
1058         if (!data)
1059                 return -1;
1060
1061         memset(data, 0, sizeof(*data));
1062         data->channel = channel;
1063
1064         data->fd = open_socket(channel);
1065         if (data->fd < 0) {
1066                 free(data);
1067                 return -1;
1068         }
1069
1070         if (filter_index != HCI_DEV_NONE)
1071                 attach_index_filter(data->fd, filter_index);
1072
1073         if (mainloop_add_fd(data->fd, EPOLLIN, data_callback,
1074                                                 data, free_data) < 0) {
1075                 close(data->fd);
1076                 free(data);
1077                 return -1;
1078         };
1079
1080         return 0;
1081 }
1082
1083 static void client_callback(int fd, uint32_t events, void *user_data)
1084 {
1085         struct control_data *data = user_data;
1086         ssize_t len;
1087
1088         if (events & (EPOLLERR | EPOLLHUP)) {
1089                 mainloop_remove_fd(data->fd);
1090                 return;
1091         }
1092
1093         len = recv(data->fd, data->buf + data->offset,
1094                         sizeof(data->buf) - data->offset, MSG_DONTWAIT);
1095         if (len < 0)
1096                 return;
1097
1098         data->offset += len;
1099
1100         while (data->offset >= MGMT_HDR_SIZE) {
1101                 struct mgmt_hdr *hdr = (struct mgmt_hdr *) data->buf;
1102                 uint16_t pktlen = le16_to_cpu(hdr->len);
1103                 uint16_t opcode, index;
1104
1105                 if (data->offset < pktlen + MGMT_HDR_SIZE)
1106                         return;
1107
1108                 opcode = le16_to_cpu(hdr->opcode);
1109                 index = le16_to_cpu(hdr->index);
1110
1111                 packet_monitor(NULL, NULL, index, opcode,
1112                                         data->buf + MGMT_HDR_SIZE, pktlen);
1113
1114                 data->offset -= pktlen + MGMT_HDR_SIZE;
1115
1116                 if (data->offset > 0)
1117                         memmove(data->buf, data->buf + MGMT_HDR_SIZE + pktlen,
1118                                                                 data->offset);
1119         }
1120 }
1121
1122 static void server_accept_callback(int fd, uint32_t events, void *user_data)
1123 {
1124         struct control_data *data;
1125         struct sockaddr_un addr;
1126         socklen_t len;
1127         int nfd;
1128
1129         if (events & (EPOLLERR | EPOLLHUP)) {
1130                 mainloop_remove_fd(fd);
1131                 return;
1132         }
1133
1134         memset(&addr, 0, sizeof(addr));
1135         len = sizeof(addr);
1136
1137         nfd = accept(fd, (struct sockaddr *) &addr, &len);
1138         if (nfd < 0) {
1139                 perror("Failed to accept client socket");
1140                 return;
1141         }
1142
1143         printf("--- New monitor connection ---\n");
1144
1145         data = malloc(sizeof(*data));
1146         if (!data) {
1147                 close(nfd);
1148                 return;
1149         }
1150
1151         memset(data, 0, sizeof(*data));
1152         data->channel = HCI_CHANNEL_MONITOR;
1153         data->fd = nfd;
1154
1155         if (mainloop_add_fd(data->fd, EPOLLIN, client_callback,
1156                                                 data, free_data) < 0) {
1157                 close(data->fd);
1158                 free(data);
1159         }
1160 }
1161
1162 static int server_fd = -1;
1163
1164 void control_server(const char *path)
1165 {
1166         struct sockaddr_un addr;
1167         int fd;
1168
1169         if (server_fd >= 0)
1170                 return;
1171
1172         if (strlen(path) > sizeof(addr.sun_path) - 1) {
1173                 fprintf(stderr, "Socket name too long\n");
1174                 return;
1175         }
1176
1177         unlink(path);
1178
1179         fd = socket(PF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
1180         if (fd < 0) {
1181                 perror("Failed to open server socket");
1182                 return;
1183         }
1184
1185         memset(&addr, 0, sizeof(addr));
1186         addr.sun_family = AF_UNIX;
1187         strcpy(addr.sun_path, path);
1188
1189         if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1190                 perror("Failed to bind server socket");
1191                 close(fd);
1192                 return;
1193         }
1194
1195         if (listen(fd, 5) < 0) {
1196                 perror("Failed to listen server socket");
1197                 close(fd);
1198                 return;
1199         }
1200
1201         if (mainloop_add_fd(fd, EPOLLIN, server_accept_callback,
1202                                                 NULL, NULL) < 0) {
1203                 close(fd);
1204                 return;
1205         }
1206
1207         server_fd = fd;
1208 }
1209
1210 static bool parse_drops(uint8_t **data, uint8_t *len, uint8_t *drops,
1211                                                         uint32_t *total)
1212 {
1213         if (*len < 1)
1214                 return false;
1215
1216         *drops = **data;
1217         *total += *drops;
1218         (*data)++;
1219         (*len)--;
1220
1221         return true;
1222 }
1223
1224 static bool tty_parse_header(uint8_t *hdr, uint8_t len, struct timeval **tv,
1225                                 struct timeval *ctv, uint32_t *drops)
1226 {
1227         uint8_t cmd = 0;
1228         uint8_t evt = 0;
1229         uint8_t acl_tx = 0;
1230         uint8_t acl_rx = 0;
1231         uint8_t sco_tx = 0;
1232         uint8_t sco_rx = 0;
1233         uint8_t other = 0;
1234         uint32_t total = 0;
1235         uint32_t ts32;
1236
1237         while (len) {
1238                 uint8_t type = hdr[0];
1239
1240                 hdr++; len--;
1241
1242                 switch (type) {
1243                 case TTY_EXTHDR_COMMAND_DROPS:
1244                         if (!parse_drops(&hdr, &len, &cmd, &total))
1245                                 return false;
1246                         break;
1247                 case TTY_EXTHDR_EVENT_DROPS:
1248                         if (!parse_drops(&hdr, &len, &evt, &total))
1249                                 return false;
1250                         break;
1251                 case TTY_EXTHDR_ACL_TX_DROPS:
1252                         if (!parse_drops(&hdr, &len, &acl_tx, &total))
1253                                 return false;
1254                         break;
1255                 case TTY_EXTHDR_ACL_RX_DROPS:
1256                         if (!parse_drops(&hdr, &len, &acl_rx, &total))
1257                                 return false;
1258                         break;
1259                 case TTY_EXTHDR_SCO_TX_DROPS:
1260                         if (!parse_drops(&hdr, &len, &sco_tx, &total))
1261                                 return false;
1262                         break;
1263                 case TTY_EXTHDR_SCO_RX_DROPS:
1264                         if (!parse_drops(&hdr, &len, &sco_rx, &total))
1265                                 return false;
1266                         break;
1267                 case TTY_EXTHDR_OTHER_DROPS:
1268                         if (!parse_drops(&hdr, &len, &other, &total))
1269                                 return false;
1270                         break;
1271                 case TTY_EXTHDR_TS32:
1272                         if (len < sizeof(ts32))
1273                                 return false;
1274                         ts32 = get_le32(hdr);
1275                         hdr += sizeof(ts32); len -= sizeof(ts32);
1276                         /* ts32 is in units of 1/10th of a millisecond */
1277                         ctv->tv_sec = ts32 / 10000;
1278                         ctv->tv_usec = (ts32 % 10000) * 100;
1279                         *tv = ctv;
1280                         break;
1281                 default:
1282                         printf("Unknown extended header type %u\n", type);
1283                         return false;
1284                 }
1285         }
1286
1287         if (total) {
1288                 *drops += total;
1289                 printf("* Drops: cmd %u evt %u acl_tx %u acl_rx %u sco_tx %u "
1290                         "sco_rx %u other %u\n", cmd, evt, acl_tx, acl_rx,
1291                         sco_tx, sco_rx, other);
1292         }
1293
1294         return true;
1295 }
1296
1297 static void process_data(struct control_data *data)
1298 {
1299         while (data->offset >= sizeof(struct tty_hdr)) {
1300                 struct tty_hdr *hdr = (struct tty_hdr *) data->buf;
1301                 uint16_t pktlen, opcode, data_len;
1302                 struct timeval *tv = NULL;
1303                 struct timeval ctv;
1304                 uint32_t drops = 0;
1305
1306                 data_len = le16_to_cpu(hdr->data_len);
1307
1308                 if (data->offset < 2 + data_len)
1309                         return;
1310
1311                 if (data->offset < sizeof(*hdr) + hdr->hdr_len) {
1312                         fprintf(stderr, "Received corrupted data from TTY\n");
1313                         memmove(data->buf, data->buf + 2 + data_len,
1314                                                                 data->offset);
1315                         return;
1316                 }
1317
1318                 if (!tty_parse_header(hdr->ext_hdr, hdr->hdr_len,
1319                                                         &tv, &ctv, &drops))
1320                         fprintf(stderr, "Unable to parse extended header\n");
1321
1322                 opcode = le16_to_cpu(hdr->opcode);
1323                 pktlen = data_len - 4 - hdr->hdr_len;
1324
1325                 btsnoop_write_hci(btsnoop_file, tv, 0, opcode, drops,
1326                                         hdr->ext_hdr + hdr->hdr_len, pktlen);
1327                 ellisys_inject_hci(tv, 0, opcode, hdr->ext_hdr + hdr->hdr_len,
1328                                         pktlen);
1329                 packet_monitor(tv, NULL, 0, opcode,
1330                                         hdr->ext_hdr + hdr->hdr_len, pktlen);
1331
1332                 data->offset -= 2 + data_len;
1333
1334                 if (data->offset > 0)
1335                         memmove(data->buf, data->buf + 2 + data_len,
1336                                                                 data->offset);
1337         }
1338 }
1339
1340 static void tty_callback(int fd, uint32_t events, void *user_data)
1341 {
1342         struct control_data *data = user_data;
1343         ssize_t len;
1344
1345         if (events & (EPOLLERR | EPOLLHUP)) {
1346                 mainloop_remove_fd(data->fd);
1347                 return;
1348         }
1349
1350         len = read(data->fd, data->buf + data->offset,
1351                                         sizeof(data->buf) - data->offset);
1352         if (len < 0)
1353                 return;
1354
1355         data->offset += len;
1356
1357         process_data(data);
1358 }
1359
1360 int control_tty(const char *path, unsigned int speed)
1361 {
1362         struct control_data *data;
1363         struct termios ti;
1364         int fd, err;
1365
1366         fd = open(path, O_RDWR | O_NOCTTY | O_NONBLOCK);
1367         if (fd < 0) {
1368                 err = -errno;
1369                 perror("Failed to open serial port");
1370                 return err;
1371         }
1372
1373         if (tcflush(fd, TCIOFLUSH) < 0) {
1374                 err = -errno;
1375                 perror("Failed to flush serial port");
1376                 close(fd);
1377                 return err;
1378         }
1379
1380         memset(&ti, 0, sizeof(ti));
1381         /* Switch TTY to raw mode */
1382         cfmakeraw(&ti);
1383
1384         ti.c_cflag |= (CLOCAL | CREAD);
1385         ti.c_cflag &= ~CRTSCTS;
1386
1387         cfsetspeed(&ti, speed);
1388
1389         if (tcsetattr(fd, TCSANOW, &ti) < 0) {
1390                 err = -errno;
1391                 perror("Failed to set serial port settings");
1392                 close(fd);
1393                 return err;
1394         }
1395
1396         printf("--- %s opened ---\n", path);
1397
1398         data = malloc(sizeof(*data));
1399         if (!data) {
1400                 close(fd);
1401                 return -ENOMEM;
1402         }
1403
1404         memset(data, 0, sizeof(*data));
1405         data->channel = HCI_CHANNEL_MONITOR;
1406         data->fd = fd;
1407
1408         if (mainloop_add_fd(data->fd, EPOLLIN, tty_callback,
1409                                                 data, free_data) < 0) {
1410                 close(data->fd);
1411                 free(data);
1412                 return -1;
1413         }
1414
1415         return 0;
1416 }
1417
1418 static void rtt_callback(int id, void *user_data)
1419 {
1420         struct control_data *data = user_data;
1421         ssize_t len;
1422
1423         do {
1424                 len = jlink_rtt_read(data->buf + data->offset,
1425                                 sizeof(data->buf) - data->offset);
1426                 data->offset += len;
1427                 process_data(data);
1428         } while (len > 0);
1429
1430         if (mainloop_modify_timeout(id, 1) < 0)
1431                 mainloop_exit_failure();
1432 }
1433
1434 int control_rtt(char *jlink, char *rtt)
1435 {
1436         struct control_data *data;
1437
1438         if (jlink_init() < 0) {
1439                 fprintf(stderr, "Failed to initialize J-Link library\n");
1440                 return -EIO;
1441         }
1442
1443         if (jlink_connect(jlink) < 0) {
1444                 fprintf(stderr, "Failed to connect to target device\n");
1445                 return -ENODEV;
1446         }
1447
1448         if (jlink_start_rtt(rtt) < 0) {
1449                 fprintf(stderr, "Failed to initialize RTT\n");
1450                 return -ENODEV;
1451         }
1452
1453         printf("--- RTT opened ---\n");
1454
1455         data = new0(struct control_data, 1);
1456         data->channel = HCI_CHANNEL_MONITOR;
1457         data->fd = -1;
1458
1459         if (mainloop_add_timeout(1, rtt_callback, data, free_data) < 0) {
1460                 free(data);
1461                 return -EIO;
1462         }
1463
1464         return 0;
1465 }
1466
1467 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1468 bool control_writer(const char *path, int16_t rotate_count, ssize_t file_size)
1469 #else
1470 bool control_writer(const char *path)
1471 #endif
1472 {
1473 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1474         btsnoop_file = btsnoop_create(path, BTSNOOP_FORMAT_MONITOR,
1475                         rotate_count, file_size);
1476 #else
1477         btsnoop_file = btsnoop_create(path, 0, 0, BTSNOOP_FORMAT_MONITOR);
1478 #endif
1479
1480         return !!btsnoop_file;
1481 }
1482
1483 void control_reader(const char *path, bool pager)
1484 {
1485         unsigned char buf[BTSNOOP_MAX_PACKET_SIZE];
1486         uint16_t pktlen;
1487         uint32_t format;
1488         struct timeval tv;
1489
1490         btsnoop_file = btsnoop_open(path, BTSNOOP_FLAG_PKLG_SUPPORT);
1491         if (!btsnoop_file)
1492                 return;
1493
1494         format = btsnoop_get_format(btsnoop_file);
1495
1496         switch (format) {
1497         case BTSNOOP_FORMAT_HCI:
1498         case BTSNOOP_FORMAT_UART:
1499         case BTSNOOP_FORMAT_SIMULATOR:
1500                 packet_del_filter(PACKET_FILTER_SHOW_INDEX);
1501                 break;
1502
1503         case BTSNOOP_FORMAT_MONITOR:
1504                 packet_add_filter(PACKET_FILTER_SHOW_INDEX);
1505                 break;
1506         }
1507
1508 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1509         setenv("PAGER", "cat", 0);
1510 #endif
1511         if (pager)
1512                 open_pager();
1513
1514         switch (format) {
1515         case BTSNOOP_FORMAT_HCI:
1516         case BTSNOOP_FORMAT_UART:
1517         case BTSNOOP_FORMAT_MONITOR:
1518                 while (1) {
1519                         uint16_t index, opcode;
1520
1521                         if (!btsnoop_read_hci(btsnoop_file, &tv, &index,
1522                                                         &opcode, buf, &pktlen))
1523                                 break;
1524
1525                         if (opcode == 0xffff)
1526                                 continue;
1527
1528                         packet_monitor(&tv, NULL, index, opcode, buf, pktlen);
1529                         ellisys_inject_hci(&tv, index, opcode, buf, pktlen);
1530                 }
1531                 break;
1532
1533         case BTSNOOP_FORMAT_SIMULATOR:
1534                 while (1) {
1535                         uint16_t frequency;
1536
1537                         if (!btsnoop_read_phy(btsnoop_file, &tv, &frequency,
1538                                                                 buf, &pktlen))
1539                                 break;
1540
1541                         packet_simulator(&tv, frequency, buf, pktlen);
1542                 }
1543                 break;
1544         }
1545
1546         if (pager)
1547                 close_pager();
1548
1549         btsnoop_unref(btsnoop_file);
1550 }
1551
1552 int control_tracing(void)
1553 {
1554         packet_add_filter(PACKET_FILTER_SHOW_INDEX);
1555
1556         if (server_fd >= 0)
1557                 return 0;
1558
1559         if (open_channel(HCI_CHANNEL_MONITOR) < 0) {
1560                 if (!hcidump_fallback)
1561                         return -1;
1562                 if (hcidump_tracing() < 0)
1563                         return -1;
1564                 return 0;
1565         }
1566
1567         if (packet_has_filter(PACKET_FILTER_SHOW_MGMT_SOCKET))
1568                 open_channel(HCI_CHANNEL_CONTROL);
1569
1570         return 0;
1571 }
1572
1573 void control_disable_decoding(void)
1574 {
1575         decode_control = false;
1576 }
1577
1578 void control_filter_index(uint16_t index)
1579 {
1580         filter_index = index;
1581 }