mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-01-18 19:21:54 +00:00
Code Issues Packages Projects Releases Wiki Activity
btstack/test/mesh/mesh_message_test.cpp

1223 lines
46 KiB
C++
Raw Blame History

#include <stdio.h>
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
#include "btstack_debug.h"
#include "btstack_memory.h"
#include "btstack_util.h"
#include "mesh/adv_bearer.h"
#include "mesh/gatt_bearer.h"
#include "mesh/mesh_access.h"
#include "mesh/mesh_crypto.h"
#include "mesh/mesh_foundation.h"
#include "mesh/mesh_iv_index_seq_number.h"
#include "mesh/mesh_lower_transport.h"
#include "mesh/mesh_network.h"
#include "mesh/mesh_upper_transport.h"
#include "mesh/provisioning.h"
#include "mesh/mesh_peer.h"
#include "mock.h"
static mesh_network_pdu_t * received_network_pdu;
static mesh_network_pdu_t * received_proxy_pdu;
static uint8_t outgoing_gatt_network_pdu_data[29];
static uint8_t outgoing_gatt_network_pdu_len;
static uint8_t outgoing_adv_network_pdu_data[29];
static uint8_t outgoing_adv_network_pdu_len;
static uint8_t recv_upper_transport_pdu_data[100];
static uint16_t recv_upper_transport_pdu_len;
#ifdef ENABLE_MESH_ADV_BEARER
static btstack_packet_handler_t adv_packet_handler;
void adv_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){
adv_packet_handler = packet_handler;
}
void adv_bearer_request_can_send_now_for_network_pdu(void){
// simulate can send now
uint8_t event[3];
event[0] = HCI_EVENT_MESH_META;
event[1] = 1;
event[2] = MESH_SUBEVENT_CAN_SEND_NOW;
(*adv_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
}
void adv_bearer_send_network_pdu(const uint8_t * network_pdu, uint16_t size, uint8_t count, uint16_t interval){
(void) count;
(void) interval;
// printf("ADV Network PDU: ");
// printf_hexdump(network_pdu, size);
memcpy(outgoing_adv_network_pdu_data, network_pdu, size);
outgoing_adv_network_pdu_len = size;
}
static void adv_bearer_emit_sent(void){
uint8_t event[3];
event[0] = HCI_EVENT_MESH_META;
event[1] = 1;
event[2] = MESH_SUBEVENT_MESSAGE_SENT;
(*adv_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
}
#endif
#ifdef ENABLE_MESH_GATT_BEARER
static btstack_packet_handler_t gatt_packet_handler;
void gatt_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){
gatt_packet_handler = packet_handler;
}
void gatt_bearer_register_for_mesh_proxy_configuration(btstack_packet_handler_t packet_handler){
UNUSED(packet_handler);
}
void gatt_bearer_request_can_send_now_for_network_pdu(void){
// simulate can send now
uint8_t event[3];
event[0] = HCI_EVENT_MESH_META;
event[1] = 1;
event[2] = MESH_SUBEVENT_CAN_SEND_NOW;
(*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
}
void gatt_bearer_send_network_pdu(const uint8_t * network_pdu, uint16_t size){
// printf("ADV Network PDU: ");
// printf_hexdump(network_pdu, size);
memcpy(outgoing_gatt_network_pdu_data, network_pdu, size);
outgoing_gatt_network_pdu_len = size;
}
static void gatt_bearer_emit_sent(void){
uint8_t event[3];
event[0] = HCI_EVENT_MESH_META;
event[1] = 1;
event[2] = MESH_SUBEVENT_MESSAGE_SENT;
(*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
}
static void gatt_bearer_emit_connected(void){
uint8_t event[5];
event[0] = HCI_EVENT_MESH_META;
event[1] = 1;
event[2] = MESH_SUBEVENT_PROXY_CONNECTED;
little_endian_store_16(event, 3, 0x1234);
(*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
}
#endif
// copy from mesh_message.c for now
uint16_t mesh_pdu_dst(mesh_pdu_t * pdu){
switch (pdu->pdu_type){
case MESH_PDU_TYPE_UNSEGMENTED:
case MESH_PDU_TYPE_NETWORK:
case MESH_PDU_TYPE_UPPER_UNSEGMENTED_CONTROL:
return mesh_network_dst((mesh_network_pdu_t *) pdu);
case MESH_PDU_TYPE_ACCESS: {
return ((mesh_access_pdu_t *) pdu)->dst;
}
case MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS:
case MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS:
return ((mesh_upper_transport_pdu_t *) pdu)->dst;
default:
btstack_assert(false);
return MESH_ADDRESS_UNSASSIGNED;
}
}
uint16_t mesh_pdu_ctl(mesh_pdu_t * pdu){
switch (pdu->pdu_type){
case MESH_PDU_TYPE_NETWORK:
case MESH_PDU_TYPE_UPPER_UNSEGMENTED_CONTROL:
return mesh_network_control((mesh_network_pdu_t *) pdu);
case MESH_PDU_TYPE_ACCESS: {
return ((mesh_access_pdu_t *) pdu)->ctl_ttl >> 7;
}
default:
btstack_assert(false);
return 0;
}
}
static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
int i;
for (i=0; i<size; i++){
if (expected[i] != actual[i]) {
printf("offset %u wrong\n", i);
printf("expected: "); printf_hexdump(expected, size);
printf("actual: "); printf_hexdump(actual, size);
}
BYTES_EQUAL(expected[i], actual[i]);
}
}
static int scan_hex_byte(const char * byte_string){
uint8_t upper_nibble = nibble_for_char(*byte_string++);
if (upper_nibble < 0) return -1;
uint8_t lower_nibble = nibble_for_char(*byte_string);
if (lower_nibble < 0) return -1;
return (upper_nibble << 4) | lower_nibble;
}
static int btstack_parse_hex(const char * string, uint16_t len, uint8_t * buffer){
int i;
for (i = 0; i < len; i++) {
int single_byte = scan_hex_byte(string);
if (single_byte < 0) return 0;
string += 2;
buffer[i] = (uint8_t)single_byte;
// don't check separator after last byte
if (i == len - 1) {
return 1;
}
// optional seperator
char separator = *string;
if (separator == ':' || separator == '-' || separator == ' ') {
string++;
}
}
return 1;
}
#if 0
static void btstack_print_hex(const uint8_t * data, uint16_t len, char separator){
int i;
for (i=0;i<len;i++){
printf("%02x", data[i]);
if (separator){
printf("%c", separator);
}
}
printf("\n");
}
#endif
static mesh_transport_key_t test_application_key;
static void mesh_application_key_set(uint16_t netkey_index, uint16_t appkey_index, uint8_t aid, const uint8_t *application_key) {
test_application_key.netkey_index = netkey_index;
test_application_key.appkey_index = appkey_index;
test_application_key.aid = aid;
test_application_key.akf = 1;
memcpy(test_application_key.key, application_key, 16);
mesh_transport_key_add(&test_application_key);
}
static void load_network_key_nid_68(void){
mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get();
network_key->nid = 0x68;
btstack_parse_hex("0953fa93e7caac9638f58820220a398e", 16, network_key->encryption_key);
btstack_parse_hex("8b84eedec100067d670971dd2aa700cf", 16, network_key->privacy_key);
mesh_network_key_add(network_key);
mesh_subnet_setup_for_netkey_index(network_key->netkey_index);
}
static void load_network_key_nid_5e(void){
mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get();
network_key->nid = 0x5e;
btstack_parse_hex("be635105434859f484fc798e043ce40e", 16, network_key->encryption_key);
btstack_parse_hex("5d396d4b54d3cbafe943e051fe9a4eb8", 16, network_key->privacy_key);
mesh_network_key_add(network_key);
mesh_subnet_setup_for_netkey_index(network_key->netkey_index);
}
static void load_network_key_nid_10(void){
mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get();
network_key->nid = 0x10;
btstack_parse_hex("3a4fe84a6cc2c6a766ea93f1084d4039", 16, network_key->encryption_key);
btstack_parse_hex("f695fcce709ccface4d8b7a1e6e39d25", 16, network_key->privacy_key);
mesh_network_key_add(network_key);
mesh_subnet_setup_for_netkey_index(network_key->netkey_index);
}
static void load_provisioning_data_test_message(void){
uint8_t application_key[16];
btstack_parse_hex("63964771734fbd76e3b40519d1d94a48", 16, application_key);
mesh_application_key_set( 0, 0, 0x26, application_key);
uint8_t device_key[16];
btstack_parse_hex("9d6dd0e96eb25dc19a40ed9914f8f03f", 16, device_key);
mesh_transport_set_device_key(device_key);
}
static void test_lower_transport_callback_handler(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu){
switch (callback_type){
case MESH_NETWORK_PDU_RECEIVED:
printf("test MESH_NETWORK_PDU_RECEIVED\n");
received_network_pdu = network_pdu;
break;
case MESH_NETWORK_PDU_SENT:
printf("test MESH_NETWORK_PDU_SENT\n");
mesh_lower_transport_received_message(MESH_NETWORK_PDU_SENT, network_pdu);
break;
default:
break;
}
}
static void test_proxy_server_callback_handler(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu){
switch (callback_type){
case MESH_NETWORK_PDU_RECEIVED:
printf("test MESH_PROXY_PDU_RECEIVED\n");
received_proxy_pdu = network_pdu;
break;
case MESH_NETWORK_PDU_SENT:
// printf("test MESH_PROXY_PDU_SENT\n");
// mesh_lower_transport_received_mesage(MESH_NETWORK_PDU_SENT, network_pdu);
break;
case MESH_NETWORK_PDU_ENCRYPTED:
printf("test MESH_NETWORK_PDU_ENCRYPTED\n");
received_proxy_pdu = network_pdu;
break;
default:
break;
}
}
static void test_upper_transport_access_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
UNUSED(status);
// free sent pdus
if (callback_type == MESH_TRANSPORT_PDU_SENT) {
mesh_upper_transport_pdu_free(pdu);
return;
}
// process pdu received
mesh_access_pdu_t * access_pdu;
mesh_network_pdu_t * network_pdu;
mesh_segmented_pdu_t * message_pdu;
switch(pdu->pdu_type){
case MESH_PDU_TYPE_ACCESS:
access_pdu = (mesh_access_pdu_t *) pdu;
printf("test access handler MESH_PDU_TYPE_ACCESS received\n");
recv_upper_transport_pdu_len = access_pdu->len;
memcpy(recv_upper_transport_pdu_data, access_pdu->data, recv_upper_transport_pdu_len);
mesh_upper_transport_message_processed_by_higher_layer(pdu);
break;
case MESH_PDU_TYPE_SEGMENTED:
message_pdu = (mesh_segmented_pdu_t *) pdu;
printf("test access handler MESH_PDU_TYPE_SEGMENTED received\n");
network_pdu = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&message_pdu->segments);
recv_upper_transport_pdu_len = mesh_network_pdu_len(network_pdu) - 1;
memcpy(recv_upper_transport_pdu_data, mesh_network_pdu_data(network_pdu) + 1, recv_upper_transport_pdu_len);
mesh_upper_transport_message_processed_by_higher_layer(pdu);
break;
default:
btstack_assert(0);
break;
}
}
static void test_upper_transport_control_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
UNUSED(status);
// ignore pdu sent
if (callback_type == MESH_TRANSPORT_PDU_SENT) return;
// process pdu received
mesh_control_pdu_t * control_pdu;
switch(pdu->pdu_type){
case MESH_PDU_TYPE_CONTROL:
control_pdu = (mesh_control_pdu_t *) pdu;
printf("test MESH_PDU_TYPE_CONTROL\n");
recv_upper_transport_pdu_len = control_pdu->len + 1;
recv_upper_transport_pdu_data[0] = control_pdu->akf_aid_control;
memcpy(&recv_upper_transport_pdu_data[1], control_pdu->data, control_pdu->len);
mesh_upper_transport_message_processed_by_higher_layer(pdu);
break;
default:
btstack_assert(0);
break;
}
}
TEST_GROUP(MessageTest){
void setup(void){
btstack_memory_init();
btstack_crypto_init();
load_provisioning_data_test_message();
mesh_network_init();
mesh_lower_transport_init();
mesh_upper_transport_init();
mesh_network_key_init();
// intercept messages between network and lower layer
mesh_network_set_higher_layer_handler(&test_lower_transport_callback_handler);
mesh_network_set_proxy_message_handler(&test_proxy_server_callback_handler);
// register to receive upper transport messages
mesh_upper_transport_register_access_message_handler(&test_upper_transport_access_message_handler);
mesh_upper_transport_register_control_message_handler(&test_upper_transport_control_message_handler);
mesh_seq_auth_reset();
#ifdef ENABLE_MESH_GATT_BEARER
mesh_foundation_gatt_proxy_set(1);
gatt_bearer_emit_connected();
#endif
outgoing_gatt_network_pdu_len = 0;
outgoing_adv_network_pdu_len = 0;
received_network_pdu = NULL;
recv_upper_transport_pdu_len =0;
}
void teardown(void){
// printf("-- teardown start --\n\n");
btstack_crypto_reset();
mesh_network_reset();
mesh_lower_transport_reset();
mesh_upper_transport_dump();
mesh_upper_transport_reset();
// mesh_network_dump();
// mesh_transport_dump();
printf("-- teardown complete --\n\n");
}
};
static uint8_t transport_pdu_data[64];
static uint16_t transport_pdu_len;
static uint8_t test_network_pdu_len;
static uint8_t test_network_pdu_data[29];
static void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_transport_pdus, char * access_pdu){
int i;
for (i=0;i<count;i++){
test_network_pdu_len = strlen(network_pdus[i]) / 2;
btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
mesh_network_received_message(test_network_pdu_data, test_network_pdu_len, 0);
while (received_network_pdu == NULL) {
mock_process_hci_cmd();
}
transport_pdu_len = strlen(lower_transport_pdus[i]) / 2;
btstack_parse_hex(lower_transport_pdus[i], transport_pdu_len, transport_pdu_data);
uint8_t * lower_transport_pdu = mesh_network_pdu_data(received_network_pdu);
uint8_t lower_transport_pdu_len = mesh_network_pdu_len(received_network_pdu);
// printf_hexdump(lower_transport_pdu, lower_transport_pdu_len);
CHECK_EQUAL( transport_pdu_len, lower_transport_pdu_len);
CHECK_EQUAL_ARRAY(transport_pdu_data, lower_transport_pdu, transport_pdu_len);
// forward to mesh_transport
mesh_lower_transport_received_message(MESH_NETWORK_PDU_RECEIVED, received_network_pdu);
// done
received_network_pdu = NULL;
}
// wait for transport pdu
while (recv_upper_transport_pdu_len == 0) {
mock_process_hci_cmd();
// check for acks
if (outgoing_gatt_network_pdu_len != 0){
outgoing_gatt_network_pdu_len = 0;
gatt_bearer_emit_sent();
}
if (outgoing_adv_network_pdu_len != 0){
outgoing_adv_network_pdu_len = 0;
adv_bearer_emit_sent();
}
}
transport_pdu_len = strlen(access_pdu) / 2;
btstack_parse_hex(access_pdu, transport_pdu_len, transport_pdu_data);
printf("UpperTransportPDU: ");
printf_hexdump(recv_upper_transport_pdu_data, recv_upper_transport_pdu_len);
CHECK_EQUAL( transport_pdu_len, recv_upper_transport_pdu_len);
CHECK_EQUAL_ARRAY(transport_pdu_data, recv_upper_transport_pdu_data, transport_pdu_len);
}
static void expect_gatt_network_pdu(void){
while (outgoing_gatt_network_pdu_len == 0) {
mock_process_hci_cmd();
}
if (outgoing_gatt_network_pdu_len != test_network_pdu_len){
printf("Test Network PDU (%u): ", outgoing_gatt_network_pdu_len); printf_hexdump(outgoing_gatt_network_pdu_data, outgoing_gatt_network_pdu_len);
printf("Expected PDU (%u): ", test_network_pdu_len); printf_hexdump(test_network_pdu_data, test_network_pdu_len);
}
CHECK_EQUAL( outgoing_gatt_network_pdu_len, test_network_pdu_len);
CHECK_EQUAL_ARRAY(test_network_pdu_data, outgoing_gatt_network_pdu_data, test_network_pdu_len);
outgoing_gatt_network_pdu_len = 0;
gatt_bearer_emit_sent();
}
static void expect_adv_network_pdu(void){
while (outgoing_adv_network_pdu_len == 0) {
mock_process_hci_cmd();
}
if (outgoing_adv_network_pdu_len != test_network_pdu_len){
printf("Test Network PDU (%u): ", outgoing_adv_network_pdu_len); printf_hexdump(outgoing_adv_network_pdu_data, outgoing_adv_network_pdu_len);
printf("Expected PDU (%u): ", test_network_pdu_len); printf_hexdump(test_network_pdu_data, test_network_pdu_len);
}
CHECK_EQUAL( outgoing_adv_network_pdu_len, test_network_pdu_len);
CHECK_EQUAL_ARRAY(test_network_pdu_data, outgoing_adv_network_pdu_data, test_network_pdu_len);
outgoing_adv_network_pdu_len = 0;
adv_bearer_emit_sent();
}
static 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){
UNUSED(lower_transport_pdus);
transport_pdu_len = strlen(control_pdu) / 2;
btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data);
mesh_pdu_type_t pdu_type;
if (count == 1 ){
// send as unsegmented access pdu
pdu_type = MESH_PDU_TYPE_UPPER_UNSEGMENTED_ACCESS;
} else {
// send as segmented access pdu
pdu_type = MESH_PDU_TYPE_UPPER_SEGMENTED_ACCESS;
}
#if 0
//
upper_pdu.lower_pdu = NULL;
upper_pdu.flags = 0;
upper_pdu.pdu_type = pdu_type;
mesh_pdu_t * pdu = (mesh_pdu_t *) &upper_pdu;
mesh_upper_transport_setup_access_pdu(pdu, netkey_index, appkey_index, ttl, src, dest, szmic, transport_pdu_data, transport_pdu_len);
#else
mesh_upper_transport_builder_t builder;
mesh_upper_transport_message_init(&builder, pdu_type);
mesh_upper_transport_message_add_data(&builder, transport_pdu_data, transport_pdu_len);
mesh_pdu_t * pdu = (mesh_pdu_t *) mesh_upper_transport_message_finalize(&builder);
mesh_upper_transport_setup_access_pdu_header(pdu, netkey_index, appkey_index, ttl, src, dest, szmic);
#endif
mesh_upper_transport_send_access_pdu(pdu);
// check for all network pdus
int i;
for (i=0;i<count;i++){
// parse expected network pdu
test_network_pdu_len = strlen(network_pdus[i]) / 2;
btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
#ifdef ENABLE_MESH_GATT_BEARER
expect_gatt_network_pdu();
#endif
#ifdef ENABLE_MESH_ADV_BEARER
expect_adv_network_pdu();
#endif
}
// mesh_upper_transport_pdu_free(pdu);
}
static 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){
UNUSED(lower_transport_pdus);
transport_pdu_len = strlen(control_pdu) / 2;
btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data);
uint8_t opcode = transport_pdu_data[0];
mesh_pdu_t * pdu;
if (transport_pdu_len < 12){
// send as unsegmented control pdu
mesh_network_pdu_t * network_pdu = mesh_network_pdu_get();
mesh_upper_transport_setup_unsegmented_control_pdu(network_pdu, netkey_index, ttl, src, dest, opcode, transport_pdu_data+1, transport_pdu_len-1);
pdu = (mesh_pdu_t *) network_pdu;
} else {
mesh_upper_transport_builder_t builder;
mesh_upper_transport_message_init(&builder, MESH_PDU_TYPE_UPPER_SEGMENTED_CONTROL);
mesh_upper_transport_message_add_data(&builder, transport_pdu_data+1, transport_pdu_len-1);
mesh_upper_transport_pdu_t * final_upper_pdu = (mesh_upper_transport_pdu_t *) mesh_upper_transport_message_finalize(&builder);
mesh_upper_transport_setup_segmented_control_pdu_header(final_upper_pdu, netkey_index, ttl, src, dest, opcode);
pdu = (mesh_pdu_t *) final_upper_pdu;
}
mesh_upper_transport_send_control_pdu(pdu);
// check for all network pdus
int i;
for (i=0;i<count;i++){
// expected network pdu
test_network_pdu_len = strlen(network_pdus[i]) / 2;
btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
#ifdef ENABLE_MESH_GATT_BEARER
expect_gatt_network_pdu();
#endif
#ifdef ENABLE_MESH_ADV_BEARER
expect_adv_network_pdu();
#endif
}
}
#if 1
// Message 1
char * message1_network_pdus[] = {
(char *) "68eca487516765b5e5bfdacbaf6cb7fb6bff871f035444ce83a670df"
};
char * message1_lower_transport_pdus[] = {
(char *) "034b50057e400000010000",
};
char * message1_upper_transport_pdu = (char *) "034b50057e400000010000";
TEST(MessageTest, Message1Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message1_network_pdus, message1_lower_transport_pdus, message1_upper_transport_pdu);
}
TEST(MessageTest, Message1Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x1201;
uint16_t dest = 0xfffd;
uint32_t seq = 1;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message1_upper_transport_pdu, 1, message1_lower_transport_pdus, message1_network_pdus);
}
// Message 2
char * message2_network_pdus[] = {
(char *) "68d4c826296d7979d7dbc0c9b4d43eebec129d20a620d01e"
};
char * message2_lower_transport_pdus[] = {
(char *) "04320308ba072f",
};
char * message2_upper_transport_pdu = (char *) "04320308ba072f";
TEST(MessageTest, Message2Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message2_network_pdus, message2_lower_transport_pdus, message2_upper_transport_pdu);
}
TEST(MessageTest, Message2Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x2345;
uint16_t dest = 0x1201;
uint32_t seq = 0x014820;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message2_upper_transport_pdu, 1, message2_lower_transport_pdus, message2_network_pdus);
}
// Message 3
char * message3_network_pdus[] = {
(char *) "68da062bc96df253273086b8c5ee00bdd9cfcc62a2ddf572"
};
char * message3_lower_transport_pdus[] = {
(char *) "04fa0205a6000a",
};
char * message3_upper_transport_pdu = (char *) "04fa0205a6000a";
TEST(MessageTest, Message3Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message3_network_pdus, message3_lower_transport_pdus, message3_upper_transport_pdu);
}
TEST(MessageTest, Message3Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x2fe3;
uint16_t dest = 0x1201;
uint32_t seq = 0x2b3832;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message3_upper_transport_pdu, 1, message3_lower_transport_pdus, message3_network_pdus);
}
// Message 4
char * message4_network_pdus[] = {
(char *) "5e84eba092380fb0e5d0ad970d579a4e88051c"
};
char * message4_lower_transport_pdus[] = {
(char *) "0100",
};
char * message4_upper_transport_pdu = (char *) "0100";
TEST(MessageTest, Message4Receive){
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message4_network_pdus, message4_lower_transport_pdus, message4_upper_transport_pdu);
}
TEST(MessageTest, Message4Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x1201;
uint16_t dest = 0x2345;
uint32_t seq = 0x000002;
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message4_upper_transport_pdu, 1, message4_lower_transport_pdus, message4_network_pdus);
}
// Message 5
char * message5_network_pdus[] = {
(char *) "5eafd6f53c43db5c39da1792b1fee9ec74b786c56d3a9dee",
};
char * message5_lower_transport_pdus[] = {
(char *) "02001234567800",
};
char * message5_upper_transport_pdu = (char *) "02001234567800";
TEST(MessageTest, Message5Receive){
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message5_network_pdus, message5_lower_transport_pdus, message5_upper_transport_pdu);
}
TEST(MessageTest, Message5Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x2345;
uint16_t dest = 0x1201;
uint32_t seq = 0x014834;
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message5_upper_transport_pdu, 1, message5_lower_transport_pdus, message5_network_pdus);
}
// Message 6
char * message6_network_pdus[] = {
(char *) "68cab5c5348a230afba8c63d4e686364979deaf4fd40961145939cda0e",
(char *) "681615b5dd4a846cae0c032bf0746f44f1b8cc8ce5edc57e55beed49c0",
};
char * message6_lower_transport_pdus[] = {
(char *) "8026ac01ee9dddfd2169326d23f3afdf",
(char *) "8026ac21cfdc18c52fdef772e0e17308",
};
char * message6_upper_transport_pdu = (char *) "0056341263964771734fbd76e3b40519d1d94a48";
TEST(MessageTest, Message6Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(2, message6_network_pdus, message6_lower_transport_pdus, message6_upper_transport_pdu);
}
TEST(MessageTest, Message6Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = MESH_DEVICE_KEY_INDEX;
uint8_t ttl = 4;
uint16_t src = 0x0003;
uint16_t dest = 0x1201;
uint32_t seq = 0x3129ab;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message6_upper_transport_pdu, 2, message6_lower_transport_pdus, message6_network_pdus);
}
// Message 7 - ACK
char * message7_network_pdus[] = {
(char *) "68e476b5579c980d0d730f94d7f3509df987bb417eb7c05f",
};
char * message7_lower_transport_pdus[] = {
(char *) "00a6ac00000002",
};
char * message7_upper_transport_pdu = (char *) "00a6ac00000002";
TEST(MessageTest, Message7Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0x0b;
uint16_t src = 0x2345;
uint16_t dest = 0x0003;
uint32_t seq = 0x014835;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message7_upper_transport_pdu, 1, message7_lower_transport_pdus, message7_network_pdus);
}
// ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu
// TEST(MessageTest, Message7Receive){
// mesh_set_iv_index(0x12345678);
// test_receive_network_pdus(1, message7_network_pdus, message7_lower_transport_pdus, message7_upper_transport_pdu);
// }
// Message 8 - ACK
char * message8_network_pdus[] = {
(char *) "684daa6267c2cf0e2f91add6f06e66006844cec97f973105ae2534f958",
};
char * message8_lower_transport_pdus[] = {
(char *) "8026ac01ee9dddfd2169326d23f3afdf",
};
char * message8_upper_transport_pdu = (char *) "8026ac01ee9dddfd2169326d23f3afdf";
// ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu
// TEST(MessageTest, Message8Receive){
// mesh_set_iv_index(0x12345678);
// test_receive_network_pdus(1, message8_network_pdus, message8_lower_transport_pdus, message8_upper_transport_pdu);
// }
// Message 9 - ACK
// Message 10
char * message10_network_pdus[] = {
(char *) "5e7b786568759f7777ed355afaf66d899c1e3d",
};
char * message10_lower_transport_pdus[] = {
(char *) "0101",
};
char * message10_upper_transport_pdu = (char *) "0101";
TEST(MessageTest, Message10Receive){
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message10_network_pdus, message10_lower_transport_pdus, message10_upper_transport_pdu);
}
TEST(MessageTest, Message10Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x1201;
uint16_t dest = 0x2345;
uint32_t seq = 0x000003;
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message10_upper_transport_pdu, 1, message10_lower_transport_pdus, message10_network_pdus);
}
// Message 11
// The Friend node responds to this poll with the first segment of the stored message. It also indicates that it has more data.
// Message 12
char * message12_network_pdus[] = {
(char *) "5e8a18fc6e4d05ae21466087599c2426ce9a35",
};
char * message12_lower_transport_pdus[] = {
(char *) "0101",
};
char * message12_upper_transport_pdu = (char *) "0101";
TEST(MessageTest, Message12Receive){
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message12_network_pdus, message12_lower_transport_pdus, message12_upper_transport_pdu);
}
TEST(MessageTest, Message12Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x1201;
uint16_t dest = 0x2345;
uint32_t seq = 0x000004;
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message12_upper_transport_pdu, 1, message12_lower_transport_pdus, message12_network_pdus);
}
// Message 13
// The Friend node responds with the same message as last time.
// Message 14
// The Low Power node received the retransmitted stored message. As that message has the MD bit set
// it sends another Friend Poll to obtain the next message.
char * message14_network_pdus[] = {
(char *) "5e0bbaf92b5c8f7d3ae62a3c75dff683dce24e",
};
char * message14_lower_transport_pdus[] = {
(char *) "0100",
};
char * message14_upper_transport_pdu = (char *) "0100";
TEST(MessageTest, Message14Receive){
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message14_network_pdus, message14_lower_transport_pdus, message14_upper_transport_pdu);
}
TEST(MessageTest, Message14Send){
uint16_t netkey_index = 0;
uint8_t ttl = 0;
uint16_t src = 0x1201;
uint16_t dest = 0x2345;
uint32_t seq = 0x000005;
load_network_key_nid_5e();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_control_message(netkey_index, ttl, src, dest, message14_upper_transport_pdu, 1, message14_lower_transport_pdus, message14_network_pdus);
}
// Message 15
// 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.
char * message15_network_pdus[] = {
(char *) "5ea8dab50e7ee7f1d29805664d235eacd707217dedfe78497fefec7391",
};
char * message15_lower_transport_pdus[] = {
(char *) "8026ac21cfdc18c52fdef772e0e17308",
};
char * message15_upper_transport_pdu = (char *) "0100";
// ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu
// not sure - no upper access message
// TEST(MessageTest, Message15Receive){
// load_network_key_nid_5e();
// mesh_set_iv_index(0x12345678);
// test_receive_network_pdus(1, message15_network_pdus, message15_lower_transport_pdus, message15_upper_transport_pdu);
// }
// Message 16
char * message16_network_pdus[] = {
(char *) "68e80e5da5af0e6b9be7f5a642f2f98680e61c3a8b47f228",
};
char * message16_lower_transport_pdus[] = {
(char *) "0089511bf1d1a81c11dcef",
};
char * message16_upper_transport_pdu = (char *) "800300563412";
TEST(MessageTest, Message16Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message16_network_pdus, message16_lower_transport_pdus, message16_upper_transport_pdu);
}
TEST(MessageTest, Message16Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = MESH_DEVICE_KEY_INDEX;
uint8_t ttl = 0x0b;
uint16_t src = 0x1201;
uint16_t dest = 0x0003;
uint32_t seq = 0x000006;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message16_upper_transport_pdu, 1, message16_lower_transport_pdus, message16_network_pdus);
}
// Message 17
// A Relay node receives the message from the Low Power node and relays it, decrementing the TTL value.
// Message 18
char * message18_network_pdus[] = {
(char *) "6848cba437860e5673728a627fb938535508e21a6baf57",
};
char * message18_lower_transport_pdus[] = {
(char *) "665a8bde6d9106ea078a",
};
char * message18_upper_transport_pdu = (char *) "0400000000";
TEST(MessageTest, Message18Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message18_network_pdus, message18_lower_transport_pdus, message18_upper_transport_pdu);
}
TEST(MessageTest, Message18Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1201;
uint16_t dest = 0xffff;
uint32_t seq = 0x00007;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message18_upper_transport_pdu, 1, message18_lower_transport_pdus, message18_network_pdus);
}
// Message 19
// The Low Power node sends another Health Current Status message indicating that there are three faults:
// Battery Low Warning, Power Supply Interrupted Warning, and Supply Voltage Too Low Warning.
char * message19_network_pdus[] = {
(char *) "68110edeecd83c3010a05e1b23a926023da75d25ba91793736",
};
char * message19_lower_transport_pdus[] = {
(char *) "66ca6cd88e698d1265f43fc5",
};
char * message19_upper_transport_pdu = (char *) "04000000010703";
TEST(MessageTest, Message19Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
test_receive_network_pdus(1, message19_network_pdus, message19_lower_transport_pdus, message19_upper_transport_pdu);
}
TEST(MessageTest, Message19Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1201;
uint16_t dest = 0xffff;
uint32_t seq = 0x00009;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345678);
mesh_sequence_number_set(seq);
test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message19_upper_transport_pdu, 1, message19_lower_transport_pdus, message19_network_pdus);
}
// Message 20
char * message20_network_pdus[] = {
(char *) "e85cca51e2e8998c3dc87344a16c787f6b08cc897c941a5368",
};
char * message20_lower_transport_pdus[] = {
(char *) "669c9803e110fea929e9542d",
};
char * message20_upper_transport_pdu = (char *) "04000000010703";
TEST(MessageTest, Message20Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
test_receive_network_pdus(1, message20_network_pdus, message20_lower_transport_pdus, message20_upper_transport_pdu);
}
TEST(MessageTest, Message20Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1234;
uint16_t dest = 0xffff;
uint32_t seq = 0x070809;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
mesh_sequence_number_set(seq);
test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message20_upper_transport_pdu, 1, message20_lower_transport_pdus, message20_network_pdus);
}
// Message 21
// The Low Power node sends a vendor command to a group address.
char * message21_network_pdus[] = {
(char *) "e84e8fbe003f58a4d61157bb76352ea6307eebfe0f30b83500e9",
};
char * message21_lower_transport_pdus[] = {
(char *) "664d92e9dfcf3ab85b6e8fcf03",
};
char * message21_upper_transport_pdu = (char *) "d50a0048656c6c6f";
TEST(MessageTest, Message21Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
test_receive_network_pdus(1, message21_network_pdus, message21_lower_transport_pdus, message21_upper_transport_pdu);
}
TEST(MessageTest, Message21Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1234;
uint16_t dest = 0xc105;
uint32_t seq = 0x07080a;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
mesh_sequence_number_set(seq);
test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message21_upper_transport_pdu, 1, message21_lower_transport_pdus, message21_network_pdus);
}
// Message 22
char * message22_network_pdus[] = {
(char *) "e8d85caecef1e3ed31f3fdcf88a411135fea55df730b6b28e255",
};
char * message22_lower_transport_pdus[] = {
(char *) "663871b904d431526316ca48a0",
};
char * message22_upper_transport_pdu = (char *) "d50a0048656c6c6f";
char * message22_label_string = (char *) "0073e7e4d8b9440faf8415df4c56c0e1";
TEST(MessageTest, Message22Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
uint8_t label_uuid[16];
btstack_parse_hex(message22_label_string, 16, label_uuid);
mesh_virtual_address_register(label_uuid, 0xb529);
test_receive_network_pdus(1, message22_network_pdus, message22_lower_transport_pdus, message22_upper_transport_pdu);
}
TEST(MessageTest, Message22Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1234;
uint32_t seq = 0x07080b;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
mesh_sequence_number_set(seq);
uint8_t label_uuid[16];
btstack_parse_hex(message22_label_string, 16, label_uuid);
mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0xb529);
uint16_t pseudo_dst = virtual_address->pseudo_dst;
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);
}
// Message 23
char * message23_network_pdus[] = {
(char *) "e877a48dd5fe2d7a9d696d3dd16a75489696f0b70c711b881385",
};
char * message23_lower_transport_pdus[] = {
(char *) "662456db5e3100eef65daa7a38",
};
char * message23_upper_transport_pdu = (char *) "d50a0048656c6c6f";
char * message23_label_string = (char *) "f4a002c7fb1e4ca0a469a021de0db875";
TEST(MessageTest, Message23Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
uint8_t label_uuid[16];
btstack_parse_hex(message23_label_string, 16, label_uuid);
mesh_virtual_address_register(label_uuid, 0x9736);
test_receive_network_pdus(1, message23_network_pdus, message23_lower_transport_pdus, message23_upper_transport_pdu);
}
TEST(MessageTest, Message23Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1234;
uint32_t seq = 0x07080c;
uint8_t szmic = 0;
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
mesh_sequence_number_set(seq);
uint8_t label_uuid[16];
btstack_parse_hex(message23_label_string, 16, label_uuid);
mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0x9736);
uint16_t pseudo_dst = virtual_address->pseudo_dst;
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);
}
#endif
// Message 24
char * message24_network_pdus[] = {
(char *) "e8624e65bb8c1794e998b4081f47a35251fdd3896d99e4db489b918599",
(char *) "e8a7d0f0a2ea42dc2f4dd6fb4db33a6c088d023b47",
};
char * message24_lower_transport_pdus[] = {
(char *) "e6a03401c3c51d8e476b28e3aa5001f3",
(char *) "e6a034211c01cea6",
};
char * message24_upper_transport_pdu = (char *) "ea0a00576f726c64";
char * message24_label_string = (char *) "f4a002c7fb1e4ca0a469a021de0db875";
TEST(MessageTest, Message24Receive){
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
uint8_t label_uuid[16];
btstack_parse_hex(message24_label_string, 16, label_uuid);
mesh_virtual_address_register(label_uuid, 0x9736);
test_receive_network_pdus(2, message24_network_pdus, message24_lower_transport_pdus, message24_upper_transport_pdu);
}
TEST(MessageTest, Message24Send){
uint16_t netkey_index = 0;
uint16_t appkey_index = 0;
uint8_t ttl = 3;
uint16_t src = 0x1234;
uint32_t seq = 0x07080d;
uint8_t szmic = 1;
load_network_key_nid_68();
mesh_set_iv_index(0x12345677);
mesh_sequence_number_set(seq);
uint8_t label_uuid[16];
btstack_parse_hex(message24_label_string, 16, label_uuid);
mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0x9736);
uint16_t pseudo_dst = virtual_address->pseudo_dst;
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);
}
// Proxy Configuration Test
char * proxy_config_pdus[] = {
(char *) "0210386bd60efbbb8b8c28512e792d3711f4b526",
};
char * proxy_config_lower_transport_pdus[] = {
(char *) "0000",
};
char * proxy_config_upper_transport_pdu = (char *) "ea0a00576f726c64";
TEST(MessageTest, ProxyConfigReceive){
mesh_set_iv_index(0x12345678);
load_network_key_nid_10();
int i = 0;
char ** network_pdus = proxy_config_pdus;
test_network_pdu_len = strlen(network_pdus[i]) / 2;
btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
mesh_network_process_proxy_configuration_message(&test_network_pdu_data[1], test_network_pdu_len-1);
while (received_proxy_pdu == NULL) {
mock_process_hci_cmd();
}
char ** lower_transport_pdus = proxy_config_lower_transport_pdus;
transport_pdu_len = strlen(lower_transport_pdus[i]) / 2;
btstack_parse_hex(lower_transport_pdus[i], transport_pdu_len, transport_pdu_data);
uint8_t * lower_transport_pdu = mesh_network_pdu_data(received_proxy_pdu);
uint8_t lower_transport_pdu_len = mesh_network_pdu_len(received_proxy_pdu);
// printf_hexdump(lower_transport_pdu, lower_transport_pdu_len);
CHECK_EQUAL( transport_pdu_len, lower_transport_pdu_len);
CHECK_EQUAL_ARRAY(transport_pdu_data, lower_transport_pdu, transport_pdu_len);
// done
mesh_network_message_processed_by_higher_layer(received_proxy_pdu);
received_proxy_pdu = NULL;
}
TEST(MessageTest, ProxyConfigSend){
uint16_t netkey_index = 0;
uint8_t ctl = 1;
uint8_t ttl = 0;
uint16_t src = 1;
uint16_t dest = 0;
uint32_t seq = 1;
uint8_t nid = 0x10;
mesh_set_iv_index(0x12345678);
load_network_key_nid_10();
mesh_network_pdu_t * network_pdu = mesh_network_pdu_get();
uint8_t data[] = { 0 , 0 };
mesh_network_setup_pdu(network_pdu, netkey_index, nid, ctl, ttl, seq, src, dest, data, sizeof(data));
mesh_network_encrypt_proxy_configuration_message(network_pdu);
while (received_proxy_pdu == NULL) {
mock_process_hci_cmd();
}
uint8_t * proxy_pdu_data = received_proxy_pdu->data;
uint8_t proxy_pdu_len = received_proxy_pdu->len;
int i = 0;
char ** network_pdus = proxy_config_pdus;
transport_pdu_len = strlen(network_pdus[i]) / 2;
btstack_parse_hex(network_pdus[i], transport_pdu_len, transport_pdu_data);
CHECK_EQUAL( transport_pdu_len-1, proxy_pdu_len);
CHECK_EQUAL_ARRAY(transport_pdu_data+1, proxy_pdu_data, transport_pdu_len-1);
received_proxy_pdu = NULL;
mesh_network_pdu_free(network_pdu);
}
static btstack_crypto_aes128_t crypto_request_aes128;
static uint8_t plaintext[16];
static uint8_t identity_key[16];
static uint8_t hash[16];
static uint8_t random_value[8];
static void mesh_proxy_handle_get_aes128(void * arg){
UNUSED(arg);
uint8_t expected_hash[8];
uint8_t expected_random_value[8];
btstack_parse_hex("00861765aefcc57b", 8, expected_hash);
CHECK_EQUAL_ARRAY(&hash[8], expected_hash, 8);
btstack_parse_hex("34ae608fbbc1f2c6", 8, expected_random_value);
CHECK_EQUAL_ARRAY(random_value, expected_random_value, 8);
}
TEST(MessageTest, ServiceDataUsingNodeIdentityTest){
btstack_parse_hex("34ae608fbbc1f2c6", 8, random_value);
memset(plaintext, 0, sizeof(plaintext));
memcpy(&plaintext[6] , random_value, 8);
big_endian_store_16(plaintext, 14, 0x1201);
// 84396c435ac48560b5965385253e210c
btstack_parse_hex("84396c435ac48560b5965385253e210c", 16, identity_key);
btstack_crypto_aes128_encrypt(&crypto_request_aes128, identity_key, plaintext, hash, mesh_proxy_handle_get_aes128, NULL);
}
// Mesh v1.0, 8.2.1
static btstack_crypto_aes128_cmac_t aes_cmac_request;
static uint8_t k4_result[1];
static void handle_k4_result(void *arg){
UNUSED(arg);
printf("ApplicationkeyIDTest: %02x\n", k4_result[0]);
CHECK_EQUAL( 0x26, k4_result[0]);
}
TEST(MessageTest, ApplicationkeyIDTest){
static uint8_t application_key[16];
btstack_parse_hex("63964771734fbd76e3b40519d1d94a48", 16, application_key);
mesh_k4(&aes_cmac_request, application_key, &k4_result[0], &handle_k4_result, NULL);
}
int main (int argc, const char * argv[]){
return CommandLineTestRunner::RunAllTests(argc, argv);
}
Reference in New Issue View Git Blame Copy Permalink