tools/parser/hci.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2000-2002  Maxim Krasnyansky <maxk@qualcomm.com>
   6  *  Copyright (C) 2003-2011  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <ctype.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #include "parser.h"
  37 #include "lib/hci.h"
  38 #include "lib/hci_lib.h"
  39 #include "lib/amp.h"
  40
  41 static uint16_t manufacturer = DEFAULT_COMPID;
  42
  43 static inline uint16_t get_manufacturer(void)
  44 {
  45         return (manufacturer == DEFAULT_COMPID ? parser.defcompid : manufacturer);
  46 }
  47
  48 #define EVENT_NUM 77
  49 static char *event_str[EVENT_NUM + 1] = {
  50         "Unknown",
  51         "Inquiry Complete",
  52         "Inquiry Result",
  53         "Connect Complete",
  54         "Connect Request",
  55         "Disconn Complete",
  56         "Auth Complete",
  57         "Remote Name Req Complete",
  58         "Encrypt Change",
  59         "Change Connection Link Key Complete",
  60         "Master Link Key Complete",
  61         "Read Remote Supported Features",
  62         "Read Remote Ver Info Complete",
  63         "QoS Setup Complete",
  64         "Command Complete",
  65         "Command Status",
  66         "Hardware Error",
  67         "Flush Occurred",
  68         "Role Change",
  69         "Number of Completed Packets",
  70         "Mode Change",
  71         "Return Link Keys",
  72         "PIN Code Request",
  73         "Link Key Request",
  74         "Link Key Notification",
  75         "Loopback Command",
  76         "Data Buffer Overflow",
  77         "Max Slots Change",
  78         "Read Clock Offset Complete",
  79         "Connection Packet Type Changed",
  80         "QoS Violation",
  81         "Page Scan Mode Change",
  82         "Page Scan Repetition Mode Change",
  83         "Flow Specification Complete",
  84         "Inquiry Result with RSSI",
  85         "Read Remote Extended Features",
  86         "Unknown",
  87         "Unknown",
  88         "Unknown",
  89         "Unknown",
  90         "Unknown",
  91         "Unknown",
  92         "Unknown",
  93         "Unknown",
  94         "Synchronous Connect Complete",
  95         "Synchronous Connect Changed",
  96         "Sniff Subrate",
  97         "Extended Inquiry Result",
  98         "Encryption Key Refresh Complete",
  99         "IO Capability Request",
 100         "IO Capability Response",
 101         "User Confirmation Request",
 102         "User Passkey Request",
 103         "Remote OOB Data Request",
 104         "Simple Pairing Complete",
 105         "Unknown",
 106         "Link Supervision Timeout Change",
 107         "Enhanced Flush Complete",
 108         "Unknown",
 109         "User Passkey Notification",
 110         "Keypress Notification",
 111         "Remote Host Supported Features Notification",
 112         "LE Meta Event",
 113         "Unknown",
 114         "Physical Link Complete",
 115         "Channel Selected",
 116         "Disconnection Physical Link Complete",
 117         "Physical Link Loss Early Warning",
 118         "Physical Link Recovery",
 119         "Logical Link Complete",
 120         "Disconnection Logical Link Complete",
 121         "Flow Spec Modify Complete",
 122         "Number Of Completed Data Blocks",
 123         "AMP Start Test",
 124         "AMP Test End",
 125         "AMP Receiver Report",
 126         "Short Range Mode Change Complete",
 127         "AMP Status Change",
 128 };
 129
 130 #define LE_EV_NUM 5
 131 static char *ev_le_meta_str[LE_EV_NUM + 1] = {
 132         "Unknown",
 133         "LE Connection Complete",
 134         "LE Advertising Report",
 135         "LE Connection Update Complete",
 136         "LE Read Remote Used Features Complete",
 137         "LE Long Term Key Request",
 138 };
 139
 140 #define CMD_LINKCTL_NUM 60
 141 static char *cmd_linkctl_str[CMD_LINKCTL_NUM + 1] = {
 142         "Unknown",
 143         "Inquiry",
 144         "Inquiry Cancel",
 145         "Periodic Inquiry Mode",
 146         "Exit Periodic Inquiry Mode",
 147         "Create Connection",
 148         "Disconnect",
 149         "Add SCO Connection",
 150         "Create Connection Cancel",
 151         "Accept Connection Request",
 152         "Reject Connection Request",
 153         "Link Key Request Reply",
 154         "Link Key Request Negative Reply",
 155         "PIN Code Request Reply",
 156         "PIN Code Request Negative Reply",
 157         "Change Connection Packet Type",
 158         "Unknown",
 159         "Authentication Requested",
 160         "Unknown",
 161         "Set Connection Encryption",
 162         "Unknown",
 163         "Change Connection Link Key",
 164         "Unknown",
 165         "Master Link Key",
 166         "Unknown",
 167         "Remote Name Request",
 168         "Remote Name Request Cancel",
 169         "Read Remote Supported Features",
 170         "Read Remote Extended Features",
 171         "Read Remote Version Information",
 172         "Unknown",
 173         "Read Clock Offset",
 174         "Read LMP Handle",
 175         "Unknown",
 176         "Unknown",
 177         "Unknown",
 178         "Unknown",
 179         "Unknown",
 180         "Unknown",
 181         "Unknown",
 182         "Setup Synchronous Connection",
 183         "Accept Synchronous Connection",
 184         "Reject Synchronous Connection",
 185         "IO Capability Request Reply",
 186         "User Confirmation Request Reply",
 187         "User Confirmation Request Negative Reply",
 188         "User Passkey Request Reply",
 189         "User Passkey Request Negative Reply",
 190         "Remote OOB Data Request Reply",
 191         "Unknown",
 192         "Unknown",
 193         "Remote OOB Data Request Negative Reply",
 194         "IO Capability Request Negative Reply",
 195         "Create Physical Link",
 196         "Accept Physical Link",
 197         "Disconnect Physical Link",
 198         "Create Logical Link",
 199         "Accept Logical Link",
 200         "Disconnect Logical Link",
 201         "Logical Link Cancel",
 202         "Flow Spec Modify",
 203 };
 204
 205 #define CMD_LINKPOL_NUM 17
 206 static char *cmd_linkpol_str[CMD_LINKPOL_NUM + 1] = {
 207         "Unknown",
 208         "Hold Mode",
 209         "Unknown",
 210         "Sniff Mode",
 211         "Exit Sniff Mode",
 212         "Park State",
 213         "Exit Park State",
 214         "QoS Setup",
 215         "Unknown",
 216         "Role Discovery",
 217         "Unknown",
 218         "Switch Role",
 219         "Read Link Policy Settings",
 220         "Write Link Policy Settings",
 221         "Read Default Link Policy Settings",
 222         "Write Default Link Policy Settings",
 223         "Flow Specification",
 224         "Sniff Subrating",
 225 };
 226
 227 #define CMD_HOSTCTL_NUM 109
 228 static char *cmd_hostctl_str[CMD_HOSTCTL_NUM + 1] = {
 229         "Unknown",
 230         "Set Event Mask",
 231         "Unknown",
 232         "Reset",
 233         "Unknown",
 234         "Set Event Filter",
 235         "Unknown",
 236         "Unknown",
 237         "Flush",
 238         "Read PIN Type ",
 239         "Write PIN Type",
 240         "Create New Unit Key",
 241         "Unknown",
 242         "Read Stored Link Key",
 243         "Unknown",
 244         "Unknown",
 245         "Unknown",
 246         "Write Stored Link Key",
 247         "Delete Stored Link Key",
 248         "Write Local Name",
 249         "Read Local Name",
 250         "Read Connection Accept Timeout",
 251         "Write Connection Accept Timeout",
 252         "Read Page Timeout",
 253         "Write Page Timeout",
 254         "Read Scan Enable",
 255         "Write Scan Enable",
 256         "Read Page Scan Activity",
 257         "Write Page Scan Activity",
 258         "Read Inquiry Scan Activity",
 259         "Write Inquiry Scan Activity",
 260         "Read Authentication Enable",
 261         "Write Authentication Enable",
 262         "Read Encryption Mode",
 263         "Write Encryption Mode",
 264         "Read Class of Device",
 265         "Write Class of Device",
 266         "Read Voice Setting",
 267         "Write Voice Setting",
 268         "Read Automatic Flush Timeout",
 269         "Write Automatic Flush Timeout",
 270         "Read Num Broadcast Retransmissions",
 271         "Write Num Broadcast Retransmissions",
 272         "Read Hold Mode Activity ",
 273         "Write Hold Mode Activity",
 274         "Read Transmit Power Level",
 275         "Read Synchronous Flow Control Enable",
 276         "Write Synchronous Flow Control Enable",
 277         "Unknown",
 278         "Set Host Controller To Host Flow Control",
 279         "Unknown",
 280         "Host Buffer Size",
 281         "Unknown",
 282         "Host Number of Completed Packets",
 283         "Read Link Supervision Timeout",
 284         "Write Link Supervision Timeout",
 285         "Read Number of Supported IAC",
 286         "Read Current IAC LAP",
 287         "Write Current IAC LAP",
 288         "Read Page Scan Period Mode",
 289         "Write Page Scan Period Mode",
 290         "Read Page Scan Mode",
 291         "Write Page Scan Mode",
 292         "Set AFH Host Channel Classification",
 293         "Unknown",
 294         "Unknown",
 295         "Read Inquiry Scan Type",
 296         "Write Inquiry Scan Type",
 297         "Read Inquiry Mode",
 298         "Write Inquiry Mode",
 299         "Read Page Scan Type",
 300         "Write Page Scan Type",
 301         "Read AFH Channel Assessment Mode",
 302         "Write AFH Channel Assessment Mode",
 303         "Unknown",
 304         "Unknown",
 305         "Unknown",
 306         "Unknown",
 307         "Unknown",
 308         "Unknown",
 309         "Unknown",
 310         "Read Extended Inquiry Response",
 311         "Write Extended Inquiry Response",
 312         "Refresh Encryption Key",
 313         "Unknown",
 314         "Read Simple Pairing Mode",
 315         "Write Simple Pairing Mode",
 316         "Read Local OOB Data",
 317         "Read Inquiry Response Transmit Power Level",
 318         "Write Inquiry Transmit Power Level",
 319         "Read Default Erroneous Data Reporting",
 320         "Write Default Erroneous Data Reporting",
 321         "Unknown",
 322         "Unknown",
 323         "Unknown",
 324         "Enhanced Flush",
 325         "Unknown",
 326         "Read Logical Link Accept Timeout",
 327         "Write Logical Link Accept Timeout",
 328         "Set Event Mask Page 2",
 329         "Read Location Data",
 330         "Write Location Data",
 331         "Read Flow Control Mode",
 332         "Write Flow Control Mode",
 333         "Read Enhanced Transmit Power Level",
 334         "Read Best Effort Flush Timeout",
 335         "Write Best Effort Flush Timeout",
 336         "Short Range Mode",
 337         "Read LE Host Supported",
 338         "Write LE Host Supported",
 339 };
 340
 341 #define CMD_INFO_NUM 10
 342 static char *cmd_info_str[CMD_INFO_NUM + 1] = {
 343         "Unknown",
 344         "Read Local Version Information",
 345         "Read Local Supported Commands",
 346         "Read Local Supported Features",
 347         "Read Local Extended Features",
 348         "Read Buffer Size",
 349         "Unknown",
 350         "Read Country Code",
 351         "Unknown",
 352         "Read BD ADDR",
 353         "Read Data Block Size",
 354 };
 355
 356 #define CMD_STATUS_NUM 11
 357 static char *cmd_status_str[CMD_STATUS_NUM + 1] = {
 358         "Unknown",
 359         "Read Failed Contact Counter",
 360         "Reset Failed Contact Counter",
 361         "Read Link Quality",
 362         "Unknown",
 363         "Read RSSI",
 364         "Read AFH Channel Map",
 365         "Read Clock",
 366         "Read Encryption Key Size",
 367         "Read Local AMP Info",
 368         "Read Local AMP ASSOC",
 369         "Write Remote AMP ASSOC"
 370 };
 371
 372 #define CMD_TESTING_NUM 4
 373 static char *cmd_testing_str[CMD_TESTING_NUM + 1] = {
 374         "Unknown",
 375         "Read Loopback Mode",
 376         "Write Loopback Mode",
 377         "Enable Device Under Test mode",
 378         "Unknown",
 379 };
 380
 381 #define CMD_LE_NUM 31
 382 static char *cmd_le_str[CMD_LE_NUM + 1] = {
 383         "Unknown",
 384         "LE Set Event Mask",
 385         "LE Read Buffer Size",
 386         "LE Read Local Supported Features",
 387         "Unknown",
 388         "LE Set Random Address",
 389         "LE Set Advertising Parameters",
 390         "LE Read Advertising Channel Tx Power",
 391         "LE Set Advertising Data",
 392         "LE Set Scan Response Data",
 393         "LE Set Advertise Enable",
 394         "LE Set Scan Parameters",
 395         "LE Set Scan Enable",
 396         "LE Create Connection",
 397         "LE Create Connection Cancel",
 398         "LE Read White List Size",
 399         "LE Clear White List",
 400         "LE Add Device To White List",
 401         "LE Remove Device From White List",
 402         "LE Connection Update",
 403         "LE Set Host Channel Classification",
 404         "LE Read Channel Map",
 405         "LE Read Remote Used Features",
 406         "LE Encrypt",
 407         "LE Rand",
 408         "LE Start Encryption",
 409         "LE Long Term Key Request Reply",
 410         "LE Long Term Key Request Negative Reply",
 411         "LE Read Supported States",
 412         "LE Receiver Test",
 413         "LE Transmitter Test",
 414         "LE Test End",
 415 };
 416
 417 #define ERROR_CODE_NUM 63
 418 static char *error_code_str[ERROR_CODE_NUM + 1] = {
 419         "Success",
 420         "Unknown HCI Command",
 421         "Unknown Connection Identifier",
 422         "Hardware Failure",
 423         "Page Timeout",
 424         "Authentication Failure",
 425         "PIN or Key Missing",
 426         "Memory Capacity Exceeded",
 427         "Connection Timeout",
 428         "Connection Limit Exceeded",
 429         "Synchronous Connection to a Device Exceeded",
 430         "ACL Connection Already Exists",
 431         "Command Disallowed",
 432         "Connection Rejected due to Limited Resources",
 433         "Connection Rejected due to Security Reasons",
 434         "Connection Rejected due to Unacceptable BD_ADDR",
 435         "Connection Accept Timeout Exceeded",
 436         "Unsupported Feature or Parameter Value",
 437         "Invalid HCI Command Parameters",
 438         "Remote User Terminated Connection",
 439         "Remote Device Terminated Connection due to Low Resources",
 440         "Remote Device Terminated Connection due to Power Off",
 441         "Connection Terminated by Local Host",
 442         "Repeated Attempts",
 443         "Pairing Not Allowed",
 444         "Unknown LMP PDU",
 445         "Unsupported Remote Feature / Unsupported LMP Feature",
 446         "SCO Offset Rejected",
 447         "SCO Interval Rejected",
 448         "SCO Air Mode Rejected",
 449         "Invalid LMP Parameters / Invalid LL Parameters",
 450         "Unspecified Error",
 451         "Unsupported LMP Parameter Value / Unsupported LL Parameter Value",
 452         "Role Change Not Allowed",
 453         "LMP Response Timeout",
 454         "LMP Error Transaction Collision",
 455         "LMP PDU Not Allowed",
 456         "Encryption Mode Not Acceptable",
 457         "Link Key Can Not be Changed",
 458         "Requested QoS Not Supported",
 459         "Instant Passed",
 460         "Pairing with Unit Key Not Supported",
 461         "Different Transaction Collision",
 462         "Reserved",
 463         "QoS Unacceptable Parameter",
 464         "QoS Rejected",
 465         "Channel Classification Not Supported",
 466         "Insufficient Security",
 467         "Parameter out of Mandatory Range",
 468         "Reserved",
 469         "Role Switch Pending",
 470         "Reserved",
 471         "Reserved Slot Violation",
 472         "Role Switch Failed",
 473         "Extended Inquiry Response Too Large",
 474         "Simple Pairing Not Supported by Host",
 475         "Host Busy - Pairing",
 476         "Connection Rejected due to No Suitable Channel Found",
 477         "Controller Busy",
 478         "Unacceptable Connection Parameters",
 479         "Directed Advertising Timeout",
 480         "Connection Terminated Due to MIC Failure",
 481         "Connection Failed to be Established",
 482         "MAC Connection Failed",
 483 };
 484
 485 static char *status2str(uint8_t status)
 486 {
 487         char *str;
 488
 489         if (status <= ERROR_CODE_NUM)
 490                 str = error_code_str[status];
 491         else
 492                 str = "Unknown";
 493
 494         return str;
 495 }
 496
 497 static char *opcode2str(uint16_t opcode)
 498 {
 499         uint16_t ogf = cmd_opcode_ogf(opcode);
 500         uint16_t ocf = cmd_opcode_ocf(opcode);
 501         char *cmd;
 502
 503         switch (ogf) {
 504         case OGF_INFO_PARAM:
 505                 if (ocf <= CMD_INFO_NUM)
 506                         cmd = cmd_info_str[ocf];
 507                 else
 508                         cmd = "Unknown";
 509                 break;
 510
 511         case OGF_HOST_CTL:
 512                 if (ocf <= CMD_HOSTCTL_NUM)
 513                         cmd = cmd_hostctl_str[ocf];
 514                 else
 515                         cmd = "Unknown";
 516                 break;
 517
 518         case OGF_LINK_CTL:
 519                 if (ocf <= CMD_LINKCTL_NUM)
 520                         cmd = cmd_linkctl_str[ocf];
 521                 else
 522                         cmd = "Unknown";
 523                 break;
 524
 525         case OGF_LINK_POLICY:
 526                 if (ocf <= CMD_LINKPOL_NUM)
 527                         cmd = cmd_linkpol_str[ocf];
 528                 else
 529                         cmd = "Unknown";
 530                 break;
 531
 532         case OGF_STATUS_PARAM:
 533                 if (ocf <= CMD_STATUS_NUM)
 534                         cmd = cmd_status_str[ocf];
 535                 else
 536                         cmd = "Unknown";
 537                 break;
 538
 539         case OGF_TESTING_CMD:
 540                 if (ocf <= CMD_TESTING_NUM)
 541                         cmd = cmd_testing_str[ocf];
 542                 else
 543                         cmd = "Unknown";
 544                 break;
 545
 546         case OGF_LE_CTL:
 547                 if (ocf <= CMD_LE_NUM)
 548                         cmd = cmd_le_str[ocf];
 549                 else
 550                         cmd = "Unknown";
 551                 break;
 552
 553         case OGF_VENDOR_CMD:
 554                 cmd = "Vendor";
 555                 break;
 556
 557         default:
 558                 cmd = "Unknown";
 559                 break;
 560         }
 561
 562         return cmd;
 563 }
 564
 565 static char *linktype2str(uint8_t type)
 566 {
 567         switch (type) {
 568         case 0x00:
 569                 return "SCO";
 570         case 0x01:
 571                 return "ACL";
 572         case 0x02:
 573                 return "eSCO";
 574         default:
 575                 return "Unknown";
 576         }
 577 }
 578
 579 static char *role2str(uint8_t role)
 580 {
 581         switch (role) {
 582         case 0x00:
 583                 return "Master";
 584         case 0x01:
 585                 return "Slave";
 586         default:
 587                 return "Unknown";
 588         }
 589 }
 590
 591 static char *mode2str(uint8_t mode)
 592 {
 593         switch (mode) {
 594         case 0x00:
 595                 return "Active";
 596         case 0x01:
 597                 return "Hold";
 598         case 0x02:
 599                 return "Sniff";
 600         case 0x03:
 601                 return "Park";
 602         default:
 603                 return "Unknown";
 604         }
 605 }
 606
 607 static char *airmode2str(uint8_t mode)
 608 {
 609         switch (mode) {
 610         case 0x00:
 611                 return "u-law log";
 612         case 0x01:
 613                 return "A-law log";
 614         case 0x02:
 615                 return "CVSD";
 616         case 0x04:
 617                 return "Transparent data";
 618         default:
 619                 return "Reserved";
 620         }
 621 }
 622
 623 static const char *bdaddrtype2str(uint8_t type)
 624 {
 625         switch (type) {
 626         case 0x00:
 627                 return "Public";
 628         case 0x01:
 629                 return "Random";
 630         default:
 631                 return "Reserved";
 632         }
 633 }
 634
 635 static const char *evttype2str(uint8_t type)
 636 {
 637         switch (type) {
 638         case 0x00:
 639                 return "ADV_IND - Connectable undirected advertising";
 640         case 0x01:
 641                 return "ADV_DIRECT_IND - Connectable directed advertising";
 642         case 0x02:
 643                 return "ADV_SCAN_IND - Scannable undirected advertising";
 644         case 0x03:
 645                 return "ADV_NONCONN_IND - Non connectable undirected advertising";
 646         case 0x04:
 647                 return "SCAN_RSP - Scan Response";
 648         default:
 649                 return "Reserved";
 650         }
 651 }
 652
 653 static char *keytype2str(uint8_t type)
 654 {
 655         switch (type) {
 656         case 0x00:
 657                 return "Combination Key";
 658         case 0x01:
 659                 return "Local Unit Key";
 660         case 0x02:
 661                 return "Remote Unit Key";
 662         case 0x03:
 663                 return "Debug Combination Key";
 664         case 0x04:
 665                 return "Unauthenticated Combination Key";
 666         case 0x05:
 667                 return "Authenticated Combination Key";
 668         case 0x06:
 669                 return "Changed Combination Key";
 670         default:
 671                 return "Reserved";
 672         }
 673 }
 674
 675 static char *capability2str(uint8_t capability)
 676 {
 677         switch (capability) {
 678         case 0x00:
 679                 return "DisplayOnly";
 680         case 0x01:
 681                 return "DisplayYesNo";
 682         case 0x02:
 683                 return "KeyboardOnly";
 684         case 0x03:
 685                 return "NoInputNoOutput";
 686         default:
 687                 return "Reserved";
 688         }
 689 }
 690
 691 static char *authentication2str(uint8_t authentication)
 692 {
 693         switch (authentication) {
 694         case 0x00:
 695                 return "No Bonding (No MITM Protection)";
 696         case 0x01:
 697                 return "No Bonding (MITM Protection)";
 698         case 0x02:
 699                 return "Dedicated Bonding (No MITM Protection)";
 700         case 0x03:
 701                 return "Dedicated Bonding (MITM Protection)";
 702         case 0x04:
 703                 return "General Bonding (No MITM Protection)";
 704         case 0x05:
 705                 return "General Bonding (MITM Protection)";
 706         default:
 707                 return "Reserved";
 708         }
 709 }
 710
 711 static char *eventmask2str(const uint8_t mask[8])
 712 {
 713         int i;
 714
 715         for (i = 0; i < 7; i++) {
 716                 if (mask[i] != 0x00)
 717                         return "Reserved";
 718         }
 719
 720         switch (mask[7]) {
 721         case 0x00:
 722                 return "No LE events specified";
 723         case 0x01:
 724                 return "LE Connection Complete Event";
 725         case 0x02:
 726                 return "LE Advertising Report Event";
 727         case 0x04:
 728                 return "LE Connection Update Complete Event";
 729         case 0x08:
 730                 return "LE Read Remote Used Features Complete Event";
 731         case 0x10:
 732                 return "LE Long Term Key Request Event";
 733         case 0x1F:
 734                 return "Default";
 735         default:
 736                 return "Reserved";
 737         }
 738 }
 739
 740 static char *lefeatures2str(const uint8_t features[8])
 741 {
 742         if (features[0] & 0x01)
 743                 return "Link Layer supports LE Encryption";
 744
 745         return "RFU";
 746 }
 747
 748 static char *filterpolicy2str(uint8_t policy)
 749 {
 750         switch (policy) {
 751         case 0x00:
 752                 return "Allow scan from any, connection from any";
 753         case 0x01:
 754                 return "Allow scan from white list, connection from any";
 755         case 0x02:
 756                 return "Allow scan from any, connection from white list";
 757         case 0x03:
 758                 return "Allow scan and connection from white list";
 759         default:
 760                 return "Reserved";
 761         }
 762 }
 763
 764 static inline void ext_inquiry_data_dump(int level, struct frame *frm,
 765                                                 uint8_t *data)
 766 {
 767         uint8_t len = data[0];
 768         uint8_t type;
 769         char *str;
 770         int i;
 771
 772         if (len == 0)
 773                 return;
 774
 775         type = data[1];
 776         data += 2;
 777         len -= 1;
 778
 779         switch (type) {
 780         case 0x01:
 781                 p_indent(level, frm);
 782                 printf("Flags:");
 783                 for (i = 0; i < len; i++)
 784                         printf(" 0x%2.2x", data[i]);
 785                 printf("\n");
 786                 break;
 787
 788         case 0x02:
 789         case 0x03:
 790                 p_indent(level, frm);
 791                 printf("%s service classes:",
 792                                 type == 0x02 ? "Shortened" : "Complete");
 793
 794                 for (i = 0; i < len / 2; i++)
 795                         printf(" 0x%4.4x", get_le16(data + i * 2));
 796
 797                 printf("\n");
 798                 break;
 799
 800         case 0x08:
 801         case 0x09:
 802                 str = malloc(len + 1);
 803                 if (str) {
 804                         snprintf(str, len + 1, "%s", (char *) data);
 805                         for (i = 0; i < len; i++)
 806                                 if (!isprint(str[i]))
 807                                         str[i] = '.';
 808                         p_indent(level, frm);
 809                         printf("%s local name: \'%s\'\n",
 810                                 type == 0x08 ? "Shortened" : "Complete", str);
 811                         free(str);
 812                 }
 813                 break;
 814
 815         case 0x0a:
 816                 p_indent(level, frm);
 817                 printf("TX power level: %d\n", *((uint8_t *) data));
 818                 break;
 819
 820         default:
 821                 p_indent(level, frm);
 822                 printf("Unknown type 0x%02x with %d bytes data\n",
 823                                                         type, len);
 824                 break;
 825         }
 826 }
 827
 828 static inline void ext_inquiry_response_dump(int level, struct frame *frm)
 829 {
 830         void *ptr = frm->ptr;
 831         uint32_t len = frm->len;
 832         uint8_t *data;
 833         uint8_t length;
 834
 835         data = frm->ptr;
 836         length = p_get_u8(frm);
 837
 838         while (length > 0) {
 839                 ext_inquiry_data_dump(level, frm, data);
 840
 841                 frm->ptr += length;
 842                 frm->len -= length;
 843
 844                 data = frm->ptr;
 845                 length = p_get_u8(frm);
 846         }
 847
 848         frm->ptr = ptr +
 849                 (EXTENDED_INQUIRY_INFO_SIZE - INQUIRY_INFO_WITH_RSSI_SIZE);
 850         frm->len = len +
 851                 (EXTENDED_INQUIRY_INFO_SIZE - INQUIRY_INFO_WITH_RSSI_SIZE);
 852 }
 853
 854 static inline void bdaddr_command_dump(int level, struct frame *frm)
 855 {
 856         bdaddr_t *bdaddr = frm->ptr;
 857         char addr[18];
 858
 859         frm->ptr += sizeof(bdaddr_t);
 860         frm->len -= sizeof(bdaddr_t);
 861
 862         p_indent(level, frm);
 863         p_ba2str(bdaddr, addr);
 864         printf("bdaddr %s\n", addr);
 865
 866         raw_dump(level, frm);
 867 }
 868
 869 static inline void generic_command_dump(int level, struct frame *frm)
 870 {
 871         uint16_t handle = btohs(htons(p_get_u16(frm)));
 872
 873         p_indent(level, frm);
 874         printf("handle %d\n", handle);
 875
 876         raw_dump(level, frm);
 877 }
 878
 879 static inline void generic_write_mode_dump(int level, struct frame *frm)
 880 {
 881         uint8_t mode = p_get_u8(frm);
 882
 883         p_indent(level, frm);
 884         printf("mode 0x%2.2x\n", mode);
 885 }
 886
 887 static inline void inquiry_dump(int level, struct frame *frm)
 888 {
 889         inquiry_cp *cp = frm->ptr;
 890
 891         p_indent(level, frm);
 892         printf("lap 0x%2.2x%2.2x%2.2x len %d num %d\n",
 893                 cp->lap[2], cp->lap[1], cp->lap[0], cp->length, cp->num_rsp);
 894 }
 895
 896 static inline void periodic_inquiry_dump(int level, struct frame *frm)
 897 {
 898         periodic_inquiry_cp *cp = frm->ptr;
 899
 900         p_indent(level, frm);
 901         printf("max %d min %d lap 0x%2.2x%2.2x%2.2x len %d num %d\n",
 902                 btohs(cp->max_period), btohs(cp->min_period),
 903                 cp->lap[2], cp->lap[1], cp->lap[0], cp->length, cp->num_rsp);
 904 }
 905
 906 static inline void create_conn_dump(int level, struct frame *frm)
 907 {
 908         create_conn_cp *cp = frm->ptr;
 909         uint16_t ptype = btohs(cp->pkt_type);
 910         uint16_t clkoffset = btohs(cp->clock_offset);
 911         char addr[18], *str;
 912
 913         p_indent(level, frm);
 914         p_ba2str(&cp->bdaddr, addr);
 915         printf("bdaddr %s ptype 0x%4.4x rswitch 0x%2.2x clkoffset 0x%4.4x%s\n",
 916                 addr, ptype, cp->role_switch,
 917                 clkoffset & 0x7fff, clkoffset & 0x8000 ? " (valid)" : "");
 918
 919         str = hci_ptypetostr(ptype);
 920         if (str) {
 921                 p_indent(level, frm);
 922                 printf("Packet type: %s\n", str);
 923                 free(str);
 924         }
 925 }
 926
 927 static inline void disconnect_dump(int level, struct frame *frm)
 928 {
 929         disconnect_cp *cp = frm->ptr;
 930
 931         p_indent(level, frm);
 932         printf("handle %d reason 0x%2.2x\n", btohs(cp->handle), cp->reason);
 933
 934         p_indent(level, frm);
 935         printf("Reason: %s\n", status2str(cp->reason));
 936 }
 937
 938 static inline void add_sco_dump(int level, struct frame *frm)
 939 {
 940         add_sco_cp *cp = frm->ptr;
 941         uint16_t ptype = btohs(cp->pkt_type);
 942         char *str;
 943
 944         p_indent(level, frm);
 945         printf("handle %d ptype 0x%4.4x\n", btohs(cp->handle), ptype);
 946
 947         str = hci_ptypetostr(ptype);
 948         if (str) {
 949                 p_indent(level, frm);
 950                 printf("Packet type: %s\n", str);
 951                 free(str);
 952         }
 953 }
 954
 955 static inline void accept_conn_req_dump(int level, struct frame *frm)
 956 {
 957         accept_conn_req_cp *cp = frm->ptr;
 958         char addr[18];
 959
 960         p_indent(level, frm);
 961         p_ba2str(&cp->bdaddr, addr);
 962         printf("bdaddr %s role 0x%2.2x\n", addr, cp->role);
 963
 964         p_indent(level, frm);
 965         printf("Role: %s\n", role2str(cp->role));
 966 }
 967
 968 static inline void reject_conn_req_dump(int level, struct frame *frm)
 969 {
 970         reject_conn_req_cp *cp = frm->ptr;
 971         char addr[18];
 972
 973         p_indent(level, frm);
 974         p_ba2str(&cp->bdaddr, addr);
 975         printf("bdaddr %s reason 0x%2.2x\n", addr, cp->reason);
 976
 977         p_indent(level, frm);
 978         printf("Reason: %s\n", status2str(cp->reason));
 979 }
 980
 981 static inline void pin_code_reply_dump(int level, struct frame *frm)
 982 {
 983         pin_code_reply_cp *cp = frm->ptr;
 984         char addr[18], pin[17];
 985
 986         p_indent(level, frm);
 987         p_ba2str(&cp->bdaddr, addr);
 988         memset(pin, 0, sizeof(pin));
 989         if (parser.flags & DUMP_NOVENDOR)
 990                 memset(pin, '*', cp->pin_len);
 991         else
 992                 memcpy(pin, cp->pin_code, cp->pin_len);
 993         printf("bdaddr %s len %d pin \'%s\'\n", addr, cp->pin_len, pin);
 994 }
 995
 996 static inline void link_key_reply_dump(int level, struct frame *frm)
 997 {
 998         link_key_reply_cp *cp = frm->ptr;
 999         char addr[18];
1000         int i;
1001
1002         p_indent(level, frm);
1003         p_ba2str(&cp->bdaddr, addr);
1004         printf("bdaddr %s key ", addr);
1005         for (i = 0; i < 16; i++)
1006                 if (parser.flags & DUMP_NOVENDOR)
1007                         printf("**");
1008                 else
1009                         printf("%2.2X", cp->link_key[i]);
1010         printf("\n");
1011 }
1012
1013 static inline void pin_code_neg_reply_dump(int level, struct frame *frm)
1014 {
1015         bdaddr_t *bdaddr = frm->ptr;
1016         char addr[18];
1017
1018         p_indent(level, frm);
1019         p_ba2str(bdaddr, addr);
1020         printf("bdaddr %s\n", addr);
1021 }
1022
1023 static inline void user_passkey_reply_dump(int level, struct frame *frm)
1024 {
1025         user_passkey_reply_cp *cp = frm->ptr;
1026         char addr[18];
1027
1028         p_indent(level, frm);
1029         p_ba2str(&cp->bdaddr, addr);
1030         printf("bdaddr %s passkey %d\n", addr, btohl(cp->passkey));
1031 }
1032
1033 static inline void remote_oob_data_reply_dump(int level, struct frame *frm)
1034 {
1035         remote_oob_data_reply_cp *cp = frm->ptr;
1036         char addr[18];
1037         int i;
1038
1039         p_indent(level, frm);
1040         p_ba2str(&cp->bdaddr, addr);
1041         printf("bdaddr %s\n", addr);
1042
1043         p_indent(level, frm);
1044         printf("hash 0x");
1045         for (i = 0; i < 16; i++)
1046                 printf("%02x", cp->hash[i]);
1047         printf("\n");
1048
1049         p_indent(level, frm);
1050         printf("randomizer 0x");
1051         for (i = 0; i < 16; i++)
1052                         printf("%02x", cp->randomizer[i]);
1053         printf("\n");
1054 }
1055
1056 static inline void io_capability_reply_dump(int level, struct frame *frm)
1057 {
1058         io_capability_reply_cp *cp = frm->ptr;
1059         char addr[18];
1060
1061         p_indent(level, frm);
1062         p_ba2str(&cp->bdaddr, addr);
1063         printf("bdaddr %s capability 0x%2.2x oob 0x%2.2x auth 0x%2.2x\n",
1064                                         addr, cp->capability, cp->oob_data,
1065                                                         cp->authentication);
1066
1067         p_indent(level, frm);
1068         printf("Capability: %s (OOB data %s)\n",
1069                         capability2str(cp->capability),
1070                         cp->oob_data == 0x00 ? "not present" : "available");
1071
1072         p_indent(level, frm);
1073         printf("Authentication: %s\n", authentication2str(cp->authentication));
1074 }
1075
1076 static inline void set_conn_encrypt_dump(int level, struct frame *frm)
1077 {
1078         set_conn_encrypt_cp *cp = frm->ptr;
1079
1080         p_indent(level, frm);
1081         printf("handle %d encrypt 0x%2.2x\n", btohs(cp->handle), cp->encrypt);
1082 }
1083
1084 static inline void remote_name_req_dump(int level, struct frame *frm)
1085 {
1086         remote_name_req_cp *cp = frm->ptr;
1087         uint16_t clkoffset = btohs(cp->clock_offset);
1088         char addr[18];
1089
1090         p_indent(level, frm);
1091         p_ba2str(&cp->bdaddr, addr);
1092         printf("bdaddr %s mode %d clkoffset 0x%4.4x%s\n",
1093                 addr, cp->pscan_rep_mode,
1094                 clkoffset & 0x7fff, clkoffset & 0x8000 ? " (valid)" : "");
1095 }
1096
1097 static inline void master_link_key_dump(int level, struct frame *frm)
1098 {
1099         master_link_key_cp *cp = frm->ptr;
1100
1101         p_indent(level, frm);
1102         printf("flag %d\n", cp->key_flag);
1103 }
1104
1105 static inline void read_remote_ext_features_dump(int level, struct frame *frm)
1106 {
1107         read_remote_ext_features_cp *cp = frm->ptr;
1108
1109         p_indent(level, frm);
1110         printf("handle %d page %d\n", btohs(cp->handle), cp->page_num);
1111 }
1112
1113 static inline void setup_sync_conn_dump(int level, struct frame *frm)
1114 {
1115         setup_sync_conn_cp *cp = frm->ptr;
1116
1117         p_indent(level, frm);
1118         printf("handle %d voice setting 0x%4.4x ptype 0x%4.4x\n",
1119                 btohs(cp->handle), btohs(cp->voice_setting),
1120                 btohs(cp->pkt_type));
1121 }
1122
1123 static inline void create_physical_link_dump(int level, struct frame *frm)
1124 {
1125         create_physical_link_cp *cp = frm->ptr;
1126         int i;
1127
1128         p_indent(level, frm);
1129         printf("phy handle 0x%2.2x key length %d key type %d\n",
1130                 cp->handle, cp->key_length, cp->key_type);
1131         p_indent(level, frm);
1132         printf("key ");
1133         for (i = 0; i < cp->key_length && cp->key_length <= 32; i++)
1134                 printf("%2.2x", cp->key[i]);
1135         printf("\n");
1136 }
1137
1138 static inline void create_logical_link_dump(int level, struct frame *frm)
1139 {
1140         create_logical_link_cp *cp = frm->ptr;
1141         int i;
1142
1143         p_indent(level, frm);
1144         printf("phy handle 0x%2.2x\n", cp->handle);
1145
1146         p_indent(level, frm);
1147         printf("tx_flow ");
1148         for (i = 0; i < 16; i++)
1149                 printf("%2.2x", cp->tx_flow[i]);
1150         printf("\n");
1151
1152         p_indent(level, frm);
1153         printf("rx_flow ");
1154         for (i = 0; i < 16; i++)
1155                 printf("%2.2x", cp->rx_flow[i]);
1156         printf("\n");
1157 }
1158
1159 static inline void hold_mode_dump(int level, struct frame *frm)
1160 {
1161         hold_mode_cp *cp = frm->ptr;
1162
1163         p_indent(level, frm);
1164         printf("handle %d max %d min %d\n", btohs(cp->handle),
1165                         btohs(cp->max_interval), btohs(cp->min_interval));
1166 }
1167
1168 static inline void sniff_mode_dump(int level, struct frame *frm)
1169 {
1170         sniff_mode_cp *cp = frm->ptr;
1171
1172         p_indent(level, frm);
1173         printf("handle %d max %d min %d attempt %d timeout %d\n",
1174                 btohs(cp->handle), btohs(cp->max_interval),
1175                 btohs(cp->min_interval), btohs(cp->attempt), btohs(cp->timeout));
1176 }
1177
1178 static inline void qos_setup_dump(int level, struct frame *frm)
1179 {
1180         qos_setup_cp *cp = frm->ptr;
1181
1182         p_indent(level, frm);
1183         printf("handle %d flags 0x%2.2x\n", btohs(cp->handle), cp->flags);
1184
1185         p_indent(level, frm);
1186         printf("Service type: %d\n", cp->qos.service_type);
1187         p_indent(level, frm);
1188         printf("Token rate: %d\n", btohl(cp->qos.token_rate));
1189         p_indent(level, frm);
1190         printf("Peak bandwith: %d\n", btohl(cp->qos.peak_bandwidth));
1191         p_indent(level, frm);
1192         printf("Latency: %d\n", btohl(cp->qos.latency));
1193         p_indent(level, frm);
1194         printf("Delay variation: %d\n", btohl(cp->qos.delay_variation));
1195 }
1196
1197 static inline void write_link_policy_dump(int level, struct frame *frm)
1198 {
1199         write_link_policy_cp *cp = frm->ptr;
1200         uint16_t policy = btohs(cp->policy);
1201         char *str;
1202
1203         p_indent(level, frm);
1204         printf("handle %d policy 0x%2.2x\n", btohs(cp->handle), policy);
1205
1206         str = hci_lptostr(policy);
1207         if (str) {
1208                 p_indent(level, frm);
1209                 printf("Link policy: %s\n", str);
1210                 free(str);
1211         }
1212 }
1213
1214 static inline void write_default_link_policy_dump(int level, struct frame *frm)
1215 {
1216         uint16_t policy = btohs(htons(p_get_u16(frm)));
1217         char *str;
1218
1219         p_indent(level, frm);
1220         printf("policy 0x%2.2x\n", policy);
1221
1222         str = hci_lptostr(policy);
1223         if (str) {
1224                 p_indent(level, frm);
1225                 printf("Link policy: %s\n", str);
1226                 free(str);
1227         }
1228 }
1229
1230 static inline void sniff_subrating_dump(int level, struct frame *frm)
1231 {
1232         sniff_subrating_cp *cp = frm->ptr;
1233
1234         p_indent(level, frm);
1235         printf("handle %d\n", btohs(cp->handle));
1236
1237         p_indent(level, frm);
1238         printf("max latency %d\n", btohs(cp->max_latency));
1239
1240         p_indent(level, frm);
1241         printf("min timeout remote %d local %d\n",
1242                 btohs(cp->min_remote_timeout), btohs(cp->min_local_timeout));
1243 }
1244
1245 static inline void set_event_mask_dump(int level, struct frame *frm)
1246 {
1247         set_event_mask_cp *cp = frm->ptr;
1248         int i;
1249
1250         p_indent(level, frm);
1251         printf("Mask: 0x");
1252         for (i = 0; i < 8; i++)
1253                 printf("%2.2x", cp->mask[i]);
1254         printf("\n");
1255 }
1256
1257 static inline void set_event_flt_dump(int level, struct frame *frm)
1258 {
1259         set_event_flt_cp *cp = frm->ptr;
1260         uint8_t dev_class[3], dev_mask[3];
1261         char addr[18];
1262
1263         p_indent(level, frm);
1264         printf("type %d condition %d\n", cp->flt_type,
1265                                 (cp->flt_type == 0) ? 0 : cp->cond_type);
1266
1267         switch (cp->flt_type) {
1268         case FLT_CLEAR_ALL:
1269                 p_indent(level, frm);
1270                 printf("Clear all filters\n");
1271                 break;
1272         case FLT_INQ_RESULT:
1273                 p_indent(level, frm);
1274                 printf("Inquiry result");
1275                 switch (cp->cond_type) {
1276                 case INQ_RESULT_RETURN_ALL:
1277                         printf(" for all devices\n");
1278                         break;
1279                 case INQ_RESULT_RETURN_CLASS:
1280                         memcpy(dev_class, cp->condition, 3);
1281                         memcpy(dev_mask, cp->condition + 3, 3);
1282                         printf(" with class 0x%2.2x%2.2x%2.2x mask 0x%2.2x%2.2x%2.2x\n",
1283                                 dev_class[2], dev_class[1], dev_class[0],
1284                                 dev_mask[2], dev_mask[1], dev_mask[0]);
1285                         break;
1286                 case INQ_RESULT_RETURN_BDADDR:
1287                         p_ba2str((bdaddr_t *) cp->condition, addr);
1288                         printf(" with bdaddr %s\n", addr);
1289                         break;
1290                 default:
1291                         printf("\n");
1292                         break;
1293                 }
1294                 break;
1295         case FLT_CONN_SETUP:
1296                 p_indent(level, frm);
1297                 printf("Connection setup");
1298                 switch (cp->cond_type) {
1299                 case CONN_SETUP_ALLOW_ALL:
1300                 case CONN_SETUP_ALLOW_CLASS:
1301                 case CONN_SETUP_ALLOW_BDADDR:
1302                 default:
1303                         printf("\n");
1304                         break;
1305                 }
1306                 break;
1307         }
1308 }
1309
1310 static inline void write_pin_type_dump(int level, struct frame *frm)
1311 {
1312         write_pin_type_cp *cp = frm->ptr;
1313
1314         p_indent(level, frm);
1315         printf("type %d\n", cp->pin_type);
1316 }
1317
1318 static inline void request_stored_link_key_dump(int level, struct frame *frm)
1319 {
1320         read_stored_link_key_cp *cp = frm->ptr;
1321         char addr[18];
1322
1323         p_indent(level, frm);
1324         p_ba2str(&cp->bdaddr, addr);
1325         printf("bdaddr %s all %d\n", addr, cp->read_all);
1326 }
1327
1328 static inline void return_link_keys_dump(int level, struct frame *frm)
1329 {
1330         uint8_t num = p_get_u8(frm);
1331         uint8_t key[16];
1332         char addr[18];
1333         int i, n;
1334
1335         for (n = 0; n < num; n++) {
1336                 p_ba2str(frm->ptr, addr);
1337                 memcpy(key, frm->ptr + 6, 16);
1338
1339                 p_indent(level, frm);
1340                 printf("bdaddr %s key ", addr);
1341                 for (i = 0; i < 16; i++)
1342                         if (parser.flags & DUMP_NOVENDOR)
1343                                 printf("**");
1344                         else
1345                                 printf("%2.2X", key[i]);
1346                 printf("\n");
1347
1348                 frm->ptr += 2;
1349                 frm->len -= 2;
1350         }
1351 }
1352
1353 static inline void change_local_name_dump(int level, struct frame *frm)
1354 {
1355         change_local_name_cp *cp = frm->ptr;
1356         char name[249];
1357         int i;
1358
1359         memset(name, 0, sizeof(name));
1360         for (i = 0; i < 248 && cp->name[i]; i++)
1361                 if (isprint(cp->name[i]))
1362                         name[i] = cp->name[i];
1363                 else
1364                         name[i] = '.';
1365
1366         p_indent(level, frm);
1367         printf("name \'%s\'\n", name);
1368 }
1369
1370 static inline void write_class_of_dev_dump(int level, struct frame *frm)
1371 {
1372         write_class_of_dev_cp *cp = frm->ptr;
1373
1374         p_indent(level, frm);
1375         printf("class 0x%2.2x%2.2x%2.2x\n",
1376                         cp->dev_class[2], cp->dev_class[1], cp->dev_class[0]);
1377 }
1378
1379 static inline void write_voice_setting_dump(int level, struct frame *frm)
1380 {
1381         write_voice_setting_cp *cp = frm->ptr;
1382
1383         p_indent(level, frm);
1384         printf("voice setting 0x%4.4x\n", btohs(cp->voice_setting));
1385 }
1386
1387 static inline void write_current_iac_lap_dump(int level, struct frame *frm)
1388 {
1389         write_current_iac_lap_cp *cp = frm->ptr;
1390         int i;
1391
1392         for (i = 0; i < cp->num_current_iac; i++) {
1393                 p_indent(level, frm);
1394                 printf("IAC 0x%2.2x%2.2x%2.2x", cp->lap[i][2], cp->lap[i][1], cp->lap[i][0]);
1395                 if (cp->lap[i][2] == 0x9e && cp->lap[i][1] == 0x8b) {
1396                         switch (cp->lap[i][0]) {
1397                         case 0x00:
1398                                 printf(" (Limited Inquiry Access Code)");
1399                                 break;
1400                         case 0x33:
1401                                 printf(" (General Inquiry Access Code)");
1402                                 break;
1403                         }
1404                 }
1405                 printf("\n");
1406         }
1407 }
1408
1409 static inline void write_scan_enable_dump(int level, struct frame *frm)
1410 {
1411         uint8_t enable = p_get_u8(frm);
1412
1413         p_indent(level, frm);
1414         printf("enable %d\n", enable);
1415 }
1416
1417 static inline void write_page_timeout_dump(int level, struct frame *frm)
1418 {
1419         write_page_timeout_cp *cp = frm->ptr;
1420
1421         p_indent(level, frm);
1422         printf("timeout %d\n", btohs(cp->timeout));
1423 }
1424
1425 static inline void write_page_activity_dump(int level, struct frame *frm)
1426 {
1427         write_page_activity_cp *cp = frm->ptr;
1428
1429         p_indent(level, frm);
1430         printf("interval %d window %d\n", btohs(cp->interval), btohs(cp->window));
1431 }
1432
1433 static inline void write_inquiry_scan_type_dump(int level, struct frame *frm)
1434 {
1435         write_inquiry_scan_type_cp *cp = frm->ptr;
1436
1437         p_indent(level, frm);
1438         printf("type %d\n", cp->type);
1439 }
1440
1441 static inline void write_inquiry_mode_dump(int level, struct frame *frm)
1442 {
1443         write_inquiry_mode_cp *cp = frm->ptr;
1444
1445         p_indent(level, frm);
1446         printf("mode %d\n", cp->mode);
1447 }
1448
1449 static inline void set_afh_classification_dump(int level, struct frame *frm)
1450 {
1451         set_afh_classification_cp *cp = frm->ptr;
1452         int i;
1453
1454         p_indent(level, frm);
1455         printf("map 0x");
1456         for (i = 0; i < 10; i++)
1457                 printf("%02x", cp->map[i]);
1458         printf("\n");
1459 }
1460
1461 static inline void write_link_supervision_timeout_dump(int level, struct frame *frm)
1462 {
1463         write_link_supervision_timeout_cp *cp = frm->ptr;
1464
1465         p_indent(level, frm);
1466         printf("handle %d timeout %d\n",
1467                                 btohs(cp->handle), btohs(cp->timeout));
1468 }
1469
1470 static inline void write_ext_inquiry_response_dump(int level, struct frame *frm)
1471 {
1472         write_ext_inquiry_response_cp *cp = frm->ptr;
1473
1474         p_indent(level, frm);
1475         printf("fec 0x%2.2x\n", cp->fec);
1476
1477         frm->ptr++;
1478         frm->len--;
1479
1480         ext_inquiry_response_dump(level, frm);
1481 }
1482
1483 static inline void write_inquiry_transmit_power_level_dump(int level, struct frame *frm)
1484 {
1485         write_inquiry_transmit_power_level_cp *cp = frm->ptr;
1486
1487         p_indent(level, frm);
1488         printf("level %d\n", cp->level);
1489 }
1490
1491 static inline void write_default_error_data_reporting_dump(int level, struct frame *frm)
1492 {
1493         write_default_error_data_reporting_cp *cp = frm->ptr;
1494
1495         p_indent(level, frm);
1496         printf("reporting %d\n", cp->reporting);
1497 }
1498
1499 static inline void enhanced_flush_dump(int level, struct frame *frm)
1500 {
1501         enhanced_flush_cp *cp = frm->ptr;
1502
1503         p_indent(level, frm);
1504         printf("handle %d type %d\n", btohs(cp->handle), cp->type);
1505 }
1506
1507 static inline void send_keypress_notify_dump(int level, struct frame *frm)
1508 {
1509         send_keypress_notify_cp *cp = frm->ptr;
1510         char addr[18];
1511
1512         p_indent(level, frm);
1513         p_ba2str(&cp->bdaddr, addr);
1514         printf("bdaddr %s type %d\n", addr, cp->type);
1515 }
1516
1517 static inline void request_transmit_power_level_dump(int level, struct frame *frm)
1518 {
1519         read_transmit_power_level_cp *cp = frm->ptr;
1520
1521         p_indent(level, frm);
1522         printf("handle %d type %d (%s)\n",
1523                                         btohs(cp->handle), cp->type,
1524                                         cp->type ? "maximum" : "current");
1525 }
1526
1527 static inline void request_local_ext_features_dump(int level, struct frame *frm)
1528 {
1529         read_local_ext_features_cp *cp = frm->ptr;
1530
1531         p_indent(level, frm);
1532         printf("page %d\n", cp->page_num);
1533 }
1534
1535 static inline void request_clock_dump(int level, struct frame *frm)
1536 {
1537         read_clock_cp *cp = frm->ptr;
1538
1539         p_indent(level, frm);
1540         printf("handle %d which %d (%s)\n",
1541                                         btohs(cp->handle), cp->which_clock,
1542                                         cp->which_clock ? "piconet" : "local");
1543 }
1544
1545 static inline void host_buffer_size_dump(int level, struct frame *frm)
1546 {
1547         host_buffer_size_cp *cp = frm->ptr;
1548
1549         p_indent(level, frm);
1550         printf("ACL MTU %d:%d SCO MTU %d:%d\n",
1551                                 btohs(cp->acl_mtu), btohs(cp->acl_max_pkt),
1552                                 cp->sco_mtu, btohs(cp->sco_max_pkt));
1553 }
1554
1555 static inline void num_comp_pkts_dump(int level, struct frame *frm)
1556 {
1557         uint8_t num = p_get_u8(frm);
1558         uint16_t handle, packets;
1559         int i;
1560
1561         for (i = 0; i < num; i++) {
1562                 handle = btohs(htons(p_get_u16(frm)));
1563                 packets = btohs(htons(p_get_u16(frm)));
1564
1565                 p_indent(level, frm);
1566                 printf("handle %d packets %d\n", handle, packets);
1567         }
1568 }
1569
1570 static inline void le_create_connection_dump(int level, struct frame *frm)
1571 {
1572         char addr[18];
1573         le_create_connection_cp *cp = frm->ptr;
1574
1575         p_indent(level, frm);
1576         p_ba2str(&cp->peer_bdaddr, addr);
1577         printf("bdaddr %s type %d\n", addr, cp->peer_bdaddr_type);
1578         p_indent(level, frm);
1579         printf("interval %u window %u initiator_filter %u\n",
1580                 btohs(cp->interval), btohs(cp->window), cp->initiator_filter);
1581         p_indent(level, frm);
1582         printf("own_bdaddr_type %u min_interval %u max_interval %u\n",
1583                         cp->own_bdaddr_type, btohs(cp->min_interval),
1584                         btohs(cp->max_interval));
1585         p_indent(level, frm);
1586         printf("latency %u supervision_to %u min_ce %u max_ce %u\n",
1587                         btohs(cp->latency), btohs(cp->supervision_timeout),
1588                         btohs(cp->min_ce_length), btohs(cp->max_ce_length));
1589 }
1590
1591 static inline void le_set_event_mask_dump(int level, struct frame *frm)
1592 {
1593         int i;
1594         le_set_event_mask_cp *cp = frm->ptr;
1595
1596         p_indent(level, frm);
1597         printf("mask 0x");
1598         for (i = 0; i < 8; i++)
1599                 printf("%.2x", cp->mask[i]);
1600
1601         printf(" (%s)\n", eventmask2str(cp->mask));
1602 }
1603
1604 static inline void le_set_random_address_dump(int level, struct frame *frm)
1605 {
1606         char addr[18];
1607         le_set_random_address_cp *cp = frm->ptr;
1608
1609         p_indent(level, frm);
1610         p_ba2str(&cp->bdaddr, addr);
1611         printf("bdaddr %s\n", addr);
1612 }
1613
1614
1615 static inline void le_set_advertising_parameters_dump(int level, struct frame *frm)
1616 {
1617         char addr[18];
1618         le_set_advertising_parameters_cp *cp = frm->ptr;
1619
1620         p_indent(level, frm);
1621         printf("min %.3fms, max %.3fms\n", btohs(cp->min_interval) * 0.625,
1622                         btohs(cp->max_interval) * 0.625);
1623
1624         p_indent(level, frm);
1625         printf("type 0x%02x (%s) ownbdaddr 0x%02x (%s)\n", cp->advtype,
1626                         evttype2str(cp->advtype), cp->own_bdaddr_type,
1627                         bdaddrtype2str(cp->own_bdaddr_type));
1628
1629         p_indent(level, frm);
1630         p_ba2str(&cp->direct_bdaddr, addr);
1631         printf("directbdaddr 0x%02x (%s) %s\n", cp->direct_bdaddr_type,
1632                         bdaddrtype2str(cp->direct_bdaddr_type), addr);
1633
1634         p_indent(level, frm);
1635         printf("channelmap 0x%02x filterpolicy 0x%02x (%s)\n",
1636                         cp->chan_map, cp->filter, filterpolicy2str(cp->filter));
1637 }
1638
1639 static inline void le_set_scan_parameters_dump(int level, struct frame *frm)
1640 {
1641         le_set_scan_parameters_cp *cp = frm->ptr;
1642
1643         p_indent(level, frm);
1644         printf("type 0x%02x (%s)\n", cp->type,
1645                 cp->type == 0x00 ? "passive" : "active");
1646
1647         p_indent(level, frm);
1648         printf("interval %.3fms window %.3fms\n", btohs(cp->interval) * 0.625,
1649                 btohs(cp->window) * 0.625);
1650
1651         p_indent(level, frm);
1652         printf("own address: 0x%02x (%s) policy: %s\n", cp->own_bdaddr_type,
1653                         bdaddrtype2str(cp->own_bdaddr_type),
1654                 (cp->filter == 0x00 ? "All" :
1655                         (cp->filter == 0x01 ? "white list only" : "reserved")));
1656 }
1657
1658 static inline void le_set_scan_enable_dump(int level, struct frame *frm)
1659 {
1660         le_set_scan_enable_cp *cp = frm->ptr;
1661
1662         p_indent(level, frm);
1663         printf("value 0x%02x (%s)\n", cp->enable,
1664                 (cp->enable == 0x00 ? "scanning disabled" :
1665                 "scanning enabled"));
1666
1667         p_indent(level, frm);
1668         printf("filter duplicates 0x%02x (%s)\n", cp->filter_dup,
1669                 (cp->filter_dup == 0x00 ? "disabled" : "enabled"));
1670 }
1671
1672 static inline void write_remote_amp_assoc_cmd_dump(int level,
1673                                                         struct frame *frm)
1674 {
1675         write_remote_amp_assoc_cp *cp = frm->ptr;
1676
1677         p_indent(level, frm);
1678         printf("handle 0x%2.2x len_so_far %d remaining_len %d\n", cp->handle,
1679                                 cp->length_so_far, cp->remaining_length);
1680
1681         amp_assoc_dump(level + 1, cp->fragment, frm->len - 5);
1682 }
1683
1684 static inline void command_dump(int level, struct frame *frm)
1685 {
1686         hci_command_hdr *hdr = frm->ptr;
1687         uint16_t opcode = btohs(hdr->opcode);
1688         uint16_t ogf = cmd_opcode_ogf(opcode);
1689         uint16_t ocf = cmd_opcode_ocf(opcode);
1690
1691         if (p_filter(FILT_HCI))
1692                 return;
1693
1694         if (ogf == OGF_VENDOR_CMD && (parser.flags & DUMP_NOVENDOR))
1695                 return;
1696
1697         p_indent(level, frm);
1698         printf("HCI Command: %s (0x%2.2x|0x%4.4x) plen %d\n",
1699                                 opcode2str(opcode), ogf, ocf, hdr->plen);
1700
1701         frm->ptr += HCI_COMMAND_HDR_SIZE;
1702         frm->len -= HCI_COMMAND_HDR_SIZE;
1703
1704         if (ogf == OGF_VENDOR_CMD) {
1705                 if (ocf == 0 && get_manufacturer() == 10) {
1706                         csr_dump(level + 1, frm);
1707                         return;
1708                 }
1709         }
1710
1711         if (!(parser.flags & DUMP_VERBOSE)) {
1712                 raw_dump(level, frm);
1713                 return;
1714         }
1715
1716         switch (ogf) {
1717         case OGF_LINK_CTL:
1718                 switch (ocf) {
1719                 case OCF_INQUIRY:
1720                         inquiry_dump(level + 1, frm);
1721                         return;
1722                 case OCF_PERIODIC_INQUIRY:
1723                         periodic_inquiry_dump(level + 1, frm);
1724                         return;
1725                 case OCF_INQUIRY_CANCEL:
1726                 case OCF_EXIT_PERIODIC_INQUIRY:
1727                         return;
1728                 case OCF_CREATE_CONN:
1729                         create_conn_dump(level + 1, frm);
1730                         return;
1731                 case OCF_DISCONNECT:
1732                         disconnect_dump(level + 1, frm);
1733                         return;
1734                 case OCF_CREATE_CONN_CANCEL:
1735                 case OCF_REMOTE_NAME_REQ_CANCEL:
1736                 case OCF_ACCEPT_SYNC_CONN_REQ:
1737                         bdaddr_command_dump(level + 1, frm);
1738                         return;
1739                 case OCF_ADD_SCO:
1740                 case OCF_SET_CONN_PTYPE:
1741                         add_sco_dump(level + 1, frm);
1742                         return;
1743                 case OCF_ACCEPT_CONN_REQ:
1744                         accept_conn_req_dump(level + 1, frm);
1745                         return;
1746                 case OCF_REJECT_CONN_REQ:
1747                 case OCF_REJECT_SYNC_CONN_REQ:
1748                 case OCF_IO_CAPABILITY_NEG_REPLY:
1749                         reject_conn_req_dump(level + 1, frm);
1750                         return;
1751                 case OCF_PIN_CODE_REPLY:
1752                         pin_code_reply_dump(level + 1, frm);
1753                         return;
1754                 case OCF_LINK_KEY_REPLY:
1755                         link_key_reply_dump(level + 1, frm);
1756                         return;
1757                 case OCF_PIN_CODE_NEG_REPLY:
1758                 case OCF_LINK_KEY_NEG_REPLY:
1759                 case OCF_USER_CONFIRM_REPLY:
1760                 case OCF_USER_CONFIRM_NEG_REPLY:
1761                 case OCF_USER_PASSKEY_NEG_REPLY:
1762                 case OCF_REMOTE_OOB_DATA_NEG_REPLY:
1763                         pin_code_neg_reply_dump(level + 1, frm);
1764                         return;
1765                 case OCF_USER_PASSKEY_REPLY:
1766                         user_passkey_reply_dump(level + 1, frm);
1767                         return;
1768                 case OCF_REMOTE_OOB_DATA_REPLY:
1769                         remote_oob_data_reply_dump(level + 1, frm);
1770                         return;
1771                 case OCF_IO_CAPABILITY_REPLY:
1772                         io_capability_reply_dump(level + 1, frm);
1773                         return;
1774                 case OCF_SET_CONN_ENCRYPT:
1775                         set_conn_encrypt_dump(level + 1, frm);
1776                         return;
1777                 case OCF_AUTH_REQUESTED:
1778                 case OCF_CHANGE_CONN_LINK_KEY:
1779                 case OCF_READ_REMOTE_FEATURES:
1780                 case OCF_READ_REMOTE_VERSION:
1781                 case OCF_READ_CLOCK_OFFSET:
1782                 case OCF_READ_LMP_HANDLE:
1783                 case OCF_DISCONNECT_LOGICAL_LINK:
1784                         generic_command_dump(level + 1, frm);
1785                         return;
1786                 case OCF_MASTER_LINK_KEY:
1787                         master_link_key_dump(level + 1, frm);
1788                         return;
1789                 case OCF_READ_REMOTE_EXT_FEATURES:
1790                         read_remote_ext_features_dump(level + 1, frm);
1791                         return;
1792                 case OCF_REMOTE_NAME_REQ:
1793                         remote_name_req_dump(level + 1, frm);
1794                         return;
1795                 case OCF_SETUP_SYNC_CONN:
1796                         setup_sync_conn_dump(level + 1, frm);
1797                         return;
1798                 case OCF_CREATE_PHYSICAL_LINK:
1799                 case OCF_ACCEPT_PHYSICAL_LINK:
1800                         create_physical_link_dump(level + 1, frm);
1801                         return;
1802                 case OCF_CREATE_LOGICAL_LINK:
1803                 case OCF_ACCEPT_LOGICAL_LINK:
1804                         create_logical_link_dump(level + 1, frm);
1805                         return;
1806                 }
1807                 break;
1808
1809         case OGF_LINK_POLICY:
1810                 switch (ocf) {
1811                 case OCF_HOLD_MODE:
1812                 case OCF_PARK_MODE:
1813                         hold_mode_dump(level + 1, frm);
1814                         return;
1815                 case OCF_SNIFF_MODE:
1816                         sniff_mode_dump(level + 1, frm);
1817                         return;
1818                 case OCF_EXIT_SNIFF_MODE:
1819                 case OCF_EXIT_PARK_MODE:
1820                 case OCF_ROLE_DISCOVERY:
1821                 case OCF_READ_LINK_POLICY:
1822                         generic_command_dump(level + 1, frm);
1823                         return;
1824                 case OCF_READ_DEFAULT_LINK_POLICY:
1825                         return;
1826                 case OCF_SWITCH_ROLE:
1827                         accept_conn_req_dump(level + 1, frm);
1828                         return;
1829                 case OCF_QOS_SETUP:
1830                         qos_setup_dump(level + 1, frm);
1831                         return;
1832                 case OCF_WRITE_LINK_POLICY:
1833                         write_link_policy_dump(level + 1, frm);
1834                         return;
1835                 case OCF_WRITE_DEFAULT_LINK_POLICY:
1836                         write_default_link_policy_dump(level + 1, frm);
1837                         return;
1838                 case OCF_SNIFF_SUBRATING:
1839                         sniff_subrating_dump(level + 1, frm);
1840                         return;
1841                 }
1842                 break;
1843
1844         case OGF_HOST_CTL:
1845                 switch (ocf) {
1846                 case OCF_RESET:
1847                 case OCF_CREATE_NEW_UNIT_KEY:
1848                         return;
1849                 case OCF_SET_EVENT_MASK:
1850                 case OCF_SET_EVENT_MASK_PAGE_2:
1851                         set_event_mask_dump(level + 1, frm);
1852                         return;
1853                 case OCF_SET_EVENT_FLT:
1854                         set_event_flt_dump(level + 1, frm);
1855                         return;
1856                 case OCF_WRITE_PIN_TYPE:
1857                         write_pin_type_dump(level + 1, frm);
1858                         return;
1859                 case OCF_READ_STORED_LINK_KEY:
1860                 case OCF_DELETE_STORED_LINK_KEY:
1861                         request_stored_link_key_dump(level + 1, frm);
1862                         return;
1863                 case OCF_WRITE_STORED_LINK_KEY:
1864                         return_link_keys_dump(level + 1, frm);
1865                         return;
1866                 case OCF_CHANGE_LOCAL_NAME:
1867                         change_local_name_dump(level + 1, frm);
1868                         return;
1869                 case OCF_WRITE_CLASS_OF_DEV:
1870                         write_class_of_dev_dump(level + 1, frm);
1871                         return;
1872                 case OCF_WRITE_VOICE_SETTING:
1873                         write_voice_setting_dump(level + 1, frm);
1874                         return;
1875                 case OCF_WRITE_CURRENT_IAC_LAP:
1876                         write_current_iac_lap_dump(level + 1, frm);
1877                         return;
1878                 case OCF_WRITE_SCAN_ENABLE:
1879                 case OCF_WRITE_AUTH_ENABLE:
1880                 case OCF_SET_CONTROLLER_TO_HOST_FC:
1881                         write_scan_enable_dump(level + 1, frm);
1882                         return;
1883                 case OCF_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT:
1884                 case OCF_WRITE_CONN_ACCEPT_TIMEOUT:
1885                 case OCF_WRITE_PAGE_TIMEOUT:
1886                         write_page_timeout_dump(level + 1, frm);
1887                         return;
1888                 case OCF_WRITE_PAGE_ACTIVITY:
1889                 case OCF_WRITE_INQ_ACTIVITY:
1890                         write_page_activity_dump(level + 1, frm);
1891                         return;
1892                 case OCF_WRITE_INQUIRY_SCAN_TYPE:
1893                         write_inquiry_scan_type_dump(level + 1, frm);
1894                         return;
1895                 case OCF_WRITE_ENCRYPT_MODE:
1896                 case OCF_WRITE_INQUIRY_MODE:
1897                 case OCF_WRITE_AFH_MODE:
1898                         write_inquiry_mode_dump(level + 1, frm);
1899                         return;
1900                 case OCF_SET_AFH_CLASSIFICATION:
1901                         set_afh_classification_dump(level + 1, frm);
1902                         return;
1903                 case OCF_READ_TRANSMIT_POWER_LEVEL:
1904                         request_transmit_power_level_dump(level + 1, frm);
1905                         return;
1906                 case OCF_HOST_BUFFER_SIZE:
1907                         host_buffer_size_dump(level + 1, frm);
1908                         return;
1909                 case OCF_HOST_NUM_COMP_PKTS:
1910                         num_comp_pkts_dump(level + 1, frm);
1911                         return;
1912                 case OCF_FLUSH:
1913                 case OCF_READ_LINK_SUPERVISION_TIMEOUT:
1914                 case OCF_REFRESH_ENCRYPTION_KEY:
1915                 case OCF_READ_BEST_EFFORT_FLUSH_TIMEOUT:
1916                         generic_command_dump(level + 1, frm);
1917                         return;
1918                 case OCF_WRITE_LINK_SUPERVISION_TIMEOUT:
1919                         write_link_supervision_timeout_dump(level + 1, frm);
1920                         return;
1921                 case OCF_WRITE_EXT_INQUIRY_RESPONSE:
1922                         write_ext_inquiry_response_dump(level + 1, frm);
1923                         return;
1924                 case OCF_WRITE_SIMPLE_PAIRING_MODE:
1925                 case OCF_WRITE_FLOW_CONTROL_MODE:
1926                         generic_write_mode_dump(level + 1, frm);
1927                         return;
1928                 case OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL:
1929                         write_inquiry_transmit_power_level_dump(level + 1, frm);
1930                         return;
1931                 case OCF_WRITE_DEFAULT_ERROR_DATA_REPORTING:
1932                         write_default_error_data_reporting_dump(level + 1, frm);
1933                         return;
1934                 case OCF_ENHANCED_FLUSH:
1935                         enhanced_flush_dump(level + 1, frm);
1936                         return;
1937                 case OCF_SEND_KEYPRESS_NOTIFY:
1938                         send_keypress_notify_dump(level + 1, frm);
1939                         return;
1940                 }
1941                 break;
1942
1943         case OGF_INFO_PARAM:
1944                 switch (ocf) {
1945                 case OCF_READ_LOCAL_EXT_FEATURES:
1946                         request_local_ext_features_dump(level + 1, frm);
1947                         return;
1948                 }
1949                 break;
1950
1951         case OGF_STATUS_PARAM:
1952                 switch (ocf) {
1953                 case OCF_READ_LINK_QUALITY:
1954                 case OCF_READ_RSSI:
1955                 case OCF_READ_AFH_MAP:
1956                         generic_command_dump(level + 1, frm);
1957                         return;
1958                 case OCF_READ_CLOCK:
1959                         request_clock_dump(level + 1, frm);
1960                         return;
1961                 case OCF_WRITE_REMOTE_AMP_ASSOC:
1962                         write_remote_amp_assoc_cmd_dump(level + 1, frm);
1963                         return;
1964                 }
1965                 break;
1966
1967         case OGF_TESTING_CMD:
1968                 switch (ocf) {
1969                 case OCF_WRITE_LOOPBACK_MODE:
1970                 case OCF_WRITE_SIMPLE_PAIRING_DEBUG_MODE:
1971                         generic_write_mode_dump(level + 1, frm);
1972                         return;
1973                 }
1974                 break;
1975
1976         case OGF_LE_CTL:
1977                 switch (ocf) {
1978                 case OCF_LE_SET_EVENT_MASK:
1979                         le_set_event_mask_dump(level + 1, frm);
1980                         return;
1981                 case OCF_LE_READ_BUFFER_SIZE:
1982                 case OCF_LE_READ_LOCAL_SUPPORTED_FEATURES:
1983                 case OCF_LE_READ_ADVERTISING_CHANNEL_TX_POWER:
1984                         return;
1985                 case OCF_LE_SET_RANDOM_ADDRESS:
1986                         le_set_random_address_dump(level + 1, frm);
1987                         return;
1988                 case OCF_LE_SET_ADVERTISING_PARAMETERS:
1989                         le_set_advertising_parameters_dump(level + 1, frm);
1990                         return;
1991                 case OCF_LE_SET_SCAN_PARAMETERS:
1992                         le_set_scan_parameters_dump(level + 1, frm);
1993                         return;
1994                 case OCF_LE_SET_SCAN_ENABLE:
1995                         le_set_scan_enable_dump(level + 1, frm);
1996                         return;
1997                 case OCF_LE_CREATE_CONN:
1998                         le_create_connection_dump(level + 1, frm);
1999                         return;
2000                 }
2001                 break;
2002         }
2003
2004         raw_dump(level, frm);
2005 }
2006
2007 static inline void status_response_dump(int level, struct frame *frm)
2008 {
2009         uint8_t status = p_get_u8(frm);
2010
2011         p_indent(level, frm);
2012         printf("status 0x%2.2x\n", status);
2013
2014         if (status > 0) {
2015                 p_indent(level, frm);
2016                 printf("Error: %s\n", status2str(status));
2017         }
2018
2019         raw_dump(level, frm);
2020 }
2021
2022 static inline void handle_response_dump(int level, struct frame *frm)
2023 {
2024         uint16_t handle = btohs(htons(p_get_u16(frm)));
2025
2026         p_indent(level, frm);
2027         printf("handle %d\n", handle);
2028
2029         raw_dump(level, frm);
2030 }
2031
2032 static inline void bdaddr_response_dump(int level, struct frame *frm)
2033 {
2034         uint8_t status = p_get_u8(frm);
2035         bdaddr_t *bdaddr = frm->ptr;
2036         char addr[18];
2037
2038         frm->ptr += sizeof(bdaddr_t);
2039         frm->len -= sizeof(bdaddr_t);
2040
2041         p_indent(level, frm);
2042         p_ba2str(bdaddr, addr);
2043         printf("status 0x%2.2x bdaddr %s\n", status, addr);
2044
2045         if (status > 0) {
2046                 p_indent(level, frm);
2047                 printf("Error: %s\n", status2str(status));
2048         }
2049
2050         raw_dump(level, frm);
2051 }
2052
2053 static inline void read_data_block_size_dump(int level, struct frame *frm)
2054 {
2055         read_data_block_size_rp *rp = frm->ptr;
2056
2057         p_indent(level, frm);
2058         printf("status 0x%2.2x\n", rp->status);
2059
2060         if (rp->status > 0) {
2061                 p_indent(level, frm);
2062                 printf("Error: %s\n", status2str(rp->status));
2063         } else {
2064                 p_indent(level, frm);
2065                 printf("Max ACL %d Block len %d Num blocks %d\n",
2066                         btohs(rp->max_acl_len), btohs(rp->data_block_len),
2067                                                         btohs(rp->num_blocks));
2068         }
2069 }
2070
2071 static inline void generic_response_dump(int level, struct frame *frm)
2072 {
2073         uint8_t status = p_get_u8(frm);
2074         uint16_t handle = btohs(htons(p_get_u16(frm)));
2075
2076         p_indent(level, frm);
2077         printf("status 0x%2.2x handle %d\n", status, handle);
2078
2079         if (status > 0) {
2080                 p_indent(level, frm);
2081                 printf("Error: %s\n", status2str(status));
2082         }
2083
2084         raw_dump(level, frm);
2085 }
2086
2087 static inline void status_mode_dump(int level, struct frame *frm)
2088 {
2089         uint8_t status = p_get_u8(frm);
2090         uint8_t mode = p_get_u8(frm);
2091
2092         p_indent(level, frm);
2093         printf("status 0x%2.2x mode 0x%2.2x\n", status, mode);
2094
2095         if (status > 0) {
2096                 p_indent(level, frm);
2097                 printf("Error: %s\n", status2str(status));
2098         }
2099 }
2100
2101 static inline void read_link_policy_dump(int level, struct frame *frm)
2102 {
2103         read_link_policy_rp *rp = frm->ptr;
2104         uint16_t policy = btohs(rp->policy);
2105         char *str;
2106
2107         p_indent(level, frm);
2108         printf("status 0x%2.2x handle %d policy 0x%2.2x\n",
2109                                 rp->status, btohs(rp->handle), policy);
2110
2111         if (rp->status > 0) {
2112                 p_indent(level, frm);
2113                 printf("Error: %s\n", status2str(rp->status));
2114         } else {
2115                 str = hci_lptostr(policy);
2116                 if (str) {
2117                         p_indent(level, frm);
2118                         printf("Link policy: %s\n", str);
2119                         free(str);
2120                 }
2121         }
2122 }
2123
2124 static inline void read_default_link_policy_dump(int level, struct frame *frm)
2125 {
2126         uint8_t status = p_get_u8(frm);
2127         uint16_t policy = btohs(htons(p_get_u16(frm)));
2128         char *str;
2129
2130         p_indent(level, frm);
2131         printf("status 0x%2.2x policy 0x%2.2x\n", status, policy);
2132
2133         if (status > 0) {
2134                 p_indent(level, frm);
2135                 printf("Error: %s\n", status2str(status));
2136         } else {
2137                 str = hci_lptostr(policy);
2138                 if (str) {
2139                         p_indent(level, frm);
2140                         printf("Link policy: %s\n", str);
2141                         free(str);
2142                 }
2143         }
2144 }
2145
2146 static inline void read_pin_type_dump(int level, struct frame *frm)
2147 {
2148         read_pin_type_rp *rp = frm->ptr;
2149
2150         p_indent(level, frm);
2151         printf("status 0x%2.2x type %d\n", rp->status, rp->pin_type);
2152
2153         if (rp->status > 0) {
2154                 p_indent(level, frm);
2155                 printf("Error: %s\n", status2str(rp->status));
2156         }
2157 }
2158
2159 static inline void read_stored_link_key_dump(int level, struct frame *frm)
2160 {
2161         read_stored_link_key_rp *rp = frm->ptr;
2162
2163         p_indent(level, frm);
2164         printf("status 0x%2.2x max %d num %d\n",
2165                                 rp->status, rp->max_keys, rp->num_keys);
2166
2167         if (rp->status > 0) {
2168                 p_indent(level, frm);
2169                 printf("Error: %s\n", status2str(rp->status));
2170         }
2171 }
2172
2173 static inline void write_stored_link_key_dump(int level, struct frame *frm)
2174 {
2175         write_stored_link_key_rp *rp = frm->ptr;
2176
2177         p_indent(level, frm);
2178         printf("status 0x%2.2x written %d\n", rp->status, rp->num_keys);
2179
2180         if (rp->status > 0) {
2181                 p_indent(level, frm);
2182                 printf("Error: %s\n", status2str(rp->status));
2183         }
2184 }
2185
2186 static inline void delete_stored_link_key_dump(int level, struct frame *frm)
2187 {
2188         delete_stored_link_key_rp *rp = frm->ptr;
2189
2190         p_indent(level, frm);
2191         printf("status 0x%2.2x deleted %d\n", rp->status, btohs(rp->num_keys));
2192
2193         if (rp->status > 0) {
2194                 p_indent(level, frm);
2195                 printf("Error: %s\n", status2str(rp->status));
2196         }
2197 }
2198
2199 static inline void read_local_name_dump(int level, struct frame *frm)
2200 {
2201         read_local_name_rp *rp = frm->ptr;
2202         char name[249];
2203         int i;
2204
2205         memset(name, 0, sizeof(name));
2206         for (i = 0; i < 248 && rp->name[i]; i++)
2207                 if (isprint(rp->name[i]))
2208                         name[i] = rp->name[i];
2209                 else
2210                         name[i] = '.';
2211
2212         p_indent(level, frm);
2213         printf("status 0x%2.2x name \'%s\'\n", rp->status, name);
2214
2215         if (rp->status > 0) {
2216                 p_indent(level, frm);
2217                 printf("Error: %s\n", status2str(rp->status));
2218         }
2219 }
2220
2221 static inline void read_class_of_dev_dump(int level, struct frame *frm)
2222 {
2223         read_class_of_dev_rp *rp = frm->ptr;
2224
2225         p_indent(level, frm);
2226         printf("status 0x%2.2x class 0x%2.2x%2.2x%2.2x\n", rp->status,
2227                         rp->dev_class[2], rp->dev_class[1], rp->dev_class[0]);
2228
2229         if (rp->status > 0) {
2230                 p_indent(level, frm);
2231                 printf("Error: %s\n", status2str(rp->status));
2232         }
2233 }
2234
2235 static inline void read_voice_setting_dump(int level, struct frame *frm)
2236 {
2237         read_voice_setting_rp *rp = frm->ptr;
2238
2239         p_indent(level, frm);
2240         printf("status 0x%2.2x voice setting 0x%4.4x\n",
2241                                         rp->status, btohs(rp->voice_setting));
2242
2243         if (rp->status > 0) {
2244                 p_indent(level, frm);
2245                 printf("Error: %s\n", status2str(rp->status));
2246         }
2247 }
2248
2249 static inline void read_current_iac_lap_dump(int level, struct frame *frm)
2250 {
2251         read_current_iac_lap_rp *rp = frm->ptr;
2252         int i;
2253
2254         for (i = 0; i < rp->num_current_iac; i++) {
2255                 p_indent(level, frm);
2256                 printf("IAC 0x%2.2x%2.2x%2.2x", rp->lap[i][2], rp->lap[i][1], rp->lap[i][0]);
2257                 if (rp->lap[i][2] == 0x9e && rp->lap[i][1] == 0x8b) {
2258                         switch (rp->lap[i][0]) {
2259                         case 0x00:
2260                                 printf(" (Limited Inquiry Access Code)");
2261                                 break;
2262                         case 0x33:
2263                                 printf(" (General Inquiry Access Code)");
2264                                 break;
2265                         }
2266                 }
2267                 printf("\n");
2268         }
2269 }
2270
2271 static inline void read_scan_enable_dump(int level, struct frame *frm)
2272 {
2273         uint8_t status = p_get_u8(frm);
2274         uint8_t enable = p_get_u8(frm);
2275
2276         p_indent(level, frm);
2277         printf("status 0x%2.2x enable %d\n", status, enable);
2278
2279         if (status > 0) {
2280                 p_indent(level, frm);
2281                 printf("Error: %s\n", status2str(status));
2282         }
2283 }
2284
2285 static inline void read_page_timeout_dump(int level, struct frame *frm)
2286 {
2287         read_page_timeout_rp *rp = frm->ptr;
2288
2289         p_indent(level, frm);
2290         printf("status 0x%2.2x timeout %d\n", rp->status, btohs(rp->timeout));
2291
2292         if (rp->status > 0) {
2293                 p_indent(level, frm);
2294                 printf("Error: %s\n", status2str(rp->status));
2295         }
2296 }
2297
2298 static inline void read_page_activity_dump(int level, struct frame *frm)
2299 {
2300         read_page_activity_rp *rp = frm->ptr;
2301
2302         p_indent(level, frm);
2303         printf("status 0x%2.2x interval %d window %d\n",
2304                         rp->status, btohs(rp->interval), btohs(rp->window));
2305
2306         if (rp->status > 0) {
2307                 p_indent(level, frm);
2308                 printf("Error: %s\n", status2str(rp->status));
2309         }
2310 }
2311
2312 static inline void read_inquiry_scan_type_dump(int level, struct frame *frm)
2313 {
2314         read_inquiry_scan_type_rp *rp = frm->ptr;
2315
2316         p_indent(level, frm);
2317         printf("status 0x%2.2x type %d\n", rp->status, rp->type);
2318
2319         if (rp->status > 0) {
2320                 p_indent(level, frm);
2321                 printf("Error: %s\n", status2str(rp->status));
2322         }
2323 }
2324
2325 static inline void read_inquiry_mode_dump(int level, struct frame *frm)
2326 {
2327         read_inquiry_mode_rp *rp = frm->ptr;
2328
2329         p_indent(level, frm);
2330         printf("status 0x%2.2x mode %d\n", rp->status, rp->mode);
2331
2332         if (rp->status > 0) {
2333                 p_indent(level, frm);
2334                 printf("Error: %s\n", status2str(rp->status));
2335         }
2336 }
2337
2338 static inline void read_link_supervision_timeout_dump(int level, struct frame *frm)
2339 {
2340         read_link_supervision_timeout_rp *rp = frm->ptr;
2341
2342         p_indent(level, frm);
2343         printf("status 0x%2.2x handle %d timeout %d\n",
2344                         rp->status, btohs(rp->handle), btohs(rp->timeout));
2345
2346         if (rp->status > 0) {
2347                 p_indent(level, frm);
2348                 printf("Error: %s\n", status2str(rp->status));
2349         }
2350 }
2351
2352 static inline void read_transmit_power_level_dump(int level, struct frame *frm)
2353 {
2354         read_transmit_power_level_rp *rp = frm->ptr;
2355
2356         p_indent(level, frm);
2357         printf("status 0x%2.2x handle %d level %d\n",
2358                                 rp->status, btohs(rp->handle), rp->level);
2359
2360         if (rp->status > 0) {
2361                 p_indent(level, frm);
2362                 printf("Error: %s\n", status2str(rp->status));
2363         }
2364 }
2365
2366 static inline void read_ext_inquiry_response_dump(int level, struct frame *frm)
2367 {
2368         read_ext_inquiry_response_rp *rp = frm->ptr;
2369
2370         p_indent(level, frm);
2371         printf("status 0x%2.2x fec 0x%2.2x\n", rp->status, rp->fec);
2372
2373         if (rp->status > 0) {
2374                 p_indent(level, frm);
2375                 printf("Error: %s\n", status2str(rp->status));
2376         } else {
2377                 frm->ptr += 2;
2378                 frm->len -= 2;
2379
2380                 ext_inquiry_response_dump(level, frm);
2381         }
2382 }
2383
2384 static inline void read_inquiry_transmit_power_level_dump(int level, struct frame *frm)
2385 {
2386         read_inquiry_transmit_power_level_rp *rp = frm->ptr;
2387
2388         p_indent(level, frm);
2389         printf("status 0x%2.2x level %d\n", rp->status, rp->level);
2390
2391         if (rp->status > 0) {
2392                 p_indent(level, frm);
2393                 printf("Error: %s\n", status2str(rp->status));
2394         }
2395 }
2396
2397 static inline void read_default_error_data_reporting_dump(int level, struct frame *frm)
2398 {
2399         read_default_error_data_reporting_rp *rp = frm->ptr;
2400
2401         p_indent(level, frm);
2402         printf("status 0x%2.2x reporting %d\n", rp->status, rp->reporting);
2403
2404         if (rp->status > 0) {
2405                 p_indent(level, frm);
2406                 printf("Error: %s\n", status2str(rp->status));
2407         }
2408 }
2409
2410 static inline void read_local_oob_data_dump(int level, struct frame *frm)
2411 {
2412         read_local_oob_data_rp *rp = frm->ptr;
2413         int i;
2414
2415         p_indent(level, frm);
2416         printf("status 0x%2.2x\n", rp->status);
2417
2418         if (rp->status > 0) {
2419                 p_indent(level, frm);
2420                 printf("Error: %s\n", status2str(rp->status));
2421         } else {
2422                 p_indent(level, frm);
2423                 printf("hash 0x");
2424                 for (i = 0; i < 16; i++)
2425                         printf("%02x", rp->hash[i]);
2426                 printf("\n");
2427
2428                 p_indent(level, frm);
2429                 printf("randomizer 0x");
2430                 for (i = 0; i < 16; i++)
2431                         printf("%02x", rp->randomizer[i]);
2432                 printf("\n");
2433         }
2434 }
2435
2436 static inline void read_local_version_dump(int level, struct frame *frm)
2437 {
2438         read_local_version_rp *rp = frm->ptr;
2439         uint16_t manufacturer = btohs(rp->manufacturer);
2440
2441         p_indent(level, frm);
2442         printf("status 0x%2.2x\n", rp->status);
2443
2444         if (rp->status > 0) {
2445                 p_indent(level, frm);
2446                 printf("Error: %s\n", status2str(rp->status));
2447         } else {
2448                 char *lmpver = lmp_vertostr(rp->lmp_ver);
2449                 char *hciver = hci_vertostr(rp->hci_ver);
2450
2451                 p_indent(level, frm);
2452                 printf("HCI Version: %s (0x%x) HCI Revision: 0x%x\n",
2453                                         hciver ? hciver : "n/a",
2454                                         rp->hci_ver, btohs(rp->hci_rev));
2455                 p_indent(level, frm);
2456                 printf("LMP Version: %s (0x%x) LMP Subversion: 0x%x\n",
2457                                         lmpver ? lmpver : "n/a",
2458                                         rp->lmp_ver, btohs(rp->lmp_subver));
2459                 p_indent(level, frm);
2460                 printf("Manufacturer: %s (%d)\n",
2461                                 bt_compidtostr(manufacturer), manufacturer);
2462
2463                 if (lmpver)
2464                         free(lmpver);
2465                 if (hciver)
2466                         free(hciver);
2467         }
2468 }
2469
2470 static inline void read_local_commands_dump(int level, struct frame *frm)
2471 {
2472         read_local_commands_rp *rp = frm->ptr;
2473         int i, max = 0;
2474
2475         p_indent(level, frm);
2476         printf("status 0x%2.2x\n", rp->status);
2477
2478         if (rp->status > 0) {
2479                 p_indent(level, frm);
2480                 printf("Error: %s\n", status2str(rp->status));
2481         } else {
2482                 for (i = 0; i < 64; i++)
2483                         if (rp->commands[i])
2484                                 max = i + 1;
2485                 p_indent(level, frm);
2486                 printf("Commands: ");
2487                 for (i = 0; i < (max > 32 ? 32 : max); i++)
2488                         printf("%2.2x", rp->commands[i]);
2489                 printf("\n");
2490                 if (max > 32) {
2491                         p_indent(level, frm);
2492                         printf("          ");
2493                         for (i = 32; i < max; i++)
2494                                 printf("%2.2x", rp->commands[i]);
2495                         printf("\n");
2496                 }
2497         }
2498 }
2499
2500 static inline void read_local_features_dump(int level, struct frame *frm)
2501 {
2502         read_local_features_rp *rp = frm->ptr;
2503         int i;
2504
2505         p_indent(level, frm);
2506         printf("status 0x%2.2x\n", rp->status);
2507
2508         if (rp->status > 0) {
2509                 p_indent(level, frm);
2510                 printf("Error: %s\n", status2str(rp->status));
2511         } else {
2512                 p_indent(level, frm);
2513                 printf("Features:");
2514                 for (i = 0; i < 8; i++)
2515                         printf(" 0x%2.2x", rp->features[i]);
2516                 printf("\n");
2517         }
2518 }
2519
2520 static inline void read_local_ext_features_dump(int level, struct frame *frm)
2521 {
2522         read_local_ext_features_rp *rp = frm->ptr;
2523         int i;
2524
2525         p_indent(level, frm);
2526         printf("status 0x%2.2x page %d max %d\n",
2527                 rp->status, rp->page_num, rp->max_page_num);
2528
2529         if (rp->status > 0) {
2530                 p_indent(level, frm);
2531                 printf("Error: %s\n", status2str(rp->status));
2532         } else {
2533                 p_indent(level, frm);
2534                 printf("Features:");
2535                 for (i = 0; i < 8; i++)
2536                          printf(" 0x%2.2x", rp->features[i]);
2537                 printf("\n");
2538         }
2539 }
2540
2541 static inline void read_buffer_size_dump(int level, struct frame *frm)
2542 {
2543         read_buffer_size_rp *rp = frm->ptr;
2544
2545         p_indent(level, frm);
2546         printf("status 0x%2.2x\n", rp->status);
2547
2548         if (rp->status > 0) {
2549                 p_indent(level, frm);
2550                 printf("Error: %s\n", status2str(rp->status));
2551         } else {
2552                 p_indent(level, frm);
2553                 printf("ACL MTU %d:%d SCO MTU %d:%d\n",
2554                                 btohs(rp->acl_mtu), btohs(rp->acl_max_pkt),
2555                                 rp->sco_mtu, btohs(rp->sco_max_pkt));
2556         }
2557 }
2558
2559 static inline void read_link_quality_dump(int level, struct frame *frm)
2560 {
2561         read_link_quality_rp *rp = frm->ptr;
2562
2563         p_indent(level, frm);
2564         printf("status 0x%2.2x handle %d lq %d\n",
2565                         rp->status, btohs(rp->handle), rp->link_quality);
2566
2567         if (rp->status > 0) {
2568                 p_indent(level, frm);
2569                 printf("Error: %s\n", status2str(rp->status));
2570         }
2571 }
2572
2573 static inline void read_rssi_dump(int level, struct frame *frm)
2574 {
2575         read_rssi_rp *rp = frm->ptr;
2576
2577         p_indent(level, frm);
2578         printf("status 0x%2.2x handle %d rssi %d\n",
2579                                 rp->status, btohs(rp->handle), rp->rssi);
2580
2581         if (rp->status > 0) {
2582                 p_indent(level, frm);
2583                 printf("Error: %s\n", status2str(rp->status));
2584         }
2585 }
2586
2587 static inline void read_afh_map_dump(int level, struct frame *frm)
2588 {
2589         read_afh_map_rp *rp = frm->ptr;
2590         int i;
2591
2592         p_indent(level, frm);
2593         printf("status 0x%2.2x handle %d mode %d\n",
2594                                 rp->status, btohs(rp->handle), rp->mode);
2595
2596         if (rp->status > 0) {
2597                 p_indent(level, frm);
2598                 printf("Error: %s\n", status2str(rp->status));
2599         } else {
2600                 p_indent(level, frm);
2601                 printf("AFH map: 0x");
2602                 for (i = 0; i < 10; i++)
2603                         printf("%2.2x", rp->map[i]);
2604                 printf("\n");
2605         }
2606 }
2607
2608 static inline void read_clock_dump(int level, struct frame *frm)
2609 {
2610         read_clock_rp *rp = frm->ptr;
2611
2612         p_indent(level, frm);
2613         printf("status 0x%2.2x handle %d clock 0x%4.4x accuracy %d\n",
2614                                         rp->status, btohs(rp->handle),
2615                                         btohl(rp->clock), btohs(rp->accuracy));
2616
2617         if (rp->status > 0) {
2618                 p_indent(level, frm);
2619                 printf("Error: %s\n", status2str(rp->status));
2620         }
2621 }
2622
2623 static inline void read_local_amp_info_dump(int level, struct frame *frm)
2624 {
2625         read_local_amp_info_rp *rp = frm->ptr;
2626
2627         p_indent(level, frm);
2628         printf("status 0x%2.2x amp status 0x%2.2x\n",
2629                         rp->status, rp->amp_status);
2630         if (rp->status > 0) {
2631                 p_indent(level, frm);
2632                 printf("Error: %s\n", status2str(rp->status));
2633         } else {
2634                 p_indent(level, frm);
2635                 printf("total bandwidth %d, max guaranteed bandwidth %d\n",
2636                         btohl(rp->total_bandwidth),
2637                         btohl(rp->max_guaranteed_bandwidth));
2638                 p_indent(level, frm);
2639                 printf("min latency %d, max PDU %d, controller type 0x%2.2x\n",
2640                         btohl(rp->min_latency), btohl(rp->max_pdu_size),
2641                         rp->controller_type);
2642                 p_indent(level, frm);
2643                 printf("pal caps 0x%4.4x, max assoc len %d\n",
2644                         btohs(rp->pal_caps), btohs(rp->max_amp_assoc_length));
2645                 p_indent(level, frm);
2646                 printf("max flush timeout %d, best effort flush timeout %d\n",
2647                         btohl(rp->max_flush_timeout),
2648                         btohl(rp->best_effort_flush_timeout));
2649         }
2650 }
2651
2652 static inline void read_local_amp_assoc_dump(int level, struct frame *frm)
2653 {
2654         read_local_amp_assoc_rp *rp = frm->ptr;
2655         uint16_t len = btohs(rp->length);
2656
2657         p_indent(level, frm);
2658         printf("status 0x%2.2x handle 0x%2.2x remaining len %d\n",
2659                         rp->status, rp->handle, len);
2660         if (rp->status > 0) {
2661                 p_indent(level, frm);
2662                 printf("Error: %s\n", status2str(rp->status));
2663         } else {
2664                 amp_assoc_dump(level + 1, rp->fragment, len);
2665         }
2666 }
2667
2668 static inline void write_remote_amp_assoc_dump(int level, struct frame *frm)
2669 {
2670         write_remote_amp_assoc_rp *rp = frm->ptr;
2671
2672         p_indent(level, frm);
2673         printf("status 0x%2.2x handle 0x%2.2x\n", rp->status, rp->handle);
2674         if (rp->status > 0) {
2675                 p_indent(level, frm);
2676                 printf("Error: %s\n", status2str(rp->status));
2677         }
2678 }
2679
2680 static inline void le_read_buffer_size_response_dump(int level, struct frame *frm)
2681 {
2682         le_read_buffer_size_rp *rp = frm->ptr;
2683
2684         p_indent(level, frm);
2685         printf("status 0x%2.2x pktlen 0x%4.4x maxpkt 0x%2.2x\n", rp->status,
2686                         rp->pkt_len, rp->max_pkt);
2687
2688         if (rp->status > 0) {
2689                 p_indent(level, frm);
2690                 printf("Error: %s\n", status2str(rp->status));
2691         }
2692 }
2693
2694 static inline void le_read_local_supported_features_dump(int level, struct frame *frm)
2695 {
2696         int i;
2697         le_read_local_supported_features_rp *rp = frm->ptr;
2698
2699         p_indent(level, frm);
2700         printf("status 0x%2.2x features 0x", rp->status);
2701         for (i = 0; i < 8; i++)
2702                 printf("%2.2x", rp->features[i]);
2703         printf(" (%s)\n", lefeatures2str(rp->features));
2704
2705         if (rp->status > 0) {
2706                 p_indent(level, frm);
2707                 printf("Error: %s\n", status2str(rp->status));
2708         }
2709 }
2710
2711 static inline void le_read_advertising_channel_tx_power_dump(int level, struct frame *frm)
2712 {
2713         le_read_advertising_channel_tx_power_rp *rp = frm->ptr;
2714
2715         p_indent(level, frm);
2716         printf("status 0x%2.2x level 0x%x (dBm)\n", rp->status, rp->level);
2717
2718         if (rp->status > 0) {
2719                 p_indent(level, frm);
2720                 printf("Error: %s\n", status2str(rp->status));
2721         }
2722 }
2723
2724 static inline void cmd_complete_dump(int level, struct frame *frm)
2725 {
2726         evt_cmd_complete *evt = frm->ptr;
2727         uint16_t opcode = btohs(evt->opcode);
2728         uint16_t ogf = cmd_opcode_ogf(opcode);
2729         uint16_t ocf = cmd_opcode_ocf(opcode);
2730
2731         if (ogf == OGF_VENDOR_CMD && (parser.flags & DUMP_NOVENDOR))
2732                 return;
2733
2734         p_indent(level, frm);
2735         printf("%s (0x%2.2x|0x%4.4x) ncmd %d\n",
2736                                 opcode2str(opcode), ogf, ocf, evt->ncmd);
2737
2738         frm->ptr += EVT_CMD_COMPLETE_SIZE;
2739         frm->len -= EVT_CMD_COMPLETE_SIZE;
2740
2741         if (!(parser.flags & DUMP_VERBOSE)) {
2742                 raw_dump(level, frm);
2743                 return;
2744         }
2745
2746         switch (ogf) {
2747         case OGF_LINK_CTL:
2748                 switch (ocf) {
2749                 case OCF_INQUIRY_CANCEL:
2750                 case OCF_PERIODIC_INQUIRY:
2751                 case OCF_EXIT_PERIODIC_INQUIRY:
2752                 case OCF_READ_REMOTE_EXT_FEATURES:
2753                         status_response_dump(level, frm);
2754                         return;
2755                 case OCF_CREATE_CONN_CANCEL:
2756                 case OCF_REMOTE_NAME_REQ_CANCEL:
2757                 case OCF_PIN_CODE_REPLY:
2758                 case OCF_LINK_KEY_REPLY:
2759                 case OCF_PIN_CODE_NEG_REPLY:
2760                 case OCF_LINK_KEY_NEG_REPLY:
2761                 case OCF_USER_CONFIRM_REPLY:
2762                 case OCF_USER_CONFIRM_NEG_REPLY:
2763                 case OCF_USER_PASSKEY_REPLY:
2764                 case OCF_USER_PASSKEY_NEG_REPLY:
2765                 case OCF_REMOTE_OOB_DATA_REPLY:
2766                 case OCF_REMOTE_OOB_DATA_NEG_REPLY:
2767                 case OCF_IO_CAPABILITY_REPLY:
2768                 case OCF_IO_CAPABILITY_NEG_REPLY:
2769                         bdaddr_response_dump(level, frm);
2770                         return;
2771                 }
2772                 break;
2773
2774         case OGF_LINK_POLICY:
2775                 switch (ocf) {
2776                 case OCF_READ_LINK_POLICY:
2777                         read_link_policy_dump(level, frm);
2778                         return;
2779                 case OCF_WRITE_LINK_POLICY:
2780                 case OCF_SNIFF_SUBRATING:
2781                         generic_response_dump(level, frm);
2782                         return;
2783                 case OCF_READ_DEFAULT_LINK_POLICY:
2784                         read_default_link_policy_dump(level, frm);
2785                         return;
2786                 case OCF_WRITE_DEFAULT_LINK_POLICY:
2787                         status_response_dump(level, frm);
2788                         return;
2789                 }
2790                 break;
2791
2792         case OGF_HOST_CTL:
2793                 switch (ocf) {
2794                 case OCF_READ_PIN_TYPE:
2795                         read_pin_type_dump(level, frm);
2796                         return;
2797                 case OCF_READ_STORED_LINK_KEY:
2798                         read_stored_link_key_dump(level, frm);
2799                         return;
2800                 case OCF_WRITE_STORED_LINK_KEY:
2801                         write_stored_link_key_dump(level, frm);
2802                         return;
2803                 case OCF_DELETE_STORED_LINK_KEY:
2804                         delete_stored_link_key_dump(level, frm);
2805                         return;
2806                 case OCF_READ_LOCAL_NAME:
2807                         read_local_name_dump(level, frm);
2808                         return;
2809                 case OCF_READ_CLASS_OF_DEV:
2810                         read_class_of_dev_dump(level, frm);
2811                         return;
2812                 case OCF_READ_VOICE_SETTING:
2813                         read_voice_setting_dump(level, frm);
2814                         return;
2815                 case OCF_READ_CURRENT_IAC_LAP:
2816                         read_current_iac_lap_dump(level, frm);
2817                         return;
2818                 case OCF_READ_SCAN_ENABLE:
2819                 case OCF_READ_AUTH_ENABLE:
2820                         read_scan_enable_dump(level, frm);
2821                         return;
2822                 case OCF_READ_CONN_ACCEPT_TIMEOUT:
2823                 case OCF_READ_PAGE_TIMEOUT:
2824                 case OCF_READ_LOGICAL_LINK_ACCEPT_TIMEOUT:
2825                         read_page_timeout_dump(level, frm);
2826                         return;
2827                 case OCF_READ_PAGE_ACTIVITY:
2828                 case OCF_READ_INQ_ACTIVITY:
2829                         read_page_activity_dump(level, frm);
2830                         return;
2831                 case OCF_READ_INQUIRY_SCAN_TYPE:
2832                         read_inquiry_scan_type_dump(level, frm);
2833                         return;
2834                 case OCF_READ_ENCRYPT_MODE:
2835                 case OCF_READ_INQUIRY_MODE:
2836                 case OCF_READ_AFH_MODE:
2837                         read_inquiry_mode_dump(level, frm);
2838                         return;
2839                 case OCF_READ_LINK_SUPERVISION_TIMEOUT:
2840                         read_link_supervision_timeout_dump(level, frm);
2841                         return;
2842                 case OCF_READ_TRANSMIT_POWER_LEVEL:
2843                         read_transmit_power_level_dump(level, frm);
2844                         return;
2845                 case OCF_READ_EXT_INQUIRY_RESPONSE:
2846                         read_ext_inquiry_response_dump(level, frm);
2847                         return;
2848                 case OCF_READ_INQUIRY_TRANSMIT_POWER_LEVEL:
2849                         read_inquiry_transmit_power_level_dump(level, frm);
2850                         return;
2851                 case OCF_READ_DEFAULT_ERROR_DATA_REPORTING:
2852                         read_default_error_data_reporting_dump(level, frm);
2853                         return;
2854                 case OCF_READ_LOCAL_OOB_DATA:
2855                         read_local_oob_data_dump(level, frm);
2856                         return;
2857                 case OCF_READ_SIMPLE_PAIRING_MODE:
2858                 case OCF_READ_FLOW_CONTROL_MODE:
2859                         status_mode_dump(level, frm);
2860                         return;
2861                 case OCF_FLUSH:
2862                 case OCF_WRITE_LINK_SUPERVISION_TIMEOUT:
2863                         generic_response_dump(level, frm);
2864                         return;
2865                 case OCF_RESET:
2866                 case OCF_SET_EVENT_MASK:
2867                 case OCF_SET_EVENT_FLT:
2868                 case OCF_WRITE_PIN_TYPE:
2869                 case OCF_CREATE_NEW_UNIT_KEY:
2870                 case OCF_CHANGE_LOCAL_NAME:
2871                 case OCF_WRITE_CLASS_OF_DEV:
2872                 case OCF_WRITE_VOICE_SETTING:
2873                 case OCF_WRITE_CURRENT_IAC_LAP:
2874                 case OCF_WRITE_SCAN_ENABLE:
2875                 case OCF_WRITE_AUTH_ENABLE:
2876                 case OCF_WRITE_ENCRYPT_MODE:
2877                 case OCF_WRITE_CONN_ACCEPT_TIMEOUT:
2878                 case OCF_WRITE_PAGE_TIMEOUT:
2879                 case OCF_WRITE_PAGE_ACTIVITY:
2880                 case OCF_WRITE_INQ_ACTIVITY:
2881                 case OCF_WRITE_INQUIRY_SCAN_TYPE:
2882                 case OCF_WRITE_INQUIRY_MODE:
2883                 case OCF_WRITE_AFH_MODE:
2884                 case OCF_SET_AFH_CLASSIFICATION:
2885                 case OCF_WRITE_EXT_INQUIRY_RESPONSE:
2886                 case OCF_WRITE_SIMPLE_PAIRING_MODE:
2887                 case OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL:
2888                 case OCF_WRITE_DEFAULT_ERROR_DATA_REPORTING:
2889                 case OCF_SET_CONTROLLER_TO_HOST_FC:
2890                 case OCF_HOST_BUFFER_SIZE:
2891                 case OCF_REFRESH_ENCRYPTION_KEY:
2892                 case OCF_SEND_KEYPRESS_NOTIFY:
2893                 case OCF_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT:
2894                 case OCF_SET_EVENT_MASK_PAGE_2:
2895                 case OCF_WRITE_LOCATION_DATA:
2896                 case OCF_WRITE_FLOW_CONTROL_MODE:
2897                 case OCF_READ_BEST_EFFORT_FLUSH_TIMEOUT:
2898                 case OCF_WRITE_BEST_EFFORT_FLUSH_TIMEOUT:
2899                         status_response_dump(level, frm);
2900                         return;
2901                 }
2902                 break;
2903
2904         case OGF_INFO_PARAM:
2905                 switch (ocf) {
2906                 case OCF_READ_LOCAL_VERSION:
2907                         read_local_version_dump(level, frm);
2908                         return;
2909                 case OCF_READ_LOCAL_COMMANDS:
2910                         read_local_commands_dump(level, frm);
2911                         return;
2912                 case OCF_READ_LOCAL_FEATURES:
2913                         read_local_features_dump(level, frm);
2914                         return;
2915                 case OCF_READ_LOCAL_EXT_FEATURES:
2916                         read_local_ext_features_dump(level, frm);
2917                         return;
2918                 case OCF_READ_BUFFER_SIZE:
2919                         read_buffer_size_dump(level, frm);
2920                         return;
2921                 case OCF_READ_BD_ADDR:
2922                         bdaddr_response_dump(level, frm);
2923                         return;
2924                 case OCF_READ_DATA_BLOCK_SIZE:
2925                         read_data_block_size_dump(level, frm);
2926                         return;
2927                 }
2928                 break;
2929
2930         case OGF_STATUS_PARAM:
2931                 switch (ocf) {
2932                 case OCF_READ_FAILED_CONTACT_COUNTER:
2933                 case OCF_RESET_FAILED_CONTACT_COUNTER:
2934                         status_response_dump(level, frm);
2935                         return;
2936                 case OCF_READ_LINK_QUALITY:
2937                         read_link_quality_dump(level, frm);
2938                         return;
2939                 case OCF_READ_RSSI:
2940                         read_rssi_dump(level, frm);
2941                         return;
2942                 case OCF_READ_AFH_MAP:
2943                         read_afh_map_dump(level, frm);
2944                         return;
2945                 case OCF_READ_CLOCK:
2946                         read_clock_dump(level, frm);
2947                         return;
2948                 case OCF_READ_LOCAL_AMP_INFO:
2949                         read_local_amp_info_dump(level, frm);
2950                         return;
2951                 case OCF_READ_LOCAL_AMP_ASSOC:
2952                         read_local_amp_assoc_dump(level, frm);
2953                         return;
2954                 case OCF_WRITE_REMOTE_AMP_ASSOC:
2955                         write_remote_amp_assoc_dump(level, frm);
2956                         return;
2957                 }
2958                 break;
2959
2960         case OGF_TESTING_CMD:
2961                 switch (ocf) {
2962                 case OCF_READ_LOOPBACK_MODE:
2963                         status_mode_dump(level, frm);
2964                         return;
2965                 case OCF_WRITE_LOOPBACK_MODE:
2966                 case OCF_ENABLE_DEVICE_UNDER_TEST_MODE:
2967                 case OCF_WRITE_SIMPLE_PAIRING_DEBUG_MODE:
2968                         status_response_dump(level, frm);
2969                         return;
2970                 }
2971                 break;
2972
2973         case OGF_LE_CTL:
2974                 switch (ocf) {
2975                 case OCF_LE_SET_EVENT_MASK:
2976                 case OCF_LE_SET_RANDOM_ADDRESS:
2977                 case OCF_LE_SET_ADVERTISING_PARAMETERS:
2978                 case OCF_LE_SET_ADVERTISING_DATA:
2979                 case OCF_LE_SET_SCAN_RESPONSE_DATA:
2980                 case OCF_LE_SET_ADVERTISE_ENABLE:
2981                 case OCF_LE_SET_SCAN_PARAMETERS:
2982                 case OCF_LE_SET_SCAN_ENABLE:
2983                 case OCF_LE_CREATE_CONN:
2984                 case OCF_LE_CLEAR_WHITE_LIST:
2985                 case OCF_LE_ADD_DEVICE_TO_WHITE_LIST:
2986                 case OCF_LE_REMOVE_DEVICE_FROM_WHITE_LIST:
2987                 case OCF_LE_SET_HOST_CHANNEL_CLASSIFICATION:
2988                 case OCF_LE_RECEIVER_TEST:
2989                 case OCF_LE_TRANSMITTER_TEST:
2990                         status_response_dump(level, frm);
2991                         return;
2992                 case OCF_LE_READ_BUFFER_SIZE:
2993                         le_read_buffer_size_response_dump(level, frm);
2994                         return;
2995                 case OCF_LE_READ_LOCAL_SUPPORTED_FEATURES:
2996                         le_read_local_supported_features_dump(level, frm);
2997                         return;
2998                 case OCF_LE_READ_ADVERTISING_CHANNEL_TX_POWER:
2999                         le_read_advertising_channel_tx_power_dump(level, frm);
3000                         return;
3001                 }
3002                 break;
3003         }
3004
3005         raw_dump(level, frm);
3006 }
3007
3008 static inline void cmd_status_dump(int level, struct frame *frm)
3009 {
3010         evt_cmd_status *evt = frm->ptr;
3011         uint16_t opcode = btohs(evt->opcode);
3012         uint16_t ogf = cmd_opcode_ogf(opcode);
3013         uint16_t ocf = cmd_opcode_ocf(opcode);
3014
3015         if (ogf == OGF_VENDOR_CMD && (parser.flags & DUMP_NOVENDOR))
3016                 return;
3017
3018         p_indent(level, frm);
3019         printf("%s (0x%2.2x|0x%4.4x) status 0x%2.2x ncmd %d\n",
3020                         opcode2str(opcode), ogf, ocf, evt->status, evt->ncmd);
3021
3022         if (evt->status > 0) {
3023                 p_indent(level, frm);
3024                 printf("Error: %s\n", status2str(evt->status));
3025         }
3026 }
3027
3028 static inline void hardware_error_dump(int level, struct frame *frm)
3029 {
3030         evt_hardware_error *evt = frm->ptr;
3031
3032         p_indent(level, frm);
3033         printf("code %d\n", evt->code);
3034 }
3035
3036 static inline void inq_result_dump(int level, struct frame *frm)
3037 {
3038         uint8_t num = p_get_u8(frm);
3039         char addr[18];
3040         int i;
3041
3042         for (i = 0; i < num; i++) {
3043                 inquiry_info *info = frm->ptr;
3044
3045                 p_ba2str(&info->bdaddr, addr);
3046
3047                 p_indent(level, frm);
3048                 printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x\n",
3049                         addr, info->pscan_rep_mode, btohs(info->clock_offset),
3050                         info->dev_class[2], info->dev_class[1], info->dev_class[0]);
3051
3052                 frm->ptr += INQUIRY_INFO_SIZE;
3053                 frm->len -= INQUIRY_INFO_SIZE;
3054         }
3055 }
3056
3057 static inline void conn_complete_dump(int level, struct frame *frm)
3058 {
3059         evt_conn_complete *evt = frm->ptr;
3060         char addr[18];
3061
3062         p_ba2str(&evt->bdaddr, addr);
3063
3064         p_indent(level, frm);
3065         printf("status 0x%2.2x handle %d bdaddr %s type %s encrypt 0x%2.2x\n",
3066                         evt->status, btohs(evt->handle), addr,
3067                         linktype2str(evt->link_type), evt->encr_mode);
3068
3069         if (evt->status > 0) {
3070                 p_indent(level, frm);
3071                 printf("Error: %s\n", status2str(evt->status));
3072         }
3073 }
3074
3075 static inline void conn_request_dump(int level, struct frame *frm)
3076 {
3077         evt_conn_request *evt = frm->ptr;
3078         char addr[18];
3079
3080         p_ba2str(&evt->bdaddr, addr);
3081
3082         p_indent(level, frm);
3083         printf("bdaddr %s class 0x%2.2x%2.2x%2.2x type %s\n",
3084                         addr, evt->dev_class[2], evt->dev_class[1],
3085                         evt->dev_class[0], linktype2str(evt->link_type));
3086 }
3087
3088 static inline void disconn_complete_dump(int level, struct frame *frm)
3089 {
3090         evt_disconn_complete *evt = frm->ptr;
3091
3092         p_indent(level, frm);
3093         printf("status 0x%2.2x handle %d reason 0x%2.2x\n",
3094                                 evt->status, btohs(evt->handle), evt->reason);
3095
3096         if (evt->status > 0) {
3097                 p_indent(level, frm);
3098                 printf("Error: %s\n", status2str(evt->status));
3099         } else if (evt->reason > 0) {
3100                 p_indent(level, frm);
3101                 printf("Reason: %s\n", status2str(evt->reason));
3102         }
3103 }
3104
3105 static inline void remote_name_req_complete_dump(int level, struct frame *frm)
3106 {
3107         evt_remote_name_req_complete *evt = frm->ptr;
3108         char addr[18], name[249];
3109         int i;
3110
3111         p_ba2str(&evt->bdaddr, addr);
3112
3113         memset(name, 0, sizeof(name));
3114         for (i = 0; i < 248 && evt->name[i]; i++)
3115                 if (isprint(evt->name[i]))
3116                         name[i] = evt->name[i];
3117                 else
3118                         name[i] = '.';
3119
3120         p_indent(level, frm);
3121         printf("status 0x%2.2x bdaddr %s name '%s'\n", evt->status, addr, name);
3122
3123         if (evt->status > 0) {
3124                 p_indent(level, frm);
3125                 printf("Error: %s\n", status2str(evt->status));
3126         }
3127 }
3128
3129 static inline void master_link_key_complete_dump(int level, struct frame *frm)
3130 {
3131         evt_master_link_key_complete *evt = frm->ptr;
3132
3133         p_indent(level, frm);
3134         printf("status 0x%2.2x handle %d flag %d\n",
3135                                 evt->status, btohs(evt->handle), evt->key_flag);
3136
3137         if (evt->status > 0) {
3138                 p_indent(level, frm);
3139                 printf("Error: %s\n", status2str(evt->status));
3140         }
3141 }
3142
3143 static inline void encrypt_change_dump(int level, struct frame *frm)
3144 {
3145         evt_encrypt_change *evt = frm->ptr;
3146
3147         p_indent(level, frm);
3148         printf("status 0x%2.2x handle %d encrypt 0x%2.2x\n",
3149                                 evt->status, btohs(evt->handle), evt->encrypt);
3150
3151         if (evt->status > 0) {
3152                 p_indent(level, frm);
3153                 printf("Error: %s\n", status2str(evt->status));
3154         }
3155 }
3156
3157 static inline void read_remote_features_complete_dump(int level, struct frame *frm)
3158 {
3159         evt_read_remote_features_complete *evt = frm->ptr;
3160         int i;
3161
3162         p_indent(level, frm);
3163         printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
3164
3165         if (evt->status > 0) {
3166                 p_indent(level, frm);
3167                 printf("Error: %s\n", status2str(evt->status));
3168         } else {
3169                 p_indent(level, frm);
3170                 printf("Features:");
3171                 for (i = 0; i < 8; i++)
3172                         printf(" 0x%2.2x", evt->features[i]);
3173                 printf("\n");
3174         }
3175 }
3176
3177 static inline void read_remote_version_complete_dump(int level, struct frame *frm)
3178 {
3179         evt_read_remote_version_complete *evt = frm->ptr;
3180         uint16_t manufacturer = btohs(evt->manufacturer);
3181
3182         p_indent(level, frm);
3183         printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
3184
3185         if (evt->status > 0) {
3186                 p_indent(level, frm);
3187                 printf("Error: %s\n", status2str(evt->status));
3188         } else {
3189                 char *lmpver = lmp_vertostr(evt->lmp_ver);
3190
3191                 p_indent(level, frm);
3192                 printf("LMP Version: %s (0x%x) LMP Subversion: 0x%x\n",
3193                         lmpver ? lmpver : "n/a", evt->lmp_ver,
3194                         btohs(evt->lmp_subver));
3195                 p_indent(level, frm);
3196                 printf("Manufacturer: %s (%d)\n",
3197                         bt_compidtostr(manufacturer), manufacturer);
3198
3199                 if (lmpver)
3200                         free(lmpver);
3201         }
3202 }
3203
3204 static inline void qos_setup_complete_dump(int level, struct frame *frm)
3205 {
3206         evt_qos_setup_complete *evt = frm->ptr;
3207
3208         p_indent(level, frm);
3209         printf("status 0x%2.2x handle %d flags %d\n",
3210                                 evt->status, btohs(evt->handle), evt->flags);
3211
3212         if (evt->status > 0) {
3213                 p_indent(level, frm);
3214                 printf("Error: %s\n", status2str(evt->status));
3215         } else {
3216                 p_indent(level, frm);
3217                 printf("Service type: %d\n", evt->qos.service_type);
3218                 p_indent(level, frm);
3219                 printf("Token rate: %d\n", btohl(evt->qos.token_rate));
3220                 p_indent(level, frm);
3221                 printf("Peak bandwith: %d\n", btohl(evt->qos.peak_bandwidth));
3222                 p_indent(level, frm);
3223                 printf("Latency: %d\n", btohl(evt->qos.latency));
3224                 p_indent(level, frm);
3225                 printf("Delay variation: %d\n", btohl(evt->qos.delay_variation));
3226         }
3227 }
3228
3229 static inline void role_change_dump(int level, struct frame *frm)
3230 {
3231         evt_role_change *evt = frm->ptr;
3232         char addr[18];
3233
3234         p_indent(level, frm);
3235         p_ba2str(&evt->bdaddr, addr);
3236         printf("status 0x%2.2x bdaddr %s role 0x%2.2x\n",
3237                                                 evt->status, addr, evt->role);
3238
3239         if (evt->status > 0) {
3240                 p_indent(level, frm);
3241                 printf("Error: %s\n", status2str(evt->status));
3242         } else {
3243                 p_indent(level, frm);
3244                 printf("Role: %s\n", role2str(evt->role));
3245         }
3246 }
3247
3248 static inline void mode_change_dump(int level, struct frame *frm)
3249 {
3250         evt_mode_change *evt = frm->ptr;
3251
3252         p_indent(level, frm);
3253         printf("status 0x%2.2x handle %d mode 0x%2.2x interval %d\n",
3254                 evt->status, btohs(evt->handle), evt->mode, btohs(evt->interval));
3255
3256         if (evt->status > 0) {
3257                 p_indent(level, frm);
3258                 printf("Error: %s\n", status2str(evt->status));
3259         } else {
3260                 p_indent(level, frm);
3261                 printf("Mode: %s\n", mode2str(evt->mode));
3262         }
3263 }
3264
3265 static inline void pin_code_req_dump(int level, struct frame *frm)
3266 {
3267         evt_pin_code_req *evt = frm->ptr;
3268         char addr[18];
3269
3270         p_indent(level, frm);
3271         p_ba2str(&evt->bdaddr, addr);
3272         printf("bdaddr %s\n", addr);
3273 }
3274
3275 static inline void link_key_notify_dump(int level, struct frame *frm)
3276 {
3277         evt_link_key_notify *evt = frm->ptr;
3278         char addr[18];
3279         int i;
3280
3281         p_indent(level, frm);
3282         p_ba2str(&evt->bdaddr, addr);
3283         printf("bdaddr %s key ", addr);
3284         for (i = 0; i < 16; i++)
3285                 if (parser.flags & DUMP_NOVENDOR)
3286                         printf("**");
3287                 else
3288                         printf("%2.2X", evt->link_key[i]);
3289         printf(" type %d\n", evt->key_type);
3290
3291         p_indent(level, frm);
3292         printf("Type: %s\n", keytype2str(evt->key_type));
3293 }
3294
3295 static inline void max_slots_change_dump(int level, struct frame *frm)
3296 {
3297         evt_max_slots_change *evt = frm->ptr;
3298
3299         p_indent(level, frm);
3300         printf("handle %d slots %d\n", btohs(evt->handle), evt->max_slots);
3301 }
3302
3303 static inline void data_buffer_overflow_dump(int level, struct frame *frm)
3304 {
3305         evt_data_buffer_overflow *evt = frm->ptr;
3306
3307         p_indent(level, frm);
3308         printf("type %s\n", linktype2str(evt->link_type));
3309 }
3310
3311 static inline void read_clock_offset_complete_dump(int level, struct frame *frm)
3312 {
3313         evt_read_clock_offset_complete *evt = frm->ptr;
3314
3315         p_indent(level, frm);
3316         printf("status 0x%2.2x handle %d clkoffset 0x%4.4x\n",
3317                 evt->status, btohs(evt->handle), btohs(evt->clock_offset));
3318
3319         if (evt->status > 0) {
3320                 p_indent(level, frm);
3321                 printf("Error: %s\n", status2str(evt->status));
3322         }
3323 }
3324
3325 static inline void conn_ptype_changed_dump(int level, struct frame *frm)
3326 {
3327         evt_conn_ptype_changed *evt = frm->ptr;
3328         uint16_t ptype = btohs(evt->ptype);
3329         char *str;
3330
3331         p_indent(level, frm);
3332         printf("status 0x%2.2x handle %d ptype 0x%4.4x\n",
3333                                 evt->status, btohs(evt->handle), ptype);
3334
3335         if (evt->status > 0) {
3336                 p_indent(level, frm);
3337                 printf("Error: %s\n", status2str(evt->status));
3338         } else {
3339                 str = hci_ptypetostr(ptype);
3340                 if (str) {
3341                         p_indent(level, frm);
3342                         printf("Packet type: %s\n", str);
3343                         free(str);
3344                 }
3345         }
3346 }
3347
3348 static inline void pscan_rep_mode_change_dump(int level, struct frame *frm)
3349 {
3350         evt_pscan_rep_mode_change *evt = frm->ptr;
3351         char addr[18];
3352
3353         p_indent(level, frm);
3354         p_ba2str(&evt->bdaddr, addr);
3355         printf("bdaddr %s mode %d\n", addr, evt->pscan_rep_mode);
3356 }
3357
3358 static inline void flow_spec_complete_dump(int level, struct frame *frm)
3359 {
3360         evt_flow_spec_complete *evt = frm->ptr;
3361
3362         p_indent(level, frm);
3363         printf("status 0x%2.2x handle 0x%4.4x flags %d %s\n",
3364                                 evt->status, btohs(evt->handle), evt->flags,
3365                                 evt->direction == 0 ? "outgoing" : "incoming");
3366
3367         if (evt->status > 0) {
3368                 p_indent(level, frm);
3369                 printf("Error: %s\n", status2str(evt->status));
3370         } else {
3371                 p_indent(level, frm);
3372                 printf("Service type: %d\n", evt->qos.service_type);
3373                 p_indent(level, frm);
3374                 printf("Token rate: %d\n", btohl(evt->qos.token_rate));
3375                 p_indent(level, frm);
3376                 printf("Peak bandwith: %d\n", btohl(evt->qos.peak_bandwidth));
3377                 p_indent(level, frm);
3378                 printf("Latency: %d\n", btohl(evt->qos.latency));
3379                 p_indent(level, frm);
3380                 printf("Delay variation: %d\n", btohl(evt->qos.delay_variation));
3381         }
3382 }
3383
3384 static inline void inq_result_with_rssi_dump(int level, struct frame *frm)
3385 {
3386         uint8_t num = p_get_u8(frm);
3387         char addr[18];
3388         int i;
3389
3390         if (!num)
3391                 return;
3392
3393         if (frm->len / num == INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE) {
3394                 for (i = 0; i < num; i++) {
3395                         inquiry_info_with_rssi_and_pscan_mode *info = frm->ptr;
3396
3397                         p_indent(level, frm);
3398
3399                         p_ba2str(&info->bdaddr, addr);
3400                         printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x rssi %d\n",
3401                                 addr, info->pscan_rep_mode, btohs(info->clock_offset),
3402                                 info->dev_class[2], info->dev_class[1], info->dev_class[0], info->rssi);
3403
3404                         frm->ptr += INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE;
3405                         frm->len -= INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE;
3406                 }
3407         } else {
3408                 for (i = 0; i < num; i++) {
3409                         inquiry_info_with_rssi *info = frm->ptr;
3410
3411                         p_indent(level, frm);
3412
3413                         p_ba2str(&info->bdaddr, addr);
3414                         printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x rssi %d\n",
3415                                 addr, info->pscan_rep_mode, btohs(info->clock_offset),
3416                                 info->dev_class[2], info->dev_class[1], info->dev_class[0], info->rssi);
3417
3418                         frm->ptr += INQUIRY_INFO_WITH_RSSI_SIZE;
3419                         frm->len -= INQUIRY_INFO_WITH_RSSI_SIZE;
3420                 }
3421         }
3422 }
3423
3424 static inline void read_remote_ext_features_complete_dump(int level, struct frame *frm)
3425 {
3426         evt_read_remote_ext_features_complete *evt = frm->ptr;
3427         int i;
3428
3429         p_indent(level, frm);
3430         printf("status 0x%2.2x handle %d page %d max %d\n",
3431                                         evt->status, btohs(evt->handle),
3432                                         evt->page_num, evt->max_page_num);
3433
3434         if (evt->status > 0) {
3435                 p_indent(level, frm);
3436                 printf("Error: %s\n", status2str(evt->status));
3437         } else {
3438                 p_indent(level, frm);
3439                 printf("Features:");
3440                 for (i = 0; i < 8; i++)
3441                         printf(" 0x%2.2x", evt->features[i]);
3442                 printf("\n");
3443         }
3444 }
3445
3446 static inline void sync_conn_complete_dump(int level, struct frame *frm)
3447 {
3448         evt_sync_conn_complete *evt = frm->ptr;
3449         char addr[18];
3450
3451         p_ba2str(&evt->bdaddr, addr);
3452
3453         p_indent(level, frm);
3454         printf("status 0x%2.2x handle %d bdaddr %s type %s\n",
3455                                         evt->status, btohs(evt->handle), addr,
3456                                         evt->link_type == 0 ? "SCO" : "eSCO");
3457
3458         if (evt->status > 0) {
3459                 p_indent(level, frm);
3460                 printf("Error: %s\n", status2str(evt->status));
3461         } else {
3462                 p_indent(level, frm);
3463                 printf("Air mode: %s\n", airmode2str(evt->air_mode));
3464         }
3465 }
3466
3467 static inline void sync_conn_changed_dump(int level, struct frame *frm)
3468 {
3469         evt_sync_conn_changed *evt = frm->ptr;
3470
3471         p_indent(level, frm);
3472         printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
3473
3474         if (evt->status > 0) {
3475                 p_indent(level, frm);
3476                 printf("Error: %s\n", status2str(evt->status));
3477         }
3478 }
3479
3480 static inline void sniff_subrating_event_dump(int level, struct frame *frm)
3481 {
3482         evt_sniff_subrating *evt = frm->ptr;
3483
3484         p_indent(level, frm);
3485         printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
3486
3487         if (evt->status > 0) {
3488                 p_indent(level, frm);
3489                 printf("Error: %s\n", status2str(evt->status));
3490         } else {
3491                 p_indent(level, frm);
3492                 printf("max latency transmit %d receive %d\n",
3493                                         btohs(evt->max_tx_latency),
3494                                         btohs(evt->max_rx_latency));
3495
3496                 p_indent(level, frm);
3497                 printf("min timeout remote %d local %d\n",
3498                                         btohs(evt->min_remote_timeout),
3499                                         btohs(evt->min_local_timeout));
3500         }
3501 }
3502
3503 static inline void extended_inq_result_dump(int level, struct frame *frm)
3504 {
3505         uint8_t num = p_get_u8(frm);
3506         char addr[18];
3507         int i;
3508
3509         for (i = 0; i < num; i++) {
3510                 extended_inquiry_info *info = frm->ptr;
3511
3512                 p_ba2str(&info->bdaddr, addr);
3513
3514                 p_indent(level, frm);
3515                 printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x rssi %d\n",
3516                         addr, info->pscan_rep_mode, btohs(info->clock_offset),
3517                         info->dev_class[2], info->dev_class[1], info->dev_class[0], info->rssi);
3518
3519                 frm->ptr += INQUIRY_INFO_WITH_RSSI_SIZE;
3520                 frm->len -= INQUIRY_INFO_WITH_RSSI_SIZE;
3521
3522                 ext_inquiry_response_dump(level, frm);
3523         }
3524 }
3525
3526 static inline void link_supervision_timeout_changed_dump(int level, struct frame *frm)
3527 {
3528         evt_link_supervision_timeout_changed *evt = frm->ptr;
3529
3530         p_indent(level, frm);
3531         printf("handle %d timeout %d\n",
3532                                 btohs(evt->handle), btohs(evt->timeout));
3533 }
3534
3535 static inline void user_passkey_notify_dump(int level, struct frame *frm)
3536 {
3537         evt_user_passkey_notify *evt = frm->ptr;
3538         char addr[18];
3539
3540         p_indent(level, frm);
3541         p_ba2str(&evt->bdaddr, addr);
3542         printf("bdaddr %s passkey %d\n", addr, btohl(evt->passkey));
3543 }
3544
3545 static inline void keypress_notify_dump(int level, struct frame *frm)
3546 {
3547         evt_keypress_notify *evt = frm->ptr;
3548         char addr[18];
3549
3550         p_indent(level, frm);
3551         p_ba2str(&evt->bdaddr, addr);
3552         printf("bdaddr %s type %d\n", addr, evt->type);
3553 }
3554
3555 static inline void remote_host_features_notify_dump(int level, struct frame *frm)
3556 {
3557         evt_remote_host_features_notify *evt = frm->ptr;
3558         char addr[18];
3559         int i;
3560
3561         p_indent(level, frm);
3562         p_ba2str(&evt->bdaddr, addr);
3563         printf("bdaddr %s\n", addr);
3564
3565         p_indent(level, frm);
3566         printf("Features:");
3567         for (i = 0; i < 8; i++)
3568                 printf(" 0x%2.2x", evt->features[i]);
3569         printf("\n");
3570 }
3571
3572 static inline void evt_le_conn_complete_dump(int level, struct frame *frm)
3573 {
3574         evt_le_connection_complete *evt = frm->ptr;
3575         char addr[18];
3576
3577         p_indent(level, frm);
3578         printf("status 0x%2.2x handle %d, role %s\n",
3579                                         evt->status, btohs(evt->handle),
3580                                         evt->role ? "slave" : "master");
3581
3582         p_indent(level, frm);
3583         p_ba2str(&evt->peer_bdaddr, addr);
3584         printf("bdaddr %s (%s)\n", addr, bdaddrtype2str(evt->peer_bdaddr_type));
3585 }
3586
3587 static inline void evt_le_advertising_report_dump(int level, struct frame *frm)
3588 {
3589         uint8_t num_reports = p_get_u8(frm);
3590         const uint8_t RSSI_SIZE = 1;
3591
3592         while (num_reports--) {
3593                 char addr[18];
3594                 le_advertising_info *info = frm->ptr;
3595                 int offset = 0;
3596
3597                 p_ba2str(&info->bdaddr, addr);
3598
3599                 p_indent(level, frm);
3600                 printf("%s (%d)\n", evttype2str(info->evt_type), info->evt_type);
3601
3602                 p_indent(level, frm);
3603                 printf("bdaddr %s (%s)\n", addr,
3604                                         bdaddrtype2str(info->bdaddr_type));
3605
3606                 while (offset < info->length) {
3607                         int eir_data_len = info->data[offset];
3608
3609                         ext_inquiry_data_dump(level, frm, &info->data[offset]);
3610
3611                         offset += eir_data_len + 1;
3612                 }
3613
3614                 frm->ptr += LE_ADVERTISING_INFO_SIZE + info->length;
3615                 frm->len -= LE_ADVERTISING_INFO_SIZE + info->length;
3616
3617                 p_indent(level, frm);
3618                 printf("RSSI: %d\n", ((int8_t *) frm->ptr)[frm->len - 1]);
3619
3620                 frm->ptr += RSSI_SIZE;
3621                 frm->len -= RSSI_SIZE;
3622         }
3623 }
3624
3625 static inline void evt_le_conn_update_complete_dump(int level,
3626                                                         struct frame *frm)
3627 {
3628         evt_le_connection_update_complete *uevt = frm->ptr;
3629
3630         p_indent(level, frm);
3631         printf("status 0x%2.2x handle %d\n", uevt->status, btohs(uevt->handle));
3632
3633         p_indent(level, frm);
3634         printf("interval %.2fms, latency %.2fms, superv. timeout %.2fms\n",
3635                         btohs(uevt->interval) * 1.25, btohs(uevt->latency) * 1.25,
3636                         btohs(uevt->supervision_timeout) * 10.0);
3637 }
3638
3639 static inline void evt_le_read_remote_used_features_complete_dump(int level, struct frame *frm)
3640 {
3641         int i;
3642         evt_le_read_remote_used_features_complete *revt = frm->ptr;
3643
3644         p_indent(level, frm);
3645         printf("status 0x%2.2x handle %d\n", revt->status, btohs(revt->handle));
3646
3647         if (revt->status > 0) {
3648                 p_indent(level, frm);
3649                 printf("Error: %s\n", status2str(revt->status));
3650         } else {
3651                 p_indent(level, frm);
3652                 printf("Features:");
3653                 for (i = 0; i < 8; i++)
3654                         printf(" 0x%2.2x", revt->features[i]);
3655                 printf("\n");
3656         }
3657 }
3658
3659 static inline void le_meta_ev_dump(int level, struct frame *frm)
3660 {
3661         evt_le_meta_event *mevt = frm->ptr;
3662         uint8_t subevent;
3663
3664         subevent = mevt->subevent;
3665
3666         frm->ptr += EVT_LE_META_EVENT_SIZE;
3667         frm->len -= EVT_LE_META_EVENT_SIZE;
3668
3669         p_indent(level, frm);
3670         printf("%s\n", ev_le_meta_str[subevent]);
3671
3672         switch (mevt->subevent) {
3673         case EVT_LE_CONN_COMPLETE:
3674                 evt_le_conn_complete_dump(level + 1, frm);
3675                 break;
3676         case EVT_LE_ADVERTISING_REPORT:
3677                 evt_le_advertising_report_dump(level + 1, frm);
3678                 break;
3679         case EVT_LE_CONN_UPDATE_COMPLETE:
3680                 evt_le_conn_update_complete_dump(level + 1, frm);
3681                 break;
3682         case EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE:
3683                 evt_le_read_remote_used_features_complete_dump(level + 1, frm);
3684                 break;
3685         default:
3686                 raw_dump(level, frm);
3687                 break;
3688         }
3689 }
3690
3691 static inline void phys_link_complete_dump(int level, struct frame *frm)
3692 {
3693         evt_physical_link_complete *evt = frm->ptr;
3694
3695         p_indent(level, frm);
3696         printf("status 0x%2.2x phy handle 0x%2.2x\n", evt->status, evt->handle);
3697
3698         if (evt->status > 0) {
3699                 p_indent(level, frm);
3700                 printf("Error: %s\n", status2str(evt->status));
3701         }
3702 }
3703
3704 static inline void disconn_phys_link_complete_dump(int level, struct frame *frm)
3705 {
3706         evt_disconn_physical_link_complete *evt = frm->ptr;
3707
3708         p_indent(level, frm);
3709         printf("status 0x%2.2x handle 0x%2.2x reason 0x%2.2x\n",
3710                                 evt->status, evt->handle, evt->reason);
3711
3712         if (evt->status > 0) {
3713                 p_indent(level, frm);
3714                 printf("Error: %s\n", status2str(evt->status));
3715         } else if (evt->reason > 0) {
3716                 p_indent(level, frm);
3717                 printf("Reason: %s\n", status2str(evt->reason));
3718         }
3719 }
3720
3721 static inline void phys_link_loss_warning_dump(int level, struct frame *frm)
3722 {
3723         evt_physical_link_loss_warning *evt = frm->ptr;
3724
3725         p_indent(level, frm);
3726         printf("phy handle 0x%2.2x reason 0x%2.2x\n", evt->handle, evt->reason);
3727 }
3728
3729 static inline void phys_link_handle_dump(int level, struct frame *frm)
3730 {
3731         evt_physical_link_recovery *evt = frm->ptr;
3732
3733         p_indent(level, frm);
3734         printf("phy handle 0x%2.2x\n", evt->handle);
3735 }
3736
3737 static inline void logical_link_complete_dump(int level, struct frame *frm)
3738 {
3739         evt_logical_link_complete *evt = frm->ptr;
3740
3741         p_indent(level, frm);
3742         printf("status 0x%2.2x log handle 0x%4.4x phy handle 0x%2.2x"
3743                                                         " tx_flow_id %d\n",
3744                         evt->status, btohs(evt->log_handle), evt->handle,
3745                         evt->tx_flow_id);
3746
3747         if (evt->status > 0) {
3748                 p_indent(level, frm);
3749                 printf("Error: %s\n", status2str(evt->status));
3750         }
3751 }
3752
3753 static inline void flow_spec_modify_dump(int level, struct frame *frm)
3754 {
3755         evt_flow_spec_modify_complete *evt = frm->ptr;
3756
3757         p_indent(level, frm);
3758         printf("status 0x%2.2x handle 0x%4.4x\n",
3759                                         evt->status, btohs(evt->handle));
3760
3761         if (evt->status > 0) {
3762                 p_indent(level, frm);
3763                 printf("Error: %s\n", status2str(evt->status));
3764         }
3765 }
3766
3767 static inline void num_completed_blocks_dump(int level, struct frame *frm)
3768 {
3769         evt_num_completed_blocks *evt = frm->ptr;
3770         int i;
3771
3772         p_indent(level, frm);
3773         printf("Total num blocks %d Num handles %d\n",
3774                         btohs(evt->total_num_blocks), evt->num_handles);
3775
3776         for (i = 0; i < evt->num_handles; i++) {
3777                 cmplt_handle *h = &evt->handles[i];
3778
3779                 p_indent(level + 1, frm);
3780                 printf("Handle 0x%4.4x: Num complt pkts %d Num complt blks %d\n",
3781                                 btohs(h->handle), btohs(h->num_cmplt_pkts),
3782                                 btohs(h->num_cmplt_blks));
3783         }
3784 }
3785
3786 static inline void event_dump(int level, struct frame *frm)
3787 {
3788         hci_event_hdr *hdr = frm->ptr;
3789         uint8_t event = hdr->evt;
3790
3791         if (p_filter(FILT_HCI))
3792                 return;
3793
3794         if (event <= EVENT_NUM) {
3795                 p_indent(level, frm);
3796                 printf("HCI Event: %s (0x%2.2x) plen %d\n",
3797                                         event_str[hdr->evt], hdr->evt, hdr->plen);
3798         } else if (hdr->evt == EVT_TESTING) {
3799                 p_indent(level, frm);
3800                 printf("HCI Event: Testing (0x%2.2x) plen %d\n", hdr->evt, hdr->plen);
3801         } else if (hdr->evt == EVT_VENDOR) {
3802                 uint16_t manufacturer;
3803
3804                 if (parser.flags & DUMP_NOVENDOR)
3805                         return;
3806
3807                 p_indent(level, frm);
3808                 printf("HCI Event: Vendor (0x%2.2x) plen %d\n", hdr->evt, hdr->plen);
3809
3810                 manufacturer = get_manufacturer();
3811
3812                 switch (manufacturer) {
3813                 case 0:
3814                 case 37:
3815                 case 48:
3816                         frm->ptr += HCI_EVENT_HDR_SIZE;
3817                         frm->len -= HCI_EVENT_HDR_SIZE;
3818                         ericsson_dump(level + 1, frm);
3819                         return;
3820                 case 10:
3821                         frm->ptr += HCI_EVENT_HDR_SIZE;
3822                         frm->len -= HCI_EVENT_HDR_SIZE;
3823                         csr_dump(level + 1, frm);
3824                         return;
3825                 }
3826         } else {
3827                 p_indent(level, frm);
3828                 printf("HCI Event: code 0x%2.2x plen %d\n", hdr->evt, hdr->plen);
3829         }
3830
3831         frm->ptr += HCI_EVENT_HDR_SIZE;
3832         frm->len -= HCI_EVENT_HDR_SIZE;
3833
3834         if (event == EVT_CMD_COMPLETE) {
3835                 evt_cmd_complete *cc = frm->ptr;
3836                 if (cc->opcode == cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_VERSION)) {
3837                         read_local_version_rp *rp = frm->ptr + EVT_CMD_COMPLETE_SIZE;
3838                         manufacturer = rp->manufacturer;
3839                 }
3840         }
3841
3842         if (event == EVT_DISCONN_COMPLETE) {
3843                 evt_disconn_complete *evt = frm->ptr;
3844                 l2cap_clear(btohs(evt->handle));
3845         }
3846
3847         if (!(parser.flags & DUMP_VERBOSE)) {
3848                 raw_dump(level, frm);
3849                 return;
3850         }
3851
3852         switch (event) {
3853         case EVT_LOOPBACK_COMMAND:
3854                 command_dump(level + 1, frm);
3855                 break;
3856         case EVT_CMD_COMPLETE:
3857                 cmd_complete_dump(level + 1, frm);
3858                 break;
3859         case EVT_CMD_STATUS:
3860                 cmd_status_dump(level + 1, frm);
3861                 break;
3862         case EVT_HARDWARE_ERROR:
3863                 hardware_error_dump(level + 1, frm);
3864                 break;
3865         case EVT_FLUSH_OCCURRED:
3866         case EVT_QOS_VIOLATION:
3867                 handle_response_dump(level + 1, frm);
3868                 break;
3869         case EVT_INQUIRY_COMPLETE:
3870                 status_response_dump(level + 1, frm);
3871                 break;
3872         case EVT_INQUIRY_RESULT:
3873                 inq_result_dump(level + 1, frm);
3874                 break;
3875         case EVT_CONN_COMPLETE:
3876                 conn_complete_dump(level + 1, frm);
3877                 break;
3878         case EVT_CONN_REQUEST:
3879                 conn_request_dump(level + 1, frm);
3880                 break;
3881         case EVT_DISCONN_COMPLETE:
3882         case EVT_DISCONNECT_LOGICAL_LINK_COMPLETE:
3883                 disconn_complete_dump(level + 1, frm);
3884                 break;
3885         case EVT_AUTH_COMPLETE:
3886         case EVT_CHANGE_CONN_LINK_KEY_COMPLETE:
3887                 generic_response_dump(level + 1, frm);
3888                 break;
3889         case EVT_MASTER_LINK_KEY_COMPLETE:
3890                 master_link_key_complete_dump(level + 1, frm);
3891                 break;
3892         case EVT_REMOTE_NAME_REQ_COMPLETE:
3893                 remote_name_req_complete_dump(level + 1, frm);
3894                 break;
3895         case EVT_ENCRYPT_CHANGE:
3896                 encrypt_change_dump(level + 1, frm);
3897                 break;
3898         case EVT_READ_REMOTE_FEATURES_COMPLETE:
3899                 read_remote_features_complete_dump(level + 1, frm);
3900                 break;
3901         case EVT_READ_REMOTE_VERSION_COMPLETE:
3902                 read_remote_version_complete_dump(level + 1, frm);
3903                 break;
3904         case EVT_QOS_SETUP_COMPLETE:
3905                 qos_setup_complete_dump(level + 1, frm);
3906                 break;
3907         case EVT_ROLE_CHANGE:
3908                 role_change_dump(level + 1, frm);
3909                 break;
3910         case EVT_NUM_COMP_PKTS:
3911                 num_comp_pkts_dump(level + 1, frm);
3912                 break;
3913         case EVT_MODE_CHANGE:
3914                 mode_change_dump(level + 1, frm);
3915                 break;
3916         case EVT_RETURN_LINK_KEYS:
3917                 return_link_keys_dump(level + 1, frm);
3918                 break;
3919         case EVT_PIN_CODE_REQ:
3920         case EVT_LINK_KEY_REQ:
3921         case EVT_IO_CAPABILITY_REQUEST:
3922         case EVT_USER_PASSKEY_REQUEST:
3923         case EVT_REMOTE_OOB_DATA_REQUEST:
3924                 pin_code_req_dump(level + 1, frm);
3925                 break;
3926         case EVT_LINK_KEY_NOTIFY:
3927                 link_key_notify_dump(level + 1, frm);
3928                 break;
3929         case EVT_DATA_BUFFER_OVERFLOW:
3930                 data_buffer_overflow_dump(level + 1, frm);
3931                 break;
3932         case EVT_MAX_SLOTS_CHANGE:
3933                 max_slots_change_dump(level + 1, frm);
3934                 break;
3935         case EVT_READ_CLOCK_OFFSET_COMPLETE:
3936                 read_clock_offset_complete_dump(level + 1, frm);
3937                 break;
3938         case EVT_CONN_PTYPE_CHANGED:
3939                 conn_ptype_changed_dump(level + 1, frm);
3940                 break;
3941         case EVT_PSCAN_REP_MODE_CHANGE:
3942                 pscan_rep_mode_change_dump(level + 1, frm);
3943                 break;
3944         case EVT_FLOW_SPEC_COMPLETE:
3945                 flow_spec_complete_dump(level + 1, frm);
3946                 break;
3947         case EVT_INQUIRY_RESULT_WITH_RSSI:
3948                 inq_result_with_rssi_dump(level + 1, frm);
3949                 break;
3950         case EVT_READ_REMOTE_EXT_FEATURES_COMPLETE:
3951                 read_remote_ext_features_complete_dump(level + 1, frm);
3952                 break;
3953         case EVT_SYNC_CONN_COMPLETE:
3954                 sync_conn_complete_dump(level + 1, frm);
3955                 break;
3956         case EVT_SYNC_CONN_CHANGED:
3957                 sync_conn_changed_dump(level + 1, frm);
3958                 break;
3959         case EVT_SNIFF_SUBRATING:
3960                 sniff_subrating_event_dump(level + 1, frm);
3961                 break;
3962         case EVT_EXTENDED_INQUIRY_RESULT:
3963                 extended_inq_result_dump(level + 1, frm);
3964                 break;
3965         case EVT_ENCRYPTION_KEY_REFRESH_COMPLETE:
3966                 generic_response_dump(level + 1, frm);
3967                 break;
3968         case EVT_SIMPLE_PAIRING_COMPLETE:
3969                 bdaddr_response_dump(level + 1, frm);
3970                 break;
3971         case EVT_LINK_SUPERVISION_TIMEOUT_CHANGED:
3972                 link_supervision_timeout_changed_dump(level + 1, frm);
3973                 break;
3974         case EVT_ENHANCED_FLUSH_COMPLETE:
3975                 generic_command_dump(level + 1, frm);
3976                 break;
3977         case EVT_IO_CAPABILITY_RESPONSE:
3978                 io_capability_reply_dump(level + 1, frm);
3979                 break;
3980         case EVT_USER_CONFIRM_REQUEST:
3981         case EVT_USER_PASSKEY_NOTIFY:
3982                 user_passkey_notify_dump(level + 1, frm);
3983                 break;
3984         case EVT_KEYPRESS_NOTIFY:
3985                 keypress_notify_dump(level + 1, frm);
3986                 break;
3987         case EVT_REMOTE_HOST_FEATURES_NOTIFY:
3988                 remote_host_features_notify_dump(level + 1, frm);
3989                 break;
3990         case EVT_LE_META_EVENT:
3991                 le_meta_ev_dump(level + 1, frm);
3992                 break;
3993         case EVT_PHYSICAL_LINK_COMPLETE:
3994                 phys_link_complete_dump(level + 1, frm);
3995                 break;
3996         case EVT_DISCONNECT_PHYSICAL_LINK_COMPLETE:
3997                 disconn_phys_link_complete_dump(level + 1, frm);
3998                 break;
3999         case EVT_PHYSICAL_LINK_LOSS_EARLY_WARNING:
4000                 phys_link_loss_warning_dump(level + 1, frm);
4001                 break;
4002         case EVT_PHYSICAL_LINK_RECOVERY:
4003         case EVT_CHANNEL_SELECTED:
4004                 phys_link_handle_dump(level + 1, frm);
4005                 break;
4006         case EVT_LOGICAL_LINK_COMPLETE:
4007                 logical_link_complete_dump(level + 1, frm);
4008                 break;
4009         case EVT_FLOW_SPEC_MODIFY_COMPLETE:
4010                 flow_spec_modify_dump(level + 1, frm);
4011                 break;
4012         case EVT_NUMBER_COMPLETED_BLOCKS:
4013                 num_completed_blocks_dump(level + 1, frm);
4014                 break;
4015         default:
4016                 raw_dump(level, frm);
4017                 break;
4018         }
4019 }
4020
4021 static inline void acl_dump(int level, struct frame *frm)
4022 {
4023         hci_acl_hdr *hdr = (void *) frm->ptr;
4024         uint16_t handle = btohs(hdr->handle);
4025         uint16_t dlen = btohs(hdr->dlen);
4026         uint8_t flags = acl_flags(handle);
4027
4028         if (!p_filter(FILT_HCI)) {
4029                 p_indent(level, frm);
4030                 printf("ACL data: handle %d flags 0x%2.2x dlen %d\n",
4031                         acl_handle(handle), flags, dlen);
4032                 level++;
4033         }
4034
4035         frm->ptr += HCI_ACL_HDR_SIZE;
4036         frm->len -= HCI_ACL_HDR_SIZE;
4037         frm->flags  = flags;
4038         frm->handle = acl_handle(handle);
4039
4040         if (parser.filter & ~FILT_HCI)
4041                 l2cap_dump(level, frm);
4042         else
4043                 raw_dump(level, frm);
4044 }
4045
4046 static inline void sco_dump(int level, struct frame *frm)
4047 {
4048         hci_sco_hdr *hdr = (void *) frm->ptr;
4049         uint16_t handle = btohs(hdr->handle);
4050         uint8_t flags = acl_flags(handle);
4051         int len;
4052
4053         if (frm->audio_fd > fileno(stderr)) {
4054                 len = write(frm->audio_fd, frm->ptr + HCI_SCO_HDR_SIZE, hdr->dlen);
4055                 if (len < 0)
4056                         return;
4057         }
4058
4059         if (!p_filter(FILT_SCO)) {
4060                 p_indent(level, frm);
4061                 printf("SCO data: handle %d flags 0x%2.2x dlen %d\n",
4062                                 acl_handle(handle), flags, hdr->dlen);
4063                 level++;
4064
4065                 frm->ptr += HCI_SCO_HDR_SIZE;
4066                 frm->len -= HCI_SCO_HDR_SIZE;
4067                 raw_dump(level, frm);
4068         }
4069 }
4070
4071 static inline void vendor_dump(int level, struct frame *frm)
4072 {
4073         if (p_filter(FILT_HCI))
4074                 return;
4075
4076         if (frm->dev_id == HCI_DEV_NONE) {
4077                 uint16_t device = btohs(htons(p_get_u16(frm)));
4078                 uint16_t proto = btohs(htons(p_get_u16(frm)));
4079                 uint16_t type = btohs(htons(p_get_u16(frm)));
4080                 uint16_t plen = btohs(htons(p_get_u16(frm)));
4081
4082                 p_indent(level, frm);
4083
4084                 printf("System %s: device hci%d proto 0x%2.2x type 0x%2.2x plen %d\n",
4085                         frm->in ? "event" : "command", device, proto, type, plen);
4086
4087                 raw_dump(level, frm);
4088                 return;
4089         }
4090
4091         if (parser.flags & DUMP_NOVENDOR)
4092                 return;
4093
4094         if (get_manufacturer() == 12) {
4095                 bpa_dump(level, frm);
4096                 return;
4097         }
4098
4099         p_indent(level, frm);
4100         printf("Vendor data: len %d\n", frm->len);
4101         raw_dump(level, frm);
4102 }
4103
4104 void hci_dump(int level, struct frame *frm)
4105 {
4106         uint8_t type = *(uint8_t *)frm->ptr;
4107
4108         frm->ptr++; frm->len--;
4109
4110         switch (type) {
4111         case HCI_COMMAND_PKT:
4112                 command_dump(level, frm);
4113                 break;
4114
4115         case HCI_EVENT_PKT:
4116                 event_dump(level, frm);
4117                 break;
4118
4119         case HCI_ACLDATA_PKT:
4120                 acl_dump(level, frm);
4121                 break;
4122
4123         case HCI_SCODATA_PKT:
4124                 sco_dump(level, frm);
4125                 break;
4126
4127         case HCI_VENDOR_PKT:
4128                 vendor_dump(level, frm);
4129                 break;
4130
4131         default:
4132                 if (p_filter(FILT_HCI))
4133                         break;
4134
4135                 p_indent(level, frm);
4136                 printf("Unknown: type 0x%2.2x len %d\n", type, frm->len);
4137                 raw_dump(level, frm);
4138                 break;
4139         }
4140 }