| /* |
| * Copyright (c) 2017 Intel Corporation |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <stdlib.h> |
| #include <ctype.h> |
| #include <zephyr/kernel.h> |
| #include <zephyr/sys/printk.h> |
| #include <zephyr/sys/util.h> |
| |
| #include <zephyr/shell/shell.h> |
| #include <zephyr/settings/settings.h> |
| |
| #include <zephyr/bluetooth/bluetooth.h> |
| #include <zephyr/bluetooth/mesh.h> |
| #include <zephyr/bluetooth/mesh/shell.h> |
| |
| /* Private includes for raw Network & Transport layer access */ |
| #include "mesh/mesh.h" |
| #include "mesh/net.h" |
| #include "mesh/rpl.h" |
| #include "mesh/transport.h" |
| #include "mesh/foundation.h" |
| #include "mesh/settings.h" |
| #include "mesh/access.h" |
| #include "utils.h" |
| #include "dfu.h" |
| #include "blob.h" |
| |
| #define CID_NVAL 0xffff |
| #define COMPANY_ID_LF 0x05F1 |
| #define COMPANY_ID_NORDIC_SEMI 0x05F9 |
| |
| const struct shell *bt_mesh_shell_ctx_shell; |
| |
| struct bt_mesh_shell_target bt_mesh_shell_target_ctx = { |
| .dst = BT_MESH_ADDR_UNASSIGNED, |
| }; |
| |
| #define shell_print_ctx(_ft, ...) \ |
| do { \ |
| if (bt_mesh_shell_ctx_shell != NULL) { \ |
| shell_print(bt_mesh_shell_ctx_shell, _ft, ##__VA_ARGS__); \ |
| } \ |
| } while (0) |
| |
| /* Default net, app & dev key values, unless otherwise specified */ |
| const uint8_t bt_mesh_shell_default_key[16] = { |
| 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, |
| 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, |
| }; |
| |
| #if defined(CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE) |
| static uint8_t cur_faults[BT_MESH_SHELL_CUR_FAULTS_MAX]; |
| static uint8_t reg_faults[BT_MESH_SHELL_CUR_FAULTS_MAX * 2]; |
| |
| static void get_faults(uint8_t *faults, uint8_t faults_size, uint8_t *dst, uint8_t *count) |
| { |
| uint8_t i, limit = *count; |
| |
| for (i = 0U, *count = 0U; i < faults_size && *count < limit; i++) { |
| if (faults[i]) { |
| *dst++ = faults[i]; |
| (*count)++; |
| } |
| } |
| } |
| |
| static int fault_get_cur(const struct bt_mesh_model *model, uint8_t *test_id, |
| uint16_t *company_id, uint8_t *faults, uint8_t *fault_count) |
| { |
| shell_print_ctx("Sending current faults"); |
| |
| *test_id = 0x00; |
| *company_id = BT_COMP_ID_LF; |
| |
| get_faults(cur_faults, sizeof(cur_faults), faults, fault_count); |
| |
| return 0; |
| } |
| |
| static int fault_get_reg(const struct bt_mesh_model *model, uint16_t cid, |
| uint8_t *test_id, uint8_t *faults, uint8_t *fault_count) |
| { |
| if (cid != CONFIG_BT_COMPANY_ID) { |
| shell_print_ctx("Faults requested for unknown Company ID" |
| " 0x%04x", cid); |
| return -EINVAL; |
| } |
| |
| shell_print_ctx("Sending registered faults"); |
| |
| *test_id = 0x00; |
| |
| get_faults(reg_faults, sizeof(reg_faults), faults, fault_count); |
| |
| return 0; |
| } |
| |
| static int fault_clear(const struct bt_mesh_model *model, uint16_t cid) |
| { |
| if (cid != CONFIG_BT_COMPANY_ID) { |
| return -EINVAL; |
| } |
| |
| (void)memset(reg_faults, 0, sizeof(reg_faults)); |
| |
| return 0; |
| } |
| |
| static int fault_test(const struct bt_mesh_model *model, uint8_t test_id, |
| uint16_t cid) |
| { |
| if (cid != CONFIG_BT_COMPANY_ID) { |
| return -EINVAL; |
| } |
| |
| if (test_id != 0x00) { |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static void attention_on(const struct bt_mesh_model *model) |
| { |
| shell_print_ctx("Attention On"); |
| } |
| |
| static void attention_off(const struct bt_mesh_model *model) |
| { |
| shell_print_ctx("Attention Off"); |
| } |
| |
| static const struct bt_mesh_health_srv_cb health_srv_cb = { |
| .fault_get_cur = fault_get_cur, |
| .fault_get_reg = fault_get_reg, |
| .fault_clear = fault_clear, |
| .fault_test = fault_test, |
| .attn_on = attention_on, |
| .attn_off = attention_off, |
| }; |
| #endif /* CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE */ |
| |
| #ifdef CONFIG_BT_MESH_LARGE_COMP_DATA_SRV |
| static uint8_t health_tests[] = { |
| BT_MESH_HEALTH_TEST_INFO(COMPANY_ID_LF, 6, 0x01, 0x02, 0x03, 0x04, 0x34, 0x15), |
| BT_MESH_HEALTH_TEST_INFO(COMPANY_ID_NORDIC_SEMI, 3, 0x01, 0x02, 0x03), |
| }; |
| |
| static struct bt_mesh_models_metadata_entry health_srv_meta[] = { |
| BT_MESH_HEALTH_TEST_INFO_METADATA(health_tests), |
| BT_MESH_MODELS_METADATA_END, |
| }; |
| #endif |
| |
| struct bt_mesh_health_srv bt_mesh_shell_health_srv = { |
| #if defined(CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE) |
| .cb = &health_srv_cb, |
| #endif |
| #ifdef CONFIG_BT_MESH_LARGE_COMP_DATA_SRV |
| .metadata = health_srv_meta, |
| #endif |
| }; |
| |
| #if defined(CONFIG_BT_MESH_SHELL_HEALTH_CLI) |
| static void show_faults(uint8_t test_id, uint16_t cid, uint8_t *faults, size_t fault_count) |
| { |
| size_t i; |
| |
| if (!fault_count) { |
| shell_print_ctx("Health Test ID 0x%02x Company ID " |
| "0x%04x: no faults", test_id, cid); |
| return; |
| } |
| |
| shell_print_ctx("Health Test ID 0x%02x Company ID 0x%04x Fault " |
| "Count %zu:", test_id, cid, fault_count); |
| |
| for (i = 0; i < fault_count; i++) { |
| shell_print_ctx("\t0x%02x", faults[i]); |
| } |
| } |
| |
| static void health_current_status(struct bt_mesh_health_cli *cli, uint16_t addr, |
| uint8_t test_id, uint16_t cid, uint8_t *faults, |
| size_t fault_count) |
| { |
| shell_print_ctx("Health Current Status from 0x%04x", addr); |
| show_faults(test_id, cid, faults, fault_count); |
| } |
| |
| static void health_fault_status(struct bt_mesh_health_cli *cli, uint16_t addr, |
| uint8_t test_id, uint16_t cid, uint8_t *faults, |
| size_t fault_count) |
| { |
| shell_print_ctx("Health Fault Status from 0x%04x", addr); |
| show_faults(test_id, cid, faults, fault_count); |
| } |
| |
| static void health_attention_status(struct bt_mesh_health_cli *cli, |
| uint16_t addr, uint8_t attention) |
| { |
| shell_print_ctx("Health Attention Status from 0x%04x: %u", addr, attention); |
| } |
| |
| static void health_period_status(struct bt_mesh_health_cli *cli, uint16_t addr, |
| uint8_t period) |
| { |
| shell_print_ctx("Health Fast Period Divisor Status from 0x%04x: %u", addr, period); |
| } |
| |
| struct bt_mesh_health_cli bt_mesh_shell_health_cli = { |
| .current_status = health_current_status, |
| .fault_status = health_fault_status, |
| .attention_status = health_attention_status, |
| .period_status = health_period_status, |
| }; |
| #endif /* CONFIG_BT_MESH_SHELL_HEALTH_CLI */ |
| |
| static int cmd_init(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| |
| bt_mesh_shell_ctx_shell = sh; |
| shell_print(sh, "Mesh shell initialized"); |
| |
| #if defined(CONFIG_BT_MESH_SHELL_DFU_CLI) || defined(CONFIG_BT_MESH_SHELL_DFU_SRV) |
| bt_mesh_shell_dfu_cmds_init(); |
| #endif |
| #if defined(CONFIG_BT_MESH_SHELL_BLOB_CLI) || defined(CONFIG_BT_MESH_SHELL_BLOB_SRV) || \ |
| defined(CONFIG_BT_MESH_SHELL_BLOB_IO_FLASH) |
| bt_mesh_shell_blob_cmds_init(); |
| #endif |
| |
| if (IS_ENABLED(CONFIG_BT_MESH_RPR_SRV)) { |
| bt_mesh_prov_enable(BT_MESH_PROV_REMOTE); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_reset(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| #if defined(CONFIG_BT_MESH_CDB) |
| bt_mesh_cdb_clear(); |
| # endif |
| bt_mesh_reset(); |
| shell_print(sh, "Local node reset complete"); |
| |
| return 0; |
| } |
| |
| #if defined(CONFIG_BT_MESH_SHELL_LOW_POWER) |
| static int cmd_lpn(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| static bool enabled; |
| bool onoff; |
| int err = 0; |
| |
| if (argc < 2) { |
| shell_print(sh, "%s", enabled ? "enabled" : "disabled"); |
| return 0; |
| } |
| |
| onoff = shell_strtobool(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (onoff) { |
| if (enabled) { |
| shell_print(sh, "LPN already enabled"); |
| return 0; |
| } |
| |
| err = bt_mesh_lpn_set(true); |
| if (err) { |
| shell_error(sh, "Enabling LPN failed (err %d)", err); |
| } else { |
| enabled = true; |
| } |
| } else { |
| if (!enabled) { |
| shell_print(sh, "LPN already disabled"); |
| return 0; |
| } |
| |
| err = bt_mesh_lpn_set(false); |
| if (err) { |
| shell_error(sh, "Enabling LPN failed (err %d)", err); |
| } else { |
| enabled = false; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_poll(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err; |
| |
| err = bt_mesh_lpn_poll(); |
| if (err) { |
| shell_error(sh, "Friend Poll failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static void lpn_established(uint16_t net_idx, uint16_t friend_addr, |
| uint8_t queue_size, uint8_t recv_win) |
| { |
| shell_print_ctx("Friendship (as LPN) established to " |
| "Friend 0x%04x Queue Size %d Receive Window %d", |
| friend_addr, queue_size, recv_win); |
| } |
| |
| static void lpn_terminated(uint16_t net_idx, uint16_t friend_addr) |
| { |
| shell_print_ctx("Friendship (as LPN) lost with Friend " |
| "0x%04x", friend_addr); |
| } |
| |
| BT_MESH_LPN_CB_DEFINE(lpn_cb) = { |
| .established = lpn_established, |
| .terminated = lpn_terminated, |
| }; |
| #endif /* CONFIG_BT_MESH_SHELL_LOW_POWER */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_GATT_PROXY) |
| #if defined(CONFIG_BT_MESH_GATT_PROXY) |
| static int cmd_ident(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err; |
| |
| err = bt_mesh_proxy_identity_enable(); |
| if (err) { |
| shell_error(sh, "Failed advertise using Node Identity (err " |
| "%d)", err); |
| } |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_GATT_PROXY */ |
| |
| #if defined(CONFIG_BT_MESH_PROXY_CLIENT) |
| static int cmd_proxy_connect(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| uint16_t net_idx; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_proxy_connect(net_idx); |
| if (err) { |
| shell_error(sh, "Proxy connect failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_proxy_disconnect(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| uint16_t net_idx; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_proxy_disconnect(net_idx); |
| if (err) { |
| shell_error(sh, "Proxy disconnect failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_PROXY_CLIENT */ |
| |
| #if defined(CONFIG_BT_MESH_PROXY_SOLICITATION) |
| static int cmd_proxy_solicit(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| uint16_t net_idx; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_proxy_solicit(net_idx); |
| if (err) { |
| shell_error(sh, "Failed to advertise solicitation PDU (err %d)", |
| err); |
| } |
| |
| return err; |
| } |
| #endif /* CONFIG_BT_MESH_PROXY_SOLICITATION */ |
| #endif /* CONFIG_BT_MESH_SHELL_GATT_PROXY */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_PROV) |
| static int cmd_input_num(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = 0; |
| uint32_t val; |
| |
| val = shell_strtoul(argv[1], 10, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_input_number(val); |
| if (err) { |
| shell_error(sh, "Numeric input failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_input_str(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = bt_mesh_input_string(argv[1]); |
| |
| if (err) { |
| shell_error(sh, "String input failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static const char *bearer2str(bt_mesh_prov_bearer_t bearer) |
| { |
| switch (bearer) { |
| case BT_MESH_PROV_ADV: |
| return "PB-ADV"; |
| case BT_MESH_PROV_GATT: |
| return "PB-GATT"; |
| case BT_MESH_PROV_REMOTE: |
| return "PB-REMOTE"; |
| default: |
| return "unknown"; |
| } |
| } |
| |
| #if defined(CONFIG_BT_MESH_SHELL_PROV_CTX_INSTANCE) |
| static uint8_t dev_uuid[16] = { 0xdd, 0xdd }; |
| |
| static void prov_complete(uint16_t net_idx, uint16_t addr) |
| { |
| |
| shell_print_ctx("Local node provisioned, net_idx 0x%04x address " |
| "0x%04x", net_idx, addr); |
| |
| bt_mesh_shell_target_ctx.net_idx = net_idx, |
| bt_mesh_shell_target_ctx.dst = addr; |
| } |
| |
| static void reprovisioned(uint16_t addr) |
| { |
| shell_print(bt_mesh_shell_ctx_shell, "Local node re-provisioned, new address 0x%04x", |
| addr); |
| |
| if (bt_mesh_shell_target_ctx.dst == bt_mesh_primary_addr()) { |
| bt_mesh_shell_target_ctx.dst = addr; |
| } |
| } |
| |
| static void prov_node_added(uint16_t net_idx, uint8_t uuid[16], uint16_t addr, |
| uint8_t num_elem) |
| { |
| shell_print_ctx("Node provisioned, net_idx 0x%04x address " |
| "0x%04x elements %d", net_idx, addr, num_elem); |
| |
| bt_mesh_shell_target_ctx.net_idx = net_idx, |
| bt_mesh_shell_target_ctx.dst = addr; |
| } |
| |
| #if defined(CONFIG_BT_MESH_PROVISIONER) |
| static const char * const output_meth_string[] = { |
| "Blink", |
| "Beep", |
| "Vibrate", |
| "Display Number", |
| "Display String", |
| }; |
| |
| static const char *const input_meth_string[] = { |
| "Push", |
| "Twist", |
| "Enter Number", |
| "Enter String", |
| }; |
| |
| static void capabilities(const struct bt_mesh_dev_capabilities *cap) |
| { |
| shell_print_ctx("Provisionee capabilities:"); |
| shell_print_ctx("\tStatic OOB is %ssupported", cap->oob_type & 1 ? "" : "not "); |
| |
| shell_print_ctx("\tAvailable output actions (%d bytes max):%s", cap->output_size, |
| cap->output_actions ? "" : "\n\t\tNone"); |
| for (int i = 0; i < ARRAY_SIZE(output_meth_string); i++) { |
| if (cap->output_actions & BIT(i)) { |
| shell_print_ctx("\t\t%s", output_meth_string[i]); |
| } |
| } |
| |
| shell_print_ctx("\tAvailable input actions (%d bytes max):%s", cap->input_size, |
| cap->input_actions ? "" : "\n\t\tNone"); |
| for (int i = 0; i < ARRAY_SIZE(input_meth_string); i++) { |
| if (cap->input_actions & BIT(i)) { |
| shell_print_ctx("\t\t%s", input_meth_string[i]); |
| } |
| } |
| } |
| #endif |
| |
| static void prov_input_complete(void) |
| { |
| shell_print_ctx("Input complete"); |
| } |
| |
| static void prov_reset(void) |
| { |
| shell_print_ctx("The local node has been reset and needs " |
| "reprovisioning"); |
| } |
| |
| static int output_number(bt_mesh_output_action_t action, uint32_t number) |
| { |
| switch (action) { |
| case BT_MESH_BLINK: |
| shell_print_ctx("OOB blink Number: %u", number); |
| break; |
| case BT_MESH_BEEP: |
| shell_print_ctx("OOB beep Number: %u", number); |
| break; |
| case BT_MESH_VIBRATE: |
| shell_print_ctx("OOB vibrate Number: %u", number); |
| break; |
| case BT_MESH_DISPLAY_NUMBER: |
| shell_print_ctx("OOB display Number: %u", number); |
| break; |
| default: |
| if (bt_mesh_shell_ctx_shell != NULL) { |
| shell_error(bt_mesh_shell_ctx_shell, |
| "Unknown Output action %u (number %u) requested!", |
| action, number); |
| } |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static int output_string(const char *str) |
| { |
| shell_print_ctx("OOB String: %s", str); |
| return 0; |
| } |
| |
| static int input(bt_mesh_input_action_t act, uint8_t size) |
| { |
| |
| switch (act) { |
| case BT_MESH_ENTER_NUMBER: |
| shell_print_ctx("Enter a number (max %u digits) with: Input-num <num>", size); |
| break; |
| case BT_MESH_ENTER_STRING: |
| shell_print_ctx("Enter a string (max %u chars) with: Input-str <str>", size); |
| break; |
| case BT_MESH_TWIST: |
| shell_print_ctx("\"Twist\" a number (max %u digits) with: Input-num <num>", size); |
| break; |
| case BT_MESH_PUSH: |
| shell_print_ctx("\"Push\" a number (max %u digits) with: Input-num <num>", size); |
| break; |
| default: |
| if (bt_mesh_shell_ctx_shell != NULL) { |
| shell_error(bt_mesh_shell_ctx_shell, |
| "Unknown Input action %u (size %u) requested!", act, size); |
| } |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static void link_open(bt_mesh_prov_bearer_t bearer) |
| { |
| shell_print_ctx("Provisioning link opened on %s", bearer2str(bearer)); |
| } |
| |
| static void link_close(bt_mesh_prov_bearer_t bearer) |
| { |
| shell_print_ctx("Provisioning link closed on %s", bearer2str(bearer)); |
| } |
| |
| static uint8_t static_val[32]; |
| |
| struct bt_mesh_prov bt_mesh_shell_prov = { |
| .uuid = dev_uuid, |
| .link_open = link_open, |
| .link_close = link_close, |
| .complete = prov_complete, |
| .reprovisioned = reprovisioned, |
| .node_added = prov_node_added, |
| .reset = prov_reset, |
| .static_val = NULL, |
| .static_val_len = 0, |
| .output_size = 6, |
| .output_actions = (BT_MESH_BLINK | BT_MESH_BEEP | BT_MESH_VIBRATE | BT_MESH_DISPLAY_NUMBER | |
| BT_MESH_DISPLAY_STRING), |
| .output_number = output_number, |
| .output_string = output_string, |
| .input_size = 6, |
| .input_actions = |
| (BT_MESH_ENTER_NUMBER | BT_MESH_ENTER_STRING | BT_MESH_TWIST | BT_MESH_PUSH), |
| .input = input, |
| .input_complete = prov_input_complete, |
| #if defined(CONFIG_BT_MESH_PROVISIONER) |
| .capabilities = capabilities |
| #endif |
| }; |
| |
| static int cmd_static_oob(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| if (argc < 2) { |
| bt_mesh_shell_prov.static_val = NULL; |
| bt_mesh_shell_prov.static_val_len = 0U; |
| } else { |
| bt_mesh_shell_prov.static_val_len = hex2bin(argv[1], strlen(argv[1]), |
| static_val, 32); |
| if (bt_mesh_shell_prov.static_val_len) { |
| bt_mesh_shell_prov.static_val = static_val; |
| } else { |
| bt_mesh_shell_prov.static_val = NULL; |
| } |
| } |
| |
| if (bt_mesh_shell_prov.static_val) { |
| shell_print(sh, "Static OOB value set (length %u)", |
| bt_mesh_shell_prov.static_val_len); |
| } else { |
| shell_print(sh, "Static OOB value cleared"); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_uuid(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| uint8_t uuid[16]; |
| size_t len; |
| |
| if (argc < 2) { |
| char uuid_hex_str[32 + 1]; |
| |
| bin2hex(dev_uuid, 16, uuid_hex_str, sizeof(uuid_hex_str)); |
| |
| shell_print_ctx("Device UUID: %s", uuid_hex_str); |
| return 0; |
| } |
| |
| len = hex2bin(argv[1], strlen(argv[1]), uuid, sizeof(uuid)); |
| if (len < 1) { |
| return -EINVAL; |
| } |
| |
| memcpy(dev_uuid, uuid, len); |
| (void)memset(dev_uuid + len, 0, sizeof(dev_uuid) - len); |
| |
| shell_print(sh, "Device UUID set"); |
| |
| return 0; |
| } |
| |
| static void print_unprovisioned_beacon(uint8_t uuid[16], |
| bt_mesh_prov_oob_info_t oob_info, |
| uint32_t *uri_hash) |
| { |
| char uuid_hex_str[32 + 1]; |
| |
| bin2hex(uuid, 16, uuid_hex_str, sizeof(uuid_hex_str)); |
| |
| shell_print_ctx("PB-ADV UUID %s, OOB Info 0x%04x, URI Hash 0x%x", |
| uuid_hex_str, oob_info, |
| (uri_hash == NULL ? 0 : *uri_hash)); |
| } |
| |
| #if defined(CONFIG_BT_MESH_PB_GATT_CLIENT) |
| static void pb_gatt_unprovisioned(uint8_t uuid[16], |
| bt_mesh_prov_oob_info_t oob_info) |
| { |
| char uuid_hex_str[32 + 1]; |
| |
| bin2hex(uuid, 16, uuid_hex_str, sizeof(uuid_hex_str)); |
| |
| shell_print_ctx("PB-GATT UUID %s, OOB Info 0x%04x", uuid_hex_str, oob_info); |
| } |
| #endif |
| |
| static int cmd_beacon_listen(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| int err = 0; |
| bool val = shell_strtobool(argv[1], 0, &err); |
| |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (val) { |
| bt_mesh_shell_prov.unprovisioned_beacon = print_unprovisioned_beacon; |
| #if defined(CONFIG_BT_MESH_PB_GATT_CLIENT) |
| bt_mesh_shell_prov.unprovisioned_beacon_gatt = pb_gatt_unprovisioned; |
| #endif |
| } else { |
| bt_mesh_shell_prov.unprovisioned_beacon = NULL; |
| bt_mesh_shell_prov.unprovisioned_beacon_gatt = NULL; |
| } |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_SHELL_PROV_CTX_INSTANCE */ |
| |
| #if defined(CONFIG_BT_MESH_PB_GATT_CLIENT) |
| static int cmd_provision_gatt(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| static uint8_t uuid[16]; |
| uint8_t attention_duration; |
| uint16_t net_idx; |
| uint16_t addr; |
| size_t len; |
| int err = 0; |
| |
| len = hex2bin(argv[1], strlen(argv[1]), uuid, sizeof(uuid)); |
| (void)memset(uuid + len, 0, sizeof(uuid) - len); |
| |
| net_idx = shell_strtoul(argv[2], 0, &err); |
| addr = shell_strtoul(argv[3], 0, &err); |
| attention_duration = shell_strtoul(argv[4], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_provision_gatt(uuid, net_idx, addr, attention_duration); |
| if (err) { |
| shell_error(sh, "Provisioning failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_PB_GATT_CLIENT */ |
| |
| #if defined(CONFIG_BT_MESH_PROVISIONEE) |
| static int cmd_pb(bt_mesh_prov_bearer_t bearer, const struct shell *sh, |
| size_t argc, char *argv[]) |
| { |
| int err = 0; |
| bool onoff; |
| |
| if (argc < 2) { |
| return -EINVAL; |
| } |
| |
| onoff = shell_strtobool(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (onoff) { |
| err = bt_mesh_prov_enable(bearer); |
| if (err) { |
| shell_error(sh, "Failed to enable %s (err %d)", |
| bearer2str(bearer), err); |
| } else { |
| shell_print(sh, "%s enabled", bearer2str(bearer)); |
| } |
| } else { |
| err = bt_mesh_prov_disable(bearer); |
| if (err) { |
| shell_error(sh, "Failed to disable %s (err %d)", |
| bearer2str(bearer), err); |
| } else { |
| shell_print(sh, "%s disabled", bearer2str(bearer)); |
| } |
| } |
| |
| return 0; |
| } |
| |
| #if defined(CONFIG_BT_MESH_PB_ADV) |
| static int cmd_pb_adv(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| return cmd_pb(BT_MESH_PROV_ADV, sh, argc, argv); |
| } |
| #endif /* CONFIG_BT_MESH_PB_ADV */ |
| |
| #if defined(CONFIG_BT_MESH_PB_GATT) |
| static int cmd_pb_gatt(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| return cmd_pb(BT_MESH_PROV_GATT, sh, argc, argv); |
| } |
| #endif /* CONFIG_BT_MESH_PB_GATT */ |
| #endif /* CONFIG_BT_MESH_PROVISIONEE */ |
| |
| #if defined(CONFIG_BT_MESH_PROVISIONER) |
| static int cmd_remote_pub_key_set(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| size_t len; |
| uint8_t pub_key[64]; |
| int err = 0; |
| |
| len = hex2bin(argv[1], strlen(argv[1]), pub_key, sizeof(pub_key)); |
| if (len < 1) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return -EINVAL; |
| } |
| |
| err = bt_mesh_prov_remote_pub_key_set(pub_key); |
| |
| if (err) { |
| shell_error(sh, "Setting remote pub key failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_auth_method_set_input(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = 0; |
| bt_mesh_input_action_t action = shell_strtoul(argv[1], 10, &err); |
| uint8_t size = shell_strtoul(argv[2], 10, &err); |
| |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_auth_method_set_input(action, size); |
| if (err) { |
| shell_error(sh, "Setting input OOB authentication action failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_auth_method_set_output(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = 0; |
| bt_mesh_output_action_t action = shell_strtoul(argv[1], 10, &err); |
| uint8_t size = shell_strtoul(argv[2], 10, &err); |
| |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_auth_method_set_output(action, size); |
| if (err) { |
| shell_error(sh, "Setting output OOB authentication action failed (err %d)", err); |
| } |
| return 0; |
| } |
| |
| static int cmd_auth_method_set_static(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| size_t len; |
| uint8_t static_oob_auth[32]; |
| int err = 0; |
| |
| len = hex2bin(argv[1], strlen(argv[1]), static_oob_auth, sizeof(static_oob_auth)); |
| if (len < 1) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return -EINVAL; |
| } |
| |
| err = bt_mesh_auth_method_set_static(static_oob_auth, len); |
| if (err) { |
| shell_error(sh, "Setting static OOB authentication failed (err %d)", err); |
| } |
| return 0; |
| } |
| |
| static int cmd_auth_method_set_none(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = bt_mesh_auth_method_set_none(); |
| |
| if (err) { |
| shell_error(sh, "Disabling authentication failed (err %d)", err); |
| } |
| return 0; |
| } |
| |
| static int cmd_provision_adv(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| uint8_t uuid[16]; |
| uint8_t attention_duration; |
| uint16_t net_idx; |
| uint16_t addr; |
| size_t len; |
| int err = 0; |
| |
| len = hex2bin(argv[1], strlen(argv[1]), uuid, sizeof(uuid)); |
| (void)memset(uuid + len, 0, sizeof(uuid) - len); |
| |
| net_idx = shell_strtoul(argv[2], 0, &err); |
| addr = shell_strtoul(argv[3], 0, &err); |
| attention_duration = shell_strtoul(argv[4], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| err = bt_mesh_provision_adv(uuid, net_idx, addr, attention_duration); |
| if (err) { |
| shell_error(sh, "Provisioning failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_PROVISIONER */ |
| |
| static int cmd_provision_local(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| uint8_t net_key[16]; |
| uint16_t net_idx, addr; |
| uint32_t iv_index; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| addr = shell_strtoul(argv[2], 0, &err); |
| |
| if (argc > 3) { |
| iv_index = shell_strtoul(argv[3], 0, &err); |
| } else { |
| iv_index = 0U; |
| } |
| |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| memcpy(net_key, bt_mesh_shell_default_key, sizeof(net_key)); |
| |
| if (IS_ENABLED(CONFIG_BT_MESH_CDB)) { |
| struct bt_mesh_cdb_subnet *sub; |
| |
| sub = bt_mesh_cdb_subnet_get(net_idx); |
| if (!sub) { |
| shell_error(sh, "No cdb entry for subnet 0x%03x", net_idx); |
| return 0; |
| } |
| |
| if (bt_mesh_cdb_subnet_key_export(sub, SUBNET_KEY_TX_IDX(sub), net_key)) { |
| shell_error(sh, "Unable to export key for subnet 0x%03x", net_idx); |
| return 0; |
| } |
| } |
| |
| err = bt_mesh_provision(net_key, net_idx, 0, iv_index, addr, bt_mesh_shell_default_key); |
| if (err) { |
| shell_error(sh, "Provisioning failed (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_comp_change(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| bt_mesh_comp_change_prepare(); |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_SHELL_PROV */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_TEST) |
| static int cmd_net_send(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| NET_BUF_SIMPLE_DEFINE(msg, 32); |
| |
| struct bt_mesh_msg_ctx ctx = BT_MESH_MSG_CTX_INIT(bt_mesh_shell_target_ctx.net_idx, |
| bt_mesh_shell_target_ctx.app_idx, |
| bt_mesh_shell_target_ctx.dst, |
| BT_MESH_TTL_DEFAULT); |
| struct bt_mesh_net_tx tx = { |
| .ctx = &ctx, |
| .src = bt_mesh_primary_addr(), |
| }; |
| |
| size_t len; |
| int err; |
| |
| len = hex2bin(argv[1], strlen(argv[1]), |
| msg.data, net_buf_simple_tailroom(&msg) - 4); |
| net_buf_simple_add(&msg, len); |
| |
| err = bt_mesh_trans_send(&tx, &msg, NULL, NULL); |
| if (err) { |
| shell_error(sh, "Failed to send (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| #if defined(CONFIG_BT_MESH_IV_UPDATE_TEST) |
| static int cmd_iv_update(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| if (bt_mesh_iv_update()) { |
| shell_print(sh, "Transitioned to IV Update In Progress " |
| "state"); |
| } else { |
| shell_print(sh, "Transitioned to IV Update Normal state"); |
| } |
| |
| shell_print(sh, "IV Index is 0x%08x", bt_mesh.iv_index); |
| |
| return 0; |
| } |
| |
| static int cmd_iv_update_test(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| int err = 0; |
| bool enable; |
| |
| enable = shell_strtobool(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (enable) { |
| shell_print(sh, "Enabling IV Update test mode"); |
| } else { |
| shell_print(sh, "Disabling IV Update test mode"); |
| } |
| |
| bt_mesh_iv_update_test(enable); |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_IV_UPDATE_TEST */ |
| |
| static int cmd_rpl_clear(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| bt_mesh_rpl_clear(); |
| return 0; |
| } |
| |
| #if defined(CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE) |
| static const struct bt_mesh_elem *primary_element(void) |
| { |
| const struct bt_mesh_comp *comp = bt_mesh_comp_get(); |
| |
| if (comp) { |
| return &comp->elem[0]; |
| } |
| |
| return NULL; |
| } |
| |
| static int cmd_add_fault(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| uint8_t fault_id; |
| uint8_t i; |
| const struct bt_mesh_elem *elem; |
| int err = 0; |
| |
| elem = primary_element(); |
| if (elem == NULL) { |
| shell_print(sh, "Element not found!"); |
| return -EINVAL; |
| } |
| |
| fault_id = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (!fault_id) { |
| shell_print(sh, "The Fault ID must be non-zero!"); |
| return -EINVAL; |
| } |
| |
| for (i = 0U; i < sizeof(cur_faults); i++) { |
| if (!cur_faults[i]) { |
| cur_faults[i] = fault_id; |
| break; |
| } |
| } |
| |
| if (i == sizeof(cur_faults)) { |
| shell_print(sh, "Fault array is full. Use \"del-fault\" to " |
| "clear it"); |
| return 0; |
| } |
| |
| for (i = 0U; i < sizeof(reg_faults); i++) { |
| if (!reg_faults[i]) { |
| reg_faults[i] = fault_id; |
| break; |
| } |
| } |
| |
| if (i == sizeof(reg_faults)) { |
| shell_print(sh, "No space to store more registered faults"); |
| } |
| |
| bt_mesh_health_srv_fault_update(elem); |
| |
| return 0; |
| } |
| |
| static int cmd_del_fault(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| uint8_t fault_id; |
| uint8_t i; |
| const struct bt_mesh_elem *elem; |
| int err = 0; |
| |
| elem = primary_element(); |
| if (elem == NULL) { |
| shell_print(sh, "Element not found!"); |
| return -EINVAL; |
| } |
| |
| if (argc < 2) { |
| (void)memset(cur_faults, 0, sizeof(cur_faults)); |
| shell_print(sh, "All current faults cleared"); |
| bt_mesh_health_srv_fault_update(elem); |
| return 0; |
| } |
| |
| fault_id = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (!fault_id) { |
| shell_print(sh, "The Fault ID must be non-zero!"); |
| return -EINVAL; |
| } |
| |
| for (i = 0U; i < sizeof(cur_faults); i++) { |
| if (cur_faults[i] == fault_id) { |
| cur_faults[i] = 0U; |
| shell_print(sh, "Fault cleared"); |
| } |
| } |
| |
| bt_mesh_health_srv_fault_update(elem); |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE */ |
| #endif /* CONFIG_BT_MESH_SHELL_TEST */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_CDB) |
| static int cmd_cdb_create(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| uint8_t net_key[16]; |
| size_t len; |
| int err; |
| |
| if (argc < 2) { |
| bt_rand(net_key, 16); |
| } else { |
| len = hex2bin(argv[1], strlen(argv[1]), net_key, |
| sizeof(net_key)); |
| memset(net_key + len, 0, sizeof(net_key) - len); |
| } |
| |
| err = bt_mesh_cdb_create(net_key); |
| if (err < 0) { |
| shell_print(sh, "Failed to create CDB (err %d)", err); |
| } |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_clear(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| bt_mesh_cdb_clear(); |
| |
| shell_print(sh, "Cleared CDB"); |
| |
| return 0; |
| } |
| |
| static void cdb_print_nodes(const struct shell *sh) |
| { |
| char key_hex_str[32 + 1], uuid_hex_str[32 + 1]; |
| struct bt_mesh_cdb_node *node; |
| int i, total = 0; |
| bool configured; |
| uint8_t dev_key[16]; |
| |
| shell_print(sh, "Address Elements Flags %-32s DevKey", "UUID"); |
| |
| for (i = 0; i < ARRAY_SIZE(bt_mesh_cdb.nodes); ++i) { |
| node = &bt_mesh_cdb.nodes[i]; |
| if (node->addr == BT_MESH_ADDR_UNASSIGNED) { |
| continue; |
| } |
| |
| configured = atomic_test_bit(node->flags, |
| BT_MESH_CDB_NODE_CONFIGURED); |
| |
| total++; |
| bin2hex(node->uuid, 16, uuid_hex_str, sizeof(uuid_hex_str)); |
| if (bt_mesh_cdb_node_key_export(node, dev_key)) { |
| shell_error(sh, "Unable to export key for node 0x%04x", node->addr); |
| continue; |
| } |
| bin2hex(dev_key, 16, key_hex_str, sizeof(key_hex_str)); |
| shell_print(sh, "0x%04x %-8d %-5s %s %s", node->addr, |
| node->num_elem, configured ? "C" : "-", |
| uuid_hex_str, key_hex_str); |
| } |
| |
| shell_print(sh, "> Total nodes: %d", total); |
| } |
| |
| static void cdb_print_subnets(const struct shell *sh) |
| { |
| struct bt_mesh_cdb_subnet *subnet; |
| char key_hex_str[32 + 1]; |
| int i, total = 0; |
| uint8_t net_key[16]; |
| |
| shell_print(sh, "NetIdx NetKey"); |
| |
| for (i = 0; i < ARRAY_SIZE(bt_mesh_cdb.subnets); ++i) { |
| subnet = &bt_mesh_cdb.subnets[i]; |
| if (subnet->net_idx == BT_MESH_KEY_UNUSED) { |
| continue; |
| } |
| |
| if (bt_mesh_cdb_subnet_key_export(subnet, 0, net_key)) { |
| shell_error(sh, "Unable to export key for subnet 0x%03x", |
| subnet->net_idx); |
| continue; |
| } |
| |
| total++; |
| bin2hex(net_key, 16, key_hex_str, sizeof(key_hex_str)); |
| shell_print(sh, "0x%03x %s", subnet->net_idx, key_hex_str); |
| } |
| |
| shell_print(sh, "> Total subnets: %d", total); |
| } |
| |
| static void cdb_print_app_keys(const struct shell *sh) |
| { |
| struct bt_mesh_cdb_app_key *key; |
| char key_hex_str[32 + 1]; |
| int i, total = 0; |
| uint8_t app_key[16]; |
| |
| shell_print(sh, "NetIdx AppIdx AppKey"); |
| |
| for (i = 0; i < ARRAY_SIZE(bt_mesh_cdb.app_keys); ++i) { |
| key = &bt_mesh_cdb.app_keys[i]; |
| if (key->net_idx == BT_MESH_KEY_UNUSED) { |
| continue; |
| } |
| |
| if (bt_mesh_cdb_app_key_export(key, 0, app_key)) { |
| shell_error(sh, "Unable to export app key 0x%03x", key->app_idx); |
| continue; |
| } |
| |
| total++; |
| bin2hex(app_key, 16, key_hex_str, sizeof(key_hex_str)); |
| shell_print(sh, "0x%03x 0x%03x %s", key->net_idx, key->app_idx, key_hex_str); |
| } |
| |
| shell_print(sh, "> Total app-keys: %d", total); |
| } |
| |
| static int cmd_cdb_show(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| if (!atomic_test_bit(bt_mesh_cdb.flags, BT_MESH_CDB_VALID)) { |
| shell_print(sh, "No valid networks"); |
| return 0; |
| } |
| |
| shell_print(sh, "Mesh Network Information"); |
| shell_print(sh, "========================"); |
| |
| cdb_print_nodes(sh); |
| shell_print(sh, "---"); |
| cdb_print_subnets(sh); |
| shell_print(sh, "---"); |
| cdb_print_app_keys(sh); |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_node_add(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| struct bt_mesh_cdb_node *node; |
| uint8_t uuid[16], dev_key[16]; |
| uint16_t addr, net_idx; |
| uint8_t num_elem; |
| size_t len; |
| int err = 0; |
| |
| len = hex2bin(argv[1], strlen(argv[1]), uuid, sizeof(uuid)); |
| memset(uuid + len, 0, sizeof(uuid) - len); |
| |
| addr = shell_strtoul(argv[2], 0, &err); |
| num_elem = shell_strtoul(argv[3], 0, &err); |
| net_idx = shell_strtoul(argv[4], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (argc < 6) { |
| bt_rand(dev_key, 16); |
| } else { |
| len = hex2bin(argv[5], strlen(argv[5]), dev_key, |
| sizeof(dev_key)); |
| memset(dev_key + len, 0, sizeof(dev_key) - len); |
| } |
| |
| node = bt_mesh_cdb_node_alloc(uuid, addr, num_elem, net_idx); |
| if (node == NULL) { |
| shell_print(sh, "Failed to allocate node"); |
| return 0; |
| } |
| |
| err = bt_mesh_cdb_node_key_import(node, dev_key); |
| if (err) { |
| shell_warn(sh, "Unable to import device key into cdb"); |
| return err; |
| } |
| |
| if (IS_ENABLED(CONFIG_BT_SETTINGS)) { |
| bt_mesh_cdb_node_store(node); |
| } |
| |
| shell_print(sh, "Added node 0x%04x", node->addr); |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_node_del(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| struct bt_mesh_cdb_node *node; |
| uint16_t addr; |
| int err = 0; |
| |
| addr = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| node = bt_mesh_cdb_node_get(addr); |
| if (node == NULL) { |
| shell_print(sh, "No node with address 0x%04x", addr); |
| return 0; |
| } |
| |
| bt_mesh_cdb_node_del(node, true); |
| |
| shell_print(sh, "Deleted node 0x%04x", addr); |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_subnet_add(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| struct bt_mesh_cdb_subnet *sub; |
| uint8_t net_key[16]; |
| uint16_t net_idx; |
| size_t len; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (argc < 3) { |
| bt_rand(net_key, 16); |
| } else { |
| len = hex2bin(argv[2], strlen(argv[2]), net_key, |
| sizeof(net_key)); |
| memset(net_key + len, 0, sizeof(net_key) - len); |
| } |
| |
| sub = bt_mesh_cdb_subnet_alloc(net_idx); |
| if (sub == NULL) { |
| shell_print(sh, "Could not add subnet"); |
| return 0; |
| } |
| |
| if (bt_mesh_cdb_subnet_key_import(sub, 0, net_key)) { |
| shell_error(sh, "Unable to import key for subnet 0x%03x", net_idx); |
| return 0; |
| } |
| |
| if (IS_ENABLED(CONFIG_BT_SETTINGS)) { |
| bt_mesh_cdb_subnet_store(sub); |
| } |
| |
| shell_print(sh, "Added Subnet 0x%03x", net_idx); |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_subnet_del(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| struct bt_mesh_cdb_subnet *sub; |
| uint16_t net_idx; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| sub = bt_mesh_cdb_subnet_get(net_idx); |
| if (sub == NULL) { |
| shell_print(sh, "No subnet with NetIdx 0x%03x", net_idx); |
| return 0; |
| } |
| |
| bt_mesh_cdb_subnet_del(sub, true); |
| |
| shell_print(sh, "Deleted subnet 0x%03x", net_idx); |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_app_key_add(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| struct bt_mesh_cdb_app_key *key; |
| uint16_t net_idx, app_idx; |
| uint8_t app_key[16]; |
| size_t len; |
| int err = 0; |
| |
| net_idx = shell_strtoul(argv[1], 0, &err); |
| app_idx = shell_strtoul(argv[2], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| if (argc < 4) { |
| bt_rand(app_key, 16); |
| } else { |
| len = hex2bin(argv[3], strlen(argv[3]), app_key, |
| sizeof(app_key)); |
| memset(app_key + len, 0, sizeof(app_key) - len); |
| } |
| |
| key = bt_mesh_cdb_app_key_alloc(net_idx, app_idx); |
| if (key == NULL) { |
| shell_print(sh, "Could not add AppKey"); |
| return 0; |
| } |
| |
| if (bt_mesh_cdb_app_key_import(key, 0, app_key)) { |
| shell_error(sh, "Unable to import app key 0x%03x", app_idx); |
| return 0; |
| } |
| |
| if (IS_ENABLED(CONFIG_BT_SETTINGS)) { |
| bt_mesh_cdb_app_key_store(key); |
| } |
| |
| shell_print(sh, "Added AppKey 0x%03x", app_idx); |
| |
| return 0; |
| } |
| |
| static int cmd_cdb_app_key_del(const struct shell *sh, size_t argc, |
| char *argv[]) |
| { |
| struct bt_mesh_cdb_app_key *key; |
| uint16_t app_idx; |
| int err = 0; |
| |
| app_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| key = bt_mesh_cdb_app_key_get(app_idx); |
| if (key == NULL) { |
| shell_print(sh, "No AppKey 0x%03x", app_idx); |
| return 0; |
| } |
| |
| bt_mesh_cdb_app_key_del(key, true); |
| |
| shell_print(sh, "Deleted AppKey 0x%03x", app_idx); |
| |
| return 0; |
| } |
| #endif /* CONFIG_BT_MESH_SHELL_CDB */ |
| |
| static int cmd_dst(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = 0; |
| |
| if (argc < 2) { |
| shell_print(sh, "Destination address: 0x%04x%s", bt_mesh_shell_target_ctx.dst, |
| bt_mesh_shell_target_ctx.dst == bt_mesh_primary_addr() |
| ? " (local)" |
| : ""); |
| return 0; |
| } |
| |
| if (!strcmp(argv[1], "local")) { |
| bt_mesh_shell_target_ctx.dst = bt_mesh_primary_addr(); |
| } else { |
| bt_mesh_shell_target_ctx.dst = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| } |
| |
| shell_print(sh, "Destination address set to 0x%04x%s", bt_mesh_shell_target_ctx.dst, |
| bt_mesh_shell_target_ctx.dst == bt_mesh_primary_addr() ? " (local)" |
| : ""); |
| return 0; |
| } |
| |
| static int cmd_netidx(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = 0; |
| |
| if (argc < 2) { |
| shell_print(sh, "NetIdx: 0x%04x", bt_mesh_shell_target_ctx.net_idx); |
| return 0; |
| } |
| |
| bt_mesh_shell_target_ctx.net_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| shell_print(sh, "NetIdx set to 0x%04x", bt_mesh_shell_target_ctx.net_idx); |
| return 0; |
| } |
| |
| static int cmd_appidx(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| int err = 0; |
| |
| if (argc < 2) { |
| shell_print(sh, "AppIdx: 0x%04x", bt_mesh_shell_target_ctx.app_idx); |
| return 0; |
| } |
| |
| bt_mesh_shell_target_ctx.app_idx = shell_strtoul(argv[1], 0, &err); |
| if (err) { |
| shell_warn(sh, "Unable to parse input string argument"); |
| return err; |
| } |
| |
| shell_print(sh, "AppIdx set to 0x%04x", bt_mesh_shell_target_ctx.app_idx); |
| return 0; |
| } |
| |
| #if defined(CONFIG_BT_MESH_STATISTIC) |
| static int cmd_stat_get(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| struct bt_mesh_statistic st; |
| |
| bt_mesh_stat_get(&st); |
| |
| shell_print(sh, "Received frames over:"); |
| shell_print(sh, "adv: %d", st.rx_adv); |
| shell_print(sh, "loopback: %d", st.rx_loopback); |
| shell_print(sh, "proxy: %d", st.rx_proxy); |
| shell_print(sh, "unknown: %d", st.rx_uknown); |
| |
| shell_print(sh, "Transmitted frames: <planned> - <succeeded>"); |
| shell_print(sh, "relay adv: %d - %d", st.tx_adv_relay_planned, st.tx_adv_relay_succeeded); |
| shell_print(sh, "local adv: %d - %d", st.tx_local_planned, st.tx_local_succeeded); |
| shell_print(sh, "friend: %d - %d", st.tx_friend_planned, st.tx_friend_succeeded); |
| |
| return 0; |
| } |
| |
| static int cmd_stat_clear(const struct shell *sh, size_t argc, char *argv[]) |
| { |
| bt_mesh_stat_reset(); |
| |
| return 0; |
| } |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_SHELL_CDB) |
| SHELL_STATIC_SUBCMD_SET_CREATE( |
| cdb_cmds, |
| /* Mesh Configuration Database Operations */ |
| SHELL_CMD_ARG(create, NULL, "[NetKey(1-16 hex)]", cmd_cdb_create, 1, 1), |
| SHELL_CMD_ARG(clear, NULL, NULL, cmd_cdb_clear, 1, 0), |
| SHELL_CMD_ARG(show, NULL, NULL, cmd_cdb_show, 1, 0), |
| SHELL_CMD_ARG(node-add, NULL, |
| "<UUID(1-16 hex)> <Addr> <ElemCnt> <NetKeyIdx> [DevKey(1-16 hex)]", |
| cmd_cdb_node_add, 5, 1), |
| SHELL_CMD_ARG(node-del, NULL, "<Addr>", cmd_cdb_node_del, 2, 0), |
| SHELL_CMD_ARG(subnet-add, NULL, "<NetKeyIdx> [<NetKey(1-16 hex)>]", cmd_cdb_subnet_add, 2, |
| 1), |
| SHELL_CMD_ARG(subnet-del, NULL, "<NetKeyIdx>", cmd_cdb_subnet_del, 2, 0), |
| SHELL_CMD_ARG(app-key-add, NULL, "<NetKeyIdx> <AppKeyIdx> [<AppKey(1-16 hex)>]", |
| cmd_cdb_app_key_add, 3, 1), |
| SHELL_CMD_ARG(app-key-del, NULL, "<AppKeyIdx>", cmd_cdb_app_key_del, 2, 0), |
| SHELL_SUBCMD_SET_END); |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_SHELL_PROV) |
| #if defined(CONFIG_BT_MESH_PROVISIONER) |
| SHELL_STATIC_SUBCMD_SET_CREATE(auth_cmds, |
| SHELL_CMD_ARG(input, NULL, "<Action> <Size>", |
| cmd_auth_method_set_input, 3, 0), |
| SHELL_CMD_ARG(output, NULL, "<Action> <Size>", |
| cmd_auth_method_set_output, 3, 0), |
| SHELL_CMD_ARG(static, NULL, "<Val(1-16 hex)>", cmd_auth_method_set_static, 2, |
| 0), |
| SHELL_CMD_ARG(none, NULL, NULL, cmd_auth_method_set_none, 1, 0), |
| SHELL_SUBCMD_SET_END); |
| #endif |
| |
| SHELL_STATIC_SUBCMD_SET_CREATE( |
| prov_cmds, SHELL_CMD_ARG(input-num, NULL, "<Number>", cmd_input_num, 2, 0), |
| SHELL_CMD_ARG(input-str, NULL, "<String>", cmd_input_str, 2, 0), |
| SHELL_CMD_ARG(local, NULL, "<NetKeyIdx> <Addr> [IVI]", cmd_provision_local, 3, 1), |
| #if defined(CONFIG_BT_MESH_SHELL_PROV_CTX_INSTANCE) |
| SHELL_CMD_ARG(static-oob, NULL, "[Val]", cmd_static_oob, 2, 1), |
| SHELL_CMD_ARG(uuid, NULL, "[UUID(1-16 hex)]", cmd_uuid, 1, 1), |
| SHELL_CMD_ARG(beacon-listen, NULL, "<Val(off, on)>", cmd_beacon_listen, 2, 0), |
| #endif |
| |
| SHELL_CMD_ARG(comp-change, NULL, NULL, cmd_comp_change, 1, 0), |
| |
| /* Provisioning operations */ |
| #if defined(CONFIG_BT_MESH_PROVISIONEE) |
| #if defined(CONFIG_BT_MESH_PB_GATT) |
| SHELL_CMD_ARG(pb-gatt, NULL, "<Val(off, on)>", cmd_pb_gatt, 2, 0), |
| #endif |
| #if defined(CONFIG_BT_MESH_PB_ADV) |
| SHELL_CMD_ARG(pb-adv, NULL, "<Val(off, on)>", cmd_pb_adv, 2, 0), |
| #endif |
| #endif /* CONFIG_BT_MESH_PROVISIONEE */ |
| |
| #if defined(CONFIG_BT_MESH_PROVISIONER) |
| SHELL_CMD(auth-method, &auth_cmds, "Authentication methods", bt_mesh_shell_mdl_cmds_help), |
| SHELL_CMD_ARG(remote-pub-key, NULL, "<PubKey>", cmd_remote_pub_key_set, 2, 0), |
| SHELL_CMD_ARG(remote-adv, NULL, |
| "<UUID(1-16 hex)> <NetKeyIdx> <Addr> " |
| "<AttDur(s)>", |
| cmd_provision_adv, 5, 0), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_PB_GATT_CLIENT) |
| SHELL_CMD_ARG(remote-gatt, NULL, |
| "<UUID(1-16 hex)> <NetKeyIdx> <Addr> " |
| "<AttDur(s)>", |
| cmd_provision_gatt, 5, 0), |
| #endif |
| SHELL_SUBCMD_SET_END); |
| #endif /* CONFIG_BT_MESH_SHELL_PROV */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_TEST) |
| #if defined(CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE) |
| SHELL_STATIC_SUBCMD_SET_CREATE(health_srv_cmds, |
| /* Health Server Model Operations */ |
| SHELL_CMD_ARG(add-fault, NULL, "<FaultID>", cmd_add_fault, 2, 0), |
| SHELL_CMD_ARG(del-fault, NULL, "[FaultID]", cmd_del_fault, 1, 1), |
| SHELL_SUBCMD_SET_END); |
| #endif |
| |
| SHELL_STATIC_SUBCMD_SET_CREATE(test_cmds, |
| /* Commands which access internal APIs, for testing only */ |
| SHELL_CMD_ARG(net-send, NULL, "<HexString>", cmd_net_send, |
| 2, 0), |
| #if defined(CONFIG_BT_MESH_IV_UPDATE_TEST) |
| SHELL_CMD_ARG(iv-update, NULL, NULL, cmd_iv_update, 1, 0), |
| SHELL_CMD_ARG(iv-update-test, NULL, "<Val(off, on)>", cmd_iv_update_test, 2, 0), |
| #endif |
| SHELL_CMD_ARG(rpl-clear, NULL, NULL, cmd_rpl_clear, 1, 0), |
| #if defined(CONFIG_BT_MESH_SHELL_HEALTH_SRV_INSTANCE) |
| SHELL_CMD(health-srv, &health_srv_cmds, "Health Server test", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| SHELL_SUBCMD_SET_END); |
| #endif /* CONFIG_BT_MESH_SHELL_TEST */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_GATT_PROXY) |
| SHELL_STATIC_SUBCMD_SET_CREATE(proxy_cmds, |
| #if defined(CONFIG_BT_MESH_GATT_PROXY) |
| SHELL_CMD_ARG(identity-enable, NULL, NULL, cmd_ident, 1, 0), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_PROXY_CLIENT) |
| SHELL_CMD_ARG(connect, NULL, "<NetKeyIdx>", cmd_proxy_connect, 2, 0), |
| SHELL_CMD_ARG(disconnect, NULL, "<NetKeyIdx>", cmd_proxy_disconnect, 2, 0), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_PROXY_SOLICITATION) |
| SHELL_CMD_ARG(solicit, NULL, "<NetKeyIdx>", |
| cmd_proxy_solicit, 2, 0), |
| #endif |
| SHELL_SUBCMD_SET_END); |
| #endif /* CONFIG_BT_MESH_SHELL_GATT_PROXY */ |
| |
| #if defined(CONFIG_BT_MESH_SHELL_LOW_POWER) |
| SHELL_STATIC_SUBCMD_SET_CREATE(low_pwr_cmds, |
| SHELL_CMD_ARG(set, NULL, "<Val(off, on)>", cmd_lpn, 2, 0), |
| SHELL_CMD_ARG(poll, NULL, NULL, cmd_poll, 1, 0), |
| SHELL_SUBCMD_SET_END); |
| #endif |
| |
| SHELL_STATIC_SUBCMD_SET_CREATE(target_cmds, |
| SHELL_CMD_ARG(dst, NULL, "[DstAddr]", cmd_dst, 1, 1), |
| SHELL_CMD_ARG(net, NULL, "[NetKeyIdx]", cmd_netidx, 1, 1), |
| SHELL_CMD_ARG(app, NULL, "[AppKeyIdx]", cmd_appidx, 1, 1), |
| SHELL_SUBCMD_SET_END); |
| |
| #if defined(CONFIG_BT_MESH_STATISTIC) |
| SHELL_STATIC_SUBCMD_SET_CREATE(stat_cmds, |
| SHELL_CMD_ARG(get, NULL, NULL, cmd_stat_get, 1, 0), |
| SHELL_CMD_ARG(clear, NULL, NULL, cmd_stat_clear, 1, 0), |
| SHELL_SUBCMD_SET_END); |
| #endif |
| |
| /* Placeholder for model shell modules that is configured in the application */ |
| SHELL_SUBCMD_SET_CREATE(model_cmds, (mesh, models)); |
| |
| /* List of Mesh subcommands. |
| * |
| * Each command is documented in doc/reference/bluetooth/mesh/shell.rst. |
| * |
| * Please keep the documentation up to date by adding any new commands to the |
| * list. |
| */ |
| SHELL_STATIC_SUBCMD_SET_CREATE(mesh_cmds, |
| SHELL_CMD_ARG(init, NULL, NULL, cmd_init, 1, 0), |
| SHELL_CMD_ARG(reset-local, NULL, NULL, cmd_reset, 1, 0), |
| |
| SHELL_CMD(models, &model_cmds, "Model commands", bt_mesh_shell_mdl_cmds_help), |
| |
| #if defined(CONFIG_BT_MESH_SHELL_LOW_POWER) |
| SHELL_CMD(lpn, &low_pwr_cmds, "Low Power commands", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_SHELL_CDB) |
| SHELL_CMD(cdb, &cdb_cmds, "Configuration Database", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_SHELL_GATT_PROXY) |
| SHELL_CMD(proxy, &proxy_cmds, "Proxy commands", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_SHELL_PROV) |
| SHELL_CMD(prov, &prov_cmds, "Provisioning commands", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| |
| #if defined(CONFIG_BT_MESH_SHELL_TEST) |
| SHELL_CMD(test, &test_cmds, "Test commands", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| SHELL_CMD(target, &target_cmds, "Target commands", bt_mesh_shell_mdl_cmds_help), |
| |
| #if defined(CONFIG_BT_MESH_STATISTIC) |
| SHELL_CMD(stat, &stat_cmds, "Statistic commands", bt_mesh_shell_mdl_cmds_help), |
| #endif |
| |
| SHELL_SUBCMD_SET_END |
| ); |
| |
| SHELL_CMD_ARG_REGISTER(mesh, &mesh_cmds, "Bluetooth Mesh shell commands", |
| bt_mesh_shell_mdl_cmds_help, 1, 1); |