espressif/esp-nimble
1
0
Fork 0
mirror of https://github.com/espressif/esp-nimble.git synced 2026-06-06 05:14:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

apps/bttester: refactor Mesh service

Browse Source 
Accomodate to new API.
This commit is contained in:
Krzysztof Kopyściński
2023-07-12 12:21:16 +02:00
committed by Szymon Janc
parent 2210018c04
commit 8abb2ecef8
2 changed files with 301 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/bttester/src/btp/bttester.h
-2
View File
@@ -127,8 +127,6 @@ uint8_t
tester_init_mesh(void);
uint8_t
tester_unregister_mesh(void);
void
tester_handle_mesh(uint8_t opcode, uint8_t *data, uint16_t len);
#endif /* MYNEWT_VAL(BLE_MESH) */
void
apps/bttester/src/btp_mesh.c
+301 -244
View File
@@ -84,42 +84,40 @@ static struct {
.dst = BT_MESH_ADDR_UNASSIGNED,
};
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)
{
struct os_mbuf *buf = NET_BUF_SIMPLE(BTP_DATA_MAX_SIZE);
struct btp_mesh_read_supported_commands_rp *rp = rsp;
net_buf_simple_init(buf, 0);
/* 1st octet */
memset(net_buf_simple_add(buf, 1), 0, 1);
tester_set_bit(buf->om_data, BTP_MESH_READ_SUPPORTED_COMMANDS);
tester_set_bit(buf->om_data, BTP_MESH_CONFIG_PROVISIONING);
tester_set_bit(buf->om_data, BTP_MESH_PROVISION_NODE);
tester_set_bit(buf->om_data, BTP_MESH_INIT);
tester_set_bit(buf->om_data, BTP_MESH_RESET);
tester_set_bit(buf->om_data, BTP_MESH_INPUT_NUMBER);
tester_set_bit(buf->om_data, BTP_MESH_INPUT_STRING);
/* 2nd octet */
tester_set_bit(buf->om_data, BTP_MESH_IVU_TEST_MODE);
tester_set_bit(buf->om_data, BTP_MESH_IVU_TOGGLE_STATE);
tester_set_bit(buf->om_data, BTP_MESH_NET_SEND);
tester_set_bit(buf->om_data, BTP_MESH_HEALTH_GENERATE_FAULTS);
tester_set_bit(buf->om_data, BTP_MESH_HEALTH_CLEAR_FAULTS);
tester_set_bit(buf->om_data, BTP_MESH_LPN);
tester_set_bit(buf->om_data, BTP_MESH_LPN_POLL);
tester_set_bit(buf->om_data, BTP_MESH_MODEL_SEND);
/* 3rd octet */
memset(net_buf_simple_add(buf, 1), 0, 1);
/* octet 0 */
tester_set_bit(rp->data, BTP_MESH_READ_SUPPORTED_COMMANDS);
tester_set_bit(rp->data, BTP_MESH_CONFIG_PROVISIONING);
tester_set_bit(rp->data, BTP_MESH_PROVISION_NODE);
tester_set_bit(rp->data, BTP_MESH_INIT);
tester_set_bit(rp->data, BTP_MESH_RESET);
tester_set_bit(rp->data, BTP_MESH_INPUT_NUMBER);
tester_set_bit(rp->data, BTP_MESH_INPUT_STRING);
/* octet 1 */
tester_set_bit(rp->data, BTP_MESH_IVU_TEST_MODE);
tester_set_bit(rp->data, BTP_MESH_IVU_TOGGLE_STATE);
tester_set_bit(rp->data, BTP_MESH_NET_SEND);
tester_set_bit(rp->data, BTP_MESH_HEALTH_GENERATE_FAULTS);
tester_set_bit(rp->data, BTP_MESH_HEALTH_CLEAR_FAULTS);
tester_set_bit(rp->data, BTP_MESH_LPN);
tester_set_bit(rp->data, BTP_MESH_LPN_POLL);
tester_set_bit(rp->data, BTP_MESH_MODEL_SEND);
/* octet 2 */
#if MYNEWT_VAL(BLE_MESH_TESTING)
tester_set_bit(buf->om_data, BTP_MESH_LPN_SUBSCRIBE);
tester_set_bit(buf->om_data, BTP_MESH_LPN_UNSUBSCRIBE);
tester_set_bit(buf->om_data, BTP_MESH_RPL_CLEAR);
tester_set_bit(rp->data, BTP_MESH_LPN_SUBSCRIBE);
tester_set_bit(rp->data, BTP_MESH_LPN_UNSUBSCRIBE);
tester_set_bit(rp->data, BTP_MESH_RPL_CLEAR);
#endif /* CONFIG_BT_TESTING */
tester_set_bit(buf->om_data, BTP_MESH_PROXY_IDENTITY);
tester_set_bit(rp->data, BTP_MESH_PROXY_IDENTITY);
tester_send_buf(BTP_SERVICE_ID_MESH, BTP_MESH_READ_SUPPORTED_COMMANDS,
CONTROLLER_INDEX, buf);
*rsp_len = sizeof(*rp) + 3;
return BTP_STATUS_SUCCESS;
}
static void
@@ -410,153 +408,161 @@ static struct bt_mesh_prov prov = {
.reset = prov_reset,
};
static void
config_prov(uint8_t *data, uint16_t len)
static uint8_t
config_prov(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
const struct btp_mesh_config_provisioning_cmd *cmd = (void *) data;
const struct btp_mesh_config_provisioning_cmd *cp = cmd;
SYS_LOG_DBG("");
memcpy(dev_uuid, cmd->uuid, sizeof(dev_uuid));
memcpy(static_auth, cmd->static_auth, sizeof(static_auth));
if (cmd_len < sizeof(*cp)) {
return BTP_STATUS_FAILED;
}
prov.output_size = cmd->out_size;
prov.output_actions = sys_le16_to_cpu(cmd->out_actions);
prov.input_size = cmd->in_size;
prov.input_actions = sys_le16_to_cpu(cmd->in_actions);
memcpy(dev_uuid, cp->uuid, sizeof(dev_uuid));
memcpy(static_auth, cp->static_auth, sizeof(static_auth));
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_CONFIG_PROVISIONING,
BTP_STATUS_SUCCESS);
prov.output_size = cp->out_size;
prov.output_actions = sys_le16_to_cpu(cp->out_actions);
prov.input_size = cp->in_size;
prov.input_actions = sys_le16_to_cpu(cp->in_actions);
return BTP_STATUS_SUCCESS;
}
static void
provision_node(uint8_t *data, uint16_t len)
static uint8_t
provision_node(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
const struct btp_mesh_provision_node_cmd *cmd = (void *) data;
const struct btp_mesh_provision_node_cmd *cp = cmd;
SYS_LOG_DBG("");
memcpy(dev_key, cmd->dev_key, sizeof(dev_key));
memcpy(net_key, cmd->net_key, sizeof(net_key));
if (cmd_len != sizeof(*cp)) {
return BTP_STATUS_FAILED;
}
addr = sys_le16_to_cpu(cmd->addr);
flags = cmd->flags;
iv_index = le32toh(cmd->iv_index);
net_key_idx = sys_le16_to_cpu(cmd->net_key_idx);
memcpy(dev_key, cp->dev_key, sizeof(dev_key));
memcpy(net_key, cp->net_key, sizeof(net_key));
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_PROVISION_NODE,
BTP_STATUS_SUCCESS);
addr = sys_le16_to_cpu(cp->addr);
flags = cp->flags;
iv_index = le32toh(cp->iv_index);
net_key_idx = sys_le16_to_cpu(cp->net_key_idx);
return BTP_STATUS_SUCCESS;
}
static void
init(uint8_t *data, uint16_t len)
static uint8_t
init(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
uint8_t status = BTP_STATUS_SUCCESS;
int err;
SYS_LOG_DBG("");
err = bt_mesh_init(own_addr_type, &prov, &comp);
if (err) {
status = BTP_STATUS_FAILED;
goto rsp;
return BTP_STATUS_FAILED;
}
if (addr) {
err = bt_mesh_provision(net_key, net_key_idx, flags, iv_index,
addr, dev_key);
if (err) {
status = BTP_STATUS_FAILED;
return BTP_STATUS_FAILED;
}
} else {
err = bt_mesh_prov_enable(BT_MESH_PROV_ADV | BT_MESH_PROV_GATT);
if (err) {
status = BTP_STATUS_FAILED;
return BTP_STATUS_FAILED;
}
}
rsp:
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INIT, status);
return BTP_STATUS_SUCCESS;
}
static void
reset(uint8_t *data, uint16_t len)
static uint8_t
reset(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
SYS_LOG_DBG("");
bt_mesh_reset();
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_RESET,
BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
input_number(uint8_t *data, uint16_t len)
static uint8_t
input_number(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
const struct btp_mesh_input_number_cmd *cmd = (void *) data;
uint8_t status = BTP_STATUS_SUCCESS;
const struct btp_mesh_input_number_cmd *cp = cmd;
uint32_t number;
int err;
number = le32toh(cmd->number);
number = le32toh(cp->number);
SYS_LOG_DBG("number 0x%04lx", number);
err = bt_mesh_input_number(number);
if (err) {
status = BTP_STATUS_FAILED;
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INPUT_NUMBER, status);
return BTP_STATUS_SUCCESS;
}
static void
input_string(uint8_t *data, uint16_t len)
static uint8_t
input_string(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
const struct btp_mesh_input_string_cmd *cmd = (void *) data;
uint8_t status = BTP_STATUS_SUCCESS;
uint8_t str_auth[16];
const struct btp_mesh_input_string_cmd *cp = cmd;
int err;
SYS_LOG_DBG("");
if (cmd->string_len > sizeof(str_auth)) {
SYS_LOG_ERR("Too long input (%u chars required)", input_size);
status = BTP_STATUS_FAILED;
goto rsp;
} else if (cmd->string_len < input_size) {
if (cmd_len < sizeof(*cp) &&
cmd_len != (sizeof(*cp) + cp->string_len)) {
return BTP_STATUS_FAILED;
}
/* for historical reasons this commands must send NULL terminated
* string
*/
if (cp->string[cp->string_len] != '\0') {
return BTP_STATUS_FAILED;
}
if (strlen((char *)cp->string) < input_size) {
SYS_LOG_ERR("Too short input (%u chars required)", input_size);
status = BTP_STATUS_FAILED;
goto rsp;
return BTP_STATUS_FAILED;
}
strncpy((char *) str_auth, (char *) cmd->string, cmd->string_len);
err = bt_mesh_input_string((char *) str_auth);
err = bt_mesh_input_string((char *)cp->string);
if (err) {
status = BTP_STATUS_FAILED;
return BTP_STATUS_FAILED;
}
rsp:
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_INPUT_STRING, status);
return BTP_STATUS_SUCCESS;
}
static void
ivu_test_mode(uint8_t *data, uint16_t len)
static uint8_t
ivu_test_mode(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
const struct btp_mesh_ivu_test_mode_cmd *cmd = (void *) data;
const struct btp_mesh_ivu_test_mode_cmd *cp = cmd;
SYS_LOG_DBG("enable 0x%02x", cmd->enable);
SYS_LOG_DBG("enable 0x%02x", cp->enable);
bt_mesh_iv_update_test(cmd->enable ? true : false);
bt_mesh_iv_update_test(cp->enable ? true : false);
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_IVU_TEST_MODE,
BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
ivu_toggle_state(uint8_t *data, uint16_t len)
static uint8_t
ivu_toggle_state(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
bool result;
@@ -565,33 +571,35 @@ ivu_toggle_state(uint8_t *data, uint16_t len)
result = bt_mesh_iv_update();
if (!result) {
SYS_LOG_ERR("Failed to toggle the IV Update state");
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_IVU_TOGGLE_STATE,
result ? BTP_STATUS_SUCCESS : BTP_STATUS_FAILED);
return BTP_STATUS_SUCCESS;
}
static void
lpn(uint8_t *data, uint16_t len)
static uint8_t
lpn(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
struct btp_mesh_lpn_set_cmd *cmd = (void *) data;
const struct btp_mesh_lpn_set_cmd *cp = cmd;
bool enable;
int err;
SYS_LOG_DBG("enable 0x%02x", cmd->enable);
SYS_LOG_DBG("enable 0x%02x", cp->enable);
enable = cmd->enable ? true : false;
enable = cp->enable ? true : false;
err = bt_mesh_lpn_set(enable);
if (err) {
SYS_LOG_ERR("Failed to toggle LPN (err %d)", err);
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
lpn_poll(uint8_t *data, uint16_t len)
static uint8_t
lpn_poll(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
int err;
@@ -600,27 +608,34 @@ lpn_poll(uint8_t *data, uint16_t len)
err = bt_mesh_lpn_poll();
if (err) {
SYS_LOG_ERR("Failed to send poll msg (err %d)", err);
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_POLL,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
net_send(uint8_t *data, uint16_t len)
static uint8_t
net_send(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
struct btp_mesh_net_send_cmd *cmd = (void *) data;
const struct btp_mesh_net_send_cmd *cp = cmd;
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,
.addr = sys_le16_to_cpu(cmd->dst),
.send_ttl = cmd->ttl,
.addr = sys_le16_to_cpu(cp->dst),
.send_ttl = cp->ttl,
};
int err;
int status = BTP_STATUS_SUCCESS;
if (cmd_len < sizeof(*cp) &&
cmd_len != (sizeof(*cp) + cp->payload_len)) {
return BTP_STATUS_FAILED;
}
SYS_LOG_DBG("ttl 0x%02x dst 0x%04x payload_len %d", ctx.send_ttl,
ctx.addr, cmd->payload_len);
ctx.addr, cp->payload_len);
if (!bt_mesh_app_key_exists(vnd_app_key_idx)) {
(void) bt_mesh_app_key_add(vnd_app_key_idx, net.net_idx,
@@ -628,48 +643,47 @@ net_send(uint8_t *data, uint16_t len)
vnd_models[0].keys[0] = vnd_app_key_idx;
}
net_buf_simple_add_mem(msg, cmd->payload, cmd->payload_len);
net_buf_simple_add_mem(msg, cp->payload, cp->payload_len);
err = bt_mesh_model_send(&vnd_models[0], &ctx, msg, NULL, NULL);
if (err) {
SYS_LOG_ERR("Failed to send (err %d)", err);
status = BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_NET_SEND,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
os_mbuf_free_chain(msg);
return status;
}
static void
health_generate_faults(uint8_t *data, uint16_t len)
static uint8_t
health_generate_faults(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_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 btp_mesh_health_generate_faults_rp *rp = rsp;
uint8_t some_faults[] = {0x01, 0x02, 0x03, 0xff, 0x06};
uint8_t cur_faults_count, reg_faults_count;
rp = net_buf_simple_add(buf, sizeof(*rp));
cur_faults_count = min(sizeof(cur_faults), sizeof(some_faults));
memcpy(cur_faults, some_faults, cur_faults_count);
net_buf_simple_add_mem(buf, cur_faults, cur_faults_count);
memcpy(rp->current_faults, cur_faults, cur_faults_count);
rp->cur_faults_count = cur_faults_count;
reg_faults_count = min(sizeof(reg_faults), sizeof(some_faults));
memcpy(reg_faults, some_faults, reg_faults_count);
net_buf_simple_add_mem(buf, reg_faults, reg_faults_count);
memcpy(rp->registered_faults + cur_faults_count, reg_faults, reg_faults_count);
rp->reg_faults_count = reg_faults_count;
bt_mesh_fault_update(&elements[0]);
tester_send_buf(BTP_SERVICE_ID_MESH, BTP_MESH_HEALTH_GENERATE_FAULTS,
CONTROLLER_INDEX, buf);
*rsp_len = sizeof(*rp) + cur_faults_count + reg_faults_count;
return BTP_STATUS_SUCCESS;
}
static void
health_clear_faults(uint8_t *data, uint16_t len)
static uint8_t
health_clear_faults(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
SYS_LOG_DBG("");
@@ -678,24 +692,33 @@ 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,
BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
model_send(uint8_t *data, uint16_t len)
static uint8_t
model_send(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
struct btp_mesh_model_send_cmd *cmd = (void *) data;
const struct btp_mesh_model_send_cmd *cp = cmd;
struct os_mbuf *msg = NET_BUF_SIMPLE(UINT8_MAX);
struct bt_mesh_model *model = NULL;
int err, i;
uint16_t src;
int status = BTP_STATUS_SUCCESS;
if (cmd_len < sizeof(*cp) &&
cmd_len != (sizeof(*cp) + cp->payload_len)) {
return BTP_STATUS_FAILED;
}
struct bt_mesh_msg_ctx ctx = {
.net_idx = net.net_idx,
.app_idx = BT_MESH_KEY_DEV,
.addr = sys_le16_to_cpu(cmd->dst),
.addr = sys_le16_to_cpu(cp->dst),
.send_ttl = BT_MESH_TTL_DEFAULT,
};
struct bt_mesh_model *model = NULL;
int err, i;
uint16_t src = sys_le16_to_cpu(cmd->src);
src = sys_le16_to_cpu(cp->src);
/* Lookup source address */
for (i = 0; i < ARRAY_SIZE(model_bound); i++) {
@@ -709,35 +732,35 @@ model_send(uint8_t *data, uint16_t len)
if (!model) {
SYS_LOG_ERR("Model not found");
err = -EINVAL;
status = BTP_STATUS_FAILED;
goto fail;
goto rsp;
}
SYS_LOG_DBG("src 0x%04x dst 0x%04x model %p payload_len %d", src,
ctx.addr, model, cmd->payload_len);
ctx.addr, model, cp->payload_len);
net_buf_simple_add_mem(msg, cmd->payload, cmd->payload_len);
net_buf_simple_add_mem(msg, cp->payload, cp->payload_len);
err = bt_mesh_model_send(model, &ctx, msg, NULL, NULL);
if (err) {
SYS_LOG_ERR("Failed to send (err %d)", err);
status = BTP_STATUS_FAILED;
}
fail:
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_MODEL_SEND,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
rsp:
os_mbuf_free_chain(msg);
return status;
}
#if MYNEWT_VAL(BLE_MESH_TESTING)
static void
lpn_subscribe(uint8_t *data, uint16_t len)
static uint8_t
lpn_subscribe(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
struct btp_mesh_lpn_subscribe_cmd *cmd = (void *) data;
uint16_t address = sys_le16_to_cpu(cmd->address);
const struct btp_mesh_lpn_subscribe_cmd *cp = cmd;
uint16_t address = sys_le16_to_cpu(cp->address);
int err;
SYS_LOG_DBG("address 0x%04x", address);
@@ -747,15 +770,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,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
lpn_unsubscribe(uint8_t *data, uint16_t len)
static uint8_t
lpn_unsubscribe(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
struct btp_mesh_lpn_unsubscribe_cmd *cmd = (void *) data;
uint16_t address = sys_le16_to_cpu(cmd->address);
const struct btp_mesh_lpn_unsubscribe_cmd *cp = cmd;
uint16_t address = sys_le16_to_cpu(cp->address);
int err;
SYS_LOG_DBG("address 0x%04x", address);
@@ -763,14 +786,15 @@ lpn_unsubscribe(uint8_t *data, uint16_t len)
err = bt_test_mesh_lpn_group_remove(&address, 1);
if (err) {
SYS_LOG_ERR("Failed to unsubscribe (err %d)", err);
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_LPN_UNSUBSCRIBE,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
static void
rpl_clear(uint8_t *data, uint16_t len)
static uint8_t
rpl_clear(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
int err;
@@ -779,16 +803,17 @@ rpl_clear(uint8_t *data, uint16_t len)
err = bt_test_mesh_rpl_clear();
if (err) {
SYS_LOG_ERR("Failed to clear RPL (err %d)", err);
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_RPL_CLEAR,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
#endif /* MYNEWT_VAL(BLE_MESH_TESTING) */
static void
proxy_identity_enable(uint8_t *data, uint16_t len)
static uint8_t
proxy_identity_enable(const void *cmd, uint16_t cmd_len,
void *rsp, uint16_t *rsp_len)
{
int err;
@@ -797,81 +822,110 @@ proxy_identity_enable(uint8_t *data, uint16_t len)
err = bt_mesh_proxy_identity_enable();
if (err) {
SYS_LOG_ERR("Failed to enable proxy identity (err %d)", err);
return BTP_STATUS_FAILED;
}
tester_rsp(BTP_SERVICE_ID_MESH, BTP_MESH_PROXY_IDENTITY,
err ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS);
return BTP_STATUS_SUCCESS;
}
void
tester_handle_mesh(uint8_t opcode, uint8_t *data, uint16_t len)
{
switch (opcode) {
case BTP_MESH_READ_SUPPORTED_COMMANDS:
supported_commands(data, len);
break;
case BTP_MESH_CONFIG_PROVISIONING:
config_prov(data, len);
break;
case BTP_MESH_PROVISION_NODE:
provision_node(data, len);
break;
case BTP_MESH_INIT:
init(data, len);
break;
case BTP_MESH_RESET:
reset(data, len);
break;
case BTP_MESH_INPUT_NUMBER:
input_number(data, len);
break;
case BTP_MESH_INPUT_STRING:
input_string(data, len);
break;
case BTP_MESH_IVU_TEST_MODE:
ivu_test_mode(data, len);
break;
case BTP_MESH_IVU_TOGGLE_STATE:
ivu_toggle_state(data, len);
break;
case BTP_MESH_LPN:
lpn(data, len);
break;
case BTP_MESH_LPN_POLL:
lpn_poll(data, len);
break;
case BTP_MESH_NET_SEND:
net_send(data, len);
break;
case BTP_MESH_HEALTH_GENERATE_FAULTS:
health_generate_faults(data, len);
break;
case BTP_MESH_HEALTH_CLEAR_FAULTS:
health_clear_faults(data, len);
break;
case BTP_MESH_MODEL_SEND:
model_send(data, len);
break;
#if MYNEWT_VAL(BLE_MESH_TESTING)
case BTP_MESH_LPN_SUBSCRIBE:
lpn_subscribe(data, len);
break;
case BTP_MESH_LPN_UNSUBSCRIBE:
lpn_unsubscribe(data, len);
break;
case BTP_MESH_RPL_CLEAR:
rpl_clear(data, len);
break;
#endif /* MYNEWT_VAL(BLE_MESH_TESTING) */
case BTP_MESH_PROXY_IDENTITY:
proxy_identity_enable(data, len);
break;
default:
tester_rsp(BTP_SERVICE_ID_MESH, opcode,
BTP_STATUS_UNKNOWN_CMD);
break;
}
}
static const struct btp_handler handlers[] = {
{
.opcode = BTP_MESH_READ_SUPPORTED_COMMANDS,
.index = BTP_INDEX_NONE,
.expect_len = 0,
.func = supported_commands,
},
{
.opcode = BTP_MESH_CONFIG_PROVISIONING,
.expect_len = -1,
.func = config_prov,
},
{
.opcode = BTP_MESH_PROVISION_NODE,
.expect_len = -1,
.func = provision_node,
},
{
.opcode = BTP_MESH_INIT,
.expect_len = 0,
.func = init,
},
{
.opcode = BTP_MESH_RESET,
.expect_len = 0,
.func = reset,
},
{
.opcode = BTP_MESH_INPUT_NUMBER,
.expect_len = sizeof(struct btp_mesh_input_number_cmd),
.func = input_number,
},
{
.opcode = BTP_MESH_INPUT_STRING,
.expect_len = -1,
.func = input_string,
},
{
.opcode = BTP_MESH_IVU_TEST_MODE,
.expect_len = sizeof(struct btp_mesh_ivu_test_mode_cmd),
.func = ivu_test_mode,
},
{
.opcode = BTP_MESH_IVU_TOGGLE_STATE,
.expect_len = 0,
.func = ivu_toggle_state,
},
{
.opcode = BTP_MESH_LPN,
.expect_len = sizeof(struct btp_mesh_lpn_set_cmd),
.func = lpn,
},
{
.opcode = BTP_MESH_LPN_POLL,
.expect_len = 0,
.func = lpn_poll,
},
{
.opcode = BTP_MESH_NET_SEND,
.expect_len = -1,
.func = net_send,
},
{
.opcode = BTP_MESH_HEALTH_GENERATE_FAULTS,
.expect_len = 0,
.func = health_generate_faults,
},
{
.opcode = BTP_MESH_HEALTH_CLEAR_FAULTS,
.expect_len = 0,
.func = health_clear_faults,
},
{
.opcode = BTP_MESH_MODEL_SEND,
.expect_len = -1,
.func = model_send,
},
{
.opcode = BTP_MESH_LPN_SUBSCRIBE,
.expect_len = sizeof(struct btp_mesh_lpn_subscribe_cmd),
.func = lpn_subscribe,
},
{
.opcode = BTP_MESH_LPN_UNSUBSCRIBE,
.expect_len = sizeof(struct btp_mesh_lpn_unsubscribe_cmd),
.func = lpn_unsubscribe,
},
{
.opcode = BTP_MESH_RPL_CLEAR,
.expect_len = 0,
.func = rpl_clear,
},
{
.opcode = BTP_MESH_PROXY_IDENTITY,
.expect_len = 0,
.func = proxy_identity_enable,
},
};
void
net_recv_ev(uint8_t ttl,
@@ -1029,6 +1083,9 @@ tester_init_mesh(void)
bt_test_cb_register(&bt_test_cb);
}
tester_register_command_handlers(BTP_SERVICE_ID_MESH, handlers,
ARRAY_SIZE(handlers));
return BTP_STATUS_SUCCESS;
}