[nrf fromtree] bluetooth: tbs: Fix GTBS call handling and add (G)TBS bearer registration

Replaces the previous static bearer registration with a dynamic
runtime registration flow driven by Auto-PTS. This allows the
tester to create GTBS and TBS instances at runtime with complete
metadata in the correct registration orders.

Signed-off-by: Alex Ciascai <ciascai.alexandru@gmail.com>
(cherry picked from commit d1f1173)

Author: ciascai

tests/bluetooth/tester/src/audio/btp/btp_tbs.h

@@ -80,3 +80,18 @@ struct btp_tbs_set_signal_strength_cmd {
 struct btp_tbs_terminate_call_cmd {
 	uint8_t index;
 } __packed;
+
+#define BTP_TBS_REGISTER_BEARER		0x0c
+struct btp_tbs_register_bearer_cmd {
+	uint8_t gtbs;
+	uint8_t technology;
+	uint16_t optional_opcodes;
+	uint8_t provider_name_len;
+	uint8_t uci_len;
+	uint8_t uri_scheme_list_len;
+	uint8_t strings[]; /* provider_name, uci, uri_scheme_list packed in order */
+} __packed;
+
+struct btp_tbs_register_bearer_rp {
+	uint8_t index;
+} __packed;

tests/bluetooth/tester/src/audio/btp_ccp.c

@@ -31,6 +31,7 @@ struct bt_tbs_instance *tbs_inst;
 static uint8_t call_index;
 static uint8_t inst_ccid;
 static bool send_ev;
+static uint8_t tbs_register_bearer(const void *cmd, uint16_t cmd_len, void *rsp, uint16_t *rsp_len);
 
 static uint8_t ccp_supported_commands(const void *cmd, uint16_t cmd_len,
 				      void *rsp, uint16_t *rsp_len)
@@ -1092,6 +1093,11 @@ static struct bt_tbs_cb tbs_cbs = {
 };
 
 static const struct btp_handler tbs_handlers[] = {
+	{
+		.opcode = BTP_TBS_REGISTER_BEARER,
+		.expect_len = BTP_HANDLER_LENGTH_VARIABLE,
+		.func = tbs_register_bearer,
+	},
 	{
 		.opcode = BTP_TBS_READ_SUPPORTED_COMMANDS,
 		.index = BTP_INDEX_NONE,
@@ -1152,50 +1158,89 @@ static const struct btp_handler tbs_handlers[] = {
 
 uint8_t tester_init_tbs(void)
 {
-	const struct bt_tbs_register_param gtbs_param = {
-		.provider_name = "Generic TBS",
-		.uci = "un000",
-		.uri_schemes_supported = "tel,skype",
-		.gtbs = true,
-		.authorization_required = false,
-		.technology = BT_TBS_TECHNOLOGY_3G,
-		.supported_features = CONFIG_BT_TBS_SUPPORTED_FEATURES,
-	};
-	const struct bt_tbs_register_param tbs_param = {
-		.provider_name = "TBS",
-		.uci = "un000",
-		.uri_schemes_supported = "tel,skype",
-		.gtbs = false,
-		.authorization_required = false,
-		/* Set different technologies per bearer */
-		.technology = BT_TBS_TECHNOLOGY_4G,
-		.supported_features = CONFIG_BT_TBS_SUPPORTED_FEATURES,
-	};
-	int err;
-
 	bt_tbs_register_cb(&tbs_cbs);
 
 	tester_register_command_handlers(BTP_SERVICE_ID_TBS, tbs_handlers,
 					 ARRAY_SIZE(tbs_handlers));
 
-	err = bt_tbs_register_bearer(&gtbs_param);
-	if (err < 0) {
-		LOG_DBG("Failed to register GTBS: %d", err);
+	return BTP_STATUS_SUCCESS;
+}
 
+uint8_t tester_unregister_tbs(void)
+{
+	return BTP_STATUS_SUCCESS;
+}
+
+static uint8_t tbs_register_bearer(const void *cmd, uint16_t cmd_len, void *rsp, uint16_t *rsp_len)
+{
+	const struct btp_tbs_register_bearer_cmd *cp = cmd;
+	const uint8_t *strings = cp->strings;
+	struct btp_tbs_register_bearer_rp *rp = rsp;
+	char provider_name[CONFIG_BT_TBS_MAX_PROVIDER_NAME_LENGTH + 1];
+	char uci[BT_TBS_MAX_UCI_SIZE];
+	char uri_scheme_list[CONFIG_BT_TBS_MAX_URI_LENGTH + 1];
+
+	if (cmd_len < sizeof(*cp)) {
+		LOG_DBG("Packet too short: %u", cmd_len);
 		return BTP_STATUS_FAILED;
 	}
 
-	err = bt_tbs_register_bearer(&tbs_param);
-	if (err < 0) {
-		LOG_DBG("Failed to register TBS: %d", err);
+	if (cmd_len != sizeof(*cp) + cp->provider_name_len +
+	    cp->uci_len + cp->uri_scheme_list_len) {
+		LOG_DBG("Invalid length: %u", cmd_len);
+		return BTP_STATUS_FAILED;
+	}
 
+	if (cp->provider_name_len >= sizeof(provider_name)) {
+		LOG_DBG("Buffer overflow risk: provider_name_len=%u (max=%d)",
+			cp->provider_name_len, CONFIG_BT_TBS_MAX_PROVIDER_NAME_LENGTH);
 		return BTP_STATUS_FAILED;
 	}
 
-	return BTP_STATUS_SUCCESS;
-}
+	if (cp->uci_len >= sizeof(uci)) {
+		LOG_DBG("Buffer overflow risk: uci_len=%u (max=%u)",
+			cp->uci_len, BT_TBS_MAX_UCI_SIZE - 1U);
+		return BTP_STATUS_FAILED;
+	}
+
+	if (cp->uri_scheme_list_len >= sizeof(uri_scheme_list)) {
+		LOG_DBG("Buffer overflow risk: uri_scheme_list_len=%u (max=%d)",
+			cp->uri_scheme_list_len, CONFIG_BT_TBS_MAX_URI_LENGTH);
+		return BTP_STATUS_FAILED;
+	}
+
+	/* Extract provider_name */
+	(void)memcpy(provider_name, strings, cp->provider_name_len);
+	provider_name[cp->provider_name_len] = '\0';
+
+	/* Extract uci */
+	(void)memcpy(uci, strings + cp->provider_name_len, cp->uci_len);
+	uci[cp->uci_len] = '\0';
+
+	/* Extract uri_scheme_list */
+	(void)memcpy(uri_scheme_list,
+		     strings + cp->provider_name_len + cp->uci_len,
+		     cp->uri_scheme_list_len);
+	uri_scheme_list[cp->uri_scheme_list_len] = '\0';
+
+	struct bt_tbs_register_param param = {
+		.provider_name = provider_name,
+		.uci = uci,
+		.uri_schemes_supported = uri_scheme_list,
+		.gtbs = cp->gtbs == 1U ? true : false,
+		.technology = cp->technology,
+		.supported_features  = sys_le16_to_cpu(cp->optional_opcodes),
+	};
+
+	int index = bt_tbs_register_bearer(&param);
+
+	if (index < 0) {
+		return BTP_STATUS_FAILED;
+	}
+
+	/* Return the assigned index in the response */
+	rp->index = (uint8_t)index;
+	*rsp_len = sizeof(*rp);
 
-uint8_t tester_unregister_tbs(void)
-{
 	return BTP_STATUS_SUCCESS;
 }

tests/bsim/bluetooth/tester/src/audio/ccp_peripheral.c

@@ -32,6 +32,11 @@ static void test_ccp_peripheral(void)
 	bsim_btp_core_register(BTP_SERVICE_ID_GAP);
 	bsim_btp_core_register(BTP_SERVICE_ID_TBS);
 
+	bsim_btp_tbs_register_bearer(true, BT_TBS_TECHNOLOGY_3G, BT_TBS_FEATURE_ALL,
+				     "GTBS Provider", "un000", "tel");
+	bsim_btp_tbs_register_bearer(false, BT_TBS_TECHNOLOGY_3G, BT_TBS_FEATURE_ALL,
+				     "TBS Provider", "un000", "tel");
+
 	bsim_btp_gap_set_discoverable(BTP_GAP_GENERAL_DISCOVERABLE);
 	bsim_btp_gap_start_advertising(0U, 0U, NULL, BT_HCI_OWN_ADDR_PUBLIC);
 	bsim_btp_wait_for_gap_device_connected(&remote_addr);

tests/bsim/bluetooth/tester/src/bsim_btp.c

@@ -1670,6 +1670,8 @@ static bool is_valid_tbs_packet_len(const struct btp_hdr *hdr, struct net_buf_si
 		return buf_simple->len == 0U;
 	case BTP_TBS_SET_SIGNAL_STRENGTH:
 		return buf_simple->len == 0U;
+	case BTP_TBS_REGISTER_BEARER:
+		return buf_simple->len == sizeof(struct btp_tbs_register_bearer_rp);
 
 	/* No events */
 	default:

tests/bsim/bluetooth/tester/src/bsim_btp.h

@@ -1092,6 +1092,38 @@ static inline void bsim_btp_wait_for_mcp_cmd_ntf(uint8_t *requested_opcode)
 	net_buf_unref(buf);
 }
 
+static inline void bsim_btp_tbs_register_bearer(
+	bool gtbs, uint8_t technology,
+	uint16_t optional_opcodes,
+	const char *provider_name,
+	const char *uci,
+	const char *uri_scheme_list)
+{
+	struct btp_tbs_register_bearer_cmd *cmd;
+	struct btp_hdr *cmd_hdr;
+
+	NET_BUF_SIMPLE_DEFINE(cmd_buffer, BTP_MTU);
+
+	cmd_hdr = net_buf_simple_add(&cmd_buffer, sizeof(*cmd_hdr));
+	cmd_hdr->service = BTP_SERVICE_ID_TBS;
+	cmd_hdr->opcode = BTP_TBS_REGISTER_BEARER;
+	cmd_hdr->index = BTP_INDEX;
+	cmd = net_buf_simple_add(&cmd_buffer, sizeof(*cmd));
+	cmd->gtbs = gtbs ? 1U : 0U;
+	cmd->technology = technology;
+	cmd->optional_opcodes = sys_cpu_to_le16(optional_opcodes);
+	cmd->provider_name_len = strlen(provider_name);
+	cmd->uci_len = strlen(uci);
+	cmd->uri_scheme_list_len = strlen(uri_scheme_list);
+	net_buf_simple_add_mem(&cmd_buffer, provider_name, cmd->provider_name_len);
+	net_buf_simple_add_mem(&cmd_buffer, uci, cmd->uci_len);
+	net_buf_simple_add_mem(&cmd_buffer, uri_scheme_list, cmd->uri_scheme_list_len);
+
+	cmd_hdr->len = sys_cpu_to_le16(cmd_buffer.len - sizeof(*cmd_hdr));
+
+	bsim_btp_send_to_tester(cmd_buffer.data, cmd_buffer.len);
+}
+
 static inline void bsim_btp_tmap_discover(const bt_addr_le_t *address)
 {
 	struct btp_tmap_discover_cmd *cmd;