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 (10)
Hide whitespace changes
Inline Side-by-side
Showing
with 293 additions and 448 deletions
dap-sdk @ f2b762fc
Compare 16bc9813...f2b762fc
Subproject commit 16bc9813751b728c9b0ad67402198a5749a1ce86
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;
......@@ -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
......@@ -591,8 +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;
}
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");
......@@ -992,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;
......@@ -1023,14 +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;
s_session_send_startsync(l_session);
l_session->sync_timer = NULL;
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) {
......@@ -1092,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;
......@@ -1156,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);
}
......@@ -3084,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
......@@ -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);
......
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)
......@@ -2806,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;
......@@ -3208,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;
......
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_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);
}
......
modules/net/include/dap_chain_ledger.h
View file @ 8209034a
......@@ -451,6 +451,7 @@ dap_chain_datum_tx_t *dap_ledger_datum_iter_get_last(dap_ledger_datum_iter_t *a_
void dap_ledger_tx_add_notify(dap_ledger_t *a_ledger, dap_ledger_tx_add_notify_t a_callback, void *a_arg);
void dap_ledger_bridged_tx_notify_add(dap_ledger_t *a_ledger, dap_ledger_bridged_tx_notify_t a_callback, void *a_arg);
bool dap_ledger_datum_is_blacklisted(dap_ledger_t *a_ledger, dap_hash_fast_t a_hash);
bool dap_ledger_cache_enabled(dap_ledger_t *a_ledger);
void dap_ledger_set_cache_tx_check_callback(dap_ledger_t *a_ledger, dap_ledger_cache_tx_check_callback_t a_callback);
......
modules/net/include/dap_chain_net_balancer.h
View file @ 8209034a
......@@ -30,6 +30,8 @@ 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_balancer_request_info dap_balancer_request_info_t;
typedef struct dap_chain_net_links {
uint64_t count_node;
byte_t nodes_info[];
......@@ -40,6 +42,15 @@ typedef enum dap_balancer_type {
DAP_CHAIN_NET_BALANCER_TYPE_DNS
} dap_balancer_type_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_type_t type;
} dap_balancer_link_request_t;
DAP_STATIC_INLINE const char *dap_chain_net_balancer_type_to_str(dap_balancer_type_t a_type)
{
......@@ -54,4 +65,4 @@ void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, vo
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
void dap_chain_net_balancer_request(void *a_arg);
\ No newline at end of file