apache-mynewt-bot commented on PR #1296: URL: https://github.com/apache/mynewt-nimble/pull/1296#issuecomment-1180102723
<!-- style-bot --> ## Style check summary ### Our coding style is [here!](https://github.com/apache/mynewt-core/blob/master/CODING_STANDARDS.md) #### nimble/host/mesh/src/adv.c <details> ```diff @@ -45,205 +45,212 @@ static struct bt_mesh_adv adv_pool[CONFIG_BT_MESH_ADV_BUF_COUNT]; -static struct bt_mesh_adv *adv_alloc(int id) -{ - return &adv_pool[id]; -} - -struct os_mbuf *bt_mesh_adv_create_from_pool(struct os_mbuf_pool *pool, - bt_mesh_adv_alloc_t get_id, - enum bt_mesh_adv_type type, - uint8_t xmit, int32_t timeout) -{ - struct bt_mesh_adv *adv; - struct os_mbuf *buf; - - if (atomic_test_bit(bt_mesh.flags, BT_MESH_SUSPENDED)) { - BT_WARN("Refusing to allocate buffer while suspended"); - return NULL; - } - - buf = os_mbuf_get_pkthdr(pool, BT_MESH_ADV_USER_DATA_SIZE); - if (!buf) { - return NULL; - } - - adv = get_id(net_buf_id(buf)); - BT_MESH_ADV(buf) = adv; - - memset(adv, 0, sizeof(*adv)); - - adv->type = type; - adv->xmit = xmit; - - adv->ref_cnt = 1; - ble_npl_event_set_arg(&adv->ev, buf); - - return buf; -} - -struct os_mbuf *bt_mesh_adv_create(enum bt_mesh_adv_type type, uint8_t xmit, - int32_t timeout) -{ - return bt_mesh_adv_create_from_pool(&adv_os_mbuf_pool, adv_alloc, type, - xmit, timeout); -} - -void bt_mesh_adv_send(struct os_mbuf *buf, const struct bt_mesh_send_cb *cb, - void *cb_data) -{ - BT_DBG("buf %p, type 0x%02x len %u: %s", buf, BT_MESH_ADV(buf)->type, buf->om_len, - bt_hex(buf->om_data, buf->om_len)); - - BT_MESH_ADV(buf)->cb = cb; - BT_MESH_ADV(buf)->cb_data = cb_data; - BT_MESH_ADV(buf)->busy = 1; - - net_buf_put(&bt_mesh_adv_queue, net_buf_ref(buf)); - bt_mesh_adv_buf_ready(); -} - -static void bt_mesh_scan_cb(const bt_addr_le_t *addr, int8_t rssi, - uint8_t adv_type, struct os_mbuf *buf) -{ - if (adv_type != BLE_HCI_ADV_TYPE_ADV_NONCONN_IND) { - return; - } +static struct bt_mesh_adv * +adv_alloc(int id) +{ + return &adv_pool[id]; +} + +struct os_mbuf * +bt_mesh_adv_create_from_pool(struct os_mbuf_pool *pool, + bt_mesh_adv_alloc_t get_id, + enum bt_mesh_adv_type type, + uint8_t xmit, int32_t timeout) +{ + struct bt_mesh_adv *adv; + struct os_mbuf *buf; + + if (atomic_test_bit(bt_mesh.flags, BT_MESH_SUSPENDED)) { + BT_WARN("Refusing to allocate buffer while suspended"); + return NULL; + } + + buf = os_mbuf_get_pkthdr(pool, BT_MESH_ADV_USER_DATA_SIZE); + if (!buf) { + return NULL; + } + + adv = get_id(net_buf_id(buf)); + BT_MESH_ADV(buf) = adv; + + memset(adv, 0, sizeof(*adv)); + + adv->type = type; + adv->xmit = xmit; + + adv->ref_cnt = 1; + ble_npl_event_set_arg(&adv->ev, buf); + + return buf; +} + +struct os_mbuf * +bt_mesh_adv_create(enum bt_mesh_adv_type type, uint8_t xmit, + int32_t timeout) +{ + return bt_mesh_adv_create_from_pool(&adv_os_mbuf_pool, adv_alloc, type, + xmit, timeout); +} + +void +bt_mesh_adv_send(struct os_mbuf *buf, const struct bt_mesh_send_cb *cb, + void *cb_data) +{ + BT_DBG("buf %p, type 0x%02x len %u: %s", buf, BT_MESH_ADV(buf)->type, buf->om_len, + bt_hex(buf->om_data, buf->om_len)); + + BT_MESH_ADV(buf)->cb = cb; + BT_MESH_ADV(buf)->cb_data = cb_data; + BT_MESH_ADV(buf)->busy = 1; + + net_buf_put(&bt_mesh_adv_queue, net_buf_ref(buf)); + bt_mesh_adv_buf_ready(); +} + +static void +bt_mesh_scan_cb(const bt_addr_le_t *addr, int8_t rssi, + uint8_t adv_type, struct os_mbuf *buf) +{ + if (adv_type != BLE_HCI_ADV_TYPE_ADV_NONCONN_IND) { + return; + } #if BT_MESH_EXTENDED_DEBUG - BT_DBG("len %u: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); -#endif - - while (buf->om_len > 1) { - struct net_buf_simple_state state; - uint8_t len, type; - - len = net_buf_simple_pull_u8(buf); - /* Check for early termination */ - if (len == 0) { - return; - } - - if (len > buf->om_len) { - BT_WARN("AD malformed"); - return; - } - - net_buf_simple_save(buf, &state); - - type = net_buf_simple_pull_u8(buf); - - switch (type) { - case BLE_HS_ADV_TYPE_MESH_MESSAGE: - bt_mesh_net_recv(&buf, rssi, BT_MESH_NET_IF_ADV); - break; + BT_DBG("len %u: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); +#endif + + while (buf->om_len > 1) { + struct net_buf_simple_state state; + uint8_t len, type; + + len = net_buf_simple_pull_u8(buf); + /* Check for early termination */ + if (len == 0) { + return; + } + + if (len > buf->om_len) { + BT_WARN("AD malformed"); + return; + } + + net_buf_simple_save(buf, &state); + + type = net_buf_simple_pull_u8(buf); + + switch (type) { + case BLE_HS_ADV_TYPE_MESH_MESSAGE: + bt_mesh_net_recv(&buf, rssi, BT_MESH_NET_IF_ADV); + break; #if MYNEWT_VAL(BLE_MESH_PB_ADV) - case BLE_HS_ADV_TYPE_MESH_PROV: - bt_mesh_pb_adv_recv(buf); - break; -#endif - case BLE_HS_ADV_TYPE_MESH_BEACON: - bt_mesh_beacon_recv(buf); - break; - default: - break; - } - - net_buf_simple_restore(buf, &state); - net_buf_simple_pull_mem(buf, len); - } + case BLE_HS_ADV_TYPE_MESH_PROV: + bt_mesh_pb_adv_recv(buf); + break; +#endif + case BLE_HS_ADV_TYPE_MESH_BEACON: + bt_mesh_beacon_recv(buf); + break; + default: + break; + } + + net_buf_simple_restore(buf, &state); + net_buf_simple_pull_mem(buf, len); + } } int ble_adv_gap_mesh_cb(struct ble_gap_event *event, void *arg) { #if MYNEWT_VAL(BLE_EXT_ADV) - struct ble_gap_ext_disc_desc *ext_desc; -#endif - struct ble_gap_disc_desc *desc; - struct os_mbuf *buf = NULL; + struct ble_gap_ext_disc_desc *ext_desc; +#endif + struct ble_gap_disc_desc *desc; + struct os_mbuf *buf = NULL; #if BT_MESH_EXTENDED_DEBUG - BT_DBG("event->type %d", event->type); -#endif - - switch (event->type) { + BT_DBG("event->type %d", event->type); +#endif + + switch (event->type) { #if MYNEWT_VAL(BLE_EXT_ADV) - case BLE_GAP_EVENT_EXT_DISC: - ext_desc = &event->ext_disc; - buf = os_mbuf_get_pkthdr(&adv_os_mbuf_pool, 0); - if (!buf || os_mbuf_append(buf, ext_desc->data, ext_desc->length_data)) { - BT_ERR("Could not append data"); - goto done; - } - bt_mesh_scan_cb(&ext_desc->addr, ext_desc->rssi, - ext_desc->legacy_event_type, buf); - break; -#endif - case BLE_GAP_EVENT_DISC: - desc = &event->disc; - buf = os_mbuf_get_pkthdr(&adv_os_mbuf_pool, 0); - if (!buf || os_mbuf_append(buf, desc->data, desc->length_data)) { - BT_ERR("Could not append data"); - goto done; - } - - bt_mesh_scan_cb(&desc->addr, desc->rssi, desc->event_type, buf); - break; - default: - break; - } + case BLE_GAP_EVENT_EXT_DISC: + ext_desc = &event->ext_disc; + buf = os_mbuf_get_pkthdr(&adv_os_mbuf_pool, 0); + if (!buf || os_mbuf_append(buf, ext_desc->data, ext_desc->length_data)) { + BT_ERR("Could not append data"); + goto done; + } + bt_mesh_scan_cb(&ext_desc->addr, ext_desc->rssi, + ext_desc->legacy_event_type, buf); + break; +#endif + case BLE_GAP_EVENT_DISC: + desc = &event->disc; + buf = os_mbuf_get_pkthdr(&adv_os_mbuf_pool, 0); + if (!buf || os_mbuf_append(buf, desc->data, desc->length_data)) { + BT_ERR("Could not append data"); + goto done; + } + + bt_mesh_scan_cb(&desc->addr, desc->rssi, desc->event_type, buf); + break; + default: + break; + } done: - if (buf) { - os_mbuf_free_chain(buf); - } - - return 0; -} - -int bt_mesh_scan_enable(void) -{ - int err; + if (buf) { + os_mbuf_free_chain(buf); + } + + return 0; +} + +int +bt_mesh_scan_enable(void) +{ + int err; #if MYNEWT_VAL(BLE_EXT_ADV) - struct ble_gap_ext_disc_params uncoded_params = - { .itvl = MESH_SCAN_INTERVAL, .window = MESH_SCAN_WINDOW, - .passive = 1 }; - - BT_DBG(""); - - err = ble_gap_ext_disc(g_mesh_addr_type, 0, 0, 0, 0, 0, - &uncoded_params, NULL, NULL, NULL); + struct ble_gap_ext_disc_params uncoded_params = + { .itvl = MESH_SCAN_INTERVAL, .window = MESH_SCAN_WINDOW, + .passive = 1 }; + + BT_DBG(""); + + err = ble_gap_ext_disc(g_mesh_addr_type, 0, 0, 0, 0, 0, + &uncoded_params, NULL, NULL, NULL); #else - struct ble_gap_disc_params scan_param = - { .passive = 1, .filter_duplicates = 0, .itvl = - MESH_SCAN_INTERVAL, .window = MESH_SCAN_WINDOW }; - - BT_DBG(""); - - err = ble_gap_disc(g_mesh_addr_type, BLE_HS_FOREVER, &scan_param, - NULL, NULL); -#endif - if (err && err != BLE_HS_EALREADY) { - BT_ERR("starting scan failed (err %d)", err); - return err; - } - - return 0; -} - -int bt_mesh_scan_disable(void) -{ - int err; - - BT_DBG(""); - - err = ble_gap_disc_cancel(); - if (err && err != BLE_HS_EALREADY) { - BT_ERR("stopping scan failed (err %d)", err); - return err; - } - - return 0; -} + struct ble_gap_disc_params scan_param = + { .passive = 1, .filter_duplicates = 0, .itvl = + MESH_SCAN_INTERVAL, .window = MESH_SCAN_WINDOW }; + + BT_DBG(""); + + err = ble_gap_disc(g_mesh_addr_type, BLE_HS_FOREVER, &scan_param, + NULL, NULL); +#endif + if (err && err != BLE_HS_EALREADY) { + BT_ERR("starting scan failed (err %d)", err); + return err; + } + + return 0; +} + +int +bt_mesh_scan_disable(void) +{ + int err; + + BT_DBG(""); + + err = ble_gap_disc_cancel(); + if (err && err != BLE_HS_EALREADY) { + BT_ERR("stopping scan failed (err %d)", err); + return err; + } + + return 0; +} ``` </details> #### nimble/host/mesh/src/net.c <details> ```diff @@ -640,584 +659,603 @@ * get sent to the advertising bearer. If the packet came in through GATT, * then we should only relay it if the GATT Proxy state is enabled. */ -static bool relay_to_adv(enum bt_mesh_net_if net_if) -{ - switch (net_if) { - case BT_MESH_NET_IF_ADV: - return (bt_mesh_relay_get() == BT_MESH_RELAY_ENABLED); - case BT_MESH_NET_IF_PROXY: - return (bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_ENABLED); - default: - return false; - } -} - -static void bt_mesh_net_relay(struct os_mbuf *sbuf, - struct bt_mesh_net_rx *rx) -{ - const struct bt_mesh_net_cred *cred; - struct os_mbuf *buf; - uint8_t transmit; - - if (rx->ctx.recv_ttl <= 1U) { - return; - } - - if (rx->net_if == BT_MESH_NET_IF_ADV && - !rx->friend_cred && - bt_mesh_relay_get() != BT_MESH_RELAY_ENABLED && - bt_mesh_gatt_proxy_get() != BT_MESH_GATT_PROXY_ENABLED) { - return; - } - - BT_DBG("TTL %u CTL %u dst 0x%04x", rx->ctx.recv_ttl, rx->ctl, - rx->ctx.recv_dst); - - /* The Relay Retransmit state is only applied to adv-adv relaying. - * Anything else (like GATT to adv, or locally originated packets) - * use the Network Transmit state. - */ - if (rx->net_if == BT_MESH_NET_IF_ADV && !rx->friend_cred) { - transmit = bt_mesh_relay_retransmit_get(); - } else { - transmit = bt_mesh_net_transmit_get(); - } - - buf = bt_mesh_adv_create(BT_MESH_ADV_DATA, transmit, K_NO_WAIT); - if (!buf) { - BT_ERR("Out of relay buffers"); - return; - } - - /* Leave CTL bit intact */ - sbuf->om_data[1] &= 0x80; - sbuf->om_data[1] |= rx->ctx.recv_ttl - 1U; - - net_buf_add_mem(buf, sbuf->om_data, sbuf->om_len); - - cred = &rx->sub->keys[SUBNET_KEY_TX_IDX(rx->sub)].msg; - - BT_DBG("Relaying packet. TTL is now %u", TTL(buf->om_data)); - - /* Update NID if RX or RX was with friend credentials */ - if (rx->friend_cred) { - buf->om_data[0] &= 0x80; /* Clear everything except IVI */ - buf->om_data[0] |= cred->nid; - } - - /* We re-encrypt and obfuscate using the received IVI rather than - * the normal TX IVI (which may be different) since the transport - * layer nonce includes the IVI. - */ - if (net_encrypt(buf, cred, BT_MESH_NET_IVI_RX(rx), false)) { - BT_ERR("Re-encrypting failed"); - goto done; - } - - BT_DBG("encoded %u bytes: %s", buf->om_len, - bt_hex(buf->om_data, buf->om_len)); - - /* When the Friend node relays message for lpn, the message will be - * retransmitted using the managed flooding security credentials and - * the Network PDU shall be retransmitted to all network interfaces. - */ - if (IS_ENABLED(CONFIG_BT_MESH_GATT_PROXY) && - (rx->friend_cred || - bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_ENABLED)) { - bt_mesh_proxy_relay(buf, rx->ctx.recv_dst); - } - - if (relay_to_adv(rx->net_if) || rx->friend_cred) { - bt_mesh_adv_send(buf, NULL, NULL); - } +static bool +relay_to_adv(enum bt_mesh_net_if net_if) +{ + switch (net_if) { + case BT_MESH_NET_IF_ADV: + return (bt_mesh_relay_get() == BT_MESH_RELAY_ENABLED); + case BT_MESH_NET_IF_PROXY: + return (bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_ENABLED); + default: + return false; + } +} + +static void +bt_mesh_net_relay(struct os_mbuf *sbuf, + struct bt_mesh_net_rx *rx) +{ + const struct bt_mesh_net_cred *cred; + struct os_mbuf *buf; + uint8_t transmit; + + if (rx->ctx.recv_ttl <= 1U) { + return; + } + + if (rx->net_if == BT_MESH_NET_IF_ADV && + !rx->friend_cred && + bt_mesh_relay_get() != BT_MESH_RELAY_ENABLED && + bt_mesh_gatt_proxy_get() != BT_MESH_GATT_PROXY_ENABLED) { + return; + } + + BT_DBG("TTL %u CTL %u dst 0x%04x", rx->ctx.recv_ttl, rx->ctl, + rx->ctx.recv_dst); + + /* The Relay Retransmit state is only applied to adv-adv relaying. + * Anything else (like GATT to adv, or locally originated packets) + * use the Network Transmit state. + */ + if (rx->net_if == BT_MESH_NET_IF_ADV && !rx->friend_cred) { + transmit = bt_mesh_relay_retransmit_get(); + } else { + transmit = bt_mesh_net_transmit_get(); + } + + buf = bt_mesh_adv_create(BT_MESH_ADV_DATA, transmit, K_NO_WAIT); + if (!buf) { + BT_ERR("Out of relay buffers"); + return; + } + + /* Leave CTL bit intact */ + sbuf->om_data[1] &= 0x80; + sbuf->om_data[1] |= rx->ctx.recv_ttl - 1U; + + net_buf_add_mem(buf, sbuf->om_data, sbuf->om_len); + + cred = &rx->sub->keys[SUBNET_KEY_TX_IDX(rx->sub)].msg; + + BT_DBG("Relaying packet. TTL is now %u", TTL(buf->om_data)); + + /* Update NID if RX or RX was with friend credentials */ + if (rx->friend_cred) { + buf->om_data[0] &= 0x80; /* Clear everything except IVI */ + buf->om_data[0] |= cred->nid; + } + + /* We re-encrypt and obfuscate using the received IVI rather than + * the normal TX IVI (which may be different) since the transport + * layer nonce includes the IVI. + */ + if (net_encrypt(buf, cred, BT_MESH_NET_IVI_RX(rx), false)) { + BT_ERR("Re-encrypting failed"); + goto done; + } + + BT_DBG("encoded %u bytes: %s", buf->om_len, + bt_hex(buf->om_data, buf->om_len)); + + /* When the Friend node relays message for lpn, the message will be + * retransmitted using the managed flooding security credentials and + * the Network PDU shall be retransmitted to all network interfaces. + */ + if (IS_ENABLED(CONFIG_BT_MESH_GATT_PROXY) && + (rx->friend_cred || + bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_ENABLED)) { + bt_mesh_proxy_relay(buf, rx->ctx.recv_dst); + } + + if (relay_to_adv(rx->net_if) || rx->friend_cred) { + bt_mesh_adv_send(buf, NULL, NULL); + } done: - net_buf_unref(buf); -} - -void bt_mesh_net_header_parse(struct os_mbuf *buf, - struct bt_mesh_net_rx *rx) -{ - rx->old_iv = (IVI(buf->om_data) != (bt_mesh.iv_index & 0x01)); - rx->ctl = CTL(buf->om_data); - rx->ctx.recv_ttl = TTL(buf->om_data); - rx->seq = SEQ(buf->om_data); - rx->ctx.addr = SRC(buf->om_data); - rx->ctx.recv_dst = DST(buf->om_data); -} - -int bt_mesh_net_decode(struct os_mbuf *in, enum bt_mesh_net_if net_if, - struct bt_mesh_net_rx *rx, struct os_mbuf *out) -{ - if (in->om_len < BT_MESH_NET_MIN_PDU_LEN) { - BT_WARN("Dropping too short mesh packet (len %u)", in->om_len); - BT_WARN("%s", bt_hex(in->om_data, in->om_len)); - return -EINVAL; - } - - if (in->om_len > BT_MESH_NET_MAX_PDU_LEN) { - BT_WARN("Dropping too long mesh packet (len %u)", in->om_len); - return -EINVAL; - } - - if (net_if == BT_MESH_NET_IF_ADV && check_dup(in)) { - BT_DBG("duplicate packet; dropping %u bytes: %s", in->om_len, - bt_hex(in->om_data, in->om_len)); - return -EINVAL; - } - - BT_DBG("%u bytes: %s", in->om_len, bt_hex(in->om_data, in->om_len)); - - rx->net_if = net_if; - - if (!bt_mesh_net_cred_find(rx, in, out, net_decrypt)) { - BT_DBG("Unable to find matching net for packet"); - return -ENOENT; - } - - /* Initialize AppIdx to a sane value */ - rx->ctx.app_idx = BT_MESH_KEY_UNUSED; - - rx->ctx.recv_ttl = TTL(out->om_data); - - /* Default to responding with TTL 0 for non-routed messages */ - if (rx->ctx.recv_ttl == 0) { - rx->ctx.send_ttl = 0; - } else { - rx->ctx.send_ttl = BT_MESH_TTL_DEFAULT; - } - - rx->ctl = CTL(out->om_data); - rx->seq = SEQ(out->om_data); - rx->ctx.recv_dst = DST(out->om_data); - - BT_DBG("Decryption successful. Payload len %u: %s", out->om_len, - bt_hex(out->om_data, out->om_len)); - - if (net_if != BT_MESH_NET_IF_PROXY_CFG && - rx->ctx.recv_dst == BT_MESH_ADDR_UNASSIGNED) { - BT_ERR("Destination address is unassigned; dropping packet"); - return -EBADMSG; - } - - BT_DBG("src 0x%04x dst 0x%04x ttl %u", rx->ctx.addr, rx->ctx.recv_dst, - rx->ctx.recv_ttl); - BT_DBG("PDU: %s", bt_hex(out->om_data, out->om_len)); - - msg_cache_add(rx); - - return 0; -} - -void bt_mesh_net_recv(struct os_mbuf **data, int8_t rssi, - enum bt_mesh_net_if net_if) -{ - struct os_mbuf *buf = NET_BUF_SIMPLE(BT_MESH_NET_MAX_PDU_LEN); - struct bt_mesh_net_rx rx = { .ctx.recv_rssi = rssi }; - struct net_buf_simple_state state; - - BT_DBG("rssi %d net_if %u", rssi, net_if); - - if (!bt_mesh_is_provisioned()) { - BT_ERR("Not provisioned; dropping packet"); - goto done; - } - - if (bt_mesh_net_decode(*data, net_if, &rx, buf)) { - goto done; - } - - /* Save the state so the buffer can later be relayed */ - net_buf_simple_save(buf, &state); - - rx.local_match = (bt_mesh_fixed_group_match(rx.ctx.recv_dst) || - bt_mesh_has_addr(rx.ctx.recv_dst)); - - if ((MYNEWT_VAL(BLE_MESH_GATT_PROXY)) && - net_if == BT_MESH_NET_IF_PROXY) { - bt_mesh_proxy_addr_add(*data, rx.ctx.addr); - - if (bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_DISABLED && - !rx.local_match) { - BT_INFO("Proxy is disabled; ignoring message"); - goto done; - } - } - - /* The transport layer has indicated that it has rejected the message, - * but would like to see it again if it is received in the future. - * This can happen if a message is received when the device is in - * Low Power mode, but the message was not encrypted with the friend - * credentials. Remove it from the message cache so that we accept - * it again in the future. - */ - if (bt_mesh_trans_recv(buf, &rx) == -EAGAIN) { - BT_WARN("Removing rejected message from Network Message Cache"); - msg_cache[rx.msg_cache_idx].src = BT_MESH_ADDR_UNASSIGNED; - /* Rewind the next index now that we're not using this entry */ - msg_cache_next = rx.msg_cache_idx; - } - - /* Relay if this was a group/virtual address, or if the destination - * was neither a local element nor an LPN we're Friends for. - */ - if (!BT_MESH_ADDR_IS_UNICAST(rx.ctx.recv_dst) || - (!rx.local_match && !rx.friend_match)) { - net_buf_simple_restore(buf, &state); - bt_mesh_net_relay(buf, &rx); - } + net_buf_unref(buf); +} + +void +bt_mesh_net_header_parse(struct os_mbuf *buf, + struct bt_mesh_net_rx *rx) +{ + rx->old_iv = (IVI(buf->om_data) != (bt_mesh.iv_index & 0x01)); + rx->ctl = CTL(buf->om_data); + rx->ctx.recv_ttl = TTL(buf->om_data); + rx->seq = SEQ(buf->om_data); + rx->ctx.addr = SRC(buf->om_data); + rx->ctx.recv_dst = DST(buf->om_data); +} + +int +bt_mesh_net_decode(struct os_mbuf *in, enum bt_mesh_net_if net_if, + struct bt_mesh_net_rx *rx, struct os_mbuf *out) +{ + if (in->om_len < BT_MESH_NET_MIN_PDU_LEN) { + BT_WARN("Dropping too short mesh packet (len %u)", in->om_len); + BT_WARN("%s", bt_hex(in->om_data, in->om_len)); + return -EINVAL; + } + + if (in->om_len > BT_MESH_NET_MAX_PDU_LEN) { + BT_WARN("Dropping too long mesh packet (len %u)", in->om_len); + return -EINVAL; + } + + if (net_if == BT_MESH_NET_IF_ADV && check_dup(in)) { + BT_DBG("duplicate packet; dropping %u bytes: %s", in->om_len, + bt_hex(in->om_data, in->om_len)); + return -EINVAL; + } + + BT_DBG("%u bytes: %s", in->om_len, bt_hex(in->om_data, in->om_len)); + + rx->net_if = net_if; + + if (!bt_mesh_net_cred_find(rx, in, out, net_decrypt)) { + BT_DBG("Unable to find matching net for packet"); + return -ENOENT; + } + + /* Initialize AppIdx to a sane value */ + rx->ctx.app_idx = BT_MESH_KEY_UNUSED; + + rx->ctx.recv_ttl = TTL(out->om_data); + + /* Default to responding with TTL 0 for non-routed messages */ + if (rx->ctx.recv_ttl == 0) { + rx->ctx.send_ttl = 0; + } else { + rx->ctx.send_ttl = BT_MESH_TTL_DEFAULT; + } + + rx->ctl = CTL(out->om_data); + rx->seq = SEQ(out->om_data); + rx->ctx.recv_dst = DST(out->om_data); + + BT_DBG("Decryption successful. Payload len %u: %s", out->om_len, + bt_hex(out->om_data, out->om_len)); + + if (net_if != BT_MESH_NET_IF_PROXY_CFG && + rx->ctx.recv_dst == BT_MESH_ADDR_UNASSIGNED) { + BT_ERR("Destination address is unassigned; dropping packet"); + return -EBADMSG; + } + + BT_DBG("src 0x%04x dst 0x%04x ttl %u", rx->ctx.addr, rx->ctx.recv_dst, + rx->ctx.recv_ttl); + BT_DBG("PDU: %s", bt_hex(out->om_data, out->om_len)); + + msg_cache_add(rx); + + return 0; +} + +void +bt_mesh_net_recv(struct os_mbuf **data, int8_t rssi, + enum bt_mesh_net_if net_if) +{ + struct os_mbuf *buf = NET_BUF_SIMPLE(BT_MESH_NET_MAX_PDU_LEN); + struct bt_mesh_net_rx rx = { .ctx.recv_rssi = rssi }; + struct net_buf_simple_state state; + + BT_DBG("rssi %d net_if %u", rssi, net_if); + + if (!bt_mesh_is_provisioned()) { + BT_ERR("Not provisioned; dropping packet"); + goto done; + } + + if (bt_mesh_net_decode(*data, net_if, &rx, buf)) { + goto done; + } + + /* Save the state so the buffer can later be relayed */ + net_buf_simple_save(buf, &state); + + rx.local_match = (bt_mesh_fixed_group_match(rx.ctx.recv_dst) || + bt_mesh_has_addr(rx.ctx.recv_dst)); + + if ((MYNEWT_VAL(BLE_MESH_GATT_PROXY)) && + net_if == BT_MESH_NET_IF_PROXY) { + bt_mesh_proxy_addr_add(*data, rx.ctx.addr); + + if (bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_DISABLED && + !rx.local_match) { + BT_INFO("Proxy is disabled; ignoring message"); + goto done; + } + } + + /* The transport layer has indicated that it has rejected the message, + * but would like to see it again if it is received in the future. + * This can happen if a message is received when the device is in + * Low Power mode, but the message was not encrypted with the friend + * credentials. Remove it from the message cache so that we accept + * it again in the future. + */ + if (bt_mesh_trans_recv(buf, &rx) == -EAGAIN) { + BT_WARN("Removing rejected message from Network Message Cache"); + msg_cache[rx.msg_cache_idx].src = BT_MESH_ADDR_UNASSIGNED; + /* Rewind the next index now that we're not using this entry */ + msg_cache_next = rx.msg_cache_idx; + } + + /* Relay if this was a group/virtual address, or if the destination + * was neither a local element nor an LPN we're Friends for. + */ + if (!BT_MESH_ADDR_IS_UNICAST(rx.ctx.recv_dst) || + (!rx.local_match && !rx.friend_match)) { + net_buf_simple_restore(buf, &state); + bt_mesh_net_relay(buf, &rx); + } done: os_mbuf_free_chain(buf); } -static void ivu_refresh(struct ble_npl_event *work) -{ - if (!bt_mesh_is_provisioned()) { - return; - } - - bt_mesh.ivu_duration = MIN(UINT8_MAX, - bt_mesh.ivu_duration + BT_MESH_IVU_HOURS); - - BT_DBG("%s for %u hour%s", - atomic_test_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS) ? - "IVU in Progress" : "IVU Normal mode", - bt_mesh.ivu_duration, bt_mesh.ivu_duration == 1 ? "" : "s"); - - if (bt_mesh.ivu_duration < BT_MESH_IVU_MIN_HOURS) { - if (IS_ENABLED(CONFIG_BT_SETTINGS)) { - store_iv(true); - } - - k_work_reschedule(&bt_mesh.ivu_timer, BT_MESH_IVU_TIMEOUT); - return; - } - - if (atomic_test_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS)) { - bt_mesh_beacon_ivu_initiator(true); - bt_mesh_net_iv_update(bt_mesh.iv_index, false); - } else if (IS_ENABLED(CONFIG_BT_SETTINGS)) { - store_iv(true); - } +static void +ivu_refresh(struct ble_npl_event *work) +{ + if (!bt_mesh_is_provisioned()) { + return; + } + + bt_mesh.ivu_duration = MIN(UINT8_MAX, + bt_mesh.ivu_duration + BT_MESH_IVU_HOURS); + + BT_DBG("%s for %u hour%s", + atomic_test_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS) ? + "IVU in Progress" : "IVU Normal mode", + bt_mesh.ivu_duration, bt_mesh.ivu_duration == 1 ? "" : "s"); + + if (bt_mesh.ivu_duration < BT_MESH_IVU_MIN_HOURS) { + if (IS_ENABLED(CONFIG_BT_SETTINGS)) { + store_iv(true); + } + + k_work_reschedule(&bt_mesh.ivu_timer, BT_MESH_IVU_TIMEOUT); + return; + } + + if (atomic_test_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS)) { + bt_mesh_beacon_ivu_initiator(true); + bt_mesh_net_iv_update(bt_mesh.iv_index, false); + } else if (IS_ENABLED(CONFIG_BT_SETTINGS)) { + store_iv(true); + } } #if MYNEWT_VAL(BLE_MESH_SETTINGS) -static int net_set(int argc, char **argv, char *val) -{ - struct net_val net; - int len, err; - - BT_DBG("val %s", val ? val : "(null)"); - - if (!val) { - bt_mesh_comp_unprovision(); - memset(bt_mesh.dev_key, 0, sizeof(bt_mesh.dev_key)); - return 0; - } - - len = sizeof(net); - err = settings_bytes_from_str(val, &net, &len); - if (err) { - BT_ERR("Failed to decode value %s (err %d)", val, err); - return err; - } - - if (len != sizeof(net)) { - BT_ERR("Unexpected value length (%d != %zu)", len, sizeof(net)); - return -EINVAL; - } - - memcpy(bt_mesh.dev_key, net.dev_key, sizeof(bt_mesh.dev_key)); - bt_mesh_comp_provision(net.primary_addr); - - BT_DBG("Provisioned with primary address 0x%04x", net.primary_addr); - BT_DBG("Recovered DevKey %s", bt_hex(bt_mesh.dev_key, 16)); - - return 0; -} - -static int iv_set(int argc, char **argv, char *val) -{ - struct iv_val iv; - int len, err; - - BT_DBG("val %s", val ? val : "(null)"); - - if (!val) { - bt_mesh.iv_index = 0U; - atomic_clear_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS); - return 0; - } - - len = sizeof(iv); - err = settings_bytes_from_str(val, &iv, &len); - if (err) { - BT_ERR("Failed to decode value %s (err %d)", val, err); - return err; - } - - if (len != sizeof(iv)) { - BT_ERR("Unexpected value length (%d != %zu)", len, sizeof(iv)); - return -EINVAL; - } - - bt_mesh.iv_index = iv.iv_index; - atomic_set_bit_to(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS, iv.iv_update); - bt_mesh.ivu_duration = iv.iv_duration; - - BT_DBG("IV Index 0x%04x (IV Update Flag %u) duration %u hours", - (unsigned) iv.iv_index, iv.iv_update, iv.iv_duration); - - return 0; -} - -static int seq_set(int argc, char **argv, char *val) -{ - struct seq_val seq; - int len, err; - - BT_DBG("val %s", val ? val : "(null)"); - - if (!val) { - bt_mesh.seq = 0; - return 0; - } - - len = sizeof(seq); - err = settings_bytes_from_str(val, &seq, &len); - if (err) { - BT_ERR("Failed to decode value %s (err %d)", val, err); - return err; - } - - if (len != sizeof(seq)) { - BT_ERR("Unexpected value length (%d != %zu)", len, sizeof(seq)); - return -EINVAL; - } - - bt_mesh.seq = sys_get_le24(seq.val); - - if (CONFIG_BT_MESH_SEQ_STORE_RATE > 0) { - /* Make sure we have a large enough sequence number. We - * subtract 1 so that the first transmission causes a write - * to the settings storage. - */ - bt_mesh.seq += (CONFIG_BT_MESH_SEQ_STORE_RATE - - (bt_mesh.seq % CONFIG_BT_MESH_SEQ_STORE_RATE)); - bt_mesh.seq--; - } - - BT_DBG("Sequence Number 0x%06x", bt_mesh.seq); - - return 0; +static int +net_set(int argc, char **argv, char *val) +{ + struct net_val net; + int len, err; + + BT_DBG("val %s", val ? val : "(null)"); + + if (!val) { + bt_mesh_comp_unprovision(); + memset(bt_mesh.dev_key, 0, sizeof(bt_mesh.dev_key)); + return 0; + } + + len = sizeof(net); + err = settings_bytes_from_str(val, &net, &len); + if (err) { + BT_ERR("Failed to decode value %s (err %d)", val, err); + return err; + } + + if (len != sizeof(net)) { + BT_ERR("Unexpected value length (%d != %zu)", len, sizeof(net)); + return -EINVAL; + } + + memcpy(bt_mesh.dev_key, net.dev_key, sizeof(bt_mesh.dev_key)); + bt_mesh_comp_provision(net.primary_addr); + + BT_DBG("Provisioned with primary address 0x%04x", net.primary_addr); + BT_DBG("Recovered DevKey %s", bt_hex(bt_mesh.dev_key, 16)); + + return 0; +} + +static int +iv_set(int argc, char **argv, char *val) +{ + struct iv_val iv; + int len, err; + + BT_DBG("val %s", val ? val : "(null)"); + + if (!val) { + bt_mesh.iv_index = 0U; + atomic_clear_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS); + return 0; + } + + len = sizeof(iv); + err = settings_bytes_from_str(val, &iv, &len); + if (err) { + BT_ERR("Failed to decode value %s (err %d)", val, err); + return err; + } + + if (len != sizeof(iv)) { + BT_ERR("Unexpected value length (%d != %zu)", len, sizeof(iv)); + return -EINVAL; + } + + bt_mesh.iv_index = iv.iv_index; + atomic_set_bit_to(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS, iv.iv_update); + bt_mesh.ivu_duration = iv.iv_duration; + + BT_DBG("IV Index 0x%04x (IV Update Flag %u) duration %u hours", + (unsigned) iv.iv_index, iv.iv_update, iv.iv_duration); + + return 0; +} + +static int +seq_set(int argc, char **argv, char *val) +{ + struct seq_val seq; + int len, err; + + BT_DBG("val %s", val ? val : "(null)"); + + if (!val) { + bt_mesh.seq = 0; + return 0; + } + + len = sizeof(seq); + err = settings_bytes_from_str(val, &seq, &len); + if (err) { + BT_ERR("Failed to decode value %s (err %d)", val, err); + return err; + } + + if (len != sizeof(seq)) { + BT_ERR("Unexpected value length (%d != %zu)", len, sizeof(seq)); + return -EINVAL; + } + + bt_mesh.seq = sys_get_le24(seq.val); + + if (CONFIG_BT_MESH_SEQ_STORE_RATE > 0) { + /* Make sure we have a large enough sequence number. We + * subtract 1 so that the first transmission causes a write + * to the settings storage. + */ + bt_mesh.seq += (CONFIG_BT_MESH_SEQ_STORE_RATE - + (bt_mesh.seq % CONFIG_BT_MESH_SEQ_STORE_RATE)); + bt_mesh.seq--; + } + + BT_DBG("Sequence Number 0x%06x", bt_mesh.seq); + + return 0; } static struct conf_handler bt_mesh_net_conf_handler = { - .ch_name = "bt_mesh", - .ch_get = NULL, - .ch_set = net_set, - .ch_commit = NULL, - .ch_export = NULL, + .ch_name = "bt_mesh", + .ch_get = NULL, + .ch_set = net_set, + .ch_commit = NULL, + .ch_export = NULL, }; static struct conf_handler bt_mesh_iv_conf_handler = { - .ch_name = "bt_mesh", - .ch_get = NULL, - .ch_set = iv_set, - .ch_commit = NULL, - .ch_export = NULL, + .ch_name = "bt_mesh", + .ch_get = NULL, + .ch_set = iv_set, + .ch_commit = NULL, + .ch_export = NULL, }; static struct conf_handler bt_mesh_seq_conf_handler = { - .ch_name = "bt_mesh", - .ch_get = NULL, - .ch_set = seq_set, - .ch_commit = NULL, - .ch_export = NULL, + .ch_name = "bt_mesh", + .ch_get = NULL, + .ch_set = seq_set, + .ch_commit = NULL, + .ch_export = NULL, }; #endif -void bt_mesh_net_init(void) -{ - int rc; +void +bt_mesh_net_init(void) +{ + int rc; #if MYNEWT_VAL(BLE_MESH_SETTINGS) - rc = conf_register(&bt_mesh_net_conf_handler); - - SYSINIT_PANIC_ASSERT_MSG(rc == 0, - "Failed to register bt_mesh_net conf"); - - - rc = conf_register(&bt_mesh_iv_conf_handler); - - SYSINIT_PANIC_ASSERT_MSG(rc == 0, - "Failed to register bt_mesh_iv conf"); - - rc = conf_register(&bt_mesh_seq_conf_handler); - - SYSINIT_PANIC_ASSERT_MSG(rc == 0, - "Failed to register bt_mesh_seq conf"); + rc = conf_register(&bt_mesh_net_conf_handler); + + SYSINIT_PANIC_ASSERT_MSG(rc == 0, + "Failed to register bt_mesh_net conf"); + + + rc = conf_register(&bt_mesh_iv_conf_handler); + + SYSINIT_PANIC_ASSERT_MSG(rc == 0, + "Failed to register bt_mesh_iv conf"); + + rc = conf_register(&bt_mesh_seq_conf_handler); + + SYSINIT_PANIC_ASSERT_MSG(rc == 0, + "Failed to register bt_mesh_seq conf"); #endif - k_work_init_delayable(&bt_mesh.ivu_timer, ivu_refresh); - - k_work_init(&bt_mesh.local_work, bt_mesh_net_local); - net_buf_slist_init(&bt_mesh.local_queue); - - rc = os_mempool_init(&loopback_buf_mempool, MYNEWT_VAL(BLE_MESH_LOOPBACK_BUFS), - LOOPBACK_MAX_PDU_LEN + BT_MESH_MBUF_HEADER_SIZE, - &loopback_mbuf_membuf[0], "loopback_buf_pool"); - assert(rc == 0); - - rc = os_mbuf_pool_init(&loopback_os_mbuf_pool, &loopback_buf_mempool, - LOOPBACK_MAX_PDU_LEN + BT_MESH_MBUF_HEADER_SIZE, - MYNEWT_VAL(BLE_MESH_LOOPBACK_BUFS)); - assert(rc == 0); + k_work_init_delayable(&bt_mesh.ivu_timer, ivu_refresh); + + k_work_init(&bt_mesh.local_work, bt_mesh_net_local); + net_buf_slist_init(&bt_mesh.local_queue); + + rc = os_mempool_init(&loopback_buf_mempool, MYNEWT_VAL(BLE_MESH_LOOPBACK_BUFS), + LOOPBACK_MAX_PDU_LEN + BT_MESH_MBUF_HEADER_SIZE, + &loopback_mbuf_membuf[0], "loopback_buf_pool"); + assert(rc == 0); + + rc = os_mbuf_pool_init(&loopback_os_mbuf_pool, &loopback_buf_mempool, + LOOPBACK_MAX_PDU_LEN + BT_MESH_MBUF_HEADER_SIZE, + MYNEWT_VAL(BLE_MESH_LOOPBACK_BUFS)); + assert(rc == 0); } #if MYNEWT_VAL(BLE_MESH_SETTINGS) -static void clear_iv(void) -{ - int err; - - err = settings_save_one("bt_mesh/IV", NULL); - if (err) { - BT_ERR("Failed to clear IV"); - } else { - BT_DBG("Cleared IV"); - } -} - -static void store_pending_iv(void) -{ - char buf[BT_SETTINGS_SIZE(sizeof(struct iv_val))]; - struct iv_val iv; - char *str; - int err; - - iv.iv_index = bt_mesh.iv_index; - iv.iv_update = atomic_test_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS); - iv.iv_duration = bt_mesh.ivu_duration; - - str = settings_str_from_bytes(&iv, sizeof(iv), buf, sizeof(buf)); - if (!str) { - BT_ERR("Unable to encode IV as value"); - return; - } - - BT_DBG("Saving IV as value %s", str); - err = settings_save_one("bt_mesh/IV", str); - if (err) { - BT_ERR("Failed to store IV"); - } else { - BT_DBG("Stored IV"); - } -} - -void bt_mesh_net_pending_iv_store(void) -{ - if (atomic_test_bit(bt_mesh.flags, BT_MESH_VALID)) { - store_pending_iv(); - } else { - clear_iv(); - } -} - -static void clear_net(void) -{ - int err; - - err = settings_save_one("bt_mesh/Net", NULL); - if (err) { - BT_ERR("Failed to clear Network"); - } else { - BT_DBG("Cleared Network"); - } -} - -static void store_pending_net(void) -{ - char buf[BT_SETTINGS_SIZE(sizeof(struct net_val))]; - struct net_val net; - char *str; - int err; - - BT_DBG("addr 0x%04x DevKey %s", bt_mesh_primary_addr(), - bt_hex(bt_mesh.dev_key, 16)); - - net.primary_addr = bt_mesh_primary_addr(); - memcpy(net.dev_key, bt_mesh.dev_key, 16); - - str = settings_str_from_bytes(&net, sizeof(net), buf, sizeof(buf)); - if (!str) { - BT_ERR("Unable to encode Network as value"); - return; - } - - BT_DBG("Saving Network as value %s", str); - err = settings_save_one("bt_mesh/Net", str); - if (err) { - BT_ERR("Failed to store Network"); - } else { - BT_DBG("Stored Network"); - } -} - -void bt_mesh_net_pending_net_store(void) -{ - if (atomic_test_bit(bt_mesh.flags, BT_MESH_VALID)) { - store_pending_net(); - } else { - clear_net(); - } -} - -void bt_mesh_net_pending_seq_store(void) -{ - char buf[BT_SETTINGS_SIZE(sizeof(struct seq_val))]; - char *str; - struct seq_val seq; - int err; - - if (atomic_test_bit(bt_mesh.flags, BT_MESH_VALID)) { - sys_put_le24(bt_mesh.seq, seq.val); - - str = settings_str_from_bytes(&seq, sizeof(seq), buf, sizeof(buf)); - if (!str) { - BT_ERR("Unable to encode Network as value"); - return; - } - - BT_DBG("Saving Network as value %s", str); - err = settings_save_one("bt_mesh/Seq", str); - if (err) { - BT_ERR("Failed to stor Seq value"); - } else { - BT_DBG("Stored Seq value"); - } - } else { - err = settings_save_one("bt_mesh/Seq", NULL); - if (err) { - BT_ERR("Failed to clear Seq value"); - } else { - BT_DBG("Cleared Seq value"); - } - } -} - -void bt_mesh_net_clear(void) -{ - bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_NET_PENDING); - bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_IV_PENDING); - bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_CFG_PENDING); - bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_SEQ_PENDING); +static void +clear_iv(void) +{ + int err; + + err = settings_save_one("bt_mesh/IV", NULL); + if (err) { + BT_ERR("Failed to clear IV"); + } else { + BT_DBG("Cleared IV"); + } +} + +static void +store_pending_iv(void) +{ + char buf[BT_SETTINGS_SIZE(sizeof(struct iv_val))]; + struct iv_val iv; + char *str; + int err; + + iv.iv_index = bt_mesh.iv_index; + iv.iv_update = atomic_test_bit(bt_mesh.flags, BT_MESH_IVU_IN_PROGRESS); + iv.iv_duration = bt_mesh.ivu_duration; + + str = settings_str_from_bytes(&iv, sizeof(iv), buf, sizeof(buf)); + if (!str) { + BT_ERR("Unable to encode IV as value"); + return; + } + + BT_DBG("Saving IV as value %s", str); + err = settings_save_one("bt_mesh/IV", str); + if (err) { + BT_ERR("Failed to store IV"); + } else { + BT_DBG("Stored IV"); + } +} + +void +bt_mesh_net_pending_iv_store(void) +{ + if (atomic_test_bit(bt_mesh.flags, BT_MESH_VALID)) { + store_pending_iv(); + } else { + clear_iv(); + } +} + +static void +clear_net(void) +{ + int err; + + err = settings_save_one("bt_mesh/Net", NULL); + if (err) { + BT_ERR("Failed to clear Network"); + } else { + BT_DBG("Cleared Network"); + } +} + +static void +store_pending_net(void) +{ + char buf[BT_SETTINGS_SIZE(sizeof(struct net_val))]; + struct net_val net; + char *str; + int err; + + BT_DBG("addr 0x%04x DevKey %s", bt_mesh_primary_addr(), + bt_hex(bt_mesh.dev_key, 16)); + + net.primary_addr = bt_mesh_primary_addr(); + memcpy(net.dev_key, bt_mesh.dev_key, 16); + + str = settings_str_from_bytes(&net, sizeof(net), buf, sizeof(buf)); + if (!str) { + BT_ERR("Unable to encode Network as value"); + return; + } + + BT_DBG("Saving Network as value %s", str); + err = settings_save_one("bt_mesh/Net", str); + if (err) { + BT_ERR("Failed to store Network"); + } else { + BT_DBG("Stored Network"); + } +} + +void +bt_mesh_net_pending_net_store(void) +{ + if (atomic_test_bit(bt_mesh.flags, BT_MESH_VALID)) { + store_pending_net(); + } else { + clear_net(); + } +} + +void +bt_mesh_net_pending_seq_store(void) +{ + char buf[BT_SETTINGS_SIZE(sizeof(struct seq_val))]; + char *str; + struct seq_val seq; + int err; + + if (atomic_test_bit(bt_mesh.flags, BT_MESH_VALID)) { + sys_put_le24(bt_mesh.seq, seq.val); + + str = settings_str_from_bytes(&seq, sizeof(seq), buf, sizeof(buf)); + if (!str) { + BT_ERR("Unable to encode Network as value"); + return; + } + + BT_DBG("Saving Network as value %s", str); + err = settings_save_one("bt_mesh/Seq", str); + if (err) { + BT_ERR("Failed to stor Seq value"); + } else { + BT_DBG("Stored Seq value"); + } + } else { + err = settings_save_one("bt_mesh/Seq", NULL); + if (err) { + BT_ERR("Failed to clear Seq value"); + } else { + BT_DBG("Cleared Seq value"); + } + } +} + +void +bt_mesh_net_clear(void) +{ + bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_NET_PENDING); + bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_IV_PENDING); + bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_CFG_PENDING); + bt_mesh_settings_store_schedule(BT_MESH_SETTINGS_SEQ_PENDING); } #endif -void bt_mesh_net_settings_commit(void) -{ - if (bt_mesh.ivu_duration < BT_MESH_IVU_MIN_HOURS) { - k_work_reschedule(&bt_mesh.ivu_timer, BT_MESH_IVU_TIMEOUT); - } -} +void +bt_mesh_net_settings_commit(void) +{ + if (bt_mesh.ivu_duration < BT_MESH_IVU_MIN_HOURS) { + k_work_reschedule(&bt_mesh.ivu_timer, BT_MESH_IVU_TIMEOUT); + } +} ``` </details> #### nimble/host/mesh/src/net.h <details> ```diff @@ -280,21 +281,21 @@ } int bt_mesh_net_create(uint16_t idx, uint8_t flags, const uint8_t key[16], - uint32_t iv_index); + uint32_t iv_index); bool bt_mesh_net_iv_update(uint32_t iv_index, bool iv_update); int bt_mesh_net_encode(struct bt_mesh_net_tx *tx, struct os_mbuf *buf, - bool proxy); + bool proxy); int bt_mesh_net_decode(struct os_mbuf *in, enum bt_mesh_net_if net_if, - struct bt_mesh_net_rx *rx, struct os_mbuf *out); + struct bt_mesh_net_rx *rx, struct os_mbuf *out); int bt_mesh_net_send(struct bt_mesh_net_tx *tx, struct os_mbuf *buf, - const struct bt_mesh_send_cb *cb, void *cb_data); + const struct bt_mesh_send_cb *cb, void *cb_data); void bt_mesh_net_recv(struct os_mbuf **data, int8_t rssi, - enum bt_mesh_net_if net_if); + enum bt_mesh_net_if net_if); void bt_mesh_net_loopback_clear(uint16_t net_idx); ``` </details> #### nimble/host/mesh/src/proxy_srv.c <details> ```diff @@ -60,325 +60,342 @@ static int conn_count; -struct bt_mesh_proxy_client *find_client(uint16_t conn_handle) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(clients); i++) { - if (clients[i].conn_handle == conn_handle) { - return &clients[i]; - } - } - return NULL; -} - -static struct bt_mesh_proxy_client *get_client(uint16_t conn_handle) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(clients); i++) { - if (clients[i].conn_handle == 0xffff) { - clients[i].conn_handle = conn_handle; - return &clients[i]; - } - } - return NULL; +struct bt_mesh_proxy_client * +find_client(uint16_t conn_handle) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(clients); i++) { + if (clients[i].conn_handle == conn_handle) { + return &clients[i]; + } + } + return NULL; +} + +static struct bt_mesh_proxy_client * +get_client(uint16_t conn_handle) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(clients); i++) { + if (clients[i].conn_handle == 0xffff) { + clients[i].conn_handle = conn_handle; + return &clients[i]; + } + } + return NULL; } /* Next subnet in queue to be advertised */ static struct bt_mesh_subnet *beacon_sub; -static int filter_set(struct bt_mesh_proxy_client *client, - struct os_mbuf *buf) -{ - uint8_t type; - - if (buf->om_len < 1) { - BT_WARN("Too short Filter Set message"); - return -EINVAL; - } - - type = net_buf_simple_pull_u8(buf); - BT_DBG("type 0x%02x", type); - - switch (type) { - case 0x00: - (void)memset(client->filter, 0, sizeof(client->filter)); - client->filter_type = ACCEPT; - break; - case 0x01: - (void)memset(client->filter, 0, sizeof(client->filter)); - client->filter_type = REJECT; - break; - default: - BT_WARN("Prohibited Filter Type 0x%02x", type); - return -EINVAL; - } - - return 0; -} - -static void filter_add(struct bt_mesh_proxy_client *client, uint16_t addr) -{ - int i; - - BT_DBG("addr 0x%04x", addr); - - if (addr == BT_MESH_ADDR_UNASSIGNED) { - return; - } - - for (i = 0; i < ARRAY_SIZE(client->filter); i++) { - if (client->filter[i] == addr) { - return; - } - } - - for (i = 0; i < ARRAY_SIZE(client->filter); i++) { - if (client->filter[i] == BT_MESH_ADDR_UNASSIGNED) { - client->filter[i] = addr; - return; - } - } -} - -static void filter_remove(struct bt_mesh_proxy_client *client, uint16_t addr) -{ - int i; - - BT_DBG("addr 0x%04x", addr); - - if (addr == BT_MESH_ADDR_UNASSIGNED) { - return; - } - - for (i = 0; i < ARRAY_SIZE(client->filter); i++) { - if (client->filter[i] == addr) { - client->filter[i] = BT_MESH_ADDR_UNASSIGNED; - return; - } - } -} - -static void send_filter_status(struct bt_mesh_proxy_client *client, - struct bt_mesh_net_rx *rx, - struct os_mbuf *buf) -{ - struct bt_mesh_net_tx tx = { - .sub = rx->sub, - .ctx = &rx->ctx, - .src = bt_mesh_primary_addr(), - }; - uint16_t filter_size; - int i, err; - - /* Configuration messages always have dst unassigned */ - tx.ctx->addr = BT_MESH_ADDR_UNASSIGNED; - - net_buf_simple_init(buf, 10); - - net_buf_simple_add_u8(buf, CFG_FILTER_STATUS); - - if (client->filter_type == ACCEPT) { - net_buf_simple_add_u8(buf, 0x00); - } else { - net_buf_simple_add_u8(buf, 0x01); - } - - for (filter_size = 0U, i = 0; i < ARRAY_SIZE(client->filter); i++) { - if (client->filter[i] != BT_MESH_ADDR_UNASSIGNED) { - filter_size++; - } - } - - net_buf_simple_add_be16(buf, filter_size); - - BT_DBG("%u bytes: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); - - err = bt_mesh_net_encode(&tx, buf, true); - if (err) { - BT_ERR("Encoding Proxy cfg message failed (err %d)", err); - return; - } - - err = bt_mesh_proxy_msg_send(client->cli, BT_MESH_PROXY_CONFIG, buf); - if (err) { - BT_ERR("Failed to send proxy cfg message (err %d)", err); - } -} - -static void proxy_filter_recv(uint16_t conn_handle, - struct bt_mesh_net_rx *rx, struct os_mbuf *buf) -{ - struct bt_mesh_proxy_client *client; - uint8_t opcode; - - client = find_client(conn_handle); - - opcode = net_buf_simple_pull_u8(buf); - switch (opcode) { - case CFG_FILTER_SET: - filter_set(client, buf); - send_filter_status(client, rx, buf); - break; - case CFG_FILTER_ADD: - while (buf->om_len >= 2) { - uint16_t addr; - - addr = net_buf_simple_pull_be16(buf); - filter_add(client, addr); - } - send_filter_status(client, rx, buf); - break; - case CFG_FILTER_REMOVE: - while (buf->om_len >= 2) { - uint16_t addr; - - addr = net_buf_simple_pull_be16(buf); - filter_remove(client, addr); - } - send_filter_status(client, rx, buf); - break; - default: - BT_WARN("Unhandled configuration OpCode 0x%02x", opcode); - break; - } -} - -static void proxy_cfg(struct bt_mesh_proxy_role *role) -{ - struct os_mbuf *buf = NET_BUF_SIMPLE(BT_MESH_NET_MAX_PDU_LEN); - struct bt_mesh_net_rx rx; - int err; - - err = bt_mesh_net_decode(role->buf, BT_MESH_NET_IF_PROXY_CFG, - &rx, buf); - if (err) { - BT_ERR("Failed to decode Proxy Configuration (err %d)", err); - return; - } - - rx.local_match = 1U; - - if (bt_mesh_rpl_check(&rx, NULL)) { - BT_WARN("Replay: src 0x%04x dst 0x%04x seq 0x%06x", - rx.ctx.addr, rx.ctx.recv_dst, rx.seq); - return; - } - - /* Remove network headers */ - net_buf_simple_pull(buf, BT_MESH_NET_HDR_LEN); - - BT_DBG("%u bytes: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); - - if (buf->om_len < 1) { - BT_WARN("Too short proxy configuration PDU"); - return; - } - - proxy_filter_recv(role->conn_handle, &rx, buf); -} - -static void proxy_msg_recv(struct bt_mesh_proxy_role *role) -{ - switch (role->msg_type) { - case BT_MESH_PROXY_NET_PDU: - BT_DBG("Mesh Network PDU"); - bt_mesh_net_recv(&(role->buf), 0, BT_MESH_NET_IF_PROXY); - break; - case BT_MESH_PROXY_BEACON: - BT_DBG("Mesh Beacon PDU"); - bt_mesh_beacon_recv(role->buf); - break; - case BT_MESH_PROXY_CONFIG: - BT_DBG("Mesh Configuration PDU"); - proxy_cfg(role); - break; - default: - BT_WARN("Unhandled Message Type 0x%02x", role->msg_type); - break; - } -} - -static int beacon_send(struct bt_mesh_proxy_client *client, struct bt_mesh_subnet *sub) -{ - struct os_mbuf *buf = NET_BUF_SIMPLE(23); - int rc; - - net_buf_simple_init(buf, 1); - bt_mesh_beacon_create(sub, buf); - - rc = bt_mesh_proxy_msg_send(client->cli, BT_MESH_PROXY_BEACON, buf); - os_mbuf_free_chain(buf); - return rc; -} - -static int send_beacon_cb(struct bt_mesh_subnet *sub, void *cb_data) -{ - struct bt_mesh_proxy_client *client = cb_data; - - return beacon_send(client, sub); -} - -static void proxy_send_beacons(struct ble_npl_event *work) -{ - struct bt_mesh_proxy_client *client; - - client = ble_npl_event_get_arg(work); - - (void)bt_mesh_subnet_find(send_beacon_cb, client); -} - -void bt_mesh_proxy_beacon_send(struct bt_mesh_subnet *sub) -{ - int i; - - if (!sub) { - /* NULL means we send on all subnets */ - bt_mesh_subnet_foreach(bt_mesh_proxy_beacon_send); - return; - } - - for (i = 0; i < ARRAY_SIZE(clients); i++) { - if (clients[i].cli) { - beacon_send(&clients[i], sub); - } - } -} - -static void node_id_start(struct bt_mesh_subnet *sub) -{ - sub->node_id = BT_MESH_NODE_IDENTITY_RUNNING; - sub->node_id_start = k_uptime_get_32(); -} - -void bt_mesh_proxy_identity_start(struct bt_mesh_subnet *sub) -{ - node_id_start(sub); - - /* Prioritize the recently enabled subnet */ - beacon_sub = sub; -} - -void bt_mesh_proxy_identity_stop(struct bt_mesh_subnet *sub) - { - sub->node_id = BT_MESH_NODE_IDENTITY_STOPPED; - sub->node_id_start = 0U; -} - -int bt_mesh_proxy_identity_enable(void) -{ - BT_DBG(""); - - if (!bt_mesh_is_provisioned()) { - return -EAGAIN; - } - - if (bt_mesh_subnet_foreach(node_id_start)) { - bt_mesh_adv_update(); - } - - return 0; +static int +filter_set(struct bt_mesh_proxy_client *client, + struct os_mbuf *buf) +{ + uint8_t type; + + if (buf->om_len < 1) { + BT_WARN("Too short Filter Set message"); + return -EINVAL; + } + + type = net_buf_simple_pull_u8(buf); + BT_DBG("type 0x%02x", type); + + switch (type) { + case 0x00: + (void)memset(client->filter, 0, sizeof(client->filter)); + client->filter_type = ACCEPT; + break; + case 0x01: + (void)memset(client->filter, 0, sizeof(client->filter)); + client->filter_type = REJECT; + break; + default: + BT_WARN("Prohibited Filter Type 0x%02x", type); + return -EINVAL; + } + + return 0; +} + +static void +filter_add(struct bt_mesh_proxy_client *client, uint16_t addr) +{ + int i; + + BT_DBG("addr 0x%04x", addr); + + if (addr == BT_MESH_ADDR_UNASSIGNED) { + return; + } + + for (i = 0; i < ARRAY_SIZE(client->filter); i++) { + if (client->filter[i] == addr) { + return; + } + } + + for (i = 0; i < ARRAY_SIZE(client->filter); i++) { + if (client->filter[i] == BT_MESH_ADDR_UNASSIGNED) { + client->filter[i] = addr; + return; + } + } +} + +static void +filter_remove(struct bt_mesh_proxy_client *client, uint16_t addr) +{ + int i; + + BT_DBG("addr 0x%04x", addr); + + if (addr == BT_MESH_ADDR_UNASSIGNED) { + return; + } + + for (i = 0; i < ARRAY_SIZE(client->filter); i++) { + if (client->filter[i] == addr) { + client->filter[i] = BT_MESH_ADDR_UNASSIGNED; + return; + } + } +} + +static void +send_filter_status(struct bt_mesh_proxy_client *client, + struct bt_mesh_net_rx *rx, + struct os_mbuf *buf) +{ + struct bt_mesh_net_tx tx = { + .sub = rx->sub, + .ctx = &rx->ctx, + .src = bt_mesh_primary_addr(), + }; + uint16_t filter_size; + int i, err; + + /* Configuration messages always have dst unassigned */ + tx.ctx->addr = BT_MESH_ADDR_UNASSIGNED; + + net_buf_simple_init(buf, 10); + + net_buf_simple_add_u8(buf, CFG_FILTER_STATUS); + + if (client->filter_type == ACCEPT) { + net_buf_simple_add_u8(buf, 0x00); + } else { + net_buf_simple_add_u8(buf, 0x01); + } + + for (filter_size = 0U, i = 0; i < ARRAY_SIZE(client->filter); i++) { + if (client->filter[i] != BT_MESH_ADDR_UNASSIGNED) { + filter_size++; + } + } + + net_buf_simple_add_be16(buf, filter_size); + + BT_DBG("%u bytes: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); + + err = bt_mesh_net_encode(&tx, buf, true); + if (err) { + BT_ERR("Encoding Proxy cfg message failed (err %d)", err); + return; + } + + err = bt_mesh_proxy_msg_send(client->cli, BT_MESH_PROXY_CONFIG, buf); + if (err) { + BT_ERR("Failed to send proxy cfg message (err %d)", err); + } +} + +static void +proxy_filter_recv(uint16_t conn_handle, + struct bt_mesh_net_rx *rx, struct os_mbuf *buf) +{ + struct bt_mesh_proxy_client *client; + uint8_t opcode; + + client = find_client(conn_handle); + + opcode = net_buf_simple_pull_u8(buf); + switch (opcode) { + case CFG_FILTER_SET: + filter_set(client, buf); + send_filter_status(client, rx, buf); + break; + case CFG_FILTER_ADD: + while (buf->om_len >= 2) { + uint16_t addr; + + addr = net_buf_simple_pull_be16(buf); + filter_add(client, addr); + } + send_filter_status(client, rx, buf); + break; + case CFG_FILTER_REMOVE: + while (buf->om_len >= 2) { + uint16_t addr; + + addr = net_buf_simple_pull_be16(buf); + filter_remove(client, addr); + } + send_filter_status(client, rx, buf); + break; + default: + BT_WARN("Unhandled configuration OpCode 0x%02x", opcode); + break; + } +} + +static void +proxy_cfg(struct bt_mesh_proxy_role *role) +{ + struct os_mbuf *buf = NET_BUF_SIMPLE(BT_MESH_NET_MAX_PDU_LEN); + struct bt_mesh_net_rx rx; + int err; + + err = bt_mesh_net_decode(role->buf, BT_MESH_NET_IF_PROXY_CFG, + &rx, buf); + if (err) { + BT_ERR("Failed to decode Proxy Configuration (err %d)", err); + return; + } + + rx.local_match = 1U; + + if (bt_mesh_rpl_check(&rx, NULL)) { + BT_WARN("Replay: src 0x%04x dst 0x%04x seq 0x%06x", + rx.ctx.addr, rx.ctx.recv_dst, rx.seq); + return; + } + + /* Remove network headers */ + net_buf_simple_pull(buf, BT_MESH_NET_HDR_LEN); + + BT_DBG("%u bytes: %s", buf->om_len, bt_hex(buf->om_data, buf->om_len)); + + if (buf->om_len < 1) { + BT_WARN("Too short proxy configuration PDU"); + return; + } + + proxy_filter_recv(role->conn_handle, &rx, buf); +} + +static void +proxy_msg_recv(struct bt_mesh_proxy_role *role) +{ + switch (role->msg_type) { + case BT_MESH_PROXY_NET_PDU: + BT_DBG("Mesh Network PDU"); + bt_mesh_net_recv(&(role->buf), 0, BT_MESH_NET_IF_PROXY); + break; + case BT_MESH_PROXY_BEACON: + BT_DBG("Mesh Beacon PDU"); + bt_mesh_beacon_recv(role->buf); + break; + case BT_MESH_PROXY_CONFIG: + BT_DBG("Mesh Configuration PDU"); + proxy_cfg(role); + break; + default: + BT_WARN("Unhandled Message Type 0x%02x", role->msg_type); + break; + } +} + +static int +beacon_send(struct bt_mesh_proxy_client *client, struct bt_mesh_subnet *sub) +{ + struct os_mbuf *buf = NET_BUF_SIMPLE(23); + int rc; + + net_buf_simple_init(buf, 1); + bt_mesh_beacon_create(sub, buf); + + rc = bt_mesh_proxy_msg_send(client->cli, BT_MESH_PROXY_BEACON, buf); + os_mbuf_free_chain(buf); + return rc; +} + +static int +send_beacon_cb(struct bt_mesh_subnet *sub, void *cb_data) +{ + struct bt_mesh_proxy_client *client = cb_data; + + return beacon_send(client, sub); +} + +static void +proxy_send_beacons(struct ble_npl_event *work) +{ + struct bt_mesh_proxy_client *client; + + client = ble_npl_event_get_arg(work); + + (void)bt_mesh_subnet_find(send_beacon_cb, client); +} + +void +bt_mesh_proxy_beacon_send(struct bt_mesh_subnet *sub) +{ + int i; + + if (!sub) { + /* NULL means we send on all subnets */ + bt_mesh_subnet_foreach(bt_mesh_proxy_beacon_send); + return; + } + + for (i = 0; i < ARRAY_SIZE(clients); i++) { + if (clients[i].cli) { + beacon_send(&clients[i], sub); + } + } +} + +static void +node_id_start(struct bt_mesh_subnet *sub) +{ + sub->node_id = BT_MESH_NODE_IDENTITY_RUNNING; + sub->node_id_start = k_uptime_get_32(); +} + +void +bt_mesh_proxy_identity_start(struct bt_mesh_subnet *sub) +{ + node_id_start(sub); + + /* Prioritize the recently enabled subnet */ + beacon_sub = sub; +} + +void +bt_mesh_proxy_identity_stop(struct bt_mesh_subnet *sub) +{ + sub->node_id = BT_MESH_NODE_IDENTITY_STOPPED; + sub->node_id_start = 0U; +} + +int +bt_mesh_proxy_identity_enable(void) +{ + BT_DBG(""); + + if (!bt_mesh_is_provisioned()) { + return -EAGAIN; + } + + if (bt_mesh_subnet_foreach(node_id_start)) { + bt_mesh_adv_update(); + } + + return 0; } #define ID_TYPE_NET 0x00 @@ -390,616 +407,639 @@ #define NODE_ID_TIMEOUT (CONFIG_BT_MESH_NODE_ID_TIMEOUT * MSEC_PER_SEC) static uint8_t proxy_svc_data[NODE_ID_LEN] = { - BT_UUID_16_ENCODE(BT_UUID_MESH_PROXY_VAL), + BT_UUID_16_ENCODE(BT_UUID_MESH_PROXY_VAL), }; static const struct bt_data node_id_ad[] = { - BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), - BT_DATA_BYTES(BT_DATA_UUID16_ALL, - BT_UUID_16_ENCODE(BT_UUID_MESH_PROXY_VAL)), - BT_DATA(BT_DATA_SVC_DATA16, proxy_svc_data, NODE_ID_LEN), + BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), + BT_DATA_BYTES(BT_DATA_UUID16_ALL, + BT_UUID_16_ENCODE(BT_UUID_MESH_PROXY_VAL)), + BT_DATA(BT_DATA_SVC_DATA16, proxy_svc_data, NODE_ID_LEN), }; static const struct bt_data net_id_ad[] = { - BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), - BT_DATA_BYTES(BT_DATA_UUID16_ALL, - BT_UUID_16_ENCODE(BT_UUID_MESH_PROXY_VAL)), - BT_DATA(BT_DATA_SVC_DATA16, proxy_svc_data, NET_ID_LEN), + BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), + BT_DATA_BYTES(BT_DATA_UUID16_ALL, + BT_UUID_16_ENCODE(BT_UUID_MESH_PROXY_VAL)), + BT_DATA(BT_DATA_SVC_DATA16, proxy_svc_data, NET_ID_LEN), }; -static int node_id_adv(struct bt_mesh_subnet *sub, int32_t duration) -{ - struct ble_gap_adv_params fast_adv_param = { - ADV_OPT_PROXY - ADV_FAST_INT - }; +static int +node_id_adv(struct bt_mesh_subnet *sub, int32_t duration) +{ + struct ble_gap_adv_params fast_adv_param = { + ADV_OPT_PROXY + ADV_FAST_INT + }; #if ADV_OPT_USE_NAME - const char *name = CONFIG_BT_DEVICE_NAME; - size_t name_len = strlen(name); - struct bt_data sd = { - .type = BT_DATA_NAME_COMPLETE, - .data_len = name_len, - .data = (void *)name - }; + const char *name = CONFIG_BT_DEVICE_NAME; + size_t name_len = strlen(name); + struct bt_data sd = { + .type = BT_DATA_NAME_COMPLETE, + .data_len = name_len, + .data = (void *)name + }; #else - struct bt_data *sd = NULL; + struct bt_data *sd = NULL; #endif - uint8_t tmp[16]; - int err; - - BT_DBG(""); - - proxy_svc_data[2] = ID_TYPE_NODE; - - err = bt_rand(proxy_svc_data + 11, 8); - if (err) { - return err; - } - - (void)memset(tmp, 0, 6); - memcpy(tmp + 6, proxy_svc_data + 11, 8); - sys_put_be16(bt_mesh_primary_addr(), tmp + 14); - - err = bt_encrypt_be(sub->keys[SUBNET_KEY_TX_IDX(sub)].identity, tmp, - tmp); - if (err) { - return err; - } - - memcpy(proxy_svc_data + 3, tmp + 8, 8); - - err = bt_mesh_adv_start(&fast_adv_param, duration, node_id_ad, - ARRAY_SIZE(node_id_ad), sd, 0); - if (err) { - BT_WARN("Failed to advertise using Node ID (err %d)", err); - return err; - } - - return 0; -} - -static int net_id_adv(struct bt_mesh_subnet *sub, int32_t duration) -{ - struct ble_gap_adv_params slow_adv_param = { - ADV_OPT_PROXY - ADV_SLOW_INT - }; + uint8_t tmp[16]; + int err; + + BT_DBG(""); + + proxy_svc_data[2] = ID_TYPE_NODE; + + err = bt_rand(proxy_svc_data + 11, 8); + if (err) { + return err; + } + + (void)memset(tmp, 0, 6); + memcpy(tmp + 6, proxy_svc_data + 11, 8); + sys_put_be16(bt_mesh_primary_addr(), tmp + 14); + + err = bt_encrypt_be(sub->keys[SUBNET_KEY_TX_IDX(sub)].identity, tmp, + tmp); + if (err) { + return err; + } + + memcpy(proxy_svc_data + 3, tmp + 8, 8); + + err = bt_mesh_adv_start(&fast_adv_param, duration, node_id_ad, + ARRAY_SIZE(node_id_ad), sd, 0); + if (err) { + BT_WARN("Failed to advertise using Node ID (err %d)", err); + return err; + } + + return 0; +} + +static int +net_id_adv(struct bt_mesh_subnet *sub, int32_t duration) +{ + struct ble_gap_adv_params slow_adv_param = { + ADV_OPT_PROXY + ADV_SLOW_INT + }; #if ADV_OPT_USE_NAME - const char *name = CONFIG_BT_DEVICE_NAME; - size_t name_len = strlen(name); - struct bt_data sd = { - .type = BT_DATA_NAME_COMPLETE, - .data_len = name_len, - .data = (void *)name - }; + const char *name = CONFIG_BT_DEVICE_NAME; + size_t name_len = strlen(name); + struct bt_data sd = { + .type = BT_DATA_NAME_COMPLETE, + .data_len = name_len, + .data = (void *)name + }; #else - struct bt_data *sd = NULL; + struct bt_data *sd = NULL; #endif - int err; - - BT_DBG(""); - - proxy_svc_data[2] = ID_TYPE_NET; - - BT_DBG("Advertising with NetId %s", - bt_hex(sub->keys[SUBNET_KEY_TX_IDX(sub)].net_id, 8)); - - memcpy(proxy_svc_data + 3, sub->keys[SUBNET_KEY_TX_IDX(sub)].net_id, 8); - - err = bt_mesh_adv_start(&slow_adv_param, duration, net_id_ad, - ARRAY_SIZE(net_id_ad), sd, 0); - if (err) { - BT_WARN("Failed to advertise using Network ID (err %d)", err); - return err; - } - - return 0; -} - -static bool advertise_subnet(struct bt_mesh_subnet *sub) -{ - if (sub->net_idx == BT_MESH_KEY_UNUSED) { - return false; - } - - return (sub->node_id == BT_MESH_NODE_IDENTITY_RUNNING || - bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_ENABLED); -} - -static struct bt_mesh_subnet *next_sub(void) -{ - struct bt_mesh_subnet *sub = NULL; - - if (!beacon_sub) { - beacon_sub = bt_mesh_subnet_next(NULL); - if (!beacon_sub) { - /* No valid subnets */ - return NULL; - } - } - - sub = beacon_sub; - do { - if (advertise_subnet(sub)) { - beacon_sub = sub; - return sub; - } - - sub = bt_mesh_subnet_next(sub); - } while (sub != beacon_sub); - - /* No subnets to advertise on */ - return NULL; -} - -static int sub_count_cb(struct bt_mesh_subnet *sub, void *cb_data) -{ - int *count = cb_data; - - if (advertise_subnet(sub)) { - (*count)++; - } - - return 0; -} - -static int sub_count(void) -{ - int count = 0; - - (void)bt_mesh_subnet_find(sub_count_cb, &count); - - return count; -} - -static int gatt_proxy_advertise(struct bt_mesh_subnet *sub) -{ - int32_t remaining = K_FOREVER; - int subnet_count; - int err = -EBUSY; - - BT_DBG(""); - - if (conn_count == CONFIG_BT_MAX_CONN) { - BT_DBG("Connectable advertising deferred (max connections %d)", conn_count); - return -ENOMEM; - } - - sub = beacon_sub ? beacon_sub : bt_mesh_subnet_next(beacon_sub); - if (!sub) { - BT_WARN("No subnets to advertise on"); - return -ENOENT; - } - - subnet_count = sub_count(); - BT_DBG("sub_count %u", subnet_count); - if (subnet_count > 1) { - int32_t max_timeout; - - /* We use NODE_ID_TIMEOUT as a starting point since it may - * be less than 60 seconds. Divide this period into at least - * 6 slices, but make sure that a slice is at least one - * second long (to avoid excessive rotation). - */ - max_timeout = NODE_ID_TIMEOUT / max(subnet_count, 6); - max_timeout = max(max_timeout, K_SECONDS(1)); - - if (remaining > max_timeout || remaining < 0) { - remaining = max_timeout; - } - } - - if (sub->node_id == BT_MESH_NODE_IDENTITY_RUNNING) { - uint32_t active = k_uptime_get_32() - sub->node_id_start; - - if (active < NODE_ID_TIMEOUT) { - remaining = NODE_ID_TIMEOUT - active; - BT_DBG("Node ID active for %u ms, %d ms remaining", - active, remaining); - err = node_id_adv(sub, remaining); - } else { - bt_mesh_proxy_identity_stop(sub); - BT_DBG("Node ID stopped"); - } - } - - if (sub->node_id == BT_MESH_NODE_IDENTITY_STOPPED) { - err = net_id_adv(sub, remaining); - } - - BT_DBG("Advertising %d ms for net_idx 0x%04x", - (int) remaining, sub->net_idx); - - beacon_sub = bt_mesh_subnet_next(beacon_sub); - - return err; -} - -static void subnet_evt(struct bt_mesh_subnet *sub, enum bt_mesh_key_evt evt) -{ - if (evt == BT_MESH_KEY_DELETED) { - if (sub == beacon_sub) { - beacon_sub = NULL; - } - } else { - bt_mesh_proxy_beacon_send(sub); - } -} - -static void proxy_ccc_write(uint16_t conn_handle) -{ - struct bt_mesh_proxy_client *client; - - BT_DBG("conn_handle %d", conn_handle); - - client = find_client(conn_handle); - - if (client->filter_type == NONE) { - client->filter_type = ACCEPT; - k_work_add_arg(&client->send_beacons, client); - k_work_submit(&client->send_beacons); - } -} - -int bt_mesh_proxy_gatt_enable(void) -{ - uint16_t handle; - int rc; - int i; - - BT_DBG(""); - - if (!bt_mesh_is_provisioned()) { - return -ENOTSUP; - } - - if (service_registered) { - return -EBUSY; - } - - rc = ble_gatts_find_svc(BLE_UUID16_DECLARE(BT_UUID_MESH_PROXY_VAL), &handle); - assert(rc == 0); - ble_gatts_svc_set_visibility(handle, 1); - /* FIXME: figure out end handle */ - ble_svc_gatt_changed(svc_handles.proxy_h, 0xffff); - - service_registered = true; - - for (i = 0; i < ARRAY_SIZE(clients); i++) { - if (clients[i].cli) { - clients[i].filter_type = ACCEPT; - } - } - return 0; -} - -void bt_mesh_proxy_gatt_disconnect(void) -{ - int rc; - int i; - - BT_DBG(""); - - for (i = 0; i < ARRAY_SIZE(clients); i++) { - struct bt_mesh_proxy_client *client = &clients[i]; - - if ((client->cli) && - (client->filter_type == ACCEPT || - client->filter_type == REJECT)) { - client->filter_type = NONE; - rc = ble_gap_terminate(client->cli->conn_handle, - BLE_ERR_REM_USER_CONN_TERM); - assert(rc == 0); - } - } -} - -int bt_mesh_proxy_gatt_disable(void) -{ - uint16_t handle; - int rc; - BT_DBG(""); - - if (!service_registered) { - return -EALREADY; - } - - bt_mesh_proxy_gatt_disconnect(); - - rc = ble_gatts_find_svc(BLE_UUID16_DECLARE(BT_UUID_MESH_PROXY_VAL), &handle); - assert(rc == 0); - ble_gatts_svc_set_visibility(handle, 0); - /* FIXME: figure out end handle */ - ble_svc_gatt_changed(svc_handles.proxy_h, 0xffff); - service_registered = false; - - return 0; -} - -void bt_mesh_proxy_addr_add(struct os_mbuf **buf, uint16_t addr) -{ - struct bt_mesh_proxy_client *client; - struct bt_mesh_proxy_role *cli = - CONTAINER_OF(buf, struct bt_mesh_proxy_role, buf); - - client = find_client(cli->conn_handle); - - BT_DBG("filter_type %u addr 0x%04x", client->filter_type, addr); - - if (client->filter_type == ACCEPT) { - filter_add(client, addr); - } else if (client->filter_type == REJECT) { - filter_remove(client, addr); - } -} - -static bool client_filter_match(struct bt_mesh_proxy_client *client, - uint16_t addr) -{ - int i; - - BT_DBG("filter_type %u addr 0x%04x", client->filter_type, addr); - - if (client->filter_type == REJECT) { - for (i = 0; i < ARRAY_SIZE(client->filter); i++) { - if (client->filter[i] == addr) { - return false; - } - } - - return true; - } - - if (addr == BT_MESH_ADDR_ALL_NODES) { - return true; - } - - if (client->filter_type == ACCEPT) { - for (i = 0; i < ARRAY_SIZE(client->filter); i++) { - if (client->filter[i] == addr) { - return true; - } - } - } - - return false; -} - -bool bt_mesh_proxy_relay(struct os_mbuf *buf, uint16_t dst) -{ - const struct bt_mesh_send_cb *cb = BT_MESH_ADV(buf)->cb; - void *cb_data = BT_MESH_ADV(buf)->cb_data; - bool relayed = false; - int i, err; - - BT_DBG("%u bytes to dst 0x%04x", buf->om_len, dst); - - for (i = 0; i < ARRAY_SIZE(clients); i++) { - struct bt_mesh_proxy_client *client = &clients[i]; - struct os_mbuf *msg; - - if (!client->cli) { - continue; - } - - if (!client_filter_match(client, dst)) { - continue; - } - - /* Proxy PDU sending modifies the original buffer, - * so we need to make a copy. - */ - msg = NET_BUF_SIMPLE(32); - net_buf_simple_init(msg, 1); - net_buf_simple_add_mem(msg, buf->om_data, buf->om_len); - - err = bt_mesh_proxy_msg_send(client->cli, BT_MESH_PROXY_NET_PDU, - msg); - - adv_send_start(0, err, cb, cb_data); - if (err) { - BT_ERR("Failed to send proxy message (err %d)", err); - - /* If segment_and_send() fails the buf_send_end() callback will - * not be called, so we need to clear the user data (net_buf, - * which is just opaque data to segment_and send) reference given - * to segment_and_send() here. - */ - net_buf_unref(buf); - continue; - } - os_mbuf_free_chain(msg); - relayed = true; - } - - return relayed; -} - -static void gatt_connected(uint16_t conn_handle) -{ - struct bt_mesh_proxy_client *client; - struct ble_gap_conn_desc info; - struct ble_hs_conn *conn; - - conn = ble_hs_conn_find(conn_handle); - bt_conn_get_info(conn, &info); - if (info.role != BLE_GAP_ROLE_SLAVE || - !service_registered) { - return; - } - BT_DBG("conn %d", conn_handle); - - conn_count++; - - client = get_client(conn_handle); - assert(client); - - client->filter_type = NONE; - (void)memset(client->filter, 0, sizeof(client->filter)); - - client->cli = bt_mesh_proxy_role_setup(conn_handle, proxy_send, - proxy_msg_recv); - - /* Try to re-enable advertising in case it's possible */ - if (conn_count < CONFIG_BT_MAX_CONN) { - bt_mesh_adv_update(); - } -} - -static void gatt_disconnected(struct ble_gap_conn_desc conn, uint8_t reason) -{ - struct bt_mesh_proxy_client *client; - - if (conn.role != BLE_GAP_ROLE_SLAVE) { - return; - } - - if (!service_registered && bt_mesh_is_provisioned()) { - (void)bt_mesh_proxy_gatt_enable(); - return; - } - - conn_count--; - client = find_client(conn.conn_handle); - if (client->cli) { - bt_mesh_proxy_role_cleanup(client->cli); - client->cli = NULL; - } - - client->conn_handle = 0xffff; -} - -void notify_complete(void) -{ - sys_snode_t *n; - - if (atomic_dec(&pending_notifications) > 1) { - return; - } - - BT_DBG(""); - - while ((n = sys_slist_get(&idle_waiters))) { - CONTAINER_OF(n, struct bt_mesh_proxy_idle_cb, n)->cb(); - } -} - -static int proxy_send(uint16_t conn_handle, - const void *data, uint16_t len) -{ - struct os_mbuf *om; - int err = 0; - - BT_DBG("%u bytes: %s", len, bt_hex(data, len)); - - om = ble_hs_mbuf_from_flat(data, len); - assert(om); - err = ble_gatts_notify_custom(conn_handle, svc_handles.proxy_data_out_h, om); - notify_complete(); - - if (!err) { - atomic_inc(&pending_notifications); - } - - return err; -} - -int bt_mesh_proxy_adv_start(void) -{ - BT_DBG(""); - - if (!service_registered || !bt_mesh_is_provisioned()) { - return -ENOTSUP; - } - - return gatt_proxy_advertise(next_sub()); -} - - -static void ble_mesh_handle_connect(struct ble_gap_event *event, void *arg) + int err; + + BT_DBG(""); + + proxy_svc_data[2] = ID_TYPE_NET; + + BT_DBG("Advertising with NetId %s", + bt_hex(sub->keys[SUBNET_KEY_TX_IDX(sub)].net_id, 8)); + + memcpy(proxy_svc_data + 3, sub->keys[SUBNET_KEY_TX_IDX(sub)].net_id, 8); + + err = bt_mesh_adv_start(&slow_adv_param, duration, net_id_ad, + ARRAY_SIZE(net_id_ad), sd, 0); + if (err) { + BT_WARN("Failed to advertise using Network ID (err %d)", err); + return err; + } + + return 0; +} + +static bool +advertise_subnet(struct bt_mesh_subnet *sub) +{ + if (sub->net_idx == BT_MESH_KEY_UNUSED) { + return false; + } + + return (sub->node_id == BT_MESH_NODE_IDENTITY_RUNNING || + bt_mesh_gatt_proxy_get() == BT_MESH_GATT_PROXY_ENABLED); +} + +static struct bt_mesh_subnet * +next_sub(void) +{ + struct bt_mesh_subnet *sub = NULL; + + if (!beacon_sub) { + beacon_sub = bt_mesh_subnet_next(NULL); + if (!beacon_sub) { + /* No valid subnets */ + return NULL; + } + } + + sub = beacon_sub; + do { + if (advertise_subnet(sub)) { + beacon_sub = sub; + return sub; + } + + sub = bt_mesh_subnet_next(sub); + } while (sub != beacon_sub); + + /* No subnets to advertise on */ + return NULL; +} + +static int +sub_count_cb(struct bt_mesh_subnet *sub, void *cb_data) +{ + int *count = cb_data; + + if (advertise_subnet(sub)) { + (*count)++; + } + + return 0; +} + +static int +sub_count(void) +{ + int count = 0; + + (void)bt_mesh_subnet_find(sub_count_cb, &count); + + return count; +} + +static int +gatt_proxy_advertise(struct bt_mesh_subnet *sub) +{ + int32_t remaining = K_FOREVER; + int subnet_count; + int err = -EBUSY; + + BT_DBG(""); + + if (conn_count == CONFIG_BT_MAX_CONN) { + BT_DBG("Connectable advertising deferred (max connections %d)", conn_count); + return -ENOMEM; + } + + sub = beacon_sub ? beacon_sub : bt_mesh_subnet_next(beacon_sub); + if (!sub) { + BT_WARN("No subnets to advertise on"); + return -ENOENT; + } + + subnet_count = sub_count(); + BT_DBG("sub_count %u", subnet_count); + if (subnet_count > 1) { + int32_t max_timeout; + + /* We use NODE_ID_TIMEOUT as a starting point since it may + * be less than 60 seconds. Divide this period into at least + * 6 slices, but make sure that a slice is at least one + * second long (to avoid excessive rotation). + */ + max_timeout = NODE_ID_TIMEOUT / max(subnet_count, 6); + max_timeout = max(max_timeout, K_SECONDS(1)); + + if (remaining > max_timeout || remaining < 0) { + remaining = max_timeout; + } + } + + if (sub->node_id == BT_MESH_NODE_IDENTITY_RUNNING) { + uint32_t active = k_uptime_get_32() - sub->node_id_start; + + if (active < NODE_ID_TIMEOUT) { + remaining = NODE_ID_TIMEOUT - active; + BT_DBG("Node ID active for %u ms, %d ms remaining", + active, remaining); + err = node_id_adv(sub, remaining); + } else { + bt_mesh_proxy_identity_stop(sub); + BT_DBG("Node ID stopped"); + } + } + + if (sub->node_id == BT_MESH_NODE_IDENTITY_STOPPED) { + err = net_id_adv(sub, remaining); + } + + BT_DBG("Advertising %d ms for net_idx 0x%04x", + (int) remaining, sub->net_idx); + + beacon_sub = bt_mesh_subnet_next(beacon_sub); + + return err; +} + +static void +subnet_evt(struct bt_mesh_subnet *sub, enum bt_mesh_key_evt evt) +{ + if (evt == BT_MESH_KEY_DELETED) { + if (sub == beacon_sub) { + beacon_sub = NULL; + } + } else { + bt_mesh_proxy_beacon_send(sub); + } +} + +static void +proxy_ccc_write(uint16_t conn_handle) +{ + struct bt_mesh_proxy_client *client; + + BT_DBG("conn_handle %d", conn_handle); + + client = find_client(conn_handle); + + if (client->filter_type == NONE) { + client->filter_type = ACCEPT; + k_work_add_arg(&client->send_beacons, client); + k_work_submit(&client->send_beacons); + } +} + +int +bt_mesh_proxy_gatt_enable(void) +{ + uint16_t handle; + int rc; + int i; + + BT_DBG(""); + + if (!bt_mesh_is_provisioned()) { + return -ENOTSUP; + } + + if (service_registered) { + return -EBUSY; + } + + rc = ble_gatts_find_svc(BLE_UUID16_DECLARE(BT_UUID_MESH_PROXY_VAL), &handle); + assert(rc == 0); + ble_gatts_svc_set_visibility(handle, 1); + /* FIXME: figure out end handle */ + ble_svc_gatt_changed(svc_handles.proxy_h, 0xffff); + + service_registered = true; + + for (i = 0; i < ARRAY_SIZE(clients); i++) { + if (clients[i].cli) { + clients[i].filter_type = ACCEPT; + } + } + return 0; +} + +void +bt_mesh_proxy_gatt_disconnect(void) +{ + int rc; + int i; + + BT_DBG(""); + + for (i = 0; i < ARRAY_SIZE(clients); i++) { + struct bt_mesh_proxy_client *client = &clients[i]; + + if ((client->cli) && + (client->filter_type == ACCEPT || + client->filter_type == REJECT)) { + client->filter_type = NONE; + rc = ble_gap_terminate(client->cli->conn_handle, + BLE_ERR_REM_USER_CONN_TERM); + assert(rc == 0); + } + } +} + +int +bt_mesh_proxy_gatt_disable(void) +{ + uint16_t handle; + int rc; + BT_DBG(""); + + if (!service_registered) { + return -EALREADY; + } + + bt_mesh_proxy_gatt_disconnect(); + + rc = ble_gatts_find_svc(BLE_UUID16_DECLARE(BT_UUID_MESH_PROXY_VAL), &handle); + assert(rc == 0); + ble_gatts_svc_set_visibility(handle, 0); + /* FIXME: figure out end handle */ + ble_svc_gatt_changed(svc_handles.proxy_h, 0xffff); + service_registered = false; + + return 0; +} + +void +bt_mesh_proxy_addr_add(struct os_mbuf **buf, uint16_t addr) +{ + struct bt_mesh_proxy_client *client; + struct bt_mesh_proxy_role *cli = + CONTAINER_OF(buf, struct bt_mesh_proxy_role, buf); + + client = find_client(cli->conn_handle); + + BT_DBG("filter_type %u addr 0x%04x", client->filter_type, addr); + + if (client->filter_type == ACCEPT) { + filter_add(client, addr); + } else if (client->filter_type == REJECT) { + filter_remove(client, addr); + } +} + +static bool +client_filter_match(struct bt_mesh_proxy_client *client, + uint16_t addr) +{ + int i; + + BT_DBG("filter_type %u addr 0x%04x", client->filter_type, addr); + + if (client->filter_type == REJECT) { + for (i = 0; i < ARRAY_SIZE(client->filter); i++) { + if (client->filter[i] == addr) { + return false; + } + } + + return true; + } + + if (addr == BT_MESH_ADDR_ALL_NODES) { + return true; + } + + if (client->filter_type == ACCEPT) { + for (i = 0; i < ARRAY_SIZE(client->filter); i++) { + if (client->filter[i] == addr) { + return true; + } + } + } + + return false; +} + +bool +bt_mesh_proxy_relay(struct os_mbuf *buf, uint16_t dst) +{ + const struct bt_mesh_send_cb *cb = BT_MESH_ADV(buf)->cb; + void *cb_data = BT_MESH_ADV(buf)->cb_data; + bool relayed = false; + int i, err; + + BT_DBG("%u bytes to dst 0x%04x", buf->om_len, dst); + + for (i = 0; i < ARRAY_SIZE(clients); i++) { + struct bt_mesh_proxy_client *client = &clients[i]; + struct os_mbuf *msg; + + if (!client->cli) { + continue; + } + + if (!client_filter_match(client, dst)) { + continue; + } + + /* Proxy PDU sending modifies the original buffer, + * so we need to make a copy. + */ + msg = NET_BUF_SIMPLE(32); + net_buf_simple_init(msg, 1); + net_buf_simple_add_mem(msg, buf->om_data, buf->om_len); + + err = bt_mesh_proxy_msg_send(client->cli, BT_MESH_PROXY_NET_PDU, + msg); + + adv_send_start(0, err, cb, cb_data); + if (err) { + BT_ERR("Failed to send proxy message (err %d)", err); + + /* If segment_and_send() fails the buf_send_end() callback will + * not be called, so we need to clear the user data (net_buf, + * which is just opaque data to segment_and send) reference given + * to segment_and_send() here. + */ + net_buf_unref(buf); + continue; + } + os_mbuf_free_chain(msg); + relayed = true; + } + + return relayed; +} + +static void +gatt_connected(uint16_t conn_handle) +{ + struct bt_mesh_proxy_client *client; + struct ble_gap_conn_desc info; + struct ble_hs_conn *conn; + + conn = ble_hs_conn_find(conn_handle); + bt_conn_get_info(conn, &info); + if (info.role != BLE_GAP_ROLE_SLAVE || + !service_registered) { + return; + } + BT_DBG("conn %d", conn_handle); + + conn_count++; + + client = get_client(conn_handle); + assert(client); + + client->filter_type = NONE; + (void)memset(client->filter, 0, sizeof(client->filter)); + + client->cli = bt_mesh_proxy_role_setup(conn_handle, proxy_send, + proxy_msg_recv); + + /* Try to re-enable advertising in case it's possible */ + if (conn_count < CONFIG_BT_MAX_CONN) { + bt_mesh_adv_update(); + } +} + +static void +gatt_disconnected(struct ble_gap_conn_desc conn, uint8_t reason) +{ + struct bt_mesh_proxy_client *client; + + if (conn.role != BLE_GAP_ROLE_SLAVE) { + return; + } + + if (!service_registered && bt_mesh_is_provisioned()) { + (void)bt_mesh_proxy_gatt_enable(); + return; + } + + conn_count--; + client = find_client(conn.conn_handle); + if (client->cli) { + bt_mesh_proxy_role_cleanup(client->cli); + client->cli = NULL; + } + + client->conn_handle = 0xffff; +} + +void +notify_complete(void) +{ + sys_snode_t *n; + + if (atomic_dec(&pending_notifications) > 1) { + return; + } + + BT_DBG(""); + + while ((n = sys_slist_get(&idle_waiters))) { + CONTAINER_OF(n, struct bt_mesh_proxy_idle_cb, n)->cb(); + } +} + +static int +proxy_send(uint16_t conn_handle, + const void *data, uint16_t len) +{ + struct os_mbuf *om; + int err = 0; + + BT_DBG("%u bytes: %s", len, bt_hex(data, len)); + + om = ble_hs_mbuf_from_flat(data, len); + assert(om); + err = ble_gatts_notify_custom(conn_handle, svc_handles.proxy_data_out_h, om); + notify_complete(); + + if (!err) { + atomic_inc(&pending_notifications); + } + + return err; +} + +int +bt_mesh_proxy_adv_start(void) +{ + BT_DBG(""); + + if (!service_registered || !bt_mesh_is_provisioned()) { + return -ENOTSUP; + } + + return gatt_proxy_advertise(next_sub()); +} + + +static void +ble_mesh_handle_connect(struct ble_gap_event *event, void *arg) { #if MYNEWT_VAL(BLE_EXT_ADV) - /* When EXT ADV is enabled then mesh proxy is connected - * when proxy advertising instance is completed. - * Therefore no need to handle BLE_GAP_EVENT_CONNECT - */ - if (event->type == BLE_GAP_EVENT_ADV_COMPLETE) { - /* Reason 0 means advertising has been completed because - * connection has been established - */ - if (event->adv_complete.reason != 0) { - return; - } - - if (event->adv_complete.instance != BT_MESH_ADV_GATT_INST) { - return; - } - - gatt_connected(event->adv_complete.conn_handle); + /* When EXT ADV is enabled then mesh proxy is connected + * when proxy advertising instance is completed. + * Therefore no need to handle BLE_GAP_EVENT_CONNECT + */ + if (event->type == BLE_GAP_EVENT_ADV_COMPLETE) { + /* Reason 0 means advertising has been completed because + * connection has been established + */ + if (event->adv_complete.reason != 0) { + return; + } + + if (event->adv_complete.instance != BT_MESH_ADV_GATT_INST) { + return; + } + + gatt_connected(event->adv_complete.conn_handle); #if MYNEWT_VAL(BLE_MESH_PB_GATT) - gatt_connected_pb_gatt(event->adv_complete.conn_handle, - event->adv_complete.reason); + gatt_connected_pb_gatt(event->adv_complete.conn_handle, + event->adv_complete.reason); #endif - } + } #else - if (event->type == BLE_GAP_EVENT_CONNECT) { - gatt_connected(event->connect.conn_handle); + if (event->type == BLE_GAP_EVENT_CONNECT) { + gatt_connected(event->connect.conn_handle); #if MYNEWT_VAL(BLE_MESH_PB_GATT) - gatt_connected_pb_gatt(event->connect.conn_handle, event->connect.status); + gatt_connected_pb_gatt(event->connect.conn_handle, event->connect.status); #endif - } + } #endif } -int ble_mesh_proxy_gap_event(struct ble_gap_event *event, void *arg) -{ - if ((event->type == BLE_GAP_EVENT_CONNECT) || - (event->type == BLE_GAP_EVENT_ADV_COMPLETE)) { - ble_mesh_handle_connect(event, arg); - } else if (event->type == BLE_GAP_EVENT_DISCONNECT) { - gatt_disconnected(event->disconnect.conn, - event->disconnect.reason); +int +ble_mesh_proxy_gap_event(struct ble_gap_event *event, void *arg) +{ + if ((event->type == BLE_GAP_EVENT_CONNECT) || + (event->type == BLE_GAP_EVENT_ADV_COMPLETE)) { + ble_mesh_handle_connect(event, arg); + } else if (event->type == BLE_GAP_EVENT_DISCONNECT) { + gatt_disconnected(event->disconnect.conn, + event->disconnect.reason); #if MYNEWT_VAL(BLE_MESH_PB_GATT) - gatt_disconnected_pb_gatt(event->disconnect.conn, - event->disconnect.reason); + gatt_disconnected_pb_gatt(event->disconnect.conn, + event->disconnect.reason); #endif - } else if (event->type == BLE_GAP_EVENT_SUBSCRIBE) { - if (event->subscribe.attr_handle == svc_handles.proxy_data_out_h) { + } else if (event->type == BLE_GAP_EVENT_SUBSCRIBE) { + if (event->subscribe.attr_handle == svc_handles.proxy_data_out_h) { #if (MYNEWT_VAL(BLE_MESH_GATT_PROXY)) - proxy_ccc_write(event->subscribe.conn_handle); + proxy_ccc_write(event->subscribe.conn_handle); #endif - } else if (event->subscribe.attr_handle == - svc_handles.prov_data_out_h) { + } else if (event->subscribe.attr_handle == + svc_handles.prov_data_out_h) { #if (MYNEWT_VAL(BLE_MESH_PB_GATT)) - prov_ccc_write(event->subscribe.conn_handle, event->type); + prov_ccc_write(event->subscribe.conn_handle, event->type); #endif - } - } - - return 0; -} - -int bt_mesh_proxy_init(void) -{ - int i; + } + } + + return 0; +} + +int +bt_mesh_proxy_init(void) +{ + int i; #if (MYNEWT_VAL(BLE_MESH_GATT_PROXY)) - if (!bt_mesh_subnet_cb_list[4]) { - bt_mesh_subnet_cb_list[4] = subnet_evt; - } + if (!bt_mesh_subnet_cb_list[4]) { + bt_mesh_subnet_cb_list[4] = subnet_evt; + } #endif - for (i = 0; i < MYNEWT_VAL(BLE_MAX_CONNECTIONS); ++i) { + for (i = 0; i < MYNEWT_VAL(BLE_MAX_CONNECTIONS); ++i) { #if (MYNEWT_VAL(BLE_MESH_GATT_PROXY)) - k_work_init(&clients[i].send_beacons, proxy_send_beacons); + k_work_init(&clients[i].send_beacons, proxy_send_beacons); #endif - clients[i].conn_handle = 0xffff; - } - - resolve_svc_handles(); - - ble_gatts_svc_set_visibility(svc_handles.proxy_h, 0); - ble_gatts_svc_set_visibility(svc_handles.prov_h, 0); - - return 0; -} + clients[i].conn_handle = 0xffff; + } + + resolve_svc_handles(); + + ble_gatts_svc_set_visibility(svc_handles.proxy_h, 0); + ble_gatts_svc_set_visibility(svc_handles.prov_h, 0); + + return 0; +} ``` </details> -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: commits-unsubscr...@mynewt.apache.org For queries about this service, please contact Infrastructure at: us...@infra.apache.org
