Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-06-09 06:36:35 +03:00
Code Issues Packages Projects Releases Wiki Activity

feat(ble_mesh): Miscellaneous log enhancement for Provisioning

Browse Source
This commit is contained in:
luoxu
2025-09-01 20:47:15 +08:00
committed by Luo Xu
parent 3c6426168e
commit 6360b56e0b
3 changed files with 87 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
components/bt/esp_ble_mesh/core/prov_common.c
View File

@@ -48,6 +48,7 @@ void bt_mesh_prov_buf_init(struct net_buf_simple *buf, uint8_t type)
bt_mesh_output_action_t bt_mesh_prov_output_action(uint8_t action)
{
BT_DBG("ProvOutputAction:%d", action);
switch (action) {
case OUTPUT_OOB_BLINK:
return BLE_MESH_BLINK;
@@ -66,6 +67,7 @@ bt_mesh_output_action_t bt_mesh_prov_output_action(uint8_t action)
bt_mesh_input_action_t bt_mesh_prov_input_action(uint8_t action)
{
BT_DBG("ProvInputAction:%d", action);
switch (action) {
case INPUT_OOB_PUSH:
return BLE_MESH_PUSH;
@@ -151,20 +153,27 @@ static uint8_t bt_mesh_prov_buf_type_get(struct net_buf_simple *buf)
uint8_t node_next_xact_id(struct bt_mesh_prov_link *link)
{
uint8_t nxt_xact_id = 0;
if (link->tx.id != 0 && link->tx.id != 0xFF) {
return ++link->tx.id;
nxt_xact_id = ++link->tx.id;
} else {
link->tx.id = 0x80;
nxt_xact_id = 0x80;
}
link->tx.id = 0x80;
return link->tx.id;
BT_DBG("NodeNextXActId:%d", nxt_xact_id);
return nxt_xact_id;
}
uint8_t pvnr_next_xact_id(struct bt_mesh_prov_link *link)
{
uint8_t nxt_xact_id = 0;
if (link->tx.id > 0x7F) {
link->tx.id = 0;
}
return link->tx.id++;
nxt_xact_id = link->tx.id++;
BT_DBG("PvnrNextXActId:%d", nxt_xact_id);
return nxt_xact_id;
}
bool bt_mesh_gen_prov_start(struct bt_mesh_prov_link *link,
@@ -186,7 +195,7 @@ bool bt_mesh_gen_prov_start(struct bt_mesh_prov_link *link,
link->rx.id = rx->xact_id;
link->rx.fcs = net_buf_simple_pull_u8(buf);
BT_DBG("len %u last_seg %u total_len %u fcs 0x%02x", buf->len,
BT_DBG("LinkId:%08x,len %u last_seg %u total_len %u fcs 0x%02x", link->link_id, buf->len,
START_LAST_SEG(rx->gpc), link->rx.buf->len, link->rx.fcs);
/* At least one-octet pdu type is needed */
@@ -227,9 +236,10 @@ bool bt_mesh_gen_prov_start(struct bt_mesh_prov_link *link,
link->rx.last_seg = START_LAST_SEG(rx->gpc);
memcpy(link->rx.buf->data, buf->data, buf->len);
XACT_SEG_RECV(link, 0);
BT_DBG("Seg: %04x, lastSeg: %04x, Data: %s", link->rx.seg, link->rx.last_seg, bt_hex(buf->data, buf->len));
/* Still have some segments to receive */
if (link->rx.seg) {
BT_DBG("Still have some segments to receive: %02x", link->rx.seg);
return false;
}
@@ -242,7 +252,7 @@ bool bt_mesh_gen_prov_cont(struct bt_mesh_prov_link *link,
{
uint8_t seg = CONT_SEG_INDEX(rx->gpc);
BT_DBG("len %u, seg_index %u", buf->len, seg);
BT_DBG("LinkId:%08x,len %u,seg_index %u", link->link_id, buf->len, seg);
if (link->rx.seg == 0 && link->rx.prev_id == rx->xact_id) {
BT_INFO("Resending ack");
@@ -287,6 +297,7 @@ bool bt_mesh_gen_prov_cont(struct bt_mesh_prov_link *link,
/* Still have some segments to receive */
if (link->rx.seg) {
BT_DBG("Still have some segments to receive: %02x", link->rx.seg);
return false;
}
@@ -346,12 +357,14 @@ void bt_mesh_gen_prov_ack_send(struct bt_mesh_prov_link *link, uint8_t xact_id)
net_buf_add_u8(buf, xact_id);
net_buf_add_u8(buf, GPC_ACK);
BT_DBG("GenericProvAckSend,LinkId:%08x,XActId:%02x", link->link_id, xact_id);
bt_mesh_adv_send(buf, PROV_XMIT, complete, link);
net_buf_unref(buf);
}
static void free_segments(struct bt_mesh_prov_link *link)
{
BT_DBG("FreeSegments:%08x", link->link_id);
for (size_t i = 0; i < ARRAY_SIZE(link->tx.buf); i++) {
struct net_buf *buf = link->tx.buf[i];
@@ -386,6 +399,7 @@ static void buf_sent(int err, void *user_data)
int32_t timeout = RETRANSMIT_TIMEOUT;
if (!link->tx.buf[0]) {
BT_DBG("LinkId:%08x,NoTxBuf", link->link_id);
return;
}
@@ -412,6 +426,8 @@ static void prov_retransmit(struct k_work *work)
struct bt_mesh_prov_link *link = work->user_data;
int64_t timeout = TRANSACTION_TIMEOUT;
BT_DBG("LinkRetransmit:%08x,flag:%s", link->link_id, bt_hex(link->flags, sizeof(link->flags)));
if (!bt_mesh_atomic_test_bit(link->flags, LINK_ACTIVE) &&
!bt_mesh_atomic_test_bit(link->flags, LINK_CLOSING)) {
BT_WARN("Link not active");
@@ -493,7 +509,7 @@ static void prov_retransmit(struct k_work *work)
BT_DBG("%u bytes: %s", buf->len, bt_hex(buf->data, buf->len));
if (i + 1 < ARRAY_SIZE(link->tx.buf) && link->tx.buf[i + 1]) {
if (likely(i + 1 < ARRAY_SIZE(link->tx.buf) && link->tx.buf[i + 1])) {
bt_mesh_adv_send(buf, PROV_XMIT, NULL, NULL);
} else {
bt_mesh_adv_send(buf, PROV_XMIT, &buf_sent_cb, link);
@@ -521,7 +537,7 @@ static void send_reliable(struct bt_mesh_prov_link *link, uint8_t xmit)
break;
}
if (i + 1 < ARRAY_SIZE(link->tx.buf) && link->tx.buf[i + 1]) {
if (likely(i + 1 < ARRAY_SIZE(link->tx.buf) && link->tx.buf[i + 1])) {
bt_mesh_adv_send(buf, xmit, NULL, NULL);
} else {
bt_mesh_adv_send(buf, xmit, &buf_sent_cb, link);

32
components/bt/esp_ble_mesh/core/prov_node.c
View File

@@ -52,6 +52,7 @@ struct bt_mesh_prov_link *bt_mesh_prov_node_get_link(void)
static void close_link(uint8_t reason)
{
BT_DBG("LinkClose(Rpr:%d),Reason:%d", bt_mesh_atomic_test_bit(prov_link.flags, PB_REMOTE), reason);
if (bt_mesh_atomic_test_bit(prov_link.flags, PB_REMOTE)) {
if (prov_link.pb_remote_close) {
prov_link.pb_remote_close(&prov_link, reason);
@@ -69,6 +70,7 @@ void bt_mesh_prov_node_close_link(uint8_t reason)
static void reset_state(void)
{
BT_INFO("ProvLinkStateReset");
k_delayed_work_cancel(&prov_link.prot_timer);
/* Disable Attention Timer if it was set */
@@ -122,6 +124,7 @@ static void reset_adv_link(struct bt_mesh_prov_link *link, uint8_t reason)
{
ARG_UNUSED(link);
BT_INFO("ResetAdvLink:%08x", link->link_id);
bt_mesh_prov_clear_tx(&prov_link, true);
if (bt_mesh_prov_get()->link_close) {
@@ -267,6 +270,7 @@ static int prov_auth(uint8_t method, uint8_t action, uint8_t size)
auth_size = PROV_AUTH_SIZE(&prov_link);
BT_INFO("ProvAuth:method:%d,action:%d,size:%d", method, action, size);
switch (method) {
case AUTH_METHOD_NO_OOB:
if (action || size) {
@@ -411,6 +415,7 @@ static void prov_start(const uint8_t *data)
if ((bt_mesh_prov_get()->oob_type & BIT(PROV_ONLY_OOB_AUTH_SUPPORT)) &&
((data[0] == PROV_ALG_P256_HMAC_SHA256 && data[2] == AUTH_METHOD_NO_OOB) ||
data[0] == PROV_ALG_P256_CMAC_AES128)) {
BT_WARN("InvalidCapabilities,Alg:%d,Method:%d", data[0], data[2]);
close_link(PROV_ERR_NVAL_FMT);
return;
}
@@ -561,9 +566,10 @@ int bt_mesh_input_number(uint32_t num)
auth_size = PROV_AUTH_SIZE(&prov_link);
BT_INFO("%u", num);
BT_INFO("ProvInputNumber:%u", num);
if (!bt_mesh_atomic_test_and_clear_bit(prov_link.flags, WAIT_NUMBER)) {
BT_WARN("InvalidFlag:WAIT_NUMBER");
return -EINVAL;
}
@@ -572,6 +578,7 @@ int bt_mesh_input_number(uint32_t num)
send_input_complete();
if (!bt_mesh_atomic_test_bit(prov_link.flags, HAVE_DHKEY)) {
BT_INFO("DHKeyExists");
return 0;
}
@@ -587,6 +594,7 @@ int bt_mesh_input_string(const char *str)
BT_INFO("%s", str);
if (!bt_mesh_atomic_test_and_clear_bit(prov_link.flags, WAIT_STRING)) {
BT_WARN("InvalidFlag:WAIT_STRING");
return -EINVAL;
}
@@ -595,6 +603,7 @@ int bt_mesh_input_string(const char *str)
send_input_complete();
if (!bt_mesh_atomic_test_bit(prov_link.flags, HAVE_DHKEY)) {
BT_INFO("DHKeyExists");
return 0;
}
@@ -712,6 +721,7 @@ int bt_mesh_set_oob_pub_key(const uint8_t pub_key_x[32],
/* If remote public key is not got, just return */
if (!bt_mesh_atomic_test_bit(prov_link.flags, REMOTE_PUB_KEY)) {
BT_WARN("RemotePubKeyNotSet");
return 0;
}
@@ -902,6 +912,7 @@ static void prov_data(const uint8_t *data)
uint8_t reason = 0;
if (bt_mesh_rpr_srv_nppi_check(prov_link.pb_remote_nppi, pdu, net_idx,
iv_index, addr, &reason) == false) {
BT_WARN("RprNppiCheckFail:%d", reason);
close_link(reason);
return;
}
@@ -924,6 +935,7 @@ static void prov_data(const uint8_t *data)
pdu, net_idx, flags,
iv_index, addr, dev_key);
if (err) {
BT_WARN("RprNppiStoreFail:%d", err);
close_link(PROV_ERR_UNEXP_ERR);
return;
}
@@ -964,6 +976,7 @@ static void prov_data(const uint8_t *data)
* using Node Identity.
*/
if (IS_ENABLED(CONFIG_BLE_MESH_GATT_PROXY_SERVER) && identity_enable) {
BT_DBG("EnableProxyIdentity");
bt_mesh_proxy_identity_enable();
}
}
@@ -973,7 +986,7 @@ static void prov_complete(const uint8_t *data)
static void prov_failed(const uint8_t *data)
{
BT_WARN("Error: 0x%02x", data[0]);
BT_WARN("ProvError: 0x%02x", data[0]);
#if CONFIG_BLE_MESH_RPR_SRV
if (bt_mesh_atomic_test_bit(prov_link.flags, PB_REMOTE)) {
@@ -1011,7 +1024,7 @@ static const struct {
#if CONFIG_BLE_MESH_PB_ADV
static void link_open(struct prov_rx *rx, struct net_buf_simple *buf)
{
BT_DBG("len %u", buf->len);
BT_DBG("LinkOpenLen:%u", buf->len);
if (buf->len < 16) {
BT_ERR("Too short bearer open message (len %u)", buf->len);
@@ -1065,7 +1078,7 @@ static void link_open(struct prov_rx *rx, struct net_buf_simple *buf)
static void link_ack(struct prov_rx *rx, struct net_buf_simple *buf)
{
BT_DBG("len %u", buf->len);
BT_DBG("LinkAckLen:%u",buf->len);
#if CONFIG_BLE_MESH_RPR_SRV
if (bt_mesh_atomic_test_bit(prov_link.flags, PB_REMOTE)) {
@@ -1094,7 +1107,7 @@ static void link_close(struct prov_rx *rx, struct net_buf_simple *buf)
{
uint8_t reason = 0;
BT_DBG("len %u", buf->len);
BT_DBG("LinkCloseLen %u", buf->len);
if (buf->len != 1) {
BT_ERR("Invalid Link Close length %d", buf->len);
@@ -1258,12 +1271,14 @@ static void gen_prov_ack(struct prov_rx *rx, struct net_buf_simple *buf)
BT_DBG("len %u", buf->len);
if (!prov_link.tx.buf[0]) {
BT_DBG("AlreadyReceived");
return;
}
#if CONFIG_BLE_MESH_RPR_SRV
if (bt_mesh_atomic_test_bit(prov_link.flags, PB_REMOTE)) {
if (prov_link.tx.id == 0) {
BT_DBG("ZeroTxId");
return;
}
@@ -1278,6 +1293,7 @@ static void gen_prov_ack(struct prov_rx *rx, struct net_buf_simple *buf)
#endif /* CONFIG_BLE_MESH_RPR_SRV */
if (rx->xact_id == prov_link.tx.id) {
BT_DBG("XActId:%04x,ReceivedAck", rx->xact_id);
bt_mesh_prov_clear_tx(&prov_link, true);
}
}
@@ -1342,7 +1358,7 @@ void bt_mesh_pb_adv_recv(struct net_buf_simple *buf)
rx.xact_id = net_buf_simple_pull_u8(buf);
rx.gpc = net_buf_simple_pull_u8(buf);
BT_DBG("link_id 0x%08x xact_id %u", rx.link_id, rx.xact_id);
BT_DBG("link_id 0x%08x xact_id %u gpc %u", rx.link_id, rx.xact_id, rx.gpc);
if (bt_mesh_atomic_test_bit(prov_link.flags, LINK_ACTIVE) &&
prov_link.link_id != rx.link_id) {
@@ -1441,7 +1457,7 @@ int bt_mesh_pb_gatt_recv(struct bt_mesh_conn *conn, struct net_buf_simple *buf)
int bt_mesh_pb_gatt_open(struct bt_mesh_conn *conn)
{
BT_DBG("conn %p", conn);
BT_DBG("ProvConnOpen %p", conn);
/**
* It's necessary to determine if it is PB_REMOTE because when the
@@ -1482,7 +1498,7 @@ int bt_mesh_pb_gatt_open(struct bt_mesh_conn *conn)
int bt_mesh_pb_gatt_close(struct bt_mesh_conn *conn, uint8_t reason)
{
BT_DBG("conn %p", conn);
BT_DBG("ProvConnClose %p", conn);
if (prov_link.conn != conn) {
BT_ERR("Not connected");

46
components/bt/esp_ble_mesh/core/prov_pvnr.c
View File

@@ -202,6 +202,7 @@ static inline void bt_mesh_pb_gatt_unlock(void)
void bt_mesh_provisioner_pbg_count_dec(void)
{
BT_DBG("PbgCntDec:%d", prov_ctx.pbg_count);
if (prov_ctx.pbg_count) {
prov_ctx.pbg_count--;
}
@@ -210,6 +211,7 @@ void bt_mesh_provisioner_pbg_count_dec(void)
static inline void provisioner_pbg_count_inc(void)
{
prov_ctx.pbg_count++;
BT_DBG("PbgCntInc:%d", prov_ctx.pbg_count);
}
void bt_mesh_provisioner_clear_link_info(const uint8_t addr[6])
@@ -436,8 +438,8 @@ static int provisioner_start_prov_pb_gatt(const uint8_t uuid[16], const bt_mesh_
*/
if (assign_addr == BLE_MESH_ADDR_UNASSIGNED &&
prov_ctx.alloc_addr == BLE_MESH_ADDR_UNASSIGNED) {
BT_ERR("No available unicast address to assign");
bt_mesh_pb_gatt_unlock();
BT_ERR("No available unicast address to assign");
return -EIO;
}
@@ -451,6 +453,7 @@ static int provisioner_start_prov_pb_gatt(const uint8_t uuid[16], const bt_mesh_
!bt_mesh_atomic_test_bit(prov_links[i].flags, LINK_ACTIVE)) {
if (bt_mesh_gattc_conn_create(addr, BLE_MESH_UUID_MESH_PROV_VAL)) {
bt_mesh_pb_gatt_unlock();
BT_ERR("ProvGattCreateFailed:%s", bt_hex(addr->val, 6));
return -EIO;
}
@@ -598,6 +601,7 @@ int bt_mesh_provisioner_add_unprov_dev(struct bt_mesh_unprov_dev_add *add_dev, u
start:
/* If not provisioning immediately, directly return here */
if (!(flags & START_PROV_NOW)) {
BT_DBG("StartProvNotSet");
return 0;
}
@@ -617,6 +621,9 @@ start:
}
if ((err = provisioner_check_unprov_dev_info(add_dev->uuid, add_dev->bearer))) {
if (err == -EALREADY) {
BT_INFO("The device is being provisioning");
}
return err;
}
@@ -710,6 +717,9 @@ int bt_mesh_provisioner_prov_device_with_addr(const uint8_t uuid[16], const uint
}
if ((err = provisioner_check_unprov_dev_info(uuid, bearer))) {
if (err == -EALREADY) {
BT_INFO("The device is being provisioning");
}
return err;
}
@@ -749,10 +759,12 @@ int bt_mesh_provisioner_delete_device(struct bt_mesh_device_delete *del_dev)
return -EINVAL;
}
BT_INFO("ProvisionerDeleteDevice:%s", bt_hex(del_dev->uuid, 16));
/* Find if the device is in the device queue */
for (i = 0; i < ARRAY_SIZE(unprov_dev); i++) {
if (!memcmp(unprov_dev[i].uuid, del_dev->uuid, 16)) {
memset(&unprov_dev[i], 0, sizeof(struct unprov_dev_queue));
BT_INFO("Device is in the queue");
break;
}
}
@@ -761,6 +773,7 @@ int bt_mesh_provisioner_delete_device(struct bt_mesh_device_delete *del_dev)
for (i = 0; i < ARRAY_SIZE(prov_links); i++) {
if (!memcmp(prov_links[i].uuid, del_dev->uuid, 16)) {
close_link(&prov_links[i], CLOSE_REASON_FAILED);
BT_INFO("Device is being provisioned");
break;
}
}
@@ -776,6 +789,7 @@ int bt_mesh_provisioner_set_dev_uuid_match(uint8_t offset, uint8_t length,
return -EINVAL;
}
BT_INFO("SetUUIDMatch,offset:%d,value:%s,flag:%d", offset, bt_hex(match, length), prov_flag);
(void)memset(prov_ctx.match_value, 0, 16);
prov_ctx.match_offset = offset;
@@ -795,6 +809,7 @@ int bt_mesh_provisioner_adv_pkt_cb_register(unprov_adv_pkt_cb_t cb)
return -EINVAL;
}
BT_INFO("RegisterAdvCB:%p", notify_unprov_adv_pkt_cb);
notify_unprov_adv_pkt_cb = cb;
return 0;
}
@@ -815,6 +830,7 @@ int bt_mesh_provisioner_set_prov_data_info(struct bt_mesh_prov_data_info *info)
}
prov_ctx.net_idx = info->net_idx;
BT_INFO("SetProvCtx,NetIndex:%d", info->net_idx);
}
return 0;
@@ -881,6 +897,7 @@ void bt_mesh_provisioner_set_prov_bearer(bt_mesh_prov_bearer_t bearers, bool cle
} else {
prov_ctx.bearers &= ~bearers;
}
BT_INFO("ProvCtxBearer:%04x,clear:%d", prov_ctx.bearers, clear);
}
bt_mesh_prov_bearer_t bt_mesh_provisioner_get_prov_bearer(void)
@@ -909,7 +926,7 @@ int bt_mesh_provisioner_set_static_oob_value(const uint8_t *value, uint8_t lengt
prov_ctx.static_oob_len = MIN(BLE_MESH_PROV_STATIC_OOB_MAX_LEN, length);
memcpy(prov_ctx.static_oob_val, value, prov_ctx.static_oob_len);
BT_INFO("SetStaticOob:%s", bt_hex(value, prov_ctx.static_oob_len));
return 0;
}
@@ -984,11 +1001,13 @@ int bt_mesh_test_provisioner_update_alloc_addr(uint16_t unicast_addr, uint16_t e
void bt_mesh_provisioner_fast_prov_enable(bool enable)
{
prov_ctx.fast_prov.enable = enable;
BT_INFO("FastProvEnable:%d", enable);
}
void bt_mesh_provisioner_set_fast_prov_net_idx(uint16_t net_idx)
{
prov_ctx.fast_prov.net_idx = net_idx;
BT_INFO("FastProvNetIdx:%d", net_idx);
}
uint16_t bt_mesh_provisioner_get_fast_prov_net_idx(void)
@@ -1017,7 +1036,7 @@ uint8_t bt_mesh_set_fast_prov_unicast_addr_range(uint16_t min, uint16_t max)
prov_ctx.fast_prov.unicast_addr_max = max;
prov_ctx.alloc_addr = prov_ctx.fast_prov.unicast_addr_min;
BT_INFO("FastProv,AddrMin:%04x,Max:%04x,allocAddr:%04x", min, max, prov_ctx.alloc_addr);
return 0x0; /* status: success */
}
@@ -1038,6 +1057,7 @@ static struct net_buf_simple *get_rx_buf(const uint8_t idx)
static void reset_adv_link(struct bt_mesh_prov_link *link, uint8_t reason)
{
BT_INFO("ResetAdvLink:%08x", link->link_id);
bt_mesh_prov_clear_tx(link, true);
if (bt_mesh_prov_get()->prov_link_close) {
@@ -1106,6 +1126,7 @@ static void send_link_open(struct bt_mesh_prov_link *link)
if (bt_mesh_atomic_test_bit(prov_links[i].flags, LINK_ACTIVE) &&
prov_links[i].link_id == link->link_id) {
bt_mesh_rand(&link->link_id, sizeof(link->link_id));
BT_DBG("ProvLinkIdx:%d,LinkId:%08x", i, link->link_id);
break;
}
}
@@ -1280,6 +1301,7 @@ static void prov_capabilities(struct bt_mesh_prov_link *link,
if ((algorithms & BIT(PROV_ALG_P256_CMAC_AES128)) ||
(!((oob_type & BIT(PROV_STATIC_OOB_AVAILABLE)) == 0x00 ||
output_size == 0x00 || input_size == 0x00))) {
BT_INFO("InvalidOobTypeSet:%02x,Alg:%02x", oob_type, algorithms);
goto fail;
}
}
@@ -1358,6 +1380,7 @@ static void prov_capabilities(struct bt_mesh_prov_link *link,
* send Remote Provisioning PDU Send with Public Key.
*/
if (bt_mesh_atomic_test_bit(link->flags, PB_REMOTE)) {
BT_DBG("WaitForRprClientCmd");
return;
}
@@ -1387,6 +1410,7 @@ static int prov_auth(struct bt_mesh_prov_link *link,
bt_mesh_input_action_t input = 0U;
uint8_t auth_size = PROV_AUTH_SIZE(link);
BT_INFO("ProvAuth:method:%d,action:%d,size:%d", method, action, size);
switch (method) {
case AUTH_METHOD_NO_OOB:
if (action || size) {
@@ -1778,6 +1802,7 @@ static void prov_gen_dh_key(struct bt_mesh_prov_link *link)
*/
if (link->auth_method == AUTH_METHOD_OUTPUT ||
link->auth_method == AUTH_METHOD_INPUT) {
BT_INFO("WaitForNextAction:%d", link->auth_method);
return;
}
@@ -1814,6 +1839,7 @@ static void prov_gen_dh_key(struct bt_mesh_prov_link *link)
* Input Complete, because if the authentication method is
* Output OOB or Input OOB, it will directly return above.
*/
BT_DBG("LinkExpect:%d", link->expect);
if (link->expect != PROV_INPUT_COMPLETE) {
send_confirm(link);
}
@@ -2094,6 +2120,7 @@ static void send_prov_data(struct bt_mesh_prov_link *link)
link->unicast_addr = alloc_addr;
}
BT_DBG("ProvAllocAddr:%04x", link->unicast_addr);
bt_mesh_prov_buf_init(&buf, PROV_DATA);
err = bt_mesh_prov_encrypt(session_key, nonce, pdu, net_buf_simple_add(&buf, 33));
@@ -2310,7 +2337,7 @@ static void prov_complete(struct bt_mesh_prov_link *link,
static void prov_failed(struct bt_mesh_prov_link *link,
struct net_buf_simple *buf)
{
BT_WARN("Error 0x%02x", buf->data[0]);
BT_WARN("ProvError 0x%02x", buf->data[0]);
close_link(link, CLOSE_REASON_FAILED);
}
@@ -2360,7 +2387,7 @@ static void close_link(struct bt_mesh_prov_link *link, uint8_t reason)
#if CONFIG_BLE_MESH_PB_ADV
static void link_ack(struct bt_mesh_prov_link *link, struct prov_rx *rx, struct net_buf_simple *buf)
{
BT_DBG("len %u", buf->len);
BT_DBG("LinkAckLen %u", buf->len);
if (buf->len) {
BT_ERR("Invalid Link ACK length %d", buf->len);
@@ -2388,7 +2415,7 @@ static void link_ack(struct bt_mesh_prov_link *link, struct prov_rx *rx, struct
static void link_close(struct bt_mesh_prov_link *link, struct prov_rx *rx, struct net_buf_simple *buf)
{
BT_DBG("len %u", buf->len);
BT_DBG("LinkCloseLen %u", buf->len);
if (buf->len != 1) {
BT_ERR("Invalid Link Close length %d", buf->len);
@@ -2511,10 +2538,12 @@ static void gen_prov_ack(struct bt_mesh_prov_link *link,
BT_DBG("len %u", buf->len);
if (!link->tx.buf[0]) {
BT_DBG("NullTxbuf");
return;
}
if (!link->tx.id) {
BT_DBG("ZeroTxId");
return;
}
@@ -2620,7 +2649,7 @@ void bt_mesh_provisioner_pb_adv_recv(struct net_buf_simple *buf)
rx.xact_id = net_buf_simple_pull_u8(buf);
rx.gpc = net_buf_simple_pull_u8(buf);
BT_DBG("link_id 0x%08x xact_id %u", rx.link_id, rx.xact_id);
BT_DBG("link_id 0x%08x xact_id %u gpc %u", rx.link_id, rx.xact_id, rx.gpc);
link = find_pba_link(rx.link_id);
if (link == NULL) {
@@ -2783,7 +2812,7 @@ static void protocol_timeout(struct k_work *work)
{
struct bt_mesh_prov_link *link = work->user_data;
BT_WARN("Protocol timeout");
BT_WARN("Protocol timeout,LinkId:%08x", link->link_id);
close_link(link, CLOSE_REASON_TIMEOUT);
}
@@ -3112,6 +3141,7 @@ int bt_mesh_rpr_cli_pdu_recv(struct bt_mesh_prov_link *link, uint8_t type,
return -EINVAL;
}
BT_INFO("RprCliProvType:%d", type);
prov_handlers[type].func(link, buf);
return 0;
}