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