From 6535961a1f105e850ecdf294c128b9fc982ee05a Mon Sep 17 00:00:00 2001 From: Matthias Ringwald Date: Mon, 2 Dec 2019 18:17:20 +0100 Subject: [PATCH] ignore memcpy return value (always returns first parameter) --- src/ble/ancs_client.c | 2 +- src/ble/att_db.c | 13 +- src/ble/att_db_util.c | 4 +- src/ble/att_server.c | 2 +- .../cycling_power_service_server.c | 3 +- .../device_information_service_server.c | 4 +- src/ble/gatt_client.c | 18 +-- src/ble/le_device_db_memory.c | 24 ++-- src/ble/le_device_db_tlv.c | 24 ++-- src/ble/sm.c | 125 +++++++++--------- src/btstack_crypto.c | 31 +++-- src/btstack_ring_buffer.c | 10 +- src/btstack_util.c | 4 +- src/classic/a2dp_source.c | 6 +- src/classic/avdtp.c | 9 +- src/classic/avdtp_acceptor.c | 3 +- src/classic/avdtp_initiator.c | 4 +- src/classic/avdtp_source.c | 2 +- src/classic/avdtp_util.c | 15 ++- src/classic/avrcp.c | 2 +- src/classic/avrcp_browsing_controller.c | 20 +-- src/classic/avrcp_browsing_target.c | 11 +- src/classic/avrcp_controller.c | 25 ++-- src/classic/avrcp_target.c | 21 +-- src/classic/bnep.c | 2 +- src/classic/btstack_cvsd_plc.c | 2 +- src/classic/btstack_link_key_db_memory.c | 10 +- src/classic/btstack_link_key_db_tlv.c | 10 +- src/classic/btstack_sbc_decoder_bluedroid.c | 7 +- src/classic/goep_client.c | 4 +- src/classic/hfp.c | 6 +- src/classic/hfp_ag.c | 19 ++- src/classic/hfp_msbc.c | 5 +- src/classic/hid_device.c | 4 +- src/classic/hsp_ag.c | 2 +- src/classic/hsp_hs.c | 4 +- src/classic/obex_message_builder.c | 2 +- src/classic/pbap_client.c | 19 ++- src/classic/rfcomm.c | 16 ++- src/classic/sdp_client.c | 22 +-- src/classic/sdp_client_rfcomm.c | 2 +- src/classic/sdp_util.c | 13 +- src/hci.c | 72 ++++++---- src/hci_cmd.c | 12 +- src/hci_transport_em9304_spi.c | 4 +- src/l2cap.c | 38 ++++-- src/l2cap_signaling.c | 2 +- src/mesh/adv_bearer.c | 4 +- src/mesh/beacon.c | 10 +- src/mesh/gatt_bearer.c | 12 +- src/mesh/mesh.c | 38 +++--- src/mesh/mesh_access.c | 4 +- src/mesh/mesh_configuration_server.c | 14 +- src/mesh/mesh_crypto.c | 15 ++- src/mesh/mesh_keys.c | 2 +- src/mesh/mesh_lower_transport.c | 7 +- src/mesh/mesh_network.c | 20 +-- src/mesh/mesh_node.c | 2 +- src/mesh/mesh_proxy.c | 22 +-- src/mesh/mesh_upper_transport.c | 19 +-- src/mesh/mesh_virtual_addresses.c | 2 +- src/mesh/pb_adv.c | 10 +- src/mesh/pb_gatt.c | 13 +- src/mesh/provisioning_device.c | 49 +++---- src/mesh/provisioning_provisioner.c | 49 +++---- 65 files changed, 534 insertions(+), 417 deletions(-) diff --git a/src/ble/ancs_client.c b/src/ble/ancs_client.c index f456cf033..6aba74c90 100644 --- a/src/ble/ancs_client.c +++ b/src/ble/ancs_client.c @@ -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); diff --git a/src/ble/att_db.c b/src/ble/att_db.c index e576ae1ee..d97adf0ca 100644 --- a/src/ble/att_db.c +++ b/src/ble/att_db.c @@ -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; diff --git a/src/ble/att_db_util.c b/src/ble/att_db_util.c index a606611dd..7bd945cab 100644 --- a/src/ble/att_db_util.c +++ b/src/ble/att_db_util.c @@ -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(); } diff --git a/src/ble/att_server.c b/src/ble/att_server.c index c835542e7..7d7754def 100644 --- a/src/ble/att_server.c +++ b/src/ble/att_server.c @@ -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); } diff --git a/src/ble/gatt-service/cycling_power_service_server.c b/src/ble/gatt-service/cycling_power_service_server.c index 8f0937d7b..11202ab3e 100644 --- a/src/ble/gatt-service/cycling_power_service_server.c +++ b/src/ble/gatt-service/cycling_power_service_server.c @@ -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; diff --git a/src/ble/gatt-service/device_information_service_server.c b/src/ble/gatt-service/device_information_service_server.c index 2c5704413..0df379d9c 100644 --- a/src/ble/gatt-service/device_information_service_server.c +++ b/src/ble/gatt-service/device_information_service_server.c @@ -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; diff --git a/src/ble/gatt_client.c b/src/ble/gatt_client.c index 6e264b433..9044a3933 100644 --- a/src/ble/gatt_client.c +++ b/src/ble/gatt_client.c @@ -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; diff --git a/src/ble/le_device_db_memory.c b/src/ble/le_device_db_memory.c index 9b62c1c99..633c8aff8 100644 --- a/src/ble/le_device_db_memory.c +++ b/src/ble/le_device_db_memory.c @@ -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 diff --git a/src/ble/le_device_db_tlv.c b/src/ble/le_device_db_tlv.c index f44533130..5a386f84c 100644 --- a/src/ble/le_device_db_tlv.c +++ b/src/ble/le_device_db_tlv.c @@ -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); diff --git a/src/ble/sm.c b/src/ble/sm.c index f45239cd5..f87832f7d 100644 --- a/src/ble/sm.c +++ b/src/ble/sm.c @@ -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(); } diff --git a/src/btstack_crypto.c b/src/btstack_crypto.c index 8b8fee957..123f3a2d1 100644 --- a/src/btstack_crypto.c +++ b/src/btstack_crypto.c @@ -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); diff --git a/src/btstack_ring_buffer.c b/src/btstack_ring_buffer.c index 3ef510029..3c845b119 100644 --- a/src/btstack_ring_buffer.c +++ b/src/btstack_ring_buffer.c @@ -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; } diff --git a/src/btstack_util.c b/src/btstack_util.c index 0d1f7824f..718cbf902 100644 --- a/src/btstack_util.c +++ b/src/btstack_util.c @@ -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); } diff --git a/src/classic/a2dp_source.c b/src/classic/a2dp_source.c index 4d8cd783c..3563ffacc 100644 --- a/src/classic/a2dp_source.c +++ b/src/classic/a2dp_source.c @@ -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; diff --git a/src/classic/avdtp.c b/src/classic/avdtp.c index 5ff2b2650..f1b03a014 100644 --- a/src/classic/avdtp.c +++ b/src/classic/avdtp.c @@ -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); } diff --git a/src/classic/avdtp_acceptor.c b/src/classic/avdtp_acceptor.c index eb6d58fe3..830ef22a6 100644 --- a/src/classic/avdtp_acceptor.c +++ b/src/classic/avdtp_acceptor.c @@ -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); } diff --git a/src/classic/avdtp_initiator.c b/src/classic/avdtp_initiator.c index 43fb1f2b4..ae1c920d4 100644 --- a/src/classic/avdtp_initiator.c +++ b/src/classic/avdtp_initiator.c @@ -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; diff --git a/src/classic/avdtp_source.c b/src/classic/avdtp_source.c index 547e2d787..57401d5a5 100644 --- a/src/classic/avdtp_source.c +++ b/src/classic/avdtp_source.c @@ -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; } diff --git a/src/classic/avdtp_util.c b/src/classic/avdtp_util.c index dc9b75b1c..786520196 100644 --- a/src/classic/avdtp_util.c +++ b/src/classic/avdtp_util.c @@ -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)); } diff --git a/src/classic/avrcp.c b/src/classic/avrcp.c index e41dfc60d..2ee91c923 100644 --- a/src/classic/avrcp.c +++ b/src/classic/avrcp.c @@ -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; } diff --git a/src/classic/avrcp_browsing_controller.c b/src/classic/avrcp_browsing_controller.c index 7fa93d1c5..4fecd3482 100644 --- a/src/classic/avrcp_browsing_controller.c +++ b/src/classic/avrcp_browsing_controller.c @@ -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; } diff --git a/src/classic/avrcp_browsing_target.c b/src/classic/avrcp_browsing_target.c index b44a319b6..daa2b1364 100644 --- a/src/classic/avrcp_browsing_target.c +++ b/src/classic/avrcp_browsing_target.c @@ -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); diff --git a/src/classic/avrcp_controller.c b/src/classic/avrcp_controller.c index f95cd33fe..27b752748 100644 --- a/src/classic/avrcp_controller.c +++ b/src/classic/avrcp_controller.c @@ -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); diff --git a/src/classic/avrcp_target.c b/src/classic/avrcp_target.c index 793bdbb8c..b41a7570f 100644 --- a/src/classic/avrcp_target.c +++ b/src/classic/avrcp_target.c @@ -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); diff --git a/src/classic/bnep.c b/src/classic/bnep.c index bb54881fe..389d108ca 100644 --- a/src/classic/bnep.c +++ b/src/classic/bnep.c @@ -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); diff --git a/src/classic/btstack_cvsd_plc.c b/src/classic/btstack_cvsd_plc.c index a1ed179ce..4b3d94ea2 100644 --- a/src/classic/btstack_cvsd_plc.c +++ b/src/classic/btstack_cvsd_plc.c @@ -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){ diff --git a/src/classic/btstack_link_key_db_memory.c b/src/classic/btstack_link_key_db_memory.c index a37dd49aa..b5593afb4 100644 --- a/src/classic/btstack_link_key_db_memory.c +++ b/src/classic/btstack_link_key_db_memory.c @@ -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 diff --git a/src/classic/btstack_link_key_db_tlv.c b/src/classic/btstack_link_key_db_tlv.c index 99746ad81..ca58028cc 100644 --- a/src/classic/btstack_link_key_db_tlv.c +++ b/src/classic/btstack_link_key_db_tlv.c @@ -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; diff --git a/src/classic/btstack_sbc_decoder_bluedroid.c b/src/classic/btstack_sbc_decoder_bluedroid.c index 2d5cc6089..bd0017f94 100644 --- a/src/classic/btstack_sbc_decoder_bluedroid.c +++ b/src/classic/btstack_sbc_decoder_bluedroid.c @@ -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, diff --git a/src/classic/goep_client.c b/src/classic/goep_client.c index 10e2c9da3..063c62021 100644 --- a/src/classic/goep_client.c +++ b/src/classic/goep_client.c @@ -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; diff --git a/src/classic/hfp.c b/src/classic/hfp.c index 02737473f..c72f4575d 100644 --- a/src/classic/hfp.c +++ b/src/classic/hfp.c @@ -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; diff --git a/src/classic/hfp_ag.c b/src/classic/hfp_ag.c index d43633606..b5d26ab44 100644 --- a/src/classic/hfp_ag.c +++ b/src/classic/hfp_ag.c @@ -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 *)); } diff --git a/src/classic/hfp_msbc.c b/src/classic/hfp_msbc.c index 8ef435bcc..e237b0ceb 100644 --- a/src/classic/hfp_msbc.c +++ b/src/classic/hfp_msbc.c @@ -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; } diff --git a/src/classic/hid_device.c b/src/classic/hid_device.c index 0589b0eb8..7749af707 100644 --- a/src/classic/hid_device.c +++ b/src/classic/hid_device.c @@ -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; diff --git a/src/classic/hsp_ag.c b/src/classic/hsp_ag.c index 537eedff0..d4542c0fb 100644 --- a/src/classic/hsp_ag.c +++ b/src/classic/hsp_ag.c @@ -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(); } diff --git a/src/classic/hsp_hs.c b/src/classic/hsp_hs.c index 3e064a2c1..e0e891555 100644 --- a/src/classic/hsp_hs.c +++ b/src/classic/hsp_hs.c @@ -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 diff --git a/src/classic/obex_message_builder.c b/src/classic/obex_message_builder.c index 097fedea1..1e6fc4762 100644 --- a/src/classic/obex_message_builder.c +++ b/src/classic/obex_message_builder.c @@ -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; diff --git a/src/classic/pbap_client.c b/src/classic/pbap_client.c index 39f9d6248..7bfdbbecc 100644 --- a/src/classic/pbap_client.c +++ b/src/classic/pbap_client.c @@ -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; diff --git a/src/classic/rfcomm.c b/src/classic/rfcomm.c index eb36603bf..2dafd299f 100644 --- a/src/classic/rfcomm.c +++ b/src/classic/rfcomm.c @@ -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); diff --git a/src/classic/sdp_client.c b/src/classic/sdp_client.c index c2632e75a..32ccf06d4 100644 --- a/src/classic/sdp_client.c +++ b/src/classic/sdp_client.c @@ -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 diff --git a/src/classic/sdp_client_rfcomm.c b/src/classic/sdp_client_rfcomm.c index 7623dcf6f..c97a465e5 100644 --- a/src/classic/sdp_client_rfcomm.c +++ b/src/classic/sdp_client_rfcomm.c @@ -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; diff --git a/src/classic/sdp_util.c b/src/classic/sdp_util.c index aaa7272e4..bdd5200ac 100644 --- a/src/classic/sdp_util.c +++ b/src/classic/sdp_util.c @@ -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; } diff --git a/src/hci.c b/src/hci.c index 52d01424c..a380d0e7a 100644 --- a/src/hci.c +++ b/src/hci.c @@ -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; } diff --git a/src/hci_cmd.c b/src/hci_cmd.c index 6af233222..5132ba541 100644 --- a/src/hci_cmd.c +++ b/src/hci_cmd.c @@ -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; } diff --git a/src/hci_transport_em9304_spi.c b/src/hci_transport_em9304_spi.c index aaea368c9..427478ba0 100644 --- a/src/hci_transport_em9304_spi.c +++ b/src/hci_transport_em9304_spi.c @@ -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; diff --git a/src/l2cap.c b/src/l2cap.c index 4c901bf9e..aef4547ff 100644 --- a/src/l2cap.c +++ b/src/l2cap.c @@ -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); diff --git a/src/l2cap_signaling.c b/src/l2cap_signaling.c index d9824c2a6..cf0baa7f1 100644 --- a/src/l2cap_signaling.c +++ b/src/l2cap_signaling.c @@ -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: diff --git a/src/mesh/adv_bearer.c b/src/mesh/adv_bearer.c index 83b90a320..fe6621e67 100644 --- a/src/mesh/adv_bearer.c +++ b/src/mesh/adv_bearer.c @@ -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; diff --git a/src/mesh/beacon.c b/src/mesh/beacon.c index ca8bbe412..5973fd63d 100644 --- a/src/mesh/beacon.c +++ b/src/mesh/beacon.c @@ -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); diff --git a/src/mesh/gatt_bearer.c b/src/mesh/gatt_bearer.c index 9585af63a..940df01aa 100644 --- a/src/mesh/gatt_bearer.c +++ b/src/mesh/gatt_bearer.c @@ -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: diff --git a/src/mesh/mesh.c b/src/mesh/mesh.c index e5017e8c9..627f4938d 100644 --- a/src/mesh/mesh.c +++ b/src/mesh/mesh.c @@ -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; diff --git a/src/mesh/mesh_access.c b/src/mesh/mesh_access.c index 69722e64f..7587fd8cd 100644 --- a/src/mesh/mesh_access.c +++ b/src/mesh/mesh_access.c @@ -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); } diff --git a/src/mesh/mesh_configuration_server.c b/src/mesh/mesh_configuration_server.c index e8b8c2bfc..f0e0815f9 100644 --- a/src/mesh/mesh_configuration_server.c +++ b/src/mesh/mesh_configuration_server.c @@ -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 { diff --git a/src/mesh/mesh_crypto.c b/src/mesh/mesh_crypto.c index fc2d605bb..d169c8aef 100644 --- a/src/mesh/mesh_crypto.c +++ b/src/mesh/mesh_crypto.c @@ -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; diff --git a/src/mesh/mesh_keys.c b/src/mesh/mesh_keys.c index e0f97f615..62879a654 100644 --- a/src/mesh/mesh_keys.c +++ b/src/mesh/mesh_keys.c @@ -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; diff --git a/src/mesh/mesh_lower_transport.c b/src/mesh/mesh_lower_transport.c index 6fb1352b6..58e6623bf 100644 --- a/src/mesh/mesh_lower_transport.c +++ b/src/mesh/mesh_lower_transport.c @@ -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< 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); diff --git a/src/mesh/mesh_network.c b/src/mesh/mesh_network.c index dff76493b..e891c6ce1 100644 --- a/src/mesh/mesh_network.c +++ b/src/mesh/mesh_network.c @@ -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; } diff --git a/src/mesh/mesh_node.c b/src/mesh/mesh_node.c index b97f2046a..2ba4d9cce 100644 --- a/src/mesh/mesh_node.c +++ b/src/mesh/mesh_node.c @@ -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; } diff --git a/src/mesh/mesh_proxy.c b/src/mesh/mesh_proxy.c index 9173f962b..e9d91f687 100644 --- a/src/mesh/mesh_proxy.c +++ b/src/mesh/mesh_proxy.c @@ -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); diff --git a/src/mesh/mesh_upper_transport.c b/src/mesh/mesh_upper_transport.c index cc4026b5e..24813c885 100644 --- a/src/mesh/mesh_upper_transport.c +++ b/src/mesh/mesh_upper_transport.c @@ -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; } diff --git a/src/mesh/mesh_virtual_addresses.c b/src/mesh/mesh_virtual_addresses.c index 2b1d0c1c9..3f8d01869 100644 --- a/src/mesh/mesh_virtual_addresses.c +++ b/src/mesh/mesh_virtual_addresses.c @@ -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; diff --git a/src/mesh/pb_adv.c b/src/mesh/pb_adv.c index 3ac0ee935..6ca59b85b 100644 --- a/src/mesh/pb_adv.c +++ b/src/mesh/pb_adv.c @@ -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); diff --git a/src/mesh/pb_gatt.c b/src/mesh/pb_gatt.c index 944c4d0c5..eb1698004 100644 --- a/src/mesh/pb_gatt.c +++ b/src/mesh/pb_gatt.c @@ -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); diff --git a/src/mesh/provisioning_device.c b/src/mesh/provisioning_device.c index a51d8369c..771d6b6c7 100644 --- a/src/mesh/provisioning_device.c +++ b/src/mesh/provisioning_device.c @@ -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; } diff --git a/src/mesh/provisioning_provisioner.c b/src/mesh/provisioning_provisioner.c index db32510ff..d560f5da3 100644 --- a/src/mesh/provisioning_provisioner.c +++ b/src/mesh/provisioning_provisioner.c @@ -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(); }