mirror of
https://git.kernel.org/pub/scm/bluetooth/bluez.git
synced 2024-12-15 23:14:38 +08:00
4854 lines
119 KiB
C
4854 lines
119 KiB
C
/*
|
|
*
|
|
* BlueZ - Bluetooth protocol stack for Linux
|
|
*
|
|
* Copyright (C) 2011-2012 Intel Corporation
|
|
* Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <inttypes.h>
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <bluetooth/bluetooth.h>
|
|
#include <bluetooth/hci.h>
|
|
#include <bluetooth/hci_lib.h>
|
|
|
|
#include "display.h"
|
|
#include "bt.h"
|
|
#include "l2cap.h"
|
|
#include "control.h"
|
|
#include "packet.h"
|
|
|
|
#define COLOR_INDEX_LABEL COLOR_WHITE
|
|
#define COLOR_TIMESTAMP COLOR_YELLOW
|
|
|
|
#define COLOR_NEW_INDEX COLOR_GREEN
|
|
#define COLOR_DEL_INDEX COLOR_RED
|
|
|
|
#define COLOR_HCI_COMMAND COLOR_BLUE
|
|
#define COLOR_HCI_COMMAND_UNKNOWN COLOR_WHITE_BG
|
|
|
|
#define COLOR_HCI_EVENT COLOR_MAGENTA
|
|
#define COLOR_HCI_EVENT_UNKNOWN COLOR_WHITE_BG
|
|
|
|
#define COLOR_HCI_ACLDATA COLOR_CYAN
|
|
#define COLOR_HCI_SCODATA COLOR_YELLOW
|
|
|
|
static time_t time_offset = ((time_t) -1);
|
|
static unsigned long filter_mask = 0;
|
|
static bool index_filter = false;
|
|
static uint16_t index_number = 0;
|
|
|
|
void packet_set_filter(unsigned long filter)
|
|
{
|
|
filter_mask = filter;
|
|
}
|
|
|
|
void packet_add_filter(unsigned long filter)
|
|
{
|
|
if (index_filter)
|
|
filter &= ~PACKET_FILTER_SHOW_INDEX;
|
|
|
|
filter_mask |= filter;
|
|
}
|
|
|
|
void packet_del_filter(unsigned long filter)
|
|
{
|
|
filter_mask &= ~filter;
|
|
}
|
|
|
|
void packet_select_index(uint16_t index)
|
|
{
|
|
filter_mask &= ~PACKET_FILTER_SHOW_INDEX;
|
|
|
|
index_filter = true;
|
|
index_number = index;
|
|
}
|
|
|
|
#define print_space(x) printf("%*c", (x), ' ');
|
|
|
|
static void print_packet(struct timeval *tv, uint16_t index, char ident,
|
|
const char *color, const char *label,
|
|
const char *text, const char *extra)
|
|
{
|
|
int col = num_columns();
|
|
char line[256], ts_str[64];
|
|
int n, ts_len = 0, ts_pos = 0, len = 0, pos = 0;
|
|
|
|
if (filter_mask & PACKET_FILTER_SHOW_INDEX) {
|
|
if (use_color()) {
|
|
n = sprintf(ts_str + ts_pos, "%s", COLOR_INDEX_LABEL);
|
|
if (n > 0)
|
|
ts_pos += n;
|
|
}
|
|
|
|
n = sprintf(ts_str + ts_pos, " [hci%d]", index);
|
|
if (n > 0) {
|
|
ts_pos += n;
|
|
ts_len += n;
|
|
}
|
|
}
|
|
|
|
if (tv) {
|
|
time_t t = tv->tv_sec;
|
|
struct tm tm;
|
|
|
|
localtime_r(&t, &tm);
|
|
|
|
if (use_color()) {
|
|
n = sprintf(ts_str + ts_pos, "%s", COLOR_TIMESTAMP);
|
|
if (n > 0)
|
|
ts_pos += n;
|
|
}
|
|
|
|
if (filter_mask & PACKET_FILTER_SHOW_DATE) {
|
|
n = sprintf(ts_str + ts_pos, " %04d-%02d-%02d",
|
|
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
|
|
if (n > 0) {
|
|
ts_pos += n;
|
|
ts_len += n;
|
|
}
|
|
}
|
|
|
|
if (filter_mask & PACKET_FILTER_SHOW_TIME) {
|
|
n = sprintf(ts_str + ts_pos, " %02d:%02d:%02d.%06lu",
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec, tv->tv_usec);
|
|
if (n > 0) {
|
|
ts_pos += n;
|
|
ts_len += n;
|
|
}
|
|
}
|
|
|
|
if (filter_mask & PACKET_FILTER_SHOW_TIME_OFFSET) {
|
|
n = sprintf(ts_str + ts_pos, " %lu.%06lu",
|
|
tv->tv_sec - time_offset, tv->tv_usec);
|
|
if (n > 0) {
|
|
ts_pos += n;
|
|
ts_len += n;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (use_color()) {
|
|
n = sprintf(ts_str + ts_pos, "%s", COLOR_OFF);
|
|
if (n > 0)
|
|
ts_pos += n;
|
|
}
|
|
|
|
if (use_color()) {
|
|
n = sprintf(line + pos, "%s", color);
|
|
if (n > 0)
|
|
pos += n;
|
|
}
|
|
|
|
n = sprintf(line + pos, "%c %s", ident, label);
|
|
if (n > 0) {
|
|
pos += n;
|
|
len += n;
|
|
}
|
|
|
|
if (text) {
|
|
int extra_len = extra ? strlen(extra) : 0;
|
|
int max_len = col - len - extra_len - ts_len - 3;
|
|
|
|
n = snprintf(line + pos, max_len + 1, ": %s", text);
|
|
if (n > max_len) {
|
|
line[pos + max_len - 1] = '.';
|
|
line[pos + max_len - 2] = '.';
|
|
if (line[pos + max_len - 3] == ' ')
|
|
line[pos + max_len - 3] = '.';
|
|
|
|
n = max_len;
|
|
}
|
|
|
|
if (n > 0) {
|
|
pos += n;
|
|
len += n;
|
|
}
|
|
}
|
|
|
|
if (use_color()) {
|
|
n = sprintf(line + pos, "%s", COLOR_OFF);
|
|
if (n > 0)
|
|
pos += n;
|
|
}
|
|
|
|
if (extra) {
|
|
n = sprintf(line + pos, " %s", extra);
|
|
if (n > 0) {
|
|
pos += n;
|
|
len += n;
|
|
}
|
|
}
|
|
|
|
if (ts_len > 0) {
|
|
printf("%s", line);
|
|
if (len < col)
|
|
print_space(col - len - ts_len - 1);
|
|
printf("%s%s\n", use_color() ? COLOR_TIMESTAMP : "", ts_str);
|
|
} else
|
|
printf("%s\n", line);
|
|
}
|
|
|
|
static const struct {
|
|
uint8_t error;
|
|
const char *str;
|
|
} error2str_table[] = {
|
|
{ 0x00, "Success" },
|
|
{ 0x01, "Unknown HCI Command" },
|
|
{ 0x02, "Unknown Connection Identifier" },
|
|
{ 0x03, "Hardware Failure" },
|
|
{ 0x04, "Page Timeout" },
|
|
{ 0x05, "Authentication Failure" },
|
|
{ 0x06, "PIN or Key Missing" },
|
|
{ 0x07, "Memory Capacity Exceeded" },
|
|
{ 0x08, "Connection Timeout" },
|
|
{ 0x09, "Connection Limit Exceeded" },
|
|
{ 0x0a, "Synchronous Connection Limit to a Device Exceeded" },
|
|
{ 0x0b, "ACL Connection Already Exists" },
|
|
{ 0x0c, "Command Disallowed" },
|
|
{ 0x0d, "Connection Rejected due to Limited Resources" },
|
|
{ 0x0e, "Connection Rejected due to Security Reasons" },
|
|
{ 0x0f, "Connection Rejected due to Unacceptable BD_ADDR" },
|
|
{ 0x10, "Connection Accept Timeout Exceeded" },
|
|
{ 0x11, "Unsupported Feature or Parameter Value" },
|
|
{ 0x12, "Invalid HCI Command Parameters" },
|
|
{ 0x13, "Remote User Terminated Connection" },
|
|
{ 0x14, "Remote Device Terminated due to Low Resources" },
|
|
{ 0x15, "Remote Device Terminated due to Power Off" },
|
|
{ 0x16, "Connection Terminated By Local Host" },
|
|
{ 0x17, "Repeated Attempts" },
|
|
{ 0x18, "Pairing Not Allowed" },
|
|
{ 0x19, "Unknown LMP PDU" },
|
|
{ 0x1a, "Unsupported Remote Feature / Unsupported LMP Feature" },
|
|
{ 0x1b, "SCO Offset Rejected" },
|
|
{ 0x1c, "SCO Interval Rejected" },
|
|
{ 0x1d, "SCO Air Mode Rejected" },
|
|
{ 0x1e, "Invalid LMP Parameters" },
|
|
{ 0x1f, "Unspecified Error" },
|
|
{ 0x20, "Unsupported LMP Parameter Value" },
|
|
{ 0x21, "Role Change Not Allowed" },
|
|
{ 0x22, "LMP Response Timeout / LL Response Timeout" },
|
|
{ 0x23, "LMP Error Transaction Collision" },
|
|
{ 0x24, "LMP PDU Not Allowed" },
|
|
{ 0x25, "Encryption Mode Not Acceptable" },
|
|
{ 0x26, "Link Key cannot be Changed" },
|
|
{ 0x27, "Requested QoS Not Supported" },
|
|
{ 0x28, "Instant Passed" },
|
|
{ 0x29, "Pairing With Unit Key Not Supported" },
|
|
{ 0x2a, "Different Transaction Collision" },
|
|
{ 0x2b, "Reserved" },
|
|
{ 0x2c, "QoS Unacceptable Parameter" },
|
|
{ 0x2d, "QoS Rejected" },
|
|
{ 0x2e, "Channel Classification Not Supported" },
|
|
{ 0x2f, "Insufficient Security" },
|
|
{ 0x30, "Parameter Out Of Manadatory Range" },
|
|
{ 0x31, "Reserved" },
|
|
{ 0x32, "Role Switch Pending" },
|
|
{ 0x33, "Reserved" },
|
|
{ 0x34, "Reserved Slot Violation" },
|
|
{ 0x35, "Role Switch Failed" },
|
|
{ 0x36, "Extended Inquiry Response Too Large" },
|
|
{ 0x37, "Secure Simple Pairing Not Supported By Host" },
|
|
{ 0x38, "Host Busy - Pairing" },
|
|
{ 0x39, "Connection Rejected due to No Suitable Channel Found" },
|
|
{ 0x3a, "Controller Busy" },
|
|
{ 0x3b, "Unacceptable Connection Interval" },
|
|
{ 0x3c, "Directed Advertising Timeout" },
|
|
{ 0x3d, "Connection Terminated due to MIC Failure" },
|
|
{ 0x3e, "Connection Failed to be Established" },
|
|
{ 0x3f, "MAC Connection Failed" },
|
|
{ }
|
|
};
|
|
|
|
static void print_error(const char *label, uint8_t error)
|
|
{
|
|
const char *str = "Unknown";
|
|
const char *color_on, *color_off;
|
|
int i;
|
|
|
|
for (i = 0; error2str_table[i].str; i++) {
|
|
if (error2str_table[i].error == error) {
|
|
str = error2str_table[i].str;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (use_color()) {
|
|
if (error)
|
|
color_on = COLOR_RED;
|
|
else
|
|
color_on = COLOR_GREEN;
|
|
color_off = COLOR_OFF;
|
|
} else {
|
|
color_on = "";
|
|
color_off = "";
|
|
}
|
|
|
|
print_field("%s: %s%s%s (0x%2.2x)", label,
|
|
color_on, str, color_off, error);
|
|
}
|
|
|
|
static void print_status(uint8_t status)
|
|
{
|
|
print_error("Status", status);
|
|
}
|
|
|
|
static void print_reason(uint8_t reason)
|
|
{
|
|
print_error("Reason", reason);
|
|
}
|
|
|
|
static void print_bdaddr(const uint8_t *bdaddr)
|
|
{
|
|
print_field("Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
|
|
" (OUI %2.2X-%2.2X-%2.2X)",
|
|
bdaddr[5], bdaddr[4], bdaddr[3],
|
|
bdaddr[2], bdaddr[1], bdaddr[0],
|
|
bdaddr[5], bdaddr[4], bdaddr[3]);
|
|
}
|
|
|
|
static void print_addr(const uint8_t *addr, uint8_t addr_type)
|
|
{
|
|
const char *str;
|
|
|
|
switch (addr_type) {
|
|
case 0x00:
|
|
print_bdaddr(addr);
|
|
break;
|
|
case 0x01:
|
|
switch ((addr[5] & 0xc0) >> 6) {
|
|
case 0x00:
|
|
str = "Non-Resolvable";
|
|
break;
|
|
case 0x01:
|
|
str = "Resolvable";
|
|
break;
|
|
case 0x03:
|
|
str = "Static";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
|
|
" (%s)", addr[5], addr[4], addr[3],
|
|
addr[2], addr[1], addr[0], str);
|
|
break;
|
|
default:
|
|
print_field("Address: %2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2X",
|
|
addr[5], addr[4], addr[3],
|
|
addr[2], addr[1], addr[0]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void print_addr_type(const char *label, uint8_t addr_type)
|
|
{
|
|
const char *str;
|
|
|
|
switch (addr_type) {
|
|
case 0x00:
|
|
str = "Public";
|
|
break;
|
|
case 0x01:
|
|
str = "Random";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("%s: %s (0x%2.2x)", label, str, addr_type);
|
|
}
|
|
|
|
static void print_handle(uint16_t handle)
|
|
{
|
|
print_field("Handle: %d", btohs(handle));
|
|
}
|
|
|
|
static void print_phy_handle(uint8_t phy_handle)
|
|
{
|
|
print_field("Physical handle: %d", phy_handle);
|
|
}
|
|
|
|
static void print_pkt_type(uint16_t pkt_type)
|
|
{
|
|
print_field("Packet type: 0x%4.4x", btohs(pkt_type));
|
|
}
|
|
|
|
static void print_iac(const uint8_t *lap)
|
|
{
|
|
print_field("Access code: 0x%2.2x%2.2x%2.2x", lap[2], lap[1], lap[0]);
|
|
}
|
|
|
|
static void print_dev_class(const uint8_t *dev_class)
|
|
{
|
|
print_field("Class: 0x%2.2x%2.2x%2.2x",
|
|
dev_class[2], dev_class[1], dev_class[0]);
|
|
}
|
|
|
|
static void print_voice_setting(uint16_t setting)
|
|
{
|
|
print_field("Setting: 0x%4.4x", btohs(setting));
|
|
}
|
|
|
|
static void print_retransmission_effort(uint8_t effort)
|
|
{
|
|
const char *str;
|
|
|
|
switch (effort) {
|
|
case 0x00:
|
|
str = "No retransmissions";
|
|
break;
|
|
case 0x01:
|
|
str = "Optimize for power consumption";
|
|
break;
|
|
case 0x02:
|
|
str = "Optimize for link quality";
|
|
break;
|
|
case 0xff:
|
|
str = "Don't care";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Retransmission effort: %s (0x%2.2x)", str, effort);
|
|
}
|
|
|
|
static void print_scan_enable(uint8_t scan_enable)
|
|
{
|
|
const char *str;
|
|
|
|
switch (scan_enable) {
|
|
case 0x00:
|
|
str = "No Scans";
|
|
break;
|
|
case 0x01:
|
|
str = "Inquiry Scan";
|
|
break;
|
|
case 0x02:
|
|
str = "Page Scan";
|
|
break;
|
|
case 0x03:
|
|
str = "Inquiry Scan + Page Scan";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Scan enable: %s (0x%2.2x)", str, scan_enable);
|
|
}
|
|
|
|
static void print_link_policy(uint16_t link_policy)
|
|
{
|
|
print_field("Link policy: 0x%4.4x", btohs(link_policy));
|
|
}
|
|
|
|
static void print_air_mode(uint8_t mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (mode) {
|
|
case 0x00:
|
|
str = "u-law log";
|
|
break;
|
|
case 0x01:
|
|
str = "A-law log";
|
|
break;
|
|
case 0x02:
|
|
str = "CVSD";
|
|
break;
|
|
case 0x03:
|
|
str = "Transparent";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Air mode: %s (0x%2.2x)", str, mode);
|
|
}
|
|
|
|
static void print_inquiry_mode(uint8_t mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (mode) {
|
|
case 0x00:
|
|
str = "Standard Inquiry Result";
|
|
break;
|
|
case 0x01:
|
|
str = "Inquiry Result with RSSI";
|
|
break;
|
|
case 0x02:
|
|
str = "Inquiry Result with RSSI or Extended Inquiry Result";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Mode: %s (0x%2.2x)", str, mode);
|
|
}
|
|
|
|
static void print_simple_pairing_mode(uint8_t mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (mode) {
|
|
case 0x00:
|
|
str = "Disabled";
|
|
break;
|
|
case 0x01:
|
|
str = "Enabled";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Mode: %s (0x%2.2x)", str, mode);
|
|
}
|
|
|
|
static void print_pscan_rep_mode(uint8_t pscan_rep_mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (pscan_rep_mode) {
|
|
case 0x00:
|
|
str = "R0";
|
|
break;
|
|
case 0x01:
|
|
str = "R1";
|
|
break;
|
|
case 0x02:
|
|
str = "R2";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Page scan repetition mode: %s (0x%2.2x)",
|
|
str, pscan_rep_mode);
|
|
}
|
|
|
|
static void print_pscan_period_mode(uint8_t pscan_period_mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (pscan_period_mode) {
|
|
case 0x00:
|
|
str = "P0";
|
|
break;
|
|
case 0x01:
|
|
str = "P1";
|
|
break;
|
|
case 0x02:
|
|
str = "P2";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Page period mode: %s (0x%2.2x)", str, pscan_period_mode);
|
|
}
|
|
|
|
static void print_pscan_mode(uint8_t pscan_mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (pscan_mode) {
|
|
case 0x00:
|
|
str = "Mandatory";
|
|
break;
|
|
case 0x01:
|
|
str = "Optional I";
|
|
break;
|
|
case 0x02:
|
|
str = "Optional II";
|
|
break;
|
|
case 0x03:
|
|
str = "Optional III";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Page scan mode: %s (0x%2.2x)", str, pscan_mode);
|
|
}
|
|
|
|
static void print_clock_offset(uint16_t clock_offset)
|
|
{
|
|
print_field("Clock offset: 0x%4.4x", btohs(clock_offset));
|
|
}
|
|
|
|
static void print_link_type(uint8_t link_type)
|
|
{
|
|
const char *str;
|
|
|
|
switch (link_type) {
|
|
case 0x00:
|
|
str = "SCO";
|
|
break;
|
|
case 0x01:
|
|
str = "ACL";
|
|
break;
|
|
case 0x02:
|
|
str = "eSCO";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Link type: %s (0x%2.2x)", str, link_type);
|
|
}
|
|
|
|
static void print_encr_mode(uint8_t encr_mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (encr_mode) {
|
|
case 0x00:
|
|
str = "Disabled";
|
|
break;
|
|
case 0x01:
|
|
str = "Enabled";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Encryption: %s (0x%2.2x)", str, encr_mode);
|
|
}
|
|
|
|
static void print_pin_type(uint8_t pin_type)
|
|
{
|
|
const char *str;
|
|
|
|
switch (pin_type) {
|
|
case 0x00:
|
|
str = "Variable";
|
|
break;
|
|
case 0x01:
|
|
str = "Fixed";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("PIN type: %s (0x%2.2x)", str, pin_type);
|
|
}
|
|
|
|
static void print_key_flag(uint8_t key_flag)
|
|
{
|
|
const char *str;
|
|
|
|
switch (key_flag) {
|
|
case 0x00:
|
|
str = "Semi-permanent";
|
|
break;
|
|
case 0x01:
|
|
str = "Temporary";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Key flag: %s (0x%2.2x)", str, key_flag);
|
|
}
|
|
|
|
static void print_key_len(uint8_t key_len)
|
|
{
|
|
const char *str;
|
|
|
|
switch (key_len) {
|
|
case 32:
|
|
str = "802.11 PAL";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Key length: %s (%d)", str, key_len);
|
|
}
|
|
|
|
static void print_key_type(uint8_t key_type)
|
|
{
|
|
const char *str;
|
|
|
|
switch (key_type) {
|
|
case 0x00:
|
|
str = "Combination key";
|
|
break;
|
|
case 0x01:
|
|
str = "Local Unit key";
|
|
break;
|
|
case 0x02:
|
|
str = "Remote Unit key";
|
|
break;
|
|
case 0x03:
|
|
str = "Debug Combination key";
|
|
break;
|
|
case 0x04:
|
|
str = "Unauthenticated Combination key";
|
|
break;
|
|
case 0x05:
|
|
str = "Authenticated Combination key";
|
|
break;
|
|
case 0x06:
|
|
str = "Changed Combination key";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Key type: %s (0x%2.2x)", str, key_type);
|
|
}
|
|
|
|
static void print_key_size(uint8_t key_size)
|
|
{
|
|
print_field("Key size: %d", key_size);
|
|
}
|
|
|
|
static void print_hex_field(const char *label, const uint8_t *data,
|
|
uint8_t len)
|
|
{
|
|
char str[len * 2 + 1];
|
|
uint8_t i;
|
|
|
|
for (i = 0; i < len; i++)
|
|
sprintf(str + (i * 2), "%2.2x", data[i]);
|
|
|
|
print_field("%s: %s", label, str);
|
|
}
|
|
|
|
static void print_key(const char *label, const uint8_t *link_key)
|
|
{
|
|
print_hex_field(label, link_key, 16);
|
|
}
|
|
|
|
static void print_link_key(const uint8_t *link_key)
|
|
{
|
|
print_key("Link key", link_key);
|
|
}
|
|
|
|
static void print_pin_code(const uint8_t *pin_code)
|
|
{
|
|
print_key("PIN code", pin_code);
|
|
}
|
|
|
|
static void print_hash(const uint8_t *hash)
|
|
{
|
|
print_key("Hash C", hash);
|
|
}
|
|
|
|
static void print_randomizer(const uint8_t *randomizer)
|
|
{
|
|
print_key("Randomizer R", randomizer);
|
|
}
|
|
|
|
static void print_passkey(uint32_t passkey)
|
|
{
|
|
print_field("Passkey: %06d", btohl(passkey));
|
|
}
|
|
|
|
static void print_io_capability(uint8_t capability)
|
|
{
|
|
const char *str;
|
|
|
|
switch (capability) {
|
|
case 0x00:
|
|
str = "DisplayOnly";
|
|
break;
|
|
case 0x01:
|
|
str = "DisplayYesNo";
|
|
break;
|
|
case 0x02:
|
|
str = "KeyboardOnly";
|
|
break;
|
|
case 0x03:
|
|
str = "NoInputNoOutput";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("IO capability: %s (0x%2.2x)", str, capability);
|
|
}
|
|
|
|
static void print_oob_data(uint8_t oob_data)
|
|
{
|
|
const char *str;
|
|
|
|
switch (oob_data) {
|
|
case 0x00:
|
|
str = "Authentication data not present";
|
|
break;
|
|
case 0x01:
|
|
str = "Authentication data present";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("OOB data: %s (0x%2.2x)", str, oob_data);
|
|
}
|
|
|
|
static void print_authentication(uint8_t authentication)
|
|
{
|
|
const char *str;
|
|
|
|
switch (authentication) {
|
|
case 0x00:
|
|
str = "No Bonding - MITM not required";
|
|
break;
|
|
case 0x01:
|
|
str = "No Bonding - MITM required";
|
|
break;
|
|
case 0x02:
|
|
str = "Dedicated Bonding - MITM not required";
|
|
break;
|
|
case 0x03:
|
|
str = "Dedicated Bonding - MITM required";
|
|
break;
|
|
case 0x04:
|
|
str = "General Bonding - MITM not required";
|
|
break;
|
|
case 0x05:
|
|
str = "General Bonding - MITM required";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Authentication: %s (0x%2.2x)", str, authentication);
|
|
}
|
|
|
|
static void print_flow_direction(uint8_t direction)
|
|
{
|
|
const char *str;
|
|
|
|
switch (direction) {
|
|
case 0x00:
|
|
str = "Outgoing";
|
|
break;
|
|
case 0x01:
|
|
str = "Incoming";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Flow direction: %s (0x%2.2x)", str, direction);
|
|
}
|
|
|
|
static void print_service_type(uint8_t service_type)
|
|
{
|
|
const char *str;
|
|
|
|
switch (service_type) {
|
|
case 0x00:
|
|
str = "No Traffic";
|
|
break;
|
|
case 0x01:
|
|
str = "Best Effort";
|
|
break;
|
|
case 0x02:
|
|
str = "Guaranteed";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Service type: %s (0x%2.2x)", str, service_type);
|
|
}
|
|
|
|
static void print_flow_spec(const char *label, const uint8_t *data)
|
|
{
|
|
const char *str;
|
|
|
|
switch (data[1]) {
|
|
case 0x00:
|
|
str = "No traffic";
|
|
break;
|
|
case 0x01:
|
|
str = "Best effort";
|
|
break;
|
|
case 0x02:
|
|
str = "Guaranteed";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("%s flow spec: 0x%2.2x", label, data[0]);
|
|
print_field(" Service type: %s (0x%2.2x)", str, data[1]);
|
|
print_field(" Maximum SDU size: 0x%4.4x", bt_get_le16(data + 2));
|
|
print_field(" SDU inter-arrival time: 0x%8.8x", bt_get_le32(data + 4));
|
|
print_field(" Access latency: 0x%8.8x", bt_get_le32(data + 8));
|
|
print_field(" Flush timeout: 0x%8.8x", bt_get_le32(data + 12));
|
|
}
|
|
|
|
static void print_short_range_mode(uint8_t mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (mode) {
|
|
case 0x00:
|
|
str = "Disabled";
|
|
break;
|
|
case 0x01:
|
|
str = "Enabled";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Short range mode: %s (0x%2.2x)", str, mode);
|
|
}
|
|
|
|
static void print_amp_status(uint8_t amp_status)
|
|
{
|
|
const char *str;
|
|
|
|
switch (amp_status) {
|
|
case 0x00:
|
|
str = "Present";
|
|
break;
|
|
case 0x01:
|
|
str = "Bluetooth only";
|
|
break;
|
|
case 0x02:
|
|
str = "No capacity";
|
|
break;
|
|
case 0x03:
|
|
str = "Low capacity";
|
|
break;
|
|
case 0x04:
|
|
str = "Medium capacity";
|
|
break;
|
|
case 0x05:
|
|
str = "High capacity";
|
|
break;
|
|
case 0x06:
|
|
str = "Full capacity";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("AMP status: %s (0x%2.2x)", str, amp_status);
|
|
}
|
|
|
|
static void print_num_resp(uint8_t num_resp)
|
|
{
|
|
print_field("Num responses: %d", num_resp);
|
|
}
|
|
|
|
static void print_num_reports(uint8_t num_reports)
|
|
{
|
|
print_field("Num reports: %d", num_reports);
|
|
}
|
|
|
|
static void print_rssi(int8_t rssi)
|
|
{
|
|
print_field("RSSI: %d dBm", rssi);
|
|
}
|
|
|
|
static void print_slot_625(const char *label, uint16_t value)
|
|
{
|
|
print_field("%s: %.3f msec (0x%4.4x)", label,
|
|
btohs(value) * 0.625, value);
|
|
}
|
|
|
|
static void print_slot_125(const char *label, uint16_t value)
|
|
{
|
|
print_field("%s: %.2f msec (0x%4.4x)", label,
|
|
btohs(value) * 1.25, value);
|
|
}
|
|
|
|
static void print_timeout(uint16_t timeout)
|
|
{
|
|
print_slot_625("Timeout", timeout);
|
|
}
|
|
|
|
static void print_interval(uint16_t interval)
|
|
{
|
|
print_slot_625("Interval", interval);
|
|
}
|
|
|
|
static void print_window(uint16_t window)
|
|
{
|
|
print_slot_625("Window", window);
|
|
}
|
|
|
|
static void print_role(uint8_t role)
|
|
{
|
|
const char *str;
|
|
|
|
switch (role) {
|
|
case 0x00:
|
|
str = "Master";
|
|
break;
|
|
case 0x01:
|
|
str = "Slave";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Role: %s (0x%2.2x)", str, role);
|
|
}
|
|
|
|
static void print_mode(uint8_t mode)
|
|
{
|
|
const char *str;
|
|
|
|
switch (mode) {
|
|
case 0x00:
|
|
str = "Active";
|
|
break;
|
|
case 0x01:
|
|
str = "Hold";
|
|
break;
|
|
case 0x02:
|
|
str = "Sniff";
|
|
break;
|
|
case 0x03:
|
|
str = "Park";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Mode: %s (0x%2.2x)", str, mode);
|
|
}
|
|
|
|
static void print_name(const uint8_t *name)
|
|
{
|
|
char str[249];
|
|
|
|
memcpy(str, name, 248);
|
|
str[248] = '\0';
|
|
|
|
print_field("Name: %s", str);
|
|
}
|
|
|
|
static void print_version(const char *label, uint8_t version, uint16_t revision)
|
|
{
|
|
print_field("%s: %d - 0x%4.4x", label, version, revision);
|
|
}
|
|
|
|
static void print_hci_version(uint8_t hci_ver, uint16_t hci_rev)
|
|
{
|
|
print_version("HCI version", hci_ver, hci_rev);
|
|
}
|
|
|
|
static void print_lmp_version(uint8_t lmp_ver, uint16_t lmp_subver)
|
|
{
|
|
print_version("LMP version", lmp_ver, lmp_subver);
|
|
}
|
|
|
|
static void print_manufacturer(uint16_t manufacturer)
|
|
{
|
|
print_field("Manufacturer: %d", manufacturer);
|
|
}
|
|
|
|
static void print_commands(const uint8_t *commands)
|
|
{
|
|
char str[129];
|
|
int i;
|
|
|
|
for (i = 0; i < 64; i++)
|
|
sprintf(str + (i * 2), "%2.2x", commands[i]);
|
|
|
|
print_field("Commands: 0x%s", str);
|
|
}
|
|
|
|
struct features_data {
|
|
uint8_t bit;
|
|
const char *str;
|
|
};
|
|
|
|
static const struct features_data features_page0[] = {
|
|
{ 0, "3 slot packets" },
|
|
{ 1, "5 slot packets" },
|
|
{ 2, "Encryption" },
|
|
{ 3, "Slot offset" },
|
|
{ 4, "Timing accuracy" },
|
|
{ 5, "Role switch" },
|
|
{ 6, "Hold mode" },
|
|
{ 7, "Sniff mode" },
|
|
{ 8, "Park state" },
|
|
{ 9, "Power control requests" },
|
|
{ 10, "Channel quality driven data rate (CQDDR)"},
|
|
{ 11, "SCO link" },
|
|
{ 12, "HV2 packets" },
|
|
{ 13, "HV3 packets" },
|
|
{ 14, "u-law log synchronous data" },
|
|
{ 15, "A-law log synchronous data" },
|
|
{ 16, "CVSD synchronous data" },
|
|
{ 17, "Paging parameter negotiation" },
|
|
{ 18, "Power control" },
|
|
{ 19, "Transparent synchronous data" },
|
|
{ 23, "Broadcast Encryption" },
|
|
{ 25, "Enhanced Data Rate ACL 2 Mbps mode" },
|
|
{ 26, "Enhanced Data Rate ACL 3 Mbps mode" },
|
|
{ 27, "Enhanced inquiry scan" },
|
|
{ 28, "Interlaced inquiry scan" },
|
|
{ 29, "Interlaced page scan" },
|
|
{ 30, "RSSI with inquiry results" },
|
|
{ 31, "Extended SCO link (EV3 packets)" },
|
|
{ 32, "EV4 packets" },
|
|
{ 33, "EV5 packets" },
|
|
{ 35, "AFH capable slave" },
|
|
{ 36, "AFH classification slave" },
|
|
{ 37, "BR/EDR Not Supported" },
|
|
{ 38, "LE Supported (Controller)" },
|
|
{ 39, "3-slot Enhanced Data Rate ACL packets" },
|
|
{ 40, "5-slot Enhanced Data Rate ACL packets" },
|
|
{ 41, "Sniff subrating" },
|
|
{ 42, "Pause encryption" },
|
|
{ 43, "AFH capable master" },
|
|
{ 44, "AFH classification master" },
|
|
{ 45, "Enhanced Data Rate eSCO 2 Mbps mode" },
|
|
{ 46, "Enhanced Data Rate eSCO 3 Mbps mode" },
|
|
{ 47, "3-slot Enhanced Data Rate eSCO packets" },
|
|
{ 48, "Extended Inquiry Response" },
|
|
{ 49, "Simultaneous LE and BR/EDR (Controller)" },
|
|
{ 51, "Secure Simple Pairing" },
|
|
{ 52, "Encapsulated PDU" },
|
|
{ 53, "Erroneous Data Reporting" },
|
|
{ 54, "Non-flushable Packet Boundary Flag" },
|
|
{ 56, "Link Supervision Timeout Changed Event" },
|
|
{ 57, "Inquiry TX Power Level" },
|
|
{ 58, "Enhanced Power Control" },
|
|
{ 63, "Extended features" },
|
|
{ }
|
|
};
|
|
|
|
static const struct features_data features_page1[] = {
|
|
{ 0, "Secure Simple Pairing (Host Support)" },
|
|
{ 1, "LE Supported (Host)" },
|
|
{ 2, "Simultaneous LE and BR/EDR (Host)" },
|
|
{ }
|
|
};
|
|
|
|
static const struct features_data features_page2[] = {
|
|
{ }
|
|
};
|
|
|
|
static void print_features(uint8_t page, const uint8_t *features_array)
|
|
{
|
|
const struct features_data *features_table = NULL;
|
|
uint64_t mask, features = 0;
|
|
char str[41];
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
sprintf(str + (i * 5), " 0x%2.2x", features_array[i]);
|
|
features |= ((uint64_t) features_array[i]) << (i * 8);
|
|
}
|
|
|
|
print_field("Features:%s", str);
|
|
|
|
switch (page) {
|
|
case 0:
|
|
features_table = features_page0;
|
|
break;
|
|
case 1:
|
|
features_table = features_page1;
|
|
break;
|
|
case 2:
|
|
features_table = features_page2;
|
|
break;
|
|
}
|
|
|
|
if (!features_table)
|
|
return;
|
|
|
|
mask = features;
|
|
|
|
for (i = 0; features_table[i].str; i++) {
|
|
if (features & (((uint64_t) 1) << features_table[i].bit)) {
|
|
print_field(" %s", features_table[i].str);
|
|
mask &= ~(((uint64_t) 1) << features_table[i].bit);
|
|
}
|
|
}
|
|
|
|
if (mask)
|
|
print_field(" Unknown features (0x%16.16" PRIx64 ")", mask);
|
|
}
|
|
|
|
static void print_le_states(const uint8_t *states)
|
|
{
|
|
char str[17];
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
sprintf(str + (i * 2), "%2.2x", states[i]);
|
|
|
|
print_field("States: 0x%s", str);
|
|
}
|
|
|
|
static void print_le_channel_map(const uint8_t *map)
|
|
{
|
|
char str[11];
|
|
int i;
|
|
|
|
for (i = 0; i < 5; i++)
|
|
sprintf(str + (i * 2), "%2.2x", map[i]);
|
|
|
|
print_field("Channel map: 0x%s", str);
|
|
}
|
|
|
|
static void print_random_number(const uint8_t *number)
|
|
{
|
|
print_hex_field("Random number", number, 8);
|
|
}
|
|
|
|
static const struct {
|
|
uint8_t bit;
|
|
const char *str;
|
|
} events_table[] = {
|
|
{ 0, "Inquiry Complete" },
|
|
{ 1, "Inquiry Result" },
|
|
{ 2, "Connection Complete" },
|
|
{ 3, "Connection Request" },
|
|
{ 4, "Disconnection Complete" },
|
|
{ 5, "Authentication Complete" },
|
|
{ 6, "Remote Name Request Complete" },
|
|
{ 7, "Encryption Change" },
|
|
{ 8, "Change Connection Link Key Complete" },
|
|
{ 9, "Master Link Key Complete" },
|
|
{ 10, "Read Remote Supported Features Complete" },
|
|
{ 11, "Read Remote Version Information Complete" },
|
|
{ 12, "QoS Setup Complete" },
|
|
{ 13, "Command Complete" },
|
|
{ 14, "Command Status" },
|
|
{ 15, "Hardware Error" },
|
|
{ 16, "Flush Occurred" },
|
|
{ 17, "Role Change" },
|
|
{ 19, "Mode Change" },
|
|
{ 20, "Return Link Keys" },
|
|
{ 21, "PIN Code Request" },
|
|
{ 22, "Link Key Request" },
|
|
{ 23, "Link Key Notification" },
|
|
{ 24, "Loopback Command" },
|
|
{ 25, "Data Buffer Overflow" },
|
|
{ 26, "Max Slots Change" },
|
|
{ 27, "Read Clock Offset Complete" },
|
|
{ 28, "Connection Packet Type Changed" },
|
|
{ 29, "QoS Violation" },
|
|
{ 30, "Page Scan Mode Change" },
|
|
{ 31, "Page Scan Repetition Mode Change" },
|
|
{ 32, "Flow Specification Complete" },
|
|
{ 33, "Inquiry Result with RSSI" },
|
|
{ 34, "Read Remote Extended Features Complete" },
|
|
{ 43, "Synchronous Connection Complete" },
|
|
{ 44, "Synchronous Connection Changed" },
|
|
{ 45, "Sniff Subrating" },
|
|
{ 46, "Extended Inquiry Result" },
|
|
{ 47, "Encryption Key Refresh Complete" },
|
|
{ 48, "IO Capability Request" },
|
|
{ 49, "IO Capability Request Reply" },
|
|
{ 50, "User Confirmation Request" },
|
|
{ 51, "User Passkey Request" },
|
|
{ 52, "Remote OOB Data Request" },
|
|
{ 53, "Simple Pairing Complete" },
|
|
{ 55, "Link Supervision Timeout Changed" },
|
|
{ 56, "Enhanced Flush Complete" },
|
|
{ 58, "User Passkey Notification" },
|
|
{ 59, "Keypress Notification" },
|
|
{ 60, "Remote Host Supported Features Notification" },
|
|
{ 61, "LE Meta" },
|
|
{ }
|
|
};
|
|
|
|
static void print_event_mask(const uint8_t *events_array)
|
|
{
|
|
uint64_t mask, events = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
events |= ((uint64_t) events_array[i]) << (i * 8);
|
|
|
|
print_field("Mask: 0x%16.16" PRIx64, events);
|
|
|
|
mask = events;
|
|
|
|
for (i = 0; events_table[i].str; i++) {
|
|
if (events & (((uint64_t) 1) << events_table[i].bit)) {
|
|
print_field(" %s", events_table[i].str);
|
|
mask &= ~(((uint64_t) 1) << events_table[i].bit);
|
|
}
|
|
}
|
|
|
|
if (mask)
|
|
print_field(" Unknown mask (0x%16.16" PRIx64 ")", mask);
|
|
}
|
|
|
|
static const struct {
|
|
uint8_t bit;
|
|
const char *str;
|
|
} events_page2_table[] = {
|
|
{ 0, "Physical Link Complete" },
|
|
{ 1, "Channel Selected" },
|
|
{ 2, "Disconnection Physical Link" },
|
|
{ 3, "Physical Link Loss Early Warning" },
|
|
{ 4, "Physical Link Recovery" },
|
|
{ 5, "Logical Link Complete" },
|
|
{ 6, "Disconnection Logical Link Complete" },
|
|
{ 7, "Flow Spec Modify Complete" },
|
|
{ 8, "Number of Completed Data Blocks" },
|
|
{ 9, "AMP Start Test" },
|
|
{ 10, "AMP Test End" },
|
|
{ 11, "AMP Receiver Report" },
|
|
{ 12, "Short Range Mode Change Complete" },
|
|
{ 13, "AMP Status Change" },
|
|
{ }
|
|
};
|
|
|
|
static void print_event_mask_page2(const uint8_t *events_array)
|
|
{
|
|
uint64_t mask, events = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
events |= ((uint64_t) events_array[i]) << (i * 8);
|
|
|
|
print_field("Mask: 0x%16.16" PRIx64, events);
|
|
|
|
mask = events;
|
|
|
|
for (i = 0; events_page2_table[i].str; i++) {
|
|
if (events & (((uint64_t) 1) << events_page2_table[i].bit)) {
|
|
print_field(" %s", events_page2_table[i].str);
|
|
mask &= ~(((uint64_t) 1) << events_page2_table[i].bit);
|
|
}
|
|
}
|
|
|
|
if (mask)
|
|
print_field(" Unknown mask (0x%16.16" PRIx64 ")", mask);
|
|
}
|
|
|
|
static void print_fec(uint8_t fec)
|
|
{
|
|
const char *str;
|
|
|
|
switch (fec) {
|
|
case 0x00:
|
|
str = "Not required";
|
|
break;
|
|
case 0x01:
|
|
str = "Required";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("FEC: %s (0x%02x)", str, fec);
|
|
}
|
|
|
|
#define BT_EIR_FLAGS 0x01
|
|
#define BT_EIR_UUID16_SOME 0x02
|
|
#define BT_EIR_UUID16_ALL 0x03
|
|
#define BT_EIR_UUID32_SOME 0x04
|
|
#define BT_EIR_UUID32_ALL 0x05
|
|
#define BT_EIR_UUID128_SOME 0x06
|
|
#define BT_EIR_UUID128_ALL 0x07
|
|
#define BT_EIR_NAME_SHORT 0x08
|
|
#define BT_EIR_NAME_COMPLETE 0x09
|
|
#define BT_EIR_TX_POWER 0x0a
|
|
#define BT_EIR_CLASS_OF_DEV 0x0d
|
|
#define BT_EIR_SSP_HASH 0x0e
|
|
#define BT_EIR_SSP_RANDOMIZER 0x0f
|
|
#define BT_EIR_DEVICE_ID 0x10
|
|
#define BT_EIR_SMP_TK 0x10
|
|
#define BT_EIR_SMP_OOB_FLAGS 0x11
|
|
#define BT_EIR_SLAVE_CONN_INT 0x12
|
|
#define BT_EIR_SERVICE_UUID16 0x14
|
|
#define BT_EIR_SERVICE_UUID128 0x15
|
|
#define BT_EIR_SERVICE_DATA 0x16
|
|
#define BT_EIR_RANDOM_ADDRESS 0x17
|
|
#define BT_EIR_PUBLIC_ADDRESS 0x18
|
|
#define BT_EIR_GAP_APPEARANCE 0x19
|
|
#define BT_EIR_MANUFACTURER_DATA 0xff
|
|
|
|
static void print_uuid16_list(const char *label, const void *data,
|
|
uint8_t data_len)
|
|
{
|
|
const uint16_t *uuids = data;
|
|
uint8_t count = data_len / sizeof(uint16_t);
|
|
char str[count * 7 + 1];
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
sprintf(str + (i * 7), "0x%4.4x ", bt_get_le16(&uuids[i]));
|
|
|
|
print_field("%s: %s", label, str);
|
|
}
|
|
|
|
static void print_uuid32_list(const char *label, const void *data,
|
|
uint8_t data_len)
|
|
{
|
|
const uint32_t *uuids = data;
|
|
uint8_t count = data_len / sizeof(uint32_t);
|
|
char str[count * 11 + 1];
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
sprintf(str + (i * 11), "0x%8.8x ", bt_get_le32(&uuids[i]));
|
|
|
|
print_field("%s: %s", label, str);
|
|
}
|
|
|
|
static void print_uuid128_list(const char *label, const void *data,
|
|
uint8_t data_len)
|
|
{
|
|
uint8_t count = data_len / 16;
|
|
char str[count * 38 + 1];
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
const uint8_t *uuid = data + (i * 16);
|
|
|
|
sprintf(str + (i * 38), "%.8x-%.4x-%.4x-%.4x-%.8x%.4x ",
|
|
bt_get_le32(&uuid[12]), bt_get_le16(&uuid[10]),
|
|
bt_get_le16(&uuid[8]), bt_get_le16(&uuid[6]),
|
|
bt_get_le32(&uuid[2]), bt_get_le16(&uuid[0]));
|
|
}
|
|
|
|
print_field("%s: %s", label, str);
|
|
}
|
|
|
|
static void print_eir(const uint8_t *eir, uint8_t eir_len, bool le)
|
|
{
|
|
uint8_t len = 0;
|
|
|
|
if (eir_len == 0)
|
|
return;
|
|
|
|
while (len < eir_len - 1) {
|
|
uint8_t field_len = eir[0];
|
|
const uint8_t *data = &eir[2];
|
|
uint8_t data_len;
|
|
char name[239], label[100];
|
|
uint32_t cls;
|
|
|
|
/* Check for the end of EIR */
|
|
if (field_len == 0)
|
|
break;
|
|
|
|
len += field_len + 1;
|
|
|
|
/* Do not continue EIR Data parsing if got incorrect length */
|
|
if (len > eir_len) {
|
|
len -= field_len + 1;
|
|
break;
|
|
}
|
|
|
|
data_len = field_len - 1;
|
|
|
|
switch (eir[1]) {
|
|
case BT_EIR_FLAGS:
|
|
print_field("Flags: 0x%2.2x", *data);
|
|
break;
|
|
|
|
case BT_EIR_UUID16_SOME:
|
|
if (data_len < sizeof(uint16_t))
|
|
break;
|
|
print_uuid16_list("16-bit Service UUIDs (partial)",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_UUID16_ALL:
|
|
if (data_len < sizeof(uint16_t))
|
|
break;
|
|
print_uuid16_list("16-bit Service UUIDs (complete)",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_UUID32_SOME:
|
|
if (data_len < sizeof(uint32_t))
|
|
break;
|
|
print_uuid32_list("32-bit Service UUIDs (partial)",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_UUID32_ALL:
|
|
if (data_len < sizeof(uint32_t))
|
|
break;
|
|
print_uuid32_list("32-bit Service UUIDs (complete)",
|
|
data, data_len);
|
|
break;
|
|
case BT_EIR_UUID128_SOME:
|
|
if (data_len < 16)
|
|
break;
|
|
print_uuid128_list("128-bit Service UUIDs (partial)",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_UUID128_ALL:
|
|
if (data_len < 16)
|
|
break;
|
|
print_uuid128_list("128-bit Service UUIDs (complete)",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_NAME_SHORT:
|
|
memset(name, 0, sizeof(name));
|
|
memcpy(name, data, data_len);
|
|
print_field("Name (short): %s", name);
|
|
break;
|
|
|
|
case BT_EIR_NAME_COMPLETE:
|
|
memset(name, 0, sizeof(name));
|
|
memcpy(name, data, data_len);
|
|
print_field("Name (complete): %s", name);
|
|
break;
|
|
|
|
case BT_EIR_TX_POWER:
|
|
print_field("TX power: %d dBm", (int8_t) *data);
|
|
break;
|
|
|
|
case BT_EIR_CLASS_OF_DEV:
|
|
if (data_len < 3)
|
|
break;
|
|
cls = data[0] | (data[1] << 8) | (data[2] << 16);
|
|
print_field("Class Of Device: 0x%6.6x", cls);
|
|
break;
|
|
|
|
case BT_EIR_SSP_HASH:
|
|
print_hex_field("SSP Hash", data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_SSP_RANDOMIZER:
|
|
print_hex_field("SSP Rand", data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_DEVICE_ID:
|
|
/* SMP TK has the same value as Device ID */
|
|
if (le)
|
|
print_hex_field("SMP TK", data, data_len);
|
|
else if (data_len >= 8)
|
|
print_field("Device ID: "
|
|
"Source 0x%4.4x "
|
|
"Vendor 0x%4.4x "
|
|
"Product 0x%4.4x "
|
|
"Version 0x%4.4x",
|
|
bt_get_le16(&data[0]),
|
|
bt_get_le16(&data[2]),
|
|
bt_get_le16(&data[4]),
|
|
bt_get_le16(&data[6]));
|
|
break;
|
|
|
|
case BT_EIR_SMP_OOB_FLAGS:
|
|
print_field("SMP OOB Flags: 0x%2.2x", *data);
|
|
break;
|
|
|
|
case BT_EIR_SLAVE_CONN_INT:
|
|
if (data_len < 4)
|
|
break;
|
|
print_field("Slave Conn. Interval: 0x%4.4x - 0x%4.4x",
|
|
bt_get_le16(&data[0]),
|
|
bt_get_le16(&data[2]));
|
|
break;
|
|
|
|
case BT_EIR_SERVICE_UUID16:
|
|
if (data_len < sizeof(uint16_t))
|
|
break;
|
|
print_uuid16_list("16-bit Service UUIDs",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_SERVICE_UUID128:
|
|
if (data_len < 16)
|
|
break;
|
|
print_uuid128_list("128-bit Service UUIDs",
|
|
data, data_len);
|
|
break;
|
|
|
|
case BT_EIR_SERVICE_DATA:
|
|
if (data_len < 2)
|
|
break;
|
|
sprintf(label, "Service Data (UUID 0x%4.4x)",
|
|
bt_get_le16(&data[0]));
|
|
print_hex_field(label, &data[2], data_len - 2);
|
|
break;
|
|
|
|
case BT_EIR_RANDOM_ADDRESS:
|
|
if (data_len < 6)
|
|
break;
|
|
print_addr(data, 0x01);
|
|
break;
|
|
|
|
case BT_EIR_PUBLIC_ADDRESS:
|
|
if (data_len < 6)
|
|
break;
|
|
print_addr(data, 0x00);
|
|
break;
|
|
|
|
case BT_EIR_GAP_APPEARANCE:
|
|
if (data_len < 2)
|
|
break;
|
|
print_field("Appearance: 0x%4.4x", bt_get_le16(data));
|
|
break;
|
|
|
|
case BT_EIR_MANUFACTURER_DATA:
|
|
print_hex_field("Manufacturer Data", data, data_len);
|
|
break;
|
|
|
|
default:
|
|
sprintf(label, "Unknown EIR field 0x%2.2x", eir[1]);
|
|
print_hex_field(label, data, data_len);
|
|
break;
|
|
}
|
|
|
|
eir += field_len + 1;
|
|
}
|
|
|
|
if (len < eir_len && eir[0] != 0)
|
|
packet_hexdump(eir, eir_len - len);
|
|
}
|
|
|
|
void packet_hexdump(const unsigned char *buf, uint16_t len)
|
|
{
|
|
static const char hexdigits[] = "0123456789abcdef";
|
|
char str[68];
|
|
uint16_t i;
|
|
|
|
if (!len)
|
|
return;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
str[((i % 16) * 3) + 0] = hexdigits[buf[i] >> 4];
|
|
str[((i % 16) * 3) + 1] = hexdigits[buf[i] & 0xf];
|
|
str[((i % 16) * 3) + 2] = ' ';
|
|
str[(i % 16) + 49] = isprint(buf[i]) ? buf[i] : '.';
|
|
|
|
if ((i + 1) % 16 == 0) {
|
|
str[47] = ' ';
|
|
str[48] = ' ';
|
|
str[65] = '\0';
|
|
print_text(COLOR_WHITE, "%s", str);
|
|
str[0] = ' ';
|
|
}
|
|
}
|
|
|
|
if (i % 16 > 0) {
|
|
uint16_t j;
|
|
for (j = (i % 16); j < 16; j++) {
|
|
str[(j * 3) + 0] = ' ';
|
|
str[(j * 3) + 1] = ' ';
|
|
str[(j * 3) + 2] = ' ';
|
|
str[j + 49] = ' ';
|
|
}
|
|
str[47] = ' ';
|
|
str[48] = ' ';
|
|
str[65] = '\0';
|
|
print_text(COLOR_WHITE, "%s", str);
|
|
}
|
|
}
|
|
|
|
void packet_control(struct timeval *tv, uint16_t index, uint16_t opcode,
|
|
const void *data, uint16_t size)
|
|
{
|
|
if (index_filter && index_number != index)
|
|
return;
|
|
|
|
control_message(opcode, data, size);
|
|
}
|
|
|
|
#define MONITOR_NEW_INDEX 0
|
|
#define MONITOR_DEL_INDEX 1
|
|
#define MONITOR_COMMAND_PKT 2
|
|
#define MONITOR_EVENT_PKT 3
|
|
#define MONITOR_ACL_TX_PKT 4
|
|
#define MONITOR_ACL_RX_PKT 5
|
|
#define MONITOR_SCO_TX_PKT 6
|
|
#define MONITOR_SCO_RX_PKT 7
|
|
|
|
struct monitor_new_index {
|
|
uint8_t type;
|
|
uint8_t bus;
|
|
bdaddr_t bdaddr;
|
|
char name[8];
|
|
} __attribute__((packed));
|
|
|
|
#define MONITOR_NEW_INDEX_SIZE 16
|
|
|
|
#define MONITOR_DEL_INDEX_SIZE 0
|
|
|
|
#define MAX_INDEX 16
|
|
|
|
struct index_data {
|
|
bdaddr_t bdaddr;
|
|
};
|
|
|
|
static struct index_data index_list[MAX_INDEX];
|
|
|
|
uint32_t packet_get_flags(uint16_t opcode)
|
|
{
|
|
switch (opcode) {
|
|
case MONITOR_NEW_INDEX:
|
|
case MONITOR_DEL_INDEX:
|
|
break;
|
|
case MONITOR_COMMAND_PKT:
|
|
return 0x02;
|
|
case MONITOR_EVENT_PKT:
|
|
return 0x03;
|
|
case MONITOR_ACL_TX_PKT:
|
|
return 0x00;
|
|
case MONITOR_ACL_RX_PKT:
|
|
return 0x01;
|
|
case MONITOR_SCO_TX_PKT:
|
|
case MONITOR_SCO_RX_PKT:
|
|
break;
|
|
}
|
|
|
|
return 0xff;
|
|
}
|
|
|
|
uint16_t packet_get_opcode(uint8_t type, uint32_t flags)
|
|
{
|
|
switch (type) {
|
|
case HCI_COMMAND_PKT:
|
|
return MONITOR_COMMAND_PKT;
|
|
case HCI_ACLDATA_PKT:
|
|
if (flags & 0x01)
|
|
return MONITOR_ACL_RX_PKT;
|
|
else
|
|
return MONITOR_ACL_TX_PKT;
|
|
case HCI_SCODATA_PKT:
|
|
if (flags & 0x01)
|
|
return MONITOR_SCO_RX_PKT;
|
|
else
|
|
return MONITOR_SCO_TX_PKT;
|
|
case HCI_EVENT_PKT:
|
|
return MONITOR_EVENT_PKT;
|
|
case 0xff:
|
|
if (flags & 0x02) {
|
|
if (flags & 0x01)
|
|
return MONITOR_EVENT_PKT;
|
|
else
|
|
return MONITOR_COMMAND_PKT;
|
|
} else {
|
|
if (flags & 0x01)
|
|
return MONITOR_ACL_RX_PKT;
|
|
else
|
|
return MONITOR_ACL_TX_PKT;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0xff;
|
|
}
|
|
|
|
void packet_monitor(struct timeval *tv, uint16_t index, uint16_t opcode,
|
|
const void *data, uint16_t size)
|
|
{
|
|
const struct monitor_new_index *ni;
|
|
char str[18], extra_str[24];
|
|
|
|
if (index_filter && index_number != index)
|
|
return;
|
|
|
|
if (tv && time_offset == ((time_t) -1))
|
|
time_offset = tv->tv_sec;
|
|
|
|
switch (opcode) {
|
|
case MONITOR_NEW_INDEX:
|
|
ni = data;
|
|
|
|
if (index < MAX_INDEX) {
|
|
bacpy(&index_list[index].bdaddr, &ni->bdaddr);
|
|
}
|
|
|
|
ba2str(&ni->bdaddr, str);
|
|
packet_new_index(tv, index, str, ni->type, ni->bus, ni->name);
|
|
break;
|
|
case MONITOR_DEL_INDEX:
|
|
if (index < MAX_INDEX)
|
|
ba2str(&index_list[index].bdaddr, str);
|
|
else
|
|
ba2str(BDADDR_ANY, str);
|
|
|
|
packet_del_index(tv, index, str);
|
|
break;
|
|
case MONITOR_COMMAND_PKT:
|
|
packet_hci_command(tv, index, data, size);
|
|
break;
|
|
case MONITOR_EVENT_PKT:
|
|
packet_hci_event(tv, index, data, size);
|
|
break;
|
|
case MONITOR_ACL_TX_PKT:
|
|
packet_hci_acldata(tv, index, false, data, size);
|
|
break;
|
|
case MONITOR_ACL_RX_PKT:
|
|
packet_hci_acldata(tv, index, true, data, size);
|
|
break;
|
|
case MONITOR_SCO_TX_PKT:
|
|
packet_hci_scodata(tv, index, false, data, size);
|
|
break;
|
|
case MONITOR_SCO_RX_PKT:
|
|
packet_hci_scodata(tv, index, true, data, size);
|
|
break;
|
|
default:
|
|
sprintf(extra_str, "(code %d len %d)", opcode, size);
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Unknown packet", NULL, extra_str);
|
|
packet_hexdump(data, size);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void null_cmd(const void *data, uint8_t size)
|
|
{
|
|
}
|
|
|
|
static void status_rsp(const void *data, uint8_t size)
|
|
{
|
|
uint8_t status = *((const uint8_t *) data);
|
|
|
|
print_status(status);
|
|
}
|
|
|
|
static void status_bdaddr_rsp(const void *data, uint8_t size)
|
|
{
|
|
uint8_t status = *((const uint8_t *) data);
|
|
|
|
print_status(status);
|
|
print_bdaddr(data + 1);
|
|
}
|
|
|
|
static void inquiry_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_inquiry *cmd = data;
|
|
|
|
print_iac(cmd->lap);
|
|
print_field("Length: %.2fs (0x%2.2x)",
|
|
cmd->length * 1.28, cmd->length);
|
|
print_num_resp(cmd->num_resp);
|
|
}
|
|
|
|
static void periodic_inquiry_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_periodic_inquiry *cmd = data;
|
|
|
|
print_field("Max period: %.2fs (0x%2.2x)",
|
|
cmd->max_period * 1.28, cmd->max_period);
|
|
print_field("Min period: %.2fs (0x%2.2x)",
|
|
cmd->min_period * 1.28, cmd->min_period);
|
|
print_iac(cmd->lap);
|
|
print_field("Length: %.2fs (0x%2.2x)",
|
|
cmd->length * 1.28, cmd->length);
|
|
print_num_resp(cmd->num_resp);
|
|
}
|
|
|
|
static void create_conn_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_create_conn *cmd = data;
|
|
const char *str;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_pkt_type(cmd->pkt_type);
|
|
print_pscan_rep_mode(cmd->pscan_rep_mode);
|
|
print_pscan_mode(cmd->pscan_mode);
|
|
print_clock_offset(cmd->clock_offset);
|
|
|
|
switch (cmd->role_switch) {
|
|
case 0x00:
|
|
str = "Stay master";
|
|
break;
|
|
case 0x01:
|
|
str = "Allow slave";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Role switch: %s (0x%2.2x)", str, cmd->role_switch);
|
|
}
|
|
|
|
static void disconnect_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_disconnect *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_reason(cmd->reason);
|
|
}
|
|
|
|
static void add_sco_conn_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_add_sco_conn *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_pkt_type(cmd->pkt_type);
|
|
}
|
|
|
|
static void create_conn_cancel_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_create_conn_cancel *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void accept_conn_request_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_accept_conn_request *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_role(cmd->role);
|
|
}
|
|
|
|
static void reject_conn_request_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_reject_conn_request *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_reason(cmd->reason);
|
|
}
|
|
|
|
static void link_key_request_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_link_key_request_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_link_key(cmd->link_key);
|
|
}
|
|
|
|
static void link_key_request_neg_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_link_key_request_neg_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void pin_code_request_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_pin_code_request_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_field("PIN length: %d", cmd->pin_len);
|
|
print_pin_code(cmd->pin_code);
|
|
}
|
|
|
|
static void pin_code_request_neg_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_pin_code_request_neg_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void change_conn_pkt_type_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_change_conn_pkt_type *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_pkt_type(cmd->pkt_type);
|
|
}
|
|
|
|
static void auth_requested_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_auth_requested *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void set_conn_encrypt_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_set_conn_encrypt *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_encr_mode(cmd->encr_mode);
|
|
}
|
|
|
|
static void change_conn_link_key_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_change_conn_link_key *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void master_link_key_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_master_link_key *cmd = data;
|
|
|
|
print_key_flag(cmd->key_flag);
|
|
}
|
|
|
|
static void remote_name_request_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_remote_name_request *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_pscan_rep_mode(cmd->pscan_rep_mode);
|
|
print_pscan_mode(cmd->pscan_mode);
|
|
print_clock_offset(cmd->clock_offset);
|
|
}
|
|
|
|
static void remote_name_request_cancel_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_remote_name_request_cancel *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void read_remote_features_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_remote_features *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_remote_ext_features_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_remote_ext_features *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_field("Page: %d", cmd->page);
|
|
}
|
|
|
|
static void read_remote_version_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_remote_version *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_clock_offset_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_clock_offset *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_lmp_handle_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_lmp_handle *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_lmp_handle_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_lmp_handle *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
print_field("LMP handle: %d", rsp->lmp_handle);
|
|
print_field("Reserved: %d", btohl(rsp->reserved));
|
|
}
|
|
|
|
static void setup_sync_conn_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_setup_sync_conn *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_field("Transmit bandwidth: %d", btohl(cmd->tx_bandwidth));
|
|
print_field("Receive bandwidth: %d", btohl(cmd->rx_bandwidth));
|
|
print_field("Max latency: %d", btohs(cmd->max_latency));
|
|
print_voice_setting(cmd->voice_setting);
|
|
print_retransmission_effort(cmd->retrans_effort);
|
|
print_pkt_type(cmd->pkt_type);
|
|
}
|
|
|
|
static void accept_sync_conn_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_accept_sync_conn *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_field("Transmit bandwidth: %d", btohl(cmd->tx_bandwidth));
|
|
print_field("Receive bandwidth: %d", btohl(cmd->rx_bandwidth));
|
|
print_field("Max latency: %d", btohs(cmd->max_latency));
|
|
print_voice_setting(cmd->voice_setting);
|
|
print_retransmission_effort(cmd->retrans_effort);
|
|
print_pkt_type(cmd->pkt_type);
|
|
}
|
|
|
|
static void reject_sync_conn_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_reject_sync_conn *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_reason(cmd->reason);
|
|
}
|
|
|
|
static void io_capability_request_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_io_capability_request_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_io_capability(cmd->capability);
|
|
print_oob_data(cmd->oob_data);
|
|
print_authentication(cmd->authentication);
|
|
}
|
|
|
|
static void user_confirm_request_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_user_confirm_request_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void user_confirm_request_neg_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_user_confirm_request_neg_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void user_passkey_request_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_user_passkey_request_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_passkey(cmd->passkey);
|
|
}
|
|
|
|
static void user_passkey_request_neg_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_user_passkey_request_neg_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void remote_oob_data_request_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_remote_oob_data_request_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_hash(cmd->hash);
|
|
print_randomizer(cmd->randomizer);
|
|
}
|
|
|
|
static void remote_oob_data_request_neg_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_remote_oob_data_request_neg_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
}
|
|
|
|
static void io_capability_request_neg_reply_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_io_capability_request_neg_reply *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_reason(cmd->reason);
|
|
}
|
|
|
|
static void create_phy_link_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_create_phy_link *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_key_len(cmd->key_len);
|
|
print_key_type(cmd->key_type);
|
|
|
|
packet_hexdump(data + 3, size - 3);
|
|
}
|
|
|
|
static void accept_phy_link_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_accept_phy_link *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_key_len(cmd->key_len);
|
|
print_key_type(cmd->key_type);
|
|
|
|
packet_hexdump(data + 3, size - 3);
|
|
}
|
|
|
|
static void disconn_phy_link_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_disconn_phy_link *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_reason(cmd->reason);
|
|
}
|
|
|
|
static void create_logic_link_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_create_logic_link *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_flow_spec("TX", cmd->tx_flow_spec);
|
|
print_flow_spec("RX", cmd->rx_flow_spec);
|
|
}
|
|
|
|
static void accept_logic_link_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_accept_logic_link *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_flow_spec("TX", cmd->tx_flow_spec);
|
|
print_flow_spec("RX", cmd->rx_flow_spec);
|
|
}
|
|
|
|
static void disconn_logic_link_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_disconn_logic_link *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void logic_link_cancel_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_logic_link_cancel *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_field("TX flow spec: 0x%2.2x", cmd->flow_spec);
|
|
}
|
|
|
|
static void logic_link_cancel_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_logic_link_cancel *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_phy_handle(rsp->phy_handle);
|
|
print_field("TX flow spec: 0x%2.2x", rsp->flow_spec);
|
|
}
|
|
|
|
static void flow_spec_modify_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_flow_spec_modify *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_flow_spec("TX", cmd->tx_flow_spec);
|
|
print_flow_spec("RX", cmd->rx_flow_spec);
|
|
}
|
|
|
|
static void hold_mode_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_hold_mode *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_slot_625("Hold max interval", cmd->max_interval);
|
|
print_slot_625("Hold min interval", cmd->min_interval);
|
|
}
|
|
|
|
static void sniff_mode_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_sniff_mode *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_slot_625("Sniff max interval", cmd->max_interval);
|
|
print_slot_625("Sniff min interval", cmd->min_interval);
|
|
print_slot_125("Sniff attempt", cmd->attempt);
|
|
print_slot_125("Sniff timeout", cmd->timeout);
|
|
}
|
|
|
|
static void exit_sniff_mode_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_exit_sniff_mode *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void park_state_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_park_state *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_slot_625("Beacon max interval", cmd->max_interval);
|
|
print_slot_625("Beacon min interval", cmd->min_interval);
|
|
}
|
|
|
|
static void exit_park_state_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_exit_park_state *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void qos_setup_cmd(const void *data, uint8_t size)
|
|
{
|
|
packet_hexdump(data, size);
|
|
}
|
|
|
|
static void role_discovery_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_role_discovery *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void role_discovery_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_role_discovery *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
print_role(rsp->role);
|
|
}
|
|
|
|
static void switch_role_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_switch_role *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_role(cmd->role);
|
|
}
|
|
|
|
static void read_link_policy_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_link_policy *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_link_policy_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_link_policy *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
print_link_policy(rsp->policy);
|
|
}
|
|
|
|
static void write_link_policy_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_link_policy *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_link_policy(cmd->policy);
|
|
}
|
|
|
|
static void write_link_policy_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_write_link_policy *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
}
|
|
|
|
static void read_default_link_policy_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_default_link_policy *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_link_policy(rsp->policy);
|
|
}
|
|
|
|
static void write_default_link_policy_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_default_link_policy *cmd = data;
|
|
|
|
print_link_policy(cmd->policy);
|
|
}
|
|
|
|
static void flow_spec_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_flow_spec *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_field("Flags: 0x%2.2x", cmd->flags);
|
|
|
|
print_flow_direction(cmd->direction);
|
|
print_service_type(cmd->service_type);
|
|
|
|
print_field("Token rate: %d", btohl(cmd->token_rate));
|
|
print_field("Token bucket size: %d", btohl(cmd->token_bucket_size));
|
|
print_field("Peak bandwidth: %d", btohl(cmd->peak_bandwidth));
|
|
print_field("Access latency: %d", btohl(cmd->access_latency));
|
|
}
|
|
|
|
static void sniff_subrating_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_sniff_subrating *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_slot_625("Max latency", cmd->max_latency);
|
|
print_slot_625("Min remote timeout", cmd->min_remote_timeout);
|
|
print_slot_625("Min local timeout", cmd->min_local_timeout);
|
|
}
|
|
|
|
static void sniff_subrating_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_sniff_subrating *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
}
|
|
|
|
static void set_event_mask_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_set_event_mask *cmd = data;
|
|
|
|
print_event_mask(cmd->mask);
|
|
}
|
|
|
|
static void set_event_filter_cmd(const void *data, uint8_t size)
|
|
{
|
|
uint8_t type = *((const uint8_t *) data);
|
|
|
|
print_field("Type: 0x%2.2x", type);
|
|
|
|
packet_hexdump(data + 1, size - 1);
|
|
}
|
|
|
|
static void flush_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_flush *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void flush_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_flush *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
}
|
|
|
|
static void read_pin_type_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_pin_type *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_pin_type(rsp->pin_type);
|
|
}
|
|
|
|
static void write_pin_type_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_pin_type *cmd = data;
|
|
|
|
print_pin_type(cmd->pin_type);
|
|
}
|
|
|
|
static void read_stored_link_key_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_stored_link_key *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_field("Read all: 0x%2.2x", cmd->read_all);
|
|
}
|
|
|
|
static void read_stored_link_key_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_stored_link_key *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Max num keys: %d", btohs(rsp->max_num_keys));
|
|
print_field("Num keys: %d", btohs(rsp->num_keys));
|
|
}
|
|
|
|
static void write_stored_link_key_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_stored_link_key *cmd = data;
|
|
|
|
print_field("Num keys: %d", cmd->num_keys);
|
|
|
|
packet_hexdump(data + 1, size - 1);
|
|
}
|
|
|
|
static void write_stored_link_key_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_write_stored_link_key *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Num keys: %d", rsp->num_keys);
|
|
}
|
|
|
|
static void delete_stored_link_key_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_delete_stored_link_key *cmd = data;
|
|
|
|
print_bdaddr(cmd->bdaddr);
|
|
print_field("Delete all: 0x%2.2x", cmd->delete_all);
|
|
}
|
|
|
|
static void delete_stored_link_key_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_delete_stored_link_key *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Num keys: %d", btohs(rsp->num_keys));
|
|
}
|
|
|
|
static void write_local_name_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_local_name *cmd = data;
|
|
|
|
print_name(cmd->name);
|
|
}
|
|
|
|
static void read_local_name_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_name *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_name(rsp->name);
|
|
}
|
|
|
|
static void read_conn_accept_timeout_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_conn_accept_timeout *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_timeout(rsp->timeout);
|
|
}
|
|
|
|
static void write_conn_accept_timeout_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_conn_accept_timeout *cmd = data;
|
|
|
|
print_timeout(cmd->timeout);
|
|
}
|
|
|
|
static void read_page_timeout_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_page_timeout *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_timeout(rsp->timeout);
|
|
}
|
|
|
|
static void write_page_timeout_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_page_timeout *cmd = data;
|
|
|
|
print_timeout(cmd->timeout);
|
|
}
|
|
|
|
static void read_scan_enable_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_scan_enable *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_scan_enable(rsp->enable);
|
|
}
|
|
|
|
static void write_scan_enable_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_scan_enable *cmd = data;
|
|
|
|
print_scan_enable(cmd->enable);
|
|
}
|
|
|
|
static void read_class_of_dev_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_class_of_dev *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_dev_class(rsp->dev_class);
|
|
}
|
|
|
|
static void write_class_of_dev_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_class_of_dev *cmd = data;
|
|
|
|
print_dev_class(cmd->dev_class);
|
|
}
|
|
|
|
static void read_voice_setting_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_voice_setting *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_voice_setting(rsp->setting);
|
|
}
|
|
|
|
static void write_voice_setting_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_voice_setting *cmd = data;
|
|
|
|
print_voice_setting(cmd->setting);
|
|
}
|
|
|
|
static void read_inquiry_mode_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_inquiry_mode *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_inquiry_mode(rsp->mode);
|
|
}
|
|
|
|
static void write_inquiry_mode_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_inquiry_mode *cmd = data;
|
|
|
|
print_inquiry_mode(cmd->mode);
|
|
}
|
|
|
|
static void read_ext_inquiry_response_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_ext_inquiry_response *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_fec(rsp->fec);
|
|
print_eir(rsp->data, sizeof(rsp->data), false);
|
|
}
|
|
|
|
static void write_ext_inquiry_response_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_ext_inquiry_response *cmd = data;
|
|
|
|
print_fec(cmd->fec);
|
|
print_eir(cmd->data, sizeof(cmd->data), false);
|
|
}
|
|
|
|
static void refresh_encrypt_key_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_refresh_encrypt_key *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_simple_pairing_mode_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_simple_pairing_mode *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_simple_pairing_mode(rsp->mode);
|
|
}
|
|
|
|
static void write_simple_pairing_mode_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_simple_pairing_mode *cmd = data;
|
|
|
|
print_simple_pairing_mode(cmd->mode);
|
|
}
|
|
|
|
static void read_inquiry_resp_tx_power_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_inquiry_resp_tx_power *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("TX power: %d dBm", rsp->level);
|
|
}
|
|
|
|
static void enhanced_flush_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_enhanced_flush *cmd = data;
|
|
const char *str;
|
|
|
|
print_handle(cmd->handle);
|
|
|
|
switch (cmd->type) {
|
|
case 0x00:
|
|
str = "Automatic flushable only";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Type: %s (0x%2.2x)", str, cmd->type);
|
|
}
|
|
|
|
static void set_event_mask_page2_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_set_event_mask_page2 *cmd = data;
|
|
|
|
print_event_mask_page2(cmd->mask);
|
|
}
|
|
|
|
static void read_le_host_supported_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_le_host_supported *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Supported: 0x%2.2x", rsp->supported);
|
|
print_field("Simultaneous: 0x%2.2x", rsp->simultaneous);
|
|
}
|
|
|
|
static void write_le_host_supported_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_le_host_supported *cmd = data;
|
|
|
|
print_field("Supported: 0x%2.2x", cmd->supported);
|
|
print_field("Simultaneous: 0x%2.2x", cmd->simultaneous);
|
|
}
|
|
|
|
static void read_local_version_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_version *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_hci_version(rsp->hci_ver, rsp->hci_rev);
|
|
print_lmp_version(rsp->lmp_ver, rsp->lmp_subver);
|
|
print_manufacturer(rsp->manufacturer);
|
|
}
|
|
|
|
static void read_local_commands_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_commands *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_commands(rsp->commands);
|
|
}
|
|
|
|
static void read_local_features_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_features *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_features(0, rsp->features);
|
|
}
|
|
|
|
static void read_local_ext_features_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_local_ext_features *cmd = data;
|
|
|
|
print_field("Page: %d", cmd->page);
|
|
}
|
|
|
|
static void read_local_ext_features_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_ext_features *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Page: %d/%d", rsp->page, rsp->max_page);
|
|
print_features(rsp->page, rsp->features);
|
|
}
|
|
|
|
static void read_buffer_size_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_buffer_size *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("ACL MTU: %-4d ACL max packet: %d",
|
|
btohs(rsp->acl_mtu), btohs(rsp->acl_max_pkt));
|
|
print_field("SCO MTU: %-4d SCO max packet: %d",
|
|
rsp->sco_mtu, btohs(rsp->sco_max_pkt));
|
|
}
|
|
|
|
static void read_country_code_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_country_code *rsp = data;
|
|
const char *str;
|
|
|
|
print_status(rsp->status);
|
|
|
|
switch (rsp->code) {
|
|
case 0x00:
|
|
str = "North America, Europe*, Japan";
|
|
break;
|
|
case 0x01:
|
|
str = "France";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Country code: %s (0x%2.2x)", str, rsp->code);
|
|
}
|
|
|
|
static void read_bd_addr_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_bd_addr *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_bdaddr(rsp->bdaddr);
|
|
}
|
|
|
|
static void read_data_block_size_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_data_block_size *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Max ACL length: %d", btohs(rsp->max_acl_len));
|
|
print_field("Block length: %d", btohs(rsp->block_len));
|
|
print_field("Num blocks: %d", btohs(rsp->num_blocks));
|
|
}
|
|
|
|
static void read_encrypt_key_size_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_encrypt_key_size *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void read_encrypt_key_size_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_encrypt_key_size *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
print_key_size(rsp->key_size);
|
|
}
|
|
|
|
static void read_local_amp_info_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_amp_info *rsp = data;
|
|
const char *str;
|
|
|
|
print_status(rsp->status);
|
|
print_amp_status(rsp->amp_status);
|
|
|
|
print_field("Total bandwidth: %d kbps", btohl(rsp->total_bw));
|
|
print_field("Max guaranteed bandwidth: %d kbps", btohl(rsp->max_bw));
|
|
print_field("Min latency: %d", btohl(rsp->min_latency));
|
|
print_field("Max PDU size: %d", btohl(rsp->max_pdu));
|
|
|
|
switch (rsp->amp_type) {
|
|
case 0x00:
|
|
str = "Primary BR/EDR Controller";
|
|
break;
|
|
case 0x01:
|
|
str = "802.11 AMP Controller";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Controller type: %s (0x%2.2x)", str, rsp->amp_type);
|
|
|
|
print_field("PAL capabilities: 0x%4.4x", btohs(rsp->pal_cap));
|
|
print_field("Max ASSOC length: %d", btohs(rsp->max_assoc_len));
|
|
print_field("Max flush timeout: %d", btohl(rsp->max_flush_to));
|
|
print_field("Best effort flush timeout: %d", btohl(rsp->be_flush_to));
|
|
}
|
|
|
|
static void read_local_amp_assoc_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_read_local_amp_assoc *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_field("Length so far: %d", btohs(cmd->len_so_far));
|
|
print_field("Max ASSOC length: %d", btohs(cmd->max_assoc_len));
|
|
}
|
|
|
|
static void read_local_amp_assoc_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_read_local_amp_assoc *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_phy_handle(rsp->phy_handle);
|
|
print_field("Remaining ASSOC length: %d", btohs(rsp->remain_assoc_len));
|
|
|
|
packet_hexdump(data + 4, size - 4);
|
|
}
|
|
|
|
static void write_remote_amp_assoc_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_write_remote_amp_assoc *cmd = data;
|
|
|
|
print_phy_handle(cmd->phy_handle);
|
|
print_field("Length so far: %d", btohs(cmd->len_so_far));
|
|
print_field("Remaining ASSOC length: %d", btohs(cmd->remain_assoc_len));
|
|
|
|
packet_hexdump(data + 5, size - 5);
|
|
}
|
|
|
|
static void write_remote_amp_assoc_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_write_remote_amp_assoc *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_phy_handle(rsp->phy_handle);
|
|
}
|
|
|
|
static void le_set_event_mask_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_event_mask *cmd = data;
|
|
|
|
print_event_mask(cmd->mask);
|
|
}
|
|
|
|
static void le_read_buffer_size_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_read_buffer_size *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("Data packet length: %d", btohs(rsp->le_mtu));
|
|
print_field("Num data packets: %d", rsp->le_max_pkt);
|
|
}
|
|
|
|
static void le_read_local_features_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_read_local_features *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_features(0, rsp->features);
|
|
}
|
|
|
|
static void le_set_random_address_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_random_address *cmd = data;
|
|
|
|
print_addr(cmd->addr, 0x01);
|
|
}
|
|
|
|
static void le_read_adv_tx_power_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_read_adv_tx_power *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_field("TX power: %d dBm", rsp->level);
|
|
}
|
|
|
|
static void le_set_adv_data_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_adv_data *cmd = data;
|
|
|
|
print_field("Length: %d", cmd->len);
|
|
print_eir(cmd->data, cmd->len, true);
|
|
}
|
|
|
|
static void le_set_scan_response_data_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_scan_response_data *cmd = data;
|
|
|
|
print_field("Length: %d", cmd->len);
|
|
print_eir(cmd->data, cmd->len, true);
|
|
}
|
|
|
|
static void le_set_adv_enable_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_adv_enable *cmd = data;
|
|
const char *str;
|
|
|
|
switch (cmd->enable) {
|
|
case 0x00:
|
|
str = "Disabled";
|
|
break;
|
|
case 0x01:
|
|
str = "Enabled";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Advertising: %s (0x%2.2x)", str, cmd->enable);
|
|
}
|
|
|
|
static void le_set_scan_parameters_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_scan_parameters *cmd = data;
|
|
const char *str;
|
|
|
|
switch (cmd->type) {
|
|
case 0x00:
|
|
str = "Passive";
|
|
break;
|
|
case 0x01:
|
|
str = "Active";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Type: %s (0x%2.2x)", str, cmd->type);
|
|
|
|
print_interval(cmd->interval);
|
|
print_window(cmd->window);
|
|
print_addr_type("Own address type", cmd->own_addr_type);
|
|
|
|
switch (cmd->filter_policy) {
|
|
case 0x00:
|
|
str = "Accept all advertisement";
|
|
break;
|
|
case 0x01:
|
|
str = "Ignore not in white list";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
|
|
}
|
|
|
|
static void le_set_scan_enable_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_scan_enable *cmd = data;
|
|
const char *str;
|
|
|
|
switch (cmd->enable) {
|
|
case 0x00:
|
|
str = "Disabled";
|
|
break;
|
|
case 0x01:
|
|
str = "Enabled";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Scanning: %s (0x%2.2x)", str, cmd->enable);
|
|
|
|
switch (cmd->filter_dup) {
|
|
case 0x00:
|
|
str = "Disabled";
|
|
break;
|
|
case 0x01:
|
|
str = "Enabled";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Filter duplicates: %s (0x%2.2x)", str, cmd->filter_dup);
|
|
}
|
|
|
|
static void le_create_conn_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_create_conn *cmd = data;
|
|
|
|
print_slot_625("Scan interval", cmd->scan_interval);
|
|
print_slot_625("Scan window", cmd->scan_window);
|
|
print_field("Filter policy: 0x%2.2x", cmd->filter_policy);
|
|
print_addr_type("Peer address type", cmd->peer_addr_type);
|
|
print_addr(cmd->peer_addr, cmd->peer_addr_type);
|
|
print_addr_type("Own address type", cmd->own_addr_type);
|
|
print_slot_125("Min connection interval", cmd->min_interval);
|
|
print_slot_125("Max connection interval", cmd->max_interval);
|
|
print_field("Connection latency: 0x%4.4x", btohs(cmd->latency));
|
|
print_field("Supervision timeout: %d msec (0x%4.4x)",
|
|
btohs(cmd->supv_timeout) * 10, btohs(cmd->supv_timeout));
|
|
print_slot_625("Min connection length", cmd->min_length);
|
|
print_slot_625("Max connection length", cmd->max_length);
|
|
}
|
|
|
|
static void le_conn_update_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_conn_update *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_slot_125("Min connection interval", cmd->min_interval);
|
|
print_slot_125("Max connection interval", cmd->max_interval);
|
|
print_field("Connection latency: 0x%4.4x", btohs(cmd->latency));
|
|
print_field("Supervision timeout: %d msec (0x%4.4x)",
|
|
btohs(cmd->supv_timeout) * 10, btohs(cmd->supv_timeout));
|
|
print_slot_625("Min connection length", cmd->min_length);
|
|
print_slot_625("Max connection length", cmd->max_length);
|
|
}
|
|
|
|
static void le_set_host_classification_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_set_host_classification *cmd = data;
|
|
|
|
print_le_channel_map(cmd->map);
|
|
}
|
|
|
|
static void le_read_channel_map_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_read_channel_map *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void le_read_channel_map_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_read_channel_map *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_handle(rsp->handle);
|
|
print_le_channel_map(rsp->map);
|
|
}
|
|
|
|
static void le_read_remote_features_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_read_remote_features *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
}
|
|
|
|
static void le_encrypt_cmd(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_encrypt *cmd = data;
|
|
|
|
print_key("Key", cmd->key);
|
|
print_key("Plaintext data", cmd->plaintext);
|
|
}
|
|
|
|
static void le_encrypt_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_encrypt *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_key("Encrypted data", rsp->data);
|
|
}
|
|
|
|
static void le_rand_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_rand *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_random_number(rsp->number);
|
|
}
|
|
|
|
static void le_start_encrypt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_cmd_le_start_encrypt *cmd = data;
|
|
|
|
print_handle(cmd->handle);
|
|
print_random_number(cmd->number);
|
|
print_field("Encryption diversifier: 0x%4.4x",
|
|
btohs(cmd->diversifier));
|
|
print_key("Long term key", cmd->ltk);
|
|
|
|
}
|
|
|
|
static void le_read_supported_states_rsp(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_rsp_le_read_supported_states *rsp = data;
|
|
|
|
print_status(rsp->status);
|
|
print_le_states(rsp->states);
|
|
}
|
|
|
|
struct opcode_data {
|
|
uint16_t opcode;
|
|
const char *str;
|
|
void (*cmd_func) (const void *data, uint8_t size);
|
|
uint8_t cmd_size;
|
|
bool cmd_fixed;
|
|
void (*rsp_func) (const void *data, uint8_t size);
|
|
uint8_t rsp_size;
|
|
bool rsp_fixed;
|
|
};
|
|
|
|
static const struct opcode_data opcode_table[] = {
|
|
{ 0x0000, "NOP" },
|
|
|
|
/* OGF 1 - Link Control */
|
|
{ 0x0401, "Inquiry",
|
|
inquiry_cmd, 5, true },
|
|
{ 0x0402, "Inquiry Cancel",
|
|
null_cmd, 0, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0403, "Periodic Inquiry Mode",
|
|
periodic_inquiry_cmd, 9, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0404, "Exit Periodic Inquiry Mode",
|
|
null_cmd, 0, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0405, "Create Connection",
|
|
create_conn_cmd, 13, true },
|
|
{ 0x0406, "Disconnect",
|
|
disconnect_cmd, 3, true },
|
|
{ 0x0407, "Add SCO Connection",
|
|
add_sco_conn_cmd, 4, true },
|
|
{ 0x0408, "Create Connection Cancel",
|
|
create_conn_cancel_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x0409, "Accept Connection Request",
|
|
accept_conn_request_cmd, 7, true },
|
|
{ 0x040a, "Reject Connection Request",
|
|
reject_conn_request_cmd, 7, true },
|
|
{ 0x040b, "Link Key Request Reply",
|
|
link_key_request_reply_cmd, 22, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x040c, "Link Key Request Negative Reply",
|
|
link_key_request_neg_reply_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x040d, "PIN Code Request Reply",
|
|
pin_code_request_reply_cmd, 23, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x040e, "PIN Code Request Negative Reply",
|
|
pin_code_request_neg_reply_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x040f, "Change Connection Packet Type",
|
|
change_conn_pkt_type_cmd, 4, true },
|
|
/* reserved command */
|
|
{ 0x0411, "Authentication Requested",
|
|
auth_requested_cmd, 2, true },
|
|
/* reserved command */
|
|
{ 0x0413, "Set Connection Encryption",
|
|
set_conn_encrypt_cmd, 3, true },
|
|
/* reserved command */
|
|
{ 0x0415, "Change Connection Link Key",
|
|
change_conn_link_key_cmd, 2, true },
|
|
/* reserved command */
|
|
{ 0x0417, "Master Link Key",
|
|
master_link_key_cmd, 1, true },
|
|
/* reserved command */
|
|
{ 0x0419, "Remote Name Request",
|
|
remote_name_request_cmd, 10, true },
|
|
{ 0x041a, "Remote Name Request Cancel",
|
|
remote_name_request_cancel_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x041b, "Read Remote Supported Features",
|
|
read_remote_features_cmd, 2, true },
|
|
{ 0x041c, "Read Remote Extended Features",
|
|
read_remote_ext_features_cmd, 3, true },
|
|
{ 0x041d, "Read Remote Version Information",
|
|
read_remote_version_cmd, 2, true },
|
|
/* reserved command */
|
|
{ 0x041f, "Read Clock Offset",
|
|
read_clock_offset_cmd, 2, true },
|
|
{ 0x0420, "Read LMP Handle",
|
|
read_lmp_handle_cmd, 2, true,
|
|
read_lmp_handle_rsp, 8, true },
|
|
/* reserved commands */
|
|
{ 0x0428, "Setup Synchronous Connection",
|
|
setup_sync_conn_cmd, 17, true },
|
|
{ 0x0429, "Accept Synchronous Connection",
|
|
accept_sync_conn_cmd, 21, true },
|
|
{ 0x042a, "Reject Synchronous Connection",
|
|
reject_sync_conn_cmd, 7, true },
|
|
{ 0x042b, "IO Capability Request Reply",
|
|
io_capability_request_reply_cmd, 9, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x042c, "User Confirmation Request Reply",
|
|
user_confirm_request_reply_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x042d, "User Confirmation Request Neg Reply",
|
|
user_confirm_request_neg_reply_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x042e, "User Passkey Request Reply",
|
|
user_passkey_request_reply_cmd, 10, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x042f, "User Passkey Request Negative Reply",
|
|
user_passkey_request_neg_reply_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x0430, "Remote OOB Data Request Reply",
|
|
remote_oob_data_request_reply_cmd, 38, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
/* reserved commands */
|
|
{ 0x0433, "Remote OOB Data Request Neg Reply",
|
|
remote_oob_data_request_neg_reply_cmd, 6, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x0434, "IO Capability Request Negative Reply",
|
|
io_capability_request_neg_reply_cmd, 7, true,
|
|
status_bdaddr_rsp, 7, true },
|
|
{ 0x0435, "Create Physical Link",
|
|
create_phy_link_cmd, 3, false },
|
|
{ 0x0436, "Accept Physical Link",
|
|
accept_phy_link_cmd, 3, false },
|
|
{ 0x0437, "Disconnect Physical Link",
|
|
disconn_phy_link_cmd, 2, true },
|
|
{ 0x0438, "Create Logical Link",
|
|
create_logic_link_cmd, 33, true },
|
|
{ 0x0439, "Accept Logical Link",
|
|
accept_logic_link_cmd, 33, true },
|
|
{ 0x043a, "Disconnect Logical Link",
|
|
disconn_logic_link_cmd, 2, true },
|
|
{ 0x043b, "Logical Link Cancel",
|
|
logic_link_cancel_cmd, 2, true,
|
|
logic_link_cancel_rsp, 3, true },
|
|
{ 0x043c, "Flow Specifcation Modify",
|
|
flow_spec_modify_cmd, 34, true },
|
|
{ 0x043d, "Enhanced Setup Synchronous Connection" },
|
|
{ 0x043e, "Enhanced Accept Synchronous Connection" },
|
|
|
|
/* OGF 2 - Link Policy */
|
|
{ 0x0801, "Holde Mode",
|
|
hold_mode_cmd, 6, true },
|
|
/* reserved command */
|
|
{ 0x0803, "Sniff Mode",
|
|
sniff_mode_cmd, 10, true },
|
|
{ 0x0804, "Exit Sniff Mode",
|
|
exit_sniff_mode_cmd, 2, true },
|
|
{ 0x0805, "Park State",
|
|
park_state_cmd, 6, true },
|
|
{ 0x0806, "Exit Park State",
|
|
exit_park_state_cmd, 2, true },
|
|
{ 0x0807, "QoS Setup",
|
|
qos_setup_cmd, 20, true },
|
|
/* reserved command */
|
|
{ 0x0809, "Role Discovery",
|
|
role_discovery_cmd, 2, true,
|
|
role_discovery_rsp, 4, true },
|
|
/* reserved command */
|
|
{ 0x080b, "Switch Role",
|
|
switch_role_cmd, 7, true },
|
|
{ 0x080c, "Read Link Policy Settings",
|
|
read_link_policy_cmd, 2, true,
|
|
read_link_policy_rsp, 5, true },
|
|
{ 0x080d, "Write Link Policy Settings",
|
|
write_link_policy_cmd, 2, true,
|
|
write_link_policy_rsp, 2, true },
|
|
{ 0x080e, "Read Default Link Policy Settings",
|
|
null_cmd, 0, true,
|
|
read_default_link_policy_rsp, 3, true },
|
|
{ 0x080f, "Write Default Link Policy Settings",
|
|
write_default_link_policy_cmd, 2, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0810, "Flow Specification",
|
|
flow_spec_cmd, 21, true },
|
|
{ 0x0811, "Sniff Subrating",
|
|
sniff_subrating_cmd, 8, true,
|
|
sniff_subrating_rsp, 3, true },
|
|
|
|
/* OGF 3 - Host Control */
|
|
{ 0x0c01, "Set Event Mask",
|
|
set_event_mask_cmd, 8, true,
|
|
status_rsp, 1, true },
|
|
/* reserved command */
|
|
{ 0x0c03, "Reset",
|
|
null_cmd, 0, true,
|
|
status_rsp, 1, true },
|
|
/* reserved command */
|
|
{ 0x0c05, "Set Event Filter",
|
|
set_event_filter_cmd, 1, false,
|
|
status_rsp, 1, true },
|
|
/* reserved commands */
|
|
{ 0x0c08, "Flush",
|
|
flush_cmd, 2, true,
|
|
flush_rsp, 3, true },
|
|
{ 0x0c09, "Read PIN Type",
|
|
null_cmd, 0, true,
|
|
read_pin_type_rsp, 2, true },
|
|
{ 0x0c0a, "Write PIN Type",
|
|
write_pin_type_cmd, 1, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c0b, "Create New Unit Key",
|
|
null_cmd, 0, true,
|
|
status_rsp, 1, true },
|
|
/* reserved command */
|
|
{ 0x0c0d, "Read Stored Link Key",
|
|
read_stored_link_key_cmd, 7, true,
|
|
read_stored_link_key_rsp, 5, true },
|
|
/* reserved commands */
|
|
{ 0x0c11, "Write Stored Link Key",
|
|
write_stored_link_key_cmd, 1, false,
|
|
write_stored_link_key_rsp, 2, true },
|
|
{ 0x0c12, "Delete Stored Link Key",
|
|
delete_stored_link_key_cmd, 7, true,
|
|
delete_stored_link_key_rsp, 3, true },
|
|
{ 0x0c13, "Write Local Name",
|
|
write_local_name_cmd, 248, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c14, "Read Local Name",
|
|
null_cmd, 0, true,
|
|
read_local_name_rsp, 249, true },
|
|
{ 0x0c15, "Read Connection Accept Timeout",
|
|
null_cmd, 0, true,
|
|
read_conn_accept_timeout_rsp, 3, true },
|
|
{ 0x0c16, "Write Connection Accept Timeout",
|
|
write_conn_accept_timeout_cmd, 2, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c17, "Read Page Timeout",
|
|
null_cmd, 0, true,
|
|
read_page_timeout_rsp, 3, true },
|
|
{ 0x0c18, "Write Page Timeout",
|
|
write_page_timeout_cmd, 2, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c19, "Read Scan Enable",
|
|
null_cmd, 0, true,
|
|
read_scan_enable_rsp, 2, true },
|
|
{ 0x0c1a, "Write Scan Enable",
|
|
write_scan_enable_cmd, 1, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c1b, "Read Page Scan Activity" },
|
|
{ 0x0c1c, "Write Page Scan Activity" },
|
|
{ 0x0c1d, "Read Inquiry Scan Activity" },
|
|
{ 0x0c1e, "Write Inquiry Scan Activity" },
|
|
{ 0x0c1f, "Read Authentication Enable" },
|
|
{ 0x0c20, "Write Authentication Enable" },
|
|
{ 0x0c21, "Read Encryption Mode" },
|
|
{ 0x0c22, "Write Encryption Mode" },
|
|
{ 0x0c23, "Read Class of Device",
|
|
null_cmd, 0, true,
|
|
read_class_of_dev_rsp, 4, true },
|
|
{ 0x0c24, "Write Class of Device",
|
|
write_class_of_dev_cmd, 3, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c25, "Read Voice Setting",
|
|
null_cmd, 0, true,
|
|
read_voice_setting_rsp, 3, true },
|
|
{ 0x0c26, "Write Voice Setting",
|
|
write_voice_setting_cmd, 2, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c27, "Read Automatic Flush Timeout" },
|
|
{ 0x0c28, "Write Automatic Flush Timeout" },
|
|
{ 0x0c29, "Read Num Broadcast Retransmissions" },
|
|
{ 0x0c2a, "Write Num Broadcast Retransmissions" },
|
|
{ 0x0c2b, "Read Hold Mode Activity" },
|
|
{ 0x0c2c, "Write Hold Mode Activity" },
|
|
{ 0x0c2d, "Read Transmit Power Level" },
|
|
{ 0x0c2e, "Read Sync Flow Control Enable" },
|
|
{ 0x0c2f, "Write Sync Flow Control Enable" },
|
|
/* reserved command */
|
|
{ 0x0c31, "Set Host Controller To Host Flow" },
|
|
/* reserved command */
|
|
{ 0x0c33, "Host Buffer Size" },
|
|
/* reserved command */
|
|
{ 0x0c35, "Host Number of Completed Packets" },
|
|
{ 0x0c36, "Read Link Supervision Timeout" },
|
|
{ 0x0c37, "Write Link Supervision Timeout" },
|
|
{ 0x0c38, "Read Number of Supported IAC" },
|
|
{ 0x0c39, "Read Current IAC LAP" },
|
|
{ 0x0c3a, "Write Current IAC LAP" },
|
|
{ 0x0c3b, "Read Page Scan Period Mode" },
|
|
{ 0x0c3c, "Write Page Scan Period Mode" },
|
|
{ 0x0c3d, "Read Page Scan Mode" },
|
|
{ 0x0c3e, "Write Page Scan Mode" },
|
|
{ 0x0c3f, "Set AFH Host Channel Classification" },
|
|
/* reserved commands */
|
|
{ 0x0c42, "Read Inquiry Scan Type" },
|
|
{ 0x0c43, "Write Inquiry Scan Type" },
|
|
{ 0x0c44, "Read Inquiry Mode",
|
|
null_cmd, 0, true,
|
|
read_inquiry_mode_rsp, 2, true },
|
|
{ 0x0c45, "Write Inquiry Mode",
|
|
write_inquiry_mode_cmd, 1, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c46, "Read Page Scan Type" },
|
|
{ 0x0c47, "Write Page Scan Type" },
|
|
{ 0x0c48, "Read AFH Channel Assessment Mode" },
|
|
{ 0x0c49, "Write AFH Channel Assessment Mode" },
|
|
/* reserved commands */
|
|
{ 0x0c51, "Read Extended Inquiry Response",
|
|
null_cmd, 0, true,
|
|
read_ext_inquiry_response_rsp, 242, true },
|
|
{ 0x0c52, "Write Extended Inquiry Response",
|
|
write_ext_inquiry_response_cmd, 241, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c53, "Refresh Encryption Key",
|
|
refresh_encrypt_key_cmd, 2, true },
|
|
/* reserved command */
|
|
{ 0x0c55, "Read Simple Pairing Mode",
|
|
null_cmd, 0, true,
|
|
read_simple_pairing_mode_rsp, 2, true },
|
|
{ 0x0c56, "Write Simple Pairing Mode",
|
|
write_simple_pairing_mode_cmd, 1, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c57, "Read Local OOB Data" },
|
|
{ 0x0c58, "Read Inquiry Response TX Power Level",
|
|
null_cmd, 0, true,
|
|
read_inquiry_resp_tx_power_rsp, 2, true },
|
|
{ 0x0c59, "Write Inquiry Transmit Power Level" },
|
|
{ 0x0c5a, "Read Default Erroneous Reporting" },
|
|
{ 0x0c5b, "Write Default Erroneous Reporting" },
|
|
/* reserved commands */
|
|
{ 0x0c5f, "Enhanced Flush",
|
|
enhanced_flush_cmd, 3, true },
|
|
/* reserved command */
|
|
{ 0x0c61, "Read Logical Link Accept Timeout" },
|
|
{ 0x0c62, "Write Logical Link Accept Timeout" },
|
|
{ 0x0c63, "Set Event Mask Page 2",
|
|
set_event_mask_page2_cmd, 8, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c64, "Read Location Data" },
|
|
{ 0x0c65, "Write Location Data" },
|
|
{ 0x0c66, "Read Flow Control Mode" },
|
|
{ 0x0c67, "Write Flow Control Mode" },
|
|
{ 0x0c68, "Read Enhanced Transmit Power Level" },
|
|
{ 0x0c69, "Read Best Effort Flush Timeout" },
|
|
{ 0x0c6a, "Write Best Effort Flush Timeout" },
|
|
{ 0x0c6b, "Short Range Mode" },
|
|
{ 0x0c6c, "Read LE Host Supported",
|
|
null_cmd, 0, true,
|
|
read_le_host_supported_rsp, 3, true },
|
|
{ 0x0c6d, "Write LE Host Supported",
|
|
write_le_host_supported_cmd, 2, true,
|
|
status_rsp, 1, true },
|
|
{ 0x0c6e, "Set MWS Channel Parameters" },
|
|
{ 0x0c6f, "Set External Fram Configuration" },
|
|
{ 0x0c70, "Set MWS Signaling" },
|
|
{ 0x0c71, "Set MWS Transport Layer" },
|
|
{ 0x0c72, "Set MWS Scan Frequency Table" },
|
|
{ 0x0c73, "Set MWS Pattern Configuration" },
|
|
|
|
/* OGF 4 - Information Parameter */
|
|
{ 0x1001, "Read Local Version Information",
|
|
null_cmd, 0, true,
|
|
read_local_version_rsp, 9, true },
|
|
{ 0x1002, "Read Local Supported Commands",
|
|
null_cmd, 0, true,
|
|
read_local_commands_rsp, 65, true },
|
|
{ 0x1003, "Read Local Supported Features",
|
|
null_cmd, 0, true,
|
|
read_local_features_rsp, 9, true },
|
|
{ 0x1004, "Read Local Extended Features",
|
|
read_local_ext_features_cmd, 1, true,
|
|
read_local_ext_features_rsp, 11, true },
|
|
{ 0x1005, "Read Buffer Size",
|
|
null_cmd, 0, true,
|
|
read_buffer_size_rsp, 8, true },
|
|
/* reserved command */
|
|
{ 0x1007, "Read Country Code",
|
|
null_cmd, 0, true,
|
|
read_country_code_rsp, 2, true },
|
|
/* reserved command */
|
|
{ 0x1009, "Read BD ADDR",
|
|
null_cmd, 0, true,
|
|
read_bd_addr_rsp, 7, true },
|
|
{ 0x100a, "Read Data Block Size",
|
|
null_cmd, 0, true,
|
|
read_data_block_size_rsp, 7, true },
|
|
{ 0x100b, "Read Local Supported Codecs" },
|
|
|
|
/* OGF 5 - Status Parameter */
|
|
{ 0x1401, "Read Failed Contact Counter" },
|
|
{ 0x1402, "Reset Failed Contact Counter" },
|
|
{ 0x1403, "Read Link Quality" },
|
|
/* reserved command */
|
|
{ 0x1405, "Read RSSI" },
|
|
{ 0x1406, "Read AFH Channel Map" },
|
|
{ 0x1407, "Read Clock" },
|
|
{ 0x1408, "Read Encryption Key Size",
|
|
read_encrypt_key_size_cmd, 2, true,
|
|
read_encrypt_key_size_rsp, 4, true },
|
|
{ 0x1409, "Read Local AMP Info",
|
|
null_cmd, 0, true,
|
|
read_local_amp_info_rsp, 31, true },
|
|
{ 0x140a, "Read Local AMP ASSOC",
|
|
read_local_amp_assoc_cmd, 5, true,
|
|
read_local_amp_assoc_rsp, 5, false },
|
|
{ 0x140b, "Write Remote AMP ASSOC",
|
|
write_remote_amp_assoc_cmd, 6, false,
|
|
write_remote_amp_assoc_rsp, 2, true },
|
|
{ 0x140c, "Get MWS Transport Layer Configuration" },
|
|
|
|
/* OGF 6 - Testing */
|
|
{ 0x1801, "Read Loopback Mode" },
|
|
{ 0x1802, "Write Loopback Mode" },
|
|
{ 0x1803, "Enable Device Under Test Mode" },
|
|
{ 0x1804, "Write Simple Pairing Debug Mode" },
|
|
/* reserved commands */
|
|
{ 0x1807, "Enable AMP Receiver Reports" },
|
|
{ 0x1808, "AMP Test End" },
|
|
{ 0x1809, "AMP Test" },
|
|
|
|
/* OGF 8 - LE Control */
|
|
{ 0x2001, "LE Set Event Mask",
|
|
le_set_event_mask_cmd, 8, true,
|
|
status_rsp, 1, true },
|
|
{ 0x2002, "LE Read Buffer Size",
|
|
null_cmd, 0, true,
|
|
le_read_buffer_size_rsp, 4, true },
|
|
{ 0x2003, "LE Read Local Supported Features",
|
|
null_cmd, 0, true,
|
|
le_read_local_features_rsp, 9, true },
|
|
/* reserved command */
|
|
{ 0x2005, "LE Set Random Address",
|
|
le_set_random_address_cmd, 6, true,
|
|
status_rsp, 1, true },
|
|
{ 0x2006, "LE Set Advertising Parameters" },
|
|
{ 0x2007, "LE Read Advertising Channel TX Power",
|
|
null_cmd, 0, true,
|
|
le_read_adv_tx_power_rsp, 2, true },
|
|
{ 0x2008, "LE Set Advertising Data",
|
|
le_set_adv_data_cmd, 32, true,
|
|
status_rsp, 1, true },
|
|
{ 0x2009, "LE Set Scan Response Data",
|
|
le_set_scan_response_data_cmd, 32, true,
|
|
status_rsp, 1, true },
|
|
{ 0x200a, "LE Set Advertise Enable",
|
|
le_set_adv_enable_cmd, 1, true,
|
|
status_rsp, 1, true },
|
|
{ 0x200b, "LE Set Scan Parameters",
|
|
le_set_scan_parameters_cmd, 7, true,
|
|
status_rsp, 1, true },
|
|
{ 0x200c, "LE Set Scan Enable",
|
|
le_set_scan_enable_cmd, 2, true,
|
|
status_rsp, 1, true },
|
|
{ 0x200d, "LE Create Connection",
|
|
le_create_conn_cmd, 25, true },
|
|
{ 0x200e, "LE Create Connection Cancel",
|
|
null_cmd, 0, true,
|
|
status_rsp, 1, true },
|
|
{ 0x200f, "LE Read White List Size" },
|
|
{ 0x2010, "LE Clear White List" },
|
|
{ 0x2011, "LE Add Device To White List" },
|
|
{ 0x2012, "LE Remove Device From White List" },
|
|
{ 0x2013, "LE Connection Update",
|
|
le_conn_update_cmd, 14, true },
|
|
{ 0x2014, "LE Set Host Channel Classification",
|
|
le_set_host_classification_cmd, 5, true,
|
|
status_rsp, 1, true },
|
|
{ 0x2015, "LE Read Channel Map",
|
|
le_read_channel_map_cmd, 2, true,
|
|
le_read_channel_map_rsp, 8, true },
|
|
{ 0x2016, "LE Read Remote Used Features",
|
|
le_read_remote_features_cmd, 2, true },
|
|
{ 0x2017, "LE Encrypt",
|
|
le_encrypt_cmd, 32, true,
|
|
le_encrypt_rsp, 17, true },
|
|
{ 0x2018, "LE Rand",
|
|
null_cmd, 0, true,
|
|
le_rand_rsp, 9, true },
|
|
{ 0x2019, "LE Start Encryption",
|
|
le_start_encrypt, 28, true },
|
|
{ 0x201a, "LE Long Term Key Request Reply" },
|
|
{ 0x201b, "LE Long Term Key Request Neg Reply" },
|
|
{ 0x201c, "LE Read Supported States",
|
|
null_cmd, 0, true,
|
|
le_read_supported_states_rsp, 9, true },
|
|
{ 0x201d, "LE Receiver Test" },
|
|
{ 0x201e, "LE Transmitter Test" },
|
|
{ 0x201f, "LE Test End" },
|
|
{ }
|
|
};
|
|
|
|
static void status_evt(const void *data, uint8_t size)
|
|
{
|
|
uint8_t status = *((uint8_t *) data);
|
|
|
|
print_status(status);
|
|
}
|
|
|
|
static void inquiry_result_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_inquiry_result *evt = data;
|
|
|
|
print_num_resp(evt->num_resp);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_pscan_rep_mode(evt->pscan_rep_mode);
|
|
print_pscan_period_mode(evt->pscan_period_mode);
|
|
print_pscan_mode(evt->pscan_mode);
|
|
print_dev_class(evt->dev_class);
|
|
print_clock_offset(evt->clock_offset);
|
|
|
|
if (size > sizeof(*evt))
|
|
packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
|
|
}
|
|
|
|
static void conn_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_conn_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_link_type(evt->link_type);
|
|
print_encr_mode(evt->encr_mode);
|
|
}
|
|
|
|
static void conn_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_conn_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_dev_class(evt->dev_class);
|
|
print_link_type(evt->link_type);
|
|
}
|
|
|
|
static void disconnect_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_disconnect_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_reason(evt->reason);
|
|
}
|
|
|
|
static void auth_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_auth_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void remote_name_request_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_remote_name_request_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_name(evt->name);
|
|
}
|
|
|
|
static void encrypt_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_encrypt_change *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_encr_mode(evt->encr_mode);
|
|
}
|
|
|
|
static void change_conn_link_key_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_change_conn_link_key_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void master_link_key_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_master_link_key_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_key_flag(evt->key_flag);
|
|
}
|
|
|
|
static void remote_features_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_remote_features_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_features(0, evt->features);
|
|
}
|
|
|
|
static void remote_version_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_remote_version_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_lmp_version(evt->lmp_ver, evt->lmp_subver);
|
|
print_manufacturer(evt->manufacturer);
|
|
}
|
|
|
|
static void qos_setup_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
uint8_t status = *((uint8_t *) data);
|
|
|
|
print_status(status);
|
|
|
|
packet_hexdump(data + 1, size - 1);
|
|
}
|
|
|
|
static void cmd_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_cmd_complete *evt = data;
|
|
uint16_t opcode = btohs(evt->opcode);
|
|
uint16_t ogf = cmd_opcode_ogf(opcode);
|
|
uint16_t ocf = cmd_opcode_ocf(opcode);
|
|
const struct opcode_data *opcode_data = NULL;
|
|
const char *opcode_color, *opcode_str;
|
|
int i;
|
|
|
|
for (i = 0; opcode_table[i].str; i++) {
|
|
if (opcode_table[i].opcode == opcode) {
|
|
opcode_data = &opcode_table[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (opcode_data) {
|
|
if (opcode_data->rsp_func)
|
|
opcode_color = COLOR_HCI_COMMAND;
|
|
else
|
|
opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
|
|
opcode_str = opcode_data->str;
|
|
} else {
|
|
opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
|
|
opcode_str = "Unknown";
|
|
}
|
|
|
|
print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
|
|
" (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
|
|
|
|
if (!opcode_data->rsp_func) {
|
|
packet_hexdump(data + 3, size - 3);
|
|
return;
|
|
}
|
|
|
|
if (opcode_data->rsp_fixed) {
|
|
if (size - 3 != opcode_data->rsp_size) {
|
|
print_text(COLOR_ERROR, "invalid packet size");
|
|
packet_hexdump(data + 3, size - 3);
|
|
return;
|
|
}
|
|
} else {
|
|
if (size - 3 < opcode_data->rsp_size) {
|
|
print_text(COLOR_ERROR, "too short packet");
|
|
packet_hexdump(data + 3, size - 3);
|
|
return;
|
|
}
|
|
}
|
|
|
|
opcode_data->rsp_func(data + 3, size - 3);
|
|
}
|
|
|
|
static void cmd_status_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_cmd_status *evt = data;
|
|
uint16_t opcode = btohs(evt->opcode);
|
|
uint16_t ogf = cmd_opcode_ogf(opcode);
|
|
uint16_t ocf = cmd_opcode_ocf(opcode);
|
|
const struct opcode_data *opcode_data = NULL;
|
|
const char *opcode_color, *opcode_str;
|
|
int i;
|
|
|
|
for (i = 0; opcode_table[i].str; i++) {
|
|
if (opcode_table[i].opcode == opcode) {
|
|
opcode_data = &opcode_table[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (opcode_data) {
|
|
opcode_color = COLOR_HCI_COMMAND;
|
|
opcode_str = opcode_data->str;
|
|
} else {
|
|
opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
|
|
opcode_str = "Unknown";
|
|
}
|
|
|
|
print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
|
|
" (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
|
|
|
|
print_status(evt->status);
|
|
}
|
|
|
|
static void hardware_error_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_hardware_error *evt = data;
|
|
|
|
print_field("Code: 0x%2.2x", evt->code);
|
|
}
|
|
|
|
static void flush_occurred_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_flush_occurred *evt = data;
|
|
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void role_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_role_change *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_role(evt->role);
|
|
}
|
|
|
|
static void num_completed_packets_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_num_completed_packets *evt = data;
|
|
|
|
print_field("Num handles: %d", evt->num_handles);
|
|
print_handle(evt->handle);
|
|
print_field("Count: %d", btohs(evt->count));
|
|
|
|
if (size > sizeof(*evt))
|
|
packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
|
|
}
|
|
|
|
static void mode_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_mode_change *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_mode(evt->mode);
|
|
print_interval(evt->interval);
|
|
}
|
|
|
|
static void return_link_keys_evt(const void *data, uint8_t size)
|
|
{
|
|
uint8_t num_keys = *((uint8_t *) data);
|
|
|
|
print_field("Num keys: %d", num_keys);
|
|
|
|
packet_hexdump(data + 1, size - 1);
|
|
}
|
|
|
|
static void pin_code_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_pin_code_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
}
|
|
|
|
static void link_key_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_link_key_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
}
|
|
|
|
static void link_key_notify_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_link_key_notify *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_link_key(evt->link_key);
|
|
print_key_type(evt->key_type);
|
|
}
|
|
|
|
static void loopback_command_evt(const void *data, uint8_t size)
|
|
{
|
|
packet_hexdump(data, size);
|
|
}
|
|
|
|
static void data_buffer_overflow_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_data_buffer_overflow *evt = data;
|
|
|
|
print_link_type(evt->link_type);
|
|
}
|
|
|
|
static void max_slots_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_max_slots_change *evt = data;
|
|
|
|
print_handle(evt->handle);
|
|
print_field("Max slots: %d", evt->max_slots);
|
|
}
|
|
|
|
static void clock_offset_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_clock_offset_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_clock_offset(evt->clock_offset);
|
|
}
|
|
|
|
static void conn_pkt_type_changed_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_conn_pkt_type_changed *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_pkt_type(evt->pkt_type);
|
|
}
|
|
|
|
static void qos_violation_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_qos_violation *evt = data;
|
|
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void pscan_mode_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_pscan_mode_change *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_pscan_mode(evt->pscan_mode);
|
|
}
|
|
|
|
static void pscan_rep_mode_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_pscan_rep_mode_change *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_pscan_rep_mode(evt->pscan_rep_mode);
|
|
}
|
|
|
|
static void flow_spec_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_flow_spec_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_field("Flags: 0x%2.2x", evt->flags);
|
|
|
|
print_flow_direction(evt->direction);
|
|
print_service_type(evt->service_type);
|
|
|
|
print_field("Token rate: %d", btohl(evt->token_rate));
|
|
print_field("Token bucket size: %d", btohl(evt->token_bucket_size));
|
|
print_field("Peak bandwidth: %d", btohl(evt->peak_bandwidth));
|
|
print_field("Access latency: %d", btohl(evt->access_latency));
|
|
}
|
|
|
|
static void inquiry_result_with_rssi_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_inquiry_result_with_rssi *evt = data;
|
|
|
|
print_num_resp(evt->num_resp);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_pscan_rep_mode(evt->pscan_rep_mode);
|
|
print_pscan_period_mode(evt->pscan_period_mode);
|
|
print_dev_class(evt->dev_class);
|
|
print_clock_offset(evt->clock_offset);
|
|
print_rssi(evt->rssi);
|
|
|
|
if (size > sizeof(*evt))
|
|
packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
|
|
}
|
|
|
|
static void remote_ext_features_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_remote_ext_features_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_field("Page: %d/%d", evt->page, evt->max_page);
|
|
print_features(evt->page, evt->features);
|
|
}
|
|
|
|
static void sync_conn_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_sync_conn_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_link_type(evt->link_type);
|
|
print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
|
|
print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
|
|
print_field("RX packet length: %d", btohs(evt->rx_pkt_len));
|
|
print_field("TX packet length: %d", btohs(evt->tx_pkt_len));
|
|
print_air_mode(evt->air_mode);
|
|
}
|
|
|
|
static void sync_conn_changed_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_sync_conn_changed *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
|
|
print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
|
|
print_field("RX packet length: %d", btohs(evt->rx_pkt_len));
|
|
print_field("TX packet length: %d", btohs(evt->tx_pkt_len));
|
|
}
|
|
|
|
static void sniff_subrating_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_sniff_subrating *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_slot_625("Max transmit latency", evt->max_tx_latency);
|
|
print_slot_625("Max receive latency", evt->max_rx_latency);
|
|
print_slot_625("Min remote timeout", evt->min_remote_timeout);
|
|
print_slot_625("Min local timeout", evt->min_local_timeout);
|
|
}
|
|
|
|
static void ext_inquiry_result_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_ext_inquiry_result *evt = data;
|
|
|
|
print_num_resp(evt->num_resp);
|
|
print_bdaddr(evt->bdaddr);
|
|
print_pscan_rep_mode(evt->pscan_rep_mode);
|
|
print_pscan_period_mode(evt->pscan_period_mode);
|
|
print_dev_class(evt->dev_class);
|
|
print_clock_offset(evt->clock_offset);
|
|
print_rssi(evt->rssi);
|
|
print_eir(evt->data, sizeof(evt->data), false);
|
|
}
|
|
|
|
static void encrypt_key_refresh_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_encrypt_key_refresh_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void io_capability_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_io_capability_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
}
|
|
|
|
static void io_capability_response_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_io_capability_response *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_io_capability(evt->capability);
|
|
print_oob_data(evt->oob_data);
|
|
print_authentication(evt->authentication);
|
|
}
|
|
|
|
static void user_confirm_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_user_confirm_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_passkey(evt->passkey);
|
|
}
|
|
|
|
static void user_passkey_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_user_passkey_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
}
|
|
|
|
static void remote_oob_data_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_remote_oob_data_request *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
}
|
|
|
|
static void simple_pairing_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_simple_pairing_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_bdaddr(evt->bdaddr);
|
|
}
|
|
|
|
static void link_supv_timeout_changed_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_link_supv_timeout_changed *evt = data;
|
|
|
|
print_handle(evt->handle);
|
|
print_timeout(evt->timeout);
|
|
}
|
|
|
|
static void enhanced_flush_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_enhanced_flush_complete *evt = data;
|
|
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void user_passkey_notify_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_user_passkey_notify *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_passkey(evt->passkey);
|
|
}
|
|
|
|
static void keypress_notify_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_keypress_notify *evt = data;
|
|
const char *str;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
|
|
switch (evt->type) {
|
|
case 0x00:
|
|
str = "Passkey entry started";
|
|
break;
|
|
case 0x01:
|
|
str = "Passkey digit entered";
|
|
break;
|
|
case 0x02:
|
|
str = "Passkey digit erased";
|
|
break;
|
|
case 0x03:
|
|
str = "Passkey clared";
|
|
break;
|
|
case 0x04:
|
|
str = "Passkey entry completed";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Notification type: %s (0x%2.2x)", str, evt->type);
|
|
}
|
|
|
|
static void remote_host_features_notify_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_remote_host_features_notify *evt = data;
|
|
|
|
print_bdaddr(evt->bdaddr);
|
|
print_features(1, evt->features);
|
|
}
|
|
|
|
static void phy_link_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_phy_link_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_phy_handle(evt->phy_handle);
|
|
}
|
|
|
|
static void channel_selected_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_channel_selected *evt = data;
|
|
|
|
print_phy_handle(evt->phy_handle);
|
|
}
|
|
|
|
static void disconn_phy_link_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_disconn_phy_link_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_phy_handle(evt->phy_handle);
|
|
print_reason(evt->reason);
|
|
}
|
|
|
|
static void phy_link_loss_early_warning_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_phy_link_loss_early_warning *evt = data;
|
|
const char *str;
|
|
|
|
print_phy_handle(evt->phy_handle);
|
|
|
|
switch (evt->reason) {
|
|
case 0x00:
|
|
str = "Unknown";
|
|
break;
|
|
case 0x01:
|
|
str = "Range related";
|
|
break;
|
|
case 0x02:
|
|
str = "Bandwidth related";
|
|
break;
|
|
case 0x03:
|
|
str = "Resolving conflict";
|
|
break;
|
|
case 0x04:
|
|
str = "Interference";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Reason: %s (0x%2.2x)", str, evt->reason);
|
|
}
|
|
|
|
static void phy_link_recovery_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_phy_link_recovery *evt = data;
|
|
|
|
print_phy_handle(evt->phy_handle);
|
|
}
|
|
|
|
static void logic_link_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_logic_link_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_phy_handle(evt->phy_handle);
|
|
print_field("TX flow spec: 0x%2.2x", evt->flow_spec);
|
|
}
|
|
|
|
static void disconn_logic_link_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_disconn_logic_link_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_reason(evt->reason);
|
|
}
|
|
|
|
static void flow_spec_modify_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_flow_spec_modify_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
}
|
|
|
|
static void num_completed_data_blocks_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_num_completed_data_blocks *evt = data;
|
|
|
|
print_field("Total num data blocks: %d", btohs(evt->total_num_blocks));
|
|
print_field("Num handles: %d", evt->num_handles);
|
|
print_handle(evt->handle);
|
|
print_field("Num packets: %d", evt->num_packets);
|
|
print_field("Num blocks: %d", evt->num_blocks);
|
|
|
|
if (size > sizeof(*evt))
|
|
packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
|
|
}
|
|
|
|
static void short_range_mode_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_short_range_mode_change *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_phy_handle(evt->phy_handle);
|
|
print_short_range_mode(evt->mode);
|
|
}
|
|
|
|
static void amp_status_change_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_amp_status_change *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_amp_status(evt->amp_status);
|
|
}
|
|
|
|
static void le_conn_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_le_conn_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_role(evt->role);
|
|
print_addr_type("Peer address type", evt->peer_addr_type);
|
|
print_addr(evt->peer_addr, evt->peer_addr_type);
|
|
print_slot_125("Connection interval", evt->interval);
|
|
print_slot_125("Connection latency", evt->latency);
|
|
print_field("Supervision timeout: %d msec (0x%4.4x)",
|
|
btohs(evt->supv_timeout) * 10, btohs(evt->supv_timeout));
|
|
print_field("Master clock accuracy: 0x%2.2x", evt->clock_accuracy);
|
|
}
|
|
|
|
static void le_adv_report_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_le_adv_report *evt = data;
|
|
const char *str;
|
|
uint8_t evt_len;
|
|
int8_t *rssi;
|
|
|
|
print_num_reports(evt->num_reports);
|
|
|
|
switch (evt->event_type) {
|
|
case 0x00:
|
|
str = "Connectable undirected - ADV_IND";
|
|
break;
|
|
case 0x01:
|
|
str = "Connectable directed - ADV_DIRECT_IND";
|
|
break;
|
|
case 0x02:
|
|
str = "Scannable undirected - ADV_SCAN_IND";
|
|
break;
|
|
case 0x03:
|
|
str = "Non connectable undirected - ADV_NONCONN_IND";
|
|
break;
|
|
case 0x04:
|
|
str = "Scan response - SCAN_RSP";
|
|
break;
|
|
default:
|
|
str = "Reserved";
|
|
break;
|
|
}
|
|
|
|
print_field("Event type: %s (0x%2.2x)", str, evt->event_type);
|
|
print_addr_type("Address type", evt->addr_type);
|
|
print_addr(evt->addr, evt->addr_type);
|
|
print_field("Data length: %d", evt->data_len);
|
|
print_eir(evt->data, evt->data_len, true);
|
|
|
|
rssi = (int8_t *) (evt->data + evt->data_len);
|
|
print_rssi(*rssi);
|
|
|
|
evt_len = sizeof(*evt) + evt->data_len + 1;
|
|
|
|
if (size > evt_len)
|
|
packet_hexdump(data + evt_len, size - evt_len);
|
|
}
|
|
|
|
static void le_conn_update_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_le_conn_update_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_slot_125("Connection interval", evt->interval);
|
|
print_slot_125("Connection latency", evt->latency);
|
|
print_field("Supervision timeout: %d msec (0x%4.4x)",
|
|
btohs(evt->supv_timeout) * 10, btohs(evt->supv_timeout));
|
|
}
|
|
|
|
static void le_remote_features_complete_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_le_remote_features_complete *evt = data;
|
|
|
|
print_status(evt->status);
|
|
print_handle(evt->handle);
|
|
print_features(0, evt->features);
|
|
}
|
|
|
|
static void le_long_term_key_request_evt(const void *data, uint8_t size)
|
|
{
|
|
const struct bt_hci_evt_le_long_term_key_request *evt = data;
|
|
|
|
print_handle(evt->handle);
|
|
print_random_number(evt->number);
|
|
print_field("Encryption diversifier: 0x%4.4x",
|
|
btohs(evt->diversifier));
|
|
}
|
|
|
|
struct subevent_data {
|
|
uint8_t subevent;
|
|
const char *str;
|
|
void (*func) (const void *data, uint8_t size);
|
|
uint8_t size;
|
|
bool fixed;
|
|
};
|
|
|
|
static const struct subevent_data subevent_table[] = {
|
|
{ 0x01, "LE Connection Complete",
|
|
le_conn_complete_evt, 18, true },
|
|
{ 0x02, "LE Advertising Report",
|
|
le_adv_report_evt, 1, false },
|
|
{ 0x03, "LE Connection Update Complete",
|
|
le_conn_update_complete_evt, 9, true },
|
|
{ 0x04, "LE Read Remote Used Features",
|
|
le_remote_features_complete_evt, 11, true },
|
|
{ 0x05, "LE Long Term Key Request",
|
|
le_long_term_key_request_evt, 12, true },
|
|
{ }
|
|
};
|
|
|
|
static void le_meta_event_evt(const void *data, uint8_t size)
|
|
{
|
|
uint8_t subevent = *((const uint8_t *) data);
|
|
const struct subevent_data *subevent_data = NULL;
|
|
const char *subevent_color, *subevent_str;
|
|
int i;
|
|
|
|
for (i = 0; subevent_table[i].str; i++) {
|
|
if (subevent_table[i].subevent == subevent) {
|
|
subevent_data = &subevent_table[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (subevent_data) {
|
|
if (subevent_data->func)
|
|
subevent_color = COLOR_HCI_EVENT;
|
|
else
|
|
subevent_color = COLOR_HCI_EVENT_UNKNOWN;
|
|
subevent_str = subevent_data->str;
|
|
} else {
|
|
subevent_color = COLOR_HCI_EVENT_UNKNOWN;
|
|
subevent_str = "Unknown";
|
|
}
|
|
|
|
print_indent(6, subevent_color, "", subevent_str, COLOR_OFF,
|
|
" (0x%2.2x)", subevent);
|
|
|
|
if (!subevent_data || !subevent_data->func) {
|
|
packet_hexdump(data + 1, size - 1);
|
|
return;
|
|
}
|
|
|
|
if (subevent_data->fixed) {
|
|
if (size - 1 != subevent_data->size) {
|
|
print_text(COLOR_ERROR, "invalid packet size");
|
|
packet_hexdump(data + 1, size - 1);
|
|
return;
|
|
}
|
|
} else {
|
|
if (size - 1 < subevent_data->size) {
|
|
print_text(COLOR_ERROR, "too short packet");
|
|
packet_hexdump(data + 1, size - 1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
subevent_data->func(data + 1, size - 1);
|
|
}
|
|
|
|
struct event_data {
|
|
uint8_t event;
|
|
const char *str;
|
|
void (*func) (const void *data, uint8_t size);
|
|
uint8_t size;
|
|
bool fixed;
|
|
};
|
|
|
|
static const struct event_data event_table[] = {
|
|
{ 0x01, "Inquiry Complete",
|
|
status_evt, 1, true },
|
|
{ 0x02, "Inquiry Result",
|
|
inquiry_result_evt, 1, false },
|
|
{ 0x03, "Connect Complete",
|
|
conn_complete_evt, 11, true },
|
|
{ 0x04, "Connect Request",
|
|
conn_request_evt, 10, true },
|
|
{ 0x05, "Disconnect Complete",
|
|
disconnect_complete_evt, 4, true },
|
|
{ 0x06, "Auth Complete",
|
|
auth_complete_evt, 3, true },
|
|
{ 0x07, "Remote Name Req Complete",
|
|
remote_name_request_complete_evt, 255, true },
|
|
{ 0x08, "Encryption Change",
|
|
encrypt_change_evt, 4, true },
|
|
{ 0x09, "Change Connection Link Key Complete",
|
|
change_conn_link_key_complete_evt, 3, true },
|
|
{ 0x0a, "Master Link Key Complete",
|
|
master_link_key_complete_evt, 4, true },
|
|
{ 0x0b, "Read Remote Supported Features",
|
|
remote_features_complete_evt, 11, true },
|
|
{ 0x0c, "Read Remote Version Complete",
|
|
remote_version_complete_evt, 8, true },
|
|
{ 0x0d, "QoS Setup Complete",
|
|
qos_setup_complete_evt, 21, true },
|
|
{ 0x0e, "Command Complete",
|
|
cmd_complete_evt, 3, false },
|
|
{ 0x0f, "Command Status",
|
|
cmd_status_evt, 4, true },
|
|
{ 0x10, "Hardware Error",
|
|
hardware_error_evt, 1, true },
|
|
{ 0x11, "Flush Occurred",
|
|
flush_occurred_evt, 2, true },
|
|
{ 0x12, "Role Change",
|
|
role_change_evt, 8, true },
|
|
{ 0x13, "Number of Completed Packets",
|
|
num_completed_packets_evt, 1, false },
|
|
{ 0x14, "Mode Change",
|
|
mode_change_evt, 6, true },
|
|
{ 0x15, "Return Link Keys",
|
|
return_link_keys_evt, 1, false },
|
|
{ 0x16, "PIN Code Request",
|
|
pin_code_request_evt, 6, true },
|
|
{ 0x17, "Link Key Request",
|
|
link_key_request_evt, 6, true },
|
|
{ 0x18, "Link Key Notification",
|
|
link_key_notify_evt, 23, true },
|
|
{ 0x19, "Loopback Command",
|
|
loopback_command_evt, 3, false },
|
|
{ 0x1a, "Data Buffer Overflow",
|
|
data_buffer_overflow_evt, 1, true },
|
|
{ 0x1b, "Max Slots Change",
|
|
max_slots_change_evt, 3, true },
|
|
{ 0x1c, "Read Clock Offset Complete",
|
|
clock_offset_complete_evt, 5, true },
|
|
{ 0x1d, "Connection Packet Type Changed",
|
|
conn_pkt_type_changed_evt, 5, true },
|
|
{ 0x1e, "QoS Violation",
|
|
qos_violation_evt, 2, true },
|
|
{ 0x1f, "Page Scan Mode Change",
|
|
pscan_mode_change_evt, 7, true },
|
|
{ 0x20, "Page Scan Repetition Mode Change",
|
|
pscan_rep_mode_change_evt, 7, true },
|
|
{ 0x21, "Flow Specification Complete",
|
|
flow_spec_complete_evt, 22, true },
|
|
{ 0x22, "Inquiry Result with RSSI",
|
|
inquiry_result_with_rssi_evt, 1, false },
|
|
{ 0x23, "Read Remote Extended Features",
|
|
remote_ext_features_complete_evt, 13, true },
|
|
/* reserved events */
|
|
{ 0x2c, "Synchronous Connect Complete",
|
|
sync_conn_complete_evt, 17, true },
|
|
{ 0x2d, "Synchronous Connect Changed",
|
|
sync_conn_changed_evt, 9, true },
|
|
{ 0x2e, "Sniff Subrating",
|
|
sniff_subrating_evt, 11, true },
|
|
{ 0x2f, "Extended Inquiry Result",
|
|
ext_inquiry_result_evt, 1, false },
|
|
{ 0x30, "Encryption Key Refresh Complete",
|
|
encrypt_key_refresh_complete_evt, 3, true },
|
|
{ 0x31, "IO Capability Request",
|
|
io_capability_request_evt, 6, true },
|
|
{ 0x32, "IO Capability Response",
|
|
io_capability_response_evt, 9, true },
|
|
{ 0x33, "User Confirmation Request",
|
|
user_confirm_request_evt, 10, true },
|
|
{ 0x34, "User Passkey Request",
|
|
user_passkey_request_evt, 6, true },
|
|
{ 0x35, "Remote OOB Data Request",
|
|
remote_oob_data_request_evt, 6, true },
|
|
{ 0x36, "Simple Pairing Complete",
|
|
simple_pairing_complete_evt, 7, true },
|
|
/* reserved event */
|
|
{ 0x38, "Link Supervision Timeout Changed",
|
|
link_supv_timeout_changed_evt, 4, true },
|
|
{ 0x39, "Enhanced Flush Complete",
|
|
enhanced_flush_complete_evt, 2, true },
|
|
/* reserved event */
|
|
{ 0x3b, "User Passkey Notification",
|
|
user_passkey_notify_evt, 10, true },
|
|
{ 0x3c, "Keypress Notification",
|
|
keypress_notify_evt, 7, true },
|
|
{ 0x3d, "Remote Host Supported Features",
|
|
remote_host_features_notify_evt, 14, true },
|
|
{ 0x3e, "LE Meta Event",
|
|
le_meta_event_evt, 1, false },
|
|
/* reserved event */
|
|
{ 0x40, "Physical Link Complete",
|
|
phy_link_complete_evt, 2, true },
|
|
{ 0x41, "Channel Selected",
|
|
channel_selected_evt, 1, true },
|
|
{ 0x42, "Disconnect Physical Link Complete",
|
|
disconn_phy_link_complete_evt, 3, true },
|
|
{ 0x43, "Physical Link Loss Early Warning",
|
|
phy_link_loss_early_warning_evt, 2, true },
|
|
{ 0x44, "Physical Link Recovery",
|
|
phy_link_recovery_evt, 1, true },
|
|
{ 0x45, "Logical Link Complete",
|
|
logic_link_complete_evt, 5, true },
|
|
{ 0x46, "Disconnect Logical Link Complete",
|
|
disconn_logic_link_complete_evt, 4, true },
|
|
{ 0x47, "Flow Spec Modify Complete",
|
|
flow_spec_modify_complete_evt, 3, true },
|
|
{ 0x48, "Number Of Completed Data Blocks",
|
|
num_completed_data_blocks_evt, 3, false },
|
|
{ 0x49, "AMP Start Test" },
|
|
{ 0x4a, "AMP Test End" },
|
|
{ 0x4b, "AMP Receiver Report" },
|
|
{ 0x4c, "Short Range Mode Change Complete",
|
|
short_range_mode_change_evt, 3, true },
|
|
{ 0x4d, "AMP Status Change",
|
|
amp_status_change_evt, 2, true },
|
|
{ 0xfe, "Testing" },
|
|
{ 0xff, "Vendor" },
|
|
{ }
|
|
};
|
|
|
|
void packet_new_index(struct timeval *tv, uint16_t index, const char *label,
|
|
uint8_t type, uint8_t bus, const char *name)
|
|
{
|
|
char details[48];
|
|
|
|
sprintf(details, "(%s,%s,%s)", hci_typetostr(type),
|
|
hci_bustostr(bus), name);
|
|
|
|
print_packet(tv, index, '=', COLOR_NEW_INDEX, "New Index",
|
|
label, details);
|
|
}
|
|
|
|
void packet_del_index(struct timeval *tv, uint16_t index, const char *label)
|
|
{
|
|
print_packet(tv, index, '=', COLOR_DEL_INDEX, "Delete Index",
|
|
label, NULL);
|
|
}
|
|
|
|
void packet_hci_command(struct timeval *tv, uint16_t index,
|
|
const void *data, uint16_t size)
|
|
{
|
|
const hci_command_hdr *hdr = data;
|
|
uint16_t opcode = btohs(hdr->opcode);
|
|
uint16_t ogf = cmd_opcode_ogf(opcode);
|
|
uint16_t ocf = cmd_opcode_ocf(opcode);
|
|
const struct opcode_data *opcode_data = NULL;
|
|
const char *opcode_color, *opcode_str;
|
|
char extra_str[25];
|
|
int i;
|
|
|
|
if (size < HCI_COMMAND_HDR_SIZE) {
|
|
sprintf(extra_str, "(len %d)", size);
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Malformed HCI Command packet", NULL, extra_str);
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
data += HCI_COMMAND_HDR_SIZE;
|
|
size -= HCI_COMMAND_HDR_SIZE;
|
|
|
|
for (i = 0; opcode_table[i].str; i++) {
|
|
if (opcode_table[i].opcode == opcode) {
|
|
opcode_data = &opcode_table[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (opcode_data) {
|
|
if (opcode_data->cmd_func)
|
|
opcode_color = COLOR_HCI_COMMAND;
|
|
else
|
|
opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
|
|
opcode_str = opcode_data->str;
|
|
} else {
|
|
opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
|
|
opcode_str = "Unknown";
|
|
}
|
|
|
|
sprintf(extra_str, "(0x%2.2x|0x%4.4x) plen %d", ogf, ocf, hdr->plen);
|
|
|
|
print_packet(tv, index, '<', opcode_color, "HCI Command",
|
|
opcode_str, extra_str);
|
|
|
|
if (!opcode_data || !opcode_data->cmd_func) {
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
if (opcode_data->cmd_fixed) {
|
|
if (hdr->plen != opcode_data->cmd_size) {
|
|
print_text(COLOR_ERROR, "invalid packet size");
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
} else {
|
|
if (hdr->plen < opcode_data->cmd_size) {
|
|
print_text(COLOR_ERROR, "too short packet");
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
}
|
|
|
|
opcode_data->cmd_func(data, hdr->plen);
|
|
}
|
|
|
|
void packet_hci_event(struct timeval *tv, uint16_t index,
|
|
const void *data, uint16_t size)
|
|
{
|
|
const hci_event_hdr *hdr = data;
|
|
const struct event_data *event_data = NULL;
|
|
const char *event_color, *event_str;
|
|
char extra_str[25];
|
|
int i;
|
|
|
|
if (size < HCI_EVENT_HDR_SIZE) {
|
|
sprintf(extra_str, "(len %d)", size);
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Malformed HCI Event packet", NULL, extra_str);
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
data += HCI_EVENT_HDR_SIZE;
|
|
size -= HCI_EVENT_HDR_SIZE;
|
|
|
|
for (i = 0; event_table[i].str; i++) {
|
|
if (event_table[i].event == hdr->evt) {
|
|
event_data = &event_table[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (event_data) {
|
|
if (event_data->func)
|
|
event_color = COLOR_HCI_EVENT;
|
|
else
|
|
event_color = COLOR_HCI_EVENT_UNKNOWN;
|
|
event_str = event_data->str;
|
|
} else {
|
|
event_color = COLOR_HCI_EVENT_UNKNOWN;
|
|
event_str = "Unknown";
|
|
}
|
|
|
|
sprintf(extra_str, "(0x%2.2x) plen %d", hdr->evt, hdr->plen);
|
|
|
|
print_packet(tv, index, '>', event_color, "HCI Event",
|
|
event_str, extra_str);
|
|
|
|
if (!event_data || !event_data->func) {
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
if (event_data->fixed) {
|
|
if (hdr->plen != event_data->size) {
|
|
print_text(COLOR_ERROR, "invalid packet size");
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
} else {
|
|
if (hdr->plen < event_data->size) {
|
|
print_text(COLOR_ERROR, "too short packet");
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
}
|
|
|
|
event_data->func(data, hdr->plen);
|
|
}
|
|
|
|
void packet_hci_acldata(struct timeval *tv, uint16_t index, bool in,
|
|
const void *data, uint16_t size)
|
|
{
|
|
const hci_acl_hdr *hdr = data;
|
|
uint16_t handle = btohs(hdr->handle);
|
|
uint16_t dlen = btohs(hdr->dlen);
|
|
uint8_t flags = acl_flags(handle);
|
|
char handle_str[16], extra_str[32];
|
|
|
|
if (size < HCI_ACL_HDR_SIZE) {
|
|
if (in)
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Malformed ACL Data RX packet", NULL, NULL);
|
|
else
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Malformed ACL Data TX packet", NULL, NULL);
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
data += HCI_ACL_HDR_SIZE;
|
|
size -= HCI_ACL_HDR_SIZE;
|
|
|
|
sprintf(handle_str, "Handle %d", acl_handle(handle));
|
|
sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, dlen);
|
|
|
|
print_packet(tv, index, in ? '>' : '<', COLOR_HCI_ACLDATA,
|
|
in ? "ACL Data RX" : "ACL Data TX",
|
|
handle_str, extra_str);
|
|
|
|
if (size != dlen) {
|
|
print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
|
|
size, dlen);
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
if (filter_mask & PACKET_FILTER_SHOW_ACL_DATA)
|
|
packet_hexdump(data, size);
|
|
|
|
l2cap_packet(index, in, acl_handle(handle), flags, data, size);
|
|
}
|
|
|
|
void packet_hci_scodata(struct timeval *tv, uint16_t index, bool in,
|
|
const void *data, uint16_t size)
|
|
{
|
|
const hci_sco_hdr *hdr = data;
|
|
uint16_t handle = btohs(hdr->handle);
|
|
uint8_t flags = acl_flags(handle);
|
|
char handle_str[16], extra_str[32];
|
|
|
|
if (size < HCI_SCO_HDR_SIZE) {
|
|
if (in)
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Malformed SCO Data RX packet", NULL, NULL);
|
|
else
|
|
print_packet(tv, index, '*', COLOR_ERROR,
|
|
"Malformed SCO Data TX packet", NULL, NULL);
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
data += HCI_SCO_HDR_SIZE;
|
|
size -= HCI_SCO_HDR_SIZE;
|
|
|
|
sprintf(handle_str, "Handle %d", acl_handle(handle));
|
|
sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
|
|
|
|
print_packet(tv, index, in ? '>' : '<', COLOR_HCI_SCODATA,
|
|
in ? "SCO Data RX" : "SCO Data TX",
|
|
handle_str, extra_str);
|
|
|
|
if (size != hdr->dlen) {
|
|
print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
|
|
size, hdr->dlen);
|
|
packet_hexdump(data, size);
|
|
return;
|
|
}
|
|
|
|
if (filter_mask & PACKET_FILTER_SHOW_SCO_DATA)
|
|
packet_hexdump(data, size);
|
|
}
|