This is an automated email from the ASF dual-hosted git repository. sjanc pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit 53f5f2d6d2c4635f7632f95c0c11a46e9260dd28 Author: raiden00pl <[email protected]> AuthorDate: Wed Oct 14 10:03:45 2026 +0200 nimble/mesh: Rename provisioning bearer link state The PB-ADV and PB-GATT bearers keep their state in a file-scope variable named link, which collides with the POSIX link() declaration whenever unistd.h is visible, for example through pthread.h on NuttX. Rename the variables to adv_link and gatt_link. No functional change. Assisted-by: Claude:claude-fable-5-1 Signed-off-by: raiden00pl <[email protected]> --- nimble/host/mesh/src/pb_adv.c | 270 ++++++++++++++++++++--------------------- nimble/host/mesh/src/pb_gatt.c | 46 +++---- 2 files changed, 158 insertions(+), 158 deletions(-) diff --git a/nimble/host/mesh/src/pb_adv.c b/nimble/host/mesh/src/pb_adv.c index 76b96ae36..2705e21b1 100644 --- a/nimble/host/mesh/src/pb_adv.c +++ b/nimble/host/mesh/src/pb_adv.c @@ -43,8 +43,8 @@ #define LINK_CLOSE 0x02 #define XACT_SEG_OFFSET(_seg) (20 + ((_seg - 1) * 23)) -#define XACT_SEG_DATA(_seg) (&link.rx.buf->om_data[XACT_SEG_OFFSET(_seg)]) -#define XACT_SEG_RECV(_seg) (link.rx.seg &= ~(1 << (_seg))) +#define XACT_SEG_DATA(_seg) (&adv_link.rx.buf->om_data[XACT_SEG_OFFSET(_seg)]) +#define XACT_SEG_RECV(_seg) (adv_link.rx.seg &= ~(1 << (_seg))) #define XACT_ID_MAX 0x7f #define XACT_ID_NVAL 0xff @@ -122,7 +122,7 @@ struct prov_rx { }; static struct os_mbuf *rx_buf; -static struct pb_adv link; +static struct pb_adv adv_link; static void gen_prov_ack_send(uint8_t xact_id); static void link_open(struct prov_rx *rx, struct os_mbuf *buf); @@ -135,7 +135,7 @@ static void buf_sent(int err, void *user_data) { BT_DBG("buf_send"); - if (atomic_test_and_clear_bit(link.flags, ADV_LINK_CLOSING)) { + if (atomic_test_and_clear_bit(adv_link.flags, ADV_LINK_CLOSING)) { close_link(PROV_BEARER_LINK_STATUS_SUCCESS); return; } @@ -168,14 +168,14 @@ static void free_segments(void) { int i; - for (i = 0; i < ARRAY_SIZE(link.tx.buf); i++) { - struct os_mbuf *buf = link.tx.buf[i]; + for (i = 0; i < ARRAY_SIZE(adv_link.tx.buf); i++) { + struct os_mbuf *buf = adv_link.tx.buf[i]; if (!buf) { break; } - link.tx.buf[i] = NULL; + adv_link.tx.buf[i] = NULL; /* Mark as canceled */ BT_MESH_ADV(buf)->busy = 0U; net_buf_unref(buf); @@ -196,7 +196,7 @@ static void prov_clear_tx(void) * LINK_ACTIVE flag, so if this call is part of reset_adv_link, it'll * exit early. */ - (void)k_work_cancel_delayable(&link.tx.retransmit); + (void)k_work_cancel_delayable(&adv_link.tx.retransmit); free_segments(); } @@ -209,33 +209,33 @@ static void reset_adv_link(void) /* If this fails, the work handler will exit early on the LINK_ACTIVE * check. */ - (void)k_work_cancel_delayable(&link.prot_timer); + (void)k_work_cancel_delayable(&adv_link.prot_timer); - if (atomic_test_bit(link.flags, ADV_PROVISIONER)) { + if (atomic_test_bit(adv_link.flags, ADV_PROVISIONER)) { /* Clear everything except the retransmit and protocol timer * delayed work objects. */ - (void)memset(&link, 0, offsetof(struct pb_adv, tx.retransmit)); - link.rx.id = XACT_ID_NVAL; + (void)memset(&adv_link, 0, offsetof(struct pb_adv, tx.retransmit)); + adv_link.rx.id = XACT_ID_NVAL; } else { /* Accept another provisioning attempt */ - link.id = 0; - atomic_clear(link.flags); - link.rx.id = XACT_ID_MAX; - link.tx.id = XACT_ID_NVAL; + adv_link.id = 0; + atomic_clear(adv_link.flags); + adv_link.rx.id = XACT_ID_MAX; + adv_link.tx.id = XACT_ID_NVAL; } - link.tx.pending_ack = XACT_ID_NVAL; + adv_link.tx.pending_ack = XACT_ID_NVAL; if (!rx_buf) { rx_buf = NET_BUF_SIMPLE(RX_BUFFER_MAX); } - link.rx.buf = rx_buf; - net_buf_simple_reset(link.rx.buf); + adv_link.rx.buf = rx_buf; + net_buf_simple_reset(adv_link.rx.buf); } static void close_link(enum prov_bearer_link_status reason) { - const struct prov_bearer_cb *cb = link.cb; - void *cb_data = link.cb_data; + const struct prov_bearer_cb *cb = adv_link.cb; + void *cb_data = adv_link.cb_data; reset_adv_link(); cb->link_closed(&pb_adv, cb_data, reason); @@ -258,52 +258,52 @@ static struct os_mbuf *adv_buf_create(uint8_t retransmits) static void ack_complete(uint16_t duration, int err, void *user_data) { - BT_DBG("xact 0x%x complete", (uint8_t)link.tx.pending_ack); - atomic_clear_bit(link.flags, ADV_ACK_PENDING); + BT_DBG("xact 0x%x complete", (uint8_t)adv_link.tx.pending_ack); + atomic_clear_bit(adv_link.flags, ADV_ACK_PENDING); } static bool ack_pending(void) { - return atomic_test_bit(link.flags, ADV_ACK_PENDING); + return atomic_test_bit(adv_link.flags, ADV_ACK_PENDING); } static void prov_failed(uint8_t err) { BT_DBG("%u", err); - link.cb->error(&pb_adv, link.cb_data, err); - atomic_set_bit(link.flags, ADV_LINK_INVALID); + adv_link.cb->error(&pb_adv, adv_link.cb_data, err); + atomic_set_bit(adv_link.flags, ADV_LINK_INVALID); } static void prov_msg_recv(void) { - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + k_work_reschedule(&adv_link.prot_timer, PROTOCOL_TIMEOUT); - if (!bt_mesh_fcs_check(link.rx.buf, link.rx.fcs)) { + if (!bt_mesh_fcs_check(adv_link.rx.buf, adv_link.rx.fcs)) { BT_ERR("Incorrect FCS"); return; } - gen_prov_ack_send(link.rx.id); + gen_prov_ack_send(adv_link.rx.id); - if (atomic_test_bit(link.flags, ADV_LINK_INVALID)) { + if (atomic_test_bit(adv_link.flags, ADV_LINK_INVALID)) { BT_WARN("Unexpected msg 0x%02x on invalidated link", - link.rx.buf->om_data[0]); + adv_link.rx.buf->om_data[0]); prov_failed(PROV_ERR_UNEXP_PDU); return; } - link.cb->recv(&pb_adv, link.cb_data, link.rx.buf); + adv_link.cb->recv(&pb_adv, adv_link.cb_data, adv_link.rx.buf); } static void protocol_timeout(struct ble_npl_event *work) { - if (!atomic_test_bit(link.flags, ADV_LINK_ACTIVE)) { + if (!atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE)) { return; } BT_DBG(""); - link.rx.seg = 0U; + adv_link.rx.seg = 0U; prov_link_close(PROV_BEARER_LINK_STATUS_TIMEOUT); } /******************************************************************************* @@ -317,29 +317,29 @@ static void gen_prov_ack_send(uint8_t xact_id) }; const struct bt_mesh_send_cb *complete; struct os_mbuf *buf; - bool pending = atomic_test_and_set_bit(link.flags, ADV_ACK_PENDING); + bool pending = atomic_test_and_set_bit(adv_link.flags, ADV_ACK_PENDING); BT_DBG("xact_id 0x%x", xact_id); - if (pending && link.tx.pending_ack == xact_id) { + if (pending && adv_link.tx.pending_ack == xact_id) { BT_DBG("Not sending duplicate ack"); return; } buf = adv_buf_create(RETRANSMITS_ACK); if (!buf) { - atomic_clear_bit(link.flags, ADV_ACK_PENDING); + atomic_clear_bit(adv_link.flags, ADV_ACK_PENDING); return; } if (pending) { complete = NULL; } else { - link.tx.pending_ack = xact_id; + adv_link.tx.pending_ack = xact_id; complete = &cb; } - net_buf_add_be32(buf, link.id); + net_buf_add_be32(buf, adv_link.id); net_buf_add_u8(buf, xact_id); net_buf_add_u8(buf, GPC_ACK); @@ -353,7 +353,7 @@ static void gen_prov_cont(struct prov_rx *rx, struct os_mbuf *buf) BT_DBG("len %u, seg_index %u", buf->om_len, seg); - if (!link.rx.seg && link.rx.id == rx->xact_id) { + if (!adv_link.rx.seg && adv_link.rx.id == rx->xact_id) { if (!ack_pending()) { BT_DBG("Resending ack"); gen_prov_ack_send(rx->xact_id); @@ -362,30 +362,30 @@ static void gen_prov_cont(struct prov_rx *rx, struct os_mbuf *buf) return; } - if (!link.rx.seg && - next_transaction_id(link.rx.id) == rx->xact_id) { + if (!adv_link.rx.seg && + next_transaction_id(adv_link.rx.id) == rx->xact_id) { BT_DBG("Start segment lost"); - link.rx.id = rx->xact_id; + adv_link.rx.id = rx->xact_id; - net_buf_simple_reset(link.rx.buf); - link.rx.seg = SEG_NVAL; - link.rx.last_seg = SEG_NVAL; + net_buf_simple_reset(adv_link.rx.buf); + adv_link.rx.seg = SEG_NVAL; + adv_link.rx.last_seg = SEG_NVAL; prov_clear_tx(); - } else if (rx->xact_id != link.rx.id) { + } else if (rx->xact_id != adv_link.rx.id) { BT_WARN("Data for unknown transaction (0x%x != 0x%x)", - rx->xact_id, link.rx.id); + rx->xact_id, adv_link.rx.id); return; } - if (seg > link.rx.last_seg) { + if (seg > adv_link.rx.last_seg) { BT_ERR("Invalid segment index %u", seg); prov_failed(PROV_ERR_NVAL_FMT); return; } - if (!(link.rx.seg & BIT(seg))) { + if (!(adv_link.rx.seg & BIT(seg))) { BT_DBG("Ignoring already received segment"); return; } @@ -398,11 +398,11 @@ static void gen_prov_cont(struct prov_rx *rx, struct os_mbuf *buf) memcpy(XACT_SEG_DATA(seg), buf->om_data, buf->om_len); XACT_SEG_RECV(seg); - if (seg == link.rx.last_seg && !(link.rx.seg & BIT(0))) { + if (seg == adv_link.rx.last_seg && !(adv_link.rx.seg & BIT(0))) { uint8_t expect_len; - expect_len = (link.rx.buf->om_len - 20U - - ((link.rx.last_seg - 1) * 23U)); + expect_len = (adv_link.rx.buf->om_len - 20U - + ((adv_link.rx.last_seg - 1) * 23U)); if (expect_len != buf->om_len) { BT_ERR("Incorrect last seg len: %u != %u", expect_len, buf->om_len); @@ -411,7 +411,7 @@ static void gen_prov_cont(struct prov_rx *rx, struct os_mbuf *buf) } } - if (!link.rx.seg) { + if (!adv_link.rx.seg) { prov_msg_recv(); } } @@ -420,18 +420,18 @@ static void gen_prov_ack(struct prov_rx *rx, struct os_mbuf *buf) { BT_DBG("len %u", buf->om_len); - if (!link.tx.buf[0]) { + if (!adv_link.tx.buf[0]) { return; } - if (rx->xact_id == link.tx.id) { + if (rx->xact_id == adv_link.tx.id) { /* Don't clear resending of link_close messages */ - if (!atomic_test_bit(link.flags, ADV_LINK_CLOSING)) { + if (!atomic_test_bit(adv_link.flags, ADV_LINK_CLOSING)) { prov_clear_tx(); } - if (link.tx.cb) { - link.tx.cb(0, link.tx.cb_data); + if (adv_link.tx.cb) { + adv_link.tx.cb(0, adv_link.tx.cb_data); } } } @@ -440,8 +440,8 @@ static void gen_prov_start(struct prov_rx *rx, struct os_mbuf *buf) { uint8_t seg = SEG_NVAL; - if (rx->xact_id == link.rx.id) { - if (!link.rx.seg) { + if (rx->xact_id == adv_link.rx.id) { + if (!adv_link.rx.seg) { if (!ack_pending()) { BT_DBG("Resending ack"); gen_prov_ack_send(rx->xact_id); @@ -450,31 +450,31 @@ static void gen_prov_start(struct prov_rx *rx, struct os_mbuf *buf) return; } - if (!(link.rx.seg & BIT(0))) { + if (!(adv_link.rx.seg & BIT(0))) { BT_DBG("Ignoring duplicate segment"); return; } - } else if (rx->xact_id != next_transaction_id(link.rx.id)) { + } else if (rx->xact_id != next_transaction_id(adv_link.rx.id)) { BT_WARN("Unexpected xact 0x%x, expected 0x%x", rx->xact_id, - next_transaction_id(link.rx.id)); + next_transaction_id(adv_link.rx.id)); return; } - net_buf_simple_reset(link.rx.buf); - link.rx.buf->om_len = net_buf_simple_pull_be16(buf); - link.rx.id = rx->xact_id; - link.rx.fcs = net_buf_simple_pull_u8(buf); + net_buf_simple_reset(adv_link.rx.buf); + adv_link.rx.buf->om_len = net_buf_simple_pull_be16(buf); + adv_link.rx.id = rx->xact_id; + adv_link.rx.fcs = net_buf_simple_pull_u8(buf); - BT_DBG("%p len %u last_seg %u total_len %u fcs 0x%02x", link.rx.buf, buf->om_len, - START_LAST_SEG(rx->gpc), link.rx.buf->om_len, link.rx.fcs); + BT_DBG("%p len %u last_seg %u total_len %u fcs 0x%02x", adv_link.rx.buf, buf->om_len, + START_LAST_SEG(rx->gpc), adv_link.rx.buf->om_len, adv_link.rx.fcs); - if (link.rx.buf->om_len < 1) { + if (adv_link.rx.buf->om_len < 1) { BT_ERR("Ignoring zero-length provisioning PDU"); prov_failed(PROV_ERR_NVAL_FMT); return; } - if (START_LAST_SEG(rx->gpc) > 0 && link.rx.buf->om_len <= 20U) { + if (START_LAST_SEG(rx->gpc) > 0 && adv_link.rx.buf->om_len <= 20U) { BT_ERR("Too small total length for multi-segment PDU"); prov_failed(PROV_ERR_NVAL_FMT); return; @@ -482,23 +482,23 @@ static void gen_prov_start(struct prov_rx *rx, struct os_mbuf *buf) prov_clear_tx(); - link.rx.last_seg = START_LAST_SEG(rx->gpc); - if ((link.rx.seg & BIT(0)) && - (find_msb_set((~link.rx.seg) & SEG_NVAL) - 1 > link.rx.last_seg)) { + adv_link.rx.last_seg = START_LAST_SEG(rx->gpc); + if ((adv_link.rx.seg & BIT(0)) && + (find_msb_set((~adv_link.rx.seg) & SEG_NVAL) - 1 > adv_link.rx.last_seg)) { BT_ERR("Invalid segment index %u", seg); prov_failed(PROV_ERR_NVAL_FMT); return; } - if (link.rx.seg) { - seg = link.rx.seg; + if (adv_link.rx.seg) { + seg = adv_link.rx.seg; } - link.rx.seg = seg & ((1 << (START_LAST_SEG(rx->gpc) + 1)) - 1); - memcpy(link.rx.buf->om_data, buf->om_data, buf->om_len); + adv_link.rx.seg = seg & ((1 << (START_LAST_SEG(rx->gpc) + 1)) - 1); + memcpy(adv_link.rx.buf->om_data, buf->om_data, buf->om_len); XACT_SEG_RECV(0); - if (!link.rx.seg) { + if (!adv_link.rx.seg) { prov_msg_recv(); } } @@ -512,14 +512,14 @@ static void gen_prov_ctl(struct prov_rx *rx, struct os_mbuf *buf) link_open(rx, buf); break; case LINK_ACK: - if (!atomic_test_bit(link.flags, ADV_LINK_ACTIVE)) { + if (!atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE)) { return; } link_ack(rx, buf); break; case LINK_CLOSE: - if (!atomic_test_bit(link.flags, ADV_LINK_ACTIVE)) { + if (!atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE)) { return; } @@ -554,7 +554,7 @@ static void gen_prov_recv(struct prov_rx *rx, struct os_mbuf *buf) return; } - if (!atomic_test_bit(link.flags, ADV_LINK_ACTIVE) && + if (!atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE) && gen_prov[GPCF(rx->gpc)].require_link) { BT_DBG("Ignoring message that requires active link"); return; @@ -571,8 +571,8 @@ static void send_reliable(void) { int i; - for (i = 0; i < ARRAY_SIZE(link.tx.buf); i++) { - struct os_mbuf *buf = link.tx.buf[i]; + for (i = 0; i < ARRAY_SIZE(adv_link.tx.buf); i++) { + struct os_mbuf *buf = adv_link.tx.buf[i]; if (!buf) { break; @@ -587,19 +587,19 @@ static void send_reliable(void) bt_mesh_adv_send(buf, NULL, NULL); } - k_work_reschedule(&link.tx.retransmit, RETRANSMIT_TIMEOUT); + k_work_reschedule(&adv_link.tx.retransmit, RETRANSMIT_TIMEOUT); } static void prov_retransmit(struct ble_npl_event *work) { BT_DBG(""); - if (!atomic_test_bit(link.flags, ADV_LINK_ACTIVE)) { + if (!atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE)) { BT_WARN("Link not active"); return; } - if (k_uptime_get() - link.tx.start > TRANSACTION_TIMEOUT) { + if (k_uptime_get() - adv_link.tx.start > TRANSACTION_TIMEOUT) { BT_WARN("Giving up transaction"); prov_link_close(PROV_BEARER_LINK_STATUS_FAIL); return; @@ -620,7 +620,7 @@ static struct os_mbuf *ctl_buf_create(uint8_t op, const void *data, uint8_t data return NULL; } - net_buf_add_be32(buf, link.id); + net_buf_add_be32(buf, adv_link.id); /* Transaction ID, always 0 for Bearer messages */ net_buf_add_u8(buf, 0x00); net_buf_add_u8(buf, GPC_CTL(op)); @@ -634,10 +634,10 @@ static int bearer_ctl_send(struct os_mbuf *buf) return -ENOMEM; } prov_clear_tx(); - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + k_work_reschedule(&adv_link.prot_timer, PROTOCOL_TIMEOUT); - link.tx.start = k_uptime_get(); - link.tx.buf[0] = buf; + adv_link.tx.start = k_uptime_get(); + adv_link.tx.buf[0] = buf; send_reliable(); return 0; @@ -650,7 +650,7 @@ static int bearer_ctl_send_unacked(struct os_mbuf *buf) } prov_clear_tx(); - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + k_work_reschedule(&adv_link.prot_timer, PROTOCOL_TIMEOUT); bt_mesh_adv_send(buf, &buf_sent_cb, NULL); net_buf_unref(buf); @@ -664,27 +664,27 @@ static int prov_send_adv(struct os_mbuf *msg, uint8_t seg_len, seg_id; prov_clear_tx(); - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + k_work_reschedule(&adv_link.prot_timer, PROTOCOL_TIMEOUT); start = adv_buf_create(RETRANSMITS_RELIABLE); if (!start) { return -ENOBUFS; } - link.tx.id = next_transaction_id(link.tx.id); - net_buf_add_be32(start, link.id); - net_buf_add_u8(start, link.tx.id); + adv_link.tx.id = next_transaction_id(adv_link.tx.id); + net_buf_add_be32(start, adv_link.id); + net_buf_add_u8(start, adv_link.tx.id); net_buf_add_u8(start, GPC_START(last_seg(msg->om_len))); net_buf_add_be16(start, msg->om_len); net_buf_add_u8(start, bt_mesh_fcs_calc(msg->om_data, msg->om_len)); - link.tx.buf[0] = start; - link.tx.cb = cb; - link.tx.cb_data = cb_data; - link.tx.start = k_uptime_get(); + adv_link.tx.buf[0] = start; + adv_link.tx.cb = cb; + adv_link.tx.cb_data = cb_data; + adv_link.tx.start = k_uptime_get(); - BT_DBG("xact_id: 0x%x len: %u", link.tx.id, msg->om_len); + BT_DBG("xact_id: 0x%x len: %u", adv_link.tx.id, msg->om_len); seg_len = MIN(msg->om_len, START_PAYLOAD_MAX); BT_DBG("seg 0 len %u: %s", seg_len, bt_hex(msg->om_data, seg_len)); @@ -693,7 +693,7 @@ static int prov_send_adv(struct os_mbuf *msg, buf = start; for (seg_id = 1U; msg->om_len > 0; seg_id++) { - if (seg_id >= ARRAY_SIZE(link.tx.buf)) { + if (seg_id >= ARRAY_SIZE(adv_link.tx.buf)) { BT_ERR("Too big message"); free_segments(); return -E2BIG; @@ -705,15 +705,15 @@ static int prov_send_adv(struct os_mbuf *msg, return -ENOBUFS; } - link.tx.buf[seg_id] = buf; + adv_link.tx.buf[seg_id] = buf; seg_len = MIN(msg->om_len, CONT_PAYLOAD_MAX); BT_DBG("seg %u len %u: %s", seg_id, seg_len, bt_hex(msg->om_data, seg_len)); - net_buf_add_be32(buf, link.id); - net_buf_add_u8(buf, link.tx.id); + net_buf_add_be32(buf, adv_link.id); + net_buf_add_u8(buf, adv_link.tx.id); net_buf_add_u8(buf, GPC_CONT(seg_id)); net_buf_add_mem(buf, msg->om_data, seg_len); net_buf_simple_pull_mem(msg, seg_len); @@ -739,9 +739,9 @@ static void link_open(struct prov_rx *rx, struct os_mbuf *buf) return; } - if (atomic_test_bit(link.flags, ADV_LINK_ACTIVE)) { + if (atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE)) { /* Send another link ack if the provisioner missed the last */ - if (link.id != rx->link_id) { + if (adv_link.id != rx->link_id) { BT_DBG("Ignoring bearer open: link already active"); return; } @@ -757,9 +757,9 @@ static void link_open(struct prov_rx *rx, struct os_mbuf *buf) return; } - link.id = rx->link_id; - atomic_set_bit(link.flags, ADV_LINK_ACTIVE); - net_buf_simple_reset(link.rx.buf); + adv_link.id = rx->link_id; + atomic_set_bit(adv_link.flags, ADV_LINK_ACTIVE); + net_buf_simple_reset(adv_link.rx.buf); err = bearer_ctl_send_unacked(ctl_buf_create(LINK_ACK, NULL, 0, RETRANSMITS_ACK)); if (err) { @@ -767,21 +767,21 @@ static void link_open(struct prov_rx *rx, struct os_mbuf *buf) return; } - link.cb->link_opened(&pb_adv, link.cb_data); + adv_link.cb->link_opened(&pb_adv, adv_link.cb_data); } static void link_ack(struct prov_rx *rx, struct os_mbuf *buf) { BT_DBG("len %u", buf->om_len); - if (atomic_test_bit(link.flags, ADV_PROVISIONER)) { - if (atomic_test_and_set_bit(link.flags, ADV_LINK_ACK_RECVD)) { + if (atomic_test_bit(adv_link.flags, ADV_PROVISIONER)) { + if (atomic_test_and_set_bit(adv_link.flags, ADV_LINK_ACK_RECVD)) { return; } prov_clear_tx(); - link.cb->link_opened(&pb_adv, link.cb_data); + adv_link.cb->link_opened(&pb_adv, adv_link.cb_data); } } @@ -804,7 +804,7 @@ void bt_mesh_pb_adv_recv(struct os_mbuf *buf) { struct prov_rx rx; - if (!link.cb) { + if (!adv_link.cb) { return; } @@ -817,7 +817,7 @@ void bt_mesh_pb_adv_recv(struct os_mbuf *buf) rx.xact_id = net_buf_simple_pull_u8(buf); rx.gpc = net_buf_simple_pull_u8(buf); - if (atomic_test_bit(link.flags, ADV_LINK_ACTIVE) && link.id != rx.link_id) { + if (atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE) && adv_link.id != rx.link_id) { return; } @@ -839,19 +839,19 @@ static int prov_link_open(const uint8_t uuid[16], int32_t timeout, return err; } - if (atomic_test_and_set_bit(link.flags, ADV_LINK_ACTIVE)) { + if (atomic_test_and_set_bit(adv_link.flags, ADV_LINK_ACTIVE)) { return -EBUSY; } - atomic_set_bit(link.flags, ADV_PROVISIONER); + atomic_set_bit(adv_link.flags, ADV_PROVISIONER); - bt_rand(&link.id, sizeof(link.id)); - link.tx.id = XACT_ID_MAX; - link.rx.id = XACT_ID_NVAL; - link.cb = cb; - link.cb_data = cb_data; + bt_rand(&adv_link.id, sizeof(adv_link.id)); + adv_link.tx.id = XACT_ID_MAX; + adv_link.rx.id = XACT_ID_NVAL; + adv_link.cb = cb; + adv_link.cb_data = cb_data; - net_buf_simple_reset(link.rx.buf); + net_buf_simple_reset(adv_link.rx.buf); return bearer_ctl_send(ctl_buf_create(LINK_OPEN, uuid, 16, RETRANSMITS_RELIABLE)); } @@ -866,14 +866,14 @@ static int prov_link_accept(const struct prov_bearer_cb *cb, void *cb_data) return err; } - if (atomic_test_bit(link.flags, ADV_LINK_ACTIVE)) { + if (atomic_test_bit(adv_link.flags, ADV_LINK_ACTIVE)) { return -EBUSY; } - link.rx.id = XACT_ID_MAX; - link.tx.id = XACT_ID_NVAL; - link.cb = cb; - link.cb_data = cb_data; + adv_link.rx.id = XACT_ID_MAX; + adv_link.tx.id = XACT_ID_NVAL; + adv_link.cb = cb; + adv_link.cb_data = cb_data; /* Make sure we're scanning for provisioning invitations */ bt_mesh_scan_enable(); @@ -885,7 +885,7 @@ static int prov_link_accept(const struct prov_bearer_cb *cb, void *cb_data) static void prov_link_close(enum prov_bearer_link_status status) { - if (atomic_test_and_set_bit(link.flags, ADV_LINK_CLOSING)) { + if (atomic_test_and_set_bit(adv_link.flags, ADV_LINK_CLOSING)) { return; } @@ -895,14 +895,14 @@ static void prov_link_close(enum prov_bearer_link_status status) void pb_adv_init(void) { - k_work_init_delayable(&link.prot_timer, protocol_timeout); - k_work_init_delayable(&link.tx.retransmit, prov_retransmit); + k_work_init_delayable(&adv_link.prot_timer, protocol_timeout); + k_work_init_delayable(&adv_link.tx.retransmit, prov_retransmit); if (!rx_buf) { rx_buf = NET_BUF_SIMPLE(RX_BUFFER_MAX); } - link.rx.buf = rx_buf; - net_buf_simple_reset(link.rx.buf); + adv_link.rx.buf = rx_buf; + net_buf_simple_reset(adv_link.rx.buf); } void pb_adv_reset(void) diff --git a/nimble/host/mesh/src/pb_gatt.c b/nimble/host/mesh/src/pb_gatt.c index ddf8ed736..af6aeb03f 100644 --- a/nimble/host/mesh/src/pb_gatt.c +++ b/nimble/host/mesh/src/pb_gatt.c @@ -39,21 +39,21 @@ struct prov_link { struct k_work_delayable prot_timer; }; -static struct prov_link link; +static struct prov_link gatt_link; static void reset_state(void) { - link.conn_handle = BLE_HS_CONN_HANDLE_NONE; + gatt_link.conn_handle = BLE_HS_CONN_HANDLE_NONE; /* If this fails, the protocol timeout handler will exit early. */ - (void)k_work_cancel_delayable(&link.prot_timer); + (void)k_work_cancel_delayable(&gatt_link.prot_timer); } static void link_closed(enum prov_bearer_link_status status) { - const struct prov_bearer_cb *cb = link.cb; + const struct prov_bearer_cb *cb = gatt_link.cb; - void *cb_data = link.cb_data; + void *cb_data = gatt_link.cb_data; reset_state(); @@ -62,7 +62,7 @@ static void link_closed(enum prov_bearer_link_status status) static void protocol_timeout(struct ble_npl_event *work) { - if (!link.conn_handle) { + if (!gatt_link.conn_handle) { /* Already disconnected */ return; } @@ -76,7 +76,7 @@ int bt_mesh_pb_gatt_recv(uint16_t conn_handle, struct os_mbuf *buf) { BT_DBG("%u bytes: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); - if (link.conn_handle != conn_handle || !link.cb) { + if (gatt_link.conn_handle != conn_handle || !gatt_link.cb) { BT_WARN("Data for unexpected connection"); return -ENOTCONN; } @@ -86,9 +86,9 @@ int bt_mesh_pb_gatt_recv(uint16_t conn_handle, struct os_mbuf *buf) return -EINVAL; } - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + k_work_reschedule(&gatt_link.prot_timer, PROTOCOL_TIMEOUT); - link.cb->recv(&pb_gatt, link.cb_data, buf); + gatt_link.cb->recv(&pb_gatt, gatt_link.cb_data, buf); return 0; } @@ -97,14 +97,14 @@ int bt_mesh_pb_gatt_open(uint16_t conn_handle) { BT_DBG("conn %p", conn_handle); - if (link.conn_handle) { + if (gatt_link.conn_handle) { return -EBUSY; } - link.conn_handle = conn_handle; - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + gatt_link.conn_handle = conn_handle; + k_work_reschedule(&gatt_link.prot_timer, PROTOCOL_TIMEOUT); - link.cb->link_opened(&pb_gatt, link.cb_data); + gatt_link.cb->link_opened(&pb_gatt, gatt_link.cb_data); return 0; } @@ -113,12 +113,12 @@ int bt_mesh_pb_gatt_close(uint16_t conn_handle) { BT_DBG("conn %p", conn_handle); - if (link.conn_handle != conn_handle) { + if (gatt_link.conn_handle != conn_handle) { BT_DBG("Not connected"); return -ENOTCONN; } - link.cb->link_closed(&pb_gatt, link.cb_data, + gatt_link.cb->link_closed(&pb_gatt, gatt_link.cb_data, PROV_BEARER_LINK_STATUS_SUCCESS); reset_state(); @@ -131,8 +131,8 @@ static int link_accept(const struct prov_bearer_cb *cb, void *cb_data) (void)bt_mesh_pb_gatt_enable(); bt_mesh_adv_update(); - link.cb = cb; - link.cb_data = cb_data; + gatt_link.cb = cb; + gatt_link.cb_data = cb_data; return 0; } @@ -140,16 +140,16 @@ static int link_accept(const struct prov_bearer_cb *cb, void *cb_data) static int buf_send(struct os_mbuf *buf, prov_bearer_send_complete_t cb, void *cb_data) { - if (!link.conn_handle) { + if (!gatt_link.conn_handle) { return -ENOTCONN; } - link.comp.cb = cb; - link.comp.cb_data = cb_data; + gatt_link.comp.cb = cb; + gatt_link.comp.cb_data = cb_data; - k_work_reschedule(&link.prot_timer, PROTOCOL_TIMEOUT); + k_work_reschedule(&gatt_link.prot_timer, PROTOCOL_TIMEOUT); - return bt_mesh_pb_gatt_send(link.conn_handle, buf); + return bt_mesh_pb_gatt_send(gatt_link.conn_handle, buf); } static void clear_tx(void) @@ -159,7 +159,7 @@ static void clear_tx(void) void pb_gatt_init(void) { - k_work_init_delayable(&link.prot_timer, protocol_timeout); + k_work_init_delayable(&gatt_link.prot_timer, protocol_timeout); } void pb_gatt_reset(void)
