xref: /btstack/src/mesh/mesh_upper_transport.c (revision 1b51af657a454a2dc920c9c6d282dd1eaf10ab47)
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