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