mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-04-15 23:42:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

ignore memcpy return value (always returns first parameter)

Browse Source
This commit is contained in:
Matthias Ringwald 2019-12-02 18:17:20 +01:00
parent 9c2810d096
commit 6535961a1f
65 changed files with 534 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ble/ancs_client.c
View File

@ -121,7 +121,7 @@ static void notify_client_text(int event_type){
event[2] = event_type;
little_endian_store_16(event, 3, gc_handle);
little_endian_store_16(event, 5, ancs_attribute_id);
memcpy(&event[7], ancs_notification_buffer, ancs_attribute_len);
(void)memcpy(&event[7], ancs_notification_buffer, ancs_attribute_len);
// we're nice
event[7+ancs_attribute_len] = 0;
(*client_handler)(HCI_EVENT_PACKET, 0, event, event[1] + 2);

13
src/ble/att_db.c
View File

@ -198,7 +198,7 @@ static int att_copy_value(att_iterator_t *it, uint16_t offset, uint8_t * buffer,
if (bytes_to_copy > buffer_size){
bytes_to_copy = buffer_size;
}
memcpy(buffer, it->value, bytes_to_copy);
(void)memcpy(buffer, it->value, bytes_to_copy);
return bytes_to_copy;
}
@ -427,7 +427,7 @@ static uint16_t handle_find_information_request2(att_connection_t * att_connecti
little_endian_store_16(response_buffer, offset, it.handle);
offset += 2;
memcpy(response_buffer + offset, it.uuid, uuid_len);
(void)memcpy(response_buffer + offset, it.uuid, uuid_len);
offset += uuid_len;
}
@ -892,7 +892,8 @@ static uint16_t handle_read_by_group_type_request2(att_connection_t * att_connec
offset += 2;
little_endian_store_16(response_buffer, offset, prev_handle);
offset += 2;
memcpy(response_buffer + offset, group_start_value, pair_len - 4);
(void)memcpy(response_buffer + offset, group_start_value,
pair_len - 4);
offset += pair_len - 4;
in_group = 0;
@ -1041,7 +1042,7 @@ static uint16_t handle_prepare_write_request(att_connection_t * att_connection,
}
// response: echo request
memcpy(response_buffer, request_buffer, request_len);
(void)memcpy(response_buffer, request_buffer, request_len);
response_buffer[0] = ATT_PREPARE_WRITE_RESPONSE;
return request_len;
}
@ -1114,7 +1115,7 @@ static uint16_t prepare_handle_value(att_connection_t * att_connection,
if (value_len > (att_connection->mtu - 3)){
value_len = att_connection->mtu - 3;
}
memcpy(&response_buffer[3], value, value_len);
(void)memcpy(&response_buffer[3], value, value_len);
return value_len + 3;
}
@ -1386,7 +1387,7 @@ bool att_is_persistent_ccc(uint16_t handle){
uint16_t att_read_callback_handle_blob(const uint8_t * blob, uint16_t blob_size, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){
if (buffer){
uint16_t bytes_to_copy = btstack_min(blob_size - offset, buffer_size);
memcpy(buffer, &blob[offset], bytes_to_copy);
(void)memcpy(buffer, &blob[offset], bytes_to_copy);
return bytes_to_copy;
} else {
return blob_size;

4
src/ble/att_db_util.c
View File

@ -122,7 +122,7 @@ static void att_db_util_add_attribute_uuid16(uint16_t uuid16, uint16_t flags, ui
att_db_next_handle++;
little_endian_store_16(att_db, att_db_size, uuid16);
att_db_size += 2;
memcpy(&att_db[att_db_size], data, data_len);
(void)memcpy(&att_db[att_db_size], data, data_len);
att_db_size += data_len;
att_db_util_set_end_tag();
}
@ -140,7 +140,7 @@ static void att_db_util_add_attribute_uuid128(const uint8_t * uuid128, uint16_t
att_db_next_handle++;
reverse_128(uuid128, &att_db[att_db_size]);
att_db_size += 16;
memcpy(&att_db[att_db_size], data, data_len);
(void)memcpy(&att_db[att_db_size], data, data_len);
att_db_size += data_len;
att_db_util_set_end_tag();
}

2
src/ble/att_server.c
View File

@ -802,7 +802,7 @@ static void att_server_handle_att_pdu(att_server_t * att_server, uint8_t * packe
// store request
att_server->state = ATT_SERVER_REQUEST_RECEIVED;
att_server->request_size = size;
memcpy(att_server->request_buffer, packet, size);
(void)memcpy(att_server->request_buffer, packet, size);
att_run_for_context(att_server);
}

3
src/ble/gatt-service/cycling_power_service_server.c
View File

@ -654,7 +654,8 @@ static void cycling_power_service_response_can_send_now(void * context){
pos += 2;
int data_len = (instance->num_manufacturer_specific_data < CYCLING_POWER_MANUFACTURER_SPECIFIC_DATA_MAX_SIZE) ? instance->num_manufacturer_specific_data : (CYCLING_POWER_MANUFACTURER_SPECIFIC_DATA_MAX_SIZE - 1);
value[pos++] = data_len;
memcpy(&value[pos], instance->manufacturer_specific_data, data_len);
(void)memcpy(&value[pos],
instance->manufacturer_specific_data, data_len);
pos += data_len;
value[pos++] = 0;
break;

4
src/ble/gatt-service/device_information_service_server.c
View File

@ -109,7 +109,9 @@ static uint16_t device_information_service_read_callback(hci_con_handle_t con_ha
return device_information_fields[i].len;
}
int bytes_to_copy = btstack_min(device_information_fields[i].len - offset, buffer_size);
memcpy(buffer, &device_information_fields[i].data[offset], bytes_to_copy);
(void)memcpy(buffer,
&device_information_fields[i].data[offset],
bytes_to_copy);
return bytes_to_copy;
}
return 0;

18
src/ble/gatt_client.c
View File

@ -236,7 +236,7 @@ static uint8_t att_find_by_type_value_request(uint16_t request_type, uint16_t at
little_endian_store_16(request, 1, start_handle);
little_endian_store_16(request, 3, end_handle);
little_endian_store_16(request, 5, attribute_group_type);
memcpy(&request[7], value, value_size);
(void)memcpy(&request[7], value, value_size);
return l2cap_send_prepared_connectionless(peripheral_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, 7+value_size);
}
@ -307,7 +307,7 @@ static uint8_t att_signed_write_request(uint16_t request_type, uint16_t peripher
uint8_t * request = l2cap_get_outgoing_buffer();
request[0] = request_type;
little_endian_store_16(request, 1, attribute_handle);
memcpy(&request[3], value, value_length);
(void)memcpy(&request[3], value, value_length);
little_endian_store_32(request, 3 + value_length, sign_counter);
reverse_64(sgn, &request[3 + value_length + 4]);
@ -321,7 +321,7 @@ static uint8_t att_write_request(uint16_t request_type, uint16_t peripheral_hand
uint8_t * request = l2cap_get_outgoing_buffer();
request[0] = request_type;
little_endian_store_16(request, 1, attribute_handle);
memcpy(&request[3], value, value_length);
(void)memcpy(&request[3], value, value_length);
return l2cap_send_prepared_connectionless(peripheral_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, 3 + value_length);
}
@ -343,7 +343,7 @@ static uint8_t att_prepare_write_request(uint16_t request_type, uint16_t periphe
request[0] = request_type;
little_endian_store_16(request, 1, attribute_handle);
little_endian_store_16(request, 3, value_offset);
memcpy(&request[5], &value[value_offset], blob_length);
(void)memcpy(&request[5], &value[value_offset], blob_length);
return l2cap_send_prepared_connectionless(peripheral_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, 5+blob_length);
}
@ -630,7 +630,7 @@ static void characteristic_start_found(gatt_client_t * peripheral, uint16_t star
if (peripheral->filter_with_uuid) return;
peripheral->uuid16 = uuid16;
memcpy(peripheral->uuid128, uuid128, 16);
(void)memcpy(peripheral->uuid128, uuid128, 16);
}
static void characteristic_end_found(gatt_client_t * peripheral, uint16_t end_handle){
@ -1624,7 +1624,7 @@ static void att_signed_write_handle_cmac_result(uint8_t hash[8]){
gatt_client_t * peripheral = (gatt_client_t *) btstack_linked_list_iterator_next(&it);
if (peripheral->gatt_client_state == P_W4_CMAC_RESULT){
// store result
memcpy(peripheral->cmac, hash, 8);
(void)memcpy(peripheral->cmac, hash, 8);
// reverse_64(hash, peripheral->cmac);
peripheral->gatt_client_state = P_W2_SEND_SIGNED_WRITE;
gatt_client_run();
@ -1687,7 +1687,7 @@ uint8_t gatt_client_discover_primary_services_by_uuid128(btstack_packet_handler_
peripheral->start_group_handle = 0x0001;
peripheral->end_group_handle = 0xffff;
peripheral->uuid16 = 0;
memcpy(peripheral->uuid128, uuid128, 16);
(void)memcpy(peripheral->uuid128, uuid128, 16);
peripheral->gatt_client_state = P_W2_SEND_SERVICE_WITH_UUID_QUERY;
gatt_client_run();
return ERROR_CODE_SUCCESS;
@ -1748,7 +1748,7 @@ uint8_t gatt_client_discover_characteristics_for_handle_range_by_uuid128(btstack
peripheral->end_group_handle = end_handle;
peripheral->filter_with_uuid = 1;
peripheral->uuid16 = 0;
memcpy(peripheral->uuid128, uuid128, 16);
(void)memcpy(peripheral->uuid128, uuid128, 16);
peripheral->characteristic_start_handle = 0;
peripheral->gatt_client_state = P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY;
gatt_client_run();
@ -1822,7 +1822,7 @@ uint8_t gatt_client_read_value_of_characteristics_by_uuid128(btstack_packet_hand
peripheral->query_start_handle = start_handle;
peripheral->query_end_handle = end_handle;
peripheral->uuid16 = 0;
memcpy(peripheral->uuid128, uuid128, 16);
(void)memcpy(peripheral->uuid128, uuid128, 16);
peripheral->gatt_client_state = P_W2_SEND_READ_BY_TYPE_REQUEST;
gatt_client_run();
return ERROR_CODE_SUCCESS;

24
src/ble/le_device_db_memory.c
View File

@ -129,8 +129,8 @@ int le_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){
log_info_key("irk", irk);
le_devices[index].addr_type = addr_type;
memcpy(le_devices[index].addr, addr, 6);
memcpy(le_devices[index].irk, irk, 16);
(void)memcpy(le_devices[index].addr, addr, 6);
(void)memcpy(le_devices[index].irk, irk, 16);
#ifdef ENABLE_LE_SIGNED_WRITE
le_devices[index].remote_counter = 0;
#endif
@ -141,8 +141,8 @@ int le_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){
// get device information: addr type and address
void le_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t irk){
if (addr_type) *addr_type = le_devices[index].addr_type;
if (addr) memcpy(addr, le_devices[index].addr, 6);
if (irk) memcpy(irk, le_devices[index].irk, 16);
if (addr) (void)memcpy(addr, le_devices[index].addr, 6);
if (irk) (void)memcpy(irk, le_devices[index].irk, 16);
}
void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk, int key_size, int authenticated, int authorized, int secure_connection){
@ -150,8 +150,8 @@ void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_k
index, ediv, key_size, authenticated, authorized, secure_connection);
le_device_memory_db_t * device = &le_devices[index];
device->ediv = ediv;
if (rand) memcpy(device->rand, rand, 8);
if (ltk) memcpy(device->ltk, ltk, 16);
if (rand) (void)memcpy(device->rand, rand, 8);
if (ltk) (void)memcpy(device->ltk, ltk, 16);
device->key_size = key_size;
device->authenticated = authenticated;
device->authorized = authorized;
@ -163,8 +163,8 @@ void le_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm
log_info("LE Device DB encryption for %u, ediv x%04x, keysize %u, authenticated %u, authorized %u, secure connection %u",
index, device->ediv, device->key_size, device->authenticated, device->authorized, device->secure_connection);
if (ediv) *ediv = device->ediv;
if (rand) memcpy(rand, device->rand, 8);
if (ltk) memcpy(ltk, device->ltk, 16);
if (rand) (void)memcpy(rand, device->rand, 8);
if (ltk) (void)memcpy(ltk, device->ltk, 16);
if (key_size) *key_size = device->key_size;
if (authenticated) *authenticated = device->authenticated;
if (authorized) *authorized = device->authorized;
@ -179,7 +179,7 @@ void le_device_db_remote_csrk_get(int index, sm_key_t csrk){
log_error("le_device_db_remote_csrk_get called with invalid index %d", index);
return;
}
if (csrk) memcpy(csrk, le_devices[index].remote_csrk, 16);
if (csrk) (void)memcpy(csrk, le_devices[index].remote_csrk, 16);
}
void le_device_db_remote_csrk_set(int index, sm_key_t csrk){
@ -187,7 +187,7 @@ void le_device_db_remote_csrk_set(int index, sm_key_t csrk){
log_error("le_device_db_remote_csrk_set called with invalid index %d", index);
return;
}
if (csrk) memcpy(le_devices[index].remote_csrk, csrk, 16);
if (csrk) (void)memcpy(le_devices[index].remote_csrk, csrk, 16);
}
void le_device_db_local_csrk_get(int index, sm_key_t csrk){
@ -195,7 +195,7 @@ void le_device_db_local_csrk_get(int index, sm_key_t csrk){
log_error("le_device_db_local_csrk_get called with invalid index %d", index);
return;
}
if (csrk) memcpy(csrk, le_devices[index].local_csrk, 16);
if (csrk) (void)memcpy(csrk, le_devices[index].local_csrk, 16);
}
void le_device_db_local_csrk_set(int index, sm_key_t csrk){
@ -203,7 +203,7 @@ void le_device_db_local_csrk_set(int index, sm_key_t csrk){
log_error("le_device_db_local_csrk_set called with invalid index %d", index);
return;
}
if (csrk) memcpy(le_devices[index].local_csrk, csrk, 16);
if (csrk) (void)memcpy(le_devices[index].local_csrk, csrk, 16);
}
// query last used/seen signing counter

24
src/ble/le_device_db_tlv.c
View File

@ -248,8 +248,8 @@ int le_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){
memset(&entry, 0, sizeof(le_device_db_entry_t));
entry.addr_type = addr_type;
memcpy(entry.addr, addr, 6);
memcpy(entry.irk, irk, 16);
(void)memcpy(entry.addr, addr, 6);
(void)memcpy(entry.irk, irk, 16);
entry.seq_nr = highest_seq_nr + 1;
#ifdef ENABLE_LE_SIGNED_WRITE
entry.remote_counter = 0;
@ -288,8 +288,8 @@ void le_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t irk)
// setup return values
if (addr_type) *addr_type = entry.addr_type;
if (addr) memcpy(addr, entry.addr, 6);
if (irk) memcpy(irk, entry.irk, 16);
if (addr) (void)memcpy(addr, entry.addr, 6);
if (irk) (void)memcpy(irk, entry.irk, 16);
}
void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk, int key_size, int authenticated, int authorized, int secure_connection){
@ -303,8 +303,8 @@ void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_k
log_info("LE Device DB set encryption for %u, ediv x%04x, key size %u, authenticated %u, authorized %u, secure connection %u",
index, ediv, key_size, authenticated, authorized, secure_connection);
entry.ediv = ediv;
if (rand) memcpy(entry.rand, rand, 8);
if (ltk) memcpy(entry.ltk, ltk, 16);
if (rand) (void)memcpy(entry.rand, rand, 8);
if (ltk) (void)memcpy(entry.ltk, ltk, 16);
entry.key_size = key_size;
entry.authenticated = authenticated;
entry.authorized = authorized;
@ -328,8 +328,8 @@ void le_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm
log_info("LE Device DB encryption for %u, ediv x%04x, keysize %u, authenticated %u, authorized %u, secure connection %u",
index, entry.ediv, entry.key_size, entry.authenticated, entry.authorized, entry.secure_connection);
if (ediv) *ediv = entry.ediv;
if (rand) memcpy(rand, entry.rand, 8);
if (ltk) memcpy(ltk, entry.ltk, 16);
if (rand) (void)memcpy(rand, entry.rand, 8);
if (ltk) (void)memcpy(ltk, entry.ltk, 16);
if (key_size) *key_size = entry.key_size;
if (authenticated) *authenticated = entry.authenticated;
if (authorized) *authorized = entry.authorized;
@ -346,7 +346,7 @@ void le_device_db_remote_csrk_get(int index, sm_key_t csrk){
int ok = le_device_db_tlv_fetch(index, &entry);
if (!ok) return;
if (csrk) memcpy(csrk, entry.remote_csrk, 16);
if (csrk) (void)memcpy(csrk, entry.remote_csrk, 16);
}
void le_device_db_remote_csrk_set(int index, sm_key_t csrk){
@ -359,7 +359,7 @@ void le_device_db_remote_csrk_set(int index, sm_key_t csrk){
if (!csrk) return;
// update
memcpy(entry.remote_csrk, csrk, 16);
(void)memcpy(entry.remote_csrk, csrk, 16);
// store
le_device_db_tlv_store(index, &entry);
@ -375,7 +375,7 @@ void le_device_db_local_csrk_get(int index, sm_key_t csrk){
if (!csrk) return;
// fill
memcpy(csrk, entry.local_csrk, 16);
(void)memcpy(csrk, entry.local_csrk, 16);
}
void le_device_db_local_csrk_set(int index, sm_key_t csrk){
@ -388,7 +388,7 @@ void le_device_db_local_csrk_set(int index, sm_key_t csrk){
if (!csrk) return;
// update
memcpy(entry.local_csrk, csrk, 16);
(void)memcpy(entry.local_csrk, csrk, 16);
// store
le_device_db_tlv_store(index, &entry);

125
src/ble/sm.c
View File

@ -612,7 +612,7 @@ static void gap_random_address_update_stop(void){
static void sm_ah_r_prime(uint8_t r[3], uint8_t * r_prime){
// r'= padding || r
memset(r_prime, 0, 16);
memcpy(&r_prime[13], r, 3);
(void)memcpy(&r_prime[13], r, 3);
}
// d1 helper
@ -661,8 +661,8 @@ static void sm_c1_t3(sm_key_t t2, bd_addr_t ia, bd_addr_t ra, uint8_t * t3){
sm_key_t p2;
memset(p2, 0, 16);
memcpy(&p2[4], ia, 6);
memcpy(&p2[10], ra, 6);
(void)memcpy(&p2[4], ia, 6);
(void)memcpy(&p2[10], ra, 6);
log_info_key("p2", p2);
// c1 = e(k, t2_xor_p2)
@ -676,8 +676,8 @@ static void sm_c1_t3(sm_key_t t2, bd_addr_t ia, bd_addr_t ra, uint8_t * t3){
static void sm_s1_r_prime(sm_key_t r1, sm_key_t r2, uint8_t * r_prime){
log_info_key("r1", r1);
log_info_key("r2", r2);
memcpy(&r_prime[8], &r2[8], 8);
memcpy(&r_prime[0], &r1[8], 8);
(void)memcpy(&r_prime[8], &r2[8], 8);
(void)memcpy(&r_prime[0], &r1[8], 8);
}
static void sm_dispatch_event(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size){
@ -848,7 +848,7 @@ static int sm_address_resolution_idle(void){
}
static void sm_address_resolution_start_lookup(uint8_t addr_type, hci_con_handle_t con_handle, bd_addr_t addr, address_resolution_mode_t mode, void * context){
memcpy(sm_address_resolution_address, addr, 6);
(void)memcpy(sm_address_resolution_address, addr, 6);
sm_address_resolution_addr_type = addr_type;
sm_address_resolution_test = 0;
sm_address_resolution_mode = mode;
@ -871,7 +871,7 @@ int sm_address_resolution_lookup(uint8_t address_type, bd_addr_t address){
entry = btstack_memory_sm_lookup_entry_get();
if (!entry) return BTSTACK_MEMORY_ALLOC_FAILED;
entry->address_type = (bd_addr_type_t) address_type;
memcpy(entry->address, address, 6);
(void)memcpy(entry->address, address, 6);
btstack_linked_list_add(&sm_address_resolution_general_queue, (btstack_linked_item_t *) entry);
sm_run();
return 0;
@ -1039,7 +1039,7 @@ static void sm_init_setup(sm_connection_t * sm_conn){
// fill in sm setup
setup->sm_peer_addr_type = sm_conn->sm_peer_addr_type;
memcpy(setup->sm_peer_address, sm_conn->sm_peer_address, 6);
(void)memcpy(setup->sm_peer_address, sm_conn->sm_peer_address, 6);
// query client for Legacy Pairing OOB data
setup->sm_have_oob_data = 0;
@ -1078,13 +1078,13 @@ static void sm_init_setup(sm_connection_t * sm_conn){
local_packet = &setup->sm_s_pres;
gap_le_get_own_address(&setup->sm_s_addr_type, setup->sm_s_address);
setup->sm_m_addr_type = sm_conn->sm_peer_addr_type;
memcpy(setup->sm_m_address, sm_conn->sm_peer_address, 6);
(void)memcpy(setup->sm_m_address, sm_conn->sm_peer_address, 6);
} else {
// master
local_packet = &setup->sm_m_preq;
gap_le_get_own_address(&setup->sm_m_addr_type, setup->sm_m_address);
setup->sm_s_addr_type = sm_conn->sm_peer_addr_type;
memcpy(setup->sm_s_address, sm_conn->sm_peer_address, 6);
(void)memcpy(setup->sm_s_address, sm_conn->sm_peer_address, 6);
int key_distribution_flags = sm_key_distribution_flags_for_auth_req();
sm_pairing_packet_set_initiator_key_distribution(setup->sm_m_preq, key_distribution_flags);
@ -1418,7 +1418,7 @@ static void sm_sc_cmac_done(uint8_t * hash){
switch (sm_conn->sm_engine_state){
case SM_SC_W4_CMAC_FOR_CONFIRMATION:
memcpy(setup->sm_local_confirm, hash, 16);
(void)memcpy(setup->sm_local_confirm, hash, 16);
sm_conn->sm_engine_state = SM_SC_SEND_CONFIRMATION;
break;
case SM_SC_W4_CMAC_FOR_CHECK_CONFIRMATION:
@ -1437,11 +1437,11 @@ static void sm_sc_cmac_done(uint8_t * hash){
break;
}
case SM_SC_W4_CALCULATE_F5_SALT:
memcpy(setup->sm_t, hash, 16);
(void)memcpy(setup->sm_t, hash, 16);
sm_conn->sm_engine_state = SM_SC_W2_CALCULATE_F5_MACKEY;
break;
case SM_SC_W4_CALCULATE_F5_MACKEY:
memcpy(setup->sm_mackey, hash, 16);
(void)memcpy(setup->sm_mackey, hash, 16);
sm_conn->sm_engine_state = SM_SC_W2_CALCULATE_F5_LTK;
break;
case SM_SC_W4_CALCULATE_F5_LTK:
@ -1449,13 +1449,13 @@ static void sm_sc_cmac_done(uint8_t * hash){
// Errata Service Release to the Bluetooth Specification: ESR09
// E6405 – Cross transport key derivation from a key of size less than 128 bits
// Note: When the BR/EDR link key is being derived from the LTK, the derivation is done before the LTK gets masked."
memcpy(setup->sm_ltk, hash, 16);
memcpy(setup->sm_local_ltk, hash, 16);
(void)memcpy(setup->sm_ltk, hash, 16);
(void)memcpy(setup->sm_local_ltk, hash, 16);
sm_truncate_key(setup->sm_ltk, sm_conn->sm_actual_encryption_key_size);
sm_conn->sm_engine_state = SM_SC_W2_CALCULATE_F6_FOR_DHKEY_CHECK;
break;
case SM_SC_W4_CALCULATE_F6_FOR_DHKEY_CHECK:
memcpy(setup->sm_local_dhkey_check, hash, 16);
(void)memcpy(setup->sm_local_dhkey_check, hash, 16);
if (IS_RESPONDER(sm_conn->sm_role)){
// responder
if (setup->sm_state_vars & SM_STATE_VAR_DHKEY_COMMAND_RECEIVED){
@ -1481,7 +1481,7 @@ static void sm_sc_cmac_done(uint8_t * hash){
}
break;
case SM_SC_W4_CALCULATE_H6_ILK:
memcpy(setup->sm_t, hash, 16);
(void)memcpy(setup->sm_t, hash, 16);
sm_conn->sm_engine_state = SM_SC_W2_CALCULATE_H6_BR_EDR_LINK_KEY;
break;
case SM_SC_W4_CALCULATE_H6_BR_EDR_LINK_KEY:
@ -1514,8 +1514,8 @@ static void sm_sc_cmac_done(uint8_t * hash){
static void f4_engine(sm_connection_t * sm_conn, const sm_key256_t u, const sm_key256_t v, const sm_key_t x, uint8_t z){
const uint16_t message_len = 65;
sm_cmac_connection = sm_conn;
memcpy(sm_cmac_sc_buffer, u, 32);
memcpy(sm_cmac_sc_buffer+32, v, 32);
(void)memcpy(sm_cmac_sc_buffer, u, 32);
(void)memcpy(sm_cmac_sc_buffer + 32, v, 32);
sm_cmac_sc_buffer[64] = z;
log_info("f4 key");
log_info_hexdump(x, 16);
@ -1533,7 +1533,7 @@ static void f5_calculate_salt(sm_connection_t * sm_conn){
// calculate salt for f5
const uint16_t message_len = 32;
sm_cmac_connection = sm_conn;
memcpy(sm_cmac_sc_buffer, setup->sm_dhkey, message_len);
(void)memcpy(sm_cmac_sc_buffer, setup->sm_dhkey, message_len);
sm_cmac_message_start(f5_salt, message_len, sm_cmac_sc_buffer, &sm_sc_cmac_done);
}
@ -1543,12 +1543,12 @@ static inline void f5_mackkey(sm_connection_t * sm_conn, sm_key_t t, const sm_ke
// f5(W, N1, N2, A1, A2) = AES-CMACT (Counter = 0 || keyID || N1 || N2|| A1|| A2 || Length = 256) -- this is the MacKey
sm_cmac_sc_buffer[0] = 0;
memcpy(sm_cmac_sc_buffer+01, f5_key_id, 4);
memcpy(sm_cmac_sc_buffer+05, n1, 16);
memcpy(sm_cmac_sc_buffer+21, n2, 16);
memcpy(sm_cmac_sc_buffer+37, a1, 7);
memcpy(sm_cmac_sc_buffer+44, a2, 7);
memcpy(sm_cmac_sc_buffer+51, f5_length, 2);
(void)memcpy(sm_cmac_sc_buffer + 01, f5_key_id, 4);
(void)memcpy(sm_cmac_sc_buffer + 05, n1, 16);
(void)memcpy(sm_cmac_sc_buffer + 21, n2, 16);
(void)memcpy(sm_cmac_sc_buffer + 37, a1, 7);
(void)memcpy(sm_cmac_sc_buffer + 44, a2, 7);
(void)memcpy(sm_cmac_sc_buffer + 51, f5_length, 2);
log_info("f5 key");
log_info_hexdump(t, 16);
log_info("f5 message for MacKey");
@ -1560,8 +1560,8 @@ static void f5_calculate_mackey(sm_connection_t * sm_conn){
sm_key56_t bd_addr_master, bd_addr_slave;
bd_addr_master[0] = setup->sm_m_addr_type;
bd_addr_slave[0] = setup->sm_s_addr_type;
memcpy(&bd_addr_master[1], setup->sm_m_address, 6);
memcpy(&bd_addr_slave[1], setup->sm_s_address, 6);
(void)memcpy(&bd_addr_master[1], setup->sm_m_address, 6);
(void)memcpy(&bd_addr_slave[1], setup->sm_s_address, 6);
if (IS_RESPONDER(sm_conn->sm_role)){
// responder
f5_mackkey(sm_conn, setup->sm_t, setup->sm_peer_nonce, setup->sm_local_nonce, bd_addr_master, bd_addr_slave);
@ -1591,12 +1591,12 @@ static void f5_calculate_ltk(sm_connection_t * sm_conn){
static void f6_engine(sm_connection_t * sm_conn, const sm_key_t w, const sm_key_t n1, const sm_key_t n2, const sm_key_t r, const sm_key24_t io_cap, const sm_key56_t a1, const sm_key56_t a2){
const uint16_t message_len = 65;
sm_cmac_connection = sm_conn;
memcpy(sm_cmac_sc_buffer, n1, 16);
memcpy(sm_cmac_sc_buffer+16, n2, 16);
memcpy(sm_cmac_sc_buffer+32, r, 16);
memcpy(sm_cmac_sc_buffer+48, io_cap, 3);
memcpy(sm_cmac_sc_buffer+51, a1, 7);
memcpy(sm_cmac_sc_buffer+58, a2, 7);
(void)memcpy(sm_cmac_sc_buffer, n1, 16);
(void)memcpy(sm_cmac_sc_buffer + 16, n2, 16);
(void)memcpy(sm_cmac_sc_buffer + 32, r, 16);
(void)memcpy(sm_cmac_sc_buffer + 48, io_cap, 3);
(void)memcpy(sm_cmac_sc_buffer + 51, a1, 7);
(void)memcpy(sm_cmac_sc_buffer + 58, a2, 7);
log_info("f6 key");
log_info_hexdump(w, 16);
log_info("f6 message");
@ -1612,9 +1612,9 @@ static void f6_engine(sm_connection_t * sm_conn, const sm_key_t w, const sm_key_
static void g2_engine(sm_connection_t * sm_conn, const sm_key256_t u, const sm_key256_t v, const sm_key_t x, const sm_key_t y){
const uint16_t message_len = 80;
sm_cmac_connection = sm_conn;
memcpy(sm_cmac_sc_buffer, u, 32);
memcpy(sm_cmac_sc_buffer+32, v, 32);
memcpy(sm_cmac_sc_buffer+64, y, 16);
(void)memcpy(sm_cmac_sc_buffer, u, 32);
(void)memcpy(sm_cmac_sc_buffer + 32, v, 32);
(void)memcpy(sm_cmac_sc_buffer + 64, y, 16);
log_info("g2 key");
log_info_hexdump(x, 16);
log_info("g2 message");
@ -1696,8 +1696,8 @@ static void sm_sc_calculate_f6_for_dhkey_check(sm_connection_t * sm_conn){
sm_key56_t bd_addr_master, bd_addr_slave;
bd_addr_master[0] = setup->sm_m_addr_type;
bd_addr_slave[0] = setup->sm_s_addr_type;
memcpy(&bd_addr_master[1], setup->sm_m_address, 6);
memcpy(&bd_addr_slave[1], setup->sm_s_address, 6);
(void)memcpy(&bd_addr_master[1], setup->sm_m_address, 6);
(void)memcpy(&bd_addr_slave[1], setup->sm_s_address, 6);
uint8_t iocap_a[3];
iocap_a[0] = sm_pairing_packet_get_auth_req(setup->sm_m_preq);
iocap_a[1] = sm_pairing_packet_get_oob_data_flag(setup->sm_m_preq);
@ -1720,8 +1720,8 @@ static void sm_sc_calculate_f6_to_verify_dhkey_check(sm_connection_t * sm_conn){
sm_key56_t bd_addr_master, bd_addr_slave;
bd_addr_master[0] = setup->sm_m_addr_type;
bd_addr_slave[0] = setup->sm_s_addr_type;
memcpy(&bd_addr_master[1], setup->sm_m_address, 6);
memcpy(&bd_addr_slave[1], setup->sm_s_address, 6);
(void)memcpy(&bd_addr_master[1], setup->sm_m_address, 6);
(void)memcpy(&bd_addr_slave[1], setup->sm_s_address, 6);
uint8_t iocap_a[3];
iocap_a[0] = sm_pairing_packet_get_auth_req(setup->sm_m_preq);
@ -1801,7 +1801,7 @@ static void sm_load_security_info(sm_connection_t * sm_connection){
#ifdef ENABLE_LE_PERIPHERAL
static void sm_start_calculating_ltk_from_ediv_and_rand(sm_connection_t * sm_connection){
memcpy(setup->sm_local_rand, sm_connection->sm_local_rand, 8);
(void)memcpy(setup->sm_local_rand, sm_connection->sm_local_rand, 8);
setup->sm_local_ediv = sm_connection->sm_local_ediv;
// re-establish used key encryption size
// no db for encryption size hack: encryption size is stored in lowest nibble of setup->sm_local_rand
@ -1945,7 +1945,7 @@ static void sm_run(void){
log_info("LE Device Lookup: calculate AH");
log_info_key("IRK", irk);
memcpy(sm_aes128_key, irk, 16);
(void)memcpy(sm_aes128_key, irk, 16);
sm_ah_r_prime(sm_address_resolution_address, sm_aes128_plaintext);
sm_address_resolution_ah_calculation_active = 1;
sm_aes128_state = SM_AES128_ACTIVE;
@ -2051,7 +2051,9 @@ static void sm_run(void){
sm_reset_setup();
sm_init_setup(sm_connection);
// recover pairing request
memcpy(&setup->sm_m_preq, &sm_connection->sm_m_preq, sizeof(sm_pairing_packet_t));
(void)memcpy(&setup->sm_m_preq,
&sm_connection->sm_m_preq,
sizeof(sm_pairing_packet_t));
err = sm_stk_generation_init(sm_connection);
#ifdef ENABLE_TESTING_SUPPORT
@ -2087,7 +2089,8 @@ static void sm_run(void){
sm_reset_setup();
sm_load_security_info(sm_connection);
if ((setup->sm_peer_ediv == 0) && sm_is_null_random(setup->sm_peer_rand) && !sm_is_null_key(setup->sm_peer_ltk)){
memcpy(setup->sm_ltk, setup->sm_peer_ltk, 16);
(void)memcpy(setup->sm_ltk,
setup->sm_peer_ltk, 16);
sm_connection->sm_engine_state = SM_RESPONDER_PH4_SEND_LTK_REPLY;
break;
}
@ -2323,8 +2326,8 @@ static void sm_run(void){
case PK_RESP_INPUT:
case PK_BOTH_INPUT:
// use random TK for display
memcpy(setup->sm_ra, setup->sm_tk, 16);
memcpy(setup->sm_rb, setup->sm_tk, 16);
(void)memcpy(setup->sm_ra, setup->sm_tk, 16);
(void)memcpy(setup->sm_rb, setup->sm_tk, 16);
setup->sm_passkey_bit = 0;
if (IS_RESPONDER(connection->sm_role)){
@ -2516,7 +2519,7 @@ static void sm_run(void){
// r' = padding || r
// r - 64 bit value
memset(&sm_aes128_plaintext[0], 0, 8);
memcpy(&sm_aes128_plaintext[8], setup->sm_local_rand, 8);
(void)memcpy(&sm_aes128_plaintext[8], setup->sm_local_rand, 8);
// Y = dm(DHK, Rand)
connection->sm_engine_state = SM_PH3_Y_W4_ENC;
@ -2562,7 +2565,7 @@ static void sm_run(void){
// r' = padding || r
// r - 64 bit value
memset(&sm_aes128_plaintext[0], 0, 8);
memcpy(&sm_aes128_plaintext[8], setup->sm_local_rand, 8);
(void)memcpy(&sm_aes128_plaintext[8], setup->sm_local_rand, 8);
// Y = dm(DHK, Rand)
connection->sm_engine_state = SM_RESPONDER_PH4_Y_W4_ENC;
@ -2911,7 +2914,7 @@ static void sm_handle_encryption_result_rau(void *arg){
UNUSED(arg);
sm_aes128_state = SM_AES128_IDLE;
memcpy(&sm_random_address[3], &sm_aes128_ciphertext[13], 3);
(void)memcpy(&sm_random_address[3], &sm_aes128_ciphertext[13], 3);
rau_state = RAU_SET_ADDRESS;
sm_run();
}
@ -3543,7 +3546,8 @@ static void sm_pdu_handler(uint8_t packet_type, hci_con_handle_t con_handle, uin
}
// store pairing request
memcpy(&setup->sm_s_pres, packet, sizeof(sm_pairing_packet_t));
(void)memcpy(&setup->sm_s_pres, packet,
sizeof(sm_pairing_packet_t));
err = sm_stk_generation_init(sm_conn);
#ifdef ENABLE_TESTING_SUPPORT
@ -3629,7 +3633,8 @@ static void sm_pdu_handler(uint8_t packet_type, hci_con_handle_t con_handle, uin
}
// store pairing request
memcpy(&sm_conn->sm_m_preq, packet, sizeof(sm_pairing_packet_t));
(void)memcpy(&sm_conn->sm_m_preq, packet,
sizeof(sm_pairing_packet_t));
sm_conn->sm_engine_state = SM_RESPONDER_PH1_PAIRING_REQUEST_RECEIVED;
break;
#endif
@ -3751,7 +3756,7 @@ static void sm_pdu_handler(uint8_t packet_type, hci_con_handle_t con_handle, uin
log_info("Reset rb as A does not have OOB data");
memset(setup->sm_rb, 0, 16);
} else {
memcpy(setup->sm_rb, sm_sc_oob_random, 16);
(void)memcpy(setup->sm_rb, sm_sc_oob_random, 16);
log_info("Use stored rb");
log_info_hexdump(setup->sm_rb, 16);
}
@ -3760,7 +3765,7 @@ static void sm_pdu_handler(uint8_t packet_type, hci_con_handle_t con_handle, uin
log_info("Reset ra as B does not have OOB data");
memset(setup->sm_ra, 0, 16);
} else {
memcpy(setup->sm_ra, sm_sc_oob_random, 16);
(void)memcpy(setup->sm_ra, sm_sc_oob_random, 16);
log_info("Use stored ra");
log_info_hexdump(setup->sm_ra, 16);
}
@ -3962,16 +3967,16 @@ void sm_set_request_security(int enable){
#endif
void sm_set_er(sm_key_t er){
memcpy(sm_persistent_er, er, 16);
(void)memcpy(sm_persistent_er, er, 16);
}
void sm_set_ir(sm_key_t ir){
memcpy(sm_persistent_ir, ir, 16);
(void)memcpy(sm_persistent_ir, ir, 16);
}
// Testing support only
void sm_test_set_irk(sm_key_t irk){
memcpy(sm_persistent_irk, irk, 16);
(void)memcpy(sm_persistent_irk, irk, 16);
dkg_state = DKG_CALC_DHK;
test_use_fixed_local_irk = true;
}
@ -4210,8 +4215,8 @@ void sm_passkey_input(hci_con_handle_t con_handle, uint32_t passkey){
btstack_crypto_random_generate(&sm_crypto_random_request, setup->sm_local_random, 16, &sm_handle_random_result_ph2_random, (void *)(uintptr_t) sm_conn->sm_handle);
}
#ifdef ENABLE_LE_SECURE_CONNECTIONS
memcpy(setup->sm_ra, setup->sm_tk, 16);
memcpy(setup->sm_rb, setup->sm_tk, 16);
(void)memcpy(setup->sm_ra, setup->sm_tk, 16);
(void)memcpy(setup->sm_rb, setup->sm_tk, 16);
if (sm_conn->sm_engine_state == SM_SC_W4_USER_RESPONSE){
sm_sc_start_calculating_local_confirm(sm_conn);
}
@ -4346,7 +4351,7 @@ void gap_random_address_set_update_period(int period_ms){
void gap_random_address_set(bd_addr_t addr){
gap_random_address_set_mode(GAP_RANDOM_ADDRESS_TYPE_STATIC);
memcpy(sm_random_address, addr, 6);
(void)memcpy(sm_random_address, addr, 6);
rau_state = RAU_SET_ADDRESS;
sm_run();
}

31
src/btstack_crypto.c
View File

@ -229,13 +229,13 @@ static void btstack_crypto_cmac_handle_encryption_result(btstack_crypto_aes128_c
switch (btstack_crypto_cmac_state){
case CMAC_W4_SUBKEYS: {
sm_key_t k1;
memcpy(k1, data, 16);
(void)memcpy(k1, data, 16);
btstack_crypto_cmac_shift_left_by_one_bit_inplace(16, k1);
if (data[0] & 0x80){
k1[15] ^= 0x87;
}
sm_key_t k2;
memcpy(k2, k1, 16);
(void)memcpy(k2, k1, 16);
btstack_crypto_cmac_shift_left_by_one_bit_inplace(16, k2);
if (k1[0] & 0x80){
k2[15] ^= 0x87;
@ -271,7 +271,7 @@ static void btstack_crypto_cmac_handle_encryption_result(btstack_crypto_aes128_c
break;
}
case CMAC_W4_MI:
memcpy(btstack_crypto_cmac_x, data, 16);
(void)memcpy(btstack_crypto_cmac_x, data, 16);
btstack_crypto_cmac_state = (btstack_crypto_cmac_block_current < (btstack_crypto_cmac_block_count - 1)) ? CMAC_CALC_MI : CMAC_CALC_MLAST;
break;
case CMAC_W4_MLAST:
@ -279,7 +279,7 @@ static void btstack_crypto_cmac_handle_encryption_result(btstack_crypto_aes128_c
log_info("Setting CMAC Engine to IDLE");
btstack_crypto_cmac_state = CMAC_IDLE;
log_info_key("CMAC", data);
memcpy(btstack_crypto_cmac->hash, data, 16);
(void)memcpy(btstack_crypto_cmac->hash, data, 16);
btstack_linked_list_pop(&btstack_crypto_operations);
(*btstack_crypto_cmac->btstack_crypto.context_callback.callback)(btstack_crypto_cmac->btstack_crypto.context_callback.context);
break;
@ -291,7 +291,7 @@ static void btstack_crypto_cmac_handle_encryption_result(btstack_crypto_aes128_c
static void btstack_crypto_cmac_start(btstack_crypto_aes128_cmac_t * btstack_crypto_cmac){
memcpy(btstack_crypto_cmac_k, btstack_crypto_cmac->key, 16);
(void)memcpy(btstack_crypto_cmac_k, btstack_crypto_cmac->key, 16);
memset(btstack_crypto_cmac_x, 0, 16);
btstack_crypto_cmac_block_current = 0;
@ -338,7 +338,7 @@ static void btstack_crypto_cmac_start(btstack_crypto_aes128_cmac_t * btstack_cry
static void btstack_crypto_ccm_setup_a_i(btstack_crypto_ccm_t * btstack_crypto_ccm, uint16_t counter){
btstack_crypto_ccm_s[0] = 1; // L' = L - 1
memcpy(&btstack_crypto_ccm_s[1], btstack_crypto_ccm->nonce, 13);
(void)memcpy(&btstack_crypto_ccm_s[1], btstack_crypto_ccm->nonce, 13);
big_endian_store_16(btstack_crypto_ccm_s, 14, counter);
#ifdef DEBUG_CCM
printf("ststack_crypto_ccm_setup_a_%u\n", counter);
@ -375,7 +375,7 @@ static void btstack_crypto_ccm_setup_b_0(btstack_crypto_ccm_t * btstack_crypto_c
uint8_t m_prime = (btstack_crypto_ccm->auth_len - 2) / 2;
uint8_t Adata = btstack_crypto_ccm->aad_len ? 1 : 0;
b0[0] = (Adata << 6) | (m_prime << 3) | 1 ; // Adata, M', L' = L - 1
memcpy(&b0[1], btstack_crypto_ccm->nonce, 13);
(void)memcpy(&b0[1], btstack_crypto_ccm->nonce, 13);
big_endian_store_16(b0, 14, btstack_crypto_ccm->message_len);
#ifdef DEBUG_CCM
printf("%16s: ", "B0");
@ -540,7 +540,8 @@ static void btstack_crypto_ccm_calc_xn(btstack_crypto_ccm_t * btstack_crypto_ccm
for (i = 0; i < bytes_to_decrypt ; i++){
btstack_crypto_ccm_buffer[i] = btstack_crypto_ccm->x_i[i] ^ plaintext[i];
}
memcpy(&btstack_crypto_ccm_buffer[i], &btstack_crypto_ccm->x_i[i], 16 - bytes_to_decrypt);
(void)memcpy(&btstack_crypto_ccm_buffer[i], &btstack_crypto_ccm->x_i[i],
16 - bytes_to_decrypt);
#ifdef DEBUG_CCM
printf("%16s: ", "Xn XOR bn");
printf_hexdump(btstack_crypto_ccm_buffer, 16);
@ -721,7 +722,8 @@ static void btstack_crypto_run(void){
case ECC_P256_KEY_GENERATION_DONE:
// done
btstack_crypto_log_ec_publickey(btstack_crypto_ecc_p256_public_key);
memcpy(btstack_crypto_ec_p192->public_key, btstack_crypto_ecc_p256_public_key, 64);
(void)memcpy(btstack_crypto_ec_p192->public_key,
btstack_crypto_ecc_p256_public_key, 64);
btstack_linked_list_pop(&btstack_crypto_operations);
(*btstack_crypto_ec_p192->btstack_crypto.context_callback.callback)(btstack_crypto_ec_p192->btstack_crypto.context_callback.context);
break;
@ -779,7 +781,7 @@ static void btstack_crypto_handle_random_data(const uint8_t * data, uint16_t len
case BTSTACK_CRYPTO_RANDOM:
btstack_crypto_random = (btstack_crypto_random_t*) btstack_crypto;
bytes_to_copy = btstack_min(btstack_crypto_random->size, len);
memcpy(btstack_crypto_random->buffer, data, bytes_to_copy);
(void)memcpy(btstack_crypto_random->buffer, data, bytes_to_copy);
btstack_crypto_random->buffer += bytes_to_copy;
btstack_crypto_random->size -= bytes_to_copy;
// data processed, more?
@ -791,7 +793,8 @@ static void btstack_crypto_handle_random_data(const uint8_t * data, uint16_t len
break;
#ifdef ENABLE_ECC_P256
case BTSTACK_CRYPTO_ECC_P256_GENERATE_KEY:
memcpy(&btstack_crypto_ecc_p256_random[btstack_crypto_ecc_p256_random_len], data, 8);
(void)memcpy(&btstack_crypto_ecc_p256_random[btstack_crypto_ecc_p256_random_len],
data, 8);
btstack_crypto_ecc_p256_random_len += 8;
if (btstack_crypto_ecc_p256_random_len >= 64) {
btstack_crypto_ecc_p256_key_generation_state = ECC_P256_KEY_GENERATION_ACTIVE;
@ -1172,7 +1175,7 @@ void btstack_crypto_ccm_digest(btstack_crypto_ccm_t * request, uint8_t * additio
}
void btstack_crypto_ccm_get_authentication_value(btstack_crypto_ccm_t * request, uint8_t * authentication_value){
memcpy(authentication_value, request->x_i, request->auth_len);
(void)memcpy(authentication_value, request->x_i, request->auth_len);
}
void btstack_crypto_ccm_encrypt_block(btstack_crypto_ccm_t * request, uint16_t block_len, const uint8_t * plaintext, uint8_t * ciphertext, void (* callback)(void * arg), void * callback_arg){
@ -1209,8 +1212,8 @@ void btstack_crypto_ccm_decrypt_block(btstack_crypto_ccm_t * request, uint16_t b
// PTS only
void btstack_crypto_ecc_p256_set_key(const uint8_t * public_key, const uint8_t * private_key){
#ifdef USE_SOFTWARE_ECC_P256_IMPLEMENTATION
memcpy(btstack_crypto_ecc_p256_d, private_key, 32);
memcpy(btstack_crypto_ecc_p256_public_key, public_key, 64);
(void)memcpy(btstack_crypto_ecc_p256_d, private_key, 32);
(void)memcpy(btstack_crypto_ecc_p256_public_key, public_key, 64);
btstack_crypto_ecc_p256_key_generation_state = ECC_P256_KEY_GENERATION_DONE;
#else
UNUSED(public_key);

10
src/btstack_ring_buffer.c
View File

@ -90,7 +90,8 @@ int btstack_ring_buffer_write(btstack_ring_buffer_t * ring_buffer, uint8_t * dat
// copy first chunk
unsigned int bytes_until_end = ring_buffer->size - ring_buffer->last_written_index;
unsigned int bytes_to_copy = btstack_min(bytes_until_end, data_length);
memcpy(&ring_buffer->storage[ring_buffer->last_written_index], data, bytes_to_copy);
(void)memcpy(&ring_buffer->storage[ring_buffer->last_written_index],
data, bytes_to_copy);
data_length -= bytes_to_copy;
data += bytes_to_copy;
@ -102,7 +103,7 @@ int btstack_ring_buffer_write(btstack_ring_buffer_t * ring_buffer, uint8_t * dat
// copy second chunk
if (data_length) {
memcpy(&ring_buffer->storage[0], data, data_length);
(void)memcpy(&ring_buffer->storage[0], data, data_length);
ring_buffer->last_written_index += data_length;
}
@ -125,7 +126,8 @@ void btstack_ring_buffer_read(btstack_ring_buffer_t * ring_buffer, uint8_t * dat
// copy first chunk
unsigned int bytes_until_end = ring_buffer->size - ring_buffer->last_read_index;
unsigned int bytes_to_copy = btstack_min(bytes_until_end, data_length);
memcpy(data, &ring_buffer->storage[ring_buffer->last_read_index], bytes_to_copy);
(void)memcpy(data, &ring_buffer->storage[ring_buffer->last_read_index],
bytes_to_copy);
data_length -= bytes_to_copy;
data += bytes_to_copy;
@ -137,7 +139,7 @@ void btstack_ring_buffer_read(btstack_ring_buffer_t * ring_buffer, uint8_t * dat
// copy second chunk
if (data_length) {
memcpy(data, &ring_buffer->storage[0], data_length);
(void)memcpy(data, &ring_buffer->storage[0], data_length);
ring_buffer->last_read_index += data_length;
}

4
src/btstack_util.c
View File

@ -68,7 +68,7 @@ int bd_addr_cmp(const bd_addr_t a, const bd_addr_t b){
* @param src
*/
void bd_addr_copy(bd_addr_t dest, const bd_addr_t src){
memcpy(dest,src,BD_ADDR_LEN);
(void)memcpy(dest, src, BD_ADDR_LEN);
}
uint16_t little_endian_read_16(const uint8_t * buffer, int pos){
@ -294,7 +294,7 @@ const uint8_t bluetooth_base_uuid[] = { 0x00, 0x00, 0x00, 0x00, /* - */ 0x00, 0x
0x80, 0x00, /* - */ 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
void uuid_add_bluetooth_prefix(uint8_t *uuid, uint32_t shortUUID){
memcpy(uuid, bluetooth_base_uuid, 16);
(void)memcpy(uuid, bluetooth_base_uuid, 16);
big_endian_store_32(uuid, 0, shortUUID);
}

6
src/classic/a2dp_source.c
View File

@ -519,7 +519,7 @@ uint8_t a2dp_source_establish_stream(bd_addr_t remote_addr, uint8_t loc_seid, ui
log_error(" no local_stream_endpoint for seid %d", loc_seid);
return AVDTP_SEID_DOES_NOT_EXIST;
}
memcpy(sc.remote_addr, remote_addr, 6);
(void)memcpy(sc.remote_addr, remote_addr, 6);
return avdtp_source_connect(remote_addr, a2dp_cid);
}
@ -532,7 +532,9 @@ uint8_t a2dp_source_reconfigure_stream_sampling_frequency(uint16_t a2dp_cid, uin
log_info("a2dp_source_reconfigure_stream");
memcpy(sc.local_stream_endpoint->reconfigure_media_codec_sbc_info, sc.local_stream_endpoint->remote_sep.configuration.media_codec.media_codec_information, 4);
(void)memcpy(sc.local_stream_endpoint->reconfigure_media_codec_sbc_info,
sc.local_stream_endpoint->remote_sep.configuration.media_codec.media_codec_information,
4);
// update sampling frequency
uint8_t config = sc.local_stream_endpoint->reconfigure_media_codec_sbc_info[0] & 0x0f;

9
src/classic/avdtp.c
View File

@ -255,7 +255,9 @@ void avdtp_register_content_protection_category(avdtp_stream_endpoint_t * stream
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_CONTENT_PROTECTION, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
stream_endpoint->sep.capabilities.content_protection.cp_type = cp_type;
memcpy(stream_endpoint->sep.capabilities.content_protection.cp_type_value, cp_type_value, btstack_min(cp_type_value_len, AVDTP_MAX_CONTENT_PROTECTION_TYPE_VALUE_LEN));
(void)memcpy(stream_endpoint->sep.capabilities.content_protection.cp_type_value,
cp_type_value,
btstack_min(cp_type_value_len, AVDTP_MAX_CONTENT_PROTECTION_TYPE_VALUE_LEN));
stream_endpoint->sep.capabilities.content_protection.cp_type_value_len = btstack_min(cp_type_value_len, AVDTP_MAX_CONTENT_PROTECTION_TYPE_VALUE_LEN);
}
@ -344,7 +346,7 @@ avdtp_connection_t * avdtp_create_connection(bd_addr_t remote_addr, avdtp_contex
connection->initiator_transaction_label = avdtp_get_next_initiator_transaction_label(context);
connection->avdtp_cid = avdtp_get_next_avdtp_cid(context);
context->avdtp_cid = connection->avdtp_cid;
memcpy(connection->remote_addr, remote_addr, 6);
(void)memcpy(connection->remote_addr, remote_addr, 6);
btstack_linked_list_add(&context->connections, (btstack_linked_item_t *) connection);
return connection;
}
@ -1052,7 +1054,8 @@ uint8_t avdtp_set_configuration(uint16_t avdtp_cid, uint8_t local_seid, uint8_t
stream_endpoint->media_codec_type = configuration.media_codec.media_codec_type;
if (configuration.media_codec.media_codec_type == AVDTP_CODEC_SBC){
stream_endpoint->media_type = configuration.media_codec.media_type;
memcpy(stream_endpoint->media_codec_sbc_info, configuration.media_codec.media_codec_information, 4);
(void)memcpy(stream_endpoint->media_codec_sbc_info,
configuration.media_codec.media_codec_information, 4);
}
return avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}

3
src/classic/avdtp_acceptor.c
View File

@ -55,7 +55,8 @@ static int avdtp_acceptor_send_accept_response(uint16_t cid, uint8_t transactio
}
static int avdtp_acceptor_process_chunk(avdtp_signaling_packet_t * signaling_packet, uint8_t * packet, uint16_t size){
memcpy(signaling_packet->command + signaling_packet->size, packet, size);
(void)memcpy(signaling_packet->command + signaling_packet->size, packet,
size);
signaling_packet->size += size;
return (signaling_packet->packet_type == AVDTP_SINGLE_PACKET) || (signaling_packet->packet_type == AVDTP_END_PACKET);
}

4
src/classic/avdtp_initiator.c
View File

@ -156,7 +156,9 @@ void avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_
// copy sbc media codec info
stream_endpoint->remote_sep.configured_service_categories |= stream_endpoint->remote_configuration_bitmap;
stream_endpoint->remote_sep.configuration = stream_endpoint->remote_configuration;
memcpy(stream_endpoint->media_codec_sbc_info, stream_endpoint->remote_configuration.media_codec.media_codec_information, 4);
(void)memcpy(stream_endpoint->media_codec_sbc_info,
stream_endpoint->remote_configuration.media_codec.media_codec_information,
4);
stream_endpoint->remote_sep.configuration.media_codec.media_codec_information = stream_endpoint->media_codec_sbc_info;
stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED;
break;

2
src/classic/avdtp_source.c
View File

@ -218,7 +218,7 @@ static void avdtp_source_copy_media_payload(uint8_t * media_packet, int size, in
int pos = *offset;
media_packet[pos++] = num_frames; // (fragmentation << 7) | (starting_packet << 6) | (last_packet << 5) | num_frames;
memcpy(media_packet + pos, storage, num_bytes_to_copy);
(void)memcpy(media_packet + pos, storage, num_bytes_to_copy);
pos += num_bytes_to_copy;
*offset = pos;
}

15
src/classic/avdtp_util.c
View File

@ -269,7 +269,8 @@ int avdtp_pack_service_capabilities(uint8_t * buffer, int size, avdtp_capabiliti
buffer[pos++] = caps.content_protection.cp_type_value_len + 2;
big_endian_store_16(buffer, pos, caps.content_protection.cp_type);
pos += 2;
memcpy(buffer+pos, caps.content_protection.cp_type_value, caps.content_protection.cp_type_value_len);
(void)memcpy(buffer + pos, caps.content_protection.cp_type_value,
caps.content_protection.cp_type_value_len);
break;
case AVDTP_HEADER_COMPRESSION:
buffer[pos++] = (caps.header_compression.back_ch << 7) | (caps.header_compression.media << 6) | (caps.header_compression.recovery << 5);
@ -530,7 +531,8 @@ int avdtp_signaling_create_fragment(uint16_t cid, avdtp_signaling_packet_t * sig
}
}
out_buffer[0] = avdtp_header(signaling_packet->transaction_label, signaling_packet->packet_type, signaling_packet->message_type);
memcpy(out_buffer+pos, signaling_packet->command + offset, data_len);
(void)memcpy(out_buffer + pos, signaling_packet->command + offset,
data_len);
pos += data_len;
return pos;
}
@ -777,7 +779,8 @@ static void avdtp_signaling_emit_content_protection_capability(btstack_packet_ha
//TODO: reserve place for value
if (content_protection->cp_type_value_len < 10){
memcpy(event+pos, content_protection->cp_type_value, content_protection->cp_type_value_len);
(void)memcpy(event + pos, content_protection->cp_type_value,
content_protection->cp_type_value_len);
}
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
@ -841,7 +844,8 @@ static void avdtp_signaling_emit_media_codec_other_capability(btstack_packet_han
pos += 2;
little_endian_store_16(event, pos, media_codec.media_codec_information_len);
pos += 2;
memcpy(event+pos, media_codec.media_codec_information, btstack_min(media_codec.media_codec_information_len, MAX_MEDIA_CODEC_INFORMATION_LENGTH));
(void)memcpy(event + pos, media_codec.media_codec_information,
btstack_min(media_codec.media_codec_information_len, MAX_MEDIA_CODEC_INFORMATION_LENGTH));
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
@ -955,7 +959,8 @@ static inline void avdtp_signaling_emit_media_codec_other(btstack_packet_handler
pos += 2;
int media_codec_len = btstack_min(MAX_MEDIA_CODEC_INFORMATION_LENGTH, media_codec.media_codec_information_len);
memcpy(event+pos, media_codec.media_codec_information, media_codec_len);
(void)memcpy(event + pos, media_codec.media_codec_information,
media_codec_len);
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}

2
src/classic/avrcp.c
View File

@ -398,7 +398,7 @@ static avrcp_connection_t * avrcp_create_connection(avrcp_role_t role, bd_addr_t
connection->max_num_fragments = 0xFF;
connection->avrcp_cid = avrcp_get_next_cid(role);
log_info("avrcp_create_connection, role %d, avrcp cid 0x%02x", role, connection->avrcp_cid);
memcpy(connection->remote_addr, remote_addr, 6);
(void)memcpy(connection->remote_addr, remote_addr, 6);
btstack_linked_list_add(&connections, (btstack_linked_item_t *) connection);
return connection;
}

20
src/classic/avrcp_browsing_controller.c
View File

@ -129,7 +129,8 @@ static uint8_t avrcp_browsing_connect(bd_addr_t remote_addr, uint8_t * ertm_buff
connection->ertm_buffer_size = size;
avrcp_connection->browsing_connection = connection;
avrcp_connection->browsing_connection->state = AVCTP_CONNECTION_W4_L2CAP_CONNECTED;
memcpy(&connection->ertm_config, ertm_config, sizeof(l2cap_ertm_config_t));
(void)memcpy(&connection->ertm_config, ertm_config,
sizeof(l2cap_ertm_config_t));
return l2cap_create_ertm_channel(avrcp_browsing_controller_packet_handler, remote_addr, avrcp_connection->browsing_l2cap_psm,
&connection->ertm_config, connection->ertm_buffer, connection->ertm_buffer_size, NULL);
@ -300,7 +301,7 @@ static int avrcp_browsing_controller_send_get_item_attributes_cmd(uint16_t cid,
pos += 2;
command[pos++] = connection->scope;
memcpy(command+pos, connection->folder_uid, 8);
(void)memcpy(command + pos, connection->folder_uid, 8);
pos += 8;
big_endian_store_16(command, pos, connection->uid_counter);
pos += 2;
@ -335,7 +336,7 @@ static int avrcp_browsing_controller_send_change_path_cmd(uint16_t cid, avrcp_br
pos += 2;
pos += 2;
command[pos++] = connection->direction;
memcpy(command+pos, connection->folder_uid, 8);
(void)memcpy(command + pos, connection->folder_uid, 8);
pos += 8;
return l2cap_send(cid, command, pos);
}
@ -359,7 +360,8 @@ static int avrcp_browsing_controller_send_search_cmd(uint16_t cid, avrcp_browsin
big_endian_store_16(command, pos, connection->search_str_len);
pos += 2;
memcpy(command+pos,connection->search_str, connection->search_str_len);
(void)memcpy(command + pos, connection->search_str,
connection->search_str_len);
pos += connection->search_str_len;
return l2cap_send(cid, command, pos);
}
@ -739,7 +741,8 @@ uint8_t avrcp_browsing_controller_configure_incoming_connection(uint16_t avrcp_b
avrcp_connection->browsing_connection->state = AVCTP_CONNECTION_W4_L2CAP_CONNECTED;
avrcp_connection->browsing_connection->ertm_buffer = ertm_buffer;
avrcp_connection->browsing_connection->ertm_buffer_size = size;
memcpy(&avrcp_connection->browsing_connection->ertm_config, ertm_config, sizeof(l2cap_ertm_config_t));
(void)memcpy(&avrcp_connection->browsing_connection->ertm_config,
ertm_config, sizeof(l2cap_ertm_config_t));
l2cap_accept_ertm_connection(avrcp_connection->browsing_connection->l2cap_browsing_cid, &avrcp_connection->browsing_connection->ertm_config, avrcp_connection->browsing_connection->ertm_buffer, avrcp_connection->browsing_connection->ertm_buffer_size);
return ERROR_CODE_SUCCESS;
}
@ -774,7 +777,7 @@ uint8_t avrcp_browsing_controller_get_item_attributes_for_scope(uint16_t avrcp_b
connection->get_item_attributes = 1;
connection->scope = scope;
memcpy(connection->folder_uid, uid, 8);
(void)memcpy(connection->folder_uid, uid, 8);
connection->uid_counter = uid_counter;
connection->attr_bitmap = attr_bitmap;
@ -877,7 +880,7 @@ uint8_t avrcp_browsing_controller_change_path(uint16_t avrcp_browsing_cid, uint8
connection->direction = direction;
memset(connection->folder_uid, 0, 8);
if (folder_uid){
memcpy(connection->folder_uid, folder_uid, 8);
(void)memcpy(connection->folder_uid, folder_uid, 8);
}
avrcp_request_can_send_now(avrcp_connection, connection->l2cap_browsing_cid);
@ -918,7 +921,8 @@ uint8_t avrcp_browsing_controller_search(uint16_t avrcp_browsing_cid, uint16_t s
connection->search_str_len = btstack_min(search_str_len, sizeof(connection->search_str)-1);
memset(connection->search_str, 0, sizeof(connection->search_str));
memcpy(connection->search_str, search_str, connection->search_str_len);
(void)memcpy(connection->search_str, search_str,
connection->search_str_len);
avrcp_request_can_send_now(avrcp_connection, connection->l2cap_browsing_cid);
return ERROR_CODE_SUCCESS;
}

11
src/classic/avrcp_browsing_target.c
View File

@ -70,7 +70,8 @@ static int avrcp_browsing_target_handle_can_send_now(avrcp_browsing_connection_t
// Profile IDentifier (PID)
packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8;
packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF;
memcpy(packet+pos, connection->cmd_operands, connection->cmd_operands_length);
(void)memcpy(packet + pos, connection->cmd_operands,
connection->cmd_operands_length);
pos += connection->cmd_operands_length;
connection->wait_to_send = 0;
@ -200,7 +201,8 @@ static uint8_t avrcp_browsing_connect(bd_addr_t remote_addr, avrcp_context_t * c
connection->ertm_buffer_size = size;
avrcp_connection->browsing_connection = connection;
memcpy(&connection->ertm_config, ertm_config, sizeof(l2cap_ertm_config_t));
(void)memcpy(&connection->ertm_config, ertm_config,
sizeof(l2cap_ertm_config_t));
return l2cap_create_ertm_channel(avrcp_browsing_target_packet_handler, remote_addr, avrcp_connection->browsing_l2cap_psm,
&connection->ertm_config, connection->ertm_buffer, connection->ertm_buffer_size, NULL);
@ -437,7 +439,8 @@ uint8_t avrcp_browsing_target_configure_incoming_connection(uint16_t avrcp_brows
avrcp_connection->browsing_connection->state = AVCTP_CONNECTION_W4_L2CAP_CONNECTED;
avrcp_connection->browsing_connection->ertm_buffer = ertm_buffer;
avrcp_connection->browsing_connection->ertm_buffer_size = size;
memcpy(&avrcp_connection->browsing_connection->ertm_config, ertm_config, sizeof(l2cap_ertm_config_t));
(void)memcpy(&avrcp_connection->browsing_connection->ertm_config,
ertm_config, sizeof(l2cap_ertm_config_t));
l2cap_accept_ertm_connection(avrcp_connection->browsing_connection->l2cap_browsing_cid, &avrcp_connection->browsing_connection->ertm_config, avrcp_connection->browsing_connection->ertm_buffer, avrcp_connection->browsing_connection->ertm_buffer_size);
return ERROR_CODE_SUCCESS;
}
@ -493,7 +496,7 @@ uint8_t avrcp_subevent_browsing_get_folder_items_response(uint16_t avrcp_browsin
log_info(" todo: list too big, invoke fragmentation");
return 1;
}
memcpy(&connection->cmd_operands[pos], attr_list, attr_list_size);
(void)memcpy(&connection->cmd_operands[pos], attr_list, attr_list_size);
pos += attr_list_size;
connection->cmd_operands_length = pos;
// printf_hexdump(connection->cmd_operands, connection->cmd_operands_length);

25
src/classic/avrcp_controller.c
View File

@ -205,11 +205,14 @@ static int avrcp_send_cmd(avrcp_connection_t * connection, avrcp_packet_type_t p
if (packet_type == AVRCP_SINGLE_PACKET){
// operands
memcpy(command+pos, connection->cmd_operands, connection->cmd_operands_length);
(void)memcpy(command + pos, connection->cmd_operands,
connection->cmd_operands_length);
pos += connection->cmd_operands_length;
} else {
uint16_t bytes_to_copy = btstack_min(connection->cmd_operands_fragmented_len-connection->cmd_operands_fragmented_pos, max_bytes);
memcpy(command+pos, &connection->cmd_operands_fragmented_buffer[connection->cmd_operands_fragmented_pos], bytes_to_copy);
(void)memcpy(command + pos,
&connection->cmd_operands_fragmented_buffer[connection->cmd_operands_fragmented_pos],
bytes_to_copy);
pos += bytes_to_copy;
connection->cmd_operands_fragmented_pos += bytes_to_copy;
}
@ -288,22 +291,22 @@ static void avrcp_controller_emit_now_playing_info_event(btstack_packet_handler_
case AVRCP_MEDIA_ATTR_TITLE:
event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_TITLE_INFO;
event[pos++] = value_len;
memcpy(event+pos, value, value_len);
(void)memcpy(event + pos, value, value_len);
break;
case AVRCP_MEDIA_ATTR_ARTIST:
event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_ARTIST_INFO;
event[pos++] = value_len;
memcpy(event+pos, value, value_len);
(void)memcpy(event + pos, value, value_len);
break;
case AVRCP_MEDIA_ATTR_ALBUM:
event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_ALBUM_INFO;
event[pos++] = value_len;
memcpy(event+pos, value, value_len);
(void)memcpy(event + pos, value, value_len);
break;
case AVRCP_MEDIA_ATTR_GENRE:
event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_GENRE_INFO;
event[pos++] = value_len;
memcpy(event+pos, value, value_len);
(void)memcpy(event + pos, value, value_len);
break;
case AVRCP_MEDIA_ATTR_SONG_LENGTH_MS:
event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_SONG_LENGTH_MS_INFO;
@ -491,7 +494,7 @@ static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connec
if (connection->state != AVCTP_W2_RECEIVE_RESPONSE) return;
connection->state = AVCTP_CONNECTION_OPENED;
// operands:
memcpy(operands, packet+pos, 5);
(void)memcpy(operands, packet + pos, 5);
uint8_t unit_type = operands[1] >> 3;
uint8_t max_subunit_ID = operands[1] & 0x07;
log_info(" SUBUNIT INFO response: ctype 0x%02x (0C), subunit_type 0x%02x (1F), subunit_id 0x%02x (07), opcode 0x%02x (30), unit_type 0x%02x, max_subunit_ID %d", ctype, subunit_type, subunit_id, opcode, unit_type, max_subunit_ID);
@ -501,7 +504,7 @@ static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connec
if (connection->state != AVCTP_W2_RECEIVE_RESPONSE) return;
connection->state = AVCTP_CONNECTION_OPENED;
// operands:
memcpy(operands, packet+pos, 5);
(void)memcpy(operands, packet + pos, 5);
uint8_t unit_type = operands[1] >> 3;
uint8_t unit = operands[1] & 0x07;
uint32_t company_id = (operands[2] << 16) | (operands[3] << 8) | operands[4];
@ -515,7 +518,7 @@ static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connec
return;
};
// operands:
memcpy(operands, packet+pos, 7);
(void)memcpy(operands, packet + pos, 7);
pos += 7;
// uint32_t company_id = operands[0] << 16 | operands[1] << 8 | operands[2];
pdu_id = operands[3];
@ -1372,7 +1375,7 @@ uint8_t avrcp_controller_play_item_for_scope(uint16_t avrcp_cid, uint8_t * uid,
connection->cmd_operands[pos++] = scope;
memset(&connection->cmd_operands[pos], 0, 8);
if (uid){
memcpy(&connection->cmd_operands[pos], uid, 8);
(void)memcpy(&connection->cmd_operands[pos], uid, 8);
}
pos += 8;
big_endian_store_16(connection->cmd_operands, pos, uid_counter);
@ -1412,7 +1415,7 @@ uint8_t avrcp_controller_add_item_from_scope_to_now_playing_list(uint16_t avrcp_
connection->cmd_operands[pos++] = scope;
memset(&connection->cmd_operands[pos], 0, 8);
if (uid){
memcpy(&connection->cmd_operands[pos], uid, 8);
(void)memcpy(&connection->cmd_operands[pos], uid, 8);
}
pos += 8;
big_endian_store_16(connection->cmd_operands, pos, uid_counter);

21
src/classic/avrcp_target.c
View File

@ -124,7 +124,7 @@ static uint16_t avrcp_target_pack_single_element_attribute_string(uint8_t * pack
big_endian_store_16(packet, pos, attr_value_size);
pos += 2;
}
memcpy(packet+pos, attr_value, attr_value_to_copy);
(void)memcpy(packet + pos, attr_value, attr_value_to_copy);
pos += attr_value_size;
return (header * 8) + attr_value_size;
}
@ -326,7 +326,8 @@ static int avrcp_target_send_response(uint16_t cid, avrcp_connection_t * connect
// pos += 3;
// }
// operands
memcpy(packet+pos, connection->cmd_operands, connection->cmd_operands_length);
(void)memcpy(packet + pos, connection->cmd_operands,
connection->cmd_operands_length);
pos += connection->cmd_operands_length;
// printf(" pos to send %d\n", pos);
// printf_hexdump(packet, pos);
@ -412,7 +413,7 @@ static uint8_t avrcp_target_response_vendor_dependent_interim(avrcp_connection_t
pos += 2;
connection->cmd_operands[pos++] = event_id;
if (value && (value_len > 0)){
memcpy(connection->cmd_operands + pos, value, value_len);
(void)memcpy(connection->cmd_operands + pos, value, value_len);
pos += value_len;
}
connection->cmd_operands_length = pos;
@ -561,7 +562,8 @@ static uint8_t avrcp_target_subunit_info(avrcp_connection_t * connection, uint8_
connection->cmd_operands_length = 5;
connection->cmd_operands[0] = (page << 4) | extension_code;
memcpy(connection->cmd_operands+1, connection->subunit_info_data + offset, 4);
(void)memcpy(connection->cmd_operands + 1,
connection->subunit_info_data + offset, 4);
connection->state = AVCTP_W2_SEND_RESPONSE;
avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
@ -597,7 +599,8 @@ static uint8_t avrcp_target_capability(uint16_t avrcp_cid, avrcp_capability_id_t
connection->cmd_operands[connection->cmd_operands_length++] = capability_id;
connection->cmd_operands[connection->cmd_operands_length++] = capabilities_num;
memcpy(connection->cmd_operands+connection->cmd_operands_length, capabilities, size);
(void)memcpy(connection->cmd_operands + connection->cmd_operands_length,
capabilities, size);
connection->cmd_operands_length += size;
connection->state = AVCTP_W2_SEND_RESPONSE;
@ -676,7 +679,7 @@ void avrcp_target_set_now_playing_info(uint16_t avrcp_cid, const avrcp_track_t *
connection->playback_status = AVRCP_PLAYBACK_STATUS_ERROR;
return;
}
memcpy(connection->track_id, current_track->track_id, 8);
(void)memcpy(connection->track_id, current_track->track_id, 8);
connection->song_length_ms = current_track->song_length_ms;
connection->track_nr = current_track->track_nr;
connection->total_tracks = total_tracks;
@ -703,7 +706,7 @@ uint8_t avrcp_target_track_changed(uint16_t avrcp_cid, uint8_t * track_id){
if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED)) {
connection->track_changed = 1;
memcpy(connection->track_id, track_id, 8);
(void)memcpy(connection->track_id, track_id, 8);
avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
}
return ERROR_CODE_SUCCESS;
@ -907,7 +910,7 @@ static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connec
// 1 - reserved
// 2-3 param length,
length = big_endian_read_16(pdu, 2);
memcpy(connection->cmd_operands, company_id, 3);
(void)memcpy(connection->cmd_operands, company_id, 3);
connection->cmd_operands_length = 3;
switch (pdu_id){
case AVRCP_PDU_ID_SET_ADDRESSED_PLAYER:{
@ -1140,7 +1143,7 @@ static int avrcp_target_send_notification(uint16_t cid, avrcp_connection_t * con
big_endian_store_16(packet, pos, caped_value_len);
pos += 2;
packet[pos++] = notification_id;
memcpy(packet+pos, value, caped_value_len-1);
(void)memcpy(packet + pos, value, caped_value_len - 1);
pos += caped_value_len - 1;
connection->wait_to_send = 0;
return l2cap_send_prepared(cid, pos);

2
src/classic/bnep.c
View File

@ -593,7 +593,7 @@ int bnep_send(uint16_t bnep_cid, uint8_t *packet, uint16_t len)
/* TODO: Add extension headers, if we may support them at a later stage */
/* Add the payload and then send out the package */
memcpy(bnep_out_buffer + pos_out, packet + pos, payload_len);
(void)memcpy(bnep_out_buffer + pos_out, packet + pos, payload_len);
pos_out += payload_len;
err = l2cap_send_prepared(channel->l2cap_cid, pos_out);

2
src/classic/btstack_cvsd_plc.c
View File

@ -465,7 +465,7 @@ void btstack_cvsd_plc_process_data(btstack_cvsd_plc_state_t * plc_state, BTSTACK
int is_bad_frame = bad_frame(plc_state, in, num_samples);
if (is_bad_frame){
memcpy(out, in, num_samples * 2);
(void)memcpy(out, in, num_samples * 2);
if (plc_state->good_samples > CVSD_LHIST){
btstack_cvsd_plc_bad_frame(plc_state, num_samples, out);
if (is_zero_frame){

10
src/classic/btstack_link_key_db_memory.c
View File

@ -78,7 +78,7 @@ static int get_link_key(bd_addr_t bd_addr, link_key_t link_key, link_key_type_t
if (!item) return 0;
memcpy(link_key, item->link_key, LINK_KEY_LEN);
(void)memcpy(link_key, item->link_key, LINK_KEY_LEN);
if (link_key_type) {
*link_key_type = item->link_key_type;
}
@ -121,8 +121,8 @@ static void put_link_key(bd_addr_t bd_addr, link_key_t link_key, link_key_type_t
if (!record) return;
memcpy(record->bd_addr, bd_addr, sizeof(bd_addr_t));
memcpy(record->link_key, link_key, LINK_KEY_LEN);
(void)memcpy(record->bd_addr, bd_addr, sizeof(bd_addr_t));
(void)memcpy(record->link_key, link_key, LINK_KEY_LEN);
record->link_key_type = link_key_type;
btstack_linked_list_add(&db_mem_link_keys, (btstack_linked_item_t *) record);
}
@ -137,8 +137,8 @@ static int iterator_get_next(btstack_link_key_iterator_t * it, bd_addr_t bd_add
if (item == NULL) return 0;
// fetch values
memcpy(bd_addr, item->bd_addr, 6);
memcpy(link_key, item->link_key, 16);
(void)memcpy(bd_addr, item->bd_addr, 6);
(void)memcpy(link_key, item->link_key, 16);
*link_key_type = item->link_key_type;
// next

10
src/classic/btstack_link_key_db_tlv.c
View File

@ -95,7 +95,7 @@ static int btstack_link_key_db_tlv_get_link_key(bd_addr_t bd_addr, link_key_t li
log_info("tag %x, addr %s", tag, bd_addr_to_str(entry.bd_addr));
if (memcmp(bd_addr, entry.bd_addr, 6)) continue;
// found, pass back
memcpy(link_key, entry.link_key, 16);
(void)memcpy(link_key, entry.link_key, 16);
*link_key_type = entry.link_key_type;
return 1;
}
@ -166,8 +166,8 @@ static void btstack_link_key_db_tlv_put_link_key(bd_addr_t bd_addr, link_key_t l
link_key_nvm_t entry;
memcpy(entry.bd_addr, bd_addr, 6);
memcpy(entry.link_key, link_key, 16);
(void)memcpy(entry.bd_addr, bd_addr, 6);
(void)memcpy(entry.link_key, link_key, 16);
entry.link_key_type = link_key_type;
entry.seq_nr = highest_seq_nr + 1;
@ -190,8 +190,8 @@ static int btstack_link_key_db_tlv_iterator_get_next(btstack_link_key_iterator_
uint32_t tag = btstack_link_key_db_tag_for_index(i++);
int size = self->btstack_tlv_impl->get_tag(self->btstack_tlv_context, tag, (uint8_t*) &entry, sizeof(entry));
if (size == 0) continue;
memcpy(bd_addr, entry.bd_addr, 6);
memcpy(link_key, entry.link_key, 16);
(void)memcpy(bd_addr, entry.bd_addr, 6);
(void)memcpy(link_key, entry.link_key, 16);
*link_key_type = entry.link_key_type;
found = 1;
break;

7
src/classic/btstack_sbc_decoder_bluedroid.c
View File

@ -203,7 +203,8 @@ static void append_received_sbc_data(bludroid_decoder_state_t * state, uint8_t *
log_error("SBC data: more bytes read %u than free bytes in buffer %u", size, numFreeBytes);
}
memcpy(state->frame_buffer + state->bytes_in_frame_buffer, buffer, size);
(void)memcpy(state->frame_buffer + state->bytes_in_frame_buffer, buffer,
size);
state->bytes_in_frame_buffer += size;
}
@ -353,7 +354,9 @@ static void btstack_sbc_decoder_process_msbc_data(btstack_sbc_decoder_state_t *
if (plc_enabled) {
btstack_sbc_plc_bad_frame(&state->plc_state, decoder_state->pcm_plc_data, decoder_state->pcm_data);
} else {
memcpy(decoder_state->pcm_data, decoder_state->pcm_plc_data, decoder_state->pcm_bytes);
(void)memcpy(decoder_state->pcm_data,
decoder_state->pcm_plc_data,
decoder_state->pcm_bytes);
}
state->handle_pcm_data(decoder_state->pcm_data,

4
src/classic/goep_client.c
View File

@ -126,7 +126,7 @@ static inline void goep_client_emit_connected_event(goep_client_t * context, uin
little_endian_store_16(event,pos,context->cid);
pos+=2;
event[pos++] = status;
memcpy(&event[pos], context->bd_addr, 6);
(void)memcpy(&event[pos], context->bd_addr, 6);
pos += 6;
little_endian_store_16(event,pos,context->con_handle);
pos += 2;
@ -386,7 +386,7 @@ uint8_t goep_client_create_connection(btstack_packet_handler_t handler, bd_addr_
context->l2cap_psm = 0;
context->rfcomm_port = 0;
context->pbap_supported_features = PBAP_FEATURES_NOT_PRESENT;
memcpy(context->bd_addr, addr, 6);
(void)memcpy(context->bd_addr, addr, 6);
sdp_client_query_uuid16(&goep_client_handle_sdp_query_event, context->bd_addr, uuid);
*out_cid = context->cid;
return 0;

6
src/classic/hfp.c
View File

@ -204,7 +204,7 @@ void hfp_hf_drop_mSBC_if_eSCO_not_supported(uint8_t * codecs, uint8_t * codecs_n
tmp_codecs[tmp_codec_nr++] = codecs[i];
}
*codecs_nr = tmp_codec_nr;
memcpy(codecs, tmp_codecs, tmp_codec_nr);
(void)memcpy(codecs, tmp_codecs, tmp_codec_nr);
}
// UTILS
@ -427,7 +427,7 @@ static hfp_connection_t * provide_hfp_connection_context_for_bd_addr(bd_addr_t b
hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role);
if (hfp_connection) return hfp_connection;
hfp_connection = create_hfp_connection_context();
memcpy(hfp_connection->remote_addr, bd_addr, 6);
(void)memcpy(hfp_connection->remote_addr, bd_addr, 6);
hfp_connection->local_role = local_role;
log_info("Create HFP context %p: role %u, addr %s", hfp_connection, local_role, bd_addr_to_str(bd_addr));
@ -1483,7 +1483,7 @@ void hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_
hfp_connection->state = HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART;
return;
case HFP_IDLE:
memcpy(hfp_connection->remote_addr, bd_addr, 6);
(void)memcpy(hfp_connection->remote_addr, bd_addr, 6);
hfp_connection->state = HFP_W4_SDP_QUERY_COMPLETE;
connection_doing_sdp_query = hfp_connection;
hfp_connection->service_uuid = service_uuid;

19
src/classic/hfp_ag.c
View File

@ -114,7 +114,8 @@ hfp_ag_indicator_t * hfp_ag_get_ag_indicators(hfp_connection_t * hfp_connection)
static int hfp_ag_get_ag_indicators_nr(hfp_connection_t * hfp_connection){
if (hfp_connection->ag_indicators_nr != hfp_ag_indicators_nr){
hfp_connection->ag_indicators_nr = hfp_ag_indicators_nr;
memcpy(hfp_connection->ag_indicators, hfp_ag_indicators, hfp_ag_indicators_nr * sizeof(hfp_ag_indicator_t));
(void)memcpy(hfp_connection->ag_indicators, hfp_ag_indicators,
hfp_ag_indicators_nr * sizeof(hfp_ag_indicator_t));
}
return hfp_connection->ag_indicators_nr;
}
@ -123,7 +124,8 @@ hfp_ag_indicator_t * hfp_ag_get_ag_indicators(hfp_connection_t * hfp_connection)
// TODO: save only value, and value changed in the hfp_connection?
if (hfp_connection->ag_indicators_nr != hfp_ag_indicators_nr){
hfp_connection->ag_indicators_nr = hfp_ag_indicators_nr;
memcpy(hfp_connection->ag_indicators, hfp_ag_indicators, hfp_ag_indicators_nr * sizeof(hfp_ag_indicator_t));
(void)memcpy(hfp_connection->ag_indicators, hfp_ag_indicators,
hfp_ag_indicators_nr * sizeof(hfp_ag_indicator_t));
}
return (hfp_ag_indicator_t *)&(hfp_connection->ag_indicators);
}
@ -322,7 +324,7 @@ static void hgp_ag_indicators_cmd_generator_store_segment(hfp_connection_t * hfp
*buffer++ = '\r';
*buffer++ = '\n';
int len = strlen(HFP_INDICATOR);
memcpy(buffer, HFP_INDICATOR, len);
(void)memcpy(buffer, HFP_INDICATOR, len);
buffer += len;
*buffer++ = ':';
return;
@ -335,7 +337,7 @@ static void hgp_ag_indicators_cmd_generator_store_segment(hfp_connection_t * hfp
return;
}
if (indicator_index == (num_indicators-1)){
memcpy(buffer, "\r\n\r\nOK\r\n", 8);
(void)memcpy(buffer, "\r\n\r\nOK\r\n", 8);
return;
}
*buffer = ',';
@ -2095,18 +2097,21 @@ void hfp_ag_init_supported_features(uint32_t supported_features){
void hfp_ag_init_ag_indicators(int ag_indicators_nr, hfp_ag_indicator_t * ag_indicators){
hfp_ag_indicators_nr = ag_indicators_nr;
memcpy(hfp_ag_indicators, ag_indicators, ag_indicators_nr * sizeof(hfp_ag_indicator_t));
(void)memcpy(hfp_ag_indicators, ag_indicators,
ag_indicators_nr * sizeof(hfp_ag_indicator_t));
}
void hfp_ag_init_hf_indicators(int hf_indicators_nr, hfp_generic_status_indicator_t * hf_indicators){
if (hf_indicators_nr > HFP_MAX_NUM_HF_INDICATORS) return;
hfp_generic_status_indicators_nr = hf_indicators_nr;
memcpy(hfp_generic_status_indicators, hf_indicators, hf_indicators_nr * sizeof(hfp_generic_status_indicator_t));
(void)memcpy(hfp_generic_status_indicators, hf_indicators,
hf_indicators_nr * sizeof(hfp_generic_status_indicator_t));
}
void hfp_ag_init_call_hold_services(int call_hold_services_nr, const char * call_hold_services[]){
hfp_ag_call_hold_services_nr = call_hold_services_nr;
memcpy(hfp_ag_call_hold_services, call_hold_services, call_hold_services_nr * sizeof(char *));
(void)memcpy(hfp_ag_call_hold_services, call_hold_services,
call_hold_services_nr * sizeof(char *));
}

5
src/classic/hfp_msbc.c
View File

@ -85,7 +85,8 @@ void hfp_msbc_encode_audio_frame(int16_t * pcm_samples){
// SBC Frame
btstack_sbc_encoder_process_data(pcm_samples);
memcpy(msbc_buffer + msbc_buffer_offset, btstack_sbc_encoder_sbc_buffer(), MSBC_FRAME_SIZE);
(void)memcpy(msbc_buffer + msbc_buffer_offset,
btstack_sbc_encoder_sbc_buffer(), MSBC_FRAME_SIZE);
msbc_buffer_offset += MSBC_FRAME_SIZE;
// Final padding to use 60 bytes for 120 audio samples
@ -100,7 +101,7 @@ void hfp_msbc_read_from_stream(uint8_t * buf, int size){
return;
}
memcpy(buf, msbc_buffer, bytes_to_copy);
(void)memcpy(buf, msbc_buffer, bytes_to_copy);
memmove(msbc_buffer, msbc_buffer + bytes_to_copy, sizeof(msbc_buffer) - bytes_to_copy);
msbc_buffer_offset -= bytes_to_copy;
}

4
src/classic/hid_device.c
View File

@ -142,7 +142,7 @@ static hid_device_t * hid_device_get_instance_for_hid_cid(uint16_t hid_cid){
static hid_device_t * hid_device_provide_instance_for_bd_addr(bd_addr_t bd_addr){
if (!_hid_device.cid){
memcpy(_hid_device.bd_addr, bd_addr, 6);
(void)memcpy(_hid_device.bd_addr, bd_addr, 6);
_hid_device.cid = hid_device_get_next_cid();
_hid_device.protocol_mode = HID_PROTOCOL_MODE_REPORT;
_hid_device.con_handle = HCI_CON_HANDLE_INVALID;
@ -942,7 +942,7 @@ uint8_t hid_device_connect(bd_addr_t addr, uint16_t * hid_cid){
*hid_cid = hid_device_get_next_cid();
// store address
memcpy(hid_device->bd_addr, addr, 6);
(void)memcpy(hid_device->bd_addr, addr, 6);
// reset state
hid_device->cid = *hid_cid;

2
src/classic/hsp_ag.c
View File

@ -289,7 +289,7 @@ void hsp_ag_init(uint8_t rfcomm_channel_nr){
void hsp_ag_connect(bd_addr_t bd_addr){
if (hsp_state != HSP_IDLE) return;
hsp_state = HSP_SDP_QUERY_RFCOMM_CHANNEL;
memcpy(remote, bd_addr, 6);
(void)memcpy(remote, bd_addr, 6);
hsp_run();
}

4
src/classic/hsp_hs.c
View File

@ -295,7 +295,7 @@ void hsp_hs_init(uint8_t rfcomm_channel_nr){
void hsp_hs_connect(bd_addr_t bd_addr){
if (hsp_state != HSP_IDLE) return;
hsp_state = HSP_SDP_QUERY_RFCOMM_CHANNEL;
memcpy(remote, bd_addr, 6);
(void)memcpy(remote, bd_addr, 6);
hsp_run();
}
@ -549,7 +549,7 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
sco_handle = little_endian_read_16(packet, index);
index+=2;
bd_addr_t address;
memcpy(address, &packet[index], 6);
(void)memcpy(address, &packet[index], 6);
index+=6;
uint8_t link_type = packet[index++];
uint8_t transmission_interval = packet[index++]; // measured in slots

2
src/classic/obex_message_builder.c
View File

@ -57,7 +57,7 @@ static uint8_t obex_message_builder_packet_init(uint8_t * buffer, uint16_t buffe
static uint8_t obex_message_builder_packet_append(uint8_t * buffer, uint16_t buffer_len, const uint8_t * data, uint16_t len){
uint16_t pos = big_endian_read_16(buffer, 1);
if (buffer_len < pos + len) return ERROR_CODE_MEMORY_CAPACITY_EXCEEDED;
memcpy(&buffer[pos], data, len);
(void)memcpy(&buffer[pos], data, len);
pos += len;
big_endian_store_16(buffer, 1, pos);
return ERROR_CODE_SUCCESS;

19
src/classic/pbap_client.c
View File

@ -165,7 +165,7 @@ static void pbap_client_emit_connected_event(pbap_client_t * context, uint8_t st
little_endian_store_16(event,pos,context->cid);
pos+=2;
event[pos++] = status;
memcpy(&event[pos], context->bd_addr, 6);
(void)memcpy(&event[pos], context->bd_addr, 6);
pos += 6;
little_endian_store_16(event,pos,context->con_handle);
pos += 2;
@ -246,11 +246,11 @@ static void pbap_client_emit_card_result_event(pbap_client_t * context, const ch
pos+=2;
int name_len = btstack_min(PBAP_MAX_NAME_LEN, strlen(name));
event[pos++] = name_len;
memcpy(&event[pos], name, name_len);
(void)memcpy(&event[pos], name, name_len);
pos += name_len;
int handle_len = btstack_min(PBAP_MAX_HANDLE_LEN, strlen(handle));
event[pos++] = handle_len;
memcpy(&event[pos], handle, handle_len);
(void)memcpy(&event[pos], handle, handle_len);
pos += handle_len;
event[1] = pos - 2;
context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos);
@ -308,7 +308,8 @@ static void pbap_handle_can_send_now(void){
i += 16;
challenge_response[i++] = 2; // Tag Nonce
challenge_response[i++] = 16; // Len
memcpy(&challenge_response[i], pbap_client->authentication_nonce, 16);
(void)memcpy(&challenge_response[i],
pbap_client->authentication_nonce, 16);
i += 16;
goep_client_header_add_challenge_response(pbap_client->goep_cid, challenge_response, i);
pbap_client->state = PBAP_W4_CONNECT_RESPONSE;
@ -401,7 +402,8 @@ static void pbap_handle_can_send_now(void){
phone_number_len = btstack_min(PBAP_MAX_PHONE_NUMBER_LEN, strlen(pbap_client->phone_number));
application_parameters[i++] = PBAP_APPLICATION_PARAMETER_SEARCH_VALUE;
application_parameters[i++] = phone_number_len;
memcpy(&application_parameters[i], pbap_client->phone_number, phone_number_len);
(void)memcpy(&application_parameters[i],
pbap_client->phone_number, phone_number_len);
i += phone_number_len;
application_parameters[i++] = PBAP_APPLICATION_PARAMETER_SEARCH_PROPERTY;
application_parameters[i++] = 1;
@ -453,7 +455,9 @@ static void pbap_handle_can_send_now(void){
pbap_client->set_path_offset++;
}
path_element_len = pbap_client->set_path_offset-path_element_start;
memcpy(path_element, &pbap_client->current_folder[path_element_start], path_element_len);
(void)memcpy(path_element,
&pbap_client->current_folder[path_element_start],
path_element_len);
path_element[path_element_len] = 0;
// skip /
@ -494,7 +498,8 @@ static void pbap_parse_authentication_challenge(pbap_client_t * context, const u
log_error("Invalid OBEX digest len %u", len);
return;
}
memcpy(context->authentication_nonce, &challenge_data[i], 16);
(void)memcpy(context->authentication_nonce,
&challenge_data[i], 16);
// printf("Nonce: ");
// printf_hexdump(context->authentication_nonce, 16);
break;

16
src/classic/rfcomm.c
View File

@ -312,7 +312,8 @@ static void rfcomm_emit_port_configuration(rfcomm_channel_t *channel){
uint8_t event[2+sizeof(rfcomm_rpn_data_t)];
event[0] = RFCOMM_EVENT_PORT_CONFIGURATION;
event[1] = sizeof(rfcomm_rpn_data_t);
memcpy(&event[2], (uint8_t*) &channel->rpn_data, sizeof(rfcomm_rpn_data_t));
(void)memcpy(&event[2], (uint8_t *)&channel->rpn_data,
sizeof(rfcomm_rpn_data_t));
hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
(channel->packet_handler)(HCI_EVENT_PACKET, channel->rfcomm_cid, event, sizeof(event));
}
@ -583,7 +584,7 @@ static int rfcomm_send_packet_for_multiplexer(rfcomm_multiplexer_t *multiplexer,
// copy actual data
if (len) {
memcpy(&rfcomm_out_buffer[pos], data, len);
(void)memcpy(&rfcomm_out_buffer[pos], data, len);
pos += len;
}
@ -702,7 +703,7 @@ static int rfcomm_send_uih_test_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t *
len = RFCOMM_TEST_DATA_MAX_LEN;
}
payload[pos++] = (len << 1) | 1; // len
memcpy(&payload[pos], data, len);
(void)memcpy(&payload[pos], data, len);
pos += len;
return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos);
}
@ -1068,7 +1069,7 @@ static int rfcomm_hci_event_handler(uint8_t *packet, uint16_t size){
// request
rfcomm_ertm_request_t request;
memset(&request, 0, sizeof(rfcomm_ertm_request_t));
memcpy(request.addr, event_addr, 6);
(void)memcpy(request.addr, event_addr, 6);
request.ertm_id = rfcomm_next_ertm_id();
if (rfcomm_ertm_request_callback){
(*rfcomm_ertm_request_callback)(&request);
@ -1273,7 +1274,8 @@ static int rfcomm_multiplexer_l2cap_packet_handler(uint16_t channel, uint8_t *pa
}
len = btstack_min(len, size - 1 - payload_offset); // avoid information leak
multiplexer->test_data_len = len;
memcpy(multiplexer->test_data, &packet[payload_offset + 2], len);
(void)memcpy(multiplexer->test_data,
&packet[payload_offset + 2], len);
l2cap_request_can_send_now_event(multiplexer->l2cap_cid);
return 1;
}
@ -2334,7 +2336,7 @@ int rfcomm_send(uint16_t rfcomm_cid, uint8_t *data, uint16_t len){
#endif
uint8_t * rfcomm_payload = rfcomm_get_outgoing_buffer();
memcpy(rfcomm_payload, data, len);
(void)memcpy(rfcomm_payload, data, len);
err = rfcomm_send_prepared(rfcomm_cid, len);
#ifdef RFCOMM_USE_OUTGOING_BUFFER
@ -2449,7 +2451,7 @@ static uint8_t rfcomm_channel_create_internal(btstack_packet_handler_t packet_ha
// request
rfcomm_ertm_request_t request;
memset(&request, 0, sizeof(rfcomm_ertm_request_t));
memcpy(request.addr, addr, 6);
(void)memcpy(request.addr, addr, 6);
request.ertm_id = rfcomm_next_ertm_id();
if (rfcomm_ertm_request_callback){
(*rfcomm_ertm_request_callback)(&request);

22
src/classic/sdp_client.c
View File

@ -389,7 +389,7 @@ static void sdp_client_parse_service_search_attribute_response(uint8_t* packet,
// continuation state
if ((offset + continuationStateLen) > size) return;
memcpy(continuationState, packet+offset, continuationStateLen);
(void)memcpy(continuationState, packet + offset, continuationStateLen);
// offset+=continuationStateLen;
}
@ -498,7 +498,8 @@ static uint16_t sdp_client_setup_service_search_attribute_request(uint8_t * data
// parameters:
// Service_search_pattern - DES (min 1 UUID, max 12)
uint16_t service_search_pattern_len = de_get_len(service_search_pattern);
memcpy(data + offset, service_search_pattern, service_search_pattern_len);
(void)memcpy(data + offset, service_search_pattern,
service_search_pattern_len);
offset += service_search_pattern_len;
// MaximumAttributeByteCount - uint16_t 0x0007 - 0xffff -> mtu
@ -507,13 +508,13 @@ static uint16_t sdp_client_setup_service_search_attribute_request(uint8_t * data
// AttibuteIDList
uint16_t attribute_id_list_len = de_get_len(attribute_id_list);
memcpy(data + offset, attribute_id_list, attribute_id_list_len);
(void)memcpy(data + offset, attribute_id_list, attribute_id_list_len);
offset += attribute_id_list_len;
// ContinuationState - uint8_t number of cont. bytes N<=16
data[offset++] = continuationStateLen;
// - N-bytes previous response from server
memcpy(data + offset, continuationState, continuationStateLen);
(void)memcpy(data + offset, continuationState, continuationStateLen);
offset += continuationStateLen;
// uint16_t paramLength
@ -542,7 +543,8 @@ static uint16_t sdp_client_setup_service_search_request(uint8_t * data){
// parameters:
// Service_search_pattern - DES (min 1 UUID, max 12)
uint16_t service_search_pattern_len = de_get_len(service_search_pattern);
memcpy(data + offset, service_search_pattern, service_search_pattern_len);
(void)memcpy(data + offset, service_search_pattern,
service_search_pattern_len);
offset += service_search_pattern_len;
// MaximumAttributeByteCount - uint16_t 0x0007 - 0xffff -> mtu
@ -552,7 +554,7 @@ static uint16_t sdp_client_setup_service_search_request(uint8_t * data){
// ContinuationState - uint8_t number of cont. bytes N<=16
data[offset++] = continuationStateLen;
// - N-bytes previous response from server
memcpy(data + offset, continuationState, continuationStateLen);
(void)memcpy(data + offset, continuationState, continuationStateLen);
offset += continuationStateLen;
// uint16_t paramLength
@ -586,13 +588,13 @@ static uint16_t sdp_client_setup_service_attribute_request(uint8_t * data){
// AttibuteIDList
uint16_t attribute_id_list_len = de_get_len(attribute_id_list);
memcpy(data + offset, attribute_id_list, attribute_id_list_len);
(void)memcpy(data + offset, attribute_id_list, attribute_id_list_len);
offset += attribute_id_list_len;
// ContinuationState - uint8_t number of cont. bytes N<=16
data[offset++] = continuationStateLen;
// - N-bytes previous response from server
memcpy(data + offset, continuationState, continuationStateLen);
(void)memcpy(data + offset, continuationState, continuationStateLen);
offset += continuationStateLen;
// uint16_t paramLength
@ -633,7 +635,7 @@ static void sdp_client_parse_service_search_response(uint8_t* packet, uint16_t s
return;
}
if (offset + continuationStateLen > size) return;
memcpy(continuationState, packet+offset, continuationStateLen);
(void)memcpy(continuationState, packet + offset, continuationStateLen);
// offset+=continuationStateLen;
}
@ -668,7 +670,7 @@ static void sdp_client_parse_service_attribute_response(uint8_t* packet, uint16_
return;
}
if (offset + continuationStateLen > size) return;
memcpy(continuationState, packet+offset, continuationStateLen);
(void)memcpy(continuationState, packet + offset, continuationStateLen);
// offset+=continuationStateLen;
}
#endif

2
src/classic/sdp_client_rfcomm.c
View File

@ -95,7 +95,7 @@ static void sdp_rfcomm_query_emit_service(void){
event[0] = SDP_EVENT_QUERY_RFCOMM_SERVICE;
event[1] = sdp_service_name_len + 1;
event[2] = sdp_rfcomm_channel_nr;
memcpy(&event[3], sdp_service_name, sdp_service_name_len);
(void)memcpy(&event[3], sdp_service_name, sdp_service_name_len);
event[3+sdp_service_name_len] = 0;
(*sdp_app_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
sdp_rfcomm_channel_nr = 0;

13
src/classic/sdp_util.c
View File

@ -149,7 +149,7 @@ int de_get_normalized_uuid(uint8_t *uuid128, const uint8_t *element){
shortUUID = big_endian_read_32(element, 1);
break;
case DE_SIZE_128:
memcpy(uuid128, element+1, 16);
(void)memcpy(uuid128, element + 1, 16);
return 1;
default:
return 0;
@ -254,7 +254,7 @@ void de_add_data( uint8_t *seq, de_type_t type, uint16_t size, uint8_t *data){
de_store_descriptor_with_len(seq+3+data_size, type, DE_SIZE_VAR_8, size);
data_size += 2;
}
memcpy( seq + 3 + data_size, data, size);
(void)memcpy(seq + 3 + data_size, data, size);
data_size += size;
big_endian_store_16(seq, 1, data_size);
}
@ -262,7 +262,7 @@ void de_add_data( uint8_t *seq, de_type_t type, uint16_t size, uint8_t *data){
void de_add_uuid128(uint8_t * seq, uint8_t * uuid){
int data_size = big_endian_read_16(seq,1);
de_store_descriptor(seq+3+data_size, DE_UUID, DE_SIZE_128);
memcpy( seq + 4 + data_size, uuid, 16);
(void)memcpy(seq + 4 + data_size, uuid, 16);
big_endian_store_16(seq, 1, data_size+1+16);
}
@ -401,7 +401,8 @@ static int sdp_traversal_append_attributes(uint16_t attributeID, uint8_t * attri
// copy Attribute
de_add_number(context->buffer, DE_UINT, DE_SIZE_16, attributeID);
data_size += 3; // 3 bytes
memcpy(context->buffer + 3 + data_size, attributeValue, attribute_len);
(void)memcpy(context->buffer + 3 + data_size, attributeValue,
attribute_len);
big_endian_store_16(context->buffer,1,data_size+attribute_len);
} else {
// not enought space left -> continue with previous element
@ -441,7 +442,7 @@ static int spd_append_range(struct sdp_context_filter_attributes* context, uint1
remainder_len = context->maxBytes;
ok = 0;
}
memcpy(context->buffer, &data[context->startOffset], remainder_len);
(void)memcpy(context->buffer, &data[context->startOffset], remainder_len);
context->usedBytes += remainder_len;
context->buffer += remainder_len;
context->maxBytes -= remainder_len;
@ -723,7 +724,7 @@ uint8_t* sdp_service_search_pattern_for_uuid16(uint16_t uuid16){
}
uint8_t* sdp_service_search_pattern_for_uuid128(const uint8_t * uuid128){
memcpy(&des_serviceSearchPatternUUID128[3], uuid128, 16);
(void)memcpy(&des_serviceSearchPatternUUID128[3], uuid128, 16);
return (uint8_t*)des_serviceSearchPatternUUID128;
}

72
src/hci.c
View File

@ -870,7 +870,8 @@ static void acl_handler(uint8_t *packet, int size){
}
// append fragment payload (header already stored)
memcpy(&conn->acl_recombination_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + conn->acl_recombination_pos], &packet[4], acl_length );
(void)memcpy(&conn->acl_recombination_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + conn->acl_recombination_pos],
&packet[4], acl_length);
conn->acl_recombination_pos += acl_length;
// log_error( "ACL Cont Fragment: acl_len %u, combined_len %u, l2cap_len %u", acl_length,
@ -911,7 +912,8 @@ static void acl_handler(uint8_t *packet, int size){
}
// store first fragment and tweak acl length for complete package
memcpy(&conn->acl_recombination_buffer[HCI_INCOMING_PRE_BUFFER_SIZE], packet, acl_length + 4);
(void)memcpy(&conn->acl_recombination_buffer[HCI_INCOMING_PRE_BUFFER_SIZE],
packet, acl_length + 4);
conn->acl_recombination_pos = acl_length + 4;
conn->acl_recombination_length = l2cap_length;
little_endian_store_16(conn->acl_recombination_buffer, HCI_INCOMING_PRE_BUFFER_SIZE + 2, l2cap_length +4);
@ -1060,9 +1062,9 @@ static int hci_le_supported(void){
void gap_le_get_own_address(uint8_t * addr_type, bd_addr_t addr){
*addr_type = hci_stack->le_own_addr_type;
if (hci_stack->le_own_addr_type){
memcpy(addr, hci_stack->le_random_address, 6);
(void)memcpy(addr, hci_stack->le_random_address, 6);
} else {
memcpy(addr, hci_stack->local_bd_addr, 6);
(void)memcpy(addr, hci_stack->local_bd_addr, 6);
}
}
@ -1086,13 +1088,13 @@ void le_handle_advertisement_report(uint8_t *packet, uint16_t size){
int pos = 0;
event[pos++] = GAP_EVENT_ADVERTISING_REPORT;
event[pos++] = event_size;
memcpy(&event[pos], &packet[offset], 1+1+6); // event type + address type + address
(void)memcpy(&event[pos], &packet[offset], 1 + 1 + 6); // event type + address type + address
offset += 8;
pos += 8;
event[pos++] = packet[offset + 1 + data_length]; // rssi
event[pos++] = data_length;
offset++;
memcpy(&event[pos], &packet[offset], data_length);
(void)memcpy(&event[pos], &packet[offset], data_length);
pos += data_length;
offset += data_length + 1; // rssi
hci_emit_event(event, pos, 1);
@ -1201,7 +1203,8 @@ static void hci_replace_bd_addr_placeholder(uint8_t * data, uint16_t size){
continue;
}
// set real address
memcpy(&data[i], bd_addr_to_str(hci_stack->local_bd_addr), bd_addr_string_len);
(void)memcpy(&data[i], bd_addr_to_str(hci_stack->local_bd_addr),
bd_addr_string_len);
i += bd_addr_string_len;
}
}
@ -1420,7 +1423,8 @@ static void hci_initializing_run(void){
packet[1] = opcode >> 8;
packet[2] = DEVICE_NAME_LEN;
memset(&packet[3], 0, DEVICE_NAME_LEN);
memcpy(&packet[3], hci_stack->local_name, strlen(hci_stack->local_name));
(void)memcpy(&packet[3], hci_stack->local_name,
strlen(hci_stack->local_name));
// expand '00:00:00:00:00:00' in name with bd_addr
hci_replace_bd_addr_placeholder(&packet[3], DEVICE_NAME_LEN);
hci_send_cmd_packet(packet, HCI_CMD_HEADER_SIZE + DEVICE_NAME_LEN);
@ -1438,13 +1442,13 @@ static void hci_initializing_run(void){
packet[2] = 1 + 240;
packet[3] = 0; // FEC not required
if (hci_stack->eir_data){
memcpy(&packet[4], hci_stack->eir_data, 240);
(void)memcpy(&packet[4], hci_stack->eir_data, 240);
} else {
memset(&packet[4], 0, 240);
int name_len = strlen(hci_stack->local_name);
packet[4] = name_len + 1;
packet[5] = BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME;
memcpy(&packet[6], hci_stack->local_name, name_len);
(void)memcpy(&packet[6], hci_stack->local_name, name_len);
}
// expand '00:00:00:00:00:00' in name with bd_addr
hci_replace_bd_addr_placeholder(&packet[4], 240);
@ -1841,7 +1845,7 @@ static void hci_initializing_event_handler(uint8_t * packet, uint16_t size){
static void hci_handle_connection_failed(hci_connection_t * conn, uint8_t status){
log_info("Outgoing connection to %s failed", bd_addr_to_str(conn->address));
bd_addr_t bd_address;
memcpy(&bd_address, conn->address, 6);
(void)memcpy(&bd_address, conn->address, 6);
#ifdef ENABLE_CLASSIC
// cache needed data
@ -1924,7 +1928,7 @@ static void event_handler(uint8_t *packet, int size){
uint8_t event[5];
event[0] = GAP_EVENT_RSSI_MEASUREMENT;
event[1] = 3;
memcpy(&event[2], &packet[6], 3);
(void)memcpy(&event[2], &packet[6], 3);
hci_emit_event(event, sizeof(event), 1);
}
}
@ -1978,7 +1982,9 @@ static void event_handler(uint8_t *packet, int size){
// Note: HCI init checks
if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_supported_features)){
memcpy(hci_stack->local_supported_features, &packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE+1], 8);
(void)memcpy(hci_stack->local_supported_features,
&packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE + 1],
8);
#ifdef ENABLE_CLASSIC
// determine usable ACL packet types based on host buffer size and supported features
@ -2591,7 +2597,7 @@ static void event_handler(uint8_t *packet, int size){
uint8_t status = aConn->bonding_status;
uint16_t flags = aConn->bonding_flags;
bd_addr_t bd_address;
memcpy(&bd_address, aConn->address, 6);
(void)memcpy(&bd_address, aConn->address, 6);
hci_shutdown_connection(aConn);
// connection struct is gone, don't access anymore
if (flags & BONDING_EMIT_COMPLETE_ON_DISCONNECT){
@ -2947,7 +2953,7 @@ void hci_disable_l2cap_timeout_check(void){
#if !defined(HAVE_PLATFORM_IPHONE_OS) && !defined (HAVE_HOST_CONTROLLER_API)
// Set Public BD ADDR - passed on to Bluetooth chipset if supported in bt_control_h
void hci_set_bd_addr(bd_addr_t addr){
memcpy(hci_stack->custom_bd_addr, addr, 6);
(void)memcpy(hci_stack->custom_bd_addr, addr, 6);
hci_stack->custom_bd_addr_set = 1;
}
#endif
@ -3239,7 +3245,7 @@ void gap_connectable_control(uint8_t enable){
#endif
void gap_local_bd_addr(bd_addr_t address_buffer){
memcpy(address_buffer, hci_stack->local_bd_addr, 6);
(void)memcpy(address_buffer, hci_stack->local_bd_addr, 6);
}
#ifdef ENABLE_HCI_CONTROLLER_TO_HOST_FLOW_CONTROL
@ -3440,7 +3446,8 @@ static void hci_run(void){
hci_stack->le_advertisements_todo &= ~LE_ADVERTISEMENT_TASKS_SET_ADV_DATA;
uint8_t adv_data_clean[31];
memset(adv_data_clean, 0, sizeof(adv_data_clean));
memcpy(adv_data_clean, hci_stack->le_advertisements_data, hci_stack->le_advertisements_data_len);
(void)memcpy(adv_data_clean, hci_stack->le_advertisements_data,
hci_stack->le_advertisements_data_len);
hci_replace_bd_addr_placeholder(adv_data_clean, hci_stack->le_advertisements_data_len);
hci_send_cmd(&hci_le_set_advertising_data, hci_stack->le_advertisements_data_len, adv_data_clean);
return;
@ -3449,7 +3456,8 @@ static void hci_run(void){
hci_stack->le_advertisements_todo &= ~LE_ADVERTISEMENT_TASKS_SET_SCAN_DATA;
uint8_t scan_data_clean[31];
memset(scan_data_clean, 0, sizeof(scan_data_clean));
memcpy(scan_data_clean, hci_stack->le_scan_response_data, hci_stack->le_scan_response_data_len);
(void)memcpy(scan_data_clean, hci_stack->le_scan_response_data,
hci_stack->le_scan_response_data_len);
hci_replace_bd_addr_placeholder(scan_data_clean, hci_stack->le_scan_response_data_len);
hci_send_cmd(&hci_le_set_scan_response_data, hci_stack->le_scan_response_data_len, scan_data_clean);
return;
@ -3498,7 +3506,7 @@ static void hci_run(void){
if (entry->state & LE_WHITELIST_REMOVE_FROM_CONTROLLER){
bd_addr_t address;
bd_addr_type_t address_type = entry->address_type;
memcpy(address, entry->address, 6);
(void)memcpy(address, entry->address, 6);
btstack_linked_list_remove(&hci_stack->le_whitelist, (btstack_linked_item_t *) entry);
btstack_memory_whitelist_entry_free(entry);
hci_send_cmd(&hci_le_remove_device_from_white_list, address_type, address);
@ -3550,7 +3558,8 @@ static void hci_run(void){
#ifdef ENABLE_LE_CENTRAL
// track outgoing connection
hci_stack->outgoing_addr_type = connection->address_type;
memcpy(hci_stack->outgoing_addr, connection->address, 6);
(void)memcpy(hci_stack->outgoing_addr,
connection->address, 6);
log_info("sending hci_le_create_connection");
hci_send_cmd(&hci_le_create_connection,
hci_stack->le_connection_scan_interval, // conn scan interval
@ -3949,7 +3958,7 @@ int hci_send_cmd_packet(uint8_t *packet, int size){
// track outgoing connection
hci_stack->outgoing_addr_type = BD_ADDR_TYPE_ACL;
memcpy(hci_stack->outgoing_addr, addr, 6);
(void)memcpy(hci_stack->outgoing_addr, addr, 6);
}
if (IS_COMMAND(packet, hci_link_key_request_reply)){
@ -4165,10 +4174,14 @@ static void gap_inquiry_explode(uint8_t * packet){
event[0] = GAP_EVENT_INQUIRY_RESULT;
uint8_t event_size = 18; // if name is not set by EIR
memcpy(&event[2], &packet[3 + (i*6)], 6); // bd_addr
(void)memcpy(&event[2], &packet[3 + (i * 6)], 6); // bd_addr
event[8] = packet[3 + (num_responses*(6)) + (i*1)]; // page_scan_repetition_mode
memcpy(&event[9], &packet[3 + (num_responses*(6+1+num_reserved_fields)) + (i*3)], 3); // class of device
memcpy(&event[12], &packet[3 + (num_responses*(6+1+num_reserved_fields+3)) + (i*2)], 2); // clock offset
(void)memcpy(&event[9],
&packet[3 + (num_responses * (6 + 1 + num_reserved_fields)) + (i * 3)],
3); // class of device
(void)memcpy(&event[12],
&packet[3 + (num_responses * (6 + 1 + num_reserved_fields + 3)) + (i * 2)],
2); // clock offset
switch (event_type){
case HCI_EVENT_INQUIRY_RESULT:
@ -4208,7 +4221,7 @@ static void gap_inquiry_explode(uint8_t * packet){
// truncate name if needed
int len = btstack_min(name_len, GAP_INQUIRY_MAX_NAME_LEN);
event[17] = len;
memcpy(&event[18], name, len);
(void)memcpy(&event[18], name, len);
event_size += len;
}
break;
@ -4759,7 +4772,8 @@ void gap_scan_response_set_data(uint8_t scan_response_data_length, uint8_t * sca
hci_stack->le_advertisements_direct_address_type = direct_address_typ;
hci_stack->le_advertisements_channel_map = channel_map;
hci_stack->le_advertisements_filter_policy = filter_policy;
memcpy(hci_stack->le_advertisements_direct_address, direct_address, 6);
(void)memcpy(hci_stack->le_advertisements_direct_address, direct_address,
6);
hci_stack->le_advertisements_todo |= LE_ADVERTISEMENT_TASKS_SET_PARAMS;
gap_advertisments_changed();
@ -4873,7 +4887,7 @@ int gap_auto_connection_start(bd_addr_type_t address_type, bd_addr_t address){
whitelist_entry_t * entry = btstack_memory_whitelist_entry_get();
if (!entry) return BTSTACK_MEMORY_ALLOC_FAILED;
entry->address_type = address_type;
memcpy(entry->address, address, 6);
(void)memcpy(entry->address, address, 6);
entry->state = LE_WHITELIST_ADD_TO_CONTROLLER;
btstack_linked_list_add(&hci_stack->le_whitelist, (btstack_linked_item_t*) entry);
hci_run();
@ -4993,7 +5007,7 @@ int gap_inquiry_stop(void){
*/
int gap_remote_name_request(bd_addr_t addr, uint8_t page_scan_repetition_mode, uint16_t clock_offset){
if (hci_stack->remote_name_state != GAP_REMOTE_NAME_STATE_IDLE) return ERROR_CODE_COMMAND_DISALLOWED;
memcpy(hci_stack->remote_name_addr, addr, 6);
(void)memcpy(hci_stack->remote_name_addr, addr, 6);
hci_stack->remote_name_page_scan_repetition_mode = page_scan_repetition_mode;
hci_stack->remote_name_clock_offset = clock_offset;
hci_stack->remote_name_state = GAP_REMOTE_NAME_STATE_W2_SEND;
@ -5003,7 +5017,7 @@ int gap_remote_name_request(bd_addr_t addr, uint8_t page_scan_repetition_mode, u
static int gap_pairing_set_state_and_run(bd_addr_t addr, uint8_t state){
hci_stack->gap_pairing_state = state;
memcpy(hci_stack->gap_pairing_addr, addr, 6);
(void)memcpy(hci_stack->gap_pairing_addr, addr, 6);
hci_run();
return 0;
}

12
src/hci_cmd.c
View File

@ -117,12 +117,12 @@ uint16_t hci_cmd_create_from_template(uint8_t *hci_cmd_buffer, const hci_cmd_t *
break;
case 'D': // 8 byte data block
ptr = va_arg(argptr, uint8_t *);
memcpy(&hci_cmd_buffer[pos], ptr, 8);
(void)memcpy(&hci_cmd_buffer[pos], ptr, 8);
pos += 8;
break;
case 'E': // Extended Inquiry Information 240 octets
ptr = va_arg(argptr, uint8_t *);
memcpy(&hci_cmd_buffer[pos], ptr, 240);
(void)memcpy(&hci_cmd_buffer[pos], ptr, 240);
pos += 240;
break;
case 'N': { // UTF-8 string, null terminated
@ -131,7 +131,7 @@ uint16_t hci_cmd_create_from_template(uint8_t *hci_cmd_buffer, const hci_cmd_t *
if (len > 248) {
len = 248;
}
memcpy(&hci_cmd_buffer[pos], ptr, len);
(void)memcpy(&hci_cmd_buffer[pos], ptr, len);
if (len < 248) {
// fill remaining space with zeroes
memset(&hci_cmd_buffer[pos+len], 0, 248-len);
@ -141,13 +141,13 @@ uint16_t hci_cmd_create_from_template(uint8_t *hci_cmd_buffer, const hci_cmd_t *
}
case 'P': // 16 byte PIN code or link key
ptr = va_arg(argptr, uint8_t *);
memcpy(&hci_cmd_buffer[pos], ptr, 16);
(void)memcpy(&hci_cmd_buffer[pos], ptr, 16);
pos += 16;
break;
#ifdef ENABLE_BLE
case 'A': // 31 bytes advertising data
ptr = va_arg(argptr, uint8_t *);
memcpy(&hci_cmd_buffer[pos], ptr, 31);
(void)memcpy(&hci_cmd_buffer[pos], ptr, 31);
pos += 31;
break;
#endif
@ -155,7 +155,7 @@ uint16_t hci_cmd_create_from_template(uint8_t *hci_cmd_buffer, const hci_cmd_t *
case 'S': { // Service Record (Data Element Sequence)
ptr = va_arg(argptr, uint8_t *);
uint16_t len = de_get_len(ptr);
memcpy(&hci_cmd_buffer[pos], ptr, len);
(void)memcpy(&hci_cmd_buffer[pos], ptr, len);
pos += len;
break;
}

4
src/hci_transport_em9304_spi.c
View File

@ -288,7 +288,9 @@ static void em9304_spi_engine_run(void){
} else {
// TODO: get rid of alignment requirement
// enforce alignment by copying to spi buffer first
memcpy(em9304_spi_engine_spi_buffer.bytes, em9304_spi_engine_tx_data, em9304_spi_engine_tx_request_len);
(void)memcpy(em9304_spi_engine_spi_buffer.bytes,
em9304_spi_engine_tx_data,
em9304_spi_engine_tx_request_len);
btstack_em9304_spi->transmit( (uint8_t*) em9304_spi_engine_spi_buffer.bytes, em9304_spi_engine_tx_request_len);
}
break;

38
src/l2cap.c
View File

@ -377,7 +377,9 @@ static int l2cap_ertm_send_information_frame(l2cap_channel_t * channel, int inde
uint16_t control = l2cap_encanced_control_field_for_information_frame(tx_state->tx_seq, final, channel->req_seq, tx_state->sar);
log_info("I-Frame: control 0x%04x", control);
little_endian_store_16(acl_buffer, 8, control);
memcpy(&acl_buffer[8+2], &channel->tx_packets_data[index * channel->local_mps], tx_state->len);
(void)memcpy(&acl_buffer[8 + 2],
&channel->tx_packets_data[index * channel->local_mps],
tx_state->len);
// (re-)start retransmission timer on
l2cap_ertm_start_retransmission_timer(channel);
// send
@ -400,7 +402,7 @@ static void l2cap_ertm_store_fragment(l2cap_channel_t * channel, l2cap_segmentat
little_endian_store_16(tx_packet, 0, sdu_length);
pos += 2;
}
memcpy(&tx_packet[pos], data, len);
(void)memcpy(&tx_packet[pos], data, len);
tx_state->len = pos + len;
// update
@ -783,7 +785,7 @@ static void l2cap_ertm_handle_out_of_sequence_sdu(l2cap_channel_t * l2cap_channe
rx_state->sar = sar;
rx_state->len = size;
uint8_t * rx_buffer = &l2cap_channel->rx_packets_data[index];
memcpy(rx_buffer, payload, size);
(void)memcpy(rx_buffer, payload, size);
}
// @assumption size <= l2cap_channel->local_mps (checked in l2cap_acl_classic_handler)
@ -805,21 +807,23 @@ static void l2cap_ertm_handle_in_sequence_sdu(l2cap_channel_t * l2cap_channel, l
if (reassembly_sdu_length > l2cap_channel->local_mtu) break;
// store start segment
l2cap_channel->reassembly_sdu_length = reassembly_sdu_length;
memcpy(&l2cap_channel->reassembly_buffer[0], payload, size);
(void)memcpy(&l2cap_channel->reassembly_buffer[0], payload, size);
l2cap_channel->reassembly_pos = size;
break;
case L2CAP_SEGMENTATION_AND_REASSEMBLY_CONTINUATION_OF_L2CAP_SDU:
// assert size of reassembled data <= our mtu
if (l2cap_channel->reassembly_pos + size > l2cap_channel->local_mtu) break;
// store continuation segment
memcpy(&l2cap_channel->reassembly_buffer[l2cap_channel->reassembly_pos], payload, size);
(void)memcpy(&l2cap_channel->reassembly_buffer[l2cap_channel->reassembly_pos],
payload, size);
l2cap_channel->reassembly_pos += size;
break;
case L2CAP_SEGMENTATION_AND_REASSEMBLY_END_OF_L2CAP_SDU:
// assert size of reassembled data <= our mtu
if (l2cap_channel->reassembly_pos + size > l2cap_channel->local_mtu) break;
// store continuation segment
memcpy(&l2cap_channel->reassembly_buffer[l2cap_channel->reassembly_pos], payload, size);
(void)memcpy(&l2cap_channel->reassembly_buffer[l2cap_channel->reassembly_pos],
payload, size);
l2cap_channel->reassembly_pos += size;
// assert size of reassembled data matches announced sdu length
if (l2cap_channel->reassembly_pos != l2cap_channel->reassembly_sdu_length) break;
@ -991,7 +995,7 @@ int l2cap_send_connectionless(hci_con_handle_t con_handle, uint16_t cid, uint8_t
hci_reserve_packet_buffer();
uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
memcpy(&acl_buffer[8], data, len);
(void)memcpy(&acl_buffer[8], data, len);
return l2cap_send_prepared_connectionless(con_handle, cid, len);
}
@ -1332,7 +1336,7 @@ int l2cap_send(uint16_t local_cid, uint8_t *data, uint16_t len){
hci_reserve_packet_buffer();
uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
memcpy(&acl_buffer[8], data, len);
(void)memcpy(&acl_buffer[8], data, len);
return l2cap_send_prepared(local_cid, len);
}
@ -1455,7 +1459,9 @@ static void l2cap_run(void){
signaling_responses_pending--;
int i;
for (i=0; i < signaling_responses_pending; i++){
memcpy(&signaling_responses[i], &signaling_responses[i+1], sizeof(l2cap_signaling_response_t));
(void)memcpy(&signaling_responses[i],
&signaling_responses[i + 1],
sizeof(l2cap_signaling_response_t));
}
switch (response_code){
@ -1563,7 +1569,7 @@ static void l2cap_run(void){
// send connection request - set state first
channel->state = L2CAP_STATE_WAIT_CONNECTION_COMPLETE;
// BD_ADDR, Packet_Type, Page_Scan_Repetition_Mode, Reserved, Clock_Offset, Allow_Role_Switch
memcpy(l2cap_outgoing_classic_addr, channel->address, 6);
(void)memcpy(l2cap_outgoing_classic_addr, channel->address, 6);
hci_send_cmd(&hci_create_connection, channel->address, hci_usable_acl_packet_types(), 0, 0, 0, 1);
break;
@ -2239,7 +2245,7 @@ static void l2cap_hci_event_handler(uint8_t packet_type, uint16_t cid, uint8_t *
// check command status for create connection for errors
if (HCI_EVENT_IS_COMMAND_STATUS(packet, hci_create_connection)){
// cache outgoing address and reset
memcpy(address, l2cap_outgoing_classic_addr, 6);
(void)memcpy(address, l2cap_outgoing_classic_addr, 6);
memset(l2cap_outgoing_classic_addr, 0, 6);
// error => outgoing connection failed
uint8_t status = hci_event_command_status_get_status(packet);
@ -3034,7 +3040,7 @@ static int l2cap_le_signaling_handler_dispatch(hci_con_handle_t handle, uint8_t
event[0] = L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_REQUEST;
event[1] = 8;
little_endian_store_16(event, 2, handle);
memcpy(&event[4], &command[4], 8);
(void)memcpy(&event[4], &command[4], 8);
hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
(*l2cap_event_packet_handler)( HCI_EVENT_PACKET, 0, event, sizeof(event));
break;
@ -3572,7 +3578,9 @@ static void l2cap_acl_le_handler(hci_con_handle_t handle, uint8_t *packet, uint1
uint16_t fragment_size = size-COMPLETE_L2CAP_HEADER;
uint16_t remaining_space = l2cap_channel->local_mtu - l2cap_channel->receive_sdu_pos;
if (fragment_size > remaining_space) break; // SDU would cause buffer overrun
memcpy(&l2cap_channel->receive_sdu_buffer[l2cap_channel->receive_sdu_pos], &packet[COMPLETE_L2CAP_HEADER+pos], fragment_size);
(void)memcpy(&l2cap_channel->receive_sdu_buffer[l2cap_channel->receive_sdu_pos],
&packet[COMPLETE_L2CAP_HEADER + pos],
fragment_size);
l2cap_channel->receive_sdu_pos += size - COMPLETE_L2CAP_HEADER;
// done?
log_debug("le packet pos %u, len %u", l2cap_channel->receive_sdu_pos, l2cap_channel->receive_sdu_len);
@ -3778,7 +3786,9 @@ static void l2cap_le_send_pdu(l2cap_channel_t *channel){
}
uint16_t payload_size = btstack_min(channel->send_sdu_len + 2 - channel->send_sdu_pos, channel->remote_mps - pos);
log_info("len %u, pos %u => payload %u, credits %u", channel->send_sdu_len, channel->send_sdu_pos, payload_size, channel->credits_outgoing);
memcpy(&l2cap_payload[pos], &channel->send_sdu_buffer[channel->send_sdu_pos-2], payload_size); // -2 for virtual SDU len
(void)memcpy(&l2cap_payload[pos],
&channel->send_sdu_buffer[channel->send_sdu_pos - 2],
payload_size); // -2 for virtual SDU len
pos += payload_size;
channel->send_sdu_pos += payload_size;
l2cap_setup_header(acl_buffer, channel->con_handle, 0, channel->remote_cid, pos);

2
src/l2cap_signaling.c
View File

@ -119,7 +119,7 @@ static uint16_t l2cap_create_signaling_internal(uint8_t * acl_buffer, hci_con_ha
case 'D': // variable data. passed: len, ptr
word = va_arg(argptr, int);
ptr = va_arg(argptr, uint8_t *);
memcpy(&acl_buffer[pos], ptr, word);
(void)memcpy(&acl_buffer[pos], ptr, word);
pos += word;
break;
default:

4
src/mesh/adv_bearer.c
View File

@ -293,7 +293,7 @@ static void adv_bearer_prepare_message(const uint8_t * data, uint16_t data_len,
// prepare message
adv_bearer_buffer[0] = data_len+1;
adv_bearer_buffer[1] = type;
memcpy(&adv_bearer_buffer[2], data, data_len);
(void)memcpy(&adv_bearer_buffer[2], data, data_len);
adv_bearer_buffer_length = data_len + 2;
// setup trasmission schedule
@ -388,7 +388,7 @@ void adv_bearer_advertisements_set_params(uint16_t adv_int_min, uint16_t adv_int
gap_adv_int_ms = gap_adv_int_min * 625 / 1000;
gap_adv_type = adv_type;
gap_direct_address_typ = direct_address_typ;
memcpy(gap_direct_address, &direct_address, 6);
(void)memcpy(gap_direct_address, &direct_address, 6);
gap_channel_map = channel_map;
gap_filter_policy = filter_policy;

10
src/mesh/beacon.c
View File

@ -109,7 +109,7 @@ static void beacon_timer_handler(btstack_timer_source_t * ts){
// setup beacon
mesh_beacon_len = UNPROVISIONED_BEACON_LEN;
mesh_beacon_data[0] = BEACON_TYPE_UNPROVISIONED_DEVICE;
memcpy(&mesh_beacon_data[1], beacon_device_uuid, 16);
(void)memcpy(&mesh_beacon_data[1], beacon_device_uuid, 16);
big_endian_store_16(mesh_beacon_data, 17, beacon_oob_information);
big_endian_store_32(mesh_beacon_data, 19, beacon_uri_hash);
@ -122,7 +122,8 @@ static void beacon_timer_handler(btstack_timer_source_t * ts){
static void mesh_secure_network_beacon_auth_value_calculated(void * arg){
mesh_subnet_t * mesh_subnet = (mesh_subnet_t *) arg;
memcpy(&mesh_beacon_data[14], mesh_secure_network_beacon_auth_value, 8);
(void)memcpy(&mesh_beacon_data[14],
mesh_secure_network_beacon_auth_value, 8);
mesh_beacon_len = SECURE_NETWORK_BEACON_LEN;
printf("Secure Network Beacon\n");
@ -152,7 +153,7 @@ static void mesh_secure_network_beacon_setup(mesh_subnet_t * mesh_subnet){
mesh_beacon_data[1] = mesh_secure_network_beacon_get_flags(mesh_subnet);
// TODO: pick correct key based on key refresh phase
memcpy(&mesh_beacon_data[2], mesh_subnet->old_key->network_id, 8);
(void)memcpy(&mesh_beacon_data[2], mesh_subnet->old_key->network_id, 8);
big_endian_store_32(mesh_beacon_data, 10, mesh_get_iv_index());
mesh_network_key_t * network_key = mesh_subnet_get_outgoing_network_key(mesh_subnet);
btstack_crypto_aes128_cmac_message(&mesh_secure_network_beacon_cmac_request, network_key->beacon_key, 13,
@ -325,7 +326,8 @@ static void beacon_handle_secure_beacon(uint8_t * packet, uint16_t size){
if (mesh_secure_network_beacon_active) return;
mesh_secure_network_beacon_active = 1;
memcpy(mesh_secure_network_beacon_validate_buffer, &packet[0], SECURE_NETWORK_BEACON_LEN);
(void)memcpy(mesh_secure_network_beacon_validate_buffer, &packet[0],
SECURE_NETWORK_BEACON_LEN);
btstack_crypto_aes128_cmac_message(&mesh_secure_network_beacon_cmac_request, network_key->beacon_key, 13,
&mesh_secure_network_beacon_validate_buffer[1], mesh_secure_network_beacon_auth_value, &beacon_handle_secure_beacon_auth_value_calculated, subnet);

12
src/mesh/gatt_bearer.c
View File

@ -129,7 +129,8 @@ static void gatt_bearer_request(mesh_msg_type_t type_id){
static void gatt_bearer_start_sending(hci_con_handle_t con_handle){
uint16_t pdu_segment_len = btstack_min(proxy_pdu_size - segmentation_offset, gatt_bearer_mtu - 1 - 3);
sar_buffer.segmentation_buffer[0] = (segmentation_state << 6) | msg_type;
memcpy(&sar_buffer.segmentation_buffer[1], &proxy_pdu[segmentation_offset], pdu_segment_len);
(void)memcpy(&sar_buffer.segmentation_buffer[1],
&proxy_pdu[segmentation_offset], pdu_segment_len);
segmentation_offset += pdu_segment_len;
mesh_proxy_service_server_send_proxy_pdu(con_handle, sar_buffer.segmentation_buffer, pdu_segment_len + 1);
@ -203,17 +204,20 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case MESH_MSG_SAR_FIELD_FIRST_SEGMENT:
memset(sar_buffer.reassembly_buffer, 0, sizeof(sar_buffer.reassembly_buffer));
if (sizeof(sar_buffer.reassembly_buffer) < pdu_segment_len) return;
memcpy(sar_buffer.reassembly_buffer, packet+pos, pdu_segment_len);
(void)memcpy(sar_buffer.reassembly_buffer, packet + pos,
pdu_segment_len);
reassembly_offset = pdu_segment_len;
break;
case MESH_MSG_SAR_FIELD_CONTINUE:
if ((sizeof(sar_buffer.reassembly_buffer) - reassembly_offset) < pdu_segment_len) return;
memcpy(sar_buffer.reassembly_buffer + reassembly_offset, packet+pos, pdu_segment_len);
(void)memcpy(sar_buffer.reassembly_buffer + reassembly_offset,
packet + pos, pdu_segment_len);
reassembly_offset += pdu_segment_len;
return;
case MESH_MSG_SAR_FIELD_LAST_SEGMENT:
if ((sizeof(sar_buffer.reassembly_buffer) - reassembly_offset) < pdu_segment_len) return;
memcpy(sar_buffer.reassembly_buffer + reassembly_offset, packet+pos, pdu_segment_len);
(void)memcpy(sar_buffer.reassembly_buffer + reassembly_offset,
packet + pos, pdu_segment_len);
reassembly_offset += pdu_segment_len;
break;
default:

38
src/mesh/mesh.c
View File

@ -381,7 +381,7 @@ static void mesh_store_virtual_address(uint16_t pseudo_dest, uint16_t hash, cons
mesh_persistent_virtual_address_t data;
uint32_t tag = mesh_virtual_address_tag_for_pseudo_dst(pseudo_dest);
data.hash = hash;
memcpy(data.label_uuid, label_uuid, 16);
(void)memcpy(data.label_uuid, label_uuid, 16);
int result = btstack_tlv_singleton_impl->store_tag(btstack_tlv_singleton_context, tag, (uint8_t *) &data, sizeof(data));
report_store_error(result, "virtual address");
}
@ -405,7 +405,7 @@ void mesh_load_virtual_addresses(void){
virtual_address->pseudo_dst = pseudo_dst;
virtual_address->hash = data.hash;
memcpy(virtual_address->label_uuid, data.label_uuid, 16);
(void)memcpy(virtual_address->label_uuid, data.label_uuid, 16);
mesh_virtual_address_add(virtual_address);
}
}
@ -605,14 +605,14 @@ void mesh_store_network_key(mesh_network_key_t * network_key){
printf_hexdump(network_key->net_key, 16);
uint32_t tag = mesh_network_key_tag_for_internal_index(network_key->internal_index);
data.netkey_index = network_key->netkey_index;
memcpy(data.net_key, network_key->net_key, 16);
memcpy(data.identity_key, network_key->identity_key, 16);
memcpy(data.beacon_key, network_key->beacon_key, 16);
memcpy(data.network_id, network_key->network_id, 8);
(void)memcpy(data.net_key, network_key->net_key, 16);
(void)memcpy(data.identity_key, network_key->identity_key, 16);
(void)memcpy(data.beacon_key, network_key->beacon_key, 16);
(void)memcpy(data.network_id, network_key->network_id, 8);
data.nid = network_key->nid;
data.version = network_key->version;
memcpy(data.encryption_key, network_key->encryption_key, 16);
memcpy(data.privacy_key, network_key->privacy_key, 16);
(void)memcpy(data.encryption_key, network_key->encryption_key, 16);
(void)memcpy(data.privacy_key, network_key->privacy_key, 16);
int result = btstack_tlv_singleton_impl->store_tag(btstack_tlv_singleton_context, tag, (uint8_t *) &data, sizeof(mesh_persistent_net_key_t));
report_store_error(result, "network key");
}
@ -636,14 +636,14 @@ void mesh_load_network_keys(void){
network_key->internal_index = internal_index;
network_key->netkey_index = data.netkey_index;
memcpy(network_key->net_key, data.net_key, 16);
memcpy(network_key->identity_key, data.identity_key, 16);
memcpy(network_key->beacon_key, data.beacon_key, 16);
memcpy(network_key->network_id, data.network_id, 8);
(void)memcpy(network_key->net_key, data.net_key, 16);
(void)memcpy(network_key->identity_key, data.identity_key, 16);
(void)memcpy(network_key->beacon_key, data.beacon_key, 16);
(void)memcpy(network_key->network_id, data.network_id, 8);
network_key->nid = data.nid;
network_key->version = data.version;
memcpy(network_key->encryption_key, data.encryption_key, 16);
memcpy(network_key->privacy_key, data.privacy_key, 16);
(void)memcpy(network_key->encryption_key, data.encryption_key, 16);
(void)memcpy(network_key->privacy_key, data.privacy_key, 16);
#ifdef ENABLE_GATT_BEARER
// setup advertisement with network id
@ -686,7 +686,7 @@ void mesh_store_app_key(mesh_transport_key_t * app_key){
data.appkey_index = app_key->appkey_index;
data.aid = app_key->aid;
data.version = app_key->version;
memcpy(data.key, app_key->key, 16);
(void)memcpy(data.key, app_key->key, 16);
int result = btstack_tlv_singleton_impl->store_tag(btstack_tlv_singleton_context, tag, (uint8_t *) &data, sizeof(data));
report_store_error(result, "app key");
}
@ -714,7 +714,7 @@ void mesh_load_app_keys(void){
key->aid = data.aid;
key->akf = 1;
key->version = data.version;
memcpy(key->key, data.key, 16);
(void)memcpy(key->key, data.key, 16);
mesh_transport_key_add(key);
printf("- internal index 0x%x, AppKey Index 0x%06x, AID %02x: ", key->internal_index, key->appkey_index, key->aid);
printf_hexdump(key->key, 16);
@ -1035,7 +1035,8 @@ static void mesh_node_store_provisioning_data(mesh_provisioning_data_t * provisi
persistent_provisioning_data.unicast_address = provisioning_data->unicast_address;
persistent_provisioning_data.flags = provisioning_data->flags;
memcpy(persistent_provisioning_data.device_key, provisioning_data->device_key, 16);
(void)memcpy(persistent_provisioning_data.device_key,
provisioning_data->device_key, 16);
// store in tlv
btstack_tlv_get_instance(&btstack_tlv_singleton_impl, &btstack_tlv_singleton_context);
@ -1087,7 +1088,8 @@ static int mesh_node_startup_from_tlv(void){
// copy into mesh_provisioning_data
mesh_provisioning_data_t provisioning_data;
memcpy(provisioning_data.device_key, persistent_provisioning_data.device_key, 16);
(void)memcpy(provisioning_data.device_key,
persistent_provisioning_data.device_key, 16);
provisioning_data.unicast_address = persistent_provisioning_data.unicast_address;
provisioning_data.flags = persistent_provisioning_data.flags;
provisioning_data.network_key = NULL;

4
src/mesh/mesh_access.c
View File

@ -565,12 +565,12 @@ void mesh_access_parser_get_u128(mesh_access_parser_state_t * state, uint8_t * d
}
void mesh_access_parser_get_label_uuid(mesh_access_parser_state_t * state, uint8_t * dest){
memcpy( dest, state->data, 16);
(void)memcpy(dest, state->data, 16);
mesh_access_parser_skip(state, 16);
}
void mesh_access_parser_get_key(mesh_access_parser_state_t * state, uint8_t * dest){
memcpy( dest, state->data, 16);
(void)memcpy(dest, state->data, 16);
mesh_access_parser_skip(state, 16);
}

14
src/mesh/mesh_configuration_server.c
View File

@ -659,7 +659,7 @@ static void config_netkey_add_handler(mesh_model_t * mesh_model, mesh_pdu_t * pd
// setup key
new_network_key->internal_index = internal_index;
new_network_key->netkey_index = new_netkey_index;
memcpy(new_network_key->net_key, new_netkey, 16);
(void)memcpy(new_network_key->net_key, new_netkey, 16);
// setup subnet
new_subnet->old_key = new_network_key;
@ -743,7 +743,7 @@ static void config_netkey_update_handler(mesh_model_t * mesh_model, mesh_pdu_t *
new_network_key->internal_index = internal_index;
new_network_key->netkey_index = netkey_index;
new_network_key->version = (uint8_t)(subnet->old_key->version + 1);
memcpy(new_network_key->net_key, new_netkey, 16);
(void)memcpy(new_network_key->net_key, new_netkey, 16);
// store in subnet (not active yet)
subnet->new_key = new_network_key;
@ -928,7 +928,7 @@ static void config_appkey_add_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu
app_key->version = 0;
app_key->old_key = 0;
memcpy(app_key->key, appkey, 16);
(void)memcpy(app_key->key, appkey, 16);
// calculate AID
access_pdu_in_process = pdu;
@ -999,7 +999,7 @@ static void config_appkey_update_handler(mesh_model_t *mesh_model, mesh_pdu_t *
new_app_key->netkey_index = netkey_index;
new_app_key->key_refresh = 1;
new_app_key->version = (uint8_t)(existing_app_key->version + 1);
memcpy(new_app_key->key, appkey, 16);
(void)memcpy(new_app_key->key, appkey, 16);
// mark old key
existing_app_key->old_key = 1;
@ -1873,7 +1873,8 @@ static void config_heartbeat_publication_set_handler(mesh_model_t *mesh_model, m
}
// accept update
memcpy(mesh_heartbeat_publication, &requested_publication, sizeof(mesh_heartbeat_publication_t));
(void)memcpy(mesh_heartbeat_publication, &requested_publication,
sizeof(mesh_heartbeat_publication_t));
}
config_heartbeat_publication_status(mesh_model, mesh_pdu_netkey_index(pdu), mesh_pdu_src(pdu), status, mesh_heartbeat_publication);
@ -2032,7 +2033,8 @@ static uint32_t config_heartbeat_subscription_get_period_remaining_s(mesh_heartb
static void config_heartbeat_subscription_get_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu) {
mesh_heartbeat_subscription_t * mesh_heartbeat_subscription = &((mesh_configuration_server_model_context_t*) mesh_model->model_data)->heartbeat_subscription;
mesh_heartbeat_subscription_t subscription;
memcpy(&subscription, mesh_heartbeat_subscription, sizeof(subscription));
(void)memcpy(&subscription, mesh_heartbeat_subscription,
sizeof(subscription));
if (mesh_heartbeat_subscription->source == MESH_ADDRESS_UNSASSIGNED || mesh_heartbeat_subscription->destination == MESH_ADDRESS_UNSASSIGNED){
memset(&subscription, 0, sizeof(subscription));
} else {

15
src/mesh/mesh_crypto.c
View File

@ -83,7 +83,7 @@ static void mesh_k2_callback_d(void * arg){
log_info("PrivacyKey: ");
log_info_hexdump(mesh_k2_t, 16);
// collect result
memcpy(&mesh_k2_result[17], mesh_k2_t2, 16);
(void)memcpy(&mesh_k2_result[17], mesh_k2_t2, 16);
//
(*mesh_k2_callback)(mesh_k2_arg);
}
@ -92,9 +92,9 @@ static void mesh_k2_callback_c(void * arg){
log_info("EncryptionKey: ");
log_info_hexdump(mesh_k2_t, 16);
// collect result
memcpy(&mesh_k2_result[1], mesh_k2_t2, 16);
(void)memcpy(&mesh_k2_result[1], mesh_k2_t2, 16);
//
memcpy(mesh_k2_t1, mesh_k2_t2, 16);
(void)memcpy(mesh_k2_t1, mesh_k2_t2, 16);
mesh_k2_t1[16] = 0; // p
mesh_k2_t1[17] = 0x03;
btstack_crypto_aes128_cmac_message(request, mesh_k2_t, 18, mesh_k2_t1, mesh_k2_t2, mesh_k2_callback_d, request);
@ -105,7 +105,7 @@ static void mesh_k2_callback_b(void * arg){
// collect result
mesh_k2_result[0] = mesh_k2_t2[15] & 0x7f;
//
memcpy(mesh_k2_t1, mesh_k2_t2, 16);
(void)memcpy(mesh_k2_t1, mesh_k2_t2, 16);
mesh_k2_t1[16] = 0; // p
mesh_k2_t1[17] = 0x02;
btstack_crypto_aes128_cmac_message(request, mesh_k2_t, 18, mesh_k2_t1, mesh_k2_t2, mesh_k2_callback_c, request);
@ -140,7 +140,7 @@ static const uint8_t mesh_salt_smk3[] = { 0x00, 0x36, 0x44, 0x35, 0x03, 0xf1, 0x
static void mesh_k3_result128_calculated(void * arg){
UNUSED(arg);
memcpy(mesh_k3_result, &mesh_k3_result128[8], 8);
(void)memcpy(mesh_k3_result, &mesh_k3_result128[8], 8);
(*mesh_k3_callback)(mesh_k3_arg);
}
static void mesh_k3_temp_callback(void * arg){
@ -237,8 +237,9 @@ static void mesh_network_key_derive_network_id_calculated(void * arg) {
static void mesh_network_key_derive_k2_calculated(void * arg){
// store
mesh_network_key_derive_key->nid = k2_result[0];
memcpy(mesh_network_key_derive_key->encryption_key, &k2_result[1], 16);
memcpy(mesh_network_key_derive_key->privacy_key, &k2_result[17], 16);
(void)memcpy(mesh_network_key_derive_key->encryption_key, &k2_result[1],
16);
(void)memcpy(mesh_network_key_derive_key->privacy_key, &k2_result[17], 16);
// calculate Network ID / k3
btstack_crypto_aes128_cmac_t * request = (btstack_crypto_aes128_cmac_t*) arg;

2
src/mesh/mesh_keys.c
View File

@ -138,7 +138,7 @@ void mesh_transport_set_device_key(const uint8_t * device_key){
mesh_transport_device_key.aid = 0;
mesh_transport_device_key.akf = 0;
mesh_transport_device_key.netkey_index = 0; // unused
memcpy(mesh_transport_device_key.key, device_key, 16);
(void)memcpy(mesh_transport_device_key.key, device_key, 16);
// use internal slot #0
mesh_transport_device_key.internal_index = 0;

7
src/mesh/mesh_lower_transport.c
View File

@ -422,7 +422,7 @@ static mesh_transport_pdu_t * mesh_lower_transport_pdu_for_segmented_message(mes
if (!pdu) return NULL;
// cache network pdu header
memcpy(pdu->network_header, network_pdu->data, 9);
(void)memcpy(pdu->network_header, network_pdu->data, 9);
// store lower 24 bit of SeqAuth for App / Device Nonce
big_endian_store_24(pdu->network_header, 2, seq_auth);
@ -476,7 +476,7 @@ static void mesh_lower_transport_process_segment( mesh_transport_pdu_t * transpo
#endif
// store segment
memcpy(&transport_pdu->data[seg_o * 12], segment_data, 12);
(void)memcpy(&transport_pdu->data[seg_o * 12], segment_data, 12);
// mark as received
transport_pdu->block_ack |= (1<<seg_o);
// last segment -> store len
@ -590,7 +590,8 @@ static void mesh_lower_transport_setup_segment(mesh_transport_pdu_t *transport_p
lower_transport_pdu_data[0] = 0x80 | transport_pdu->akf_aid_control;
big_endian_store_24(lower_transport_pdu_data, 1, (szmic << 23) | (seq_zero << 10) | (seg_o << 5) | seg_n);
uint16_t segment_len = btstack_min(transport_pdu->len - seg_offset, max_segment_len);
memcpy(&lower_transport_pdu_data[4], &transport_pdu->data[seg_offset], segment_len);
(void)memcpy(&lower_transport_pdu_data[4],
&transport_pdu->data[seg_offset], segment_len);
uint16_t lower_transport_pdu_len = 4 + segment_len;
mesh_network_setup_pdu(network_pdu, transport_pdu->netkey_index, nid, 0, ttl, seq, src, dest, lower_transport_pdu_data, lower_transport_pdu_len);

20
src/mesh/mesh_network.c
View File

@ -237,7 +237,7 @@ int mesh_network_addresses_valid(uint8_t ctl, uint16_t src, uint16_t dst){
static void mesh_network_create_nonce(uint8_t * nonce, const mesh_network_pdu_t * pdu, uint32_t iv_index){
unsigned int pos = 0;
nonce[pos++] = 0x0; // Network Nonce
memcpy(&nonce[pos], &pdu->data[1], 6);
(void)memcpy(&nonce[pos], &pdu->data[1], 6);
pos += 6;
big_endian_store_16(nonce, pos, 0);
pos += 2;
@ -248,7 +248,7 @@ static void mesh_proxy_create_nonce(uint8_t * nonce, const mesh_network_pdu_t *
unsigned int pos = 0;
nonce[pos++] = 0x3; // Proxy Nonce
nonce[pos++] = 0;
memcpy(&nonce[pos], &pdu->data[2], 5);
(void)memcpy(&nonce[pos], &pdu->data[2], 5);
pos += 5;
big_endian_store_16(nonce, pos, 0);
pos += 2;
@ -321,7 +321,7 @@ static void mesh_network_send_b(void *arg){
// store MIC
uint8_t net_mic_len = outgoing_pdu->data[1] & 0x80 ? 8 : 4;
memcpy(&outgoing_pdu->data[outgoing_pdu->len], net_mic, net_mic_len);
(void)memcpy(&outgoing_pdu->data[outgoing_pdu->len], net_mic, net_mic_len);
outgoing_pdu->len += net_mic_len;
btstack_assert(outgoing_pdu->len <= 29);
@ -334,7 +334,7 @@ static void mesh_network_send_b(void *arg){
// calc PECB
memset(encryption_block, 0, 5);
big_endian_store_32(encryption_block, 5, iv_index);
memcpy(&encryption_block[9], &outgoing_pdu->data[7], 7);
(void)memcpy(&encryption_block[9], &outgoing_pdu->data[7], 7);
btstack_crypto_aes128_encrypt(&mesh_network_crypto_request.aes128, current_network_key->privacy_key, encryption_block, obfuscation_block, &mesh_network_send_c, NULL);
}
@ -494,7 +494,8 @@ static void process_network_pdu_validate_d(void * arg){
printf_hexdump(net_mic, net_mic_len);
#endif
// store in decoded pdu
memcpy(&incoming_pdu_decoded->data[incoming_pdu_decoded->len-net_mic_len], net_mic, net_mic_len);
(void)memcpy(&incoming_pdu_decoded->data[incoming_pdu_decoded->len - net_mic_len],
net_mic, net_mic_len);
#ifdef LOG_NETWORK
uint8_t cypher_len = incoming_pdu_decoded->len - 9 - net_mic_len;
@ -661,7 +662,7 @@ static void process_network_pdu_validate(void){
uint32_t iv_index = iv_index_for_pdu(incoming_pdu_raw);
memset(encryption_block, 0, 5);
big_endian_store_32(encryption_block, 5, iv_index);
memcpy(&encryption_block[9], &incoming_pdu_raw->data[7], 7);
(void)memcpy(&encryption_block[9], &incoming_pdu_raw->data[7], 7);
btstack_crypto_aes128_encrypt(&mesh_network_crypto_request.aes128, current_network_key->privacy_key, encryption_block, obfuscation_block, &process_network_pdu_validate_b, NULL);
}
@ -1017,7 +1018,7 @@ void mesh_network_received_message(const uint8_t * pdu_data, uint8_t pdu_len, ui
if (!network_pdu) return;
// store data
memcpy(network_pdu->data, pdu_data, pdu_len);
(void)memcpy(network_pdu->data, pdu_data, pdu_len);
network_pdu->len = pdu_len;
network_pdu->flags = flags;
@ -1036,7 +1037,7 @@ void mesh_network_process_proxy_configuration_message(const uint8_t * pdu_data,
if (!network_pdu) return;
// store data
memcpy(network_pdu->data, pdu_data, pdu_len);
(void)memcpy(network_pdu->data, pdu_data, pdu_len);
network_pdu->len = pdu_len;
network_pdu->flags = MESH_NETWORK_PDU_FLAGS_PROXY_CONFIGURATION; // Network PDU
@ -1106,7 +1107,8 @@ void mesh_network_setup_pdu(mesh_network_pdu_t * network_pdu, uint16_t netkey_in
network_pdu->len += 2;
big_endian_store_16(network_pdu->data, network_pdu->len, dest);
network_pdu->len += 2;
memcpy(&network_pdu->data[network_pdu->len], transport_pdu_data, transport_pdu_len);
(void)memcpy(&network_pdu->data[network_pdu->len], transport_pdu_data,
transport_pdu_len);
network_pdu->len += transport_pdu_len;
}

2
src/mesh/mesh_node.c
View File

@ -250,7 +250,7 @@ int mesh_model_contains_subscription(mesh_model_t * mesh_model, uint16_t address
}
void mesh_node_set_device_uuid(const uint8_t * device_uuid){
memcpy(mesh_node_device_uuid, device_uuid, 16);
(void)memcpy(mesh_node_device_uuid, device_uuid, 16);
mesh_node_have_device_uuid = 1;
}

22
src/mesh/mesh_proxy.c
View File

@ -125,9 +125,11 @@ static void mesh_proxy_setup_advertising_unprovisioned(adv_bearer_connectable_ad
// store in advertisement item
memset(advertisement_item, 0, sizeof(adv_bearer_connectable_advertisement_data_item_t));
advertisement_item->adv_length = adv_data_unprovisioned_template_len + 18;
memcpy(advertisement_item->adv_data, (uint8_t*) adv_data_unprovisioned_template, adv_data_unprovisioned_template_len);
(void)memcpy(advertisement_item->adv_data,
(uint8_t *)adv_data_unprovisioned_template,
adv_data_unprovisioned_template_len);
// dynamically store device uuid into adv data
memcpy(&advertisement_item->adv_data[11], device_uuid, 16);
(void)memcpy(&advertisement_item->adv_data[11], device_uuid, 16);
little_endian_store_16(advertisement_item->adv_data, 27, 0);
}
@ -150,8 +152,8 @@ void mesh_proxy_stop_advertising_unprovisioned_device(void){
#endif
static uint8_t mesh_proxy_setup_advertising_with_network_id(uint8_t * buffer, uint8_t * network_id){
memcpy(&buffer[0], adv_data_with_network_id_template, 12);
memcpy(&buffer[12], network_id, 8);
(void)memcpy(&buffer[0], adv_data_with_network_id_template, 12);
(void)memcpy(&buffer[12], network_id, 8);
return 20;
}
@ -181,9 +183,12 @@ static void mesh_proxy_node_id_timeout_handler(btstack_timer_source_t * ts){
static void mesh_proxy_node_id_handle_get_aes128(void * arg){
mesh_subnet_t * mesh_subnet = (mesh_subnet_t *) arg;
memcpy(mesh_subnet->advertisement_with_node_id.adv_data, adv_data_with_node_id_template, 12);
memcpy(&mesh_subnet->advertisement_with_node_id.adv_data[12], &mesh_proxy_node_id_hash[8], 8);
memcpy(&mesh_subnet->advertisement_with_node_id.adv_data[20], mesh_proxy_node_id_random_value, 8);
(void)memcpy(mesh_subnet->advertisement_with_node_id.adv_data,
adv_data_with_node_id_template, 12);
(void)memcpy(&mesh_subnet->advertisement_with_node_id.adv_data[12],
&mesh_proxy_node_id_hash[8], 8);
(void)memcpy(&mesh_subnet->advertisement_with_node_id.adv_data[20],
mesh_proxy_node_id_random_value, 8);
mesh_subnet->advertisement_with_node_id.adv_length = 28;
// setup advertisements
@ -208,7 +213,8 @@ static void mesh_proxy_node_id_handle_random(void * arg){
// Hash = e(IdentityKey, Padding | Random | Address) mod 2^64
memset(mesh_proxy_node_id_plaintext, 0, sizeof(mesh_proxy_node_id_plaintext));
memcpy(&mesh_proxy_node_id_plaintext[6] , mesh_proxy_node_id_random_value, 8);
(void)memcpy(&mesh_proxy_node_id_plaintext[6],
mesh_proxy_node_id_random_value, 8);
big_endian_store_16(mesh_proxy_node_id_plaintext, 14, primary_element_address);
// TODO: old vs. new key
btstack_crypto_aes128_encrypt(&mesh_proxy_node_id_crypto_request_aes128, mesh_subnet->old_key->identity_key, mesh_proxy_node_id_plaintext, mesh_proxy_node_id_hash, mesh_proxy_node_id_handle_get_aes128, mesh_subnet);

19
src/mesh/mesh_upper_transport.c
View File

@ -251,13 +251,13 @@ static uint32_t iv_index_for_ivi_nid(uint8_t ivi_nid){
static void transport_unsegmented_setup_nonce(uint8_t * nonce, const mesh_network_pdu_t * network_pdu){
nonce[1] = 0x00; // SZMIC if a Segmented Access message or 0 for all other message formats
memcpy(&nonce[2], &network_pdu->data[2], 7);
(void)memcpy(&nonce[2], &network_pdu->data[2], 7);
big_endian_store_32(nonce, 9, iv_index_for_ivi_nid(network_pdu->data[0]));
}
static void transport_segmented_setup_nonce(uint8_t * nonce, const mesh_transport_pdu_t * transport_pdu){
nonce[1] = transport_pdu->transmic_len == 8 ? 0x80 : 0x00;
memcpy(&nonce[2], &transport_pdu->network_header[2], 7);
(void)memcpy(&nonce[2], &transport_pdu->network_header[2], 7);
big_endian_store_32(nonce, 9, iv_index_for_ivi_nid(transport_pdu->network_header[0]));
}
@ -505,7 +505,9 @@ static void mesh_upper_transport_validate_segmented_message(void){
static void mesh_upper_transport_process_unsegmented_access_message(void){
// copy original pdu
incoming_network_pdu_decoded->len = incoming_network_pdu_raw->len;
memcpy(incoming_network_pdu_decoded->data, incoming_network_pdu_raw->data, incoming_network_pdu_decoded->len);
(void)memcpy(incoming_network_pdu_decoded->data,
incoming_network_pdu_raw->data,
incoming_network_pdu_decoded->len);
//
uint8_t * lower_transport_pdu = &incoming_network_pdu_raw->data[9];
@ -525,7 +527,8 @@ static void mesh_upper_transport_process_unsegmented_access_message(void){
static void mesh_upper_transport_process_message(void){
// copy original pdu
memcpy(incoming_transport_pdu_decoded, incoming_transport_pdu_raw, sizeof(mesh_transport_pdu_t));
(void)memcpy(incoming_transport_pdu_decoded, incoming_transport_pdu_raw,
sizeof(mesh_transport_pdu_t));
//
uint8_t * upper_transport_pdu = incoming_transport_pdu_decoded->data;
@ -623,7 +626,7 @@ static uint8_t mesh_upper_transport_setup_unsegmented_control_pdu(mesh_network_p
uint8_t transport_pdu_data[12];
transport_pdu_data[0] = opcode;
memcpy(&transport_pdu_data[1], control_pdu_data, control_pdu_len);
(void)memcpy(&transport_pdu_data[1], control_pdu_data, control_pdu_len);
uint16_t transport_pdu_len = control_pdu_len + 1;
// setup network_pdu
@ -640,7 +643,7 @@ static uint8_t mesh_upper_transport_setup_segmented_control_pdu(mesh_transport_p
const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index);
if (!network_key) return 1;
memcpy(transport_pdu->data, control_pdu_data, control_pdu_len);
(void)memcpy(transport_pdu->data, control_pdu_data, control_pdu_len);
transport_pdu->len = control_pdu_len;
transport_pdu->netkey_index = netkey_index;
transport_pdu->akf_aid_control = opcode;
@ -695,7 +698,7 @@ static uint8_t mesh_upper_transport_setup_unsegmented_access_pdu(mesh_network_pd
if (status) return status;
// store in transport pdu
memcpy(&network_pdu->data[10], access_pdu_data, access_pdu_len);
(void)memcpy(&network_pdu->data[10], access_pdu_data, access_pdu_len);
network_pdu->len = 10 + access_pdu_len;
return 0;
}
@ -741,7 +744,7 @@ static uint8_t mesh_upper_transport_setup_segmented_access_pdu(mesh_transport_pd
if (status) return status;
// store in transport pdu
memcpy(transport_pdu->data, access_pdu_data, access_pdu_len);
(void)memcpy(transport_pdu->data, access_pdu_data, access_pdu_len);
transport_pdu->len = access_pdu_len;
return 0;
}

2
src/mesh/mesh_virtual_addresses.c
View File

@ -81,7 +81,7 @@ mesh_virtual_address_t * mesh_virtual_address_register(uint8_t * label_uuid, uin
virtual_address->hash = hash;
virtual_address->pseudo_dst = pseudo_dst;
memcpy(virtual_address->label_uuid, label_uuid, 16);
(void)memcpy(virtual_address->label_uuid, label_uuid, 16);
mesh_virtual_address_add(virtual_address);
return virtual_address;

10
src/mesh/pb_adv.c
View File

@ -282,7 +282,7 @@ static void pb_adv_handle_transaction_start(uint8_t transaction_nr, const uint8_
// store payload
uint16_t payload_len = size - 4;
memcpy(pb_adv_msg_in_buffer, &pdu[4], payload_len);
(void)memcpy(pb_adv_msg_in_buffer, &pdu[4], payload_len);
// complete?
if (pb_adv_msg_in_segments_missing == 0){
@ -330,7 +330,7 @@ static void pb_adv_handle_transaction_cont(uint8_t transaction_nr, const uint8_t
}
// store segment and mark as received
memcpy(&pb_adv_msg_in_buffer[msg_pos], &pdu[1], fragment_size);
(void)memcpy(&pb_adv_msg_in_buffer[msg_pos], &pdu[1], fragment_size);
pb_adv_msg_in_segments_missing &= ~seg_mask;
// last segment
@ -458,7 +458,7 @@ static void pb_adv_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
big_endian_store_32(buffer, 0, pb_adv_link_id);
buffer[4] = 0; // Transaction ID = 0
buffer[5] = (0 << 2) | 3; // Link Open | Provisioning Bearer Control
memcpy(&buffer[6], pb_adv_peer_device_uuid, 16);
(void)memcpy(&buffer[6], pb_adv_peer_device_uuid, 16);
adv_bearer_send_provisioning_pdu(buffer, sizeof(buffer));
log_info("link open %08x", pb_adv_link_id);
printf("PB-ADV: Sending Link Open for device uuid: ");
@ -547,7 +547,9 @@ static void pb_adv_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
}
pb_adv_msg_out_seg++;
uint16_t bytes_to_copy = btstack_min(bytes_left, pb_adv_msg_out_len - pb_adv_msg_out_pos);
memcpy(&buffer[pos], &pb_adv_msg_out_buffer[pb_adv_msg_out_pos], bytes_to_copy);
(void)memcpy(&buffer[pos],
&pb_adv_msg_out_buffer[pb_adv_msg_out_pos],
bytes_to_copy);
pos += bytes_to_copy;
printf("bytes %02u, pos %02u, len %02u: ", bytes_to_copy, pb_adv_msg_out_pos, pb_adv_msg_out_len);
printf_hexdump(buffer, pos);

13
src/mesh/pb_gatt.c
View File

@ -110,15 +110,18 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
switch (msg_sar_field){
case MESH_MSG_SAR_FIELD_FIRST_SEGMENT:
memset(sar_buffer.reassembly_buffer, 0, sizeof(sar_buffer.reassembly_buffer));
memcpy(sar_buffer.reassembly_buffer, packet+pos, pdu_segment_len);
(void)memcpy(sar_buffer.reassembly_buffer, packet + pos,
pdu_segment_len);
reassembly_offset = pdu_segment_len;
return;
case MESH_MSG_SAR_FIELD_CONTINUE:
memcpy(sar_buffer.reassembly_buffer + reassembly_offset, packet+pos, pdu_segment_len);
(void)memcpy(sar_buffer.reassembly_buffer + reassembly_offset,
packet + pos, pdu_segment_len);
reassembly_offset += pdu_segment_len;
return;
case MESH_MSG_SAR_FIELD_LAST_SEGMENT:
memcpy(sar_buffer.reassembly_buffer + reassembly_offset, packet+pos, pdu_segment_len);
(void)memcpy(sar_buffer.reassembly_buffer + reassembly_offset,
packet + pos, pdu_segment_len);
reassembly_offset += pdu_segment_len;
// send to provisioning device
pb_gatt_packet_handler(PROVISIONING_DATA_PACKET, 0, sar_buffer.reassembly_buffer, reassembly_offset);
@ -147,7 +150,9 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
sar_buffer.segmentation_buffer[0] = (segmentation_state << 6) | MESH_MSG_TYPE_PROVISIONING_PDU;
pdu_segment_len = btstack_min(proxy_pdu_size - segmentation_offset, pb_gatt_mtu - 1);
memcpy(&sar_buffer.segmentation_buffer[1], &proxy_pdu[segmentation_offset], pdu_segment_len);
(void)memcpy(&sar_buffer.segmentation_buffer[1],
&proxy_pdu[segmentation_offset],
pdu_segment_len);
segmentation_offset += pdu_segment_len;
mesh_provisioning_service_server_send_proxy_pdu(con_handle, sar_buffer.segmentation_buffer, pdu_segment_len + 1);

49
src/mesh/provisioning_device.c
View File

@ -267,7 +267,7 @@ static void provisioning_send_capabilites(void){
big_endian_store_16(prov_buffer_out, 10, prov_input_oob_actions);
// store for confirmation inputs: len 11
memcpy(&prov_confirmation_inputs[1], &prov_buffer_out[1], 11);
(void)memcpy(&prov_confirmation_inputs[1], &prov_buffer_out[1], 11);
// send
@ -277,10 +277,10 @@ static void provisioning_send_capabilites(void){
static void provisioning_send_public_key(void){
// setup response
prov_buffer_out[0] = MESH_PROV_PUB_KEY;
memcpy(&prov_buffer_out[1], prov_ec_q, 64);
(void)memcpy(&prov_buffer_out[1], prov_ec_q, 64);
// store for confirmation inputs: len 64
memcpy(&prov_confirmation_inputs[81], &prov_buffer_out[1], 64);
(void)memcpy(&prov_confirmation_inputs[81], &prov_buffer_out[1], 64);
// send
pb_send_pdu(pb_transport_cid, prov_buffer_out, 65);
@ -296,7 +296,7 @@ static void provisioning_send_input_complete(void){
static void provisioning_send_confirm(void){
// setup response
prov_buffer_out[0] = MESH_PROV_CONFIRM;
memcpy(&prov_buffer_out[1], confirmation_device, 16);
(void)memcpy(&prov_buffer_out[1], confirmation_device, 16);
// send
pb_send_pdu(pb_transport_cid, prov_buffer_out, 17);
@ -305,7 +305,7 @@ static void provisioning_send_confirm(void){
static void provisioning_send_random(void){
// setup response
prov_buffer_out[0] = MESH_PROV_RANDOM;
memcpy(&prov_buffer_out[1], random_device, 16);
(void)memcpy(&prov_buffer_out[1], random_device, 16);
// send pdu
pb_send_pdu(pb_transport_cid, prov_buffer_out, 17);
@ -362,7 +362,8 @@ static void provisioning_public_key_exchange_complete(void){
device_state = DEVICE_W4_CONFIRM;
break;
case 0x01:
memcpy(&auth_value[16-prov_static_oob_len], prov_static_oob_data, prov_static_oob_len);
(void)memcpy(&auth_value[16 - prov_static_oob_len],
prov_static_oob_data, prov_static_oob_len);
device_state = DEVICE_W4_CONFIRM;
break;
case 0x02:
@ -445,7 +446,7 @@ static void provisioning_handle_invite(uint8_t *packet, uint16_t size){
if (size != 1) return;
// store for confirmation inputs: len 1
memcpy(&prov_confirmation_inputs[0], packet, 1);
(void)memcpy(&prov_confirmation_inputs[0], packet, 1);
// handle invite message
prov_attention_timer_timeout = packet[0];
@ -499,7 +500,7 @@ static void provisioning_handle_start(uint8_t * packet, uint16_t size){
}
// store for confirmation inputs: len 5
memcpy(&prov_confirmation_inputs[12], packet, 5);
(void)memcpy(&prov_confirmation_inputs[12], packet, 5);
// public key oob
prov_public_key_oob_used = packet[1];
@ -528,7 +529,7 @@ static void provisioning_handle_public_key_dhkey(void * arg){
// skip sending own public key when public key oob is used
if (prov_public_key_oob_available && prov_public_key_oob_used){
// just copy key for confirmation inputs
memcpy(&prov_confirmation_inputs[81], prov_ec_q, 64);
(void)memcpy(&prov_confirmation_inputs[81], prov_ec_q, 64);
provisioning_public_key_exchange_complete();
} else {
// queue public key pdu
@ -552,16 +553,16 @@ static void provisioning_handle_public_key(uint8_t *packet, uint16_t size){
provisioning_emit_event(1, MESH_SUBEVENT_PB_PROV_STOP_EMIT_PUBLIC_KEY_OOB);
printf("Replace generated ECC with Public Key OOB:");
memcpy(prov_ec_q, prov_public_key_oob_q, 64);
(void)memcpy(prov_ec_q, prov_public_key_oob_q, 64);
printf_hexdump(prov_ec_q, sizeof(prov_ec_q));
btstack_crypto_ecc_p256_set_key(prov_public_key_oob_q, prov_public_key_oob_d);
}
// store for confirmation inputs: len 64
memcpy(&prov_confirmation_inputs[17], packet, 64);
(void)memcpy(&prov_confirmation_inputs[17], packet, 64);
// store remote q
memcpy(remote_ec_q, packet, sizeof(remote_ec_q));
(void)memcpy(remote_ec_q, packet, sizeof(remote_ec_q));
// calculate DHKey
btstack_crypto_ecc_p256_calculate_dhkey(&prov_ecc_p256_request, remote_ec_q, dhkey, provisioning_handle_public_key_dhkey, NULL);
@ -581,8 +582,8 @@ static void provisioning_handle_confirmation_random_device(void * arg){
UNUSED(arg);
// re-use prov_confirmation_inputs buffer
memcpy(&prov_confirmation_inputs[0], random_device, 16);
memcpy(&prov_confirmation_inputs[16], auth_value, 16);
(void)memcpy(&prov_confirmation_inputs[0], random_device, 16);
(void)memcpy(&prov_confirmation_inputs[16], auth_value, 16);
// calc confirmation device
btstack_crypto_aes128_cmac_message(&prov_cmac_request, confirmation_key, 32, prov_confirmation_inputs, confirmation_device, &provisioning_handle_confirmation_device_calculated, NULL);
@ -636,8 +637,8 @@ static void provisioning_handle_random_session_nonce_calculated(void * arg){
// The nonce shall be the 13 least significant octets == zero most significant octets
uint8_t temp[13];
memcpy(temp, &session_nonce[3], 13);
memcpy(session_nonce, temp, 13);
(void)memcpy(temp, &session_nonce[3], 13);
(void)memcpy(session_nonce, temp, 13);
// SessionNonce
printf("SessionNonce: ");
@ -678,9 +679,9 @@ static void provisioning_handle_random(uint8_t *packet, uint16_t size){
// TODO: validate Confirmation
// calc ProvisioningSalt = s1(ConfirmationSalt || RandomProvisioner || RandomDevice)
memcpy(&prov_confirmation_inputs[0], confirmation_salt, 16);
memcpy(&prov_confirmation_inputs[16], packet, 16);
memcpy(&prov_confirmation_inputs[32], random_device, 16);
(void)memcpy(&prov_confirmation_inputs[0], confirmation_salt, 16);
(void)memcpy(&prov_confirmation_inputs[16], packet, 16);
(void)memcpy(&prov_confirmation_inputs[32], random_device, 16);
btstack_crypto_aes128_cmac_zero(&prov_cmac_request, 48, prov_confirmation_inputs, provisioning_salt, &provisioning_handle_random_s1_calculated, NULL);
}
@ -719,7 +720,7 @@ static void provisioning_handle_data_ccm(void * arg){
network_key = btstack_memory_mesh_network_key_get();
// sort provisoning data
memcpy(network_key->net_key, provisioning_data, 16);
(void)memcpy(network_key->net_key, provisioning_data, 16);
network_key->netkey_index = big_endian_read_16(provisioning_data, 16);
// assume free index available for very first network key
network_key->internal_index = mesh_network_key_get_free_index();
@ -735,7 +736,7 @@ static void provisioning_handle_data(uint8_t *packet, uint16_t size){
UNUSED(size);
memcpy(enc_provisioning_data, packet, 25);
(void)memcpy(enc_provisioning_data, packet, 25);
// decode response
btstack_crypto_ccm_init(&prov_ccm_request, session_key, session_nonce, 25, 0, 8);
@ -832,7 +833,7 @@ static void prov_key_generated(void * arg){
// allow override
if (prov_public_key_oob_available){
printf("Replace generated ECC with Public Key OOB:");
memcpy(prov_ec_q, prov_public_key_oob_q, 64);
(void)memcpy(prov_ec_q, prov_public_key_oob_q, 64);
printf_hexdump(prov_ec_q, sizeof(prov_ec_q));
btstack_crypto_ecc_p256_set_key(prov_public_key_oob_q, prov_public_key_oob_d);
}
@ -900,7 +901,7 @@ void provisioning_device_input_oob_complete_alphanumeric(uint16_t pb_adv_cid, co
// store input_oob and fillup with zeros
input_oob_len = btstack_min(input_oob_len, 16);
memset(auth_value, 0, 16);
memcpy(auth_value, input_oob_data, input_oob_len);
(void)memcpy(auth_value, input_oob_data, input_oob_len);
device_state = DEVICE_SEND_INPUT_COMPLETE;
provisioning_run();
}
@ -909,6 +910,6 @@ void provisioning_device_data_get(mesh_provisioning_data_t * the_provisioning_da
the_provisioning_data->unicast_address = unicast_address;
the_provisioning_data->iv_index = iv_index;
the_provisioning_data->flags = flags;
memcpy(the_provisioning_data->device_key, device_key, 16);
(void)memcpy(the_provisioning_data->device_key, device_key, 16);
the_provisioning_data->network_key = network_key;
}

49
src/mesh/provisioning_provisioner.c
View File

@ -184,7 +184,7 @@ static void provisioning_send_invite(uint16_t the_pb_adv_cid){
prov_buffer_out[1] = prov_attention_timer;
pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 2);
// collect confirmation_inputs
memcpy(&prov_confirmation_inputs[0], &prov_buffer_out[1], 1);
(void)memcpy(&prov_confirmation_inputs[0], &prov_buffer_out[1], 1);
}
static void provisioning_send_start(uint16_t the_pb_adv_cid){
@ -196,7 +196,7 @@ static void provisioning_send_start(uint16_t the_pb_adv_cid){
prov_buffer_out[5] = prov_start_authentication_size;
pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 6);
// store for confirmation inputs: len 5
memcpy(&prov_confirmation_inputs[12], &prov_buffer_out[1], 5);
(void)memcpy(&prov_confirmation_inputs[12], &prov_buffer_out[1], 5);
}
static void provisioning_send_provisioning_error(uint16_t the_pb_adv_cid){
@ -207,28 +207,28 @@ static void provisioning_send_provisioning_error(uint16_t the_pb_adv_cid){
static void provisioning_send_public_key(uint16_t the_pb_adv_cid){
prov_buffer_out[0] = MESH_PROV_PUB_KEY;
memcpy(&prov_buffer_out[1], prov_ec_q, 64);
(void)memcpy(&prov_buffer_out[1], prov_ec_q, 64);
pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 65);
// store for confirmation inputs: len 64
memcpy(&prov_confirmation_inputs[17], &prov_buffer_out[1], 64);
(void)memcpy(&prov_confirmation_inputs[17], &prov_buffer_out[1], 64);
}
static void provisioning_send_confirm(uint16_t the_pb_adv_cid){
prov_buffer_out[0] = MESH_PROV_CONFIRM;
memcpy(&prov_buffer_out[1], confirmation_provisioner, 16);
(void)memcpy(&prov_buffer_out[1], confirmation_provisioner, 16);
pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 17);
}
static void provisioning_send_random(uint16_t the_pb_adv_cid){
prov_buffer_out[0] = MESH_PROV_RANDOM;
memcpy(&prov_buffer_out[1], random_provisioner, 16);
(void)memcpy(&prov_buffer_out[1], random_provisioner, 16);
pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 17);
}
static void provisioning_send_data(uint16_t the_pb_adv_cid){
prov_buffer_out[0] = MESH_PROV_DATA;
memcpy(&prov_buffer_out[1], enc_provisioning_data, 25);
memcpy(&prov_buffer_out[26], provisioning_data_mic, 8);
(void)memcpy(&prov_buffer_out[1], enc_provisioning_data, 25);
(void)memcpy(&prov_buffer_out[26], provisioning_data_mic, 8);
pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 34);
}
@ -341,7 +341,7 @@ static void provisioning_handle_capabilities(uint16_t the_pb_adv_cid, const uint
if (packet_len != 11) return;
// collect confirmation_inputs
memcpy(&prov_confirmation_inputs[1], packet_data, packet_len);
(void)memcpy(&prov_confirmation_inputs[1], packet_data, packet_len);
provisioner_state = PROVISIONER_W4_AUTH_CONFIGURATION;
@ -376,8 +376,8 @@ static void provisioning_handle_random_provisioner(void * arg){
printf_hexdump(random_provisioner, sizeof(random_provisioner));
// re-use prov_confirmation_inputs buffer
memcpy(&prov_confirmation_inputs[0], random_provisioner, 16);
memcpy(&prov_confirmation_inputs[16], auth_value, 16);
(void)memcpy(&prov_confirmation_inputs[0], random_provisioner, 16);
(void)memcpy(&prov_confirmation_inputs[16], auth_value, 16);
// calc confirmation device
btstack_crypto_aes128_cmac_message(&prov_cmac_request, confirmation_key, 32, prov_confirmation_inputs, confirmation_provisioner, &provisioning_handle_confirmation_provisioner_calculated, NULL);
@ -451,7 +451,8 @@ static void provisioning_public_key_exchange_complete(void){
provisioning_handle_auth_value_ready();
break;
case 0x01:
memcpy(&auth_value[16-prov_static_oob_len], prov_static_oob_data, prov_static_oob_len);
(void)memcpy(&auth_value[16 - prov_static_oob_len],
prov_static_oob_data, prov_static_oob_len);
provisioning_handle_auth_value_ready();
break;
case 0x02:
@ -524,10 +525,10 @@ static void provisioning_handle_public_key(uint16_t the_pb_adv_cid, const uint8_
#endif
// store for confirmation inputs: len 64
memcpy(&prov_confirmation_inputs[81], packet_data, 64);
(void)memcpy(&prov_confirmation_inputs[81], packet_data, 64);
// store remote q
memcpy(remote_ec_q, packet_data, sizeof(remote_ec_q));
(void)memcpy(remote_ec_q, packet_data, sizeof(remote_ec_q));
provisioning_public_key_ready();
}
@ -576,15 +577,15 @@ static void provisioning_handle_session_nonce_calculated(void * arg){
// The nonce shall be the 13 least significant octets == zero most significant octets
uint8_t temp[13];
memcpy(temp, &session_nonce[3], 13);
memcpy(session_nonce, temp, 13);
(void)memcpy(temp, &session_nonce[3], 13);
(void)memcpy(session_nonce, temp, 13);
// SessionNonce
printf("SessionNonce: ");
printf_hexdump(session_nonce, 13);
// setup provisioning data
memcpy(&provisioning_data[0], net_key, 16);
(void)memcpy(&provisioning_data[0], net_key, 16);
big_endian_store_16(provisioning_data, 16, net_key_index);
provisioning_data[18] = flags;
big_endian_store_32(provisioning_data, 19, iv_index);
@ -625,9 +626,9 @@ static void provisioning_handle_random(uint16_t the_pb_adv_cid, const uint8_t *p
// TODO: validate Confirmation
// calc ProvisioningSalt = s1(ConfirmationSalt || RandomProvisioner || RandomDevice)
memcpy(&prov_confirmation_inputs[0], confirmation_salt, 16);
memcpy(&prov_confirmation_inputs[16], random_provisioner, 16);
memcpy(&prov_confirmation_inputs[32], packet_data, 16);
(void)memcpy(&prov_confirmation_inputs[0], confirmation_salt, 16);
(void)memcpy(&prov_confirmation_inputs[16], random_provisioner, 16);
(void)memcpy(&prov_confirmation_inputs[32], packet_data, 16);
btstack_crypto_aes128_cmac_zero(&prov_cmac_request, 48, prov_confirmation_inputs, provisioning_salt, &provisioning_handle_provisioning_salt_calculated, NULL);
}
@ -714,7 +715,7 @@ static void prov_key_generated(void * arg){
// allow override
if (prov_public_key_oob_available){
printf("Replace generated ECC with Public Key OOB:");
memcpy(prov_ec_q, prov_public_key_oob_q, 64);
(void)memcpy(prov_ec_q, prov_public_key_oob_q, 64);
printf_hexdump(prov_ec_q, sizeof(prov_ec_q));
btstack_crypto_ecc_p256_set_key(prov_public_key_oob_q, prov_public_key_oob_d);
}
@ -767,10 +768,10 @@ uint8_t provisioning_provisioner_public_key_oob_received(uint16_t the_pb_adv_cid
if (provisioner_state != PROVISIONER_W4_PUB_KEY_OOB) return ERROR_CODE_COMMAND_DISALLOWED;
// store for confirmation inputs: len 64
memcpy(&prov_confirmation_inputs[81], public_key, 64);
(void)memcpy(&prov_confirmation_inputs[81], public_key, 64);
// store remote q
memcpy(remote_ec_q, public_key, sizeof(remote_ec_q));
(void)memcpy(remote_ec_q, public_key, sizeof(remote_ec_q));
// continue procedure
provisioner_state = PROVISIONER_SEND_PUB_KEY;
@ -795,7 +796,7 @@ void provisioning_provisioner_input_oob_complete_alphanumeric(uint16_t the_pb_ad
// store input_oob and fillup with zeros
input_oob_len = btstack_min(input_oob_len, 16);
memset(auth_value, 0, 16);
memcpy(auth_value, input_oob_data, input_oob_len);
(void)memcpy(auth_value, input_oob_data, input_oob_len);
provisioning_handle_auth_value_ready();
}