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