From d59614042a9034ecc34cad0a47d1493815819c02 Mon Sep 17 00:00:00 2001
From: "oljas.jarasbaev" <oljas.jarasbaev@demlabs.net>
Date: Wed, 12 Jul 2023 10:42:54 +0000
Subject: [PATCH] Bugfix 9102
---
CMakeLists.txt | 2 +-
modules/chain/dap_chain.c | 40 +++-
modules/chain/dap_chain_cell.c | 6 +-
modules/chain/dap_chain_cs.c | 8 +
modules/chain/dap_chain_ledger.c | 188 +++++++++++++++++-
modules/chain/dap_chain_pvt.c | 4 +
modules/chain/dap_chain_tx.c | 4 +
modules/chain/include/dap_chain_ledger.h | 2 +-
.../dap_stream_ch_chain_net_srv.c | 3 +-
.../chain-net/dap_stream_ch_chain_net.c | 5 +
.../chain-voting/dap_stream_ch_chain_voting.c | 4 +
modules/channel/chain/dap_stream_ch_chain.c | 20 ++
modules/common/dap_chain_common.c | 8 +
modules/common/dap_chain_datum.c | 18 ++
modules/common/dap_chain_datum_decree.c | 5 +
modules/common/dap_chain_datum_token.c | 4 +
modules/common/dap_chain_datum_tx.c | 4 +
modules/common/dap_chain_datum_tx_items.c | 24 +++
.../block-poa/dap_chain_cs_block_poa.c | 12 ++
.../block-pos/dap_chain_cs_block_pos.c | 46 +++--
.../consensus/dag-poa/dap_chain_cs_dag_poa.c | 21 ++
.../consensus/dag-pos/dap_chain_cs_dag_pos.c | 52 +++--
.../consensus/esbocs/dap_chain_cs_esbocs.c | 61 +++++-
modules/consensus/none/dap_chain_cs_none.c | 25 +++
modules/mempool/dap_chain_mempool.c | 10 +
modules/net/dap_chain_net.c | 92 ++++++++-
modules/net/dap_chain_net_balancer.c | 5 +
modules/net/dap_chain_net_decree.c | 10 +-
modules/net/dap_chain_net_tx.c | 22 ++
modules/net/dap_chain_node.c | 4 +
modules/net/dap_chain_node_cli_cmd.c | 40 +++-
modules/net/dap_chain_node_cli_cmd_tx.c | 28 +++
modules/net/dap_chain_node_client.c | 4 +
modules/net/dap_chain_node_dns_client.c | 4 +
modules/net/dap_chain_node_dns_server.c | 24 +++
modules/net/dap_chain_node_ping.c | 24 +++
modules/net/srv/dap_chain_net_srv.c | 15 ++
modules/net/srv/dap_chain_net_srv_client.c | 9 +
modules/net/srv/dap_chain_net_srv_geoip.c | 8 +-
modules/net/srv/dap_chain_net_srv_order.c | 16 ++
.../srv/dap_chain_net_srv_stream_session.c | 8 +
.../service/datum/dap_chain_net_srv_datum.c | 4 +
.../dap_chain_net_srv_stake_pos_delegate.c | 57 ++++++
modules/service/vpn/dap_chain_net_srv_vpn.c | 51 +++++
.../service/vpn/dap_chain_net_vpn_client.c | 4 +
.../vpn/dap_chain_net_vpn_client_tun.c | 12 +-
.../xchange/dap_chain_net_srv_xchange.c | 18 ++
modules/type/blocks/dap_chain_block.c | 4 +
modules/type/blocks/dap_chain_block_cache.c | 14 ++
modules/type/blocks/dap_chain_block_chunk.c | 16 ++
modules/type/blocks/dap_chain_cs_blocks.c | 37 ++++
modules/type/dag/dap_chain_cs_dag.c | 53 +++++
modules/type/dag/dap_chain_cs_dag_event.c | 4 +
modules/wallet/dap_chain_wallet.c | 4 +
54 files changed, 1103 insertions(+), 64 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index de17da8a1f..7839fd7e97 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.10)
project(cellframe-sdk C)
set(CMAKE_C_STANDARD 11)
-set(CELLFRAME_SDK_NATIVE_VERSION "3.2-0")
+set(CELLFRAME_SDK_NATIVE_VERSION "3.3-0")
add_definitions ("-DCELLFRAME_SDK_VERSION=\"${CELLFRAME_SDK_NATIVE_VERSION}\"")
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index ccaae7c3a5..87579e9962 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -104,6 +104,8 @@ void dap_chain_deinit(void)
dap_chain_t * dap_chain_create(dap_ledger_t* a_ledger, const char * a_chain_net_name, const char * a_chain_name, dap_chain_net_id_t a_chain_net_id, dap_chain_id_t a_chain_id )
{
dap_chain_t * l_ret = DAP_NEW_Z(dap_chain_t);
+ if ( !l_ret )
+ return log_it(L_ERROR, "Memory allocation error in dap_chain_create, errno=%d", errno), NULL;
DAP_CHAIN_PVT_LOCAL_NEW(l_ret);
memcpy(l_ret->id.raw,a_chain_id.raw,sizeof(a_chain_id));
memcpy(l_ret->net_id.raw,a_chain_net_id.raw,sizeof(a_chain_net_id));
@@ -113,6 +115,10 @@ dap_chain_t * dap_chain_create(dap_ledger_t* a_ledger, const char * a_chain_net_
pthread_rwlock_init(&l_ret->rwlock, NULL);
pthread_rwlock_init(&l_ret->cell_rwlock,NULL);
dap_chain_item_t * l_ret_item = DAP_NEW_Z(dap_chain_item_t);
+ if ( !l_ret_item ){
+ DAP_DELETE(l_ret);
+ return log_it(L_ERROR, "Memory allocation error in dap_chain_create, errno=%d", errno), NULL;
+ }
l_ret_item->chain = l_ret;
memcpy(l_ret_item->item_id.id.raw ,a_chain_id.raw,sizeof(a_chain_id));
memcpy(l_ret_item->item_id.net_id.raw ,a_chain_net_id.raw,sizeof(a_chain_net_id));
@@ -436,7 +442,11 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
if (l_datum_types && l_datum_types_count > 0)
{
l_chain->datum_types = DAP_NEW_SIZE(dap_chain_type_t, l_datum_types_count * sizeof(dap_chain_type_t)); // TODO: pls check counter for recognized types before memory allocation!
- l_count_recognized = 0;
+ if ( !l_chain->datum_types ) {
+ DAP_DELETE(l_chain);
+ return log_it(L_ERROR, "Memory allocation error in dap_chain_load_from_cfg, errno=%d", errno), NULL;
+ }
+ l_count_recognized = 0;
for (uint16_t i = 0; i < l_datum_types_count; i++)
{
dap_chain_type_t l_chain_type = s_chain_type_from_str(l_datum_types[i]);
@@ -454,7 +464,13 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
if (l_default_datum_types && l_default_datum_types_count > 0)
{
l_chain->default_datum_types = DAP_NEW_SIZE(dap_chain_type_t, l_default_datum_types_count * sizeof(dap_chain_type_t)); // TODO: pls check counter for recognized types before memory allocation!
- l_count_recognized = 0;
+ if ( !l_chain->default_datum_types ) {
+ if (l_chain->datum_types)
+ DAP_DELETE(l_chain->datum_types);
+ DAP_DELETE(l_chain);
+ return log_it(L_ERROR, "Memory allocation error in dap_chain_load_from_cfg, errno=%d", errno), NULL;
+ }
+ l_count_recognized = 0;
for (uint16_t i = 0; i < l_default_datum_types_count; i++)
{
dap_chain_type_t l_chain_type = s_chain_type_from_str(l_default_datum_types[i]);
@@ -476,7 +492,15 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
if (l_datum_types && l_datum_types_count)
{
l_chain->autoproc_datum_types = DAP_NEW_Z_SIZE(uint16_t, l_chain->datum_types_count * sizeof(uint16_t)); // TODO: pls check counter for recognized types before memory allocation!
- l_count_recognized = 0;
+ if ( !l_chain->autoproc_datum_types ) {
+ if (l_chain->datum_types)
+ DAP_DELETE(l_chain->datum_types);
+ if (l_chain->default_datum_types)
+ DAP_DELETE(l_chain->default_datum_types);
+ DAP_DELETE(l_chain);
+ return log_it(L_ERROR, "Memory allocation error in dap_chain_load_from_cfg, errno=%d", errno), NULL;
+ }
+ l_count_recognized = 0;
for (uint16_t i = 0; i < l_datum_types_count; i++)
{
if (!dap_strcmp(l_datum_types[i], "all") && l_chain->datum_types_count)
@@ -725,15 +749,25 @@ int dap_cert_chain_file_save(dap_chain_datum_t *datum, char *net_name)
const char *cert_name = cert->name;
size_t cert_path_length = dap_strlen(net_name) + dap_strlen(cert_name) + 9 + dap_strlen(s_system_chain_ca_dir);
char *cert_path = DAP_NEW_STACK_SIZE(char, cert_path_length);
+ if ( !cert_path ) {
+ dap_cert_delete(cert);
+ log_it(L_ERROR, "Memory allocation error in dap_cert_chain_file_save, errno=%d", errno);
+ return -1;
+ }
snprintf(cert_path, cert_path_length, "%s/%s/%s.dcert", s_system_chain_ca_dir, net_name, cert_name);
// In cert_path resolve all `..` and `.`s
char *cert_path_c = dap_canonicalize_filename(cert_path, NULL);
// Protect the ca folder from using "/.." in cert_name
if(dap_strncmp(s_system_chain_ca_dir, cert_path_c, dap_strlen(s_system_chain_ca_dir))) {
+ dap_cert_delete(cert);
+ DAP_DELETE(cert_path_c);
+ DAP_DELETE(cert_path);
log_it(L_ERROR, "Cert path '%s' is not in ca dir: %s", cert_path_c, s_system_chain_ca_dir);
return -1;
}
int l_ret = dap_cert_file_save(cert, cert_path_c);
+ dap_cert_delete(cert);
+ DAP_DELETE(cert_path);
DAP_DELETE(cert_path_c);
// if ( access( l_cert_path, F_OK ) != -1 ) {
// log_it (L_ERROR, "File %s is already exists.", l_cert_path);
diff --git a/modules/chain/dap_chain_cell.c b/modules/chain/dap_chain_cell.c
index 0e50a6a194..3a839f3b4f 100644
--- a/modules/chain/dap_chain_cell.c
+++ b/modules/chain/dap_chain_cell.c
@@ -101,6 +101,10 @@ dap_chain_cell_t * dap_chain_cell_create_fill(dap_chain_t * a_chain, dap_chain_c
return l_cell;
}
l_cell = DAP_NEW_Z(dap_chain_cell_t);
+ if ( !l_cell ) {
+ pthread_rwlock_unlock(&a_chain->cell_rwlock);
+ return log_it(L_ERROR, "Memory allocation error in dap_chain_cell_create_fill, errno=%d", errno), NULL;
+ }
l_cell->chain = a_chain;
l_cell->id.uint64 = a_cell_id.uint64;
l_cell->file_storage_path = dap_strdup_printf("%0"DAP_UINT64_FORMAT_x".dchaincell", l_cell->id.uint64);
@@ -211,7 +215,7 @@ int dap_chain_cell_load(dap_chain_t * a_chain, const char * a_cell_file_path)
}
dap_chain_atom_ptr_t l_element = DAP_NEW_SIZE(dap_chain_atom_ptr_t, l_el_size);
if (!l_element) {
- log_it(L_ERROR, "Out of memory");
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cell_load, errno=%d", errno), NULL;
ret = -5;
break;
}
diff --git a/modules/chain/dap_chain_cs.c b/modules/chain/dap_chain_cs.c
index 198e499b4d..352092a672 100644
--- a/modules/chain/dap_chain_cs.c
+++ b/modules/chain/dap_chain_cs.c
@@ -65,6 +65,10 @@ void dap_chain_cs_deinit(void)
void dap_chain_cs_type_add (const char * a_cs_str, dap_chain_callback_new_cfg_t a_callback_init)
{
dap_chain_callback_new_cfg_item_t *l_item = DAP_NEW_Z ( dap_chain_callback_new_cfg_item_t );
+ if ( !l_item ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_type_add, errno=%d", errno);
+ return;
+ }
strncpy(l_item->name, a_cs_str, sizeof (l_item->name) - 1);
l_item->name[sizeof (l_item->name) - 1] = '\0';
l_item->callback_init = a_callback_init;
@@ -101,6 +105,10 @@ int dap_chain_cs_type_create(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
void dap_chain_cs_add (const char * a_cs_str, dap_chain_callback_new_cfg_t a_callback_init)
{
dap_chain_callback_new_cfg_item_t *l_item = DAP_NEW_Z ( dap_chain_callback_new_cfg_item_t );
+ if ( !l_item ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_add, errno=%d", errno);
+ return;
+ }
strncpy(l_item->name, a_cs_str, sizeof (l_item->name) - 1);
l_item->name[sizeof (l_item->name) - 1] = '\0';
l_item->callback_init = a_callback_init;
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 68a91b32aa..d6a4bc90f1 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -387,9 +387,17 @@ void dap_chain_ledger_deinit()
static dap_ledger_t * dap_chain_ledger_handle_new(void)
{
dap_ledger_t *l_ledger = DAP_NEW_Z(dap_ledger_t);
+ if ( !l_ledger ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_handle_new, errno=%d", errno);
+ return NULL;
+ }
dap_ledger_private_t * l_ledger_pvt;
l_ledger->_internal = l_ledger_pvt = DAP_NEW_Z(dap_ledger_private_t);
-
+ if ( !l_ledger_pvt ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_handle_new, errno=%d", errno);
+ DAP_DELETE(l_ledger);
+ return NULL;
+ }
// Initialize Read/Write Lock Attribute
pthread_rwlock_init(&l_ledger_pvt->ledger_rwlock, NULL);
pthread_rwlock_init(&l_ledger_pvt->tokens_rwlock, NULL);
@@ -440,6 +448,8 @@ struct json_object *wallet_info_json_collect(dap_ledger_t *a_ledger, dap_ledger_
if (pos) {
size_t l_addr_len = pos - a_bal->key;
char *l_addr_str = DAP_NEW_STACK_SIZE(char, l_addr_len + 1);
+ if ( !l_addr_str )
+ return log_it(L_ERROR, "Memory allocation error in wallet_info_json_collect, errno=%d", errno), NULL;
memcpy(l_addr_str, a_bal->key, pos - a_bal->key);
*(l_addr_str + l_addr_len) = '\0';
json_object_object_add(l_network, "address", json_object_new_string(l_addr_str));
@@ -983,6 +993,10 @@ void s_ledger_token_cache_update(dap_ledger_t *a_ledger, dap_chain_ledger_token_
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TOKENS_STR);
size_t l_cache_size = l_token_item->datum_token_size + sizeof(uint256_t);
uint8_t *l_cache = DAP_NEW_STACK_SIZE(uint8_t, l_cache_size);
+ if ( !l_cache ) {
+ log_it(L_ERROR, "Memory allocation error in s_ledger_token_cache_update, errno=%d", errno);
+ return;
+ }
memcpy(l_cache, &l_token_item->current_supply, sizeof(uint256_t));
memcpy(l_cache + sizeof(uint256_t), l_token_item->datum_token, l_token_item->datum_token_size);
if (dap_global_db_set(l_gdb_group, l_token_item->ticker, l_cache, l_cache_size, false, NULL, NULL)) {
@@ -1076,6 +1090,10 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
break;
default:
l_token = DAP_DUP_SIZE(a_token, a_token_size);
+ if ( !l_token ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_token_add");
+ return -6;
+ }
break;
}
@@ -1120,6 +1138,12 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
return -7;
}
l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
+ if ( !l_token_item ) {
+ if (l_token)
+ DAP_DELETE(l_token);
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_token_add");
+ return -8;
+ }
*l_token_item = (dap_chain_ledger_token_item_t) {
.version = l_token->version,
.type = l_token->type,
@@ -1133,6 +1157,21 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
.auth_signs_total = l_auth_signs_total,
.auth_signs_valid = l_auth_signs_valid
};
+ if ( !l_token_item->auth_pkeys ) {
+ if (l_token)
+ DAP_DELETE(l_token);
+ DAP_DELETE(l_token_item);
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_token_add");
+ return -6;
+ };
+ if ( !l_token_item->auth_pkeys ) {
+ if (l_token)
+ DAP_DELETE(l_token);
+ DAP_DEL_Z(l_token_item->auth_pkeys);
+ DAP_DELETE(l_token_item);
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_token_add");
+ return -6;
+ }
dap_stpcpy(l_token_item->ticker, l_token->ticker);
for (uint16_t k = 0; k < l_token_item->auth_signs_total; k++) {
l_token_item->auth_pkeys[k] = dap_pkey_get_from_sign_deserialization(l_signs[k]);
@@ -1141,8 +1180,9 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
DAP_DELETE(l_signs);
}
+
l_token_item->datum_token_size = l_token_size;
- l_token_item->datum_token = l_token; //DAP_DUP_SIZE(l_token, l_token_size);
+ l_token_item->datum_token = l_token;
l_token_item->datum_token->type = l_token->type;
if (l_token->type != DAP_CHAIN_DATUM_TOKEN_TYPE_UPDATE) {
@@ -1585,7 +1625,8 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
if(s_debug_more)
log_it(L_ERROR,"Wrong address checksum in TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD (code %d)",
l_add_addr_check);
- DAP_DELETE(l_addrs);
+ if (l_addrs)
+ DAP_DELETE(l_addrs);
return -12;
}
// Check if its already present
@@ -1596,7 +1637,8 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
log_it(L_ERROR,"TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD has address %s thats already present in list",
l_addr_str);
DAP_DELETE(l_addr_str);
- DAP_DELETE(l_addrs);
+ if (l_addrs)
+ DAP_DELETE(l_addrs);
return -11;
}
}
@@ -2205,6 +2247,10 @@ static void s_load_cache_gdb_loaded_spent_txs_callback(dap_global_db_context_t *
for (size_t i = 0; i < a_values_count; i++) {
dap_chain_ledger_tx_spent_item_t *l_tx_spent_item = DAP_NEW_Z(dap_chain_ledger_tx_spent_item_t);
+ if ( !l_tx_spent_item ) {
+ log_it(L_ERROR, "Memory allocation error in s_load_cache_gdb_loaded_spent_txs_callback");
+ return;
+ }
dap_chain_hash_fast_from_str(a_values[i].key, &l_tx_spent_item->tx_hash_fast);
l_tx_spent_item->cache_data = *(typeof(((dap_chain_ledger_tx_spent_item_t*)0)->cache_data)*)a_values[i].value;
HASH_ADD(hh, l_ledger_pvt->spent_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_tx_spent_item);
@@ -2236,8 +2282,17 @@ static void s_load_cache_gdb_loaded_txs_callback(dap_global_db_context_t *a_glob
dap_ledger_private_t * l_ledger_pvt = PVT(l_ledger);
for (size_t i = 0; i < a_values_count; i++) {
dap_chain_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
+ if ( !l_tx_item ) {
+ log_it(L_ERROR, "Memory allocation error in s_load_cache_gdb_loaded_txs_callback");
+ return;
+ }
dap_chain_hash_fast_from_str(a_values[i].key, &l_tx_item->tx_hash_fast);
l_tx_item->tx = DAP_NEW_Z_SIZE(dap_chain_datum_tx_t, a_values[i].value_len - sizeof(l_tx_item->cache_data));
+ if ( !l_tx_item->tx ) {
+ DAP_DELETE(l_tx_item);
+ log_it(L_ERROR, "Memory allocation error in s_load_cache_gdb_loaded_txs_callback");
+ return;
+ }
memcpy(&l_tx_item->cache_data, a_values[i].value, sizeof(l_tx_item->cache_data));
memcpy(l_tx_item->tx, a_values[i].value + sizeof(l_tx_item->cache_data), a_values[i].value_len - sizeof(l_tx_item->cache_data));
l_tx_item->ts_added = dap_nanotime_now();
@@ -2309,6 +2364,10 @@ static void s_load_cache_gdb_loaded_emissions_callback(dap_global_db_context_t *
continue;
}
dap_chain_ledger_token_emission_item_t *l_emission_item = DAP_NEW_Z(dap_chain_ledger_token_emission_item_t);
+ if ( !l_emission_item ) {
+ log_it(L_ERROR, "Memory allocation error in s_load_cache_gdb_loaded_emissions_callback");
+ return;
+ }
dap_chain_hash_fast_from_str(a_values[i].key, &l_emission_item->datum_token_emission_hash);
l_emission_item->tx_used_out = *(dap_hash_fast_t*)a_values[i].value;
l_emission_item->datum_token_emission = DAP_DUP_SIZE(a_values[i].value + sizeof(dap_hash_fast_t),
@@ -2698,7 +2757,16 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
if (l_ret == DAP_CHAIN_CS_VERIFY_CODE_NO_DECREE) { // TODO remove emissions threshold
if (HASH_COUNT(l_ledger_pvt->threshold_emissions) < s_threshold_emissions_max) {
l_token_emission_item = DAP_NEW_Z(dap_chain_ledger_token_emission_item_t);
+ if ( !l_token_emission_item ) {
+ log_it(L_ERROR, "Memory allocation error in s_token_emission_add");
+ return DAP_CHAIN_LEDGER_EMISSION_ADD_MEMORY_PROBLEM;
+ }
l_token_emission_item->datum_token_emission = DAP_DUP_SIZE(a_token_emission, a_token_emission_size);
+ if ( !l_token_emission_item->datum_token_emission ) {
+ DAP_DELETE(l_token_emission_item);
+ log_it(L_ERROR, "Memory allocation error in s_token_emission_add");
+ return DAP_CHAIN_LEDGER_EMISSION_ADD_MEMORY_PROBLEM;
+ }
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
dap_hash_fast_t l_emi_hash = {0};
dap_hash_fast(a_token_emission, a_token_emission_size, &l_emi_hash);
@@ -3016,6 +3084,10 @@ void dap_chain_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledge
if(l_tx_item) {
l_tickers_size = 10;
l_tickers = DAP_NEW_Z_SIZE(char *, l_tickers_size * sizeof(char*));
+ if ( !l_tickers ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_addr_get_token_ticker_all_depricated");
+ return;
+ }
while(l_tx_item) {
bool l_is_not_in_list = true;
for(size_t i = 0; i < l_tickers_size; i++) {
@@ -3030,6 +3102,10 @@ void dap_chain_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledge
if((l_tickers_pos + 1) == l_tickers_size) {
l_tickers_size += (l_tickers_size / 2);
l_tickers = DAP_REALLOC(l_tickers, l_tickers_size);
+ if ( !l_tickers ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_addr_get_token_ticker_all_depricated");
+ return;
+ }
}
l_tickers[l_tickers_pos] = dap_strdup(l_tx_item->cache_data.token_ticker);
l_tickers_pos++;
@@ -3040,6 +3116,10 @@ void dap_chain_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledge
}
l_tickers_size = l_tickers_pos + 1;
l_tickers = DAP_REALLOC(l_tickers, l_tickers_size * sizeof(char*));
+ if ( !l_tickers ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_addr_get_token_ticker_all_depricated");
+ return;
+ }
}
*a_tickers = l_tickers;
*a_tickers_size = l_tickers_pos;
@@ -3403,6 +3483,22 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
dap_list_t *l_list_tmp = l_list_in;
for (int l_list_tmp_num = 0; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_list_tmp_num++) {
bound_item = DAP_NEW_Z(dap_chain_ledger_tx_bound_t);
+ if (!bound_item) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_tx_cache_check");
+ if ( l_list_bound_items )
+ dap_list_free_full(l_list_bound_items, NULL);
+ if (l_list_tx_out)
+ dap_list_free(l_list_tx_out);
+ HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
+ HASH_DEL(l_values_from_prev_tx, l_value_cur);
+ DAP_DELETE(l_value_cur);
+ }
+ HASH_ITER(hh, l_values_from_cur_tx, l_value_cur, l_tmp) {
+ HASH_DEL(l_values_from_cur_tx, l_value_cur);
+ DAP_DELETE(l_value_cur);
+ }
+ return -1;
+ }
dap_chain_tx_in_t *l_tx_in = NULL;
dap_chain_addr_t l_tx_in_from={0};
dap_chain_tx_in_cond_t *l_tx_in_cond = NULL;
@@ -3786,6 +3882,16 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
HASH_FIND_STR(l_values_from_prev_tx, l_token, l_value_cur);
if (!l_value_cur) {
l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
+ if ( !l_value_cur ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_tx_cache_check");
+ if (bound_item)
+ DAP_DELETE(bound_item);
+ if ( l_list_bound_items )
+ dap_list_free_full(l_list_bound_items, NULL);
+ if (l_list_tx_out)
+ dap_list_free(l_list_tx_out);
+ return -1;
+ }
strcpy(l_value_cur->token_ticker, l_token);
HASH_ADD_STR(l_values_from_prev_tx, token_ticker, l_value_cur);
}
@@ -3823,6 +3929,16 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
} else {
l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
+ if ( !l_value_cur ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_tx_cache_check");
+ if (bound_item)
+ DAP_DELETE(bound_item);
+ if ( l_list_bound_items )
+ dap_list_free_full(l_list_bound_items, NULL);
+ if (l_list_tx_out)
+ dap_list_free(l_list_tx_out);
+ return -1;
+ }
dap_stpcpy(l_value_cur->token_ticker, l_token);
if (!l_main_ticker)
l_main_ticker = l_value_cur->token_ticker;
@@ -3895,6 +4011,16 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
HASH_FIND_STR(l_values_from_cur_tx, l_token, l_value_cur);
if (!l_value_cur) {
l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
+ if ( !l_value_cur ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_tx_cache_check");
+ if (bound_item)
+ DAP_DELETE(bound_item);
+ if ( l_list_bound_items )
+ dap_list_free_full(l_list_bound_items, NULL);
+ if (l_list_tx_out)
+ dap_list_free(l_list_tx_out);
+ return -1;
+ }
strcpy(l_value_cur->token_ticker, l_token);
HASH_ADD_STR(l_values_from_cur_tx, token_ticker, l_value_cur);
}
@@ -4164,8 +4290,17 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
s_threshold_txs_max);
} else {
l_item_tmp = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
+ if ( !l_item_tmp ) {
+ log_it(L_ERROR, "Memory allocation error in s_tx_add");
+ return -1;
+ }
l_item_tmp->tx_hash_fast = *a_tx_hash;
l_item_tmp->tx = DAP_DUP_SIZE(a_tx, dap_chain_datum_tx_get_size(a_tx));
+ if ( !l_item_tmp->tx ) {
+ DAP_DELETE(l_item_tmp);
+ log_it(L_ERROR, "Memory allocation error in s_tx_add");
+ return -1;
+ }
l_item_tmp->ts_added = dap_nanotime_now();
HASH_ADD_BYHASHVALUE(hh, l_ledger_pvt->threshold_txs, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_hash_value, l_item_tmp);
if(s_debug_more)
@@ -4189,6 +4324,14 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
size_t l_outs_used = dap_list_length(l_list_bound_items);
size_t l_cache_size = sizeof(dap_store_obj_t) * (l_outs_used + 1);
dap_store_obj_t *l_cache_used_outs = DAP_NEW_Z_SIZE(dap_store_obj_t, l_cache_size);
+ if ( !l_cache_used_outs ) {
+ if (l_item_tmp->tx)
+ DAP_DELETE(l_item_tmp->tx);
+ if (l_item_tmp)
+ DAP_DELETE(l_item_tmp);
+ log_it(L_ERROR, "Memory allocation error in s_tx_add");
+ return -1;
+ }
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
const char *l_cur_token_ticker = NULL;
@@ -4424,6 +4567,11 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
s_balance_cache_update(a_ledger, wallet_balance);
} else {
wallet_balance = DAP_NEW_Z(dap_ledger_wallet_balance_t);
+ if (!wallet_balance) {
+ log_it(L_ERROR, "Memoru allocation error in s_load_cache_gdb_loaded_txs_callback");
+ l_ret = -1;
+ goto FIN;
+ }
wallet_balance->key = l_wallet_balance_key;
strcpy(wallet_balance->token_ticker, l_cur_token_ticker);
SUM_256_256(wallet_balance->balance, l_value, &wallet_balance->balance);
@@ -4441,6 +4589,11 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
// add transaction to the cache list
dap_chain_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
+ if ( !l_tx_item ) {
+ log_it(L_ERROR, "Memory allocation error in s_load_cache_gdb_loaded_txs_callback");
+ l_ret = -1;
+ goto FIN;
+ }
l_tx_item->tx_hash_fast = *a_tx_hash;
size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
l_tx_item->tx = DAP_DUP_SIZE(a_tx, l_tx_size);
@@ -4575,6 +4728,15 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
HASH_FIND_BYHASHVALUE(hh, l_ledger_pvt->spent_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_hash_value, l_item_used);
if (!l_item_used) { // Add it to spent items
l_item_used = DAP_NEW_Z(dap_chain_ledger_tx_spent_item_t);
+ if ( !l_item_used ) {
+ if (l_item_tmp->tx)
+ DAP_DELETE(l_item_tmp->tx);
+ if (l_item_tmp)
+ DAP_DELETE(l_item_tmp);
+ pthread_rwlock_unlock(&l_ledger_pvt->ledger_rwlock);
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_tx_remove");
+ return -1;
+ }
l_item_used->tx_hash_fast = *a_tx_hash;
l_item_used->cache_data.spent_time = a_spent_time;
strncpy(l_item_used->cache_data.token_ticker, l_item_tmp->cache_data.token_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
@@ -5249,6 +5411,12 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
// Check whether used 'out' items
if (!dap_chain_ledger_tx_hash_is_used_out_item (a_ledger, &l_tx_cur_hash, l_out_idx_tmp)) {
dap_chain_tx_used_out_item_t *l_item = DAP_NEW_Z(dap_chain_tx_used_out_item_t);
+ if ( !l_item ) {
+ if (l_list_used_out)
+ dap_list_free_full(l_list_used_out, NULL);
+ dap_list_free(l_list_out_items);
+ return NULL;
+ }
l_item->tx_hash_fast = l_tx_cur_hash;
l_item->num_idx_out = l_out_idx_tmp;
l_item->value = l_value;
@@ -5275,7 +5443,7 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
return l_list_used_out;
}
-// Add new verificator callback with associated subtype. Returns 1 if callback replaced, overwise returns 0
+// Add new verificator callback with associated subtype. Returns 1 if callback replaced, -1 error, overwise returns 0
int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_chain_ledger_verificator_callback_t a_callback, dap_chain_ledger_updater_callback_t a_callback_added)
{
dap_chain_ledger_verificator_t *l_new_verificator;
@@ -5288,6 +5456,10 @@ int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype,
return 1;
}
l_new_verificator = DAP_NEW(dap_chain_ledger_verificator_t);
+ if ( !l_new_verificator ) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_ledger_verificator_add");
+ return -1;
+ }
l_new_verificator->subtype = (int)a_subtype;
l_new_verificator->callback = a_callback;
l_new_verificator->callback_added = a_callback_added;
@@ -5383,6 +5555,12 @@ dap_list_t *dap_chain_ledger_get_list_tx_cond_outs_with_val(dap_ledger_t *a_ledg
}
if (!IS_ZERO_256(l_value)) {
dap_chain_tx_used_out_item_t *l_item = DAP_NEW(dap_chain_tx_used_out_item_t);
+ if ( !l_item ) {
+ if (l_list_used_out)
+ dap_list_free_full(l_list_used_out, free);
+ dap_list_free(l_list_out_cond_items);
+ return NULL;
+ }
l_item->tx_hash_fast = l_tx_cur_hash;
l_item->num_idx_out = l_out_idx_tmp;
l_item->value = l_value;
diff --git a/modules/chain/dap_chain_pvt.c b/modules/chain/dap_chain_pvt.c
index 6c432762c2..010a4ab842 100644
--- a/modules/chain/dap_chain_pvt.c
+++ b/modules/chain/dap_chain_pvt.c
@@ -37,6 +37,10 @@
void dap_chain_add_mempool_notify_callback(dap_chain_t *a_chain, dap_store_obj_callback_notify_t a_callback, void *a_cb_arg)
{
dap_chain_gdb_notifier_t *l_notifier = DAP_NEW(dap_chain_gdb_notifier_t);
+ if (!l_notifier) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_add_mempool_notify_callback");
+ return;
+ }
l_notifier->callback = a_callback;
l_notifier->cb_arg = a_cb_arg;
DAP_CHAIN_PVT(a_chain)->mempool_notifires = dap_list_append(DAP_CHAIN_PVT(a_chain)->mempool_notifires, l_notifier);
diff --git a/modules/chain/dap_chain_tx.c b/modules/chain/dap_chain_tx.c
index b5d3441d6d..78738e7839 100644
--- a/modules/chain/dap_chain_tx.c
+++ b/modules/chain/dap_chain_tx.c
@@ -36,6 +36,10 @@
dap_chain_tx_t * dap_chain_tx_wrap_packed(dap_chain_datum_tx_t * a_tx_packed)
{
dap_chain_tx_t * l_tx = DAP_NEW_Z(dap_chain_tx_t);
+ if (!l_tx) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_tx_wrap_packed");
+ return NULL;
+ }
dap_hash_fast(a_tx_packed, dap_chain_datum_tx_get_size(a_tx_packed), &l_tx->hash);
l_tx->datum_tx = a_tx_packed;
return l_tx;
diff --git a/modules/chain/include/dap_chain_ledger.h b/modules/chain/include/dap_chain_ledger.h
index dd522a8189..77744f24bb 100644
--- a/modules/chain/include/dap_chain_ledger.h
+++ b/modules/chain/include/dap_chain_ledger.h
@@ -92,7 +92,7 @@ typedef enum dap_chain_ledger_emission_err{
DAP_CHAIN_LEDGER_EMISSION_ADD_CHECK_ZERO_VALUE,
DAP_CHAIN_LEDGER_EMISSION_ADD_TSD_CHECK_FAILED,
/* add custom codes here */
-
+ DAP_CHAIN_LEDGER_EMISSION_ADD_MEMORY_PROBLEM,
DAP_CHAIN_LEDGER_EMISSION_ADD_UNKNOWN /* MAX */
} dap_chain_ledger_emission_err_code_t;
diff --git a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
index 27629e3954..1e330ae02d 100644
--- a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
+++ b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
@@ -379,7 +379,7 @@ static void s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
dap_chain_net_srv_price_t *l_price_tmp;
DL_FOREACH(a_grace->usage->service->pricelist, l_price_tmp) {
- if (l_price_tmp && l_price_tmp->net->pub.id.uint64 == a_grace->usage->net->pub.id.uint64
+ if (l_price_tmp && l_price_tmp->net->pub.id.uint64 == a_grace->usage->net->pub.id.uint64
&& dap_strcmp(l_price_tmp->token, l_ticker) == 0
&& l_price_tmp->units_uid.enm == l_tx_out_cond->subtype.srv_pay.unit.enm
)//&& (l_price_tmp->value_datoshi/l_price_tmp->units) < l_tx_out_cond->subtype.srv_pay.header.unit_price_max_datoshi)
@@ -412,7 +412,6 @@ static void s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
dap_stream_ch_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_SIGN_REQUEST,
a_grace->usage->receipt, a_grace->usage->receipt->size);
}
-
DAP_DELETE(a_grace->request);
DAP_DELETE(a_grace);
diff --git a/modules/channel/chain-net/dap_stream_ch_chain_net.c b/modules/channel/chain-net/dap_stream_ch_chain_net.c
index 85ba2f81e1..da1d49c44e 100644
--- a/modules/channel/chain-net/dap_stream_ch_chain_net.c
+++ b/modules/channel/chain-net/dap_stream_ch_chain_net.c
@@ -173,6 +173,11 @@ void s_stream_ch_new(dap_stream_ch_t* a_ch, void* a_arg)
HASH_FIND_INT(s_chain_net_data, &a_ch->stream->session->id, l_sdata);
if(l_sdata == NULL) {
l_sdata = DAP_NEW_Z(dap_chain_net_session_data_t);
+ if (!l_sdata) {
+ log_it(L_ERROR, "Memory allocation error in s_stream_ch_new");
+ pthread_mutex_unlock(&s_hash_mutex);
+ return;
+ }
l_sdata->session_id = a_ch->stream->session->id;
HASH_ADD_INT(s_chain_net_data, session_id, l_sdata);
}
diff --git a/modules/channel/chain-voting/dap_stream_ch_chain_voting.c b/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
index 5077f939c0..a2b39e60f2 100644
--- a/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
+++ b/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
@@ -105,6 +105,10 @@ void dap_stream_ch_chain_voting_message_write(dap_chain_net_t *a_net, dap_chain_
l_node_client->client->always_reconnect = true;
l_node_client_item = DAP_NEW_Z(struct voting_node_client_list);
+ if (!l_node_client_item) {
+ log_it(L_ERROR, "Memory allocation error in dap_stream_ch_chain_voting_message_write");
+ return;
+ }
l_node_client_item->node_addr = *a_remote_node_addr;
l_node_client_item->node_info = l_node_info;
l_node_client_item->node_client = l_node_client;
diff --git a/modules/channel/chain/dap_stream_ch_chain.c b/modules/channel/chain/dap_stream_ch_chain.c
index 1b55a35784..4a08e0645d 100644
--- a/modules/channel/chain/dap_stream_ch_chain.c
+++ b/modules/channel/chain/dap_stream_ch_chain.c
@@ -800,6 +800,10 @@ struct sync_request *dap_stream_ch_chain_create_sync_request(dap_stream_ch_chain
{
dap_stream_ch_chain_t * l_ch_chain = DAP_STREAM_CH_CHAIN(a_ch);
struct sync_request *l_sync_request = DAP_NEW_Z(struct sync_request);
+ if (!l_sync_request) {
+ log_it(L_ERROR, "Memory allocation error in dap_stream_ch_chain_create_sync_request");
+ return NULL;
+ }
*l_sync_request = (struct sync_request) {
.worker = a_ch->stream_worker->worker,
.ch_uuid = a_ch->uuid,
@@ -1034,6 +1038,10 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
l_hash_item_hashv, l_hash_item);
if (!l_hash_item) {
l_hash_item = DAP_NEW_Z(dap_stream_ch_chain_hash_item_t);
+ if (!l_hash_item) {
+ log_it(L_ERROR, "Memory allocation error in s_stream_ch_packet_in");
+ return;
+ }
l_hash_item->hash = l_element->hash;
l_hash_item->size = l_element->size;
HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_gdbs, hash, sizeof(l_hash_item->hash),
@@ -1245,6 +1253,10 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
l_hash_item_hashv, l_hash_item);
if( ! l_hash_item ){
l_hash_item = DAP_NEW_Z(dap_stream_ch_chain_hash_item_t);
+ if (!l_hash_item) {
+ log_it(L_ERROR, "Memory allocation error in s_stream_ch_packet_in");
+ return;
+ }
l_hash_item->hash = l_element->hash;
l_hash_item->size = l_element->size;
HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_atoms, hash, sizeof(dap_hash_fast_t),
@@ -1671,6 +1683,10 @@ void s_stream_ch_packet_out(dap_stream_ch_t *a_ch, void *a_arg)
l_skip_count++;
} else {
l_hash_item = DAP_NEW_Z(dap_stream_ch_chain_hash_item_t);
+ if (!l_hash_item) {
+ log_it(L_ERROR, "Memory allocation error in s_stream_ch_packet_out");
+ return;
+ }
l_hash_item->hash = l_obj->hash;
l_hash_item->size = l_obj->pkt->data_size;
HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_gdbs, hash, sizeof(dap_chain_hash_fast_t),
@@ -1771,6 +1787,10 @@ void s_stream_ch_packet_out(dap_stream_ch_t *a_ch, void *a_arg)
}*/
}else{
l_hash_item = DAP_NEW_Z(dap_stream_ch_chain_hash_item_t);
+ if (!l_hash_item) {
+ log_it(L_ERROR, "Memory allocation error in s_stream_ch_packet_out");
+ return;
+ }
l_hash_item->hash = *l_ch_chain->request_atom_iter->cur_hash;
if(s_debug_more){
char l_atom_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
diff --git a/modules/common/dap_chain_common.c b/modules/common/dap_chain_common.c
index e1ccc29309..20fa9b9fc3 100644
--- a/modules/common/dap_chain_common.c
+++ b/modules/common/dap_chain_common.c
@@ -296,6 +296,10 @@ uint128_t dap_chain_uint128_from_uint256(uint256_t a_from)
char *dap_chain_balance_print128(uint128_t a_balance)
{
char *l_buf = DAP_NEW_Z_SIZE(char, DATOSHI_POW + 2);
+ if (!l_buf) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_balance_print128");
+ return NULL;
+ }
int l_pos = 0;
uint128_t l_value = a_balance;
#ifdef DAP_GLOBAL_IS_INT128
@@ -626,6 +630,10 @@ uint256_t dap_chain_coins_to_balance256(const char *a_coins)
char *dap_cvt_uint256_to_str(uint256_t a_uint256) {
char *l_buf = DAP_NEW_Z_SIZE(char, DATOSHI_POW256 + 2); // for decimal dot and trailing zero
+ if (!l_buf) {
+ log_it(L_ERROR, "Memory allocation error in dap_cvt_uint256_to_str");
+ return NULL;
+ }
int l_pos = 0;
uint256_t l_value = a_uint256;
uint256_t uint256_ten = GET_256_FROM_64(10);
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index 945c9d35e8..fa21942e37 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -349,8 +349,20 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
l_value_str);
if (((dap_chain_datum_tx_receipt_t*)item)->exts_size == sizeof(dap_sign_t) + sizeof(dap_sign_t)){
dap_sign_t *l_provider = DAP_NEW_Z(dap_sign_t);
+ if (!l_provider) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_datum_dump_tx");
+ DAP_DELETE(l_value_str);
+ DAP_DELETE(l_coins_str);
+ return false;
+ }
memcpy(l_provider, ((dap_chain_datum_tx_receipt_t*)item)->exts_n_signs, sizeof(dap_sign_t));
dap_sign_t *l_client = DAP_NEW_Z(dap_sign_t);
+ if (!l_client) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_datum_dump_tx");
+ DAP_DELETE(l_value_str);
+ DAP_DELETE(l_coins_str);
+ return false;
+ }
memcpy(l_client,
((dap_chain_datum_tx_receipt_t*)item)->exts_n_signs + sizeof(dap_sign_t),
sizeof(dap_sign_t));
@@ -361,6 +373,12 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
dap_sign_get_information(l_client, a_str_out, a_hash_out_type);
} else if (((dap_chain_datum_tx_receipt_t*)item)->exts_size == sizeof(dap_sign_t)) {
dap_sign_t *l_provider = DAP_NEW_Z(dap_sign_t);
+ if (!l_provider) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_datum_dump_tx");
+ DAP_DELETE(l_value_str);
+ DAP_DELETE(l_coins_str);
+ return false;
+ }
memcpy(l_provider, ((dap_chain_datum_tx_receipt_t*)item)->exts_n_signs, sizeof(dap_sign_t));
dap_string_append_printf(a_str_out, "Exts:\n"
" Provider:\n");
diff --git a/modules/common/dap_chain_datum_decree.c b/modules/common/dap_chain_datum_decree.c
index 40adfe8121..1a9c50e8fe 100644
--- a/modules/common/dap_chain_datum_decree.c
+++ b/modules/common/dap_chain_datum_decree.c
@@ -450,6 +450,11 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
char *l_stake_addr_signing_str = dap_chain_addr_to_str(&l_stake_addr_signing);
dap_string_append_printf(a_str_out, "\tSigning addr: %s\n", l_stake_addr_signing_str);
dap_chain_hash_fast_t *l_pkey_signing = DAP_NEW(dap_chain_hash_fast_t);
+ if (!l_pkey_signing) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_datum_decree_dump");
+ DAP_DELETE(l_stake_addr_signing_str);
+ return;
+ }
memcpy(l_pkey_signing, l_stake_addr_signing.data.key, sizeof(dap_chain_hash_fast_t));
char *l_pkey_signing_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str(l_pkey_signing)
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index fb2aba0a5b..b2504b308f 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -350,6 +350,10 @@ dap_sign_t ** dap_chain_datum_token_signs_parse(dap_chain_datum_token_t * a_datu
dap_chain_datum_token_emission_t *dap_chain_datum_emission_create(uint256_t a_value, const char *a_ticker, dap_chain_addr_t *a_addr)
{
dap_chain_datum_token_emission_t *l_emission = DAP_NEW_Z(dap_chain_datum_token_emission_t);
+ if (!l_emission) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_datum_emission_create");
+ return NULL;
+ }
l_emission->hdr.version = 3;
l_emission->hdr.value_256 = a_value;
strncpy(l_emission->hdr.ticker, a_ticker, DAP_CHAIN_TICKER_SIZE_MAX - 1);
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 6fdbfb13f1..9480c69043 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -39,6 +39,10 @@
dap_chain_datum_tx_t* dap_chain_datum_tx_create(void)
{
dap_chain_datum_tx_t *tx = DAP_NEW_Z(dap_chain_datum_tx_t);
+ if (!tx) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_datum_tx_create");
+ return 0;
+ }
tx->header.ts_created = time(NULL);
return tx;
}
diff --git a/modules/common/dap_chain_datum_tx_items.c b/modules/common/dap_chain_datum_tx_items.c
index b22863e40c..5ec7c2a87b 100644
--- a/modules/common/dap_chain_datum_tx_items.c
+++ b/modules/common/dap_chain_datum_tx_items.c
@@ -235,6 +235,9 @@ dap_chain_tx_in_ems_t *dap_chain_datum_tx_item_in_ems_create(dap_chain_id_t a_id
if(!a_ticker)
return NULL;
dap_chain_tx_in_ems_t *l_item = DAP_NEW_Z(dap_chain_tx_in_ems_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.type = TX_ITEM_TYPE_IN_EMS;
l_item->header.token_emission_chain_id.uint64 = a_id.uint64;
l_item->header.token_emission_hash = *a_datum_token_hash;;
@@ -266,6 +269,9 @@ dap_chain_tx_in_t* dap_chain_datum_tx_item_in_create(dap_chain_hash_fast_t *a_tx
if(!a_tx_prev_hash)
return NULL;
dap_chain_tx_in_t *l_item = DAP_NEW_Z(dap_chain_tx_in_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.type = TX_ITEM_TYPE_IN;
l_item->header.tx_out_prev_idx = a_tx_out_prev_idx;
l_item->header.tx_prev_hash = *a_tx_prev_hash;
@@ -325,6 +331,9 @@ dap_chain_tx_in_cond_t* dap_chain_datum_tx_item_in_cond_create(dap_chain_hash_fa
if(!a_tx_prev_hash )
return NULL;
dap_chain_tx_in_cond_t *l_item = DAP_NEW_Z(dap_chain_tx_in_cond_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.type = TX_ITEM_TYPE_IN_COND;
l_item->header.receipt_idx = a_receipt_idx;
l_item->header.tx_out_prev_idx = a_tx_out_prev_idx;
@@ -360,6 +369,9 @@ dap_chain_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a
if (!a_addr || IS_ZERO_256(a_value))
return NULL;
dap_chain_tx_out_t *l_item = DAP_NEW_Z(dap_chain_tx_out_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->addr = *a_addr;
l_item->header.type = TX_ITEM_TYPE_OUT;
l_item->header.value = a_value;
@@ -382,6 +394,9 @@ dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_a
if (IS_ZERO_256(a_value))
return NULL;
dap_chain_tx_out_ext_t *l_item = DAP_NEW_Z(dap_chain_tx_out_ext_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.type = TX_ITEM_TYPE_OUT_EXT;
l_item->header.value = a_value;
l_item->addr = *a_addr;
@@ -407,6 +422,9 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_fee(uint256_t a
if (IS_ZERO_256(a_value))
return NULL;
dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z(dap_chain_tx_out_cond_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.item_type = TX_ITEM_TYPE_OUT_COND;
l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_FEE;
@@ -544,6 +562,9 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_c
if (IS_ZERO_256(a_value))
return NULL;
dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z(dap_chain_tx_out_cond_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.item_type = TX_ITEM_TYPE_OUT_COND;
l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE;
@@ -591,6 +612,9 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake_lock(
if (IS_ZERO_256(a_value))
return NULL;
dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z(dap_chain_tx_out_cond_t);
+ if (!l_item) {
+ return NULL;
+ }
l_item->header.item_type = TX_ITEM_TYPE_OUT_COND;
l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK;
diff --git a/modules/consensus/block-poa/dap_chain_cs_block_poa.c b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
index 42641314b8..04f795aebd 100644
--- a/modules/consensus/block-poa/dap_chain_cs_block_poa.c
+++ b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
@@ -176,11 +176,19 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
dap_chain_cs_blocks_new(a_chain, a_chain_cfg);
dap_chain_cs_blocks_t * l_blocks = DAP_CHAIN_CS_BLOCKS( a_chain );
dap_chain_cs_block_poa_t * l_poa = DAP_NEW_Z ( dap_chain_cs_block_poa_t);
+ if (!l_poa) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
l_blocks->_inheritor = l_poa;
l_blocks->callback_delete = s_callback_delete;
l_blocks->callback_block_verify = s_callback_block_verify;
l_blocks->callback_block_sign = s_callback_block_sign;
l_poa->_pvt = DAP_NEW_Z(dap_chain_cs_block_poa_pvt_t);
+ if (!l_poa->_pvt) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
dap_chain_cs_block_poa_pvt_t *l_poa_pvt = PVT(l_poa);
if (dap_config_get_item_str(a_chain_cfg,"block-poa","auth_certs_prefix") ) {
@@ -190,6 +198,10 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
if (l_poa_pvt->auth_certs_count && l_poa_pvt->auth_certs_count_verify ) {
// Type sizeof's misunderstanding in malloc?
l_poa_pvt->auth_certs = DAP_NEW_Z_SIZE ( dap_cert_t *, l_poa_pvt->auth_certs_count * sizeof(dap_cert_t*));
+ if (!l_poa_pvt->auth_certs) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
char l_cert_name[512];
for (size_t i = 0; i < l_poa_pvt->auth_certs_count ; i++ ){
snprintf(l_cert_name,sizeof(l_cert_name),"%s.%zu",l_poa_pvt->auth_certs_prefix, i);
diff --git a/modules/consensus/block-pos/dap_chain_cs_block_pos.c b/modules/consensus/block-pos/dap_chain_cs_block_pos.c
index 70195b5196..53b8e25880 100644
--- a/modules/consensus/block-pos/dap_chain_cs_block_pos.c
+++ b/modules/consensus/block-pos/dap_chain_cs_block_pos.c
@@ -80,21 +80,27 @@ void dap_chain_cs_block_pos_deinit(void)
static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
{
dap_chain_cs_blocks_new(a_chain, a_chain_cfg);
+ char ** l_tokens_hold = NULL;
+ char ** l_tokens_hold_value_str = NULL;
+ uint16_t l_tokens_hold_size = 0;
+ uint16_t l_tokens_hold_value_size = 0;
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
dap_chain_cs_block_pos_t *l_pos = DAP_NEW_Z(dap_chain_cs_block_pos_t);
+ if (!l_pos) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
l_blocks->_inheritor = l_pos;
l_blocks->callback_delete = s_callback_delete;
l_blocks->callback_block_verify = s_callback_block_verify;
l_blocks->callback_block_sign = s_callback_block_sign;
l_pos->_pvt = DAP_NEW_Z(dap_chain_cs_block_pos_pvt_t);
-
+ if (!l_pos->_pvt) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
dap_chain_cs_block_pos_pvt_t *l_pos_pvt = PVT(l_pos);
- char ** l_tokens_hold = NULL;
- char ** l_tokens_hold_value_str = NULL;
- uint16_t l_tokens_hold_size = 0;
- uint16_t l_tokens_hold_value_size = 0;
-
l_tokens_hold = dap_config_get_array_str(a_chain_cfg, "block-pos", "stake_tokens", &l_tokens_hold_size);
l_tokens_hold_value_str = dap_config_get_array_str(a_chain_cfg, "block-pos", "stake_tokens_value", &l_tokens_hold_value_size);
@@ -105,8 +111,15 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
l_pos_pvt->confirmations_minimum = dap_config_get_item_uint16_default(a_chain_cfg, "block-pos", "verifications_minimum", 1);
l_pos_pvt->tokens_hold_size = l_tokens_hold_size;
l_pos_pvt->tokens_hold = DAP_NEW_Z_SIZE(char *, sizeof(char *) * l_tokens_hold_size);
+ if (!l_pos_pvt->tokens_hold) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
l_pos_pvt->tokens_hold_value = DAP_NEW_Z_SIZE(uint64_t, l_tokens_hold_value_size * sizeof(uint64_t));
-
+ if (!l_pos_pvt->tokens_hold_value) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
for (size_t i = 0; i < l_tokens_hold_value_size; i++) {
l_pos_pvt->tokens_hold[i] = dap_strdup(l_tokens_hold[i]);
if ((l_pos_pvt->tokens_hold_value[i] =
@@ -122,17 +135,22 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
return 0;
lb_err:
- for (int i = 0; i < l_tokens_hold_size; i++)
- DAP_DELETE(l_tokens_hold[i]);
- DAP_DELETE(l_tokens_hold);
- DAP_DELETE(l_pos_pvt->tokens_hold_value);
- DAP_DELETE(l_pos_pvt);
- DAP_DELETE(l_pos );
+ for (int i = 0; i < l_tokens_hold_size; i++) {
+ if (l_tokens_hold[i])
+ DAP_DELETE(l_tokens_hold[i]);
+ }
+ if (l_tokens_hold)
+ DAP_DELETE(l_tokens_hold);
+ if (l_pos_pvt->tokens_hold_value)
+ DAP_DELETE(l_pos_pvt->tokens_hold_value);
+ if (l_pos_pvt)
+ DAP_DELETE(l_pos_pvt);
+ if (l_pos)
+ DAP_DELETE(l_pos);
l_blocks->_inheritor = NULL;
l_blocks->callback_delete = NULL;
l_blocks->callback_block_verify = NULL;
return -1;
-
}
/**
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index adfd99dd67..1e566122d1 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -157,6 +157,10 @@ void dap_chain_cs_dag_poa_presign_callback_set(dap_chain_t *a_chain, dap_chain_c
dap_chain_cs_dag_poa_pvt_t * l_poa_pvt = PVT(DAP_CHAIN_CS_DAG_POA(l_dag));
l_poa_pvt->callback_pre_sign =
(dap_chain_cs_dag_poa_presign_callback_t*)DAP_NEW_Z(dap_chain_cs_dag_poa_presign_callback_t);
+ if (!l_poa_pvt->callback_pre_sign) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_dag_poa_presign_callback_set");
+ return;
+ }
l_poa_pvt->callback_pre_sign->callback = a_callback;
l_poa_pvt->callback_pre_sign->arg = a_arg;
}
@@ -332,12 +336,20 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
dap_chain_cs_dag_new(a_chain,a_chain_cfg);
dap_chain_cs_dag_t *l_dag = DAP_CHAIN_CS_DAG ( a_chain );
dap_chain_cs_dag_poa_t *l_poa = DAP_NEW_Z ( dap_chain_cs_dag_poa_t);
+ if (!l_poa) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
l_dag->_inheritor = l_poa;
l_dag->callback_delete = s_callback_delete;
l_dag->callback_cs_verify = s_callback_event_verify;
l_dag->callback_cs_event_create = s_callback_event_create;
l_dag->chain->callback_get_poa_certs = dap_chain_cs_dag_poa_get_auth_certs;
l_poa->_pvt = DAP_NEW_Z ( dap_chain_cs_dag_poa_pvt_t );
+ if (!l_poa->_pvt) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
pthread_rwlock_init(&l_poa_pvt->rounds_rwlock, NULL);
// PoA rounds
@@ -351,6 +363,10 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
l_poa_pvt->auth_certs_count_verify = dap_config_get_item_uint16_default(a_chain_cfg,"dag-poa","auth_certs_number_verify",0);
if (l_poa_pvt->auth_certs_count && l_poa_pvt->auth_certs_count_verify) {
l_poa_pvt->auth_certs = DAP_NEW_Z_SIZE ( dap_cert_t *, l_poa_pvt->auth_certs_count * sizeof(dap_cert_t *));
+ if (!l_poa_pvt->auth_certs) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
char l_cert_name[512];
for (size_t i = 0; i < l_poa_pvt->auth_certs_count ; i++ ){
snprintf(l_cert_name,sizeof(l_cert_name),"%s.%zu",l_poa_pvt->auth_certs_prefix, i);
@@ -626,6 +642,11 @@ static void s_round_event_cs_done(dap_chain_cs_dag_t * a_dag, uint64_t a_round_i
return;
}
l_callback_arg = DAP_NEW_Z(struct round_timer_arg);
+ if (!l_callback_arg) {
+ log_it(L_ERROR, "Memory allocation error in s_round_event_cs_done");
+ pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
+ return;
+ }
l_callback_arg->dag = a_dag;
l_callback_arg->round_id = a_round_id;
// placement in chain by timer
diff --git a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c b/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
index 75aa18e310..ec07f04253 100644
--- a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
+++ b/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
@@ -81,13 +81,11 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
{
dap_chain_cs_dag_new(a_chain,a_chain_cfg);
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG ( a_chain );
- dap_chain_cs_dag_pos_t * l_pos = DAP_NEW_Z ( dap_chain_cs_dag_pos_t);
- l_dag->_inheritor = l_pos;
- l_dag->callback_delete = s_callback_delete;
- l_dag->callback_cs_verify = s_callback_event_verify;
- l_dag->callback_cs_event_create = s_callback_event_create;
- l_pos->_pvt = DAP_NEW_Z ( dap_chain_cs_dag_pos_pvt_t );
-
+ dap_chain_cs_dag_pos_t *l_pos = DAP_NEW_Z( dap_chain_cs_dag_pos_t);
+ if (!l_pos) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ return -1;
+ }
dap_chain_cs_dag_pos_pvt_t * l_pos_pvt = PVT ( l_pos );
char ** l_tokens_hold = NULL;
@@ -95,21 +93,37 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
uint16_t l_tokens_hold_size = 0;
uint16_t l_tokens_hold_value_size = 0;
+ l_dag->_inheritor = l_pos;
+ l_dag->callback_delete = s_callback_delete;
+ l_dag->callback_cs_verify = s_callback_event_verify;
+ l_dag->callback_cs_event_create = s_callback_event_create;
+ l_pos->_pvt = DAP_NEW_Z ( dap_chain_cs_dag_pos_pvt_t );
+ if (!l_pos->_pvt) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
+
l_tokens_hold = dap_config_get_array_str( a_chain_cfg,"dag-pos","tokens_hold",&l_tokens_hold_size);
l_tokens_hold_value_str = dap_config_get_array_str( a_chain_cfg,"dag-pos","tokens_hold_value",&l_tokens_hold_value_size);
if ( l_tokens_hold_size != l_tokens_hold_value_size ){
- log_it(L_CRITICAL, "tokens_hold and tokens_hold_value are different size!");
+ log_it(L_CRITICAL, "Entries tokens_hold and tokens_hold_value are different size!");
goto lb_err;
}
l_pos_pvt->confirmations_minimum = dap_config_get_item_uint16_default( a_chain_cfg,"dag-pos","confirmations_minimum",1);
l_pos_pvt->tokens_hold_size = l_tokens_hold_size;
l_pos_pvt->tokens_hold = DAP_NEW_Z_SIZE( char*, sizeof(char*) *
l_tokens_hold_size );
-
+ if (!l_pos_pvt->tokens_hold) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
l_pos_pvt->tokens_hold_value = DAP_NEW_Z_SIZE(uint64_t,
(l_tokens_hold_value_size +1) *sizeof (uint64_t));
-
+ if (!l_pos_pvt->tokens_hold_value) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ goto lb_err;
+ }
for (size_t i = 0; i < l_tokens_hold_value_size; i++){
l_pos_pvt->tokens_hold[i] = dap_strdup( l_tokens_hold[i] );
if ( ( l_pos_pvt->tokens_hold_value[i] =
@@ -123,12 +137,18 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
return 0;
lb_err:
- for (int i = 0; i < l_tokens_hold_size; i++ )
- DAP_DELETE(l_tokens_hold[i]);
- DAP_DELETE(l_tokens_hold);
- DAP_DELETE( l_pos_pvt->tokens_hold_value);
- DAP_DELETE( l_pos_pvt);
- DAP_DELETE(l_pos );
+ for (int i = 0; i < l_tokens_hold_size; i++) {
+ if (l_tokens_hold[i])
+ DAP_DELETE(l_tokens_hold[i]);
+ }
+ if (l_tokens_hold)
+ DAP_DELETE(l_tokens_hold);
+ if (l_pos_pvt->tokens_hold_value)
+ DAP_DELETE(l_pos_pvt->tokens_hold_value);
+ if (l_pos_pvt)
+ DAP_DELETE(l_pos_pvt);
+ if (l_pos)
+ DAP_DELETE(l_pos);
l_dag->_inheritor = NULL;
l_dag->callback_delete = NULL;
l_dag->callback_cs_verify = NULL;
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 743255587b..8d1df94841 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -164,7 +164,13 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
dap_chain_cs_blocks_new(a_chain, a_chain_cfg);
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
+ int l_ret = 0;
dap_chain_esbocs_t *l_esbocs = DAP_NEW_Z(dap_chain_esbocs_t);
+ if (!l_esbocs) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ l_ret = - 5;
+ goto lb_err;
+ }
l_esbocs->blocks = l_blocks;
l_blocks->_inheritor = l_esbocs;
l_blocks->callback_delete = s_callback_delete;
@@ -177,6 +183,11 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
a_chain->callback_get_signing_certificate = s_callback_get_sign_key;
l_esbocs->_pvt = DAP_NEW_Z(dap_chain_esbocs_pvt_t);
+ if (!l_esbocs->_pvt) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ l_ret = - 5;
+ goto lb_err;
+ }
dap_chain_esbocs_pvt_t *l_esbocs_pvt = PVT(l_esbocs);
l_esbocs_pvt->debug = dap_config_get_item_bool_default(a_chain_cfg, "esbocs", "consensus_debug", false);
l_esbocs_pvt->poa_mode = dap_config_get_item_bool_default(a_chain_cfg, "esbocs", "poa_mode", false);
@@ -185,7 +196,6 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
l_esbocs_pvt->round_attempts_max = dap_config_get_item_uint16_default(a_chain_cfg, "esbocs", "round_attempts_max", 4);
l_esbocs_pvt->round_attempt_timeout = dap_config_get_item_uint16_default(a_chain_cfg, "esbocs", "round_attempt_timeout", 10);
- int l_ret = 0;
l_esbocs_pvt->start_validators_min = l_esbocs_pvt->min_validators_count =
dap_config_get_item_uint16(a_chain_cfg, "esbocs", "min_validators_count");
if (!l_esbocs_pvt->min_validators_count) {
@@ -227,6 +237,11 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
DAP_DELETE(l_signer_addr);
dap_chain_esbocs_validator_t *l_validator = DAP_NEW_Z(dap_chain_esbocs_validator_t);
+ if (!l_validator) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_new");
+ l_ret = - 5;
+ goto lb_err;
+ }
l_validator->signing_addr = l_signing_addr;
l_validator->node_addr = l_signer_node_addr;
l_validator->weight = uint256_1;
@@ -246,8 +261,10 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
lb_err:
dap_list_free_full(l_esbocs_pvt->poa_validators, NULL);
- DAP_DELETE(l_esbocs_pvt);
- DAP_DELETE(l_esbocs);
+ if (l_esbocs_pvt)
+ DAP_DELETE(l_esbocs_pvt);
+ if (l_esbocs)
+ DAP_DELETE(l_esbocs);
l_blocks->_inheritor = NULL;
l_blocks->callback_delete = NULL;
l_blocks->callback_block_verify = NULL;
@@ -509,6 +526,10 @@ static void *s_callback_list_copy(const void *a_validator, UNUSED_ARG void *a_da
static void *s_callback_list_form(const void *a_srv_validator, UNUSED_ARG void *a_data)
{
dap_chain_esbocs_validator_t *l_validator = DAP_NEW_Z(dap_chain_esbocs_validator_t);
+ if (!l_validator) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_list_form");
+ return NULL;
+ }
l_validator->node_addr = ((dap_chain_net_srv_stake_item_t *)a_srv_validator)->node_addr;
l_validator->signing_addr = ((dap_chain_net_srv_stake_item_t *)a_srv_validator)->signing_addr;
l_validator->weight = ((dap_chain_net_srv_stake_item_t *)a_srv_validator)->value;
@@ -1183,6 +1204,10 @@ static void s_message_chain_add(dap_chain_esbocs_session_t *a_session,
}
dap_chain_esbocs_round_t *l_round = &a_session->cur_round;
dap_chain_esbocs_message_item_t *l_message_item = DAP_NEW_Z(dap_chain_esbocs_message_item_t);
+ if (!l_message_item) {
+ log_it(L_ERROR, "Memory allocation error in s_message_chain_add");
+ return;
+ }
if (!a_message_hash) {
dap_chain_hash_fast_t l_message_hash;
dap_hash_fast(a_message, a_message_size, &l_message_hash);
@@ -1541,7 +1566,15 @@ static void s_session_round_finish(dap_chain_esbocs_session_t *a_session, dap_ch
l_compare && PVT(a_session->esbocs)->fee_addr) {
fee_serv_param_t *tmp = DAP_NEW(fee_serv_param_t);
+ if (!tmp) {
+ log_it(L_ERROR, "Memory allocation error in s_session_round_finish");
+ return;
+ }
dap_chain_addr_t * addr = DAP_NEW_Z(dap_chain_addr_t);
+ if (!addr) {
+ log_it(L_ERROR, "Memory allocation error in s_session_round_finish");
+ return;
+ }
*addr = *PVT(a_session->esbocs)->fee_addr;
tmp->a_addr_to = addr;
tmp->block_hash = l_precommit_candidate_hash;
@@ -1560,6 +1593,10 @@ void s_session_sync_queue_add(dap_chain_esbocs_session_t *a_session, dap_chain_e
HASH_FIND(hh, a_session->sync_items, &a_message->hdr.candidate_hash, sizeof(dap_hash_fast_t), l_sync_item);
if (!l_sync_item) {
l_sync_item = DAP_NEW_Z(dap_chain_esbocs_sync_item_t);
+ if (!l_sync_item) {
+ log_it(L_ERROR, "Memory allocation error in s_session_sync_queue_add");
+ return;
+ }
l_sync_item->last_block_hash = a_message->hdr.candidate_hash;
HASH_ADD(hh, a_session->sync_items, last_block_hash, sizeof(dap_hash_fast_t), l_sync_item);
}
@@ -2092,6 +2129,10 @@ static void s_session_packet_in(void *a_arg, dap_chain_node_addr_t *a_sender_nod
// store for new candidate
l_store = DAP_NEW_Z(dap_chain_esbocs_store_t);
+ if (!l_store) {
+ log_it(L_ERROR, "Memory allocation error in s_session_packet_in");
+ goto session_unlock;
+ }
l_store->candidate_size = l_candidate_size;
l_store->candidate_hash = *l_candidate_hash;
l_store->candidate = DAP_DUP_SIZE(l_candidate, l_candidate_size);
@@ -2491,12 +2532,21 @@ static dap_chain_datum_decree_t *s_esbocs_decree_set_min_validators_count(dap_ch
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(uint256_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in s_esbocs_decree_set_min_validators_count");
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT;
l_tsd->size = sizeof(uint256_t);
*(uint256_t*)(l_tsd->data) = a_value;
l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
l_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, sizeof(dap_chain_datum_decree_t) + l_total_tsd_size);
+ if (!l_decree) {
+ log_it(L_ERROR, "Memory allocation error in s_esbocs_decree_set_min_validators_count");
+ DAP_DEL_Z(l_tsd);
+ return NULL;
+ }
l_decree->decree_version = DAP_CHAIN_DATUM_DECREE_VERSION;
l_decree->header.ts_created = dap_time_now();
l_decree->header.type = DAP_CHAIN_DATUM_DECREE_TYPE_COMMON;
@@ -2506,6 +2556,7 @@ static dap_chain_datum_decree_t *s_esbocs_decree_set_min_validators_count(dap_ch
l_chain = dap_chain_net_get_default_chain_by_chain_type(a_net, CHAIN_TYPE_ANCHOR);
if(!l_chain){
log_it(L_ERROR, "Can't find chain with decree support.");
+ DAP_DEL_Z(l_tsd);
DAP_DELETE(l_decree);
return NULL;
}
@@ -2541,10 +2592,12 @@ static dap_chain_datum_decree_t *s_esbocs_decree_set_min_validators_count(dap_ch
log_it(L_DEBUG,"<-- Signed with '%s'", a_cert->name);
}else{
log_it(L_ERROR, "Decree signing failed");
+ DAP_DEL_Z(l_tsd);
DAP_DELETE(l_decree);
return NULL;
}
-
+
+ DAP_DEL_Z(l_tsd);
return l_decree;
}
diff --git a/modules/consensus/none/dap_chain_cs_none.c b/modules/consensus/none/dap_chain_cs_none.c
index 25d0303b86..b9d4c4b149 100644
--- a/modules/consensus/none/dap_chain_cs_none.c
+++ b/modules/consensus/none/dap_chain_cs_none.c
@@ -171,7 +171,16 @@ static void s_callback_memepool_notify(dap_global_db_context_t *a_context UNUSED
int dap_chain_gdb_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
{
dap_chain_gdb_t *l_gdb = DAP_NEW_Z(dap_chain_gdb_t);
+ if (!l_gdb) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_gdb_new");
+ return -1;
+ }
dap_chain_gdb_private_t *l_gdb_priv = DAP_NEW_Z(dap_chain_gdb_private_t);
+ if (!l_gdb_priv) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_gdb_new");
+ DAP_DELETE(l_gdb);
+ return -1;
+ }
l_gdb->chain = a_chain;
l_gdb->_internal = (void*) l_gdb_priv;
a_chain->_inheritor = l_gdb;
@@ -386,6 +395,10 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
return ATOM_REJECT;
dap_chain_gdb_datum_hash_item_t * l_hash_item = DAP_NEW_Z(dap_chain_gdb_datum_hash_item_t);
+ if (!l_hash_item) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_add");
+ return ATOM_REJECT;
+ }
size_t l_datum_size = dap_chain_datum_size(l_datum);
dap_hash_fast(l_datum->data,l_datum->header.data_size,&l_hash_item->datum_data_hash );
dap_chain_hash_fast_to_str(&l_hash_item->datum_data_hash, l_hash_item->key, sizeof(l_hash_item->key));
@@ -438,6 +451,10 @@ static size_t s_chain_callback_atom_get_static_hdr_size()
static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold)
{
dap_chain_atom_iter_t * l_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
+ if (!l_iter) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_iter_create");
+ return NULL;
+ }
l_iter->chain = a_chain;
l_iter->cell_id = a_cell_id;
l_iter->with_treshold = a_with_treshold;
@@ -456,6 +473,10 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
dap_chain_atom_ptr_t a_atom, size_t a_atom_size)
{
dap_chain_atom_iter_t * l_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
+ if (!l_iter) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_iter_create");
+ return NULL;
+ }
l_iter->chain = a_chain;
l_iter->cur = a_atom;
l_iter->cur_size = a_atom_size;
@@ -621,6 +642,10 @@ static dap_chain_datum_t **s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t
dap_chain_datum_t *l_datum = (dap_chain_datum_t *)a_atom;
if (l_datum){
dap_chain_datum_t **l_datums = DAP_NEW(dap_chain_datum_t *);
+ if (!l_datums) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_get_datum");
+ return NULL;
+ }
if (a_datums_count)
*a_datums_count = 1;
l_datums[0] = l_datum;
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index a3478c334b..be5d6ae3db 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -533,6 +533,12 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
}
if ( memcmp(&l_out->addr, a_addr_from, sizeof (*a_addr_from))==0 ){
dap_chain_tx_used_out_item_t *l_item_back = DAP_NEW_Z(dap_chain_tx_used_out_item_t);
+ if (!l_item_back) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_mempool_tx_create_massive");
+ DAP_DELETE(l_objs);
+ dap_list_free( l_list_out_items);
+ return -6;
+ }
l_item_back->tx_hash_fast = l_tx_new_hash;
l_item_back->num_idx_out = l_out_idx_tmp;
l_item_back->value = l_value_back;
@@ -1034,6 +1040,10 @@ dap_datum_mempool_t * dap_datum_mempool_deserialize(uint8_t *a_datum_mempool_ser
//uint8_t *a_datum_mempool_ser = DAP_NEW_Z_SIZE(uint8_t, datum_mempool_size / 2 + 1);
//datum_mempool_size = hex2bin(a_datum_mempool_ser, datum_mempool_str_in, datum_mempool_size) / 2;
dap_datum_mempool_t *datum_mempool = DAP_NEW_Z(dap_datum_mempool_t);
+ if (!datum_mempool) {
+ log_it(L_ERROR, "Memory allocation error in dap_datum_mempool_deserialize");
+ return NULL;
+ }
datum_mempool->version = *(uint16_t*)(a_datum_mempool_ser + shift_size);
shift_size += sizeof(uint16_t);
datum_mempool->datum_count = *(uint16_t*)(a_datum_mempool_ser + shift_size);
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 648297520d..4d2193d831 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -445,6 +445,10 @@ dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t *a_net)
void dap_chain_net_add_gdb_notify_callback(dap_chain_net_t *a_net, dap_store_obj_callback_notify_t a_callback, void *a_cb_arg)
{
dap_chain_gdb_notifier_t *l_notifier = DAP_NEW(dap_chain_gdb_notifier_t);
+ if (!l_notifier) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_add_gdb_notify_callback");
+ return;
+ }
l_notifier->callback = a_callback;
l_notifier->cb_arg = a_cb_arg;
PVT(a_net)->gdb_notifiers = dap_list_append(PVT(a_net)->gdb_notifiers, l_notifier);
@@ -465,6 +469,11 @@ int dap_chain_net_add_downlink(dap_chain_net_t *a_net, dap_stream_worker_t *a_wo
return -2;
}
l_downlink = DAP_NEW_Z(struct downlink);
+ if (l_downlink) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_add_downlink");
+ pthread_rwlock_unlock(&l_net_pvt->downlinks_lock);
+ return -1;
+ }
l_downlink->worker = a_worker;
l_downlink->ch_uuid = a_ch_uuid;
l_downlink->esocket_uuid = a_esocket_uuid;
@@ -566,6 +575,10 @@ static void s_chain_callback_notify(void *a_arg, dap_chain_t *a_chain, dap_chain
return;
struct net_broadcast_atoms_args *l_args = DAP_NEW(struct net_broadcast_atoms_args);
+ if (!l_args) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_notify");
+ return;
+ }
l_args->net = l_net;
l_args->atom = DAP_DUP_SIZE(a_atom, a_atom_size);
l_args->atom_size = a_atom_size;
@@ -690,6 +703,11 @@ static int s_net_link_add(dap_chain_net_t *a_net, dap_chain_node_info_t *a_link_
return -3;
}
l_new_link = DAP_NEW_Z(struct net_link);
+ if (!l_new_link) {
+ log_it(L_ERROR, "Memory allocation error in s_net_link_add");
+ pthread_mutex_unlock(&PVT(a_net)->uplinks_mutex);
+ return -4;
+ }
l_new_link->link_info = DAP_DUP(a_link_node_info);
l_new_link->uplink_ip = a_link_node_info->hdr.ext_addr_v4.s_addr;
HASH_ADD(hh, l_pvt_net->net_links, uplink_ip, sizeof(l_new_link->uplink_ip), l_new_link);
@@ -1138,6 +1156,10 @@ static bool s_new_balancer_link_request(dap_chain_net_t *a_net, int a_link_repla
inet_ntop(AF_INET, &l_link_node_info->hdr.ext_addr_v4, l_node_addr_str, INET_ADDRSTRLEN);
log_it(L_DEBUG, "Start balancer %s request to %s", PVT(a_net)->balancer_http ? "HTTP" : "DNS", l_node_addr_str);
struct balancer_link_request *l_balancer_request = DAP_NEW_Z(struct balancer_link_request);
+ if (!l_balancer_request) {
+ log_it(L_ERROR, "Memory allocation error in s_new_balancer_link_request");
+ return false;
+ }
l_balancer_request->net = a_net;
l_balancer_request->link_info = l_link_node_info;
l_balancer_request->worker = dap_events_worker_get_auto();
@@ -1295,6 +1317,11 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
if (i >= l_net_pvt->gdb_sync_nodes_addrs_count)
break;
dap_chain_node_info_t *l_link_node_info = DAP_NEW_Z(dap_chain_node_info_t);
+ if (!l_link_node_info) {
+ log_it(L_ERROR, "Memory allocation error in s_net_states_proc");
+ pthread_rwlock_unlock(&l_net_pvt->states_lock);
+ return false;
+ }
l_link_node_info->hdr.address.uint64 = l_net_pvt->gdb_sync_nodes_addrs[i].uint64;
l_link_node_info->hdr.ext_addr_v4.s_addr = l_net_pvt->gdb_sync_nodes_links_ips[i];
l_link_node_info->hdr.ext_port = l_net_pvt->gdb_sync_nodes_links_ports[i];
@@ -1452,6 +1479,10 @@ static dap_chain_net_t *s_net_new(const char *a_id, const char *a_name,
if (!a_id || !a_name || !a_native_ticker || !a_node_role)
return NULL;
dap_chain_net_t *ret = DAP_NEW_Z_SIZE( dap_chain_net_t, sizeof(ret->pub) + sizeof(dap_chain_net_pvt_t) );
+ if (!ret) {
+ log_it(L_ERROR, "Memory allocation error in s_net_new");
+ return NULL;
+ }
ret->pub.name = strdup( a_name );
ret->pub.native_ticker = strdup( a_native_ticker );
pthread_mutexattr_t l_mutex_attr;
@@ -2259,6 +2290,11 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
if(l_gdb_sync_nodes_addrs && l_net_pvt->gdb_sync_nodes_addrs_count > 0) {
l_net_pvt->gdb_sync_nodes_addrs = DAP_NEW_Z_SIZE(dap_chain_node_addr_t,
sizeof(dap_chain_node_addr_t)*l_net_pvt->gdb_sync_nodes_addrs_count);
+ if (!l_net_pvt->gdb_sync_nodes_addrs) {
+ log_it(L_ERROR, "Memory allocation error in s_net_init");
+ dap_config_close(l_cfg);
+ return -1;
+ }
for(uint16_t i = 0; i < l_net_pvt->gdb_sync_nodes_addrs_count; i++) {
dap_chain_node_addr_from_str(l_net_pvt->gdb_sync_nodes_addrs + i, l_gdb_sync_nodes_addrs[i]);
}
@@ -2269,16 +2305,26 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
char **l_gdb_sync_nodes_links = dap_config_get_array_str(l_cfg, "general", "gdb_sync_nodes_links", &l_gdb_links_count);
if (l_gdb_sync_nodes_links && l_gdb_links_count > 0) {
l_net_pvt->gdb_sync_nodes_links_ips = DAP_NEW_Z_SIZE(uint32_t, l_gdb_links_count * sizeof(uint32_t));
+ if (!l_net_pvt->gdb_sync_nodes_links_ips) {
+ log_it(L_ERROR, "Memory allocation error in s_net_init");
+ dap_config_close(l_cfg);
+ return -1;
+ }
l_net_pvt->gdb_sync_nodes_links_ports = DAP_NEW_SIZE(uint16_t, l_gdb_links_count * sizeof(uint16_t));
+ if (!l_net_pvt->gdb_sync_nodes_links_ports) {
+ log_it(L_ERROR, "Memory allocation error in s_net_init");
+ DAP_DEL_Z(l_net_pvt->gdb_sync_nodes_links_ips);
+ dap_config_close(l_cfg);
+ return -1;
+ }
for(uint16_t i = 0; i < l_gdb_links_count; i++) {
char *l_gdb_link_port_str = strchr(l_gdb_sync_nodes_links[i], ':');
if (!l_gdb_link_port_str) {
continue;
}
uint16_t l_gdb_link_port = atoi(l_gdb_link_port_str + 1);
- if (!l_gdb_link_port) {
+ if (!l_gdb_link_port)
continue;
- }
int l_gdb_link_len = l_gdb_link_port_str - l_gdb_sync_nodes_links[i];
char l_gdb_link_ip_str[l_gdb_link_len + 1];
memcpy(l_gdb_link_ip_str, l_gdb_sync_nodes_links[i], l_gdb_link_len);
@@ -2303,6 +2349,11 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
// Add network to the list
dap_chain_net_item_t * l_net_item = DAP_NEW_Z( dap_chain_net_item_t);
+ if (!l_net_item) {
+ log_it(L_ERROR, "Memory allocation error in s_net_init");
+ dap_config_close(l_cfg);
+ return -1;
+ }
snprintf(l_net_item->name,sizeof (l_net_item->name),"%s"
,dap_config_get_item_str(l_cfg , "general" , "name" ));
l_net_item->chain_net = l_net;
@@ -2593,6 +2644,13 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
dap_config_t * l_cfg = dap_config_open(l_chains_path);
if(l_cfg) {
list_priority *l_chain_prior = DAP_NEW_Z(list_priority);
+ if (!l_chain_prior) {
+ log_it(L_ERROR, "Memory allocation error in s_net_init");
+ DAP_DELETE (l_entry_name);
+ closedir(l_chains_dir);
+ dap_config_close(l_cfg);
+ return -1;
+ }
l_chain_prior->prior = dap_config_get_item_uint16_default(l_cfg, "chain", "load_priority", 100);
l_chain_prior->chains_path = l_chains_path;
// add chain to load list;
@@ -2836,6 +2894,11 @@ dap_chain_net_t **dap_chain_net_list(uint16_t *a_size)
*a_size = HASH_COUNT(s_net_items);
if(*a_size){
dap_chain_net_t **l_net_list = DAP_NEW_SIZE(dap_chain_net_t *, (*a_size) * sizeof(dap_chain_net_t *));
+ if (!l_net_list) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_list");
+ pthread_rwlock_unlock(&s_net_items_rwlock);
+ return NULL;
+ }
dap_chain_net_item_t *l_current_item, *l_tmp;
int i = 0;
HASH_ITER(hh, s_net_items, l_current_item, l_tmp) {
@@ -2843,8 +2906,8 @@ dap_chain_net_t **dap_chain_net_list(uint16_t *a_size)
if(i > *a_size)
break;
}
- return l_net_list;
pthread_rwlock_unlock(&s_net_items_rwlock);
+ return l_net_list;
} else {
pthread_rwlock_unlock(&s_net_items_rwlock);
return NULL;
@@ -3100,10 +3163,15 @@ dap_list_t* dap_chain_net_get_link_node_list(dap_chain_net_t * l_net, bool a_is_
dap_chain_node_info_t *l_remote_node_info = dap_chain_node_info_read(l_net, l_remote_address);
if(!l_remote_node_info || l_remote_node_info->hdr.cell_id.uint64 != l_cur_node_info->hdr.cell_id.uint64)
l_is_add = false;
- DAP_DELETE(l_remote_node_info);
+ if (l_remote_node_info)
+ DAP_DELETE(l_remote_node_info);
}
if(l_is_add) {
dap_chain_node_addr_t *l_address = DAP_NEW(dap_chain_node_addr_t);
+ if (!l_address) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_get_link_node_list");
+ return NULL;
+ }
l_address->uint64 = l_cur_node_info->links[i].uint64;
l_node_list = dap_list_append(l_node_list, l_address);
}
@@ -3138,6 +3206,10 @@ dap_list_t* dap_chain_net_get_node_list(dap_chain_net_t * l_net)
for(size_t i = 0; i < l_nodes_count; i++) {
dap_chain_node_info_t *l_node_info = (dap_chain_node_info_t *) l_objs[i].value;
dap_chain_node_addr_t *l_address = DAP_NEW(dap_chain_node_addr_t);
+ if (!l_address) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_get_node_list");
+ return NULL;
+ }
l_address->uint64 = l_node_info->hdr.address.uint64;
l_node_list = dap_list_append(l_node_list, l_address);
}
@@ -3337,6 +3409,11 @@ static uint8_t *s_net_set_acl(dap_chain_hash_fast_t *a_pkey_hash)
dap_chain_net_t **l_net_list = dap_chain_net_list(&l_net_count);
if (l_net_count && l_net_list) {
uint8_t *l_ret = DAP_NEW_SIZE(uint8_t, l_net_count);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in s_net_set_acl");
+ DAP_DELETE(l_net_list);
+ return NULL;
+ }
for (uint16_t i = 0; i < l_net_count; i++) {
l_ret[i] = s_net_check_acl(l_net_list[i], a_pkey_hash);
}
@@ -3387,7 +3464,12 @@ dap_list_t* dap_chain_datum_list(dap_chain_net_t *a_net, dap_chain_t *a_chain, d
*/
l_sz = sizeof(dap_chain_datum_t) + l_datum->header.data_size + 16;
l_datum2 = DAP_NEW_Z_SIZE(dap_chain_datum_t, l_sz);
- assert ( l_datum2 );
+ if (!l_datum2) {
+ log_it(L_ERROR, "Memory allocation in dap_chain_datum_list");
+ DAP_DEL_Z(l_datums);
+ dap_list_free(l_list);
+ return NULL;
+ }
memcpy(l_datum2, l_datum, l_sz);
/* Add new entry into the list */
diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index b21a20d888..50aefc9b42 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -81,6 +81,11 @@ dap_chain_node_info_t *dap_chain_net_balancer_get_node(const char *a_net_name)
l_node_num = rand() % l_nodes_count;
l_node_candidate = (dap_chain_node_info_t *)dap_list_nth_data(l_objs_list,l_node_num);
dap_chain_node_info_t *l_node_info = DAP_NEW_Z(dap_chain_node_info_t);
+ if (!l_node_info) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_balancer_get_node");
+ dap_list_free(l_objs_list);
+ return NULL;
+ }
memcpy(l_node_info, l_node_candidate, sizeof(dap_chain_node_info_t));
dap_list_free(l_objs_list);
return l_node_info;
diff --git a/modules/net/dap_chain_net_decree.c b/modules/net/dap_chain_net_decree.c
index a334887a54..5ffef5faec 100644
--- a/modules/net/dap_chain_net_decree.c
+++ b/modules/net/dap_chain_net_decree.c
@@ -265,11 +265,15 @@ int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_d
return -110;
}
if (l_decree_hh->is_applied) {
- log_it(L_WARNING,"Decree already applyed");
+ log_it(L_WARNING,"Decree already applied");
return -111;
}
} else {
l_decree_hh = DAP_NEW_Z(struct decree_hh);
+ if (!l_decree_hh) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_decree_apply");
+ return -1;
+ }
l_decree_hh->decree = DAP_DUP_SIZE(a_decree, dap_chain_datum_decree_get_size(a_decree));
l_decree_hh->key = *a_decree_hash;
HASH_ADD(hh, s_decree_hh, key, sizeof(dap_hash_fast_t), l_decree_hh);
@@ -386,6 +390,10 @@ static int s_common_decree_handler(dap_chain_datum_decree_t * a_decree, dap_chai
}
} else{
dap_chain_addr_t *l_decree_addr = DAP_NEW_Z_SIZE(dap_chain_addr_t, sizeof(dap_chain_addr_t));
+ if (!l_decree_addr) {
+ log_it(L_ERROR, "Memory allocation error in s_common_decree_handler");
+ return -1;
+ }
memcpy(l_decree_addr, &l_addr, sizeof(dap_chain_addr_t));
l_net->pub.decree->fee_addr = l_decree_addr;
}
diff --git a/modules/net/dap_chain_net_tx.c b/modules/net/dap_chain_net_tx.c
index a3e7548543..40973efac8 100644
--- a/modules/net/dap_chain_net_tx.c
+++ b/modules/net/dap_chain_net_tx.c
@@ -45,6 +45,10 @@ dap_chain_datum_tx_spends_items_t * dap_chain_net_get_tx_cond_all_with_spends_by
{
dap_ledger_t * l_ledger = a_net->pub.ledger;
dap_chain_datum_tx_spends_items_t * l_ret = DAP_NEW_Z(dap_chain_datum_tx_spends_items_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_get_tx_cond_all_with_spends_by_srv_uid");
+ return NULL;
+ }
switch (a_search_type) {
case TX_SEARCH_TYPE_NET:
@@ -113,6 +117,11 @@ dap_chain_datum_tx_spends_items_t * dap_chain_net_get_tx_cond_all_with_spends_by
if (l_tx_prev_out_item){ // we found previous out_cond with target srv_uid
dap_chain_datum_tx_spends_item_t *l_item_in = DAP_NEW_Z(dap_chain_datum_tx_spends_item_t);
+ if (!l_item_in) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_get_tx_cond_all_with_spends_by_srv_uid");
+ DAP_DEL_Z(l_datums);
+ return NULL;
+ }
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
dap_chain_datum_tx_t * l_tx_dup = DAP_DUP_SIZE(l_tx,l_tx_size);
dap_hash_fast(l_tx_dup,l_tx_size, &l_item_in->tx_hash);
@@ -130,6 +139,11 @@ dap_chain_datum_tx_spends_items_t * dap_chain_net_get_tx_cond_all_with_spends_by
dap_chain_tx_out_cond_t * l_tx_out_cond = (dap_chain_tx_out_cond_t *)l_item;
if(l_tx_out_cond->header.srv_uid.uint64 == a_srv_uid.uint64){
dap_chain_datum_tx_spends_item_t * l_item = DAP_NEW_Z(dap_chain_datum_tx_spends_item_t);
+ if (!l_item) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_get_tx_cond_all_with_spends_by_srv_uid");
+ DAP_DEL_Z(l_datums);
+ return NULL;
+ }
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
dap_chain_datum_tx_t * l_tx_dup = DAP_DUP_SIZE(l_tx,l_tx_size);
dap_hash_fast(l_tx,l_tx_size, &l_item->tx_hash);
@@ -316,6 +330,10 @@ static void s_get_tx_cond_chain_callback(dap_chain_net_t* a_net, dap_chain_datum
dap_list_t * dap_chain_net_get_tx_cond_chain(dap_chain_net_t * a_net, dap_hash_fast_t * a_tx_hash, dap_chain_net_srv_uid_t a_srv_uid)
{
struct get_tx_cond_all_from_tx * l_args = DAP_NEW_Z(struct get_tx_cond_all_from_tx);
+ if (!l_args) {
+ log_it (L_ERROR, "Memory allocation error in dap_chain_net_get_tx_cond_all_for_addr");
+ return NULL;
+ }
l_args->tx_begin_hash = a_tx_hash;
l_args->srv_uid = a_srv_uid;
dap_chain_net_get_tx_all(a_net,TX_SEARCH_TYPE_NET,s_get_tx_cond_chain_callback, l_args);
@@ -430,6 +448,10 @@ static void s_get_tx_cond_all_for_addr_callback(dap_chain_net_t* a_net, dap_chai
dap_list_t * dap_chain_net_get_tx_cond_all_for_addr(dap_chain_net_t * a_net, dap_chain_addr_t * a_addr, dap_chain_net_srv_uid_t a_srv_uid)
{
struct get_tx_cond_all_for_addr * l_args = DAP_NEW_Z(struct get_tx_cond_all_for_addr);
+ if (!l_args) {
+ log_it (L_ERROR, "Memory allocation error in dap_chain_net_get_tx_cond_all_for_addr");
+ return NULL;
+ }
l_args->addr = a_addr;
l_args->srv_uid = a_srv_uid;
dap_chain_net_get_tx_all(a_net,TX_SEARCH_TYPE_NET,s_get_tx_cond_all_for_addr_callback, l_args);
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index dc81e4636f..b646c2bf11 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -55,6 +55,10 @@
dap_chain_node_addr_t* dap_chain_node_gen_addr(dap_chain_net_id_t a_net_id)
{
dap_chain_node_addr_t *l_addr = DAP_NEW_Z(dap_chain_node_addr_t);
+ if (!l_addr) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_node_gen_addr");
+ return NULL;
+ }
dap_chain_hash_fast_t l_hash;
dap_hash_fast(&a_net_id, sizeof(dap_chain_net_id_t), &l_hash);
// first 4 bytes is last 4 bytes of shard id hash
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 27d07c0709..761dc607da 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -187,6 +187,10 @@ static dap_chain_node_addr_t* s_node_info_get_addr(dap_chain_net_t * a_net, dap_
}
if(a_addr->uint64) {
l_address = DAP_NEW(dap_chain_node_addr_t);
+ if (!l_address) {
+ log_it(L_ERROR, "Memory allocation error in s_node_info_get_addr");
+ return NULL;
+ }
l_address->uint64 = a_addr->uint64;
}
return l_address;
@@ -536,19 +540,20 @@ static int node_info_dump_with_reply(dap_chain_net_t * a_net, dap_chain_node_add
dap_chain_node_addr_t *l_addr = NULL;
if(a_addr && a_addr->uint64) {
l_addr = DAP_NEW(dap_chain_node_addr_t);
+ if(!l_addr) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "addr not valid");
+ dap_string_free(l_string_reply, true);
+ return -1;
+ }
l_addr->uint64 = a_addr->uint64;
} else if(a_alias) {
l_addr = dap_chain_node_alias_find(a_net, a_alias);
}
- if(!l_addr) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "addr not valid");
- dap_string_free(l_string_reply, true);
- return -1;
- }
+
// read node
dap_chain_node_info_t *node_info_read = node_info_read_and_reply(a_net, l_addr, a_str_reply);
if(!node_info_read) {
- DAP_DELETE(l_addr);
+ DAP_DEL_Z(l_addr);
dap_string_free(l_string_reply, true);
return -2;
}
@@ -6055,6 +6060,11 @@ int cmd_remove(int a_argc, char **a_argv, char ** a_str_reply)
for (uint16_t i = 0; i < l_net_count; i++) {
size_t l_aliases_count = 0;
_pvt_net_aliases_list_t *l_gdb_groups = DAP_NEW(_pvt_net_aliases_list_t);
+ if (!l_gdb_groups) {
+ log_it(L_ERROR, "Memory allocation error in cmd_remove");
+ dap_list_free(l_net_returns);
+ return -1;
+ }
l_gdb_groups->net = l_net_list[i];
l_gdb_groups->group_aliases = dap_global_db_get_all_sync(l_gdb_groups->net->pub.gdb_nodes_aliases, &l_gdb_groups->count_aliases);
l_gdb_groups->group_nodes = dap_global_db_get_all_sync(l_gdb_groups->net->pub.gdb_nodes, &l_gdb_groups->count_nodes);
@@ -6409,6 +6419,11 @@ static char **s_parse_items(const char *a_str, char a_delimiter, int *a_count, c
}
char **lines = DAP_CALLOC(l_count_temp, sizeof (void *));
+ if (!lines) {
+ log_it(L_ERROR, "Memoru allocation error in s_parse_items");
+ DAP_FREE(l_temp_str);
+ return NULL;
+ }
for (int i = 0; i < l_count_temp; i++) {
while (*s == 0) s++;
lines[i] = strdup(s);
@@ -6654,7 +6669,10 @@ static byte_t *s_concat_meta (dap_list_t *a_meta, size_t *a_fullsize)
if (l_counter >= l_part_power) {
l_part_power = l_part * l_power++;
l_buf = (byte_t *) DAP_REALLOC(l_buf, l_part_power);
-
+ if (!l_buf) {
+ log_it(L_ERROR, "Memory allocation error in s_concat_meta");
+ return NULL;
+ }
}
memcpy (&l_buf[l_index], l_tsd->data, strlen((char *)l_tsd->data));
}
@@ -6674,6 +6692,10 @@ static uint8_t *s_concat_hash_and_mimetypes (dap_chain_hash_fast_t *a_chain_hash
size_t l_len_meta_buf = *a_fullsize;
*a_fullsize += sizeof (a_chain_hash->raw) + 1;
uint8_t *l_fullbuf = DAP_CALLOC(*a_fullsize, 1);
+ if (!l_fullbuf) {
+ log_it(L_ERROR, "Memory allocation error in s_concat_hash_and_mimetypes");
+ return NULL;
+ }
uint8_t *l_s = l_fullbuf;
memcpy(l_s, a_chain_hash->raw, sizeof(a_chain_hash->raw));
@@ -6688,6 +6710,10 @@ static uint8_t *s_concat_hash_and_mimetypes (dap_chain_hash_fast_t *a_chain_hash
static char *s_strdup_by_index (const char *a_file, const int a_index)
{
char *l_buf = DAP_CALLOC(a_index + 1, 1);
+ if (!l_buf) {
+ log_it(L_ERROR, "Memory allocation error in s_strdup_by_index");
+ return NULL;
+ }
strncpy (l_buf, a_file, a_index);
return l_buf;
}
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index 96a764ff53..e2c9cf7370 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -170,6 +170,10 @@ static void s_tx_header_print(dap_string_t *a_str_out, dap_chain_tx_hash_process
l_declined = true;
else {
l_tx_data = DAP_NEW_Z(dap_chain_tx_hash_processed_ht_t);
+ if (!l_tx_data) {
+ log_it(L_ERROR, "Memory allocation error in s_tx_header_print");
+ return;
+ }
l_tx_data->hash = *a_tx_hash;
HASH_ADD(hh, *a_tx_data_ht, hash, sizeof(*a_tx_hash), l_tx_data);
const char *l_token_ticker = dap_chain_ledger_tx_get_token_ticker_by_hash(a_ledger, a_tx_hash);
@@ -550,6 +554,10 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
break;
}
l_sht = DAP_NEW_Z(dap_chain_tx_hash_processed_ht_t);
+ if (!l_sht) {
+ log_it(L_ERROR, "Memory allocation error in dap_db_history_filter");
+ return NULL;
+ }
l_sht->hash = l_tx_hash;
HASH_ADD(hh, a_tx_hash_processed, hash, sizeof(dap_chain_hash_fast_t), l_sht);
l_tx_num++;
@@ -676,6 +684,11 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_addr_t *l_addr_tmp = (dap_chain_addr_t *) dap_chain_wallet_get_addr(l_wallet,
l_net->pub.id);
l_addr = DAP_NEW_SIZE(dap_chain_addr_t, sizeof(dap_chain_addr_t));
+ if (!l_addr) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory!");
+ log_it(L_ERROR, "Memory allocation error in com_ledger");
+ return -1;
+ }
memcpy(l_addr, l_addr_tmp, sizeof(dap_chain_addr_t));
dap_chain_wallet_close(l_wallet);
}
@@ -1326,6 +1339,11 @@ int cmd_decree(int a_argc, char **a_argv, char ** a_str_reply)
}else{
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(dap_chain_addr_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in cmd_decree");
+ dap_list_free_full(l_tsd_list, NULL);
+ return -1;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET;
l_tsd->size = sizeof(dap_chain_addr_t);
dap_chain_addr_t *l_addr = dap_chain_addr_from_str(l_param_addr_str);
@@ -1335,6 +1353,11 @@ int cmd_decree(int a_argc, char **a_argv, char ** a_str_reply)
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(uint256_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in cmd_decree");
+ dap_list_free_full(l_tsd_list, NULL);
+ return -1;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE;
l_tsd->size = sizeof(uint256_t);
*(uint256_t*)(l_tsd->data) = dap_cvt_str_to_uint256(l_param_value_str);
@@ -1387,6 +1410,11 @@ int cmd_decree(int a_argc, char **a_argv, char ** a_str_reply)
l_total_tsd_size = sizeof(dap_tsd_t) + sizeof(uint256_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in cmd_decree");
+ dap_list_free_full(l_tsd_list, NULL);
+ return -1;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER;
l_tsd->size = sizeof(uint256_t);
*(uint256_t*)(l_tsd->data) = l_new_num_of_owners;
diff --git a/modules/net/dap_chain_node_client.c b/modules/net/dap_chain_node_client.c
index e96fdc788f..3b2a569259 100644
--- a/modules/net/dap_chain_node_client.c
+++ b/modules/net/dap_chain_node_client.c
@@ -685,6 +685,10 @@ dap_chain_node_client_t *dap_chain_node_client_create(dap_chain_net_t *a_net,
return NULL;
}
dap_chain_node_client_t *l_node_client = DAP_NEW_Z(dap_chain_node_client_t);
+ if (!l_node_client) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_node_client_create");
+ return NULL;
+ }
l_node_client->state = NODE_CLIENT_STATE_DISCONNECTED;
l_node_client->callbacks_arg = a_callback_arg;
diff --git a/modules/net/dap_chain_node_dns_client.c b/modules/net/dap_chain_node_dns_client.c
index 3b8ed6a715..641f11bedc 100644
--- a/modules/net/dap_chain_node_dns_client.c
+++ b/modules/net/dap_chain_node_dns_client.c
@@ -171,6 +171,10 @@ static void s_dns_client_esocket_worker_assign_callback(dap_events_socket_t * a_
dap_events_socket_write_unsafe(a_esocket,l_dns_client->dns_request.data, l_dns_client->dns_request.size );
dap_events_socket_uuid_t * l_es_uuid_ptr = DAP_NEW_Z(dap_events_socket_uuid_t);
+ if (!l_es_uuid_ptr) {
+ log_it(L_ERROR, "Memory allocation error in s_dns_client_esocket_worker_assign_callback");
+ return;
+ }
*l_es_uuid_ptr = a_esocket->uuid;
dap_timerfd_start_on_worker(a_worker, dap_config_get_item_uint64_default(g_config,"dns_client","request_timeout",10)*1000,
s_dns_client_esocket_timeout_callback,l_es_uuid_ptr);
diff --git a/modules/net/dap_chain_node_dns_server.c b/modules/net/dap_chain_node_dns_server.c
index 7ed8fea282..da023392ec 100644
--- a/modules/net/dap_chain_node_dns_server.c
+++ b/modules/net/dap_chain_node_dns_server.c
@@ -53,6 +53,10 @@ int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback) {
HASH_FIND_STR(s_dns_server->hash_table, zone, new_zone);
if (new_zone == NULL) { // zone is not present
new_zone = DAP_NEW(dap_dns_zone_hash_t);
+ if (!new_zone) {
+ log_it(L_ERROR, "Memory allocation error in dap_dns_zone_register");
+ return DNS_ERROR_FAILURE;
+ }
new_zone->zone = dap_strdup(zone);
HASH_ADD_KEYPTR(hh, s_dns_server->hash_table, new_zone->zone, strlen(new_zone->zone), new_zone);
} // if zone present, just reassign callback
@@ -112,8 +116,20 @@ void dap_dns_client_read(dap_events_socket_t *a_es, void *a_arg) {
return;
}
dap_dns_buf_t *dns_message = DAP_NEW(dap_dns_buf_t);
+ if (!dns_message) {
+ log_it(L_ERROR, "Memory allocation error in dap_dns_client_read");
+ return;
+ }
dap_dns_buf_t *dns_reply = DAP_NEW(dap_dns_buf_t);
+ if (!dns_reply) {
+ log_it(L_ERROR, "Memory allocation error in dap_dns_client_read");
+ return;
+ }
dns_message->data = DAP_NEW_SIZE(char, a_es->buf_in_size + 1);
+ if (!dns_message->data) {
+ log_it(L_ERROR, "Memory allocation error in dap_dns_client_read");
+ return;
+ }
dns_message->data[a_es->buf_in_size] = 0;
dap_events_socket_pop_from_buf_in(a_es, dns_message->data, a_es->buf_in_size);
dns_message->size = 0;
@@ -121,6 +137,10 @@ void dap_dns_client_read(dap_events_socket_t *a_es, void *a_arg) {
// Parse incoming DNS message
int block_len = DNS_HEADER_SIZE;
dns_reply->data = DAP_NEW_SIZE(char, block_len);
+ if (!dns_reply->data) {
+ log_it(L_ERROR, "Memory allocation error in dap_dns_client_read");
+ return;
+ }
dns_reply->size = 0;
uint16_t val = dap_dns_buf_get_uint16(dns_message); // ID
dap_dns_buf_put_uint16(dns_reply, val);
@@ -260,6 +280,10 @@ cleanup:
void dap_dns_server_start( uint16_t a_port)
{
s_dns_server = DAP_NEW_Z(dap_dns_server_t);
+ if (!s_dns_server) {
+ log_it(L_ERROR, "Memory allocation error in dap_dns_server_start");
+ return;
+ }
dap_events_socket_callbacks_t l_cb = {};
l_cb.read_callback = dap_dns_client_read;
s_dns_server->instance = dap_server_new( NULL, a_port, SERVER_UDP, &l_cb);
diff --git a/modules/net/dap_chain_node_ping.c b/modules/net/dap_chain_node_ping.c
index f40d10edec..10d65ae03a 100644
--- a/modules/net/dap_chain_node_ping.c
+++ b/modules/net/dap_chain_node_ping.c
@@ -87,6 +87,10 @@ static void* node_ping_proc(void *a_arg)
DAP_DELETE(a_arg);
char *host4 = DAP_NEW_SIZE(char, INET_ADDRSTRLEN);
+ if (!host4) {
+ log_it(L_ERROR, "Memory allocation error in node_ping_proc");
+ return NULL;
+ }
struct sockaddr_in sa4 = { .sin_family = AF_INET, .sin_addr = l_addr };
const char* str_ip4 = inet_ntop(AF_INET, &(((struct sockaddr_in *) &sa4)->sin_addr), host4, INET_ADDRSTRLEN);
if(!str_ip4){
@@ -156,6 +160,10 @@ static void* node_ping_proc(void *a_arg)
int start_node_ping(pthread_t *a_thread, struct in_addr a_addr, int a_port, int a_count)
{
uint8_t *l_data = DAP_NEW_Z_SIZE(uint8_t, sizeof(struct in_addr) + 2 * sizeof(int));
+ if (!l_data) {
+ log_it(L_ERROR, "Memory allocation error in start_node_ping");
+ return -1;
+ }
memcpy(l_data, &a_count, sizeof(int));
memcpy(l_data + sizeof(int), &a_port, sizeof(int));
memcpy(l_data + 2 * sizeof(int), &a_addr, sizeof(struct in_addr));
@@ -265,6 +273,12 @@ static void* node_ping_background_proc(void *a_arg)
// allocate memory for best node addresses
dap_chain_node_addr_t *l_node_addr_tmp;
l_node_addr_tmp = DAP_NEW(dap_chain_node_addr_t);
+ if (!l_node_addr_tmp) {
+ log_it(L_ERROR, "Memory allocation error in node_ping_background_proc");
+ dap_list_free_full(l_node_list0, NULL);
+ DAP_DEL_Z(s_node_addr_ping);
+ return 0;
+ }
memcpy(l_node_addr_tmp, s_node_addr_tr, sizeof(dap_chain_node_addr_t));
DAP_DELETE(s_node_addr_tr);
s_node_addr_tr = l_node_addr_tmp;
@@ -292,12 +306,22 @@ int dap_chain_node_ping_background_start(dap_chain_net_t *a_net, dap_list_t *a_n
dap_list_t *l_node_list_tmp = a_node_list;
while(l_node_list_tmp) {
dap_chain_node_addr_t *l_addr = DAP_NEW(dap_chain_node_addr_t);
+ if (!l_addr) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_node_ping_background_start");
+ dap_list_free_full(l_node_list, NULL);
+ return -1;
+ }
memcpy(l_addr, l_node_list_tmp->data, sizeof(dap_chain_node_addr_t));
l_node_list = dap_list_append(l_node_list, l_addr);
l_node_list_tmp = dap_list_next(l_node_list_tmp);
}
// start searching for better nodes
uint8_t *l_arg = DAP_NEW_SIZE(uint8_t, sizeof(dap_chain_net_t*) + sizeof(dap_list_t*));
+ if (!l_arg) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_node_ping_background_start");
+ dap_list_free_full(l_node_list, NULL);
+ return -1;
+ }
memcpy(l_arg, &a_net, sizeof(dap_chain_net_t*));
memcpy(l_arg + sizeof(dap_chain_net_t*), &l_node_list, sizeof(dap_list_t*));
pthread_create(&s_thread, NULL, node_ping_background_proc, l_arg);
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 7640a9c071..67a0e57b2c 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -758,6 +758,10 @@ int dap_chain_net_srv_parse_pricelist(dap_chain_net_srv_t *a_srv, const char *a_
char **l_pricelist = dap_config_get_array_str(g_config, a_config_section, "pricelist", &l_pricelist_count);
for (uint16_t i = 0; i < l_pricelist_count; i++) {
dap_chain_net_srv_price_t *l_price = DAP_NEW_Z(dap_chain_net_srv_price_t);
+ if (!l_price) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_parse_pricelist");
+ return ret;
+ }
short l_iter = 0;
char *l_ctx;
for (char *l_price_token = strtok_r(l_pricelist[i], ":", &l_ctx); l_price_token || l_iter == 6; l_price_token = strtok_r(NULL, ":", &l_ctx), ++l_iter) {
@@ -853,11 +857,22 @@ dap_chain_net_srv_t* dap_chain_net_srv_add(dap_chain_net_srv_uid_t a_uid,
HASH_FIND(hh, s_srv_list, &l_uid, sizeof(l_uid), l_sdata);
if(l_sdata == NULL) {
l_srv = DAP_NEW_Z(dap_chain_net_srv_t);
+ if (!l_srv) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_add");
+ pthread_mutex_unlock(&s_srv_list_mutex);
+ return NULL;
+ }
l_srv->uid.uint64 = a_uid.uint64;
if (a_callbacks)
l_srv->callbacks = *a_callbacks;
pthread_mutex_init(&l_srv->banlist_mutex, NULL);
l_sdata = DAP_NEW_Z(service_list_t);
+ if (!l_sdata) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_add");
+ DAP_DEL_Z(l_srv);
+ pthread_mutex_unlock(&s_srv_list_mutex);
+ return NULL;
+ }
l_sdata->uid = l_uid;
strncpy(l_sdata->name, a_config_section, sizeof(l_sdata->name) - 1);
l_sdata->srv = l_srv;
diff --git a/modules/net/srv/dap_chain_net_srv_client.c b/modules/net/srv/dap_chain_net_srv_client.c
index 90259de8c2..16f080dc10 100644
--- a/modules/net/srv/dap_chain_net_srv_client.c
+++ b/modules/net/srv/dap_chain_net_srv_client.c
@@ -41,6 +41,10 @@ dap_chain_net_srv_client_t *dap_chain_net_srv_client_create_n_connect(dap_chain_
void *a_callbacks_arg)
{
dap_chain_net_srv_client_t *l_ret = DAP_NEW_Z(dap_chain_net_srv_client_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_client_create_n_connect");
+ return NULL;
+ }
if (a_callbacks)
l_ret->callbacks = *a_callbacks;
l_ret->callbacks_arg = a_callbacks_arg;
@@ -50,6 +54,11 @@ dap_chain_net_srv_client_t *dap_chain_net_srv_client_create_n_connect(dap_chain_
.delete = s_srv_client_callback_deleted
};
dap_chain_node_info_t *l_info = DAP_NEW_Z(dap_chain_node_info_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_client_create_n_connect");
+ DAP_DEL_Z(l_ret);
+ return NULL;
+ }
inet_pton(AF_INET, a_addr, &l_info->hdr.ext_addr_v4);
l_info->hdr.ext_port = a_port;
const char l_channels[] = {dap_stream_ch_chain_net_srv_get_id(), '\0'};
diff --git a/modules/net/srv/dap_chain_net_srv_geoip.c b/modules/net/srv/dap_chain_net_srv_geoip.c
index 84bc1c133e..ad6fa65425 100644
--- a/modules/net/srv/dap_chain_net_srv_geoip.c
+++ b/modules/net/srv/dap_chain_net_srv_geoip.c
@@ -175,17 +175,21 @@ geoip_info_t *chain_net_geoip_get_ip_info_by_local_db(const char *a_ip_str, cons
//char *l_file_db_name = dap_strdup_printf("%s/share/geoip/GeoLite2-City.mmdb", g_sys_dir_path);
if(!dap_file_test(s_geoip_db_file_path)) {
//DAP_DELETE(l_file_db_name);
- return NULL ;
+ return NULL;
}
MMDB_s mmdb;
int l_status = MMDB_open(s_geoip_db_file_path, MMDB_MODE_MMAP, &mmdb);
if(MMDB_SUCCESS != l_status) {
log_it(L_WARNING, "geoip file %s opened with errcode=%d", s_geoip_db_file_path, l_status);
- return NULL ;
+ return NULL;
}
//DAP_DELETE(l_file_db_name);
geoip_info_t *l_ret = DAP_NEW_Z(geoip_info_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in chain_net_geoip_get_ip_info_by_local_db");
+ return NULL;
+ }
int gai_error, mmdb_error;
MMDB_lookup_result_s result = MMDB_lookup_string(&mmdb, a_ip_str, &gai_error, &mmdb_error);
diff --git a/modules/net/srv/dap_chain_net_srv_order.c b/modules/net/srv/dap_chain_net_srv_order.c
index 0f761ac149..bc02a41a4c 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -218,6 +218,10 @@ bool dap_chain_net_srv_order_get_continent_region(dap_chain_net_srv_order_t *a_o
size_t l_size = a_order_static->ext_size - sizeof(uint8_t) - 1;
if(l_size > 0) {
*a_region = DAP_NEW_SIZE(char, l_size);
+ if (!a_region) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_order_get_continent_region");
+ return false;
+ }
memcpy(*a_region, a_order_static->ext_n_sign + 1 + sizeof(uint8_t), l_size);
}
else
@@ -347,11 +351,19 @@ dap_chain_net_srv_order_t *dap_chain_net_srv_order_compose(dap_chain_net_t *a_ne
dap_chain_net_srv_order_t *l_order;
if (a_ext_size) {
l_order = (dap_chain_net_srv_order_t *)DAP_NEW_Z_SIZE(void, sizeof(dap_chain_net_srv_order_t) + a_ext_size);
+ if (!l_order) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_order_compose");
+ return NULL;
+ }
memcpy(l_order->ext_n_sign, a_ext, a_ext_size);
l_order->ext_size = a_ext_size;
}
else {
l_order = DAP_NEW_Z(dap_chain_net_srv_order_t);
+ if (!l_order) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_order_compose");
+ return NULL;
+ }
dap_chain_net_srv_order_set_continent_region(&l_order, a_continent_num, a_region);
}
@@ -688,6 +700,10 @@ static void s_srv_order_callback_notify(dap_global_db_context_t *a_context, dap_
void dap_chain_net_srv_order_add_notify_callback(dap_chain_net_t *a_net, dap_store_obj_callback_notify_t a_callback, void *a_cb_arg)
{
struct dap_order_notify *l_notifier = DAP_NEW(struct dap_order_notify);
+ if (!l_notifier) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_order_add_notify_callback");
+ return;
+ }
l_notifier->net = a_net;
l_notifier->callback = a_callback;
l_notifier->cb_arg = a_cb_arg;
diff --git a/modules/net/srv/dap_chain_net_srv_stream_session.c b/modules/net/srv/dap_chain_net_srv_stream_session.c
index 98136f6fbc..445a8eddb8 100644
--- a/modules/net/srv/dap_chain_net_srv_stream_session.c
+++ b/modules/net/srv/dap_chain_net_srv_stream_session.c
@@ -41,6 +41,10 @@ dap_chain_net_srv_stream_session_t * dap_chain_net_srv_stream_session_create( da
return NULL;
}
dap_chain_net_srv_stream_session_t * l_session_srv= DAP_NEW_Z(dap_chain_net_srv_stream_session_t);
+ if (!l_session_srv) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stream_session_create");
+ return NULL;
+ }
a_session->_inheritor = l_session_srv;
l_session_srv->parent = a_session;
log_it(L_NOTICE, "created service session");
@@ -75,6 +79,10 @@ dap_chain_net_srv_usage_t* dap_chain_net_srv_usage_add (dap_chain_net_srv_stream
{
if ( a_srv_session && a_net && a_srv ){
dap_chain_net_srv_usage_t * l_ret = DAP_NEW_Z(dap_chain_net_srv_usage_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_usage_add");
+ return NULL;
+ }
randombytes(&l_ret->id, sizeof(l_ret->id));
l_ret->net = a_net;
l_ret->service = a_srv;
diff --git a/modules/service/datum/dap_chain_net_srv_datum.c b/modules/service/datum/dap_chain_net_srv_datum.c
index 65da564e58..f4e35a0afc 100644
--- a/modules/service/datum/dap_chain_net_srv_datum.c
+++ b/modules/service/datum/dap_chain_net_srv_datum.c
@@ -46,6 +46,10 @@ int dap_chain_net_srv_datum_init()
"srv_datum -net <net_name> -chain <chain_name> datum load -datum <datum_hash>\n"
"\tLoad datum custum from file to mempool.\n\n");
s_srv_datum = DAP_NEW_Z(dap_chain_net_srv_t);
+ if (!s_srv_datum) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_datum_init");
+ return -1;
+ }
s_srv_datum->uid.uint64 = DAP_CHAIN_NET_SRV_DATUM_ID;
int l_net_count = dap_chain_net_srv_parse_pricelist(s_srv_datum, "srv_datum");
dap_chain_net_srv_price_t *l_price;
diff --git a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
index c7e2a338ea..854480ccb0 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
@@ -93,6 +93,10 @@ int dap_chain_net_srv_stake_pos_delegate_init()
);
s_srv_stake = DAP_NEW_Z(dap_chain_net_srv_stake_t);
+ if (!s_srv_stake) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_pos_delegate_init");
+ return -1;
+ }
s_srv_stake->delegate_allowed_min = dap_chain_coins_to_balance("1.0");
return 0;
@@ -340,6 +344,10 @@ int dap_chain_net_srv_stake_load_cache(dap_chain_net_t *a_net)
dap_chain_net_srv_stake_cache_data_t *l_cache_data =
(dap_chain_net_srv_stake_cache_data_t *)l_store_obj[i].value;
dap_chain_net_srv_stake_cache_item_t *l_cache = DAP_NEW_Z(dap_chain_net_srv_stake_cache_item_t);
+ if (!l_cache) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_load_cache");
+ return -1;
+ }
l_cache->signing_addr = l_cache_data->signing_addr;
l_cache->tx_hash = l_cache_data->tx_hash;
HASH_ADD(hh, s_srv_stake->cache, tx_hash, sizeof(dap_hash_fast_t), l_cache);
@@ -531,6 +539,10 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(dap_hash_fast_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_decree_approve");
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH;
l_tsd->size = sizeof(dap_hash_fast_t);
*(dap_hash_fast_t*)(l_tsd->data) = *a_stake_tx_hash;
@@ -538,6 +550,11 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(uint256_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_decree_approve");
+ dap_list_free_full(l_tsd_list, NULL);
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE;
l_tsd->size = sizeof(uint256_t);
*(uint256_t*)(l_tsd->data) = l_tx_out_cond->header.value;
@@ -545,6 +562,11 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(dap_chain_addr_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_decree_approve");
+ dap_list_free_full(l_tsd_list, NULL);
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR;
l_tsd->size = sizeof(dap_chain_addr_t);
*(dap_chain_addr_t*)(l_tsd->data) = l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr;
@@ -552,12 +574,22 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(dap_chain_node_addr_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_decree_approve");
+ dap_list_free_full(l_tsd_list, NULL);
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNER_NODE_ADDR;
l_tsd->size = sizeof(dap_chain_node_addr_t);
*(dap_chain_node_addr_t*)(l_tsd->data) = l_tx_out_cond->subtype.srv_stake_pos_delegate.signer_node_addr;
l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
l_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, sizeof(dap_chain_datum_decree_t) + l_total_tsd_size);
+ if (!l_decree) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_stake_decree_approve");
+ dap_list_free_full(l_tsd_list, NULL);
+ return NULL;
+ }
l_decree->decree_version = DAP_CHAIN_DATUM_DECREE_VERSION;
l_decree->header.ts_created = dap_time_now();
l_decree->header.type = DAP_CHAIN_DATUM_DECREE_TYPE_COMMON;
@@ -753,12 +785,21 @@ static dap_chain_datum_decree_t *s_stake_decree_invalidate(dap_chain_net_t *a_ne
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(dap_chain_addr_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in s_stake_decree_invalidate");
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR;
l_tsd->size = sizeof(dap_chain_addr_t);
*(dap_chain_addr_t*)(l_tsd->data) = l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr;
l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
l_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, sizeof(dap_chain_datum_decree_t) + l_total_tsd_size);
+ if (!l_decree) {
+ log_it(L_ERROR, "Memory allocation error in s_stake_decree_set_min_stake");
+ dap_list_free_full(l_tsd_list, NULL);
+ return NULL;
+ }
l_decree->decree_version = DAP_CHAIN_DATUM_DECREE_VERSION;
l_decree->header.ts_created = dap_time_now();
l_decree->header.type = DAP_CHAIN_DATUM_DECREE_TYPE_COMMON;
@@ -768,6 +809,7 @@ static dap_chain_datum_decree_t *s_stake_decree_invalidate(dap_chain_net_t *a_ne
l_chain = dap_chain_net_get_chain_by_chain_type(a_net, CHAIN_TYPE_ANCHOR);
if (!l_chain) {
log_it(L_ERROR, "No chain supported anchor datum type");
+ dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
l_decree->header.common_decree_params.chain_id = l_chain->id;
@@ -818,12 +860,21 @@ static dap_chain_datum_decree_t *s_stake_decree_set_min_stake(dap_chain_net_t *a
l_total_tsd_size += sizeof(dap_tsd_t) + sizeof(uint256_t);
l_tsd = DAP_NEW_Z_SIZE(dap_tsd_t, l_total_tsd_size);
+ if (!l_tsd) {
+ log_it(L_ERROR, "Memory allocation error in s_stake_decree_set_min_stake");
+ return NULL;
+ }
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE;
l_tsd->size = sizeof(uint256_t);
*(uint256_t*)(l_tsd->data) = a_value;
l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
l_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, sizeof(dap_chain_datum_decree_t) + l_total_tsd_size);
+ if (!l_decree) {
+ log_it(L_ERROR, "Memory allocation error in s_stake_decree_set_min_stake");
+ dap_list_free_full(l_tsd_list, NULL);
+ return NULL;
+ }
l_decree->decree_version = DAP_CHAIN_DATUM_DECREE_VERSION;
l_decree->header.ts_created = dap_time_now();
l_decree->header.type = DAP_CHAIN_DATUM_DECREE_TYPE_COMMON;
@@ -833,6 +884,7 @@ static dap_chain_datum_decree_t *s_stake_decree_set_min_stake(dap_chain_net_t *a
l_chain = dap_chain_net_get_chain_by_chain_type(a_net, CHAIN_TYPE_ANCHOR);
if (!l_chain) {
log_it(L_ERROR, "No chain supported anchor datum type");
+ dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
l_decree->header.common_decree_params.chain_id = l_chain->id;
@@ -1640,6 +1692,11 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
return -4;
}
struct get_tx_cond_pos_del_from_tx * l_args = DAP_NEW_Z(struct get_tx_cond_pos_del_from_tx);
+ if(!l_args) {
+ log_it(L_ERROR, "Memory allocation error in s_cli_srv_stake");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory");
+ return -1;
+ }
dap_string_t * l_str_tmp = dap_string_new(NULL);
dap_hash_fast_t l_datum_hash;
dap_chain_datum_tx_t *l_datum_tx = NULL;
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn.c b/modules/service/vpn/dap_chain_net_srv_vpn.c
index 41f000cce2..a50285aa9e 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -319,6 +319,10 @@ static bool s_tun_client_send_data(dap_chain_net_srv_ch_vpn_info_t * l_ch_vpn_in
} else {
/* Shift it to other worker context */
tun_socket_msg_t* l_msg = DAP_NEW_Z(tun_socket_msg_t);
+ if (!l_msg) {
+ log_it(L_ERROR, "Memory allocation error in s_tun_client_send_data");
+ return false;
+ }
l_msg->type = TUN_SOCKET_MSG_CH_VPN_SEND;
l_msg->ch_vpn = l_ch_vpn_info->ch_vpn;
l_msg->esocket = l_ch_vpn_info->esocket;
@@ -394,6 +398,11 @@ static void s_tun_recv_msg_callback(dap_events_socket_t * a_esocket_queue, void
log_it(L_WARNING, "Already assigned address %s on tun sock #%u", l_addrbuf, l_tun_sock->worker_id);
}else{
l_new_info = DAP_NEW_Z(dap_chain_net_srv_ch_vpn_info_t);
+ if (!l_new_info) {
+ log_it (L_ERROR, "Memory allocation error in s_tun_recv_msg_callback");
+ DAP_DELETE(l_msg);
+ return;
+ }
l_new_info->ch_vpn = l_msg->ch_vpn;
l_new_info->addr_ipv4 = l_msg->ip_assigment.addr;
l_new_info->queue_msg = s_tun_sockets_queue_msg[l_msg->ip_assigment.worker_id];
@@ -467,6 +476,10 @@ static void s_tun_recv_msg_callback(dap_events_socket_t * a_esocket_queue, void
static void s_tun_send_msg_ip_assigned(uint32_t a_worker_own_id, uint32_t a_worker_id, dap_chain_net_srv_ch_vpn_t * a_ch_vpn, struct in_addr a_addr )
{
struct tun_socket_msg * l_msg = DAP_NEW_Z(struct tun_socket_msg);
+ if (!l_msg) {
+ log_it (L_ERROR, "Memory allocation error in s_tun_send_msg_ip_assigned");
+ return;
+ }
l_msg->type = TUN_SOCKET_MSG_IP_ASSIGNED;
l_msg->ch_vpn = a_ch_vpn;
l_msg->esocket = a_ch_vpn->ch->stream->esocket;
@@ -504,6 +517,10 @@ static void s_tun_send_msg_ip_assigned_all(uint32_t a_worker_own_id, dap_chain_n
static void s_tun_send_msg_ip_unassigned(uint32_t a_worker_own_id, uint32_t a_worker_id, dap_chain_net_srv_ch_vpn_t * a_ch_vpn, struct in_addr a_addr)
{
struct tun_socket_msg * l_msg = DAP_NEW_Z(struct tun_socket_msg);
+ if (!l_msg) {
+ log_it (L_ERROR, "Memory allocation error in s_tun_send_msg_ip_unassigned");
+ return;
+ }
l_msg->type = TUN_SOCKET_MSG_IP_UNASSIGNED;
l_msg->ch_vpn = a_ch_vpn;
l_msg->ip_unassigment.addr = a_addr;
@@ -549,6 +566,10 @@ static void s_tun_send_msg_esocket_reassigned_inter(uint32_t a_worker_own_id, da
dap_events_socket_uuid_t a_esocket_uuid, struct in_addr a_addr)
{
struct tun_socket_msg * l_msg = DAP_NEW_Z(struct tun_socket_msg);
+ if (!l_msg) {
+ log_it (L_ERROR, "Memory allocation error in s_tun_send_msg_esocket_reassigned_inter");
+ return;
+ }
l_msg->type = TUN_SOCKET_MSG_ESOCKET_REASSIGNED ;
l_msg->ch_vpn = a_ch_vpn;
l_msg->esocket_reassigment.addr = a_addr;
@@ -801,6 +822,10 @@ lb_err:
static int s_vpn_tun_init()
{
s_raw_server=DAP_NEW_Z(vpn_local_network_t);
+ if (!s_raw_server) {
+ log_it(L_ERROR, "Memory allocation error in s_vpn_tun_init");
+ return -1;
+ }
pthread_rwlock_init(&s_raw_server->rwlock, NULL);
pthread_mutex_init(&s_raw_server->pkt_out_mutex,NULL);
pthread_mutex_init(&s_tun_sockets_mutex_started, NULL);
@@ -826,6 +851,10 @@ static int s_vpn_service_create(dap_config_t * g_config)
dap_chain_net_srv_t* l_srv = dap_chain_net_srv_add(l_uid, "srv_vpn", &l_srv_callbacks);
dap_chain_net_srv_vpn_t* l_srv_vpn = DAP_NEW_Z( dap_chain_net_srv_vpn_t);
+ if(!l_srv_vpn) {
+ log_it(L_ERROR, "Memory allocation error in s_vpn_service_create");
+ return -1;
+ }
l_srv->_internal = l_srv_vpn;
l_srv_vpn->parent = l_srv;
@@ -915,8 +944,17 @@ static int s_callback_response_success(dap_chain_net_srv_t * a_srv, uint32_t a_u
usage_client_t * l_usage_client = NULL;
l_usage_client = DAP_NEW_Z(usage_client_t);
+ if (!l_usage_client) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_response_success");
+ return -1;
+ }
l_usage_client->usage_id = a_usage_id;
l_usage_client->receipt = DAP_NEW_SIZE(dap_chain_datum_tx_receipt_t,l_receipt_size);
+ if (!l_usage_client->receipt) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_response_success");
+ DAP_DEL_Z(l_usage_client);
+ return -1;
+ }
memcpy(l_usage_client->receipt, l_receipt, l_receipt_size);
@@ -1130,6 +1168,11 @@ static void s_ch_vpn_delete(dap_stream_ch_t* a_ch, void* arg)
if ( l_is_unleased ){ // If unleased
log_it(L_DEBUG, "Unlease address %s and store in treshold", inet_ntoa(l_ch_vpn->addr_ipv4));
dap_chain_net_srv_vpn_item_ipv4_t * l_item_unleased = DAP_NEW_Z(dap_chain_net_srv_vpn_item_ipv4_t);
+ if (!l_is_unleased) {
+ log_it(L_ERROR, "Memory allocation error in s_ch_vpn_delete");
+ pthread_rwlock_unlock(&s_clients_rwlock);
+ return;
+ }
l_item_unleased->addr.s_addr = l_ch_vpn->addr_ipv4.s_addr;
l_item_unleased->next = l_srv_vpn->ipv4_unleased;
l_srv_vpn->ipv4_unleased = l_item_unleased;
@@ -1298,6 +1341,10 @@ static void send_pong_pkt(dap_stream_ch_t* a_ch)
{
// log_it(L_DEBUG,"---------------------------------- PONG!");
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
+ if (!pkt_out) {
+ log_it(L_ERROR, "Memory allocation error in send_pong_pkt");
+ return;
+ }
pkt_out->header.op_code = VPN_PACKET_OP_CODE_PONG;
dap_stream_ch_pkt_write_unsafe(a_ch, 'd', pkt_out,
@@ -1322,6 +1369,10 @@ static void s_ch_packet_in_vpn_address_request(dap_stream_ch_t* a_ch, dap_chain_
if ( l_ch_vpn->addr_ipv4.s_addr ) {
log_it(L_WARNING, "IP address is already leased");
ch_vpn_pkt_t* pkt_out = DAP_NEW_STACK_SIZE(ch_vpn_pkt_t, sizeof(pkt_out->header));
+ if (!pkt_out) {
+ log_it(L_ERROR, "Memory allocation error in send_pong_pkt");
+ return;
+ }
pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
pkt_out->header.sock_id = s_raw_server->tun_fd;
pkt_out->header.usage_id = a_usage->id;
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index 9366297ade..b7b3337c67 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -181,6 +181,10 @@ static int s_callback_client_success(dap_chain_net_srv_t * a_srv, uint32_t a_usa
if(l_ch) { // Is present in hash table such destination address
size_t l_ipv4_str_len = 0; //dap_strlen(a_ipv4_str);
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header) + l_ipv4_str_len);
+ if (!pkt_out) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_client_success");
+ return -1;
+ }
pkt_out->header.op_code = VPN_PACKET_OP_CODE_VPN_ADDR_REQUEST;
//pkt_out->header.sock_id = l_stream->stream->events_socket->socket;
diff --git a/modules/service/vpn/dap_chain_net_vpn_client_tun.c b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
index f75fbb914c..6f77ec4eed 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client_tun.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
@@ -685,6 +685,14 @@ void ch_sf_tun_client_send(dap_chain_net_srv_ch_vpn_t * ch_sf, void * pkt_data,
log_it(L_ERROR, "write() returned error %d : '%s'", ret, strerror(errno));
//log_it(ERROR,"raw socket ring buffer overflowed");
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
+ if (!pkt_out) {
+ log_it(L_ERROR, "Memory allocation error in ch_sf_tun_client_send");
+ if(in_daddr_str)
+ free(in_daddr_str);
+ if(in_saddr_str)
+ free(in_saddr_str);
+ return;
+ }
pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
pkt_out->header.op_problem.code = VPN_PROBLEM_CODE_PACKET_LOST;
pkt_out->header.sock_id = s_fd_tun;
@@ -697,9 +705,9 @@ void ch_sf_tun_client_send(dap_chain_net_srv_ch_vpn_t * ch_sf, void * pkt_data,
}
if(in_daddr_str)
- free(in_daddr_str);
+ free(in_daddr_str);
if(in_saddr_str)
- free(in_saddr_str);
+ free(in_saddr_str);
}
/**
diff --git a/modules/service/xchange/dap_chain_net_srv_xchange.c b/modules/service/xchange/dap_chain_net_srv_xchange.c
index c420689a50..d12f23d1a9 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -130,6 +130,10 @@ int dap_chain_net_srv_xchange_init()
dap_chain_net_srv_t* l_srv = dap_chain_net_srv_add(l_uid, "srv_xchange", &l_srv_callbacks);
s_srv_xchange = DAP_NEW_Z(dap_chain_net_srv_xchange_t);
+ if (!s_srv_xchange) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_net_srv_xchange_init");
+ return -1;
+ }
l_srv->_internal = s_srv_xchange;
s_srv_xchange->parent = l_srv;
s_srv_xchange->enabled = false;
@@ -329,6 +333,10 @@ static dap_chain_datum_tx_receipt_t *s_xchange_receipt_create(dap_chain_net_srv_
{
uint32_t l_ext_size = sizeof(uint256_t) + DAP_CHAIN_TICKER_SIZE_MAX;
uint8_t *l_ext = DAP_NEW_STACK_SIZE(uint8_t, l_ext_size);
+ if (!l_ext) {
+ log_it(L_ERROR, "Memory allocation error in s_xchange_receipt_create");
+ return NULL;
+ }
memcpy(l_ext, &a_datoshi_buy, sizeof(uint256_t));
strcpy((char *)&l_ext[sizeof(uint256_t)], a_price->token_buy);
dap_chain_net_srv_price_unit_uid_t l_unit = { .uint32 = SERV_UNIT_UNDEFINED};
@@ -915,6 +923,10 @@ char *s_xchange_order_create(dap_chain_net_srv_xchange_price_t *a_price, dap_cha
dap_chain_net_srv_xchange_price_t *s_xchange_price_from_order(dap_chain_net_t *a_net, dap_chain_net_srv_order_t *a_order, bool a_ret_is_invalid)
{
dap_chain_net_srv_xchange_price_t *l_price = DAP_NEW_Z(dap_chain_net_srv_xchange_price_t);
+ if (!l_price) {
+ log_it(L_ERROR, "Memory allocation error in s_xchange_price_from_order");
+ return NULL;
+ }
dap_srv_xchange_order_ext_t *l_ext = (dap_srv_xchange_order_ext_t *)a_order->ext_n_sign;
strcpy(l_price->token_buy, l_ext->token_buy);
l_price->datoshi_buy = l_ext->datoshi_buy;
@@ -1071,6 +1083,12 @@ static int s_cli_srv_xchange_order(int a_argc, char **a_argv, int a_arg_index, c
}
// Create the price
dap_chain_net_srv_xchange_price_t *l_price = DAP_NEW_Z(dap_chain_net_srv_xchange_price_t);
+ if (!l_price) {
+ log_it(L_ERROR, "Memory allocation error in s_cli_srv_xchange_order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory");
+ dap_chain_wallet_close(l_wallet);
+ return -1;
+ }
l_price->wallet_str = dap_strdup(l_wallet_str);
dap_stpcpy(l_price->token_sell, l_token_sell_str);
l_price->net = l_net;
diff --git a/modules/type/blocks/dap_chain_block.c b/modules/type/blocks/dap_chain_block.c
index 15083cccb2..8c7379149a 100644
--- a/modules/type/blocks/dap_chain_block.c
+++ b/modules/type/blocks/dap_chain_block.c
@@ -460,6 +460,10 @@ dap_chain_block_meta_t** dap_chain_block_get_meta(dap_chain_block_t * a_block, s
size_t l_offset = 0;
dap_chain_block_meta_t * l_meta=NULL;
dap_chain_block_meta_t ** l_ret = DAP_NEW_Z_SIZE(dap_chain_block_meta_t *,sizeof (dap_chain_block_meta_t *)* a_block->hdr.meta_count );
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_get_meta");
+ return NULL;
+ }
for( size_t i = 0; i< a_block->hdr.meta_count &&
l_offset < (a_block_size-sizeof (a_block->hdr)) &&
sizeof (l_meta->hdr) <= (a_block_size-sizeof (a_block->hdr)) - l_offset ; i++){
diff --git a/modules/type/blocks/dap_chain_block_cache.c b/modules/type/blocks/dap_chain_block_cache.c
index b374fc923c..1182d280d8 100644
--- a/modules/type/blocks/dap_chain_block_cache.c
+++ b/modules/type/blocks/dap_chain_block_cache.c
@@ -61,6 +61,10 @@ dap_chain_block_cache_t *dap_chain_block_cache_new(dap_chain_cs_blocks_t *a_bloc
return NULL;
dap_chain_block_cache_t * l_block_cache = DAP_NEW_Z(dap_chain_block_cache_t);
+ if (!l_block_cache) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_cache_new");
+ return NULL;
+ }
l_block_cache->block = a_block;
l_block_cache->block_size= a_block_size;
l_block_cache->_inheritor = a_blocks;
@@ -83,6 +87,10 @@ dap_chain_block_cache_t *dap_chain_block_cache_new(dap_chain_cs_blocks_t *a_bloc
dap_chain_block_cache_t * dap_chain_block_cache_dup(dap_chain_block_cache_t * a_block)
{
dap_chain_block_cache_t * l_ret = DAP_NEW_Z(dap_chain_block_cache_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_cache_dup");
+ return NULL;
+ }
memcpy(l_ret,a_block, sizeof (*a_block));
memset(&l_ret->hh,0, sizeof (l_ret->hh)); // Drop hash handle to prevent its usage
return l_ret;
@@ -172,6 +180,12 @@ dap_list_t * dap_chain_block_get_list_tx_cond_outs_with_val(dap_ledger_t *a_ledg
dap_hash_fast_t *l_tx_hash = a_block_cache->datum_hash + i;
if (!dap_chain_ledger_tx_hash_is_used_out_item (a_ledger, l_tx_hash, l_out_idx_tmp)) {
dap_chain_tx_used_out_item_t *l_item = DAP_NEW_Z(dap_chain_tx_used_out_item_t);
+ if (!l_item) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_get_list_tx_cond_outs_with_val");
+ if (l_list_used_out)
+ dap_list_free_full(l_list_used_out, NULL);
+ return NULL;
+ }
l_item->tx_hash_fast = *l_tx_hash;
l_item->num_idx_out = l_out_idx_tmp;
l_item->value = l_tx_out_cond->header.value;
diff --git a/modules/type/blocks/dap_chain_block_chunk.c b/modules/type/blocks/dap_chain_block_chunk.c
index 4aeef8db38..c8b15c24ba 100644
--- a/modules/type/blocks/dap_chain_block_chunk.c
+++ b/modules/type/blocks/dap_chain_block_chunk.c
@@ -37,6 +37,10 @@ dap_chain_block_chunks_t * dap_chain_block_chunks_create(dap_chain_cs_blocks_t *
assert(a_blocks);
assert(a_blocks->chain);
dap_chain_block_chunks_t * l_ret = DAP_NEW_Z(dap_chain_block_chunks_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_chunks_create");
+ return NULL;
+ }
l_ret->blocks = a_blocks;
l_ret->gdb_group = dap_strdup_printf("local.%s.%s.block.chunks",a_blocks->chain->net_name, a_blocks->chain->name );
@@ -106,6 +110,10 @@ void dap_chain_block_chunks_add(dap_chain_block_chunks_t * a_chunks,dap_chain_bl
if(dap_hash_fast_compare(&l_chunk->block_cache_top->block_hash, &a_block_cache->prev_hash ) ){
// Init cache-hash object
l_chunk_cache_hash = DAP_NEW_Z(dap_chain_block_cache_hash_t);
+ if (!l_chunk_cache_hash) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_chunks_add");
+ return;
+ }
l_chunk_cache_hash->block_cache=a_block_cache;
l_chunk_cache_hash->ts_created = time(NULL);
l_chunk_cache_hash->block_hash = a_block_cache->block_hash;
@@ -128,6 +136,10 @@ void dap_chain_block_chunks_add(dap_chain_block_chunks_t * a_chunks,dap_chain_bl
// Init cache-hash object
l_chunk_cache_hash = DAP_NEW_Z(dap_chain_block_cache_hash_t);
+ if (!l_chunk_cache_hash) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_chunks_add");
+ return;
+ }
l_chunk_cache_hash->block_cache=a_block_cache;
l_chunk_cache_hash->ts_created = time(NULL);
l_chunk_cache_hash->block_hash = a_block_cache->block_hash;
@@ -156,6 +168,10 @@ void dap_chain_block_chunks_add(dap_chain_block_chunks_t * a_chunks,dap_chain_bl
dap_chain_block_chunk_t * dap_chain_block_chunk_create(dap_chain_block_chunks_t * a_chunks)
{
dap_chain_block_chunk_t * l_chunk = DAP_NEW_Z(dap_chain_block_chunk_t);
+ if (!l_chunk) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_block_chunk_create ");
+ return NULL;
+ }
// Add in tail
l_chunk->prev = a_chunks->chunks_first;
if (a_chunks->chunks_first){
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 801e1ecf22..c10a22fbfe 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -202,6 +202,10 @@ void dap_chain_cs_blocks_deinit()
int dap_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_config)
{
dap_chain_cs_blocks_t * l_cs_blocks = DAP_NEW_Z(dap_chain_cs_blocks_t);
+ if (!l_cs_blocks) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_blocks_new");
+ return -1;
+ }
a_chain->_inheritor = l_cs_blocks;
l_cs_blocks->chain = a_chain;
@@ -244,6 +248,10 @@ int dap_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_config
l_cs_blocks->callback_new_block_move = s_new_block_move;
dap_chain_cs_blocks_pvt_t *l_cs_blocks_pvt = DAP_NEW_Z(dap_chain_cs_blocks_pvt_t);
+ if (!l_cs_blocks_pvt) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_blocks_new");
+ return -1;
+ }
l_cs_blocks->_pvt = l_cs_blocks_pvt;
pthread_rwlock_init(&l_cs_blocks_pvt->rwlock,NULL);
pthread_rwlock_init(&l_cs_blocks_pvt->datums_lock, NULL);
@@ -460,6 +468,11 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
dap_chain_datum_t ** l_datums = DAP_NEW_Z_SIZE(dap_chain_datum_t*,
sizeof(dap_chain_datum_t*)*l_datums_count);
+ if (!l_datums) {
+ log_it(L_ERROR, "Memory allocation error in s_cli_blocks");
+ dap_cli_server_cmd_set_reply_text(a_str_reply,"Out of memory in s_cli_blocks");
+ return -1;
+ }
size_t l_datum_size = 0;
dap_chain_datum_t * l_datum = (dap_chain_datum_t*) dap_global_db_get_sync(l_gdb_group_mempool, l_subcmd_str_arg ,
@@ -891,6 +904,10 @@ static int s_add_atom_datums(dap_chain_cs_blocks_t *a_blocks, dap_chain_block_ca
l_ret++;
// Save datum hash -> block_hash link in hash table
dap_chain_block_datum_index_t *l_datum_index = DAP_NEW_Z(dap_chain_block_datum_index_t);
+ if (!l_datum_index) {
+ log_it(L_ERROR, "Memory allocation error in s_add_atom_datums");
+ return 1;
+ }
l_datum_index->ts_added = time(NULL);
l_datum_index->block_cache = a_block_cache;
l_datum_index->datum_hash = *l_datum_hash;
@@ -1156,6 +1173,10 @@ static size_t s_callback_atom_get_static_hdr_size(void)
static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold)
{
dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
+ if (!l_atom_iter) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_atom_iter_create");
+ return NULL;
+ }
l_atom_iter->chain = a_chain;
l_atom_iter->cell_id = a_cell_id;
l_atom_iter->with_treshold = a_with_treshold;
@@ -1379,9 +1400,21 @@ static dap_chain_atom_ptr_t *s_callback_atom_iter_get_lasts( dap_chain_atom_iter
*a_links_size = 1;
if (a_lasts_size_ptr) {
*a_lasts_size_ptr = DAP_NEW_Z(size_t);
+ if (!a_lasts_size_ptr) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_atom_iter_get_lasts");
+ return NULL;
+ }
(*a_lasts_size_ptr)[0] = l_block_cache_last->block_size;
}
dap_chain_atom_ptr_t *l_ret = DAP_NEW_Z(dap_chain_atom_ptr_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_atom_iter_get_lasts");
+ return NULL;
+ }
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in s_callback_atom_iter_get_lasts");
+ return NULL;
+ }
l_ret[0] = l_block_cache_last->block;
return l_ret;
}
@@ -1410,6 +1443,10 @@ static void s_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter)
static dap_chain_datum_iter_t *s_chain_callback_datum_iter_create(dap_chain_t *a_chain)
{
dap_chain_datum_iter_t *l_ret = DAP_NEW_Z(dap_chain_datum_iter_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_datum_iter_create");
+ return NULL;
+ }
l_ret->chain = a_chain;
return l_ret;
}
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index f72e63d3ea..1a47abbba4 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -226,7 +226,16 @@ static void s_timer_process_callback(void *a_arg)
int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
{
dap_chain_cs_dag_t * l_dag = DAP_NEW_Z(dap_chain_cs_dag_t);
+ if (!l_dag){
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_dag_new");
+ return -1;
+ }
l_dag->_pvt = DAP_NEW_Z(dap_chain_cs_dag_pvt_t);
+ if (!l_dag->_pvt){
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_dag_new");
+ DAP_DELETE(l_dag);
+ return -1;
+ }
l_dag->chain = a_chain;
pthread_mutexattr_t l_mutex_attr;
@@ -291,6 +300,12 @@ int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
char **l_hard_accept_list = dap_config_get_array_str(a_chain_cfg, "dag", "hard_accept_list", &l_list_len);
for (uint16_t i = 0; i < l_list_len; i++) {
dap_chain_cs_dag_hal_item_t *l_hal_item = DAP_NEW_Z(dap_chain_cs_dag_hal_item_t);
+ if (!l_hal_item){
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_dag_new");
+ DAP_DEL_Z(l_dag->_pvt);
+ DAP_DELETE(l_dag);
+ return -1;
+ }
dap_chain_hash_fast_from_str(l_hard_accept_list[i], &l_hal_item->hash);
HASH_ADD(hh, l_dag->hal, hash, sizeof(l_hal_item->hash), l_hal_item);
}
@@ -335,6 +350,11 @@ static void s_dap_chain_cs_dag_threshold_free(dap_chain_cs_dag_t *a_dag) {
HASH_ITER(hh, l_pvt->events_treshold, l_current, l_tmp) {
if (l_current->ts_added < l_time_cut_off) {
dap_chain_cs_dag_blocked_t *l_el = DAP_NEW(dap_chain_cs_dag_blocked_t);
+ if (!l_el) {
+ log_it(L_ERROR, "Memory allocation error in s_dap_chain_cs_dag_threshold_free");
+ pthread_mutex_unlock(&l_pvt->events_mutex);
+ return;
+ }
l_el->hash = l_current->hash;
HASH_ADD(hh, l_pvt->removed_events_from_treshold, hash, sizeof(dap_chain_hash_fast_t), l_el);
char *l_hash_dag = dap_hash_fast_to_str_new(&l_current->hash);
@@ -477,6 +497,10 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *) a_atom;
dap_chain_cs_dag_event_item_t * l_event_item = DAP_NEW_Z(dap_chain_cs_dag_event_item_t);
+ if (!l_event_item) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_add");
+ return ATOM_REJECT;
+ }
pthread_mutex_t *l_events_mutex = &PVT(l_dag)->events_mutex;
l_event_item->event = l_event;
l_event_item->event_size = a_atom_size;
@@ -895,6 +919,10 @@ void s_dag_events_lasts_process_new_last_event(dap_chain_cs_dag_t * a_dag, dap_c
//add self
dap_chain_cs_dag_event_item_t * l_event_last= DAP_NEW_Z(dap_chain_cs_dag_event_item_t);
+ if (!l_event_last) {
+ log_it(L_ERROR, "Memory allocation error in s_dag_events_lasts_process_new_last_event");
+ return;
+ }
l_event_last->ts_added = a_event_item->ts_added;
l_event_last->event = a_event_item->event;
l_event_last->event_size = a_event_item->event_size;
@@ -1011,6 +1039,10 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
dap_chain_atom_ptr_t a_atom, size_t a_atom_size)
{
dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
+ if (!l_atom_iter) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_iter_create_from");
+ return NULL;
+ }
l_atom_iter->chain = a_chain;
l_atom_iter->cur = a_atom;
l_atom_iter->cur_size = a_atom_size;
@@ -1036,6 +1068,10 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold)
{
dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
+ if (!l_atom_iter) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_iter_create");
+ return NULL;
+ }
l_atom_iter->chain = a_chain;
l_atom_iter->cell_id = a_cell_id;
l_atom_iter->with_treshold = a_with_treshold;
@@ -1062,6 +1098,10 @@ static dap_chain_datum_t **s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t
return NULL;
dap_chain_datum_t **l_datums = DAP_NEW_Z(dap_chain_datum_t*);
+ if (!l_datums) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_get_datum");
+ return NULL;
+ }
if (a_datums_count)
*a_datums_count = 1;
l_datums[0] = l_datum;
@@ -1173,9 +1213,18 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_links( dap_chain_ato
if ( l_event->header.hash_count > 0){
dap_chain_atom_ptr_t * l_ret = DAP_NEW_Z_SIZE(dap_chain_atom_ptr_t,
sizeof (dap_chain_atom_ptr_t) * l_event->header.hash_count );
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_iter_get_links");
+ return NULL;
+ }
if( a_links_size)
*a_links_size = l_event->header.hash_count;
*a_links_size_array = DAP_NEW_Z_SIZE(size_t, l_event->header.hash_count*sizeof (size_t));
+ if (!a_links_size_array) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_atom_iter_get_links");
+ DAP_DEL_Z(l_ret);
+ return NULL;
+ }
for (uint16_t i = 0; i < l_event->header.hash_count; i++){
dap_chain_cs_dag_event_item_t * l_link_item = NULL;
dap_chain_hash_fast_t * l_link_hash = (dap_chain_hash_fast_t *)
@@ -1318,6 +1367,10 @@ static void s_chain_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_ite
static dap_chain_datum_iter_t *s_chain_callback_datum_iter_create(dap_chain_t *a_chain)
{
dap_chain_datum_iter_t *l_ret = DAP_NEW_Z(dap_chain_datum_iter_t);
+ if (!l_ret) {
+ log_it(L_ERROR, "Memory allocation error in s_chain_callback_datum_iter_create");
+ return NULL;
+ }
l_ret->chain = a_chain;
return l_ret;
}
diff --git a/modules/type/dag/dap_chain_cs_dag_event.c b/modules/type/dag/dap_chain_cs_dag_event.c
index c1600428d4..9e5360fd37 100644
--- a/modules/type/dag/dap_chain_cs_dag_event.c
+++ b/modules/type/dag/dap_chain_cs_dag_event.c
@@ -230,6 +230,10 @@ static bool s_event_broadcast_send(dap_chain_cs_dag_event_round_broadcast_t *a_a
void dap_chain_cs_dag_event_broadcast(dap_chain_cs_dag_t *a_dag, dap_store_obj_t *a_obj, dap_global_db_context_t *a_context)
{
dap_chain_cs_dag_event_round_broadcast_t *l_arg = DAP_NEW(dap_chain_cs_dag_event_round_broadcast_t);
+ if (!l_arg) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_cs_dag_event_broadcast");
+ return;
+ }
l_arg->dag = a_dag;
l_arg->obj = dap_store_obj_copy(a_obj, 1);
l_arg->context = a_context;
diff --git a/modules/wallet/dap_chain_wallet.c b/modules/wallet/dap_chain_wallet.c
index b3dbc67491..d23c3681de 100644
--- a/modules/wallet/dap_chain_wallet.c
+++ b/modules/wallet/dap_chain_wallet.c
@@ -125,6 +125,10 @@ char *c_wallets_path;
if ( !l_prec )
{
l_prec = DAP_NEW_Z(dap_chain_wallet_n_pass_t); /* Get memory for new record */
+ if (!l_prec) {
+ log_it(L_ERROR, "Memory allocation error in dap_chain_wallet_activate");
+ return -EINVAL;
+ }
*l_prec = l_rec; /* Fill it by data */
HASH_ADD_STR(s_wallet_n_pass, name, l_prec); /* Add into the hash-table */
}
--
GitLab