/src/bluez/lib/bluetooth/hci.c

Source
// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 *  BlueZ - Bluetooth protocol stack for Linux
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#define _GNU_SOURCE
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>

#include <sys/param.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>

#include "bluetooth.h"
#include "hci.h"
#include "hci_lib.h"

typedef struct {
  char *str;
  unsigned int val;
} hci_map;

static char *hci_bit2str(const hci_map *m, unsigned int val)
{
  char *str = malloc(120);
  char *ptr = str;

  if (!str)
    return NULL;

  *ptr = 0;
  while (m->str) {
    if ((unsigned int) m->val & val)
      ptr += sprintf(ptr, "%s ", m->str);
    m++;
  }
  return str;
}

static int hci_str2bit(const hci_map *map, char *str, unsigned int *val)
{
  char *t, *ptr;
  const hci_map *m;
  int set;

  if (!str || !(str = ptr = strdup(str)))
    return 0;

  *val = set = 0;

  while ((t = strsep(&ptr, ","))) {
    for (m = map; m->str; m++) {
      if (!strcasecmp(m->str, t)) {
        *val |= (unsigned int) m->val;
        set = 1;
      }
    }
  }
  free(str);

  return set;
}

static char *hci_uint2str(const hci_map *m, unsigned int val)
{
  char *str = malloc(50);
  char *ptr = str;

  if (!str)
    return NULL;

  *ptr = 0;
  while (m->str) {
    if ((unsigned int) m->val == val) {
      ptr += sprintf(ptr, "%s", m->str);
      break;
    }
    m++;
  }
  return str;
}

static int hci_str2uint(const hci_map *map, char *str, unsigned int *val)
{
  char *t, *ptr;
  const hci_map *m;
  int set = 0;

  if (!str)
    return 0;

  str = ptr = strdup(str);

  while ((t = strsep(&ptr, ","))) {
    for (m = map; m->str; m++) {
      if (!strcasecmp(m->str,t)) {
        *val = (unsigned int) m->val;
        set = 1;
        break;
      }
    }
  }
  free(str);

  return set;
}

const char *hci_bustostr(int bus)
{
  switch (bus) {
  case HCI_VIRTUAL:
    return "Virtual";
  case HCI_USB:
    return "USB";
  case HCI_PCCARD:
    return "PCCARD";
  case HCI_UART:
    return "UART";
  case HCI_RS232:
    return "RS232";
  case HCI_PCI:
    return "PCI";
  case HCI_SDIO:
    return "SDIO";
  case HCI_SPI:
    return "SPI";
  case HCI_I2C:
    return "I2C";
  case HCI_SMD:
    return "SMD";
  case HCI_VIRTIO:
    return "VIRTIO";
  case HCI_IPC:
    return "IPC";
  default:
    return "Unknown";
  }
}

const char *hci_dtypetostr(int type)
{
  return hci_bustostr(type & 0x0f);
}

char *hci_typetostr(int type)
{
  switch (type) {
  case HCI_PRIMARY:
    return "Primary";
  case HCI_AMP:
    return "AMP";
  default:
    return "Unknown";
  }
}

/* HCI dev flags mapping */
static const hci_map dev_flags_map[] = {
  { "UP",      HCI_UP      },
  { "INIT",    HCI_INIT    },
  { "RUNNING", HCI_RUNNING },
  { "RAW",     HCI_RAW     },
  { "PSCAN",   HCI_PSCAN   },
  { "ISCAN",   HCI_ISCAN   },
  { "INQUIRY", HCI_INQUIRY },
  { "AUTH",    HCI_AUTH    },
  { "ENCRYPT", HCI_ENCRYPT },
  { NULL }
};

char *hci_dflagstostr(uint32_t flags)
{
  char *str = bt_malloc(50);
  char *ptr = str;
  const hci_map *m = dev_flags_map;

  if (!str)
    return NULL;

  *ptr = 0;

  if (!hci_test_bit(HCI_UP, &flags))
    ptr += sprintf(ptr, "DOWN ");

  while (m->str) {
    if (hci_test_bit(m->val, &flags))
      ptr += sprintf(ptr, "%s ", m->str);
    m++;
  }
  return str;
}

/* HCI packet type mapping */
static const hci_map pkt_type_map[] = {
  { "DM1",   HCI_DM1  },
  { "DM3",   HCI_DM3  },
  { "DM5",   HCI_DM5  },
  { "DH1",   HCI_DH1  },
  { "DH3",   HCI_DH3  },
  { "DH5",   HCI_DH5  },
  { "HV1",   HCI_HV1  },
  { "HV2",   HCI_HV2  },
  { "HV3",   HCI_HV3  },
  { "2-DH1", HCI_2DH1 },
  { "2-DH3", HCI_2DH3 },
  { "2-DH5", HCI_2DH5 },
  { "3-DH1", HCI_3DH1 },
  { "3-DH3", HCI_3DH3 },
  { "3-DH5", HCI_3DH5 },
  { NULL }
};

static const hci_map sco_ptype_map[] = {
  { "HV1",   0x0001   },
  { "HV2",   0x0002   },
  { "HV3",   0x0004   },
  { "EV3",   HCI_EV3  },
  { "EV4",   HCI_EV4  },
  { "EV5",   HCI_EV5  },
  { "2-EV3", HCI_2EV3 },
  { "2-EV5", HCI_2EV5 },
  { "3-EV3", HCI_3EV3 },
  { "3-EV5", HCI_3EV5 },
  { NULL }
};

char *hci_ptypetostr(unsigned int ptype)
{
  return hci_bit2str(pkt_type_map, ptype);
}

int hci_strtoptype(char *str, unsigned int *val)
{
  return hci_str2bit(pkt_type_map, str, val);
}

char *hci_scoptypetostr(unsigned int ptype)
{
  return hci_bit2str(sco_ptype_map, ptype);
}

int hci_strtoscoptype(char *str, unsigned int *val)
{
  return hci_str2bit(sco_ptype_map, str, val);
}

/* Link policy mapping */
static const hci_map link_policy_map[] = {
  { "NONE", 0   },
  { "RSWITCH",  HCI_LP_RSWITCH  },
  { "HOLD", HCI_LP_HOLD },
  { "SNIFF",  HCI_LP_SNIFF  },
  { "PARK", HCI_LP_PARK },
  { NULL }
};

char *hci_lptostr(unsigned int lp)
{
  return hci_bit2str(link_policy_map, lp);
}

int hci_strtolp(char *str, unsigned int *val)
{
  return hci_str2bit(link_policy_map, str, val);
}

/* Link mode mapping */
static const hci_map link_mode_map[] = {
  { "NONE", 0   },
  { "ACCEPT", HCI_LM_ACCEPT },
  { "CENTRAL",  HCI_LM_MASTER },
  { "AUTH", HCI_LM_AUTH },
  { "ENCRYPT",  HCI_LM_ENCRYPT  },
  { "TRUSTED",  HCI_LM_TRUSTED  },
  { "RELIABLE", HCI_LM_RELIABLE },
  { "SECURE", HCI_LM_SECURE },
  { NULL }
};

char *hci_lmtostr(unsigned int lm)
{
  char *s, *str = bt_malloc(50);
  if (!str)
    return NULL;

  *str = 0;
  if (!(lm & HCI_LM_MASTER))
    strcpy(str, "PERIPHERAL ");

  s = hci_bit2str(link_mode_map, lm);
  if (!s) {
    bt_free(str);
    return NULL;
  }

  strcat(str, s);
  free(s);
  return str;
}

int hci_strtolm(char *str, unsigned int *val)
{
  int ret = hci_str2bit(link_mode_map, str, val);

  /* Deprecated name. Kept for compatibility. */
  if (!!str && strcasestr(str, "MASTER")) {
    ret = 1;
    *val |= HCI_LM_MASTER;
  }

  return ret;
}

/* Command mapping */
static const hci_map commands_map[] = {
  { "Inquiry",          0   },
  { "Inquiry Cancel",       1   },
  { "Periodic Inquiry Mode",      2   },
  { "Exit Periodic Inquiry Mode",     3   },
  { "Create Connection",        4   },
  { "Disconnect",         5   },
  { "Add SCO Connection",       6   },
  { "Cancel Create Connection",     7   },

  { "Accept Connection Request",      8   },
  { "Reject Connection Request",      9   },
  { "Link Key Request Reply",     10  },
  { "Link Key Request Negative Reply",    11  },
  { "PIN Code Request Reply",     12  },
  { "PIN Code Request Negative Reply",    13  },
  { "Change Connection Packet Type",    14  },
  { "Authentication Requested",     15  },

  { "Set Connection Encryption",      16  },
  { "Change Connection Link Key",     17  },
  { "Temporary Link Key",       18  },
  { "Remote Name Request",      19  },
  { "Cancel Remote Name Request",     20  },
  { "Read Remote Supported Features",   21  },
  { "Read Remote Extended Features",    22  },
  { "Read Remote Version Information",    23  },

  { "Read Clock Offset",        24  },
  { "Read LMP Handle",        25  },
  { "Reserved",         26  },
  { "Reserved",         27  },
  { "Reserved",         28  },
  { "Reserved",         29  },
  { "Reserved",         30  },
  { "Reserved",         31  },

  { "Reserved",         32  },
  { "Hold Mode",          33  },
  { "Sniff Mode",         34  },
  { "Exit Sniff Mode",        35  },
  { "Park State",         36  },
  { "Exit Park State",        37  },
  { "QoS Setup",          38  },
  { "Role Discovery",       39  },

  { "Switch Role",        40  },
  { "Read Link Policy Settings",      41  },
  { "Write Link Policy Settings",     42  },
  { "Read Default Link Policy Settings",    43  },
  { "Write Default Link Policy Settings",   44  },
  { "Flow Specification",       45  },
  { "Set Event Mask",       46  },
  { "Reset",          47  },

  { "Set Event Filter",       48  },
  { "Flush",          49  },
  { "Read PIN Type",        50  },
  { "Write PIN Type",       51  },
  { "Create New Unit Key",      52  },
  { "Read Stored Link Key",     53  },
  { "Write Stored Link Key",      54  },
  { "Delete Stored Link Key",     55  },

  { "Write Local Name",       56  },
  { "Read Local Name",        57  },
  { "Read Connection Accept Timeout",   58  },
  { "Write Connection Accept Timeout",    59  },
  { "Read Page Timeout",        60  },
  { "Write Page Timeout",       61  },
  { "Read Scan Enable",       62  },
  { "Write Scan Enable",        63  },

  { "Read Page Scan Activity",      64  },
  { "Write Page Scan Activity",     65  },
  { "Read Inquiry Scan Activity",     66  },
  { "Write Inquiry Scan Activity",    67  },
  { "Read Authentication Enable",     68  },
  { "Write Authentication Enable",    69  },
  { "Read Encryption Mode",     70  },
  { "Write Encryption Mode",      71  },

  { "Read Class Of Device",     72  },
  { "Write Class Of Device",      73  },
  { "Read Voice Setting",       74  },
  { "Write Voice Setting",      75  },
  { "Read Automatic Flush Timeout",   76  },
  { "Write Automatic Flush Timeout",    77  },
  { "Read Num Broadcast Retransmissions",   78  },
  { "Write Num Broadcast Retransmissions",  79  },

  { "Read Hold Mode Activity",      80  },
  { "Write Hold Mode Activity",     81  },
  { "Read Transmit Power Level",      82  },
  { "Read Synchronous Flow Control Enable", 83  },
  { "Write Synchronous Flow Control Enable",  84  },
  { "Set Host Controller To Host Flow Control", 85  },
  { "Host Buffer Size",       86  },
  { "Host Number Of Completed Packets",   87  },

  { "Read Link Supervision Timeout",    88  },
  { "Write Link Supervision Timeout",   89  },
  { "Read Number of Supported IAC",   90  },
  { "Read Current IAC LAP",     91  },
  { "Write Current IAC LAP",      92  },
  { "Read Page Scan Period Mode",     93  },
  { "Write Page Scan Period Mode",    94  },
  { "Read Page Scan Mode",      95  },

  { "Write Page Scan Mode",     96  },
  { "Set AFH Channel Classification",   97  },
  { "Reserved",         98  },
  { "Reserved",         99  },
  { "Read Inquiry Scan Type",     100 },
  { "Write Inquiry Scan Type",      101 },
  { "Read Inquiry Mode",        102 },
  { "Write Inquiry Mode",       103 },

  { "Read Page Scan Type",      104 },
  { "Write Page Scan Type",     105 },
  { "Read AFH Channel Assessment Mode",   106 },
  { "Write AFH Channel Assessment Mode",    107 },
  { "Reserved",         108 },
  { "Reserved",         109 },
  { "Reserved",         110 },
  { "Reserved",         111 },

  { "Reserved",         112 },
  { "Reserved",         113 },
  { "Reserved",         114 },
  { "Read Local Version Information",   115 },
  { "Read Local Supported Commands",    116 },
  { "Read Local Supported Features",    117 },
  { "Read Local Extended Features",   118 },
  { "Read Buffer Size",       119 },

  { "Read Country Code",        120 },
  { "Read BD ADDR",       121 },
  { "Read Failed Contact Counter",    122 },
  { "Reset Failed Contact Counter",   123 },
  { "Get Link Quality",       124 },
  { "Read RSSI",          125 },
  { "Read AFH Channel Map",     126 },
  { "Read BD Clock",        127 },

  { "Read Loopback Mode",       128 },
  { "Write Loopback Mode",      129 },
  { "Enable Device Under Test Mode",    130 },
  { "Setup Synchronous Connection",   131 },
  { "Accept Synchronous Connection",    132 },
  { "Reject Synchronous Connection",    133 },
  { "Reserved",         134 },
  { "Reserved",         135 },

  { "Read Extended Inquiry Response",   136 },
  { "Write Extended Inquiry Response",    137 },
  { "Refresh Encryption Key",     138 },
  { "Reserved",         139 },
  { "Sniff Subrating",        140 },
  { "Read Simple Pairing Mode",     141 },
  { "Write Simple Pairing Mode",      142 },
  { "Read Local OOB Data",      143 },

  { "Read Inquiry Response Transmit Power Level", 144 },
  { "Write Inquiry Transmit Power Level",   145 },
  { "Read Default Erroneous Data Reporting",  146 },
  { "Write Default Erroneous Data Reporting", 147 },
  { "Reserved",         148 },
  { "Reserved",         149 },
  { "Reserved",         150 },
  { "IO Capability Request Reply",    151 },

  { "User Confirmation Request Reply",    152 },
  { "User Confirmation Request Negative Reply", 153 },
  { "User Passkey Request Reply",     154 },
  { "User Passkey Request Negative Reply",  155 },
  { "Remote OOB Data Request Reply",    156 },
  { "Write Simple Pairing Debug Mode",    157 },
  { "Enhanced Flush",       158 },
  { "Remote OOB Data Request Negative Reply", 159 },

  { "Reserved",         160 },
  { "Reserved",         161 },
  { "Send Keypress Notification",     162 },
  { "IO Capability Request Negative Reply", 163 },
  { "Read Encryption Key Size",     164 },
  { "Reserved",         165 },
  { "Reserved",         166 },
  { "Reserved",         167 },

  { "Create Physical Link",     168 },
  { "Accept Physical Link",     169 },
  { "Disconnect Physical Link",     170 },
  { "Create Logical Link",      171 },
  { "Accept Logical Link",      172 },
  { "Disconnect Logical Link",      173 },
  { "Logical Link Cancel",      174 },
  { "Flow Specification Modify",      175 },

  { "Read Logical Link Accept Timeout",   176 },
  { "Write Logical Link Accept Timeout",    177 },
  { "Set Event Mask Page 2",      178 },
  { "Read Location Data",       179 },
  { "Write Location Data",      180 },
  { "Read Local AMP Info",      181 },
  { "Read Local AMP_ASSOC",     182 },
  { "Write Remote AMP_ASSOC",     183 },

  { "Read Flow Control Mode",     184 },
  { "Write Flow Control Mode",      185 },
  { "Read Data Block Size",     186 },
  { "Reserved",         187 },
  { "Reserved",         188 },
  { "Enable AMP Receiver Reports",    189 },
  { "AMP Test End",       190 },
  { "AMP Test Command",       191 },

  { "Read Enhanced Transmit Power Level",   192 },
  { "Reserved",         193 },
  { "Read Best Effort Flush Timeout",   194 },
  { "Write Best Effort Flush Timeout",    195 },
  { "Short Range Mode",       196 },
  { "Read LE Host Support",     197 },
  { "Write LE Host Support",      198 },
  { "Reserved",         199 },

  { "LE Set Event Mask",        200 },
  { "LE Read Buffer Size",      201 },
  { "LE Read Local Supported Features",   202 },
  { "Reserved",         203 },
  { "LE Set Random Address",      204 },
  { "LE Set Advertising Parameters",    205 },
  { "LE Read Advertising Channel TX Power", 206 },
  { "LE Set Advertising Data",      207 },

  { "LE Set Scan Response Data",      208 },
  { "LE Set Advertise Enable",      209 },
  { "LE Set Scan Parameters",     210 },
  { "LE Set Scan Enable",       211 },
  { "LE Create Connection",     212 },
  { "LE Create Connection Cancel",    213 },
  { "LE Read Accept List Size",     214 },
  { "LE Clear Accept List",     215 },

  { "LE Add Device To Accept List",   216 },
  { "LE Remove Device From Accept List",    217 },
  { "LE Connection Update",     218 },
  { "LE Set Host Channel Classification",   219 },
  { "LE Read Channel Map",      220 },
  { "LE Read Remote Used Features",   221 },
  { "LE Encrypt",         222 },
  { "LE Rand",          223 },

  { "LE Start Encryption",      224 },
  { "LE Long Term Key Request Reply",   225 },
  { "LE Long Term Key Request Negative Reply",  226 },
  { "LE Read Supported States",     227 },
  { "LE Receiver Test",       228 },
  { "LE Transmitter Test",      229 },
  { "LE Test End",        230 },
  { "Reserved",         231 },

  { NULL }
};

char *hci_cmdtostr(unsigned int cmd)
{
  return hci_uint2str(commands_map, cmd);
}

char *hci_commandstostr(const uint8_t *commands, const char *pref, int width)
{
  unsigned int maxwidth = width - 3;
  const hci_map *m;
  char *off, *ptr, *str;
  int size = 1;
  int pref_len;

  if (pref) {
    pref_len = strlen(pref);
  } else {
    pref_len = 0;
    pref = "";
  }

  m = commands_map;

  while (m->str) {
    if (commands[m->val / 8] & (1 << (m->val % 8)))
      size += pref_len + strlen(m->str) + 3;
    m++;
  }

  str = bt_malloc(size);
  if (!str)
    return NULL;

  ptr = str; *ptr = '\0';

  ptr += sprintf(ptr, "%s", pref);
  off = ptr;

  m = commands_map;

  while (m->str) {
    if (commands[m->val / 8] & (1 << (m->val % 8))) {
      if (ptr != str &&
        strlen(off) + strlen(m->str) > maxwidth) {
        ptr = ptr - 1;
        ptr += sprintf(ptr, "\n%s", pref);
        off = ptr;
      }
      ptr += sprintf(ptr, "'%s' ", m->str);
    }
    m++;
  }

  if (ptr != str)
    /* Trim trailing space. */
    ptr[-1] = '\0';

  return str;
}

/* Version mapping */
static const hci_map ver_map[] = {
  { "1.0b", 0x00 },
  { "1.1",  0x01 },
  { "1.2",  0x02 },
  { "2.0",  0x03 },
  { "2.1",  0x04 },
  { "3.0",  0x05 },
  { "4.0",  0x06 },
  { "4.1",  0x07 },
  { "4.2",  0x08 },
  { "5.0",  0x09 },
  { "5.1",  0x0a },
  { "5.2",  0x0b },
  { "5.3",  0x0c },
  { "5.4",  0x0d },
  { NULL }
};

char *hci_vertostr(unsigned int ver)
{
  return hci_uint2str(ver_map, ver);
}

int hci_strtover(char *str, unsigned int *ver)
{
  return hci_str2uint(ver_map, str, ver);
}

char *lmp_vertostr(unsigned int ver)
{
  return hci_uint2str(ver_map, ver);
}

int lmp_strtover(char *str, unsigned int *ver)
{
  return hci_str2uint(ver_map, str, ver);
}

static const hci_map pal_map[] = {
  { "3.0",  0x01 },
  { NULL }
};

char *pal_vertostr(unsigned int ver)
{
  return hci_uint2str(pal_map, ver);
}

int pal_strtover(char *str, unsigned int *ver)
{
  return hci_str2uint(pal_map, str, ver);
}

/* LMP features mapping */
static const hci_map lmp_features_map[8][9] = {
  { /* Byte 0 */
    { "<3-slot packets>", LMP_3SLOT },  /* Bit 0 */
    { "<5-slot packets>", LMP_5SLOT },  /* Bit 1 */
    { "<encryption>", LMP_ENCRYPT },  /* Bit 2 */
    { "<slot offset>",  LMP_SOFFSET },  /* Bit 3 */
    { "<timing accuracy>",  LMP_TACCURACY },  /* Bit 4 */
    { "<role switch>",  LMP_RSWITCH },  /* Bit 5 */
    { "<hold mode>",  LMP_HOLD  },  /* Bit 6 */
    { "<sniff mode>", LMP_SNIFF },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 1 */
    { "<park state>", LMP_PARK  },  /* Bit 0 */
    { "<RSSI>",   LMP_RSSI  },  /* Bit 1 */
    { "<channel quality>",  LMP_QUALITY },  /* Bit 2 */
    { "<SCO link>",   LMP_SCO   },  /* Bit 3 */
    { "<HV2 packets>",  LMP_HV2   },  /* Bit 4 */
    { "<HV3 packets>",  LMP_HV3   },  /* Bit 5 */
    { "<u-law log>",  LMP_ULAW  },  /* Bit 6 */
    { "<A-law log>",  LMP_ALAW  },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 2 */
    { "<CVSD>",   LMP_CVSD  },  /* Bit 0 */
    { "<paging scheme>",  LMP_PSCHEME },  /* Bit 1 */
    { "<power control>",  LMP_PCONTROL  },  /* Bit 2 */
    { "<transparent SCO>",  LMP_TRSP_SCO  },  /* Bit 3 */
    { "<broadcast encrypt>",LMP_BCAST_ENC },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 3 */
    { "<no. 24>",   0x01    },  /* Bit 0 */
    { "<EDR ACL 2 Mbps>", LMP_EDR_ACL_2M  },  /* Bit 1 */
    { "<EDR ACL 3 Mbps>", LMP_EDR_ACL_3M  },  /* Bit 2 */
    { "<enhanced iscan>", LMP_ENH_ISCAN },  /* Bit 3 */
    { "<interlaced iscan>", LMP_ILACE_ISCAN },  /* Bit 4 */
    { "<interlaced pscan>", LMP_ILACE_PSCAN },  /* Bit 5 */
    { "<inquiry with RSSI>",LMP_RSSI_INQ  },  /* Bit 6 */
    { "<extended SCO>", LMP_ESCO  },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 4 */
    { "<EV4 packets>",  LMP_EV4   },  /* Bit 0 */
    { "<EV5 packets>",  LMP_EV5   },  /* Bit 1 */
    { "<no. 34>",   0x04    },  /* Bit 2 */
    { "<AFH cap. perip.>",  LMP_AFH_CAP_SLV },  /* Bit 3 */
    { "<AFH cls. perip.>",  LMP_AFH_CLS_SLV },  /* Bit 4 */
    { "<BR/EDR not supp.>", LMP_NO_BREDR  },  /* Bit 5 */
    { "<LE support>", LMP_LE    },  /* Bit 6 */
    { "<3-slot EDR ACL>", LMP_EDR_3SLOT },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 5 */
    { "<5-slot EDR ACL>", LMP_EDR_5SLOT },  /* Bit 0 */
    { "<sniff subrating>",  LMP_SNIFF_SUBR  },  /* Bit 1 */
    { "<pause encryption>", LMP_PAUSE_ENC },  /* Bit 2 */
    { "<AFH cap. central>", LMP_AFH_CAP_MST },  /* Bit 3 */
    { "<AFH cls. central>", LMP_AFH_CLS_MST },  /* Bit 4 */
    { "<EDR eSCO 2 Mbps>",  LMP_EDR_ESCO_2M },  /* Bit 5 */
    { "<EDR eSCO 3 Mbps>",  LMP_EDR_ESCO_3M },  /* Bit 6 */
    { "<3-slot EDR eSCO>",  LMP_EDR_3S_ESCO },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 6 */
    { "<extended inquiry>", LMP_EXT_INQ },  /* Bit 0 */
    { "<LE and BR/EDR>",  LMP_LE_BREDR  },  /* Bit 1 */
    { "<no. 50>",   0x04    },  /* Bit 2 */
    { "<simple pairing>", LMP_SIMPLE_PAIR },  /* Bit 3 */
    { "<encapsulated PDU>", LMP_ENCAPS_PDU  },  /* Bit 4 */
    { "<err. data report>", LMP_ERR_DAT_REP },  /* Bit 5 */
    { "<non-flush flag>", LMP_NFLUSH_PKTS },  /* Bit 6 */
    { "<no. 55>",   0x80    },  /* Bit 7 */
    { NULL }
  },
  { /* Byte 7 */
    { "<LSTO>",   LMP_LSTO  },  /* Bit 1 */
    { "<inquiry TX power>", LMP_INQ_TX_PWR  },  /* Bit 1 */
    { "<EPC>",    LMP_EPC   },  /* Bit 2 */
    { "<no. 59>",   0x08    },  /* Bit 3 */
    { "<no. 60>",   0x10    },  /* Bit 4 */
    { "<no. 61>",   0x20    },  /* Bit 5 */
    { "<no. 62>",   0x40    },  /* Bit 6 */
    { "<extended features>",LMP_EXT_FEAT  },  /* Bit 7 */
    { NULL }
  },
};

char *lmp_featurestostr(uint8_t *features, char *pref, int width)
{
  unsigned int maxwidth = width - 1;
  char *off, *ptr, *str;
  int i, size = 10;

  for (i = 0; i < 8; i++) {
    const hci_map *m = lmp_features_map[i];

    while (m->str) {
      if (m->val & features[i])
        size += strlen(m->str) +
            (pref ? strlen(pref) : 0) + 1;
      m++;
    }
  }

  str = bt_malloc(size);
  if (!str)
    return NULL;

  ptr = str; *ptr = '\0';

  if (pref)
    ptr += sprintf(ptr, "%s", pref);

  off = ptr;

  for (i = 0; i < 8; i++) {
    const hci_map *m = lmp_features_map[i];

    while (m->str) {
      if (m->val & features[i]) {
        if (strlen(off) + strlen(m->str) > maxwidth) {
          ptr += sprintf(ptr, "\n%s",
              pref ? pref : "");
          off = ptr;
        }
        ptr += sprintf(ptr, "%s ", m->str);
      }
      m++;
    }
  }

  return str;
}

/* HCI functions that do not require open device */
int hci_for_each_dev(int flag, int (*func)(int dd, int dev_id, long arg),
      long arg)
{
  struct hci_dev_list_req *dl;
  struct hci_dev_req *dr;
  int dev_id = -1;
  int i, sk, err = 0;

  sk = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
  if (sk < 0)
    return -1;

  dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
  if (!dl) {
    err = errno;
    goto done;
  }

  memset(dl, 0, HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));

  dl->dev_num = HCI_MAX_DEV;
  dr = dl->dev_req;

  if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) {
    err = errno;
    goto free;
  }

  for (i = 0; i < dl->dev_num; i++, dr++) {
    if (hci_test_bit(flag, &dr->dev_opt))
      if (!func || func(sk, dr->dev_id, arg)) {
        dev_id = dr->dev_id;
        break;
      }
  }

  if (dev_id < 0)
    err = ENODEV;

free:
  free(dl);

done:
  close(sk);
  errno = err;

  return dev_id;
}

static int __other_bdaddr(int dd, int dev_id, long arg)
{
  struct hci_dev_info di = { .dev_id = dev_id };

  if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
    return 0;

  if (hci_test_bit(HCI_RAW, &di.flags))
    return 0;

  return bacmp((bdaddr_t *) arg, &di.bdaddr);
}

static int __same_bdaddr(int dd, int dev_id, long arg)
{
  struct hci_dev_info di = { .dev_id = dev_id };

  if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
    return 0;

  return !bacmp((bdaddr_t *) arg, &di.bdaddr);
}

int hci_get_route(bdaddr_t *bdaddr)
{
  int dev_id;

  dev_id = hci_for_each_dev(HCI_UP, __other_bdaddr,
        (long) (bdaddr ? bdaddr : BDADDR_ANY));
  if (dev_id < 0)
    dev_id = hci_for_each_dev(HCI_UP, __same_bdaddr,
        (long) (bdaddr ? bdaddr : BDADDR_ANY));

  return dev_id;
}

int hci_devid(const char *str)
{
  bdaddr_t ba;
  int id = -1;

  if (!strncmp(str, "hci", 3) && strlen(str) >= 4) {
    id = atoi(str + 3);
    if (hci_devba(id, &ba) < 0)
      return -1;
  } else {
    errno = ENODEV;
    str2ba(str, &ba);
    id = hci_for_each_dev(HCI_UP, __same_bdaddr, (long) &ba);
  }

  return id;
}

int hci_devinfo(int dev_id, struct hci_dev_info *di)
{
  int dd, err, ret;

  dd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
  if (dd < 0)
    return dd;

  memset(di, 0, sizeof(struct hci_dev_info));

  di->dev_id = dev_id;
  ret = ioctl(dd, HCIGETDEVINFO, (void *) di);

  err = errno;
  close(dd);
  errno = err;

  return ret;
}

int hci_devba(int dev_id, bdaddr_t *bdaddr)
{
  struct hci_dev_info di;

  memset(&di, 0, sizeof(di));

  if (hci_devinfo(dev_id, &di))
    return -1;

  if (!hci_test_bit(HCI_UP, &di.flags)) {
    errno = ENETDOWN;
    return -1;
  }

  bacpy(bdaddr, &di.bdaddr);

  return 0;
}

int hci_inquiry(int dev_id, int len, int nrsp, const uint8_t *lap,
    inquiry_info **ii, long flags)
{
  struct hci_inquiry_req *ir;
  uint8_t num_rsp = nrsp;
  void *buf;
  int dd, size, err, ret = -1;

  if (nrsp <= 0) {
    num_rsp = 0;
    nrsp = 255;
  }

  if (dev_id < 0) {
    dev_id = hci_get_route(NULL);
    if (dev_id < 0) {
      errno = ENODEV;
      return -1;
    }
  }

  dd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
  if (dd < 0)
    return dd;

  buf = malloc(sizeof(*ir) + (sizeof(inquiry_info) * (nrsp)));
  if (!buf)
    goto done;

  ir = buf;
  ir->dev_id  = dev_id;
  ir->num_rsp = num_rsp;
  ir->length  = len;
  ir->flags   = flags;

  if (lap) {
    memcpy(ir->lap, lap, 3);
  } else {
    ir->lap[0] = 0x33;
    ir->lap[1] = 0x8b;
    ir->lap[2] = 0x9e;
  }

  ret = ioctl(dd, HCIINQUIRY, (unsigned long) buf);
  if (ret < 0)
    goto free;

  size = sizeof(inquiry_info) * ir->num_rsp;

  if (!*ii)
    *ii = malloc(size);

  if (*ii) {
    memcpy((void *) *ii, buf + sizeof(*ir), size);
    ret = ir->num_rsp;
  } else
    ret = -1;

free:
  free(buf);

done:
  err = errno;
  close(dd);
  errno = err;

  return ret;
}

/* Open HCI device.
 * Returns device descriptor (dd). */
int hci_open_dev(int dev_id)
{
  struct sockaddr_hci a;
  int dd, err;

  /* Check for valid device id */
  if (dev_id < 0) {
    errno = ENODEV;
    return -1;
  }

  /* Create HCI socket */
  dd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
  if (dd < 0)
    return dd;

  /* Bind socket to the HCI device */
  memset(&a, 0, sizeof(a));
  a.hci_family = AF_BLUETOOTH;
  a.hci_dev = dev_id;
  if (bind(dd, (struct sockaddr *) &a, sizeof(a)) < 0)
    goto failed;

  return dd;

failed:
  err = errno;
  close(dd);
  errno = err;

  return -1;
}

int hci_close_dev(int dd)
{
  return close(dd);
}

/* HCI functions that require open device
 * dd - Device descriptor returned by hci_open_dev. */

int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
{
  uint8_t type = HCI_COMMAND_PKT;
  hci_command_hdr hc;
  struct iovec iv[3];
  int ivn;

  hc.opcode = htobs(cmd_opcode_pack(ogf, ocf));
  hc.plen= plen;

  iv[0].iov_base = &type;
  iv[0].iov_len  = 1;
  iv[1].iov_base = &hc;
  iv[1].iov_len  = HCI_COMMAND_HDR_SIZE;
  ivn = 2;

  if (plen) {
    iv[2].iov_base = param;
    iv[2].iov_len  = plen;
    ivn = 3;
  }

  while (writev(dd, iv, ivn) < 0) {
    if (errno == EAGAIN || errno == EINTR)
      continue;
    return -1;
  }
  return 0;
}

int hci_send_req(int dd, struct hci_request *r, int to)
{
  unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr;
  uint16_t opcode = htobs(cmd_opcode_pack(r->ogf, r->ocf));
  struct hci_filter nf, of;
  socklen_t olen;
  hci_event_hdr *hdr;
  int err, try;

  olen = sizeof(of);
  if (getsockopt(dd, SOL_HCI, HCI_FILTER, &of, &olen) < 0)
    return -1;

  hci_filter_clear(&nf);
  hci_filter_set_ptype(HCI_EVENT_PKT,  &nf);
  hci_filter_set_event(EVT_CMD_STATUS, &nf);
  hci_filter_set_event(EVT_CMD_COMPLETE, &nf);
  hci_filter_set_event(EVT_LE_META_EVENT, &nf);
  hci_filter_set_event(r->event, &nf);
  hci_filter_set_opcode(opcode, &nf);
  if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0)
    return -1;

  if (hci_send_cmd(dd, r->ogf, r->ocf, r->clen, r->cparam) < 0)
    goto failed;

  try = 10;
  while (try--) {
    evt_cmd_complete *cc;
    evt_cmd_status *cs;
    evt_remote_name_req_complete *rn;
    evt_le_meta_event *me;
    remote_name_req_cp *cp;
    int len;

    if (to) {
      struct pollfd p;
      int n;

      p.fd = dd; p.events = POLLIN;
      while ((n = poll(&p, 1, to)) < 0) {
        if (errno == EAGAIN || errno == EINTR)
          continue;
        goto failed;
      }

      if (!n) {
        errno = ETIMEDOUT;
        goto failed;
      }

      to -= 10;
      if (to < 0)
        to = 0;

    }

    while ((len = read(dd, buf, sizeof(buf))) < 0) {
      if (errno == EAGAIN || errno == EINTR)
        continue;
      goto failed;
    }

    hdr = (void *) (buf + 1);
    ptr = buf + (1 + HCI_EVENT_HDR_SIZE);
    len -= (1 + HCI_EVENT_HDR_SIZE);

    switch (hdr->evt) {
    case EVT_CMD_STATUS:
      cs = (void *) ptr;

      if (cs->opcode != opcode)
        continue;

      if (r->event != EVT_CMD_STATUS) {
        if (cs->status) {
          errno = EIO;
          goto failed;
        }
        break;
      }

      r->rlen = MIN(len, r->rlen);
      memcpy(r->rparam, ptr, r->rlen);
      goto done;

    case EVT_CMD_COMPLETE:
      cc = (void *) ptr;

      if (cc->opcode != opcode)
        continue;

      ptr += EVT_CMD_COMPLETE_SIZE;
      len -= EVT_CMD_COMPLETE_SIZE;

      r->rlen = MIN(len, r->rlen);
      memcpy(r->rparam, ptr, r->rlen);
      goto done;

    case EVT_REMOTE_NAME_REQ_COMPLETE:
      if (hdr->evt != r->event)
        break;

      rn = (void *) ptr;
      cp = r->cparam;

      if (bacmp(&rn->bdaddr, &cp->bdaddr))
        continue;

      r->rlen = MIN(len, r->rlen);
      memcpy(r->rparam, ptr, r->rlen);
      goto done;

    case EVT_LE_META_EVENT:
      me = (void *) ptr;

      if (me->subevent != r->event)
        continue;

      len -= 1;
      r->rlen = MIN(len, r->rlen);
      memcpy(r->rparam, me->data, r->rlen);
      goto done;

    default:
      if (hdr->evt != r->event)
        break;

      r->rlen = MIN(len, r->rlen);
      memcpy(r->rparam, ptr, r->rlen);
      goto done;
    }
  }
  errno = ETIMEDOUT;

failed:
  err = errno;
  if (setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of)) < 0)
    err = errno;
  errno = err;
  return -1;

done:
  if (setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of)) < 0)
    return -1;
  return 0;
}

int hci_create_connection(int dd, const bdaddr_t *bdaddr, uint16_t ptype,
        uint16_t clkoffset, uint8_t rswitch,
        uint16_t *handle, int to)
{
  evt_conn_complete rp;
  create_conn_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  bacpy(&cp.bdaddr, bdaddr);
  cp.pkt_type       = ptype;
  cp.pscan_rep_mode = 0x02;
  cp.clock_offset   = clkoffset;
  cp.role_switch    = rswitch;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_CREATE_CONN;
  rq.event  = EVT_CONN_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = CREATE_CONN_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_CONN_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *handle = rp.handle;
  return 0;
}

int hci_disconnect(int dd, uint16_t handle, uint8_t reason, int to)
{
  evt_disconn_complete rp;
  disconnect_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;
  cp.reason = reason;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_DISCONNECT;
  rq.event  = EVT_DISCONN_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = DISCONNECT_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_DISCONN_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }
  return 0;
}

int hci_le_add_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
{
  struct hci_request rq;
  le_add_device_to_white_list_cp cp;
  uint8_t status;

  memset(&cp, 0, sizeof(cp));
  cp.bdaddr_type = type;
  bacpy(&cp.bdaddr, bdaddr);

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
  rq.cparam = &cp;
  rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_rm_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
{
  struct hci_request rq;
  le_remove_device_from_white_list_cp cp;
  uint8_t status;

  memset(&cp, 0, sizeof(cp));
  cp.bdaddr_type = type;
  bacpy(&cp.bdaddr, bdaddr);

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_WHITE_LIST;
  rq.cparam = &cp;
  rq.clen = LE_REMOVE_DEVICE_FROM_WHITE_LIST_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_read_white_list_size(int dd, uint8_t *size, int to)
{
  struct hci_request rq;
  le_read_white_list_size_rp rp;

  memset(&rp, 0, sizeof(rp));
  memset(&rq, 0, sizeof(rq));

  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_READ_WHITE_LIST_SIZE;
  rq.rparam = &rp;
  rq.rlen = LE_READ_WHITE_LIST_SIZE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (size)
    *size = rp.size;

  return 0;
}

int hci_le_clear_white_list(int dd, int to)
{
  struct hci_request rq;
  uint8_t status;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_CLEAR_WHITE_LIST;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_add_resolving_list(int dd, const bdaddr_t *bdaddr, uint8_t type,
        uint8_t *peer_irk, uint8_t *local_irk, int to)
{
  struct hci_request rq;
  le_add_device_to_resolv_list_cp cp;
  uint8_t status;

  memset(&cp, 0, sizeof(cp));
  cp.bdaddr_type = type;
  bacpy(&cp.bdaddr, bdaddr);
  if (peer_irk)
    memcpy(cp.peer_irk, peer_irk, 16);
  if (local_irk)
    memcpy(cp.local_irk, local_irk, 16);

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_ADD_DEVICE_TO_RESOLV_LIST;
  rq.cparam = &cp;
  rq.clen = LE_ADD_DEVICE_TO_RESOLV_LIST_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_rm_resolving_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
{
  struct hci_request rq;
  le_remove_device_from_resolv_list_cp cp;
  uint8_t status;

  memset(&cp, 0, sizeof(cp));
  cp.bdaddr_type = type;
  bacpy(&cp.bdaddr, bdaddr);

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_RESOLV_LIST;
  rq.cparam = &cp;
  rq.clen = LE_REMOVE_DEVICE_FROM_RESOLV_LIST_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_clear_resolving_list(int dd, int to)
{
  struct hci_request rq;
  uint8_t status;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_CLEAR_RESOLV_LIST;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_read_resolving_list_size(int dd, uint8_t *size, int to)
{
  struct hci_request rq;
  le_read_resolv_list_size_rp rp;

  memset(&rp, 0, sizeof(rp));
  memset(&rq, 0, sizeof(rq));

  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_READ_RESOLV_LIST_SIZE;
  rq.rparam = &rp;
  rq.rlen = LE_READ_RESOLV_LIST_SIZE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (size)
    *size = rp.size;

  return 0;
}

int hci_le_set_address_resolution_enable(int dd, uint8_t enable, int to)
{
  struct hci_request rq;
  le_set_address_resolution_enable_cp cp;
  uint8_t status;

  memset(&cp, 0, sizeof(cp));
  cp.enable = enable;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_SET_ADDRESS_RESOLUTION_ENABLE;
  rq.cparam = &cp;
  rq.clen = LE_SET_ADDRESS_RESOLUTION_ENABLE_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_local_name(int dd, int len, char *name, int to)
{
  read_local_name_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_LOCAL_NAME;
  rq.rparam = &rp;
  rq.rlen   = READ_LOCAL_NAME_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  rp.name[247] = '\0';
  strncpy(name, (char *) rp.name, len);
  return 0;
}

int hci_write_local_name(int dd, const char *name, int to)
{
  change_local_name_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  strncpy((char *) cp.name, name, sizeof(cp.name) - 1);

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_CHANGE_LOCAL_NAME;
  rq.cparam = &cp;
  rq.clen   = CHANGE_LOCAL_NAME_CP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  return 0;
}

int hci_read_remote_name_with_clock_offset(int dd, const bdaddr_t *bdaddr,
            uint8_t pscan_rep_mode,
            uint16_t clkoffset,
            int len, char *name, int to)
{
  evt_remote_name_req_complete rn;
  remote_name_req_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  bacpy(&cp.bdaddr, bdaddr);
  cp.pscan_rep_mode = pscan_rep_mode;
  cp.clock_offset   = clkoffset;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_REMOTE_NAME_REQ;
  rq.cparam = &cp;
  rq.clen   = REMOTE_NAME_REQ_CP_SIZE;
  rq.event  = EVT_REMOTE_NAME_REQ_COMPLETE;
  rq.rparam = &rn;
  rq.rlen   = EVT_REMOTE_NAME_REQ_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rn.status) {
    errno = EIO;
    return -1;
  }

  rn.name[247] = '\0';
  strncpy(name, (char *) rn.name, len);
  return 0;
}

int hci_read_remote_name(int dd, const bdaddr_t *bdaddr, int len, char *name,
        int to)
{
  return hci_read_remote_name_with_clock_offset(dd, bdaddr, 0x02, 0x0000,
              len, name, to);
}

int hci_read_remote_name_cancel(int dd, const bdaddr_t *bdaddr, int to)
{
  remote_name_req_cancel_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  bacpy(&cp.bdaddr, bdaddr);

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_REMOTE_NAME_REQ_CANCEL;
  rq.cparam = &cp;
  rq.clen   = REMOTE_NAME_REQ_CANCEL_CP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  return 0;
}

int hci_read_remote_version(int dd, uint16_t handle, struct hci_version *ver,
        int to)
{
  evt_read_remote_version_complete rp;
  read_remote_version_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_READ_REMOTE_VERSION;
  rq.event  = EVT_READ_REMOTE_VERSION_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = READ_REMOTE_VERSION_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_READ_REMOTE_VERSION_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  ver->manufacturer = btohs(rp.manufacturer);
  ver->lmp_ver      = rp.lmp_ver;
  ver->lmp_subver   = btohs(rp.lmp_subver);
  return 0;
}

int hci_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to)
{
  evt_read_remote_features_complete rp;
  read_remote_features_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_READ_REMOTE_FEATURES;
  rq.event  = EVT_READ_REMOTE_FEATURES_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = READ_REMOTE_FEATURES_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_READ_REMOTE_FEATURES_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (features)
    memcpy(features, rp.features, 8);

  return 0;
}

int hci_read_remote_ext_features(int dd, uint16_t handle, uint8_t page,
          uint8_t *max_page, uint8_t *features,
          int to)
{
  evt_read_remote_ext_features_complete rp;
  read_remote_ext_features_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle   = handle;
  cp.page_num = page;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_READ_REMOTE_EXT_FEATURES;
  rq.event  = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = READ_REMOTE_EXT_FEATURES_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (max_page)
    *max_page = rp.max_page_num;

  if (features)
    memcpy(features, rp.features, 8);

  return 0;
}

int hci_read_clock_offset(int dd, uint16_t handle, uint16_t *clkoffset, int to)
{
  evt_read_clock_offset_complete rp;
  read_clock_offset_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_READ_CLOCK_OFFSET;
  rq.event  = EVT_READ_CLOCK_OFFSET_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = READ_CLOCK_OFFSET_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_READ_CLOCK_OFFSET_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *clkoffset = rp.clock_offset;
  return 0;
}

int hci_read_local_version(int dd, struct hci_version *ver, int to)
{
  read_local_version_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_INFO_PARAM;
  rq.ocf    = OCF_READ_LOCAL_VERSION;
  rq.rparam = &rp;
  rq.rlen   = READ_LOCAL_VERSION_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  ver->manufacturer = btohs(rp.manufacturer);
  ver->hci_ver      = rp.hci_ver;
  ver->hci_rev      = btohs(rp.hci_rev);
  ver->lmp_ver      = rp.lmp_ver;
  ver->lmp_subver   = btohs(rp.lmp_subver);
  return 0;
}

int hci_read_local_commands(int dd, uint8_t *commands, int to)
{
  read_local_commands_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_INFO_PARAM;
  rq.ocf    = OCF_READ_LOCAL_COMMANDS;
  rq.rparam = &rp;
  rq.rlen   = READ_LOCAL_COMMANDS_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (commands)
    memcpy(commands, rp.commands, 64);

  return 0;
}

int hci_read_local_features(int dd, uint8_t *features, int to)
{
  read_local_features_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_INFO_PARAM;
  rq.ocf    = OCF_READ_LOCAL_FEATURES;
  rq.rparam = &rp;
  rq.rlen   = READ_LOCAL_FEATURES_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (features)
    memcpy(features, rp.features, 8);

  return 0;
}

int hci_read_local_ext_features(int dd, uint8_t page, uint8_t *max_page,
        uint8_t *features, int to)
{
  read_local_ext_features_cp cp;
  read_local_ext_features_rp rp;
  struct hci_request rq;

  cp.page_num = page;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_INFO_PARAM;
  rq.ocf    = OCF_READ_LOCAL_EXT_FEATURES;
  rq.cparam = &cp;
  rq.clen   = READ_LOCAL_EXT_FEATURES_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = READ_LOCAL_EXT_FEATURES_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (max_page)
    *max_page = rp.max_page_num;

  if (features)
    memcpy(features, rp.features, 8);

  return 0;
}

int hci_read_bd_addr(int dd, bdaddr_t *bdaddr, int to)
{
  read_bd_addr_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_INFO_PARAM;
  rq.ocf    = OCF_READ_BD_ADDR;
  rq.rparam = &rp;
  rq.rlen   = READ_BD_ADDR_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (bdaddr)
    bacpy(bdaddr, &rp.bdaddr);

  return 0;
}

int hci_read_class_of_dev(int dd, uint8_t *cls, int to)
{
  read_class_of_dev_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_CLASS_OF_DEV;
  rq.rparam = &rp;
  rq.rlen   = READ_CLASS_OF_DEV_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  memcpy(cls, rp.dev_class, 3);
  return 0;
}

int hci_write_class_of_dev(int dd, uint32_t cls, int to)
{
  write_class_of_dev_cp cp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  cp.dev_class[0] = cls & 0xff;
  cp.dev_class[1] = (cls >> 8) & 0xff;
  cp.dev_class[2] = (cls >> 16) & 0xff;
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_CLASS_OF_DEV;
  rq.cparam = &cp;
  rq.clen   = WRITE_CLASS_OF_DEV_CP_SIZE;
  return hci_send_req(dd, &rq, to);
}

int hci_read_voice_setting(int dd, uint16_t *vs, int to)
{
  read_voice_setting_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_VOICE_SETTING;
  rq.rparam = &rp;
  rq.rlen   = READ_VOICE_SETTING_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *vs = rp.voice_setting;
  return 0;
}

int hci_write_voice_setting(int dd, uint16_t vs, int to)
{
  write_voice_setting_cp cp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  cp.voice_setting = vs;
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_VOICE_SETTING;
  rq.cparam = &cp;
  rq.clen   = WRITE_VOICE_SETTING_CP_SIZE;

  return hci_send_req(dd, &rq, to);
}

int hci_read_current_iac_lap(int dd, uint8_t *num_iac, uint8_t *lap, int to)
{
  read_current_iac_lap_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_CURRENT_IAC_LAP;
  rq.rparam = &rp;
  rq.rlen   = READ_CURRENT_IAC_LAP_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *num_iac = rp.num_current_iac;
  memcpy(lap, rp.lap, rp.num_current_iac * 3);
  return 0;
}

int hci_write_current_iac_lap(int dd, uint8_t num_iac, uint8_t *lap, int to)
{
  write_current_iac_lap_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.num_current_iac = num_iac;
  memcpy(&cp.lap, lap, num_iac * 3);

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_CURRENT_IAC_LAP;
  rq.cparam = &cp;
  rq.clen   = num_iac * 3 + 1;

  return hci_send_req(dd, &rq, to);
}

int hci_read_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
{
  read_stored_link_key_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  bacpy(&cp.bdaddr, bdaddr);
  cp.read_all = all;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_STORED_LINK_KEY;
  rq.cparam = &cp;
  rq.clen   = READ_STORED_LINK_KEY_CP_SIZE;

  return hci_send_req(dd, &rq, to);
}

int hci_write_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t *key, int to)
{
  unsigned char cp[WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16];
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp[0] = 1;
  bacpy((bdaddr_t *) (cp + 1), bdaddr);
  memcpy(cp + 7, key, 16);

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_STORED_LINK_KEY;
  rq.cparam = &cp;
  rq.clen   = WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16;

  return hci_send_req(dd, &rq, to);
}

int hci_delete_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
{
  delete_stored_link_key_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  bacpy(&cp.bdaddr, bdaddr);
  cp.delete_all = all;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_DELETE_STORED_LINK_KEY;
  rq.cparam = &cp;
  rq.clen   = DELETE_STORED_LINK_KEY_CP_SIZE;

  return hci_send_req(dd, &rq, to);
}

int hci_authenticate_link(int dd, uint16_t handle, int to)
{
  auth_requested_cp cp;
  evt_auth_complete rp;
  struct hci_request rq;

  cp.handle = handle;

  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_AUTH_REQUESTED;
  rq.event  = EVT_AUTH_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = AUTH_REQUESTED_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_AUTH_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_encrypt_link(int dd, uint16_t handle, uint8_t encrypt, int to)
{
  set_conn_encrypt_cp cp;
  evt_encrypt_change rp;
  struct hci_request rq;

  cp.handle  = handle;
  cp.encrypt = encrypt;

  rq.ogf     = OGF_LINK_CTL;
  rq.ocf     = OCF_SET_CONN_ENCRYPT;
  rq.event   = EVT_ENCRYPT_CHANGE;
  rq.cparam  = &cp;
  rq.clen    = SET_CONN_ENCRYPT_CP_SIZE;
  rq.rparam  = &rp;
  rq.rlen    = EVT_ENCRYPT_CHANGE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_change_link_key(int dd, uint16_t handle, int to)
{
  change_conn_link_key_cp cp;
  evt_change_conn_link_key_complete rp;
  struct hci_request rq;

  cp.handle = handle;

  rq.ogf    = OGF_LINK_CTL;
  rq.ocf    = OCF_CHANGE_CONN_LINK_KEY;
  rq.event  = EVT_CHANGE_CONN_LINK_KEY_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = CHANGE_CONN_LINK_KEY_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_CHANGE_CONN_LINK_KEY_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_switch_role(int dd, bdaddr_t *bdaddr, uint8_t role, int to)
{
  switch_role_cp cp;
  evt_role_change rp;
  struct hci_request rq;

  bacpy(&cp.bdaddr, bdaddr);
  cp.role   = role;
  rq.ogf    = OGF_LINK_POLICY;
  rq.ocf    = OCF_SWITCH_ROLE;
  rq.cparam = &cp;
  rq.clen   = SWITCH_ROLE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_ROLE_CHANGE_SIZE;
  rq.event  = EVT_ROLE_CHANGE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_park_mode(int dd, uint16_t handle, uint16_t max_interval,
      uint16_t min_interval, int to)
{
  park_mode_cp cp;
  evt_mode_change rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof (cp));
  cp.handle       = handle;
  cp.max_interval = max_interval;
  cp.min_interval = min_interval;

  memset(&rq, 0, sizeof (rq));
  rq.ogf    = OGF_LINK_POLICY;
  rq.ocf    = OCF_PARK_MODE;
  rq.event  = EVT_MODE_CHANGE;
  rq.cparam = &cp;
  rq.clen   = PARK_MODE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_MODE_CHANGE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_exit_park_mode(int dd, uint16_t handle, int to)
{
  exit_park_mode_cp cp;
  evt_mode_change rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof (cp));
  cp.handle = handle;

  memset (&rq, 0, sizeof (rq));
  rq.ogf    = OGF_LINK_POLICY;
  rq.ocf    = OCF_EXIT_PARK_MODE;
  rq.event  = EVT_MODE_CHANGE;
  rq.cparam = &cp;
  rq.clen   = EXIT_PARK_MODE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_MODE_CHANGE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_inquiry_scan_type(int dd, uint8_t *type, int to)
{
  read_inquiry_scan_type_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_INQUIRY_SCAN_TYPE;
  rq.rparam = &rp;
  rq.rlen   = READ_INQUIRY_SCAN_TYPE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *type = rp.type;
  return 0;
}

int hci_write_inquiry_scan_type(int dd, uint8_t type, int to)
{
  write_inquiry_scan_type_cp cp;
  write_inquiry_scan_type_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.type = type;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_INQUIRY_SCAN_TYPE;
  rq.cparam = &cp;
  rq.clen   = WRITE_INQUIRY_SCAN_TYPE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_INQUIRY_SCAN_TYPE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_inquiry_mode(int dd, uint8_t *mode, int to)
{
  read_inquiry_mode_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_INQUIRY_MODE;
  rq.rparam = &rp;
  rq.rlen   = READ_INQUIRY_MODE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *mode = rp.mode;
  return 0;
}

int hci_write_inquiry_mode(int dd, uint8_t mode, int to)
{
  write_inquiry_mode_cp cp;
  write_inquiry_mode_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.mode = mode;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_INQUIRY_MODE;
  rq.cparam = &cp;
  rq.clen   = WRITE_INQUIRY_MODE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_INQUIRY_MODE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_afh_mode(int dd, uint8_t *mode, int to)
{
  read_afh_mode_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_AFH_MODE;
  rq.rparam = &rp;
  rq.rlen   = READ_AFH_MODE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *mode = rp.mode;
  return 0;
}

int hci_write_afh_mode(int dd, uint8_t mode, int to)
{
  write_afh_mode_cp cp;
  write_afh_mode_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.mode = mode;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_AFH_MODE;
  rq.cparam = &cp;
  rq.clen   = WRITE_AFH_MODE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_AFH_MODE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_ext_inquiry_response(int dd, uint8_t *fec, uint8_t *data, int to)
{
  read_ext_inquiry_response_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_EXT_INQUIRY_RESPONSE;
  rq.rparam = &rp;
  rq.rlen   = READ_EXT_INQUIRY_RESPONSE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *fec = rp.fec;
  memcpy(data, rp.data, HCI_MAX_EIR_LENGTH);

  return 0;
}

int hci_write_ext_inquiry_response(int dd, uint8_t fec, uint8_t *data, int to)
{
  write_ext_inquiry_response_cp cp;
  write_ext_inquiry_response_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.fec = fec;
  memcpy(cp.data, data, HCI_MAX_EIR_LENGTH);

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_EXT_INQUIRY_RESPONSE;
  rq.cparam = &cp;
  rq.clen   = WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_EXT_INQUIRY_RESPONSE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_simple_pairing_mode(int dd, uint8_t *mode, int to)
{
  read_simple_pairing_mode_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_SIMPLE_PAIRING_MODE;
  rq.rparam = &rp;
  rq.rlen   = READ_SIMPLE_PAIRING_MODE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *mode = rp.mode;
  return 0;
}

int hci_write_simple_pairing_mode(int dd, uint8_t mode, int to)
{
  write_simple_pairing_mode_cp cp;
  write_simple_pairing_mode_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.mode = mode;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_SIMPLE_PAIRING_MODE;
  rq.cparam = &cp;
  rq.clen   = WRITE_SIMPLE_PAIRING_MODE_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_SIMPLE_PAIRING_MODE_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_local_oob_data(int dd, uint8_t *hash, uint8_t *randomizer, int to)
{
  read_local_oob_data_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_LOCAL_OOB_DATA;
  rq.rparam = &rp;
  rq.rlen   = READ_LOCAL_OOB_DATA_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  memcpy(hash, rp.hash, 16);
  memcpy(randomizer, rp.randomizer, 16);
  return 0;
}

int hci_read_inq_response_tx_power_level(int dd, int8_t *level, int to)
{
  read_inq_response_tx_power_level_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL;
  rq.rparam = &rp;
  rq.rlen   = READ_INQ_RESPONSE_TX_POWER_LEVEL_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *level = rp.level;
  return 0;
}

int hci_read_inquiry_transmit_power_level(int dd, int8_t *level, int to)
{
  return hci_read_inq_response_tx_power_level(dd, level, to);
}

int hci_write_inquiry_transmit_power_level(int dd, int8_t level, int to)
{
  write_inquiry_transmit_power_level_cp cp;
  write_inquiry_transmit_power_level_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.level = level;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL;
  rq.cparam = &cp;
  rq.clen   = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_transmit_power_level(int dd, uint16_t handle, uint8_t type,
          int8_t *level, int to)
{
  read_transmit_power_level_cp cp;
  read_transmit_power_level_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;
  cp.type   = type;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_TRANSMIT_POWER_LEVEL;
  rq.cparam = &cp;
  rq.clen   = READ_TRANSMIT_POWER_LEVEL_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = READ_TRANSMIT_POWER_LEVEL_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *level = rp.level;
  return 0;
}

int hci_read_link_policy(int dd, uint16_t handle, uint16_t *policy, int to)
{
  read_link_policy_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_POLICY;
  rq.ocf    = OCF_READ_LINK_POLICY;
  rq.cparam = &handle;
  rq.clen   = 2;
  rq.rparam = &rp;
  rq.rlen   = READ_LINK_POLICY_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *policy = rp.policy;
  return 0;
}

int hci_write_link_policy(int dd, uint16_t handle, uint16_t policy, int to)
{
  write_link_policy_cp cp;
  write_link_policy_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;
  cp.policy = policy;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LINK_POLICY;
  rq.ocf    = OCF_WRITE_LINK_POLICY;
  rq.cparam = &cp;
  rq.clen   = WRITE_LINK_POLICY_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_LINK_POLICY_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_link_supervision_timeout(int dd, uint16_t handle,
          uint16_t *timeout, int to)
{
  read_link_supervision_timeout_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_READ_LINK_SUPERVISION_TIMEOUT;
  rq.cparam = &handle;
  rq.clen   = 2;
  rq.rparam = &rp;
  rq.rlen   = READ_LINK_SUPERVISION_TIMEOUT_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *timeout = rp.timeout;
  return 0;
}

int hci_write_link_supervision_timeout(int dd, uint16_t handle,
          uint16_t timeout, int to)
{
  write_link_supervision_timeout_cp cp;
  write_link_supervision_timeout_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle  = handle;
  cp.timeout = timeout;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_WRITE_LINK_SUPERVISION_TIMEOUT;
  rq.cparam = &cp;
  rq.clen   = WRITE_LINK_SUPERVISION_TIMEOUT_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = WRITE_LINK_SUPERVISION_TIMEOUT_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_set_afh_classification(int dd, uint8_t *map, int to)
{
  set_afh_classification_cp cp;
  set_afh_classification_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  memcpy(cp.map, map, 10);

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_HOST_CTL;
  rq.ocf    = OCF_SET_AFH_CLASSIFICATION;
  rq.cparam = &cp;
  rq.clen   = SET_AFH_CLASSIFICATION_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = SET_AFH_CLASSIFICATION_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_read_link_quality(int dd, uint16_t handle, uint8_t *link_quality,
        int to)
{
  read_link_quality_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_STATUS_PARAM;
  rq.ocf    = OCF_READ_LINK_QUALITY;
  rq.cparam = &handle;
  rq.clen   = 2;
  rq.rparam = &rp;
  rq.rlen   = READ_LINK_QUALITY_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *link_quality = rp.link_quality;
  return 0;
}

int hci_read_rssi(int dd, uint16_t handle, int8_t *rssi, int to)
{
  read_rssi_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_STATUS_PARAM;
  rq.ocf    = OCF_READ_RSSI;
  rq.cparam = &handle;
  rq.clen   = 2;
  rq.rparam = &rp;
  rq.rlen   = READ_RSSI_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *rssi = rp.rssi;
  return 0;
}

int hci_read_afh_map(int dd, uint16_t handle, uint8_t *mode, uint8_t *map,
      int to)
{
  read_afh_map_rp rp;
  struct hci_request rq;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_STATUS_PARAM;
  rq.ocf    = OCF_READ_AFH_MAP;
  rq.cparam = &handle;
  rq.clen   = 2;
  rq.rparam = &rp;
  rq.rlen   = READ_AFH_MAP_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *mode = rp.mode;
  memcpy(map, rp.map, 10);
  return 0;
}

int hci_read_clock(int dd, uint16_t handle, uint8_t which, uint32_t *clock,
      uint16_t *accuracy, int to)
{
  read_clock_cp cp;
  read_clock_rp rp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle      = handle;
  cp.which_clock = which;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_STATUS_PARAM;
  rq.ocf    = OCF_READ_CLOCK;
  rq.cparam = &cp;
  rq.clen   = READ_CLOCK_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = READ_CLOCK_RP_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  *clock    = rp.clock;
  *accuracy = rp.accuracy;
  return 0;
}

int hci_le_set_scan_enable(int dd, uint8_t enable, uint8_t filter_dup, int to)
{
  struct hci_request rq;
  le_set_scan_enable_cp scan_cp;
  uint8_t status;

  memset(&scan_cp, 0, sizeof(scan_cp));
  scan_cp.enable = enable;
  scan_cp.filter_dup = filter_dup;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_SET_SCAN_ENABLE;
  rq.cparam = &scan_cp;
  rq.clen = LE_SET_SCAN_ENABLE_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_set_scan_parameters(int dd, uint8_t type,
          uint16_t interval, uint16_t window,
          uint8_t own_type, uint8_t filter, int to)
{
  struct hci_request rq;
  le_set_scan_parameters_cp param_cp;
  uint8_t status;

  memset(&param_cp, 0, sizeof(param_cp));
  param_cp.type = type;
  param_cp.interval = interval;
  param_cp.window = window;
  param_cp.own_bdaddr_type = own_type;
  param_cp.filter = filter;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_SET_SCAN_PARAMETERS;
  rq.cparam = &param_cp;
  rq.clen = LE_SET_SCAN_PARAMETERS_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_set_advertise_enable(int dd, uint8_t enable, int to)
{
  struct hci_request rq;
  le_set_advertise_enable_cp adv_cp;
  uint8_t status;

  memset(&adv_cp, 0, sizeof(adv_cp));
  adv_cp.enable = enable;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_SET_ADVERTISE_ENABLE;
  rq.cparam = &adv_cp;
  rq.clen = LE_SET_ADVERTISE_ENABLE_CP_SIZE;
  rq.rparam = &status;
  rq.rlen = 1;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_create_conn(int dd, uint16_t interval, uint16_t window,
    uint8_t initiator_filter, uint8_t peer_bdaddr_type,
    bdaddr_t peer_bdaddr, uint8_t own_bdaddr_type,
    uint16_t min_interval, uint16_t max_interval,
    uint16_t latency, uint16_t supervision_timeout,
    uint16_t min_ce_length, uint16_t max_ce_length,
    uint16_t *handle, int to)
{
  struct hci_request rq;
  le_create_connection_cp create_conn_cp;
  evt_le_connection_complete conn_complete_rp;

  memset(&create_conn_cp, 0, sizeof(create_conn_cp));
  create_conn_cp.interval = interval;
  create_conn_cp.window = window;
  create_conn_cp.initiator_filter = initiator_filter;
  create_conn_cp.peer_bdaddr_type = peer_bdaddr_type;
  create_conn_cp.peer_bdaddr = peer_bdaddr;
  create_conn_cp.own_bdaddr_type = own_bdaddr_type;
  create_conn_cp.min_interval = min_interval;
  create_conn_cp.max_interval = max_interval;
  create_conn_cp.latency = latency;
  create_conn_cp.supervision_timeout = supervision_timeout;
  create_conn_cp.min_ce_length = min_ce_length;
  create_conn_cp.max_ce_length = max_ce_length;

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_CREATE_CONN;
  rq.event = EVT_LE_CONN_COMPLETE;
  rq.cparam = &create_conn_cp;
  rq.clen = LE_CREATE_CONN_CP_SIZE;
  rq.rparam = &conn_complete_rp;
  rq.rlen = EVT_CONN_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (conn_complete_rp.status) {
    errno = EIO;
    return -1;
  }

  if (handle)
    *handle = conn_complete_rp.handle;

  return 0;
}

int hci_le_conn_update(int dd, uint16_t handle, uint16_t min_interval,
      uint16_t max_interval, uint16_t latency,
      uint16_t supervision_timeout, int to)
{
  evt_le_connection_update_complete evt;
  le_connection_update_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;
  cp.min_interval = min_interval;
  cp.max_interval = max_interval;
  cp.latency = latency;
  cp.supervision_timeout = supervision_timeout;
  cp.min_ce_length = htobs(0x0001);
  cp.max_ce_length = htobs(0x0001);

  memset(&rq, 0, sizeof(rq));
  rq.ogf = OGF_LE_CTL;
  rq.ocf = OCF_LE_CONN_UPDATE;
  rq.cparam = &cp;
  rq.clen = LE_CONN_UPDATE_CP_SIZE;
  rq.event = EVT_LE_CONN_UPDATE_COMPLETE;
  rq.rparam = &evt;
  rq.rlen = sizeof(evt);

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (evt.status) {
    errno = EIO;
    return -1;
  }

  return 0;
}

int hci_le_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to)
{
  evt_le_read_remote_used_features_complete rp;
  le_read_remote_used_features_cp cp;
  struct hci_request rq;

  memset(&cp, 0, sizeof(cp));
  cp.handle = handle;

  memset(&rq, 0, sizeof(rq));
  rq.ogf    = OGF_LE_CTL;
  rq.ocf    = OCF_LE_READ_REMOTE_USED_FEATURES;
  rq.event  = EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE;
  rq.cparam = &cp;
  rq.clen   = LE_READ_REMOTE_USED_FEATURES_CP_SIZE;
  rq.rparam = &rp;
  rq.rlen   = EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE_SIZE;

  if (hci_send_req(dd, &rq, to) < 0)
    return -1;

  if (rp.status) {
    errno = EIO;
    return -1;
  }

  if (features)
    memcpy(features, rp.features, 8);

  return 0;
}

Coverage Report

Created: 2026-07-25 06:35