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
mesh_print_hex(const char * name,const uint8_t * data,uint16_t len)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
mesh_segmented_pdu_get(void)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
mesh_segmented_pdu_free(mesh_segmented_pdu_t * message_pdu)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
mesh_lower_transport_incoming_deliver_to_higher_layer(void)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
mesh_lower_transport_incoming_queue_for_higher_layer(mesh_pdu_t * pdu)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
mesh_lower_transport_incoming_setup_acknowledge_message(uint8_t * data,uint8_t obo,uint16_t seq_zero,uint32_t block_ack)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
mesh_lower_transport_incoming_send_ack(uint16_t netkey_index,uint8_t ttl,uint16_t dest,uint16_t seq_zero,uint32_t block_ack)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
mesh_lower_transport_incoming_send_ack_for_segmented_pdu(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_incoming_send_ack_for_network_pdu(mesh_network_pdu_t * network_pdu,uint16_t seq_zero,uint32_t block_ack)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
mesh_lower_transport_incoming_stop_acknowledgment_timer(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_incoming_stop_incomplete_timer(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_incoming_segmented_message_complete(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_incoming_ack_timeout(btstack_timer_source_t * ts)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
mesh_lower_transport_incoming_incomplete_timeout(btstack_timer_source_t * ts)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
mesh_lower_transport_incoming_start_acknowledgment_timer(mesh_segmented_pdu_t * segmented_pdu,uint32_t timeout)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
mesh_lower_transport_incoming_restart_incomplete_timer(mesh_segmented_pdu_t * segmented_pdu,uint32_t timeout,void (* callback)(btstack_timer_source_t * ts))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
mesh_lower_transport_incoming_pdu_for_segmented_message(mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_incoming_process_segment(mesh_segmented_pdu_t * message_pdu,mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_message_processed_by_higher_layer(mesh_pdu_t * pdu)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
mesh_lower_transport_outgoing_setup_block_ack(mesh_segmented_pdu_t * message_pdu)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
mesh_lower_transport_outgoing_message_for_dst(uint16_t dst)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
mesh_lower_transport_outgoing_process_segment_acknowledgement_message(mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_outgoing_stop_acknowledgment_timer(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_outgoing_restart_segment_transmission_timer(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_outgoing_complete(mesh_segmented_pdu_t * segmented_pdu,mesh_transport_status_t status)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
mesh_lower_transport_outgoing_setup_segment(mesh_segmented_pdu_t * message_pdu,uint8_t seg_o,mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_outgoing_send_next_segment(void)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
mesh_lower_transport_outgoing_setup_sending_segmented_pdus(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_outgoing_segment_transmission_fired(mesh_segmented_pdu_t * segmented_pdu)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
mesh_lower_transport_outgoing_segment_transmission_timeout(btstack_timer_source_t * ts)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
mesh_lower_transport_network_pdu_sent(mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_process_unsegmented_control_message(mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_process_network_pdu(mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_received_message(mesh_network_callback_type_t callback_type,mesh_network_pdu_t * network_pdu)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
mesh_lower_transport_run(void)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
mesh_lower_transport_send_pdu(mesh_pdu_t * pdu)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
mesh_lower_transport_dump_network_pdus(const char * name,btstack_linked_list_t * list)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
mesh_lower_transport_reset_network_pdus(btstack_linked_list_t * list)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
mesh_lower_transport_can_send_to_dest(uint16_t dest)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 #else
1004 UNUSED(num_messages);
1005 #endif
1006 return true;
1007 }
1008
mesh_lower_transport_reserve_slot(void)1009 void mesh_lower_transport_reserve_slot(void){
1010 }
1011
mesh_lower_transport_reset(void)1012 void mesh_lower_transport_reset(void){
1013 if (lower_transport_outgoing_message){
1014 while (!btstack_linked_list_empty(&lower_transport_outgoing_message->segments)){
1015 mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_message->segments);
1016 mesh_network_pdu_free(network_pdu);
1017 }
1018 lower_transport_outgoing_message = NULL;
1019 }
1020 while (!btstack_linked_list_empty(&lower_transport_outgoing_waiting)){
1021 mesh_segmented_pdu_t * segmented_pdu = (mesh_segmented_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_waiting);
1022 btstack_memory_mesh_segmented_pdu_free(segmented_pdu);
1023 }
1024 mesh_network_pdu_free(lower_transport_outgoing_segment);
1025 lower_transport_outgoing_segment_at_network_layer = false;
1026 lower_transport_outgoing_segment = NULL;
1027 }
1028
mesh_lower_transport_init()1029 void mesh_lower_transport_init(){
1030 // register with network layer
1031 mesh_network_set_higher_layer_handler(&mesh_lower_transport_received_message);
1032 // allocate network_pdu for segmentation
1033 lower_transport_outgoing_segment_at_network_layer = false;
1034 lower_transport_outgoing_segment = mesh_network_pdu_get();
1035 }
1036
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))1037 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)){
1038 higher_layer_handler = pdu_handler;
1039 }
1040