1 #include <stdio.h> 2 3 #include "CppUTest/TestHarness.h" 4 #include "CppUTest/CommandLineTestRunner.h" 5 6 #include "bluetooth_data_types.h" 7 #include "bluetooth_gatt.h" 8 #include "btstack_debug.h" 9 #include "btstack_memory.h" 10 #include "btstack_util.h" 11 #include "mesh/adv_bearer.h" 12 #include "mesh/gatt_bearer.h" 13 #include "mesh/mesh_access.h" 14 #include "mesh/mesh_crypto.h" 15 #include "mesh/mesh_foundation.h" 16 #include "mesh/mesh_iv_index_seq_number.h" 17 #include "mesh/mesh_lower_transport.h" 18 #include "mesh/mesh_network.h" 19 #include "mesh/mesh_upper_transport.h" 20 #include "mesh/provisioning.h" 21 #include "mesh/mesh_peer.h" 22 23 extern "C" int mock_process_hci_cmd(void); 24 25 static mesh_network_pdu_t * received_network_pdu; 26 static mesh_network_pdu_t * received_proxy_pdu; 27 28 static uint8_t outgoing_gatt_network_pdu_data[29]; 29 static uint8_t outgoing_gatt_network_pdu_len; 30 31 static uint8_t outgoing_adv_network_pdu_data[29]; 32 static uint8_t outgoing_adv_network_pdu_len; 33 34 static uint8_t recv_upper_transport_pdu_data[100]; 35 static uint16_t recv_upper_transport_pdu_len; 36 37 #ifdef ENABLE_MESH_ADV_BEARER 38 static btstack_packet_handler_t adv_packet_handler; 39 void adv_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){ 40 adv_packet_handler = packet_handler; 41 } 42 void adv_bearer_request_can_send_now_for_network_pdu(void){ 43 // simulate can send now 44 uint8_t event[3]; 45 event[0] = HCI_EVENT_MESH_META; 46 event[1] = 1; 47 event[2] = MESH_SUBEVENT_CAN_SEND_NOW; 48 (*adv_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 49 } 50 void adv_bearer_send_network_pdu(const uint8_t * network_pdu, uint16_t size, uint8_t count, uint16_t interval){ 51 (void) count; 52 (void) interval; 53 // printf("ADV Network PDU: "); 54 // printf_hexdump(network_pdu, size); 55 memcpy(outgoing_adv_network_pdu_data, network_pdu, size); 56 outgoing_adv_network_pdu_len = size; 57 } 58 static void adv_bearer_emit_sent(void){ 59 uint8_t event[3]; 60 event[0] = HCI_EVENT_MESH_META; 61 event[1] = 1; 62 event[2] = MESH_SUBEVENT_MESSAGE_SENT; 63 (*adv_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 64 } 65 #endif 66 67 #ifdef ENABLE_MESH_GATT_BEARER 68 static btstack_packet_handler_t gatt_packet_handler; 69 void gatt_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){ 70 gatt_packet_handler = packet_handler; 71 } 72 void gatt_bearer_register_for_mesh_proxy_configuration(btstack_packet_handler_t packet_handler){ 73 } 74 void gatt_bearer_request_can_send_now_for_network_pdu(void){ 75 // simulate can send now 76 uint8_t event[3]; 77 event[0] = HCI_EVENT_MESH_META; 78 event[1] = 1; 79 event[2] = MESH_SUBEVENT_CAN_SEND_NOW; 80 (*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 81 } 82 void gatt_bearer_send_network_pdu(const uint8_t * network_pdu, uint16_t size){ 83 // printf("ADV Network PDU: "); 84 // printf_hexdump(network_pdu, size); 85 memcpy(outgoing_gatt_network_pdu_data, network_pdu, size); 86 outgoing_gatt_network_pdu_len = size; 87 } 88 static void gatt_bearer_emit_sent(void){ 89 uint8_t event[3]; 90 event[0] = HCI_EVENT_MESH_META; 91 event[1] = 1; 92 event[2] = MESH_SUBEVENT_MESSAGE_SENT; 93 (*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 94 } 95 static void gatt_bearer_emit_connected(void){ 96 uint8_t event[5]; 97 event[0] = HCI_EVENT_MESH_META; 98 event[1] = 1; 99 event[2] = MESH_SUBEVENT_PROXY_CONNECTED; 100 little_endian_store_16(event, 3, 0x1234); 101 (*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 102 } 103 #endif 104 105 // copy from mesh_message.c for now 106 uint16_t mesh_pdu_dst(mesh_pdu_t * pdu){ 107 switch (pdu->pdu_type){ 108 case MESH_PDU_TYPE_NETWORK: 109 return mesh_network_dst((mesh_network_pdu_t *) pdu); 110 case MESH_PDU_TYPE_UNSEGMENTED: 111 return mesh_network_dst(((mesh_unsegmented_pdu_t *) pdu)->segment); 112 case MESH_PDU_TYPE_ACCESS: 113 return mesh_access_dst((mesh_access_pdu_t *) pdu); 114 case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS: 115 case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS: 116 return ((mesh_upper_transport_pdu_t *) pdu)->dst; 117 default: 118 btstack_assert(false); 119 return MESH_ADDRESS_UNSASSIGNED; 120 } 121 } 122 uint16_t mesh_pdu_ctl(mesh_pdu_t * pdu){ 123 switch (pdu->pdu_type){ 124 case MESH_PDU_TYPE_NETWORK: 125 return mesh_network_control((mesh_network_pdu_t *) pdu); 126 case MESH_PDU_TYPE_ACCESS: 127 return mesh_access_ctl((mesh_access_pdu_t *) pdu); 128 default: 129 btstack_assert(false); 130 return 0; 131 } 132 } 133 134 void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){ 135 int i; 136 for (i=0; i<size; i++){ 137 if (expected[i] != actual[i]) { 138 printf("offset %u wrong\n", i); 139 printf("expected: "); printf_hexdump(expected, size); 140 printf("actual: "); printf_hexdump(actual, size); 141 } 142 BYTES_EQUAL(expected[i], actual[i]); 143 } 144 } 145 146 static int scan_hex_byte(const char * byte_string){ 147 int upper_nibble = nibble_for_char(*byte_string++); 148 if (upper_nibble < 0) return -1; 149 int lower_nibble = nibble_for_char(*byte_string); 150 if (lower_nibble < 0) return -1; 151 return (upper_nibble << 4) | lower_nibble; 152 } 153 154 static int btstack_parse_hex(const char * string, uint16_t len, uint8_t * buffer){ 155 int i; 156 for (i = 0; i < len; i++) { 157 int single_byte = scan_hex_byte(string); 158 if (single_byte < 0) return 0; 159 string += 2; 160 buffer[i] = (uint8_t)single_byte; 161 // don't check seperator after last byte 162 if (i == len - 1) { 163 return 1; 164 } 165 // optional seperator 166 char separator = *string; 167 if (separator == ':' && separator == '-' && separator == ' ') { 168 string++; 169 } 170 } 171 return 1; 172 } 173 174 #if 0 175 static void btstack_print_hex(const uint8_t * data, uint16_t len, char separator){ 176 int i; 177 for (i=0;i<len;i++){ 178 printf("%02x", data[i]); 179 if (separator){ 180 printf("%c", separator); 181 } 182 } 183 printf("\n"); 184 } 185 #endif 186 187 static mesh_transport_key_t test_application_key; 188 static void mesh_application_key_set(uint16_t netkey_index, uint16_t appkey_index, uint8_t aid, const uint8_t *application_key) { 189 test_application_key.netkey_index = netkey_index; 190 test_application_key.appkey_index = appkey_index; 191 test_application_key.aid = aid; 192 test_application_key.akf = 1; 193 memcpy(test_application_key.key, application_key, 16); 194 mesh_transport_key_add(&test_application_key); 195 } 196 197 static void load_network_key_nid_68(void){ 198 mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get(); 199 network_key->nid = 0x68; 200 btstack_parse_hex("0953fa93e7caac9638f58820220a398e", 16, network_key->encryption_key); 201 btstack_parse_hex("8b84eedec100067d670971dd2aa700cf", 16, network_key->privacy_key); 202 mesh_network_key_add(network_key); 203 mesh_subnet_setup_for_netkey_index(network_key->netkey_index); 204 } 205 206 static void load_network_key_nid_5e(void){ 207 mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get(); 208 network_key->nid = 0x5e; 209 btstack_parse_hex("be635105434859f484fc798e043ce40e", 16, network_key->encryption_key); 210 btstack_parse_hex("5d396d4b54d3cbafe943e051fe9a4eb8", 16, network_key->privacy_key); 211 mesh_network_key_add(network_key); 212 mesh_subnet_setup_for_netkey_index(network_key->netkey_index); 213 } 214 215 static void load_network_key_nid_10(void){ 216 mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get(); 217 network_key->nid = 0x10; 218 btstack_parse_hex("3a4fe84a6cc2c6a766ea93f1084d4039", 16, network_key->encryption_key); 219 btstack_parse_hex("f695fcce709ccface4d8b7a1e6e39d25", 16, network_key->privacy_key); 220 mesh_network_key_add(network_key); 221 mesh_subnet_setup_for_netkey_index(network_key->netkey_index); 222 } 223 224 static void load_provisioning_data_test_message(void){ 225 uint8_t application_key[16]; 226 btstack_parse_hex("63964771734fbd76e3b40519d1d94a48", 16, application_key); 227 mesh_application_key_set( 0, 0, 0x26, application_key); 228 229 uint8_t device_key[16]; 230 btstack_parse_hex("9d6dd0e96eb25dc19a40ed9914f8f03f", 16, device_key); 231 mesh_transport_set_device_key(device_key); 232 } 233 234 static void test_lower_transport_callback_handler(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu){ 235 switch (callback_type){ 236 case MESH_NETWORK_PDU_RECEIVED: 237 printf("test MESH_NETWORK_PDU_RECEIVED\n"); 238 received_network_pdu = network_pdu; 239 break; 240 case MESH_NETWORK_PDU_SENT: 241 printf("test MESH_NETWORK_PDU_SENT\n"); 242 mesh_lower_transport_received_message(MESH_NETWORK_PDU_SENT, network_pdu); 243 break; 244 default: 245 break; 246 } 247 } 248 249 static void test_proxy_server_callback_handler(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu){ 250 switch (callback_type){ 251 case MESH_NETWORK_PDU_RECEIVED: 252 printf("test MESH_PROXY_PDU_RECEIVED\n"); 253 received_proxy_pdu = network_pdu; 254 break; 255 case MESH_NETWORK_PDU_SENT: 256 // printf("test MESH_PROXY_PDU_SENT\n"); 257 // mesh_lower_transport_received_mesage(MESH_NETWORK_PDU_SENT, network_pdu); 258 break; 259 case MESH_NETWORK_PDU_ENCRYPTED: 260 printf("test MESH_NETWORK_PDU_ENCRYPTED\n"); 261 received_proxy_pdu = network_pdu; 262 break; 263 default: 264 break; 265 } 266 } 267 268 static void test_upper_transport_access_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){ 269 270 // ignore pdu sent 271 if (callback_type == MESH_TRANSPORT_PDU_SENT) return; 272 273 // process pdu received 274 mesh_access_pdu_t * access_pdu; 275 mesh_network_pdu_t * network_pdu; 276 mesh_segmented_pdu_t * message_pdu; 277 278 switch(pdu->pdu_type){ 279 case MESH_PDU_TYPE_ACCESS: 280 access_pdu = (mesh_access_pdu_t *) pdu; 281 printf("test access handler MESH_PDU_TYPE_ACCESS received\n"); 282 recv_upper_transport_pdu_len = access_pdu->len; 283 memcpy(recv_upper_transport_pdu_data, access_pdu->data, recv_upper_transport_pdu_len); 284 mesh_upper_transport_message_processed_by_higher_layer(pdu); 285 break; 286 case MESH_PDU_TYPE_SEGMENTED: 287 message_pdu = (mesh_segmented_pdu_t *) pdu; 288 printf("test access handler MESH_PDU_TYPE_SEGMENTED received\n"); 289 network_pdu = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&message_pdu->segments); 290 recv_upper_transport_pdu_len = mesh_network_pdu_len(network_pdu) - 1; 291 memcpy(recv_upper_transport_pdu_data, mesh_network_pdu_data(network_pdu) + 1, recv_upper_transport_pdu_len); 292 mesh_upper_transport_message_processed_by_higher_layer(pdu); 293 break; 294 default: 295 btstack_assert(0); 296 break; 297 } 298 } 299 300 static void test_upper_transport_control_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){ 301 // ignore pdu sent 302 if (callback_type == MESH_TRANSPORT_PDU_SENT) return; 303 304 // process pdu received 305 mesh_control_pdu_t * control_pdu; 306 switch(pdu->pdu_type){ 307 case MESH_PDU_TYPE_CONTROL: 308 control_pdu = (mesh_control_pdu_t *) pdu; 309 printf("test MESH_PDU_TYPE_CONTROL\n"); 310 recv_upper_transport_pdu_len = control_pdu->len + 1; 311 recv_upper_transport_pdu_data[0] = control_pdu->akf_aid_control; 312 memcpy(&recv_upper_transport_pdu_data[1], control_pdu->data, control_pdu->len); 313 mesh_upper_transport_message_processed_by_higher_layer(pdu); 314 break; 315 default: 316 btstack_assert(0); 317 break; 318 } 319 } 320 321 TEST_GROUP(MessageTest){ 322 void setup(void){ 323 btstack_memory_init(); 324 btstack_crypto_init(); 325 load_provisioning_data_test_message(); 326 mesh_network_init(); 327 mesh_lower_transport_init(); 328 mesh_upper_transport_init(); 329 mesh_network_key_init(); 330 // intercept messages between network and lower layer 331 mesh_network_set_higher_layer_handler(&test_lower_transport_callback_handler); 332 mesh_network_set_proxy_message_handler(&test_proxy_server_callback_handler); 333 // register to receive upper transport messages 334 mesh_upper_transport_register_access_message_handler(&test_upper_transport_access_message_handler); 335 mesh_upper_transport_register_control_message_handler(&test_upper_transport_control_message_handler); 336 mesh_seq_auth_reset(); 337 #ifdef ENABLE_MESH_GATT_BEARER 338 mesh_foundation_gatt_proxy_set(1); 339 gatt_bearer_emit_connected(); 340 #endif 341 outgoing_gatt_network_pdu_len = 0; 342 outgoing_adv_network_pdu_len = 0; 343 received_network_pdu = NULL; 344 recv_upper_transport_pdu_len =0; 345 } 346 void teardown(void){ 347 // printf("-- teardown start --\n\n"); 348 btstack_crypto_reset(); 349 mesh_network_reset(); 350 mesh_lower_transport_reset(); 351 mesh_upper_transport_dump(); 352 mesh_upper_transport_reset(); 353 // mesh_network_dump(); 354 // mesh_transport_dump(); 355 printf("-- teardown complete --\n\n"); 356 } 357 }; 358 359 static uint8_t transport_pdu_data[64]; 360 static uint16_t transport_pdu_len; 361 362 static uint8_t test_network_pdu_len; 363 static uint8_t test_network_pdu_data[29]; 364 365 void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_transport_pdus, char * access_pdu){ 366 int i; 367 for (i=0;i<count;i++){ 368 test_network_pdu_len = strlen(network_pdus[i]) / 2; 369 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 370 371 mesh_network_received_message(test_network_pdu_data, test_network_pdu_len, 0); 372 373 while (received_network_pdu == NULL) { 374 mock_process_hci_cmd(); 375 } 376 377 transport_pdu_len = strlen(lower_transport_pdus[i]) / 2; 378 btstack_parse_hex(lower_transport_pdus[i], transport_pdu_len, transport_pdu_data); 379 380 uint8_t * lower_transport_pdu = mesh_network_pdu_data(received_network_pdu); 381 uint8_t lower_transport_pdu_len = mesh_network_pdu_len(received_network_pdu); 382 383 // printf_hexdump(lower_transport_pdu, lower_transport_pdu_len); 384 385 CHECK_EQUAL( transport_pdu_len, lower_transport_pdu_len); 386 CHECK_EQUAL_ARRAY(transport_pdu_data, lower_transport_pdu, transport_pdu_len); 387 388 // forward to mesh_transport 389 mesh_lower_transport_received_message(MESH_NETWORK_PDU_RECEIVED, received_network_pdu); 390 391 // done 392 received_network_pdu = NULL; 393 } 394 395 // wait for tranport pdu 396 while (recv_upper_transport_pdu_len == 0) { 397 mock_process_hci_cmd(); 398 } 399 400 transport_pdu_len = strlen(access_pdu) / 2; 401 btstack_parse_hex(access_pdu, transport_pdu_len, transport_pdu_data); 402 403 printf("UpperTransportPDU: "); 404 printf_hexdump(recv_upper_transport_pdu_data, recv_upper_transport_pdu_len); 405 CHECK_EQUAL( transport_pdu_len, recv_upper_transport_pdu_len); 406 CHECK_EQUAL_ARRAY(transport_pdu_data, recv_upper_transport_pdu_data, transport_pdu_len); 407 } 408 409 static void expect_gatt_network_pdu(const uint8_t * data, uint16_t len){ 410 while (outgoing_gatt_network_pdu_len == 0) { 411 mock_process_hci_cmd(); 412 } 413 414 if (outgoing_gatt_network_pdu_len != test_network_pdu_len){ 415 printf("Test Network PDU (%u): ", outgoing_gatt_network_pdu_len); printf_hexdump(outgoing_gatt_network_pdu_data, outgoing_gatt_network_pdu_len); 416 printf("Expected PDU (%u): ", test_network_pdu_len); printf_hexdump(test_network_pdu_data, test_network_pdu_len); 417 } 418 CHECK_EQUAL( outgoing_gatt_network_pdu_len, test_network_pdu_len); 419 CHECK_EQUAL_ARRAY(test_network_pdu_data, outgoing_gatt_network_pdu_data, test_network_pdu_len); 420 421 outgoing_gatt_network_pdu_len = 0; 422 gatt_bearer_emit_sent(); 423 } 424 425 static void expect_adv_network_pdu(const uint8_t * data, uint16_t len){ 426 while (outgoing_adv_network_pdu_len == 0) { 427 mock_process_hci_cmd(); 428 } 429 430 if (outgoing_adv_network_pdu_len != test_network_pdu_len){ 431 printf("Test Network PDU (%u): ", outgoing_adv_network_pdu_len); printf_hexdump(outgoing_adv_network_pdu_data, outgoing_adv_network_pdu_len); 432 printf("Expected PDU (%u): ", test_network_pdu_len); printf_hexdump(test_network_pdu_data, test_network_pdu_len); 433 } 434 CHECK_EQUAL( outgoing_adv_network_pdu_len, test_network_pdu_len); 435 CHECK_EQUAL_ARRAY(test_network_pdu_data, outgoing_adv_network_pdu_data, test_network_pdu_len); 436 437 outgoing_adv_network_pdu_len = 0; 438 adv_bearer_emit_sent(); 439 } 440 441 void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){ 442 443 transport_pdu_len = strlen(control_pdu) / 2; 444 btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data); 445 446 static mesh_upper_transport_pdu_t upper_pdu = { 0 }; 447 upper_pdu.flags = 0; 448 449 mesh_pdu_t * pdu = (mesh_pdu_t *) &upper_pdu; 450 if (count == 1 ){ 451 // send as unsegmented access pdu 452 upper_pdu.pdu_header.pdu_type = MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS; 453 } else { 454 // send as segmented access pdu 455 upper_pdu.pdu_header.pdu_type = MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS; 456 } 457 mesh_upper_transport_setup_access_pdu(pdu, netkey_index, appkey_index, ttl, src, dest, szmic, transport_pdu_data, transport_pdu_len); 458 mesh_upper_transport_send_access_pdu(pdu); 459 460 // check for all network pdus 461 int i; 462 for (i=0;i<count;i++){ 463 // parse expected network pdu 464 test_network_pdu_len = strlen(network_pdus[i]) / 2; 465 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 466 467 #ifdef ENABLE_MESH_GATT_BEARER 468 expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len); 469 #endif 470 471 #ifdef ENABLE_MESH_ADV_BEARER 472 expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len); 473 #endif 474 } 475 // free segments 476 while (btstack_linked_list_empty(&upper_pdu.segments) == false){ 477 mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&upper_pdu.segments); 478 mesh_network_pdu_free(network_pdu); 479 } 480 } 481 482 void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src, uint16_t dest, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){ 483 484 transport_pdu_len = strlen(control_pdu) / 2; 485 btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data); 486 487 uint8_t opcode = transport_pdu_data[0]; 488 489 mesh_pdu_t * pdu; 490 if (transport_pdu_len < 12){ 491 // send as unsegmented control pdu 492 pdu = (mesh_pdu_t *) mesh_network_pdu_get(); 493 } else { 494 // send as segmented control pdu 495 pdu = (mesh_pdu_t *) mesh_transport_pdu_get(); 496 } 497 mesh_upper_transport_setup_control_pdu(pdu, netkey_index, ttl, src, dest, opcode, transport_pdu_data+1, transport_pdu_len-1); 498 mesh_upper_transport_send_control_pdu(pdu); 499 500 // check for all network pdus 501 int i; 502 for (i=0;i<count;i++){ 503 // expected network pdu 504 test_network_pdu_len = strlen(network_pdus[i]) / 2; 505 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 506 507 #ifdef ENABLE_MESH_GATT_BEARER 508 expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len); 509 #endif 510 511 #ifdef ENABLE_MESH_ADV_BEARER 512 expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len); 513 #endif 514 515 } 516 } 517 #if 1 518 // Message 1 519 char * message1_network_pdus[] = { 520 (char *) "68eca487516765b5e5bfdacbaf6cb7fb6bff871f035444ce83a670df" 521 }; 522 char * message1_lower_transport_pdus[] = { 523 (char *) "034b50057e400000010000", 524 }; 525 char * message1_upper_transport_pdu = (char *) "034b50057e400000010000"; 526 TEST(MessageTest, Message1Receive){ 527 load_network_key_nid_68(); 528 mesh_set_iv_index(0x12345678); 529 test_receive_network_pdus(1, message1_network_pdus, message1_lower_transport_pdus, message1_upper_transport_pdu); 530 } 531 TEST(MessageTest, Message1Send){ 532 uint16_t netkey_index = 0; 533 uint8_t ttl = 0; 534 uint16_t src = 0x1201; 535 uint16_t dest = 0xfffd; 536 uint32_t seq = 1; 537 load_network_key_nid_68(); 538 mesh_set_iv_index(0x12345678); 539 mesh_sequence_number_set(seq); 540 test_send_control_message(netkey_index, ttl, src, dest, message1_upper_transport_pdu, 1, message1_lower_transport_pdus, message1_network_pdus); 541 } 542 543 // Message 2 544 char * message2_network_pdus[] = { 545 (char *) "68d4c826296d7979d7dbc0c9b4d43eebec129d20a620d01e" 546 }; 547 char * message2_lower_transport_pdus[] = { 548 (char *) "04320308ba072f", 549 }; 550 char * message2_upper_transport_pdu = (char *) "04320308ba072f"; 551 TEST(MessageTest, Message2Receive){ 552 load_network_key_nid_68(); 553 mesh_set_iv_index(0x12345678); 554 test_receive_network_pdus(1, message2_network_pdus, message2_lower_transport_pdus, message2_upper_transport_pdu); 555 } 556 TEST(MessageTest, Message2Send){ 557 uint16_t netkey_index = 0; 558 uint8_t ttl = 0; 559 uint16_t src = 0x2345; 560 uint16_t dest = 0x1201; 561 uint32_t seq = 0x014820; 562 load_network_key_nid_68(); 563 mesh_set_iv_index(0x12345678); 564 mesh_sequence_number_set(seq); 565 test_send_control_message(netkey_index, ttl, src, dest, message2_upper_transport_pdu, 1, message2_lower_transport_pdus, message2_network_pdus); 566 } 567 568 // Message 3 569 char * message3_network_pdus[] = { 570 (char *) "68da062bc96df253273086b8c5ee00bdd9cfcc62a2ddf572" 571 }; 572 char * message3_lower_transport_pdus[] = { 573 (char *) "04fa0205a6000a", 574 }; 575 char * message3_upper_transport_pdu = (char *) "04fa0205a6000a"; 576 TEST(MessageTest, Message3Receive){ 577 load_network_key_nid_68(); 578 mesh_set_iv_index(0x12345678); 579 test_receive_network_pdus(1, message3_network_pdus, message3_lower_transport_pdus, message3_upper_transport_pdu); 580 } 581 TEST(MessageTest, Message3Send){ 582 uint16_t netkey_index = 0; 583 uint8_t ttl = 0; 584 uint16_t src = 0x2fe3; 585 uint16_t dest = 0x1201; 586 uint32_t seq = 0x2b3832; 587 load_network_key_nid_68(); 588 mesh_set_iv_index(0x12345678); 589 mesh_sequence_number_set(seq); 590 test_send_control_message(netkey_index, ttl, src, dest, message3_upper_transport_pdu, 1, message3_lower_transport_pdus, message3_network_pdus); 591 } 592 593 // Message 4 594 char * message4_network_pdus[] = { 595 (char *) "5e84eba092380fb0e5d0ad970d579a4e88051c" 596 }; 597 char * message4_lower_transport_pdus[] = { 598 (char *) "0100", 599 }; 600 char * message4_upper_transport_pdu = (char *) "0100"; 601 TEST(MessageTest, Message4Receive){ 602 load_network_key_nid_5e(); 603 mesh_set_iv_index(0x12345678); 604 test_receive_network_pdus(1, message4_network_pdus, message4_lower_transport_pdus, message4_upper_transport_pdu); 605 } 606 TEST(MessageTest, Message4Send){ 607 uint16_t netkey_index = 0; 608 uint8_t ttl = 0; 609 uint16_t src = 0x1201; 610 uint16_t dest = 0x2345; 611 uint32_t seq = 0x000002; 612 load_network_key_nid_5e(); 613 mesh_set_iv_index(0x12345678); 614 mesh_sequence_number_set(seq); 615 test_send_control_message(netkey_index, ttl, src, dest, message4_upper_transport_pdu, 1, message4_lower_transport_pdus, message4_network_pdus); 616 } 617 618 // Message 5 619 char * message5_network_pdus[] = { 620 (char *) "5eafd6f53c43db5c39da1792b1fee9ec74b786c56d3a9dee", 621 }; 622 char * message5_lower_transport_pdus[] = { 623 (char *) "02001234567800", 624 }; 625 char * message5_upper_transport_pdu = (char *) "02001234567800"; 626 TEST(MessageTest, Message5Receive){ 627 load_network_key_nid_5e(); 628 mesh_set_iv_index(0x12345678); 629 test_receive_network_pdus(1, message5_network_pdus, message5_lower_transport_pdus, message5_upper_transport_pdu); 630 } 631 TEST(MessageTest, Message5Send){ 632 uint16_t netkey_index = 0; 633 uint8_t ttl = 0; 634 uint16_t src = 0x2345; 635 uint16_t dest = 0x1201; 636 uint32_t seq = 0x014834; 637 load_network_key_nid_5e(); 638 mesh_set_iv_index(0x12345678); 639 mesh_sequence_number_set(seq); 640 test_send_control_message(netkey_index, ttl, src, dest, message5_upper_transport_pdu, 1, message5_lower_transport_pdus, message5_network_pdus); 641 } 642 643 // Message 6 644 char * message6_network_pdus[] = { 645 (char *) "68cab5c5348a230afba8c63d4e686364979deaf4fd40961145939cda0e", 646 (char *) "681615b5dd4a846cae0c032bf0746f44f1b8cc8ce5edc57e55beed49c0", 647 }; 648 char * message6_lower_transport_pdus[] = { 649 (char *) "8026ac01ee9dddfd2169326d23f3afdf", 650 (char *) "8026ac21cfdc18c52fdef772e0e17308", 651 }; 652 char * message6_upper_transport_pdu = (char *) "0056341263964771734fbd76e3b40519d1d94a48"; 653 TEST(MessageTest, Message6Receive){ 654 load_network_key_nid_68(); 655 mesh_set_iv_index(0x12345678); 656 test_receive_network_pdus(2, message6_network_pdus, message6_lower_transport_pdus, message6_upper_transport_pdu); 657 } 658 TEST(MessageTest, Message6Send){ 659 uint16_t netkey_index = 0; 660 uint16_t appkey_index = MESH_DEVICE_KEY_INDEX; 661 uint8_t ttl = 4; 662 uint16_t src = 0x0003; 663 uint16_t dest = 0x1201; 664 uint32_t seq = 0x3129ab; 665 uint8_t szmic = 0; 666 667 load_network_key_nid_68(); 668 mesh_set_iv_index(0x12345678); 669 mesh_sequence_number_set(seq); 670 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message6_upper_transport_pdu, 2, message6_lower_transport_pdus, message6_network_pdus); 671 } 672 673 // Message 7 - ACK 674 char * message7_network_pdus[] = { 675 (char *) "68e476b5579c980d0d730f94d7f3509df987bb417eb7c05f", 676 }; 677 char * message7_lower_transport_pdus[] = { 678 (char *) "00a6ac00000002", 679 }; 680 char * message7_upper_transport_pdu = (char *) "00a6ac00000002"; 681 TEST(MessageTest, Message7Send){ 682 uint16_t netkey_index = 0; 683 uint8_t ttl = 0x0b; 684 uint16_t src = 0x2345; 685 uint16_t dest = 0x0003; 686 uint32_t seq = 0x014835; 687 688 load_network_key_nid_68(); 689 mesh_set_iv_index(0x12345678); 690 mesh_sequence_number_set(seq); 691 test_send_control_message(netkey_index, ttl, src, dest, message7_upper_transport_pdu, 1, message7_lower_transport_pdus, message7_network_pdus); 692 } 693 // ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu 694 // TEST(MessageTest, Message7Receive){ 695 // mesh_set_iv_index(0x12345678); 696 // test_receive_network_pdus(1, message7_network_pdus, message7_lower_transport_pdus, message7_upper_transport_pdu); 697 // } 698 699 // Message 8 - ACK 700 char * message8_network_pdus[] = { 701 (char *) "684daa6267c2cf0e2f91add6f06e66006844cec97f973105ae2534f958", 702 }; 703 char * message8_lower_transport_pdus[] = { 704 (char *) "8026ac01ee9dddfd2169326d23f3afdf", 705 }; 706 char * message8_upper_transport_pdu = (char *) "8026ac01ee9dddfd2169326d23f3afdf"; 707 // ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu 708 // TEST(MessageTest, Message8Receive){ 709 // mesh_set_iv_index(0x12345678); 710 // test_receive_network_pdus(1, message8_network_pdus, message8_lower_transport_pdus, message8_upper_transport_pdu); 711 // } 712 713 // Message 9 - ACK 714 715 // Message 10 716 char * message10_network_pdus[] = { 717 (char *) "5e7b786568759f7777ed355afaf66d899c1e3d", 718 }; 719 char * message10_lower_transport_pdus[] = { 720 (char *) "0101", 721 }; 722 char * message10_upper_transport_pdu = (char *) "0101"; 723 TEST(MessageTest, Message10Receive){ 724 load_network_key_nid_5e(); 725 mesh_set_iv_index(0x12345678); 726 test_receive_network_pdus(1, message10_network_pdus, message10_lower_transport_pdus, message10_upper_transport_pdu); 727 } 728 TEST(MessageTest, Message10Send){ 729 uint16_t netkey_index = 0; 730 uint8_t ttl = 0; 731 uint16_t src = 0x1201; 732 uint16_t dest = 0x2345; 733 uint32_t seq = 0x000003; 734 735 load_network_key_nid_5e(); 736 mesh_set_iv_index(0x12345678); 737 mesh_sequence_number_set(seq); 738 test_send_control_message(netkey_index, ttl, src, dest, message10_upper_transport_pdu, 1, message10_lower_transport_pdus, message10_network_pdus); 739 } 740 741 // Message 11 742 // The Friend node responds to this poll with the first segment of the stored message. It also indicates that it has more data. 743 744 // Message 12 745 char * message12_network_pdus[] = { 746 (char *) "5e8a18fc6e4d05ae21466087599c2426ce9a35", 747 }; 748 char * message12_lower_transport_pdus[] = { 749 (char *) "0101", 750 }; 751 char * message12_upper_transport_pdu = (char *) "0101"; 752 TEST(MessageTest, Message12Receive){ 753 load_network_key_nid_5e(); 754 mesh_set_iv_index(0x12345678); 755 test_receive_network_pdus(1, message12_network_pdus, message12_lower_transport_pdus, message12_upper_transport_pdu); 756 } 757 TEST(MessageTest, Message12Send){ 758 uint16_t netkey_index = 0; 759 uint8_t ttl = 0; 760 uint16_t src = 0x1201; 761 uint16_t dest = 0x2345; 762 uint32_t seq = 0x000004; 763 764 load_network_key_nid_5e(); 765 mesh_set_iv_index(0x12345678); 766 mesh_sequence_number_set(seq); 767 test_send_control_message(netkey_index, ttl, src, dest, message12_upper_transport_pdu, 1, message12_lower_transport_pdus, message12_network_pdus); 768 } 769 770 // Message 13 771 // The Friend node responds with the same message as last time. 772 // Message 14 773 // The Low Power node received the retransmitted stored message. As that message has the MD bit set 774 // it sends another Friend Poll to obtain the next message. 775 char * message14_network_pdus[] = { 776 (char *) "5e0bbaf92b5c8f7d3ae62a3c75dff683dce24e", 777 }; 778 char * message14_lower_transport_pdus[] = { 779 (char *) "0100", 780 }; 781 char * message14_upper_transport_pdu = (char *) "0100"; 782 TEST(MessageTest, Message14Receive){ 783 load_network_key_nid_5e(); 784 mesh_set_iv_index(0x12345678); 785 test_receive_network_pdus(1, message14_network_pdus, message14_lower_transport_pdus, message14_upper_transport_pdu); 786 } 787 TEST(MessageTest, Message14Send){ 788 uint16_t netkey_index = 0; 789 uint8_t ttl = 0; 790 uint16_t src = 0x1201; 791 uint16_t dest = 0x2345; 792 uint32_t seq = 0x000005; 793 794 load_network_key_nid_5e(); 795 mesh_set_iv_index(0x12345678); 796 mesh_sequence_number_set(seq); 797 test_send_control_message(netkey_index, ttl, src, dest, message14_upper_transport_pdu, 1, message14_lower_transport_pdus, message14_network_pdus); 798 } 799 800 // Message 15 801 // The Friend node responds, with the next message in the friend queue. The Friend node has no more data, so it sets the MD to 0. 802 char * message15_network_pdus[] = { 803 (char *) "5ea8dab50e7ee7f1d29805664d235eacd707217dedfe78497fefec7391", 804 }; 805 char * message15_lower_transport_pdus[] = { 806 (char *) "8026ac21cfdc18c52fdef772e0e17308", 807 }; 808 char * message15_upper_transport_pdu = (char *) "0100"; 809 // ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu 810 // not sure - no upper access message 811 // TEST(MessageTest, Message15Receive){ 812 // load_network_key_nid_5e(); 813 // mesh_set_iv_index(0x12345678); 814 // test_receive_network_pdus(1, message15_network_pdus, message15_lower_transport_pdus, message15_upper_transport_pdu); 815 // } 816 817 // Message 16 818 char * message16_network_pdus[] = { 819 (char *) "68e80e5da5af0e6b9be7f5a642f2f98680e61c3a8b47f228", 820 }; 821 char * message16_lower_transport_pdus[] = { 822 (char *) "0089511bf1d1a81c11dcef", 823 }; 824 char * message16_upper_transport_pdu = (char *) "800300563412"; 825 TEST(MessageTest, Message16Receive){ 826 load_network_key_nid_68(); 827 mesh_set_iv_index(0x12345678); 828 test_receive_network_pdus(1, message16_network_pdus, message16_lower_transport_pdus, message16_upper_transport_pdu); 829 } 830 TEST(MessageTest, Message16Send){ 831 uint16_t netkey_index = 0; 832 uint16_t appkey_index = MESH_DEVICE_KEY_INDEX; 833 uint8_t ttl = 0x0b; 834 uint16_t src = 0x1201; 835 uint16_t dest = 0x0003; 836 uint32_t seq = 0x000006; 837 uint8_t szmic = 0; 838 839 load_network_key_nid_68(); 840 mesh_set_iv_index(0x12345678); 841 mesh_sequence_number_set(seq); 842 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message16_upper_transport_pdu, 1, message16_lower_transport_pdus, message16_network_pdus); 843 } 844 845 // Message 17 846 // A Relay node receives the message from the Low Power node and relays it, decrementing the TTL value. 847 // Message 18 848 char * message18_network_pdus[] = { 849 (char *) "6848cba437860e5673728a627fb938535508e21a6baf57", 850 }; 851 char * message18_lower_transport_pdus[] = { 852 (char *) "665a8bde6d9106ea078a", 853 }; 854 char * message18_upper_transport_pdu = (char *) "0400000000"; 855 TEST(MessageTest, Message18Receive){ 856 load_network_key_nid_68(); 857 mesh_set_iv_index(0x12345678); 858 test_receive_network_pdus(1, message18_network_pdus, message18_lower_transport_pdus, message18_upper_transport_pdu); 859 } 860 TEST(MessageTest, Message18Send){ 861 uint16_t netkey_index = 0; 862 uint16_t appkey_index = 0; 863 uint8_t ttl = 3; 864 uint16_t src = 0x1201; 865 uint16_t dest = 0xffff; 866 uint32_t seq = 0x00007; 867 uint8_t szmic = 0; 868 869 load_network_key_nid_68(); 870 mesh_set_iv_index(0x12345678); 871 mesh_sequence_number_set(seq); 872 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message18_upper_transport_pdu, 1, message18_lower_transport_pdus, message18_network_pdus); 873 } 874 875 876 // Message 19 877 // The Low Power node sends another Health Current Status message indicating that there are three faults: 878 // Battery Low Warning, Power Supply Interrupted Warning, and Supply Voltage Too Low Warning. 879 char * message19_network_pdus[] = { 880 (char *) "68110edeecd83c3010a05e1b23a926023da75d25ba91793736", 881 }; 882 char * message19_lower_transport_pdus[] = { 883 (char *) "66ca6cd88e698d1265f43fc5", 884 }; 885 char * message19_upper_transport_pdu = (char *) "04000000010703"; 886 TEST(MessageTest, Message19Receive){ 887 load_network_key_nid_68(); 888 mesh_set_iv_index(0x12345678); 889 test_receive_network_pdus(1, message19_network_pdus, message19_lower_transport_pdus, message19_upper_transport_pdu); 890 } 891 TEST(MessageTest, Message19Send){ 892 uint16_t netkey_index = 0; 893 uint16_t appkey_index = 0; 894 uint8_t ttl = 3; 895 uint16_t src = 0x1201; 896 uint16_t dest = 0xffff; 897 uint32_t seq = 0x00009; 898 uint8_t szmic = 0; 899 900 load_network_key_nid_68(); 901 mesh_set_iv_index(0x12345678); 902 mesh_sequence_number_set(seq); 903 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message19_upper_transport_pdu, 1, message19_lower_transport_pdus, message19_network_pdus); 904 } 905 906 // Message 20 907 char * message20_network_pdus[] = { 908 (char *) "e85cca51e2e8998c3dc87344a16c787f6b08cc897c941a5368", 909 }; 910 char * message20_lower_transport_pdus[] = { 911 (char *) "669c9803e110fea929e9542d", 912 }; 913 char * message20_upper_transport_pdu = (char *) "04000000010703"; 914 TEST(MessageTest, Message20Receive){ 915 load_network_key_nid_68(); 916 mesh_set_iv_index(0x12345677); 917 test_receive_network_pdus(1, message20_network_pdus, message20_lower_transport_pdus, message20_upper_transport_pdu); 918 } 919 TEST(MessageTest, Message20Send){ 920 uint16_t netkey_index = 0; 921 uint16_t appkey_index = 0; 922 uint8_t ttl = 3; 923 uint16_t src = 0x1234; 924 uint16_t dest = 0xffff; 925 uint32_t seq = 0x070809; 926 uint8_t szmic = 0; 927 928 load_network_key_nid_68(); 929 mesh_set_iv_index(0x12345677); 930 mesh_sequence_number_set(seq); 931 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message20_upper_transport_pdu, 1, message20_lower_transport_pdus, message20_network_pdus); 932 } 933 934 // Message 21 935 // The Low Power node sends a vendor command to a group address. 936 char * message21_network_pdus[] = { 937 (char *) "e84e8fbe003f58a4d61157bb76352ea6307eebfe0f30b83500e9", 938 }; 939 char * message21_lower_transport_pdus[] = { 940 (char *) "664d92e9dfcf3ab85b6e8fcf03", 941 }; 942 char * message21_upper_transport_pdu = (char *) "d50a0048656c6c6f"; 943 TEST(MessageTest, Message21Receive){ 944 load_network_key_nid_68(); 945 mesh_set_iv_index(0x12345677); 946 test_receive_network_pdus(1, message21_network_pdus, message21_lower_transport_pdus, message21_upper_transport_pdu); 947 } 948 TEST(MessageTest, Message21Send){ 949 uint16_t netkey_index = 0; 950 uint16_t appkey_index = 0; 951 uint8_t ttl = 3; 952 uint16_t src = 0x1234; 953 uint16_t dest = 0xc105; 954 uint32_t seq = 0x07080a; 955 uint8_t szmic = 0; 956 957 load_network_key_nid_68(); 958 mesh_set_iv_index(0x12345677); 959 mesh_sequence_number_set(seq); 960 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message21_upper_transport_pdu, 1, message21_lower_transport_pdus, message21_network_pdus); 961 } 962 963 // Message 22 964 char * message22_network_pdus[] = { 965 (char *) "e8d85caecef1e3ed31f3fdcf88a411135fea55df730b6b28e255", 966 }; 967 char * message22_lower_transport_pdus[] = { 968 (char *) "663871b904d431526316ca48a0", 969 }; 970 char * message22_upper_transport_pdu = (char *) "d50a0048656c6c6f"; 971 char * message22_label_string = (char *) "0073e7e4d8b9440faf8415df4c56c0e1"; 972 973 TEST(MessageTest, Message22Receive){ 974 load_network_key_nid_68(); 975 mesh_set_iv_index(0x12345677); 976 uint8_t label_uuid[16]; 977 btstack_parse_hex(message22_label_string, 16, label_uuid); 978 mesh_virtual_address_register(label_uuid, 0xb529); 979 test_receive_network_pdus(1, message22_network_pdus, message22_lower_transport_pdus, message22_upper_transport_pdu); 980 } 981 982 TEST(MessageTest, Message22Send){ 983 uint16_t netkey_index = 0; 984 uint16_t appkey_index = 0; 985 uint8_t ttl = 3; 986 uint16_t src = 0x1234; 987 uint32_t seq = 0x07080b; 988 uint8_t szmic = 0; 989 990 load_network_key_nid_68(); 991 mesh_set_iv_index(0x12345677); 992 mesh_sequence_number_set(seq); 993 uint8_t label_uuid[16]; 994 btstack_parse_hex(message22_label_string, 16, label_uuid); 995 mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0xb529); 996 uint16_t pseudo_dst = virtual_address->pseudo_dst; 997 test_send_access_message(netkey_index, appkey_index, ttl, src, pseudo_dst, szmic, message22_upper_transport_pdu, 1, message22_lower_transport_pdus, message22_network_pdus); 998 } 999 1000 // Message 23 1001 char * message23_network_pdus[] = { 1002 (char *) "e877a48dd5fe2d7a9d696d3dd16a75489696f0b70c711b881385", 1003 }; 1004 char * message23_lower_transport_pdus[] = { 1005 (char *) "662456db5e3100eef65daa7a38", 1006 }; 1007 char * message23_upper_transport_pdu = (char *) "d50a0048656c6c6f"; 1008 char * message23_label_string = (char *) "f4a002c7fb1e4ca0a469a021de0db875"; 1009 1010 TEST(MessageTest, Message23Receive){ 1011 load_network_key_nid_68(); 1012 mesh_set_iv_index(0x12345677); 1013 uint8_t label_uuid[16]; 1014 btstack_parse_hex(message23_label_string, 16, label_uuid); 1015 mesh_virtual_address_register(label_uuid, 0x9736); 1016 test_receive_network_pdus(1, message23_network_pdus, message23_lower_transport_pdus, message23_upper_transport_pdu); 1017 } 1018 TEST(MessageTest, Message23Send){ 1019 uint16_t netkey_index = 0; 1020 uint16_t appkey_index = 0; 1021 uint8_t ttl = 3; 1022 uint16_t src = 0x1234; 1023 uint32_t seq = 0x07080c; 1024 uint8_t szmic = 0; 1025 1026 load_network_key_nid_68(); 1027 mesh_set_iv_index(0x12345677); 1028 mesh_sequence_number_set(seq); 1029 uint8_t label_uuid[16]; 1030 btstack_parse_hex(message23_label_string, 16, label_uuid); 1031 mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0x9736); 1032 uint16_t pseudo_dst = virtual_address->pseudo_dst; 1033 test_send_access_message(netkey_index, appkey_index, ttl, src, pseudo_dst, szmic, message23_upper_transport_pdu, 1, message23_lower_transport_pdus, message23_network_pdus); 1034 } 1035 #endif 1036 1037 // Message 24 1038 char * message24_network_pdus[] = { 1039 (char *) "e8624e65bb8c1794e998b4081f47a35251fdd3896d99e4db489b918599", 1040 (char *) "e8a7d0f0a2ea42dc2f4dd6fb4db33a6c088d023b47", 1041 }; 1042 char * message24_lower_transport_pdus[] = { 1043 (char *) "e6a03401c3c51d8e476b28e3aa5001f3", 1044 (char *) "e6a034211c01cea6", 1045 }; 1046 char * message24_upper_transport_pdu = (char *) "ea0a00576f726c64"; 1047 char * message24_label_string = (char *) "f4a002c7fb1e4ca0a469a021de0db875"; 1048 TEST(MessageTest, Message24Receive){ 1049 load_network_key_nid_68(); 1050 mesh_set_iv_index(0x12345677); 1051 uint8_t label_uuid[16]; 1052 btstack_parse_hex(message24_label_string, 16, label_uuid); 1053 mesh_virtual_address_register(label_uuid, 0x9736); 1054 test_receive_network_pdus(2, message24_network_pdus, message24_lower_transport_pdus, message24_upper_transport_pdu); 1055 } 1056 TEST(MessageTest, Message24Send){ 1057 uint16_t netkey_index = 0; 1058 uint16_t appkey_index = 0; 1059 uint8_t ttl = 3; 1060 uint16_t src = 0x1234; 1061 uint32_t seq = 0x07080d; 1062 uint8_t szmic = 1; 1063 1064 load_network_key_nid_68(); 1065 mesh_set_iv_index(0x12345677); 1066 mesh_sequence_number_set(seq); 1067 uint8_t label_uuid[16]; 1068 btstack_parse_hex(message24_label_string, 16, label_uuid); 1069 mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0x9736); 1070 uint16_t pseudo_dst = virtual_address->pseudo_dst; 1071 test_send_access_message(netkey_index, appkey_index, ttl, src, pseudo_dst, szmic, message24_upper_transport_pdu, 2, message24_lower_transport_pdus, message24_network_pdus); 1072 } 1073 1074 // Proxy Configuration Test 1075 char * proxy_config_pdus[] = { 1076 (char *) "0210386bd60efbbb8b8c28512e792d3711f4b526", 1077 }; 1078 char * proxy_config_lower_transport_pdus[] = { 1079 (char *) "0000", 1080 }; 1081 char * proxy_config_upper_transport_pdu = (char *) "ea0a00576f726c64"; 1082 TEST(MessageTest, ProxyConfigReceive){ 1083 mesh_set_iv_index(0x12345678); 1084 load_network_key_nid_10(); 1085 int i = 0; 1086 char ** network_pdus = proxy_config_pdus; 1087 test_network_pdu_len = strlen(network_pdus[i]) / 2; 1088 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 1089 mesh_network_process_proxy_configuration_message(&test_network_pdu_data[1], test_network_pdu_len-1); 1090 while (received_proxy_pdu == NULL) { 1091 mock_process_hci_cmd(); 1092 } 1093 char ** lower_transport_pdus = proxy_config_lower_transport_pdus; 1094 transport_pdu_len = strlen(lower_transport_pdus[i]) / 2; 1095 btstack_parse_hex(lower_transport_pdus[i], transport_pdu_len, transport_pdu_data); 1096 1097 uint8_t * lower_transport_pdu = mesh_network_pdu_data(received_proxy_pdu); 1098 uint8_t lower_transport_pdu_len = mesh_network_pdu_len(received_proxy_pdu); 1099 1100 // printf_hexdump(lower_transport_pdu, lower_transport_pdu_len); 1101 1102 CHECK_EQUAL( transport_pdu_len, lower_transport_pdu_len); 1103 CHECK_EQUAL_ARRAY(transport_pdu_data, lower_transport_pdu, transport_pdu_len); 1104 1105 // done 1106 mesh_network_message_processed_by_higher_layer(received_proxy_pdu); 1107 received_proxy_pdu = NULL; 1108 } 1109 1110 1111 TEST(MessageTest, ProxyConfigSend){ 1112 uint16_t netkey_index = 0; 1113 uint8_t ctl = 1; 1114 uint8_t ttl = 0; 1115 uint16_t src = 1; 1116 uint16_t dest = 0; 1117 uint32_t seq = 1; 1118 uint8_t nid = 0x10; 1119 mesh_set_iv_index(0x12345678); 1120 load_network_key_nid_10(); 1121 mesh_network_pdu_t * network_pdu = mesh_network_pdu_get(); 1122 uint8_t data[] = { 0 , 0 }; 1123 mesh_network_setup_pdu(network_pdu, netkey_index, nid, ctl, ttl, seq, src, dest, data, sizeof(data)); 1124 mesh_network_encrypt_proxy_configuration_message(network_pdu); 1125 while (received_proxy_pdu == NULL) { 1126 mock_process_hci_cmd(); 1127 } 1128 uint8_t * proxy_pdu_data = received_proxy_pdu->data; 1129 uint8_t proxy_pdu_len = received_proxy_pdu->len; 1130 1131 int i = 0; 1132 char ** network_pdus = proxy_config_pdus; 1133 transport_pdu_len = strlen(network_pdus[i]) / 2; 1134 btstack_parse_hex(network_pdus[i], transport_pdu_len, transport_pdu_data); 1135 1136 CHECK_EQUAL( transport_pdu_len-1, proxy_pdu_len); 1137 CHECK_EQUAL_ARRAY(transport_pdu_data+1, proxy_pdu_data, transport_pdu_len-1); 1138 1139 received_proxy_pdu = NULL; 1140 1141 mesh_network_pdu_free(network_pdu); 1142 } 1143 1144 static btstack_crypto_aes128_t crypto_request_aes128; 1145 static uint8_t plaintext[16]; 1146 static uint8_t identity_key[16]; 1147 static uint8_t hash[16]; 1148 static uint8_t random_value[8]; 1149 1150 static void mesh_proxy_handle_get_aes128(void * arg){ 1151 UNUSED(arg); 1152 uint8_t expected_hash[8]; 1153 uint8_t expected_random_value[8]; 1154 1155 btstack_parse_hex("00861765aefcc57b", 8, expected_hash); 1156 CHECK_EQUAL_ARRAY(&hash[8], expected_hash, 8); 1157 1158 btstack_parse_hex("34ae608fbbc1f2c6", 8, expected_random_value); 1159 CHECK_EQUAL_ARRAY(random_value, expected_random_value, 8); 1160 } 1161 1162 TEST(MessageTest, ServiceDataUsingNodeIdentityTest){ 1163 btstack_parse_hex("34ae608fbbc1f2c6", 8, random_value); 1164 memset(plaintext, 0, sizeof(plaintext)); 1165 memcpy(&plaintext[6] , random_value, 8); 1166 big_endian_store_16(plaintext, 14, 0x1201); 1167 // 84396c435ac48560b5965385253e210c 1168 btstack_parse_hex("84396c435ac48560b5965385253e210c", 16, identity_key); 1169 btstack_crypto_aes128_encrypt(&crypto_request_aes128, identity_key, plaintext, hash, mesh_proxy_handle_get_aes128, NULL); 1170 } 1171 1172 // Mesh v1.0, 8.2.1 1173 static btstack_crypto_aes128_cmac_t aes_cmac_request; 1174 static uint8_t k4_result[1]; 1175 static void handle_k4_result(void *arg){ 1176 printf("ApplicationkeyIDTest: %02x\n", k4_result[0]); 1177 CHECK_EQUAL( 0x26, k4_result[0]); 1178 } 1179 TEST(MessageTest, ApplicationkeyIDTest){ 1180 static uint8_t application_key[16]; 1181 btstack_parse_hex("63964771734fbd76e3b40519d1d94a48", 16, application_key); 1182 mesh_k4(&aes_cmac_request, application_key, &k4_result[0], &handle_k4_result, NULL); 1183 } 1184 1185 int main (int argc, const char * argv[]){ 1186 return CommandLineTestRunner::RunAllTests(argc, argv); 1187 } 1188