1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN 24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #define BTSTACK_FILE__ "mesh_lower_transport.c" 39 40 #include <inttypes.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 45 #include "btstack_memory.h" 46 #include "btstack_util.h" 47 #include "btstack_bool.h" 48 #include "btstack_debug.h" 49 50 #include "mesh/beacon.h" 51 #include "mesh/mesh_iv_index_seq_number.h" 52 #include "mesh/mesh_lower_transport.h" 53 #include "mesh/mesh_node.h" 54 #include "mesh/mesh_peer.h" 55 56 #define LOG_LOWER_TRANSPORT 57 58 // prototypes 59 static void mesh_lower_transport_run(void); 60 static void mesh_lower_transport_outgoing_complete(mesh_segmented_pdu_t * segmented_pdu, mesh_transport_status_t status); 61 static void mesh_lower_transport_outgoing_segment_transmission_timeout(btstack_timer_source_t * ts); 62 63 64 // lower transport outgoing state 65 66 // queued mesh_segmented_pdu_t or mesh_network_pdu_t 67 static btstack_linked_list_t lower_transport_outgoing_ready; 68 69 // mesh_segmented_pdu_t to unicast address, segment transmission timer is active 70 static btstack_linked_list_t lower_transport_outgoing_waiting; 71 72 // active outgoing segmented message 73 static mesh_segmented_pdu_t * lower_transport_outgoing_message; 74 // index of outgoing segment 75 static uint16_t lower_transport_outgoing_seg_o; 76 // network pdu with outgoing segment 77 static mesh_network_pdu_t * lower_transport_outgoing_segment; 78 // segment currently queued at network layer (only valid for lower_transport_outgoing_message) 79 static bool lower_transport_outgoing_segment_at_network_layer; 80 // transmission timeout occurred (while outgoing segment queued at network layer) 81 static bool lower_transport_outgoing_transmission_timeout; 82 // transmission completed fully ack'ed (while outgoing segment queued at network layer) 83 static bool lower_transport_outgoing_transmission_complete; 84 // transmission aborted by remote (while outgoing segment queued at network layer) 85 static bool lower_transport_outgoing_transmission_aborted; 86 87 // active outgoing unsegmented message 88 static mesh_network_pdu_t * lower_transport_outgoing_network_pdu; 89 90 // deliver to higher layer 91 static void (*higher_layer_handler)( mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu); 92 static mesh_pdu_t * mesh_lower_transport_higher_layer_pdu; 93 static btstack_linked_list_t mesh_lower_transport_queued_for_higher_layer; 94 95 static void mesh_print_hex(const char * name, const uint8_t * data, uint16_t len){ 96 printf("%-20s ", name); 97 printf_hexdump(data, len); 98 } 99 100 // utility 101 102 mesh_segmented_pdu_t * mesh_segmented_pdu_get(void){ 103 mesh_segmented_pdu_t * message_pdu = btstack_memory_mesh_segmented_pdu_get(); 104 if (message_pdu){ 105 message_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_SEGMENTED; 106 } 107 return message_pdu; 108 } 109 110 void mesh_segmented_pdu_free(mesh_segmented_pdu_t * message_pdu){ 111 while (message_pdu->segments){ 112 mesh_network_pdu_t * segment = (mesh_network_pdu_t *) btstack_linked_list_pop(&message_pdu->segments); 113 mesh_network_pdu_free(segment); 114 } 115 btstack_memory_mesh_segmented_pdu_free(message_pdu); 116 } 117 118 // INCOMING // 119 120 static void mesh_lower_transport_incoming_deliver_to_higher_layer(void){ 121 if (mesh_lower_transport_higher_layer_pdu == NULL && !btstack_linked_list_empty(&mesh_lower_transport_queued_for_higher_layer)){ 122 mesh_pdu_t * pdu = (mesh_pdu_t *) btstack_linked_list_pop(&mesh_lower_transport_queued_for_higher_layer); 123 124 switch (pdu->pdu_type){ 125 case MESH_PDU_TYPE_NETWORK: 126 // unsegmented pdu 127 mesh_lower_transport_higher_layer_pdu = (mesh_pdu_t *) pdu; 128 pdu->pdu_type = MESH_PDU_TYPE_UNSEGMENTED; 129 break; 130 case MESH_PDU_TYPE_SEGMENTED: 131 // segmented control or access pdu 132 mesh_lower_transport_higher_layer_pdu = pdu; 133 break; 134 default: 135 btstack_assert(false); 136 break; 137 } 138 higher_layer_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, mesh_lower_transport_higher_layer_pdu); 139 } 140 } 141 142 static void mesh_lower_transport_incoming_queue_for_higher_layer(mesh_pdu_t * pdu){ 143 btstack_linked_list_add_tail(&mesh_lower_transport_queued_for_higher_layer, (btstack_linked_item_t *) pdu); 144 mesh_lower_transport_incoming_deliver_to_higher_layer(); 145 } 146 147 static void mesh_lower_transport_incoming_setup_acknowledge_message(uint8_t * data, uint8_t obo, uint16_t seq_zero, uint32_t block_ack){ 148 // printf("ACK Upper Transport, seq_zero %x\n", seq_zero); 149 data[0] = 0; // SEG = 0, Opcode = 0 150 big_endian_store_16( data, 1, (obo << 15) | (seq_zero << 2) | 0); // OBO, SeqZero, RFU 151 big_endian_store_32( data, 3, block_ack); 152 #ifdef LOG_LOWER_TRANSPORT 153 mesh_print_hex("ACK Upper Transport", data, 7); 154 #endif 155 } 156 157 static void mesh_lower_transport_incoming_send_ack(uint16_t netkey_index, uint8_t ttl, uint16_t dest, uint16_t seq_zero, uint32_t block_ack){ 158 // setup ack message 159 uint8_t ack_msg[7]; 160 mesh_lower_transport_incoming_setup_acknowledge_message(ack_msg, 0, seq_zero, block_ack); 161 // 162 // "3.4.5.2: The output filter of the interface connected to advertising or GATT bearers shall drop all messages with TTL value set to 1." 163 // if (ttl <= 1) return 0; 164 165 // TODO: check transport_pdu_len depending on ctl 166 167 // lookup network by netkey_index 168 const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index); 169 if (!network_key) return; 170 171 // allocate network_pdu 172 mesh_network_pdu_t * network_pdu = mesh_network_pdu_get(); 173 if (!network_pdu) return; 174 175 // setup network_pdu 176 network_pdu->pdu_header.pdu_type = MESH_PDU_TYPE_SEGMENT_ACKNOWLEDGMENT; 177 mesh_network_setup_pdu(network_pdu, netkey_index, network_key->nid, 1, ttl, mesh_sequence_number_next(), mesh_node_get_primary_element_address(), dest, ack_msg, sizeof(ack_msg)); 178 179 // send network_pdu 180 mesh_network_send_pdu(network_pdu); 181 } 182 183 static void mesh_lower_transport_incoming_send_ack_for_segmented_pdu(mesh_segmented_pdu_t * segmented_pdu){ 184 uint16_t seq_zero = segmented_pdu->seq & 0x1fff; 185 uint8_t ttl = segmented_pdu->ctl_ttl & 0x7f; 186 uint16_t dest = segmented_pdu->src; 187 uint16_t netkey_index = segmented_pdu->netkey_index; 188 #ifdef LOG_LOWER_TRANSPORT 189 printf("mesh_transport_send_ack_for_transport_pdu %p with netkey_index %x, TTL = %u, SeqZero = %x, SRC = %x, DST = %x\n", 190 segmented_pdu, netkey_index, ttl, seq_zero, mesh_node_get_primary_element_address(), dest); 191 #endif 192 mesh_lower_transport_incoming_send_ack(netkey_index, ttl, dest, seq_zero, segmented_pdu->block_ack); 193 } 194 195 static void mesh_lower_transport_incoming_send_ack_for_network_pdu(mesh_network_pdu_t *network_pdu, uint16_t seq_zero, uint32_t block_ack) { 196 uint8_t ttl = mesh_network_ttl(network_pdu); 197 uint16_t dest = mesh_network_src(network_pdu); 198 uint16_t netkey_index = network_pdu->netkey_index; 199 #ifdef LOG_LOWER_TRANSPORT 200 printf("mesh_transport_send_ack_for_network_pdu %p with netkey_index %x, TTL = %u, SeqZero = %x, SRC = %x, DST = %x\n", 201 network_pdu, netkey_index, ttl, seq_zero, mesh_node_get_primary_element_address(), dest); 202 #endif 203 mesh_lower_transport_incoming_send_ack(netkey_index, ttl, dest, seq_zero, block_ack); 204 } 205 206 static void mesh_lower_transport_incoming_stop_acknowledgment_timer(mesh_segmented_pdu_t *segmented_pdu){ 207 if ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_ACK_TIMER) == 0) return; 208 segmented_pdu->flags &= ~MESH_TRANSPORT_FLAG_ACK_TIMER; 209 btstack_run_loop_remove_timer(&segmented_pdu->acknowledgement_timer); 210 } 211 212 static void mesh_lower_transport_incoming_stop_incomplete_timer(mesh_segmented_pdu_t *segmented_pdu){ 213 if ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_INCOMPLETE_TIMER) == 0) return; 214 segmented_pdu->flags &= ~MESH_TRANSPORT_FLAG_INCOMPLETE_TIMER; 215 btstack_run_loop_remove_timer(&segmented_pdu->incomplete_timer); 216 } 217 218 static void mesh_lower_transport_incoming_segmented_message_complete(mesh_segmented_pdu_t * segmented_pdu){ 219 // stop timers 220 mesh_lower_transport_incoming_stop_acknowledgment_timer(segmented_pdu); 221 mesh_lower_transport_incoming_stop_incomplete_timer(segmented_pdu); 222 // stop reassembly 223 mesh_peer_t * peer = mesh_peer_for_addr(segmented_pdu->src); 224 if (peer){ 225 peer->message_pdu = NULL; 226 } 227 } 228 229 static void mesh_lower_transport_incoming_ack_timeout(btstack_timer_source_t *ts){ 230 mesh_segmented_pdu_t * segmented_pdu = (mesh_segmented_pdu_t *) btstack_run_loop_get_timer_context(ts); 231 #ifdef LOG_LOWER_TRANSPORT 232 printf("ACK: acknowledgement timer fired for %p, send ACK\n", segmented_pdu); 233 #endif 234 segmented_pdu->flags &= ~MESH_TRANSPORT_FLAG_ACK_TIMER; 235 mesh_lower_transport_incoming_send_ack_for_segmented_pdu(segmented_pdu); 236 } 237 238 static void mesh_lower_transport_incoming_incomplete_timeout(btstack_timer_source_t *ts){ 239 mesh_segmented_pdu_t * segmented_pdu = (mesh_segmented_pdu_t *) btstack_run_loop_get_timer_context(ts); 240 #ifdef LOG_LOWER_TRANSPORT 241 printf("mesh_lower_transport_incoming_incomplete_timeout for %p - give up\n", segmented_pdu); 242 #endif 243 mesh_lower_transport_incoming_segmented_message_complete(segmented_pdu); 244 // free message 245 mesh_segmented_pdu_free(segmented_pdu); 246 } 247 248 static void mesh_lower_transport_incoming_start_acknowledgment_timer(mesh_segmented_pdu_t * segmented_pdu, uint32_t timeout){ 249 #ifdef LOG_LOWER_TRANSPORT 250 printf("ACK: start rx ack timer for %p, timeout %u ms\n", segmented_pdu, (int) timeout); 251 #endif 252 btstack_run_loop_set_timer(&segmented_pdu->acknowledgement_timer, timeout); 253 btstack_run_loop_set_timer_handler(&segmented_pdu->acknowledgement_timer, &mesh_lower_transport_incoming_ack_timeout); 254 btstack_run_loop_set_timer_context(&segmented_pdu->acknowledgement_timer, segmented_pdu); 255 btstack_run_loop_add_timer(&segmented_pdu->acknowledgement_timer); 256 segmented_pdu->flags |= MESH_TRANSPORT_FLAG_ACK_TIMER; 257 } 258 259 static void mesh_lower_transport_incoming_restart_incomplete_timer(mesh_segmented_pdu_t * segmented_pdu, uint32_t timeout, 260 void (*callback)(btstack_timer_source_t *ts)){ 261 #ifdef LOG_LOWER_TRANSPORT 262 printf("RX-(re)start incomplete timer for %p, timeout %u ms\n", segmented_pdu, (int) timeout); 263 #endif 264 if ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_INCOMPLETE_TIMER) != 0){ 265 btstack_run_loop_remove_timer(&segmented_pdu->incomplete_timer); 266 } 267 btstack_run_loop_set_timer(&segmented_pdu->incomplete_timer, timeout); 268 btstack_run_loop_set_timer_handler(&segmented_pdu->incomplete_timer, callback); 269 btstack_run_loop_set_timer_context(&segmented_pdu->incomplete_timer, segmented_pdu); 270 btstack_run_loop_add_timer(&segmented_pdu->incomplete_timer); 271 segmented_pdu->flags |= MESH_TRANSPORT_FLAG_INCOMPLETE_TIMER; 272 } 273 274 static mesh_segmented_pdu_t * mesh_lower_transport_incoming_pdu_for_segmented_message(mesh_network_pdu_t *network_pdu){ 275 uint16_t src = mesh_network_src(network_pdu); 276 uint16_t seq_zero = ( big_endian_read_16(mesh_network_pdu_data(network_pdu), 1) >> 2) & 0x1fff; 277 #ifdef LOG_LOWER_TRANSPORT 278 printf("mesh_transport_pdu_for_segmented_message: seq_zero %x\n", seq_zero); 279 #endif 280 mesh_peer_t * peer = mesh_peer_for_addr(src); 281 if (!peer) { 282 return NULL; 283 } 284 #ifdef LOG_LOWER_TRANSPORT 285 printf("mesh_seq_zero_validate(%x, %x) -- last (%x, %x)\n", src, seq_zero, peer->address, peer->seq_zero); 286 #endif 287 288 // reception of transport message ongoing 289 if (peer->message_pdu){ 290 // check if segment for same seq zero 291 uint16_t active_seq_zero = peer->message_pdu->seq & 0x1fff; 292 if (active_seq_zero == seq_zero) { 293 #ifdef LOG_LOWER_TRANSPORT 294 printf("mesh_transport_pdu_for_segmented_message: segment for current transport pdu with SeqZero %x\n", active_seq_zero); 295 #endif 296 return peer->message_pdu; 297 } else { 298 // seq zero differs from current transport pdu, but current pdu is not complete 299 #ifdef LOG_LOWER_TRANSPORT 300 printf("mesh_transport_pdu_for_segmented_message: drop segment. current transport pdu SeqZero %x, now %x\n", active_seq_zero, seq_zero); 301 #endif 302 return NULL; 303 } 304 } 305 306 // send ACK if segment for previously completed transport pdu (no ongoing reception, block ack is cleared) 307 if ((seq_zero == peer->seq_zero) && (peer->block_ack != 0)){ 308 #ifdef LOG_LOWER_TRANSPORT 309 printf("mesh_transport_pdu_for_segmented_message: segment for last completed message. send ack\n"); 310 #endif 311 mesh_lower_transport_incoming_send_ack_for_network_pdu(network_pdu, seq_zero, peer->block_ack); 312 return NULL; 313 } 314 315 // reconstruct lowest 24 bit of SeqAuth 316 uint32_t seq = mesh_network_seq(network_pdu); 317 uint32_t seq_auth = (seq & 0xffe000) | seq_zero; 318 if (seq_auth > seq){ 319 seq_auth -= 0x2000; 320 } 321 322 // no transport pdu active, check new message: seq auth is greater OR seq auth is same but no segments 323 if (seq_auth > peer->seq_auth || (seq_auth == peer->seq_auth && peer->block_ack == 0)){ 324 mesh_segmented_pdu_t * pdu = mesh_segmented_pdu_get(); 325 if (!pdu) return NULL; 326 327 // cache network pdu header 328 pdu->ivi_nid = network_pdu->data[0]; 329 pdu->ctl_ttl = network_pdu->data[1]; 330 pdu->src = big_endian_read_16(network_pdu->data, 5); 331 pdu->dst = big_endian_read_16(network_pdu->data, 7); 332 // store lower 24 bit of SeqAuth for App / Device Nonce 333 pdu->seq = seq_auth; 334 335 // get akf_aid & transmic 336 pdu->akf_aid_control = network_pdu->data[9] & 0x7f; 337 if ((network_pdu->data[10] & 0x80) != 0){ 338 pdu->flags |= MESH_TRANSPORT_FLAG_TRANSMIC_64; 339 } 340 341 // store meta data in new pdu 342 pdu->netkey_index = network_pdu->netkey_index; 343 pdu->block_ack = 0; 344 pdu->flags &= ~MESH_TRANSPORT_FLAG_ACK_TIMER; 345 346 // update peer info 347 peer->message_pdu = pdu; 348 peer->seq_zero = seq_zero; 349 peer->seq_auth = seq_auth; 350 peer->block_ack = 0; 351 352 #ifdef LOG_LOWER_TRANSPORT 353 printf("mesh_transport_pdu_for_segmented_message: setup transport pdu %p for src %x, seq %06" PRIx32 ", seq_zero %x\n", pdu, src, 354 pdu->seq, seq_zero); 355 #endif 356 return peer->message_pdu; 357 } else { 358 // seq zero differs from current transport pdu 359 #ifdef LOG_LOWER_TRANSPORT 360 printf("mesh_transport_pdu_for_segmented_message: drop segment for old seq %x\n", seq_zero); 361 #endif 362 return NULL; 363 } 364 } 365 366 static void mesh_lower_transport_incoming_process_segment(mesh_segmented_pdu_t * message_pdu, mesh_network_pdu_t * network_pdu){ 367 368 uint8_t * lower_transport_pdu = mesh_network_pdu_data(network_pdu); 369 uint8_t lower_transport_pdu_len = mesh_network_pdu_len(network_pdu); 370 371 // get seq_zero 372 uint16_t seq_zero = ( big_endian_read_16(lower_transport_pdu, 1) >> 2) & 0x1fff; 373 374 // get seg fields 375 uint8_t seg_o = ( big_endian_read_16(lower_transport_pdu, 2) >> 5) & 0x001f; 376 uint8_t seg_n = lower_transport_pdu[3] & 0x1f; 377 uint8_t segment_len = lower_transport_pdu_len - 4; 378 uint8_t * segment_data = &lower_transport_pdu[4]; 379 380 #ifdef LOG_LOWER_TRANSPORT 381 uint8_t transmic_len = ((message_pdu->flags & MESH_TRANSPORT_FLAG_TRANSMIC_64) != 0) ? 64 : 32; 382 printf("mesh_lower_transport_incoming_process_segment: seq zero %04x, seg_o %02x, seg_n %02x, transmic len: %u bit\n", seq_zero, seg_o, seg_n, transmic_len); 383 mesh_print_hex("Segment", segment_data, segment_len); 384 #endif 385 386 // drop if already stored 387 if ((message_pdu->block_ack & (1<<seg_o)) != 0){ 388 mesh_network_message_processed_by_higher_layer(network_pdu); 389 return; 390 } 391 392 // mark as received 393 message_pdu->block_ack |= (1<<seg_o); 394 395 // store segment 396 uint8_t max_segment_len = mesh_network_control(network_pdu) ? 8 : 12; 397 mesh_network_pdu_t * latest_segment = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&message_pdu->segments); 398 if ((latest_segment != NULL) && ((MESH_NETWORK_PAYLOAD_MAX - latest_segment->len) > (max_segment_len + 1))){ 399 // store in last added segment if there is enough space available 400 latest_segment->data[latest_segment->len++] = seg_o; 401 (void) memcpy(&latest_segment->data[latest_segment->len], &lower_transport_pdu[4], segment_len); 402 latest_segment->len += segment_len; 403 // free buffer 404 mesh_network_message_processed_by_higher_layer(network_pdu); 405 } else { 406 // move to beginning 407 network_pdu->data[0] = seg_o; 408 uint8_t i; 409 for (i=0;i<segment_len;i++){ 410 network_pdu->data[1+i] = network_pdu->data[13+i]; 411 } 412 network_pdu->len = 1 + segment_len; 413 // add this buffer 414 btstack_linked_list_add(&message_pdu->segments, (btstack_linked_item_t *) network_pdu); 415 } 416 417 // last segment -> store len 418 if (seg_o == seg_n){ 419 message_pdu->len = (seg_n * max_segment_len) + segment_len; 420 #ifdef LOG_LOWER_TRANSPORT 421 printf("Assembled payload len %u\n", message_pdu->len); 422 #endif 423 } 424 425 // check for complete 426 int i; 427 for (i=0;i<=seg_n;i++){ 428 if ( (message_pdu->block_ack & (1<<i)) == 0) return; 429 } 430 431 // store block ack in peer info 432 mesh_peer_t * peer = mesh_peer_for_addr(message_pdu->src); 433 // TODO: check if NULL check can be removed 434 if (peer){ 435 peer->block_ack = message_pdu->block_ack; 436 } 437 438 // send ack 439 mesh_lower_transport_incoming_send_ack_for_segmented_pdu(message_pdu); 440 441 // forward to upper transport 442 mesh_lower_transport_incoming_queue_for_higher_layer((mesh_pdu_t *) message_pdu); 443 444 // mark as done 445 mesh_lower_transport_incoming_segmented_message_complete(message_pdu); 446 } 447 448 void mesh_lower_transport_message_processed_by_higher_layer(mesh_pdu_t * pdu){ 449 btstack_assert(pdu == mesh_lower_transport_higher_layer_pdu); 450 mesh_lower_transport_higher_layer_pdu = NULL; 451 mesh_network_pdu_t * network_pdu; 452 switch (pdu->pdu_type){ 453 case MESH_PDU_TYPE_SEGMENTED: 454 // free segments 455 mesh_segmented_pdu_free((mesh_segmented_pdu_t *) pdu); 456 break; 457 case MESH_PDU_TYPE_UNSEGMENTED: 458 network_pdu = (mesh_network_pdu_t *) pdu; 459 mesh_network_message_processed_by_higher_layer(network_pdu); 460 break; 461 default: 462 btstack_assert(0); 463 break; 464 } 465 mesh_lower_transport_incoming_deliver_to_higher_layer(); 466 } 467 468 // OUTGOING // 469 470 static void mesh_lower_transport_outgoing_setup_block_ack(mesh_segmented_pdu_t *message_pdu){ 471 // setup block ack - set bit for segment to send, will be cleared on ack 472 int ctl = message_pdu->ctl_ttl >> 7; 473 uint16_t max_segment_len = ctl ? 8 : 12; // control 8 bytes (64 bit NetMic), access 12 bytes (32 bit NetMIC) 474 uint8_t seg_n = (message_pdu->len - 1) / max_segment_len; 475 if (seg_n < 31){ 476 message_pdu->block_ack = (1 << (seg_n+1)) - 1; 477 } else { 478 message_pdu->block_ack = 0xffffffff; 479 } 480 } 481 482 static mesh_segmented_pdu_t * mesh_lower_transport_outgoing_message_for_dst(uint16_t dst){ 483 if (lower_transport_outgoing_message != NULL && lower_transport_outgoing_message->dst == dst){ 484 return lower_transport_outgoing_message; 485 } 486 return NULL; 487 } 488 489 static void mesh_lower_transport_outgoing_process_segment_acknowledgement_message(mesh_network_pdu_t *network_pdu){ 490 mesh_segmented_pdu_t * segmented_pdu = mesh_lower_transport_outgoing_message_for_dst( mesh_network_src(network_pdu)); 491 if (segmented_pdu == NULL) return; 492 493 uint8_t * lower_transport_pdu = mesh_network_pdu_data(network_pdu); 494 uint16_t seq_zero_pdu = big_endian_read_16(lower_transport_pdu, 1) >> 2; 495 uint16_t seq_zero_out = lower_transport_outgoing_message->seq & 0x1fff; 496 uint32_t block_ack = big_endian_read_32(lower_transport_pdu, 3); 497 498 #ifdef LOG_LOWER_TRANSPORT 499 printf("[+] Segment Acknowledgment message with seq_zero %06x, block_ack %08" PRIx32 " - outgoing seq %06x, block_ack %08" PRIx32 "\n", 500 seq_zero_pdu, block_ack, seq_zero_out, segmented_pdu->block_ack); 501 #endif 502 503 if (block_ack == 0){ 504 // If a Segment Acknowledgment message with the BlockAck field set to 0x00000000 is received, 505 // then the Upper Transport PDU shall be immediately cancelled and the higher layers shall be notified that 506 // the Upper Transport PDU has been cancelled. 507 #ifdef LOG_LOWER_TRANSPORT 508 printf("[+] Block Ack == 0 => Abort\n"); 509 #endif 510 // current? 511 if ((lower_transport_outgoing_message == segmented_pdu) && lower_transport_outgoing_segment_at_network_layer){ 512 lower_transport_outgoing_transmission_aborted = true; 513 } else { 514 mesh_lower_transport_outgoing_complete(segmented_pdu, MESH_TRANSPORT_STATUS_SEND_ABORT_BY_REMOTE); 515 } 516 return; 517 } 518 if (seq_zero_pdu != seq_zero_out){ 519 520 #ifdef LOG_LOWER_TRANSPORT 521 printf("[!] Seq Zero doesn't match\n"); 522 #endif 523 return; 524 } 525 526 segmented_pdu->block_ack &= ~block_ack; 527 #ifdef LOG_LOWER_TRANSPORT 528 printf("[+] Updated block_ack %08" PRIx32 "\n", segmented_pdu->block_ack); 529 #endif 530 531 if (segmented_pdu->block_ack == 0){ 532 #ifdef LOG_LOWER_TRANSPORT 533 printf("[+] Sent complete\n"); 534 #endif 535 536 if ((lower_transport_outgoing_message == segmented_pdu) && lower_transport_outgoing_segment_at_network_layer){ 537 lower_transport_outgoing_transmission_complete = true; 538 } else { 539 mesh_lower_transport_outgoing_complete(segmented_pdu, MESH_TRANSPORT_STATUS_SUCCESS); 540 } 541 } 542 } 543 544 static void mesh_lower_transport_outgoing_stop_acknowledgment_timer(mesh_segmented_pdu_t *segmented_pdu){ 545 if ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_ACK_TIMER) == 0) return; 546 segmented_pdu->flags &= ~MESH_TRANSPORT_FLAG_ACK_TIMER; 547 btstack_run_loop_remove_timer(&segmented_pdu->acknowledgement_timer); 548 } 549 550 static void mesh_lower_transport_outgoing_restart_segment_transmission_timer(mesh_segmented_pdu_t *segmented_pdu){ 551 // restart segment transmission timer for unicast dst 552 // - "This timer shall be set to a minimum of 200 + 50 * TTL milliseconds." 553 uint32_t timeout = 200 + 50 * (segmented_pdu->ctl_ttl & 0x7f); 554 if ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_ACK_TIMER) != 0){ 555 btstack_run_loop_remove_timer(&lower_transport_outgoing_message->acknowledgement_timer); 556 } 557 558 #ifdef LOG_LOWER_TRANSPORT 559 printf("[+] Lower transport, segmented pdu %p, seq %06" PRIx32 ": setup transmission timeout %u ms\n", segmented_pdu, 560 segmented_pdu->seq, (int) timeout); 561 #endif 562 563 btstack_run_loop_set_timer(&segmented_pdu->acknowledgement_timer, timeout); 564 btstack_run_loop_set_timer_handler(&segmented_pdu->acknowledgement_timer, &mesh_lower_transport_outgoing_segment_transmission_timeout); 565 btstack_run_loop_set_timer_context(&segmented_pdu->acknowledgement_timer, lower_transport_outgoing_message); 566 btstack_run_loop_add_timer(&segmented_pdu->acknowledgement_timer); 567 segmented_pdu->flags |= MESH_TRANSPORT_FLAG_ACK_TIMER; 568 } 569 570 static void mesh_lower_transport_outgoing_complete(mesh_segmented_pdu_t * segmented_pdu, mesh_transport_status_t status){ 571 btstack_assert(segmented_pdu != NULL); 572 #ifdef LOG_LOWER_TRANSPORT 573 printf("[+] outgoing_complete %p, ack timer active %u, incomplete active %u\n", segmented_pdu, 574 ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_ACK_TIMER) != 0), ((segmented_pdu->flags & MESH_TRANSPORT_FLAG_INCOMPLETE_TIMER) != 0)); 575 #endif 576 // stop timers 577 mesh_lower_transport_outgoing_stop_acknowledgment_timer(segmented_pdu); 578 579 // remove from lists 580 if (lower_transport_outgoing_message == segmented_pdu){ 581 lower_transport_outgoing_message = NULL; 582 } else { 583 btstack_linked_list_remove(&lower_transport_outgoing_waiting, (btstack_linked_item_t *) segmented_pdu); 584 btstack_linked_list_remove(&lower_transport_outgoing_ready, (btstack_linked_item_t *) segmented_pdu); 585 } 586 587 // notify upper transport 588 higher_layer_handler(MESH_TRANSPORT_PDU_SENT, status, (mesh_pdu_t *) segmented_pdu); 589 } 590 591 static void mesh_lower_transport_outgoing_setup_segment(mesh_segmented_pdu_t *message_pdu, uint8_t seg_o, mesh_network_pdu_t *network_pdu){ 592 593 int ctl = message_pdu->ctl_ttl >> 7; 594 uint16_t max_segment_len = ctl ? 8 : 12; // control 8 bytes (64 bit NetMic), access 12 bytes (32 bit NetMIC) 595 596 // use seq number from transport pdu once if MESH_TRANSPORT_FLAG_SEQ_RESERVED (to allow reserving seq number in upper transport while using all seq numbers) 597 uint32_t seq; 598 if ((message_pdu->flags & MESH_TRANSPORT_FLAG_SEQ_RESERVED) != 0){ 599 message_pdu->flags &= ~(MESH_TRANSPORT_FLAG_SEQ_RESERVED); 600 seq = message_pdu->seq; 601 } else { 602 seq = mesh_sequence_number_next(); 603 } 604 uint16_t seq_zero = message_pdu->seq & 0x01fff; 605 uint8_t seg_n = (message_pdu->len - 1) / max_segment_len; 606 uint8_t szmic = ((message_pdu->flags & MESH_TRANSPORT_FLAG_TRANSMIC_64) != 0) ? 1 : 0; 607 uint8_t nid = message_pdu->ivi_nid & 0x7f; 608 uint8_t ttl = message_pdu->ctl_ttl & 0x7f; 609 uint16_t src = message_pdu->src; 610 uint16_t dest = message_pdu->dst; 611 612 // only 1 for access messages with 64 bit TransMIC 613 btstack_assert((szmic == 0) || !ctl); 614 615 // current segment. 616 uint16_t seg_offset = seg_o * max_segment_len; 617 618 uint8_t lower_transport_pdu_data[16]; 619 lower_transport_pdu_data[0] = 0x80 | message_pdu->akf_aid_control; 620 big_endian_store_24(lower_transport_pdu_data, 1, (szmic << 23) | (seq_zero << 10) | (seg_o << 5) | seg_n); 621 uint16_t segment_len = btstack_min(message_pdu->len - seg_offset, max_segment_len); 622 623 uint16_t lower_transport_pdu_len = 4 + segment_len; 624 625 // find network-pdu with chunk for seg_offset 626 mesh_network_pdu_t * chunk = (mesh_network_pdu_t *) lower_transport_outgoing_message->segments; 627 uint16_t chunk_start = 0; 628 while ((chunk_start + MESH_NETWORK_PAYLOAD_MAX) <= seg_offset){ 629 chunk = (mesh_network_pdu_t *) chunk->pdu_header.item.next; 630 chunk_start += MESH_NETWORK_PAYLOAD_MAX; 631 } 632 // first part 633 uint16_t chunk_offset = seg_offset - chunk_start; 634 uint16_t bytes_to_copy = btstack_min(MESH_NETWORK_PAYLOAD_MAX - chunk_offset, segment_len); 635 (void)memcpy(&lower_transport_pdu_data[4], 636 &chunk->data[chunk_offset], bytes_to_copy); 637 segment_len -= bytes_to_copy; 638 // second part 639 if (segment_len > 0){ 640 chunk = (mesh_network_pdu_t *) chunk->pdu_header.item.next; 641 (void)memcpy(&lower_transport_pdu_data[4+bytes_to_copy], 642 &chunk->data[0], segment_len); 643 } 644 645 mesh_network_setup_pdu(network_pdu, message_pdu->netkey_index, nid, 0, ttl, seq, src, dest, lower_transport_pdu_data, lower_transport_pdu_len); 646 } 647 648 static void mesh_lower_transport_outgoing_send_next_segment(void){ 649 btstack_assert(lower_transport_outgoing_message != NULL); 650 651 #ifdef LOG_LOWER_TRANSPORT 652 printf("[+] Lower Transport, segmented pdu %p, seq %06" PRIx32 ": send next segment\n", lower_transport_outgoing_message, 653 lower_transport_outgoing_message->seq); 654 #endif 655 656 int ctl = lower_transport_outgoing_message->ctl_ttl >> 7; 657 uint16_t max_segment_len = ctl ? 8 : 12; // control 8 bytes (64 bit NetMic), access 12 bytes (32 bit NetMIC) 658 uint8_t seg_n = (lower_transport_outgoing_message->len - 1) / max_segment_len; 659 660 // find next unacknowledged segment 661 while ((lower_transport_outgoing_seg_o <= seg_n) && ((lower_transport_outgoing_message->block_ack & (1 << lower_transport_outgoing_seg_o)) == 0)){ 662 lower_transport_outgoing_seg_o++; 663 } 664 665 if (lower_transport_outgoing_seg_o > seg_n){ 666 #ifdef LOG_LOWER_TRANSPORT 667 printf("[+] Lower Transport, segmented pdu %p, seq %06" PRIx32 ": send complete (dst %x)\n", lower_transport_outgoing_message, 668 lower_transport_outgoing_message->seq, 669 lower_transport_outgoing_message->dst); 670 #endif 671 lower_transport_outgoing_seg_o = 0; 672 673 // done for unicast, ack timer already set, too 674 if (mesh_network_address_unicast(lower_transport_outgoing_message->dst)) { 675 btstack_linked_list_add(&lower_transport_outgoing_waiting, (btstack_linked_item_t *) lower_transport_outgoing_message); 676 lower_transport_outgoing_message = NULL; 677 return; 678 } 679 680 // done for group/virtual, no more retries? 681 if (lower_transport_outgoing_message->retry_count == 0){ 682 #ifdef LOG_LOWER_TRANSPORT 683 printf("[+] Lower Transport, message unacknowledged -> free\n"); 684 #endif 685 // notify upper transport 686 mesh_lower_transport_outgoing_complete(lower_transport_outgoing_message, MESH_TRANSPORT_STATUS_SUCCESS); 687 return; 688 } 689 690 // re-queue mssage 691 #ifdef LOG_LOWER_TRANSPORT 692 printf("[+] Lower Transport, message unacknowledged retry count %u\n", lower_transport_outgoing_message->retry_count); 693 #endif 694 lower_transport_outgoing_message->retry_count--; 695 btstack_linked_list_add(&lower_transport_outgoing_ready, (btstack_linked_item_t *) lower_transport_outgoing_message); 696 lower_transport_outgoing_message = NULL; 697 mesh_lower_transport_run(); 698 return; 699 } 700 701 // restart segment transmission timer for unicast dst 702 if (mesh_network_address_unicast(lower_transport_outgoing_message->dst)){ 703 mesh_lower_transport_outgoing_restart_segment_transmission_timer(lower_transport_outgoing_message); 704 } 705 706 mesh_lower_transport_outgoing_setup_segment(lower_transport_outgoing_message, lower_transport_outgoing_seg_o, 707 lower_transport_outgoing_segment); 708 709 #ifdef LOG_LOWER_TRANSPORT 710 printf("[+] Lower Transport, segmented pdu %p, seq %06" PRIx32 ": send seg_o %x, seg_n %x\n", lower_transport_outgoing_message, 711 lower_transport_outgoing_message->seq, lower_transport_outgoing_seg_o, seg_n); 712 mesh_print_hex("LowerTransportPDU", &lower_transport_outgoing_segment->data[9], lower_transport_outgoing_segment->len-9); 713 #endif 714 715 // next segment 716 lower_transport_outgoing_seg_o++; 717 718 // send network pdu 719 lower_transport_outgoing_segment_at_network_layer = true; 720 mesh_network_send_pdu(lower_transport_outgoing_segment); 721 } 722 723 static void mesh_lower_transport_outgoing_setup_sending_segmented_pdus(mesh_segmented_pdu_t *segmented_pdu) { 724 printf("[+] Lower Transport, segmented pdu %p, seq %06" PRIx32 ": send retry count %u\n", segmented_pdu, segmented_pdu->seq, segmented_pdu->retry_count); 725 726 segmented_pdu->retry_count--; 727 lower_transport_outgoing_seg_o = 0; 728 lower_transport_outgoing_transmission_timeout = false; 729 lower_transport_outgoing_transmission_complete = false; 730 lower_transport_outgoing_transmission_aborted = false; 731 732 lower_transport_outgoing_message = segmented_pdu; 733 } 734 735 static void mesh_lower_transport_outgoing_segment_transmission_fired(mesh_segmented_pdu_t *segmented_pdu) { 736 // once more? 737 if (segmented_pdu->retry_count == 0){ 738 printf("[!] Lower transport, segmented pdu %p, seq %06" PRIx32 ": send failed, retries exhausted\n", segmented_pdu, 739 segmented_pdu->seq); 740 mesh_lower_transport_outgoing_complete(segmented_pdu, MESH_TRANSPORT_STATUS_SEND_FAILED); 741 return; 742 } 743 744 #ifdef LOG_LOWER_TRANSPORT 745 printf("[+] Lower transport, segmented pdu %p, seq %06" PRIx32": transmission fired\n", segmented_pdu, segmented_pdu->seq); 746 #endif 747 748 // re-queue message for sending remaining segments 749 if (lower_transport_outgoing_message == segmented_pdu){ 750 lower_transport_outgoing_message = NULL; 751 } else { 752 btstack_linked_list_remove(&lower_transport_outgoing_waiting, (btstack_linked_item_t *) segmented_pdu); 753 } 754 btstack_linked_list_add_tail(&lower_transport_outgoing_ready, (btstack_linked_item_t *) segmented_pdu); 755 756 // continue 757 mesh_lower_transport_run(); 758 } 759 760 static void mesh_lower_transport_outgoing_segment_transmission_timeout(btstack_timer_source_t * ts){ 761 mesh_segmented_pdu_t * segmented_pdu = (mesh_segmented_pdu_t *) btstack_run_loop_get_timer_context(ts); 762 #ifdef LOG_LOWER_TRANSPORT 763 printf("[+] Lower transport, segmented pdu %p, seq %06" PRIx32 ": transmission timer fired\n", segmented_pdu, 764 segmented_pdu->seq); 765 #endif 766 segmented_pdu->flags &= ~MESH_TRANSPORT_FLAG_ACK_TIMER; 767 768 if ((segmented_pdu == lower_transport_outgoing_message) && lower_transport_outgoing_segment_at_network_layer){ 769 lower_transport_outgoing_transmission_timeout = true; 770 } else { 771 mesh_lower_transport_outgoing_segment_transmission_fired(segmented_pdu); 772 } 773 } 774 775 // GENERAL // 776 777 static void mesh_lower_transport_network_pdu_sent(mesh_network_pdu_t *network_pdu){ 778 // figure out what pdu was sent 779 780 // Segment Acknowledgment message sent by us? 781 if (network_pdu->pdu_header.pdu_type == MESH_PDU_TYPE_SEGMENT_ACKNOWLEDGMENT){ 782 btstack_memory_mesh_network_pdu_free(network_pdu); 783 return; 784 } 785 786 // single segment? 787 if (lower_transport_outgoing_segment == network_pdu){ 788 btstack_assert(lower_transport_outgoing_message != NULL); 789 790 // of segmented message 791 #ifdef LOG_LOWER_TRANSPORT 792 printf("[+] Lower transport, segmented pdu %p, seq %06" PRIx32 ": network pdu %p sent\n", lower_transport_outgoing_message, 793 lower_transport_outgoing_message->seq, network_pdu); 794 #endif 795 796 lower_transport_outgoing_segment_at_network_layer = false; 797 if (lower_transport_outgoing_transmission_complete){ 798 // handle success 799 lower_transport_outgoing_transmission_complete = false; 800 lower_transport_outgoing_transmission_timeout = false; 801 mesh_lower_transport_outgoing_complete(lower_transport_outgoing_message, MESH_TRANSPORT_STATUS_SUCCESS); 802 return; 803 } 804 if (lower_transport_outgoing_transmission_aborted){ 805 // handle abort 806 lower_transport_outgoing_transmission_complete = false; 807 lower_transport_outgoing_transmission_timeout = false; 808 mesh_lower_transport_outgoing_complete(lower_transport_outgoing_message, MESH_TRANSPORT_STATUS_SEND_ABORT_BY_REMOTE); 809 return; 810 } 811 if (lower_transport_outgoing_transmission_timeout){ 812 // handle timeout 813 lower_transport_outgoing_transmission_timeout = false; 814 mesh_lower_transport_outgoing_segment_transmission_fired(lower_transport_outgoing_message); 815 return; 816 } 817 818 // send next segment 819 mesh_lower_transport_outgoing_send_next_segment(); 820 return; 821 } 822 823 // other 824 higher_layer_handler(MESH_TRANSPORT_PDU_SENT, MESH_TRANSPORT_STATUS_SUCCESS, (mesh_pdu_t *) network_pdu); 825 } 826 827 static void mesh_lower_transport_process_unsegmented_control_message(mesh_network_pdu_t *network_pdu){ 828 uint8_t * lower_transport_pdu = mesh_network_pdu_data(network_pdu); 829 uint8_t opcode = lower_transport_pdu[0]; 830 831 #ifdef LOG_LOWER_TRANSPORT 832 printf("Unsegmented Control message, outgoing message %p, opcode %x\n", lower_transport_outgoing_message, opcode); 833 #endif 834 835 switch (opcode){ 836 case 0: 837 mesh_lower_transport_outgoing_process_segment_acknowledgement_message(network_pdu); 838 mesh_network_message_processed_by_higher_layer(network_pdu); 839 break; 840 default: 841 mesh_lower_transport_incoming_queue_for_higher_layer((mesh_pdu_t *) network_pdu); 842 break; 843 } 844 } 845 846 static void mesh_lower_transport_process_network_pdu(mesh_network_pdu_t *network_pdu) {// segmented? 847 if (mesh_network_segmented(network_pdu)){ 848 mesh_segmented_pdu_t * message_pdu = mesh_lower_transport_incoming_pdu_for_segmented_message(network_pdu); 849 if (message_pdu) { 850 // start acknowledgment timer if inactive 851 if ((message_pdu->flags & MESH_TRANSPORT_FLAG_ACK_TIMER) == 0){ 852 // - "The acknowledgment timer shall be set to a minimum of 150 + 50 * TTL milliseconds" 853 uint32_t timeout = 150 + 50 * mesh_network_ttl(network_pdu); 854 mesh_lower_transport_incoming_start_acknowledgment_timer(message_pdu, timeout); 855 } 856 // restart incomplete timer 857 mesh_lower_transport_incoming_restart_incomplete_timer(message_pdu, 10000, 858 &mesh_lower_transport_incoming_incomplete_timeout); 859 mesh_lower_transport_incoming_process_segment(message_pdu, network_pdu); 860 } else { 861 mesh_network_message_processed_by_higher_layer(network_pdu); 862 } 863 } else { 864 // control? 865 if (mesh_network_control(network_pdu)){ 866 // unsegmented control message (not encrypted) 867 mesh_lower_transport_process_unsegmented_control_message(network_pdu); 868 } else { 869 // unsegmented access message (encrypted) 870 mesh_lower_transport_incoming_queue_for_higher_layer((mesh_pdu_t *) network_pdu); 871 } 872 } 873 } 874 875 void mesh_lower_transport_received_message(mesh_network_callback_type_t callback_type, mesh_network_pdu_t *network_pdu){ 876 mesh_peer_t * peer; 877 uint16_t src; 878 uint16_t seq; 879 switch (callback_type){ 880 case MESH_NETWORK_PDU_RECEIVED: 881 src = mesh_network_src(network_pdu); 882 seq = mesh_network_seq(network_pdu); 883 peer = mesh_peer_for_addr(src); 884 #ifdef LOG_LOWER_TRANSPORT 885 printf("Transport: received message. SRC %x, SEQ %x\n", src, seq); 886 #endif 887 // validate seq 888 if (peer && seq > peer->seq){ 889 // track seq 890 peer->seq = seq; 891 // process 892 mesh_lower_transport_process_network_pdu(network_pdu); 893 mesh_lower_transport_run(); 894 } else { 895 // drop packet 896 #ifdef LOG_LOWER_TRANSPORT 897 printf("Transport: drop packet - src/seq auth failed\n"); 898 #endif 899 mesh_network_message_processed_by_higher_layer(network_pdu); 900 } 901 break; 902 case MESH_NETWORK_PDU_SENT: 903 mesh_lower_transport_network_pdu_sent(network_pdu); 904 break; 905 default: 906 break; 907 } 908 } 909 910 static void mesh_lower_transport_run(void){ 911 912 // check if outgoing segmented pdu is active 913 if (lower_transport_outgoing_message) return; 914 915 while(!btstack_linked_list_empty(&lower_transport_outgoing_ready)) { 916 // get next message 917 mesh_segmented_pdu_t * message_pdu; 918 mesh_pdu_t * pdu = (mesh_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_ready); 919 switch (pdu->pdu_type) { 920 case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 921 case MESH_PDU_TYPE_UPPER_UNSEGMENTED_CONTROL: 922 printf("[+] Lower transport, unsegmented pdu, sending now %p\n", pdu); 923 lower_transport_outgoing_network_pdu = (mesh_network_pdu_t *) pdu; 924 mesh_network_send_pdu(lower_transport_outgoing_network_pdu); 925 break; 926 case MESH_PDU_TYPE_SEGMENTED: 927 message_pdu = (mesh_segmented_pdu_t *) pdu; 928 // 929 printf("[+] Lower transport, segmented pdu %p, seq %06" PRIx32 ": run start sending now\n", message_pdu, 930 message_pdu->seq); 931 // start sending segmented pdu 932 mesh_lower_transport_outgoing_setup_sending_segmented_pdus(message_pdu); 933 mesh_lower_transport_outgoing_send_next_segment(); 934 break; 935 default: 936 btstack_assert(false); 937 break; 938 } 939 } 940 } 941 942 void mesh_lower_transport_send_pdu(mesh_pdu_t *pdu){ 943 mesh_segmented_pdu_t * segmented_pdu; 944 switch (pdu->pdu_type){ 945 case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 946 case MESH_PDU_TYPE_UPPER_UNSEGMENTED_CONTROL: 947 btstack_assert(((mesh_network_pdu_t *) pdu)->len >= 9); 948 break; 949 case MESH_PDU_TYPE_SEGMENTED: 950 // set num retries, set of segments to send 951 segmented_pdu = (mesh_segmented_pdu_t *) pdu; 952 segmented_pdu->retry_count = 3; 953 mesh_lower_transport_outgoing_setup_block_ack(segmented_pdu); 954 break; 955 default: 956 btstack_assert(false); 957 break; 958 } 959 btstack_linked_list_add_tail(&lower_transport_outgoing_ready, (btstack_linked_item_t*) pdu); 960 mesh_lower_transport_run(); 961 } 962 963 void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list){ 964 printf("List: %s:\n", name); 965 btstack_linked_list_iterator_t it; 966 btstack_linked_list_iterator_init(&it, list); 967 while (btstack_linked_list_iterator_has_next(&it)){ 968 mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t*) btstack_linked_list_iterator_next(&it); 969 printf("- %p: ", network_pdu); printf_hexdump(network_pdu->data, network_pdu->len); 970 } 971 } 972 973 void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list){ 974 while (!btstack_linked_list_empty(list)){ 975 mesh_network_pdu_t * pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(list); 976 btstack_memory_mesh_network_pdu_free(pdu); 977 } 978 } 979 980 bool mesh_lower_transport_can_send_to_dest(uint16_t dest){ 981 UNUSED(dest); 982 // check current 983 uint16_t num_messages = 0; 984 if (lower_transport_outgoing_message != NULL) { 985 if (lower_transport_outgoing_message->dst == dest) { 986 return false; 987 } 988 num_messages++; 989 } 990 // check waiting 991 btstack_linked_list_iterator_t it; 992 btstack_linked_list_iterator_init(&it, &lower_transport_outgoing_waiting); 993 while (btstack_linked_list_iterator_has_next(&it)){ 994 mesh_segmented_pdu_t * segmented_pdu = (mesh_segmented_pdu_t *) btstack_linked_list_iterator_next(&it); 995 num_messages++; 996 if (segmented_pdu->dst == dest){ 997 return false; 998 } 999 } 1000 #ifdef MAX_NR_MESH_OUTGOING_SEGMENTED_MESSAGES 1001 // limit number of parallel outgoing messages if configured 1002 if (num_messages >= MAX_NR_MESH_OUTGOING_SEGMENTED_MESSAGES) return false; 1003 #endif 1004 return true; 1005 } 1006 1007 void mesh_lower_transport_reserve_slot(void){ 1008 } 1009 1010 void mesh_lower_transport_reset(void){ 1011 if (lower_transport_outgoing_message){ 1012 while (!btstack_linked_list_empty(&lower_transport_outgoing_message->segments)){ 1013 mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_message->segments); 1014 mesh_network_pdu_free(network_pdu); 1015 } 1016 lower_transport_outgoing_message = NULL; 1017 } 1018 while (!btstack_linked_list_empty(&lower_transport_outgoing_waiting)){ 1019 mesh_segmented_pdu_t * segmented_pdu = (mesh_segmented_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_waiting); 1020 btstack_memory_mesh_segmented_pdu_free(segmented_pdu); 1021 } 1022 mesh_network_pdu_free(lower_transport_outgoing_segment); 1023 lower_transport_outgoing_segment_at_network_layer = false; 1024 lower_transport_outgoing_segment = NULL; 1025 } 1026 1027 void mesh_lower_transport_init(){ 1028 // register with network layer 1029 mesh_network_set_higher_layer_handler(&mesh_lower_transport_received_message); 1030 // allocate network_pdu for segmentation 1031 lower_transport_outgoing_segment_at_network_layer = false; 1032 lower_transport_outgoing_segment = mesh_network_pdu_get(); 1033 } 1034 1035 void mesh_lower_transport_set_higher_layer_handler(void (*pdu_handler)( mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu)){ 1036 higher_layer_handler = pdu_handler; 1037 } 1038