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