bartoszek/zephyr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Bluetooth: host: Align with terms in v5.3 spec

Browse Source 
Align with the new inclusive naming terms in the v5.3 spec in the
Bluetooth Host implementation.

Signed-off-by: Carles Cufi <carles.cufi@nordicsemi.no>
This commit is contained in:
Carles Cufi 2021-09-17 13:49:15 +02:00 committed by Carles Cufí
parent 1821d342c2
commit b8770acc28
14 changed files with 91 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
doc/releases/release-notes-2.7.rst
View File

@ -79,6 +79,9 @@ Modified in this release
* ``m_*`` structure members are now ``c_*``
* ``s_*`` structure members are now ``p_*``
* The ``CONFIG_BT_PERIPHERAL_PREF_SLAVE_LATENCY`` Kconfig option is now
:kconfig:`CONFIG_BT_PERIPHERAL_PREF_LATENCY`
Changes in this release
==========================

4
subsys/bluetooth/host/Kconfig
View File

@ -355,10 +355,10 @@ config BT_SMP_USB_HCI_CTLR_WORKAROUND
This option enables support for USB HCI controllers that sometimes
send out-of-order HCI events and ACL Data due to using different USB
endpoints.
Enabling this option will make the master role not require the
Enabling this option will make the central role not require the
encryption-change event to be received before accepting key-distribution
data.
It opens up for a potential vulnerability as the master cannot detect
It opens up for a potential vulnerability as the central cannot detect
if the keys are distributed over an encrypted link.
config BT_FIXED_PASSKEY

4
subsys/bluetooth/host/Kconfig.gatt
View File

@ -173,8 +173,8 @@ config BT_PERIPHERAL_PREF_MAX_INT
help
Range 3200 to 65534 is invalid. 65535 represents no specific value.
config BT_PERIPHERAL_PREF_SLAVE_LATENCY
int "Peripheral preferred slave latency in Connection Intervals"
config BT_PERIPHERAL_PREF_LATENCY
int "Peripheral preferred peripheral latency in Connection Intervals"
default 0
range 0 499

28
subsys/bluetooth/host/conn.c
View File

@ -1328,14 +1328,14 @@ void notify_le_param_updated(struct bt_conn *conn)
struct bt_conn_cb *cb;
/* If new connection parameters meet requirement of pending
* parameters don't send slave conn param request anymore on timeout
* parameters don't send peripheral conn param request anymore on timeout
*/
if (atomic_test_bit(conn->flags, BT_CONN_SLAVE_PARAM_SET) &&
if (atomic_test_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET) &&
conn->le.interval >= conn->le.interval_min &&
conn->le.interval <= conn->le.interval_max &&
conn->le.latency == conn->le.pending_latency &&
conn->le.timeout == conn->le.pending_timeout) {
atomic_clear_bit(conn->flags, BT_CONN_SLAVE_PARAM_SET);
atomic_clear_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET);
}
for (cb = callback_list; cb; cb = cb->_next) {
@ -1452,11 +1452,11 @@ static int send_conn_le_param_update(struct bt_conn *conn,
}
/* Use LE connection parameter request if both local and remote support
* it; or if local role is master then use LE connection update.
* it; or if local role is central then use LE connection update.
*/
if ((BT_FEAT_LE_CONN_PARAM_REQ_PROC(bt_dev.le.features) &&
BT_FEAT_LE_CONN_PARAM_REQ_PROC(conn->le.features) &&
!atomic_test_bit(conn->flags, BT_CONN_SLAVE_PARAM_L2CAP)) ||
!atomic_test_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_L2CAP)) ||
(conn->role == BT_HCI_ROLE_CENTRAL)) {
int rc;
@ -1471,7 +1471,7 @@ static int send_conn_le_param_update(struct bt_conn *conn,
return rc;
}
/* If remote master does not support LL Connection Parameters Request
/* If remote central does not support LL Connection Parameters Request
* Procedure
*/
return bt_l2cap_update_conn_param(conn, param);
@ -1572,7 +1572,7 @@ static void deferred_work(struct k_work *work)
/* if application set own params use those, otherwise use defaults. */
if (atomic_test_and_clear_bit(conn->flags,
BT_CONN_SLAVE_PARAM_SET)) {
BT_CONN_PERIPHERAL_PARAM_SET)) {
param = BT_LE_CONN_PARAM(conn->le.interval_min,
conn->le.interval_max,
conn->le.pending_latency,
@ -1583,13 +1583,13 @@ static void deferred_work(struct k_work *work)
param = BT_LE_CONN_PARAM(
CONFIG_BT_PERIPHERAL_PREF_MIN_INT,
CONFIG_BT_PERIPHERAL_PREF_MAX_INT,
CONFIG_BT_PERIPHERAL_PREF_SLAVE_LATENCY,
CONFIG_BT_PERIPHERAL_PREF_LATENCY,
CONFIG_BT_PERIPHERAL_PREF_TIMEOUT);
send_conn_le_param_update(conn, param);
#endif
}
atomic_set_bit(conn->flags, BT_CONN_SLAVE_PARAM_UPDATE);
atomic_set_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_UPDATE);
}
static struct bt_conn *acl_conn_new(void)
@ -2335,7 +2335,7 @@ int bt_conn_le_param_update(struct bt_conn *conn,
conn->le.interval <= param->interval_max &&
conn->le.latency == param->latency &&
conn->le.timeout == param->timeout) {
atomic_clear_bit(conn->flags, BT_CONN_SLAVE_PARAM_SET);
atomic_clear_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET);
return -EALREADY;
}
@ -2345,8 +2345,8 @@ int bt_conn_le_param_update(struct bt_conn *conn,
}
if (IS_ENABLED(CONFIG_BT_PERIPHERAL)) {
/* if slave conn param update timer expired just send request */
if (atomic_test_bit(conn->flags, BT_CONN_SLAVE_PARAM_UPDATE)) {
/* if peripheral conn param update timer expired just send request */
if (atomic_test_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_UPDATE)) {
return send_conn_le_param_update(conn, param);
}
@ -2355,7 +2355,7 @@ int bt_conn_le_param_update(struct bt_conn *conn,
conn->le.interval_max = param->interval_max;
conn->le.pending_latency = param->latency;
conn->le.pending_timeout = param->timeout;
atomic_set_bit(conn->flags, BT_CONN_SLAVE_PARAM_SET);
atomic_set_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET);
}
return 0;
@ -2509,7 +2509,7 @@ int bt_conn_le_create_auto(const struct bt_conn_le_create_param *create_param,
err = bt_le_create_conn(conn);
if (err) {
BT_ERR("Failed to start whitelist scan");
BT_ERR("Failed to start filtered scan");
conn->err = 0;
bt_conn_set_state(conn, BT_CONN_DISCONNECTED);
bt_conn_unref(conn);

6
subsys/bluetooth/host/conn_internal.h
View File

@ -29,9 +29,9 @@ enum {
BT_CONN_BR_PAIRING_INITIATOR, /* local host starts authentication */
BT_CONN_CLEANUP, /* Disconnected, pending cleanup */
BT_CONN_AUTO_PHY_UPDATE, /* Auto-update PHY */
BT_CONN_SLAVE_PARAM_UPDATE, /* If slave param update timer fired */
BT_CONN_SLAVE_PARAM_SET, /* If slave param were set from app */
BT_CONN_SLAVE_PARAM_L2CAP, /* If should force L2CAP for CPUP */
BT_CONN_PERIPHERAL_PARAM_UPDATE,/* If periph param update timer fired */
BT_CONN_PERIPHERAL_PARAM_SET, /* If periph param were set from app */
BT_CONN_PERIPHERAL_PARAM_L2CAP, /* If should force L2CAP for CPUP */
BT_CONN_FORCE_PAIR, /* Pairing even with existing keys. */
BT_CONN_AUTO_PHY_COMPLETE, /* Auto-initiated PHY procedure done */

2
subsys/bluetooth/host/gatt.c
View File

@ -150,7 +150,7 @@ static ssize_t read_ppcp(struct bt_conn *conn, const struct bt_gatt_attr *attr,
ppcp.min_int = sys_cpu_to_le16(CONFIG_BT_PERIPHERAL_PREF_MIN_INT);
ppcp.max_int = sys_cpu_to_le16(CONFIG_BT_PERIPHERAL_PREF_MAX_INT);
ppcp.latency = sys_cpu_to_le16(CONFIG_BT_PERIPHERAL_PREF_SLAVE_LATENCY);
ppcp.latency = sys_cpu_to_le16(CONFIG_BT_PERIPHERAL_PREF_LATENCY);
ppcp.timeout = sys_cpu_to_le16(CONFIG_BT_PERIPHERAL_PREF_TIMEOUT);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &ppcp,

26
subsys/bluetooth/host/hci_core.c
View File

@ -995,11 +995,11 @@ static void le_conn_complete_cancel(void)
/* Handle create connection cancel.
*
* There is no need to check ID address as only one
* connection in master role can be in pending state.
* connection in central role can be in pending state.
*/
conn = find_pending_connect(BT_HCI_ROLE_CENTRAL, NULL);
if (!conn) {
BT_ERR("No pending master connection");
BT_ERR("No pending central connection");
return;
}
@ -1019,7 +1019,7 @@ static void le_conn_complete_cancel(void)
}
} else {
if (atomic_test_bit(conn->flags, BT_CONN_AUTO_CONNECT)) {
/* Restart whitelist initiator after RPA timeout. */
/* Restart FAL initiator after RPA timeout. */
bt_le_create_conn(conn);
} else {
/* Create connection canceled by timeout */
@ -1052,11 +1052,11 @@ static void le_conn_complete_adv_timeout(void)
}
/* There is no need to check ID address as only one
* connection in slave role can be in pending state.
* connection in peripheral role can be in pending state.
*/
conn = find_pending_connect(BT_HCI_ROLE_PERIPHERAL, NULL);
if (!conn) {
BT_ERR("No pending slave connection");
BT_ERR("No pending peripheral connection");
return;
}
@ -1200,7 +1200,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
#endif
/*
* Use connection address (instead of identity address) as initiator
* or responder address. Only slave needs to be updated. For master all
* or responder address. Only peripheral needs to be updated. For central all
* was set during outgoing connection creation.
*/
if (IS_ENABLED(CONFIG_BT_PERIPHERAL) &&
@ -1234,9 +1234,9 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
}
/* if the controller supports, lets advertise for another
* slave connection.
* peripheral connection.
* check for connectable advertising state is sufficient as
* this is how this le connection complete for slave occurred.
* this is how this le connection complete for peripheral occurred.
*/
if (BT_LE_STATES_PER_CONN_ADV(bt_dev.le.states)) {
bt_le_adv_resume();
@ -1568,7 +1568,7 @@ static void le_conn_update_complete(struct net_buf *buf)
} else if (evt->status == BT_HCI_ERR_UNSUPP_REMOTE_FEATURE &&
conn->role == BT_HCI_ROLE_PERIPHERAL &&
!atomic_test_and_set_bit(conn->flags,
BT_CONN_SLAVE_PARAM_L2CAP)) {
BT_CONN_PERIPHERAL_PARAM_L2CAP)) {
/* CPR not supported, let's try L2CAP CPUP instead */
struct bt_le_conn_param param;
@ -1787,7 +1787,7 @@ static void hci_encrypt_change(struct net_buf *buf)
if (IS_ENABLED(CONFIG_BT_SMP)) {
/*
* Start SMP over BR/EDR if we are pairing and are
* master on the link
* central on the link
*/
if (atomic_test_bit(conn->flags, BT_CONN_BR_PAIRING) &&
conn->role == BT_CONN_ROLE_CENTRAL) {
@ -3688,7 +3688,7 @@ int bt_le_filter_accept_list_add(const bt_addr_le_t *addr)
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_ADD_DEV_TO_FAL, buf, NULL);
if (err) {
BT_ERR("Failed to add device to whitelist");
BT_ERR("Failed to add device to filter accept list");
return err;
}
@ -3716,7 +3716,7 @@ int bt_le_filter_accept_list_remove(const bt_addr_le_t *addr)
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_REM_DEV_FROM_FAL, buf, NULL);
if (err) {
BT_ERR("Failed to remove device from whitelist");
BT_ERR("Failed to remove device from filter accept list");
return err;
}
@ -3733,7 +3733,7 @@ int bt_le_filter_accept_list_clear(void)
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_CLEAR_FAL, NULL, NULL);
if (err) {
BT_ERR("Failed to clear whitelist");
BT_ERR("Failed to clear filter accept list");
return err;
}

2
subsys/bluetooth/host/hci_core.h
View File

@ -38,7 +38,7 @@ enum {
BT_DEV_EXPLICIT_SCAN,
BT_DEV_ACTIVE_SCAN,
BT_DEV_SCAN_FILTER_DUP,
BT_DEV_SCAN_WL,
BT_DEV_SCAN_FILTERED,
BT_DEV_SCAN_LIMITED,
BT_DEV_INITIATING,

2
subsys/bluetooth/host/iso.c
View File

@ -412,7 +412,7 @@ static void bt_iso_chan_disconnected(struct bt_iso_chan *chan, uint8_t reason)
chan->iso = NULL;
} else {
/* ISO data paths are automatically removed when the
* peripheral/slave disconnects, so we only need to
* peripheral disconnects, so we only need to
* move it for the central
*/
bt_iso_remove_data_path(chan->iso);

4
subsys/bluetooth/host/keys.c
View File

@ -490,8 +490,8 @@ void bt_keys_show_sniffer_info(struct bt_keys *keys, void *data)
BT_INFO("SC LTK: 0x%s", bt_hex(ltk, keys->enc_size));
}
if (keys->keys & BT_KEYS_SLAVE_LTK) {
sys_memcpy_swap(ltk, keys->slave_ltk.val, keys->enc_size);
if (keys->keys & BT_KEYS_PERIPH_LTK) {
sys_memcpy_swap(ltk, keys->periph_ltk.val, keys->enc_size);
BT_INFO("Legacy LTK: 0x%s (peripheral)",
bt_hex(ltk, keys->enc_size));
}

8
subsys/bluetooth/host/keys.h
View File

@ -7,15 +7,15 @@
*/
enum {
BT_KEYS_SLAVE_LTK = BIT(0),
BT_KEYS_PERIPH_LTK = BIT(0),
BT_KEYS_IRK = BIT(1),
BT_KEYS_LTK = BIT(2),
BT_KEYS_LOCAL_CSRK = BIT(3),
BT_KEYS_REMOTE_CSRK = BIT(4),
BT_KEYS_LTK_P256 = BIT(5),
BT_KEYS_ALL = (BT_KEYS_SLAVE_LTK | BT_KEYS_IRK | \
BT_KEYS_LTK | BT_KEYS_LOCAL_CSRK | \
BT_KEYS_ALL = (BT_KEYS_PERIPH_LTK | BT_KEYS_IRK |
BT_KEYS_LTK | BT_KEYS_LOCAL_CSRK |
BT_KEYS_REMOTE_CSRK | BT_KEYS_LTK_P256),
};
@ -63,7 +63,7 @@ struct bt_keys {
struct bt_csrk remote_csrk;
#endif /* BT_SIGNING */
#if !defined(CONFIG_BT_SMP_SC_PAIR_ONLY)
struct bt_ltk slave_ltk;
struct bt_ltk periph_ltk;
#endif /* CONFIG_BT_SMP_SC_PAIR_ONLY */
#if (defined(CONFIG_BT_KEYS_OVERWRITE_OLDEST))
uint32_t aging_counter;

6
subsys/bluetooth/host/scan.c
View File

@ -161,7 +161,7 @@ static int start_le_scan_ext(struct bt_hci_ext_scan_phy *phy_1m,
set_param->phys = 0;
if (IS_ENABLED(CONFIG_BT_FILTER_ACCEPT_LIST) &&
atomic_test_bit(bt_dev.flags, BT_DEV_SCAN_WL)) {
atomic_test_bit(bt_dev.flags, BT_DEV_SCAN_FILTERED)) {
set_param->filter_policy = BT_HCI_LE_SCAN_FP_BASIC_FILTER;
} else {
set_param->filter_policy = BT_HCI_LE_SCAN_FP_BASIC_NO_FILTER;
@ -210,7 +210,7 @@ static int start_le_scan_legacy(uint8_t scan_type, uint16_t interval, uint16_t w
set_param.window = sys_cpu_to_le16(window);
if (IS_ENABLED(CONFIG_BT_FILTER_ACCEPT_LIST) &&
atomic_test_bit(bt_dev.flags, BT_DEV_SCAN_WL)) {
atomic_test_bit(bt_dev.flags, BT_DEV_SCAN_FILTERED)) {
set_param.filter_policy = BT_HCI_LE_SCAN_FP_BASIC_FILTER;
} else {
set_param.filter_policy = BT_HCI_LE_SCAN_FP_BASIC_NO_FILTER;
@ -992,7 +992,7 @@ int bt_le_scan_start(const struct bt_le_scan_param *param, bt_le_scan_cb_t cb)
param->options & BT_LE_SCAN_OPT_FILTER_DUPLICATE);
#if defined(CONFIG_BT_FILTER_ACCEPT_LIST)
atomic_set_bit_to(bt_dev.flags, BT_DEV_SCAN_WL,
atomic_set_bit_to(bt_dev.flags, BT_DEV_SCAN_FILTERED,
param->options & BT_LE_SCAN_OPT_FILTER_ACCEPT_LIST);
#endif /* defined(CONFIG_BT_FILTER_ACCEPT_LIST) */

80
subsys/bluetooth/host/smp.c
View File

@ -127,7 +127,7 @@ enum {
SMP_FLAG_BOND, /* if bonding */
SMP_FLAG_SC_DEBUG_KEY, /* if Secure Connection are using debug key */
SMP_FLAG_SEC_REQ, /* if Security Request was sent/received */
SMP_FLAG_DHCHECK_WAIT, /* if waiting for remote DHCheck (as slave) */
SMP_FLAG_DHCHECK_WAIT, /* if waiting for remote DHCheck (as periph) */
SMP_FLAG_DERIVE_LK, /* if Link Key should be derived */
SMP_FLAG_BR_CONNECTED, /* if BR/EDR channel is connected */
SMP_FLAG_BR_PAIR, /* if should start BR/EDR pairing */
@ -1355,7 +1355,7 @@ static uint8_t smp_br_pairing_req(struct bt_smp_br *smp, struct net_buf *buf)
smp->local_dist &= ~BT_SMP_DIST_ENC_KEY;
smp->remote_dist &= ~BT_SMP_DIST_ENC_KEY;
/* BR/EDR acceptor is like LE Slave and distributes keys first */
/* BR/EDR acceptor is like LE Peripheral and distributes keys first */
smp_br_distribute_keys(smp);
if (smp->remote_dist & BT_SMP_DIST_ID_KEY) {
@ -1396,7 +1396,7 @@ static uint8_t smp_br_pairing_rsp(struct bt_smp_br *smp, struct net_buf *buf)
smp->local_dist &= SEND_KEYS_SC;
smp->remote_dist &= RECV_KEYS_SC;
/* slave distributes its keys first */
/* Peripheral distributes its keys first */
if (smp->remote_dist & BT_SMP_DIST_ID_KEY) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_INFO);
@ -1567,7 +1567,7 @@ static const struct {
{ }, /* pairing random not used over BR/EDR */
{ smp_br_pairing_failed, sizeof(struct bt_smp_pairing_fail) },
{ }, /* encrypt info not used over BR/EDR */
{ }, /* master ident not used over BR/EDR */
{ }, /* central ident not used over BR/EDR */
{ smp_br_ident_info, sizeof(struct bt_smp_ident_info) },
{ smp_br_ident_addr_info, sizeof(struct bt_smp_ident_addr_info) },
{ smp_br_signing_info, sizeof(struct bt_smp_signing_info) },
@ -2098,7 +2098,7 @@ static void legacy_distribute_keys(struct bt_smp *smp)
if (smp->local_dist & BT_SMP_DIST_ENC_KEY) {
struct bt_smp_encrypt_info *info;
struct bt_smp_master_ident *ident;
struct bt_smp_central_ident *ident;
struct net_buf *buf;
/* Use struct to get randomness in single call to bt_rand */
struct {
@ -2130,10 +2130,10 @@ static void legacy_distribute_keys(struct bt_smp *smp)
smp_send(smp, buf, NULL, NULL);
buf = smp_create_pdu(smp, BT_SMP_CMD_MASTER_IDENT,
buf = smp_create_pdu(smp, BT_SMP_CMD_CENTRAL_IDENT,
sizeof(*ident));
if (!buf) {
BT_ERR("Unable to allocate Master Ident buffer");
BT_ERR("Unable to allocate Central Ident buffer");
return;
}
@ -2144,14 +2144,14 @@ static void legacy_distribute_keys(struct bt_smp *smp)
smp_send(smp, buf, smp_ident_sent, NULL);
if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) {
bt_keys_add_type(keys, BT_KEYS_SLAVE_LTK);
bt_keys_add_type(keys, BT_KEYS_PERIPH_LTK);
memcpy(keys->slave_ltk.val, rand.key,
sizeof(keys->slave_ltk.val));
memcpy(keys->slave_ltk.rand, rand.rand,
sizeof(keys->slave_ltk.rand));
memcpy(keys->slave_ltk.ediv, rand.ediv,
sizeof(keys->slave_ltk.ediv));
memcpy(keys->periph_ltk.val, rand.key,
sizeof(keys->periph_ltk.val));
memcpy(keys->periph_ltk.rand, rand.rand,
sizeof(keys->periph_ltk.rand));
memcpy(keys->periph_ltk.ediv, rand.ediv,
sizeof(keys->periph_ltk.ediv));
}
}
}
@ -2483,7 +2483,7 @@ static uint8_t legacy_pairing_random(struct bt_smp *smp)
conn->role == BT_HCI_ROLE_CENTRAL) {
uint8_t ediv[2], rand[8];
/* No need to store master STK */
/* No need to store central STK */
err = smp_s1(smp->tk, smp->rrnd, smp->prnd, tmp);
if (err) {
return BT_SMP_ERR_UNSPECIFIED;
@ -2607,12 +2607,12 @@ static uint8_t smp_encrypt_info(struct bt_smp *smp, struct net_buf *buf)
memcpy(keys->ltk.val, req->ltk, 16);
}
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_MASTER_IDENT);
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_CENTRAL_IDENT);
return 0;
}
static uint8_t smp_master_ident(struct bt_smp *smp, struct net_buf *buf)
static uint8_t smp_central_ident(struct bt_smp *smp, struct net_buf *buf)
{
struct bt_conn *conn = smp->chan.chan.conn;
uint8_t err;
@ -2620,7 +2620,7 @@ static uint8_t smp_master_ident(struct bt_smp *smp, struct net_buf *buf)
BT_DBG("");
if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) {
struct bt_smp_master_ident *req = (void *)buf->data;
struct bt_smp_central_ident *req = (void *)buf->data;
struct bt_keys *keys;
keys = bt_keys_get_type(BT_KEYS_LTK, conn->id, &conn->le.dst);
@ -2696,7 +2696,7 @@ static uint8_t smp_encrypt_info(struct bt_smp *smp, struct net_buf *buf)
return BT_SMP_ERR_CMD_NOTSUPP;
}
static uint8_t smp_master_ident(struct bt_smp *smp, struct net_buf *buf)
static uint8_t smp_central_ident(struct bt_smp *smp, struct net_buf *buf)
{
return BT_SMP_ERR_CMD_NOTSUPP;
}
@ -2863,7 +2863,7 @@ bool bt_smp_request_ltk(struct bt_conn *conn, uint64_t rand, uint16_t ediv, uint
conn->le.keys = bt_keys_find(BT_KEYS_LTK_P256, conn->id,
&conn->le.dst);
if (!conn->le.keys) {
conn->le.keys = bt_keys_find(BT_KEYS_SLAVE_LTK,
conn->le.keys = bt_keys_find(BT_KEYS_PERIPH_LTK,
conn->id, &conn->le.dst);
}
}
@ -2883,12 +2883,12 @@ bool bt_smp_request_ltk(struct bt_conn *conn, uint64_t rand, uint16_t ediv, uint
}
#if !defined(CONFIG_BT_SMP_SC_PAIR_ONLY)
if (conn->le.keys && (conn->le.keys->keys & BT_KEYS_SLAVE_LTK) &&
!memcmp(conn->le.keys->slave_ltk.rand, &rand, 8) &&
!memcmp(conn->le.keys->slave_ltk.ediv, &ediv, 2)) {
if (conn->le.keys && (conn->le.keys->keys & BT_KEYS_PERIPH_LTK) &&
!memcmp(conn->le.keys->periph_ltk.rand, &rand, 8) &&
!memcmp(conn->le.keys->periph_ltk.ediv, &ediv, 2)) {
enc_size = conn->le.keys->enc_size;
memcpy(ltk, conn->le.keys->slave_ltk.val, enc_size);
memcpy(ltk, conn->le.keys->periph_ltk.val, enc_size);
if (enc_size < BT_SMP_MAX_ENC_KEY_SIZE) {
(void)memset(ltk + enc_size, 0,
BT_SMP_MAX_ENC_KEY_SIZE - enc_size);
@ -2901,7 +2901,7 @@ bool bt_smp_request_ltk(struct bt_conn *conn, uint64_t rand, uint16_t ediv, uint
if (atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ)) {
/* Notify higher level that security failed if security was
* initiated by slave.
* initiated by peripheral.
*/
bt_conn_security_changed(conn, BT_HCI_ERR_PIN_OR_KEY_MISSING,
BT_SECURITY_ERR_PIN_OR_KEY_MISSING);
@ -3380,7 +3380,7 @@ static uint8_t sc_smp_send_dhkey_check(struct bt_smp *smp, const uint8_t *e)
}
#if defined(CONFIG_BT_CENTRAL)
static uint8_t compute_and_send_master_dhcheck(struct bt_smp *smp)
static uint8_t compute_and_send_central_dhcheck(struct bt_smp *smp)
{
uint8_t e[16], r[16];
@ -3426,7 +3426,7 @@ static uint8_t compute_and_send_master_dhcheck(struct bt_smp *smp)
#endif /* CONFIG_BT_CENTRAL */
#if defined(CONFIG_BT_PERIPHERAL)
static uint8_t compute_and_check_and_send_slave_dhcheck(struct bt_smp *smp)
static uint8_t compute_and_check_and_send_periph_dhcheck(struct bt_smp *smp)
{
uint8_t re[16], e[16], r[16];
uint8_t err;
@ -3541,13 +3541,13 @@ static uint8_t smp_dhkey_ready(struct bt_smp *smp, const uint8_t *dhkey)
if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_SEND)) {
#if defined(CONFIG_BT_CENTRAL)
if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
return compute_and_send_master_dhcheck(smp);
return compute_and_send_central_dhcheck(smp);
}
#endif /* CONFIG_BT_CENTRAL */
#if defined(CONFIG_BT_PERIPHERAL)
return compute_and_check_and_send_slave_dhcheck(smp);
return compute_and_check_and_send_periph_dhcheck(smp);
#endif /* CONFIG_BT_PERIPHERAL */
}
@ -3744,7 +3744,7 @@ static uint8_t smp_pairing_random(struct bt_smp *smp, struct net_buf *buf)
return 0;
}
return compute_and_send_master_dhcheck(smp);
return compute_and_send_central_dhcheck(smp);
}
#endif /* CONFIG_BT_CENTRAL */
@ -4158,7 +4158,7 @@ static uint8_t display_passkey(struct bt_smp *smp)
}
#if defined(CONFIG_BT_PERIPHERAL)
static uint8_t smp_public_key_slave(struct bt_smp *smp)
static uint8_t smp_public_key_periph(struct bt_smp *smp)
{
uint8_t err;
@ -4317,7 +4317,7 @@ static uint8_t smp_public_key(struct bt_smp *smp, struct net_buf *buf)
return 0;
}
err = smp_public_key_slave(smp);
err = smp_public_key_periph(smp);
if (err) {
return err;
}
@ -4411,7 +4411,7 @@ static uint8_t smp_dhkey_check(struct bt_smp *smp, struct net_buf *buf)
return 0;
}
return compute_and_check_and_send_slave_dhcheck(smp);
return compute_and_check_and_send_periph_dhcheck(smp);
}
#endif /* CONFIG_BT_PERIPHERAL */
@ -4441,7 +4441,7 @@ static const struct {
{ smp_pairing_random, sizeof(struct bt_smp_pairing_random) },
{ smp_pairing_failed, sizeof(struct bt_smp_pairing_fail) },
{ smp_encrypt_info, sizeof(struct bt_smp_encrypt_info) },
{ smp_master_ident, sizeof(struct bt_smp_master_ident) },
{ smp_central_ident, sizeof(struct bt_smp_central_ident) },
{ smp_ident_info, sizeof(struct bt_smp_ident_info) },
{ smp_ident_addr_info, sizeof(struct bt_smp_ident_addr_info) },
{ smp_signing_info, sizeof(struct bt_smp_signing_info) },
@ -4551,7 +4551,7 @@ static void bt_smp_pkey_ready(const uint8_t *pkey)
}
#if defined(CONFIG_BT_PERIPHERAL)
err = smp_public_key_slave(smp);
err = smp_public_key_periph(smp);
if (err) {
smp_error(smp, err);
}
@ -4639,7 +4639,7 @@ static void bt_smp_encrypt_change(struct bt_l2cap_chan *chan,
}
/* We were waiting for encryption but with no pairing in progress.
* This can happen if paired slave sent Security Request and we
* This can happen if paired peripheral sent Security Request and we
* enabled encryption.
*/
if (!atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) {
@ -4685,7 +4685,7 @@ static void bt_smp_encrypt_change(struct bt_l2cap_chan *chan,
atomic_set_bit(smp->flags, SMP_FLAG_KEYS_DISTR);
/* Slave distributes it's keys first */
/* Peripheral distributes it's keys first */
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_CENTRAL && smp->remote_dist) {
return;
@ -5332,7 +5332,7 @@ int bt_smp_auth_passkey_confirm(struct bt_conn *conn)
#if defined(CONFIG_BT_CENTRAL)
if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
err = compute_and_send_master_dhcheck(smp);
err = compute_and_send_central_dhcheck(smp);
if (err) {
smp_error(smp, err);
}
@ -5341,7 +5341,7 @@ int bt_smp_auth_passkey_confirm(struct bt_conn *conn)
#endif /* CONFIG_BT_CENTRAL */
#if defined(CONFIG_BT_PERIPHERAL)
err = compute_and_check_and_send_slave_dhcheck(smp);
err = compute_and_check_and_send_periph_dhcheck(smp);
if (err) {
smp_error(smp, err);
}
@ -5657,7 +5657,7 @@ int bt_smp_start_security(struct bt_conn *conn)
return smp_send_pairing_req(conn);
}
/* LE SC LTK and legacy master LTK are stored in same place */
/* LE SC LTK and legacy central LTK are stored in same place */
err = bt_conn_le_start_encryption(conn,
conn->le.keys->ltk.rand,
conn->le.keys->ltk.ediv,

4
subsys/bluetooth/host/smp.h
View File

@ -86,8 +86,8 @@ struct bt_smp_encrypt_info {
uint8_t ltk[16];
} __packed;
#define BT_SMP_CMD_MASTER_IDENT 0x07
struct bt_smp_master_ident {
#define BT_SMP_CMD_CENTRAL_IDENT 0x0
struct bt_smp_central_ident {
uint8_t ediv[2];
uint8_t rand[8];
} __packed;