diff --git a/apps/bttester/src/btp/btp.h b/apps/bttester/src/btp/btp.h index 3cf172f9b..996ab7912 100644 --- a/apps/bttester/src/btp/btp.h +++ b/apps/bttester/src/btp/btp.h @@ -44,6 +44,7 @@ #define BTP_DATA_MAX_SIZE (BTP_MTU - sizeof(struct btp_hdr)) #define BTP_INDEX_NONE 0xff +#define BTP_INDEX 0x00 #define BTP_SERVICE_ID_CORE 0 #define BTP_SERVICE_ID_GAP 1 @@ -52,11 +53,18 @@ #define BTP_SERVICE_ID_MESH 4 #define BTP_SERVICE_ID_GATTC 6 +#define BTP_SERVICE_ID_MAX BTP_SERVICE_ID_GATTC + #define BTP_STATUS_SUCCESS 0x00 #define BTP_STATUS_FAILED 0x01 #define BTP_STATUS_UNKNOWN_CMD 0x02 #define BTP_STATUS_NOT_READY 0x03 +/* TODO indicate delay response, should be removed when all commands are + * converted to cmd+status+ev pattern + */ +#define BTP_STATUS_DELAY_REPLY 0xFF + #define SYS_LOG_DBG(fmt, ...) \ if (MYNEWT_VAL(BTTESTER_DEBUG)) { \ console_printf("[DBG] %s: " fmt "\n", \ diff --git a/apps/bttester/src/btp/btp_gap.h b/apps/bttester/src/btp/btp_gap.h index 4a24df678..5ef756113 100644 --- a/apps/bttester/src/btp/btp_gap.h +++ b/apps/bttester/src/btp/btp_gap.h @@ -121,6 +121,12 @@ struct btp_gap_start_advertising_cmd { uint8_t scan_rsp_len; uint8_t adv_data[0]; uint8_t scan_rsp[0]; +/* + * This command is very unfortunate because it has two fields after variable + * data. Those needs to be handled explicitly by handler. + * uint32_t duration; + * uint8_t own_addr_type; + */ } __packed; struct btp_gap_start_advertising_rp { uint32_t current_settings; @@ -148,6 +154,7 @@ struct btp_gap_start_discovery_cmd { struct btp_gap_connect_cmd { uint8_t address_type; uint8_t address[6]; + uint8_t own_addr_type; } __packed; #define BTP_GAP_DISCONNECT 0x0f diff --git a/apps/bttester/src/btp/bttester.h b/apps/bttester/src/btp/bttester.h index 06ea5833e..e13400ae9 100644 --- a/apps/bttester/src/btp/bttester.h +++ b/apps/bttester/src/btp/bttester.h @@ -36,6 +36,7 @@ #else #include "glue.h" #endif +#include static inline void tester_set_bit(uint8_t *addr, unsigned int bit) @@ -57,10 +58,21 @@ tester_test_bit(const uint8_t *addr, unsigned int bit) void tester_init(void); void -tester_rsp(uint8_t service, uint8_t opcode, uint8_t index, uint8_t status); +tester_rsp(uint8_t service, uint8_t opcode, uint8_t status); void -tester_send(uint8_t service, uint8_t opcode, uint8_t index, uint8_t *data, - size_t len); +tester_send(uint8_t service, uint8_t opcode, uint8_t *data, size_t len); + +struct btp_handler { + uint8_t opcode; + uint8_t index; + ssize_t expect_len; + uint8_t (*func)(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len); +}; + +void tester_register_command_handlers(uint8_t service, + const struct btp_handler *handlers, + size_t num); void tester_send_buf(uint8_t service, uint8_t opcode, uint8_t index, struct os_mbuf *buf); @@ -70,20 +82,16 @@ tester_init_gap(void); uint8_t tester_unregister_gap(void); void -tester_handle_gap(uint8_t opcode, uint8_t index, uint8_t *data, - uint16_t len); -void -tester_handle_core(uint8_t opcode, uint8_t index, uint8_t *data, - uint16_t len); +tester_init_core(void); uint8_t tester_init_gatt(void); uint8_t tester_unregister_gatt(void); void -tester_handle_gatt(uint8_t opcode, uint8_t index, uint8_t *data, +tester_handle_gatt(uint8_t opcode, uint8_t *data, uint16_t len); void -tester_handle_gattc(uint8_t opcode, uint8_t index, uint8_t *data, +tester_handle_gattc(uint8_t opcode, uint8_t *data, uint16_t len); int tester_gattc_notify_rx_ev(uint16_t conn_handle, uint16_t attr_handle, @@ -103,7 +111,7 @@ tester_init_l2cap(void); uint8_t tester_unregister_l2cap(void); void -tester_handle_l2cap(uint8_t opcode, uint8_t index, uint8_t *data, +tester_handle_l2cap(uint8_t opcode, uint8_t *data, uint16_t len); #endif @@ -113,7 +121,7 @@ tester_init_mesh(void); uint8_t tester_unregister_mesh(void); void -tester_handle_mesh(uint8_t opcode, uint8_t index, uint8_t *data, uint16_t len); +tester_handle_mesh(uint8_t opcode, uint8_t *data, uint16_t len); #endif /* MYNEWT_VAL(BLE_MESH) */ void diff --git a/apps/bttester/src/btp_core.c b/apps/bttester/src/btp_core.c index afcac7c52..4aee11d34 100644 --- a/apps/bttester/src/btp_core.c +++ b/apps/bttester/src/btp_core.c @@ -26,71 +26,80 @@ */ #include "btp/btp.h" +#include "atomic.h" -static void -supported_commands(uint8_t *data, uint16_t len) +static ATOMIC_DEFINE(registered_services, BTP_SERVICE_ID_MAX); + +static uint8_t +supported_commands(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t buf[1]; - struct core_read_supported_commands_rp *rp = (void *) buf; + struct btp_core_read_supported_commands_rp *rp = rsp; - memset(buf, 0, sizeof(buf)); + tester_set_bit(rp->data, BTP_CORE_READ_SUPPORTED_COMMANDS); + tester_set_bit(rp->data, BTP_CORE_READ_SUPPORTED_SERVICES); + tester_set_bit(rp->data, BTP_CORE_REGISTER_SERVICE); + tester_set_bit(rp->data, BTP_CORE_UNREGISTER_SERVICE); - tester_set_bit(buf, BTP_CORE_READ_SUPPORTED_COMMANDS); - tester_set_bit(buf, BTP_CORE_READ_SUPPORTED_SERVICES); - tester_set_bit(buf, BTP_CORE_REGISTER_SERVICE); - tester_set_bit(buf, BTP_CORE_UNREGISTER_SERVICE); + *rsp_len = sizeof(*rp) + 1; - tester_send(BTP_SERVICE_ID_CORE, BTP_CORE_READ_SUPPORTED_COMMANDS, - BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf)); + return BTP_STATUS_SUCCESS; } -static void -supported_services(uint8_t *data, uint16_t len) +static uint8_t +supported_services(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t buf[1]; - struct core_read_supported_services_rp *rp = (void *) buf; + struct btp_core_read_supported_services_rp *rp = rsp; - memset(buf, 0, sizeof(buf)); - - tester_set_bit(buf, BTP_SERVICE_ID_CORE); - tester_set_bit(buf, BTP_SERVICE_ID_GAP); - tester_set_bit(buf, BTP_SERVICE_ID_GATT); + /* octet 0 */ + tester_set_bit(rp->data, BTP_SERVICE_ID_CORE); + tester_set_bit(rp->data, BTP_SERVICE_ID_GAP); + tester_set_bit(rp->data, BTP_SERVICE_ID_GATT); #if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) - tester_set_bit(buf, BTP_SERVICE_ID_L2CAP); + tester_set_bit(rp->data, BTP_SERVICE_ID_L2CAP); #endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */ #if MYNEWT_VAL(BLE_MESH) - tester_set_bit(buf, BTP_SERVICE_ID_MESH); + tester_set_bit(rp->data, BTP_SERVICE_ID_MESH); #endif /* MYNEWT_VAL(BLE_MESH) */ - tester_set_bit(buf, BTP_SERVICE_ID_GATTC); + tester_set_bit(rp->data, BTP_SERVICE_ID_GATTC); - tester_send(BTP_SERVICE_ID_CORE, BTP_CORE_READ_SUPPORTED_SERVICES, - BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf)); + *rsp_len = sizeof(*rp) + 2; + + return BTP_STATUS_SUCCESS; } -static void -register_service(uint8_t *data, uint16_t len) +static uint8_t +register_service(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - struct core_register_service_cmd *cmd = (void *) data; + const struct btp_core_register_service_cmd *cp = cmd; uint8_t status; - switch (cmd->id) { + /* invalid service */ + if ((cp->id == BTP_SERVICE_ID_CORE) || (cp->id > BTP_SERVICE_ID_MAX)) { + return BTP_STATUS_FAILED; + } + + /* already registered */ + if (atomic_test_bit(registered_services, cp->id)) { + return BTP_STATUS_FAILED; + } + + switch (cp->id) { case BTP_SERVICE_ID_GAP: status = tester_init_gap(); - /* Rsp with success status will be handled by bt enable cb */ - if (status == BTP_STATUS_FAILED) { - goto rsp; - } - return; + break; case BTP_SERVICE_ID_GATT: status = tester_init_gatt(); break; #if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) - case BTP_SERVICE_ID_L2CAP: + case BTP_SERVICE_ID_L2CAP: status = tester_init_l2cap(); break; #endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */ #if MYNEWT_VAL(BLE_MESH) - case BTP_SERVICE_ID_MESH: + case BTP_SERVICE_ID_MESH: status = tester_init_mesh(); break; #endif /* MYNEWT_VAL(BLE_MESH) */ @@ -99,18 +108,31 @@ register_service(uint8_t *data, uint16_t len) break; } -rsp: - tester_rsp(BTP_SERVICE_ID_CORE, BTP_CORE_REGISTER_SERVICE, BTP_INDEX_NONE, - status); + if (status == BTP_STATUS_SUCCESS) { + atomic_set_bit(registered_services, cp->id); + } + + return status; } -static void -unregister_service(uint8_t *data, uint16_t len) +static uint8_t +unregister_service(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - struct core_unregister_service_cmd *cmd = (void *) data; + const struct btp_core_unregister_service_cmd *cp = cmd; uint8_t status; - switch (cmd->id) { + /* invalid service ID */ + if ((cp->id == BTP_SERVICE_ID_CORE) || (cp->id > BTP_SERVICE_ID_MAX)) { + return BTP_STATUS_FAILED; + } + + /* not registered */ + if (!atomic_test_bit(registered_services, cp->id)) { + return BTP_STATUS_FAILED; + } + + switch (cp->id) { case BTP_SERVICE_ID_GAP: status = tester_unregister_gap(); break; @@ -118,12 +140,12 @@ unregister_service(uint8_t *data, uint16_t len) status = tester_unregister_gatt(); break; #if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) - case BTP_SERVICE_ID_L2CAP: + case BTP_SERVICE_ID_L2CAP: status = tester_unregister_l2cap(); break; #endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */ #if MYNEWT_VAL(BLE_MESH) - case BTP_SERVICE_ID_MESH: + case BTP_SERVICE_ID_MESH: status = tester_unregister_mesh(); break; #endif /* MYNEWT_VAL(BLE_MESH) */ @@ -132,36 +154,44 @@ unregister_service(uint8_t *data, uint16_t len) break; } - tester_rsp(BTP_SERVICE_ID_CORE, BTP_CORE_UNREGISTER_SERVICE, BTP_INDEX_NONE, - status); + if (status == BTP_STATUS_SUCCESS) { + atomic_clear_bit(registered_services, cp->id); + } + + return status; } +static const struct btp_handler handlers[] = { + { + .opcode = BTP_CORE_READ_SUPPORTED_COMMANDS, + .index = BTP_INDEX_NONE, + .expect_len = 0, + .func = supported_commands, + }, + { + .opcode = BTP_CORE_READ_SUPPORTED_SERVICES, + .index = BTP_INDEX_NONE, + .expect_len = 0, + .func = supported_services, + }, + { + .opcode = BTP_CORE_REGISTER_SERVICE, + .index = BTP_INDEX_NONE, + .expect_len = sizeof(struct btp_core_register_service_cmd), + .func = register_service, + }, + { + .opcode = BTP_CORE_UNREGISTER_SERVICE, + .index = BTP_INDEX_NONE, + .expect_len = sizeof(struct btp_core_unregister_service_cmd), + .func = unregister_service, + }, +}; + void -tester_handle_core(uint8_t opcode, uint8_t index, uint8_t *data, - uint16_t len) +tester_init_core(void) { - if (index != BTP_INDEX_NONE) { - tester_rsp(BTP_SERVICE_ID_CORE, opcode, index, - BTP_STATUS_FAILED); - return; - } - - switch (opcode) { - case BTP_CORE_READ_SUPPORTED_COMMANDS: - supported_commands(data, len); - return; - case BTP_CORE_READ_SUPPORTED_SERVICES: - supported_services(data, len); - return; - case BTP_CORE_REGISTER_SERVICE: - register_service(data, len); - return; - case BTP_CORE_UNREGISTER_SERVICE: - unregister_service(data, len); - return; - default: - tester_rsp(BTP_SERVICE_ID_CORE, opcode, BTP_INDEX_NONE, - BTP_STATUS_UNKNOWN_CMD); - return; - } + tester_register_command_handlers(BTP_SERVICE_ID_CORE, handlers, + ARRAY_SIZE(handlers)); + atomic_set_bit(registered_services, BTP_SERVICE_ID_CORE); } diff --git a/apps/bttester/src/btp_gap.c b/apps/bttester/src/btp_gap.c index 24f7f82dc..66b88a680 100644 --- a/apps/bttester/src/btp_gap.c +++ b/apps/bttester/src/btp_gap.c @@ -85,9 +85,6 @@ static const struct ble_gap_conn_params dflt_conn_params = { .max_ce_len = 0x0300, }; -static void -conn_param_update(struct os_event *ev); - static int gap_conn_find_by_addr(const ble_addr_t *dev_addr, struct ble_gap_conn_desc *out_desc) @@ -121,66 +118,70 @@ gap_conn_find_by_addr(const ble_addr_t *dev_addr, static int gap_event_cb(struct ble_gap_event *event, void *arg); -static void -supported_commands(uint8_t *data, uint16_t len) +static uint8_t +supported_commands(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t cmds[3]; - struct btp_gap_read_supported_commands_rp *rp = (void *) &cmds; + struct btp_gap_read_supported_commands_rp *rp = rsp; - SYS_LOG_DBG(""); + /* octet 0 */ + tester_set_bit(rp->data, BTP_GAP_READ_SUPPORTED_COMMANDS); + tester_set_bit(rp->data, BTP_GAP_READ_CONTROLLER_INDEX_LIST); + tester_set_bit(rp->data, BTP_GAP_READ_CONTROLLER_INFO); + tester_set_bit(rp->data, BTP_GAP_SET_CONNECTABLE); - memset(cmds, 0, sizeof(cmds)); + /* octet 1 */ + tester_set_bit(rp->data, BTP_GAP_SET_DISCOVERABLE); + tester_set_bit(rp->data, BTP_GAP_SET_BONDABLE); + tester_set_bit(rp->data, BTP_GAP_START_ADVERTISING); + tester_set_bit(rp->data, BTP_GAP_STOP_ADVERTISING); + tester_set_bit(rp->data, BTP_GAP_START_DISCOVERY); + tester_set_bit(rp->data, BTP_GAP_STOP_DISCOVERY); + tester_set_bit(rp->data, BTP_GAP_CONNECT); + tester_set_bit(rp->data, BTP_GAP_DISCONNECT); - tester_set_bit(cmds, BTP_GAP_READ_SUPPORTED_COMMANDS); - tester_set_bit(cmds, BTP_GAP_READ_CONTROLLER_INDEX_LIST); - tester_set_bit(cmds, BTP_GAP_READ_CONTROLLER_INFO); - tester_set_bit(cmds, BTP_GAP_SET_CONNECTABLE); - tester_set_bit(cmds, BTP_GAP_SET_DISCOVERABLE); - tester_set_bit(cmds, BTP_GAP_SET_BONDABLE); - tester_set_bit(cmds, BTP_GAP_START_ADVERTISING); - tester_set_bit(cmds, BTP_GAP_STOP_ADVERTISING); - tester_set_bit(cmds, BTP_GAP_START_DISCOVERY); - tester_set_bit(cmds, BTP_GAP_STOP_DISCOVERY); - tester_set_bit(cmds, BTP_GAP_CONNECT); - tester_set_bit(cmds, BTP_GAP_DISCONNECT); - tester_set_bit(cmds, BTP_GAP_SET_IO_CAP); - tester_set_bit(cmds, BTP_GAP_PAIR); - tester_set_bit(cmds, BTP_GAP_UNPAIR); - tester_set_bit(cmds, BTP_GAP_PASSKEY_ENTRY); - tester_set_bit(cmds, BTP_GAP_PASSKEY_CONFIRM); - tester_set_bit(cmds, BTP_GAP_START_DIRECT_ADV); - tester_set_bit(cmds, BTP_GAP_CONN_PARAM_UPDATE); - tester_set_bit(cmds, BTP_GAP_OOB_LEGACY_SET_DATA); - tester_set_bit(cmds, BTP_GAP_OOB_SC_GET_LOCAL_DATA); - tester_set_bit(cmds, BTP_GAP_OOB_SC_SET_REMOTE_DATA); - tester_set_bit(cmds, BTP_GAP_SET_MITM); + /* octet 2 */ + tester_set_bit(rp->data, BTP_GAP_SET_IO_CAP); + tester_set_bit(rp->data, BTP_GAP_PAIR); + tester_set_bit(rp->data, BTP_GAP_UNPAIR); + tester_set_bit(rp->data, BTP_GAP_PASSKEY_ENTRY); + tester_set_bit(rp->data, BTP_GAP_PASSKEY_CONFIRM); + tester_set_bit(rp->data, BTP_GAP_START_DIRECT_ADV); + tester_set_bit(rp->data, BTP_GAP_CONN_PARAM_UPDATE); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_READ_SUPPORTED_COMMANDS, - CONTROLLER_INDEX, (uint8_t *) rp, sizeof(cmds)); + /* octet 3 */ + tester_set_bit(rp->data, BTP_GAP_OOB_LEGACY_SET_DATA); + tester_set_bit(rp->data, BTP_GAP_OOB_SC_GET_LOCAL_DATA); + tester_set_bit(rp->data, BTP_GAP_OOB_SC_SET_REMOTE_DATA); + tester_set_bit(rp->data, BTP_GAP_SET_MITM); + + *rsp_len = sizeof(*rp) + 4; + + return BTP_STATUS_SUCCESS; } -static void -controller_index_list(uint8_t *data, uint16_t len) +static uint8_t +controller_index_list(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - struct btp_gap_read_controller_index_list_rp *rp; - uint8_t buf[sizeof(*rp) + 1]; + struct btp_gap_read_controller_index_list_rp *rp = rsp; SYS_LOG_DBG(""); - rp = (void *) buf; - rp->num = 1; rp->index[0] = CONTROLLER_INDEX; - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_READ_CONTROLLER_INDEX_LIST, - BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf)); + *rsp_len = sizeof(*rp) + 1; + + return BTP_STATUS_SUCCESS; } -static void -controller_info(uint8_t *data, uint16_t len) +static uint8_t +controller_info(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - struct btp_gap_read_controller_info_rp rp; - uint32_t supported_settings = 0; + struct btp_gap_read_controller_info_rp *rp = rsp; + uint32_t supported_settings = 0; ble_addr_t addr; int rc; @@ -189,8 +190,6 @@ controller_info(uint8_t *data, uint16_t len) rc = ble_hs_pvcy_set_our_irk(irk); assert(rc == 0); - memset(&rp, 0, sizeof(rp)); - /* Make sure we have proper identity address set (public preferred) */ rc = ble_hs_util_ensure_addr(1); assert(rc == 0); @@ -209,12 +208,12 @@ controller_info(uint8_t *data, uint16_t len) } current_settings |= BIT(BTP_GAP_SETTINGS_PRIVACY); supported_settings |= BIT(BTP_GAP_SETTINGS_PRIVACY); - memcpy(rp.address, addr.val, sizeof(rp.address)); + memcpy(rp->address, addr.val, sizeof(rp->address)); } else { - rc = ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, rp.address, NULL); + rc = ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, rp->address, NULL); if (rc) { own_addr_type = BLE_OWN_ADDR_RANDOM; - memcpy(rp.address, addr.val, sizeof(rp.address)); + memcpy(rp->address, addr.val, sizeof(rp->address)); supported_settings |= BIT(BTP_GAP_SETTINGS_STATIC_ADDRESS); current_settings |= BIT(BTP_GAP_SETTINGS_STATIC_ADDRESS); } else { @@ -236,13 +235,14 @@ controller_info(uint8_t *data, uint16_t len) current_settings |= BIT(BTP_GAP_SETTINGS_SC); } - rp.supported_settings = sys_cpu_to_le32(supported_settings); - rp.current_settings = sys_cpu_to_le32(current_settings); + rp->supported_settings = sys_cpu_to_le32(supported_settings); + rp->current_settings = sys_cpu_to_le32(current_settings); - memcpy(rp.name, CONTROLLER_NAME, sizeof(CONTROLLER_NAME)); + memcpy(rp->name, CONTROLLER_NAME, sizeof(CONTROLLER_NAME)); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_READ_CONTROLLER_INFO, - CONTROLLER_INDEX, (uint8_t *) &rp, sizeof(rp)); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } static struct ble_gap_adv_params adv_params = { @@ -282,15 +282,16 @@ static void rotate_nrpa_cb(struct os_event *ev) } #endif -static void -set_connectable(uint8_t *data, uint16_t len) +static uint8_t +set_connectable(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_set_connectable_cmd *cmd = (void *) data; - struct btp_gap_set_connectable_rp rp; + const struct btp_gap_set_connectable_cmd *cp = cmd; + struct btp_gap_set_connectable_rp *rp = rsp; SYS_LOG_DBG(""); - if (cmd->connectable) { + if (cp->connectable) { current_settings |= BIT(BTP_GAP_SETTINGS_CONNECTABLE); adv_params.conn_mode = BLE_GAP_CONN_MODE_UND; } else { @@ -298,23 +299,25 @@ set_connectable(uint8_t *data, uint16_t len) adv_params.conn_mode = BLE_GAP_CONN_MODE_NON; } - rp.current_settings = sys_cpu_to_le32(current_settings); + rp->current_settings = sys_cpu_to_le32(current_settings); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_SET_CONNECTABLE, CONTROLLER_INDEX, - (uint8_t *) &rp, sizeof(rp)); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } static uint8_t ad_flags = BLE_HS_ADV_F_BREDR_UNSUP; -static void -set_discoverable(uint8_t *data, uint16_t len) +static uint8_t +set_discoverable(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_set_discoverable_cmd *cmd = (void *) data; - struct btp_gap_set_discoverable_rp rp; + const struct btp_gap_set_discoverable_cmd *cp = cmd; + struct btp_gap_set_discoverable_rp *rp = rsp; SYS_LOG_DBG(""); - switch (cmd->discoverable) { + switch (cp->discoverable) { case BTP_GAP_NON_DISCOVERABLE: ad_flags &= ~(BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_DISC_LTD); adv_params.disc_mode = BLE_GAP_DISC_MODE_NON; @@ -333,36 +336,35 @@ set_discoverable(uint8_t *data, uint16_t len) current_settings |= BIT(BTP_GAP_SETTINGS_DISCOVERABLE); break; default: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_SET_DISCOVERABLE, - CONTROLLER_INDEX, BTP_STATUS_FAILED); - return; + return BTP_STATUS_FAILED; } - rp.current_settings = sys_cpu_to_le32(current_settings); + rp->current_settings = sys_cpu_to_le32(current_settings); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_SET_DISCOVERABLE, CONTROLLER_INDEX, - (uint8_t *) &rp, sizeof(rp)); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } -static void -set_bondable(const uint8_t *data, uint16_t len) +static uint8_t +set_bondable(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_set_bondable_cmd *cmd = (void *) data; - struct btp_gap_set_bondable_rp rp; + const struct btp_gap_set_bondable_cmd *cp = cmd; + struct btp_gap_set_bondable_rp *rp = rsp; - SYS_LOG_DBG(""); + SYS_LOG_DBG("bondable: %d", cp->bondable); - ble_hs_cfg.sm_bonding = cmd->bondable; + ble_hs_cfg.sm_bonding = cp->bondable; if (ble_hs_cfg.sm_bonding) { current_settings |= BIT(BTP_GAP_SETTINGS_BONDABLE); } else { current_settings &= ~BIT(BTP_GAP_SETTINGS_BONDABLE); } - rp.current_settings = sys_cpu_to_le32(current_settings); - - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_SET_BONDABLE, CONTROLLER_INDEX, - (uint8_t *) &rp, sizeof(rp)); + rp->current_settings = sys_cpu_to_le32(current_settings); + *rsp_len = sizeof(*rp); + return BTP_STATUS_SUCCESS; } static struct bt_data ad[10] = { @@ -371,70 +373,91 @@ static struct bt_data ad[10] = { static struct bt_data sd[10]; static int -set_ad(const struct bt_data *ad, size_t ad_len, +set_ad(const struct bt_data *ad_data, size_t ad_len, uint8_t *buf, uint8_t *buf_len) { int i; for (i = 0; i < ad_len; i++) { - buf[(*buf_len)++] = ad[i].data_len + 1; - buf[(*buf_len)++] = ad[i].type; + buf[(*buf_len)++] = ad_data[i].data_len + 1; + buf[(*buf_len)++] = ad_data[i].type; - memcpy(&buf[*buf_len], ad[i].data, - ad[i].data_len); - *buf_len += ad[i].data_len; + memcpy(&buf[*buf_len], ad_data[i].data, + ad_data[i].data_len); + *buf_len += ad_data[i].data_len; } return 0; } -static void -start_advertising(const uint8_t *data, uint16_t len) +static uint8_t +start_advertising(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_start_advertising_cmd *cmd = (void *) data; - struct btp_gap_start_advertising_rp rp; - int32_t duration_ms = BLE_HS_FOREVER; + const struct btp_gap_start_advertising_cmd *cp = cmd; + struct btp_gap_start_advertising_rp *rp = rsp; + int32_t duration_ms = BLE_HS_FOREVER; uint8_t buf[BLE_HS_ADV_MAX_SZ]; uint8_t buf_len = 0; uint8_t adv_len, sd_len; + uint8_t addr_type; + uint32_t duration; + int err; int i; SYS_LOG_DBG(""); - for (i = 0, adv_len = 1; i < cmd->adv_data_len; adv_len++) { + /* This command is very unfortunate since after variable data there is + * additional 5 bytes (4 bytes for duration, 1 byte for own address + * type. + */ + if ((cmd_len < sizeof(*cp)) || + (cmd_len != sizeof(*cp) + cp->adv_data_len + cp->scan_rsp_len + + sizeof(duration) + sizeof(own_addr_type))) { + return BTP_STATUS_FAILED; + } + + /* currently ignored */ + duration = get_le32(cp->adv_data + cp->adv_data_len + cp->scan_rsp_len); + (void)duration; + addr_type = cp->adv_data[cp->adv_data_len + + cp->scan_rsp_len + + sizeof(duration)]; + + for (i = 0, adv_len = 1U; i < cp->adv_data_len; adv_len++) { if (adv_len >= ARRAY_SIZE(ad)) { SYS_LOG_ERR("ad[] Out of memory"); - goto fail; + return BTP_STATUS_FAILED; } - ad[adv_len].type = cmd->adv_data[i++]; - ad[adv_len].data_len = cmd->adv_data[i++]; - ad[adv_len].data = &cmd->adv_data[i]; + ad[adv_len].type = cp->scan_rsp[i++]; + ad[adv_len].data_len = cp->scan_rsp[i++]; + ad[adv_len].data = &cp->scan_rsp[i]; i += ad[adv_len].data_len; } - for (i = 0, sd_len = 0; i < cmd->scan_rsp_len; sd_len++) { + for (sd_len = 0U; i < cp->scan_rsp_len; sd_len++) { if (sd_len >= ARRAY_SIZE(sd)) { SYS_LOG_ERR("sd[] Out of memory"); - goto fail; + return BTP_STATUS_FAILED; } - sd[sd_len].type = cmd->scan_rsp[i++]; - sd[sd_len].data_len = cmd->scan_rsp[i++]; - sd[sd_len].data = &cmd->scan_rsp[i]; + sd[sd_len].type = cp->scan_rsp[i++]; + sd[sd_len].data_len = cp->scan_rsp[i++]; + sd[sd_len].data = &cp->scan_rsp[i]; i += sd[sd_len].data_len; } err = set_ad(ad, adv_len, buf, &buf_len); if (err) { - goto fail; + return BTP_STATUS_FAILED; } err = ble_gap_adv_set_data(buf, buf_len); if (err != 0) { - goto fail; + return BTP_STATUS_FAILED; } if (sd_len) { @@ -443,13 +466,13 @@ start_advertising(const uint8_t *data, uint16_t len) err = set_ad(sd, sd_len, buf, &buf_len); if (err) { SYS_LOG_ERR("Advertising failed: err %d", err); - goto fail; + return BTP_STATUS_FAILED; } err = ble_gap_adv_rsp_set_data(buf, buf_len); if (err != 0) { SYS_LOG_ERR("Advertising failed: err %d", err); - goto fail; + return BTP_STATUS_FAILED; } } @@ -457,6 +480,30 @@ start_advertising(const uint8_t *data, uint16_t len) duration_ms = MYNEWT_VAL(BTTESTER_LTD_ADV_TIMEOUT); } + /* In NimBLE, own_addr_type is configured in `controller_info` function. + * Let's just verify restrictions for Privacy options. + */ + switch (addr_type) { + case 0x00: + break; +#if defined(CONFIG_BT_PRIVACY) + case 0x01: + /* RPA usage is is controlled via privacy settings */ + if (!atomic_test_bit(¤t_settings, BTP_GAP_SETTINGS_PRIVACY)) { + return BTP_STATUS_FAILED; + } + break; + case 0x02: + /* NRPA is used only for non-connectable advertising */ + if (atomic_test_bit(¤t_settings, BTP_GAP_SETTINGS_CONNECTABLE)) { + return BTP_STATUS_FAILED; + } + break; +#endif + default: + return BTP_STATUS_FAILED; + } + #if MYNEWT_VAL(BTTESTER_PRIVACY_MODE) && MYNEWT_VAL(BTTESTER_USE_NRPA) if (MYNEWT_VAL(BTTESTER_NRPA_TIMEOUT) < duration_ms / 1000) { advertising_start = os_get_uptime_usec(); @@ -468,38 +515,37 @@ start_advertising(const uint8_t *data, uint16_t len) &adv_params, gap_event_cb, NULL); if (err) { SYS_LOG_ERR("Advertising failed: err %d", err); - goto fail; + return BTP_STATUS_FAILED; } current_settings |= BIT(BTP_GAP_SETTINGS_ADVERTISING); - rp.current_settings = sys_cpu_to_le32(current_settings); + rp->current_settings = sys_cpu_to_le32(current_settings); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_START_ADVERTISING, CONTROLLER_INDEX, - (uint8_t *) &rp, sizeof(rp)); - return; -fail: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_START_ADVERTISING, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } -static void -stop_advertising(const uint8_t *data, uint16_t len) +static uint8_t +stop_advertising(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - struct btp_gap_stop_advertising_rp rp; + struct btp_gap_stop_advertising_rp *rp = rsp; + int err; SYS_LOG_DBG(""); - if (ble_gap_adv_stop() != 0) { - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_STOP_ADVERTISING, - CONTROLLER_INDEX, BTP_STATUS_FAILED); - return; + err = ble_gap_adv_stop(); + if (err != 0) { + return BTP_STATUS_FAILED; } current_settings &= ~BIT(BTP_GAP_SETTINGS_ADVERTISING); - rp.current_settings = sys_cpu_to_le32(current_settings); + rp->current_settings = sys_cpu_to_le32(current_settings); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_STOP_ADVERTISING, CONTROLLER_INDEX, - (uint8_t *) &rp, sizeof(rp)); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } static uint8_t @@ -557,7 +603,7 @@ device_found(ble_addr_t *addr, int8_t rssi, uint8_t evtype, const uint8_t *data, uint8_t len) { struct btp_gap_device_found_ev *ev; - ble_addr_t a; + ble_addr_t a; /* if General/Limited Discovery - parse Advertising data to get flags */ if (!(discovery_flags & BTP_GAP_DISCOVERY_FLAG_LE_OBSERVE) && @@ -614,8 +660,7 @@ device_found(ble_addr_t *addr, int8_t rssi, uint8_t evtype, */ if (adv_buf->om_len) { tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_DEVICE_FOUND, - CONTROLLER_INDEX, adv_buf->om_data, - adv_buf->om_len); + adv_buf->om_data, adv_buf->om_len); } store_adv(addr, rssi, data, len); @@ -629,7 +674,7 @@ device_found(ble_addr_t *addr, int8_t rssi, uint8_t evtype, } done: tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_DEVICE_FOUND, - CONTROLLER_INDEX, adv_buf->om_data, adv_buf->om_len); + adv_buf->om_data, adv_buf->om_len); } static int @@ -644,53 +689,46 @@ discovery_cb(struct ble_gap_event *event, void *arg) return 0; } -static void -start_discovery(const uint8_t *data, uint16_t len) +static uint8_t +start_discovery(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_start_discovery_cmd *cmd = (void *) data; - struct ble_gap_disc_params params = {0}; - uint8_t status; + const struct btp_gap_start_discovery_cmd *cp = cmd; + struct ble_gap_disc_params params = {0}; SYS_LOG_DBG(""); /* only LE scan is supported */ - if (cmd->flags & BTP_GAP_DISCOVERY_FLAG_BREDR) { - status = BTP_STATUS_FAILED; - goto reply; + if (cp->flags & BTP_GAP_DISCOVERY_FLAG_BREDR) { + return BTP_STATUS_FAILED; } - params.passive = (cmd->flags & BTP_GAP_DISCOVERY_FLAG_LE_ACTIVE_SCAN) == 0; - params.limited = (cmd->flags & BTP_GAP_DISCOVERY_FLAG_LIMITED) > 0; + params.passive = (cp->flags & BTP_GAP_DISCOVERY_FLAG_LE_ACTIVE_SCAN) == 0; + params.limited = (cp->flags & BTP_GAP_DISCOVERY_FLAG_LIMITED) > 0; params.filter_duplicates = 1; if (ble_gap_disc(own_addr_type, BLE_HS_FOREVER, ¶ms, discovery_cb, NULL) != 0) { - status = BTP_STATUS_FAILED; - goto reply; + return BTP_STATUS_FAILED; } net_buf_simple_init(adv_buf, 0); - discovery_flags = cmd->flags; + discovery_flags = cp->flags; - status = BTP_STATUS_SUCCESS; -reply: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_START_DISCOVERY, CONTROLLER_INDEX, - status); + return BTP_STATUS_SUCCESS; } -static void -stop_discovery(const uint8_t *data, uint16_t len) +static uint8_t +stop_discovery(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t status = BTP_STATUS_SUCCESS; - SYS_LOG_DBG(""); if (ble_gap_disc_cancel() != 0) { - status = BTP_STATUS_FAILED; + return BTP_STATUS_FAILED; } - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_STOP_DISCOVERY, CONTROLLER_INDEX, - status); + return BTP_STATUS_SUCCESS; } /* Bluetooth Core Spec v5.1 | Section 10.7.1 @@ -729,12 +767,12 @@ device_connected_ev_send(struct os_event *ev) rc = gap_conn_find_by_addr((ble_addr_t *) &connected_ev, &desc); if (rc) { tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_EV_DEVICE_CONNECTED, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); return; } tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_DEVICE_CONNECTED, - CONTROLLER_INDEX, (uint8_t *) &connected_ev, + (uint8_t *) &connected_ev, sizeof(connected_ev)); periph_privacy(desc); @@ -775,7 +813,7 @@ le_connected(uint16_t conn_handle, int status) CONNECTED_EV_DELAY_MS(desc.conn_itvl))); #else tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_DEVICE_CONNECTED, - CONTROLLER_INDEX, (uint8_t *) &connected_ev, + (uint8_t *) &connected_ev, sizeof(connected_ev)); #endif } @@ -784,7 +822,7 @@ static void le_disconnected(struct ble_gap_conn_desc *conn, int reason) { struct btp_gap_device_disconnected_ev ev; - ble_addr_t *addr = &conn->peer_ota_addr; + ble_addr_t *addr = &conn->peer_ota_addr; SYS_LOG_DBG(""); @@ -819,7 +857,7 @@ le_disconnected(struct ble_gap_conn_desc *conn, int reason) ev.address_type = addr->type; tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_DEVICE_DISCONNECTED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void @@ -846,9 +884,9 @@ auth_passkey_oob(uint16_t conn_handle) static void auth_passkey_display(uint16_t conn_handle, unsigned int passkey) { - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct btp_gap_passkey_display_ev ev; - ble_addr_t *addr; + ble_addr_t *addr; struct ble_sm_io pk; int rc; @@ -875,15 +913,15 @@ auth_passkey_display(uint16_t conn_handle, unsigned int passkey) ev.passkey = sys_cpu_to_le32(pk.passkey); tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_PASSKEY_DISPLAY, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void auth_passkey_entry(uint16_t conn_handle) { - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct btp_gap_passkey_entry_req_ev ev; - ble_addr_t *addr; + ble_addr_t *addr; int rc; SYS_LOG_DBG(""); @@ -899,15 +937,15 @@ auth_passkey_entry(uint16_t conn_handle) ev.address_type = addr->type; tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_PASSKEY_ENTRY_REQ, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void auth_passkey_numcmp(uint16_t conn_handle, unsigned int passkey) { - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct btp_gap_passkey_confirm_req_ev ev; - ble_addr_t *addr; + ble_addr_t *addr; int rc; SYS_LOG_DBG(""); @@ -924,7 +962,7 @@ auth_passkey_numcmp(uint16_t conn_handle, unsigned int passkey) ev.passkey = sys_cpu_to_le32(passkey); tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_PASSKEY_CONFIRM_REQ, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void @@ -984,9 +1022,9 @@ le_passkey_action(uint16_t conn_handle, static void le_identity_resolved(uint16_t conn_handle) { - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct btp_gap_identity_resolved_ev ev; - int rc; + int rc; SYS_LOG_DBG(""); @@ -1006,15 +1044,15 @@ le_identity_resolved(uint16_t conn_handle) sizeof(ev.identity_address)); tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_IDENTITY_RESOLVED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void le_pairing_failed(uint16_t conn_handle, int reason) { - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct btp_gap_sec_pairing_failed_ev ev; - int rc; + int rc; SYS_LOG_DBG(""); @@ -1032,7 +1070,7 @@ le_pairing_failed(uint16_t conn_handle, int reason) ev.reason = reason; tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_SEC_PAIRING_FAILED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void @@ -1050,7 +1088,7 @@ le_conn_param_update(struct ble_gap_conn_desc *desc) ev.supervision_timeout = desc->supervision_timeout; tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_CONN_PARAM_UPDATE, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void @@ -1079,14 +1117,14 @@ le_encryption_changed(struct ble_gap_conn_desc *desc) } tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_SEC_LEVEL_CHANGED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void bond_lost(uint16_t conn_handle) { struct btp_gap_bond_lost_ev ev; - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; int rc; rc = ble_gap_conn_find(conn_handle, &desc); @@ -1096,7 +1134,6 @@ bond_lost(uint16_t conn_handle) ev.address_type = desc.peer_id_addr.type; tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_BOND_LOST, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); } @@ -1171,7 +1208,7 @@ adv_complete(void) current_settings &= ~BIT(BTP_GAP_SETTINGS_ADVERTISING); ev.current_settings = sys_cpu_to_le32(current_settings); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_NEW_SETTINGS, CONTROLLER_INDEX, + tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_EV_NEW_SETTINGS, (uint8_t *) &ev, sizeof(ev)); } @@ -1355,11 +1392,13 @@ gap_event_cb(struct ble_gap_event *event, void *arg) return 0; } -static void -connect(const uint8_t *data, uint16_t len) +static uint8_t +connect(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t status = BTP_STATUS_SUCCESS; - ble_addr_t *addr = (ble_addr_t *) data; + const struct btp_gap_connect_cmd *cp = cmd; + + ble_addr_t *addr = (ble_addr_t *)&cp->address_type; SYS_LOG_DBG(""); @@ -1369,47 +1408,43 @@ connect(const uint8_t *data, uint16_t len) if (ble_gap_connect(own_addr_type, addr, 0, &dflt_conn_params, gap_event_cb, NULL)) { - status = BTP_STATUS_FAILED; + return BTP_STATUS_FAILED; } - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_CONNECT, CONTROLLER_INDEX, status); + return BTP_STATUS_SUCCESS; } -static void -disconnect(const uint8_t *data, uint16_t len) +static uint8_t +disconnect(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { + const struct btp_gap_disconnect_cmd *cp = cmd; struct ble_gap_conn_desc desc; - uint8_t status; int rc; SYS_LOG_DBG(""); - rc = gap_conn_find_by_addr((ble_addr_t *) data, &desc); + rc = gap_conn_find_by_addr((ble_addr_t *)&cp->address_type, &desc); if (rc) { - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } if (ble_gap_terminate(desc.conn_handle, BLE_ERR_REM_USER_CONN_TERM)) { - status = BTP_STATUS_FAILED; - } else { - status = BTP_STATUS_SUCCESS; + return BTP_STATUS_FAILED; } -rsp: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_DISCONNECT, CONTROLLER_INDEX, - status); + return BTP_STATUS_SUCCESS; } -static void -set_io_cap(const uint8_t *data, uint16_t len) +static uint8_t +set_io_cap(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_set_io_cap_cmd *cmd = (void *) data; - uint8_t status; + const struct btp_gap_set_io_cap_cmd *cp = cmd; SYS_LOG_DBG(""); - switch (cmd->io_cap) { + switch (cp->io_cap) { case BTP_GAP_IO_CAP_DISPLAY_ONLY: ble_hs_cfg.sm_io_cap = BLE_SM_IO_CAP_DISP_ONLY; ble_hs_cfg.sm_mitm = 1; @@ -1431,155 +1466,132 @@ set_io_cap(const uint8_t *data, uint16_t len) ble_hs_cfg.sm_mitm = 1; break; default: - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } - status = BTP_STATUS_SUCCESS; - -rsp: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_SET_IO_CAP, CONTROLLER_INDEX, - status); + return BTP_STATUS_SUCCESS; } -static void -pair(const uint8_t *data, uint16_t len) +static uint8_t +pair(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { + const struct btp_gap_pair_cmd *cp = cmd; struct ble_gap_conn_desc desc; - uint8_t status; int rc; SYS_LOG_DBG(""); - rc = gap_conn_find_by_addr((ble_addr_t *) data, &desc); + rc = gap_conn_find_by_addr((ble_addr_t *)&cp->address_type, &desc); if (rc) { - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } rc = ble_gap_security_initiate(desc.conn_handle); if (rc != 0 && rc != BLE_HS_EALREADY) { - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } - status = BTP_STATUS_SUCCESS; - -rsp: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_PAIR, CONTROLLER_INDEX, status); + return BTP_STATUS_SUCCESS; } -static void -unpair(const uint8_t *data, uint16_t len) +static uint8_t +unpair(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t status; + const struct btp_gap_unpair_cmd *cp = cmd; int err; SYS_LOG_DBG(""); - err = ble_gap_unpair((ble_addr_t *) data); - status = (uint8_t) (err != 0 ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_UNPAIR, CONTROLLER_INDEX, status); + err = ble_gap_unpair((ble_addr_t *)&cp->address_type); + return err != 0 ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS; } -static void -passkey_entry(const uint8_t *data, uint16_t len) +static uint8_t +passkey_entry(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_passkey_entry_cmd *cmd = (void *) data; - struct ble_gap_conn_desc desc; + const struct btp_gap_passkey_entry_cmd *cp = cmd; + struct ble_gap_conn_desc desc; struct ble_sm_io pk; - uint8_t status; int rc; SYS_LOG_DBG(""); - rc = gap_conn_find_by_addr((ble_addr_t *) data, &desc); + rc = gap_conn_find_by_addr((ble_addr_t *)&cp->address_type, &desc); if (rc) { - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } pk.action = BLE_SM_IOACT_INPUT; - pk.passkey = sys_le32_to_cpu(cmd->passkey); + pk.passkey = sys_le32_to_cpu(cp->passkey); rc = ble_sm_inject_io(desc.conn_handle, &pk); if (rc) { - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } - status = BTP_STATUS_SUCCESS; - -rsp: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_PASSKEY_ENTRY, CONTROLLER_INDEX, - status); + return BTP_STATUS_SUCCESS; } -static void -passkey_confirm(const uint8_t *data, uint16_t len) +static uint8_t +passkey_confirm(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_passkey_confirm_cmd *cmd = (void *) data; - struct ble_gap_conn_desc desc; + const struct btp_gap_passkey_confirm_cmd *cp = cmd; + struct ble_gap_conn_desc desc; struct ble_sm_io pk; - uint8_t status; int rc; SYS_LOG_DBG(""); - rc = gap_conn_find_by_addr((ble_addr_t *) data, &desc); + rc = gap_conn_find_by_addr((ble_addr_t *)&cp->address_type, &desc); if (rc) { - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } pk.action = BLE_SM_IOACT_NUMCMP; - pk.numcmp_accept = cmd->match; + pk.numcmp_accept = cp->match; rc = ble_sm_inject_io(desc.conn_handle, &pk); if (rc) { console_printf("sm inject io failed"); - status = BTP_STATUS_FAILED; - goto rsp; + return BTP_STATUS_FAILED; } - status = BTP_STATUS_SUCCESS; - -rsp: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_PASSKEY_CONFIRM, CONTROLLER_INDEX, - status); + return BTP_STATUS_SUCCESS; } -static void -start_direct_adv(const uint8_t *data, uint16_t len) +static uint8_t +start_direct_adv(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_start_direct_adv_cmd *cmd = (void *) data; - struct btp_gap_start_advertising_rp rp; - static struct ble_gap_adv_params adv_params = { + const struct btp_gap_start_direct_adv_cmd *cp = cmd; + struct btp_gap_start_advertising_rp *rp = rsp; + static struct ble_gap_adv_params adv_params = { .conn_mode = BLE_GAP_CONN_MODE_DIR, }; int err; SYS_LOG_DBG(""); - adv_params.high_duty_cycle = cmd->high_duty; + adv_params.high_duty_cycle = cp->high_duty; - err = ble_gap_adv_start(own_addr_type, (ble_addr_t *) data, + err = ble_gap_adv_start(own_addr_type, (ble_addr_t *)&cp->address_type, BLE_HS_FOREVER, &adv_params, gap_event_cb, NULL); if (err) { SYS_LOG_ERR("Advertising failed: err %d", err); - goto fail; + return BTP_STATUS_FAILED; } current_settings |= BIT(BTP_GAP_SETTINGS_ADVERTISING); - rp.current_settings = sys_cpu_to_le32(current_settings); + rp->current_settings = sys_cpu_to_le32(current_settings); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_START_DIRECT_ADV, CONTROLLER_INDEX, - (uint8_t *) &rp, sizeof(rp)); - return; -fail: - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_START_DIRECT_ADV, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } static void @@ -1665,72 +1677,74 @@ rsp: SYS_LOG_ERR("Conn param update fail; rc=%d", rc); } -static void -conn_param_update_async(const uint8_t *data, uint16_t len) +static uint8_t +conn_param_update_async(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_conn_param_update_cmd *cmd = (void *) data; - update_params = *cmd; + const struct btp_gap_conn_param_update_cmd *cp = cmd; + update_params = *cp; os_callout_reset(&update_params_co, 0); - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_CONN_PARAM_UPDATE, CONTROLLER_INDEX, - BTP_STATUS_SUCCESS); + return BTP_STATUS_SUCCESS; } -static void -oob_legacy_set_data(const uint8_t *data, uint16_t len) +static uint8_t +set_oob_legacy_data(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_oob_legacy_set_data_cmd *cmd = (void *) data; + const struct btp_gap_oob_legacy_set_data_cmd *cp = cmd; ble_hs_cfg.sm_oob_data_flag = 1; - memcpy(oob, cmd->oob_data, sizeof(oob)); + memcpy(oob, cp->oob_data, sizeof(oob)); - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_OOB_LEGACY_SET_DATA, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + return BTP_STATUS_SUCCESS; } -static void -oob_sc_get_local_data(const uint8_t *data, uint16_t len) +static uint8_t +get_oob_sc_local_data(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - struct btp_gap_oob_sc_get_local_data_rp rp; + struct btp_gap_oob_sc_get_local_data_rp *rp = rsp; - memcpy(rp.r, oob_data_local.r, 16); - memcpy(rp.c, oob_data_local.c, 16); + memcpy(rp->r, oob_data_local.r, 16); + memcpy(rp->c, oob_data_local.c, 16); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_OOB_SC_GET_LOCAL_DATA, - CONTROLLER_INDEX, (uint8_t *) &rp, sizeof(rp)); + *rsp_len = sizeof(*rp); + + return BTP_STATUS_SUCCESS; } -static void -oob_sc_set_remote_data(const uint8_t *data, uint16_t len) +static uint8_t +set_oob_sc_remote_data(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_oob_sc_set_remote_data_cmd *cmd = (void *) data; + const struct btp_gap_oob_sc_set_remote_data_cmd *cp = cmd; ble_hs_cfg.sm_oob_data_flag = 1; - memcpy(oob_data_remote.r, cmd->r, 16); - memcpy(oob_data_remote.c, cmd->c, 16); + memcpy(oob_data_remote.r, cp->r, 16); + memcpy(oob_data_remote.c, cp->c, 16); - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_OOB_SC_SET_REMOTE_DATA, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + return BTP_STATUS_SUCCESS; } -static void -set_mitm(const uint8_t *data, uint16_t len) +static uint8_t +set_mitm(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - const struct btp_gap_set_mitm_cmd *cmd = (void *) data; + const struct btp_gap_set_mitm_cmd *cp = cmd; - ble_hs_cfg.sm_mitm = cmd->mitm; + ble_hs_cfg.sm_mitm = cp->mitm; - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_SET_MITM, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + return BTP_STATUS_SUCCESS; } -static void -set_filter_accept_list(const uint8_t *data, uint16_t len) +static uint8_t +set_filter_accept_list(const void *cmd, uint16_t cmd_len, + void *rsp, uint16_t *rsp_len) { - uint8_t status = BTP_STATUS_SUCCESS; - struct btp_gap_set_filter_accept_list_cmd *tmp = - (struct btp_gap_set_filter_accept_list_cmd *) data; + const struct btp_gap_set_filter_accept_list_cmd *cp = cmd; + int err; SYS_LOG_DBG(""); @@ -1738,126 +1752,147 @@ set_filter_accept_list(const uint8_t *data, uint16_t len) * Check if the nb of bytes received matches the len of addrs list. * Then set the filter accept list. */ - if (((len - sizeof(tmp->list_len)) / sizeof(ble_addr_t) != - tmp->list_len) || ble_gap_wl_set(tmp->addrs, tmp->list_len)) { - status = BTP_STATUS_FAILED; + if ((cmd_len < sizeof(*cp)) || + (cmd_len != sizeof(*cp) + (cp->list_len * sizeof(cp->addrs[0])))) { + return BTP_STATUS_FAILED; } - tester_rsp(BTP_SERVICE_ID_GAP, BTP_GAP_SET_FILTER_ACCEPT_LIST, - CONTROLLER_INDEX, status); + err = ble_gap_wl_set(cp->addrs, cp->list_len); + if (err != 0) { + return BTP_STATUS_FAILED; + } + + return BTP_STATUS_SUCCESS; } -void -tester_handle_gap(uint8_t opcode, uint8_t index, uint8_t *data, - uint16_t len) -{ - switch (opcode) { - case BTP_GAP_READ_SUPPORTED_COMMANDS: - case BTP_GAP_READ_CONTROLLER_INDEX_LIST: - if (index != BTP_INDEX_NONE) { - tester_rsp(BTP_SERVICE_ID_GAP, opcode, index, - BTP_STATUS_FAILED); - return; - } - break; - default: - if (index != CONTROLLER_INDEX) { - tester_rsp(BTP_SERVICE_ID_GAP, opcode, index, - BTP_STATUS_FAILED); - return; - } - break; - } - - switch (opcode) { - case BTP_GAP_READ_SUPPORTED_COMMANDS: - supported_commands(data, len); - return; - case BTP_GAP_READ_CONTROLLER_INDEX_LIST: - controller_index_list(data, len); - return; - case BTP_GAP_READ_CONTROLLER_INFO: - controller_info(data, len); - return; - case BTP_GAP_SET_CONNECTABLE: - set_connectable(data, len); - return; - case BTP_GAP_SET_DISCOVERABLE: - set_discoverable(data, len); - return; - case BTP_GAP_SET_BONDABLE: - set_bondable(data, len); - return; - case BTP_GAP_START_ADVERTISING: - start_advertising(data, len); - return; - case BTP_GAP_STOP_ADVERTISING: - stop_advertising(data, len); - return; - case BTP_GAP_START_DISCOVERY: - start_discovery(data, len); - return; - case BTP_GAP_STOP_DISCOVERY: - stop_discovery(data, len); - return; - case BTP_GAP_CONNECT: - connect(data, len); - return; - case BTP_GAP_DISCONNECT: - disconnect(data, len); - return; - case BTP_GAP_SET_IO_CAP: - set_io_cap(data, len); - return; - case BTP_GAP_PAIR: - pair(data, len); - return; - case BTP_GAP_UNPAIR: - unpair(data, len); - return; - case BTP_GAP_PASSKEY_ENTRY: - passkey_entry(data, len); - return; - case BTP_GAP_PASSKEY_CONFIRM: - passkey_confirm(data, len); - return; - case BTP_GAP_START_DIRECT_ADV: - start_direct_adv(data, len); - return; - case BTP_GAP_CONN_PARAM_UPDATE: - conn_param_update_async(data, len); - return; - case BTP_GAP_OOB_LEGACY_SET_DATA: - oob_legacy_set_data(data, len); - return; - case BTP_GAP_OOB_SC_GET_LOCAL_DATA: - oob_sc_get_local_data(data, len); - return; - case BTP_GAP_OOB_SC_SET_REMOTE_DATA: - oob_sc_set_remote_data(data, len); - return; - case BTP_GAP_SET_MITM: - set_mitm(data, len); - return; - case BTP_GAP_SET_FILTER_ACCEPT_LIST: - set_filter_accept_list(data, len); - return; - default: - tester_rsp(BTP_SERVICE_ID_GAP, opcode, index, - BTP_STATUS_UNKNOWN_CMD); - return; - } -} +static const struct btp_handler handlers[] = { + { + .opcode = BTP_GAP_READ_SUPPORTED_COMMANDS, + .index = BTP_INDEX_NONE, + .expect_len = 0, + .func = supported_commands, + }, + { + .opcode = BTP_GAP_READ_CONTROLLER_INDEX_LIST, + .index = BTP_INDEX_NONE, + .expect_len = 0, + .func = controller_index_list, + }, + { + .opcode = BTP_GAP_READ_CONTROLLER_INFO, + .expect_len = 0, + .func = controller_info, + }, + { + .opcode = BTP_GAP_SET_CONNECTABLE, + .expect_len = sizeof(struct btp_gap_set_connectable_cmd), + .func = set_connectable, + }, + { + .opcode = BTP_GAP_SET_DISCOVERABLE, + .expect_len = sizeof(struct btp_gap_set_discoverable_cmd), + .func = set_discoverable, + }, + { + .opcode = BTP_GAP_SET_BONDABLE, + .expect_len = sizeof(struct btp_gap_set_bondable_cmd), + .func = set_bondable, + }, + { + .opcode = BTP_GAP_START_ADVERTISING, + .expect_len = -1, + .func = start_advertising, + }, + { + .opcode = BTP_GAP_START_DIRECT_ADV, + .expect_len = sizeof(struct btp_gap_start_direct_adv_cmd), + .func = start_direct_adv, + }, + { + .opcode = BTP_GAP_STOP_ADVERTISING, + .expect_len = 0, + .func = stop_advertising, + }, + { + .opcode = BTP_GAP_START_DISCOVERY, + .expect_len = sizeof(struct btp_gap_start_discovery_cmd), + .func = start_discovery, + }, + { + .opcode = BTP_GAP_STOP_DISCOVERY, + .expect_len = 0, + .func = stop_discovery, + }, + { + .opcode = BTP_GAP_CONNECT, + .expect_len = sizeof(struct btp_gap_connect_cmd), + .func = connect, + }, + { + .opcode = BTP_GAP_DISCONNECT, + .expect_len = sizeof(struct btp_gap_disconnect_cmd), + .func = disconnect, + }, + { + .opcode = BTP_GAP_SET_IO_CAP, + .expect_len = sizeof(struct btp_gap_set_io_cap_cmd), + .func = set_io_cap, + }, + { + .opcode = BTP_GAP_PAIR, + .expect_len = sizeof(struct btp_gap_pair_cmd), + .func = pair, + }, + { + .opcode = BTP_GAP_UNPAIR, + .expect_len = sizeof(struct btp_gap_unpair_cmd), + .func = unpair, + }, + { + .opcode = BTP_GAP_PASSKEY_ENTRY, + .expect_len = sizeof(struct btp_gap_passkey_entry_cmd), + .func = passkey_entry, + }, + { + .opcode = BTP_GAP_PASSKEY_CONFIRM, + .expect_len = sizeof(struct btp_gap_passkey_confirm_cmd), + .func = passkey_confirm, + }, + { + .opcode = BTP_GAP_CONN_PARAM_UPDATE, + .expect_len = sizeof(struct btp_gap_conn_param_update_cmd), + .func = conn_param_update_async, + }, + { + .opcode = BTP_GAP_OOB_LEGACY_SET_DATA, + .expect_len = sizeof(struct btp_gap_oob_legacy_set_data_cmd), + .func = set_oob_legacy_data, + }, + { + .opcode = BTP_GAP_OOB_SC_GET_LOCAL_DATA, + .expect_len = 0, + .func = get_oob_sc_local_data, + }, + { + .opcode = BTP_GAP_OOB_SC_SET_REMOTE_DATA, + .expect_len = sizeof(struct btp_gap_oob_sc_set_remote_data_cmd), + .func = set_oob_sc_remote_data, + }, + { + .opcode = BTP_GAP_SET_MITM, + .expect_len = sizeof(struct btp_gap_set_mitm_cmd), + .func = set_mitm, + }, + { + .opcode = BTP_GAP_SET_FILTER_ACCEPT_LIST, + .expect_len = -1, + .func = set_filter_accept_list, + }, +}; static void -tester_init_gap_cb(int err) +tester_init_gap_cb() { - if (err) { - tester_rsp(BTP_SERVICE_ID_CORE, BTP_CORE_REGISTER_SERVICE, - BTP_INDEX_NONE, BTP_STATUS_FAILED); - return; - } - current_settings = 0; current_settings |= BIT(BTP_GAP_SETTINGS_POWERED); current_settings |= BIT(BTP_GAP_SETTINGS_LE); @@ -1867,9 +1902,6 @@ tester_init_gap_cb(int err) os_callout_init(&connected_ev_co, os_eventq_dflt_get(), device_connected_ev_send, NULL); - - tester_rsp(BTP_SERVICE_ID_CORE, BTP_CORE_REGISTER_SERVICE, BTP_INDEX_NONE, - BTP_STATUS_SUCCESS); } uint8_t @@ -1890,7 +1922,11 @@ tester_init_gap(void) #endif adv_buf = NET_BUF_SIMPLE(ADV_BUF_LEN); - tester_init_gap_cb(BTP_STATUS_SUCCESS); + tester_init_gap_cb(); + + tester_register_command_handlers(BTP_SERVICE_ID_GAP, handlers, + ARRAY_SIZE(handlers)); + return BTP_STATUS_SUCCESS; } diff --git a/apps/bttester/src/btp_gatt.c b/apps/bttester/src/btp_gatt.c index d3b826f53..5d62a677a 100644 --- a/apps/bttester/src/btp_gatt.c +++ b/apps/bttester/src/btp_gatt.c @@ -256,7 +256,7 @@ static void attr_value_changed_ev(uint16_t handle, struct os_mbuf *data) { struct btp_gatt_attr_value_changed_ev *ev; - struct os_mbuf *buf = os_msys_get(0, 0); + struct os_mbuf *buf = os_msys_get(0, 0); SYS_LOG_DBG(""); @@ -583,7 +583,7 @@ start_server(uint8_t *data, uint16_t len) rp.db_attr_off = 0; rp.db_attr_cnt = 0; - tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_START_SERVER, CONTROLLER_INDEX, + tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_START_SERVER, (uint8_t *) &rp, sizeof(rp)); } @@ -672,29 +672,29 @@ read_cb(uint16_t conn_handle, struct ble_gatt_attr *attr, void *arg) { - struct btp_gatt_read_rp *rp = (void *) gatt_buf.buf; - uint8_t btp_opcode = (uint8_t) (int) arg; + struct btp_gatt_read_rp *rp = (void *) gatt_buf.buf; + uint8_t btp_opcode = (uint8_t) (int) arg; SYS_LOG_DBG("status=%d", error->status); if (error->status != 0 && error->status != BLE_HS_EDONE) { rp->att_response = (uint8_t) BLE_HS_ATT_ERR(error->status); - tester_send(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, btp_opcode, gatt_buf.buf, gatt_buf + .len); read_destroy(); return 0; } if (!gatt_buf_add(attr->om->om_data, attr->om->om_len)) { tester_rsp(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); read_destroy(); return 0; } rp->data_length += attr->om->om_len; tester_send(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + gatt_buf.buf, gatt_buf.len); read_destroy(); return 0; @@ -704,7 +704,7 @@ static void read(uint8_t *data, uint16_t len) { const struct btp_gatt_read_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; int rc; SYS_LOG_DBG(""); @@ -730,8 +730,7 @@ read(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ, BTP_STATUS_FAILED); } static int @@ -740,29 +739,29 @@ read_long_cb(uint16_t conn_handle, struct ble_gatt_attr *attr, void *arg) { - struct btp_gatt_read_rp *rp = (void *) gatt_buf.buf; - uint8_t btp_opcode = (uint8_t) (int) arg; + struct btp_gatt_read_rp *rp = (void *) gatt_buf.buf; + uint8_t btp_opcode = (uint8_t) (int) arg; SYS_LOG_DBG("status=%d", error->status); if (error->status != 0 && error->status != BLE_HS_EDONE) { rp->att_response = (uint8_t) BLE_HS_ATT_ERR(error->status); - tester_send(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, btp_opcode, gatt_buf.buf, gatt_buf + .len); read_destroy(); return 0; } if (error->status == BLE_HS_EDONE) { - tester_send(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, btp_opcode, gatt_buf.buf, gatt_buf + .len); read_destroy(); return 0; } if (gatt_buf_add(attr->om->om_data, attr->om->om_len) == NULL) { tester_rsp(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); read_destroy(); return BLE_HS_ENOMEM; } @@ -776,7 +775,7 @@ static void read_long(uint8_t *data, uint16_t len) { const struct btp_gatt_read_long_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; int rc; SYS_LOG_DBG(""); @@ -804,15 +803,14 @@ read_long(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ_LONG, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ_LONG, BTP_STATUS_FAILED); } static void read_multiple(uint8_t *data, uint16_t len) { const struct btp_gatt_read_multiple_cmd *cmd = (void *) data; - uint16_t handles[cmd->handles_count]; + uint16_t handles[cmd->handles_count]; struct ble_gap_conn_desc conn; int rc, i; @@ -844,15 +842,14 @@ read_multiple(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ_MULTIPLE, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ_MULTIPLE, BTP_STATUS_FAILED); } static void write_without_rsp(uint8_t *data, uint16_t len, uint8_t op, bool sign) { const struct btp_gatt_write_without_rsp_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -871,7 +868,7 @@ write_without_rsp(uint8_t *data, uint16_t len, uint8_t op, bool sign) } rsp: - tester_rsp(BTP_SERVICE_ID_GATT, op, CONTROLLER_INDEX, status); + tester_rsp(BTP_SERVICE_ID_GATT, op, status); } static int @@ -885,7 +882,7 @@ write_rsp(uint16_t conn_handle, const struct ble_gatt_error *error, SYS_LOG_DBG(""); tester_send(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, &err, sizeof(err)); + &err, sizeof(err)); return 0; } @@ -893,7 +890,7 @@ static void write(uint8_t *data, uint16_t len) { const struct btp_gatt_write_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; int rc; SYS_LOG_DBG(""); @@ -912,15 +909,14 @@ write(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_WRITE, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_WRITE, BTP_STATUS_FAILED); } static void write_long(uint8_t *data, uint16_t len) { const struct btp_gatt_write_long_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct os_mbuf *om = NULL; int rc = 0; @@ -949,8 +945,7 @@ write_long(uint8_t *data, uint16_t len) fail: SYS_LOG_ERR("Failed to send Write Long request, rc=%d", rc); os_mbuf_free_chain(om); - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_WRITE_LONG, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_WRITE_LONG, BTP_STATUS_FAILED); } static int @@ -965,7 +960,7 @@ reliable_write_rsp(uint16_t conn_handle, SYS_LOG_DBG("Reliable write status %d", err); tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_RELIABLE_WRITE, - CONTROLLER_INDEX, &err, sizeof(err)); + &err, sizeof(err)); return 0; } @@ -973,7 +968,7 @@ static void reliable_write(uint8_t *data, uint16_t len) { const struct btp_gatt_reliable_write_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct ble_gatt_attr attr; struct os_mbuf *om = NULL; int rc; @@ -1007,8 +1002,7 @@ reliable_write(uint8_t *data, uint16_t len) fail: os_mbuf_free_chain(om); - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_WRITE_LONG, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_WRITE_LONG, BTP_STATUS_FAILED); } static struct bt_gatt_subscribe_params { @@ -1021,7 +1015,7 @@ static void read_uuid(uint8_t *data, uint16_t len) { const struct btp_gatt_read_uuid_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; ble_uuid_any_t uuid; int rc; @@ -1054,8 +1048,7 @@ read_uuid(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_READ, BTP_STATUS_FAILED); } static int @@ -1064,8 +1057,8 @@ disc_prim_uuid_cb(uint16_t conn_handle, const struct ble_gatt_svc *gatt_svc, void *arg) { struct btp_gatt_disc_prim_uuid_rp *rp = (void *) gatt_buf.buf; - struct btp_gatt_service *service; - const ble_uuid_any_t *uuid; + struct btp_gatt_service *service; + const ble_uuid_any_t *uuid; uint8_t uuid_length; uint8_t opcode = (uint8_t) (int) arg; @@ -1073,14 +1066,13 @@ disc_prim_uuid_cb(uint16_t conn_handle, if (error->status != 0 && error->status != BLE_HS_EDONE) { tester_rsp(BTP_SERVICE_ID_GATT, opcode, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return 0; } if (error->status == BLE_HS_EDONE) { - tester_send(BTP_SERVICE_ID_GATT, opcode, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, opcode, gatt_buf.buf, gatt_buf.len); discover_destroy(); return 0; } @@ -1091,7 +1083,7 @@ disc_prim_uuid_cb(uint16_t conn_handle, service = gatt_buf_reserve(sizeof(*service) + uuid_length); if (!service) { tester_rsp(BTP_SERVICE_ID_GATT, opcode, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return BLE_HS_ENOMEM; } @@ -1121,22 +1113,22 @@ disc_all_desc_cb(uint16_t conn_handle, void *arg) { struct btp_gatt_disc_all_desc_rp *rp = (void *) gatt_buf.buf; - struct btp_gatt_descriptor *dsc; - const ble_uuid_any_t *uuid; + struct btp_gatt_descriptor *dsc; + const ble_uuid_any_t *uuid; uint8_t uuid_length; SYS_LOG_DBG(""); if (error->status != 0 && error->status != BLE_HS_EDONE) { tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_DESC, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return 0; } if (error->status == BLE_HS_EDONE) { - tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_DESC, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_DESC, gatt_buf + .buf, gatt_buf.len); discover_destroy(); return 0; } @@ -1147,7 +1139,7 @@ disc_all_desc_cb(uint16_t conn_handle, dsc = gatt_buf_reserve(sizeof(*dsc) + uuid_length); if (!dsc) { tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_DESC, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return BLE_HS_ENOMEM; } @@ -1194,14 +1186,14 @@ disc_all_prim_svcs(uint8_t *data, uint16_t len) fail: tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_PRIM_SVCS, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); } static void disc_all_desc(uint8_t *data, uint16_t len) { const struct btp_gatt_disc_all_desc_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; int rc; @@ -1232,8 +1224,7 @@ disc_all_desc(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_DESC, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_DESC, BTP_STATUS_FAILED); } static int @@ -1242,8 +1233,8 @@ find_included_cb(uint16_t conn_handle, const struct ble_gatt_svc *gatt_svc, void *arg) { struct btp_gatt_find_included_rp *rp = (void *) gatt_buf.buf; - struct btp_gatt_included *included; - const ble_uuid_any_t *uuid; + struct btp_gatt_included *included; + const ble_uuid_any_t *uuid; int service_handle = (int) arg; uint8_t uuid_length; @@ -1251,14 +1242,14 @@ find_included_cb(uint16_t conn_handle, if (error->status != 0 && error->status != BLE_HS_EDONE) { tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_FIND_INCLUDED, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return 0; } if (error->status == BLE_HS_EDONE) { - tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_FIND_INCLUDED, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_FIND_INCLUDED, gatt_buf + .buf, gatt_buf.len); discover_destroy(); return 0; } @@ -1269,7 +1260,7 @@ find_included_cb(uint16_t conn_handle, included = gatt_buf_reserve(sizeof(*included) + uuid_length); if (!included) { tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_FIND_INCLUDED, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return BLE_HS_ENOMEM; } @@ -1301,7 +1292,7 @@ disc_chrc_cb(uint16_t conn_handle, { struct btp_gatt_disc_chrc_rp *rp = (void *) gatt_buf.buf; struct btp_gatt_characteristic *chrc; - const ble_uuid_any_t *uuid; + const ble_uuid_any_t *uuid; uint8_t btp_opcode = (uint8_t) (int) arg; uint8_t uuid_length; @@ -1309,14 +1300,14 @@ disc_chrc_cb(uint16_t conn_handle, if (error->status != 0 && error->status != BLE_HS_EDONE) { tester_rsp(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return 0; } if (error->status == BLE_HS_EDONE) { - tester_send(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, gatt_buf.buf, gatt_buf.len); + tester_send(BTP_SERVICE_ID_GATT, btp_opcode, gatt_buf.buf, gatt_buf + .len); discover_destroy(); return 0; } @@ -1327,7 +1318,7 @@ disc_chrc_cb(uint16_t conn_handle, chrc = gatt_buf_reserve(sizeof(*chrc) + uuid_length); if (!chrc) { tester_rsp(BTP_SERVICE_ID_GATT, btp_opcode, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); discover_destroy(); return BLE_HS_ENOMEM; } @@ -1354,7 +1345,7 @@ static void disc_chrc_uuid(uint8_t *data, uint16_t len) { const struct btp_gatt_disc_chrc_uuid_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; ble_uuid_any_t uuid; int rc; @@ -1387,7 +1378,7 @@ disc_chrc_uuid(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_CHRC_UUID, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_CHRC_UUID, BTP_STATUS_FAILED); } @@ -1395,7 +1386,7 @@ static void disc_prim_uuid(uint8_t *data, uint16_t len) { const struct btp_gatt_disc_prim_uuid_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; ble_uuid_any_t uuid; int rc; @@ -1424,7 +1415,7 @@ disc_prim_uuid(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_PRIM_UUID, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_PRIM_UUID, BTP_STATUS_FAILED); } @@ -1462,15 +1453,14 @@ disc_all_chrc(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_CHRC, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_DISC_ALL_CHRC, BTP_STATUS_FAILED); } static void find_included(uint8_t *data, uint16_t len) { const struct btp_gatt_find_included_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; int service_handle_arg; int rc; @@ -1500,8 +1490,7 @@ find_included(uint8_t *data, uint16_t len) return; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_FIND_INCLUDED, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_FIND_INCLUDED, BTP_STATUS_FAILED); } static int @@ -1513,13 +1502,12 @@ exchange_func(uint16_t conn_handle, if (error->status) { tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_EXCHANGE_MTU, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); return 0; } - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_EXCHANGE_MTU, CONTROLLER_INDEX, - BTP_STATUS_SUCCESS); + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_EXCHANGE_MTU, BTP_STATUS_SUCCESS); return 0; } @@ -1544,7 +1532,7 @@ exchange_mtu(uint8_t *data, uint16_t len) return; fail: tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_EXCHANGE_MTU, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); } static int @@ -1564,8 +1552,7 @@ enable_subscription(uint16_t conn_handle, uint16_t ccc_handle, subscribe_params.ccc_handle = value; - tester_rsp(BTP_SERVICE_ID_GATT, op, CONTROLLER_INDEX, - BTP_STATUS_SUCCESS); + tester_rsp(BTP_SERVICE_ID_GATT, op, BTP_STATUS_SUCCESS); return 0; } @@ -1595,7 +1582,7 @@ static void config_subscription(uint8_t *data, uint16_t len, uint8_t op) { const struct btp_gatt_cfg_notify_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t ccc_handle = sys_le16_to_cpu(cmd->ccc_handle); uint8_t status; int rc; @@ -1604,8 +1591,7 @@ config_subscription(uint8_t *data, uint16_t len, uint8_t op) rc = ble_gap_conn_find_by_addr((ble_addr_t *) data, &conn); if (rc) { - tester_rsp(BTP_SERVICE_ID_GATT, op, CONTROLLER_INDEX, - BTP_STATUS_FAILED); + tester_rsp(BTP_SERVICE_ID_GATT, op, BTP_STATUS_FAILED); return; } @@ -1635,7 +1621,7 @@ config_subscription(uint8_t *data, uint16_t len, uint8_t op) SYS_LOG_DBG("Config subscription (op %u) status %u", op, status); - tester_rsp(BTP_SERVICE_ID_GATT, op, CONTROLLER_INDEX, status); + tester_rsp(BTP_SERVICE_ID_GATT, op, status); } #define BTP_PERM_F_READ 0x01 @@ -1678,8 +1664,8 @@ get_attrs(uint8_t *data, uint16_t len) { const struct btp_gatt_get_attributes_cmd *cmd = (void *) data; struct btp_gatt_get_attributes_rp *rp; - struct btp_gatt_attr *gatt_attr; - struct os_mbuf *buf = os_msys_get(0, 0); + struct btp_gatt_attr *gatt_attr; + struct os_mbuf *buf = os_msys_get(0, 0); uint16_t start_handle, end_handle; struct ble_att_svr_entry *entry = NULL; ble_uuid_any_t uuid; @@ -1747,7 +1733,7 @@ get_attrs(uint8_t *data, uint16_t len) goto free; fail: - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_GET_ATTRIBUTES, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_GET_ATTRIBUTES, BTP_STATUS_FAILED); free: os_mbuf_free_chain(buf); @@ -1757,8 +1743,8 @@ static void get_attr_val(uint8_t *data, uint16_t len) { const struct btp_gatt_get_attribute_value_cmd *cmd = (void *) data; - struct btp_gatt_get_attribute_value_rp *rp; - struct ble_gap_conn_desc conn; + struct btp_gatt_get_attribute_value_rp *rp; + struct ble_gap_conn_desc conn; struct os_mbuf *buf = os_msys_get(0, 0); uint16_t handle = sys_cpu_to_le16(cmd->handle); uint8_t out_att_err = 0; @@ -1813,7 +1799,7 @@ change_database(uint8_t *data, uint16_t len) ble_svc_gatt_changed(cmd->start_handle, cmd->end_handle); - tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_CHANGE_DATABASE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_GATT, BTP_GATT_CHANGE_DATABASE, BTP_STATUS_SUCCESS); return; @@ -1822,7 +1808,7 @@ change_database(uint8_t *data, uint16_t len) static void supported_commands(uint8_t *data, uint16_t len) { - uint8_t cmds[4]; + uint8_t cmds[4]; struct btp_gatt_read_supported_commands_rp *rp = (void *) cmds; SYS_LOG_DBG(""); @@ -1854,7 +1840,7 @@ supported_commands(uint8_t *data, uint16_t len) tester_set_bit(cmds, BTP_GATT_CHANGE_DATABASE); tester_send(BTP_SERVICE_ID_GATT, BTP_GATT_READ_SUPPORTED_COMMANDS, - CONTROLLER_INDEX, (uint8_t *) rp, sizeof(cmds)); + (uint8_t *) rp, sizeof(cmds)); } enum attr_type { @@ -1864,7 +1850,7 @@ enum attr_type { }; void -tester_handle_gatt(uint8_t opcode, uint8_t index, uint8_t *data, +tester_handle_gatt(uint8_t opcode, uint8_t *data, uint16_t len) { switch (opcode) { @@ -1941,8 +1927,7 @@ tester_handle_gatt(uint8_t opcode, uint8_t index, uint8_t *data, get_attr_val(data, len); return; default: - tester_rsp(BTP_SERVICE_ID_GATT, opcode, index, - BTP_STATUS_UNKNOWN_CMD); + tester_rsp(BTP_SERVICE_ID_GATT, opcode, BTP_STATUS_UNKNOWN_CMD); return; } } @@ -1952,7 +1937,7 @@ tester_gatt_notify_rx_ev(uint16_t conn_handle, uint16_t attr_handle, uint8_t indication, struct os_mbuf *om) { struct btp_gatt_notification_ev *ev; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; diff --git a/apps/bttester/src/btp_gatt_cl.c b/apps/bttester/src/btp_gatt_cl.c index af33f17ee..f734c9c4e 100644 --- a/apps/bttester/src/btp_gatt_cl.c +++ b/apps/bttester/src/btp_gatt_cl.c @@ -124,7 +124,7 @@ tester_mtu_exchanged_ev(uint16_t conn_handle, uint16_t mtu, void *arg) { struct btp_gattc_exchange_mtu_ev *ev; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; @@ -175,7 +175,7 @@ exchange_mtu(uint8_t *data, uint16_t len) rsp: tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_EXCHANGE_MTU, - CONTROLLER_INDEX, status); + status); } static int @@ -184,9 +184,9 @@ disc_prim_svcs_cb(uint16_t conn_handle, const struct ble_gatt_svc *gatt_svc, void *arg) { struct btp_gattc_disc_prim_svcs_rp *rp; - struct ble_gap_conn_desc conn; - struct btp_gatt_service *service; - const ble_uuid_any_t *uuid; + struct ble_gap_conn_desc conn; + struct btp_gatt_service *service; + const ble_uuid_any_t *uuid; const ble_addr_t *addr; uint8_t uuid_length; struct os_mbuf *buf = os_msys_get(0, 0); @@ -280,14 +280,14 @@ disc_all_prim_svcs(uint8_t *data, uint16_t len) rsp: tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_ALL_PRIM_SVCS, - CONTROLLER_INDEX, status); + status); } static void disc_prim_uuid(uint8_t *data, uint16_t len) { const struct btp_gattc_disc_prim_uuid_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; ble_uuid_any_t uuid; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -314,8 +314,7 @@ disc_prim_uuid(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_PRIM_UUID, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_PRIM_UUID, status); } static int @@ -324,8 +323,8 @@ find_included_cb(uint16_t conn_handle, const struct ble_gatt_svc *gatt_svc, void *arg) { struct btp_gattc_find_included_rp *rp; - struct btp_gatt_included *included; - const ble_uuid_any_t *uuid; + struct btp_gatt_included *included; + const ble_uuid_any_t *uuid; int service_handle = (int) arg; uint8_t uuid_length; uint8_t err = (uint8_t) error->status; @@ -405,7 +404,7 @@ static void find_included(uint8_t *data, uint16_t len) { const struct btp_gattc_find_included_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; int service_handle_arg; uint8_t status = BTP_STATUS_SUCCESS; @@ -432,8 +431,7 @@ find_included(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_FIND_INCLUDED, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_FIND_INCLUDED, status); } static int @@ -443,7 +441,7 @@ disc_chrc_cb(uint16_t conn_handle, { struct btp_gattc_disc_chrc_rp *rp; struct btp_gatt_characteristic *chrc; - const ble_uuid_any_t *uuid; + const ble_uuid_any_t *uuid; uint8_t uuid_length; uint8_t opcode = (uint8_t) (int) arg; uint8_t err = (uint8_t) error->status; @@ -523,7 +521,7 @@ static void disc_all_chrc(uint8_t *data, uint16_t len) { const struct btp_gattc_disc_all_chrc_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -552,15 +550,14 @@ disc_all_chrc(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_ALL_CHRC, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_ALL_CHRC, status); } static void disc_chrc_uuid(uint8_t *data, uint16_t len) { const struct btp_gattc_disc_chrc_uuid_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; ble_uuid_any_t uuid; uint8_t status = BTP_STATUS_SUCCESS; @@ -592,8 +589,7 @@ disc_chrc_uuid(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_CHRC_UUID, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_CHRC_UUID, status); } static int @@ -604,8 +600,8 @@ disc_all_desc_cb(uint16_t conn_handle, void *arg) { struct btp_gattc_disc_all_desc_rp *rp; - struct btp_gatt_descriptor *dsc; - const ble_uuid_any_t *uuid; + struct btp_gatt_descriptor *dsc; + const ble_uuid_any_t *uuid; uint8_t uuid_length; uint8_t err = (uint8_t) error->status; struct os_mbuf *buf = os_msys_get(0, 0); @@ -679,7 +675,7 @@ static void disc_all_desc(uint8_t *data, uint16_t len) { const struct btp_gattc_disc_all_desc_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t start_handle, end_handle; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -710,8 +706,7 @@ disc_all_desc(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_ALL_DESC, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_DISC_ALL_DESC, status); } static int @@ -721,7 +716,7 @@ read_cb(uint16_t conn_handle, void *arg) { struct btp_gattc_read_rp *rp; - uint8_t opcode = (uint8_t) (int) arg; + uint8_t opcode = (uint8_t) (int) arg; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; struct ble_gap_conn_desc conn; @@ -772,7 +767,7 @@ static void read(uint8_t *data, uint16_t len) { const struct btp_gattc_read_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -795,8 +790,7 @@ read(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ, status); } static int @@ -807,7 +801,7 @@ read_uuid_cb(uint16_t conn_handle, { struct btp_gattc_read_uuid_rp *rp; struct btp_gatt_read_uuid_chr *chr; - uint8_t opcode = (uint8_t) (int) arg; + uint8_t opcode = (uint8_t) (int) arg; uint8_t err = (uint8_t) error->status; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; @@ -875,7 +869,7 @@ static void read_uuid(uint8_t *data, uint16_t len) { const struct btp_gattc_read_uuid_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; ble_uuid_any_t uuid; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -905,8 +899,7 @@ read_uuid(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_UUID, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_UUID, status); } static int @@ -975,7 +968,7 @@ static void read_long(uint8_t *data, uint16_t len) { const struct btp_gattc_read_long_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -999,15 +992,14 @@ read_long(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_LONG, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_LONG, status); } static void read_multiple(uint8_t *data, uint16_t len) { const struct btp_gattc_read_multiple_cmd *cmd = (void *) data; - uint16_t handles[cmd->handles_count]; + uint16_t handles[cmd->handles_count]; struct ble_gap_conn_desc conn; uint8_t status = BTP_STATUS_SUCCESS; int rc, i; @@ -1037,15 +1029,14 @@ read_multiple(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_MULTIPLE, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_MULTIPLE, status); } static void write_without_rsp(uint8_t *data, uint16_t len, uint8_t op, bool sign) { const struct btp_gattc_write_without_rsp_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -1064,7 +1055,7 @@ write_without_rsp(uint8_t *data, uint16_t len, uint8_t op, bool sign) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, op, CONTROLLER_INDEX, status); + tester_rsp(BTP_SERVICE_ID_GATTC, op, status); } static int @@ -1073,7 +1064,7 @@ write_cb(uint16_t conn_handle, const struct ble_gatt_error *error, void *arg) { struct btp_gattc_write_rp *rp; - uint8_t err = (uint8_t) error->status; + uint8_t err = (uint8_t) error->status; uint8_t opcode = (uint8_t) (int) arg; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; @@ -1107,7 +1098,7 @@ static void write(uint8_t *data, uint16_t len) { const struct btp_gattc_write_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -1126,15 +1117,14 @@ write(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_WRITE, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_WRITE, status); } static void write_long(uint8_t *data, uint16_t len) { const struct btp_gattc_write_long_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct os_mbuf *om = NULL; uint8_t status = BTP_STATUS_SUCCESS; int rc = 0; @@ -1168,8 +1158,7 @@ fail: SYS_LOG_ERR("Failed to send Write Long request, rc=%d", rc); os_mbuf_free_chain(om); rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_WRITE_LONG, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_WRITE_LONG, status); } static int @@ -1180,7 +1169,7 @@ reliable_write_cb(uint16_t conn_handle, void *arg) { struct btp_gattc_write_rp *rp; - uint8_t err = (uint8_t) error->status; + uint8_t err = (uint8_t) error->status; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; struct ble_gap_conn_desc conn; @@ -1213,7 +1202,7 @@ static void reliable_write(uint8_t *data, uint16_t len) { const struct btp_gattc_reliable_write_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct ble_gatt_attr attr; struct os_mbuf *om = NULL; uint8_t status = BTP_STATUS_SUCCESS; @@ -1251,8 +1240,7 @@ reliable_write(uint8_t *data, uint16_t len) fail: os_mbuf_free_chain(om); rsp: - tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_WRITE_LONG, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_GATTC, BTP_GATTC_WRITE_LONG, status); } static int @@ -1262,7 +1250,7 @@ subscribe_cb(uint16_t conn_handle, void *arg) { struct btp_subscribe_rp *rp; - uint8_t err = (uint8_t) error->status; + uint8_t err = (uint8_t) error->status; uint8_t opcode = (uint8_t) (int) arg; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; @@ -1351,7 +1339,7 @@ static void config_subscription(uint8_t *data, uint16_t len, uint8_t op) { const struct btp_gattc_cfg_notify_cmd *cmd = (void *) data; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; uint16_t ccc_handle = sys_le16_to_cpu(cmd->ccc_handle); uint8_t status = BTP_STATUS_SUCCESS; int rc; @@ -1389,7 +1377,7 @@ config_subscription(uint8_t *data, uint16_t len, uint8_t op) rsp: SYS_LOG_DBG("Config subscription (op %u) status %u", op, status); - tester_rsp(BTP_SERVICE_ID_GATTC, op, CONTROLLER_INDEX, status); + tester_rsp(BTP_SERVICE_ID_GATTC, op, status); } int @@ -1397,7 +1385,7 @@ tester_gattc_notify_rx_ev(uint16_t conn_handle, uint16_t attr_handle, uint8_t indication, struct os_mbuf *om) { struct btp_gattc_notification_ev *ev; - struct ble_gap_conn_desc conn; + struct ble_gap_conn_desc conn; struct os_mbuf *buf = os_msys_get(0, 0); const ble_addr_t *addr; @@ -1434,7 +1422,7 @@ fail: static void supported_commands(uint8_t *data, uint16_t len) { - uint8_t cmds[3]; + uint8_t cmds[3]; struct btp_gatt_read_supported_commands_rp *rp = (void *) cmds; SYS_LOG_DBG(""); @@ -1464,11 +1452,11 @@ supported_commands(uint8_t *data, uint16_t len) tester_set_bit(cmds, BTP_GATTC_CFG_INDICATE); tester_send(BTP_SERVICE_ID_GATTC, BTP_GATTC_READ_SUPPORTED_COMMANDS, - CONTROLLER_INDEX, (uint8_t *) rp, sizeof(cmds)); + (uint8_t *) rp, sizeof(cmds)); } void -tester_handle_gattc(uint8_t opcode, uint8_t index, uint8_t *data, +tester_handle_gattc(uint8_t opcode, uint8_t *data, uint16_t len) { switch (opcode) { @@ -1533,8 +1521,7 @@ tester_handle_gattc(uint8_t opcode, uint8_t index, uint8_t *data, config_subscription(data, len, opcode); return; default: - tester_rsp(BTP_SERVICE_ID_GATTC, opcode, index, - BTP_STATUS_UNKNOWN_CMD); + tester_rsp(BTP_SERVICE_ID_GATTC, opcode, BTP_STATUS_UNKNOWN_CMD); return; } } \ No newline at end of file diff --git a/apps/bttester/src/btp_l2cap.c b/apps/bttester/src/btp_l2cap.c index 93435943a..03d70688a 100644 --- a/apps/bttester/src/btp_l2cap.c +++ b/apps/bttester/src/btp_l2cap.c @@ -122,8 +122,8 @@ static void recv_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, struct os_mbuf *buf, void *arg) { - struct btp_l2cap_data_received_ev *ev = (void *) recv_cb_buf; - struct channel *channel = find_channel(chan); + struct btp_l2cap_data_received_ev *ev = (void *) recv_cb_buf; + struct channel *channel = find_channel(chan); assert(channel != NULL); ev->chan_id = channel->chan_id; @@ -136,7 +136,7 @@ recv_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, os_mbuf_copydata(buf, 0, ev->data_length, ev->data); tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_EV_DATA_RECEIVED, - CONTROLLER_INDEX, recv_cb_buf, sizeof(*ev) + ev->data_length); + recv_cb_buf, sizeof(*ev) + ev->data_length); tester_l2cap_coc_recv(chan, buf); } @@ -147,10 +147,10 @@ unstalled_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, { if (status) { tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_SEND_DATA, - CONTROLLER_INDEX, BTP_STATUS_FAILED); + BTP_STATUS_FAILED); } else { tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_SEND_DATA, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + BTP_STATUS_SUCCESS); } } @@ -160,7 +160,7 @@ reconfigured_ev(uint16_t conn_handle, struct ble_l2cap_chan *chan, int status) { struct btp_l2cap_reconfigured_ev ev; - struct channel *channel; + struct channel *channel; if (status != 0) { return; @@ -176,7 +176,7 @@ reconfigured_ev(uint16_t conn_handle, struct ble_l2cap_chan *chan, ev.our_mps = chan_info->our_l2cap_mtu; tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_EV_RECONFIGURED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void @@ -184,7 +184,7 @@ connected_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, struct ble_l2cap_chan_info *chan_info, void *arg) { struct btp_l2cap_connected_ev ev; - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct channel *channel = find_channel(chan); if (channel == NULL) { @@ -206,7 +206,7 @@ connected_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, sizeof(ev.address)); } - tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_EV_CONNECTED, CONTROLLER_INDEX, + tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_EV_CONNECTED, (uint8_t *) &ev, sizeof(ev)); } @@ -215,7 +215,7 @@ disconnected_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, struct ble_l2cap_chan_info *chan_info, void *arg) { struct btp_l2cap_disconnected_ev ev; - struct ble_gap_conn_desc desc; + struct ble_gap_conn_desc desc; struct channel *channel; memset(&ev, 0, sizeof(struct btp_l2cap_disconnected_ev)); @@ -235,7 +235,7 @@ disconnected_cb(uint16_t conn_handle, struct ble_l2cap_chan *chan, } tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_EV_DISCONNECTED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static int @@ -407,9 +407,9 @@ static void connect(uint8_t *data, uint16_t len) { const struct btp_l2cap_connect_cmd *cmd = (void *) data; - uint8_t rp_buf[sizeof(struct btp_l2cap_connect_rp) + cmd->num]; - struct btp_l2cap_connect_rp *rp = (void *) rp_buf; - struct ble_gap_conn_desc desc; + uint8_t rp_buf[sizeof(struct btp_l2cap_connect_rp) + cmd->num]; + struct btp_l2cap_connect_rp *rp = (void *) rp_buf; + struct ble_gap_conn_desc desc; struct channel *chan; struct os_mbuf *sdu_rx[cmd->num]; ble_addr_t *addr = (void *) data; @@ -481,13 +481,13 @@ connect(uint8_t *data, uint16_t len) goto fail; } - tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CONNECT, CONTROLLER_INDEX, + tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CONNECT, (uint8_t *) rp, sizeof(rp_buf)); return; fail: - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CONNECT, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CONNECT, BTP_STATUS_FAILED); } @@ -495,7 +495,7 @@ static void disconnect(const uint8_t *data, uint16_t len) { const struct btp_l2cap_disconnect_cmd *cmd = (void *) data; - struct channel *chan; + struct channel *chan; uint8_t status; int err; @@ -513,15 +513,15 @@ disconnect(const uint8_t *data, uint16_t len) status = BTP_STATUS_SUCCESS; rsp: - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_DISCONNECT, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_DISCONNECT, status); } static void send_data(const uint8_t *data, uint16_t len) { - const struct btp_l2cap_send_data_cmd *cmd = (void *) data; - struct os_mbuf *sdu_tx = NULL; + const struct btp_l2cap_send_data_cmd *cmd = (void *) data; + struct os_mbuf *sdu_tx = NULL; int rc; uint16_t data_len = sys_le16_to_cpu(cmd->data_len); struct channel *chan = get_channel(cmd->chan_id); @@ -550,7 +550,7 @@ send_data(const uint8_t *data, uint16_t len) /* ble_l2cap_send takes ownership of the sdu */ rc = ble_l2cap_send(chan->chan, sdu_tx); if (rc == 0 || rc == BLE_HS_ESTALLED) { - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_SEND_DATA, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_SEND_DATA, BTP_STATUS_SUCCESS); return; } @@ -559,7 +559,7 @@ send_data(const uint8_t *data, uint16_t len) os_mbuf_free_chain(sdu_tx); fail: - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_SEND_DATA, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_SEND_DATA, BTP_STATUS_FAILED); } @@ -582,12 +582,12 @@ listen(const uint8_t *data, uint16_t len) goto fail; } - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_LISTEN, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_LISTEN, BTP_STATUS_SUCCESS); return; fail: - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_LISTEN, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_LISTEN, BTP_STATUS_FAILED); } @@ -595,7 +595,7 @@ static void credits(uint8_t *data, uint16_t len) { const struct btp_l2cap_credits_cmd *cmd = (void *) data; - struct os_mbuf *sdu; + struct os_mbuf *sdu; int rc; struct channel *channel = get_channel(cmd->chan_id); @@ -613,11 +613,11 @@ credits(uint8_t *data, uint16_t len) if (rc != 0) { goto fail; } - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CREDITS, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CREDITS, BTP_STATUS_SUCCESS); return; fail: - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CREDITS, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_CREDITS, BTP_STATUS_FAILED); } @@ -658,19 +658,19 @@ reconfigure(const uint8_t *data, uint16_t len) goto fail; } - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_RECONFIGURE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_RECONFIGURE, BTP_STATUS_SUCCESS); return; fail: - tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_RECONFIGURE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_RECONFIGURE, BTP_STATUS_FAILED); } static void supported_commands(uint8_t *data, uint16_t len) { - uint8_t cmds[1]; + uint8_t cmds[1]; struct btp_l2cap_read_supported_commands_rp *rp = (void *) cmds; memset(cmds, 0, sizeof(cmds)); @@ -683,11 +683,11 @@ supported_commands(uint8_t *data, uint16_t len) tester_set_bit(cmds, BTP_L2CAP_RECONFIGURE); tester_send(BTP_SERVICE_ID_L2CAP, BTP_L2CAP_READ_SUPPORTED_COMMANDS, - CONTROLLER_INDEX, (uint8_t *) rp, sizeof(cmds)); + (uint8_t *) rp, sizeof(cmds)); } void -tester_handle_l2cap(uint8_t opcode, uint8_t index, uint8_t *data, +tester_handle_l2cap(uint8_t opcode, uint8_t *data, uint16_t len) { switch (opcode) { @@ -713,7 +713,7 @@ tester_handle_l2cap(uint8_t opcode, uint8_t index, uint8_t *data, credits(data, len); return; default: - tester_rsp(BTP_SERVICE_ID_L2CAP, opcode, index, + tester_rsp(BTP_SERVICE_ID_L2CAP, opcode, BTP_STATUS_UNKNOWN_CMD); return; } diff --git a/apps/bttester/src/btp_mesh.c b/apps/bttester/src/btp_mesh.c index cc36515a4..3e0668ea7 100644 --- a/apps/bttester/src/btp_mesh.c +++ b/apps/bttester/src/btp_mesh.c @@ -284,7 +284,7 @@ link_open(bt_mesh_prov_bearer_t bearer) } tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_PROV_LINK_OPEN, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void @@ -308,7 +308,7 @@ link_close(bt_mesh_prov_bearer_t bearer) } tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_PROV_LINK_CLOSED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static int @@ -322,7 +322,7 @@ output_number(bt_mesh_output_action_t action, uint32_t number) ev.number = sys_cpu_to_le32(number); tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_OUT_NUMBER_ACTION, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); return 0; } @@ -331,7 +331,7 @@ static int output_string(const char *str) { struct btp_mesh_out_string_action_ev *ev; - struct os_mbuf *buf = NET_BUF_SIMPLE(BTP_DATA_MAX_SIZE); + struct os_mbuf *buf = NET_BUF_SIMPLE(BTP_DATA_MAX_SIZE); SYS_LOG_DBG("str %s", str); @@ -361,7 +361,7 @@ input(bt_mesh_input_action_t action, uint8_t size) ev.action = sys_cpu_to_le16(action); ev.size = size; - tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_IN_ACTION, CONTROLLER_INDEX, + tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_IN_ACTION, (uint8_t *) &ev, sizeof(ev)); return 0; @@ -379,7 +379,7 @@ prov_complete(uint16_t net_idx, uint16_t addr) net.local = addr; net.dst = addr; - tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_PROVISIONED, CONTROLLER_INDEX, + tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_PROVISIONED, NULL, 0); } @@ -426,7 +426,7 @@ config_prov(uint8_t *data, uint16_t len) prov.input_actions = sys_le16_to_cpu(cmd->in_actions); tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_CONFIG_PROVISIONING, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + BTP_STATUS_SUCCESS); } static void @@ -445,7 +445,7 @@ provision_node(uint8_t *data, uint16_t len) net_key_idx = sys_le16_to_cpu(cmd->net_key_idx); tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_PROVISION_NODE, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + BTP_STATUS_SUCCESS); } static void @@ -477,8 +477,7 @@ init(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INIT, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INIT, status); } static void @@ -488,15 +487,15 @@ reset(uint8_t *data, uint16_t len) bt_mesh_reset(); - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_RESET, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_RESET, BTP_STATUS_SUCCESS); } static void input_number(uint8_t *data, uint16_t len) { - const struct btp_mesh_input_number_cmd *cmd = (void *) data; - uint8_t status = BTP_STATUS_SUCCESS; + const struct btp_mesh_input_number_cmd *cmd = (void *) data; + uint8_t status = BTP_STATUS_SUCCESS; uint32_t number; int err; @@ -509,15 +508,14 @@ input_number(uint8_t *data, uint16_t len) status = BTP_STATUS_FAILED; } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INPUT_NUMBER, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INPUT_NUMBER, status); } static void input_string(uint8_t *data, uint16_t len) { - const struct btp_mesh_input_string_cmd *cmd = (void *) data; - uint8_t status = BTP_STATUS_SUCCESS; + const struct btp_mesh_input_string_cmd *cmd = (void *) data; + uint8_t status = BTP_STATUS_SUCCESS; uint8_t str_auth[16]; int err; @@ -541,8 +539,7 @@ input_string(uint8_t *data, uint16_t len) } rsp: - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INPUT_STRING, CONTROLLER_INDEX, - status); + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INPUT_STRING, status); } static void @@ -554,7 +551,7 @@ ivu_test_mode(uint8_t *data, uint16_t len) bt_mesh_iv_update_test(cmd->enable ? true : false); - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_IVU_TEST_MODE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_IVU_TEST_MODE, BTP_STATUS_SUCCESS); } @@ -570,7 +567,7 @@ ivu_toggle_state(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to toggle the IV Update state"); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_IVU_TOGGLE_STATE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_IVU_TOGGLE_STATE, result ? BTP_STATUS_SUCCESS : BTP_STATUS_FAILED); } @@ -589,7 +586,7 @@ lpn(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to toggle LPN (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); } @@ -605,7 +602,7 @@ lpn_poll(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to send poll msg (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_POLL, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_POLL, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); } @@ -613,7 +610,7 @@ static void net_send(uint8_t *data, uint16_t len) { struct btp_mesh_net_send_cmd *cmd = (void *) data; - struct os_mbuf *msg = NET_BUF_SIMPLE(UINT8_MAX); + struct os_mbuf *msg = NET_BUF_SIMPLE(UINT8_MAX); struct bt_mesh_msg_ctx ctx = { .net_idx = net.net_idx, .app_idx = vnd_app_key_idx, @@ -638,7 +635,7 @@ net_send(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to send (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_NET_SEND, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_NET_SEND, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); os_mbuf_free_chain(msg); @@ -648,8 +645,8 @@ static void health_generate_faults(uint8_t *data, uint16_t len) { struct btp_mesh_health_generate_faults_rp *rp; - struct os_mbuf *buf = NET_BUF_SIMPLE(sizeof(*rp) + sizeof(cur_faults) + - sizeof(reg_faults)); + struct os_mbuf *buf = NET_BUF_SIMPLE(sizeof(*rp) + sizeof(cur_faults) + + sizeof(reg_faults)); uint8_t some_faults[] = {0x01, 0x02, 0x03, 0xff, 0x06}; uint8_t cur_faults_count, reg_faults_count; @@ -682,14 +679,14 @@ health_clear_faults(uint8_t *data, uint16_t len) bt_mesh_fault_update(&elements[0]); tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_HEALTH_CLEAR_FAULTS, - CONTROLLER_INDEX, BTP_STATUS_SUCCESS); + BTP_STATUS_SUCCESS); } static void model_send(uint8_t *data, uint16_t len) { struct btp_mesh_model_send_cmd *cmd = (void *) data; - struct os_mbuf *msg = NET_BUF_SIMPLE(UINT8_MAX); + struct os_mbuf *msg = NET_BUF_SIMPLE(UINT8_MAX); struct bt_mesh_msg_ctx ctx = { .net_idx = net.net_idx, .app_idx = BT_MESH_KEY_DEV, @@ -728,7 +725,7 @@ model_send(uint8_t *data, uint16_t len) } fail: - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_MODEL_SEND, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_MODEL_SEND, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); os_mbuf_free_chain(msg); @@ -739,8 +736,8 @@ fail: static void lpn_subscribe(uint8_t *data, uint16_t len) { - struct btp_mesh_lpn_subscribe_cmd *cmd = (void *) data; - uint16_t address = sys_le16_to_cpu(cmd->address); + struct btp_mesh_lpn_subscribe_cmd *cmd = (void *) data; + uint16_t address = sys_le16_to_cpu(cmd->address); int err; SYS_LOG_DBG("address 0x%04x", address); @@ -750,15 +747,15 @@ lpn_subscribe(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to subscribe (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_SUBSCRIBE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_SUBSCRIBE, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); } static void lpn_unsubscribe(uint8_t *data, uint16_t len) { - struct btp_mesh_lpn_unsubscribe_cmd *cmd = (void *) data; - uint16_t address = sys_le16_to_cpu(cmd->address); + struct btp_mesh_lpn_unsubscribe_cmd *cmd = (void *) data; + uint16_t address = sys_le16_to_cpu(cmd->address); int err; SYS_LOG_DBG("address 0x%04x", address); @@ -768,7 +765,7 @@ lpn_unsubscribe(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to unsubscribe (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_UNSUBSCRIBE, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_UNSUBSCRIBE, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); } @@ -784,7 +781,7 @@ rpl_clear(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to clear RPL (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_RPL_CLEAR, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_RPL_CLEAR, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); } @@ -802,12 +799,12 @@ proxy_identity_enable(uint8_t *data, uint16_t len) SYS_LOG_ERR("Failed to enable proxy identity (err %d)", err); } - tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_PROXY_IDENTITY, CONTROLLER_INDEX, + tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_PROXY_IDENTITY, err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS); } void -tester_handle_mesh(uint8_t opcode, uint8_t index, uint8_t *data, uint16_t len) +tester_handle_mesh(uint8_t opcode, uint8_t *data, uint16_t len) { switch (opcode) { case BTP_MESH_READ_SUPPORTED_COMMANDS: @@ -870,7 +867,7 @@ tester_handle_mesh(uint8_t opcode, uint8_t index, uint8_t *data, uint16_t len) proxy_identity_enable(data, len); break; default: - tester_rsp(BTP_SERVICE_ID_MESH, opcode, index, + tester_rsp(BTP_SERVICE_ID_MESH, opcode, BTP_STATUS_UNKNOWN_CMD); break; } @@ -884,7 +881,7 @@ net_recv_ev(uint8_t ttl, const void *payload, size_t payload_len) { - struct os_mbuf *buf = NET_BUF_SIMPLE(UINT8_MAX); + struct os_mbuf *buf = NET_BUF_SIMPLE(UINT8_MAX); struct btp_mesh_net_recv_ev *ev; SYS_LOG_DBG("ttl 0x%02x ctl 0x%02x src 0x%04x dst 0x%04x " @@ -964,14 +961,14 @@ invalid_bearer_cb(uint8_t opcode) SYS_LOG_DBG("opcode 0x%02x", opcode); tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_INVALID_BEARER, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void incomp_timer_exp_cb(void) { tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_INCOMP_TIMER_EXP, - CONTROLLER_INDEX, NULL, 0); + NULL, 0); } static struct bt_test_cb bt_test_cb = { @@ -996,20 +993,20 @@ lpn_established(uint16_t friend_addr) friend_addr, lpn->queue_size, lpn->recv_win); tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_LPN_ESTABLISHED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } static void lpn_terminated(uint16_t friend_addr) { - struct bt_mesh_lpn *lpn = &bt_mesh.lpn; - struct btp_mesh_lpn_terminated_ev ev = {lpn->sub->net_idx, friend_addr}; + struct bt_mesh_lpn *lpn = &bt_mesh.lpn; + struct btp_mesh_lpn_terminated_ev ev = {lpn->sub->net_idx, friend_addr}; SYS_LOG_DBG("Friendship (as LPN) lost with Friend " "0x%04x", friend_addr); tester_send(BTP_SERVICE_ID_MESH, BTP_MESH_EV_LPN_TERMINATED, - CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev)); + (uint8_t *) &ev, sizeof(ev)); } void diff --git a/apps/bttester/src/bttester.c b/apps/bttester/src/bttester.c index 1bb22e7cf..f0d088630 100644 --- a/apps/bttester/src/bttester.c +++ b/apps/bttester/src/bttester.c @@ -47,15 +47,60 @@ struct btp_buf { uint8_t data[BTP_MTU]; struct btp_hdr hdr; }; + uint8_t rsp[BTP_MTU]; }; static struct btp_buf cmd_buf[CMD_QUEUED]; +static struct { + const struct btp_handler *handlers; + uint8_t num; +} service_handler[BTP_SERVICE_ID_MAX + 1]; + +static void +tester_send_with_index(uint8_t service, uint8_t opcode, uint8_t index, + uint8_t *data, size_t len); +static void +tester_rsp_with_index(uint8_t service, uint8_t opcode, uint8_t index, + uint8_t status); + +void +tester_register_command_handlers(uint8_t service, + const struct btp_handler *handlers, + size_t num) +{ + __ASSERT_NO_MSG(service <= BTP_SERVICE_ID_MAX); + __ASSERT_NO_MSG(service_handler[service].handlers == NULL); + + service_handler[service].handlers = handlers; + service_handler[service].num = num; +} + +static const struct btp_handler * +find_btp_handler(uint8_t service, uint8_t opcode) +{ + if ((service > BTP_SERVICE_ID_MAX) || + (service_handler[service].handlers == NULL)) { + return NULL; + } + + for (uint8_t i = 0; i < service_handler[service].num; i++) { + if (service_handler[service].handlers[i].opcode == opcode) { + return &service_handler[service].handlers[i]; + } + } + + return NULL; +} + static void cmd_handler(struct os_event *ev) { + const struct btp_handler *btp; uint16_t len; struct btp_buf *cmd; + uint8_t status; + uint16_t rsp_len = 0; if (!ev || !ev->ev_arg) { return; @@ -71,43 +116,30 @@ cmd_handler(struct os_event *ev) sizeof(cmd->hdr) + len)); } - /* TODO - * verify if service is registered before calling handler - */ + btp = find_btp_handler(cmd->hdr.service, cmd->hdr.opcode); + if (btp) { + if (btp->index != cmd->hdr.index) { + status = BTP_STATUS_FAILED; + } else if ((btp->expect_len >= 0) && (btp->expect_len != len)) { + status = BTP_STATUS_FAILED; + } else { + status = btp->func(cmd->hdr.data, len, + cmd->rsp, &rsp_len); + } - switch (cmd->hdr.service) { - case BTP_SERVICE_ID_CORE: - tester_handle_core(cmd->hdr.opcode, cmd->hdr.index, - cmd->hdr.data, len); - break; - case BTP_SERVICE_ID_GAP: - tester_handle_gap(cmd->hdr.opcode, cmd->hdr.index, - cmd->hdr.data, len); - break; - case BTP_SERVICE_ID_GATT: - tester_handle_gatt(cmd->hdr.opcode, cmd->hdr.index, - cmd->hdr.data, len); - break; -#if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) - case BTP_SERVICE_ID_L2CAP: - tester_handle_l2cap(cmd->hdr.opcode, cmd->hdr.index, - cmd->hdr.data, len); - break; -#endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */ -#if MYNEWT_VAL(BLE_MESH) - case BTP_SERVICE_ID_MESH: - tester_handle_mesh(cmd->hdr.opcode, cmd->hdr.index, - cmd->hdr.data, len); - break; -#endif /* MYNEWT_VAL(BLE_MESH) */ - case BTP_SERVICE_ID_GATTC: - tester_handle_gattc(cmd->hdr.opcode, cmd->hdr.index, - cmd->hdr.data, len); - break; - default: - tester_rsp(cmd->hdr.service, cmd->hdr.opcode, - cmd->hdr.index, BTP_STATUS_FAILED); - break; + __ASSERT_NO_MSG((rsp_len + sizeof(struct btp_hdr)) <= BTP_MTU); + } else { + status = BTP_STATUS_UNKNOWN_CMD; + } + + if (status != BTP_STATUS_DELAY_REPLY) { + if ((status == BTP_STATUS_SUCCESS) && rsp_len > 0) { + tester_send_with_index(cmd->hdr.service, cmd->hdr.opcode, + cmd->hdr.index, cmd->rsp, rsp_len); + } else { + tester_rsp_with_index(cmd->hdr.service, cmd->hdr.opcode, + cmd->hdr.index, status); + } } os_eventq_put(&avail_queue, ev); @@ -191,20 +223,23 @@ tester_init(void) bttester_pipe_register(buf->data, BTP_MTU, recv_cb); - tester_send(BTP_SERVICE_ID_CORE, BTP_CORE_EV_IUT_READY, BTP_INDEX_NONE, - NULL, 0); + /* core service is always available */ + tester_init_core(); + + tester_send_with_index(BTP_SERVICE_ID_CORE, BTP_CORE_EV_IUT_READY, + BTP_INDEX_NONE, NULL, 0); } -void -tester_send(uint8_t service, uint8_t opcode, uint8_t index, uint8_t *data, - size_t len) +static void +tester_send_with_index(uint8_t service, uint8_t opcode, uint8_t index, + uint8_t *data, size_t len) { struct btp_hdr msg; msg.service = service; msg.opcode = opcode; msg.index = index; - msg.len = len; + msg.len = sys_cpu_to_le16(len); bttester_pipe_send((uint8_t *) &msg, sizeof(msg)); if (data && len) { @@ -238,16 +273,29 @@ tester_send_buf(uint8_t service, uint8_t opcode, uint8_t index, } } -void -tester_rsp(uint8_t service, uint8_t opcode, uint8_t index, uint8_t status) +static void +tester_rsp_with_index(uint8_t service, uint8_t opcode, uint8_t index, + uint8_t status) { struct btp_status s; if (status == BTP_STATUS_SUCCESS) { - tester_send(service, opcode, index, NULL, 0); + tester_send_with_index(service, opcode, index, NULL, 0); return; } s.code = status; - tester_send(service, BTP_STATUS, index, (uint8_t *) &s, sizeof(s)); + tester_send_with_index(service, BTP_STATUS, index, (uint8_t *) &s, sizeof(s)); +} + +void +tester_send(uint8_t service, uint8_t opcode, uint8_t *data, size_t len) +{ + tester_send_with_index(service, opcode, BTP_INDEX, data, len); +} + +void +tester_rsp(uint8_t service, uint8_t opcode, uint8_t status) +{ + tester_rsp_with_index(service, opcode, BTP_INDEX, status); } diff --git a/apps/bttester/src/glue.h b/apps/bttester/src/glue.h index 0372d757f..024f79564 100644 --- a/apps/bttester/src/glue.h +++ b/apps/bttester/src/glue.h @@ -67,4 +67,23 @@ net_buf_simple_push(struct os_mbuf *om, uint8_t len); const char * bt_hex(const void *buf, size_t len); +/** + * INTERNAL_HIDDEN @endcond + */ + +/** + * @brief Define an array of atomic variables. + * + * This macro defines an array of atomic variables containing at least + * @a num_bits bits. + * + * @note + * If used from file scope, the bits of the array are initialized to zero; + * if used from within a function, the bits are left uninitialized. + * + * @param name Name of array of atomic variables. + * @param num_bits Number of bits needed. + */ +#define ATOMIC_DEFINE(name, num_bits) \ + atomic_t name[1 + ((num_bits) - 1) / ATOMIC_BITS] #endif /* __GLUE_H__ */