diff --git a/dap-sdk b/dap-sdk
index 985e0aeea0cf1a3fea4e19d43baf72a7029f58f6..794906bf946a3f84f32d2b2cdf6abdd5ceda5915 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 985e0aeea0cf1a3fea4e19d43baf72a7029f58f6
+Subproject commit 794906bf946a3f84f32d2b2cdf6abdd5ceda5915
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index 3ce92f9fed3887be3fa0f05976779b3383e9a2c4..da6d4bc13c86399364b67da01d4be7f19a3d3f28 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -101,7 +101,7 @@ dap_chain_t *dap_chain_create(const char *a_chain_net_name, const char *a_chain_
{
dap_chain_t *l_ret = DAP_NEW_Z(dap_chain_t);
if ( !l_ret ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
*l_ret = (dap_chain_t) {
@@ -118,7 +118,7 @@ dap_chain_t *dap_chain_create(const char *a_chain_net_name, const char *a_chain_
DAP_DEL_Z(l_ret->name);
DAP_DEL_Z(l_ret->net_name);
DAP_DELETE(l_ret);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ret->_pvt = l_chain_pvt;
@@ -128,7 +128,7 @@ dap_chain_t *dap_chain_create(const char *a_chain_net_name, const char *a_chain_
DAP_DEL_Z(l_ret->net_name);
DAP_DELETE(l_ret->_pvt);
DAP_DELETE(l_ret);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
*l_ret_item = (dap_chain_item_t) {
@@ -438,7 +438,7 @@ dap_chain_t *dap_chain_load_from_cfg(const char *a_chain_net_name, dap_chain_net
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_count_recognized = 0;
@@ -463,7 +463,7 @@ dap_chain_t *dap_chain_load_from_cfg(const char *a_chain_net_name, dap_chain_net
if (l_chain->datum_types)
DAP_DELETE(l_chain->datum_types);
DAP_DELETE(l_chain);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_count_recognized = 0;
@@ -489,7 +489,7 @@ dap_chain_t *dap_chain_load_from_cfg(const char *a_chain_net_name, dap_chain_net
{
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 8149da8d74fa5e24d755d28ac8ef97ebb45f4e43..4d758f091650571176ae07a67a35e89d72f8a331 100644
--- a/modules/chain/dap_chain_cell.c
+++ b/modules/chain/dap_chain_cell.c
@@ -102,7 +102,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_cell->chain = a_chain;
@@ -228,7 +228,7 @@ int dap_chain_cell_load(dap_chain_t *a_chain, dap_chain_cell_t *a_cell)
}
dap_chain_atom_ptr_t l_element = DAP_NEW_SIZE(dap_chain_atom_ptr_t, l_el_size);
if (!l_element) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_ret = -5;
break;
}
diff --git a/modules/chain/dap_chain_ch.c b/modules/chain/dap_chain_ch.c
index e58ecee55b9b161f94e686f0ee47221b9e831ef3..0269a3232eb7fa304ee5985702f6dfac99ff2f28 100644
--- a/modules/chain/dap_chain_ch.c
+++ b/modules/chain/dap_chain_ch.c
@@ -230,7 +230,7 @@ void s_stream_ch_new(dap_stream_ch_t* a_ch, void* a_arg)
{
UNUSED(a_arg);
if (!(a_ch->internal = DAP_NEW_Z(dap_chain_ch_t))) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
};
dap_chain_ch_t *l_ch_chain = DAP_CHAIN_CH(a_ch);
@@ -696,7 +696,7 @@ struct sync_request *dap_chain_ch_create_sync_request(dap_chain_ch_pkt_t *a_chai
}
struct sync_request *l_sync_request = DAP_NEW_Z(struct sync_request);
if (!l_sync_request) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
*l_sync_request = (struct sync_request) {
@@ -1143,7 +1143,7 @@ static bool 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_chain_ch_hash_item_t);
if (!l_hash_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
break;
}
l_hash_item->hash = l_element->hash;
@@ -1317,7 +1317,7 @@ static bool 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_chain_ch_hash_item_t);
if (!l_hash_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
break;
}
l_hash_item->hash = l_element->hash;
@@ -1790,7 +1790,7 @@ static bool s_stream_ch_packet_out(dap_stream_ch_t *a_ch, void *a_arg)
} else {
l_hash_item = DAP_NEW_Z(dap_chain_ch_hash_item_t);
if (!l_hash_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_hash_item->hash = l_obj->hash;
@@ -1895,7 +1895,7 @@ static bool s_stream_ch_packet_out(dap_stream_ch_t *a_ch, void *a_arg)
}else{
l_hash_item = DAP_NEW_Z(dap_chain_ch_hash_item_t);
if (!l_hash_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
l_hash_item->hash = *l_ch_chain->request_atom_iter->cur_hash;
diff --git a/modules/chain/dap_chain_cs.c b/modules/chain/dap_chain_cs.c
index b1fe0de2860debeef31b924d7a588e224289328d..d61a52a22a9e84e8543cfa1e6d5a7372105bde84 100644
--- a/modules/chain/dap_chain_cs.c
+++ b/modules/chain/dap_chain_cs.c
@@ -65,7 +65,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
strncpy(l_item->name, a_cs_str, sizeof (l_item->name) - 1);
@@ -100,7 +100,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
strncpy(l_item->name, a_cs_str, sizeof (l_item->name) - 1);
diff --git a/modules/chain/dap_chain_tx.c b/modules/chain/dap_chain_tx.c
index 96deb497abfa89505d0fcd60ddad61294818809d..bb2585cb1a516901e5009890b9aa8d375ea9e356 100644
--- a/modules/chain/dap_chain_tx.c
+++ b/modules/chain/dap_chain_tx.c
@@ -36,7 +36,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 084246a696dde03b5392d3ac63615926dc8ced2d..1b817cd8e2cd2ca1fabd408dd1bd11e375de47f0 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
@@ -129,7 +129,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(a_grace->request);
DAP_DEL_Z(a_grace);
return;
@@ -376,7 +376,7 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
// Create one client
l_usage->client = DAP_NEW_Z( dap_chain_net_srv_client_remote_t);
if (!l_usage->client) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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));
@@ -435,7 +435,7 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
dap_chain_net_srv_grace_t *l_grace = DAP_NEW_Z(dap_chain_net_srv_grace_t);
if (!l_grace) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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));
@@ -447,7 +447,7 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
}
l_grace->request = DAP_DUP_SIZE(a_request, a_request_size);
if (!l_grace->request) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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));
@@ -472,7 +472,7 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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));
@@ -558,7 +558,7 @@ static bool s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
}
dap_chain_net_srv_grace_usage_t *l_item = DAP_NEW_Z(dap_chain_net_srv_grace_usage_t);
if (!l_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
s_grace_error(a_grace, l_err);
return false;
}
@@ -574,7 +574,7 @@ static bool s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
} else { // Else if first grace at service start
dap_chain_net_srv_grace_usage_t *l_item = DAP_NEW_Z(dap_chain_net_srv_grace_usage_t);
if (!l_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
s_grace_error(a_grace, l_err);
return false;
}
@@ -586,7 +586,7 @@ static bool s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_ALLOC_MEMORY_ERROR;
if(l_ch)
dap_stream_ch_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
@@ -1104,13 +1104,13 @@ static bool s_grace_period_finish(dap_chain_net_srv_grace_usage_t *a_grace_item)
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
RET_WITH_DEL_A_GRACE(0);
}
// 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
RET_WITH_DEL_A_GRACE(0);
}
l_grace_new->request->hdr.net_id = a_grace_item->grace->usage->net->pub.id;
@@ -1335,7 +1335,7 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
break;
}
l_is_first_sign = true;
@@ -1344,7 +1344,7 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
break;
}
l_usage->is_active = true;
@@ -1376,7 +1376,7 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_tx_in_hash_str);
break;
}
@@ -1384,7 +1384,7 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_grace)
DAP_DELETE(l_tx_in_hash_str);
break;
@@ -1406,14 +1406,14 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_tx_in_hash_str);
return true;
}
// 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_grace)
DAP_DELETE(l_tx_in_hash_str);
return true;
@@ -1600,7 +1600,7 @@ static bool 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
break;
}
l_success->hdr.usage_id = l_usage->id;
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index 341f52c739b33fab85bbff206568e33d3635d0b8..b1f7aec824abdaf6728ddc5366cafa4c64ce961d 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -48,7 +48,7 @@ dap_chain_datum_t *dap_chain_datum_create(uint16_t a_type_id, const void *a_data
{
dap_chain_datum_t *l_datum = DAP_NEW_Z_SIZE(dap_chain_datum_t, sizeof(l_datum->header) + a_data_size);
if(!l_datum) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
*l_datum = (dap_chain_datum_t) {
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index bd1f2d3f8504e3ae369b4748bbc7fcae6040452e..a25c8b91cdc00f85126fe3529fc8647e74f277eb 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -430,7 +430,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_emission->hdr.version = 3;
@@ -474,7 +474,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_emission->hdr.version = 2;
@@ -489,7 +489,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 4f12d11bad0434d4f39eb58a554cac47b6d0b7d1..9c2f8e4f2846bcddff189e0112167fc1ffa1d31e 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -41,7 +41,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 37a9516d8091b1b2cd75d743ee336eeb795ee7c1..6498631906238d2b6540062ecd5d9e2e8519b1ae 100644
--- a/modules/consensus/block-poa/dap_chain_cs_block_poa.c
+++ b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
@@ -184,7 +184,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_blocks->_inheritor = l_poa;
@@ -193,7 +193,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
dap_chain_cs_block_poa_pvt_t *l_poa_pvt = PVT(l_poa);
@@ -206,7 +206,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 19e975a4d848d59d044c5ef09df2b706b7fcb61a..991344598c0530e5344f134e564f9e25ead5634a 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_blocks->_inheritor = l_pos;
@@ -98,7 +98,7 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
l_pos->_pvt = DAP_NEW_Z(dap_chain_cs_block_pos_pvt_t);
dap_chain_cs_block_pos_pvt_t *l_pos_pvt = PVT(l_pos);
if (!l_pos_pvt) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
goto lb_err;
}
@@ -113,12 +113,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 5b89f0212bf66458fda55967bc3dd2e782577196..61e1ff32f44709dfe9c5301cd1433466d8e196c3 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -157,7 +157,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_poa_pvt->callback_pre_sign->callback = a_callback;
@@ -346,7 +346,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_dag->_inheritor = l_poa;
@@ -356,7 +356,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
@@ -373,7 +373,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
char l_cert_name[512];
@@ -666,7 +666,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 be70173ade267a451764a298f24525e5c9829fff..c324de5b4583194516fd262bd904c139088683ee 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
@@ -99,7 +99,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
l_pos->_pvt = DAP_NEW_Z(dap_chain_cs_dag_pos_pvt_t);
dap_chain_cs_dag_pos_pvt_t *l_pos_pvt = PVT(l_pos);
if (!l_pos_pvt) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 b77dd535b304aee129132ff910f07840ed8b7895..2b3877064cc0d60a9f67b3a68f9fb70903597c76 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -209,7 +209,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_ret = - 5;
goto lb_err;
}
@@ -261,7 +261,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_ret = - 5;
goto lb_err;
}
@@ -2221,7 +2221,7 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
// store for new candidate
l_store = DAP_NEW_Z(dap_chain_esbocs_store_t);
if (!l_store) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
goto session_unlock;
}
l_store->candidate_size = l_candidate_size;
@@ -2478,7 +2478,7 @@ static void s_message_send(dap_chain_esbocs_session_t *a_session, uint8_t a_mess
l_message->hdr.sign_size = l_sign_size;
l_message = DAP_REALLOC(l_message, l_message_size + l_sign_size);
if (!l_message) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
memcpy(l_message->msg_n_sign + a_data_size, l_sign, l_sign_size);
@@ -2681,7 +2681,7 @@ static dap_chain_datum_decree_t *s_esbocs_decree_set_min_validators_count(dap_ch
size_t l_sign_size = dap_sign_get_size(l_sign);
l_decree = DAP_REALLOC(l_decree, sizeof(dap_chain_datum_decree_t) + l_cur_sign_offset + l_sign_size);
if (!l_decree) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_sign);
return NULL;
}
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 73d98c1ba859dbab66dacf4185996b407c66b2f8..503e1d728167342629fc8aa5cf8a66f6d728a3ad 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -708,7 +708,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_objs);
dap_list_free(l_list_out_items);
return -6;
@@ -1256,7 +1256,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
datum_mempool->version = *(uint16_t*)(a_datum_mempool_ser + shift_size);
diff --git a/modules/net/dap_chain_ledger.c b/modules/net/dap_chain_ledger.c
index b83d20a05457e0d3d8f670b3d2d18febea6b9033..ffaeec9f17617d309a98a2aba5d93b98b6362a14 100644
--- a/modules/net/dap_chain_ledger.c
+++ b/modules/net/dap_chain_ledger.c
@@ -389,13 +389,13 @@ static dap_ledger_t * dap_ledger_handle_new(void)
{
dap_ledger_t *l_ledger = DAP_NEW_Z(dap_ledger_t);
if ( !l_ledger ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_ledger);
return NULL;
}
@@ -447,7 +447,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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));
@@ -649,7 +649,7 @@ static bool s_ledger_token_update_check(dap_ledger_token_item_t *a_cur_token_ite
//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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free(l_tsd_list_added_pkeys);
dap_list_free(l_tsd_list_remote_pkeys);
return false;
@@ -961,7 +961,7 @@ json_object *dap_ledger_token_tx_item_list(dap_ledger_t * a_ledger, dap_chain_ad
{
json_object * json_arr_out = json_object_new_array();
if (!json_arr_out) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
@@ -1000,7 +1000,7 @@ void s_ledger_token_cache_update(dap_ledger_t *a_ledger, dap_ledger_token_item_t
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
memcpy(l_cache, &l_token_item->current_supply, sizeof(uint256_t));
@@ -1164,7 +1164,7 @@ int dap_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_toke
l_token_item = DAP_NEW_Z(dap_ledger_token_item_t);
if ( !l_token_item ) {
DAP_DEL_Z(l_token);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -8;
}
*l_token_item = (dap_ledger_token_item_t) {
@@ -1185,7 +1185,7 @@ int dap_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_toke
if (l_token)
DAP_DELETE(l_token);
DAP_DELETE(l_token_item);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -6;
};
if ( !l_token_item->auth_pkeys ) {
@@ -1193,7 +1193,7 @@ int dap_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_toke
DAP_DELETE(l_token);
DAP_DEL_Z(l_token_item->auth_pkeys);
DAP_DELETE(l_token_item);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -6;
}
dap_stpcpy(l_token_item->ticker, l_token->ticker);
@@ -2286,12 +2286,12 @@ static bool s_load_cache_gdb_loaded_balances_callback(dap_global_db_instance_t *
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
l_balance_item->key = DAP_NEW_Z_SIZE(char, strlen(a_values[i].key) + 1);
if (!l_balance_item->key) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_balance_item);
return false;
}
@@ -2337,14 +2337,14 @@ static bool s_load_cache_gdb_loaded_txs_callback(dap_global_db_instance_t *a_dbi
for (size_t i = 0; i < a_values_count; i++) {
dap_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_ledger_tx_item_t);
if ( !l_tx_item ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
memcpy(&l_tx_item->cache_data, a_values[i].value, sizeof(l_tx_item->cache_data));
@@ -2417,7 +2417,7 @@ static bool s_load_cache_gdb_loaded_emissions_callback(dap_global_db_instance_t
}
dap_ledger_token_emission_item_t *l_emission_item = DAP_NEW_Z(dap_ledger_token_emission_item_t);
if ( !l_emission_item ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
dap_chain_hash_fast_from_str(a_values[i].key, &l_emission_item->datum_token_emission_hash);
@@ -2523,7 +2523,7 @@ dap_ledger_t *dap_ledger_create(dap_chain_net_t *a_net, uint16_t a_flags)
{
dap_ledger_t *l_ledger = dap_ledger_handle_new();
if (!l_ledger) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ledger->net = a_net;
@@ -2556,7 +2556,7 @@ dap_ledger_t *dap_ledger_create(dap_chain_net_t *a_net, uint16_t a_flags)
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_ledger_pvt);
DAP_DEL_Z(l_ledger);
dap_config_close(l_cfg);
@@ -2804,13 +2804,13 @@ int dap_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emissi
if (HASH_COUNT(l_ledger_pvt->threshold_emissions) < s_threshold_emissions_max) {
l_token_emission_item = DAP_NEW_Z(dap_ledger_token_emission_item_t);
if ( !l_token_emission_item ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return DAP_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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return DAP_LEDGER_EMISSION_ADD_MEMORY_PROBLEM;
}
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
@@ -2845,7 +2845,7 @@ int dap_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emissi
if (!l_token_emission_item) {
l_token_emission_item = DAP_NEW_Z(dap_ledger_token_emission_item_t);
if ( !l_token_emission_item ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return DAP_LEDGER_EMISSION_ADD_MEMORY_PROBLEM;
}
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
@@ -3104,7 +3104,7 @@ void dap_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledger, dap
if(l_tx_item) {
l_tickers = DAP_NEW_Z_SIZE(char *, l_tickers_size * sizeof(char*));
if ( !l_tickers ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
while(l_tx_item) {
@@ -3122,7 +3122,7 @@ void dap_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledger, dap
l_tickers_size += (l_tickers_size / 2);
l_tickers = DAP_REALLOC(l_tickers, l_tickers_size);
if ( !l_tickers ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
}
@@ -3136,7 +3136,7 @@ void dap_ledger_addr_get_token_ticker_all_depricated(dap_ledger_t *a_ledger, dap
l_tickers_size = l_tickers_pos + 1;
l_tickers = DAP_REALLOC(l_tickers, l_tickers_size * sizeof(char*));
if ( !l_tickers ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
}
@@ -3162,7 +3162,7 @@ void dap_ledger_addr_get_token_ticker_all(dap_ledger_t *a_ledger, dap_chain_addr
dap_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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_rwlock_unlock(&PVT(a_ledger)->balance_accounts_rwlock);
return;
}
@@ -3182,7 +3182,7 @@ void dap_ledger_addr_get_token_ticker_all(dap_ledger_t *a_ledger, dap_chain_addr
if(l_count && a_tickers){
char **l_tickers = DAP_NEW_Z_SIZE(char*, l_count * sizeof(char*));
if (!l_tickers) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_rwlock_unlock(&PVT(a_ledger)->balance_accounts_rwlock);
return;
}
@@ -3557,7 +3557,7 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
for (dap_list_t *it = l_list_in; it; it = it->next) {
dap_ledger_tx_bound_t *l_bound_item = DAP_NEW_Z(dap_ledger_tx_bound_t);
if (!l_bound_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_err_num = DAP_LEDGER_TX_CHECK_MEMORY_PROBLEM;
break;
}
@@ -4061,7 +4061,7 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
if (!l_value_cur) {
l_value_cur = DAP_NEW_Z(dap_ledger_tokenizer_t);
if ( !l_value_cur ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_err_num = DAP_LEDGER_TX_CHECK_MEMORY_PROBLEM;
break;
}
@@ -4105,7 +4105,7 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
} else {
l_value_cur = DAP_NEW_Z(dap_ledger_tokenizer_t);
if ( !l_value_cur ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_err_num = DAP_LEDGER_TX_CHECK_MEMORY_PROBLEM;
if ( l_list_bound_items )
dap_list_free_full(l_list_bound_items, NULL);
@@ -4199,7 +4199,7 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
if (!l_value_cur) {
l_value_cur = DAP_NEW_Z(dap_ledger_tokenizer_t);
if ( !l_value_cur ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_err_num = DAP_LEDGER_TX_CHECK_MEMORY_PROBLEM;
break;
}
@@ -4483,14 +4483,14 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
} else {
l_item_tmp = DAP_NEW_Z(dap_ledger_tx_item_t);
if ( !l_item_tmp ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_item_tmp->ts_added = dap_nanotime_now();
@@ -4518,7 +4518,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
if (PVT(a_ledger)->cached) {
dap_store_obj_t *l_cache_used_outs = DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * (l_outs_used + 1));
if ( !l_cache_used_outs ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_ret = -1;
goto FIN;
}
@@ -4565,7 +4565,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
case TX_ITEM_TYPE_IN_REWARD: {
dap_ledger_reward_item_t *l_item = DAP_NEW_Z(dap_ledger_reward_item_t);
if (!l_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_ret = -1;
goto FIN;
}
@@ -4745,7 +4745,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
// add transaction to the cache list
dap_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_ledger_tx_item_t);
if ( !l_tx_item ) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_ret = -1;
goto FIN;
}
@@ -5637,7 +5637,7 @@ int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_le
}
l_new_verificator = DAP_NEW(dap_ledger_verificator_t);
if (!l_new_verificator) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_new_verificator->subtype = (int)a_subtype;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 31eb79bfd85731ff82dacd00fd026df044a0d6cd..3f74907ba4e1968ac686201950a4b13ba94f9bf4 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -133,17 +133,10 @@
static bool s_debug_more = false;
struct request_link_info {
- char addr[DAP_HOSTADDR_STRLEN];
+ char addr[DAP_HOSTADDR_STRLEN + 1];
uint16_t port;
};
-struct balancer_link_request {
- struct request_link_info *info;
- dap_chain_net_t *net;
- dap_worker_t *worker;
- uint16_t links_requested_count;
-};
-
struct block_reward {
uint64_t block_number;
uint256_t reward;
@@ -181,7 +174,7 @@ typedef struct dap_chain_net_pvt{
dap_chain_node_info_t *node_info; // Current node's info
- int balancer_type;
+ dap_balancer_type_t balancer_type;
bool load_mode;
uint16_t permanent_links_count;
@@ -275,6 +268,7 @@ int dap_chain_net_init()
dap_chain_net_voting_init();
dap_http_ban_list_client_init();
dap_link_manager_init(&s_link_manager_callbacks);
+ dap_chain_node_init();
dap_cli_server_cmd_add ("net", s_cli_net, "Network commands",
"net list [chains -net <chain net name>]\n"
"\tList all networks or list all chains in selected network\n"
@@ -450,7 +444,7 @@ dap_stream_node_addr_t *dap_chain_net_get_authorized_nodes(dap_chain_net_t *a_ne
return dap_cluster_get_all_members_addrs(PVT(a_net)->nodes_cluster->role_cluster, a_nodes_count, DAP_GDB_MEMBER_ROLE_ROOT);
}
-static int s_net_link_add(dap_chain_net_t *a_net, dap_stream_node_addr_t *a_addr, const char *a_host, uint16_t a_port)
+int dap_chain_net_link_add(dap_chain_net_t *a_net, dap_stream_node_addr_t *a_addr, const char *a_host, uint16_t a_port)
{
bool l_is_link_present = dap_link_manager_link_find(a_addr, a_net->pub.id.uint64);
if (l_is_link_present || a_addr->uint64 == g_node_addr.uint64)
@@ -498,11 +492,11 @@ static void s_link_manager_callback_connected(dap_link_t *a_link, uint64_t a_net
&l_announce, sizeof(l_announce));
}
-static bool s_net_check_link_is_premanent(dap_chain_net_t *a_net, dap_stream_node_addr_t *a_addr)
+static bool s_net_check_link_is_premanent(dap_chain_net_t *a_net, dap_stream_node_addr_t a_addr)
{
dap_chain_net_pvt_t *l_net_pvt = PVT(a_net);
for (uint16_t i = 0; i < l_net_pvt->permanent_links_count; i++) {
- if (l_net_pvt->permanent_links[i]->node_addr.uint64 == a_addr->uint64)
+ if (l_net_pvt->permanent_links[i]->node_addr.uint64 == a_addr.uint64)
return true;
}
return false;
@@ -521,7 +515,7 @@ static bool s_link_manager_callback_disconnected(dap_link_t *a_link, uint64_t a_
// func work
dap_chain_net_t *l_net = dap_chain_net_by_id((dap_chain_net_id_t){.uint64 = a_net_id});
dap_chain_net_pvt_t *l_net_pvt = PVT(l_net);
- bool l_link_is_permanent = s_net_check_link_is_premanent(l_net, &a_link->addr);
+ bool l_link_is_permanent = s_net_check_link_is_premanent(l_net, a_link->addr);
log_it(L_INFO, "%s."NODE_ADDR_FP_STR" can't connect for now. %s", l_net ? l_net->pub.name : "(unknown)" ,
NODE_ADDR_FP_ARGS_S(a_link->addr),
l_link_is_permanent ? "Setting reconnection pause for it." : "Dropping it.");
@@ -556,77 +550,6 @@ static void s_link_manager_callback_error(dap_link_t *a_link, uint64_t a_net_id,
}
}
-/**
- * @brief s_net_state_link_prepare_success
- * @param a_worker
- * @param a_node_info
- * @param a_arg
- */
-static void s_balancer_link_prepare_success(dap_chain_net_t *a_net, dap_chain_net_links_t *a_link_full_node_list)
-{
- char l_err_str[128] = {0};
- struct json_object *l_json;
- for (size_t i = 0; i < a_link_full_node_list->count_node; ++i) {
- dap_link_info_t *l_link_info = (dap_link_info_t *)a_link_full_node_list->nodes_info + i;
- debug_if(s_debug_more, L_DEBUG,"Link " NODE_ADDR_FP_STR " [ %s : %u ] prepare success",
- NODE_ADDR_FP_ARGS_S(l_link_info->node_addr), l_link_info->uplink_addr, l_link_info->uplink_port);
- if (s_net_link_add(a_net, &l_link_info->node_addr, l_link_info->uplink_addr, l_link_info->uplink_port))
- continue;
- l_json = s_net_states_json_collect(a_net);
- snprintf(l_err_str, sizeof(l_err_str)
- , "Link " NODE_ADDR_FP_STR " prepared"
- , NODE_ADDR_FP_ARGS_S(l_link_info->node_addr));
- json_object_object_add(l_json, "errorMessage", json_object_new_string(l_err_str));
- dap_notify_server_send_mt(json_object_get_string(l_json));
- json_object_put(l_json);
- debug_if(s_debug_more, L_DEBUG, "Link "NODE_ADDR_FP_STR" successfully added",
- NODE_ADDR_FP_ARGS_S(l_link_info->node_addr));
- }
-}
-
-/**
- * @brief s_net_state_link_prepare_error
- * @param a_worker
- * @param a_node_info
- * @param a_arg
- * @param a_errno
- */
-static void s_balancer_link_prepare_error(dap_chain_net_t *a_net, const char *a_addr, int a_errno)
-{
- struct json_object *l_json = s_net_states_json_collect(a_net);
- char l_err_str[512] = { '\0' };
- dap_snprintf(l_err_str, sizeof(l_err_str)
- , "Link from balancer %s can't be prepared, errno %d"
- , a_addr, a_errno);
- log_it(L_WARNING, l_err_str);
- json_object_object_add(l_json, "errorMessage", json_object_new_string(l_err_str));
- dap_notify_server_send_mt(json_object_get_string(l_json));
- json_object_put(l_json);
-}
-
-
-void s_http_balancer_link_prepare_success(void *a_response, size_t a_response_size, void *a_arg)
-{
- struct balancer_link_request *l_balancer_request = (struct balancer_link_request *)a_arg;
- dap_chain_net_links_t *l_link_full_node_list = (dap_chain_net_links_t*)a_response;
-
- size_t l_response_size_need = sizeof(dap_chain_net_links_t) + (sizeof(dap_link_info_t) * l_balancer_request->links_requested_count);
- if (a_response_size < sizeof(dap_chain_net_links_t) + sizeof(dap_link_info_t) || a_response_size > l_response_size_need) {
- log_it(L_ERROR, "Invalid balancer response size %zu (expected %zu)", a_response_size, l_response_size_need);
- DAP_DELETE(l_balancer_request);
- return;
- }
- s_balancer_link_prepare_success(l_balancer_request->net, l_link_full_node_list);
- DAP_DELETE(l_balancer_request);
-}
-
-void s_http_balancer_link_prepare_error(int a_error_code, void *a_arg)
-{
- struct balancer_link_request *l_balancer_request = (struct balancer_link_request *)a_arg;
- s_balancer_link_prepare_error(l_balancer_request->net, l_balancer_request->info->addr, a_error_code);
- DAP_DELETE(l_balancer_request);
-}
-
/**
* @brief Launch a connect with a link
* @param a_net
@@ -644,72 +567,12 @@ int s_link_manager_link_request(uint64_t a_net_id)
return -2;
if (l_net_pvt->state == NET_STATE_LINKS_PREPARE)
l_net_pvt->state = NET_STATE_LINKS_CONNECTING;
- size_t l_required_links_count = dap_link_manager_needed_links_count(l_net->pub.id.uint64);
- // TODO make correct asynchronous local balancer request
- dap_chain_net_links_t *l_links = dap_chain_net_balancer_get_node(l_net->pub.name, l_required_links_count);
- if (l_links) {
- s_balancer_link_prepare_success(l_net, l_links);
- if (l_links->count_node >= l_required_links_count)
- return 0;
- else
- l_required_links_count -= l_links->count_node;
- }
- // dynamic links from http balancer request
- struct balancer_link_request *l_balancer_request = NULL;
- DAP_NEW_Z_RET_VAL(l_balancer_request, struct balancer_link_request, -4, NULL);
- *l_balancer_request = (struct balancer_link_request) {
- .info = s_balancer_link_from_cfg(l_net),
- .net = l_net,
- .worker = dap_events_worker_get_auto(),
- .links_requested_count = l_required_links_count
- };
- if (!l_balancer_request->info) {
- log_it(L_ERROR, "Can't process balancer link %s request", PVT(l_net)->balancer_type == 0 ? "HTTP" : "DNS");
- DAP_DELETE(l_balancer_request);
+ struct request_link_info *l_balancer_link = s_balancer_link_from_cfg(l_net);
+ if (!l_balancer_link) {
+ log_it(L_ERROR, "Can't process balancer link %s request", dap_chain_net_balancer_type_to_str(PVT(l_net)->balancer_type));
return -5;
}
- log_it(L_DEBUG, "Start balancer %s request to %s",
- PVT(l_net)->balancer_type == 0 ? "HTTP" : "DNS", l_balancer_request->info->addr);
-
- int ret;
- if (PVT(l_net)->balancer_type == 0) {
- char *l_request = dap_strdup_printf("%s/%s?version=%d,method=r,needlink=%d,net=%s",
- DAP_UPLINK_PATH_BALANCER,
- DAP_BALANCER_URI_HASH,
- DAP_BALANCER_PROTOCOL_VERSION,
- (int)l_required_links_count,
- l_net->pub.name);
- ret = dap_client_http_request(l_balancer_request->worker,
- l_balancer_request->info->addr,
- l_balancer_request->info->port,
- "GET",
- "text/text",
- l_request,
- NULL,
- 0,
- NULL,
- s_http_balancer_link_prepare_success,
- s_http_balancer_link_prepare_error,
- l_balancer_request,
- NULL) == NULL;
- DAP_DELETE(l_request);
- } else {
- l_balancer_request->info->port = DNS_LISTEN_PORT;
- // TODO: change signature and implementation
- ret = /* dap_chain_node_info_dns_request(l_balancer_request->worker,
- l_link_node_info->hdr.ext_addr_v4,
- l_link_node_info->hdr.ext_port,
- a_net->pub.name,
- s_dns_balancer_link_prepare_success,
- s_dns_balancer_link_prepare_error,
- l_balancer_request); */ -1;
- }
- if (ret) {
- log_it(L_ERROR, "Can't process balancer link %s request", PVT(l_net)->balancer_type == 0 ? "HTTP" : "DNS");
- DAP_DELETE(l_balancer_request);
- return -6;
- }
- return 0;
+ return dap_chain_net_balancer_request(l_net, l_balancer_link->addr, l_balancer_link->port, PVT(l_net)->balancer_type);
}
int s_link_manager_fill_net_info(dap_link_t *a_link)
@@ -842,6 +705,7 @@ static dap_chain_net_t *s_net_new(dap_chain_net_id_t *a_id, const char *a_name,
dap_chain_net_t *l_ret = NULL;
// memory alloc
DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_t, sizeof(dap_chain_net_t) + sizeof(dap_chain_net_pvt_t), NULL, NULL);
+ DAP_NEW_Z_SIZE_RET_VAL(PVT(l_ret)->node_info, dap_chain_node_info_t, sizeof(dap_chain_node_info_t) + DAP_HOSTADDR_STRLEN + 1, NULL, l_ret);
// func work
l_ret->pub.id.uint64 = a_id->uint64;
pthread_mutexattr_t l_mutex_attr;
@@ -1920,9 +1784,7 @@ void dap_chain_net_deinit()
HASH_ITER(hh, s_net_ids, l_current_item, l_tmp)
HASH_DELETE(hh2, s_net_ids, l_current_item);
HASH_ITER(hh, s_net_items, l_current_item, l_tmp) {
- HASH_DEL(s_net_items, l_current_item);
dap_chain_net_delete(l_current_item->chain_net);
- DAP_DELETE(l_current_item);
}
dap_http_ban_list_client_deinit();
}
@@ -2095,7 +1957,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
if (!l_net_pvt->seed_nodes_count)
l_seed_nodes_hosts = dap_config_get_array_str(l_cfg, "general", "bootstrap_hosts", &l_net_pvt->seed_nodes_count);
if (!l_net_pvt->seed_nodes_count)
- log_it(L_WARNING, "Can't read seed nodes addresses, wark with local balancer only");
+ log_it(L_WARNING, "Can't read seed nodes addresses, work with local balancer only");
else if (!(l_net_pvt->seed_nodes_info = DAP_NEW_Z_COUNT(struct request_link_info *, l_net_pvt->seed_nodes_count))) {
log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_chain_net_delete(l_net);
@@ -2141,7 +2003,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
continue;
char *l_entry_name = dap_strdup(l_dir_entry->d_name);
if (!l_entry_name) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_chain_net_delete(l_net);
closedir(l_chains_dir);
return -8;
@@ -2155,7 +2017,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_entry_name);
dap_config_close(l_cfg_new);
closedir(l_chains_dir);
@@ -2393,8 +2255,17 @@ int s_net_load(dap_chain_net_t *a_net)
}
dap_chain_net_add_auth_nodes_to_cluster(l_net, l_net_pvt->orders_cluster);
DAP_DELETE(l_gdb_groups_mask);
+ // node states cluster
+ l_gdb_groups_mask = dap_strdup_printf("%s.nodes.states", l_net->pub.gdb_groups_prefix);
+ dap_global_db_cluster_add(
+ dap_global_db_instance_get_default(),
+ l_net->pub.name, dap_guuid_compose(l_net->pub.id.uint64, 0),
+ l_gdb_groups_mask, 0, true,
+ DAP_GDB_MEMBER_ROLE_USER,
+ DAP_CLUSTER_ROLE_VIRTUAL);
+ DAP_DELETE(l_gdb_groups_mask);
// Nodes and its aliases cluster
- l_net->pub.gdb_nodes = dap_strdup_printf("%s.nodes",l_net->pub.gdb_groups_prefix);
+ l_net->pub.gdb_nodes = dap_strdup_printf("%s.nodes.list",l_net->pub.gdb_groups_prefix);
l_net->pub.gdb_nodes_aliases = dap_strdup_printf("%s.nodes.aliases",l_net->pub.gdb_groups_prefix);
l_gdb_groups_mask = dap_strdup_printf("%s.nodes*", l_net->pub.gdb_groups_prefix);
l_net_pvt->nodes_cluster = dap_global_db_cluster_add(dap_global_db_instance_get_default(),
@@ -2426,13 +2297,11 @@ int s_net_load(dap_chain_net_t *a_net)
const char *l_ext_addr = dap_config_get_item_str_default(g_config, "server", "ext_address", NULL);
if (!l_ext_addr) {
log_it(L_INFO, "External address is not set, will be detected automatically");
- l_net_pvt->node_info = DAP_NEW_Z_SIZE(dap_chain_node_info_t, sizeof(dap_chain_node_info_t) + sizeof(l_host) );
} else {
if ( dap_net_parse_hostname(l_ext_addr, l_host, &l_ext_port) )
log_it(L_ERROR, "Invalid server address \"%s\", fix config and restart node", l_ext_addr);
else {
uint8_t l_hostlen = dap_strlen(l_host);
- l_net_pvt->node_info = DAP_NEW_Z_SIZE(dap_chain_node_info_t, sizeof(dap_chain_node_info_t) + l_hostlen + 1 );
l_net_pvt->node_info->ext_port = l_ext_port;
l_net_pvt->node_info->ext_host_len = dap_strncpy(l_net_pvt->node_info->ext_host, l_host, l_hostlen) - l_net_pvt->node_info->ext_host;
}
@@ -2451,9 +2320,7 @@ int s_net_load(dap_chain_net_t *a_net)
} else
log_it(L_INFO, "Server is disabled");
- if (!l_net_pvt->node_info)
- l_net_pvt->node_info = DAP_NEW_Z_SIZE(dap_chain_node_info_t, sizeof(dap_chain_node_info_t) + DAP_HOSTADDR_STRLEN + 1 );
- l_net_pvt->node_info->address = g_node_addr;
+ l_net_pvt->node_info->address.uint64 = g_node_addr.uint64;
log_it(L_NOTICE, "Net load information: node_addr " NODE_ADDR_FP_STR ", seed links %u, cell_id 0x%016"DAP_UINT64_FORMAT_X,
NODE_ADDR_FP_ARGS_S(g_node_addr),
@@ -2797,6 +2664,7 @@ size_t dap_chain_net_count() {
}
dap_chain_net_t *dap_chain_net_iter_start() {
+ dap_return_val_if_pass(!s_net_items, NULL);
return s_net_items->chain_net;
}
diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index 5f664784d2b18bd40072f487f486d18c239f7244..591778a033598775ac23700b6b1ed2aad8bbad78 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -1,9 +1,11 @@
/*
* Authors:
* Dmitriy Gerasimov <naeper@demlabs.net>
+* Roman Khlopkov <roman.khlopkov@demlabs.net>
+* Pavel Uhanov <pavel.uhanov@demlabs.net>
* Cellframe https://cellframe.net
* DeM Labs Inc. https://demlabs.net
-* Copyright (c) 2017-2019
+* Copyright (c) 2017-2024
* All rights reserved.
This file is part of CellFrame SDK the open source project
@@ -26,201 +28,286 @@ along with any CellFrame SDK based project. If not, see <http://www.gnu.org/lic
#include "dap_chain_net.h"
#include "http_status_code.h"
#include "dap_chain_node_client.h"
+#include "dap_chain_node_dns_client.h"
#include "rand/dap_rand.h"
+#include "dap_notify_srv.h"
#define LOG_TAG "dap_chain_net_balancer"
+typedef struct dap_balancer_link_request {
+ const char* host_addr;
+ uint16_t host_port;
+ dap_chain_net_t *net;
+ dap_worker_t *worker;
+ uint16_t required_links_count;
+} dap_balancer_link_request_t;
+
static_assert(sizeof(dap_chain_net_links_t) + sizeof(dap_chain_node_info_old_t) < DAP_BALANCER_MAX_REPLY_SIZE, "DAP_BALANCER_MAX_REPLY_SIZE cannot accommodate information minimum about 1 link");
static const size_t s_max_links_response_count = (DAP_BALANCER_MAX_REPLY_SIZE - sizeof(dap_chain_net_links_t)) / sizeof(dap_chain_node_info_old_t);
-int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_chain_net_t *a_net)
+/**
+ * @brief forming json file with balancer info: class networkName nodeAddress hostAddress hostPort
+ * @param a_net - responce net
+ * @param a_host_info - host info
+ */
+struct json_object *s_balancer_states_json_collect(dap_chain_net_t *a_net, const char* a_host_addr, uint16_t a_host_port)
{
- dap_chain_node_client_t *l_client = dap_chain_node_client_connect_default_channels(a_net, a_node_info);
- return l_client ? dap_chain_node_client_wait(l_client, NODE_CLIENT_STATE_ESTABLISHED, 5000) : -1;
+ struct json_object *l_json = json_object_new_object();
+ json_object_object_add(l_json, "class" , json_object_new_string("BalancerRequest"));
+ json_object_object_add(l_json, "networkName" , json_object_new_string((const char*)a_net->pub.name));
+ json_object_object_add(l_json, "hostAddress" , json_object_new_string(a_host_addr ? a_host_addr : "localhost"));
+ if (a_host_addr)
+ json_object_object_add(l_json, "hostPort" , json_object_new_int(a_host_port));
+ return l_json;
}
-/*static uint64_t min_count_blocks_events(dap_global_db_obj_t * a_objs, size_t a_node_count, dap_chain_node_info_t **a_node_info_list, size_t a_count)
+/**
+ * @brief callback to success balancer request
+ * @param a_net - responce net
+ * @param a_link_full_node_list - getted node list
+ * @param a_host_info - host info
+ */
+static dap_chain_net_links_t *s_get_ignored_node_addrs(dap_chain_net_t *a_net, size_t *a_size)
{
- uint64_t l_blocks_events = 0;
- for (size_t i = 0; i < a_node_count; i++) {
- dap_chain_node_info_t *l_node_cand = (dap_chain_node_info_t *)a_objs[i].value;
- if (!l_node_cand) {
- log_it(L_ERROR, "Invalid record, key %s", a_objs[i].key);
- continue;
- }
- for (dap_list_t *node_i = a_node_info_list; node_i; node_i = node_i->next) {
- if( !dap_strcmp(((dap_chain_node_info_t*)node_i->data)->ext_host, l_node_cand->ext_host) ) {
- if (!l_blocks_events || l_blocks_events > l_node_cand->info.atoms_count)
- l_blocks_events = l_node_cand->info.atoms_count;
- break;
- }
- }
+// sanity check
+ dap_return_val_if_pass(!a_net, NULL);
+// data preparing
+ size_t
+ l_size = 0,
+ l_uplinks_count = 0,
+ l_low_availability_count = 0;
+ dap_stream_node_addr_t *l_uplinks = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, NULL, true);
+ dap_stream_node_addr_t *l_low_availability = dap_link_manager_get_ignored_addrs(&l_low_availability_count);
+ if(!l_uplinks && !l_low_availability) {
+ return NULL;
}
- return l_blocks_events;
+ l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_uplinks_count + l_low_availability_count);
+// memory alloc
+ dap_chain_net_links_t *l_ret = NULL;
+ DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, NULL);
+// func work
+ memcpy(l_ret->nodes_info, l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
+ memcpy(l_ret->nodes_info + l_uplinks_count, l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
+ l_ret->count_node = l_uplinks_count + l_low_availability_count;
+ if (a_size)
+ *a_size = l_size;
+ DAP_DEL_MULTY(l_uplinks, l_low_availability);
+ return l_ret;
}
-dap_link_info_t *dap_link_manager_get_net_links_info_list(uint64_t a_net_id, size_t *a_count)
+/**
+ * @brief callback to success balancer request
+ * @param a_net - responce net
+ * @param a_link_full_node_list - getted node list
+ * @param a_host_info - host info
+ */
+static void s_balancer_link_prepare_success(dap_chain_net_t* a_net, dap_chain_net_links_t *a_link_full_node_list, const char* a_host_addr, uint16_t a_host_port)
{
-// sanity check
- dap_managed_net_t *l_net = s_find_net_by_id(a_net_id);
- dap_return_val_if_pass(!l_net, 0);
-// func work
- size_t l_count = 0;
- dap_link_info_t *l_ret = NULL;
- dap_stream_node_addr_t *l_links_addrs = dap_cluster_get_all_members_addrs((dap_cluster_t *)l_net->link_clusters->data, &l_count);
- if (!l_links_addrs || !l_count) {
- return NULL;
+ char l_err_str[128] = {0};
+ struct json_object *l_json;
+ for (size_t i = 0; i < a_link_full_node_list->count_node; ++i) {
+ dap_link_info_t *l_link_info = (dap_link_info_t *)a_link_full_node_list->nodes_info + i;
+ log_it(L_DEBUG,"Link " NODE_ADDR_FP_STR " [ %s : %u ] prepare success",
+ NODE_ADDR_FP_ARGS_S(l_link_info->node_addr), l_link_info->uplink_addr, l_link_info->uplink_port);
+ if (dap_chain_net_link_add(a_net, &l_link_info->node_addr, l_link_info->uplink_addr, l_link_info->uplink_port))
+ continue;
+ l_json = s_balancer_states_json_collect(a_net, a_host_addr, a_host_port);
+ snprintf(l_err_str, sizeof(l_err_str)
+ , "Link " NODE_ADDR_FP_STR " prepared"
+ , NODE_ADDR_FP_ARGS_S(l_link_info->node_addr));
+ json_object_object_add(l_json, "errorMessage", json_object_new_string(l_err_str));
+ dap_notify_server_send_mt(json_object_get_string(l_json));
+ json_object_put(l_json);
+ log_it(L_DEBUG, "Link "NODE_ADDR_FP_STR" successfully added",
+ NODE_ADDR_FP_ARGS_S(l_link_info->node_addr));
}
- DAP_NEW_Z_COUNT_RET_VAL(l_ret, dap_link_info_t, l_count, NULL, l_links_addrs);
- pthread_rwlock_rdlock(&s_link_manager->links_lock);
- for (int i = l_count - 1; i >= 0; --i) {
- dap_link_t *l_link = NULL;
- HASH_FIND(hh, s_link_manager->links, l_links_addrs + i, sizeof(l_links_addrs[i]), l_link);
- if (!l_link || l_link->uplink.state != LINK_STATE_ESTABLISHED) {
- --l_count;
- continue;
- }
- dap_mempcpy(l_ret + i, &l_link->uplink.client->link_info, sizeof(dap_link_info_t));
- }
- pthread_rwlock_unlock(&s_link_manager->links_lock);
- DAP_DELETE(l_links_addrs);
- if (!l_count) {
- DAP_DELETE(l_ret);
- return NULL;
+}
+
+/**
+ * @brief callback to success http balancer request
+ * @param a_response - response
+ * @param a_response_size - a response size
+ * @param a_arg - callback arg (l_balancer_request)
+ */
+void s_http_balancer_link_prepare_success(void *a_response, size_t a_response_size, void *a_arg)
+{
+ dap_balancer_link_request_t *l_balancer_request = (dap_balancer_link_request_t *)a_arg;
+ dap_chain_net_links_t *l_link_full_node_list = (dap_chain_net_links_t *)a_response;
+
+ size_t l_response_size_need = sizeof(dap_chain_net_links_t) + (sizeof(dap_link_info_t) * l_balancer_request->required_links_count);
+ if (a_response_size < sizeof(dap_chain_net_links_t) + sizeof(dap_link_info_t) || a_response_size > l_response_size_need) {
+ log_it(L_ERROR, "Invalid balancer response size %zu (expected %zu)", a_response_size, l_response_size_need);
+ } else {
+ s_balancer_link_prepare_success(l_balancer_request->net, l_link_full_node_list, l_balancer_request->host_addr, l_balancer_request->host_port);
}
- if (a_count)
- *a_count = l_count;
- return l_ret;
+ DAP_DELETE(l_balancer_request);
+}
+
+/**
+ * @brief callback to error in balancer request preparing
+ * @param a_request - balancer request
+ * @param a_host_addr - host addr
+ * @param a_errno - error code
+ */
+static void s_balancer_link_prepare_error(dap_balancer_link_request_t *a_request, const char *a_host_addr, uint16_t a_host_port, int a_errno)
+{
+ struct json_object *l_json = s_balancer_states_json_collect(a_request->net, a_host_addr, a_host_port);
+ char l_err_str[512] = { '\0' };
+ dap_snprintf(l_err_str, sizeof(l_err_str)
+ , "Link from balancer %s can't be prepared, errno %d"
+ , a_host_addr, a_errno);
+ log_it(L_WARNING, "%s", l_err_str);
+ json_object_object_add(l_json, "errorMessage", json_object_new_string(l_err_str));
+ dap_notify_server_send_mt(json_object_get_string(l_json));
+ json_object_put(l_json);
}
-*/
-dap_link_info_t *s_get_links_info_list(dap_chain_net_t *a_net, size_t *a_count, bool a_external_call)
+/**
+ * @brief callback to error in http balancer request preparing
+ * @param a_errno - error code
+ * @param a_arg - callback arg (l_balancer_request)
+ */
+static void s_http_balancer_link_prepare_error(int a_errno, void *a_arg)
{
- static _Thread_local dap_global_db_driver_hash_t l_last_read_hash = {};
- assert(a_net && a_count);
- size_t l_count = *a_count;
- if (!l_count) {
- l_count = dap_global_db_driver_count(a_net->pub.gdb_nodes, c_dap_global_db_driver_hash_blank);
- if (!l_count)
- return NULL;
+ dap_balancer_link_request_t *l_balancer_request = (dap_balancer_link_request_t *)a_arg;
+ s_balancer_link_prepare_error(l_balancer_request, l_balancer_request->host_addr, l_balancer_request->host_port, a_errno);
+ DAP_DELETE(l_balancer_request);
+}
+
+/**
+ * @brief forming links info
+ * @param a_net - net to froming info
+ * @param a_links_need - needed link count, if 0 - max possible
+ * @param a_ignored - list with ignored links
+ * @param a_external_call - externl call flag, if false - max possible
+ * @return if error NULL, or pointer to link info
+ */
+static dap_chain_net_links_t *s_get_node_addrs(dap_chain_net_t *a_net, uint16_t a_links_need, dap_chain_net_links_t *a_ignored, bool a_external_call)
+{
+// sanity check
+ dap_return_val_if_pass(!a_net, NULL);
+// preparing
+ dap_list_t *l_nodes_list = dap_chain_node_get_states_list_sort(a_net, a_ignored ? (dap_chain_node_addr_t *)a_ignored->nodes_info : (dap_chain_node_addr_t *)NULL, a_ignored ? a_ignored->count_node : 0);
+ if (!l_nodes_list) {
+ log_it(L_WARNING, "There isn't any nodes in net %s", a_net->pub.name);
+ return NULL;
}
- dap_store_obj_t *l_objs = dap_global_db_driver_cond_read(a_net->pub.gdb_nodes, l_last_read_hash, &l_count);
- if (!l_objs || !l_count) {
- l_last_read_hash = c_dap_global_db_driver_hash_blank;
- return a_external_call ? s_get_links_info_list(a_net, a_count, false) : NULL;
+ size_t l_nodes_count = dap_list_length(l_nodes_list);
+ if (a_links_need) {
+ l_nodes_count = dap_min(l_nodes_count, a_links_need);
}
- l_last_read_hash = dap_global_db_driver_hash_get(l_objs + l_count - 1);
- if (dap_global_db_driver_hash_is_blank(&l_last_read_hash))
- l_count--;
- dap_link_info_t *l_ret = NULL;
- DAP_NEW_Z_COUNT_RET_VAL(l_ret, dap_link_info_t, l_count, NULL, NULL);
- for (size_t i = 0; i < l_count; i++) {
- dap_link_info_t *l_cur_info = l_ret + i;
- dap_chain_node_info_t *l_db_info = (dap_chain_node_info_t *)(l_objs + i)->value;
- l_cur_info->node_addr = l_db_info->address;
- l_cur_info->uplink_port = l_db_info->ext_port;
- dap_strncpy(l_cur_info->uplink_addr, l_db_info->ext_host, dap_min(l_db_info->ext_host_len, DAP_HOSTADDR_STRLEN));
+ if (a_external_call) {
+ l_nodes_count = dap_min(l_nodes_count, s_max_links_response_count);
}
- dap_store_obj_free(l_objs, l_count);
- if (a_external_call && l_count < *a_count) {
- size_t l_total_count = dap_global_db_driver_count(a_net->pub.gdb_nodes, c_dap_global_db_driver_hash_blank);
- if (l_count < l_total_count) {
- size_t l_tail_count = dap_min(l_total_count, *a_count) - l_count;
- dap_link_info_t *l_tail = s_get_links_info_list(a_net, &l_tail_count, false);
- if (l_tail && l_tail_count) {
- l_ret = DAP_REALLOC(l_ret, sizeof(dap_link_info_t) * (l_count + l_tail_count));
- memcpy(l_ret + l_count, l_tail, sizeof(dap_link_info_t) * l_tail_count);
- l_count += l_tail_count;
- DAP_DELETE(l_tail);
- }
- }
+// memory alloc
+ dap_chain_net_links_t *l_ret = DAP_NEW_Z_SIZE(dap_chain_net_links_t, sizeof(dap_chain_net_links_t) + l_nodes_count * sizeof(dap_link_info_t));
+ if (!l_ret) {
+ log_it(L_ERROR, "%s", g_error_memory_alloc);
+ dap_list_free_full(l_nodes_list, NULL);
+ return NULL;
+ }
+// func work
+ dap_link_info_t *l_node_info = (dap_link_info_t *)l_ret->nodes_info;
+ for(dap_list_t *i = l_nodes_list; i && l_ret->count_node < l_nodes_count; i = i->next, ++l_ret->count_node) {
+ dap_mempcpy(l_node_info + l_ret->count_node, &((dap_chain_node_states_info_t *)i->data)->link_info , sizeof(dap_link_info_t));
}
- *a_count = l_count;
+ dap_list_free_full(l_nodes_list, NULL);
return l_ret;
}
-dap_chain_net_links_t *dap_chain_net_balancer_get_node(const char *a_net_name, uint16_t a_links_need)
+/**
+ * @brief forming links info in old format
+ * @param a_net - net to froming info
+ * @param a_links_need - needed link count, if 0 - max possible
+ * @return if error NULL, or pointer to link info
+ */
+static dap_chain_net_links_t *s_get_node_addrs_old(dap_chain_net_t *a_net, uint16_t a_links_need)
{
// sanity check
- dap_return_val_if_pass(!a_net_name || !a_links_need, NULL);
- dap_chain_net_t *l_net = dap_chain_net_by_name(a_net_name);
- if (l_net == NULL) {
- log_it(L_WARNING, "There isn't any network by this name - %s", a_net_name);
- return NULL;
- }
+ dap_return_val_if_pass(!a_net, NULL);
// preparing
- size_t l_node_num_prep = a_links_need;
- dap_link_info_t *l_links_info = s_get_links_info_list(l_net, &l_node_num_prep, true);
- if (!l_links_info || !l_node_num_prep){
- log_it(L_WARNING, "Active node list in net %s is empty", a_net_name);
+ dap_list_t *l_nodes_list = dap_chain_node_get_states_list_sort(a_net, NULL, 0);
+ if (!l_nodes_list) {
+ log_it(L_WARNING, "There isn't any nodes in net %s", a_net->pub.name);
return NULL;
}
- size_t l_node_num_send = dap_min(s_max_links_response_count, l_node_num_prep);
+ size_t l_nodes_count = dap_list_length(l_nodes_list);
+ if (a_links_need) {
+ l_nodes_count = dap_min(l_nodes_count, a_links_need);
+ }
+ l_nodes_count = dap_min(l_nodes_count, s_max_links_response_count);
// memory alloc
- dap_chain_net_links_t *l_node_list_res = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_node_list_res, dap_chain_net_links_t, sizeof(dap_chain_net_links_t) + l_node_num_send * sizeof(dap_link_info_t), NULL, l_links_info);
- dap_link_info_t *l_node_info = (dap_link_info_t *)l_node_list_res->nodes_info;
+ dap_chain_net_links_t *l_ret = DAP_NEW_Z_SIZE(dap_chain_net_links_t, sizeof(dap_chain_net_links_t) + l_nodes_count * sizeof(dap_chain_node_info_old_t));
+ if (!l_ret) {
+ log_it(L_ERROR, "%s", g_error_memory_alloc);
+ dap_list_free_full(l_nodes_list, NULL);
+ return NULL;
+ }
// func work
- // if we can't send full list, choose random, not always firsts
- if (l_node_num_send < l_node_num_prep) {
- for (size_t i = 0; i < l_node_num_send; ++i)
- dap_mempcpy(l_node_info + i, l_links_info + dap_random_uint16() % l_node_num_prep, sizeof(dap_link_info_t));
- } else {
- dap_mempcpy(l_node_info, l_links_info, l_node_num_send * sizeof(dap_link_info_t));
+ dap_chain_node_info_old_t *l_node_info = (dap_chain_node_info_old_t *)l_ret->nodes_info;
+ for(dap_list_t *i = l_nodes_list; i && l_ret->count_node < l_nodes_count; i = i->next, ++l_ret->count_node) {
+ l_node_info[l_ret->count_node].hdr.address.uint64 = ((dap_chain_node_states_info_t *)i->data)->link_info.node_addr.uint64;
+ l_node_info[l_ret->count_node].hdr.ext_port = ((dap_chain_node_states_info_t *)i->data)->link_info.uplink_port;
+ inet_pton(AF_INET, ((dap_chain_node_states_info_t *)i->data)->link_info.uplink_addr, &l_node_info[l_ret->count_node].hdr.ext_addr_v4);
}
- l_node_list_res->count_node = l_node_num_send;
- DAP_DELETE(l_links_info);
- return l_node_list_res;
+ dap_list_free_full(l_nodes_list, NULL);
+ return l_ret;
}
-
-dap_chain_net_links_t *dap_chain_net_balancer_get_node_old(const char *a_net_name, uint16_t a_links_need)
+/**
+ * @brief issue to balancer request
+ * @param a_net_name - net name
+ * @param a_links_need - needed link count, if 0 - max possible
+ * @param a_protocol_version - balancer protocol version
+ * @param a_ignored_enc - encrypted to base64 ignored node addrs
+ * @return if error NULL, or pointer to link info
+ */
+static dap_chain_net_links_t *s_balancer_issue_link(const char *a_net_name, uint16_t a_links_need, int a_protocol_version, const char *a_ignored_enc)
{
// sanity check
- dap_return_val_if_pass(!a_net_name || !a_links_need, NULL);
+ dap_return_val_if_pass(!a_net_name, NULL);
+// preparing
dap_chain_net_t *l_net = dap_chain_net_by_name(a_net_name);
- if (l_net == NULL) {
+ if (!l_net) {
log_it(L_WARNING, "There isn't any network by this name - %s", a_net_name);
return NULL;
}
-// preparing
- size_t l_node_num_prep = a_links_need;
- dap_link_info_t *l_links_info = s_get_links_info_list(l_net, &l_node_num_prep, true);
- if (!l_links_info || !l_node_num_prep){
- log_it(L_WARNING, "Active node list in net %s is empty", a_net_name);
- return NULL;
- }
- size_t l_node_num_send = dap_min(s_max_links_response_count, l_node_num_prep);
-// memory alloc
- dap_chain_net_links_t *l_node_list_res = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_node_list_res, dap_chain_net_links_t, sizeof(dap_chain_net_links_t) + l_node_num_send * sizeof(dap_chain_node_info_old_t), NULL, l_links_info);
- dap_chain_node_info_old_t *l_node_info = (dap_chain_node_info_old_t *)l_node_list_res->nodes_info;
+ if(a_protocol_version == 1)
+ return s_get_node_addrs_old(l_net, a_links_need);
// func work
- // if we can't send full list, choose random, not always firsts
- if (l_node_num_send < l_node_num_prep) {
- for (size_t i = 0; i < l_node_num_send; ++i) {
- size_t j = dap_random_uint16() % l_node_num_prep;
- l_node_info[i].hdr.address.uint64 = l_links_info[j].node_addr.uint64;
- l_node_info[i].hdr.ext_port = l_links_info[j].uplink_port;
- inet_pton(AF_INET, l_links_info[j].uplink_addr, &l_node_info[i].hdr.ext_addr_v4);
- }
- } else {
- for (size_t i = 0; i < l_node_num_send; ++i) {
- l_node_info[i].hdr.address.uint64 = l_links_info[i].node_addr.uint64;
- l_node_info[i].hdr.ext_port = l_links_info[i].uplink_port;
- inet_pton(AF_INET, l_links_info[i].uplink_addr, &l_node_info[i].hdr.ext_addr_v4);
+ // prepare list of the ignred addrs
+ size_t l_ignored_size = a_ignored_enc ? strlen(a_ignored_enc) : 0;
+ dap_chain_net_links_t *l_ignored_dec = NULL;
+ if (l_ignored_size) {
+ DAP_NEW_Z_SIZE_RET_VAL(l_ignored_dec, dap_chain_net_links_t, l_ignored_size, NULL, NULL);
+ dap_enc_base64_decode(a_ignored_enc, l_ignored_size, l_ignored_dec, DAP_ENC_DATA_TYPE_B64);
+ if (l_ignored_size < DAP_ENC_BASE64_ENCODE_SIZE(sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node)) {
+ log_it(L_ERROR, "Cant't decode ignored node list, %zu %zu", l_ignored_size, DAP_ENC_BASE64_ENCODE_SIZE(sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node));
+ DAP_DEL_Z(l_ignored_dec);
}
}
- l_node_list_res->count_node = l_node_num_send;
- DAP_DELETE(l_links_info);
- return l_node_list_res;
+ dap_chain_net_links_t *l_ret = s_get_node_addrs(l_net, a_links_need, l_ignored_dec, true);
+ DAP_DEL_Z(l_ignored_dec);
+ return l_ret;
}
-DAP_STATIC_INLINE dap_chain_net_links_t *s_balancer_issue_link(const char *a_net_name, uint16_t a_links_need, int a_protocol_version)
+/**
+ * @brief balancer handshake
+ * @param a_node_info
+ * @param a_net
+ * @return -1 false, 0 timeout, 1 end of connection or sending data
+ */
+int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_chain_net_t *a_net)
{
- return a_protocol_version == 1 ? dap_chain_net_balancer_get_node_old(a_net_name, a_links_need) : dap_chain_net_balancer_get_node(a_net_name, a_links_need);
+ dap_chain_node_client_t *l_client = dap_chain_node_client_connect_default_channels(a_net, a_node_info);
+ return l_client ? dap_chain_node_client_wait(l_client, NODE_CLIENT_STATE_ESTABLISHED, 5000) : -1;
}
+/**
+ * @brief issue to http balancer request
+ * @param a_http_simple - http request
+ * @param a_arg - request arg
+ */
void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, void *a_arg)
{
log_it(L_DEBUG,"Proc enc http request");
@@ -235,10 +322,11 @@ void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, vo
int l_protocol_version = 0;
char l_issue_method = 0;
const char l_net_token[] = "net=";
- uint16_t links_need = 0;
- sscanf(a_http_simple->http_client->in_query_string, "version=%d,method=%c,needlink=%hu,net=",
- &l_protocol_version, &l_issue_method, &links_need);
- if ((l_protocol_version != DAP_BALANCER_PROTOCOL_VERSION && l_protocol_version != 1) || l_issue_method != 'r') {
+ const char l_ignored_token[] = "ignored=";
+ uint16_t l_links_need = 0;
+ sscanf(a_http_simple->http_client->in_query_string, "version=%d,method=%c,needlink=%hu",
+ &l_protocol_version, &l_issue_method, &l_links_need);
+ if (l_protocol_version > DAP_BALANCER_PROTOCOL_VERSION || l_protocol_version < 1 || l_issue_method != 'r') {
log_it(L_ERROR, "Unsupported protocol version/method in the request to dap_chain_net_balancer module");
*l_return_code = Http_Status_MethodNotAllowed;
return;
@@ -250,13 +338,22 @@ void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, vo
return;
}
l_net_str += sizeof(l_net_token) - 1;
- char l_net_name[128] = {};
- strncpy(l_net_name, l_net_str, 127);
- links_need = links_need ? links_need : 5;
- log_it(L_DEBUG, "HTTP balancer parser retrieve netname %s", l_net_name);
- dap_chain_net_links_t *l_link_full_node_list = s_balancer_issue_link(l_net_name, links_need, l_protocol_version);
+
+ char *l_ignored_str = NULL;
+ if (l_protocol_version > 1) {
+ l_ignored_str = strstr(a_http_simple->http_client->in_query_string, l_ignored_token);
+ if (!l_ignored_str) {
+ log_it(L_ERROR, "Net ignored token not found in the request to dap_chain_net_balancer module");
+ *l_return_code = Http_Status_NotFound;
+ return;
+ }
+ *(l_ignored_str - 1) = 0; // set 0 terminator to split string
+ l_ignored_str += sizeof(l_ignored_token) - 1;
+ }
+ log_it(L_DEBUG, "HTTP balancer parser retrieve netname %s", l_net_str);
+ dap_chain_net_links_t *l_link_full_node_list = s_balancer_issue_link(l_net_str, l_links_need, l_protocol_version, l_ignored_str);
if (!l_link_full_node_list) {
- log_it(L_WARNING, "Can't issue link for network %s, no acceptable links found", l_net_name);
+ log_it(L_WARNING, "Can't issue link for network %s, no acceptable links found", l_net_str);
*l_return_code = Http_Status_NotFound;
return;
}
@@ -271,14 +368,17 @@ void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, vo
}
/**
- * @brief dap_dns_resolve_hostname
- * @param str
- * @return
+ * @brief issue to dns balancer request
+ * @param a_net_name - net name
+ * @return if error NULL, or pointer to link info
*/
-dap_link_info_t *dap_chain_net_balancer_dns_issue_link(char *a_str)
+dap_link_info_t *dap_chain_net_balancer_dns_issue_link(const char *a_net_name)
{
- log_it(L_DEBUG, "DNS balancer parser retrieve netname %s", a_str);
- dap_chain_net_links_t *l_balancer_reply = s_balancer_issue_link(a_str, 1, DAP_BALANCER_PROTOCOL_VERSION);
+// sanity check
+ dap_return_val_if_pass(!a_net_name, NULL);
+// func work
+ log_it(L_DEBUG, "DNS balancer parser retrieve netname %s", a_net_name);
+ dap_chain_net_links_t *l_balancer_reply = s_balancer_issue_link(a_net_name, 1, DAP_BALANCER_PROTOCOL_VERSION, NULL);
if (!l_balancer_reply || !l_balancer_reply->count_node) {
DAP_DEL_Z(l_balancer_reply);
return NULL;
@@ -287,3 +387,128 @@ dap_link_info_t *dap_chain_net_balancer_dns_issue_link(char *a_str)
DAP_DELETE(l_balancer_reply);
return l_res;
}
+
+/**
+ * @brief prepare balancer request
+ * @param a_net - net to addrs request
+ * @param a_balancer_link - host to send request
+ * @param a_balancer_type - http or DNS
+ * @return if ok 0, error - other
+ */
+int dap_chain_net_balancer_request(dap_chain_net_t *a_net, const char *a_host_addr, uint16_t a_host_port, int a_balancer_type)
+{
+// sanity check
+ dap_return_val_if_pass(!a_net, -1);
+// func work
+ size_t l_ignored_addrs_size = 0; // prepare list of the ignored addrs
+ dap_chain_net_links_t *l_ignored_addrs = s_get_ignored_node_addrs(a_net, &l_ignored_addrs_size);
+ size_t l_required_links_count = dap_link_manager_needed_links_count(a_net->pub.id.uint64);
+ // links from local GDB
+ dap_chain_net_links_t *l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);
+ if (l_links) {
+ s_balancer_link_prepare_success(a_net, l_links, NULL, 0);
+ if (l_links->count_node >= l_required_links_count) {
+ DAP_DEL_MULTY(l_ignored_addrs, l_links);
+ return 0;
+ }
+ else
+ l_required_links_count -= l_links->count_node;
+ DAP_DELETE(l_links);
+ }
+ if (!a_host_addr || !a_host_port) {
+ log_it(L_INFO, "Can't read seed nodes addresses, work with local balancer only");
+ return 0;
+ }
+ // dynamic links from http balancer request
+ dap_balancer_link_request_t *l_balancer_request = NULL;
+ DAP_NEW_Z_RET_VAL(l_balancer_request, dap_balancer_link_request_t, -4, NULL);
+ *l_balancer_request = (dap_balancer_link_request_t) {
+ .host_addr = a_host_addr,
+ .host_port = a_host_port,
+ .net = a_net,
+ .worker = dap_events_worker_get_auto(),
+ .required_links_count = l_required_links_count
+ };
+ log_it(L_DEBUG, "Start balancer %s request to %s:%u",
+ dap_chain_net_balancer_type_to_str(a_balancer_type), l_balancer_request->host_addr, l_balancer_request->host_port);
+
+ int ret;
+ if (a_balancer_type == DAP_CHAIN_NET_BALANCER_TYPE_HTTP) {
+ char *l_ignored_addrs_str = NULL;
+ if (l_ignored_addrs) {
+ DAP_NEW_Z_SIZE_RET_VAL(
+ l_ignored_addrs_str, char, DAP_ENC_BASE64_ENCODE_SIZE(l_ignored_addrs_size) + 1,
+ -7, l_ignored_addrs, l_balancer_request);
+ dap_enc_base64_encode(l_ignored_addrs, l_ignored_addrs_size, l_ignored_addrs_str, DAP_ENC_DATA_TYPE_B64);
+ DAP_DELETE(l_ignored_addrs);
+ }
+ // request prepare
+ char *l_request = dap_strdup_printf("%s/%s?version=%d,method=r,needlink=%d,net=%s,ignored=%s",
+ DAP_UPLINK_PATH_BALANCER,
+ DAP_BALANCER_URI_HASH,
+ DAP_BALANCER_PROTOCOL_VERSION,
+ (int)l_required_links_count,
+ a_net->pub.name,
+ l_ignored_addrs_str ? l_ignored_addrs_str : "");
+ ret = dap_client_http_request(l_balancer_request->worker,
+ l_balancer_request->host_addr,
+ l_balancer_request->host_port,
+ "GET",
+ "text/text",
+ l_request,
+ NULL,
+ 0,
+ NULL,
+ s_http_balancer_link_prepare_success,
+ s_http_balancer_link_prepare_error,
+ l_balancer_request,
+ NULL) == NULL;
+ DAP_DEL_MULTY(l_ignored_addrs_str, l_request);
+ } else {
+ l_balancer_request->host_port = DNS_LISTEN_PORT;
+ // TODO: change signature and implementation
+ ret = /* dap_chain_node_info_dns_request(l_balancer_request->worker,
+ l_link_node_info->hdr.ext_addr_v4,
+ l_link_node_info->hdr.ext_port,
+ a_net->pub.name,
+ s_dns_balancer_link_prepare_success,
+ s_dns_balancer_link_prepare_error,
+ l_balancer_request); */ -1;
+ }
+ if (ret) {
+ log_it(L_ERROR, "Can't process balancer link %s request", dap_chain_net_balancer_type_to_str(a_balancer_type));
+ return -6;
+ }
+ return 0;
+}
+
+/**
+ * @brief forming report about balacer response to request
+ * @param a_net - net to report
+ * @return if error NULL, other - report
+ */
+dap_string_t *dap_chain_net_balancer_get_node_str(dap_chain_net_t *a_net)
+{
+// sanity check
+ dap_return_val_if_pass(!a_net, NULL);
+// func work
+ dap_chain_net_links_t *l_links_info_list = s_get_node_addrs(a_net, 0, NULL, false); // TODO
+ dap_string_t *l_ret = dap_string_new(l_links_info_list ?
+ "-----------------------------------------------------------------\n"
+ "|\t\tNode addr\t|\tHost addr\t\t|\n"
+ "--Send in balancer http response---------------------------------\n" : "Empty\n");
+ uint64_t l_node_num = l_links_info_list ? l_links_info_list->count_node : 0;
+ for (uint64_t i = 0; i < l_node_num; ++i) {
+ dap_link_info_t *l_link_info = (dap_link_info_t *)l_links_info_list->nodes_info + i;
+ dap_string_append_printf(l_ret, "|\t"NODE_ADDR_FP_STR"\t|\t%-16s:%u\t|\n",
+ NODE_ADDR_FP_ARGS_S(l_link_info->node_addr),
+ l_link_info->uplink_addr, l_link_info->uplink_port);
+ if(i + 1 == s_max_links_response_count && i + 1 < l_node_num) {
+ dap_string_append_printf(l_ret, "--Not send in http balancer response-----------------------------\n");
+ }
+ }
+ dap_string_prepend_printf(l_ret, "Balancer link list for total %" DAP_UINT64_FORMAT_U " records:\n", l_node_num);
+ dap_string_append(l_ret, "-----------------------------------------------------------------\n");
+ DAP_DEL_Z(l_links_info_list);
+ return l_ret;
+}
\ No newline at end of file
diff --git a/modules/net/dap_chain_net_node_list.c b/modules/net/dap_chain_net_node_list.c
index 0fbe622b3d04e29dcaa993e4396609cb66edc39f..45a95c880653240d85e7f1e6f5b7bc26dc24a0fb 100644
--- a/modules/net/dap_chain_net_node_list.c
+++ b/modules/net/dap_chain_net_node_list.c
@@ -105,7 +105,7 @@ void dap_chain_net_node_check_http_issue_link(dap_http_simple_t *a_http_simple,
*l_return_code = Http_Status_MethodNotAllowed;
return;
}
- char *l_key = dap_chain_node_addr_to_str_static( &(dap_chain_node_addr_t){.uint64 = addr} );
+ char *l_key = dap_stream_node_addr_to_str_static( (dap_chain_node_addr_t){.uint64 = addr} );
if (!l_key) {
log_it(L_ERROR, "Bad node address %zu", addr);
*l_return_code = Http_Status_BadRequest;
@@ -257,7 +257,7 @@ int dap_chain_net_node_list_request(dap_chain_net_t *a_net, uint16_t a_port, boo
struct node_link_request *l_link_node_request = s_node_list_request_init();
if (!l_link_node_request) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -4;
};
@@ -331,7 +331,7 @@ int dap_chain_net_node_list_init()
return l_res;
}
dap_chain_node_addr_t l_addr = l_addr_by_alias ? *l_addr_by_alias : a_node_info->address;
- char *a_key = dap_chain_node_addr_to_str_static(&l_addr);
+ char *a_key = dap_stream_node_addr_to_str_static(l_addr);
if ( !(l_res = dap_global_db_del_sync(a_net->pub.gdb_nodes, a_key)) ) {
dap_list_t *list_aliases = get_aliases_by_name(a_net, &l_addr), *l_el = list_aliases;
while (l_el) {
diff --git a/modules/net/dap_chain_net_tx.c b/modules/net/dap_chain_net_tx.c
index 103c97166c1124215b2aef07794dbb912f05761f..38aad05d7b2406732b7bc2732831ed0b496f5bf6 100644
--- a/modules/net/dap_chain_net_tx.c
+++ b/modules/net/dap_chain_net_tx.c
@@ -78,7 +78,7 @@ static void s_tx_cond_all_with_spends_by_srv_uid_callback(dap_chain_net_t* a_net
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return ;
}
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
@@ -99,7 +99,7 @@ static void s_tx_cond_all_with_spends_by_srv_uid_callback(dap_chain_net_t* a_net
if(l_tx_out_cond->header.srv_uid.uint64 == l_arg->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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return ;
}
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
@@ -132,14 +132,14 @@ dap_chain_datum_tx_spends_items_t * dap_chain_net_get_tx_cond_all_with_spends_by
{
cond_all_with_spends_by_srv_uid_arg_t *l_ret = DAP_NEW_Z(cond_all_with_spends_by_srv_uid_arg_t);
if (!l_ret) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ret->ret = DAP_NEW_Z(dap_chain_datum_tx_spends_items_t);
if (!l_ret->ret) {
DAP_DEL_Z(l_ret);
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ret->srv_uid = a_srv_uid;
@@ -294,7 +294,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 = a_tx_hash;
if (!l_tx_hash) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
if (dap_hash_fast_compare(l_tx_hash,l_args->tx_begin_hash)) {
@@ -327,7 +327,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_args->tx_begin_hash = a_tx_hash;
@@ -448,7 +448,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_args->addr = a_addr;
diff --git a/modules/net/dap_chain_net_voting.c b/modules/net/dap_chain_net_voting.c
index ad54206ed9a7bf02e102aad8177ba20b072cbca9..715e2a782271441b48d00a0e0ca7a116fcfa764f 100644
--- a/modules/net/dap_chain_net_voting.c
+++ b/modules/net/dap_chain_net_voting.c
@@ -129,7 +129,7 @@ uint64_t* dap_chain_net_voting_get_result(dap_ledger_t* a_ledger, dap_chain_hash
l_voting_results = DAP_NEW_Z_SIZE(uint64_t, sizeof(uint64_t)*dap_list_length(l_voting->voting_params.option_offsets_list));
if (!l_voting_results){
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index 3d476da60fd1c75dd6efe3ed5047b832ebe8aed3..5328f70f02bd2cf6c32cc6a0d60822515e6965e4 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -48,7 +48,114 @@
#include "dap_chain_cell.h"
#include "dap_chain_ledger.h"
-#define LOG_TAG "chain_node"
+#define LOG_TAG "dap_chain_node"
+
+typedef struct dap_chain_node_net_states_info {
+ dap_chain_node_addr_t address;
+ uint64_t atoms_count;
+ uint32_t uplinks_count;
+ uint32_t downlinks_count;
+ dap_chain_node_addr_t links_addrs[];
+} DAP_ALIGN_PACKED dap_chain_node_net_states_info_t;
+
+static const uint64_t s_cmp_delta_timestamp = (uint64_t)1000 /*sec*/ * (uint64_t)1000000000;
+static const uint64_t s_cmp_delta_atom = 50;
+static const uint64_t s_timer_update_states_info = 10 /*sec*/ * 1000;
+
+/**
+ * @brief get states info about current
+ * @param a_arg - pointer to callback arg
+ */
+static void s_update_node_states_info(UNUSED_ARG void *a_arg)
+{
+ for (dap_chain_net_t *l_net = dap_chain_net_iter_start(); l_net; l_net = dap_chain_net_iter_next(l_net)) {
+ dap_chain_t *l_chain = NULL;
+ if(dap_chain_net_get_state(l_net) != NET_STATE_OFFLINE && (l_chain = dap_chain_find_by_id(l_net->pub.id, (dap_chain_id_t){ .uint64 = 1 })) ) {
+ size_t
+ l_uplinks_count = 0,
+ l_downlinks_count = 0,
+ l_info_size = 0;
+ // memory alloc first
+ dap_stream_node_addr_t *l_linked_node_addrs = dap_link_manager_get_net_links_addrs(l_net->pub.id.uint64, &l_uplinks_count, &l_downlinks_count, false);
+ dap_chain_node_net_states_info_t *l_info = NULL;
+ l_info_size = sizeof(dap_chain_node_net_states_info_t) + (l_uplinks_count + l_downlinks_count) * sizeof(dap_chain_node_addr_t);
+ DAP_NEW_Z_SIZE_RET(l_info, dap_chain_node_net_states_info_t, l_info_size, l_linked_node_addrs);
+ // func work
+ // data preparing
+ l_info->address.uint64 = g_node_addr.uint64;
+ l_info->uplinks_count = l_uplinks_count;
+ l_info->downlinks_count = l_downlinks_count;
+ l_info->atoms_count = l_chain->callback_count_atom ? l_chain->callback_count_atom(l_chain) : 0;
+ memcpy(l_info->links_addrs, l_linked_node_addrs, (l_info->uplinks_count + l_info->downlinks_count) * sizeof(dap_chain_node_addr_t));
+ // DB write
+ char *l_gdb_group = dap_strdup_printf("%s.nodes.states", l_net->pub.gdb_groups_prefix);
+ char *l_node_addr_str = dap_stream_node_addr_to_str_static(l_info->address);
+ dap_global_db_set_sync(l_gdb_group, l_node_addr_str, l_info, l_info_size, false);
+ DAP_DEL_MULTY(l_linked_node_addrs, l_info, l_gdb_group);
+ }
+ }
+}
+
+static void s_states_info_to_str(dap_chain_net_t *a_net, char *a_node_addr_str, dap_string_t *l_info_str)
+{
+// sanity check
+ dap_return_if_pass(!a_net || !a_node_addr_str || !l_info_str);
+// func work
+ dap_nanotime_t l_timestamp = 0;
+ char *l_gdb_group = dap_strdup_printf("%s.nodes.states", a_net->pub.gdb_groups_prefix);
+ dap_chain_node_net_states_info_t *l_store_obj = (dap_chain_node_net_states_info_t *)dap_global_db_get_sync(l_gdb_group, a_node_addr_str, NULL, NULL, &l_timestamp);
+ if (!l_store_obj) {
+ log_it(L_ERROR, "Can't find state about %s node", a_node_addr_str);
+ return;
+ }
+ char l_ts[80] = { '\0' };
+ dap_nanotime_to_str_rfc822(l_ts, sizeof(l_ts), l_timestamp);
+ dap_string_append_printf(l_info_str,
+ "Record timestamp: %s\nNode addr: %s\nNet: %s\nAtoms count: %"DAP_UINT64_FORMAT_U"\nUplinks count: %u\nDownlinks count: %u\n",
+ l_ts, a_node_addr_str, a_net->pub.name, l_store_obj->atoms_count, l_store_obj->uplinks_count, l_store_obj->downlinks_count);
+ size_t l_max_links = dap_max(l_store_obj->uplinks_count, l_store_obj->downlinks_count);
+ if(l_max_links) {
+ dap_string_append_printf(l_info_str,
+ "-----------------------------------------------------------------\n"
+ "|\tUplinks node addrs\t|\tDownlinks node addrs\t|\n"
+ "-----------------------------------------------------------------\n");
+ }
+ for (size_t i = 0; i < l_max_links; ++i) {
+ char *l_upnlinks = i < l_store_obj->uplinks_count ? dap_stream_node_addr_to_str(l_store_obj->links_addrs[i], false) : dap_strdup("\t\t");
+ char *l_downlinks = i < l_store_obj->downlinks_count ? dap_stream_node_addr_to_str(l_store_obj->links_addrs[i + l_store_obj->uplinks_count], false) : dap_strdup("\t\t");
+ dap_string_append_printf(l_info_str, "|\t%s\t|\t%s\t|\n", l_upnlinks, l_downlinks);
+ DAP_DEL_MULTY(l_upnlinks, l_downlinks);
+ }
+ dap_string_append_printf(l_info_str, "-----------------------------------------------------------------\n");
+ DAP_DEL_MULTY(l_store_obj, l_gdb_group);
+}
+
+/**
+ * @brief get states info about current
+ * @param a_arg - pointer to callback arg
+ */
+dap_string_t *dap_chain_node_states_info_read(dap_chain_net_t *a_net, dap_stream_node_addr_t a_addr)
+{
+ dap_string_t *l_ret = dap_string_new("");
+ char *l_node_addr_str = dap_stream_node_addr_to_str_static(a_addr.uint64 ? a_addr : g_node_addr);
+ if(!a_net) {
+ for (dap_chain_net_t *l_net = dap_chain_net_iter_start(); l_net; l_net = dap_chain_net_iter_next(l_net)) {
+ s_states_info_to_str(l_net, l_node_addr_str, l_ret);
+ }
+ } else {
+ s_states_info_to_str(a_net, l_node_addr_str, l_ret);
+ }
+ return l_ret;
+}
+
+int dap_chain_node_init()
+{
+ if (dap_proc_thread_timer_add(NULL, s_update_node_states_info, NULL, s_timer_update_states_info)) {
+ log_it(L_ERROR, "Can't activate timer on node states update");
+ return -1;
+ }
+ return 0;
+}
/**
* Register alias in base
@@ -106,7 +213,7 @@ int dap_chain_node_info_save(dap_chain_net_t *a_net, dap_chain_node_info_t *a_no
return !a_node_info || !a_node_info->address.uint64
? log_it(L_ERROR,"Can't save node info, %s", a_node_info ? "null arg" : "zero address"), -1
: dap_global_db_set_sync( a_net->pub.gdb_nodes,
- dap_chain_node_addr_to_str_static(&a_node_info->address),
+ dap_stream_node_addr_to_str_static(a_node_info->address),
a_node_info,
dap_chain_node_info_get_size(a_node_info), false );
}
@@ -115,7 +222,7 @@ int dap_chain_node_info_del(dap_chain_net_t *a_net, dap_chain_node_info_t *a_nod
return !a_node_info || !a_node_info->address.uint64
? log_it(L_ERROR,"Can't delete node info, %s", a_node_info ? "null arg" : "zero address"), -1
: dap_global_db_del_sync( a_net->pub.gdb_nodes,
- dap_chain_node_addr_to_str_static(&a_node_info->address) );
+ dap_stream_node_addr_to_str_static(a_node_info->address) );
}
/**
@@ -123,7 +230,7 @@ int dap_chain_node_info_del(dap_chain_net_t *a_net, dap_chain_node_info_t *a_nod
*/
dap_chain_node_info_t* dap_chain_node_info_read(dap_chain_net_t *a_net, dap_chain_node_addr_t *a_address)
{
- char *l_key = dap_chain_node_addr_to_str_static(a_address);
+ char *l_key = dap_stream_node_addr_to_str_static(*a_address);
size_t l_node_info_size = 0;
dap_chain_node_info_t *l_node_info
= (dap_chain_node_info_t*)dap_global_db_get_sync(a_net->pub.gdb_nodes, l_key, &l_node_info_size, NULL, NULL);
@@ -265,3 +372,78 @@ bool dap_chain_node_mempool_autoproc_init()
return true;
}
+/**
+ * @brief comparing dap_chain_node_states_info_t
+ * @param a_first - pointer to first item
+ * @param a_second - pointer to second
+ * @return a_first < a_second -1, a_first > a_second 1, a_first = a_second 0
+ */
+static int s_node_states_info_cmp(dap_list_t *a_first, dap_list_t *a_second)
+{
+ dap_chain_node_states_info_t *a = (dap_chain_node_states_info_t *)a_first->data;
+ dap_chain_node_states_info_t *b = (dap_chain_node_states_info_t *)a_second->data;
+
+ if(a->timestamp > b->timestamp && a->timestamp - b->timestamp > s_cmp_delta_timestamp) return -1;
+ if(b->timestamp > a->timestamp && b->timestamp - a->timestamp > s_cmp_delta_timestamp) return 1;
+ if(a->atoms_count > b->atoms_count && a->atoms_count - b->atoms_count > s_cmp_delta_atom) return -1;
+ if(b->atoms_count > a->atoms_count && b->atoms_count - a->atoms_count > s_cmp_delta_atom) return 1;
+ if(a->downlinks_count < b->downlinks_count) return -1;
+ if(b->downlinks_count < a->downlinks_count) return 1;
+ return 0;
+}
+
+/**
+ * @brief geting sorted list with nodes states
+ * @param a_net - pointer to net
+ * @return pointer to sorted list or NULL if error
+ */
+dap_list_t *dap_chain_node_get_states_list_sort(dap_chain_net_t *a_net, dap_chain_node_addr_t *a_ignored, size_t a_ignored_count)
+{
+// sanity check
+ dap_return_val_if_pass(!a_net || (a_ignored_count && !a_ignored), NULL);
+// func work
+ size_t l_node_count = 0;
+ dap_global_db_obj_t *l_objs = dap_global_db_get_all_sync(a_net->pub.gdb_nodes, &l_node_count);
+ if (!l_node_count || !l_objs) {
+ log_it(L_ERROR, "Node list in net %s is empty", a_net->pub.name);
+ return NULL;
+ }
+ char *l_gdb_group = dap_strdup_printf("%s.nodes.states", a_net->pub.gdb_groups_prefix);
+ dap_list_t *l_ret = NULL;
+ for (size_t i = 0; i < l_node_count; ++i) {
+ if (!l_objs[i].value) {
+ log_it(L_ERROR, "Invalid record, key %s", l_objs[i].key);
+ continue;
+ }
+ dap_nanotime_t l_timestamp = 0;
+ dap_chain_node_net_states_info_t *l_store_obj = (dap_chain_node_net_states_info_t *)dap_global_db_get_sync(l_gdb_group, l_objs[i].key, NULL, NULL, &l_timestamp);
+ if (!l_store_obj) {
+ log_it(L_ERROR, "Can't find state about %s node", l_objs[i].key);
+ continue;
+ }
+ bool l_ignored = false;
+ for(size_t j = 0; !l_ignored && j < a_ignored_count; ++j) {
+ l_ignored = a_ignored[j].uint64 == ((dap_chain_node_info_t*)(l_objs + i)->value)->address.uint64;
+ }
+ if (l_ignored) {
+ log_it(L_DEBUG, "Link to "NODE_ADDR_FP_STR" ignored", NODE_ADDR_FP_ARGS_S(((dap_chain_node_info_t*)(l_objs + i)->value)->address));
+ continue;
+ }
+ dap_chain_node_states_info_t *l_item = DAP_NEW_Z(dap_chain_node_states_info_t);
+ if(!l_item) {
+ log_it(L_ERROR, "%s", g_error_memory_alloc);
+ break;
+ }
+ l_item->link_info.node_addr.uint64 = ((dap_chain_node_info_t*)(l_objs + i)->value)->address.uint64;
+ l_item->link_info.uplink_port = ((dap_chain_node_info_t*)(l_objs + i)->value)->ext_port;
+ dap_strncpy(l_item->link_info.uplink_addr, ((dap_chain_node_info_t*)(l_objs + i)->value)->ext_host, sizeof(l_item->link_info.uplink_addr) - 1);
+ l_item->atoms_count = l_store_obj->atoms_count;
+ l_item->downlinks_count = l_store_obj->downlinks_count;
+ l_item->timestamp = l_timestamp;
+ l_ret = dap_list_insert_sorted(l_ret, (void *)l_item, s_node_states_info_cmp);
+ DAP_DELETE(l_store_obj);
+ }
+ DAP_DELETE(l_gdb_group);
+ dap_global_db_objs_delete(l_objs, l_node_count);
+ return l_ret;
+}
\ No newline at end of file
diff --git a/modules/net/dap_chain_node_cli.c b/modules/net/dap_chain_node_cli.c
index 078e5076fd4c15c529786c7a9d465bef593a8bb0..c450d051262c33eb92a27148998e2fa552b47f61 100644
--- a/modules/net/dap_chain_node_cli.c
+++ b/modules/net/dap_chain_node_cli.c
@@ -106,11 +106,11 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"node handshake -net <net_name> {-addr <node_address> | -alias <node_alias>}\n"
"node connections -net <net_name>\n"
"node balancer -net <net_name>\n"
- "node dump -net <net_name> [ -addr <node_address> | -alias <node_alias>] [-full]\n\n"
+ "node dump [ -net <net_name> | -addr <node_address> ]\n\n"
+ "node list -net <net_name> [ -addr <node_address> | -alias <node_alias>] [-full]\n\n"
"node ban -net <net_name> -chain <chain_name> -certs <certs_name> [ -addr <node_address> | -ip <ip v4 or v6 address> ]\n"
"node unban -net <net_name> -chain <chain_name> -certs <certs_name> [ -addr <node_address> | -ip <ip v4 or v6 address> ]\n"
- "node banlist\n\n"
- );
+ "node banlist\n\n");
#ifndef DAP_OS_ANDROID
dap_cli_server_cmd_add ("ping", com_ping, "Send ICMP ECHO_REQUEST to network hosts",
"ping [-c <count>] host\n");
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index c0faca96be5c64b81e846e1f4cba411dabdb30e5..34afd32460d8fa7f1b50381b906a1fc886ad8fdb 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -166,7 +166,6 @@ static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net,
dap_chain_node_info_t* l_res = dap_chain_node_info_read(a_net, a_address);
if (!l_res)
dap_cli_server_cmd_set_reply_text(a_str_reply, "Node record is corrupted or doesn't exist");
-
return l_res;
}
@@ -184,7 +183,7 @@ static int node_info_save_and_reply(dap_chain_net_t * a_net, dap_chain_node_info
{
return !a_node_info || !a_node_info->address.uint64
? dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid node address"), -1
- : dap_global_db_set_sync(a_net->pub.gdb_nodes, dap_chain_node_addr_to_str_static(&a_node_info->address),
+ : dap_global_db_set_sync(a_net->pub.gdb_nodes, dap_stream_node_addr_to_str_static(a_node_info->address),
(uint8_t*)a_node_info, dap_chain_node_info_get_size(a_node_info), false);
}
@@ -233,7 +232,7 @@ static int node_info_add_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
}
/**
- * @brief node_info_dump_with_reply Handler of command 'node dump'
+ * @brief s_node_info_list_with_reply Handler of command 'node dump'
* @param a_net
* @param a_addr
* @param a_is_full
@@ -241,11 +240,11 @@ static int node_info_add_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
* @param a_str_reply
* @return int 0 Ok, -1 error
*/
-static int node_info_dump_with_reply(dap_chain_net_t * a_net, dap_chain_node_addr_t * a_addr, bool a_is_full,
+static int s_node_info_list_with_reply(dap_chain_net_t *a_net, dap_chain_node_addr_t * a_addr, bool a_is_full,
const char *a_alias, void **a_str_reply)
{
int l_ret = 0;
- dap_string_t *l_string_reply = dap_string_new("Node dump:\n");
+ dap_string_t *l_string_reply = dap_string_new("Node list:\n");
if ((a_addr && a_addr->uint64) || a_alias) {
dap_chain_node_addr_t *l_addr = a_alias
@@ -631,7 +630,7 @@ int com_global_db(int a_argc, char ** a_argv, void **a_str_reply)
dap_get_data_hash_str_static(l_value, l_value_len, l_hash_str);
char *l_value_str = DAP_NEW_Z_SIZE(char, l_value_len * 2 + 2);
if(!l_value_str) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_value);
return -1;
}
@@ -938,7 +937,7 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
dap_chain_net_t *l_net = NULL;
if(dap_chain_node_cli_cmd_values_parse_net_chain(&arg_index, a_argc, a_argv, a_str_reply, NULL, &l_net) < 0) {
- if (cmd_num != CMD_BANLIST && cmd_num != CMD_CONNECTIONS)
+ if (cmd_num != CMD_BANLIST && cmd_num != CMD_CONNECTIONS && cmd_num != CMD_DUMP)
return -11;
}
@@ -956,7 +955,7 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
? sizeof(dap_chain_node_info_t) + dap_strlen(l_hostname) + 1
: sizeof(dap_chain_node_info_t);
dap_chain_node_info_t *l_node_info = DAP_NEW_STACK_SIZE(dap_chain_node_info_t, l_info_size);
-
+ memset(l_node_info, 0, l_info_size);;
//TODO need to rework with new node info / alias /links concept
if (l_addr_str) {
@@ -1042,11 +1041,16 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
}
}
- case CMD_LIST:
- case CMD_DUMP: {
+ case CMD_LIST:{
// handler of command 'node dump'
bool l_is_full = dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-full", NULL);
- return node_info_dump_with_reply(l_net, &l_node_addr, l_is_full, alias_str, a_str_reply);
+ return s_node_info_list_with_reply(l_net, &l_node_addr, l_is_full, alias_str, a_str_reply);
+ }
+ case CMD_DUMP: {
+ dap_string_t *l_string_reply = dap_chain_node_states_info_read(l_net, l_node_info->address);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_string_reply->str);
+ dap_string_free(l_string_reply, true);
+ return 0;
}
// add alias
case CMD_ALIAS:
@@ -1455,20 +1459,9 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
case CMD_BALANCER: {
//balancer link list
- dap_chain_net_links_t *l_links_info_list = dap_chain_net_balancer_get_node(l_net->pub.name, 0);
- dap_string_t *l_links_str = dap_string_new(l_links_info_list ? "" : "Empty");
- uint64_t l_node_num = l_links_info_list ? l_links_info_list->count_node : 0;
- for (uint64_t i = 0; i < l_node_num; ++i) {
- dap_link_info_t *l_link_info = (dap_link_info_t *)l_links_info_list->nodes_info + i;
- dap_string_append_printf(l_links_str, NODE_ADDR_FP_STR" %-20s\n",
- NODE_ADDR_FP_ARGS_S(l_link_info->node_addr),
- l_link_info->uplink_addr);
- /*l_node_link->info.links_number);*/
- }
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Balancer link list for total %" DAP_UINT64_FORMAT_U " records:\n %s \n",
- l_node_num, l_links_str->str);
+ dap_string_t *l_links_str = dap_chain_net_balancer_get_node_str(l_net);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_links_str->str);
dap_string_free(l_links_str, true);
- DAP_DEL_Z(l_links_info_list);
} break;
default:
@@ -2182,7 +2175,7 @@ int l_arg_index = 1, l_rc, cmd_num = CMD_NONE;
l_seed_size = (l_restore_str_size - 2) / 2;
l_seed = DAP_NEW_Z_SIZE(uint8_t, l_seed_size);
if(!l_seed) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
json_object_put(json_arr_out);
return DAP_CHAIN_NODE_CLI_COM_TX_WALLET_MEMORY_ERR;
}
@@ -4157,7 +4150,7 @@ static int s_parse_additional_token_decl_arg(int a_argc, char ** a_argv, void **
size_t l_tsd_offset = 0;
a_params->ext.parsed_tsd = DAP_NEW_SIZE(byte_t, l_tsd_total_size);
if(l_tsd_total_size && !a_params->ext.parsed_tsd) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
for (dap_list_t *l_iter = dap_list_first(l_tsd_list); l_iter; l_iter = l_iter->next) {
@@ -4290,7 +4283,7 @@ int com_token_decl(int a_argc, char ** a_argv, void **a_str_reply)
dap_sdk_cli_params* l_params = DAP_NEW_Z(dap_sdk_cli_params);
if (!l_params) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
@@ -4401,7 +4394,7 @@ int com_token_decl(int a_argc, char ** a_argv, void **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_tsd_total_size);
if (!l_datum_token) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory in com_token_decl");
DAP_DEL_Z(l_params);
return -1;
@@ -4492,7 +4485,7 @@ int com_token_decl(int a_argc, char ** a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_cli_server_cmd_set_reply_text(a_str_reply, "Out of memory in com_token_decl");
DAP_DEL_Z(l_params);
return -1;
@@ -4623,7 +4616,7 @@ int com_token_update(int a_argc, char ** a_argv, void **a_str_reply)
dap_sdk_cli_params* l_params = DAP_NEW_Z(dap_sdk_cli_params);
if (!l_params) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
@@ -4661,7 +4654,7 @@ int com_token_update(int a_argc, char ** a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_datum_token->version = 2;
@@ -4698,7 +4691,7 @@ int com_token_update(int a_argc, char ** a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_datum_token->version = 2;
@@ -5808,7 +5801,7 @@ int com_chain_ca_pub( int a_argc, char ** a_argv, void **a_str_reply)
l_cert_new->enc_key->pub_key_data_size =
l_cert->enc_key->pub_key_data_size );
if(!l_cert_new->enc_key->pub_key_data) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_cert_new->enc_key);
DAP_DELETE(l_cert_new);
return -11;
@@ -7404,7 +7397,7 @@ int cmd_gdb_export(int a_argc, char **a_argv, void **a_str_reply)
char *l_value_enc_str = DAP_NEW_Z_SIZE(char, l_out_size);
char *l_sign_str = DAP_NEW_Z_SIZE(char, l_sign_size);
if(!l_value_enc_str) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
dap_enc_base64_encode(l_store_obj[i].value, l_store_obj[i].value_len, l_value_enc_str, DAP_ENC_DATA_TYPE_B64);
@@ -7495,7 +7488,7 @@ int cmd_gdb_import(int a_argc, char **a_argv, void **a_str_reply)
size_t l_records_count = json_object_array_length(l_json_records);
dap_store_obj_t *l_group_store = DAP_NEW_Z_SIZE(dap_store_obj_t, l_records_count * sizeof(dap_store_obj_t));
if(!l_group_store) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
for (size_t j = 0; j < l_records_count; ++j) {
@@ -7517,7 +7510,7 @@ int cmd_gdb_import(int a_argc, char **a_argv, void **a_str_reply)
const char *l_value_str = json_object_get_string(l_value);
char *l_val = DAP_NEW_Z_SIZE(char, l_group_store[j].value_len);
if(!l_val) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
l_records_count = j;
break;
}
@@ -7620,7 +7613,7 @@ int cmd_remove(int a_argc, char **a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free(l_net_returns);
return -1;
}
@@ -8190,7 +8183,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
size_t l_counter = 0;
@@ -8206,7 +8199,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
}
@@ -8229,7 +8222,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_buf);
return NULL;
}
@@ -8248,7 +8241,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 d4a9b1ab4a87b876668d5f90acac870a0ed0ea9f..f523b12f3c8e87fe6cec37cc6ae855a076b2bbd9 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -255,7 +255,7 @@ static void s_tx_header_print(json_object* json_obj_datum, dap_chain_tx_hash_pro
else {
l_tx_data = DAP_NEW_Z(dap_chain_tx_hash_processed_ht_t);
if (!l_tx_data) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_tx_data->hash = *a_tx_hash;
@@ -299,7 +299,7 @@ json_object* dap_db_history_addr(dap_chain_addr_t *a_addr, dap_chain_t *a_chain,
{
json_object* json_obj_datum = json_object_new_array();
if (!json_obj_datum){
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_json_rpc_error_add(-44, "Memory allocation error");
return NULL;
}
@@ -651,7 +651,7 @@ json_object *dap_db_history_tx_all(dap_chain_t *l_chain, dap_chain_net_t *l_net,
bool accepted_tx;
json_object* json_obj_datum = dap_db_tx_history_to_json(&l_ttx_hash, NULL, l_tx, l_chain, l_hash_out_type, l_net, 0, &accepted_tx, out_brief);
if (!json_obj_datum) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
if (accepted_tx)
@@ -693,7 +693,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
*a_token_num = 0;
@@ -781,7 +781,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
// list all transactions
@@ -867,7 +867,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_sht->hash = l_tx_hash;
@@ -1484,7 +1484,7 @@ int cmd_decree(int a_argc, char **a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return -1;
}
@@ -1498,7 +1498,7 @@ int cmd_decree(int a_argc, char **a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return -1;
}
@@ -1555,7 +1555,7 @@ int cmd_decree(int a_argc, char **a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 37cf0099a0ad2a93b02269f166b644ea1bcb522c..7b133067b03c0996dd184d4630981a6f2acf0659 100644
--- a/modules/net/dap_chain_node_client.c
+++ b/modules/net/dap_chain_node_client.c
@@ -268,7 +268,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
diff --git a/modules/net/dap_chain_node_dns_client.c b/modules/net/dap_chain_node_dns_client.c
index e0f4f715d8ff547b30518db46754ef873e2b1aff..fdf0d57a4fb35f2b7b28c344764b4f047da1a303 100644
--- a/modules/net/dap_chain_node_dns_client.c
+++ b/modules/net/dap_chain_node_dns_client.c
@@ -178,7 +178,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
*l_es_uuid_ptr = a_esocket->uuid;
diff --git a/modules/net/dap_chain_node_ping.c b/modules/net/dap_chain_node_ping.c
index 3028f314b40a99e131675315ff120486ea9750ab..26b070500ee3bfec9fdcdd246086cfdad972425e 100644
--- a/modules/net/dap_chain_node_ping.c
+++ b/modules/net/dap_chain_node_ping.c
@@ -93,7 +93,7 @@ static void* node_ping_proc(void *a_arg)
/*char *host4 = DAP_NEW_SIZE(char, INET_ADDRSTRLEN);
if (!host4) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
struct sockaddr_in sa4 = { .sin_family = AF_INET, .sin_addr = l_addr };
@@ -166,7 +166,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
memcpy(l_data, &a_count, sizeof(int));
@@ -280,7 +280,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_node_list0, NULL);
DAP_DEL_Z(s_node_addr_ping);
DAP_DELETE(a_arg);
@@ -293,7 +293,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_node_list0, NULL);
DAP_DEL_Z(s_node_addr_ping);
DAP_DELETE(a_arg);
@@ -323,7 +323,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_node_list, NULL);
return -1;
}
@@ -336,7 +336,7 @@ int dap_chain_node_ping_background_start(dap_chain_net_t *a_net, dap_list_t *a_n
// uint8_t *l_arg = DAP_NEW_SIZE(uint8_t, sizeof(dap_chain_net_t*) + sizeof(dap_list_t*));
if (!l_arg) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_node_list, NULL);
return -1;
}
diff --git a/modules/net/include/dap_chain_net.h b/modules/net/include/dap_chain_net.h
index c03d1d457a7212ec403da8f90c56bd1e99d008f7..0d34cf49183a55db1178c9af242b4747a5909e98 100644
--- a/modules/net/include/dap_chain_net.h
+++ b/modules/net/include/dap_chain_net.h
@@ -156,6 +156,7 @@ dap_global_db_cluster_t *dap_chain_net_get_mempool_cluster(dap_chain_t *a_chain)
int dap_chain_net_add_reward(dap_chain_net_t *a_net, uint256_t a_reward, uint64_t a_block_num);
uint256_t dap_chain_net_get_reward(dap_chain_net_t *a_net, uint64_t a_block_num);
+int dap_chain_net_link_add(dap_chain_net_t *a_net, dap_stream_node_addr_t *a_addr, const char *a_host, uint16_t a_port);
/**
* @brief dap_chain_net_get_gdb_group_mempool
diff --git a/modules/net/include/dap_chain_net_balancer.h b/modules/net/include/dap_chain_net_balancer.h
index 4d3a1cf651c479e2f0bcc345c1da7d0b9fab3af0..a7aa901dab156a6f97d077359f7c1fd752d11b5f 100644
--- a/modules/net/include/dap_chain_net_balancer.h
+++ b/modules/net/include/dap_chain_net_balancer.h
@@ -30,13 +30,28 @@ along with any CellFrame SDK based project. If not, see <http://www.gnu.org/lic
#define DAP_BALANCER_PROTOCOL_VERSION 2
#define DAP_BALANCER_MAX_REPLY_SIZE 2048
-typedef struct dap_chain_net_node_balancer {
+typedef struct dap_chain_net_links {
uint64_t count_node;
byte_t nodes_info[];
} DAP_ALIGN_PACKED dap_chain_net_links_t;
+typedef enum dap_balancer_type {
+ DAP_CHAIN_NET_BALANCER_TYPE_HTTP,
+ DAP_CHAIN_NET_BALANCER_TYPE_DNS
+} dap_balancer_type_t;
+
+
+DAP_STATIC_INLINE const char *dap_chain_net_balancer_type_to_str(dap_balancer_type_t a_type)
+{
+ switch (a_type) {
+ case DAP_CHAIN_NET_BALANCER_TYPE_HTTP: return "HTTP";
+ case DAP_CHAIN_NET_BALANCER_TYPE_DNS: return "DNS";
+ default: return "UNDEFINED";
+ }
+}
+
void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, void *a_arg);
-dap_link_info_t *dap_chain_net_balancer_dns_issue_link(char *a_str);
-dap_chain_net_links_t *dap_chain_net_balancer_get_node(const char *a_net_name,uint16_t a_links_need);
-void dap_chain_net_balancer_set_link_ban(dap_chain_node_info_t *a_node_info, const char *a_net_name);
-int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info,dap_chain_net_t * a_net);
+dap_link_info_t *dap_chain_net_balancer_dns_issue_link(const char *a_net_name);
+int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_chain_net_t * a_net);
+dap_string_t *dap_chain_net_balancer_get_node_str(dap_chain_net_t *a_net);
+int dap_chain_net_balancer_request(dap_chain_net_t *a_net, const char *a_host_addr, uint16_t a_host_port, int a_balancer_type);
\ No newline at end of file
diff --git a/modules/net/include/dap_chain_node.h b/modules/net/include/dap_chain_node.h
index c3ee98717989526bf9bdc00ce5d8263e944a2470..2ee68992d839a99a6e19553f689722505feafa11 100644
--- a/modules/net/include/dap_chain_node.h
+++ b/modules/net/include/dap_chain_node.h
@@ -30,6 +30,7 @@
#include "dap_chain_common.h"
#include "dap_global_db.h"
#include "dap_chain.h"
+#include "dap_client.h"
typedef struct dap_chain_net dap_chain_net_t;
@@ -56,13 +57,13 @@ typedef struct dap_chain_node_info {
uint8_t ext_host_len;
char ext_host[];
} DAP_ALIGN_PACKED dap_chain_node_info_t;
-
+// using to easy sorting and formin in balancer
typedef struct dap_chain_node_states_info {
- dap_chain_node_addr_t address;
+ dap_link_info_t link_info;
uint64_t atoms_count;
- uint32_t links_count;
- dap_chain_node_addr_t links_addrs[];
-} DAP_ALIGN_PACKED dap_chain_node_states_info_t;
+ uint32_t downlinks_count;
+ dap_nanotime_t timestamp;
+} dap_chain_node_states_info_t;
typedef dap_stream_node_addr_t dap_chain_node_addr_t;
#define dap_chain_node_addr_str_check dap_stream_node_addr_str_check
@@ -76,26 +77,6 @@ DAP_STATIC_INLINE size_t dap_chain_node_info_get_size(dap_chain_node_info_t *a_n
{
return !a_node_info ? 0 : sizeof(dap_chain_node_info_t) + a_node_info->ext_host_len + 1;
}
-
-/**
- * Compare addresses of two dap_chain_node_info_t structures
- *
- * @return True if addresses are equal, otherwise false
- */
-bool dap_chain_node_info_addr_match(dap_chain_node_info_t *node_info1, dap_chain_node_info_t *node_info2);
-
-/**
- * Compare two struct dap_chain_node_info_t
- */
-bool dap_chain_node_info_match(dap_chain_node_info_t *node_info1, dap_chain_node_info_t *node_info2);
-
-/**
- * Serialize dap_chain_node_info_t
- * size[out] - length of output string
- * return data or NULL if error
- */
-//uint8_t* dap_chain_node_info_serialize(dap_chain_node_info_t *node_info, size_t *size);
-
dap_chain_node_addr_t * dap_chain_node_alias_find(dap_chain_net_t * l_net,const char *alias);
bool dap_chain_node_alias_register(dap_chain_net_t *a_net, const char *a_alias, dap_chain_node_addr_t *a_addr);
bool dap_chain_node_alias_delete(dap_chain_net_t * l_net,const char *alias);
@@ -104,15 +85,11 @@ int dap_chain_node_info_save(dap_chain_net_t * l_net,dap_chain_node_info_t *node
int dap_chain_node_info_del(dap_chain_net_t * l_net,dap_chain_node_info_t *node_info);
dap_chain_node_info_t* dap_chain_node_info_read(dap_chain_net_t *l_net, dap_chain_node_addr_t *address);
-inline static char *dap_chain_node_addr_to_str_static(dap_chain_node_addr_t *a_address)
-{
- static _Thread_local char s_buf[23] = { '\0' };
- dap_snprintf(s_buf, sizeof(s_buf), NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS(a_address));
- return s_buf;
-}
-
+int dap_chain_node_init();
bool dap_chain_node_mempool_need_process(dap_chain_t *a_chain, dap_chain_datum_t *a_datum);
bool dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, const char *a_datum_hash_str);
void dap_chain_node_mempool_process_all(dap_chain_t *a_chain, bool a_force);
bool dap_chain_node_mempool_autoproc_init();
-inline static void dap_chain_node_mempool_autoproc_deinit() {}
\ No newline at end of file
+inline static void dap_chain_node_mempool_autoproc_deinit() {}
+dap_list_t *dap_chain_node_get_states_list_sort(dap_chain_net_t *a_net, dap_chain_node_addr_t *a_ignored, size_t a_ignored_count);
+dap_string_t *dap_chain_node_states_info_read(dap_chain_net_t *a_net, dap_stream_node_addr_t a_addr);
\ No newline at end of file
diff --git a/modules/net/include/dap_chain_node_dns_server.h b/modules/net/include/dap_chain_node_dns_server.h
index 3b9d37c2a62374744d6df0ceeb08ee95e565374a..4b8d02b3e596b8823dfea50022844e9f7355778f 100644
--- a/modules/net/include/dap_chain_node_dns_server.h
+++ b/modules/net/include/dap_chain_node_dns_server.h
@@ -102,7 +102,7 @@ typedef union _dap_dns_message_flags_t {
int val;
} dap_dns_message_flags_t;
-typedef dap_link_info_t *(*dap_dns_zone_callback_t) (char *hostname); // Callback for DNS zone operations
+typedef dap_link_info_t *(*dap_dns_zone_callback_t) (const char *hostname); // Callback for DNS zone operations
typedef struct _dap_dns_zone_hash_t {
char *zone;
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 6ef4cde5fd3c5c942aa923de663248b5f1d63d46..e471eed038271665317e49aa2a10f3590fe570b6 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -875,7 +875,7 @@ dap_chain_net_srv_price_t * dap_chain_net_srv_get_price_from_order(dap_chain_net
dap_chain_net_srv_price_t *l_price = DAP_NEW_Z(dap_chain_net_srv_price_t);
if (!l_price) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_order);
return NULL;
}
@@ -995,7 +995,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_mutex_unlock(&s_srv_list_mutex);
return NULL;
}
@@ -1005,7 +1005,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 ebb24d40199f8a0c1858e1830c29acd644831c69..de1bc0e0f5123cddf66a756dc384d2b892bb1942 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
if (a_callbacks)
diff --git a/modules/net/srv/dap_chain_net_srv_geoip.c b/modules/net/srv/dap_chain_net_srv_geoip.c
index cf1ff5b468aedaae4010f2641a17748f41224d0e..a5ac230d49216f96603ffb32507a9ffcf6443ca6 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 c1a954203a269d81271f21cb03367cdf621207ea..bd072bd1cac5dfbeea1589ddade6bbf2dc77b077 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -161,7 +161,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
memcpy(*a_region, a_order_static->ext_n_sign + 1 + sizeof(uint8_t), l_size);
@@ -296,7 +296,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
memcpy(l_order->ext_n_sign, a_ext, a_ext_size);
@@ -305,7 +305,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
dap_chain_net_srv_order_set_continent_region(&l_order, a_continent_num, a_region);
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 ddf96cb51d2fd8e6b1275a77652a1d9d40ef7260..f471895fb588d4258e00b34ec78164a58b12b0c0 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 202795189ebb30ba7bffc6f03ef98e155f5e5301..03ee829d857c7ecc8cc76b85dca9f27350580f2b 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 00a8f1eec0cf188133bda08c6b1c2097089ff901..71d25c97a5509418c7a47eec4e31fbe12e4671fc 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
@@ -105,7 +105,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
s_srv_stake->delegate_allowed_min = dap_chain_coins_to_balance("1.0");
@@ -462,7 +462,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -3;
}
l_cache->signing_addr = l_cache_data->signing_addr;
@@ -685,7 +685,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH;
@@ -696,7 +696,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -708,7 +708,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -720,7 +720,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -731,7 +731,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -772,7 +772,7 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
size_t l_sign_size = dap_sign_get_size(l_sign);
l_decree = DAP_REALLOC(l_decree, sizeof(dap_chain_datum_decree_t) + l_cur_sign_offset + l_sign_size);
if (!l_decree) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_sign);
return NULL;
}
@@ -948,7 +948,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR;
@@ -958,7 +958,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -1000,7 +1000,7 @@ static dap_chain_datum_decree_t *s_stake_decree_invalidate(dap_chain_net_t *a_ne
size_t l_sign_size = dap_sign_get_size(l_sign);
l_decree = DAP_REALLOC(l_decree, sizeof(dap_chain_datum_decree_t) + l_cur_sign_offset + l_sign_size);
if (!l_decree) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_sign);
return NULL;
}
@@ -1029,7 +1029,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE;
@@ -1039,7 +1039,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_list_free_full(l_tsd_list, NULL);
return NULL;
}
@@ -1081,7 +1081,7 @@ static dap_chain_datum_decree_t *s_stake_decree_set_min_stake(dap_chain_net_t *a
size_t l_sign_size = dap_sign_get_size(l_sign);
l_decree = DAP_REALLOC(l_decree, sizeof(dap_chain_datum_decree_t) + l_cur_sign_offset + l_sign_size);
if (!l_decree) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_sign);
return NULL;
}
@@ -2120,7 +2120,6 @@ int dap_chain_net_srv_stake_check_validator(dap_chain_net_t * a_net, dap_hash_fa
dap_chain_node_info_t *l_remote_node_info = NULL;
dap_ledger_t *l_ledger = dap_ledger_by_net_name(a_net->pub.name);
dap_chain_datum_tx_t *l_tx = dap_ledger_tx_find_by_hash(l_ledger, a_tx_hash);
- dap_chain_node_addr_t *l_signer_node_addr = NULL;
int l_overall_correct = false;
int l_prev_cond_idx = 0;
@@ -2129,11 +2128,10 @@ int dap_chain_net_srv_stake_check_validator(dap_chain_net_t * a_net, dap_hash_fa
if (!l_tx_out_cond) {
return -4;
}
- l_signer_node_addr = &l_tx_out_cond->subtype.srv_stake_pos_delegate.signer_node_addr;
-
// read node
l_remote_node_info = (dap_chain_node_info_t*) dap_global_db_get_sync(a_net->pub.gdb_nodes,
- dap_chain_node_addr_to_str_static(l_signer_node_addr), &l_node_info_size, NULL, NULL);
+ dap_stream_node_addr_to_str_static(l_tx_out_cond->subtype.srv_stake_pos_delegate.signer_node_addr),
+ &l_node_info_size, NULL, NULL);
if(!l_remote_node_info) {
return -6;
@@ -2492,7 +2490,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 22abf697ed0316fd2c8f728b2505822f1ee9b31f..4aaf501d40ee48a5689702f47c1af2df31493afa 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -294,7 +294,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return false;
}
l_pkt_out->header.op_code = VPN_PACKET_OP_CODE_VPN_RECV;
@@ -335,7 +335,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_pkt_out);
return false;
}
@@ -417,7 +417,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_msg);
return;
}
@@ -495,7 +495,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_msg->type = TUN_SOCKET_MSG_IP_ASSIGNED;
@@ -536,7 +536,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_msg->type = TUN_SOCKET_MSG_IP_UNASSIGNED;
@@ -585,7 +585,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_msg->type = TUN_SOCKET_MSG_ESOCKET_REASSIGNED ;
@@ -843,7 +843,7 @@ static int s_vpn_tun_init()
{
s_raw_server=DAP_NEW_Z(vpn_local_network_t);
if (!s_raw_server) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
pthread_rwlock_init(&s_raw_server->rwlock, NULL);
@@ -879,7 +879,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_srv->_internal = l_srv_vpn;
@@ -1247,7 +1247,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
dap_chain_net_srv_ch_vpn_t * l_srv_vpn = CH_VPN(a_ch);
@@ -1310,7 +1310,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_rwlock_unlock(&s_clients_rwlock);
return;
}
@@ -1475,7 +1475,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
pkt_out->header.op_code = VPN_PACKET_OP_CODE_PONG;
@@ -1503,7 +1503,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 6465c2df8ecce77852790fd244600e7511153b3e..435d68c32969fecc1582779d1356a77cd38862e7 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 d87cedde6aec87585158d4fe11402370ec391e54..6dd43ef69a132dd9478406291938bdd502ba5ac7 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client_tun.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
@@ -683,7 +683,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 9e0d51900c4f54bb0245156e825ad593dc424bc5..c43322ab6688cad2f90b2bd342d4a4439fc07471 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -139,7 +139,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_srv->_internal = s_srv_xchange;
@@ -153,7 +153,7 @@ int dap_chain_net_srv_xchange_init()
uint256_t l_fee_value = dap_chain_coins_to_balance(dap_config_get_item_str_default(g_config, "srv_xchange", "fee_value", "0.02"));
const char *l_wallet_addr = dap_config_get_item_str_default(g_config, "srv_xchange", "wallet_addr", NULL);
if(!l_wallet_addr){
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
const char *l_net_str = dap_config_get_item_str_default(g_config, "srv_xchange", "net", NULL);
@@ -359,7 +359,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
memcpy(l_ext, &a_datoshi_buy, sizeof(uint256_t));
@@ -1067,7 +1067,7 @@ dap_chain_net_srv_xchange_price_t *s_xchange_price_from_order(dap_chain_net_t *a
return NULL;
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_price->creation_date = a_order->header.ts_created;
@@ -1828,7 +1828,7 @@ dap_string_t *l_reply_str;
size_t l_tx_total;
if ( !(l_reply_str = dap_string_new("")) ) /* Prepare output string discriptor*/
- return log_it(L_CRITICAL, "Memory allocation error"), -ENOMEM;
+ return log_it(L_CRITICAL, "%s", g_error_memory_alloc), -ENOMEM;
memset(&l_tx_first_hash, 0, sizeof(dap_chain_hash_fast_t)); /* Initial hash == zero */
@@ -2621,7 +2621,7 @@ dap_chain_net_srv_xchange_create_error_t dap_chain_net_srv_xchange_create(dap_ch
// 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return XCHANGE_CREATE_ERROR_MEMORY_ALLOCATED;
}
dap_stpcpy(l_price->token_sell, a_token_sell);
diff --git a/modules/type/blocks/dap_chain_block.c b/modules/type/blocks/dap_chain_block.c
index ecd8665b904e967b11b3f92b9f3085d15772baa2..244f990165fcee593e212f771d3ffb4caf3c0303 100644
--- a/modules/type/blocks/dap_chain_block.c
+++ b/modules/type/blocks/dap_chain_block.c
@@ -403,7 +403,7 @@ dap_chain_datum_t** dap_chain_block_get_datums(const dap_chain_block_t *a_block,
dap_chain_datum_t * l_datum =(dap_chain_datum_t *) (a_block->meta_n_datum_n_sign + l_offset);
dap_chain_datum_t **l_ret = DAP_NEW_Z_SIZE(dap_chain_datum_t *, sizeof(dap_chain_datum_t *) * a_block->hdr.datum_count);
if (!l_ret) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
for(size_t n=0; n<a_block->hdr.datum_count && l_offset<(a_block_size-sizeof (a_block->hdr)) ; n++){
diff --git a/modules/type/blocks/dap_chain_block_cache.c b/modules/type/blocks/dap_chain_block_cache.c
index d17e917b0d9644bda61d5de4b136c4b4f4125587..dc1b11c3be82a2339456c17e6aa5a4900bf933c3 100644
--- a/modules/type/blocks/dap_chain_block_cache.c
+++ b/modules/type/blocks/dap_chain_block_cache.c
@@ -62,12 +62,12 @@ dap_chain_block_cache_t *dap_chain_block_cache_new(dap_hash_fast_t *a_block_hash
dap_chain_block_cache_t * l_block_cache = DAP_NEW_Z(dap_chain_block_cache_t);
if (!l_block_cache) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_block_cache->block = DAP_DUP_SIZE(a_block, a_block_size);
if (!l_block_cache->block) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_block_cache->block_size = a_block_size;
@@ -92,7 +92,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 800d11cab8eb5c1e3a443414cae17761342619a7..f7d814bd523741b178a41b401a628abe8dd1ba7c 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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ret->blocks = a_blocks;
@@ -110,7 +110,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_chunk_cache_hash->block_cache=a_block_cache;
@@ -136,7 +136,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_chunk_cache_hash->block_cache=a_block_cache;
@@ -168,7 +168,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 89702e22c17653172a77f5836b7bd6e07e6dedb0..2312100a12e27b7dc0c337eec410943b2022c5fb 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -231,7 +231,7 @@ static int s_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_c
{
dap_chain_cs_blocks_t * l_cs_blocks = DAP_NEW_Z(dap_chain_cs_blocks_t);
if (!l_cs_blocks) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
a_chain->_inheritor = l_cs_blocks;
@@ -276,7 +276,7 @@ static int s_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_c
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_cs_blocks->_pvt = l_cs_blocks_pvt;
@@ -309,7 +309,7 @@ static int s_chain_cs_blocks_new(dap_chain_t * a_chain, dap_config_t * a_chain_c
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_cs_blocks_pvt);
DAP_DELETE(l_cs_blocks);
return -10;
@@ -355,7 +355,7 @@ static char *s_blocks_decree_set_reward(dap_chain_net_t *a_net, dap_chain_t *a_c
size_t l_decree_size = sizeof(dap_chain_datum_decree_t) + l_tsd_total_size;
dap_chain_datum_decree_t *l_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, l_decree_size);
if (!l_decree) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
// Fill the header
@@ -619,7 +619,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_cli_server_cmd_set_reply_text(a_str_reply,"Out of memory in s_cli_blocks");
return -1;
}
@@ -1320,7 +1320,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return 1;
}
l_datum_index->ts_added = time(NULL);
@@ -1674,7 +1674,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_atom_iter->chain = a_chain;
@@ -1775,7 +1775,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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 5a9cc40d795ac213e7be2a8a5c9c719349e74d5e..38d40e5d6f9cd9ee9a15664c5fec1e5671dbdd92 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -189,12 +189,12 @@ static int s_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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
l_dag->_pvt = DAP_NEW_Z(dap_chain_cs_dag_pvt_t);
if (!l_dag->_pvt){
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_dag);
return -1;
}
@@ -261,7 +261,7 @@ static int s_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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_dag->_pvt);
DAP_DELETE(l_dag);
return -1;
@@ -297,7 +297,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_mutex_unlock(&l_pvt->events_mutex);
return;
}
@@ -470,13 +470,13 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
l_event_item = DAP_NEW_Z(dap_chain_cs_dag_event_item_t);
if (!l_event_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
return ATOM_REJECT;
}
l_event_item->event = DAP_DUP_SIZE(a_atom, a_atom_size);
if (!l_event_item->event) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
return ATOM_REJECT;
}
@@ -872,7 +872,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return;
}
l_event_last->ts_added = a_event_item->ts_added;
@@ -995,7 +995,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
if (a_datums_count)
@@ -1025,14 +1025,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_ret);
return NULL;
}
@@ -1075,7 +1075,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_atom_iter->chain = a_chain;
@@ -1193,7 +1193,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ret->chain = a_chain;
diff --git a/modules/type/none/dap_chain_cs_none.c b/modules/type/none/dap_chain_cs_none.c
index 3becb81be5b269413a830790106313ae4f1f3c58..fc8bdd8ccc1864888db8c43b7072f13fe4df56bd 100644
--- a/modules/type/none/dap_chain_cs_none.c
+++ b/modules/type/none/dap_chain_cs_none.c
@@ -143,12 +143,12 @@ static int s_cs_callback_new(dap_chain_t *a_chain, dap_config_t UNUSED_ARG *a_ch
{
dap_nonconsensus_t *l_nochain = DAP_NEW_Z(dap_nonconsensus_t);
if (!l_nochain) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -1;
}
dap_nonconsensus_private_t *l_nochain_priv = DAP_NEW_Z(dap_nonconsensus_private_t);
if (!l_nochain_priv) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_nochain);
return -2;
}
@@ -352,7 +352,7 @@ static dap_chain_atom_verify_res_t s_nonconsensus_callback_atom_add(dap_chain_t
dap_nonconsensus_datum_hash_item_t * l_hash_item = DAP_NEW_Z(dap_nonconsensus_datum_hash_item_t);
if (!l_hash_item) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return ATOM_REJECT;
}
size_t l_datum_size = dap_chain_datum_size(l_datum);
@@ -409,7 +409,7 @@ static dap_chain_atom_iter_t* s_nonconsensus_callback_atom_iter_create(dap_chain
{
dap_chain_atom_iter_t * l_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
if (!l_iter) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_iter->chain = a_chain;
@@ -537,7 +537,7 @@ static dap_chain_datum_t **s_nonconsensus_callback_atom_get_datum(dap_chain_atom
if (l_datum){
dap_chain_datum_t **l_datums = DAP_NEW(dap_chain_datum_t *);
if (!l_datums) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
if (a_datums_count)
@@ -554,7 +554,7 @@ static dap_chain_datum_iter_t *s_nonconsensus_callback_datum_iter_create(dap_cha
{
dap_chain_datum_iter_t *l_ret = DAP_NEW_Z(dap_chain_datum_iter_t);
if (!l_ret) {
- log_it(L_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return NULL;
}
l_ret->chain = a_chain;
diff --git a/modules/wallet/dap_chain_wallet.c b/modules/wallet/dap_chain_wallet.c
index 72c3ebf9bf3e8b5ddecd8020d2f48f9268fbd7c7..f5a4cee984d4e58f7bce437bbaf8d3fdb6160fc5 100644
--- a/modules/wallet/dap_chain_wallet.c
+++ b/modules/wallet/dap_chain_wallet.c
@@ -134,7 +134,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
return -EINVAL;
}
*l_prec = l_rec; /* Fill it by data */
@@ -829,7 +829,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
dap_fileclose(l_fh);
return NULL;
}
@@ -837,7 +837,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_wallet);
dap_fileclose(l_fh);
return NULL;
@@ -858,7 +858,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_CRITICAL, "Memory allocation error");
+ log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DEL_Z(l_wallet);
dap_fileclose(l_fh);
return NULL;