tests/bsim/bluetooth/host/privacy/device/src/test_undirected_central.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2023 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>

 #include <zephyr/kernel.h>

 #include <zephyr/sys/printk.h>

 #include <zephyr/bluetooth/conn.h>
 #include <zephyr/bluetooth/bluetooth.h>

 #include <zephyr/logging/log.h>
 LOG_MODULE_DECLARE(bt_bsim_privacy, LOG_LEVEL_INF);

 #include "bs_types.h"
 #include "bs_tracing.h"
 #include "bstests.h"
 #include "bs_cmd_line.h"

 #define CREATE_FLAG(flag) static atomic_t flag = (atomic_t) false
 #define SET_FLAG(flag)	  (void)atomic_set(&flag, (atomic_t) true)
 #define GET_FLAG(flag)	  (bool)atomic_get(&flag)
 #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 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)

 extern enum bst_result_t bst_result;

 CREATE_FLAG(paired);
 CREATE_FLAG(rpa_tested);
 CREATE_FLAG(identity_tested);

 static void start_scan(void);

 static struct bt_conn *default_conn;

 static bt_addr_le_t peer_rpa;
 static bt_addr_le_t peer_identity;

 enum addr_type_t {
 	RPA,
 	IDENTITY_ADDR,
 };
 static enum addr_type_t test_addr_type;

 static bool use_active_scan;
 static bool connection_test;

 static int sim_id;

 void central_test_args_parse(int argc, char *argv[])
 {
 	char *addr_type_arg = NULL;

 	bs_args_struct_t args_struct[] = {
 		{
 			.dest = &sim_id,
 			.type = 'i',
 			.name = "{positive integer}",
 			.option = "sim-id",
 			.descript = "Simulation ID counter",
 		},
 		{
 			.dest = &addr_type_arg,
 			.type = 's',
 			.name = "{identity, rpa}",
 			.option = "addr-type",
 			.descript = "Address type to test",
 		},
 		{
 			.dest = &use_active_scan,
 			.type = 'b',
 			.name = "{0, 1}",
 			.option = "active-scan",
 			.descript = "",
 		},
 		{
 			.dest = &connection_test,
 			.type = 'b',
 			.name = "{0, 1}",
 			.option = "connection-test",
 			.descript = "",
 		},
 	};

 	bs_args_parse_all_cmd_line(argc, argv, args_struct);

 	if (addr_type_arg != NULL) {
 		if (!strcmp(addr_type_arg, "identity")) {
 			test_addr_type = IDENTITY_ADDR;
 		} else if (!strcmp(addr_type_arg, "rpa")) {
 			test_addr_type = RPA;
 		}
 	}
 }

 static void wait_check_result(void)
 {
 	if (test_addr_type == IDENTITY_ADDR) {
 		WAIT_FOR_FLAG(identity_tested);
 		LOG_INF("Identity address tested");
 	} else if (test_addr_type == RPA) {
 		WAIT_FOR_FLAG(rpa_tested);
 		LOG_INF("Resolvable Private Address tested");
 	}
 }

 static void check_addresses(const bt_addr_le_t *peer_addr)
 {
 	LOG_DBG("Check addresses");

 	bool addr_equal;

 	if (test_addr_type == IDENTITY_ADDR) {
 		SET_FLAG(identity_tested);
 		addr_equal = bt_addr_le_eq(&peer_identity, peer_addr);
 		if (!addr_equal) {
 			FAIL("The peer address is not the same as the peer previously paired.\n");
 		}
 	} else if (test_addr_type == RPA) {
 		SET_FLAG(rpa_tested);
 		addr_equal = bt_addr_le_eq(&peer_identity, peer_addr);
 		if (!addr_equal) {
 			FAIL("The resolved address is not the same as the peer previously "
 			     "paired.\n");
 		}
 	}
 }


 static void scan_recv(const struct bt_le_scan_recv_info *info,
 		      struct net_buf_simple *ad)
 {
 	char addr_str[BT_ADDR_LE_STR_LEN];
 	int err;

 	if (default_conn) {
 		return;
 	}

 	bt_addr_le_to_str(info->addr, addr_str, sizeof(addr_str));
 	LOG_INF("Device found: %s (RSSI %d)", addr_str, info->rssi);

 	/* In the case of extended advertising and active scanning, this
 	 * callback will be called twice: once for the AUX_ADV_IND and
 	 * another time for the AUX_SCAN_RSP.
 	 *
 	 * We have to be careful not to stop the scanner before we have gotten
 	 * the second one, as the peripheral side waits until it gets an
 	 * AUX_SCAN_REQ to end the test.
 	 *
 	 * There is a catch though, since we have to bond, in order to exchange
 	 * the address resolving keys, then this check should only apply after
 	 * the pairing is done.
 	 */
 	if (GET_FLAG(paired) &&
 	    info->adv_props == (BT_GAP_ADV_PROP_EXT_ADV | BT_GAP_ADV_PROP_SCANNABLE)) {
 		LOG_DBG("skipping AUX_ADV_IND report, waiting for AUX_SCAN_REQ "
 			"(props: 0x%x)", info->adv_props);
 		return;
 	}

 	if (GET_FLAG(paired)) {
 		check_addresses(info->addr);
 	}

 	if (connection_test || !GET_FLAG(paired)) {
 		if (bt_le_scan_stop()) {
 			LOG_DBG("Failed to stop scanner");
 			return;
 		}
 		LOG_DBG("Scanner stopped: conn %d paired %d", connection_test, GET_FLAG(paired));

 		err = bt_conn_le_create(info->addr,
 					BT_CONN_LE_CREATE_CONN,
 					BT_LE_CONN_PARAM_DEFAULT,
 					&default_conn);
 		if (err) {
 			LOG_DBG("Create conn to %s failed (%u)", addr_str, err);
 			start_scan();
 		}
 	}
 }

 static struct bt_le_scan_cb scan_cb = {
 	.recv = scan_recv,
 };

 static void start_scan(void)
 {
 	int err;

 	LOG_DBG("Using %s scan", use_active_scan ? "active" : "passive");

 	err = bt_le_scan_start(use_active_scan ? BT_LE_SCAN_ACTIVE : BT_LE_SCAN_PASSIVE,
 			       NULL);

 	if (err) {
 		FAIL("Scanning failed to start (err %d)\n", err);
 	}

 	LOG_DBG("Scanning successfully started");
 }

 static void connected(struct bt_conn *conn, uint8_t err)
 {
 	char addr[BT_ADDR_LE_STR_LEN];

 	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

 	LOG_DBG("Connected: %s", addr);
 }

 static void disconnected(struct bt_conn *conn, uint8_t reason)
 {
 	char addr[BT_ADDR_LE_STR_LEN];

 	if (conn != default_conn) {
 		return;
 	}

 	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

 	LOG_DBG("Disconnected: %s (reason 0x%02x)", addr, reason);

 	bt_conn_unref(default_conn);
 	default_conn = NULL;

 	start_scan();
 }

 static void identity_resolved(struct bt_conn *conn, const bt_addr_le_t *rpa,
 			      const bt_addr_le_t *identity)
 {
 	char addr_identity[BT_ADDR_LE_STR_LEN];
 	char addr_rpa[BT_ADDR_LE_STR_LEN];

 	bt_addr_le_to_str(identity, addr_identity, sizeof(addr_identity));
 	bt_addr_le_to_str(rpa, addr_rpa, sizeof(addr_rpa));

 	LOG_DBG("Identity resolved %s -> %s", addr_rpa, addr_identity);

 	bt_addr_le_copy(&peer_rpa, rpa);
 	bt_addr_le_copy(&peer_identity, identity);

 	SET_FLAG(paired);
 }

 static struct bt_conn_cb central_cb;

 void test_central(void)
 {
 	int err;

 	LOG_DBG("Central device");

 	central_cb.connected = connected;
 	central_cb.disconnected = disconnected;
 	central_cb.identity_resolved = identity_resolved;

 	bt_conn_cb_register(&central_cb);
 	bt_le_scan_cb_register(&scan_cb);

 	err = bt_enable(NULL);
 	if (err) {
 		FAIL("Bluetooth init failed (err %d)\n", err);
 	}

 	UNSET_FLAG(identity_tested);
 	UNSET_FLAG(rpa_tested);

 	start_scan();

 	wait_check_result();
 }

 void test_central_main(void)
 {
 	char *addr_tested = "";

 	if (test_addr_type == RPA) {
 		addr_tested = "RPA";
 	} else if (test_addr_type == IDENTITY_ADDR) {
 		addr_tested = "identity address";
 	}

 	LOG_INF("Central test START (id: %d: params: %s scan, %sconnectable test, testing %s)\n",
 		sim_id, use_active_scan ? "active" : "passive", connection_test ? "" : "non-",
 		addr_tested);

 	test_central();

 	PASS("passed\n");
 }
	/*
	* Copyright (c) 2023 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <stddef.h>
	#include <stdint.h>
	#include <string.h>

	#include <zephyr/kernel.h>

	#include <zephyr/sys/printk.h>

	#include <zephyr/bluetooth/conn.h>
	#include <zephyr/bluetooth/bluetooth.h>

	#include <zephyr/logging/log.h>
	LOG_MODULE_DECLARE(bt_bsim_privacy, LOG_LEVEL_INF);

	#include "bs_types.h"
	#include "bs_tracing.h"
	#include "bstests.h"
	#include "bs_cmd_line.h"

	#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t) false
	#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) true)
	#define GET_FLAG(flag) (bool)atomic_get(&flag)
	#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 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)

	extern enum bst_result_t bst_result;

	CREATE_FLAG(paired);
	CREATE_FLAG(rpa_tested);
	CREATE_FLAG(identity_tested);

	static void start_scan(void);

	static struct bt_conn *default_conn;

	static bt_addr_le_t peer_rpa;
	static bt_addr_le_t peer_identity;

	enum addr_type_t {
	RPA,
	IDENTITY_ADDR,
	};
	static enum addr_type_t test_addr_type;

	static bool use_active_scan;
	static bool connection_test;

	static int sim_id;

	void central_test_args_parse(int argc, char *argv[])
	{
	char *addr_type_arg = NULL;

	bs_args_struct_t args_struct[] = {
	{
	.dest = &sim_id,
	.type = 'i',
	.name = "{positive integer}",
	.option = "sim-id",
	.descript = "Simulation ID counter",
	},
	{
	.dest = &addr_type_arg,
	.type = 's',
	.name = "{identity, rpa}",
	.option = "addr-type",
	.descript = "Address type to test",
	},
	{
	.dest = &use_active_scan,
	.type = 'b',
	.name = "{0, 1}",
	.option = "active-scan",
	.descript = "",
	},
	{
	.dest = &connection_test,
	.type = 'b',
	.name = "{0, 1}",
	.option = "connection-test",
	.descript = "",
	},
	};

	bs_args_parse_all_cmd_line(argc, argv, args_struct);

	if (addr_type_arg != NULL) {
	if (!strcmp(addr_type_arg, "identity")) {
	test_addr_type = IDENTITY_ADDR;
	} else if (!strcmp(addr_type_arg, "rpa")) {
	test_addr_type = RPA;
	}
	}
	}

	static void wait_check_result(void)
	{
	if (test_addr_type == IDENTITY_ADDR) {
	WAIT_FOR_FLAG(identity_tested);
	LOG_INF("Identity address tested");
	} else if (test_addr_type == RPA) {
	WAIT_FOR_FLAG(rpa_tested);
	LOG_INF("Resolvable Private Address tested");
	}
	}

	static void check_addresses(const bt_addr_le_t *peer_addr)
	{
	LOG_DBG("Check addresses");

	bool addr_equal;

	if (test_addr_type == IDENTITY_ADDR) {
	SET_FLAG(identity_tested);
	addr_equal = bt_addr_le_eq(&peer_identity, peer_addr);
	if (!addr_equal) {
	FAIL("The peer address is not the same as the peer previously paired.\n");
	}
	} else if (test_addr_type == RPA) {
	SET_FLAG(rpa_tested);
	addr_equal = bt_addr_le_eq(&peer_identity, peer_addr);
	if (!addr_equal) {
	FAIL("The resolved address is not the same as the peer previously "
	"paired.\n");
	}
	}
	}



	static void scan_recv(const struct bt_le_scan_recv_info *info,
	struct net_buf_simple *ad)
	{
	char addr_str[BT_ADDR_LE_STR_LEN];
	int err;

	if (default_conn) {
	return;
	}

	bt_addr_le_to_str(info->addr, addr_str, sizeof(addr_str));
	LOG_INF("Device found: %s (RSSI %d)", addr_str, info->rssi);

	/* In the case of extended advertising and active scanning, this
	* callback will be called twice: once for the AUX_ADV_IND and
	* another time for the AUX_SCAN_RSP.
	*
	* We have to be careful not to stop the scanner before we have gotten
	* the second one, as the peripheral side waits until it gets an
	* AUX_SCAN_REQ to end the test.
	*
	* There is a catch though, since we have to bond, in order to exchange
	* the address resolving keys, then this check should only apply after
	* the pairing is done.
	*/
	if (GET_FLAG(paired) &&
	info->adv_props == (BT_GAP_ADV_PROP_EXT_ADV \| BT_GAP_ADV_PROP_SCANNABLE)) {
	LOG_DBG("skipping AUX_ADV_IND report, waiting for AUX_SCAN_REQ "
	"(props: 0x%x)", info->adv_props);
	return;
	}

	if (GET_FLAG(paired)) {
	check_addresses(info->addr);
	}

	if (connection_test \|\| !GET_FLAG(paired)) {
	if (bt_le_scan_stop()) {
	LOG_DBG("Failed to stop scanner");
	return;
	}
	LOG_DBG("Scanner stopped: conn %d paired %d", connection_test, GET_FLAG(paired));

	err = bt_conn_le_create(info->addr,
	BT_CONN_LE_CREATE_CONN,
	BT_LE_CONN_PARAM_DEFAULT,
	&default_conn);
	if (err) {
	LOG_DBG("Create conn to %s failed (%u)", addr_str, err);
	start_scan();
	}
	}
	}

	static struct bt_le_scan_cb scan_cb = {
	.recv = scan_recv,
	};

	static void start_scan(void)
	{
	int err;

	LOG_DBG("Using %s scan", use_active_scan ? "active" : "passive");

	err = bt_le_scan_start(use_active_scan ? BT_LE_SCAN_ACTIVE : BT_LE_SCAN_PASSIVE,
	NULL);

	if (err) {
	FAIL("Scanning failed to start (err %d)\n", err);
	}

	LOG_DBG("Scanning successfully started");
	}

	static void connected(struct bt_conn *conn, uint8_t err)
	{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_DBG("Connected: %s", addr);
	}

	static void disconnected(struct bt_conn *conn, uint8_t reason)
	{
	char addr[BT_ADDR_LE_STR_LEN];

	if (conn != default_conn) {
	return;
	}

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_DBG("Disconnected: %s (reason 0x%02x)", addr, reason);

	bt_conn_unref(default_conn);
	default_conn = NULL;

	start_scan();
	}

	static void identity_resolved(struct bt_conn conn, const bt_addr_le_t rpa,
	const bt_addr_le_t *identity)
	{
	char addr_identity[BT_ADDR_LE_STR_LEN];
	char addr_rpa[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(identity, addr_identity, sizeof(addr_identity));
	bt_addr_le_to_str(rpa, addr_rpa, sizeof(addr_rpa));

	LOG_DBG("Identity resolved %s -> %s", addr_rpa, addr_identity);

	bt_addr_le_copy(&peer_rpa, rpa);
	bt_addr_le_copy(&peer_identity, identity);

	SET_FLAG(paired);
	}

	static struct bt_conn_cb central_cb;

	void test_central(void)
	{
	int err;

	LOG_DBG("Central device");

	central_cb.connected = connected;
	central_cb.disconnected = disconnected;
	central_cb.identity_resolved = identity_resolved;

	bt_conn_cb_register(&central_cb);
	bt_le_scan_cb_register(&scan_cb);

	err = bt_enable(NULL);
	if (err) {
	FAIL("Bluetooth init failed (err %d)\n", err);
	}

	UNSET_FLAG(identity_tested);
	UNSET_FLAG(rpa_tested);

	start_scan();

	wait_check_result();
	}

	void test_central_main(void)
	{
	char *addr_tested = "";

	if (test_addr_type == RPA) {
	addr_tested = "RPA";
	} else if (test_addr_type == IDENTITY_ADDR) {
	addr_tested = "identity address";
	}

	LOG_INF("Central test START (id: %d: params: %s scan, %sconnectable test, testing %s)\n",
	sim_id, use_active_scan ? "active" : "passive", connection_test ? "" : "non-",
	addr_tested);

	test_central();

	PASS("passed\n");
	}