177ba3d3fSMatthias Ringwald /* 277ba3d3fSMatthias Ringwald * Copyright (C) 2014 BlueKitchen GmbH 377ba3d3fSMatthias Ringwald * 477ba3d3fSMatthias Ringwald * Redistribution and use in source and binary forms, with or without 577ba3d3fSMatthias Ringwald * modification, are permitted provided that the following conditions 677ba3d3fSMatthias Ringwald * are met: 777ba3d3fSMatthias Ringwald * 877ba3d3fSMatthias Ringwald * 1. Redistributions of source code must retain the above copyright 977ba3d3fSMatthias Ringwald * notice, this list of conditions and the following disclaimer. 1077ba3d3fSMatthias Ringwald * 2. Redistributions in binary form must reproduce the above copyright 1177ba3d3fSMatthias Ringwald * notice, this list of conditions and the following disclaimer in the 1277ba3d3fSMatthias Ringwald * documentation and/or other materials provided with the distribution. 1377ba3d3fSMatthias Ringwald * 3. Neither the name of the copyright holders nor the names of 1477ba3d3fSMatthias Ringwald * contributors may be used to endorse or promote products derived 1577ba3d3fSMatthias Ringwald * from this software without specific prior written permission. 1677ba3d3fSMatthias Ringwald * 4. Any redistribution, use, or modification is done solely for 1777ba3d3fSMatthias Ringwald * personal benefit and not for any commercial purpose or for 1877ba3d3fSMatthias Ringwald * monetary gain. 1977ba3d3fSMatthias Ringwald * 2077ba3d3fSMatthias Ringwald * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 2177ba3d3fSMatthias Ringwald * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2277ba3d3fSMatthias Ringwald * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 2377ba3d3fSMatthias Ringwald * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 2477ba3d3fSMatthias Ringwald * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 2577ba3d3fSMatthias Ringwald * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 2677ba3d3fSMatthias Ringwald * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 2777ba3d3fSMatthias Ringwald * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 2877ba3d3fSMatthias Ringwald * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 2977ba3d3fSMatthias Ringwald * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 3077ba3d3fSMatthias Ringwald * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3177ba3d3fSMatthias Ringwald * SUCH DAMAGE. 3277ba3d3fSMatthias Ringwald * 3377ba3d3fSMatthias Ringwald * Please inquire about commercial licensing options at 3477ba3d3fSMatthias Ringwald * [email protected] 3577ba3d3fSMatthias Ringwald * 3677ba3d3fSMatthias Ringwald */ 3777ba3d3fSMatthias Ringwald 385beab91eSMatthias Ringwald #define BTSTACK_FILE__ "mesh_upper_transport.c" 39f4854a5eSMatthias Ringwald 40f4854a5eSMatthias Ringwald #include "mesh/mesh_upper_transport.h" 4177ba3d3fSMatthias Ringwald 4277ba3d3fSMatthias Ringwald #include <stdio.h> 4377ba3d3fSMatthias Ringwald #include <stdlib.h> 4477ba3d3fSMatthias Ringwald #include <string.h> 45f4854a5eSMatthias Ringwald 4677ba3d3fSMatthias Ringwald #include "btstack_util.h" 4777ba3d3fSMatthias Ringwald #include "btstack_memory.h" 485beab91eSMatthias Ringwald #include "btstack_debug.h" 49f4854a5eSMatthias Ringwald 50f4854a5eSMatthias Ringwald #include "mesh/beacon.h" 51f4854a5eSMatthias Ringwald #include "mesh/mesh_iv_index_seq_number.h" 52f4854a5eSMatthias Ringwald #include "mesh/mesh_keys.h" 53f4854a5eSMatthias Ringwald #include "mesh/mesh_lower_transport.h" 54f4854a5eSMatthias Ringwald #include "mesh/mesh_peer.h" 55f4854a5eSMatthias Ringwald #include "mesh/mesh_virtual_addresses.h" 5677ba3d3fSMatthias Ringwald 5710cd83b4SMatthias Ringwald // TODO: extract mesh_pdu functions into lower transport or network 5810cd83b4SMatthias Ringwald #include "mesh/mesh_access.h" 5910cd83b4SMatthias Ringwald 6077ba3d3fSMatthias Ringwald // combined key x address iterator for upper transport decryption 6177ba3d3fSMatthias Ringwald 6277ba3d3fSMatthias Ringwald typedef struct { 6377ba3d3fSMatthias Ringwald // state 6477ba3d3fSMatthias Ringwald mesh_transport_key_iterator_t key_it; 6577ba3d3fSMatthias Ringwald mesh_virtual_address_iterator_t address_it; 6677ba3d3fSMatthias Ringwald // elements 6777ba3d3fSMatthias Ringwald const mesh_transport_key_t * key; 6877ba3d3fSMatthias Ringwald const mesh_virtual_address_t * address; 6977ba3d3fSMatthias Ringwald // address - might be virtual 7077ba3d3fSMatthias Ringwald uint16_t dst; 7177ba3d3fSMatthias Ringwald // key info 7277ba3d3fSMatthias Ringwald } mesh_transport_key_and_virtual_address_iterator_t; 7377ba3d3fSMatthias Ringwald 74cae44b3bSMatthias Ringwald static void mesh_upper_transport_validate_segmented_message(void); 75cae44b3bSMatthias Ringwald static void mesh_upper_transport_run(void); 76cae44b3bSMatthias Ringwald 77cae44b3bSMatthias Ringwald static int crypto_active; 78160d2809SMatthias Ringwald 798facb3eaSMatthias Ringwald static mesh_unsegmented_pdu_t * incoming_unsegmented_pdu_raw; 80160d2809SMatthias Ringwald 81a4bbc09dSMatthias Ringwald static mesh_segmented_pdu_t incoming_message_pdu_singleton; 827667b5d1SMatthias Ringwald 83160d2809SMatthias Ringwald static mesh_access_pdu_t * incoming_access_pdu_encrypted; 84160d2809SMatthias Ringwald static mesh_access_pdu_t * incoming_access_pdu_decrypted; 85160d2809SMatthias Ringwald 86160d2809SMatthias Ringwald static mesh_access_pdu_t incoming_access_pdu_encrypted_singleton; 87160d2809SMatthias Ringwald static mesh_access_pdu_t incoming_access_pdu_decrypted_singleton; 887667b5d1SMatthias Ringwald 8925b07254SMatthias Ringwald static mesh_control_pdu_t incoming_control_pdu_singleton; 9025b07254SMatthias Ringwald static mesh_control_pdu_t * incoming_control_pdu; 9125b07254SMatthias Ringwald 92a4bbc09dSMatthias Ringwald static mesh_segmented_pdu_t outgoing_segmented_message_singleton; 93b1a7ae8fSMatthias Ringwald static mesh_access_pdu_t * outgoing_segmented_access_pdu; 94552f5710SMatthias Ringwald 95*1b51af65SMatthias Ringwald static mesh_unsegmented_pdu_t outgoing_unsegmented_pdu_singleton; 96*1b51af65SMatthias Ringwald static mesh_upper_transport_pdu_t * outgoing_upper_transport_pdu; 97536fc383SMatthias Ringwald 98cae44b3bSMatthias Ringwald static uint8_t application_nonce[13]; 99cae44b3bSMatthias Ringwald static btstack_crypto_ccm_t ccm; 100242605faSMatthias Ringwald static uint8_t crypto_buffer[MESH_ACCESS_PAYLOAD_MAX]; 101cae44b3bSMatthias Ringwald static mesh_transport_key_and_virtual_address_iterator_t mesh_transport_key_it; 102cae44b3bSMatthias Ringwald 103cae44b3bSMatthias Ringwald // upper transport callbacks - in access layer 104404d2482SMatthias Ringwald static void (*mesh_access_message_handler)( mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu); 105404d2482SMatthias Ringwald static void (*mesh_control_message_handler)( mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu); 106cae44b3bSMatthias Ringwald 107cae44b3bSMatthias Ringwald // incoming unsegmented (network) and segmented (transport) control and access messages 108cae44b3bSMatthias Ringwald static btstack_linked_list_t upper_transport_incoming; 109cae44b3bSMatthias Ringwald 110cae44b3bSMatthias Ringwald // outgoing unsegmented (network) and segmented (uppert_transport_outgoing) control and access messages 111cae44b3bSMatthias Ringwald static btstack_linked_list_t upper_transport_outgoing; 112cae44b3bSMatthias Ringwald 113cae44b3bSMatthias Ringwald 114cae44b3bSMatthias Ringwald // TODO: higher layer define used for assert 115cae44b3bSMatthias Ringwald #define MESH_ACCESS_OPCODE_NOT_SET 0xFFFFFFFEu 116cae44b3bSMatthias Ringwald 117cae44b3bSMatthias Ringwald void mesh_upper_transport_send_access_pdu(mesh_pdu_t *pdu){ 1181fda7ff0SMatthias Ringwald switch (pdu->pdu_type){ 1191fda7ff0SMatthias Ringwald case MESH_PDU_TYPE_UNSEGMENTED: 120b1a7ae8fSMatthias Ringwald case MESH_PDU_TYPE_ACCESS: 121242605faSMatthias Ringwald case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS: 122*1b51af65SMatthias Ringwald case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 1231fda7ff0SMatthias Ringwald break; 1241fda7ff0SMatthias Ringwald default: 1251fda7ff0SMatthias Ringwald btstack_assert(false); 1261fda7ff0SMatthias Ringwald break; 1271fda7ff0SMatthias Ringwald } 128cae44b3bSMatthias Ringwald 129cae44b3bSMatthias Ringwald btstack_linked_list_add_tail(&upper_transport_outgoing, (btstack_linked_item_t*) pdu); 130cae44b3bSMatthias Ringwald mesh_upper_transport_run(); 131cae44b3bSMatthias Ringwald } 132cae44b3bSMatthias Ringwald 133cae44b3bSMatthias Ringwald void mesh_upper_transport_send_control_pdu(mesh_pdu_t * pdu){ 134cae44b3bSMatthias Ringwald if (pdu->pdu_type == MESH_PDU_TYPE_NETWORK){ 135cae44b3bSMatthias Ringwald btstack_assert( ((mesh_network_pdu_t *) pdu)->len >= 9); 136cae44b3bSMatthias Ringwald } 137cae44b3bSMatthias Ringwald 138cae44b3bSMatthias Ringwald btstack_linked_list_add_tail(&upper_transport_outgoing, (btstack_linked_item_t*) pdu); 139cae44b3bSMatthias Ringwald mesh_upper_transport_run(); 140cae44b3bSMatthias Ringwald } 141cae44b3bSMatthias Ringwald 142cae44b3bSMatthias Ringwald static void mesh_print_hex(const char * name, const uint8_t * data, uint16_t len){ 143cae44b3bSMatthias Ringwald printf("%-20s ", name); 144cae44b3bSMatthias Ringwald printf_hexdump(data, len); 145cae44b3bSMatthias Ringwald } 146cae44b3bSMatthias Ringwald // static void mesh_print_x(const char * name, uint32_t value){ 147cae44b3bSMatthias Ringwald // printf("%20s: 0x%x", name, (int) value); 148cae44b3bSMatthias Ringwald // } 149cae44b3bSMatthias Ringwald 15077ba3d3fSMatthias Ringwald static void mesh_transport_key_and_virtual_address_iterator_init(mesh_transport_key_and_virtual_address_iterator_t *it, 15177ba3d3fSMatthias Ringwald uint16_t dst, uint16_t netkey_index, uint8_t akf, 15277ba3d3fSMatthias Ringwald uint8_t aid) { 15377ba3d3fSMatthias Ringwald printf("KEY_INIT: dst %04x, akf %x, aid %x\n", dst, akf, aid); 15477ba3d3fSMatthias Ringwald // config 15577ba3d3fSMatthias Ringwald it->dst = dst; 15677ba3d3fSMatthias Ringwald // init elements 15777ba3d3fSMatthias Ringwald it->key = NULL; 15877ba3d3fSMatthias Ringwald it->address = NULL; 15977ba3d3fSMatthias Ringwald // init element iterators 16077ba3d3fSMatthias Ringwald mesh_transport_key_aid_iterator_init(&it->key_it, netkey_index, akf, aid); 16177ba3d3fSMatthias Ringwald // init address iterator 16277ba3d3fSMatthias Ringwald if (mesh_network_address_virtual(it->dst)){ 16377ba3d3fSMatthias Ringwald mesh_virtual_address_iterator_init(&it->address_it, dst); 16477ba3d3fSMatthias Ringwald // get first key 16577ba3d3fSMatthias Ringwald if (mesh_transport_key_aid_iterator_has_more(&it->key_it)) { 16677ba3d3fSMatthias Ringwald it->key = mesh_transport_key_aid_iterator_get_next(&it->key_it); 16777ba3d3fSMatthias Ringwald } 16877ba3d3fSMatthias Ringwald } 16977ba3d3fSMatthias Ringwald } 17077ba3d3fSMatthias Ringwald 17177ba3d3fSMatthias Ringwald // cartesian product: keys x addressses 17277ba3d3fSMatthias Ringwald static int mesh_transport_key_and_virtual_address_iterator_has_more(mesh_transport_key_and_virtual_address_iterator_t * it){ 17377ba3d3fSMatthias Ringwald if (mesh_network_address_virtual(it->dst)) { 17477ba3d3fSMatthias Ringwald // find next valid entry 175ff3cc4a5SMatthias Ringwald while (true){ 17677ba3d3fSMatthias Ringwald if (mesh_virtual_address_iterator_has_more(&it->address_it)) return 1; 17777ba3d3fSMatthias Ringwald if (!mesh_transport_key_aid_iterator_has_more(&it->key_it)) return 0; 17877ba3d3fSMatthias Ringwald // get next key 17977ba3d3fSMatthias Ringwald it->key = mesh_transport_key_aid_iterator_get_next(&it->key_it); 18077ba3d3fSMatthias Ringwald mesh_virtual_address_iterator_init(&it->address_it, it->dst); 18177ba3d3fSMatthias Ringwald } 18277ba3d3fSMatthias Ringwald } else { 18377ba3d3fSMatthias Ringwald return mesh_transport_key_aid_iterator_has_more(&it->key_it); 18477ba3d3fSMatthias Ringwald } 18577ba3d3fSMatthias Ringwald } 18677ba3d3fSMatthias Ringwald 18777ba3d3fSMatthias Ringwald static void mesh_transport_key_and_virtual_address_iterator_next(mesh_transport_key_and_virtual_address_iterator_t * it){ 18877ba3d3fSMatthias Ringwald if (mesh_network_address_virtual(it->dst)) { 18977ba3d3fSMatthias Ringwald it->address = mesh_virtual_address_iterator_get_next(&it->address_it); 19077ba3d3fSMatthias Ringwald } else { 19177ba3d3fSMatthias Ringwald it->key = mesh_transport_key_aid_iterator_get_next(&it->key_it); 19277ba3d3fSMatthias Ringwald } 19377ba3d3fSMatthias Ringwald } 19477ba3d3fSMatthias Ringwald 19577ba3d3fSMatthias Ringwald // UPPER TRANSPORT 19677ba3d3fSMatthias Ringwald 197b1a7ae8fSMatthias Ringwald uint16_t mesh_access_dst(mesh_access_pdu_t * access_pdu){ 1987667b5d1SMatthias Ringwald return big_endian_read_16(access_pdu->network_header, 7); 1997667b5d1SMatthias Ringwald } 2007667b5d1SMatthias Ringwald 201160d2809SMatthias Ringwald uint16_t mesh_access_ctl(mesh_access_pdu_t * access_pdu){ 202160d2809SMatthias Ringwald return access_pdu->network_header[1] >> 7; 203160d2809SMatthias Ringwald } 204160d2809SMatthias Ringwald 205b1a7ae8fSMatthias Ringwald uint32_t mesh_access_seq(mesh_access_pdu_t * access_pdu){ 206b1a7ae8fSMatthias Ringwald return big_endian_read_24(access_pdu->network_header, 2); 207b1a7ae8fSMatthias Ringwald } 208b1a7ae8fSMatthias Ringwald 209b1a7ae8fSMatthias Ringwald void mesh_access_set_nid_ivi(mesh_access_pdu_t * access_pdu, uint8_t nid_ivi){ 210b1a7ae8fSMatthias Ringwald access_pdu->network_header[0] = nid_ivi; 211b1a7ae8fSMatthias Ringwald } 212b1a7ae8fSMatthias Ringwald void mesh_access_set_ctl_ttl(mesh_access_pdu_t * access_pdu, uint8_t ctl_ttl){ 213b1a7ae8fSMatthias Ringwald access_pdu->network_header[1] = ctl_ttl; 214b1a7ae8fSMatthias Ringwald } 215b1a7ae8fSMatthias Ringwald void mesh_access_set_seq(mesh_access_pdu_t * access_pdu, uint32_t seq){ 216b1a7ae8fSMatthias Ringwald big_endian_store_24(access_pdu->network_header, 2, seq); 217b1a7ae8fSMatthias Ringwald } 218b1a7ae8fSMatthias Ringwald void mesh_access_set_src(mesh_access_pdu_t * access_pdu, uint16_t src){ 219b1a7ae8fSMatthias Ringwald big_endian_store_16(access_pdu->network_header, 5, src); 220b1a7ae8fSMatthias Ringwald } 221b1a7ae8fSMatthias Ringwald void mesh_access_set_dest(mesh_access_pdu_t * access_pdu, uint16_t dest){ 222b1a7ae8fSMatthias Ringwald big_endian_store_16(access_pdu->network_header, 7, dest); 223b1a7ae8fSMatthias Ringwald } 2247667b5d1SMatthias Ringwald 225242605faSMatthias Ringwald static void mesh_segmented_pdu_flatten(btstack_linked_list_t * segments, uint8_t segment_len, uint8_t * buffer) { 226242605faSMatthias Ringwald // assemble payload 227242605faSMatthias Ringwald btstack_linked_list_iterator_t it; 228242605faSMatthias Ringwald btstack_linked_list_iterator_init(&it, segments); 229242605faSMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)) { 230242605faSMatthias Ringwald mesh_network_pdu_t *segment = (mesh_network_pdu_t *) btstack_linked_list_iterator_next(&it); 231242605faSMatthias Ringwald btstack_assert(segment->pdu_header.pdu_type == MESH_PDU_TYPE_NETWORK); 232242605faSMatthias Ringwald // get segment n 233242605faSMatthias Ringwald uint8_t *lower_transport_pdu = mesh_network_pdu_data(segment); 234242605faSMatthias Ringwald uint8_t seg_o = (big_endian_read_16(lower_transport_pdu, 2) >> 5) & 0x001f; 235242605faSMatthias Ringwald uint8_t *segment_data = &lower_transport_pdu[4]; 236242605faSMatthias Ringwald (void) memcpy(&buffer[seg_o * segment_len], segment_data, segment_len); 237242605faSMatthias Ringwald } 238242605faSMatthias Ringwald } 239242605faSMatthias Ringwald 240242605faSMatthias Ringwald static uint16_t mesh_upper_pdu_flatten(mesh_upper_transport_pdu_t * upper_pdu, uint8_t * buffer, uint16_t buffer_len) { 241242605faSMatthias Ringwald // assemble payload 242242605faSMatthias Ringwald btstack_linked_list_iterator_t it; 243*1b51af65SMatthias Ringwald btstack_linked_list_iterator_init(&it, &upper_pdu->segments); 244242605faSMatthias Ringwald uint16_t offset = 0; 245242605faSMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)) { 246242605faSMatthias Ringwald mesh_network_pdu_t *segment = (mesh_network_pdu_t *) btstack_linked_list_iterator_next(&it); 247242605faSMatthias Ringwald btstack_assert(segment->pdu_header.pdu_type == MESH_PDU_TYPE_NETWORK); 248242605faSMatthias Ringwald btstack_assert((offset + segment->len) <= buffer_len); 249242605faSMatthias Ringwald (void) memcpy(&buffer[offset], segment->data, segment->len); 250242605faSMatthias Ringwald offset += segment->len; 251242605faSMatthias Ringwald } 252242605faSMatthias Ringwald return offset; 253242605faSMatthias Ringwald } 254242605faSMatthias Ringwald 255242605faSMatthias Ringwald static void mesh_segmented_append_payload(const uint8_t * payload, uint16_t payload_len, btstack_linked_list_t * segments){ 256242605faSMatthias Ringwald uint16_t payload_offset = 0; 257242605faSMatthias Ringwald uint16_t bytes_current_segment = 0; 258242605faSMatthias Ringwald mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_get_last_item(segments); 259242605faSMatthias Ringwald if (network_pdu){ 260242605faSMatthias Ringwald bytes_current_segment = MESH_NETWORK_PAYLOAD_MAX - network_pdu->len; 261242605faSMatthias Ringwald } 262242605faSMatthias Ringwald while (payload_offset < payload_len){ 263242605faSMatthias Ringwald if (bytes_current_segment == 0){ 264242605faSMatthias Ringwald network_pdu = mesh_network_pdu_get(); 265242605faSMatthias Ringwald btstack_assert(network_pdu != NULL); 266242605faSMatthias Ringwald btstack_linked_list_add_tail(segments, (btstack_linked_item_t *) network_pdu); 267242605faSMatthias Ringwald bytes_current_segment = MESH_NETWORK_PAYLOAD_MAX; 268242605faSMatthias Ringwald } 269242605faSMatthias Ringwald uint16_t bytes_to_copy = btstack_min(bytes_current_segment, payload_len - payload_offset); 270242605faSMatthias Ringwald (void) memcpy(&network_pdu->data[network_pdu->len], &payload[payload_offset], bytes_to_copy); 271242605faSMatthias Ringwald bytes_current_segment -= bytes_to_copy; 272242605faSMatthias Ringwald network_pdu->len += bytes_to_copy; 273242605faSMatthias Ringwald payload_offset += bytes_to_copy; 274242605faSMatthias Ringwald } 275242605faSMatthias Ringwald } 276242605faSMatthias Ringwald 27777ba3d3fSMatthias Ringwald // stub lower transport 27877ba3d3fSMatthias Ringwald 279dd729594SMatthias Ringwald static void mesh_upper_transport_dump_pdus(const char *name, btstack_linked_list_t *list){ 280dd729594SMatthias Ringwald printf("List: %s:\n", name); 281dd729594SMatthias Ringwald btstack_linked_list_iterator_t it; 282dd729594SMatthias Ringwald btstack_linked_list_iterator_init(&it, list); 283dd729594SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 284dd729594SMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t*) btstack_linked_list_iterator_next(&it); 285dd729594SMatthias Ringwald printf("- %p\n", pdu); 286dd729594SMatthias Ringwald // printf_hexdump( mesh_pdu_data(pdu), mesh_pdu_len(pdu)); 287dd729594SMatthias Ringwald } 288dd729594SMatthias Ringwald } 289dd729594SMatthias Ringwald 290dd729594SMatthias Ringwald static void mesh_upper_transport_reset_pdus(btstack_linked_list_t *list){ 291dd729594SMatthias Ringwald while (!btstack_linked_list_empty(list)){ 29259613427SMatthias Ringwald mesh_upper_transport_pdu_free((mesh_pdu_t *) btstack_linked_list_pop(list)); 293dd729594SMatthias Ringwald } 294dd729594SMatthias Ringwald } 295dd729594SMatthias Ringwald 296dd729594SMatthias Ringwald void mesh_upper_transport_dump(void){ 2972ae11e2cSMatthias Ringwald printf("incoming_unsegmented_pdu_raw: %p\n", incoming_unsegmented_pdu_raw); 298dd729594SMatthias Ringwald mesh_upper_transport_dump_pdus("upper_transport_incoming", &upper_transport_incoming); 299dd729594SMatthias Ringwald } 300dd729594SMatthias Ringwald 301dd729594SMatthias Ringwald void mesh_upper_transport_reset(void){ 302dd729594SMatthias Ringwald crypto_active = 0; 3032ae11e2cSMatthias Ringwald if (incoming_unsegmented_pdu_raw){ 30484011563SMatthias Ringwald mesh_network_pdu_t * network_pdu = incoming_unsegmented_pdu_raw->segment; 3052ae11e2cSMatthias Ringwald btstack_assert(network_pdu != NULL); 30684011563SMatthias Ringwald incoming_unsegmented_pdu_raw->segment = NULL; 3072ae11e2cSMatthias Ringwald mesh_network_pdu_free(network_pdu); 3082ae11e2cSMatthias Ringwald incoming_unsegmented_pdu_raw = NULL; 309dd729594SMatthias Ringwald } 310b1a7ae8fSMatthias Ringwald outgoing_segmented_access_pdu = NULL; 311b86620d9SMatthias Ringwald mesh_upper_transport_reset_pdus(&upper_transport_incoming); 312dd729594SMatthias Ringwald } 31377ba3d3fSMatthias Ringwald 314cae44b3bSMatthias Ringwald static uint32_t iv_index_for_ivi_nid(uint8_t ivi_nid){ 315cae44b3bSMatthias Ringwald // get IV Index and IVI 316cae44b3bSMatthias Ringwald uint32_t iv_index = mesh_get_iv_index(); 317cae44b3bSMatthias Ringwald int ivi = ivi_nid >> 7; 318cae44b3bSMatthias Ringwald 319cae44b3bSMatthias Ringwald // if least significant bit differs, use previous IV Index 320cae44b3bSMatthias Ringwald if ((iv_index & 1 ) ^ ivi){ 321cae44b3bSMatthias Ringwald iv_index--; 322cae44b3bSMatthias Ringwald } 323cae44b3bSMatthias Ringwald return iv_index; 324cae44b3bSMatthias Ringwald } 325cae44b3bSMatthias Ringwald 326cae44b3bSMatthias Ringwald static void transport_unsegmented_setup_nonce(uint8_t * nonce, const mesh_network_pdu_t * network_pdu){ 327cae44b3bSMatthias Ringwald nonce[1] = 0x00; // SZMIC if a Segmented Access message or 0 for all other message formats 328cae44b3bSMatthias Ringwald (void)memcpy(&nonce[2], &network_pdu->data[2], 7); 329cae44b3bSMatthias Ringwald big_endian_store_32(nonce, 9, iv_index_for_ivi_nid(network_pdu->data[0])); 330cae44b3bSMatthias Ringwald } 331cae44b3bSMatthias Ringwald 332160d2809SMatthias Ringwald static void transport_segmented_setup_nonce(uint8_t * nonce, const mesh_pdu_t * pdu){ 333160d2809SMatthias Ringwald mesh_access_pdu_t * access_pdu; 334242605faSMatthias Ringwald mesh_upper_transport_pdu_t * upper_pdu; 335160d2809SMatthias Ringwald switch (pdu->pdu_type){ 336160d2809SMatthias Ringwald case MESH_PDU_TYPE_ACCESS: 337160d2809SMatthias Ringwald access_pdu = (mesh_access_pdu_t *) pdu; 338160d2809SMatthias Ringwald nonce[1] = access_pdu->transmic_len == 8 ? 0x80 : 0x00; 339160d2809SMatthias Ringwald (void)memcpy(&nonce[2], &access_pdu->network_header[2], 7); 340160d2809SMatthias Ringwald big_endian_store_32(nonce, 9, iv_index_for_ivi_nid(access_pdu->network_header[0])); 341160d2809SMatthias Ringwald break; 342242605faSMatthias Ringwald case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS: 343*1b51af65SMatthias Ringwald case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 344242605faSMatthias Ringwald upper_pdu = (mesh_upper_transport_pdu_t *) pdu; 345242605faSMatthias Ringwald nonce[1] = upper_pdu->transmic_len == 8 ? 0x80 : 0x00; 346242605faSMatthias Ringwald // 'network header' 347242605faSMatthias Ringwald big_endian_store_24(nonce, 2, upper_pdu->seq); 348242605faSMatthias Ringwald big_endian_store_16(nonce, 5, upper_pdu->src); 349242605faSMatthias Ringwald big_endian_store_16(nonce, 7, upper_pdu->dst); 350242605faSMatthias Ringwald big_endian_store_32(nonce, 9, iv_index_for_ivi_nid(upper_pdu->ivi_nid)); 351242605faSMatthias Ringwald break; 352160d2809SMatthias Ringwald default: 353160d2809SMatthias Ringwald btstack_assert(0); 354160d2809SMatthias Ringwald break; 355160d2809SMatthias Ringwald } 356cae44b3bSMatthias Ringwald } 357cae44b3bSMatthias Ringwald 358cae44b3bSMatthias Ringwald static void transport_unsegmented_setup_application_nonce(uint8_t * nonce, const mesh_network_pdu_t * network_pdu){ 359cae44b3bSMatthias Ringwald nonce[0] = 0x01; 360cae44b3bSMatthias Ringwald transport_unsegmented_setup_nonce(nonce, network_pdu); 361cae44b3bSMatthias Ringwald mesh_print_hex("AppNonce", nonce, 13); 362cae44b3bSMatthias Ringwald } 363cae44b3bSMatthias Ringwald 364cae44b3bSMatthias Ringwald static void transport_unsegmented_setup_device_nonce(uint8_t * nonce, const mesh_network_pdu_t * network_pdu){ 365cae44b3bSMatthias Ringwald nonce[0] = 0x02; 366cae44b3bSMatthias Ringwald transport_unsegmented_setup_nonce(nonce, network_pdu); 367cae44b3bSMatthias Ringwald mesh_print_hex("DeviceNonce", nonce, 13); 368cae44b3bSMatthias Ringwald } 369cae44b3bSMatthias Ringwald 370160d2809SMatthias Ringwald static void transport_segmented_setup_application_nonce(uint8_t * nonce, const mesh_pdu_t * pdu){ 371cae44b3bSMatthias Ringwald nonce[0] = 0x01; 372160d2809SMatthias Ringwald transport_segmented_setup_nonce(nonce, pdu); 373cae44b3bSMatthias Ringwald mesh_print_hex("AppNonce", nonce, 13); 374cae44b3bSMatthias Ringwald } 375cae44b3bSMatthias Ringwald 376160d2809SMatthias Ringwald static void transport_segmented_setup_device_nonce(uint8_t * nonce, const mesh_pdu_t * pdu){ 377cae44b3bSMatthias Ringwald nonce[0] = 0x02; 378160d2809SMatthias Ringwald transport_segmented_setup_nonce(nonce, pdu); 379cae44b3bSMatthias Ringwald mesh_print_hex("DeviceNonce", nonce, 13); 380cae44b3bSMatthias Ringwald } 381cae44b3bSMatthias Ringwald 382a4bbc09dSMatthias Ringwald static void mesh_upper_transport_process_message_done(mesh_segmented_pdu_t *message_pdu){ 383aaa248aaSMatthias Ringwald crypto_active = 0; 384aaa248aaSMatthias Ringwald btstack_assert(message_pdu == &incoming_message_pdu_singleton); 385aaa248aaSMatthias Ringwald mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&incoming_message_pdu_singleton.segments); 386aaa248aaSMatthias Ringwald if (mesh_network_control(network_pdu)) { 387aaa248aaSMatthias Ringwald btstack_assert(0); 388aaa248aaSMatthias Ringwald } else { 389aaa248aaSMatthias Ringwald btstack_assert(network_pdu != NULL); 390aaa248aaSMatthias Ringwald mesh_network_pdu_free(network_pdu); 3912ae11e2cSMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t *) incoming_unsegmented_pdu_raw; 3922ae11e2cSMatthias Ringwald incoming_unsegmented_pdu_raw = NULL; 3932ae11e2cSMatthias Ringwald mesh_lower_transport_message_processed_by_higher_layer(pdu); 394aaa248aaSMatthias Ringwald } 395aaa248aaSMatthias Ringwald mesh_upper_transport_run(); 396aaa248aaSMatthias Ringwald } 397aaa248aaSMatthias Ringwald 3983d9c3b8eSMatthias Ringwald static void mesh_upper_transport_process_unsegmented_message_done(mesh_pdu_t * pdu){ 3993d9c3b8eSMatthias Ringwald btstack_assert(pdu != NULL); 4008facb3eaSMatthias Ringwald btstack_assert(pdu->pdu_type == MESH_PDU_TYPE_UNSEGMENTED); 4013d9c3b8eSMatthias Ringwald 4028facb3eaSMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_incoming_pdu = (mesh_unsegmented_pdu_t *) pdu; 4033d9c3b8eSMatthias Ringwald btstack_assert(unsegmented_incoming_pdu == incoming_unsegmented_pdu_raw); 4043d9c3b8eSMatthias Ringwald 40577ba3d3fSMatthias Ringwald crypto_active = 0; 4063d9c3b8eSMatthias Ringwald incoming_unsegmented_pdu_raw = NULL; 40784011563SMatthias Ringwald mesh_network_pdu_t * network_pdu = unsegmented_incoming_pdu->segment; 4083d9c3b8eSMatthias Ringwald if (!mesh_network_control(network_pdu)) { 40977ba3d3fSMatthias Ringwald mesh_network_pdu_free(network_pdu); 41077ba3d3fSMatthias Ringwald } 4113d9c3b8eSMatthias Ringwald 4123d9c3b8eSMatthias Ringwald mesh_lower_transport_message_processed_by_higher_layer(pdu); 4135beab91eSMatthias Ringwald mesh_upper_transport_run(); 41477ba3d3fSMatthias Ringwald } 41577ba3d3fSMatthias Ringwald 4165131e195SMatthias Ringwald static void mesh_upper_transport_process_access_message_done(mesh_access_pdu_t *access_pdu){ 41777ba3d3fSMatthias Ringwald crypto_active = 0; 418160d2809SMatthias Ringwald btstack_assert(mesh_access_ctl(access_pdu) == 0); 419160d2809SMatthias Ringwald incoming_access_pdu_encrypted = NULL; 4205beab91eSMatthias Ringwald mesh_upper_transport_run(); 42177ba3d3fSMatthias Ringwald } 42277ba3d3fSMatthias Ringwald 4235131e195SMatthias Ringwald static void mesh_upper_transport_process_control_message_done(mesh_control_pdu_t * control_pdu){ 4245131e195SMatthias Ringwald crypto_active = 0; 4255131e195SMatthias Ringwald incoming_control_pdu = NULL; 4265131e195SMatthias Ringwald mesh_upper_transport_run(); 4275131e195SMatthias Ringwald } 4285131e195SMatthias Ringwald 42977ba3d3fSMatthias Ringwald static void mesh_upper_transport_validate_segmented_message_ccm(void * arg){ 430b86620d9SMatthias Ringwald UNUSED(arg); 43177ba3d3fSMatthias Ringwald 432160d2809SMatthias Ringwald uint8_t * upper_transport_pdu = incoming_access_pdu_decrypted->data; 433160d2809SMatthias Ringwald uint8_t upper_transport_pdu_len = incoming_access_pdu_decrypted->len - incoming_access_pdu_decrypted->transmic_len; 43477ba3d3fSMatthias Ringwald 43577ba3d3fSMatthias Ringwald mesh_print_hex("Decrypted PDU", upper_transport_pdu, upper_transport_pdu_len); 43677ba3d3fSMatthias Ringwald 43777ba3d3fSMatthias Ringwald // store TransMIC 43877ba3d3fSMatthias Ringwald uint8_t trans_mic[8]; 43977ba3d3fSMatthias Ringwald btstack_crypto_ccm_get_authentication_value(&ccm, trans_mic); 440160d2809SMatthias Ringwald mesh_print_hex("TransMIC", trans_mic, incoming_access_pdu_decrypted->transmic_len); 44177ba3d3fSMatthias Ringwald 442160d2809SMatthias Ringwald if (memcmp(trans_mic, &upper_transport_pdu[upper_transport_pdu_len], incoming_access_pdu_decrypted->transmic_len) == 0){ 44377ba3d3fSMatthias Ringwald printf("TransMIC matches\n"); 44477ba3d3fSMatthias Ringwald 44577ba3d3fSMatthias Ringwald // remove TransMIC from payload 446160d2809SMatthias Ringwald incoming_access_pdu_decrypted->len -= incoming_access_pdu_decrypted->transmic_len; 44777ba3d3fSMatthias Ringwald 44877ba3d3fSMatthias Ringwald // if virtual address, update dst to pseudo_dst 449160d2809SMatthias Ringwald if (mesh_network_address_virtual(mesh_access_dst(incoming_access_pdu_decrypted))){ 450160d2809SMatthias Ringwald big_endian_store_16(incoming_access_pdu_decrypted->network_header, 7, mesh_transport_key_it.address->pseudo_dst); 45177ba3d3fSMatthias Ringwald } 45277ba3d3fSMatthias Ringwald 45377ba3d3fSMatthias Ringwald // pass to upper layer 4547667b5d1SMatthias Ringwald btstack_assert(mesh_access_message_handler != NULL); 455160d2809SMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_access_pdu_decrypted; 456404d2482SMatthias Ringwald mesh_access_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu); 45777ba3d3fSMatthias Ringwald 45877ba3d3fSMatthias Ringwald printf("\n"); 45977ba3d3fSMatthias Ringwald 46077ba3d3fSMatthias Ringwald } else { 461160d2809SMatthias Ringwald uint8_t akf = incoming_access_pdu_decrypted->akf_aid_control & 0x40; 46277ba3d3fSMatthias Ringwald if (akf){ 46377ba3d3fSMatthias Ringwald printf("TransMIC does not match, try next key\n"); 464b86620d9SMatthias Ringwald mesh_upper_transport_validate_segmented_message(); 46577ba3d3fSMatthias Ringwald } else { 46677ba3d3fSMatthias Ringwald printf("TransMIC does not match device key, done\n"); 46777ba3d3fSMatthias Ringwald // done 4685131e195SMatthias Ringwald mesh_upper_transport_process_access_message_done(incoming_access_pdu_decrypted); 46977ba3d3fSMatthias Ringwald } 47077ba3d3fSMatthias Ringwald } 47177ba3d3fSMatthias Ringwald } 47277ba3d3fSMatthias Ringwald 47377ba3d3fSMatthias Ringwald static void mesh_upper_transport_validate_segmented_message_digest(void * arg){ 474b86620d9SMatthias Ringwald UNUSED(arg); 475160d2809SMatthias Ringwald uint8_t upper_transport_pdu_len = incoming_access_pdu_encrypted->len - incoming_access_pdu_encrypted->transmic_len; 476160d2809SMatthias Ringwald uint8_t * upper_transport_pdu_data_in = incoming_access_pdu_encrypted->data; 477160d2809SMatthias Ringwald uint8_t * upper_transport_pdu_data_out = incoming_access_pdu_decrypted->data; 478b86620d9SMatthias Ringwald btstack_crypto_ccm_decrypt_block(&ccm, upper_transport_pdu_len, upper_transport_pdu_data_in, upper_transport_pdu_data_out, &mesh_upper_transport_validate_segmented_message_ccm, NULL); 47977ba3d3fSMatthias Ringwald } 48077ba3d3fSMatthias Ringwald 481b86620d9SMatthias Ringwald static void mesh_upper_transport_validate_segmented_message(void){ 482160d2809SMatthias Ringwald uint8_t * upper_transport_pdu_data = incoming_access_pdu_decrypted->data; 483160d2809SMatthias Ringwald uint8_t upper_transport_pdu_len = incoming_access_pdu_decrypted->len - incoming_access_pdu_decrypted->transmic_len; 48477ba3d3fSMatthias Ringwald 48577ba3d3fSMatthias Ringwald if (!mesh_transport_key_and_virtual_address_iterator_has_more(&mesh_transport_key_it)){ 48677ba3d3fSMatthias Ringwald printf("No valid transport key found\n"); 4875131e195SMatthias Ringwald mesh_upper_transport_process_access_message_done(incoming_access_pdu_decrypted); 48877ba3d3fSMatthias Ringwald return; 48977ba3d3fSMatthias Ringwald } 49077ba3d3fSMatthias Ringwald mesh_transport_key_and_virtual_address_iterator_next(&mesh_transport_key_it); 49177ba3d3fSMatthias Ringwald const mesh_transport_key_t * message_key = mesh_transport_key_it.key; 49277ba3d3fSMatthias Ringwald 49377ba3d3fSMatthias Ringwald if (message_key->akf){ 494160d2809SMatthias Ringwald transport_segmented_setup_application_nonce(application_nonce, (mesh_pdu_t *) incoming_access_pdu_encrypted); 49577ba3d3fSMatthias Ringwald } else { 496160d2809SMatthias Ringwald transport_segmented_setup_device_nonce(application_nonce, (mesh_pdu_t *) incoming_access_pdu_encrypted); 49777ba3d3fSMatthias Ringwald } 49877ba3d3fSMatthias Ringwald 49977ba3d3fSMatthias Ringwald // store application / device key index 50077ba3d3fSMatthias Ringwald mesh_print_hex("AppOrDevKey", message_key->key, 16); 501160d2809SMatthias Ringwald incoming_access_pdu_decrypted->appkey_index = message_key->appkey_index; 50277ba3d3fSMatthias Ringwald 50377ba3d3fSMatthias Ringwald mesh_print_hex("EncAccessPayload", upper_transport_pdu_data, upper_transport_pdu_len); 50477ba3d3fSMatthias Ringwald 50577ba3d3fSMatthias Ringwald // decrypt ccm 50677ba3d3fSMatthias Ringwald crypto_active = 1; 50777ba3d3fSMatthias Ringwald uint16_t aad_len = 0; 508160d2809SMatthias Ringwald if (mesh_network_address_virtual(mesh_access_dst(incoming_access_pdu_decrypted))){ 50977ba3d3fSMatthias Ringwald aad_len = 16; 51077ba3d3fSMatthias Ringwald } 511160d2809SMatthias Ringwald btstack_crypto_ccm_init(&ccm, message_key->key, application_nonce, upper_transport_pdu_len, aad_len, incoming_access_pdu_decrypted->transmic_len); 51277ba3d3fSMatthias Ringwald 51377ba3d3fSMatthias Ringwald if (aad_len){ 514b86620d9SMatthias Ringwald btstack_crypto_ccm_digest(&ccm, (uint8_t *) mesh_transport_key_it.address->label_uuid, aad_len, &mesh_upper_transport_validate_segmented_message_digest, NULL); 51577ba3d3fSMatthias Ringwald } else { 516b86620d9SMatthias Ringwald mesh_upper_transport_validate_segmented_message_digest(NULL); 51777ba3d3fSMatthias Ringwald } 51877ba3d3fSMatthias Ringwald } 51977ba3d3fSMatthias Ringwald 520425d2391SMatthias Ringwald static void mesh_upper_transport_process_segmented_message(void){ 52177ba3d3fSMatthias Ringwald // copy original pdu 522160d2809SMatthias Ringwald (void)memcpy(incoming_access_pdu_decrypted, incoming_access_pdu_encrypted, 523ba660d42SMatthias Ringwald sizeof(mesh_access_pdu_t)); 52477ba3d3fSMatthias Ringwald 52577ba3d3fSMatthias Ringwald // 526160d2809SMatthias Ringwald uint8_t * upper_transport_pdu = incoming_access_pdu_decrypted->data; 527160d2809SMatthias Ringwald uint8_t upper_transport_pdu_len = incoming_access_pdu_decrypted->len - incoming_access_pdu_decrypted->transmic_len; 52877ba3d3fSMatthias Ringwald mesh_print_hex("Upper Transport pdu", upper_transport_pdu, upper_transport_pdu_len); 52977ba3d3fSMatthias Ringwald 530160d2809SMatthias Ringwald uint8_t aid = incoming_access_pdu_decrypted->akf_aid_control & 0x3f; 531160d2809SMatthias Ringwald uint8_t akf = (incoming_access_pdu_decrypted->akf_aid_control & 0x40) >> 6; 53277ba3d3fSMatthias Ringwald 53377ba3d3fSMatthias Ringwald printf("AKF: %u\n", akf); 53477ba3d3fSMatthias Ringwald printf("AID: %02x\n", aid); 53577ba3d3fSMatthias Ringwald 536160d2809SMatthias Ringwald mesh_transport_key_and_virtual_address_iterator_init(&mesh_transport_key_it, mesh_access_dst(incoming_access_pdu_decrypted), 537160d2809SMatthias Ringwald incoming_access_pdu_decrypted->netkey_index, akf, aid); 538b86620d9SMatthias Ringwald mesh_upper_transport_validate_segmented_message(); 53977ba3d3fSMatthias Ringwald } 54077ba3d3fSMatthias Ringwald 5412983fbcbSMatthias Ringwald static void mesh_upper_transport_message_received(mesh_pdu_t * pdu){ 54277ba3d3fSMatthias Ringwald btstack_linked_list_add_tail(&upper_transport_incoming, (btstack_linked_item_t*) pdu); 5435beab91eSMatthias Ringwald mesh_upper_transport_run(); 54477ba3d3fSMatthias Ringwald } 54577ba3d3fSMatthias Ringwald 54677ba3d3fSMatthias Ringwald static void mesh_upper_transport_send_unsegmented_access_pdu_ccm(void * arg){ 54777ba3d3fSMatthias Ringwald crypto_active = 0; 54877ba3d3fSMatthias Ringwald 549d38a7664SMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_pdu = (mesh_unsegmented_pdu_t *) arg; 550d38a7664SMatthias Ringwald mesh_network_pdu_t * network_pdu = unsegmented_pdu->segment; 55159613427SMatthias Ringwald 55277ba3d3fSMatthias Ringwald uint8_t * upper_transport_pdu = mesh_network_pdu_data(network_pdu) + 1; 55377ba3d3fSMatthias Ringwald uint8_t upper_transport_pdu_len = mesh_network_pdu_len(network_pdu) - 1; 55477ba3d3fSMatthias Ringwald mesh_print_hex("EncAccessPayload", upper_transport_pdu, upper_transport_pdu_len); 55577ba3d3fSMatthias Ringwald // store TransMIC 55677ba3d3fSMatthias Ringwald btstack_crypto_ccm_get_authentication_value(&ccm, &upper_transport_pdu[upper_transport_pdu_len]); 55777ba3d3fSMatthias Ringwald mesh_print_hex("TransMIC", &upper_transport_pdu[upper_transport_pdu_len], 4); 55877ba3d3fSMatthias Ringwald network_pdu->len += 4; 559b16fda24SMatthias Ringwald upper_transport_pdu_len += 4; 560b16fda24SMatthias Ringwald mesh_print_hex("UpperTransportPDU", upper_transport_pdu, upper_transport_pdu_len); 56177ba3d3fSMatthias Ringwald // send network pdu 562d38a7664SMatthias Ringwald mesh_lower_transport_send_pdu((mesh_pdu_t*) unsegmented_pdu); 56377ba3d3fSMatthias Ringwald } 56477ba3d3fSMatthias Ringwald 565b1a7ae8fSMatthias Ringwald static void mesh_upper_transport_send_segmented_pdu(mesh_access_pdu_t * access_pdu){ 566b1a7ae8fSMatthias Ringwald outgoing_segmented_access_pdu = access_pdu; 567a4bbc09dSMatthias Ringwald mesh_segmented_pdu_t * message_pdu = &outgoing_segmented_message_singleton; 568a4bbc09dSMatthias Ringwald message_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_SEGMENTED; 5698fa6125aSMatthias Ringwald 570b1a7ae8fSMatthias Ringwald // convert mesh_access_pdu_t into mesh_segmented_pdu_t 571242605faSMatthias Ringwald mesh_segmented_append_payload(access_pdu->data, access_pdu->len, &message_pdu->segments); 572242605faSMatthias Ringwald 5738fa6125aSMatthias Ringwald // copy meta 574b1a7ae8fSMatthias Ringwald message_pdu->len = access_pdu->len; 575b1a7ae8fSMatthias Ringwald message_pdu->netkey_index = access_pdu->netkey_index; 576b1a7ae8fSMatthias Ringwald message_pdu->transmic_len = access_pdu->transmic_len; 577b1a7ae8fSMatthias Ringwald message_pdu->akf_aid_control = access_pdu->akf_aid_control; 578b1a7ae8fSMatthias Ringwald message_pdu->flags = access_pdu->flags; 579b1a7ae8fSMatthias Ringwald (void)memcpy(message_pdu->network_header, access_pdu->network_header, 9); 5808fa6125aSMatthias Ringwald 5818fa6125aSMatthias Ringwald mesh_lower_transport_send_pdu((mesh_pdu_t*) message_pdu); 58212ba52abSMatthias Ringwald } 58312ba52abSMatthias Ringwald 58477ba3d3fSMatthias Ringwald static void mesh_upper_transport_send_segmented_access_pdu_ccm(void * arg){ 58577ba3d3fSMatthias Ringwald crypto_active = 0; 58677ba3d3fSMatthias Ringwald 587b1a7ae8fSMatthias Ringwald mesh_access_pdu_t * access_pdu = (mesh_access_pdu_t *) arg; 588b1a7ae8fSMatthias Ringwald mesh_print_hex("EncAccessPayload", access_pdu->data, access_pdu->len); 58977ba3d3fSMatthias Ringwald // store TransMIC 590b1a7ae8fSMatthias Ringwald btstack_crypto_ccm_get_authentication_value(&ccm, &access_pdu->data[access_pdu->len]); 591b1a7ae8fSMatthias Ringwald mesh_print_hex("TransMIC", &access_pdu->data[access_pdu->len], access_pdu->transmic_len); 592b1a7ae8fSMatthias Ringwald access_pdu->len += access_pdu->transmic_len; 593b1a7ae8fSMatthias Ringwald mesh_print_hex("UpperTransportPDU", access_pdu->data, access_pdu->len); 594b1a7ae8fSMatthias Ringwald mesh_upper_transport_send_segmented_pdu(access_pdu); 59577ba3d3fSMatthias Ringwald } 59677ba3d3fSMatthias Ringwald 59777ba3d3fSMatthias Ringwald static uint8_t mesh_upper_transport_setup_unsegmented_control_pdu(mesh_network_pdu_t * network_pdu, uint16_t netkey_index, uint8_t ttl, uint16_t src, uint16_t dest, uint8_t opcode, 59877ba3d3fSMatthias Ringwald const uint8_t * control_pdu_data, uint16_t control_pdu_len){ 59977ba3d3fSMatthias Ringwald 60077ba3d3fSMatthias Ringwald if (control_pdu_len > 11) return 1; 60177ba3d3fSMatthias Ringwald 60277ba3d3fSMatthias Ringwald const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index); 60377ba3d3fSMatthias Ringwald if (!network_key) return 1; 60477ba3d3fSMatthias Ringwald 60577ba3d3fSMatthias Ringwald uint8_t transport_pdu_data[12]; 60677ba3d3fSMatthias Ringwald transport_pdu_data[0] = opcode; 6076535961aSMatthias Ringwald (void)memcpy(&transport_pdu_data[1], control_pdu_data, control_pdu_len); 60877ba3d3fSMatthias Ringwald uint16_t transport_pdu_len = control_pdu_len + 1; 60977ba3d3fSMatthias Ringwald 61077ba3d3fSMatthias Ringwald // setup network_pdu 61187e3599cSMatthias Ringwald mesh_network_setup_pdu(network_pdu, netkey_index, network_key->nid, 1, ttl, 0, src, dest, transport_pdu_data, transport_pdu_len); 61277ba3d3fSMatthias Ringwald 61377ba3d3fSMatthias Ringwald return 0; 61477ba3d3fSMatthias Ringwald } 61577ba3d3fSMatthias Ringwald 616ba660d42SMatthias Ringwald #if 0 61777ba3d3fSMatthias Ringwald static uint8_t mesh_upper_transport_setup_segmented_control_pdu(mesh_transport_pdu_t * transport_pdu, uint16_t netkey_index, uint8_t ttl, uint16_t src, uint16_t dest, uint8_t opcode, 61877ba3d3fSMatthias Ringwald const uint8_t * control_pdu_data, uint16_t control_pdu_len){ 61977ba3d3fSMatthias Ringwald 62077ba3d3fSMatthias Ringwald if (control_pdu_len > 256) return 1; 62177ba3d3fSMatthias Ringwald 62277ba3d3fSMatthias Ringwald const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index); 62377ba3d3fSMatthias Ringwald if (!network_key) return 1; 62477ba3d3fSMatthias Ringwald 6256535961aSMatthias Ringwald (void)memcpy(transport_pdu->data, control_pdu_data, control_pdu_len); 62677ba3d3fSMatthias Ringwald transport_pdu->len = control_pdu_len; 62777ba3d3fSMatthias Ringwald transport_pdu->netkey_index = netkey_index; 628e9292fe8SMatthias Ringwald transport_pdu->akf_aid_control = opcode; 62977ba3d3fSMatthias Ringwald transport_pdu->transmic_len = 0; // no TransMIC for control 63077ba3d3fSMatthias Ringwald mesh_transport_set_nid_ivi(transport_pdu, network_key->nid); 63177ba3d3fSMatthias Ringwald mesh_transport_set_src(transport_pdu, src); 63277ba3d3fSMatthias Ringwald mesh_transport_set_dest(transport_pdu, dest); 63377ba3d3fSMatthias Ringwald mesh_transport_set_ctl_ttl(transport_pdu, 0x80 | ttl); 63477ba3d3fSMatthias Ringwald 63577ba3d3fSMatthias Ringwald return 0; 63677ba3d3fSMatthias Ringwald } 637ba660d42SMatthias Ringwald #endif 63877ba3d3fSMatthias Ringwald 63977ba3d3fSMatthias Ringwald uint8_t mesh_upper_transport_setup_control_pdu(mesh_pdu_t * pdu, uint16_t netkey_index, 64077ba3d3fSMatthias Ringwald uint8_t ttl, uint16_t src, uint16_t dest, uint8_t opcode, const uint8_t * control_pdu_data, uint16_t control_pdu_len){ 64177ba3d3fSMatthias Ringwald switch (pdu->pdu_type){ 64277ba3d3fSMatthias Ringwald case MESH_PDU_TYPE_NETWORK: 64377ba3d3fSMatthias Ringwald return mesh_upper_transport_setup_unsegmented_control_pdu((mesh_network_pdu_t *) pdu, netkey_index, ttl, src, dest, opcode, control_pdu_data, control_pdu_len); 64477ba3d3fSMatthias Ringwald default: 645ba660d42SMatthias Ringwald btstack_assert(0); 64677ba3d3fSMatthias Ringwald return 1; 64777ba3d3fSMatthias Ringwald } 64877ba3d3fSMatthias Ringwald } 64977ba3d3fSMatthias Ringwald 650d38a7664SMatthias Ringwald static uint8_t mesh_upper_transport_setup_unsegmented_access_pdu_header(mesh_unsegmented_pdu_t * unsegmented_pdu, uint16_t netkey_index, 65177ba3d3fSMatthias Ringwald uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest){ 65277ba3d3fSMatthias Ringwald 653d38a7664SMatthias Ringwald mesh_network_pdu_t * network_pdu = unsegmented_pdu->segment; 65459613427SMatthias Ringwald 65577ba3d3fSMatthias Ringwald // get app or device key 65677ba3d3fSMatthias Ringwald const mesh_transport_key_t * appkey; 65777ba3d3fSMatthias Ringwald appkey = mesh_transport_key_get(appkey_index); 65877ba3d3fSMatthias Ringwald if (appkey == NULL){ 65977ba3d3fSMatthias Ringwald printf("appkey_index %x unknown\n", appkey_index); 66077ba3d3fSMatthias Ringwald return 1; 66177ba3d3fSMatthias Ringwald } 66277ba3d3fSMatthias Ringwald uint8_t akf_aid = (appkey->akf << 6) | appkey->aid; 66377ba3d3fSMatthias Ringwald 66477ba3d3fSMatthias Ringwald // lookup network by netkey_index 66577ba3d3fSMatthias Ringwald const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index); 66677ba3d3fSMatthias Ringwald if (!network_key) return 1; 66777ba3d3fSMatthias Ringwald 668d38a7664SMatthias Ringwald unsegmented_pdu->appkey_index = appkey_index; 669c2b4731eSMatthias Ringwald 67077ba3d3fSMatthias Ringwald network_pdu->data[9] = akf_aid; 67177ba3d3fSMatthias Ringwald // setup network_pdu 672e41c0017SMatthias Ringwald mesh_network_setup_pdu_header(network_pdu, netkey_index, network_key->nid, 0, ttl, 0, src, dest); 67377ba3d3fSMatthias Ringwald return 0; 67477ba3d3fSMatthias Ringwald } 67577ba3d3fSMatthias Ringwald 676d38a7664SMatthias Ringwald static uint8_t mesh_upper_transport_setup_unsegmented_access_pdu(mesh_unsegmented_pdu_t * unsegmented_pdu, uint16_t netkey_index, uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, 67777ba3d3fSMatthias Ringwald const uint8_t * access_pdu_data, uint8_t access_pdu_len){ 67877ba3d3fSMatthias Ringwald 679d38a7664SMatthias Ringwald int status = mesh_upper_transport_setup_unsegmented_access_pdu_header(unsegmented_pdu, netkey_index, appkey_index, ttl, src, dest); 68077ba3d3fSMatthias Ringwald if (status) return status; 68177ba3d3fSMatthias Ringwald 682d38a7664SMatthias Ringwald // store in unsegmented pdu 683d38a7664SMatthias Ringwald mesh_network_pdu_t * network_pdu = unsegmented_pdu->segment; 6846535961aSMatthias Ringwald (void)memcpy(&network_pdu->data[10], access_pdu_data, access_pdu_len); 68577ba3d3fSMatthias Ringwald network_pdu->len = 10 + access_pdu_len; 68677ba3d3fSMatthias Ringwald return 0; 68777ba3d3fSMatthias Ringwald } 68877ba3d3fSMatthias Ringwald 689b1a7ae8fSMatthias Ringwald static uint8_t mesh_upper_transport_setup_segmented_access_pdu_header(mesh_access_pdu_t * access_pdu, uint16_t netkey_index, 690a332c5a2SMatthias Ringwald uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic){ 69177ba3d3fSMatthias Ringwald 69277ba3d3fSMatthias Ringwald // get app or device key 69377ba3d3fSMatthias Ringwald const mesh_transport_key_t *appkey; 69477ba3d3fSMatthias Ringwald appkey = mesh_transport_key_get(appkey_index); 69577ba3d3fSMatthias Ringwald if (appkey == NULL) { 696a332c5a2SMatthias Ringwald printf("[!] Upper transport, setup segmented Access PDU - appkey_index %x unknown\n", appkey_index); 69777ba3d3fSMatthias Ringwald return 1; 69877ba3d3fSMatthias Ringwald } 69977ba3d3fSMatthias Ringwald uint8_t akf_aid = (appkey->akf << 6) | appkey->aid; 70077ba3d3fSMatthias Ringwald 70177ba3d3fSMatthias Ringwald // lookup network by netkey_index 70277ba3d3fSMatthias Ringwald const mesh_network_key_t *network_key = mesh_network_key_list_get(netkey_index); 70377ba3d3fSMatthias Ringwald if (!network_key) return 1; 704a332c5a2SMatthias Ringwald if (network_key == NULL) { 705a332c5a2SMatthias Ringwald printf("[!] Upper transport, setup segmented Access PDU - netkey_index %x unknown\n", appkey_index); 706a332c5a2SMatthias Ringwald return 1; 707a332c5a2SMatthias Ringwald } 70877ba3d3fSMatthias Ringwald 70977ba3d3fSMatthias Ringwald const uint8_t trans_mic_len = szmic ? 8 : 4; 71077ba3d3fSMatthias Ringwald 71177ba3d3fSMatthias Ringwald // store in transport pdu 712b1a7ae8fSMatthias Ringwald access_pdu->transmic_len = trans_mic_len; 713b1a7ae8fSMatthias Ringwald access_pdu->netkey_index = netkey_index; 714b1a7ae8fSMatthias Ringwald access_pdu->appkey_index = appkey_index; 715b1a7ae8fSMatthias Ringwald access_pdu->akf_aid_control = akf_aid; 716b1a7ae8fSMatthias Ringwald mesh_access_set_nid_ivi(access_pdu, network_key->nid | ((mesh_get_iv_index_for_tx() & 1) << 7)); 717b1a7ae8fSMatthias Ringwald mesh_access_set_src(access_pdu, src); 718b1a7ae8fSMatthias Ringwald mesh_access_set_dest(access_pdu, dest); 719b1a7ae8fSMatthias Ringwald mesh_access_set_ctl_ttl(access_pdu, ttl); 72077ba3d3fSMatthias Ringwald return 0; 72177ba3d3fSMatthias Ringwald } 72277ba3d3fSMatthias Ringwald 723*1b51af65SMatthias Ringwald static uint8_t mesh_upper_transport_setup_upper_access_pdu_header(mesh_upper_transport_pdu_t * upper_pdu, uint16_t netkey_index, 724242605faSMatthias Ringwald uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic){ 725242605faSMatthias Ringwald 726242605faSMatthias Ringwald // get app or device key 727242605faSMatthias Ringwald const mesh_transport_key_t *appkey; 728242605faSMatthias Ringwald appkey = mesh_transport_key_get(appkey_index); 729242605faSMatthias Ringwald if (appkey == NULL) { 730242605faSMatthias Ringwald printf("[!] Upper transport, setup segmented Access PDU - appkey_index %x unknown\n", appkey_index); 731242605faSMatthias Ringwald return 1; 732242605faSMatthias Ringwald } 733242605faSMatthias Ringwald uint8_t akf_aid = (appkey->akf << 6) | appkey->aid; 734242605faSMatthias Ringwald 735242605faSMatthias Ringwald // lookup network by netkey_index 736242605faSMatthias Ringwald const mesh_network_key_t *network_key = mesh_network_key_list_get(netkey_index); 737242605faSMatthias Ringwald if (!network_key) return 1; 738242605faSMatthias Ringwald if (network_key == NULL) { 739242605faSMatthias Ringwald printf("[!] Upper transport, setup segmented Access PDU - netkey_index %x unknown\n", appkey_index); 740242605faSMatthias Ringwald return 1; 741242605faSMatthias Ringwald } 742242605faSMatthias Ringwald 743242605faSMatthias Ringwald const uint8_t trans_mic_len = szmic ? 8 : 4; 744242605faSMatthias Ringwald 745242605faSMatthias Ringwald // store in transport pdu 746242605faSMatthias Ringwald upper_pdu->ivi_nid = network_key->nid | ((mesh_get_iv_index_for_tx() & 1) << 7); 747242605faSMatthias Ringwald upper_pdu->ctl_ttl = ttl; 748242605faSMatthias Ringwald upper_pdu->src = src; 749242605faSMatthias Ringwald upper_pdu->dst = dest; 750242605faSMatthias Ringwald upper_pdu->transmic_len = trans_mic_len; 751242605faSMatthias Ringwald upper_pdu->netkey_index = netkey_index; 752242605faSMatthias Ringwald upper_pdu->appkey_index = appkey_index; 753242605faSMatthias Ringwald upper_pdu->akf_aid_control = akf_aid; 754242605faSMatthias Ringwald return 0; 755242605faSMatthias Ringwald } 75677ba3d3fSMatthias Ringwald 757b1a7ae8fSMatthias Ringwald static uint8_t mesh_upper_transport_setup_segmented_access_pdu(mesh_access_pdu_t * access_pdu, uint16_t netkey_index, uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, 75877ba3d3fSMatthias Ringwald uint8_t szmic, const uint8_t * access_pdu_data, uint8_t access_pdu_len){ 759b1a7ae8fSMatthias Ringwald int status = mesh_upper_transport_setup_segmented_access_pdu_header(access_pdu, netkey_index, appkey_index, ttl, src, dest, szmic); 76077ba3d3fSMatthias Ringwald if (status) return status; 76177ba3d3fSMatthias Ringwald 76277ba3d3fSMatthias Ringwald // store in transport pdu 763b1a7ae8fSMatthias Ringwald (void)memcpy(access_pdu->data, access_pdu_data, access_pdu_len); 764b1a7ae8fSMatthias Ringwald access_pdu->len = access_pdu_len; 76577ba3d3fSMatthias Ringwald return 0; 76677ba3d3fSMatthias Ringwald } 767242605faSMatthias Ringwald 768*1b51af65SMatthias Ringwald static uint8_t mesh_upper_transport_setup_upper_access_pdu(mesh_upper_transport_pdu_t * upper_pdu, uint16_t netkey_index, uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, 769242605faSMatthias Ringwald uint8_t szmic, const uint8_t * access_pdu_data, uint8_t access_pdu_len){ 770*1b51af65SMatthias Ringwald int status = mesh_upper_transport_setup_upper_access_pdu_header(upper_pdu, netkey_index, appkey_index, ttl, src, 771*1b51af65SMatthias Ringwald dest, szmic); 772242605faSMatthias Ringwald if (status) return status; 773242605faSMatthias Ringwald 774242605faSMatthias Ringwald // store in transport pdu 775242605faSMatthias Ringwald uint16_t offset = 0; 776*1b51af65SMatthias Ringwald mesh_segmented_append_payload(access_pdu_data, access_pdu_len, &upper_pdu->segments); 777242605faSMatthias Ringwald upper_pdu->len = access_pdu_len; 778242605faSMatthias Ringwald return 0; 779242605faSMatthias Ringwald } 780242605faSMatthias Ringwald 781242605faSMatthias Ringwald 78277ba3d3fSMatthias Ringwald uint8_t mesh_upper_transport_setup_access_pdu_header(mesh_pdu_t * pdu, uint16_t netkey_index, uint16_t appkey_index, 78377ba3d3fSMatthias Ringwald uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic){ 78477ba3d3fSMatthias Ringwald switch (pdu->pdu_type){ 785b1a7ae8fSMatthias Ringwald case MESH_PDU_TYPE_ACCESS: 786b1a7ae8fSMatthias Ringwald return mesh_upper_transport_setup_segmented_access_pdu_header((mesh_access_pdu_t *) pdu, netkey_index, appkey_index, ttl, src, dest, szmic); 787d38a7664SMatthias Ringwald case MESH_PDU_TYPE_UNSEGMENTED: 788d38a7664SMatthias Ringwald return mesh_upper_transport_setup_unsegmented_access_pdu_header((mesh_unsegmented_pdu_t *) pdu, netkey_index, appkey_index, ttl, src, dest); 78977ba3d3fSMatthias Ringwald default: 790d38a7664SMatthias Ringwald btstack_assert(false); 79177ba3d3fSMatthias Ringwald return 1; 79277ba3d3fSMatthias Ringwald } 79377ba3d3fSMatthias Ringwald } 79477ba3d3fSMatthias Ringwald 79577ba3d3fSMatthias Ringwald uint8_t mesh_upper_transport_setup_access_pdu(mesh_pdu_t * pdu, uint16_t netkey_index, uint16_t appkey_index, 79677ba3d3fSMatthias Ringwald uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic, 79777ba3d3fSMatthias Ringwald const uint8_t * access_pdu_data, uint8_t access_pdu_len){ 79877ba3d3fSMatthias Ringwald switch (pdu->pdu_type){ 799d38a7664SMatthias Ringwald case MESH_PDU_TYPE_UNSEGMENTED: 800d38a7664SMatthias Ringwald return mesh_upper_transport_setup_unsegmented_access_pdu((mesh_unsegmented_pdu_t *) pdu, netkey_index, appkey_index, ttl, src, dest, access_pdu_data, access_pdu_len); 801b1a7ae8fSMatthias Ringwald case MESH_PDU_TYPE_ACCESS: 802b1a7ae8fSMatthias Ringwald return mesh_upper_transport_setup_segmented_access_pdu((mesh_access_pdu_t *) pdu, netkey_index, appkey_index, ttl, src, dest, szmic, access_pdu_data, access_pdu_len); 803242605faSMatthias Ringwald case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS: 804*1b51af65SMatthias Ringwald case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 805*1b51af65SMatthias Ringwald return mesh_upper_transport_setup_upper_access_pdu((mesh_upper_transport_pdu_t *) pdu, netkey_index, 806*1b51af65SMatthias Ringwald appkey_index, ttl, src, dest, szmic, access_pdu_data, 807*1b51af65SMatthias Ringwald access_pdu_len); 80877ba3d3fSMatthias Ringwald default: 809d38a7664SMatthias Ringwald btstack_assert(false); 81077ba3d3fSMatthias Ringwald return 1; 81177ba3d3fSMatthias Ringwald } 81277ba3d3fSMatthias Ringwald } 81377ba3d3fSMatthias Ringwald 81477ba3d3fSMatthias Ringwald static void mesh_upper_transport_send_unsegmented_access_pdu_digest(void * arg){ 815d38a7664SMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_pdu = (mesh_unsegmented_pdu_t *) arg; 816d38a7664SMatthias Ringwald mesh_network_pdu_t * network_pdu = unsegmented_pdu->segment; 81777ba3d3fSMatthias Ringwald uint8_t * access_pdu_data = mesh_network_pdu_data(network_pdu) + 1; 81877ba3d3fSMatthias Ringwald uint16_t access_pdu_len = mesh_network_pdu_len(network_pdu) - 1; 819d38a7664SMatthias Ringwald btstack_crypto_ccm_encrypt_block(&ccm, access_pdu_len, access_pdu_data, access_pdu_data, &mesh_upper_transport_send_unsegmented_access_pdu_ccm, unsegmented_pdu); 82077ba3d3fSMatthias Ringwald } 82177ba3d3fSMatthias Ringwald 8224296b056SMatthias Ringwald static mesh_transport_key_t * mesh_upper_transport_get_outgoing_appkey(uint16_t netkey_index, uint16_t appkey_index){ 8234296b056SMatthias Ringwald // Device Key is fixed 8244296b056SMatthias Ringwald if (appkey_index == MESH_DEVICE_KEY_INDEX) { 8254296b056SMatthias Ringwald return mesh_transport_key_get(appkey_index); 8264296b056SMatthias Ringwald } 8274296b056SMatthias Ringwald 8284296b056SMatthias Ringwald // Get key refresh state from subnet 8294296b056SMatthias Ringwald mesh_subnet_t * subnet = mesh_subnet_get_by_netkey_index(netkey_index); 8304296b056SMatthias Ringwald if (subnet == NULL) return NULL; 8314296b056SMatthias Ringwald 8324296b056SMatthias Ringwald // identify old and new app keys for given appkey_index 8334296b056SMatthias Ringwald mesh_transport_key_t * old_key = NULL; 8344296b056SMatthias Ringwald mesh_transport_key_t * new_key = NULL; 8354296b056SMatthias Ringwald mesh_transport_key_iterator_t it; 8364296b056SMatthias Ringwald mesh_transport_key_iterator_init(&it, netkey_index); 8374296b056SMatthias Ringwald while (mesh_transport_key_iterator_has_more(&it)){ 8384296b056SMatthias Ringwald mesh_transport_key_t * transport_key = mesh_transport_key_iterator_get_next(&it); 8394296b056SMatthias Ringwald if (transport_key->appkey_index != appkey_index) continue; 8404296b056SMatthias Ringwald if (transport_key->old_key == 0) { 8414296b056SMatthias Ringwald new_key = transport_key; 8424296b056SMatthias Ringwald } else { 8434296b056SMatthias Ringwald old_key = transport_key; 8444296b056SMatthias Ringwald } 8454296b056SMatthias Ringwald } 8464296b056SMatthias Ringwald 8474296b056SMatthias Ringwald // if no key is marked as old, just use the current one 8484296b056SMatthias Ringwald if (old_key == NULL) return new_key; 8494296b056SMatthias Ringwald 8504296b056SMatthias Ringwald // use new key if it exists in phase two 8514296b056SMatthias Ringwald if ((subnet->key_refresh == MESH_KEY_REFRESH_SECOND_PHASE) && (new_key != NULL)){ 8524296b056SMatthias Ringwald return new_key; 8534296b056SMatthias Ringwald } else { 8544296b056SMatthias Ringwald return old_key; 8554296b056SMatthias Ringwald } 8564296b056SMatthias Ringwald } 8574296b056SMatthias Ringwald 858d38a7664SMatthias Ringwald static void mesh_upper_transport_send_unsegmented_access_pdu(mesh_unsegmented_pdu_t * unsegmented_pdu){ 85959613427SMatthias Ringwald 860d38a7664SMatthias Ringwald mesh_network_pdu_t * network_pdu = unsegmented_pdu->segment; 86177ba3d3fSMatthias Ringwald 86277ba3d3fSMatthias Ringwald // if dst is virtual address, lookup label uuid and hash 86377ba3d3fSMatthias Ringwald uint16_t aad_len = 0; 86477ba3d3fSMatthias Ringwald mesh_virtual_address_t * virtual_address = NULL; 86577ba3d3fSMatthias Ringwald uint16_t dst = mesh_network_dst(network_pdu); 86677ba3d3fSMatthias Ringwald if (mesh_network_address_virtual(dst)){ 86777ba3d3fSMatthias Ringwald virtual_address = mesh_virtual_address_for_pseudo_dst(dst); 86877ba3d3fSMatthias Ringwald if (!virtual_address){ 86977ba3d3fSMatthias Ringwald printf("No virtual address register for pseudo dst %4x\n", dst); 87077ba3d3fSMatthias Ringwald btstack_memory_mesh_network_pdu_free(network_pdu); 87177ba3d3fSMatthias Ringwald return; 87277ba3d3fSMatthias Ringwald } 87377ba3d3fSMatthias Ringwald aad_len = 16; 87477ba3d3fSMatthias Ringwald big_endian_store_16(network_pdu->data, 7, virtual_address->hash); 87577ba3d3fSMatthias Ringwald } 87677ba3d3fSMatthias Ringwald 877e41c0017SMatthias Ringwald // reserve slot 878e41c0017SMatthias Ringwald mesh_lower_transport_reserve_slot(); 879e41c0017SMatthias Ringwald 880e41c0017SMatthias Ringwald // Nonce for Access Payload based on Network Sequence number: needs to be fixed now and lower layers need to send packet in right order 881e41c0017SMatthias Ringwald uint32_t seq = mesh_sequence_number_next(); 882e41c0017SMatthias Ringwald mesh_network_pdu_set_seq(network_pdu, seq); 883e41c0017SMatthias Ringwald 884e8df83a5SMatthias Ringwald // Dump PDU 885d703e88fSMatthias Ringwald printf("[+] Upper transport, send unsegmented Access PDU - dest %04x, seq %06x\n", dst, mesh_network_seq(network_pdu)); 886e8df83a5SMatthias Ringwald mesh_print_hex("Access Payload", &network_pdu->data[10], network_pdu->len - 10); 887e8df83a5SMatthias Ringwald 88877ba3d3fSMatthias Ringwald // setup nonce 889d38a7664SMatthias Ringwald uint16_t appkey_index = unsegmented_pdu->appkey_index; 89077ba3d3fSMatthias Ringwald if (appkey_index == MESH_DEVICE_KEY_INDEX){ 89177ba3d3fSMatthias Ringwald transport_unsegmented_setup_device_nonce(application_nonce, network_pdu); 89277ba3d3fSMatthias Ringwald } else { 89377ba3d3fSMatthias Ringwald transport_unsegmented_setup_application_nonce(application_nonce, network_pdu); 89477ba3d3fSMatthias Ringwald } 89577ba3d3fSMatthias Ringwald 89677ba3d3fSMatthias Ringwald // get app or device key 8974296b056SMatthias Ringwald const mesh_transport_key_t * appkey = mesh_upper_transport_get_outgoing_appkey(network_pdu->netkey_index, appkey_index); 89877ba3d3fSMatthias Ringwald mesh_print_hex("AppOrDevKey", appkey->key, 16); 89977ba3d3fSMatthias Ringwald 90077ba3d3fSMatthias Ringwald // encrypt ccm 90177ba3d3fSMatthias Ringwald uint8_t trans_mic_len = 4; 90277ba3d3fSMatthias Ringwald uint16_t access_pdu_len = mesh_network_pdu_len(network_pdu) - 1; 90377ba3d3fSMatthias Ringwald crypto_active = 1; 90477ba3d3fSMatthias Ringwald 90577ba3d3fSMatthias Ringwald btstack_crypto_ccm_init(&ccm, appkey->key, application_nonce, access_pdu_len, aad_len, trans_mic_len); 90677ba3d3fSMatthias Ringwald if (virtual_address){ 90777ba3d3fSMatthias Ringwald mesh_print_hex("LabelUUID", virtual_address->label_uuid, 16); 908d38a7664SMatthias Ringwald btstack_crypto_ccm_digest(&ccm, virtual_address->label_uuid, 16, &mesh_upper_transport_send_unsegmented_access_pdu_digest, unsegmented_pdu); 90977ba3d3fSMatthias Ringwald } else { 910d38a7664SMatthias Ringwald mesh_upper_transport_send_unsegmented_access_pdu_digest(unsegmented_pdu); 91177ba3d3fSMatthias Ringwald } 91277ba3d3fSMatthias Ringwald } 91377ba3d3fSMatthias Ringwald 91477ba3d3fSMatthias Ringwald static void mesh_upper_transport_send_segmented_access_pdu_digest(void *arg){ 915b1a7ae8fSMatthias Ringwald mesh_access_pdu_t * access_pdu = (mesh_access_pdu_t *) arg; 916b1a7ae8fSMatthias Ringwald uint16_t access_pdu_len = access_pdu->len; 917b1a7ae8fSMatthias Ringwald uint8_t * access_pdu_data = access_pdu->data; 918b1a7ae8fSMatthias Ringwald btstack_crypto_ccm_encrypt_block(&ccm, access_pdu_len,access_pdu_data, access_pdu_data, &mesh_upper_transport_send_segmented_access_pdu_ccm, access_pdu); 91977ba3d3fSMatthias Ringwald } 92077ba3d3fSMatthias Ringwald 921b1a7ae8fSMatthias Ringwald static void mesh_upper_transport_send_segmented_access_pdu(mesh_access_pdu_t * access_pdu){ 92277ba3d3fSMatthias Ringwald 92377ba3d3fSMatthias Ringwald // if dst is virtual address, lookup label uuid and hash 92477ba3d3fSMatthias Ringwald uint16_t aad_len = 0; 92577ba3d3fSMatthias Ringwald mesh_virtual_address_t * virtual_address = NULL; 926b1a7ae8fSMatthias Ringwald uint16_t dst = mesh_access_dst(access_pdu); 92777ba3d3fSMatthias Ringwald if (mesh_network_address_virtual(dst)){ 92877ba3d3fSMatthias Ringwald virtual_address = mesh_virtual_address_for_pseudo_dst(dst); 92977ba3d3fSMatthias Ringwald if (!virtual_address){ 93077ba3d3fSMatthias Ringwald printf("No virtual address register for pseudo dst %4x\n", dst); 931b1a7ae8fSMatthias Ringwald mesh_access_message_handler(MESH_TRANSPORT_PDU_SENT, MESH_TRANSPORT_STATUS_SEND_FAILED, (mesh_pdu_t *) access_pdu); 93277ba3d3fSMatthias Ringwald return; 93377ba3d3fSMatthias Ringwald } 93477ba3d3fSMatthias Ringwald // printf("Using hash %4x with LabelUUID: ", virtual_address->hash); 93577ba3d3fSMatthias Ringwald // printf_hexdump(virtual_address->label_uuid, 16); 93677ba3d3fSMatthias Ringwald aad_len = 16; 937b1a7ae8fSMatthias Ringwald big_endian_store_16(access_pdu->network_header, 7, virtual_address->hash); 93877ba3d3fSMatthias Ringwald } 93977ba3d3fSMatthias Ringwald 94034b15033SMatthias Ringwald // get app or device key 941b1a7ae8fSMatthias Ringwald uint16_t appkey_index = access_pdu->appkey_index; 942b1a7ae8fSMatthias Ringwald const mesh_transport_key_t * appkey = mesh_upper_transport_get_outgoing_appkey(access_pdu->netkey_index, appkey_index); 94334b15033SMatthias Ringwald if (appkey == NULL){ 94434b15033SMatthias Ringwald printf("AppKey %04x not found, drop message\n", appkey_index); 945b1a7ae8fSMatthias Ringwald mesh_access_message_handler(MESH_TRANSPORT_PDU_SENT, MESH_TRANSPORT_STATUS_SEND_FAILED, (mesh_pdu_t *) access_pdu); 94634b15033SMatthias Ringwald return; 94734b15033SMatthias Ringwald } 94834b15033SMatthias Ringwald 94910cd83b4SMatthias Ringwald // reserve slot 95010cd83b4SMatthias Ringwald mesh_lower_transport_reserve_slot(); 95110cd83b4SMatthias Ringwald 952e41c0017SMatthias Ringwald // reserve one sequence number, which is also used to encrypt access payload 953e41c0017SMatthias Ringwald uint32_t seq = mesh_sequence_number_next(); 954b1a7ae8fSMatthias Ringwald access_pdu->flags |= MESH_TRANSPORT_FLAG_SEQ_RESERVED; 955b1a7ae8fSMatthias Ringwald mesh_access_set_seq(access_pdu, seq); 956e41c0017SMatthias Ringwald 957e8df83a5SMatthias Ringwald // Dump PDU 958b1a7ae8fSMatthias Ringwald printf("[+] Upper transport, send segmented Access PDU - dest %04x, seq %06x\n", dst, mesh_access_seq(access_pdu)); 959b1a7ae8fSMatthias Ringwald mesh_print_hex("Access Payload", access_pdu->data, access_pdu->len); 960e8df83a5SMatthias Ringwald 96177ba3d3fSMatthias Ringwald // setup nonce - uses dst, so after pseudo address translation 96277ba3d3fSMatthias Ringwald if (appkey_index == MESH_DEVICE_KEY_INDEX){ 963b1a7ae8fSMatthias Ringwald transport_segmented_setup_device_nonce(application_nonce, (mesh_pdu_t *) access_pdu); 96477ba3d3fSMatthias Ringwald } else { 965b1a7ae8fSMatthias Ringwald transport_segmented_setup_application_nonce(application_nonce, (mesh_pdu_t *) access_pdu); 96677ba3d3fSMatthias Ringwald } 96777ba3d3fSMatthias Ringwald 96834b15033SMatthias Ringwald // Dump key 96977ba3d3fSMatthias Ringwald mesh_print_hex("AppOrDevKey", appkey->key, 16); 97077ba3d3fSMatthias Ringwald 97177ba3d3fSMatthias Ringwald // encrypt ccm 972b1a7ae8fSMatthias Ringwald uint8_t transmic_len = access_pdu->transmic_len; 973b1a7ae8fSMatthias Ringwald uint16_t access_pdu_len = access_pdu->len; 97477ba3d3fSMatthias Ringwald crypto_active = 1; 97577ba3d3fSMatthias Ringwald btstack_crypto_ccm_init(&ccm, appkey->key, application_nonce, access_pdu_len, aad_len, transmic_len); 97677ba3d3fSMatthias Ringwald if (virtual_address){ 97777ba3d3fSMatthias Ringwald mesh_print_hex("LabelUUID", virtual_address->label_uuid, 16); 978b1a7ae8fSMatthias Ringwald btstack_crypto_ccm_digest(&ccm, virtual_address->label_uuid, 16, &mesh_upper_transport_send_segmented_access_pdu_digest, access_pdu); 97977ba3d3fSMatthias Ringwald } else { 980b1a7ae8fSMatthias Ringwald mesh_upper_transport_send_segmented_access_pdu_digest(access_pdu); 98177ba3d3fSMatthias Ringwald } 98277ba3d3fSMatthias Ringwald } 98377ba3d3fSMatthias Ringwald 984242605faSMatthias Ringwald static void mesh_upper_transport_send_upper_segmented_pdu(mesh_upper_transport_pdu_t * upper_pdu){ 985242605faSMatthias Ringwald 986242605faSMatthias Ringwald // TODO: store upper pdu in outgoing pdus active or similar 987*1b51af65SMatthias Ringwald outgoing_upper_transport_pdu = upper_pdu; 988242605faSMatthias Ringwald 989242605faSMatthias Ringwald mesh_segmented_pdu_t * message_pdu = &outgoing_segmented_message_singleton; 990242605faSMatthias Ringwald message_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_SEGMENTED; 991242605faSMatthias Ringwald 992242605faSMatthias Ringwald // convert mesh_access_pdu_t into mesh_segmented_pdu_t 993242605faSMatthias Ringwald mesh_segmented_append_payload(crypto_buffer, upper_pdu->len, &message_pdu->segments); 994242605faSMatthias Ringwald 995242605faSMatthias Ringwald // copy meta 996242605faSMatthias Ringwald message_pdu->len = upper_pdu->len; 997242605faSMatthias Ringwald message_pdu->netkey_index = upper_pdu->netkey_index; 998242605faSMatthias Ringwald message_pdu->transmic_len = upper_pdu->transmic_len; 999242605faSMatthias Ringwald message_pdu->akf_aid_control = upper_pdu->akf_aid_control; 1000242605faSMatthias Ringwald message_pdu->flags = upper_pdu->flags; 1001242605faSMatthias Ringwald 1002242605faSMatthias Ringwald // setup message_pdu header 1003242605faSMatthias Ringwald // (void)memcpy(message_pdu->network_header, upper_pdu->network_header, 9); 1004242605faSMatthias Ringwald // TODO: use fields in mesh_segmented_pdu_t and setup network header in lower transport 1005242605faSMatthias Ringwald message_pdu->network_header[0] = upper_pdu->ivi_nid; 1006242605faSMatthias Ringwald message_pdu->network_header[1] = upper_pdu->ctl_ttl; 1007242605faSMatthias Ringwald big_endian_store_24(message_pdu->network_header, 2, upper_pdu->seq); 1008242605faSMatthias Ringwald big_endian_store_16(message_pdu->network_header, 5, upper_pdu->src); 1009242605faSMatthias Ringwald big_endian_store_16(message_pdu->network_header, 7, upper_pdu->dst); 1010242605faSMatthias Ringwald 1011242605faSMatthias Ringwald mesh_lower_transport_send_pdu((mesh_pdu_t*) message_pdu); 1012242605faSMatthias Ringwald } 1013242605faSMatthias Ringwald 1014*1b51af65SMatthias Ringwald static void mesh_upper_transport_send_upper_unsegmented_pdu(mesh_upper_transport_pdu_t * upper_pdu){ 1015*1b51af65SMatthias Ringwald 1016*1b51af65SMatthias Ringwald // TODO: store upper pdu in outgoing pdus active or similar 1017*1b51af65SMatthias Ringwald outgoing_upper_transport_pdu = upper_pdu; 1018*1b51af65SMatthias Ringwald 1019*1b51af65SMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_pdu = &outgoing_unsegmented_pdu_singleton; 1020*1b51af65SMatthias Ringwald unsegmented_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_UNSEGMENTED; 1021*1b51af65SMatthias Ringwald 1022*1b51af65SMatthias Ringwald // provide segment 1023*1b51af65SMatthias Ringwald mesh_network_pdu_t * network_pdu = mesh_network_pdu_get(); 1024*1b51af65SMatthias Ringwald btstack_assert(network_pdu); 1025*1b51af65SMatthias Ringwald unsegmented_pdu->segment = network_pdu; 1026*1b51af65SMatthias Ringwald 1027*1b51af65SMatthias Ringwald // setup network pdu 1028*1b51af65SMatthias Ringwald network_pdu->data[0] = upper_pdu->ivi_nid; 1029*1b51af65SMatthias Ringwald network_pdu->data[1] = upper_pdu->ctl_ttl; 1030*1b51af65SMatthias Ringwald big_endian_store_24(network_pdu->data, 2, upper_pdu->seq); 1031*1b51af65SMatthias Ringwald big_endian_store_16(network_pdu->data, 5, upper_pdu->src); 1032*1b51af65SMatthias Ringwald big_endian_store_16(network_pdu->data, 7, upper_pdu->dst); 1033*1b51af65SMatthias Ringwald network_pdu->netkey_index = upper_pdu->netkey_index; 1034*1b51af65SMatthias Ringwald 1035*1b51af65SMatthias Ringwald // setup acess message 1036*1b51af65SMatthias Ringwald network_pdu->data[9] = upper_pdu->akf_aid_control; 1037*1b51af65SMatthias Ringwald btstack_assert(upper_pdu->len < 15); 1038*1b51af65SMatthias Ringwald (void)memcpy(&network_pdu->data[10], crypto_buffer, upper_pdu->len); 1039*1b51af65SMatthias Ringwald network_pdu->len = 10 + upper_pdu->len; 1040*1b51af65SMatthias Ringwald network_pdu->flags = 0; 1041*1b51af65SMatthias Ringwald 1042*1b51af65SMatthias Ringwald mesh_lower_transport_send_pdu((mesh_pdu_t*) unsegmented_pdu); 1043*1b51af65SMatthias Ringwald } 1044*1b51af65SMatthias Ringwald 1045242605faSMatthias Ringwald static void mesh_upper_transport_send_upper_segmented_access_pdu_ccm(void * arg){ 1046242605faSMatthias Ringwald crypto_active = 0; 1047242605faSMatthias Ringwald 1048242605faSMatthias Ringwald mesh_upper_transport_pdu_t * upper_pdu = (mesh_upper_transport_pdu_t *) arg; 1049242605faSMatthias Ringwald mesh_print_hex("EncAccessPayload", crypto_buffer, upper_pdu->len); 1050242605faSMatthias Ringwald // store TransMIC 1051242605faSMatthias Ringwald btstack_crypto_ccm_get_authentication_value(&ccm, &crypto_buffer[upper_pdu->len]); 1052242605faSMatthias Ringwald mesh_print_hex("TransMIC", &crypto_buffer[upper_pdu->len], upper_pdu->transmic_len); 1053242605faSMatthias Ringwald upper_pdu->len += upper_pdu->transmic_len; 1054242605faSMatthias Ringwald mesh_print_hex("UpperTransportPDU", crypto_buffer, upper_pdu->len); 1055*1b51af65SMatthias Ringwald switch (upper_pdu->pdu_header.pdu_type){ 1056*1b51af65SMatthias Ringwald case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 1057*1b51af65SMatthias Ringwald mesh_upper_transport_send_upper_unsegmented_pdu(upper_pdu); 1058*1b51af65SMatthias Ringwald break; 1059*1b51af65SMatthias Ringwald case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS: 1060242605faSMatthias Ringwald mesh_upper_transport_send_upper_segmented_pdu(upper_pdu); 1061*1b51af65SMatthias Ringwald break; 1062*1b51af65SMatthias Ringwald default: 1063*1b51af65SMatthias Ringwald btstack_assert(false); 1064*1b51af65SMatthias Ringwald } 1065242605faSMatthias Ringwald } 1066242605faSMatthias Ringwald 1067242605faSMatthias Ringwald static void mesh_upper_transport_send_upper_segmented_access_pdu_digest(void *arg){ 1068242605faSMatthias Ringwald mesh_upper_transport_pdu_t * upper_pdu = (mesh_upper_transport_pdu_t *) arg; 1069242605faSMatthias Ringwald uint16_t access_pdu_len = upper_pdu->len; 1070242605faSMatthias Ringwald btstack_crypto_ccm_encrypt_block(&ccm, access_pdu_len, crypto_buffer, crypto_buffer, &mesh_upper_transport_send_upper_segmented_access_pdu_ccm, upper_pdu); 1071242605faSMatthias Ringwald } 1072242605faSMatthias Ringwald 1073242605faSMatthias Ringwald static void mesh_upper_transport_send_upper_segmented_access_pdu(mesh_upper_transport_pdu_t * upper_pdu){ 1074242605faSMatthias Ringwald 1075242605faSMatthias Ringwald // if dst is virtual address, lookup label uuid and hash 1076242605faSMatthias Ringwald uint16_t aad_len = 0; 1077242605faSMatthias Ringwald mesh_virtual_address_t * virtual_address = NULL; 1078242605faSMatthias Ringwald if (mesh_network_address_virtual(upper_pdu->dst)){ 1079242605faSMatthias Ringwald virtual_address = mesh_virtual_address_for_pseudo_dst(upper_pdu->dst); 1080242605faSMatthias Ringwald if (!virtual_address){ 1081242605faSMatthias Ringwald printf("No virtual address register for pseudo dst %4x\n", upper_pdu->dst); 1082242605faSMatthias Ringwald mesh_access_message_handler(MESH_TRANSPORT_PDU_SENT, MESH_TRANSPORT_STATUS_SEND_FAILED, (mesh_pdu_t *) upper_pdu); 1083242605faSMatthias Ringwald return; 1084242605faSMatthias Ringwald } 1085242605faSMatthias Ringwald // printf("Using hash %4x with LabelUUID: ", virtual_address->hash); 1086242605faSMatthias Ringwald // printf_hexdump(virtual_address->label_uuid, 16); 1087242605faSMatthias Ringwald aad_len = 16; 1088242605faSMatthias Ringwald upper_pdu->dst = virtual_address->hash; 1089242605faSMatthias Ringwald } 1090242605faSMatthias Ringwald 1091242605faSMatthias Ringwald // get app or device key 1092242605faSMatthias Ringwald uint16_t appkey_index = upper_pdu->appkey_index; 1093242605faSMatthias Ringwald const mesh_transport_key_t * appkey = mesh_upper_transport_get_outgoing_appkey(upper_pdu->netkey_index, appkey_index); 1094242605faSMatthias Ringwald if (appkey == NULL){ 1095242605faSMatthias Ringwald printf("AppKey %04x not found, drop message\n", appkey_index); 1096242605faSMatthias Ringwald mesh_access_message_handler(MESH_TRANSPORT_PDU_SENT, MESH_TRANSPORT_STATUS_SEND_FAILED, (mesh_pdu_t *) upper_pdu); 1097242605faSMatthias Ringwald return; 1098242605faSMatthias Ringwald } 1099242605faSMatthias Ringwald 1100242605faSMatthias Ringwald // reserve slot 1101242605faSMatthias Ringwald mesh_lower_transport_reserve_slot(); 1102242605faSMatthias Ringwald 1103242605faSMatthias Ringwald // reserve one sequence number, which is also used to encrypt access payload 1104242605faSMatthias Ringwald uint32_t seq = mesh_sequence_number_next(); 1105242605faSMatthias Ringwald upper_pdu->flags |= MESH_TRANSPORT_FLAG_SEQ_RESERVED; 1106242605faSMatthias Ringwald upper_pdu->seq = seq; 1107242605faSMatthias Ringwald 1108242605faSMatthias Ringwald // also reserves crypto_buffer 1109242605faSMatthias Ringwald crypto_active = 1; 1110242605faSMatthias Ringwald 1111242605faSMatthias Ringwald // flatten segmented pdu into crypto buffer 1112242605faSMatthias Ringwald uint16_t payload_len = mesh_upper_pdu_flatten(upper_pdu, crypto_buffer, sizeof(crypto_buffer)); 1113242605faSMatthias Ringwald btstack_assert(payload_len == upper_pdu->len); 1114242605faSMatthias Ringwald 1115242605faSMatthias Ringwald // Dump PDU 1116*1b51af65SMatthias Ringwald printf("[+] Upper transport, send upper (un)segmented Access PDU - dest %04x, seq %06x\n", upper_pdu->dst, upper_pdu->seq); 1117242605faSMatthias Ringwald mesh_print_hex("Access Payload", crypto_buffer, upper_pdu->len); 1118242605faSMatthias Ringwald 1119242605faSMatthias Ringwald // setup nonce - uses dst, so after pseudo address translation 1120242605faSMatthias Ringwald if (appkey_index == MESH_DEVICE_KEY_INDEX){ 1121242605faSMatthias Ringwald transport_segmented_setup_device_nonce(application_nonce, (mesh_pdu_t *) upper_pdu); 1122242605faSMatthias Ringwald } else { 1123242605faSMatthias Ringwald transport_segmented_setup_application_nonce(application_nonce, (mesh_pdu_t *) upper_pdu); 1124242605faSMatthias Ringwald } 1125242605faSMatthias Ringwald 1126242605faSMatthias Ringwald // Dump key 1127242605faSMatthias Ringwald mesh_print_hex("AppOrDevKey", appkey->key, 16); 1128242605faSMatthias Ringwald 1129242605faSMatthias Ringwald // encrypt ccm 1130242605faSMatthias Ringwald uint8_t transmic_len = upper_pdu->transmic_len; 1131242605faSMatthias Ringwald uint16_t access_pdu_len = upper_pdu->len; 1132242605faSMatthias Ringwald btstack_crypto_ccm_init(&ccm, appkey->key, application_nonce, access_pdu_len, aad_len, transmic_len); 1133242605faSMatthias Ringwald if (virtual_address){ 1134242605faSMatthias Ringwald mesh_print_hex("LabelUUID", virtual_address->label_uuid, 16); 1135242605faSMatthias Ringwald btstack_crypto_ccm_digest(&ccm, virtual_address->label_uuid, 16, &mesh_upper_transport_send_upper_segmented_access_pdu_digest, upper_pdu); 1136242605faSMatthias Ringwald } else { 1137242605faSMatthias Ringwald mesh_upper_transport_send_upper_segmented_access_pdu_digest(upper_pdu); 1138242605faSMatthias Ringwald } 1139242605faSMatthias Ringwald } 1140242605faSMatthias Ringwald 1141e41c0017SMatthias Ringwald static void mesh_upper_transport_send_unsegmented_control_pdu(mesh_network_pdu_t * network_pdu){ 1142e41c0017SMatthias Ringwald // reserve slot 1143e41c0017SMatthias Ringwald mesh_lower_transport_reserve_slot(); 1144e41c0017SMatthias Ringwald // reserve sequence number 1145e41c0017SMatthias Ringwald uint32_t seq = mesh_sequence_number_next(); 1146e41c0017SMatthias Ringwald mesh_network_pdu_set_seq(network_pdu, seq); 1147e8df83a5SMatthias Ringwald // Dump PDU 1148e8df83a5SMatthias Ringwald uint8_t opcode = network_pdu->data[9]; 1149e8df83a5SMatthias Ringwald printf("[+] Upper transport, send unsegmented Control PDU %p - seq %06x opcode %02x\n", network_pdu, seq, opcode); 1150e8df83a5SMatthias Ringwald mesh_print_hex("Access Payload", &network_pdu->data[10], network_pdu->len - 10); 1151b837963cSMatthias Ringwald // wrap into mesh-unsegmented-pdu 1152*1b51af65SMatthias Ringwald outgoing_unsegmented_pdu_singleton.pdu_header.pdu_type = MESH_PDU_TYPE_UNSEGMENTED; 1153*1b51af65SMatthias Ringwald outgoing_unsegmented_pdu_singleton.segment = network_pdu; 1154*1b51af65SMatthias Ringwald outgoing_unsegmented_pdu_singleton.flags = MESH_TRANSPORT_FLAG_CONTROL; 1155b837963cSMatthias Ringwald 1156e41c0017SMatthias Ringwald // send 1157*1b51af65SMatthias Ringwald mesh_lower_transport_send_pdu((mesh_pdu_t *) &outgoing_unsegmented_pdu_singleton); 1158e41c0017SMatthias Ringwald } 1159e41c0017SMatthias Ringwald 1160ba660d42SMatthias Ringwald #if 0 1161e41c0017SMatthias Ringwald static void mesh_upper_transport_send_segmented_control_pdu(mesh_transport_pdu_t * transport_pdu){ 1162e41c0017SMatthias Ringwald // reserve slot 1163e41c0017SMatthias Ringwald mesh_lower_transport_reserve_slot(); 1164e41c0017SMatthias Ringwald // reserve sequence number 1165e41c0017SMatthias Ringwald uint32_t seq = mesh_sequence_number_next(); 1166e41c0017SMatthias Ringwald transport_pdu->flags |= MESH_TRANSPORT_FLAG_SEQ_RESERVED; 1167e41c0017SMatthias Ringwald mesh_transport_set_seq(transport_pdu, seq); 1168e8df83a5SMatthias Ringwald // Dump PDU 1169e8df83a5SMatthias Ringwald uint8_t opcode = transport_pdu->data[0]; 1170e8df83a5SMatthias Ringwald printf("[+] Upper transport, send segmented Control PDU %p - seq %06x opcode %02x\n", transport_pdu, seq, opcode); 1171e8df83a5SMatthias Ringwald mesh_print_hex("Access Payload", &transport_pdu->data[1], transport_pdu->len - 1); 1172e41c0017SMatthias Ringwald // send 1173b1a7ae8fSMatthias Ringwald btstack_assert(false); 1174b1a7ae8fSMatthias Ringwald // mesh_upper_transport_send_segmented_pdu(transport_pdu); 1175e41c0017SMatthias Ringwald } 1176ba660d42SMatthias Ringwald #endif 1177e41c0017SMatthias Ringwald 11785beab91eSMatthias Ringwald static void mesh_upper_transport_run(void){ 1179d19dd9d7SMatthias Ringwald 118077ba3d3fSMatthias Ringwald while(!btstack_linked_list_empty(&upper_transport_incoming)){ 118177ba3d3fSMatthias Ringwald 118277ba3d3fSMatthias Ringwald if (crypto_active) return; 118377ba3d3fSMatthias Ringwald 11845131e195SMatthias Ringwald // get next message 11855131e195SMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t *) btstack_linked_list_pop(&upper_transport_incoming); 118677ba3d3fSMatthias Ringwald mesh_network_pdu_t * network_pdu; 1187a4bbc09dSMatthias Ringwald mesh_segmented_pdu_t * message_pdu; 11888facb3eaSMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_pdu; 118977ba3d3fSMatthias Ringwald switch (pdu->pdu_type){ 11908facb3eaSMatthias Ringwald case MESH_PDU_TYPE_UNSEGMENTED: 11918facb3eaSMatthias Ringwald unsegmented_pdu = (mesh_unsegmented_pdu_t *) pdu; 119284011563SMatthias Ringwald network_pdu = unsegmented_pdu->segment; 11932ae11e2cSMatthias Ringwald btstack_assert(network_pdu != NULL); 11942ae11e2cSMatthias Ringwald // control? 11952ae11e2cSMatthias Ringwald if (mesh_network_control(network_pdu)) { 11965131e195SMatthias Ringwald 11975131e195SMatthias Ringwald incoming_control_pdu = &incoming_control_pdu_singleton; 11985131e195SMatthias Ringwald incoming_control_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_CONTROL; 11995131e195SMatthias Ringwald incoming_control_pdu->len = network_pdu->len; 12005131e195SMatthias Ringwald incoming_control_pdu->netkey_index = network_pdu->netkey_index; 12015131e195SMatthias Ringwald 12025131e195SMatthias Ringwald uint8_t * lower_transport_pdu = mesh_network_pdu_data(network_pdu); 12035131e195SMatthias Ringwald 12045131e195SMatthias Ringwald incoming_control_pdu->akf_aid_control = lower_transport_pdu[0]; 12055131e195SMatthias Ringwald incoming_control_pdu->len = network_pdu->len - 10; // 9 header + 1 opcode 12065131e195SMatthias Ringwald (void)memcpy(incoming_control_pdu->data, &lower_transport_pdu[1], incoming_control_pdu->len); 12075131e195SMatthias Ringwald 12085131e195SMatthias Ringwald // copy meta data into encrypted pdu buffer 12095131e195SMatthias Ringwald (void)memcpy(incoming_control_pdu->network_header, network_pdu->data, 9); 12105131e195SMatthias Ringwald 12115131e195SMatthias Ringwald mesh_print_hex("Assembled payload", incoming_control_pdu->data, incoming_control_pdu->len); 12125131e195SMatthias Ringwald 12135131e195SMatthias Ringwald // free mesh message 12145131e195SMatthias Ringwald mesh_lower_transport_message_processed_by_higher_layer(pdu); 12155131e195SMatthias Ringwald 12165131e195SMatthias Ringwald btstack_assert(mesh_control_message_handler != NULL); 12175131e195SMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_control_pdu; 12185131e195SMatthias Ringwald mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu); 12195131e195SMatthias Ringwald 12202ae11e2cSMatthias Ringwald } else { 1221aaa248aaSMatthias Ringwald 1222552f5710SMatthias Ringwald incoming_access_pdu_encrypted = &incoming_access_pdu_encrypted_singleton; 1223552f5710SMatthias Ringwald incoming_access_pdu_encrypted->pdu_header.pdu_type = MESH_PDU_TYPE_ACCESS; 1224552f5710SMatthias Ringwald incoming_access_pdu_decrypted = &incoming_access_pdu_decrypted_singleton; 1225552f5710SMatthias Ringwald 1226552f5710SMatthias Ringwald incoming_access_pdu_encrypted->netkey_index = network_pdu->netkey_index; 1227552f5710SMatthias Ringwald incoming_access_pdu_encrypted->transmic_len = 4; 1228552f5710SMatthias Ringwald 1229552f5710SMatthias Ringwald uint8_t * lower_transport_pdu = mesh_network_pdu_data(network_pdu); 1230552f5710SMatthias Ringwald 1231552f5710SMatthias Ringwald incoming_access_pdu_encrypted->akf_aid_control = lower_transport_pdu[0]; 1232552f5710SMatthias Ringwald incoming_access_pdu_encrypted->len = network_pdu->len - 10; // 9 header + 1 AID 1233552f5710SMatthias Ringwald (void)memcpy(incoming_access_pdu_encrypted->data, &lower_transport_pdu[1], incoming_access_pdu_encrypted->len); 1234552f5710SMatthias Ringwald 1235552f5710SMatthias Ringwald // copy meta data into encrypted pdu buffer 1236552f5710SMatthias Ringwald (void)memcpy(incoming_access_pdu_encrypted->network_header, network_pdu->data, 9); 1237552f5710SMatthias Ringwald 1238552f5710SMatthias Ringwald mesh_print_hex("Assembled payload", incoming_access_pdu_encrypted->data, incoming_access_pdu_encrypted->len); 1239552f5710SMatthias Ringwald 1240552f5710SMatthias Ringwald // free mesh message 1241552f5710SMatthias Ringwald mesh_lower_transport_message_processed_by_higher_layer(pdu); 1242552f5710SMatthias Ringwald 1243552f5710SMatthias Ringwald // get encoded transport pdu and start processing 1244552f5710SMatthias Ringwald mesh_upper_transport_process_segmented_message(); 124577ba3d3fSMatthias Ringwald } 124677ba3d3fSMatthias Ringwald break; 1247a4bbc09dSMatthias Ringwald case MESH_PDU_TYPE_SEGMENTED: 1248a4bbc09dSMatthias Ringwald message_pdu = (mesh_segmented_pdu_t *) pdu; 12492a974a69SMatthias Ringwald uint8_t ctl = mesh_message_ctl(message_pdu); 125077ba3d3fSMatthias Ringwald if (ctl){ 125125b07254SMatthias Ringwald incoming_control_pdu= &incoming_control_pdu_singleton; 125225b07254SMatthias Ringwald incoming_control_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_CONTROL; 125325b07254SMatthias Ringwald 1254df3fbfcbSMatthias Ringwald // flatten 1255df3fbfcbSMatthias Ringwald mesh_segmented_pdu_flatten(&message_pdu->segments, 8, incoming_control_pdu->data); 125625b07254SMatthias Ringwald 125725b07254SMatthias Ringwald // copy meta data into encrypted pdu buffer 125825b07254SMatthias Ringwald incoming_control_pdu->len = message_pdu->len; 125925b07254SMatthias Ringwald incoming_control_pdu->netkey_index = message_pdu->netkey_index; 126025b07254SMatthias Ringwald incoming_control_pdu->akf_aid_control = message_pdu->akf_aid_control; 126125b07254SMatthias Ringwald incoming_control_pdu->flags = 0; 126225b07254SMatthias Ringwald (void)memcpy(incoming_control_pdu->network_header, message_pdu->network_header, 9); 126325b07254SMatthias Ringwald 126425b07254SMatthias Ringwald mesh_print_hex("Assembled payload", incoming_control_pdu->data, incoming_control_pdu->len); 126525b07254SMatthias Ringwald 126625b07254SMatthias Ringwald // free mesh message 126725b07254SMatthias Ringwald mesh_lower_transport_message_processed_by_higher_layer((mesh_pdu_t *)message_pdu); 126825b07254SMatthias Ringwald 126925b07254SMatthias Ringwald btstack_assert(mesh_control_message_handler != NULL); 127025b07254SMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_control_pdu; 127125b07254SMatthias Ringwald mesh_access_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu); 127225b07254SMatthias Ringwald 127377ba3d3fSMatthias Ringwald } else { 12742a974a69SMatthias Ringwald 1275160d2809SMatthias Ringwald incoming_access_pdu_encrypted = &incoming_access_pdu_encrypted_singleton; 1276160d2809SMatthias Ringwald incoming_access_pdu_encrypted->pdu_header.pdu_type = MESH_PDU_TYPE_ACCESS; 1277425d2391SMatthias Ringwald incoming_access_pdu_decrypted = &incoming_access_pdu_decrypted_singleton; 12782a974a69SMatthias Ringwald 1279df3fbfcbSMatthias Ringwald // flatten 1280df3fbfcbSMatthias Ringwald mesh_segmented_pdu_flatten(&message_pdu->segments, 12, incoming_access_pdu_encrypted->data); 12817667b5d1SMatthias Ringwald 12827667b5d1SMatthias Ringwald // copy meta data into encrypted pdu buffer 1283160d2809SMatthias Ringwald incoming_access_pdu_encrypted->len = message_pdu->len; 1284160d2809SMatthias Ringwald incoming_access_pdu_encrypted->netkey_index = message_pdu->netkey_index; 1285160d2809SMatthias Ringwald incoming_access_pdu_encrypted->transmic_len = message_pdu->transmic_len; 1286160d2809SMatthias Ringwald incoming_access_pdu_encrypted->akf_aid_control = message_pdu->akf_aid_control; 1287160d2809SMatthias Ringwald (void)memcpy(incoming_access_pdu_encrypted->network_header, message_pdu->network_header, 9); 12887667b5d1SMatthias Ringwald 1289160d2809SMatthias Ringwald mesh_print_hex("Assembled payload", incoming_access_pdu_encrypted->data, incoming_access_pdu_encrypted->len); 12907667b5d1SMatthias Ringwald 12912a974a69SMatthias Ringwald // free mesh message 12922a974a69SMatthias Ringwald mesh_lower_transport_message_processed_by_higher_layer((mesh_pdu_t *)message_pdu); 12932a974a69SMatthias Ringwald 129477ba3d3fSMatthias Ringwald // get encoded transport pdu and start processing 1295425d2391SMatthias Ringwald mesh_upper_transport_process_segmented_message(); 129677ba3d3fSMatthias Ringwald } 129777ba3d3fSMatthias Ringwald break; 129877ba3d3fSMatthias Ringwald default: 12993d9c3b8eSMatthias Ringwald btstack_assert(0); 130077ba3d3fSMatthias Ringwald break; 130177ba3d3fSMatthias Ringwald } 130277ba3d3fSMatthias Ringwald } 13035beab91eSMatthias Ringwald 13045beab91eSMatthias Ringwald while (!btstack_linked_list_empty(&upper_transport_outgoing)){ 13055beab91eSMatthias Ringwald 130610cd83b4SMatthias Ringwald if (crypto_active) break; 13075beab91eSMatthias Ringwald 1308b1a7ae8fSMatthias Ringwald if (outgoing_segmented_access_pdu != NULL) break; 1309536fc383SMatthias Ringwald 1310d19dd9d7SMatthias Ringwald mesh_pdu_t * pdu = (mesh_pdu_t *) btstack_linked_list_get_first_item(&upper_transport_outgoing); 131110cd83b4SMatthias Ringwald if (mesh_lower_transport_can_send_to_dest(mesh_pdu_dst(pdu)) == 0) break; 131210cd83b4SMatthias Ringwald 1313d19dd9d7SMatthias Ringwald (void) btstack_linked_list_pop(&upper_transport_outgoing); 1314d19dd9d7SMatthias Ringwald 13157a0b7488SMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_pdu; 13167a0b7488SMatthias Ringwald 1317e41c0017SMatthias Ringwald switch (pdu->pdu_type){ 1318e41c0017SMatthias Ringwald case MESH_PDU_TYPE_NETWORK: 13197a0b7488SMatthias Ringwald btstack_assert(mesh_pdu_ctl(pdu) != 0); 1320e41c0017SMatthias Ringwald mesh_upper_transport_send_unsegmented_control_pdu((mesh_network_pdu_t *) pdu); 1321e41c0017SMatthias Ringwald break; 1322d38a7664SMatthias Ringwald case MESH_PDU_TYPE_UNSEGMENTED: 13237a0b7488SMatthias Ringwald unsegmented_pdu = ( mesh_unsegmented_pdu_t *) pdu; 13247a0b7488SMatthias Ringwald btstack_assert((unsegmented_pdu->flags & MESH_TRANSPORT_FLAG_CONTROL) == 0); 13257a0b7488SMatthias Ringwald mesh_upper_transport_send_unsegmented_access_pdu(unsegmented_pdu); 13265beab91eSMatthias Ringwald break; 1327b1a7ae8fSMatthias Ringwald case MESH_PDU_TYPE_ACCESS: 1328b1a7ae8fSMatthias Ringwald if (mesh_pdu_ctl(pdu) != 0){ 1329b1a7ae8fSMatthias Ringwald btstack_assert(false); 1330b1a7ae8fSMatthias Ringwald } else { 1331b1a7ae8fSMatthias Ringwald mesh_upper_transport_send_segmented_access_pdu((mesh_access_pdu_t *) pdu); 13327a0b7488SMatthias Ringwald } 13335beab91eSMatthias Ringwald break; 1334242605faSMatthias Ringwald case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS: 1335*1b51af65SMatthias Ringwald case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 1336242605faSMatthias Ringwald mesh_upper_transport_send_upper_segmented_access_pdu((mesh_upper_transport_pdu_t *) pdu); 1337242605faSMatthias Ringwald break; 13385beab91eSMatthias Ringwald default: 13397a0b7488SMatthias Ringwald btstack_assert(false); 13405beab91eSMatthias Ringwald break; 13415beab91eSMatthias Ringwald } 13425beab91eSMatthias Ringwald } 13435beab91eSMatthias Ringwald } 13445beab91eSMatthias Ringwald 1345404d2482SMatthias Ringwald 1346404d2482SMatthias Ringwald 1347404d2482SMatthias Ringwald static void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){ 13487a0b7488SMatthias Ringwald mesh_pdu_t * pdu_to_report; 13497a0b7488SMatthias Ringwald mesh_unsegmented_pdu_t * unsegmented_pdu; 1350404d2482SMatthias Ringwald switch (callback_type){ 1351404d2482SMatthias Ringwald case MESH_TRANSPORT_PDU_RECEIVED: 1352404d2482SMatthias Ringwald mesh_upper_transport_message_received(pdu); 1353404d2482SMatthias Ringwald break; 1354404d2482SMatthias Ringwald case MESH_TRANSPORT_PDU_SENT: 1355404d2482SMatthias Ringwald switch (pdu->pdu_type){ 1356404d2482SMatthias Ringwald case MESH_PDU_TYPE_SEGMENTED: 1357404d2482SMatthias Ringwald // free chunks 1358404d2482SMatthias Ringwald while (!btstack_linked_list_empty(&outgoing_segmented_message_singleton.segments)){ 1359404d2482SMatthias Ringwald mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&outgoing_segmented_message_singleton.segments); 1360404d2482SMatthias Ringwald mesh_network_pdu_free(network_pdu); 1361404d2482SMatthias Ringwald } 1362404d2482SMatthias Ringwald // notify upper layer but use transport pdu 1363b1a7ae8fSMatthias Ringwald pdu_to_report = (mesh_pdu_t *) outgoing_segmented_access_pdu; 1364b1a7ae8fSMatthias Ringwald outgoing_segmented_access_pdu = NULL; 13657a0b7488SMatthias Ringwald if (mesh_pdu_ctl(pdu_to_report)){ 13667a0b7488SMatthias Ringwald mesh_control_message_handler(callback_type, status, pdu_to_report); 1367404d2482SMatthias Ringwald } else { 13687a0b7488SMatthias Ringwald mesh_access_message_handler(callback_type, status, pdu_to_report); 1369404d2482SMatthias Ringwald } 1370404d2482SMatthias Ringwald break; 1371404d2482SMatthias Ringwald case MESH_PDU_TYPE_UNSEGMENTED: 13727a0b7488SMatthias Ringwald unsegmented_pdu = (mesh_unsegmented_pdu_t *) pdu; 1373*1b51af65SMatthias Ringwald if (unsegmented_pdu == &outgoing_unsegmented_pdu_singleton){ 1374*1b51af65SMatthias Ringwald if ((unsegmented_pdu->flags & MESH_TRANSPORT_FLAG_CONTROL) == 0){ 13757a0b7488SMatthias Ringwald // notify upper layer but use network pdu (control pdu) 1376*1b51af65SMatthias Ringwald mesh_network_pdu_t * network_pdu = outgoing_unsegmented_pdu_singleton.segment; 1377*1b51af65SMatthias Ringwald outgoing_unsegmented_pdu_singleton.segment = NULL; 13787a0b7488SMatthias Ringwald mesh_control_message_handler(callback_type, status, (mesh_pdu_t *) network_pdu); 1379404d2482SMatthias Ringwald } else { 1380*1b51af65SMatthias Ringwald // notify upper layer but use upper access pdu 1381*1b51af65SMatthias Ringwald mesh_network_pdu_t * network_pdu = outgoing_unsegmented_pdu_singleton.segment; 1382*1b51af65SMatthias Ringwald outgoing_unsegmented_pdu_singleton.segment = NULL; 1383*1b51af65SMatthias Ringwald mesh_network_pdu_free(network_pdu); 1384*1b51af65SMatthias Ringwald pdu_to_report = (mesh_pdu_t *) outgoing_upper_transport_pdu; 1385*1b51af65SMatthias Ringwald mesh_access_message_handler(callback_type, status, pdu_to_report); 1386*1b51af65SMatthias Ringwald } 1387*1b51af65SMatthias Ringwald } else { 13887a0b7488SMatthias Ringwald btstack_assert((unsegmented_pdu->flags & MESH_TRANSPORT_FLAG_CONTROL) == 0); 13897a0b7488SMatthias Ringwald mesh_access_message_handler(callback_type, status, pdu); 1390404d2482SMatthias Ringwald } 1391404d2482SMatthias Ringwald break; 1392404d2482SMatthias Ringwald default: 1393404d2482SMatthias Ringwald btstack_assert(false); 1394404d2482SMatthias Ringwald break; 1395404d2482SMatthias Ringwald } 1396404d2482SMatthias Ringwald mesh_upper_transport_run(); 1397404d2482SMatthias Ringwald break; 1398404d2482SMatthias Ringwald default: 1399404d2482SMatthias Ringwald break; 1400404d2482SMatthias Ringwald } 1401404d2482SMatthias Ringwald } 1402404d2482SMatthias Ringwald 1403cae44b3bSMatthias Ringwald void mesh_upper_transport_pdu_free(mesh_pdu_t * pdu){ 1404cae44b3bSMatthias Ringwald mesh_network_pdu_t * network_pdu; 1405a4bbc09dSMatthias Ringwald mesh_segmented_pdu_t * message_pdu; 1406cae44b3bSMatthias Ringwald switch (pdu->pdu_type) { 1407cae44b3bSMatthias Ringwald case MESH_PDU_TYPE_NETWORK: 1408cae44b3bSMatthias Ringwald network_pdu = (mesh_network_pdu_t *) pdu; 1409cae44b3bSMatthias Ringwald mesh_network_pdu_free(network_pdu); 1410cae44b3bSMatthias Ringwald break; 1411a4bbc09dSMatthias Ringwald case MESH_PDU_TYPE_SEGMENTED: 1412a4bbc09dSMatthias Ringwald message_pdu = (mesh_segmented_pdu_t *) pdu; 1413cae44b3bSMatthias Ringwald mesh_message_pdu_free(message_pdu); 1414cae44b3bSMatthias Ringwald default: 1415ba660d42SMatthias Ringwald btstack_assert(false); 1416cae44b3bSMatthias Ringwald break; 1417cae44b3bSMatthias Ringwald } 1418cae44b3bSMatthias Ringwald } 1419cae44b3bSMatthias Ringwald 1420cae44b3bSMatthias Ringwald void mesh_upper_transport_message_processed_by_higher_layer(mesh_pdu_t * pdu){ 1421cae44b3bSMatthias Ringwald crypto_active = 0; 1422cae44b3bSMatthias Ringwald switch (pdu->pdu_type){ 1423160d2809SMatthias Ringwald case MESH_PDU_TYPE_ACCESS: 14245131e195SMatthias Ringwald mesh_upper_transport_process_access_message_done((mesh_access_pdu_t *) pdu); 14255131e195SMatthias Ringwald case MESH_PDU_TYPE_CONTROL: 14265131e195SMatthias Ringwald mesh_upper_transport_process_control_message_done((mesh_control_pdu_t *) pdu); 14273d9c3b8eSMatthias Ringwald break; 1428cae44b3bSMatthias Ringwald default: 14293d9c3b8eSMatthias Ringwald btstack_assert(0); 1430cae44b3bSMatthias Ringwald break; 1431cae44b3bSMatthias Ringwald } 1432cae44b3bSMatthias Ringwald } 1433cae44b3bSMatthias Ringwald 1434404d2482SMatthias Ringwald void mesh_upper_transport_register_access_message_handler(void (*callback)(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu)) { 14355beab91eSMatthias Ringwald mesh_access_message_handler = callback; 14365beab91eSMatthias Ringwald } 14375beab91eSMatthias Ringwald 1438404d2482SMatthias Ringwald void mesh_upper_transport_register_control_message_handler(void (*callback)(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu)){ 14395beab91eSMatthias Ringwald mesh_control_message_handler = callback; 14405beab91eSMatthias Ringwald } 14415beab91eSMatthias Ringwald 14425beab91eSMatthias Ringwald void mesh_upper_transport_init(){ 14435beab91eSMatthias Ringwald mesh_lower_transport_set_higher_layer_handler(&mesh_upper_transport_pdu_handler); 14445beab91eSMatthias Ringwald } 1445