diff --git a/dap-sdk b/dap-sdk
index 024a62ba532fb809e88129c9bd47a4a88e3587ac..69e6e0d245c8d0ded155a79f268ff45300981021 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 024a62ba532fb809e88129c9bd47a4a88e3587ac
+Subproject commit 69e6e0d245c8d0ded155a79f268ff45300981021
diff --git a/modules/channel/chain-voting/dap_stream_ch_chain_voting.c b/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
index a289daba669399d30553ed47dfc39a5a7fd3c36c..22542e7b20ce4c3c5ba611f7be65afe3cc47cec3 100644
--- a/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
+++ b/modules/channel/chain-voting/dap_stream_ch_chain_voting.c
@@ -33,7 +33,6 @@ typedef struct voting_pkt_items {
typedef struct voting_node_client_list {
dap_chain_node_info_t *node_info;
dap_chain_node_client_t *node_client;
- dap_events_socket_uuid_t uuid;
dap_chain_node_addr_t node_addr;
UT_hash_handle hh;
} voting_node_client_list_t;
@@ -139,16 +138,8 @@ void dap_stream_ch_chain_voting_pkt_broadcast(dap_chain_net_t *a_net, dap_list_t
if ( l_remote_node_addr->uint64 != dap_chain_net_get_cur_addr_int(a_net) ) {
HASH_FIND(hh, s_node_client_list, l_remote_node_addr, sizeof(dap_chain_node_addr_t), l_node_item);
if (l_node_item) {
- dap_chain_node_client_t *l_usable = dap_chain_node_client_find(l_node_item->uuid);
- if (l_usable && !dap_client_get_stream(l_usable->client)) {
- dap_chain_node_client_close(l_node_item->uuid);
- l_usable = NULL;
- }
- if (!l_usable) {
- char l_channels[] = {dap_stream_ch_chain_voting_get_id(),0};
- l_node_item->node_client = dap_chain_node_client_connect_channels(a_net, l_node_item->node_info, l_channels);
- l_node_item->uuid = l_node_item->node_client->uuid;
- }
+ if (!dap_client_get_stream(l_node_item->node_client->client))
+ dap_chain_node_client_close_mt(l_node_item->node_client);
} else {
size_t node_info_size = 0;
char *l_key = dap_chain_node_addr_to_hash_str(l_remote_node_addr);
@@ -168,17 +159,12 @@ void dap_stream_ch_chain_voting_pkt_broadcast(dap_chain_net_t *a_net, dap_list_t
l_node_client_item->node_addr = *l_remote_node_addr;
l_node_client_item->node_info = l_node_info;
l_node_client_item->node_client = l_node_client;
- l_node_client_item->uuid = l_node_client->uuid;
HASH_ADD(hh, s_node_client_list, node_addr, sizeof(dap_chain_node_addr_t), l_node_client_item);
l_node_item = l_node_client_item;
}
if ( !l_node_item || !l_node_item->node_client ) {
continue;
}
- dap_client_pvt_t * l_client_pvt = dap_client_pvt_find(l_node_item->node_client->client->pvt_uuid);
- if (NULL == l_client_pvt) {
- continue;
- }
pthread_rwlock_wrlock(&s_pkt_items->rwlock_out);
dap_list_t* l_pkts_list_temp = s_pkt_items->pkts_out;
while(l_pkts_list_temp) {
diff --git a/modules/channel/chain/dap_stream_ch_chain.c b/modules/channel/chain/dap_stream_ch_chain.c
index 2196aa014307827e71b7a974ef0e729f50561dc3..83926112676f0ea1f812857fca17a36e30f6ed80 100644
--- a/modules/channel/chain/dap_stream_ch_chain.c
+++ b/modules/channel/chain/dap_stream_ch_chain.c
@@ -1656,10 +1656,12 @@ static void s_stream_ch_io_complete(dap_events_socket_t *a_es, void *a_arg, int
if (a_errno)
return;
dap_stream_t *l_stream = NULL;
- dap_client_pvt_t *l_client_pvt = DAP_ESOCKET_CLIENT_PVT(a_es);
- if (l_client_pvt && dap_client_pvt_find(l_client_pvt->uuid) == l_client_pvt)
+ if (!a_es->server) {
+ dap_client_t *l_client = DAP_ESOCKET_CLIENT(a_es);
+ assert(l_client);
+ dap_client_pvt_t *l_client_pvt = DAP_CLIENT_PVT(l_client);
l_stream = l_client_pvt->stream;
- else {
+ } else {
dap_http_client_t *l_http_client = DAP_HTTP_CLIENT(a_es);
if (l_http_client)
l_stream = DAP_STREAM(l_http_client);
diff --git a/modules/channel/chain/include/dap_stream_ch_chain_pkt.h b/modules/channel/chain/include/dap_stream_ch_chain_pkt.h
index 531f54d3f667fc1c16e9873f496a2f6dcd599e48..dabfa60e075034053aa74c81ea011364604041e8 100644
--- a/modules/channel/chain/include/dap_stream_ch_chain_pkt.h
+++ b/modules/channel/chain/include/dap_stream_ch_chain_pkt.h
@@ -113,7 +113,7 @@ typedef struct dap_stream_ch_chain_pkt_hdr{
uint8_t padding[7];
} DAP_ALIGN_PACKED;
uint64_t ext_id;
- }DAP_ALIGN_PACKED;
+ } DAP_ALIGN_PACKED;
dap_chain_net_id_t net_id;
dap_chain_id_t chain_id;
dap_chain_cell_id_t cell_id;
diff --git a/modules/common/include/dap_chain_common.h b/modules/common/include/dap_chain_common.h
index e038862770f87f2d4ba1b0ccdedf25c98a73a01b..09c070799482605cc42ed512bf61aef1de91b83c 100644
--- a/modules/common/include/dap_chain_common.h
+++ b/modules/common/include/dap_chain_common.h
@@ -233,8 +233,8 @@ typedef struct dap_chain_receipt_info {
union {
uint256_t value_datoshi; // Receipt value
uint64_t value_64; // Old receipts compliance
- };
-} dap_chain_receipt_info_t;
+ } DAP_ALIGN_PACKED;
+} DAP_ALIGN_PACKED dap_chain_receipt_info_t;
#ifdef __cplusplus
extern "C" {
diff --git a/modules/common/include/dap_chain_datum_tx_receipt.h b/modules/common/include/dap_chain_datum_tx_receipt.h
index 464973febbce36ce4f24a9691876f62db258e12a..60d2dd15ae0e7b2df648a6e1781f45668578a318 100644
--- a/modules/common/include/dap_chain_datum_tx_receipt.h
+++ b/modules/common/include/dap_chain_datum_tx_receipt.h
@@ -37,7 +37,7 @@ typedef struct dap_chain_datum_tx_receipt {
uint64_t size;
uint64_t exts_size;
byte_t exts_n_signs[]; // Signatures, first from provider, second from client
-}DAP_ALIGN_PACKED dap_chain_datum_tx_receipt_t;
+} DAP_ALIGN_PACKED dap_chain_datum_tx_receipt_t;
#ifdef __cplusplus
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index a69304f6947e0a9c33eef80e806ab2ca72a5d0c7..22e6b51e5b939fdb1e6dd526cb80e4472126b399 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -138,7 +138,6 @@ struct net_link {
uint64_t uplink_ip;
dap_chain_node_info_t *link_info;
dap_chain_node_client_t *link;
- dap_events_socket_uuid_t client_uuid;
UT_hash_handle hh;
};
@@ -343,6 +342,10 @@ char *dap_chain_net_get_gdb_group_acl(dap_chain_net_t *a_net)
*/
int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_new_state)
{
+ if (PVT(a_net)->load_mode) {
+ log_it(L_ERROR, "Can't chage state of loading network '%s'", a_net->pub.name);
+ return -1;
+ }
pthread_rwlock_wrlock(&PVT(a_net)->states_lock);
if (PVT(a_net)->state != NET_STATE_OFFLINE){
PVT(a_net)->state = PVT(a_net)->state_target = NET_STATE_OFFLINE;
@@ -354,8 +357,7 @@ int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_n
//PVT(a_net)->flags |= F_DAP_CHAIN_NET_SYNC_FROM_ZERO; // TODO set this flag according to -mode argument from command line
pthread_rwlock_unlock(&PVT(a_net)->states_lock);
- dap_proc_queue_add_callback(dap_events_worker_get_auto(), s_net_states_proc, a_net);
- return 0;
+ return dap_proc_queue_add_callback(dap_events_worker_get_auto(), s_net_states_proc, a_net);
}
dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t *a_net)
@@ -629,23 +631,26 @@ static int s_net_link_add(dap_chain_net_t *a_net, dap_chain_node_info_t *a_link_
return 0;
}
-static void s_net_link_remove(dap_chain_net_pvt_t *a_net_pvt, dap_events_socket_uuid_t a_client_uuid, bool a_rebase)
+static void s_net_link_remove(dap_chain_net_pvt_t *a_net_pvt, dap_chain_node_client_t *a_link, bool a_rebase)
{
struct net_link *l_link, *l_link_tmp, *l_link_found = NULL;
HASH_ITER(hh, a_net_pvt->net_links, l_link, l_link_tmp) {
- if (l_link->client_uuid == a_client_uuid) {
+ if (l_link->link == a_link) {
l_link_found = l_link;
break;
}
}
if (!l_link_found) {
- log_it(L_WARNING, "Can't find link UUID 0x%"DAP_UINT64_FORMAT_x" to remove it from links HT", a_client_uuid);
+ log_it(L_WARNING, "Can't find link %p to remove it from links HT", a_link);
return;
}
HASH_DEL(a_net_pvt->net_links, l_link_found);
+ dap_chain_node_client_t *l_client = l_link_found->link;
+ l_client->callbacks.delete = NULL;
+ a_net_pvt->links_queue = dap_list_remove_all(a_net_pvt->links_queue, l_client);
+ dap_chain_node_client_close_mt(l_client);
if (a_rebase) {
l_link_found->link = NULL;
- l_link_found->client_uuid = 0;
// Add it to the list end
HASH_ADD(hh, a_net_pvt->net_links, uplink_ip, sizeof(l_link_found->uplink_ip), l_link_found);
} else {
@@ -659,7 +664,7 @@ static size_t s_net_get_active_links_count(dap_chain_net_t * a_net)
int l_ret = 0;
struct net_link *l_link, *l_link_tmp;
HASH_ITER(hh, PVT(a_net)->net_links, l_link, l_link_tmp)
- if (l_link->client_uuid)
+ if (l_link->link)
l_ret++;
return l_ret;
}
@@ -692,7 +697,6 @@ static bool s_net_link_start(dap_chain_net_t *a_net, struct net_link *a_link, ui
else
return false;
a_link->link = l_client;
- a_link->client_uuid = l_client->uuid;
if (a_delay) {
dap_timerfd_start(a_delay * 1000, s_net_link_callback_connect_delayed, l_client);
return true;
@@ -784,7 +788,7 @@ static void s_node_link_callback_disconnected(dap_chain_node_client_t *a_node_cl
}
if (l_net_pvt->state_target != NET_STATE_OFFLINE) {
pthread_rwlock_wrlock(&l_net_pvt->uplinks_lock);
- s_net_link_remove(l_net_pvt, a_node_client->uuid, l_net_pvt->only_static_links);
+ s_net_link_remove(l_net_pvt, a_node_client, l_net_pvt->only_static_links);
a_node_client->keep_connection = false;
struct net_link *l_free_link = s_get_free_link(l_net);
if (l_free_link) {
@@ -1073,7 +1077,7 @@ static bool s_new_balancer_link_request(dap_chain_net_t *a_net, int a_link_repla
s_net_http_link_prepare_success,
s_net_http_link_prepare_error,
l_balancer_request,
- NULL);
+ NULL) == NULL;
} else {
l_link_node_info->hdr.ext_port = DNS_LISTEN_PORT;
ret = dap_chain_node_info_dns_request(l_balancer_request->worker,
@@ -1163,8 +1167,11 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
struct net_link *l_link, *l_link_tmp;
HASH_ITER(hh, l_net_pvt->net_links, l_link, l_link_tmp) {
HASH_DEL(l_net_pvt->net_links, l_link);
- if (l_link->link)
- dap_chain_node_client_close(l_link->client_uuid);
+ if (l_link->link) {
+ dap_chain_node_client_t *l_client = l_link->link;
+ l_client->callbacks.delete = NULL;
+ dap_chain_node_client_close_mt(l_client);
+ }
DAP_DEL_Z(l_link->link_info);
DAP_DELETE(l_link);
}
@@ -1268,15 +1275,10 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
return ! l_repeat_after_exit;
}
-int s_net_list_compare_uuids(const void *a_uuid1, const void *a_uuid2)
-{
- return memcmp(a_uuid1, a_uuid2, sizeof(dap_events_socket_uuid_t));
-}
-
bool dap_chain_net_sync_trylock(dap_chain_net_t *a_net, dap_chain_node_client_t *a_client)
{
dap_chain_net_pvt_t *l_net_pvt = PVT(a_net);
- int a_err = pthread_rwlock_rdlock(&l_net_pvt->uplinks_lock);
+ int a_err = pthread_rwlock_wrlock(&l_net_pvt->uplinks_lock);
bool l_found = false;
if (l_net_pvt->active_link) {
struct net_link *l_link, *l_link_tmp;
@@ -1294,10 +1296,8 @@ bool dap_chain_net_sync_trylock(dap_chain_net_t *a_net, dap_chain_node_client_t
if (!l_found) {
l_net_pvt->active_link = a_client;
}
- if (l_found && !dap_list_find_custom(l_net_pvt->links_queue, &a_client->uuid, s_net_list_compare_uuids)) {
- dap_events_socket_uuid_t *l_uuid = DAP_DUP(&a_client->uuid);
- l_net_pvt->links_queue = dap_list_append(l_net_pvt->links_queue, l_uuid);
- }
+ if (l_found && !dap_list_find(l_net_pvt->links_queue, a_client))
+ l_net_pvt->links_queue = dap_list_append(l_net_pvt->links_queue, a_client);
if (a_err != EDEADLK)
pthread_rwlock_unlock(&l_net_pvt->uplinks_lock);
return !l_found;
@@ -1313,10 +1313,9 @@ bool dap_chain_net_sync_unlock(dap_chain_net_t *a_net, dap_chain_node_client_t *
if (!a_client || l_net_pvt->active_link == a_client)
l_net_pvt->active_link = NULL;
while (l_net_pvt->active_link == NULL && l_net_pvt->links_queue) {
- dap_events_socket_uuid_t *l_uuid = l_net_pvt->links_queue->data;
- dap_chain_node_sync_status_t l_status = dap_chain_node_client_start_sync(l_uuid);
+ dap_chain_node_client_t *l_link = l_net_pvt->links_queue->data;
+ dap_chain_node_sync_status_t l_status = dap_chain_node_client_start_sync(l_link);
if (l_status != NODE_SYNC_STATUS_WAITING) {
- DAP_DELETE(l_net_pvt->links_queue->data);
dap_list_t *l_to_remove = l_net_pvt->links_queue;
l_net_pvt->links_queue = l_net_pvt->links_queue->next;
DAP_DELETE(l_to_remove);
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index cb8f668ede6ba21da022074baff6c88c41067c8c..41c0f5730f0fc4974ed01f46a2eeb3ee63c9b203 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -1167,7 +1167,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
l_node_addr.uint64 = l_remote_node_addr->uint64;
// clean client struct
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
DAP_DELETE(l_remote_node_info);
//return -1;
continue;
@@ -1189,7 +1189,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
dap_cli_server_cmd_set_reply_text(a_str_reply, "no response from remote node(s)");
log_it(L_WARNING, "No response from remote node(s): err code %d", res);
// clean client struct
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
//DAP_DELETE(l_remote_node_info);
return -1;
}
@@ -1216,7 +1216,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
NULL, 0);
if(res == 0) {
log_it(L_WARNING, "Can't send DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_ADDR_REQUEST packet");
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
DAP_DELETE(l_remote_node_info);
return -1;
}
@@ -1266,7 +1266,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
sizeof(l_sync_request))) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
// clean client struct
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
DAP_DELETE(l_remote_node_info);
return -1;
}
@@ -1278,7 +1278,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
if(res < 0) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Error: can't sync with node "NODE_ADDR_FP_STR,
NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr));
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
DAP_DELETE(l_remote_node_info);
log_it(L_WARNING, "Gdb synced err -2");
return -2;
@@ -1306,7 +1306,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
sizeof(l_sync_request))) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
// clean client struct
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
DAP_DELETE(l_remote_node_info);
log_it(L_INFO, "Chain '%s' synced error: Can't send sync chains request", l_chain->name);
return -3;
@@ -1326,7 +1326,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
DAP_DELETE(l_remote_node_info);
//dap_client_disconnect(l_node_client->client);
//l_node_client->client = NULL;
- dap_chain_node_client_close(l_node_client->uuid);
+ dap_chain_node_client_close_mt(l_node_client);
dap_cli_server_cmd_set_reply_text(a_str_reply, "Node sync completed: Chains and gdb are synced");
return 0;
@@ -1355,18 +1355,18 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
return -6;
int timeout_ms = 5000; //5 sec = 5000 ms
// start handshake
- dap_chain_node_client_t *client = dap_chain_node_client_connect_default_channels(l_net,node_info);
- if(!client) {
+ dap_chain_node_client_t *l_client = dap_chain_node_client_connect_default_channels(l_net,node_info);
+ if(!l_client) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't connect");
DAP_DELETE(node_info);
return -7;
}
// wait handshake
- int res = dap_chain_node_client_wait(client, NODE_CLIENT_STATE_ESTABLISHED, timeout_ms);
+ int res = dap_chain_node_client_wait(l_client, NODE_CLIENT_STATE_ESTABLISHED, timeout_ms);
if (res) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "No response from node");
// clean client struct
- dap_chain_node_client_close(client->uuid);
+ dap_chain_node_client_close_mt(l_client);
DAP_DELETE(node_info);
return -8;
}
diff --git a/modules/net/dap_chain_node_client.c b/modules/net/dap_chain_node_client.c
index ec000344e8781e77e94df92d154e8a9d635406a5..e8c4e591510e73b3aae5d8a31eaf5b9c15f6de9e 100644
--- a/modules/net/dap_chain_node_client.c
+++ b/modules/net/dap_chain_node_client.c
@@ -73,16 +73,6 @@
#define LOG_TAG "dap_chain_node_client"
-typedef struct dap_chain_node_client_handle {
- uint64_t uuid;
- dap_chain_node_client_t * client;
- UT_hash_handle hh;
-} dap_chain_node_client_handle_t;
-
-static dap_chain_node_client_handle_t * s_clients = NULL;
-
-//static int listen_port_tcp = 8079;
-
static void s_stage_connected_callback(dap_client_t *a_client, void *a_arg);
static bool s_timer_update_states_callback(void *a_arg);
static int s_node_client_set_notify_callbacks(dap_client_t *a_client, uint8_t a_ch_id);
@@ -118,51 +108,21 @@ int dap_chain_node_client_init(void)
*/
void dap_chain_node_client_deinit()
{
- dap_chain_node_client_handle_t *l_client = NULL, *l_tmp = NULL;
- HASH_ITER(hh, s_clients,l_client, l_tmp){
- // Clang bug at this, l_client should change at every loop cycle
- HASH_DEL(s_clients,l_client);
- DAP_DELETE(l_client);
- }
- //dap_http_client_simple_deinit();
dap_client_deinit();
}
-/**
- * @brief stage_status_callback
- * @param a_client
- * @param a_arg
- */
-static void s_stage_status_callback(dap_client_t *a_client, void *a_arg)
-{
- (void) a_client;
- (void) a_arg;
-
- //printf("* stage_status_callback client=%x data=%x\n", a_client, a_arg);
-}
-
static bool s_timer_node_reconnect(void *a_arg)
{
- dap_events_socket_uuid_t *l_uuid = (dap_events_socket_uuid_t *)a_arg;
- assert(l_uuid);
- dap_chain_node_client_handle_t *l_client_found = NULL;
- HASH_FIND(hh, s_clients, l_uuid, sizeof(*l_uuid), l_client_found);
- if(l_client_found) {
- dap_chain_node_client_t *l_me = l_client_found->client;
- if (l_me->keep_connection && l_me->state == NODE_CLIENT_STATE_DISCONNECTED) {
- if (dap_client_pvt_find(l_me->client->pvt_uuid)) {
- if (dap_client_get_stage(l_me->client) == STAGE_BEGIN) {
- log_it(L_INFO, "Reconnecting node client with peer "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_me->remote_node_addr));
- l_me->state = NODE_CLIENT_STATE_CONNECTING ;
- dap_client_go_stage(l_me->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
- } else {
- dap_chain_node_client_close(*l_uuid);
- }
- } else
- dap_chain_node_client_close(*l_uuid);
+ if (!a_arg)
+ return false;
+ dap_chain_node_client_t *l_me = a_arg;
+ if (l_me->keep_connection && l_me->state == NODE_CLIENT_STATE_DISCONNECTED) {
+ if (dap_client_get_stage(l_me->client) == STAGE_BEGIN) {
+ log_it(L_INFO, "Reconnecting node client with peer "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_me->remote_node_addr));
+ l_me->state = NODE_CLIENT_STATE_CONNECTING ;
+ dap_client_go_stage(l_me->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
}
}
- DAP_DELETE(l_uuid);
return false;
}
@@ -196,10 +156,8 @@ static void s_stage_status_error_callback(dap_client_t *a_client, void *a_arg)
if (l_node_client->keep_connection) {
if (dap_client_get_stage(l_node_client->client) != STAGE_BEGIN)
dap_client_go_stage(l_node_client->client, STAGE_BEGIN, NULL);
- dap_timerfd_start(45 * 1000, s_timer_node_reconnect, DAP_DUP(&l_node_client->uuid));
- } else
- dap_chain_node_client_close(l_node_client->uuid);
-
+ dap_timerfd_start(45 * 1000, s_timer_node_reconnect, l_node_client);
+ }
} else if(l_node_client->callbacks.error) // TODO make different error codes
l_node_client->callbacks.error(l_node_client, EINVAL, l_node_client->callbacks_arg);
}
@@ -213,8 +171,7 @@ static void s_stage_status_error_callback(dap_client_t *a_client, void *a_arg)
static void s_node_client_connected_synchro_start_callback(dap_worker_t *a_worker, void *a_arg)
{
UNUSED(a_worker);
- if (s_timer_update_states_callback(a_arg))
- DAP_DELETE(a_arg);
+ s_timer_update_states_callback(a_arg);
}
/**
@@ -223,56 +180,34 @@ static void s_node_client_connected_synchro_start_callback(dap_worker_t *a_worke
* @param a_wrlock
* @return
*/
-dap_chain_node_sync_status_t dap_chain_node_client_start_sync(dap_events_socket_uuid_t *a_uuid)
+dap_chain_node_sync_status_t dap_chain_node_client_start_sync(dap_chain_node_client_t *a_node_client)
{
- dap_chain_node_client_handle_t *l_client_found = NULL;
- HASH_FIND(hh, s_clients, a_uuid, sizeof(*a_uuid), l_client_found);
- if(!l_client_found){
- log_it(L_DEBUG,"Chain node client %p was deleted before timer fired, nothing to do", a_uuid);
- return NODE_SYNC_STATUS_MISSING;
- }
-
- dap_chain_node_client_t *l_me = l_client_found->client;
- dap_worker_t * l_worker = dap_worker_get_current();
- if (!l_worker)
- return NODE_SYNC_STATUS_FAILED;
- assert(l_me);
- dap_events_socket_t * l_es = NULL;
- dap_events_socket_uuid_t l_es_uuid = l_me->esocket_uuid;
+ assert(a_node_client);
// check if esocket still in worker
- if( (l_es = dap_context_find(l_worker->context, l_es_uuid)) != NULL ) {
- dap_client_t * l_client = dap_client_from_esocket(l_es);
- if (l_client ) {
- dap_chain_node_client_t * l_node_client = (dap_chain_node_client_t*) l_client->_inheritor;
- assert(l_node_client == l_me);
- if (l_node_client && l_node_client->ch_chain && l_node_client->stream_worker && l_node_client->ch_chain_uuid) {
- dap_stream_ch_t *l_ch = dap_stream_ch_find_by_uuid_unsafe(l_node_client->stream_worker, l_node_client->ch_chain_uuid);
- if (l_ch) {
- dap_stream_ch_chain_t *l_ch_chain = DAP_STREAM_CH_CHAIN(l_ch);
- assert(l_ch_chain);
- dap_chain_net_t * l_net = l_node_client->net;
- assert(l_net);
- // If we do nothing - init sync process
-
- if (l_ch_chain->state == CHAIN_STATE_IDLE) {
- bool l_trylocked = dap_chain_net_sync_trylock(l_net, l_node_client);
- if (l_trylocked) {
- log_it(L_INFO, "Start synchronization process with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr));
- dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
- l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
- dap_stream_ch_chain_pkt_write_unsafe(l_node_client->ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_UPDATE_GLOBAL_DB_REQ,
- l_net->pub.id.uint64, 0, 0,
- &l_sync_gdb, sizeof(l_sync_gdb));
- if (!l_ch_chain->activity_timer)
- dap_stream_ch_chain_timer_start(l_ch_chain);
- return NODE_SYNC_STATUS_STARTED;
- } else
- return NODE_SYNC_STATUS_WAITING;
- } else
- return NODE_SYNC_STATUS_IN_PROGRESS;
- }
- }
- }
+ dap_stream_ch_t *l_ch = dap_stream_ch_find_by_uuid_unsafe(a_node_client->stream_worker, a_node_client->ch_chain_uuid);
+ if (l_ch) {
+ dap_stream_ch_chain_t *l_ch_chain = DAP_STREAM_CH_CHAIN(l_ch);
+ assert(l_ch_chain);
+ dap_chain_net_t * l_net = a_node_client->net;
+ assert(l_net);
+ // If we do nothing - init sync process
+
+ if (l_ch_chain->state == CHAIN_STATE_IDLE) {
+ bool l_trylocked = dap_chain_net_sync_trylock(l_net, a_node_client);
+ if (l_trylocked) {
+ log_it(L_INFO, "Start synchronization process with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(a_node_client->remote_node_addr));
+ dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
+ l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
+ dap_stream_ch_chain_pkt_write_unsafe(a_node_client->ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_UPDATE_GLOBAL_DB_REQ,
+ l_net->pub.id.uint64, 0, 0,
+ &l_sync_gdb, sizeof(l_sync_gdb));
+ if (!l_ch_chain->activity_timer)
+ dap_stream_ch_chain_timer_start(l_ch_chain);
+ return NODE_SYNC_STATUS_STARTED;
+ } else
+ return NODE_SYNC_STATUS_WAITING;
+ } else
+ return NODE_SYNC_STATUS_IN_PROGRESS;
}
return NODE_SYNC_STATUS_FAILED;
}
@@ -284,41 +219,25 @@ dap_chain_node_sync_status_t dap_chain_node_client_start_sync(dap_events_socket_
*/
static bool s_timer_update_states_callback(void *a_arg)
{
- dap_events_socket_uuid_t *l_uuid = (dap_events_socket_uuid_t *)a_arg;
- assert(l_uuid);
- dap_chain_node_sync_status_t l_status = dap_chain_node_client_start_sync(l_uuid);
- if (l_status == NODE_SYNC_STATUS_MISSING) {
- DAP_DELETE(l_uuid);
+ if (!a_arg)
return false;
- }
+ dap_chain_node_client_t *l_me = a_arg;
+ dap_chain_node_sync_status_t l_status = dap_chain_node_client_start_sync(l_me);
if (l_status == NODE_SYNC_STATUS_FAILED) {
- dap_chain_node_client_handle_t *l_client_found = NULL;
- HASH_FIND(hh, s_clients, l_uuid, sizeof(*l_uuid), l_client_found);
- if(l_client_found) {
- dap_chain_node_client_t *l_me = l_client_found->client;
- l_me->state = NODE_CLIENT_STATE_DISCONNECTED;
+ l_me->state = NODE_CLIENT_STATE_DISCONNECTED;
+ if (l_me->keep_connection) {
+ if (dap_client_get_stage(l_me->client) != STAGE_BEGIN) {
+ dap_client_go_stage(l_me->client, STAGE_BEGIN, NULL);
+ return true;
+ }
+ if (l_me->is_connected && l_me->callbacks.disconnected)
+ l_me->callbacks.disconnected(l_me, l_me->callbacks_arg);
if (l_me->keep_connection) {
- if (dap_client_pvt_find(l_me->client->pvt_uuid)) {
- if (dap_client_get_stage(l_me->client) != STAGE_BEGIN) {
- dap_client_go_stage(l_me->client, STAGE_BEGIN, NULL);
- return true;
- }
- if (l_me->is_connected && l_me->callbacks.disconnected)
- l_me->callbacks.disconnected(l_me, l_me->callbacks_arg);
- if (l_me->keep_connection) {
- log_it(L_INFO, "Reconnecting node client with peer "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_me->remote_node_addr));
- l_me->state = NODE_CLIENT_STATE_CONNECTING ;
- dap_client_go_stage(l_me->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
- return true;
- } else {
- dap_chain_node_client_close(*l_uuid);
- }
- } else
- dap_chain_node_client_close(*l_uuid);
+ log_it(L_INFO, "Reconnecting node client with peer "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_me->remote_node_addr));
+ l_me->state = NODE_CLIENT_STATE_CONNECTING ;
+ dap_client_go_stage(l_me->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
}
}
- DAP_DELETE(l_uuid);
- return false;
}
return true;
}
@@ -337,11 +256,10 @@ static void s_stage_connected_callback(dap_client_t *a_client, void *a_arg)
log_it(L_NOTICE, "Stream connection with node " NODE_ADDR_FP_STR " established",
NODE_ADDR_FP_ARGS_S( l_node_client->remote_node_addr));
// set callbacks for C and N channels; for R and S it is not needed
- dap_client_pvt_t * l_client_internal = DAP_CLIENT_PVT(a_client);
- if(l_client_internal && l_client_internal->active_channels) {
- size_t l_channels_count = dap_strlen(l_client_internal->active_channels);
+ if (a_client->active_channels) {
+ size_t l_channels_count = dap_strlen(a_client->active_channels);
for(size_t i = 0; i < l_channels_count; i++) {
- if(s_node_client_set_notify_callbacks(a_client, l_client_internal->active_channels[i]) == -1) {
+ if(s_node_client_set_notify_callbacks(a_client, a_client->active_channels[i]) == -1) {
log_it(L_WARNING, "No ch_chain channel, can't init notify callback for pkt type CH_CHAIN");
return;
}
@@ -362,14 +280,12 @@ static void s_stage_connected_callback(dap_client_t *a_client, void *a_arg)
l_node_client->esocket_uuid = l_stream->esocket->uuid;
l_node_client->stream_worker = l_stream->stream_worker;
if (l_node_client->keep_connection) {
- dap_events_socket_uuid_t *l_uuid = DAP_DUP(&l_node_client->uuid);
- dap_events_socket_uuid_t *l_uuid_timer = DAP_DUP(&l_node_client->uuid);
if(l_node_client->stream_worker){
- dap_worker_exec_callback_on(l_stream->esocket->context->worker, s_node_client_connected_synchro_start_callback, l_uuid);
+ dap_worker_exec_callback_on(l_stream->esocket->context->worker, s_node_client_connected_synchro_start_callback, l_node_client);
l_node_client->sync_timer = dap_timerfd_start_on_worker(l_stream->esocket->context->worker,
s_timer_update_states * 1000,
s_timer_update_states_callback,
- l_uuid_timer);
+ l_node_client);
}else{
log_it(L_ERROR,"After NODE_CLIENT_STATE_ESTABLISHED: Node client has no worker, too dangerous to run update states in alien context");
}
@@ -576,11 +492,13 @@ static void s_ch_chain_callback_notify_packet_out(dap_stream_ch_chain_t* a_ch_ch
if(s_stream_ch_chain_debug_more)
log_it(L_INFO,"Out: chain %"DAP_UINT64_FORMAT_x" sent to uplink "NODE_ADDR_FP_STR,l_node_client->cur_chain ? l_node_client->cur_chain->id.uint64 : 0, NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr));
} break;
- case DAP_STREAM_CH_CHAIN_PKT_TYPE_TIMEOUT: {
+ case DAP_STREAM_CH_CHAIN_PKT_TYPE_TIMEOUT:
+ case DAP_STREAM_CH_CHAIN_PKT_TYPE_DELETE: {
dap_chain_net_t *l_net = l_node_client->net;
assert(l_net);
dap_chain_node_addr_t *l_node_addr = dap_chain_net_get_cur_addr(l_net);
- log_it(L_DEBUG, "In: State node %s."NODE_ADDR_FP_STR" is timeout for sync", l_net->pub.name, NODE_ADDR_FP_ARGS(l_node_addr));
+ log_it(L_DEBUG, "In: State node %s."NODE_ADDR_FP_STR" %s", l_net->pub.name, NODE_ADDR_FP_ARGS(l_node_addr),
+ a_pkt_type == DAP_STREAM_CH_CHAIN_PKT_TYPE_TIMEOUT ? "is timeout for sync" : "stream closed");
l_node_client->state = NODE_CLIENT_STATE_ERROR;
dap_timerfd_reset(l_node_client->sync_timer);
bool l_have_waiting = dap_chain_net_sync_unlock(l_net, l_node_client);
@@ -591,11 +509,7 @@ static void s_ch_chain_callback_notify_packet_out(dap_stream_ch_chain_t* a_ch_ch
dap_chain_net_state_go_to(l_net, NET_STATE_OFFLINE);
}
} break;
- case DAP_STREAM_CH_CHAIN_PKT_TYPE_DELETE: {
- dap_chain_node_client_close(l_node_client->uuid);
- } break;
- default: {
- }
+ default:;
}
}
@@ -765,13 +679,7 @@ dap_chain_node_client_t *dap_chain_node_client_create(dap_chain_net_t *a_net,
if (a_callbacks)
l_node_client->callbacks = *a_callbacks;
l_node_client->info = DAP_DUP(a_node_info);
- l_node_client->uuid = dap_uuid_generate_uint64();
l_node_client->net = a_net;
- dap_chain_node_client_handle_t * l_client_handle = DAP_NEW_Z(dap_chain_node_client_handle_t);
- l_client_handle->uuid = l_node_client->uuid;
- l_client_handle->client = l_node_client;
- HASH_ADD(hh, s_clients, uuid, sizeof(l_client_handle->uuid), l_client_handle);
-
#ifndef _WIN32
pthread_condattr_t attr;
pthread_condattr_init(&attr);
@@ -788,6 +696,12 @@ dap_chain_node_client_t *dap_chain_node_client_create(dap_chain_net_t *a_net,
return l_node_client;
}
+
+ void s_client_delete_callback(UNUSED_ATTR dap_client_t *a_client, void *a_arg)
+ {
+ assert(a_arg);
+ dap_chain_node_client_close_unsafe(a_arg);
+ }
/**
* @brief dap_chain_node_client_connect
* Create new dap_client, setup it, and send it in adventure trip
@@ -800,31 +714,29 @@ bool dap_chain_node_client_connect(dap_chain_node_client_t *a_node_client, const
{
if (!a_node_client)
return false;
- a_node_client->client = dap_client_new( s_stage_status_callback,
- s_stage_status_error_callback);
+ a_node_client->client = dap_client_new(s_client_delete_callback, s_stage_status_error_callback, a_node_client);
dap_client_set_is_always_reconnect(a_node_client->client, false);
a_node_client->client->_inheritor = a_node_client;
dap_client_set_active_channels_unsafe(a_node_client->client, a_active_channels);
dap_client_set_auth_cert(a_node_client->client, a_node_client->net->pub.name);
- int hostlen = 128;
- char host[hostlen];
+ char l_host_addr[INET6_ADDRSTRLEN];
if(a_node_client->info->hdr.ext_addr_v4.s_addr){
struct sockaddr_in sa4 = { .sin_family = AF_INET, .sin_addr = a_node_client->info->hdr.ext_addr_v4 };
- inet_ntop(AF_INET, &(((struct sockaddr_in *) &sa4)->sin_addr), host, hostlen);
+ inet_ntop(AF_INET, &(((struct sockaddr_in *) &sa4)->sin_addr), l_host_addr, INET6_ADDRSTRLEN);
} else {
struct sockaddr_in6 sa6 = { .sin6_family = AF_INET6, .sin6_addr = a_node_client->info->hdr.ext_addr_v6 };
- inet_ntop(AF_INET6, &(((struct sockaddr_in6 *) &sa6)->sin6_addr), host, hostlen);
+ inet_ntop(AF_INET6, &(((struct sockaddr_in6 *) &sa6)->sin6_addr), l_host_addr, INET6_ADDRSTRLEN);
}
- log_it(L_INFO, "Connecting to %s address", host);
+ log_it(L_INFO, "Connecting to %s address", l_host_addr);
// address not defined
- if(!strcmp(host, "::")) {
+ if(!strcmp(l_host_addr, "::")) {
log_it(L_WARNING, "Undefined address with node client connect to");
return false;
}
- dap_client_set_uplink_unsafe(a_node_client->client, host, a_node_client->info->hdr.ext_port);
- a_node_client->state = NODE_CLIENT_STATE_CONNECTING ;
+ dap_client_set_uplink_unsafe(a_node_client->client, l_host_addr, a_node_client->info->hdr.ext_port);
+ a_node_client->state = NODE_CLIENT_STATE_CONNECTING;
// Handshake & connect
dap_client_go_stage(a_node_client->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
return true;
@@ -842,69 +754,62 @@ void dap_chain_node_client_reset(dap_chain_node_client_t *a_client)
}
}
-dap_chain_node_client_t *dap_chain_node_client_find(dap_events_socket_uuid_t a_uuid)
-{
- dap_chain_node_client_handle_t * l_client_found = NULL;
- HASH_FIND(hh,s_clients, &a_uuid, sizeof(a_uuid), l_client_found);
- return l_client_found ? l_client_found->client : NULL;
-}
-
/**
* @brief dap_chain_node_client_close
* Close connection to server, delete chain_node_client_t *client
* @param a_client dap_chain_node_client_t
*/
-void dap_chain_node_client_close(dap_events_socket_uuid_t a_uuid)
+void dap_chain_node_client_close_unsafe(dap_chain_node_client_t *a_node_client)
{
- dap_chain_node_client_handle_t * l_client_found = NULL;
- HASH_FIND(hh, s_clients, &a_uuid, sizeof(a_uuid), l_client_found);
- if (l_client_found) {
- dap_chain_node_client_t *l_client = l_client_found->client;
- if (l_client->sync_timer) {
- DAP_DEL_Z(l_client->sync_timer->callback_arg);
- dap_timerfd_delete(l_client->sync_timer);
- }
- HASH_DEL(s_clients,l_client_found);
- DAP_DELETE(l_client_found);
- if (l_client->callbacks.delete)
- l_client->callbacks.delete(l_client, l_client->net);
- char l_node_addr_str[INET_ADDRSTRLEN] = {};
- inet_ntop(AF_INET, &l_client->info->hdr.ext_addr_v4, l_node_addr_str, INET_ADDRSTRLEN);
- log_it(L_INFO, "Closing node client to uplink %s:%d", l_node_addr_str, l_client->info->hdr.ext_port);
- if (l_client->stream_worker) {
- dap_stream_ch_t *l_ch = dap_stream_ch_find_by_uuid_unsafe(l_client->stream_worker, l_client->ch_chain_uuid);
- if (l_ch) {
- dap_stream_ch_chain_t *l_ch_chain = DAP_STREAM_CH_CHAIN(l_ch);
- l_ch_chain->callback_notify_packet_in = NULL;
- l_ch_chain->callback_notify_packet_out = NULL;
- }
- l_ch = dap_stream_ch_find_by_uuid_unsafe(l_client->stream_worker, l_client->ch_chain_net_uuid);
- if (l_ch) {
- dap_stream_ch_chain_net_t *l_ch_chain_net = DAP_STREAM_CH_CHAIN_NET(l_ch);
- l_ch_chain_net->notify_callback = NULL;
- }
+ if (a_node_client->sync_timer) {
+ a_node_client->sync_timer->callback_arg = NULL;
+ dap_timerfd_delete(a_node_client->sync_timer);
+ }
+ if (a_node_client->callbacks.delete)
+ a_node_client->callbacks.delete(a_node_client, a_node_client->net);
+ char l_node_addr_str[INET_ADDRSTRLEN] = {};
+ inet_ntop(AF_INET, &a_node_client->info->hdr.ext_addr_v4, l_node_addr_str, INET_ADDRSTRLEN);
+ log_it(L_INFO, "Closing node client to uplink %s:%d", l_node_addr_str, a_node_client->info->hdr.ext_port);
+ if (a_node_client->stream_worker) {
+ dap_stream_ch_t *l_ch = dap_stream_ch_find_by_uuid_unsafe(a_node_client->stream_worker, a_node_client->ch_chain_uuid);
+ if (l_ch) {
+ dap_stream_ch_chain_t *l_ch_chain = DAP_STREAM_CH_CHAIN(l_ch);
+ l_ch_chain->callback_notify_packet_in = NULL;
+ l_ch_chain->callback_notify_packet_out = NULL;
}
- // clean client
- dap_client_pvt_t *l_client_pvt = dap_client_pvt_find(l_client->client->pvt_uuid);
- if (l_client_pvt) {
- dap_client_delete_mt(l_client->client);
- l_client->client->_inheritor = NULL;
+ l_ch = dap_stream_ch_find_by_uuid_unsafe(a_node_client->stream_worker, a_node_client->ch_chain_net_uuid);
+ if (l_ch) {
+ dap_stream_ch_chain_net_t *l_ch_chain_net = DAP_STREAM_CH_CHAIN_NET(l_ch);
+ l_ch_chain_net->notify_callback = NULL;
}
+ }
+ // clean client
+ a_node_client->client->delete_callback = NULL;
+ dap_client_delete_unsafe(a_node_client->client);
#ifndef _WIN32
- pthread_cond_destroy(&l_client->wait_cond);
+ pthread_cond_destroy(&a_node_client->wait_cond);
#else
- CloseHandle( l_client->wait_cond );
+ CloseHandle( a_node_client->wait_cond );
#endif
- pthread_mutex_destroy(&l_client->wait_mutex);
- l_client->client = NULL;
- if (l_client->info)
- DAP_DELETE(l_client->info);
- DAP_DELETE(l_client);
- } else {
- log_it(L_WARNING, "Chain node client was removed from hash table before for some reasons");
- }
+ pthread_mutex_destroy(&a_node_client->wait_mutex);
+ a_node_client->client = NULL;
+ DAP_DEL_Z(a_node_client->info);
+ DAP_DELETE(a_node_client);
}
+void s_close_on_worker_callback(UNUSED_ATTR dap_worker_t *a_worker, void *a_arg)
+{
+ assert(a_arg);
+ dap_chain_node_client_close_unsafe(a_arg);
+}
+
+void dap_chain_node_client_close_mt(dap_chain_node_client_t *a_node_client)
+{
+ if (a_node_client->client)
+ dap_worker_exec_callback_on(DAP_CLIENT_PVT(a_node_client->client)->worker, s_close_on_worker_callback, a_node_client);
+ else
+ dap_chain_node_client_close_unsafe(a_node_client);
+}
/**
* @brief dap_chain_node_client_send_ch_pkt
@@ -1021,10 +926,7 @@ static int s_node_client_set_notify_callbacks(dap_client_t *a_client, uint8_t a_
if(l_node_client) {
pthread_mutex_lock(&l_node_client->wait_mutex);
// find current channel code
- dap_client_pvt_t * l_client_internal = DAP_CLIENT_PVT(a_client);
- dap_stream_ch_t * l_ch = NULL;
- if(l_client_internal)
- l_ch = dap_client_get_stream_ch_unsafe(a_client, a_ch_id);
+ dap_stream_ch_t *l_ch = dap_client_get_stream_ch_unsafe(a_client, a_ch_id);
if(l_ch) {
// C
if(a_ch_id == dap_stream_ch_chain_get_id()) {
diff --git a/modules/net/include/dap_chain_node_client.h b/modules/net/include/dap_chain_node_client.h
index 6a311c5f3aabd104e5a68efc5dc55a793953c45b..51c86e53e127c6b56eb5fe062adaba54b404827f 100644
--- a/modules/net/include/dap_chain_node_client.h
+++ b/modules/net/include/dap_chain_node_client.h
@@ -54,8 +54,7 @@ typedef enum dap_chain_node_sync_status {
NODE_SYNC_STATUS_STARTED = 0,
NODE_SYNC_STATUS_WAITING = 1,
NODE_SYNC_STATUS_IN_PROGRESS = 2,
- NODE_SYNC_STATUS_FAILED = -1,
- NODE_SYNC_STATUS_MISSING = -2
+ NODE_SYNC_STATUS_FAILED = -1
} dap_chain_node_sync_status_t;
typedef struct dap_chain_node_client dap_chain_node_client_t;
@@ -83,9 +82,6 @@ typedef struct dap_chain_node_client_notify_callbacks {
// state for a client connection
typedef struct dap_chain_node_client {
- // Sould be first with current architecture
- dap_events_socket_uuid_t uuid;
-
dap_chain_node_client_state_t state;
bool resync_gdb;
bool resync_chains;
@@ -171,6 +167,12 @@ DAP_STATIC_INLINE dap_chain_node_client_t* dap_chain_node_client_connect_default
{ return dap_chain_node_client_connect_channels(a_net,a_node_info, "CN"); }
+DAP_STATIC_INLINE ssize_t dap_chain_node_client_write_unsafe(dap_chain_node_client_t *a_client, const char a_ch_id, uint8_t a_type, void *a_data, size_t a_data_size)
+{ return dap_client_write_unsafe(a_client->client, a_ch_id, a_type, a_data, a_data_size); }
+
+DAP_STATIC_INLINE int dap_chain_node_client_write_mt(dap_chain_node_client_t *a_client, const char a_ch_id, uint8_t a_type, void *a_data, size_t a_data_size)
+{ return dap_client_write_mt(a_client->client, a_ch_id, a_type, a_data, a_data_size); }
+
dap_chain_node_client_t *dap_chain_node_client_find(dap_events_socket_uuid_t a_uuid);
/**
@@ -180,7 +182,8 @@ void dap_chain_node_client_reset(dap_chain_node_client_t *a_client);
/**
* Close connection to server, delete chain_node_client_t with specified UUID
*/
-void dap_chain_node_client_close(dap_events_socket_uuid_t a_uuid);
+void dap_chain_node_client_close_unsafe(dap_chain_node_client_t *a_node_client);
+void dap_chain_node_client_close_mt(dap_chain_node_client_t *a_node_client);
/**
* Send stream request to server
@@ -199,7 +202,7 @@ int dap_chain_node_client_wait(dap_chain_node_client_t *a_client, int a_waited_s
int dap_chain_node_client_send_nodelist_req(dap_chain_node_client_t *a_client);
-dap_chain_node_sync_status_t dap_chain_node_client_start_sync(dap_events_socket_uuid_t *l_uuid);
+dap_chain_node_sync_status_t dap_chain_node_client_start_sync(dap_chain_node_client_t *a_node_client);
static inline const char * dap_chain_node_client_state_to_str( dap_chain_node_client_state_t a_state)
{
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index 031f517523735314fb41d07a6d018c14da04f9e3..79388b31622ecb97db2af1edd7f3989a2d1e2580 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -531,7 +531,7 @@ int dap_chain_net_vpn_client_check(dap_chain_net_t *a_net, const char *a_ipv4_st
if(l_res) {
log_it(L_ERROR, "No response from VPN server=%s:%d", a_ipv4_str, a_port);
// clean client struct
- dap_chain_node_client_close(s_vpn_client->uuid);
+ dap_chain_node_client_close_mt(s_vpn_client);
DAP_DELETE(s_node_info);
s_node_info = NULL;
return -3;
@@ -577,7 +577,7 @@ int dap_chain_net_vpn_client_check(dap_chain_net_t *a_net, const char *a_ipv4_st
log_it(L_NOTICE, "Got response from VPN server=%s:%d", a_ipv4_str, a_port);
}
// clean client struct
- dap_chain_node_client_close(s_vpn_client->uuid);
+ dap_chain_node_client_close_mt(s_vpn_client);
DAP_DELETE(s_node_info);
s_node_info = NULL;
if(l_res)
@@ -610,7 +610,7 @@ int dap_chain_net_vpn_client_start(dap_chain_net_t *a_net, const char *a_ipv4_st
if(!s_vpn_client) {
log_it(L_ERROR, "Can't connect to VPN server=%s:%d", a_ipv4_str, a_port);
// clean client struct
- dap_chain_node_client_close(s_vpn_client->uuid);
+ dap_chain_node_client_close_mt(s_vpn_client);
DAP_DELETE(s_node_info);
s_node_info = NULL;
return -2;
@@ -621,7 +621,7 @@ int dap_chain_net_vpn_client_start(dap_chain_net_t *a_net, const char *a_ipv4_st
if(res) {
log_it(L_ERROR, "No response from VPN server=%s:%d", a_ipv4_str, a_port);
// clean client struct
- dap_chain_node_client_close(s_vpn_client->uuid);
+ dap_chain_node_client_close_mt(s_vpn_client);
DAP_DELETE(s_node_info);
s_node_info = NULL;
return -3;
@@ -660,7 +660,7 @@ int dap_chain_net_vpn_client_stop(void)
{
// delete connection with VPN server
if(s_vpn_client) {
- dap_chain_node_client_close(s_vpn_client->uuid);
+ dap_chain_node_client_close_mt(s_vpn_client);
s_vpn_client = NULL;
}
DAP_DELETE(s_node_info);