mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-04-03 10:20:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

mesh: fix compile warnings

Browse Source
This commit is contained in:
Matthias Ringwald 2020-08-08 19:47:09 +02:00
parent 17756958b1
commit df71a9a479
15 changed files with 172 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/mesh/mesh.c
View File

@ -1170,6 +1170,9 @@ static int mesh_node_startup_from_tlv(void){
}
static void mesh_control_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
UNUSED(callback_type);
UNUSED(status);
// get opcode
uint8_t opcode = mesh_pdu_control_opcode(pdu);
printf("MESH Control Message, Opcode: 0x%02x + ", opcode);

9
src/mesh/mesh_lower_transport.c
View File

@ -913,7 +913,6 @@ static void mesh_lower_transport_run(void){
while(!btstack_linked_list_empty(&lower_transport_outgoing_ready)) {
// get next message
mesh_network_pdu_t * network_pdu;
mesh_segmented_pdu_t * message_pdu;
mesh_pdu_t * pdu = (mesh_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_ready);
switch (pdu->pdu_type) {
@ -962,7 +961,7 @@ void mesh_lower_transport_send_pdu(mesh_pdu_t *pdu){
mesh_lower_transport_run();
}
static void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list){
void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list){
printf("List: %s:\n", name);
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, list);
@ -971,7 +970,8 @@ static void mesh_lower_transport_dump_network_pdus(const char *name, btstack_lin
printf("- %p: ", network_pdu); printf_hexdump(network_pdu->data, network_pdu->len);
}
}
static void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list){
void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list){
while (!btstack_linked_list_empty(list)){
mesh_network_pdu_t * pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(list);
btstack_memory_mesh_network_pdu_free(pdu);
@ -1008,9 +1008,6 @@ bool mesh_lower_transport_can_send_to_dest(uint16_t dest){
void mesh_lower_transport_reserve_slot(void){
}
void mesh_lower_transport_dump(void){
}
void mesh_lower_transport_reset(void){
if (lower_transport_outgoing_message){
while (!btstack_linked_list_empty(&lower_transport_outgoing_message->segments)){

3
src/mesh/mesh_lower_transport.h
View File

@ -89,8 +89,9 @@ void mesh_lower_transport_send_pdu(mesh_pdu_t * pdu);
// test
void mesh_lower_transport_received_message(mesh_network_callback_type_t callback_type, mesh_network_pdu_t *network_pdu);
void mesh_lower_transport_dump(void);
void mesh_lower_transport_reset(void);
void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list);
void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list);
#ifdef __cplusplus
} /* end of extern "C" */

17
src/mesh/mesh_network.c
View File

@ -275,20 +275,6 @@ static void mesh_network_send_complete(mesh_network_pdu_t * network_pdu){
}
}
static void mesh_network_send_d(mesh_network_pdu_t * network_pdu){
#ifdef LOG_NETWORK
printf("TX-D-NetworkPDU (%p): ", network_pdu);
printf_hexdump(network_pdu->data, network_pdu->len);
#endif
// add to queue
btstack_linked_list_add_tail(&network_pdus_outgoing_gatt, (btstack_linked_item_t *) network_pdu);
// go
mesh_network_run();
}
// new
static void mesh_network_send_c(void *arg){
UNUSED(arg);
@ -1089,9 +1075,6 @@ void mesh_network_send_pdu(mesh_network_pdu_t * network_pdu){
// go
mesh_network_run();
}
static void mesh_network_encrypt_proxy_configuration_encrypted(mesh_network_pdu_t * network_pdu){
(*mesh_network_proxy_message_handler)(MESH_NETWORK_PDU_ENCRYPTED, network_pdu);
}
void mesh_network_encrypt_proxy_configuration_message(mesh_network_pdu_t * network_pdu){
printf("ProxyPDU(unencrypted): ");

4
src/mesh/mesh_node.c
View File

@ -155,11 +155,11 @@ uint16_t mesh_access_get_element_address(mesh_model_t * mesh_model){
// Model Identifier utilities
uint32_t mesh_model_get_model_identifier(uint16_t vendor_id, uint16_t model_id){
return (vendor_id << 16) | model_id;
return (((uint32_t) vendor_id << 16)) | model_id;
}
uint32_t mesh_model_get_model_identifier_bluetooth_sig(uint16_t model_id){
return (BLUETOOTH_COMPANY_ID_BLUETOOTH_SIG_INC << 16) | model_id;
return ((uint32_t) BLUETOOTH_COMPANY_ID_BLUETOOTH_SIG_INC << 16) | model_id;
}
uint16_t mesh_model_get_model_id(uint32_t model_identifier){

12
src/mesh/mesh_upper_transport.c
View File

@ -384,6 +384,7 @@ static void mesh_upper_transport_process_access_message_done(mesh_access_pdu_t *
}
static void mesh_upper_transport_process_control_message_done(mesh_control_pdu_t * control_pdu){
UNUSED(control_pdu);
crypto_active = 0;
incoming_control_pdu = NULL;
mesh_upper_transport_run();
@ -856,8 +857,7 @@ static void mesh_upper_transport_run(void){
mesh_lower_transport_message_processed_by_higher_layer(pdu);
btstack_assert(mesh_control_message_handler != NULL);
mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_control_pdu;
mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu);
mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, (mesh_pdu_t*) incoming_control_pdu);
} else {
@ -905,8 +905,7 @@ static void mesh_upper_transport_run(void){
mesh_lower_transport_message_processed_by_higher_layer((mesh_pdu_t *)segmented_pdu);
btstack_assert(mesh_control_message_handler != NULL);
mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_control_pdu;
mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu);
mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, (mesh_pdu_t*) incoming_control_pdu);
} else {
@ -1037,7 +1036,6 @@ static mesh_upper_transport_pdu_t * mesh_upper_transport_find_and_remove_pdu_for
static void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
mesh_upper_transport_pdu_t * upper_pdu;
mesh_network_pdu_t * network_pdu;
mesh_segmented_pdu_t * segmented_pdu;
switch (callback_type){
case MESH_TRANSPORT_PDU_RECEIVED:
@ -1052,8 +1050,8 @@ static void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t call
segmented_pdu = (mesh_segmented_pdu_t *) pdu;
// free chunks
while (!btstack_linked_list_empty(&segmented_pdu->segments)){
mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&segmented_pdu->segments);
mesh_network_pdu_free(network_pdu);
mesh_network_pdu_t * chunk_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&segmented_pdu->segments);
mesh_network_pdu_free(chunk_pdu);
}
// free segmented pdu
btstack_memory_mesh_segmented_pdu_free(segmented_pdu);

1
test/mesh/btstack_uart_block_posix_pty.c
View File

@ -160,6 +160,7 @@ static void hci_transport_h5_process(btstack_data_source_t *ds, btstack_data_sou
}
static int btstack_uart_posix_set_baudrate(uint32_t baudrate){
UNUSED(baudrate);
#if 0
int fd = transport_data_source.source.fd;

10
test/mesh/main.c
View File

@ -87,7 +87,11 @@ static hci_transport_config_uart_t config = {
static btstack_packet_callback_registration_t hci_event_callback_registration;
static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
switch (hci_event_packet_get_type(packet)){
case BTSTACK_EVENT_STATE:
if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
@ -125,12 +129,6 @@ static void sigint_handler(int param){
exit(0);
}
static int led_state = 0;
void hal_led_toggle(void){
led_state = 1 - led_state;
printf("LED State %u\n", led_state);
}
static void local_version_information_handler(uint8_t * packet){
printf("Local version information:\n");
uint16_t hci_version = packet[6];

49
test/mesh/mesh_message_test.cpp
View File

@ -3,8 +3,6 @@
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
#include "bluetooth_data_types.h"
#include "bluetooth_gatt.h"
#include "btstack_debug.h"
#include "btstack_memory.h"
#include "btstack_util.h"
@ -19,8 +17,8 @@
#include "mesh/mesh_upper_transport.h"
#include "mesh/provisioning.h"
#include "mesh/mesh_peer.h"
#include "mock.h"
extern "C" int mock_process_hci_cmd(void);
static mesh_network_pdu_t * received_network_pdu;
static mesh_network_pdu_t * received_proxy_pdu;
@ -70,6 +68,7 @@ void gatt_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handle
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
@ -134,7 +133,7 @@ uint16_t mesh_pdu_ctl(mesh_pdu_t * pdu){
}
}
void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
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]) {
@ -147,9 +146,9 @@ void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
}
static int scan_hex_byte(const char * byte_string){
int upper_nibble = nibble_for_char(*byte_string++);
uint8_t upper_nibble = nibble_for_char(*byte_string++);
if (upper_nibble < 0) return -1;
int lower_nibble = nibble_for_char(*byte_string);
uint8_t lower_nibble = nibble_for_char(*byte_string);
if (lower_nibble < 0) return -1;
return (upper_nibble << 4) | lower_nibble;
}
@ -161,13 +160,13 @@ static int btstack_parse_hex(const char * string, uint16_t len, uint8_t * buffer
if (single_byte < 0) return 0;
string += 2;
buffer[i] = (uint8_t)single_byte;
// don't check seperator after last byte
// don't check separator after last byte
if (i == len - 1) {
return 1;
}
// optional seperator
char separator = *string;
if (separator == ':' && separator == '-' && separator == ' ') {
if (separator == ':' || separator == '-' || separator == ' ') {
string++;
}
}
@ -269,6 +268,7 @@ static void test_proxy_server_callback_handler(mesh_network_callback_type_t call
}
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);
// ignore pdu sent
if (callback_type == MESH_TRANSPORT_PDU_SENT) return;
@ -301,6 +301,8 @@ static void test_upper_transport_access_message_handler(mesh_transport_callback_
}
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;
@ -365,7 +367,7 @@ static uint16_t transport_pdu_len;
static uint8_t test_network_pdu_len;
static uint8_t test_network_pdu_data[29];
void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_transport_pdus, char * access_pdu){
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;
@ -409,7 +411,8 @@ void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_tr
CHECK_EQUAL_ARRAY(transport_pdu_data, recv_upper_transport_pdu_data, transport_pdu_len);
}
static void expect_gatt_network_pdu(const uint8_t * data, uint16_t len){
static void expect_gatt_network_pdu(void){
while (outgoing_gatt_network_pdu_len == 0) {
mock_process_hci_cmd();
}
@ -425,7 +428,7 @@ static void expect_gatt_network_pdu(const uint8_t * data, uint16_t len){
gatt_bearer_emit_sent();
}
static void expect_adv_network_pdu(const uint8_t * data, uint16_t len){
static void expect_adv_network_pdu(void){
while (outgoing_adv_network_pdu_len == 0) {
mock_process_hci_cmd();
}
@ -441,8 +444,9 @@ static void expect_adv_network_pdu(const uint8_t * data, uint16_t len){
adv_bearer_emit_sent();
}
static mesh_upper_transport_pdu_t upper_pdu = { 0 };
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){
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);
@ -479,16 +483,18 @@ void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index, uin
btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
#ifdef ENABLE_MESH_GATT_BEARER
expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len);
expect_gatt_network_pdu();
#endif
#ifdef ENABLE_MESH_ADV_BEARER
expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len);
expect_adv_network_pdu();
#endif
}
}
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){
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);
@ -505,9 +511,9 @@ void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src,
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 * upper_pdu = (mesh_upper_transport_pdu_t *) mesh_upper_transport_message_finalize(&builder);
mesh_upper_transport_setup_segmented_control_pdu_header(upper_pdu, netkey_index, ttl, src, dest, opcode);
pdu = (mesh_pdu_t *) upper_pdu;
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);
@ -519,11 +525,11 @@ void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src,
btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
#ifdef ENABLE_MESH_GATT_BEARER
expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len);
expect_gatt_network_pdu();
#endif
#ifdef ENABLE_MESH_ADV_BEARER
expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len);
expect_adv_network_pdu();
#endif
}
@ -1187,6 +1193,7 @@ TEST(MessageTest, ServiceDataUsingNodeIdentityTest){
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]);
}

67
test/mesh/mesh_pts.c
View File

@ -90,8 +90,6 @@ static const char * prov_public_key_string = "F465E43FF23D3F1B9DC7DFC04DA8758184
static uint8_t prov_private_key_data[32];
static const char * prov_private_key_string = "529AA0670D72CD6497502ED473502B037E8803B5C60829A5A3CAA219505530BA";
static mesh_transport_key_t pts_application_key;
// pin entry (pts)
static int ui_chars_for_pin;
static uint8_t ui_pin[17];
@ -154,6 +152,10 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
}
static void mesh_provisioning_message_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(packet_type);
UNUSED(channel);
UNUSED(size);
mesh_provisioning_data_t provisioning_data;
switch(packet[0]){
@ -204,6 +206,9 @@ static void mesh_provisioning_message_handler (uint8_t packet_type, uint16_t cha
}
static void mesh_state_update_message_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
switch(packet[0]){
@ -227,6 +232,9 @@ static void mesh_state_update_message_handler(uint8_t packet_type, uint16_t chan
}
static void mesh_configuration_message_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
switch(packet[0]){
@ -243,48 +251,6 @@ static void mesh_configuration_message_handler(uint8_t packet_type, uint16_t cha
}
// PTS
// helper network layer, temp
static void mesh_pts_received_network_message(mesh_network_callback_type_t callback_type, mesh_network_pdu_t *network_pdu){
switch (callback_type){
case MESH_NETWORK_PDU_RECEIVED:
printf("Received network message. SRC %04x, DST %04x, SEQ %04x\n",
mesh_network_src(network_pdu), mesh_network_dst(network_pdu), mesh_network_seq(network_pdu));
printf_hexdump(mesh_network_pdu_data(network_pdu), mesh_network_pdu_len(network_pdu));
mesh_network_message_processed_by_higher_layer(network_pdu);
break;
default:
break;
}
}
static uint8_t mesh_network_send(uint8_t ttl, uint16_t dest, const uint8_t * transport_pdu_data, uint8_t transport_pdu_len){
uint16_t netkey_index = 0;
uint8_t ctl = 0;
uint16_t src = mesh_node_get_primary_element_address();
uint32_t seq = mesh_sequence_number_next();
// "3.4.5.2: The output filter of the interface connected to advertising or GATT bearers shall drop all messages with TTL value set to 1."
// if (ttl <= 1) return 0;
// TODO: check transport_pdu_len depending on ctl
// lookup network by netkey_index
const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index);
if (!network_key) return 0;
// allocate network_pdu
mesh_network_pdu_t * network_pdu = mesh_network_pdu_get();
if (!network_pdu) return 0;
// setup network_pdu
mesh_network_setup_pdu(network_pdu, netkey_index, network_key->nid, ctl, ttl, seq, src, dest, transport_pdu_data, transport_pdu_len);
// send network_pdu
mesh_lower_transport_send_pdu((mesh_pdu_t *) network_pdu);
return 0;
}
static void printf_hex(const uint8_t * data, uint16_t len){
while (len){
printf("%02x", *data);
@ -323,6 +289,9 @@ static void mesh_pts_dump_mesh_options(void){
}
static void mesh_unprovisioned_beacon_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != MESH_BEACON_PACKET) return;
static uint8_t device_uuid[16];
uint16_t oob;
@ -372,16 +341,6 @@ static void btstack_print_hex(const uint8_t * data, uint16_t len, char separator
printf("\n");
}
static void load_pts_tspx_application_key(void){
// PTS app key
btstack_parse_hex("3216D1509884B533248541792B877F98", 16, pts_application_key.key);
pts_application_key.aid = 0x38;
pts_application_key.internal_index = mesh_transport_key_get_free_index();
mesh_transport_key_add(&pts_application_key);
printf("PTS Application Key (AID %02x): ", 0x38);
printf_hexdump(pts_application_key.key, 16);
}
static void send_pts_network_messsage(uint16_t dst_addr, uint8_t ttl){
uint8_t access_pdu_data[16];

19
test/mesh/mock.c
View File

@ -1,6 +1,7 @@
#include "mock.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ble/att_db.h"
@ -48,10 +49,14 @@ static void dump_packet(int packet_type, uint8_t * buffer, uint16_t size){
}
printf("};\n");
packet_counter++;
#else
UNUSED(packet_type);
UNUSED(buffer);
UNUSED(size);
#endif
}
void aes128_calc_cyphertext(uint8_t key[16], uint8_t plaintext[16], uint8_t cyphertext[16]){
static void aes128_calc_cyphertext(uint8_t key[16], uint8_t plaintext[16], uint8_t cyphertext[16]){
uint32_t rk[RKLENGTH(KEYBITS)];
int nrounds = rijndaelSetupEncrypt(rk, &key[0], KEYBITS);
rijndaelEncrypt(rk, nrounds, plaintext, cyphertext);
@ -152,19 +157,27 @@ HCI_STATE hci_get_state(void){
}
void btstack_run_loop_add_timer(btstack_timer_source_t * ts){
UNUSED(ts);
}
int btstack_run_loop_remove_timer(btstack_timer_source_t * ts){
UNUSED(ts);
return 0;
}
void btstack_run_loop_set_timer(btstack_timer_source_t * ts, uint32_t timeout){
UNUSED(ts);
UNUSED(timeout);
}
void btstack_run_loop_set_timer_handler(btstack_timer_source_t * ts, void (*fn)(btstack_timer_source_t * ts)){
UNUSED(ts);
UNUSED(fn);
}
static void * timer_context;
void btstack_run_loop_set_timer_context(btstack_timer_source_t * ts, void * context){
UNUSED(ts);
timer_context = context;
}
void * btstack_run_loop_get_timer_context(btstack_timer_source_t * ts){
UNUSED(ts);
return timer_context;
}
void hci_halting_defer(void){

59
test/mesh/mock.h Normal file
View File

@ -0,0 +1,59 @@
/*
* Copyright (C) 2018 BlueKitchen GmbH
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holders nor the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* 4. Any redistribution, use, or modification is done solely for
* personal benefit and not for any commercial purpose or for
* monetary gain.
*
* THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
* RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* Please inquire about commercial licensing options at
* contact@bluekitchen-gmbh.com
*
*/
#ifndef __MOCK_H
#define __MOCK_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdint.h>
void mock_init(void);
uint8_t * mock_packet_buffer(void);
void mock_clear_packet_buffer(void);
void mock_simulate_hci_event(uint8_t * packet, uint16_t size);
int mock_process_hci_cmd(void);
void mock_simulate_hci_state_working(void);
#ifdef __cplusplus
} /* end of extern "C" */
#endif
#endif

7
test/mesh/provisioner.c
View File

@ -147,6 +147,9 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
}
static void mesh_message_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
uint8_t public_oob = 0;
@ -240,7 +243,11 @@ static void mesh_message_handler (uint8_t packet_type, uint16_t channel, uint8_t
static uint8_t device_uuid[16];
static void mesh_unprovisioned_beacon_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != MESH_BEACON_PACKET) return;
uint16_t oob;
memcpy(device_uuid, &packet[1], 16);
oob = big_endian_read_16(packet, 17);

52
test/mesh/provisioning_device_test.cpp
View File

@ -37,8 +37,7 @@
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "btstack_memory.h"
#include "ble/gatt-service/mesh_provisioning_service_server.h"
#include "hci_dump.h"
#include "mesh/mesh_node.h"
@ -50,6 +49,8 @@
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
#include "mock.h"
static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
int i;
for (i=0; i<size; i++){
@ -62,37 +63,6 @@ static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
}
}
void dump_data(uint8_t * buffer, uint16_t size){
static int data_counter = 1;
char var_name[80];
sprintf(var_name, "test_data_%02u", data_counter);
printf("uint8_t %s[] = { ", var_name);
for (int i = 0; i < size ; i++){
if ((i % 16) == 0) printf("\n ");
printf ("0x%02x, ", buffer[i]);
}
printf("};\n");
data_counter++;
}
int parse_hex(uint8_t * buffer, const char * hex_string){
int len = 0;
while (*hex_string){
if (*hex_string == ' '){
hex_string++;
continue;
}
int high_nibble = nibble_for_char(*hex_string++);
int low_nibble = nibble_for_char(*hex_string++);
*buffer++ = (high_nibble << 4) | low_nibble;
len++;
}
return len;
}
// returns if anything was done
extern "C" int mock_process_hci_cmd(void);
const static uint8_t device_uuid[] = { 0x00, 0x1B, 0xDC, 0x08, 0x10, 0x21, 0x0B, 0x0E, 0x0A, 0x0C, 0x00, 0x0B, 0x0E, 0x0A, 0x0C, 0x00 };
// pb-adv mock for testing
@ -114,8 +84,14 @@ void pb_gatt_init(void){}
* @param con_handle
* @param reason 0 = success, 1 = timeout, 2 = fail
*/
void pb_gatt_close_link(hci_con_handle_t con_handle, uint8_t reason){}
void pb_adv_close_link(hci_con_handle_t con_handle, uint8_t reason){}
void pb_gatt_close_link(hci_con_handle_t con_handle, uint8_t reason){
UNUSED(con_handle);
UNUSED(reason);
}
void pb_adv_close_link(hci_con_handle_t con_handle, uint8_t reason){
UNUSED(con_handle);
UNUSED(reason);
}
/**
@ -138,7 +114,11 @@ void pb_adv_send_pdu(uint16_t pb_transport_cid, const uint8_t * pdu, uint16_t si
// dump_data((uint8_t*)pdu,size);
// printf_hexdump(pdu, size);
}
void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t pdu_size){}
void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t _pdu_size){
UNUSED(con_handle);
UNUSED(pdu);
UNUSED(_pdu_size);
}
uint16_t mesh_network_key_get_free_index(void){
return 0;

46
test/mesh/provisioning_provisioner_test.cpp
View File

@ -45,6 +45,7 @@
#include "mesh/provisioning.h"
#include "mesh/provisioning_provisioner.h"
#include "hci_dump.h"
#include "mock.h"
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
@ -61,37 +62,6 @@ static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
}
}
void dump_data(uint8_t * buffer, uint16_t size){
static int data_counter = 1;
char var_name[80];
sprintf(var_name, "test_data_%02u", data_counter);
printf("uint8_t %s[] = { ", var_name);
for (int i = 0; i < size ; i++){
if ((i % 16) == 0) printf("\n ");
printf ("0x%02x, ", buffer[i]);
}
printf("};\n");
data_counter++;
}
int parse_hex(uint8_t * buffer, const char * hex_string){
int len = 0;
while (*hex_string){
if (*hex_string == ' '){
hex_string++;
continue;
}
int high_nibble = nibble_for_char(*hex_string++);
int low_nibble = nibble_for_char(*hex_string++);
*buffer++ = (high_nibble << 4) | low_nibble;
len++;
}
return len;
}
// returns if anything was done
extern "C" int mock_process_hci_cmd(void);
// pb-adv mock for testing
static btstack_packet_handler_t pb_adv_packet_handler;
@ -114,7 +84,10 @@ static void pb_adv_emit_pdu_sent(uint8_t status){
void pb_adv_init(void){}
void pb_gatt_init(void){}
void pb_adv_close_link(uint16_t pb_adv_cid, uint8_t reason){}
void pb_adv_close_link(uint16_t pb_adv_cid, uint8_t reason){
UNUSED(pb_adv_cid);
UNUSED(reason);
}
void pb_adv_register_provisioner_packet_handler(btstack_packet_handler_t packet_handler){
pb_adv_packet_handler = packet_handler;
@ -131,9 +104,14 @@ void pb_adv_send_pdu(uint16_t pb_transport_cid, const uint8_t * pdu, uint16_t si
// dump_data((uint8_t*)pdu,size);
// printf_hexdump(pdu, size);
}
void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t pdu_size){}
void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t _pdu_size){
UNUSED(con_handle);
UNUSED(pdu);
UNUSED(_pdu_size);
}
uint16_t pb_adv_create_link(const uint8_t * device_uuid){
UNUSED(device_uuid);
// just simluate opened
pb_adv_emit_link_open(0, 1);
return 1;
@ -185,6 +163,8 @@ static uint8_t prov_static_oob_data[16];
static const char * prov_static_oob_string = "00000000000000000102030405060708";
static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
switch(packet[0]){
case HCI_EVENT_MESH_META: