diff --git a/dap-sdk b/dap-sdk
index 26f3dec199f975c29b7b8c241c108065e18e16ee..0ff84d9fde81d0bd97a8a0e9fea1b3dc379ed101 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 26f3dec199f975c29b7b8c241c108065e18e16ee
+Subproject commit 0ff84d9fde81d0bd97a8a0e9fea1b3dc379ed101
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index bcba0d6da13fc1586347e9e0647ea812cde2548c..0d6a2fe42d57f7ff5e4d98df84955c50efff6149 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -105,7 +105,7 @@ dap_chain_t * dap_chain_create(dap_ledger_t* a_ledger, const char * a_chain_net_
{
dap_chain_t * l_ret = DAP_NEW_Z(dap_chain_t);
if ( !l_ret ) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
DAP_CHAIN_PVT_LOCAL_NEW(l_ret);
@@ -119,7 +119,7 @@ dap_chain_t * dap_chain_create(dap_ledger_t* a_ledger, const char * a_chain_net_
dap_chain_item_t * l_ret_item = DAP_NEW_Z(dap_chain_item_t);
if ( !l_ret_item ){
DAP_DELETE(l_ret);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret_item->chain = l_ret;
@@ -436,7 +436,7 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
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!
if ( !l_chain->datum_types ) {
DAP_DELETE(l_chain);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_count_recognized = 0;
@@ -461,7 +461,7 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
if (l_chain->datum_types)
DAP_DELETE(l_chain->datum_types);
DAP_DELETE(l_chain);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_count_recognized = 0;
@@ -487,7 +487,7 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
{
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!
if ( !l_chain->autoproc_datum_types ) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if (l_chain->datum_types)
DAP_DELETE(l_chain->datum_types);
if (l_chain->default_datum_types)
diff --git a/modules/chain/dap_chain_cell.c b/modules/chain/dap_chain_cell.c
index 9b02441a1ed959296d634ff4d06e7f739cef10d0..7689aab2f79106bf0d1b0727aec0b023d10bb4bf 100644
--- a/modules/chain/dap_chain_cell.c
+++ b/modules/chain/dap_chain_cell.c
@@ -103,7 +103,7 @@ dap_chain_cell_t * dap_chain_cell_create_fill(dap_chain_t * a_chain, dap_chain_c
l_cell = DAP_NEW_Z(dap_chain_cell_t);
if ( !l_cell ) {
pthread_rwlock_unlock(&a_chain->cell_rwlock);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_cell->chain = a_chain;
@@ -216,7 +216,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, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
l_ret = -5;
break;
}
diff --git a/modules/chain/dap_chain_cs.c b/modules/chain/dap_chain_cs.c
index 3fa929898131dfb4fbfee923dea5136160a491f4..c3c4c9bd1122e4b380721a545d99432d578ee2ef 100644
--- a/modules/chain/dap_chain_cs.c
+++ b/modules/chain/dap_chain_cs.c
@@ -66,7 +66,7 @@ void dap_chain_cs_type_add (const char * a_cs_str, dap_chain_callback_new_cfg_t
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
strncpy(l_item->name, a_cs_str, sizeof (l_item->name) - 1);
@@ -106,7 +106,7 @@ void dap_chain_cs_add (const char * a_cs_str, dap_chain_callback_new_cfg_t a_ca
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
strncpy(l_item->name, a_cs_str, sizeof (l_item->name) - 1);
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index d9d58e2983014b96c20a3485d4e7ec8893190a85..98de78762c598baa7b48cc5d79e67c71f3d7bc8d 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -403,13 +403,13 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_ledger);
return NULL;
}
@@ -464,7 +464,7 @@ struct json_object *wallet_info_json_collect(dap_ledger_t *a_ledger, dap_ledger_
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 )
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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));
@@ -669,7 +669,7 @@ static bool s_ledger_token_update_check(dap_chain_ledger_token_item_t *a_cur_tok
//Check added signs
dap_chain_datum_token_t *l_token_tmp = DAP_DUP_SIZE(a_token_update, a_token_update_size);
if (!l_token_tmp) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free1(l_tsd_list_added_pkeys);
dap_list_free1(l_tsd_list_remote_pkeys);
return false;
@@ -856,7 +856,7 @@ char * dap_ledger_token_tx_item_list(dap_ledger_t * a_ledger, dap_chain_addr_t *
{
dap_string_t *l_str_out =dap_string_new(NULL);
if (!l_str_out) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
@@ -1020,7 +1020,7 @@ void s_ledger_token_cache_update(dap_ledger_t *a_ledger, dap_chain_ledger_token_
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
memcpy(l_cache, &l_token_item->current_supply, sizeof(uint256_t));
@@ -1117,7 +1117,7 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
default:
l_token = DAP_DUP_SIZE(a_token, a_token_size);
if ( !l_token ) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -6;
}
break;
@@ -1170,7 +1170,7 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
if ( !l_token_item ) {
DAP_DEL_Z(l_token);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -8;
}
*l_token_item = (dap_chain_ledger_token_item_t) {
@@ -1190,7 +1190,7 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
if (l_token)
DAP_DELETE(l_token);
DAP_DELETE(l_token_item);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -6;
};
if ( !l_token_item->auth_pkeys ) {
@@ -1198,7 +1198,7 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -6;
}
dap_stpcpy(l_token_item->ticker, l_token->ticker);
@@ -2235,12 +2235,12 @@ static void s_load_cache_gdb_loaded_balances_callback(dap_global_db_context_t *a
for (size_t i = 0; i < a_values_count; i++) {
dap_ledger_wallet_balance_t *l_balance_item = DAP_NEW_Z(dap_ledger_wallet_balance_t);
if (!l_balance_item) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_balance_item->key = DAP_NEW_Z_SIZE(char, strlen(a_values[i].key) + 1);
if (!l_balance_item->key) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_balance_item);
return;
}
@@ -2286,7 +2286,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dap_chain_hash_fast_from_str(a_values[i].key, &l_tx_spent_item->tx_hash_fast);
@@ -2321,14 +2321,14 @@ static void s_load_cache_gdb_loaded_txs_callback(dap_global_db_context_t *a_glob
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
memcpy(&l_tx_item->cache_data, a_values[i].value, sizeof(l_tx_item->cache_data));
@@ -2403,7 +2403,7 @@ static void s_load_cache_gdb_loaded_emissions_callback(dap_global_db_context_t *
}
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dap_chain_hash_fast_from_str(a_values[i].key, &l_emission_item->datum_token_emission_hash);
@@ -2506,7 +2506,7 @@ dap_ledger_t *dap_chain_ledger_create(uint16_t a_flags, dap_chain_net_id_t a_net
{
dap_ledger_t *l_ledger = dap_chain_ledger_handle_new();
if (!l_ledger) {
- log_it(L_ERROR, "Memory allocation error indap_chain_ledger_create");
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ledger->net_name = a_net_name;
@@ -2543,7 +2543,7 @@ dap_ledger_t *dap_chain_ledger_create(uint16_t a_flags, dap_chain_net_id_t a_net
for (uint16_t i = 0; i < l_whitelist_size; ++i) {
dap_ledger_hal_item_t *l_hal_item = DAP_NEW_Z(dap_ledger_hal_item_t);
if (!l_hal_item) {
- log_it(L_ERROR, "Memory allocation error indap_chain_ledger_create");
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_ledger_pvt);
DAP_DEL_Z(l_ledger);
dap_config_close(l_cfg);
@@ -2849,13 +2849,13 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return DAP_CHAIN_LEDGER_EMISSION_ADD_MEMORY_PROBLEM;
}
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
@@ -2893,7 +2893,7 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
if (!l_token_emission_item) {
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return DAP_CHAIN_LEDGER_EMISSION_ADD_MEMORY_PROBLEM;
}
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
@@ -3179,7 +3179,7 @@ void dap_chain_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledge
if(l_tx_item) {
l_tickers = DAP_NEW_Z_SIZE(char *, l_tickers_size * sizeof(char*));
if ( !l_tickers ) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
while(l_tx_item) {
@@ -3197,7 +3197,7 @@ void dap_chain_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledge
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
}
@@ -3211,7 +3211,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
}
@@ -3237,7 +3237,7 @@ void dap_chain_ledger_addr_get_token_ticker_all(dap_ledger_t *a_ledger, dap_chai
dap_chain_ledger_token_item_t * l_token_item, *l_tmp;
char **l_tickers = DAP_NEW_Z_SIZE(char*, l_count * sizeof(char*));
if (!l_tickers) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_rwlock_unlock(&PVT(a_ledger)->balance_accounts_rwlock);
return;
}
@@ -3257,7 +3257,7 @@ void dap_chain_ledger_addr_get_token_ticker_all(dap_ledger_t *a_ledger, dap_chai
if(l_count && a_tickers){
char **l_tickers = DAP_NEW_Z_SIZE(char*, l_count * sizeof(char*));
if (!l_tickers) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_rwlock_unlock(&PVT(a_ledger)->balance_accounts_rwlock);
return;
}
@@ -3588,7 +3588,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if ( l_list_bound_items )
dap_list_free_full(l_list_bound_items, NULL);
if (l_list_tx_out)
@@ -3991,7 +3991,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if (bound_item)
DAP_DELETE(bound_item);
if ( l_list_bound_items )
@@ -4038,7 +4038,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if (bound_item)
DAP_DELETE(bound_item);
if ( l_list_bound_items )
@@ -4120,7 +4120,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if (bound_item)
DAP_DELETE(bound_item);
if ( l_list_bound_items )
@@ -4399,14 +4399,14 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
} 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_item_tmp->ts_added = dap_nanotime_now();
@@ -4437,7 +4437,7 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
if (l_item_tmp->tx)
DAP_DELETE(l_item_tmp->tx);
DAP_DELETE(l_item_tmp);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
@@ -4704,7 +4704,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
l_ret = -1;
goto FIN;
}
@@ -4849,7 +4849,7 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
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 ) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if (l_item_tmp->tx)
DAP_DELETE(l_item_tmp->tx);
if (l_item_tmp)
@@ -5577,8 +5577,8 @@ int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype,
}
l_new_verificator = DAP_NEW(dap_chain_ledger_verificator_t);
if ( !l_new_verificator ) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
- return -1;
+ log_it(L_CRITICAL, "Memory allocation error");
+ return -1;
}
l_new_verificator->subtype = (int)a_subtype;
l_new_verificator->callback = a_callback;
diff --git a/modules/chain/dap_chain_pvt.c b/modules/chain/dap_chain_pvt.c
index fbe0005c123833be4ce383df85ccb132596556fa..0eb46180329259d4cca74eb4428fc0584bb9640b 100644
--- a/modules/chain/dap_chain_pvt.c
+++ b/modules/chain/dap_chain_pvt.c
@@ -38,7 +38,7 @@ void dap_chain_add_mempool_notify_callback(dap_chain_t *a_chain, dap_store_obj_c
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_notifier->callback = a_callback;
diff --git a/modules/chain/dap_chain_tx.c b/modules/chain/dap_chain_tx.c
index d42f6161ad2eb6eeefe9027f93c7993cad19fb6c..d895ad60705cb8032b36d5f266b9500dad4bc897 100644
--- a/modules/chain/dap_chain_tx.c
+++ b/modules/chain/dap_chain_tx.c
@@ -37,7 +37,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
dap_hash_fast(a_tx_packed, dap_chain_datum_tx_get_size(a_tx_packed), &l_tx->hash);
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 aab1161c33eb9fa4b2b26b0a9eac6b50ebd9a37b..43b131a4990da8ff14c12132342c4c297bece8bf 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
@@ -101,7 +101,7 @@ static inline void s_grace_error(dap_chain_net_srv_grace_t *a_grace, dap_stream_
else {
l_item = DAP_NEW_Z(dap_chain_net_srv_banlist_item_t);
if (!l_item) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(a_grace->request);
DAP_DELETE(a_grace);
return;
@@ -318,7 +318,7 @@ static void s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
dap_stream_ch_chain_net_srv_pkt_success_t *l_success = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_success_t,
l_success_size);
if(!l_success) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_ALLOC_MEMORY_ERROR;
if(a_ch)
dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
@@ -404,7 +404,7 @@ static void s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
}
usages_in_grace_t *l_item = DAP_NEW_Z_SIZE(usages_in_grace_t, sizeof(usages_in_grace_t));
if (!l_item) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
s_grace_error(a_grace, l_err);
return;
}
@@ -665,7 +665,7 @@ static bool s_grace_period_finish(usages_in_grace_t *a_grace_item)
log_it(L_ERROR, "Tx cond have not enough funds");
dap_chain_net_srv_grace_t* l_grace_new = DAP_NEW_Z(dap_chain_net_srv_grace_t);
if (!l_grace_new) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(a_grace_item->grace->request);
DAP_DEL_Z(a_grace_item->grace);
RET_WITH_DEL_A_GRACE;
@@ -673,7 +673,7 @@ static bool s_grace_period_finish(usages_in_grace_t *a_grace_item)
// Parse the request
l_grace_new->request = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_request_t, sizeof(dap_stream_ch_chain_net_srv_pkt_request_t));
if (!l_grace_new->request) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(a_grace_item->grace->request);
DAP_DEL_Z(a_grace_item->grace);
RET_WITH_DEL_A_GRACE;
@@ -916,7 +916,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
DAP_DELETE(l_usage->receipt);
l_usage->receipt = DAP_DUP_SIZE(l_receipt, l_receipt_size);
if (!l_usage->receipt) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_is_first_sign = true;
@@ -925,7 +925,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
DAP_DELETE(l_usage->receipt_next);
l_usage->receipt_next = DAP_DUP_SIZE(l_receipt, l_receipt_size);
if (!l_usage->receipt_next) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_usage->is_active = true;
@@ -959,7 +959,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
log_it(L_ERROR, "Can't find tx cond. Start grace!");
l_grace = DAP_NEW_Z(dap_chain_net_srv_grace_t);
if (!l_grace) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_tx_in_hash_str);
return;
}
@@ -967,7 +967,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
// Parse the request
l_grace->request = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_request_t, sizeof(dap_stream_ch_chain_net_srv_pkt_request_t));
if (!l_grace->request) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_grace)
DAP_DELETE(l_tx_in_hash_str);
return;
@@ -990,14 +990,14 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
l_usage->is_waiting_new_tx_cond = true;
l_grace = DAP_NEW_Z(dap_chain_net_srv_grace_t);
if (!l_grace) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_tx_in_hash_str);
return;
}
// Parse the request
l_grace->request = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_request_t, sizeof(dap_stream_ch_chain_net_srv_pkt_request_t));
if (!l_grace->request) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_grace)
DAP_DELETE(l_tx_in_hash_str);
return;
@@ -1178,7 +1178,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
dap_stream_ch_chain_net_srv_pkt_success_t *l_success = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_success_t,
l_success_size);
if(!l_success) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_success->hdr.usage_id = l_usage->id;
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 27bed762f2540f13504732ca9e2256976dbd998a..7a30adef2bf9692375ea0e4f302f4e5b34bba9e8 100644
--- a/modules/channel/chain-net/dap_stream_ch_chain_net.c
+++ b/modules/channel/chain-net/dap_stream_ch_chain_net.c
@@ -169,7 +169,7 @@ void s_stream_ch_new(dap_stream_ch_t* a_ch, void* a_arg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_mutex_unlock(&s_hash_mutex);
return;
}
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 22e710c5a3b53326e47cc3a559a69323236fcfb2..8fb6644105093ac3d95b55656febdea97a44387b 100644
--- a/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
+++ b/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
@@ -106,7 +106,7 @@ void dap_stream_ch_chain_voting_message_write(dap_chain_net_t *a_net, dap_chain_
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_node_client_item->node_addr = *a_remote_node_addr;
diff --git a/modules/channel/chain/dap_stream_ch_chain.c b/modules/channel/chain/dap_stream_ch_chain.c
index 79c5e0fb0be41125032f8ae09c17bbcd4380042d..55bb4951346d434d13abfbe38c37dfb8c0021a23 100644
--- a/modules/channel/chain/dap_stream_ch_chain.c
+++ b/modules/channel/chain/dap_stream_ch_chain.c
@@ -801,7 +801,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
*l_sync_request = (struct sync_request) {
@@ -1041,7 +1041,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_hash_item->hash = l_element->hash;
@@ -1256,7 +1256,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_hash_item->hash = l_element->hash;
@@ -1687,7 +1687,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_hash_item->hash = l_obj->hash;
@@ -1791,7 +1791,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_hash_item->hash = *l_ch_chain->request_atom_iter->cur_hash;
diff --git a/modules/common/dap_chain_common.c b/modules/common/dap_chain_common.c
index 1f090fb9d21d74812c562aa70f8f80ec15607407..e528930e85d6f0b20366e7b507b27a53a073615e 100644
--- a/modules/common/dap_chain_common.c
+++ b/modules/common/dap_chain_common.c
@@ -308,7 +308,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
int l_pos = 0;
@@ -642,7 +642,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
int l_pos = 0;
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index 881ea23c5ae970d823128aac9c5f4f6bb0ea464d..c2d0b7d9fbfc168db3699b9d9e7c652cc3c702e8 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -350,7 +350,7 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_value_str);
DAP_DELETE(l_coins_str);
return false;
@@ -358,7 +358,7 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_provider);
DAP_DELETE(l_value_str);
DAP_DELETE(l_coins_str);
@@ -375,7 +375,7 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
} 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_value_str);
DAP_DELETE(l_coins_str);
return false;
diff --git a/modules/common/dap_chain_datum_decree.c b/modules/common/dap_chain_datum_decree.c
index 027b3f67fa610547772b2ab092bbbf536030ec56..69941575b310fda910657a4ed0ccd38bd4d9f94b 100644
--- a/modules/common/dap_chain_datum_decree.c
+++ b/modules/common/dap_chain_datum_decree.c
@@ -451,7 +451,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_stake_addr_signing_str);
return;
}
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 223d316a41d29aff55d8fdc75be8cf5a32be3345..c7090dea095c6c0e67ae2b2cc189375cd0c1396d 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -351,7 +351,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_create(uint256_t a_va
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_emission->hdr.version = 3;
@@ -395,7 +395,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emissi
size_t l_add_size = sizeof(l_emission->hdr) - l_old_hdr_size;
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_emission_size + l_add_size);
if (!l_emission) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_emission->hdr.version = 2;
@@ -410,7 +410,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emissi
} else {
l_emission = DAP_DUP_SIZE(a_emission_serial, *a_emission_size);
if (!l_emission) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
if (((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.version == 1)
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 5de72275bb6ab75297cf0d209d4ae1a56ca37a7e..e6d5c578517c69502fd4f016ae88a16d1149fff6 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -40,7 +40,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return 0;
}
tx->header.ts_created = time(NULL);
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 d785bdfed5524d56a416b33efd5dbba103198c6a..f423dcb8405e8ccb301c314cf1800f0cad9452b6 100644
--- a/modules/consensus/block-poa/dap_chain_cs_block_poa.c
+++ b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
@@ -186,7 +186,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_blocks->_inheritor = l_poa;
@@ -195,7 +195,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
dap_chain_cs_block_poa_pvt_t *l_poa_pvt = PVT(l_poa);
@@ -208,7 +208,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
// 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
char l_cert_name[512];
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 102247e3a465cd02726c4cecb58c91ee242c5e65..d0acf7c33c786bd797a6cd9e5abef387b6feda01 100644
--- a/modules/consensus/block-pos/dap_chain_cs_block_pos.c
+++ b/modules/consensus/block-pos/dap_chain_cs_block_pos.c
@@ -87,7 +87,7 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_blocks->_inheritor = l_pos;
@@ -96,7 +96,7 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
goto lb_err;
}
dap_chain_cs_block_pos_pvt_t *l_pos_pvt = PVT(l_pos);
@@ -112,12 +112,12 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
goto lb_err;
}
for (size_t i = 0; i < l_tokens_hold_value_size; i++) {
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 9fcd932839f5698f91ec31dbbaca59210eab6165..9990b22d3c468a4aeded4e5d2bf8dc33a8f07da8 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -158,7 +158,7 @@ void dap_chain_cs_dag_poa_presign_callback_set(dap_chain_t *a_chain, dap_chain_c
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_poa_pvt->callback_pre_sign->callback = a_callback;
@@ -345,7 +345,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_dag->_inheritor = l_poa;
@@ -355,7 +355,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
@@ -372,7 +372,7 @@ 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) {
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
char l_cert_name[512];
@@ -662,7 +662,7 @@ static void s_round_event_cs_done(dap_chain_cs_dag_t * a_dag, uint64_t a_round_i
l_callback_arg = DAP_NEW_Z(struct round_timer_arg);
if (!l_callback_arg) {
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_callback_arg->dag = a_dag;
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 de2c3413c9153cc94be9dcec369863546fef46e3..b3da9c6230fc43f78f1e5c5a99fb20579a3e1e01 100644
--- a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
+++ b/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
@@ -83,7 +83,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * 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);
if (!l_pos) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
dap_chain_cs_dag_pos_pvt_t * l_pos_pvt = PVT ( l_pos );
@@ -99,7 +99,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
goto lb_err;
}
@@ -115,13 +115,13 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
goto lb_err;
}
for (size_t i = 0; i < l_tokens_hold_value_size; i++){
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 20ae7ff2c17e0490c9b3da64f384972add06b2ce..ac9d3c2f8bf0f1e91ef9bc340afafcf9bc0bfaba 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -168,7 +168,7 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return - 5;
}
l_esbocs->blocks = l_blocks;
@@ -185,7 +185,7 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
l_esbocs->_pvt = DAP_NEW_Z(dap_chain_esbocs_pvt_t);
dap_chain_esbocs_pvt_t *l_esbocs_pvt = PVT(l_esbocs);
if (!l_esbocs_pvt) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
l_ret = - 5;
goto lb_err;
}
@@ -239,7 +239,7 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
l_ret = - 5;
goto lb_err;
}
@@ -366,7 +366,7 @@ static void s_session_load_penaltys(dap_chain_esbocs_session_t *a_session)
else {
dap_chain_esbocs_penalty_item_t *l_item = DAP_NEW_Z(dap_chain_esbocs_penalty_item_t);
if (!l_item) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_item->signing_addr = *l_addr;
@@ -458,7 +458,7 @@ static int s_callback_created(dap_chain_t *a_chain, dap_config_t *a_chain_net_cf
dap_chain_esbocs_session_t *l_session = DAP_NEW_Z(dap_chain_esbocs_session_t);
if(!l_session) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -8;
}
l_session->chain = a_chain;
@@ -543,7 +543,7 @@ static void *s_callback_list_form(const void *a_srv_validator, UNUSED_ARG void *
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_validator->node_addr = ((dap_chain_net_srv_stake_item_t *)a_srv_validator)->node_addr;
@@ -741,7 +741,7 @@ static void s_session_update_penalty(dap_chain_esbocs_session_t *a_session)
if (!l_item) {
l_item = DAP_NEW_Z(dap_chain_esbocs_penalty_item_t);
if (!l_item) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_item->signing_addr = *l_signing_addr;
@@ -1235,7 +1235,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
if (!a_message_hash) {
@@ -1597,12 +1597,12 @@ static void s_session_round_finish(dap_chain_esbocs_session_t *a_session, dap_ch
fee_serv_param_t *tmp = DAP_NEW(fee_serv_param_t);
if (!tmp) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dap_chain_addr_t * addr = DAP_NEW_Z(dap_chain_addr_t);
if (!addr) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(tmp);
return;
}
@@ -1629,7 +1629,7 @@ void s_session_sync_queue_add(dap_chain_esbocs_session_t *a_session, dap_chain_e
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_sync_item->last_block_hash = a_message->hdr.candidate_hash;
@@ -1661,7 +1661,7 @@ void s_session_validator_mark_online(dap_chain_esbocs_session_t *a_session, dap_
log_it(L_ERROR, "Got sync message from validator not in active list nor in penalty list");
l_item = DAP_NEW_Z(dap_chain_esbocs_penalty_item_t);
if (!l_item) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_item->signing_addr = *a_signing_addr;
@@ -2043,7 +2043,7 @@ static void s_session_packet_in(void *a_arg, dap_chain_node_addr_t *a_sender_nod
if (l_session->db_serial) {
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
goto session_unlock;
}
l_validator->node_addr = *dap_chain_net_srv_stake_key_get_node_addr(&l_signing_addr);
@@ -2166,7 +2166,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
goto session_unlock;
}
l_store->candidate_size = l_candidate_size;
@@ -2569,7 +2569,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT;
@@ -2579,7 +2579,7 @@ static dap_chain_datum_decree_t *s_esbocs_decree_set_min_validators_count(dap_ch
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
diff --git a/modules/consensus/none/dap_chain_cs_none.c b/modules/consensus/none/dap_chain_cs_none.c
index 9086ee80fdf9e19274fa3555d67d25a7a6ec0ff9..c2e60694018c6ad621c2af627dd473c65492c2bb 100644
--- a/modules/consensus/none/dap_chain_cs_none.c
+++ b/modules/consensus/none/dap_chain_cs_none.c
@@ -172,12 +172,12 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_gdb);
return -1;
}
@@ -396,7 +396,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return ATOM_REJECT;
}
size_t l_datum_size = dap_chain_datum_size(l_datum);
@@ -452,7 +452,7 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_iter->chain = a_chain;
@@ -474,7 +474,7 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_iter->chain = a_chain;
@@ -643,7 +643,7 @@ static dap_chain_datum_t **s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
if (a_datums_count)
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 8804360b24ba7468debc1ede2d2d406c4f2b3875..1b2a10a46b73abb419a032ac4af72f1d2d069c87 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -545,7 +545,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_objs);
dap_list_free( l_list_out_items);
return -6;
@@ -1052,7 +1052,7 @@ dap_datum_mempool_t * dap_datum_mempool_deserialize(uint8_t *a_datum_mempool_ser
//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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
datum_mempool->version = *(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 eed26a2c4beb69dc83adde2cc6bd5454ef220106..325109036487ea1e812d6c53d6fd000b444a07f3 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -448,7 +448,7 @@ void dap_chain_net_add_gdb_notify_callback(dap_chain_net_t *a_net, dap_store_obj
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_notifier->callback = a_callback;
@@ -472,7 +472,7 @@ int dap_chain_net_add_downlink(dap_chain_net_t *a_net, dap_stream_worker_t *a_wo
}
l_downlink = DAP_NEW_Z(struct downlink);
if (!l_downlink) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_rwlock_unlock(&l_net_pvt->downlinks_lock);
return -1;
}
@@ -578,7 +578,7 @@ static void s_chain_callback_notify(void *a_arg, dap_chain_t *a_chain, dap_chain
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_args->net = l_net;
@@ -709,7 +709,7 @@ static int s_net_link_add(dap_chain_net_t *a_net, dap_chain_node_info_t *a_link_
}
l_new_link = DAP_NEW_Z(struct net_link);
if (!l_new_link) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_mutex_unlock(&PVT(a_net)->uplinks_mutex);
return -4;
}
@@ -1206,7 +1206,7 @@ static bool s_new_balancer_link_request(dap_chain_net_t *a_net, int a_link_repla
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_link_node_info);
return false;
}
@@ -1368,7 +1368,7 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_rwlock_unlock(&l_net_pvt->states_lock);
return false;
}
@@ -1530,7 +1530,7 @@ static dap_chain_net_t *s_net_new(const char *a_id, const char *a_name,
return NULL;
dap_chain_net_t *l_ret = DAP_NEW_Z_SIZE(dap_chain_net_t, sizeof(dap_chain_net_t) + sizeof(dap_chain_net_pvt_t));
if (!l_ret) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret->pub.name = strdup( a_name );
@@ -2372,7 +2372,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_config_close(l_cfg);
return -1;
}
@@ -2387,13 +2387,13 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_net_pvt->gdb_sync_nodes_links_ips);
dap_config_close(l_cfg);
return -1;
@@ -2431,7 +2431,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_config_close(l_cfg);
return -1;
}
@@ -2651,7 +2651,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
else {
l_node_addr = DAP_NEW_Z(dap_chain_node_addr_t);
if (!l_node_addr) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_config_close(l_cfg);
return -1;
}
@@ -2672,7 +2672,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
if ( !l_net_pvt->node_info ) { // If not present - create it
l_net_pvt->node_info = DAP_NEW_Z(dap_chain_node_info_t);
if (!l_net_pvt->node_info) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_node_addr);
dap_config_close(l_cfg);
return -1;
@@ -2730,7 +2730,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
continue;
char * l_entry_name = strdup(l_dir_entry->d_name);
if (!l_entry_name) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_config_close(l_cfg);
closedir(l_chains_dir);
return -1;
@@ -2744,7 +2744,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
if(l_cfg_new) {
list_priority *l_chain_prior = DAP_NEW_Z(list_priority);
if (!l_chain_prior) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE (l_entry_name);
closedir(l_chains_dir);
dap_config_close(l_cfg_new);
@@ -2997,7 +2997,7 @@ dap_chain_net_t **dap_chain_net_list(uint16_t *a_size)
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_rwlock_unlock(&s_net_items_rwlock);
return NULL;
}
@@ -3271,7 +3271,7 @@ dap_list_t* dap_chain_net_get_link_node_list(dap_chain_net_t * l_net, bool a_is_
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_address->uint64 = l_cur_node_info->links[i].uint64;
@@ -3309,7 +3309,7 @@ dap_list_t* dap_chain_net_get_node_list(dap_chain_net_t * l_net)
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_address->uint64 = l_node_info->hdr.address.uint64;
@@ -3512,7 +3512,7 @@ static uint8_t *s_net_set_acl(dap_chain_hash_fast_t *a_pkey_hash)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_net_list);
return NULL;
}
diff --git a/modules/net/dap_chain_net_decree.c b/modules/net/dap_chain_net_decree.c
index 40bbb64a5122e9f1c3844c98ec1b7673ff133ca6..c245f7dcbfaf5c4eb88c209f86aec206df1791e1 100644
--- a/modules/net/dap_chain_net_decree.c
+++ b/modules/net/dap_chain_net_decree.c
@@ -269,7 +269,7 @@ int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_d
} else {
l_decree_hh = DAP_NEW_Z(struct decree_hh);
if (!l_decree_hh) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_decree_hh->decree = DAP_DUP_SIZE(a_decree, dap_chain_datum_decree_get_size(a_decree));
@@ -379,7 +379,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
memcpy(l_decree_addr, &l_addr, sizeof(dap_chain_addr_t));
diff --git a/modules/net/dap_chain_net_tx.c b/modules/net/dap_chain_net_tx.c
index e88bb9ba56dd71cce3fc6d4e64d192135244ff07..45c166b2271dfd500a35eeabb510183210fa0eda 100644
--- a/modules/net/dap_chain_net_tx.c
+++ b/modules/net/dap_chain_net_tx.c
@@ -46,7 +46,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
@@ -118,7 +118,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_datums);
DAP_DEL_Z(l_ret);
return NULL;
@@ -141,7 +141,7 @@ dap_chain_datum_tx_spends_items_t * dap_chain_net_get_tx_cond_all_with_spends_by
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_datums);
DAP_DEL_Z(l_ret);
return NULL;
@@ -305,7 +305,7 @@ static void s_get_tx_cond_chain_callback(dap_chain_net_t* a_net, dap_chain_datum
}else if(a_tx){
dap_hash_fast_t * l_tx_hash = dap_chain_node_datum_tx_calc_hash(a_tx);
if (!l_tx_hash) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
if (dap_hash_fast_compare(l_tx_hash,l_args->tx_begin_hash)) {
@@ -340,7 +340,7 @@ dap_list_t * dap_chain_net_get_tx_cond_chain(dap_chain_net_t * a_net, dap_hash_f
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_args->tx_begin_hash = a_tx_hash;
@@ -458,7 +458,7 @@ dap_list_t * dap_chain_net_get_tx_cond_all_for_addr(dap_chain_net_t * a_net, dap
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_args->addr = a_addr;
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index 2903f0224dd9e4db9b8f1dd3441c988c3e0f3ece..a7c387ba5e0bb720b6fbf384ad2e9a33019c0ef8 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -56,7 +56,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
dap_chain_hash_fast_t l_hash;
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 05097a8c46efe9e4a8c66bec2588669785a42c32..23fedc849928fd2605f22fcadfa9e9c5d1e55051 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -189,7 +189,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_address->uint64 = a_addr->uint64;
@@ -3855,7 +3855,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// Create new datum token
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t) + l_params->ext.tsd_total_size);
if (!l_datum_token) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory in com_token_decl");
DAP_DEL_Z(l_params);
return -1;
@@ -3920,7 +3920,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
case DAP_CHAIN_DATUM_TOKEN_SUBTYPE_SIMPLE: { // 256
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t));
if (!l_datum_token) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory in com_token_decl");
DAP_DEL_Z(l_params);
return -1;
@@ -4089,7 +4089,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
// Create new datum token
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t) + l_params->ext.tsd_total_size);
if (!l_datum_token) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_datum_token->version = 2;
@@ -4126,7 +4126,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
case DAP_CHAIN_DATUM_TOKEN_SUBTYPE_SIMPLE: { // 256
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t));
if (!l_datum_token) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_datum_token->version = 2;
@@ -6138,7 +6138,7 @@ int cmd_remove(int a_argc, char **a_argv, char ** a_str_reply)
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free(l_net_returns);
return -1;
}
@@ -6710,7 +6710,7 @@ static byte_t *s_concat_meta (dap_list_t *a_meta, size_t *a_fullsize)
int l_power = 1;
byte_t *l_buf = DAP_CALLOC(l_part * l_power++, 1);
if (!l_buf) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
size_t l_counter = 0;
@@ -6726,7 +6726,7 @@ static byte_t *s_concat_meta (dap_list_t *a_meta, size_t *a_fullsize)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
}
@@ -6749,7 +6749,7 @@ static uint8_t *s_concat_hash_and_mimetypes (dap_chain_hash_fast_t *a_chain_hash
*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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_buf);
return NULL;
}
@@ -6768,7 +6768,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
strncpy (l_buf, a_file, a_index);
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index c19532858ae61bf590a0414f6eeda7aeba7f181b..ff303a5638b84c033b51b9fb6492b033f9529b08 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -194,7 +194,7 @@ static void s_tx_header_print(dap_string_t *a_str_out, dap_chain_tx_hash_process
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_tx_data->hash = *a_tx_hash;
@@ -236,7 +236,7 @@ char* dap_db_history_addr(dap_chain_addr_t *a_addr, dap_chain_t *a_chain, const
dap_string_t *l_str_out = dap_string_new(NULL);
if (!l_str_out) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
dap_chain_tx_hash_processed_ht_t *l_tx_data_ht = NULL;
@@ -444,7 +444,7 @@ static char* dap_db_chain_history_token_list(dap_chain_t * a_chain, const char *
}
dap_string_t *l_str_out = dap_string_new(NULL);
if (!l_str_out) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
*a_token_num = 0;
@@ -526,7 +526,7 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
}
dap_string_t *l_str_out = dap_string_new(NULL);
if (!l_str_out) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
// list all transactions
@@ -612,7 +612,7 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
}
l_sht = DAP_NEW_Z(dap_chain_tx_hash_processed_ht_t);
if (!l_sht) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_sht->hash = l_tx_hash;
@@ -743,7 +743,7 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
memcpy(l_addr, l_addr_tmp, sizeof(dap_chain_addr_t));
@@ -1374,7 +1374,7 @@ int cmd_decree(int a_argc, char **a_argv, char ** a_str_reply)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return -1;
}
@@ -1388,7 +1388,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return -1;
}
@@ -1445,7 +1445,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return -1;
}
diff --git a/modules/net/dap_chain_node_client.c b/modules/net/dap_chain_node_client.c
index 4608102891d5e7a999ca0475d6ea62401bdcdb5c..cef1a1c20f9af2270502782a99ca128e058150d8 100644
--- a/modules/net/dap_chain_node_client.c
+++ b/modules/net/dap_chain_node_client.c
@@ -686,7 +686,7 @@ dap_chain_node_client_t *dap_chain_node_client_create(dap_chain_net_t *a_net,
}
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
diff --git a/modules/net/dap_chain_node_dns_client.c b/modules/net/dap_chain_node_dns_client.c
index 0f1460e8a249a0ad265b013299b4690894b0be1e..fab8ea735b5106511d8e64c478684a489d0482c2 100644
--- a/modules/net/dap_chain_node_dns_client.c
+++ b/modules/net/dap_chain_node_dns_client.c
@@ -175,7 +175,7 @@ static void s_dns_client_esocket_worker_assign_callback(dap_events_socket_t * a_
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
*l_es_uuid_ptr = a_esocket->uuid;
diff --git a/modules/net/dap_chain_node_dns_server.c b/modules/net/dap_chain_node_dns_server.c
index a6718589b92a140e7fad2133411c9823f7b9088b..bf9a95796f3ae328e0fbd18bab3c80ee30dbcb09 100644
--- a/modules/net/dap_chain_node_dns_server.c
+++ b/modules/net/dap_chain_node_dns_server.c
@@ -54,7 +54,7 @@ int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback) {
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return DNS_ERROR_FAILURE;
}
new_zone->zone = dap_strdup(zone);
@@ -117,18 +117,18 @@ void dap_dns_client_read(dap_events_socket_t *a_es, void *a_arg) {
}
dap_dns_buf_t *dns_message = DAP_NEW(dap_dns_buf_t);
if (!dns_message) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dap_dns_buf_t *dns_reply = DAP_NEW(dap_dns_buf_t);
if (!dns_reply) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(dns_message);
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(dns_message);
DAP_DELETE(dns_reply);
return;
@@ -141,7 +141,7 @@ void dap_dns_client_read(dap_events_socket_t *a_es, void *a_arg) {
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dns_reply->size = 0;
@@ -284,7 +284,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dap_events_socket_callbacks_t l_cb = {};
diff --git a/modules/net/dap_chain_node_ping.c b/modules/net/dap_chain_node_ping.c
index 728e2171ee0083535cd373d0113a635c9044c5ee..c92605d93ebe91ddcabfb84f246615810df00819 100644
--- a/modules/net/dap_chain_node_ping.c
+++ b/modules/net/dap_chain_node_ping.c
@@ -88,7 +88,7 @@ static void* node_ping_proc(void *a_arg)
char *host4 = DAP_NEW_SIZE(char, INET_ADDRSTRLEN);
if (!host4) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
struct sockaddr_in sa4 = { .sin_family = AF_INET, .sin_addr = l_addr };
@@ -161,7 +161,7 @@ int start_node_ping(pthread_t *a_thread, struct in_addr a_addr, int a_port, int
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
memcpy(l_data, &a_count, sizeof(int));
@@ -274,7 +274,7 @@ static void* node_ping_background_proc(void *a_arg)
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_node_list0, NULL);
DAP_DEL_Z(s_node_addr_ping);
return 0;
@@ -285,7 +285,7 @@ static void* node_ping_background_proc(void *a_arg)
l_node_addr_tmp = DAP_NEW(dap_chain_node_addr_t);
if (!l_node_addr_tmp) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_node_list0, NULL);
DAP_DEL_Z(s_node_addr_ping);
return 0;
@@ -313,7 +313,7 @@ int dap_chain_node_ping_background_start(dap_chain_net_t *a_net, dap_list_t *a_n
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_node_list, NULL);
return -1;
}
@@ -324,7 +324,7 @@ int dap_chain_node_ping_background_start(dap_chain_net_t *a_net, dap_list_t *a_n
// 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_node_list, NULL);
return -1;
}
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 8a3780df189ef6cf96b8da52a0530a309eeec6c9..926f99f0044beb17aec17277879c72d4c25f98d8 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -843,7 +843,7 @@ int dap_chain_net_srv_price_apply_from_my_order(dap_chain_net_srv_t *a_srv, cons
l_err_code = 0;
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_order);
dap_global_db_objs_delete(l_orders, l_orders_count);
return -1;
@@ -893,7 +893,7 @@ int dap_chain_net_srv_parse_pricelist(dap_chain_net_srv_t *a_srv, const char *a_
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return ret;
}
short l_iter = 0;
@@ -993,7 +993,7 @@ dap_chain_net_srv_t* dap_chain_net_srv_add(dap_chain_net_srv_uid_t a_uid,
if(!l_sdata) {
l_srv = DAP_NEW_Z(dap_chain_net_srv_t);
if (!l_srv) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_mutex_unlock(&s_srv_list_mutex);
return NULL;
}
@@ -1003,7 +1003,7 @@ dap_chain_net_srv_t* dap_chain_net_srv_add(dap_chain_net_srv_uid_t a_uid,
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_srv);
pthread_mutex_unlock(&s_srv_list_mutex);
return NULL;
diff --git a/modules/net/srv/dap_chain_net_srv_client.c b/modules/net/srv/dap_chain_net_srv_client.c
index 96794885157f8a5a4bb86be802a7ff7aa90563b5..a234d08e04af2107ea2ea6a843ee068cb4ea2ec0 100644
--- a/modules/net/srv/dap_chain_net_srv_client.c
+++ b/modules/net/srv/dap_chain_net_srv_client.c
@@ -42,7 +42,7 @@ dap_chain_net_srv_client_t *dap_chain_net_srv_client_create_n_connect(dap_chain_
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
if (a_callbacks)
@@ -55,7 +55,7 @@ dap_chain_net_srv_client_t *dap_chain_net_srv_client_create_n_connect(dap_chain_
};
dap_chain_node_info_t *l_info = DAP_NEW_Z(dap_chain_node_info_t);
if (!l_info) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_ret);
return NULL;
}
diff --git a/modules/net/srv/dap_chain_net_srv_geoip.c b/modules/net/srv/dap_chain_net_srv_geoip.c
index a20016ae60d1ccf1319fd21253963eb951cfe884..1320603d216ad2fbd3ee7ccd8cd50466fdceb4e9 100644
--- a/modules/net/srv/dap_chain_net_srv_geoip.c
+++ b/modules/net/srv/dap_chain_net_srv_geoip.c
@@ -187,7 +187,7 @@ geoip_info_t *chain_net_geoip_get_ip_info_by_local_db(const char *a_ip_str, cons
geoip_info_t *l_ret = DAP_NEW_Z(geoip_info_t);
if (!l_ret) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
diff --git a/modules/net/srv/dap_chain_net_srv_order.c b/modules/net/srv/dap_chain_net_srv_order.c
index 5b0e00ee5ec870346c74d3f7059f89876cf34518..ff815c07ce388cc8f28421cd841e694d82ce13a8 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -219,7 +219,7 @@ bool dap_chain_net_srv_order_get_continent_region(dap_chain_net_srv_order_t *a_o
if(l_size > 0) {
*a_region = DAP_NEW_SIZE(char, l_size);
if (!a_region) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return false;
}
memcpy(*a_region, a_order_static->ext_n_sign + 1 + sizeof(uint8_t), l_size);
@@ -354,7 +354,7 @@ dap_chain_net_srv_order_t *dap_chain_net_srv_order_compose(dap_chain_net_t *a_ne
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
memcpy(l_order->ext_n_sign, a_ext, a_ext_size);
@@ -363,7 +363,7 @@ dap_chain_net_srv_order_t *dap_chain_net_srv_order_compose(dap_chain_net_t *a_ne
else {
l_order = DAP_NEW_Z(dap_chain_net_srv_order_t);
if (!l_order) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
dap_chain_net_srv_order_set_continent_region(&l_order, a_continent_num, a_region);
@@ -705,7 +705,7 @@ void dap_chain_net_srv_order_add_notify_callback(dap_chain_net_t *a_net, dap_sto
{
struct dap_order_notify *l_notifier = DAP_NEW(struct dap_order_notify);
if (!l_notifier) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_notifier->net = a_net;
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 5bd9804730165f6c9601bb18e5632d6e1884fb16..88245c80978ae54d0e1bc37ec0ca5fe5ab2e9b45 100644
--- a/modules/net/srv/dap_chain_net_srv_stream_session.c
+++ b/modules/net/srv/dap_chain_net_srv_stream_session.c
@@ -42,7 +42,7 @@ dap_chain_net_srv_stream_session_t * dap_chain_net_srv_stream_session_create( da
}
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
a_session->_inheritor = l_session_srv;
@@ -80,7 +80,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
randombytes(&l_ret->id, sizeof(l_ret->id));
diff --git a/modules/service/datum/dap_chain_net_srv_datum.c b/modules/service/datum/dap_chain_net_srv_datum.c
index c0b6596ff67b234a3a59df87e4c2244bcb9bfb14..9d95c9c8824cac05ceffdcb0bb9117c0c87271e1 100644
--- a/modules/service/datum/dap_chain_net_srv_datum.c
+++ b/modules/service/datum/dap_chain_net_srv_datum.c
@@ -47,7 +47,7 @@ int dap_chain_net_srv_datum_init()
"\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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
s_srv_datum->uid.uint64 = DAP_CHAIN_NET_SRV_DATUM_ID;
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 0ae4bf4443512d3cef8237f4d0fe7641a628dc30..77de9c54f37dc74ce3e2db0ec2fe8751e6603489 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
@@ -96,7 +96,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
s_srv_stake->delegate_allowed_min = dap_chain_coins_to_balance("1.0");
@@ -375,7 +375,7 @@ int dap_chain_net_srv_stake_load_cache(dap_chain_net_t *a_net)
(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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_cache->signing_addr = l_cache_data->signing_addr;
@@ -572,7 +572,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH;
@@ -583,7 +583,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -595,7 +595,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -607,7 +607,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -618,7 +618,7 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -822,7 +822,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR;
@@ -832,7 +832,7 @@ static dap_chain_datum_decree_t *s_stake_decree_invalidate(dap_chain_net_t *a_ne
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -898,7 +898,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE;
@@ -908,7 +908,7 @@ static dap_chain_datum_decree_t *s_stake_decree_set_min_stake(dap_chain_net_t *a
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -1733,7 +1733,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
}
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory");
return -1;
}
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn.c b/modules/service/vpn/dap_chain_net_srv_vpn.c
index bf8c5871a6bea4967f8b53d955173ab029151a13..31b53a8901a2529ba13db9357f763a3cf13fd312 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -285,7 +285,7 @@ static bool s_tun_client_send_data(dap_chain_net_srv_ch_vpn_info_t * l_ch_vpn_in
assert(a_data_size > sizeof (dap_os_iphdr_t));
ch_vpn_pkt_t *l_pkt_out = DAP_NEW_Z_SIZE(ch_vpn_pkt_t, sizeof(l_pkt_out->header) + a_data_size);
if (!l_pkt_out) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return false;
}
l_pkt_out->header.op_code = VPN_PACKET_OP_CODE_VPN_RECV;
@@ -326,7 +326,7 @@ static bool s_tun_client_send_data(dap_chain_net_srv_ch_vpn_info_t * l_ch_vpn_in
/* 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_pkt_out);
return false;
}
@@ -408,7 +408,7 @@ static void s_tun_recv_msg_callback(dap_events_socket_t * a_esocket_queue, void
}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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_msg);
return;
}
@@ -486,7 +486,7 @@ static void s_tun_send_msg_ip_assigned(uint32_t a_worker_own_id, uint32_t a_work
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_msg->type = TUN_SOCKET_MSG_IP_ASSIGNED;
@@ -527,7 +527,7 @@ static void s_tun_send_msg_ip_unassigned(uint32_t a_worker_own_id, uint32_t a_wo
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_msg->type = TUN_SOCKET_MSG_IP_UNASSIGNED;
@@ -576,7 +576,7 @@ static void s_tun_send_msg_esocket_reassigned_inter(uint32_t a_worker_own_id, da
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_msg->type = TUN_SOCKET_MSG_ESOCKET_REASSIGNED ;
@@ -834,7 +834,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
pthread_rwlock_init(&s_raw_server->rwlock, NULL);
@@ -863,7 +863,7 @@ static int s_vpn_service_create(dap_config_t * g_config)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_srv->_internal = l_srv_vpn;
@@ -956,7 +956,7 @@ static int s_callback_response_success(dap_chain_net_srv_t * a_srv, uint32_t a_u
l_usage_client = DAP_NEW_Z(usage_client_t);
if (!l_usage_client) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_usage_client->usage_id = a_usage_id;
@@ -964,7 +964,7 @@ static int s_callback_response_success(dap_chain_net_srv_t * a_srv, uint32_t a_u
if (!l_usage_active->is_free){
l_usage_client->receipt = DAP_DUP_SIZE(l_receipt, l_receipt_size);
if (!l_usage_client->receipt) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_usage_client);
return -1;
}
@@ -1116,7 +1116,7 @@ void s_ch_vpn_new(dap_stream_ch_t* a_ch, void* a_arg)
a_ch->internal = DAP_NEW_Z(dap_chain_net_srv_ch_vpn_t);
if (!a_ch->internal) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
dap_chain_net_srv_ch_vpn_t * l_srv_vpn = CH_VPN(a_ch);
@@ -1184,7 +1184,7 @@ static void s_ch_vpn_delete(dap_stream_ch_t* a_ch, void* arg)
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_item_unleased) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_rwlock_unlock(&s_clients_rwlock);
return;
}
@@ -1357,7 +1357,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
pkt_out->header.op_code = VPN_PACKET_OP_CODE_PONG;
@@ -1385,7 +1385,7 @@ static void s_ch_packet_in_vpn_address_request(dap_stream_ch_t* a_ch, dap_chain_
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index f069aff4ecdb5eb264d8e3a5420550287604dbf1..22aef3b0cdc93433d2c2d2df5e8882823e2794f0 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -183,7 +183,7 @@ static int s_callback_client_success(dap_chain_net_srv_t * a_srv, uint32_t a_usa
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_stream_session_unlock();
return -1;
}
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 7234a30bbda4b5f90a61a9b8b7d84af3b55d06dc..0cc4b3797e8988284a5eca28add84319544bc34b 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client_tun.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
@@ -686,7 +686,7 @@ void ch_sf_tun_client_send(dap_chain_net_srv_ch_vpn_t * ch_sf, void * pkt_data,
//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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if(in_daddr_str)
DAP_DELETE(in_daddr_str);
if(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 3266cd644301ba1b84bed2f5b4a76c9612ee0a1a..d86523f46d8eea48d05dbb8e0f973e54ee776d58 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -128,7 +128,7 @@ 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 || !l_srv) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_srv->_internal = s_srv_xchange;
@@ -331,7 +331,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
memcpy(l_ext, &a_datoshi_buy, sizeof(uint256_t));
@@ -921,7 +921,7 @@ dap_chain_net_srv_xchange_price_t *s_xchange_price_from_order(dap_chain_net_t *a
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
dap_srv_xchange_order_ext_t *l_ext = (dap_srv_xchange_order_ext_t *)a_order->ext_n_sign;
@@ -1081,7 +1081,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory");
dap_chain_wallet_close(l_wallet);
return -1;
diff --git a/modules/type/blocks/dap_chain_block.c b/modules/type/blocks/dap_chain_block.c
index c32478202bd0f951191bee71d03c9795b9067fcd..20420c7471778b6d3591ce0807d01d96fe4fa033 100644
--- a/modules/type/blocks/dap_chain_block.c
+++ b/modules/type/blocks/dap_chain_block.c
@@ -461,7 +461,7 @@ dap_chain_block_meta_t** dap_chain_block_get_meta(dap_chain_block_t * a_block, s
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
for( size_t i = 0; i< a_block->hdr.meta_count &&
diff --git a/modules/type/blocks/dap_chain_block_cache.c b/modules/type/blocks/dap_chain_block_cache.c
index c37ee74624b2ce759739ee40971e3fe9d89998e5..90a0d2467f0c0b6573dbf44e8bcea37e4ac57dab 100644
--- a/modules/type/blocks/dap_chain_block_cache.c
+++ b/modules/type/blocks/dap_chain_block_cache.c
@@ -62,7 +62,7 @@ dap_chain_block_cache_t *dap_chain_block_cache_new(dap_chain_cs_blocks_t *a_bloc
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_block_cache->block = a_block;
@@ -88,7 +88,7 @@ dap_chain_block_cache_t * dap_chain_block_cache_dup(dap_chain_block_cache_t * a_
{
dap_chain_block_cache_t *l_ret = DAP_DUP(a_block);
if (!l_ret) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret->hh = (UT_hash_handle){ }; // Drop hash handle to prevent its usage
@@ -180,7 +180,7 @@ dap_list_t * dap_chain_block_get_list_tx_cond_outs_with_val(dap_ledger_t *a_ledg
if (!dap_chain_ledger_tx_hash_is_used_out_item (a_ledger, l_tx_hash, l_out_idx_tmp, NULL)) {
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
if (l_list_used_out)
dap_list_free_full(l_list_used_out, NULL);
return NULL;
diff --git a/modules/type/blocks/dap_chain_block_chunk.c b/modules/type/blocks/dap_chain_block_chunk.c
index 79b563aa362ca17fa3ca7457306b7e63e51bb431..fd5578c9687081c946124570322561693355ac47 100644
--- a/modules/type/blocks/dap_chain_block_chunk.c
+++ b/modules/type/blocks/dap_chain_block_chunk.c
@@ -38,7 +38,7 @@ dap_chain_block_chunks_t * dap_chain_block_chunks_create(dap_chain_cs_blocks_t *
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret->blocks = a_blocks;
@@ -111,7 +111,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_chunk_cache_hash->block_cache=a_block_cache;
@@ -137,7 +137,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_chunk_cache_hash->block_cache=a_block_cache;
@@ -169,7 +169,7 @@ dap_chain_block_chunk_t * dap_chain_block_chunk_create(dap_chain_block_chunks_t
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
// Add in tail
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 8d1dfcb481ac7341129b086310bbf0580b2d4ec9..435769de77e086195459437632bca83b12f3c489 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -209,7 +209,7 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
a_chain->_inheritor = l_cs_blocks;
@@ -255,7 +255,7 @@ int dap_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_config
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -1;
}
l_cs_blocks->_pvt = l_cs_blocks_pvt;
@@ -288,7 +288,7 @@ int dap_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_config
for (uint16_t i = 0; i < l_list_len; i++) {
struct cs_blocks_hal_item *l_hal_item = DAP_NEW_Z(struct cs_blocks_hal_item);
if (!l_hal_item){
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_cs_blocks_pvt);
DAP_DELETE(l_cs_blocks);
return -10;
@@ -490,7 +490,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_cli_server_cmd_set_reply_text(a_str_reply,"Out of memory in s_cli_blocks");
return -1;
}
@@ -937,7 +937,7 @@ static int s_add_atom_datums(dap_chain_cs_blocks_t *a_blocks, dap_chain_block_ca
// 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return 1;
}
l_datum_index->ts_added = time(NULL);
@@ -1219,7 +1219,7 @@ static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain,
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_atom_iter->chain = a_chain;
@@ -1448,14 +1448,14 @@ static dap_chain_atom_ptr_t *s_callback_atom_iter_get_lasts( dap_chain_atom_iter
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret[0] = l_block_cache_last->block;
@@ -1487,7 +1487,7 @@ static dap_chain_datum_iter_t *s_chain_callback_datum_iter_create(dap_chain_t *a
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret->chain = a_chain;
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index fff78435e9dda7cca93e7326289bbaa8492f4122..04af3944ca26ce43816fee9cf32b470e67164689 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -229,12 +229,12 @@ 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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DELETE(l_dag);
return -1;
}
@@ -304,7 +304,7 @@ int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_dag->_pvt);
DAP_DELETE(l_dag);
return -1;
@@ -350,7 +350,7 @@ static void s_dap_chain_cs_dag_threshold_free(dap_chain_cs_dag_t *a_dag) {
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_mutex_unlock(&l_pvt->events_mutex);
return;
}
@@ -496,7 +496,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return ATOM_REJECT;
}
pthread_mutex_t *l_events_mutex = &PVT(l_dag)->events_mutex;
@@ -918,7 +918,7 @@ 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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_event_last->ts_added = a_event_item->ts_added;
@@ -1038,7 +1038,7 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_atom_iter->chain = a_chain;
@@ -1067,7 +1067,7 @@ static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_c
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_atom_iter->chain = a_chain;
@@ -1097,7 +1097,7 @@ static dap_chain_datum_t **s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
if (a_datums_count)
@@ -1179,7 +1179,7 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_lasts( dap_chain_ato
*a_lasts_size = l_lasts_size;
l_ret = DAP_NEW_Z_SIZE(dap_chain_atom_ptr_t, sizeof(dap_chain_atom_ptr_t) * l_lasts_size);
if (!l_ret) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
return NULL;
}
@@ -1187,7 +1187,7 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_lasts( dap_chain_ato
size_t i = 0;
*a_lasts_size_array = DAP_NEW_Z_SIZE(size_t, sizeof(size_t) * l_lasts_size);
if (!*a_lasts_size_array) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
DAP_DEL_Z(l_ret);
return NULL;
@@ -1223,14 +1223,14 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_links( dap_chain_ato
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_ret);
return NULL;
}
@@ -1377,7 +1377,7 @@ static dap_chain_datum_iter_t *s_chain_callback_datum_iter_create(dap_chain_t *a
{
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, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return NULL;
}
l_ret->chain = a_chain;
diff --git a/modules/type/dag/dap_chain_cs_dag_event.c b/modules/type/dag/dap_chain_cs_dag_event.c
index 4f5860ca067060f0077e0df78479678b28431c5b..c4c171d6fa5064566b51da52b01f211e11436411 100644
--- a/modules/type/dag/dap_chain_cs_dag_event.c
+++ b/modules/type/dag/dap_chain_cs_dag_event.c
@@ -231,7 +231,7 @@ void dap_chain_cs_dag_event_broadcast(dap_chain_cs_dag_t *a_dag, dap_store_obj_t
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return;
}
l_arg->dag = a_dag;
diff --git a/modules/wallet/dap_chain_wallet.c b/modules/wallet/dap_chain_wallet.c
index aca96f7ec06a0d722c93f68627e2f9b2b4ddbd8c..451ca8334b569eeb228de91349c352f601f05ebe 100644
--- a/modules/wallet/dap_chain_wallet.c
+++ b/modules/wallet/dap_chain_wallet.c
@@ -126,7 +126,7 @@ char *c_wallets_path;
{
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 %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
return -EINVAL;
}
*l_prec = l_rec; /* Fill it by data */
@@ -396,18 +396,23 @@ dap_chain_wallet_internal_t *l_wallet_internal;
if ( a_pass && DAP_WALLET$SZ_PASS < strnlen(a_pass, DAP_WALLET$SZ_PASS + 1) )
return log_it(L_ERROR, "Wallet's password is too long ( > %d)", DAP_WALLET$SZ_PASS), NULL;
- if ( !(l_wallet = DAP_NEW_Z(dap_chain_wallet_t)) )
- return log_it(L_ERROR, "Memory allocation error, errno=%d", errno), NULL;
+ if ( !(l_wallet = DAP_NEW_Z(dap_chain_wallet_t)) ) {
+ log_it(L_CRITICAL, "Memory allocation error");
+ return NULL;
+ }
- if ( !(l_wallet->_internal = l_wallet_internal = DAP_NEW_Z(dap_chain_wallet_internal_t)) )
- return DAP_DELETE(l_wallet), log_it(L_ERROR, "Memory allocation error, errno=%d", errno), NULL;
+ if ( !(l_wallet->_internal = l_wallet_internal = DAP_NEW_Z(dap_chain_wallet_internal_t)) ) {
+ log_it(L_CRITICAL, "Memory allocation error");
+ DAP_DELETE(l_wallet);
+ return NULL;
+ }
strncpy(l_wallet->name, a_wallet_name, DAP_WALLET$SZ_NAME);
l_wallet_internal->certs_count = 1;
l_wallet_internal->certs = DAP_NEW_Z_SIZE(dap_cert_t *,l_wallet_internal->certs_count * sizeof(dap_cert_t *));
assert(l_wallet_internal->certs);
if (!l_wallet_internal->certs) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_chain_wallet_close(l_wallet);
return NULL;
}
@@ -837,7 +842,7 @@ uint32_t l_csum = CRC32C_INIT, l_csum2 = CRC32C_INIT;
l_wallet = DAP_NEW_Z(dap_chain_wallet_t);
assert(l_wallet);
if (!l_wallet) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
dap_fileclose(l_fh);
return NULL;
}
@@ -845,7 +850,7 @@ uint32_t l_csum = CRC32C_INIT, l_csum2 = CRC32C_INIT;
DAP_CHAIN_WALLET_INTERNAL_LOCAL_NEW(l_wallet);
assert(l_wallet_internal);
if (!l_wallet_internal) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_wallet);
dap_fileclose(l_fh);
return NULL;
@@ -866,7 +871,7 @@ uint32_t l_csum = CRC32C_INIT, l_csum2 = CRC32C_INIT;
l_wallet_internal->certs = DAP_NEW_Z_SIZE(dap_cert_t *, l_wallet_internal->certs_count * sizeof(dap_cert_t *));
assert(l_wallet_internal->certs);
if (!l_wallet_internal->certs) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
+ log_it(L_CRITICAL, "Memory allocation error");
DAP_DEL_Z(l_wallet);
dap_fileclose(l_fh);
return NULL;