[nrf noup] bluetooth: host: Add support for bonding with same peer

This commit adds a new Kconfig option by enabling which Host will keep
bonding with the same Central instead of rejecting pairing.

Brief implementation details:

This implementation adds a new flag to bt_keys struct:
BT_KEYS_ID_CONFLICT. The flag is set, when:
- bonding with the same peer and conflict identified
- when loading conflicting keys from persistent storage.

When bonding and conflict is identified, the new keys aren't added to
the Resolving List immediately. Instead, the old keys stay in the
Resolving List.

When start advertising, Host finds conflicting keys that are already
added to the Resolving List and substitues them.

If, however, there is another advertiser already started for the added
keys, the new request is reject and advertising start function returns
-EPERM.

This is supported by Peripheral role only for now.

Allow to use CONFIG_BT_ID_AUTO_SWAP_MATCHING_BONDS Kconfig option even
if CONFIG_BT_PRIVACY is disabled.

This is because CONFIG_BT_PRIVACY configures privacy of local device
will still allows to resolve peer address. During pairing, peer device
may send its Identity Address and IRK which then can be used for address
resolution. This doesn't require CONFIG_BT_PRIVACY be enabled.

Signed-off-by: Pavel Vasilyev <pavel.vasilyev@nordicsemi.no>
(cherry picked from commit 8e030ea)
(cherry picked from commit 72becd4)
(cherry picked from commit 4994883)

Author: PavelVPV

include/zephyr/bluetooth/bluetooth.h

@@ -1295,6 +1295,10 @@ struct bt_le_per_adv_param {
  *                       This error code is only guaranteed when using Zephyr
  *                       controller, for other controllers code returned in
  *                       this case may be -EIO.
+ * @return -EPERM When @kconfig{CONFIG_BT_PRIVACY} and
+ *                @kconfig{CONFIG_BT_ID_AUTO_SWAP_MATCHING_BONDS} are enabled and connectable
+ *                advertising is requested, and the given local identity has a conflicting
+ *                key with another local identity for which advertising is already started.
  */
 int bt_le_adv_start(const struct bt_le_adv_param *param,
 		    const struct bt_data *ad, size_t ad_len,
@@ -1422,6 +1426,12 @@ struct bt_le_ext_adv_start_param {
  *
  * @param adv    Advertising set object.
  * @param param  Advertise start parameters.
+ *
+ * @return Zero on success or (negative) error code otherwise.
+ * @return -EPERM When @kconfig{CONFIG_BT_PRIVACY} and
+ *                @kconfig{CONFIG_BT_ID_AUTO_SWAP_MATCHING_BONDS} are enabled and connectable
+ *                advertising is requested, and the given local identity has a conflicting
+ *                key with another local identity for which advertising is already started.
  */
 int bt_le_ext_adv_start(struct bt_le_ext_adv *adv,
 			const struct bt_le_ext_adv_start_param *param);

subsys/bluetooth/host/Kconfig

@@ -659,6 +659,24 @@ config BT_ID_UNPAIR_MATCHING_BONDS
 	  link-layer. The Host does not have control over this acknowledgment,
 	  and the order of distribution is fixed by the specification.
 
+config BT_ID_AUTO_SWAP_MATCHING_BONDS
+	bool "Automatically swap conflicting entries in the Resolving List"
+	depends on !BT_ID_UNPAIR_MATCHING_BONDS
+	depends on BT_SMP && BT_PERIPHERAL && !BT_CENTRAL
+	help
+	  If this option is enabled, the Host will not add a new bond with
+	  the same peer address (or IRK) to the Resolving List if there is
+	  already a bond with the same peer address (or IRK) on another local
+	  identity.
+
+	  In case of Peripheral, the Host will swap the existing entry in the
+	  Resolving List with the new one, so that the new bond will be used for
+	  address resolution for the new local identity if the device starts
+	  advertising with the new local identity.
+
+	  Important: this option is supported exclusively in the Peripheral
+	  role. Excluding the Central role.
+
 config BT_ID_ALLOW_UNAUTH_OVERWRITE
 	bool "Allow unauthenticated pairing with same peer with other local identity"
 	depends on !BT_SMP_ALLOW_UNAUTH_OVERWRITE

subsys/bluetooth/host/adv.c

@@ -234,6 +234,25 @@ struct bt_le_ext_adv *bt_hci_adv_lookup_handle(uint8_t handle)
 #endif /* CONFIG_BT_BROADCASTER */
 #endif /* defined(CONFIG_BT_EXT_ADV) */
 
+struct bt_le_ext_adv *bt_adv_lookup_by_id(uint8_t id)
+{
+#if defined(CONFIG_BT_EXT_ADV)
+	for (size_t i = 0; i < ARRAY_SIZE(adv_pool); i++) {
+		if (atomic_test_bit(adv_pool[i].flags, BT_ADV_CREATED) &&
+		    adv_pool[i].id == id) {
+			return &adv_pool[i];
+		}
+	}
+#else
+	if (atomic_test_bit(bt_dev.adv.flags, BT_ADV_CREATED) && bt_dev.adv.id == id) {
+		return &bt_dev.adv;
+	}
+#endif
+
+	return NULL;
+}
+
+
 void bt_le_ext_adv_foreach(void (*func)(struct bt_le_ext_adv *adv, void *data),
 			   void *data)
 {
@@ -929,6 +948,14 @@ static int adv_start_legacy(struct bt_le_ext_adv *adv,
 	adv->id = param->id;
 	bt_dev.adv_conn_id = adv->id;
 
+	if (IS_ENABLED(CONFIG_BT_ID_AUTO_SWAP_MATCHING_BONDS)) {
+		err = bt_id_resolving_list_check_and_update(adv->id, param->peer);
+		if (err) {
+			LOG_ERR("Failed to check and update resolving list: %d", err);
+			return err;
+		}
+	}
+
 	err = bt_id_set_adv_own_addr(adv, param->options, dir_adv,
 				     &set_param.own_addr_type);
 	if (err) {
@@ -1212,6 +1239,15 @@ int bt_le_adv_start_ext(struct bt_le_ext_adv *adv,
 	}
 
 	adv->id = param->id;
+
+	if (IS_ENABLED(CONFIG_BT_ID_AUTO_SWAP_MATCHING_BONDS)) {
+		err = bt_id_resolving_list_check_and_update(adv->id, param->peer);
+		if (err) {
+			LOG_ERR("Failed to check and update resolving list: %d", err);
+			return err;
+		}
+	}
+
 	err = le_ext_adv_param_set(adv, param, sd != NULL);
 	if (err) {
 		return err;
@@ -1499,6 +1535,22 @@ int bt_le_ext_adv_start(struct bt_le_ext_adv *adv,
 		return -EALREADY;
 	}
 
+	if (IS_ENABLED(CONFIG_BT_ID_AUTO_SWAP_MATCHING_BONDS)) {
+		const bt_addr_le_t *peer;
+
+		if (bt_addr_le_eq(&adv->target_addr, BT_ADDR_LE_ANY)) {
+			peer = NULL;
+		} else {
+			peer = &adv->target_addr;
+		}
+
+		err = bt_id_resolving_list_check_and_update(adv->id, peer);
+		if (err) {
+			LOG_ERR("Failed to check and update resolving list: %d", err);
+			return err;
+		}
+	}
+
 	if (IS_ENABLED(CONFIG_BT_PERIPHERAL) &&
 	    atomic_test_bit(adv->flags, BT_ADV_CONNECTABLE)) {
 		err = le_adv_start_add_conn(adv, &conn);

subsys/bluetooth/host/adv.h

@@ -23,3 +23,4 @@ int bt_le_adv_set_enable_ext(struct bt_le_ext_adv *adv,
 int bt_le_adv_set_enable_legacy(struct bt_le_ext_adv *adv, bool enable);
 int bt_le_lim_adv_cancel_timeout(struct bt_le_ext_adv *adv);
 void bt_adv_reset_adv_pool(void);
+struct bt_le_ext_adv *bt_adv_lookup_by_id(uint8_t id);

subsys/bluetooth/host/hci_core.h

@@ -497,7 +497,28 @@ struct bt_keys;
 void bt_id_add(struct bt_keys *keys);
 void bt_id_del(struct bt_keys *keys);
 
-struct bt_keys *bt_id_find_conflict(struct bt_keys *candidate);
+/** @brief Find a conflict in the resolving list for a candidate IRK.
+ *
+ * @param candidate The candidate keys to check for conflicts.
+ * @param all If true, check all IRKs, otherwise check only added keys.
+ *
+ * @return The conflicting key if there is one, or NULL if no conflict was found.
+ */
+struct bt_keys *bt_id_find_conflict(struct bt_keys *candidate, bool all);
+
+/** * @brief Find multiple conflicts in the resolving list for a candidate IRK.
+ *
+ * This function iterates over all keys (added and not added to the Resolving List). If there are
+ * multiple conflicts, this function will return true. Otherwise, it will return false.
+ *
+ * If @c firt_conflict is not NULL, it will be set to the first found conflict.
+ *
+ * @param candidate The candidate key to check for conflicts.
+ * @param first_conflict Pointer to store the first found conflict, if any. Can be NULL.
+ *
+ * @return True if there are multiple conflicts, otherwise it returns false.
+ */
+bool bt_id_find_conflict_multiple(struct bt_keys *candidate, struct bt_keys **first_conflict);
 
 int bt_setup_random_id_addr(void);
 int bt_setup_public_id_addr(void);