Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • cellframe/cellframe-sdk
  • MIKA83/cellframe-sdk
2 results
Show changes
Commits on Source (30)
Hide whitespace changes
Inline Side-by-side
Showing
with 373 additions and 544 deletions
cellframe-sdk.pro
View file @ 8209034a
......@@ -9,24 +9,24 @@ linux: !android {
win32 {
CONFIG(release, debug | release): sdk_build.commands = "$$shell_path($$PWD/../cellframe-sdk/prod_build/build.sh)" --target windows release -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/
CONFIG(debug, debug | release): sdk_build.commands = "$$shell_path($$PWD/../cellframe-sdk/prod_build/build.sh)" --target windows rwd -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/
CONFIG(release, debug | release): sdk_build.commands = "$$shell_path($$PWD/../cellframe-sdk/prod_build/build.sh)" --target windows release -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCELLFRAME_NO_OPTIMIZATION=1
CONFIG(debug, debug | release): sdk_build.commands = "$$shell_path($$PWD/../cellframe-sdk/prod_build/build.sh)" --target windows rwd -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCELLFRAME_NO_OPTIMIZATION=1
}
android {
for (AABI, ANDROID_ABIS) {
message("Requested ABI: $$AABI")
CONFIG(release, debug | release): sdk_build_$${AABI}.commands += $$PWD/../cellframe-sdk/prod_build/build.sh -b $$AABI --target android release -DANDROID_PLATFORM=android-21 -DANDROID_ABI=$$AABI -DANDROID_NATIVE_API_LEVEL=29 -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON
CONFIG(debug, debug | release): sdk_build_$${AABI}.commands += $$PWD/../cellframe-sdk/prod_build/build.sh -b $$AABI --target android release -DANDROID_PLATFORM=android-21 -DANDROID_ABI=$$AABI -DANDROID_NATIVE_API_LEVEL=29 -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON
CONFIG(release, debug | release): sdk_build_$${AABI}.commands += $$PWD/../cellframe-sdk/prod_build/build.sh -b $$AABI --target android release -DANDROID_PLATFORM=android-21 -DANDROID_ABI=$$AABI -DANDROID_NATIVE_API_LEVEL=29 -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -DCELLFRAME_NO_OPTIMIZATION=1
CONFIG(debug, debug | release): sdk_build_$${AABI}.commands += $$PWD/../cellframe-sdk/prod_build/build.sh -b $$AABI --target android release -DANDROID_PLATFORM=android-21 -DANDROID_ABI=$$AABI -DANDROID_NATIVE_API_LEVEL=29 -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -DCELLFRAME_NO_OPTIMIZATION=1
}
}
mac {
CONFIG(release, debug | release): sdk_build.commands = $$PWD/../cellframe-sdk/prod_build/build.sh --target osx release -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/
CONFIG(debug, debug | release): sdk_build.commands = $$PWD/../cellframe-sdk/prod_build/build.sh --target osx rwd -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/
CONFIG(release, debug | release): sdk_build.commands = $$PWD/../cellframe-sdk/prod_build/build.sh --target osx release -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCELLFRAME_NO_OPTIMIZATION=1
CONFIG(debug, debug | release): sdk_build.commands = $$PWD/../cellframe-sdk/prod_build/build.sh --target osx rwd -DINSTALL_SDK=1 -DCMAKE_INSTALL_PREFIX=/ -DCELLFRAME_NO_OPTIMIZATION=1
}
......
dap-sdk @ f2b762fc
Compare 9e7565c9...f2b762fc
Subproject commit 9e7565c9417bad979e90b83ccd537aecfe7c07f9
Subproject commit f2b762fcfbf3d799029d9a52963b09fefd9e711b
modules/chain/dap_chain.c
View file @ 8209034a
......@@ -697,7 +697,7 @@ void dap_chain_info_dump_log(dap_chain_t * a_chain)
* @param a_callback
* @param a_arg
*/
void dap_chain_add_callback_notify(dap_chain_t * a_chain, dap_chain_callback_notify_t a_callback, void * a_callback_arg)
void dap_chain_add_callback_notify(dap_chain_t *a_chain, dap_chain_callback_notify_t a_callback, dap_proc_thread_t *a_thread, void *a_callback_arg)
{
if(!a_chain){
log_it(L_ERROR, "NULL chain passed to dap_chain_add_callback_notify()");
......@@ -714,6 +714,7 @@ void dap_chain_add_callback_notify(dap_chain_t * a_chain, dap_chain_callback_not
}
l_notifier->callback = a_callback;
l_notifier->proc_thread = a_thread;
l_notifier->arg = a_callback_arg;
pthread_rwlock_wrlock(&a_chain->rwlock);
a_chain->atom_notifiers = dap_list_append(a_chain->atom_notifiers, l_notifier);
......@@ -845,7 +846,7 @@ void dap_chain_atom_notify(dap_chain_cell_t *a_chain_cell, dap_hash_fast_t *a_ha
.hash = *a_hash,
.atom = a_chain_cell->chain->is_mapped ? (byte_t*)a_atom : DAP_DUP_SIZE(a_atom, a_atom_size),
.atom_size = a_atom_size };
dap_proc_thread_callback_add_pri(NULL, s_notify_atom_on_thread, l_arg, DAP_QUEUE_MSG_PRIORITY_LOW);
dap_proc_thread_callback_add_pri(l_notifier->proc_thread, s_notify_atom_on_thread, l_arg, DAP_QUEUE_MSG_PRIORITY_LOW);
}
}
......
modules/chain/dap_chain_ch.c
View file @ 8209034a
......@@ -619,17 +619,16 @@ static bool s_sync_in_chains_callback(void *a_arg)
return false;
}
char *l_atom_hash_str = NULL;
l_atom_hash_str = DAP_NEW_STACK_SIZE(char, DAP_CHAIN_HASH_FAST_STR_SIZE);
dap_hash_fast_t l_atom_hash = {};
dap_hash_fast_t l_atom_hash = { };
dap_hash_fast(l_atom, l_atom_size, &l_atom_hash);
if (s_debug_more)
dap_get_data_hash_str_static(l_atom, l_atom_size, l_atom_hash_str);
l_atom_hash_str = dap_hash_fast_to_str_static(&l_atom_hash);
dap_chain_atom_verify_res_t l_atom_add_res = l_chain->callback_atom_add(l_chain, l_atom, l_atom_size, &l_atom_hash, false);
bool l_ack_send = false;
switch (l_atom_add_res) {
case ATOM_PASS:
debug_if(s_debug_more, L_WARNING, "Atom with hash %s for %s:%s not accepted (code ATOM_PASS, already present)",
l_atom_hash_str, l_chain->net_name, l_chain->name);
l_atom_hash_str, l_chain->net_name, l_chain->name);
l_ack_send = true;
break;
case ATOM_MOVE_TO_THRESHOLD:
......@@ -776,12 +775,9 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
l_args->addr = a_ch->stream->node;
l_args->ack_req = true;
memcpy(l_args->data, l_chain_pkt, l_ch_pkt->hdr.data_size);
if (s_debug_more) {
char *l_atom_hash_str;
dap_get_data_hash_str_static(l_chain_pkt->data, l_chain_pkt_data_size, l_atom_hash_str);
log_it(L_INFO, "In: CHAIN pkt: atom hash %s, size %zd, net id %" DAP_UINT64_FORMAT_U ", chain id %" DAP_UINT64_FORMAT_U,
l_atom_hash_str, l_chain_pkt_data_size, l_chain_pkt->hdr.net_id.uint64, l_chain_pkt->hdr.chain_id.uint64);
}
debug_if(s_debug_more, L_INFO, "In: CHAIN pkt: atom hash %s, size %zd, net id %" DAP_UINT64_FORMAT_U ", chain id %" DAP_UINT64_FORMAT_U,
dap_get_data_hash_str(l_chain_pkt->data, l_chain_pkt_data_size).s, l_chain_pkt_data_size,
l_chain_pkt->hdr.net_id.uint64, l_chain_pkt->hdr.chain_id.uint64);
dap_proc_thread_callback_add(a_ch->stream_worker->worker->proc_queue_input, s_sync_in_chains_callback, l_args);
} break;
......@@ -877,7 +873,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
if (l_missed_hash) {
l_chain->callback_atom_iter_get(l_iter, DAP_CHAIN_ITER_OP_LAST, NULL);
dap_chain_ch_miss_info_t l_miss_info = { .missed_hash = l_request->hash_from,
.last_hash = *l_iter->cur_hash,
.last_hash = l_iter->cur_hash ? *l_iter->cur_hash : (dap_hash_fast_t){ },
.last_num = l_iter->cur_num };
dap_chain_ch_pkt_write_unsafe(a_ch, DAP_CHAIN_CH_PKT_TYPE_CHAIN_MISS,
l_chain_pkt->hdr.net_id, l_chain_pkt->hdr.chain_id,
......@@ -1498,11 +1494,8 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
}
l_chain_pkt->hdr.data_size = l_chain_pkt_data_size;
memcpy(l_args->data, l_chain_pkt, l_ch_pkt->hdr.data_size);
if (s_debug_legacy) {
char *l_atom_hash_str;
dap_get_data_hash_str_static(l_chain_pkt->data, l_chain_pkt_data_size, l_atom_hash_str);
log_it(L_INFO, "In: CHAIN_OLD pkt: atom hash %s (size %zd)", l_atom_hash_str, l_chain_pkt_data_size);
}
debug_if(s_debug_legacy, L_INFO, "In: CHAIN_OLD pkt: atom hash %s (size %zd)",
dap_get_data_hash_str(l_chain_pkt->data, l_chain_pkt_data_size).s, l_chain_pkt_data_size);
dap_proc_thread_callback_add(a_ch->stream_worker->worker->proc_queue_input, s_sync_in_chains_callback, l_args);
} break;
......
modules/chain/include/dap_chain.h
View file @ 8209034a
......@@ -231,8 +231,11 @@ typedef struct dap_chain {
void * _inheritor; // inheritor object
} dap_chain_t;
typedef struct dap_proc_thread dap_proc_thread_t;
typedef struct dap_chain_atom_notifier {
dap_chain_callback_notify_t callback;
dap_proc_thread_t *proc_thread;
void *arg;
} dap_chain_atom_notifier_t;
......@@ -274,7 +277,7 @@ dap_chain_t * dap_chain_find_by_id(dap_chain_net_id_t a_chain_net_id,dap_chain_i
dap_chain_t *dap_chain_load_from_cfg(const char *a_chain_net_name, dap_chain_net_id_t a_chain_net_id, const char *a_chain_cfg_name);
void dap_chain_delete(dap_chain_t * a_chain);
void dap_chain_add_callback_notify(dap_chain_t * a_chain, dap_chain_callback_notify_t a_callback, void * a_arg);
void dap_chain_add_callback_notify(dap_chain_t *a_chain, dap_chain_callback_notify_t a_callback, dap_proc_thread_t *a_thread, void *a_arg);
void dap_chain_atom_notify(dap_chain_cell_t *a_chain_cell, dap_hash_fast_t *a_hash, const uint8_t *a_atom, size_t a_atom_size);
void dap_chain_atom_add_from_threshold(dap_chain_t *a_chain);
dap_chain_atom_ptr_t dap_chain_get_atom_by_hash(dap_chain_t * a_chain, dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size);
......
modules/chain/tests/dap_chain_ledger_tests.c
View file @ 8209034a
......@@ -351,7 +351,7 @@ int dap_ledger_test_create_reward_decree(dap_chain_t *a_chain, dap_chain_net_id_
dap_hash_fast_t l_decree_hash = {};
dap_hash_fast(l_decree, l_decree_size, &l_decree_hash);
// a_chain->callback_atom_add();
dap_assert_PIF(dap_chain_net_decree_apply(&l_decree_hash, l_decree, a_chain)==0, "Decree applying:");
dap_assert_PIF(dap_chain_net_decree_apply(&l_decree_hash, l_decree, a_chain, false)==0, "Decree applying:");
return 0;
}
......
modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
View file @ 8209034a
......@@ -1124,7 +1124,6 @@ static bool s_grace_period_finish(dap_chain_net_srv_grace_usage_t *a_grace_item)
}
// make receipt or tx
char *l_receipt_hash_str;
dap_chain_datum_tx_receipt_t *l_receipt = NULL;
if (l_grace->usage->receipt_next){
l_receipt = l_grace->usage->receipt_next;
......@@ -1158,8 +1157,7 @@ static bool s_grace_period_finish(dap_chain_net_srv_grace_usage_t *a_grace_item)
log_it(L_WARNING, "Tx already in chain, but receipt is not signed by client. Finish grace and wait receipt sign responce.");
RET_WITH_DEL_A_GRACE(DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_RECEIPT_NO_SIGN);
}
dap_get_data_hash_str_static(l_receipt, l_receipt_size, l_receipt_hash_str);
dap_global_db_set(SRV_RECEIPTS_GDB_GROUP, l_receipt_hash_str, l_receipt, l_receipt_size, false, NULL, NULL);
dap_global_db_set(SRV_RECEIPTS_GDB_GROUP, dap_get_data_hash_str(l_receipt, l_receipt_size).s, l_receipt, l_receipt_size, false, NULL, NULL);
// Form input transaction
char *l_hash_str = dap_hash_fast_to_str_new(&l_grace->usage->tx_cond_hash);
log_it(L_NOTICE, "Trying create input tx cond from tx %s with active receipt", l_hash_str);
......@@ -1447,9 +1445,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void *a_arg)
}
// Store receipt if any problems with transactions
char *l_receipt_hash_str;
dap_get_data_hash_str_static(l_receipt, l_receipt_size, l_receipt_hash_str);
dap_global_db_set(SRV_RECEIPTS_GDB_GROUP, l_receipt_hash_str, l_receipt, l_receipt_size, false, NULL, NULL);
dap_global_db_set(SRV_RECEIPTS_GDB_GROUP, dap_get_data_hash_str(l_receipt, l_receipt_size).s, l_receipt, l_receipt_size, false, NULL, NULL);
size_t l_success_size;
if (!l_usage->is_grace) {
// Form input transaction
......
modules/channel/chain-net/dap_stream_ch_chain_net.c
View file @ 8209034a
......@@ -113,17 +113,12 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void* a_arg)
dap_stream_ch_chain_net_t * l_ch_chain_net = DAP_STREAM_CH_CHAIN_NET(a_ch);
if(l_ch_chain_net) {
dap_stream_ch_pkt_t *l_ch_pkt = (dap_stream_ch_pkt_t *)a_arg;
if (l_ch_pkt->hdr.type == DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_TEST) {
char *l_data_hash_str;
dap_get_data_hash_str_static(l_ch_pkt->data, l_ch_pkt->hdr.data_size, l_data_hash_str);
log_it(L_ATT, "Receive test data packet with hash %s", l_data_hash_str);
return false;
}
if (l_ch_pkt->hdr.data_size < sizeof(dap_stream_ch_chain_net_pkt_t)) {
log_it(L_WARNING, "Too small stream channel N packet size %u (header size %zu)",
l_ch_pkt->hdr.data_size, sizeof(dap_stream_ch_chain_net_pkt_t));
return false;
}
if (l_ch_pkt->hdr.type == DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_TEST)
return log_it(L_ATT, "Receive test data packet with hash %s",
dap_get_data_hash_str(l_ch_pkt->data, l_ch_pkt->hdr.data_size).s), false;
if (l_ch_pkt->hdr.data_size < sizeof(dap_stream_ch_chain_net_pkt_t))
return log_it(L_WARNING, "Too small stream channel N packet size %u (header size %zu)",
l_ch_pkt->hdr.data_size, sizeof(dap_stream_ch_chain_net_pkt_t)), false;
dap_stream_ch_chain_net_pkt_t *l_ch_chain_net_pkt = (dap_stream_ch_chain_net_pkt_t *)l_ch_pkt->data;
if ((uint32_t)l_ch_chain_net_pkt->hdr.data_size + sizeof(dap_stream_ch_chain_net_pkt_t) > l_ch_pkt->hdr.data_size) {
log_it(L_WARNING, "Too small stream channel N packet size %u (expected at least %zu)",
......
modules/common/dap_chain_datum_decree.c
View file @ 8209034a
......@@ -200,9 +200,7 @@ void dap_chain_datum_decree_dump_json(json_object *a_json_out, dap_chain_datum_d
}
dap_pkey_t *l_owner_pkey = /*DAP_NEW_STACK_SIZE(dap_pkey_t, l_tsd->size);
memcpy(l_owner_pkey, l_tsd->data, l_tsd->size);*/ _dap_tsd_get_object(l_tsd, dap_pkey_t);
char *l_owner_pkey_str;
dap_get_data_hash_str_static(l_owner_pkey->pkey, l_owner_pkey->header.size, l_owner_pkey_str);
json_object_object_add(a_json_out, "Owner fingerprint", json_object_new_string(l_owner_pkey_str));
json_object_object_add(a_json_out, "Owner fingerprint", json_object_new_string(dap_get_data_hash_str(l_owner_pkey->pkey, l_owner_pkey->header.size).s));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
if (l_tsd->size > sizeof(uint256_t)){
......
modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
View file @ 8209034a
......@@ -57,24 +57,20 @@ typedef struct dap_chain_cs_dag_poa_presign_callback{
void *arg;
} dap_chain_cs_dag_poa_presign_callback_t;
struct round_timer_arg {
typedef struct dap_chain_cs_dag_poa_round_item {
dap_chain_hash_fast_t datum_hash;
dap_chain_cs_dag_t *dag;
uint64_t round_id;
UT_hash_handle hh;
};
} dap_chain_cs_dag_poa_round_item_t;
typedef struct dap_chain_cs_dag_poa_pvt {
pthread_rwlock_t rounds_rwlock;
struct round_timer_arg *active_rounds;
dap_cert_t * events_sign_cert;
dap_cert_t ** auth_certs;
char * auth_certs_prefix;
uint16_t auth_certs_count;
uint16_t auth_certs_count_verify; // Number of signatures, needed for event verification
bool auto_confirmation;
bool auto_round_complete;
uint32_t confirmations_timeout; // wait signs over min value (auth_certs_count_verify)
uint32_t wait_sync_before_complete;
dap_chain_cs_dag_poa_round_item_t *event_items;
dap_cert_t *events_sign_cert, **auth_certs;
char *auth_certs_prefix;
uint16_t auth_certs_count, auth_certs_count_verify; // Number of signatures, needed for event verification
bool auto_confirmation, auto_round_complete;
uint32_t confirmations_timeout, wait_sync_before_complete;
dap_chain_cs_dag_poa_presign_callback_t *callback_pre_sign;
dap_interval_timer_t mempool_timer;
} dap_chain_cs_dag_poa_pvt_t;
......@@ -83,23 +79,21 @@ typedef struct dap_chain_cs_dag_poa_pvt {
static void s_callback_delete(dap_chain_cs_dag_t * a_dag);
static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg);
static void s_poa_round_clean(void *a_arg);
static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_cfg);
static int s_callback_event_verify(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_dag_event, dap_hash_fast_t *a_event_hash);
static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a_dag, dap_chain_datum_t * a_datum,
dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count, size_t* a_event_size);
static bool s_callback_round_event_to_chain(struct round_timer_arg *a_arg);
static bool s_callback_round_event_to_chain(dap_chain_cs_dag_poa_round_item_t *a_arg);
static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_size);
static bool s_round_event_ready_minimum_check(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_event,
size_t a_event_size, char *a_event_hash_hex_str);
static void s_round_event_cs_done(dap_chain_cs_dag_t * a_dag, uint64_t a_round_id);
static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_item);
// CLI commands
static int s_cli_dag_poa(int argc, char ** argv, void **a_str_reply);
static bool s_seed_mode = false;
static dap_interval_timer_t s_poa_round_timer = NULL;
static bool s_debug_more = false;
/**
......@@ -292,8 +286,13 @@ static int s_cli_dag_poa(int argc, char ** argv, void **a_str_reply)
l_poa_pvt->events_sign_cert->name, l_event_new_hash_base58_str);
}
ret = 0;
if (l_event_is_ready && l_poa_pvt->auto_round_complete) // cs done (minimum signs & verify passed)
s_round_event_cs_done(l_dag, l_event->header.round_id);
if (l_event_is_ready && l_poa_pvt->auto_round_complete) { // cs done (minimum signs & verify passed)
dap_chain_cs_dag_poa_round_item_t l_event_item = {
.datum_hash = l_round_item->round_info.datum_hash,
.dag = l_dag
};
s_round_event_cs_done(&l_event_item);
}
} else {
if(!dap_strcmp(l_hash_out_type, "hex")) {
dap_cli_server_cmd_set_reply_text(a_str_reply,
......@@ -396,15 +395,13 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
log_it(L_NOTICE,"Initialized DAG-PoA consensus with %u/%u minimum consensus",l_poa_pvt->auth_certs_count,l_poa_pvt->auth_certs_count_verify);
l_dag->chain->callback_created = s_callback_created;
if (!l_dag->is_add_directly && l_poa_pvt->auto_round_complete) {
dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
dap_chain_node_role_t l_role = dap_chain_net_get_role(l_net);
if (l_role.enums == NODE_ROLE_ROOT_MASTER || l_role.enums == NODE_ROLE_ROOT) {
if (!s_poa_round_timer) {
s_poa_round_timer = dap_interval_timer_create(600 * 1000, s_poa_round_clean, a_chain);
log_it(L_MSG, "DAG-PoA: Round timer is started");
}
DAP_CHAIN_PVT(a_chain)->cs_started = true;
if ( !l_dag->is_add_directly && l_poa_pvt->auto_round_complete ) {
switch ( dap_chain_net_get_role(dap_chain_net_by_id(a_chain->net_id)).enums ) {
case NODE_ROLE_ROOT_MASTER:
case NODE_ROLE_ROOT:
DAP_CHAIN_PVT(a_chain)->cs_started = true;
default:
break;
}
}
......@@ -420,69 +417,6 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
return 0;
}
/**
* @brief s_poa_round_check_callback_load_round
* @param a_global_db_context
* @param a_rc
* @param a_group
* @param a_key
* @param a_values_total
* @param a_values_shift
* @param a_values_count
* @param a_values
* @param a_arg
*/
static bool s_poa_round_check_callback_round_clean(dap_global_db_instance_t *a_dbi,
int a_rc, const char *a_group,
const size_t a_values_total, const size_t a_values_count,
dap_global_db_obj_t *a_values, void *a_arg)
{
dap_chain_cs_dag_t *l_dag = (dap_chain_cs_dag_t *)a_arg;
dap_chain_cs_dag_poa_t *l_poa = DAP_CHAIN_CS_DAG_POA(l_dag);
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
if (a_values_count) {
for (size_t i = 0; i < a_values_count; i++) {
if (!strcmp(DAG_ROUND_CURRENT_KEY, a_values[i].key))
continue;
if (a_values[i].value_len <= sizeof(dap_chain_cs_dag_event_round_item_t) + sizeof(dap_chain_cs_dag_event_t)) {
log_it(L_WARNING, "Too small round item in DAG PoA rounds GDB group");
dap_global_db_del_sync(a_group, a_values[i].key);
continue;
}
dap_chain_cs_dag_event_round_item_t *l_event_round_item = (dap_chain_cs_dag_event_round_item_t *)a_values[i].value;
uint64_t l_time_diff = dap_nanotime_now() - l_event_round_item->round_info.ts_update;
uint64_t l_timeuot = dap_nanotime_from_sec(l_poa_pvt->confirmations_timeout + l_poa_pvt->wait_sync_before_complete + 10);
uint64_t l_round_id = ((dap_chain_cs_dag_event_t *)l_event_round_item->event_n_signs)->header.round_id;
if (((int64_t)l_time_diff > 0 && l_time_diff > l_timeuot) || l_round_id <= l_dag->round_completed) {
pthread_rwlock_rdlock(&l_poa_pvt->rounds_rwlock);
struct round_timer_arg *l_arg = NULL;
HASH_FIND(hh, l_poa_pvt->active_rounds, &l_round_id, sizeof(uint64_t), l_arg);
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
if (l_arg) {
log_it(L_INFO, "Event %s is from currently active round [id %"DAP_UINT64_FORMAT_U"]", a_values[i].key, l_round_id);
continue;
}
dap_global_db_del_sync(a_group, a_values[i].key);
log_it(L_DEBUG, "DAG-PoA: Remove event %s from round %"DAP_UINT64_FORMAT_U" %s.",
a_values[i].key, l_round_id, l_time_diff > l_timeuot ? "by timer" : "owing to round completion");
}
}
}
return true;
}
/**
* @brief Timer callback for round check
* @param a_chain Chain object
* @return Always true
*/
static void s_poa_round_clean(void *a_arg)
{
dap_chain_cs_dag_t *l_dag = DAP_CHAIN_CS_DAG((dap_chain_t *)a_arg);
dap_global_db_get_all(l_dag->gdb_group_events_round_new, 0, s_poa_round_check_callback_round_clean, l_dag);
}
static bool s_round_event_ready_minimum_check(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_event,
size_t a_event_size, char * a_event_hash_hex_str)
{
......@@ -601,58 +535,78 @@ static bool s_callback_round_event_to_chain_callback_get_round_item(dap_global_d
{
if (a_rc != DAP_GLOBAL_DB_RC_SUCCESS)
return false;
struct round_timer_arg *l_arg = (struct round_timer_arg *)a_arg;
dap_chain_cs_dag_poa_round_item_t *l_arg = (dap_chain_cs_dag_poa_round_item_t*)a_arg;
dap_chain_cs_dag_t *l_dag = l_arg->dag;
uint64_t l_round_id = l_arg->round_id;
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(DAP_CHAIN_CS_DAG_POA(l_dag));
pthread_rwlock_wrlock(&l_poa_pvt->rounds_rwlock);
HASH_DEL(l_poa_pvt->active_rounds, l_arg);
HASH_DEL(l_poa_pvt->event_items, l_arg);
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
DAP_DELETE(a_arg);
uint16_t l_max_signs_count = 0;
dap_list_t *l_dups_list = NULL;
for (size_t i = 0; i < a_values_count; i++) {
size_t i, e, k;
const char *l_complete_keys[a_values_count], *l_expired_keys[a_values_count];
for (i = 0, e = 0, k = 0; i < a_values_count; i++) {
if (!strcmp(DAG_ROUND_CURRENT_KEY, a_values[i].key))
continue;
dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t *)a_values[i].value;
if (a_values[i].value_len <= sizeof(dap_chain_cs_dag_event_round_item_t) + sizeof(dap_chain_cs_dag_event_t)) {
log_it(L_WARNING, "Incorrect round item size, dump it");
dap_global_db_del_sync(a_group, a_values[i].key);
continue;
}
dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t*)a_values[i].value;
dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t *)l_round_item->event_n_signs;
if (l_event->header.round_id == l_round_id &&
l_round_item->round_info.reject_count < l_poa_pvt->auth_certs_count_verify) {
if ( dap_hash_fast_compare( &l_arg->datum_hash, &l_round_item->round_info.datum_hash )
&& l_round_item->round_info.reject_count < l_poa_pvt->auth_certs_count_verify)
{
l_dups_list = dap_list_append(l_dups_list, l_round_item);
if (l_event->header.signs_count > l_max_signs_count)
l_max_signs_count = l_event->header.signs_count;
l_complete_keys[k++] = a_values[i].key;
}
else if ( dap_nanotime_from_sec(l_poa_pvt->wait_sync_before_complete + l_poa_pvt->confirmations_timeout + 10)
< dap_nanotime_now() - l_round_item->round_info.ts_update )
{
l_expired_keys[e++] = a_values[i].key;
}
}
dap_chain_cs_dag_event_round_item_t *l_chosen_item = s_round_event_choose_dup(l_dups_list, l_max_signs_count);
dap_list_free(l_dups_list);
char l_datum_hash_str[DAP_HASH_FAST_STR_SIZE];
dap_hash_fast_to_str(&l_arg->datum_hash, l_datum_hash_str, sizeof(l_datum_hash_str));
if (l_chosen_item) {
size_t l_event_size = l_chosen_item->event_size;
dap_chain_cs_dag_event_t *l_new_atom = (dap_chain_cs_dag_event_t *)l_chosen_item->event_n_signs;
char *l_event_hash_hex_str;
dap_get_data_hash_str_static(l_new_atom, l_event_size, l_event_hash_hex_str);
dap_hash_fast_t l_atom_hash;
dap_hash_fast(l_new_atom, l_event_size, &l_atom_hash);
char l_event_hash_hex_str[DAP_HASH_FAST_STR_SIZE]; dap_hash_fast_to_str(&l_atom_hash, l_event_hash_hex_str, DAP_HASH_FAST_STR_SIZE);
dap_chain_datum_t *l_datum = dap_chain_cs_dag_event_get_datum(l_new_atom, l_event_size);
l_dag->round_completed = dap_max(l_new_atom->header.round_id, l_dag->round_current);
int l_verify_datum = dap_chain_net_verify_datum_for_add(l_dag->chain, l_datum, &l_chosen_item->round_info.datum_hash);
if (!l_verify_datum) {
dap_hash_fast_t l_atom_hash = {};
dap_hash_fast(l_new_atom, l_event_size, &l_atom_hash);
dap_chain_atom_verify_res_t l_res = l_dag->chain->callback_atom_add(l_dag->chain, l_new_atom, l_event_size, &l_atom_hash, true);
if (l_res == ATOM_ACCEPT)
s_poa_round_clean(l_dag->chain);
log_it(L_INFO, "Event %s from round %"DAP_UINT64_FORMAT_U" %s",
l_event_hash_hex_str, l_round_id, dap_chain_atom_verify_res_str[l_res]);
if (l_res == ATOM_ACCEPT) {
for (; k; --k) {
log_it(L_INFO, "Remove event %s with datum %s, round complete", l_complete_keys[k - 1], l_datum_hash_str);
dap_global_db_del_sync(a_group, l_complete_keys[k - 1]);
}
for (; e; --e) {
log_it(L_INFO, "Event %s with datum %s has expired, dump it", l_expired_keys[e - 1], l_datum_hash_str);
dap_global_db_del_sync(a_group, l_expired_keys[e - 1]);
}
}
log_it(L_INFO, "Event %s with datum %s is %s",
l_event_hash_hex_str, l_datum_hash_str, dap_chain_atom_verify_res_str[l_res]);
} else {
char l_datum_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
dap_chain_hash_fast_to_str(&l_chosen_item->round_info.datum_hash, l_datum_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
log_it(L_INFO, "Event %s from round %"DAP_UINT64_FORMAT_U" not added into chain, because the inner datum %s doesn't pass verification (%s)",
l_event_hash_hex_str, l_round_id, l_datum_hash_str, dap_chain_net_verify_datum_err_code_to_str(l_datum, l_verify_datum));
log_it(L_ERROR, "Event %s is not chained: datum %s doesn't pass verification, error \"%s\"",
l_event_hash_hex_str, l_datum_hash_str, dap_chain_net_verify_datum_err_code_to_str(l_datum, l_verify_datum));
for (; k; --k) {
log_it(L_INFO, "Remove event %s with unverified datum %s", l_complete_keys[k - 1], l_datum_hash_str);
dap_global_db_del_sync(a_group, l_complete_keys[k - 1]);
}
}
} else { /* !l_chosen_item */
l_dag->round_completed = l_dag->round_current;
log_it(L_WARNING, "No candidates for round id %"DAP_UINT64_FORMAT_U, l_round_id);
}
dap_list_free(l_dups_list);
return true;
} else /* !l_chosen_item */
log_it(L_WARNING, "No valid candidates to wrap datum %s in current round #%"DAP_UINT64_FORMAT_U"",
l_datum_hash_str, l_dag->round_id);
return DAP_DELETE(l_arg), true;
}
/**
......@@ -660,39 +614,25 @@ static bool s_callback_round_event_to_chain_callback_get_round_item(dap_global_d
* @param a_callback_arg
* @return
*/
static bool s_callback_round_event_to_chain(struct round_timer_arg *a_callback_arg)
static bool s_callback_round_event_to_chain(dap_chain_cs_dag_poa_round_item_t *a_callback_arg)
{
dap_chain_cs_dag_t *l_dag = a_callback_arg->dag;
dap_global_db_get_all(l_dag->gdb_group_events_round_new, 0, s_callback_round_event_to_chain_callback_get_round_item, a_callback_arg);
return false;
return dap_global_db_get_all(a_callback_arg->dag->gdb_group_events_round_new, 0, s_callback_round_event_to_chain_callback_get_round_item, a_callback_arg),
false;
}
static void s_round_event_cs_done(dap_chain_cs_dag_t * a_dag, uint64_t a_round_id)
static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_item)
{
dap_chain_cs_dag_poa_t *l_poa = DAP_CHAIN_CS_DAG_POA(a_dag);
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
struct round_timer_arg *l_callback_arg = NULL;
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT( DAP_CHAIN_CS_DAG_POA(a_event_item->dag) );
dap_chain_cs_dag_poa_round_item_t *l_event_item = NULL;
pthread_rwlock_wrlock(&l_poa_pvt->rounds_rwlock);
HASH_FIND(hh, l_poa_pvt->active_rounds, &a_round_id, sizeof(uint64_t), l_callback_arg);
if (!l_callback_arg) {
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, "%s", c_error_memory_alloc);
return;
}
l_callback_arg->dag = a_dag;
l_callback_arg->round_id = a_round_id;
HASH_ADD(hh, l_poa_pvt->active_rounds, round_id, sizeof(uint64_t), l_callback_arg);
// Placement into chain by confirmation timer
if (!dap_timerfd_start(PVT(l_poa)->confirmations_timeout * 1000, (dap_timerfd_callback_t)s_callback_round_event_to_chain, l_callback_arg)) {
HASH_DEL(l_poa_pvt->active_rounds, l_callback_arg);
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
DAP_DELETE(l_callback_arg);
log_it(L_ERROR,"Can't run timer for round ID %"DAP_UINT64_FORMAT_U, a_round_id);
return;
}
log_it(L_NOTICE,"Run timer for %d sec for round ID %"DAP_UINT64_FORMAT_U, PVT(l_poa)->confirmations_timeout, a_round_id);
HASH_FIND(hh, l_poa_pvt->event_items, &a_event_item->datum_hash, sizeof(dap_hash_fast_t), l_event_item);
if (!l_event_item) {
l_event_item = DAP_DUP(a_event_item);
if ( !dap_timerfd_start(l_poa_pvt->confirmations_timeout * 1000, (dap_timerfd_callback_t)s_callback_round_event_to_chain, l_event_item) )
return DAP_DELETE(l_event_item), pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock), log_it(L_CRITICAL, "Timer creation failed");
HASH_ADD(hh, l_poa_pvt->event_items, datum_hash, sizeof(dap_hash_fast_t), l_event_item);
log_it(L_INFO, "Confirmation timer for datum %s started [%d s]",
dap_chain_hash_fast_to_str_static(&l_event_item->datum_hash), l_poa_pvt->confirmations_timeout);
}
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
}
......@@ -709,22 +649,25 @@ static bool s_callback_sync_all_on_start(dap_global_db_instance_t *a_dbi, int a_
static void s_round_changes_notify(dap_store_obj_t *a_obj, void *a_arg)
{
dap_chain_cs_dag_t *l_dag = (dap_chain_cs_dag_t *)a_arg;
assert(l_dag);
assert(a_arg);
dap_chain_cs_dag_t *l_dag = (dap_chain_cs_dag_t*)a_arg;
dap_chain_net_t *l_net = dap_chain_net_by_id(l_dag->chain->net_id);
log_it(L_DEBUG, "%s.%s: op_code='%c' group=\"%s\" key=\"%s\" value_size=%zu",
l_net->pub.name, l_dag->chain->name, dap_store_obj_get_type(a_obj), a_obj->group, a_obj->key, a_obj->value_len);
if (dap_store_obj_get_type(a_obj) == DAP_GLOBAL_DB_OPTYPE_ADD) {
if (dap_strcmp(a_obj->key, DAG_ROUND_CURRENT_KEY)) // check key for round increment, if no than process event
s_callback_event_round_sync(l_dag, dap_store_obj_get_type(a_obj), a_obj->group, a_obj->key, a_obj->value, a_obj->value_len);
else
log_it(L_INFO, "Global round ID: %lu", *(uint64_t*)a_obj->value);
dap_global_db_optype_t l_type = dap_store_obj_get_type(a_obj);
log_it(L_DEBUG, "%s.%s: op_code '%c', group \"%s\", key \"%s\", value_size %zu",
l_net->pub.name, l_dag->chain->name, l_type, a_obj->group, a_obj->key, a_obj->value_len);
if ( !dap_strcmp(a_obj->key, DAG_ROUND_CURRENT_KEY) )
return;
switch ( l_type ) {
case DAP_GLOBAL_DB_OPTYPE_ADD:
s_callback_event_round_sync(l_dag, l_type, a_obj->group, a_obj->key, a_obj->value, a_obj->value_len);
default:
break;
}
}
static void s_timer_process_callback(void *a_arg)
{
dap_chain_node_mempool_process_all((dap_chain_t *)a_arg, false);
dap_chain_node_mempool_process_all( (dap_chain_t*)a_arg, false );
}
/**
......@@ -756,19 +699,15 @@ static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_net_c
dap_global_db_cluster_add_notify_callback(l_dag_cluster, s_round_changes_notify, l_dag);
dap_chain_net_add_auth_nodes_to_cluster(l_net, l_dag_cluster);
dap_link_manager_add_net_associate(l_net->pub.id.uint64, l_dag_cluster->links_cluster);
byte_t *l_current_round = dap_global_db_get_sync(l_dag->gdb_group_events_round_new, DAG_ROUND_CURRENT_KEY, NULL, NULL, NULL);
l_dag->round_current = l_current_round ? *(uint64_t*)l_current_round : 0;
DAP_DELETE(l_current_round);
log_it(L_INFO, "Current round id %"DAP_UINT64_FORMAT_U, l_dag->round_current);
l_dag->round_id = 0;
PVT(l_poa)->mempool_timer = dap_interval_timer_create(15000, s_timer_process_callback, a_chain);
dap_chain_node_role_t l_role = dap_chain_net_get_role(l_net);
if (l_role.enums == NODE_ROLE_ROOT_MASTER || l_role.enums == NODE_ROLE_ROOT) {
l_dag->round_completed = l_dag->round_current++;
log_it(L_MSG, "Round complete ID %"DAP_UINT64_FORMAT_U", current ID %"DAP_UINT64_FORMAT_U, l_dag->round_completed, l_dag->round_current);
dap_global_db_get_all(l_dag->gdb_group_events_round_new, 0, s_callback_sync_all_on_start, l_dag);
switch ( dap_chain_net_get_role(l_net).enums ) {
case NODE_ROLE_ROOT_MASTER:
case NODE_ROLE_ROOT:
dap_global_db_get_all(l_dag->gdb_group_events_round_new, 0, s_callback_sync_all_on_start, l_dag);
default:
break;
}
return 0;
}
......@@ -780,7 +719,6 @@ static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_net_c
*/
static void s_callback_delete(dap_chain_cs_dag_t * a_dag)
{
dap_interval_timer_delete(s_poa_round_timer);
dap_chain_cs_dag_poa_t * l_poa = DAP_CHAIN_CS_DAG_POA ( a_dag );
if ( l_poa->_pvt ) {
......@@ -819,26 +757,19 @@ static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a
dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count, size_t* a_event_size)
{
dap_return_val_if_fail(a_dag && a_dag->chain && DAP_CHAIN_CS_DAG_POA(a_dag), NULL);
dap_chain_cs_dag_poa_t * l_poa = DAP_CHAIN_CS_DAG_POA(a_dag);
if ( PVT(l_poa)->events_sign_cert == NULL){
dap_chain_cs_dag_poa_t *l_poa = DAP_CHAIN_CS_DAG_POA(a_dag);
if ( !PVT(l_poa)->events_sign_cert )
log_it(L_ERROR, "Can't sign event with events_sign_cert in [dag-poa] section");
return NULL;
}
if ( s_seed_mode || (a_hashes && a_hashes_count) ){
else if ( s_seed_mode || (a_hashes && a_hashes_count) ) {
if ( !PVT(l_poa)->callback_pre_sign || !PVT(l_poa)->callback_pre_sign->callback) {
dap_chain_cs_dag_event_t * l_event = dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_dag->round_current,
return dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_dag->round_id,
a_datum, PVT(l_poa)->events_sign_cert->enc_key,
a_hashes, a_hashes_count, a_event_size);
return l_event;
} else {
dap_chain_cs_dag_event_t *l_event = dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_dag->round_current,
a_datum, NULL,
a_hashes, a_hashes_count, a_event_size);
int ret = PVT(l_poa)->callback_pre_sign->callback(a_dag->chain, l_event, *a_event_size, PVT(l_poa)->callback_pre_sign->arg);
if (ret) {
DAP_DELETE(l_event);
return NULL;
}
dap_chain_cs_dag_event_t *l_event = dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_dag->round_id,
a_datum, NULL, a_hashes, a_hashes_count, a_event_size);
if ( PVT(l_poa)->callback_pre_sign->callback(a_dag->chain, l_event, *a_event_size, PVT(l_poa)->callback_pre_sign->arg) )
return DAP_DELETE(l_event), NULL;
*a_event_size = dap_chain_cs_dag_event_sign_add(&l_event, *a_event_size, PVT(l_poa)->events_sign_cert->enc_key);
return l_event;
}
......@@ -849,11 +780,8 @@ static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a
static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_size)
{
if (a_op_code != DAP_GLOBAL_DB_OPTYPE_ADD || !a_key || !a_value || !a_value_size)
return 0;
if (!strcmp(DAG_ROUND_CURRENT_KEY, a_key))
return 0;
dap_return_val_if_pass(a_op_code != DAP_GLOBAL_DB_OPTYPE_ADD || !a_key || !a_value
|| !a_value_size || !strcmp(DAG_ROUND_CURRENT_KEY, a_key), 0);
dap_chain_cs_dag_poa_t * l_poa = DAP_CHAIN_CS_DAG_POA(a_dag);
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
......@@ -867,58 +795,36 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t *)a_value;
size_t l_event_size = l_round_item->event_size;
dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t*)DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
if (!l_event) {
log_it(L_CRITICAL, "Memory allocation failed");
return -1;
}
if (l_event->header.round_id < a_dag->round_completed) {
struct round_timer_arg *l_round_active = NULL;
uint64_t l_round_id = l_event->header.round_id;
pthread_rwlock_wrlock(&l_poa_pvt->rounds_rwlock);
HASH_FIND(hh, l_poa_pvt->active_rounds, &l_round_id, sizeof(uint64_t), l_round_active);
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
if (!l_round_active) {
log_it(L_DEBUG, "DAG event came from too old round [last complete id %"DAP_UINT64_FORMAT_U" > %"DAP_UINT64_FORMAT_U"], skip it",
a_dag->round_completed, l_event->header.round_id);
DAP_DELETE(l_event);
return -2;
}
}
if (dap_chain_cs_dag_event_sign_exists(l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key)
|| dap_chain_cs_dag_event_round_sign_exists(l_round_item, l_poa_pvt->events_sign_cert->enc_key)) {
// if my sign exists
if (l_poa_pvt->auto_round_complete &&
s_round_event_ready_minimum_check(a_dag, l_event, l_event_size, (char *)a_key))
// cs done (minimum signs & verify passed)
s_round_event_cs_done(a_dag, l_event->header.round_id);
DAP_DELETE(l_event);
return 0;
if (!l_event)
return log_it(L_CRITICAL, "Memory allocation failed"), -1;
if ( dap_chain_cs_dag_event_sign_exists(l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key)
|| dap_chain_cs_dag_event_round_sign_exists(l_round_item, l_poa_pvt->events_sign_cert->enc_key)
&& l_poa_pvt->auto_round_complete
&& s_round_event_ready_minimum_check(a_dag, l_event, l_event_size, (char*)a_key) )
{
dap_chain_cs_dag_poa_round_item_t l_event_item = { .datum_hash = l_round_item->round_info.datum_hash, .dag = a_dag };
return DAP_DELETE(l_event), s_round_event_cs_done(&l_event_item), 0;
}
size_t l_event_size_new = 0;
int ret = 0;
if (l_event->header.round_id > a_dag->round_current) {
log_it(L_DEBUG, "Refresh current round ID [%lu -> %lu]", a_dag->round_current, l_event->header.round_id);
a_dag->round_current = l_event->header.round_id;
}
if (!l_poa_pvt->callback_pre_sign || !l_poa_pvt->callback_pre_sign->callback ||
!(ret = l_poa_pvt->callback_pre_sign->callback(a_dag->chain, l_event, l_event_size,
l_poa_pvt->callback_pre_sign->arg))) {
if ( !l_poa_pvt->callback_pre_sign || !l_poa_pvt->callback_pre_sign->callback
|| !(ret = l_poa_pvt->callback_pre_sign->callback(a_dag->chain, l_event, l_event_size,
l_poa_pvt->callback_pre_sign->arg)) )
{
l_event_size_new = dap_chain_cs_dag_event_sign_add(&l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key);
//char *l_event_new_hash_hex_str;
//dap_get_data_hash_str_static(l_event, l_event_size_new, l_event_new_hash_hex_str);
dap_chain_cs_dag_event_gdb_set(a_dag, /*l_event_new_hash_hex_str*/ (char*)a_key, l_event, l_event_size_new, l_round_item);
dap_chain_cs_dag_event_gdb_set(a_dag, (char*)a_key, l_event, l_event_size_new, l_round_item);
} else { // set sign for reject
l_round_item = DAP_DUP_SIZE(a_value, a_value_size);
if (dap_chain_cs_dag_event_round_sign_add(&l_round_item, a_value_size, l_poa_pvt->events_sign_cert->enc_key)) {
log_it(L_NOTICE,"Can't sign event %s, because sign rejected by pre_sign callback, ret code=%d", a_key, ret);
log_it(L_NOTICE,"Can't sign event %s, because sign rejected by pre_sign callback, ret code %d", a_key, ret);
l_round_item->round_info.reject_count++;
dap_chain_cs_dag_event_gdb_set(a_dag, (char *)a_key, l_event, l_event_size, l_round_item);
dap_chain_cs_dag_event_gdb_set(a_dag, (char*)a_key, l_event, l_event_size, l_round_item);
}
DAP_DELETE(l_round_item);
}
DAP_DELETE(l_event);
return 0;
return DAP_DELETE(l_event), ret;
}
/**
......
modules/consensus/esbocs/dap_chain_cs_esbocs.c
View file @ 8209034a
......@@ -427,7 +427,6 @@ static void s_new_atom_notifier(void *a_arg, dap_chain_t *a_chain, dap_chain_cel
{
dap_chain_esbocs_session_t *l_session = a_arg;
assert(l_session->chain == a_chain);
//pthread_mutex_lock(&l_session->mutex);
dap_chain_hash_fast_t l_last_block_hash;
dap_chain_get_atom_last_hash(l_session->chain, a_id, &l_last_block_hash);
if (!dap_hash_fast_compare(&l_last_block_hash, &l_session->cur_round.last_block_hash) &&
......@@ -435,7 +434,6 @@ static void s_new_atom_notifier(void *a_arg, dap_chain_t *a_chain, dap_chain_cel
l_session->new_round_enqueued = true;
s_session_round_new(l_session);
}
//pthread_mutex_unlock(&l_session->mutex);
if (!PVT(l_session->esbocs)->collecting_addr)
return;
dap_chain_esbocs_block_collect_t l_block_collect_params = (dap_chain_esbocs_block_collect_t){
......@@ -593,9 +591,9 @@ static int s_callback_created(dap_chain_t *a_chain, dap_config_t *a_chain_net_cf
log_it(L_ERROR, "This validator is not allowed to work in emergency mode. Use special decree to supply it");
return -5;
}
//pthread_mutex_init(&l_session->mutex, NULL);
dap_chain_add_callback_notify(a_chain, s_new_atom_notifier, l_session);
s_session_round_new(l_session);
dap_chain_add_callback_notify(a_chain, s_new_atom_notifier, l_session->proc_thread, l_session);
//s_session_round_new(l_session);
dap_proc_thread_callback_add(l_session->proc_thread, s_session_round_new, l_session);
l_session->cs_timer = !dap_proc_thread_timer_add(l_session->proc_thread, s_session_proc_state, l_session, 1000);
debug_if(l_esbocs_pvt->debug && l_session->cs_timer, L_MSG, "Consensus main timer is started");
......@@ -789,7 +787,6 @@ static void s_callback_delete(dap_chain_cs_blocks_t *a_blocks)
log_it(L_INFO, "No session found");
return;
}
//pthread_mutex_lock(&l_session->mutex);
DL_DELETE(s_session_items, l_session);
s_session_round_clear(l_session);
dap_chain_esbocs_sync_item_t *l_sync_item, *l_sync_tmp;
......@@ -803,8 +800,6 @@ static void s_callback_delete(dap_chain_cs_blocks_t *a_blocks)
HASH_DEL(l_session->penalty, l_pen_item);
DAP_DELETE(l_pen_item);
}
//pthread_mutex_unlock(&l_session->mutex);
//pthread_mutex_destroy(&l_session->mutex);
DAP_DEL_MULTY(l_session, a_blocks->_inheritor); // a_blocks->_inheritor - l_esbocs
}
......@@ -998,8 +993,9 @@ static void s_db_calc_sync_hash(dap_chain_esbocs_session_t *a_session)
a_session->is_actual_hash = true;
}
static void s_session_send_startsync(dap_chain_esbocs_session_t *a_session)
static void s_session_send_startsync(void *a_arg)
{
dap_chain_esbocs_session_t *a_session = (dap_chain_esbocs_session_t*)a_arg;
if (a_session->cur_round.sync_sent)
return; // Sync message already was sent
dap_chain_hash_fast_t l_last_block_hash;
......@@ -1029,16 +1025,6 @@ static void s_session_send_startsync(dap_chain_esbocs_session_t *a_session)
a_session->cur_round.sync_sent = true;
}
static bool s_session_send_startsync_on_timer(void *a_arg)
{
dap_chain_esbocs_session_t *l_session = a_arg;
//pthread_mutex_lock(&l_session->mutex);
s_session_send_startsync(l_session);
l_session->sync_timer = NULL;
//pthread_mutex_unlock(&l_session->mutex);
return false;
}
static void s_session_update_penalty(dap_chain_esbocs_session_t *a_session)
{
for (dap_list_t *it = a_session->cur_round.all_validators; it; it = it->next) {
......@@ -1100,11 +1086,6 @@ static bool s_session_round_new(void *a_arg)
s_session_round_clear(a_session);
a_session->cur_round.id++;
a_session->cur_round.sync_attempt++;
if (a_session->sync_timer) {
dap_timerfd_delete_mt(a_session->sync_timer->worker, a_session->sync_timer->esocket_uuid);
a_session->sync_timer = NULL;
}
a_session->state = DAP_CHAIN_ESBOCS_SESSION_STATE_WAIT_START;
a_session->ts_round_sync_start = 0;
a_session->ts_stage_entry = 0;
......@@ -1164,7 +1145,8 @@ static bool s_session_round_new(void *a_arg)
a_session->chain->net_name, a_session->chain->name,
a_session->cur_round.id, l_sync_send_delay);
if (l_sync_send_delay)
a_session->sync_timer = dap_timerfd_start(l_sync_send_delay * 1000, s_session_send_startsync_on_timer, a_session);
dap_proc_thread_timer_add_pri(a_session->proc_thread, s_session_send_startsync, a_session,
l_sync_send_delay * 1000, true, DAP_QUEUE_MSG_PRIORITY_NORMAL);
else
s_session_send_startsync(a_session);
}
......@@ -1476,8 +1458,6 @@ static void s_session_proc_state(void *a_arg)
dap_chain_esbocs_session_t *l_session = a_arg;
if (!l_session->cs_timer)
return; // Timer is inactive
//if (pthread_mutex_trylock(&l_session->mutex) != 0)
// return; // Session is busy
bool l_cs_debug = PVT(l_session->esbocs)->debug;
dap_time_t l_time = dap_time_now();
switch (l_session->state) {
......@@ -1582,8 +1562,6 @@ static void s_session_proc_state(void *a_arg)
default:
break;
}
//pthread_mutex_unlock(&l_session->mutex);
}
static void s_message_chain_add(dap_chain_esbocs_session_t *a_session,
......@@ -2219,10 +2197,8 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
dap_hash_fast(l_message, a_data_size, &l_data_hash);
if (a_sender_node_addr) { //Process network messages only
//pthread_mutex_lock(&l_session->mutex);
if (l_message->hdr.chain_id.uint64 != l_session->chain->id.uint64) {
debug_if(l_cs_debug, L_MSG, "Invalid chain ID %"DAP_UINT64_FORMAT_U, l_message->hdr.chain_id.uint64);
//goto session_unlock;
return;
}
// check hash message dup
......@@ -2233,7 +2209,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
" Message rejected: message hash is exists in chain (duplicate)",
l_session->chain->net_name, l_session->chain->name,
l_session->cur_round.id, l_message->hdr.attempt_num);
//goto session_unlock;
return;
}
l_message->hdr.sign_size = 0; // restore header on signing time
......@@ -2242,7 +2217,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
" Message rejected from addr:"NODE_ADDR_FP_STR" not passed verification",
l_session->chain->net_name, l_session->chain->name, l_session->cur_round.id,
l_session->cur_round.attempt_num, NODE_ADDR_FP_ARGS(a_sender_node_addr));
//goto session_unlock;
return;
}
l_message->hdr.sign_size = l_sign_size; // restore original header
......@@ -2255,7 +2229,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
l_session->chain->net_name, l_session->chain->name,
l_session->cur_round.id);
s_session_sync_queue_add(l_session, l_message, a_data_size);
//goto session_unlock;
return;
}
} else if (l_message->hdr.round_id != l_session->cur_round.id) {
......@@ -2291,7 +2264,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
l_session->chain->net_name, l_session->chain->name,
l_session->cur_round.id, l_message->hdr.attempt_num,
s_voting_msg_type_to_str(l_message->hdr.type));
//goto session_unlock;
return;
}
}
......@@ -2328,7 +2300,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
" Message rejected: validator key:%s not in the current validators list or not synced yet",
l_session->chain->net_name, l_session->chain->name, l_session->cur_round.id,
l_message->hdr.attempt_num, l_validator_addr_str);
//goto session_unlock;
return;
}
......@@ -2468,7 +2439,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
l_store = DAP_NEW_Z(dap_chain_esbocs_store_t);
if (!l_store) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
//goto session_unlock;
return;
}
l_store->candidate_size = l_candidate_size;
......@@ -2695,9 +2665,6 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
default:
break;
}
//session_unlock:
//if (a_sender_node_addr) //Process network message
// pthread_mutex_unlock(&l_session->mutex);
}
static void s_message_send(dap_chain_esbocs_session_t *a_session, uint8_t a_message_type, dap_hash_fast_t *a_block_hash,
......@@ -2743,7 +2710,7 @@ static void s_message_send(dap_chain_esbocs_session_t *a_session, uint8_t a_mess
a_message_type, l_message, l_message_size + l_sign_size);
continue;
}
/*struct esbocs_msg_args *l_args = DAP_NEW_SIZE(struct esbocs_msg_args,
struct esbocs_msg_args *l_args = DAP_NEW_SIZE(struct esbocs_msg_args,
sizeof(struct esbocs_msg_args) + l_message_size + l_sign_size);
if (!l_args) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
......@@ -2754,8 +2721,7 @@ static void s_message_send(dap_chain_esbocs_session_t *a_session, uint8_t a_mess
l_args->session = a_session;
l_args->message_size = l_message_size + l_sign_size;
memcpy(l_args->message, l_message, l_message_size + l_sign_size);
dap_proc_thread_callback_add(a_session->proc_thread, s_process_incoming_message, l_args);*/
s_session_packet_in(a_session, &a_session->my_addr, (byte_t*)l_message, l_message_size + l_sign_size);
dap_proc_thread_callback_add(a_session->proc_thread, s_process_incoming_message, l_args);
}
}
DAP_DELETE(l_message);
......@@ -3108,7 +3074,7 @@ static int s_cli_esbocs(int a_argc, char **a_argv, void **a_str_reply)
dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_ESBOCS_PARAM_ERR,"Command '%s' requires parameter -val_count", l_subcmd_strs[l_subcmd]);
return -DAP_CHAIN_NODE_CLI_COM_ESBOCS_PARAM_ERR;
}
uint256_t l_value = dap_chain_balance_scan(l_value_str);
uint256_t l_value = dap_uint256_scan_uninteger(l_value_str);
if (IS_ZERO_256(l_value)) {
dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_ESBOCS_UNREC_COM_ERR,"Unrecognized number in '-val_count' param");
return -DAP_CHAIN_NODE_CLI_COM_ESBOCS_UNREC_COM_ERR;
......
modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
View file @ 8209034a
......@@ -201,7 +201,6 @@ typedef struct dap_chain_esbocs_session {
dap_time_t ts_stage_entry; // time of current stage entrance
dap_chain_esbocs_sync_item_t *sync_items;
dap_timerfd_t *sync_timer;
dap_chain_addr_t my_signing_addr;
......
modules/mempool/dap_chain_mempool.c
View file @ 8209034a
......@@ -1497,9 +1497,7 @@ void dap_chain_mempool_filter(dap_chain_t *a_chain, int *a_removed){
continue;
}
//Filter hash
char *l_hash_content_str;
dap_get_data_hash_str_static(l_datum->data, l_datum->header.data_size, l_hash_content_str);
if (dap_strcmp(l_hash_content_str, l_objs[i].key) != 0) {
if (dap_strcmp(dap_get_data_hash_str(l_datum->data, l_datum->header.data_size).s, l_objs[i].key) != 0) {
l_removed++;
log_it(L_NOTICE, "Removed datum from mempool with \"%s\" key group %s. The hash of the contents of the "
"datum does not match the key.", l_objs[i].key, l_gdb_group);
......
modules/net/dap_chain_ledger.c
View file @ 8209034a
......@@ -64,7 +64,7 @@ typedef struct dap_ledger_verificator {
int subtype; // hash key
dap_ledger_verificator_callback_t callback;
dap_ledger_updater_callback_t callback_added;
dap_ledger_updater_callback_t callback_deleted;
dap_ledger_delete_callback_t callback_deleted;
UT_hash_handle hh;
} dap_ledger_verificator_t;
......@@ -276,8 +276,8 @@ typedef struct dap_ledger_private {
dap_list_t *bridged_tx_notifiers;
dap_list_t *tx_add_notifiers;
dap_ledger_cache_tx_check_callback_t cache_tx_check_callback;
// HAL
dap_ledger_hal_item_t *hal_items;
// White- and blacklist
dap_ledger_hal_item_t *hal_items, *hrl_items;
} dap_ledger_private_t;
#define PVT(a) ( (dap_ledger_private_t *) a->_internal )
......@@ -561,6 +561,12 @@ inline static dap_ledger_hal_item_t *s_check_hal(dap_ledger_t *a_ledger, dap_has
return ret;
}
bool dap_ledger_datum_is_blacklisted(dap_ledger_t *a_ledger, dap_hash_fast_t a_hash) {
dap_ledger_hal_item_t *ret = NULL;
HASH_FIND(hh, PVT(a_ledger)->hrl_items, &a_hash, sizeof(dap_hash_fast_t), ret);
return debug_if(s_debug_more && ret, L_MSG, "Datum %s is blacklisted", dap_hash_fast_to_str_static(&a_hash)), !!ret;
}
inline static dap_ledger_token_item_t *s_ledger_find_token(dap_ledger_t *a_ledger, const char *a_token_ticker)
{
dap_return_val_if_fail(a_ledger && a_token_ticker, NULL);
......@@ -2557,27 +2563,24 @@ dap_ledger_t *dap_ledger_create(dap_chain_net_t *a_net, uint16_t a_flags)
if (strlen(l_entry_name) > 4) {
if ( strncmp (l_entry_name + strlen(l_entry_name)-4,".cfg",4) == 0 ) { // its .cfg file
l_entry_name [strlen(l_entry_name)-4] = 0;
log_it(L_DEBUG,"Open chain config \"%s\"...",l_entry_name);
log_it(L_DEBUG,"Open chain config \"%s.%s\"...", a_net->pub.name, l_entry_name);
l_chains_path = dap_strdup_printf("network/%s/%s", a_net->pub.name, l_entry_name);
dap_config_t * l_cfg = dap_config_open(l_chains_path);
uint16_t l_whitelist_size;
const char **l_whitelist = dap_config_get_array_str(l_cfg, "ledger", "hard_accept_list", &l_whitelist_size);
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, "%s", c_error_memory_alloc);
DAP_DEL_Z(l_ledger_pvt);
DAP_DEL_Z(l_ledger);
dap_config_close(l_cfg);
DAP_DELETE (l_entry_name);
closedir(l_chains_dir);
return NULL;
}
dap_chain_hash_fast_from_str(l_whitelist[i], &l_hal_item->hash);
HASH_ADD(hh, l_ledger_pvt->hal_items, hash, sizeof(l_hal_item->hash), l_hal_item);
uint16_t l_whitelist_size, l_blacklist_size, i;
const char **l_whitelist = dap_config_get_array_str(l_cfg, "ledger", "hard_accept_list", &l_whitelist_size),
**l_blacklist = dap_config_get_array_str(l_cfg, "ledger", "hard_reject_list", &l_blacklist_size);
for (i = 0; i < l_blacklist_size; ++i) {
dap_ledger_hal_item_t *l_item = DAP_NEW_Z(dap_ledger_hal_item_t);
dap_chain_hash_fast_from_str(l_blacklist[i], &l_item->hash);
HASH_ADD(hh, l_ledger_pvt->hrl_items, hash, sizeof(dap_hash_fast_t), l_item);
}
for (i = 0; i < l_whitelist_size; ++i) {
dap_ledger_hal_item_t *l_item = DAP_NEW_Z(dap_ledger_hal_item_t);
dap_chain_hash_fast_from_str(l_whitelist[i], &l_item->hash);
HASH_ADD(hh, l_ledger_pvt->hal_items, hash, sizeof(dap_hash_fast_t), l_item);
}
dap_config_close(l_cfg);
log_it(L_DEBUG, "HAL items count for chain %s : %d", l_entry_name, l_whitelist_size);
log_it(L_DEBUG, "Chain %s.%s has %d datums in HAL and %d datums in HRL", a_net->pub.name, l_entry_name, l_whitelist_size, l_blacklist_size);
}
}
DAP_DELETE (l_entry_name);
......@@ -4444,7 +4447,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
pthread_rwlock_unlock(&s_verificators_rwlock);
if (l_verificator && l_verificator->callback_added)
l_verificator->callback_added(a_ledger, a_tx, l_bound_item->cond);
l_verificator->callback_added(a_ledger, a_tx, a_tx_hash, l_bound_item->cond);
} break;
default:
......@@ -4497,7 +4500,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
pthread_rwlock_unlock(&s_verificators_rwlock);
if (l_verificator && l_verificator->callback_added)
l_verificator->callback_added(a_ledger, a_tx, NULL);
l_verificator->callback_added(a_ledger, a_tx, a_tx_hash, NULL);
continue; // balance raise will be with next conditional transaction
}
......@@ -4650,7 +4653,7 @@ FIN:
return l_ret;
}
void dap_leger_load_end(dap_ledger_t *a_ledger)
void dap_ledger_load_end(dap_ledger_t *a_ledger)
{
pthread_rwlock_wrlock(&PVT(a_ledger)->ledger_rwlock);
HASH_SORT(PVT(a_ledger)->ledger_items, s_sort_ledger_tx_item);
......@@ -5610,7 +5613,7 @@ dap_list_t *dap_ledger_get_list_tx_outs(dap_ledger_t *a_ledger, const char *a_to
// Add new verificator callback with associated subtype. Returns 1 if callback replaced, -1 error, overwise returns 0
int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_ledger_verificator_callback_t a_callback, dap_ledger_updater_callback_t a_callback_added, dap_ledger_updater_callback_t a_callback_deleted)
int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_ledger_verificator_callback_t a_callback, dap_ledger_updater_callback_t a_callback_added, dap_ledger_delete_callback_t a_callback_deleted)
{
dap_ledger_verificator_t *l_new_verificator = NULL;
int l_tmp = (int)a_subtype;
......
modules/net/dap_chain_net.c
View file @ 8209034a
......@@ -495,11 +495,15 @@ int s_link_manager_link_request(uint64_t a_net_id)
if (l_net_pvt->state == NET_STATE_LINKS_PREPARE)
l_net_pvt->state = NET_STATE_LINKS_CONNECTING;
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 in nte %s", dap_chain_net_balancer_type_to_str(PVT(l_net)->balancer_type), l_net->pub.name);
return -5;
}
return dap_chain_net_balancer_request(l_net, l_balancer_link->addr, l_balancer_link->port, PVT(l_net)->balancer_type);
if (!l_balancer_link)
return log_it(L_ERROR, "Can't process balancer link %s request in net %s",
dap_chain_net_balancer_type_to_str(PVT(l_net)->balancer_type), l_net->pub.name), -5;
dap_balancer_link_request_t *l_arg = DAP_NEW_Z(dap_balancer_link_request_t);
l_arg->net = l_net;
l_arg->host_addr = (const char*)l_balancer_link->addr;
l_arg->host_port = l_balancer_link->port;
l_arg->type = PVT(l_net)->balancer_type;
return dap_worker_exec_callback_on(dap_worker_get_auto(), dap_chain_net_balancer_request, l_arg), 0;
}
int s_link_manager_fill_net_info(dap_link_t *a_link)
......@@ -2031,9 +2035,8 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
}
if (!l_chain->callback_get_poa_certs)
continue;
l_net->pub.keys = l_chain->callback_get_poa_certs(l_chain, NULL, NULL);
if (l_net->pub.keys)
break;
if (!l_net->pub.keys)
l_net->pub.keys = l_chain->callback_get_poa_certs(l_chain, NULL, NULL);
}
if (!l_net->pub.keys)
log_it(L_WARNING, "PoA certificates for net %s not found", l_net->pub.name);
......@@ -2111,7 +2114,7 @@ bool s_net_load(void *a_arg)
l_chain = l_chain->next;
}
l_net_pvt->load_mode = false;
dap_leger_load_end(l_net->pub.ledger);
dap_ledger_load_end(l_net->pub.ledger);
// Do specific role actions post-chain created
l_net_pvt->state_target = NET_STATE_OFFLINE;
......@@ -2807,6 +2810,8 @@ int dap_chain_datum_add(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t
return -101;
}
dap_ledger_t *l_ledger = dap_chain_net_by_id(a_chain->net_id)->pub.ledger;
if ( dap_ledger_datum_is_blacklisted(l_ledger, *a_datum_hash) )
return log_it(L_ERROR, "Datum is blackilsted"), -100;
switch (a_datum->header.type_id) {
case DAP_CHAIN_DATUM_DECREE: {
dap_chain_datum_decree_t *l_decree = (dap_chain_datum_decree_t *)a_datum->data;
......@@ -3209,10 +3214,10 @@ static dap_chain_t *s_switch_sync_chain(dap_chain_net_t *a_net)
}
l_net_pvt->sync_context.cur_chain = l_curr_chain;
if (l_curr_chain) {
log_it(L_DEBUG, "Go to chain \"%s\" for net %s", l_curr_chain->name, l_curr_chain->net_name);
debug_if(s_debug_more, L_DEBUG, "Go to chain \"%s\" for net %s", l_curr_chain->name, l_curr_chain->net_name);
return l_curr_chain;
}
log_it(L_DEBUG, "Go to next chain: <NULL>");
debug_if(s_debug_more, L_DEBUG, "Go to next chain: <NULL>");
if (l_net_pvt->state_target != NET_STATE_ONLINE) {
dap_chain_net_state_go_to(a_net, NET_STATE_OFFLINE);
return NULL;
......@@ -3221,7 +3226,7 @@ static dap_chain_t *s_switch_sync_chain(dap_chain_net_t *a_net)
l_net_pvt->state = NET_STATE_ONLINE;
s_net_states_proc(a_net);
if(l_prev_state == NET_STATE_SYNC_CHAINS)
dap_leger_load_end(a_net->pub.ledger);
dap_ledger_load_end(a_net->pub.ledger);
return NULL;
}
......@@ -3315,7 +3320,7 @@ static bool s_net_states_proc(void *a_arg)
assert(l_net_pvt);
if (l_net_pvt->state_target == NET_STATE_OFFLINE) {
if(l_net_pvt->state == NET_STATE_SYNC_CHAINS)
dap_leger_load_end(l_net->pub.ledger);
dap_ledger_load_end(l_net->pub.ledger);
l_net_pvt->state = NET_STATE_OFFLINE;
}
......@@ -3401,4 +3406,4 @@ DAP_INLINE dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t
return PVT(a_net)->state_target;
}
/*------------------------------------State machine block end---------------------------------*/
\ No newline at end of file
/*------------------------------------State machine block end---------------------------------*/
modules/net/dap_chain_net_anchor.c
View file @ 8209034a
......@@ -168,7 +168,7 @@ int dap_chain_net_anchor_load(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *
return -109;
}
if ((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain)) != 0){
if ((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain, true)) != 0){
debug_if(s_debug_more, L_WARNING, "Decree applying failed");
return ret_val;
}
......@@ -315,7 +315,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
return -109;
}
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain))!=0){
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain, true))!=0){
log_it(L_WARNING,"Decree applying failed");
return ret_val;
}
......@@ -351,7 +351,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
log_it(L_WARNING,"Can not find datum hash in anchor data");
return -109;
}
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain))!=0){
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain, true))!=0){
log_it(L_WARNING,"Decree applying failed");
return ret_val;
}
......@@ -368,7 +368,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
log_it(L_WARNING,"Can not find datum hash in anchor data");
return -109;
}
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain))!=0){
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain, true))!=0){
log_it(L_WARNING,"Decree applying failed");
return ret_val;
}
......@@ -389,7 +389,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
return -109;
}
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain))!=0){
if((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain, true))!=0){
log_it(L_WARNING,"Decree applying failed");
return ret_val;
}
......
modules/net/dap_chain_net_balancer.c
View file @ 8209034a
......@@ -44,15 +44,6 @@ typedef struct dap_balancer_request_info {
UT_hash_handle hh;
} dap_balancer_request_info_t;
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_request_info_t *request_info;
} 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);
static const dap_time_t s_request_period = 5; // sec
......@@ -465,66 +456,53 @@ dap_link_info_t *dap_chain_net_balancer_dns_issue_link(const char *a_net_name)
* @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)
void dap_chain_net_balancer_request(void *a_arg)
{
// sanity check
dap_return_val_if_pass(!a_net, -1);
dap_return_if_fail(a_arg);
dap_balancer_link_request_t *l_arg = (dap_balancer_link_request_t*)a_arg;
// period request check
dap_balancer_request_info_t *l_item = NULL;
HASH_FIND(hh, s_request_info_items, &a_net->pub.id, sizeof(a_net->pub.id), l_item);
HASH_FIND(hh, s_request_info_items, &l_arg->net->pub.id, sizeof(l_arg->net->pub.id), l_item);
if (!l_item) {
DAP_NEW_Z_RET_VAL(l_item, dap_balancer_request_info_t, -2, NULL);
l_item->net_id = a_net->pub.id;
DAP_NEW_Z_RET(l_item, dap_balancer_request_info_t, NULL);
l_item->net_id = l_arg->net->pub.id;
HASH_ADD(hh, s_request_info_items, net_id, sizeof(l_item->net_id), l_item);
}
if (l_item->request_time + DAP_CHAIN_NET_BALANCER_REQUEST_DELAY > dap_time_now()) {
log_it(L_DEBUG, "Who understands life, he is in no hurry. Dear %s, please wait few seconds", a_net->pub.name);
return 0;
}
if (l_item->request_time + DAP_CHAIN_NET_BALANCER_REQUEST_DELAY > dap_time_now())
return log_it(L_DEBUG, "Who understands life, he is in no hurry. Dear %s, please wait few seconds", l_arg->net->pub.name);
// preparing to request
size_t
l_ignored_addrs_size = 0,
l_required_links_count = dap_link_manager_needed_links_count(a_net->pub.id.uint64);
l_required_links_count = dap_link_manager_needed_links_count(l_arg->net->pub.id.uint64);
dap_chain_net_links_t
*l_ignored_addrs = s_get_ignored_node_addrs(a_net, &l_ignored_addrs_size),
*l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);
*l_ignored_addrs = s_get_ignored_node_addrs(l_arg->net, &l_ignored_addrs_size),
*l_links = s_get_node_addrs(l_arg->net, l_required_links_count, l_ignored_addrs, false);
// links from local GDB
if (l_links) {
log_it(L_INFO, "%"DAP_UINT64_FORMAT_U" links successful prepared from global-db in net %s", l_links->count_node, a_net->pub.name);
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;
}
log_it(L_INFO, "%"DAP_UINT64_FORMAT_U" links successful prepared from global-db in net %s", l_links->count_node, l_arg->net->pub.name);
s_balancer_link_prepare_success(l_arg->net, l_links, NULL, 0);
if (l_links->count_node >= l_required_links_count)
return DAP_DEL_MULTY(l_ignored_addrs, l_links);
l_required_links_count -= l_links->count_node;
DAP_DELETE(l_links);
}
// links from http balancer request
if (!a_host_addr || !a_host_port) {
log_it(L_INFO, "Can't read seed nodes addresses in net %s, work with local balancer only", a_net->pub.name);
DAP_DEL_Z(l_ignored_addrs);
return 0;
}
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_worker_get_current(),
.required_links_count = l_required_links_count,
.request_info = l_item
};
if (!l_arg->host_addr || !*l_arg->host_addr || !l_arg->host_port)
return DAP_DELETE(l_ignored_addrs), log_it(L_INFO, "Can't read seed nodes addresses in net %s, work with local balancer only",
l_arg->net->pub.name);
l_arg->worker = dap_worker_get_current();
l_arg->required_links_count = l_required_links_count;
l_arg->request_info = l_item;
log_it(L_DEBUG, "Start balancer %s request to %s:%u in net %s",
dap_chain_net_balancer_type_to_str(a_balancer_type), l_balancer_request->host_addr, l_balancer_request->host_port, a_net->pub.name);
dap_chain_net_balancer_type_to_str(l_arg->type), l_arg->host_addr, l_arg->host_port, l_arg->net->pub.name);
int ret;
if (a_balancer_type == DAP_CHAIN_NET_BALANCER_TYPE_HTTP) {
if (l_arg->type == DAP_CHAIN_NET_BALANCER_TYPE_HTTP) {
char *l_ignored_addrs_str = NULL;
if (l_ignored_addrs) {
DAP_NEW_Z_SIZE_RET_VAL(
DAP_NEW_Z_SIZE_RET(
l_ignored_addrs_str, char, DAP_ENC_BASE64_ENCODE_SIZE(l_ignored_addrs_size) + 1,
-7, l_ignored_addrs, l_balancer_request);
l_ignored_addrs, l_arg);
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);
}
......@@ -534,38 +512,28 @@ int dap_chain_net_balancer_request(dap_chain_net_t *a_net, const char *a_host_ad
DAP_BALANCER_URI_HASH,
DAP_BALANCER_PROTOCOL_VERSION,
(int)l_required_links_count,
a_net->pub.name,
l_arg->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;
if (! dap_client_http_request(l_arg->worker, l_arg->host_addr, l_arg->host_port,
"GET", "text/text", l_request, NULL, 0, NULL,
s_http_balancer_link_prepare_success, s_http_balancer_link_prepare_error,
l_arg, NULL) )
{
log_it(L_ERROR, "Can't process balancer link %s request in net %s",
dap_chain_net_balancer_type_to_str(l_arg->type), l_arg->net->pub.name);
}
DAP_DEL_MULTY(l_ignored_addrs_str, l_request);
} else {
l_balancer_request->host_port = DNS_LISTEN_PORT;
l_arg->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 in net %s", dap_chain_net_balancer_type_to_str(a_balancer_type), a_net->pub.name);
return -6;
/* 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); */
}
return 0;
}
/**
......
modules/net/dap_chain_net_decree.c
View file @ 8209034a
......@@ -52,7 +52,7 @@ typedef struct decree_table {
// Private fuctions prototype
static bool s_verify_pkey (dap_sign_t *a_sign, dap_chain_net_t *a_net);
static int s_common_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain_net_t *a_net, bool a_apply, bool a_load_mode);
static int s_common_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain_net_t *a_net, bool a_apply, bool a_anchored);
static int s_service_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain_net_t *a_net, bool a_apply);
static bool s_debug_more = false;
......@@ -119,7 +119,7 @@ void dap_chain_net_decree_purge(dap_chain_net_t *a_net)
dap_chain_net_decree_init(a_net);
}
static int s_decree_verify(dap_chain_net_t *a_net, dap_chain_datum_decree_t *a_decree, size_t a_data_size, dap_chain_hash_fast_t *a_decree_hash, bool a_load_mode)
static int s_decree_verify(dap_chain_net_t *a_net, dap_chain_datum_decree_t *a_decree, size_t a_data_size, dap_chain_hash_fast_t *a_decree_hash, bool a_anchored)
{
if (a_data_size < sizeof(dap_chain_datum_decree_t)) {
log_it(L_WARNING, "Decree size is too small");
......@@ -205,7 +205,7 @@ static int s_decree_verify(dap_chain_net_t *a_net, dap_chain_datum_decree_t *a_d
int l_ret = 0;
switch(a_decree->header.type) {
case DAP_CHAIN_DATUM_DECREE_TYPE_COMMON:
l_ret = s_common_decree_handler(a_decree, a_net, false, a_load_mode);
l_ret = s_common_decree_handler(a_decree, a_net, false, a_anchored);
break;
case DAP_CHAIN_DATUM_DECREE_TYPE_SERVICE:
l_ret = s_service_decree_handler(a_decree, a_net, false);
......@@ -227,7 +227,7 @@ int dap_chain_net_decree_verify(dap_chain_net_t *a_net, dap_chain_datum_decree_t
return s_decree_verify(a_net, a_decree, a_data_size, a_decree_hash, false);
}
int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_decree_t *a_decree, dap_chain_t *a_chain)
int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_decree_t *a_decree, dap_chain_t *a_chain, bool a_anchored)
{
int ret_val = 0;
dap_chain_net_t *l_net = NULL;
......@@ -282,7 +282,7 @@ int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_d
// Process decree
switch(l_new_decree->decree->header.type) {
case DAP_CHAIN_DATUM_DECREE_TYPE_COMMON:
ret_val = s_common_decree_handler(l_new_decree->decree, l_net, true, false);
ret_val = s_common_decree_handler(l_new_decree->decree, l_net, true, a_anchored);
break;
case DAP_CHAIN_DATUM_DECREE_TYPE_SERVICE:
ret_val = s_service_decree_handler(l_new_decree->decree, l_net, true);
......@@ -318,12 +318,12 @@ int dap_chain_net_decree_load(dap_chain_datum_decree_t * a_decree, dap_chain_t *
size_t l_data_size = dap_chain_datum_decree_get_size(a_decree);
if ((ret_val = s_decree_verify(l_net, a_decree, l_data_size, a_decree_hash, true)) != 0) {
if ((ret_val = s_decree_verify(l_net, a_decree, l_data_size, a_decree_hash, false)) != 0) {
//log_it(L_ERROR, "Decree verification failed!");
return ret_val;
}
return dap_chain_net_decree_apply(a_decree_hash, a_decree, a_chain);
return dap_chain_net_decree_apply(a_decree_hash, a_decree, a_chain, false);
}
int dap_chain_net_decree_reset_applied(dap_chain_net_t *a_net, dap_chain_hash_fast_t *a_decree_hash)
......@@ -356,7 +356,7 @@ static bool s_verify_pkey (dap_sign_t *a_sign, dap_chain_net_t *a_net)
return false;
}
static int s_common_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain_net_t *a_net, bool a_apply, bool a_load_mode)
static int s_common_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain_net_t *a_net, bool a_apply, bool a_anchored)
{
uint256_t l_value;
uint32_t l_sign_type;
......@@ -433,10 +433,8 @@ static int s_common_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain
log_it(L_WARNING,"Can't get signer node address from decree.");
return -108;
}
if (a_load_mode) {
assert(!a_apply);
if (!a_anchored)
break;
}
if (dap_chain_net_srv_stake_verify_key_and_node(&l_addr, &l_node_addr)) {
debug_if(s_debug_more, L_WARNING, "Key and node verification error");
return -109;
......@@ -485,6 +483,8 @@ static int s_common_decree_handler(dap_chain_datum_decree_t *a_decree, dap_chain
log_it(L_WARNING, "Can't apply this decree to specified chain");
return -115;
}
if (!a_anchored)
break;
uint16_t l_decree_count = (uint16_t)dap_chain_uint256_to(l_value);
uint16_t l_current_count = dap_chain_net_srv_stake_get_total_keys(a_net->pub.id, NULL);
if (l_decree_count > l_current_count) {
......
modules/net/dap_chain_net_node_list.c
View file @ 8209034a
......@@ -124,7 +124,7 @@ void dap_chain_net_node_check_http_issue_link(dap_http_simple_t *a_http_simple,
uint8_t l_response = ERR_UNKNOWN;
switch (l_issue_method) {
case 'a': {
uint8_t l_host_size = dap_min(INET6_ADDRSTRLEN, (int)dap_strlen(a_http_simple->es_hostaddr) + 1);
uint8_t l_host_size = (uint8_t)dap_strlen(a_http_simple->es_hostaddr) + 1;
l_node_info = DAP_NEW_STACK_SIZE(dap_chain_node_info_t, sizeof(dap_chain_node_info_t) + l_host_size);
*l_node_info = (dap_chain_node_info_t) {
.address.uint64 = addr,
......@@ -133,8 +133,7 @@ void dap_chain_net_node_check_http_issue_link(dap_http_simple_t *a_http_simple,
};
l_response = !dap_chain_net_balancer_handshake(l_node_info, l_net)
? s_dap_chain_net_node_list_add(l_net, l_node_info)
: ( log_it(L_DEBUG, "Can't do handshake with %s [ %s : %u ]", l_key, l_node_info->ext_host, l_node_info->ext_port),
ERR_HANDSHAKE );
: ( log_it(L_DEBUG, "Can't do handshake with %s [ %s : %u ]", l_key, l_node_info->ext_host, l_node_info->ext_port), ERR_HANDSHAKE );
*l_return_code = Http_Status_OK;
} break;
......@@ -148,10 +147,8 @@ void dap_chain_net_node_check_http_issue_link(dap_http_simple_t *a_http_simple,
*l_return_code = Http_Status_Forbidden;
} else {
l_response = !dap_global_db_del_sync(l_net->pub.gdb_nodes, l_key)
? ( log_it(L_DEBUG, "Node %s successfully deleted from nodelist", l_key),
DELETED_OK )
: ( log_it(L_DEBUG, "Can't delete node %s from nodelist", l_key),
ERR_EXISTS );
? ( log_it(L_DEBUG, "Node %s successfully deleted from nodelist", l_key), DELETED_OK )
: ( log_it(L_DEBUG, "Can't delete node %s from nodelist", l_key), ERR_EXISTS );
*l_return_code = Http_Status_OK;
}
DAP_DELETE(l_node_info);
......@@ -159,11 +156,9 @@ void dap_chain_net_node_check_http_issue_link(dap_http_simple_t *a_http_simple,
} break;
default:
log_it(L_ERROR, "Unsupported protocol version/method in the request to dap_chain_net_node_list module");
*l_return_code = Http_Status_MethodNotAllowed;
return;
return *l_return_code = Http_Status_MethodNotAllowed, log_it(L_ERROR, "Unsupported protocol version/method");
}
dap_http_simple_reply(a_http_simple, &l_response, sizeof(uint8_t));
}
......@@ -171,79 +166,110 @@ static void s_net_node_link_prepare_success(void *a_response, size_t a_response_
http_status_code_t http_status_code) {
(void)http_status_code;
struct node_link_request *l_node_list_request = (struct node_link_request *)a_arg;
#ifdef DAP_OS_WINDOWS
EnterCriticalSection(&l_node_list_request->wait_crit_sec);
l_node_list_request->response = *(uint8_t*)a_response;
WakeConditionVariable(&l_node_list_request->wait_cond);
LeaveCriticalSection(&l_node_list_request->wait_crit_sec);
#else
pthread_mutex_lock(&l_node_list_request->wait_mutex);
l_node_list_request->response = *(uint8_t*)a_response;
pthread_cond_signal(&l_node_list_request->wait_cond);
pthread_mutex_unlock(&l_node_list_request->wait_mutex);
#endif
}
static void s_net_node_link_prepare_error(int a_error_code, void *a_arg){
struct node_link_request * l_node_list_request = (struct node_link_request *)a_arg;
dap_chain_node_info_t *l_node_info = l_node_list_request->link_info;
if (!l_node_info) {
log_it(L_WARNING, "Link prepare error, code %d", a_error_code);
return;
}
if (!l_node_info)
return log_it(L_WARNING, "Link prepare error, code %d", a_error_code);
#ifdef DAP_OS_WINDOWS
EnterCriticalSection(&l_node_list_request->wait_crit_sec);
l_node_list_request->response = a_error_code;
WakeConditionVariable(&l_node_list_request->wait_cond);
LeaveCriticalSection(&l_node_list_request->wait_crit_sec);
#else
pthread_mutex_lock(&l_node_list_request->wait_mutex);
l_node_list_request->response = a_error_code;
pthread_cond_signal(&l_node_list_request->wait_cond);
pthread_mutex_unlock(&l_node_list_request->wait_mutex);
#endif
log_it(L_WARNING, "Link from "NODE_ADDR_FP_STR" [ %s : %u ] prepare error with code %d",
NODE_ADDR_FP_ARGS_S(l_node_info->address), l_node_info->ext_host,
l_node_info->ext_port, a_error_code);
}
static struct node_link_request *s_node_list_request_init ()
static struct node_link_request* s_node_list_request_init()
{
struct node_link_request *l_node_list_request = DAP_NEW_Z(struct node_link_request);
if(!l_node_list_request){
if (!l_node_list_request)
return NULL;
}
l_node_list_request->worker = dap_events_worker_get_auto();
l_node_list_request->response = 0;
pthread_condattr_t attr;
pthread_condattr_init(&attr);
#ifdef DAP_OS_WINDOWS
InitializeCriticalSection(&l_node_list_request->wait_crit_sec);
InitializeConditionVariable(&l_node_list_request->wait_cond);
#else
pthread_mutex_init(&l_node_list_request->wait_mutex, NULL);
#ifdef DAP_OS_DARWIN
struct timespec ts;
ts.tv_sec = 8;
ts.tv_nsec = 0;
pthread_cond_timedwait_relative_np(&l_node_list_request->wait_cond, &l_node_list_request->wait_mutex,
&ts);
pthread_cond_init(&l_node_list_request->wait_cond, NULL);
#else
pthread_condattr_t attr;
pthread_condattr_init(&attr);
pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
pthread_cond_init(&l_node_list_request->wait_cond, &attr);
#endif
#endif
pthread_cond_init(&l_node_list_request->wait_cond, &attr);
pthread_mutex_init(&l_node_list_request->wait_mutex, NULL);
return l_node_list_request;
}
static void s_node_list_request_deinit (struct node_link_request *a_node_list_request)
{
#ifdef DAP_OS_WINDOWS
DeleteCriticalSection(&a_node_list_request->wait_crit_sec);
#else
pthread_cond_destroy(&a_node_list_request->wait_cond);
pthread_mutex_destroy(&a_node_list_request->wait_mutex);
#endif
DAP_DEL_Z(a_node_list_request->link_info);
}
static int dap_chain_net_node_list_wait(struct node_link_request *a_node_list_request, int a_timeout_ms){
static int dap_chain_net_node_list_wait(struct node_link_request *a_node_list_request, int a_timeout_ms) {
#ifdef DAP_OS_WINDOWS
EnterCriticalSection(&a_node_list_request->wait_crit_sec);
if (a_node_list_request->response)
return LeaveCriticalSection(&a_node_list_request->wait_crit_sec), a_node_list_request->response;
while (!a_node_list_request->response) {
if ( !SleepConditionVariableCS(&a_node_list_request->wait_cond, &a_node_list_request->wait_crit_sec, a_timeout_ms) )
a_node_list_request->response = GetLastError() == ERROR_TIMEOUT ? ERR_WAIT_TIMEOUT : ERR_UNKNOWN;
}
return LeaveCriticalSection(&a_node_list_request->wait_crit_sec), a_node_list_request->response;
#else
pthread_mutex_lock(&a_node_list_request->wait_mutex);
if(a_node_list_request->response)
{
pthread_mutex_unlock(&a_node_list_request->wait_mutex);
return a_node_list_request->response;
}
return pthread_mutex_unlock(&a_node_list_request->wait_mutex), a_node_list_request->response;
struct timespec l_cond_timeout;
clock_gettime(CLOCK_REALTIME, &l_cond_timeout);
l_cond_timeout.tv_sec += a_timeout_ms/1000;
#ifdef DAP_OS_DARWIN
l_cond_timeout = (struct timespec){ .tv_sec = a_timeout_ms / 1000 };
#else
clock_gettime(CLOCK_MONOTONIC, &l_cond_timeout);
l_cond_timeout.tv_sec += a_timeout_ms / 1000;
#endif
while (!a_node_list_request->response) {
int l_wait = pthread_cond_timedwait(&a_node_list_request->wait_cond, &a_node_list_request->wait_mutex, &l_cond_timeout);
if (l_wait == ETIMEDOUT) {
log_it(L_NOTICE, "Waiting for status timeout");
switch (
#ifdef DAP_OS_DARWIN
pthread_cond_timedwait_relative_np(&a_node_list_request->wait_cond, &a_node_list_request->wait_mutex, &l_cond_timeout)
#else
pthread_cond_timedwait(&a_node_list_request->wait_cond, &a_node_list_request->wait_mutex, &l_cond_timeout)
#endif
) {
case ETIMEDOUT:
a_node_list_request->response = ERR_WAIT_TIMEOUT;
break;
} else {
default:
break;
}
}
pthread_mutex_unlock(&a_node_list_request->wait_mutex);
return a_node_list_request->response;
return pthread_mutex_unlock(&a_node_list_request->wait_mutex), a_node_list_request->response;
#endif
}
static int s_cb_node_addr_compare(dap_list_t *a_list_elem, dap_list_t *a_addr_elem) {
......@@ -258,10 +284,8 @@ int dap_chain_net_node_list_request(dap_chain_net_t *a_net, uint16_t a_port, boo
return -1;
struct node_link_request *l_link_node_request = s_node_list_request_init();
if (!l_link_node_request) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
return -4;
};
if (!l_link_node_request)
return log_it(L_CRITICAL, "%s", c_error_memory_alloc), -4;
char *l_request = dap_strdup_printf( "%s/%s?version=1,method=%c,addr=%zu,port=%hu,net=%s",
DAP_UPLINK_PATH_NODE_LIST, DAP_NODE_LIST_URI_HASH, a_cmd,
......@@ -273,7 +297,7 @@ int dap_chain_net_node_list_request(dap_chain_net_t *a_net, uint16_t a_port, boo
dap_chain_node_info_t *l_remote = dap_chain_node_info_read(a_net, l_seeds_addrs + i);
if (!l_remote)
continue;
if ( dap_client_http_request(l_link_node_request->worker, l_remote->ext_host, l_remote->ext_port,
if ( dap_client_http_request(dap_worker_get_auto(), l_remote->ext_host, l_remote->ext_port,
"GET", "text/text", l_request, NULL, 0, NULL,
s_net_node_link_prepare_success, s_net_node_link_prepare_error,
l_link_node_request, NULL) )
......@@ -311,9 +335,6 @@ int dap_chain_net_node_list_request(dap_chain_net_t *a_net, uint16_t a_port, boo
int dap_chain_net_node_list_init()
{
/*for (dap_chain_net_t *it = dap_chain_net_iter_start(); it; it = dap_chain_net_iter_next(it)) {
dap_chain_net_add_nodelist_notify_callback(it, s_node_list_callback_notify, it);
}*/
return 0;
}
......
modules/net/dap_chain_node_cli_cmd.c
View file @ 8209034a
......@@ -566,8 +566,6 @@ int com_global_db(int a_argc, char ** a_argv, void **a_str_reply)
switch (l_subcmd) {
case SUMCMD_GET: // Get value
{
char *l_hash_str;
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, "%s", c_error_memory_alloc);
......@@ -580,7 +578,7 @@ int com_global_db(int a_argc, char ** a_argv, void **a_str_reply)
size_t ret = dap_bin2hex(l_value_str, l_value, l_value_len);
json_object_object_add(json_obj_rec, "command status", json_object_new_string("Record found"));
json_object_object_add(json_obj_rec, "lenght(byte)", json_object_new_uint64(l_value_len));
json_object_object_add(json_obj_rec, "hash", json_object_new_string(l_hash_str));
json_object_object_add(json_obj_rec, "hash", json_object_new_string(dap_get_data_hash_str(l_value, l_value_len).s));
json_object_object_add(json_obj_rec, "pinned", l_is_pinned ? json_object_new_string("Yes") : json_object_new_string("No") );
json_object_object_add(json_obj_rec, "value", json_object_new_string(l_value_str));
DAP_DELETE(l_value_str);
......@@ -6819,9 +6817,8 @@ int com_tx_create_json(int a_argc, char ** a_argv, void **reply)
// Add transaction to mempool
char *l_gdb_group_mempool_base_tx = dap_chain_net_get_gdb_group_mempool_new(l_chain);// get group name for mempool
char *l_tx_hash_str;
dap_get_data_hash_str_static(l_datum_tx->data, l_datum_tx->header.data_size, l_tx_hash_str);
bool l_placed = !dap_global_db_set(l_gdb_group_mempool_base_tx,l_tx_hash_str, l_datum_tx, l_datum_tx_size, false, NULL, NULL);
char *l_tx_hash_str = dap_get_data_hash_str(l_datum_tx->data, l_datum_tx->header.data_size).s;
bool l_placed = !dap_global_db_set(l_gdb_group_mempool_base_tx, l_tx_hash_str, l_datum_tx, l_datum_tx_size, false, NULL, NULL);
DAP_DEL_Z(l_datum_tx);
DAP_DELETE(l_gdb_group_mempool_base_tx);
......@@ -8247,46 +8244,26 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, void **a_str
dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, l_opts_signer[i].name, (const char **) &l_opts_sign[i]);
}
if (!l_opts_sign[OPT_CERT]) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s need to be selected", l_opts_signer[OPT_CERT].name);
return -1;
}
if (!l_opts_sign[OPT_CERT])
return dap_cli_server_cmd_set_reply_text(a_str_reply, "%s need to be selected", l_opts_signer[OPT_CERT].name), -1;
dap_chain_net_t *l_network = dap_chain_net_by_name(l_opts_sign[OPT_NET]);
if (!l_network) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s network not found", l_opts_sign[OPT_NET]);
return -1;
}
if ( !l_network )
return dap_cli_server_cmd_set_reply_text(a_str_reply, "%s network not found", l_opts_sign[OPT_NET]), -1;
dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_network, l_opts_sign[OPT_CHAIN]);
if (!l_chain) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s chain not found", l_opts_sign[OPT_CHAIN]);
return -1;
}
if (!l_chain)
return dap_cli_server_cmd_set_reply_text(a_str_reply, "%s chain not found", l_opts_sign[OPT_CHAIN]), -1;
int l_ret = 0;
dap_sign_t *l_sign = NULL;
dap_chain_datum_t *l_datum = NULL;
l_ret = s_get_key_from_file(l_opts_sign[OPT_FILE], l_opts_sign[OPT_MIME], l_opts_sign[OPT_CERT], &l_sign);
if (!l_ret) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s cert not found", l_opts_sign[OPT_CERT]);
return -1;
}
l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_SIGNER, l_sign->pkey_n_sign, l_sign->header.sign_size);
if (!l_datum) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "not created datum");
return -1;
}
l_ret = l_chain->callback_add_datums(l_chain, &l_datum, 1);
char *l_key_str;
dap_get_data_hash_str_static(l_datum->data, l_datum->header.data_size, l_key_str);
dap_cli_server_cmd_set_reply_text(a_str_reply, "hash: %s", l_key_str);
DAP_DELETE(l_datum);
return l_ret;
if ( !s_get_key_from_file(l_opts_sign[OPT_FILE], l_opts_sign[OPT_MIME], l_opts_sign[OPT_CERT], &l_sign) )
return dap_cli_server_cmd_set_reply_text(a_str_reply, "%s cert not found", l_opts_sign[OPT_CERT]), -1;
dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_SIGNER, l_sign->pkey_n_sign, l_sign->header.sign_size);
if (!l_datum)
return dap_cli_server_cmd_set_reply_text(a_str_reply, "not created datum"), -1;
dap_cli_server_cmd_set_reply_text(a_str_reply, "hash: %s", dap_get_data_hash_str(l_datum->data, l_datum->header.data_size));
return DAP_DELETE(l_datum), l_chain->callback_add_datums(l_chain, &l_datum, 1);
}
......