bluetooth: tests: Add bsim test for setting bondable flag per-conn

Added test for the bt_conn_set_bondable API function.
Check if we can pair without setting the bonding flag on the
per-connection basis if the device was already bonded on the
other identity.

Signed-off-by: Mateusz Kapala <mateusz.kapala@nordicsemi.no>

tests/bsim/bluetooth/host/compile.sh

@@ -65,6 +65,7 @@ app=tests/bsim/bluetooth/host/privacy/legacy compile
 
 app=tests/bsim/bluetooth/host/security/bond_overwrite_allowed compile
 app=tests/bsim/bluetooth/host/security/bond_overwrite_denied compile
+app=tests/bsim/bluetooth/host/security/bond_per_connection compile
 app=tests/bsim/bluetooth/host/security/ccc_update compile
 app=tests/bsim/bluetooth/host/security/ccc_update conf_file=prj_2.conf compile
 

tests/bsim/bluetooth/host/security/bond_per_connection/CMakeLists.txt

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(bsim_test_multi_id_bond_per_connection)
+
+target_sources(app PRIVATE
+ src/bs_bt_utils.c
+ src/central.c
+ src/main.c
+ src/peripheral.c
+)
+
+zephyr_include_directories(
+ ${BSIM_COMPONENTS_PATH}/libUtilv1/src/
+ ${BSIM_COMPONENTS_PATH}/libPhyComv1/src/
+ )

tests/bsim/bluetooth/host/security/bond_per_connection/prj.conf

@@ -0,0 +1,17 @@
+CONFIG_BT=y
+CONFIG_BT_PERIPHERAL=y
+CONFIG_BT_CENTRAL=y
+
+CONFIG_BT_SMP=y
+
+CONFIG_ASSERT=y
+CONFIG_BT_TESTING=y
+CONFIG_LOG=y
+
+CONFIG_BT_ID_MAX=3
+CONFIG_BT_MAX_PAIRED=2
+CONFIG_BT_MAX_CONN=1
+
+CONFIG_BT_PRIVACY=y
+
+CONFIG_BT_BONDABLE_PER_CONNECTION=y

tests/bsim/bluetooth/host/security/bond_per_connection/src/bs_bt_utils.c

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "bs_bt_utils.h"
+
+BUILD_ASSERT(CONFIG_BT_MAX_PAIRED >= 2, "CONFIG_BT_MAX_PAIRED is too small.");
+BUILD_ASSERT(CONFIG_BT_ID_MAX >= 3, "CONFIG_BT_ID_MAX is too small.");
+
+#define BS_SECONDS(dur_sec) ((bs_time_t)dur_sec * 1000000)
+#define TEST_TIMEOUT_SIMULATED BS_SECONDS(60)
+
+void test_tick(bs_time_t HW_device_time)
+{
+ bs_trace_debug_time(0, "Simulation ends now.\n");
+ if (bst_result != Passed) {
+ bst_result = Failed;
+ bs_trace_error("Test did not pass before simulation ended.\n");
+ }
+}
+
+void test_init(void)
+{
+ bst_ticker_set_next_tick_absolute(TEST_TIMEOUT_SIMULATED);
+ bst_result = In_progress;
+}
+
+DEFINE_FLAG(flag_is_connected);
+struct bt_conn *g_conn;
+DEFINE_FLAG(bondable);
+DEFINE_FLAG(call_bt_conn_set_bondable);
+
+void wait_connected(void)
+{
+ WAIT_FOR_FLAG(flag_is_connected);
+}
+
+void wait_disconnected(void)
+{
+ WAIT_FOR_FLAG_UNSET(flag_is_connected);
+}
+
+static void disconnected(struct bt_conn *conn, uint8_t reason)
+{
+ UNSET_FLAG(flag_is_connected);
+}
+
+BUILD_ASSERT(CONFIG_BT_MAX_CONN == 1, "This test assumes a single link.");
+static void connected(struct bt_conn *conn, uint8_t err)
+{
+ ASSERT((!g_conn || (conn == g_conn)), "Unexpected new connection.");
+
+ if (!g_conn) {
+ g_conn = bt_conn_ref(conn);
+ }
+
+ if (err != 0) {
+ clear_g_conn();
+ return;
+ }
+
+ SET_FLAG(flag_is_connected);
+
+ if (GET_FLAG(call_bt_conn_set_bondable) && bt_conn_set_bondable(conn, GET_FLAG(bondable))) {
+ ASSERT(0, "Fail during setting bondable flag for given connection.");
+ }
+}
+
+BT_CONN_CB_DEFINE(conn_callbacks) = {
+ .connected = connected,
+ .disconnected = disconnected,
+};
+
+void clear_g_conn(void)
+{
+ struct bt_conn *conn;
+
+ conn = g_conn;
+ g_conn = NULL;
+ ASSERT(conn, "Test error: No g_conn!\n");
+ bt_conn_unref(conn);
+}
+
+/* The following flags are raised by events and lowered by test code. */
+DEFINE_FLAG(flag_pairing_complete);
+DEFINE_FLAG(flag_bonded);
+DEFINE_FLAG(flag_not_bonded);
+
+static void pairing_complete(struct bt_conn *conn, bool bonded)
+{
+ SET_FLAG(flag_pairing_complete);
+
+ if (bonded) {
+ SET_FLAG(flag_bonded);
+ } else {
+ SET_FLAG(flag_not_bonded);
+ }
+}
+
+static struct bt_conn_auth_info_cb bt_conn_auth_info_cb = {
+ .pairing_complete = pairing_complete,
+};
+
+void bs_bt_utils_setup(void)
+{
+ int err;
+
+ err = bt_enable(NULL);
+ ASSERT(!err, "bt_enable failed.\n");
+ err = bt_conn_auth_info_cb_register(&bt_conn_auth_info_cb);
+ ASSERT(!err, "bt_conn_auth_info_cb_register failed.\n");
+}
+
+static void scan_connect_to_first_result__device_found(const bt_addr_le_t *addr, int8_t rssi,
+ uint8_t type, struct net_buf_simple *ad)
+{
+ char addr_str[BT_ADDR_LE_STR_LEN];
+ int err;
+
+ if (g_conn != NULL) {
+ return;
+ }
+
+ /* We're only interested in connectable events */
+ if (type != BT_HCI_ADV_IND && type != BT_HCI_ADV_DIRECT_IND) {
+ FAIL("Unexpected advertisement type.");
+ }
+
+ bt_addr_le_to_str(addr, addr_str, sizeof(addr_str));
+ printk("Got scan result, connecting.. dst %s, RSSI %d\n", addr_str, rssi);
+
+ err = bt_le_scan_stop();
+ ASSERT(!err, "Err bt_le_scan_stop %d", err);
+
+ err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, BT_LE_CONN_PARAM_DEFAULT, &g_conn);
+ ASSERT(!err, "Err bt_conn_le_create %d", err);
+}
+
+void scan_connect_to_first_result(void)
+{
+ int err;
+
+ err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, scan_connect_to_first_result__device_found);
+ ASSERT(!err, "Err bt_le_scan_start %d", err);
+}
+
+void disconnect(void)
+{
+ int err;
+
+ err = bt_conn_disconnect(g_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
+ ASSERT(!err, "Err bt_conn_disconnect %d", err);
+}
+
+void unpair(int id)
+{
+ int err;
+
+ err = bt_unpair(id, BT_ADDR_LE_ANY);
+ ASSERT(!err, "Err bt_unpair %d", err);
+}
+
+void set_security(bt_security_t sec)
+{
+ int err;
+
+ err = bt_conn_set_security(g_conn, sec);
+ ASSERT(!err, "Err bt_conn_set_security %d", err);
+}
+
+void advertise_connectable(int id, bt_addr_le_t *directed_dst)
+{
+ int err;
+ struct bt_le_adv_param param = {};
+
+ param.id = id;
+ param.interval_min = 0x0020;
+ param.interval_max = 0x4000;
+ param.options |= BT_LE_ADV_OPT_ONE_TIME;
+ param.options |= BT_LE_ADV_OPT_CONNECTABLE;
+
+ if (directed_dst) {
+ param.options |= BT_LE_ADV_OPT_DIR_ADDR_RPA;
+ param.peer = directed_dst;
+ }
+
+ err = bt_le_adv_start(&param, NULL, 0, NULL, 0);
+ ASSERT(err == 0, "Advertising failed to start (err %d)\n", err);
+}
+
+void set_bondable(bool enable)
+{
+ if (enable) {
+ SET_FLAG(bondable);
+ } else {
+ UNSET_FLAG(bondable);
+ }
+}
+
+void enable_bt_conn_set_bondable(bool enable)
+{
+ if (enable) {
+ SET_FLAG(call_bt_conn_set_bondable);
+ } else {
+ UNSET_FLAG(call_bt_conn_set_bondable);
+ }
+}

tests/bsim/bluetooth/host/security/bond_per_connection/src/bs_bt_utils.h

@@ -0,0 +1,85 @@
+/**
+ * Common functions and helpers for BSIM GATT tests
+ *
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "bs_tracing.h"
+#include "bs_types.h"
+#include "bstests.h"
+#include "time_machine.h"
+#include "zephyr/sys/__assert.h"
+
+#include <errno.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <zephyr/bluetooth/bluetooth.h>
+#include <zephyr/bluetooth/conn.h>
+#include <zephyr/bluetooth/gatt.h>
+#include <zephyr/bluetooth/hci.h>
+#include <zephyr/bluetooth/uuid.h>
+#include <zephyr/kernel.h>
+#include <zephyr/types.h>
+
+extern enum bst_result_t bst_result;
+
+#define DECLARE_FLAG(flag) extern atomic_t flag
+#define DEFINE_FLAG(flag) atomic_t flag = (atomic_t) false
+#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) true)
+#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) false)
+#define WAIT_FOR_FLAG(flag) \
+ while (!(bool)atomic_get(&flag)) { \
+ (void)k_sleep(K_MSEC(1)); \
+ }
+#define WAIT_FOR_FLAG_UNSET(flag) \
+ while ((bool)atomic_get(&flag)) { \
+ (void)k_sleep(K_MSEC(1)); \
+ }
+#define TAKE_FLAG(flag) \
+ while (!(bool)atomic_cas(&flag, true, false)) { \
+ (void)k_sleep(K_MSEC(1)); \
+ }
+#define GET_FLAG(flag) \
+ (bool)atomic_get(&flag)
+
+#define ASSERT(expr, ...) \
+ do { \
+ if (!(expr)) { \
+ FAIL(__VA_ARGS__); \
+ } \
+ } while (0)
+
+#define FAIL(...) \
+ do { \
+ bst_result = Failed; \
+ bs_trace_error_time_line(__VA_ARGS__); \
+ } while (0)
+
+#define PASS(...) \
+ do { \
+ bst_result = Passed; \
+ bs_trace_info_time(1, __VA_ARGS__); \
+ } while (0)
+
+void test_tick(bs_time_t HW_device_time);
+void test_init(void);
+
+DECLARE_FLAG(flag_pairing_complete);
+DECLARE_FLAG(flag_bonded);
+DECLARE_FLAG(flag_not_bonded);
+
+extern struct bt_conn *g_conn;
+void wait_connected(void);
+void wait_disconnected(void);
+void clear_g_conn(void);
+void bs_bt_utils_setup(void);
+void scan_connect_to_first_result(void);
+void disconnect(void);
+void unpair(int id);
+void set_security(bt_security_t sec);
+void advertise_connectable(int id, bt_addr_le_t *directed_dst);
+void set_bondable(bool enable);
+void enable_bt_conn_set_bondable(bool enable);

tests/bsim/bluetooth/host/security/bond_per_connection/src/central.c

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "bs_bt_utils.h"
+#include "zephyr/bluetooth/addr.h"
+#include "zephyr/bluetooth/conn.h"
+
+#include <stdint.h>
+
+#include <zephyr/bluetooth/bluetooth.h>
+
+void central(void)
+{
+ bs_bt_utils_setup();
+
+ printk("== Bonding id a - global bondable mode ==\n");
+ BUILD_ASSERT(CONFIG_BT_BONDABLE, "CONFIG_BT_BONDABLE must be enabled by default.");
+ enable_bt_conn_set_bondable(false);
+ scan_connect_to_first_result();
+ wait_connected();
+ set_security(BT_SECURITY_L2);
+ TAKE_FLAG(flag_pairing_complete);
+ TAKE_FLAG(flag_bonded);
+ disconnect();
+ wait_disconnected();
+ unpair(BT_ID_DEFAULT);
+ clear_g_conn();
+
+ printk("== Bonding id a - bond per-connection ==\n");
+ enable_bt_conn_set_bondable(true);
+ set_bondable(true);
+ scan_connect_to_first_result();
+ wait_connected();
+ set_security(BT_SECURITY_L2);
+ TAKE_FLAG(flag_pairing_complete);
+ TAKE_FLAG(flag_bonded);
+ disconnect();
+ wait_disconnected();
+ clear_g_conn();
+
+ printk("== Bonding id b - bond per-connection ==\n");
+ scan_connect_to_first_result();
+ wait_connected();
+ set_security(BT_SECURITY_L2);
+ TAKE_FLAG(flag_pairing_complete);
+ TAKE_FLAG(flag_not_bonded);
+ disconnect();
+ wait_disconnected();
+ clear_g_conn();
+
+ PASS("PASS\n");
+}