This is an automated email from the ASF dual-hosted git repository. janc pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit 2d4c591e27066cd17769d0e65bc499a43c17f6c4 Author: Krzysztof Kopyściński <[email protected]> AuthorDate: Fri Jul 7 14:33:08 2023 +0200 apps/bttester: refactor BTP handling This commit refactors BTP handling to new model, where API is provided for registration of handlers for BTP commands as callbacks. New API provides also size check and common buffer for response. Removes Controlle Index validation from BTP handlers, as these are always 0. Corrected some formatting for variable declarations. This refactors only core and GAP service into new API, rest of services will not work but are compiled. They will be refactored in following commits. --- apps/bttester/src/btp/btp.h | 8 + apps/bttester/src/btp/btp_gap.h | 7 + apps/bttester/src/btp/bttester.h | 32 +- apps/bttester/src/btp_core.c | 176 ++++---- apps/bttester/src/btp_gap.c | 900 ++++++++++++++++++++------------------- apps/bttester/src/btp_gatt.c | 181 ++++---- apps/bttester/src/btp_gatt_cl.c | 111 +++-- apps/bttester/src/btp_l2cap.c | 66 +-- apps/bttester/src/btp_mesh.c | 91 ++-- apps/bttester/src/bttester.c | 142 ++++-- apps/bttester/src/glue.h | 19 + 11 files changed, 929 insertions(+), 804 deletions(-) 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 <sys/types.h> 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; - - memset(buf, 0, sizeof(buf)); + struct btp_core_read_supported_services_rp *rp = rsp; - 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); + + *rsp_len = sizeof(*rp) + 2; - tester_send(BTP_SERVICE_ID_CORE, BTP_CORE_READ_SUPPORTED_SERVICES, - BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf)); + 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; + + /* 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); + + /* 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); + + /* 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); + + /* 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; - SYS_LOG_DBG(""); - - memset(cmds, 0, sizeof(cmds)); - - 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); - - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_READ_SUPPORTED_COMMANDS, - CONTROLLER_INDEX, (uint8_t *) rp, sizeof(cmds)); + 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)); + *rsp_len = sizeof(*rp); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_READ_CONTROLLER_INFO, - CONTROLLER_INDEX, (uint8_t *) &rp, 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); + + *rsp_len = sizeof(*rp); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_SET_CONNECTABLE, CONTROLLER_INDEX, - (uint8_t *) &rp, 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); + + *rsp_len = sizeof(*rp); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_STOP_ADVERTISING, CONTROLLER_INDEX, - (uint8_t *) &rp, 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); + *rsp_len = sizeof(*rp); - tester_send(BTP_SERVICE_ID_GAP, BTP_GAP_OOB_SC_GET_LOCAL_DATA, - CONTROLLER_INDEX, (uint8_t *) &rp, 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); -} - -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; + err = ble_gap_wl_set(cp->addrs, cp->list_len); + if (err != 0) { + return BTP_STATUS_FAILED; } - 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; - } + return BTP_STATUS_SUCCESS; } +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 - */ - - 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; + 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); + } + + __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__ */
