1 /* 2 * Copyright (C) 2018 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 MATTHIAS 24 * RINGWALD 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 #ifndef __MESH_NETWORK 39 #define __MESH_NETWORK 40 41 #include "btstack_linked_list.h" 42 #include "btstack_run_loop.h" 43 44 #include "mesh/provisioning.h" 45 #include "mesh/mesh_keys.h" 46 47 #if defined __cplusplus 48 extern "C" { 49 #endif 50 51 #define MESH_DEVICE_KEY_INDEX 0xffff 52 53 #define MESH_NETWORK_PAYLOAD_MAX 29 54 #define MESH_ACCESS_PAYLOAD_MAX 384 55 #define MESH_CONTROL_PAYLOAD_MAX 256 56 57 #define MESH_ADDRESS_UNSASSIGNED 0x0000u 58 #define MESH_ADDRESS_ALL_PROXIES 0xFFFCu 59 #define MESH_ADDRESS_ALL_FRIENDS 0xFFFDu 60 #define MESH_ADDRESS_ALL_RELAYS 0xFFFEu 61 #define MESH_ADDRESS_ALL_NODES 0xFFFFu 62 63 typedef enum { 64 MESH_NETWORK_PDU_RECEIVED, 65 MESH_NETWORK_PDU_SENT, 66 MESH_NETWORK_PDU_ENCRYPTED, 67 MESH_NETWORK_CAN_SEND_NOW, 68 } mesh_network_callback_type_t; 69 70 typedef enum { 71 MESH_PDU_TYPE_NETWORK = 0, 72 MESH_PDU_TYPE_TRANSPORT, 73 MESH_PDU_TYPE_SEGMENTED, 74 MESH_PDU_TYPE_UNSEGMENTED, 75 MESH_PDU_TYPE_ACCESS, 76 MESH_PDU_TYPE_CONTROL, 77 } mesh_pdu_type_t; 78 79 typedef struct mesh_pdu { 80 // allow for linked lists 81 btstack_linked_item_t item; 82 // type 83 mesh_pdu_type_t pdu_type; 84 85 } mesh_pdu_t; 86 87 // 88 #define MESH_NETWORK_PDU_FLAGS_PROXY_CONFIGURATION 1 89 #define MESH_NETWORK_PDU_FLAGS_GATT_BEARER 2 90 #define MESH_NETWORK_PDU_FLAGS_RELAY 4 91 92 typedef struct mesh_network_pdu { 93 mesh_pdu_t pdu_header; 94 95 // meta data network layer 96 uint16_t netkey_index; 97 // MESH_NETWORK_PDU_FLAGS 98 uint16_t flags; 99 100 // pdu 101 uint16_t len; 102 uint8_t data[MESH_NETWORK_PAYLOAD_MAX]; 103 } mesh_network_pdu_t; 104 105 #define MESH_TRANSPORT_FLAG_SEQ_RESERVED 1 106 #define MESH_TRANSPORT_FLAG_CONTROL 2 107 108 109 typedef struct { 110 // generic pdu header 111 mesh_pdu_t pdu_header; 112 // meta data transport layer 113 uint16_t appkey_index; 114 // MESH_TRANSPORT_FLAG 115 uint16_t flags; 116 // pdu segment 117 mesh_network_pdu_t * segment; 118 } mesh_unsegmented_pdu_t; 119 120 typedef struct { 121 mesh_pdu_t pdu_header; 122 123 // rx/tx: acknowledgement timer / segment transmission timer 124 btstack_timer_source_t acknowledgement_timer; 125 // rx: incomplete timer / tx: resend timer 126 btstack_timer_source_t incomplete_timer; 127 // block access 128 uint32_t block_ack; 129 // meta data network layer 130 uint16_t netkey_index; 131 // meta data transport layer 132 uint16_t appkey_index; 133 // transmic size 134 uint8_t transmic_len; 135 // akf - aid for access, opcode for control 136 uint8_t akf_aid_control; 137 // network pdu header 138 uint8_t network_header[9]; 139 // MESH_TRANSPORT_FLAG 140 uint16_t flags; 141 // acknowledgement timer active 142 uint8_t acknowledgement_timer_active; 143 // incomplete timer active 144 uint8_t incomplete_timer_active; 145 // message complete 146 uint8_t message_complete; 147 // seq_zero for segmented messages 148 uint16_t seq_zero; 149 // pdu segments 150 uint16_t len; 151 btstack_linked_list_t segments; 152 } mesh_segmented_pdu_t; 153 154 typedef struct { 155 mesh_pdu_t pdu_header; 156 157 // meta data network layer 158 uint16_t netkey_index; 159 // meta data transport layer 160 uint16_t appkey_index; 161 // transmic size 162 uint8_t transmic_len; 163 // akf - aid for access, opcode for control 164 uint8_t akf_aid_control; 165 // network pdu header 166 uint8_t network_header[9]; 167 // MESH_TRANSPORT_FLAG 168 uint16_t flags; 169 // pdu 170 uint16_t len; 171 uint8_t data[MESH_ACCESS_PAYLOAD_MAX]; 172 } mesh_transport_pdu_t; 173 174 typedef struct { 175 // generic pdu header 176 mesh_pdu_t pdu_header; 177 // meta data network layer 178 uint16_t netkey_index; 179 // meta data transport layer 180 uint16_t appkey_index; 181 // transmic size 182 uint8_t transmic_len; 183 // akf - aid for access, opcode for control 184 uint8_t akf_aid_control; 185 // network pdu header 186 uint8_t network_header[9]; 187 // MESH_TRANSPORT_FLAG 188 uint16_t flags; 189 // payload 190 uint16_t len; 191 uint8_t data[MESH_ACCESS_PAYLOAD_MAX]; 192 193 } mesh_access_pdu_t; 194 195 // for unsegmented + segmented access + segmented control pdus 196 typedef struct { 197 // generic pdu header 198 mesh_pdu_t pdu_header; 199 // meta data network layer 200 uint16_t netkey_index; 201 // meta data transport layer 202 uint16_t appkey_index; 203 // transmic size 204 uint8_t transmic_len; 205 // akf - aid for access, opcode for control 206 uint8_t akf_aid_control; 207 // network pdu header 208 uint8_t network_header[9]; 209 // MESH_TRANSPORT_FLAG 210 uint16_t flags; 211 // pdu segments 212 uint16_t len; 213 btstack_linked_list_t segments; 214 215 // lower transport pdu 216 mesh_pdu_t * lower_pdu; 217 218 // access acknowledged message 219 uint16_t retransmit_count; 220 uint32_t retransmit_timeout_ms; 221 uint32_t ack_opcode; 222 223 } mesh_upper_transport_pdu_t; 224 225 226 typedef struct { 227 // generic pdu header 228 mesh_pdu_t pdu_header; 229 // meta data network layer 230 uint16_t netkey_index; 231 // akf - aid for access, opcode for control 232 uint8_t akf_aid_control; 233 // network pdu header 234 uint8_t network_header[9]; 235 // MESH_TRANSPORT_FLAG 236 uint16_t flags; 237 // payload 238 uint16_t len; 239 uint8_t data[MESH_CONTROL_PAYLOAD_MAX]; 240 } mesh_control_pdu_t; 241 242 typedef enum { 243 MESH_KEY_REFRESH_NOT_ACTIVE = 0, 244 MESH_KEY_REFRESH_FIRST_PHASE, 245 MESH_KEY_REFRESH_SECOND_PHASE 246 } mesh_key_refresh_state_t; 247 248 typedef enum { 249 MESH_SECURE_NETWORK_BEACON_W2_AUTH_VALUE, 250 MESH_SECURE_NETWORK_BEACON_W4_AUTH_VALUE, 251 MESH_SECURE_NETWORK_BEACON_AUTH_VALUE, 252 MESH_SECURE_NETWORK_BEACON_W2_SEND_ADV, 253 MESH_SECURE_NETWORK_BEACON_ADV_SENT, 254 MESH_SECURE_NETWORK_BEACON_W2_SEND_GATT, 255 MESH_SECURE_NETWORK_BEACON_GATT_SENT, 256 MESH_SECURE_NETWORK_BEACON_W4_INTERVAL 257 } mesh_secure_network_beacon_state_t; 258 259 typedef struct { 260 btstack_linked_item_t item; 261 262 // netkey index 263 uint16_t netkey_index; 264 265 // current / old key 266 mesh_network_key_t * old_key; 267 268 // new key (only set during key refresh) 269 mesh_network_key_t * new_key; 270 271 // key refresh state 272 mesh_key_refresh_state_t key_refresh; 273 274 // advertisement using node id active 275 uint8_t node_id_advertisement_running; 276 277 278 // advertisement using network id (used by proxy) 279 adv_bearer_connectable_advertisement_data_item_t advertisement_with_network_id; 280 281 // advertising using node id (used by proxy) 282 adv_bearer_connectable_advertisement_data_item_t advertisement_with_node_id; 283 284 // secure network beacons 285 mesh_secure_network_beacon_state_t beacon_state; 286 uint32_t beacon_interval_ms; 287 uint32_t beacon_observation_start_ms; 288 uint16_t beacon_observation_counter; 289 290 } mesh_subnet_t; 291 292 typedef struct { 293 btstack_linked_list_iterator_t it; 294 } mesh_subnet_iterator_t; 295 296 /** 297 * @brief Init Mesh Network Layer 298 */ 299 void mesh_network_init(void); 300 301 /** 302 * @brief Set higher layer Network PDU handler 303 * @param packet_handler 304 */ 305 void mesh_network_set_higher_layer_handler(void (*packet_handler)(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu)); 306 307 /** 308 * @brief Set higher layer Proxy PDU handler 309 * @param packet_handler 310 */ 311 void mesh_network_set_proxy_message_handler(void (*packet_handler)(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu)); 312 313 /** 314 * @brief Mark packet as processed 315 * @param newtork_pdu received via call packet_handler 316 */ 317 void mesh_network_message_processed_by_higher_layer(mesh_network_pdu_t * network_pdu); 318 319 /** 320 * @brief Send network_pdu after encryption 321 * @param network_pdu 322 */ 323 void mesh_network_send_pdu(mesh_network_pdu_t * network_pdu); 324 325 /* 326 * @brief Setup network pdu header 327 * @param netkey_index 328 * @param nid 329 * @param ctl 330 * @param ttl 331 * @param seq 332 * @param dst 333 * @param transport_pdu_data 334 * @param transport_pdu_len 335 */ 336 void mesh_network_setup_pdu(mesh_network_pdu_t * network_pdu, uint16_t netkey_index, uint8_t nid, uint8_t ctl, uint8_t ttl, uint32_t seq, uint16_t src, uint16_t dst, const uint8_t * transport_pdu_data, uint8_t transport_pdu_len); 337 338 /** 339 * Setup network pdu header without modifying len or payload 340 * @param network_pdu 341 * @param netkey_index 342 * @param nid 343 * @param ctl 344 * @param ttl 345 * @param seq 346 * @param src 347 * @param dest 348 */ 349 void mesh_network_setup_pdu_header(mesh_network_pdu_t * network_pdu, uint16_t netkey_index, uint8_t nid, uint8_t ctl, uint8_t ttl, uint32_t seq, uint16_t src, uint16_t dest); 350 351 /** 352 * @brief Validate network addresses 353 * @param ctl 354 * @param src 355 * @param dst 356 * @returns 1 if valid, 357 */ 358 int mesh_network_addresses_valid(uint8_t ctl, uint16_t src, uint16_t dst); 359 360 /** 361 * @brief Check if Unicast address 362 * @param addr 363 * @returns 1 if unicast 364 */ 365 int mesh_network_address_unicast(uint16_t addr); 366 367 /** 368 * @brief Check if Unicast address 369 * @param addr 370 * @returns 1 if unicast 371 */ 372 int mesh_network_address_group(uint16_t addr); 373 374 /** 375 * @brief Check if All Proxies address 376 * @param addr 377 * @returns 1 if all proxies 378 */ 379 int mesh_network_address_all_proxies(uint16_t addr); 380 381 /** 382 * @brief Check if All Nodes address 383 * @param addr 384 * @returns 1 if all nodes 385 */ 386 int mesh_network_address_all_nodes(uint16_t addr); 387 388 /** 389 * @brief Check if All Friends address 390 * @param addr 391 * @returns 1 if all friends 392 */ 393 int mesh_network_address_all_friends(uint16_t addr); 394 395 /** 396 * @brief Check if All Relays address 397 * @param addr 398 * @returns 1 if all relays 399 */ 400 int mesh_network_address_all_relays(uint16_t addr); 401 402 403 /** 404 * @brief Check if Virtual address 405 * @param addr 406 * @returns 1 if virtual 407 */ 408 int mesh_network_address_virtual(uint16_t addr); 409 410 411 /** 412 * @brief Add subnet to list 413 * @param subnet 414 */ 415 void mesh_subnet_add(mesh_subnet_t * subnet); 416 417 /** 418 * @brief Remove subnet from list 419 * @param subnet 420 */ 421 void mesh_subnet_remove(mesh_subnet_t * subnet); 422 423 /** 424 * @brief Get subnet for netkey_index 425 * @param netkey_index 426 * @returns mesh_subnet_t or NULL 427 */ 428 mesh_subnet_t * mesh_subnet_get_by_netkey_index(uint16_t netkey_index); 429 430 /** 431 * @brief Get number of stored subnets 432 * @returns count 433 */ 434 int mesh_subnet_list_count(void); 435 436 /** 437 * @brief Iterate over all subnets 438 * @param it 439 */ 440 void mesh_subnet_iterator_init(mesh_subnet_iterator_t *it); 441 442 /** 443 * @brief Check if another subnet is available 444 * @param it 445 * @return 446 */ 447 int mesh_subnet_iterator_has_more(mesh_subnet_iterator_t *it); 448 449 /** 450 * @brief Get next subnet 451 * @param it 452 * @return 453 */ 454 mesh_subnet_t * mesh_subnet_iterator_get_next(mesh_subnet_iterator_t *it); 455 456 /** 457 * @brief Setup subnet for given netkey index 458 */ 459 void mesh_subnet_setup_for_netkey_index(uint16_t netkey_index); 460 461 462 /** 463 * @brief Get outgoing network key for subnet based on key refresh phase 464 */ 465 mesh_network_key_t * mesh_subnet_get_outgoing_network_key(mesh_subnet_t * subnet); 466 467 // buffer pool 468 mesh_network_pdu_t * mesh_network_pdu_get(void); 469 void mesh_network_pdu_free(mesh_network_pdu_t * network_pdu); 470 471 // Mesh Network PDU Getter 472 uint16_t mesh_network_control(mesh_network_pdu_t * network_pdu); 473 uint8_t mesh_network_nid(mesh_network_pdu_t * network_pdu); 474 uint8_t mesh_network_ttl(mesh_network_pdu_t * network_pdu); 475 uint32_t mesh_network_seq(mesh_network_pdu_t * network_pdu); 476 uint16_t mesh_network_src(mesh_network_pdu_t * network_pdu); 477 uint16_t mesh_network_dst(mesh_network_pdu_t * network_pdu); 478 int mesh_network_segmented(mesh_network_pdu_t * network_pdu); 479 uint8_t mesh_network_control_opcode(mesh_network_pdu_t * network_pdu); 480 uint8_t * mesh_network_pdu_data(mesh_network_pdu_t * network_pdu); 481 uint8_t mesh_network_pdu_len(mesh_network_pdu_t * network_pdu); 482 483 // Mesh Network PDU Setter 484 void mesh_network_pdu_set_seq(mesh_network_pdu_t * network_pdu, uint32_t seq); 485 486 // Testing only 487 void mesh_network_received_message(const uint8_t * pdu_data, uint8_t pdu_len, uint8_t flags); 488 void mesh_network_process_proxy_configuration_message(const uint8_t * pdu_data, uint8_t pdu_len); 489 void mesh_network_encrypt_proxy_configuration_message(mesh_network_pdu_t * network_pdu); 490 void mesh_network_dump(void); 491 void mesh_network_reset(void); 492 493 #if defined __cplusplus 494 } 495 #endif 496 497 #endif 498