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 (6)
Hide whitespace changes
Inline Side-by-side
Showing
with 242 additions and 423 deletions
dap-sdk/net/client/dap_client_http.c
View file @ 1ceb8c13
...@@ -341,6 +341,10 @@ void* dap_client_http_request_custom(const char *a_uplink_addr, uint16_t a_uplin ...@@ -341,6 +341,10 @@ void* dap_client_http_request_custom(const char *a_uplink_addr, uint16_t a_uplin
// create socket // create socket
int l_socket = socket( PF_INET, SOCK_STREAM, 0); int l_socket = socket( PF_INET, SOCK_STREAM, 0);
if (l_socket == -1) {
log_it(L_ERROR, "Error %d with socket create", errno);
return NULL;
}
// set socket param // set socket param
int buffsize = DAP_CLIENT_HTTP_RESPONSE_SIZE_MAX; int buffsize = DAP_CLIENT_HTTP_RESPONSE_SIZE_MAX;
#ifdef _WIN32 #ifdef _WIN32
......
dap-sdk/net/client/dap_client_pvt.c
View file @ 1ceb8c13
...@@ -439,6 +439,11 @@ static void s_stage_status_after(dap_client_pvt_t * a_client_pvt) ...@@ -439,6 +439,11 @@ static void s_stage_status_after(dap_client_pvt_t * a_client_pvt)
log_it(L_INFO, "Go to stage STREAM_SESSION: process the state ops"); log_it(L_INFO, "Go to stage STREAM_SESSION: process the state ops");
a_client_pvt->stream_socket = socket( PF_INET, SOCK_STREAM, 0); a_client_pvt->stream_socket = socket( PF_INET, SOCK_STREAM, 0);
if (a_client_pvt->stream_socket == -1) {
log_it(L_ERROR, "Error %d with socket create", errno);
a_client_pvt->stage_status = STAGE_STATUS_ERROR;
break;
}
#ifdef _WIN32 #ifdef _WIN32
{ {
int buffsize = 65536; int buffsize = 65536;
......
dap-sdk/net/server/enc_server/dap_enc_http.c
View file @ 1ceb8c13
...@@ -124,9 +124,6 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg) ...@@ -124,9 +124,6 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg)
dap_enc_key_delete(msrln_key); dap_enc_key_delete(msrln_key);
*return_code = Http_Status_OK; *return_code = Http_Status_OK;
*return_code = Http_Status_Unauthorized;
} else{ } else{
log_it(L_ERROR,"Wrong path '%s' in the request to enc_http module",cl_st->http->url_path); log_it(L_ERROR,"Wrong path '%s' in the request to enc_http module",cl_st->http->url_path);
*return_code = Http_Status_NotFound; *return_code = Http_Status_NotFound;
......
dap-sdk/net/stream/ch/dap_stream_ch.c
View file @ 1ceb8c13
...@@ -132,6 +132,10 @@ void dap_stream_ch_delete(dap_stream_ch_t *a_ch) ...@@ -132,6 +132,10 @@ void dap_stream_ch_delete(dap_stream_ch_t *a_ch)
pthread_mutex_lock(&s_ch_table_lock); pthread_mutex_lock(&s_ch_table_lock);
struct dap_stream_ch_table_t *l_ret;; struct dap_stream_ch_table_t *l_ret;;
HASH_FIND_PTR(s_ch_table, a_ch, l_ret); HASH_FIND_PTR(s_ch_table, a_ch, l_ret);
if (!l_ret) {
pthread_mutex_unlock(&s_ch_table_lock);
return;
}
HASH_DEL(s_ch_table, l_ret); HASH_DEL(s_ch_table, l_ret);
pthread_mutex_unlock(&s_ch_table_lock); pthread_mutex_unlock(&s_ch_table_lock);
......
modules/channel/chain/dap_stream_ch_chain.c
View file @ 1ceb8c13
...@@ -510,9 +510,28 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg) ...@@ -510,9 +510,28 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
} }
} }
break; break;
default:{ case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS: {
dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
memcpy(&l_sync_gdb, l_chain_pkt->data, l_chain_pkt_data_size);
dap_chain_net_t *l_net = dap_chain_net_by_id(l_ch_chain->request_net_id);
l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr(l_net) ?
dap_chain_net_get_cur_addr(l_net)->uint64 :
dap_db_get_cur_node_addr(l_net->pub.name);
// Get last timestamp in log
l_sync_gdb.id_start = (uint64_t) dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);
// no limit
l_sync_gdb.id_end = (uint64_t)0;
dap_stream_ch_chain_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB, l_chain_pkt->hdr.net_id,
l_chain_pkt->hdr.chain_id, l_chain_pkt->hdr.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
}
case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS: {
dap_stream_ch_chain_sync_request_t l_sync_chains = {};
dap_stream_ch_chain_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS, l_chain_pkt->hdr.net_id,
l_chain_pkt->hdr.chain_id, l_chain_pkt->hdr.cell_id, &l_sync_chains, sizeof(l_sync_chains));
}
default: {
//log_it(L_INFO, "Get %s packet", c_dap_stream_ch_chain_pkt_type_str[l_ch_pkt->hdr.type]); //log_it(L_INFO, "Get %s packet", c_dap_stream_ch_chain_pkt_type_str[l_ch_pkt->hdr.type]);
} }
} }
if(l_ch_chain->callback_notify_packet_in) if(l_ch_chain->callback_notify_packet_in)
l_ch_chain->callback_notify_packet_in(l_ch_chain, l_ch_pkt->hdr.type, l_chain_pkt, l_ch_chain->callback_notify_packet_in(l_ch_chain, l_ch_pkt->hdr.type, l_chain_pkt,
......
modules/channel/chain/include/dap_stream_ch_chain_pkt.h
View file @ 1ceb8c13
...@@ -44,6 +44,8 @@ ...@@ -44,6 +44,8 @@
#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB 0x12 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB 0x12
#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_ALL 0x22 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_ALL 0x22
#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS 0x04
#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS 0x14
#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS 0x03 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS 0x03
#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB 0x13 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB 0x13
......
modules/net/dap_chain_net.c
View file @ 1ceb8c13
...@@ -119,18 +119,12 @@ typedef struct dap_chain_net_pvt{ ...@@ -119,18 +119,12 @@ typedef struct dap_chain_net_pvt{
time_t last_sync; time_t last_sync;
dap_chain_node_addr_t * node_addr; dap_chain_node_addr_t * node_addr;
dap_chain_node_info_t * node_info; // Current node's info dap_chain_node_info_t * node_info; // Current node's info
dap_chain_node_client_t * links; dap_list_t *links; // Links list
dap_list_t *links_info; // Links info list
dap_chain_node_addr_t *links_addrs;
size_t links_count;
size_t links_addrs_count;
size_t links_success;
size_t addr_request_attempts;
bool load_mode; bool load_mode;
uint8_t padding2[7];
char ** seed_aliases; char ** seed_aliases;
uint16_t gdb_sync_groups_count; uint16_t gdb_sync_groups_count;
...@@ -138,7 +132,6 @@ typedef struct dap_chain_net_pvt{ ...@@ -138,7 +132,6 @@ typedef struct dap_chain_net_pvt{
char **gdb_sync_groups; char **gdb_sync_groups;
dap_chain_node_addr_t *gdb_sync_nodes_addrs; dap_chain_node_addr_t *gdb_sync_nodes_addrs;
uint8_t padding3[6];
uint16_t seed_aliases_count; uint16_t seed_aliases_count;
dap_chain_net_state_t state; dap_chain_net_state_t state;
...@@ -328,18 +321,19 @@ static int s_net_states_proc(dap_chain_net_t * l_net) ...@@ -328,18 +321,19 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
int ret=0; int ret=0;
switch ( l_pvt_net->state ){ switch (l_pvt_net->state) {
case NET_STATE_OFFLINE:{ case NET_STATE_OFFLINE: {
// reset current link
l_pvt_net->links_count = 0;
// delete all links // delete all links
dap_chain_node_client_close(l_pvt_net->links); dap_list_t *l_tmp = l_pvt_net->links;
while (l_tmp) {
dap_list_t *l_next =l_tmp->next;
dap_chain_node_client_close(l_tmp->data);
DAP_DELETE(l_tmp);
l_tmp = l_next;
}
l_pvt_net->links = NULL; l_pvt_net->links = NULL;
l_pvt_net->links_addrs_count = 0; dap_list_free_full(l_pvt_net->links_info, free);
if ( l_pvt_net->links_addrs ) l_pvt_net->links_info = NULL;
DAP_DELETE(l_pvt_net->links_addrs);
l_pvt_net->links_addrs = NULL;
if ( l_pvt_net->state_target != NET_STATE_OFFLINE ){ if ( l_pvt_net->state_target != NET_STATE_OFFLINE ){
l_pvt_net->state = NET_STATE_LINKS_PREPARE; l_pvt_net->state = NET_STATE_LINKS_PREPARE;
break; break;
...@@ -348,407 +342,202 @@ static int s_net_states_proc(dap_chain_net_t * l_net) ...@@ -348,407 +342,202 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
l_pvt_net->flags &= ~F_DAP_CHAIN_NET_GO_SYNC; l_pvt_net->flags &= ~F_DAP_CHAIN_NET_GO_SYNC;
l_pvt_net->last_sync = 0; l_pvt_net->last_sync = 0;
} break; } break;
case NET_STATE_LINKS_PREPARE:{
case NET_STATE_LINKS_PREPARE: {
log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_PREPARE",l_net->pub.name); log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_PREPARE",l_net->pub.name);
if (l_pvt_net->node_info) {
for (size_t i = 0; i < l_pvt_net->node_info->hdr.links_number; i++) {
dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, &l_pvt_net->node_info->links[i]);
if (l_link_node_info->hdr.address.uint64 == l_pvt_net->node_info->hdr.address.uint64) {
continue; // Do not link with self
}
l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
}
} else {
log_it(L_WARNING,"No nodeinfo in global_db to prepare links for connecting, find nearest 3 links and fill global_db");
}
switch (l_pvt_net->node_role.enums) { switch (l_pvt_net->node_role.enums) {
case NODE_ROLE_ROOT: case NODE_ROLE_ROOT:
case NODE_ROLE_ROOT_MASTER: case NODE_ROLE_ROOT_MASTER:
case NODE_ROLE_ARCHIVE: case NODE_ROLE_ARCHIVE:
case NODE_ROLE_CELL_MASTER:{ case NODE_ROLE_CELL_MASTER: {
// This roles load predefined links from global_db // Add other root nodes as synchronization links
if ( l_pvt_net->node_info ) { while (dap_list_length(l_pvt_net->links_info) < s_max_links_count) {
if (l_pvt_net->links_addrs ) int i = rand() % l_pvt_net->seed_aliases_count;
DAP_DELETE(l_pvt_net->links_addrs); dap_chain_node_addr_t *l_link_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
l_pvt_net->links_addrs_count = l_pvt_net->node_info->hdr.links_number; dap_chain_node_info_read(l_net, l_link_addr);
l_pvt_net->links_addrs = DAP_NEW_Z_SIZE( dap_chain_node_addr_t,
l_pvt_net->links_addrs_count * sizeof(dap_chain_node_addr_t));
for (size_t i =0 ; i < l_pvt_net->node_info->hdr.links_number; i++ ){
l_pvt_net->links_addrs[i].uint64 = l_pvt_net->node_info->links[i].uint64;
}
}else {
log_it(L_WARNING,"No nodeinfo in global_db to prepare links for connecting, find nearest 3 links and fill global_db");
}
// add other root nodes for connect
//if(!l_pvt_net->links_addrs_count)
{
// use no more then 4 root node
int l_use_root_nodes = min(4, l_pvt_net->seed_aliases_count);
if(!l_pvt_net->links_addrs_count) {
l_pvt_net->links_addrs = DAP_NEW_Z_SIZE(dap_chain_node_addr_t,
l_use_root_nodes * sizeof(dap_chain_node_addr_t));
}
else{
l_pvt_net->links_addrs = DAP_REALLOC(l_pvt_net->links_addrs,
(l_pvt_net->links_addrs_count+l_use_root_nodes) * sizeof(dap_chain_node_addr_t));
memset(l_pvt_net->links_addrs + l_pvt_net->links_addrs_count, 0,
l_use_root_nodes * sizeof(dap_chain_node_addr_t));
}
for(uint16_t i = 0; i < l_use_root_nodes; i++) {
dap_chain_node_addr_t * l_node_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
if(l_node_addr) {
l_pvt_net->links_addrs[l_pvt_net->links_addrs_count].uint64 = l_node_addr->uint64;
l_pvt_net->links_addrs_count++;
}
}
}
// shuffle the order of the nodes
for(size_t i = 0; i < l_pvt_net->links_addrs_count; i++) {
unsigned int l_new_node_pos = rand() % (l_pvt_net->links_addrs_count);
if(i == l_new_node_pos)
continue;
uint64_t l_tmp_uint64 = l_pvt_net->links_addrs[i].uint64;
l_pvt_net->links_addrs[i].uint64 = l_pvt_net->links_addrs[l_new_node_pos].uint64;
l_pvt_net->links_addrs[l_new_node_pos].uint64 = l_tmp_uint64;
} }
} break; } break;
case NODE_ROLE_FULL: case NODE_ROLE_FULL:
case NODE_ROLE_MASTER: case NODE_ROLE_MASTER:
case NODE_ROLE_LIGHT:{ case NODE_ROLE_LIGHT:
// If we haven't any assigned shard - connect to root-0 default: {
if(1) { //if(l_net->pub.cell_id.uint64 == 0) { // Get DNS request result from root nodes as synchronization links
while (dap_list_length(l_pvt_net->links_info) < s_max_links_count) {
//dap_chain_net_pvt_t *pvt_debug = l_pvt_net; int i = rand() % l_pvt_net->seed_aliases_count;
// get current node address dap_chain_node_addr_t *l_remote_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
dap_chain_node_addr_t l_address; dap_chain_node_info_t *l_remote_node_info = dap_chain_node_info_read(l_net, l_remote_addr);
l_address.uint64 = dap_chain_net_get_cur_addr(l_net) ? dap_chain_node_info_t *l_link_node_info = DAP_NEW_Z(dap_chain_node_info_t);
dap_chain_net_get_cur_addr(l_net)->uint64 : int res = 0;//dap_dns_client_get_addr(l_remote_node_info->hdr.ext_addr_v4.s_addr, l_net->pub.name, l_link_node_info);
dap_db_get_cur_node_addr(l_net->pub.name); memcpy(l_link_node_info, l_remote_node_info, sizeof(dap_chain_node_info_t));
DAP_DELETE(l_remote_node_info);
// get current node info if (res) {
dap_chain_node_info_t *l_cur_node_info = dap_chain_node_info_read(l_net, &l_address); DAP_DELETE(l_link_node_info);
} else {
if ( l_cur_node_info ) { l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
uint16_t l_links_addrs_count = l_cur_node_info->hdr.links_number + l_pvt_net->seed_aliases_count;
l_pvt_net->links_addrs = DAP_NEW_Z_SIZE(dap_chain_node_addr_t,
l_links_addrs_count * sizeof(dap_chain_node_addr_t));
// add linked nodes for connect
for(uint16_t i = 0; i < min(s_max_links_count, l_cur_node_info->hdr.links_number); i++) {
dap_chain_node_addr_t *l_addr = l_cur_node_info->links + i;
//dap_chain_node_addr_t link_addr = l_cur_node_info->links[i];
dap_chain_node_info_t *l_remore_node_info = dap_chain_node_info_read(l_net, l_addr);
if(l_remore_node_info) {
// if only nodes from the same cell of cell=0
if(!l_cur_node_info->hdr.cell_id.uint64 ||
l_cur_node_info->hdr.cell_id.uint64 == l_remore_node_info->hdr.cell_id.uint64) {
l_pvt_net->links_addrs[l_pvt_net->links_addrs_count].uint64 =
l_remore_node_info->hdr.address.uint64;
l_pvt_net->links_addrs_count++;
}
DAP_DELETE(l_remore_node_info);
}
} }
} if (l_pvt_net->state_target == NET_STATE_OFFLINE) {
// if no links then add root nodes for connect l_pvt_net->state = NET_STATE_OFFLINE;
if(!l_pvt_net->links_addrs_count){ break;
// use no more then s_max_links_count root node
int l_use_root_nodes = min(s_max_links_count, l_pvt_net->seed_aliases_count);
l_pvt_net->links_addrs = DAP_NEW_Z_SIZE(dap_chain_node_addr_t,
l_use_root_nodes * sizeof(dap_chain_node_addr_t));
for(uint16_t i = 0; i < l_use_root_nodes; i++) {
dap_chain_node_addr_t * l_node_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
if(l_node_addr) {
l_pvt_net->links_addrs[l_pvt_net->links_addrs_count].uint64 = l_node_addr->uint64;
l_pvt_net->links_addrs_count++;
}
} }
} }
// shuffle the order of the nodes
for(size_t i = 0; i < l_pvt_net->links_addrs_count; i++) {
unsigned int l_new_node_pos = rand() % (l_pvt_net->links_addrs_count);
if(i==l_new_node_pos)
continue;
uint64_t l_tmp_uint64 = l_pvt_net->links_addrs[i].uint64;
l_pvt_net->links_addrs[i].uint64 = l_pvt_net->links_addrs[l_new_node_pos].uint64;
l_pvt_net->links_addrs[l_new_node_pos].uint64 = l_tmp_uint64;
}
DAP_DELETE(l_cur_node_info);
}else {
// TODO read cell's nodelist and populate array with it
}
} break; } break;
} }
if ( l_pvt_net->state_target > NET_STATE_LINKS_PREPARE ){ if (l_pvt_net->state_target != NET_STATE_OFFLINE) {
if ( l_pvt_net->links_addrs_count>0 ) { // If links are present l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
l_pvt_net->state = NET_STATE_LINKS_CONNECTING; log_it(L_DEBUG, "Prepared %u links, start to establish them", dap_list_length(l_pvt_net->links_info));
log_it(L_DEBUG,"Prepared %u links, start to establish them", l_pvt_net->links_addrs_count );
} else {
log_it(L_WARNING,"No links for connecting, return back to OFFLINE state");
l_pvt_net->state = NET_STATE_OFFLINE;
// remove looping
l_pvt_net->state_target = NET_STATE_OFFLINE;
}
}else {
log_it(L_WARNING,"Target state is NET_STATE_LINKS_PREPARE? Realy?");
l_pvt_net->state = NET_STATE_OFFLINE;
}
l_pvt_net->links_success = 0;
}
break;
case NET_STATE_LINKS_CONNECTING:{
size_t l_links_count = l_pvt_net->links_count;
if (l_pvt_net->links_success >= s_required_links_count) {
log_it(L_INFO, "Synchronization done");
l_pvt_net->links_count = 0;
l_pvt_net->links_success = 0;
l_pvt_net->flags &= ~F_DAP_CHAIN_NET_GO_SYNC;
l_pvt_net->state = NET_STATE_ONLINE;
break;
}
if (l_links_count < l_pvt_net->links_addrs_count) {
l_pvt_net->links_count++;
} else { } else {
log_it(L_NOTICE, "Can't establish enough links, go to offline"); l_pvt_net->state = l_pvt_net->state_target = NET_STATE_OFFLINE;
l_pvt_net->state = NET_STATE_OFFLINE;
l_pvt_net->state_target = NET_STATE_OFFLINE;
break;
} }
} break;
case NET_STATE_LINKS_CONNECTING: {
log_it(L_DEBUG, "%s.state: NET_STATE_LINKS_CONNECTING",l_net->pub.name); log_it(L_DEBUG, "%s.state: NET_STATE_LINKS_CONNECTING",l_net->pub.name);
log_it(L_DEBUG, "Establishing connection with " NODE_ADDR_FP_STR, for (dap_list_t *l_tmp = l_pvt_net->links_info; l_tmp; l_tmp = dap_list_next(l_tmp)) {
NODE_ADDR_FP_ARGS_S( l_pvt_net->links_addrs[l_links_count]) ); dap_chain_node_info_t *l_link_info = (dap_chain_node_info_t *)l_tmp->data;
dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, &l_pvt_net->links_addrs[l_links_count]); dap_chain_node_client_t *l_node_client = dap_chain_node_client_connect(l_link_info);
if ( l_link_node_info ) { if (l_node_client) {
dap_chain_node_client_t *l_node_client = dap_chain_node_client_connect(l_link_node_info); // wait connected
if(!l_node_client) { int timeout_ms = 5000; //5 sec = 5000 ms
DAP_DELETE(l_link_node_info); int res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_CONNECTED, timeout_ms);
ret = -1; if (res == 0 ) {
break; log_it(L_DEBUG, "Established connection with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_link_info->hdr.address));
l_pvt_net->links = dap_list_append(l_pvt_net->links, l_node_client);
} else {
dap_chain_node_client_close(l_node_client);
l_node_client = NULL;
}
} }
// wait connected if (!l_node_client) {
int timeout_ms = 5000; //5 sec = 5000 ms log_it(L_DEBUG, "Can't establish link with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_link_info->hdr.address));
int res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_CONNECTED, timeout_ms); }
if (res == 0 ){ if (dap_list_length(l_pvt_net->links) >= s_required_links_count) {
log_it(L_DEBUG, "Connected link %u", l_links_count); break;
l_pvt_net->links = l_node_client;
l_pvt_net->state = NET_STATE_LINKS_ESTABLISHED;
}else {
log_it(L_DEBUG, "Cant establish link %u", l_links_count);
dap_chain_node_client_close(l_node_client);
l_pvt_net->links = NULL;
} }
} }
} if (l_pvt_net->links) { // We have at least one working link
break; l_pvt_net->state = NET_STATE_SYNC_GDB;
} else { // Try to find another links
struct timespec l_sleep = {3, 0};
nanosleep(&l_sleep, NULL);
l_pvt_net->state = NET_STATE_OFFLINE;
}
} break;
case NET_STATE_LINKS_ESTABLISHED:{ case NET_STATE_SYNC_GDB:{
log_it(L_DEBUG,"%s.state: NET_STATE_LINKS_ESTABLISHED",l_net->pub.name); for (dap_list_t *l_tmp = l_pvt_net->links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
switch (l_pvt_net->state_target) { dap_chain_node_client_t *l_node_client = (dap_chain_node_client_t *)l_tmp->data;
case NET_STATE_ONLINE:{ // Online dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
switch ( l_pvt_net->node_role.enums ){ // Get last timestamp in log
case NODE_ROLE_ROOT_MASTER: l_sync_gdb.id_start = (uint64_t) dap_db_log_get_last_id_remote(l_node_client->remote_node_addr.uint64);
case NODE_ROLE_ROOT:{ // no limit
/*dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL; l_sync_gdb.id_end = (uint64_t)0;
// Send everybody your address when linked l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr(l_net) ?
HASH_ITER(hh,l_pvt_net->links,l_node_client,l_node_client_tmp){ dap_chain_net_get_cur_addr(l_net)->uint64 :
dap_stream_ch_chain_net_pkt_write(dap_client_get_stream_ch( dap_db_get_cur_node_addr(l_net->pub.name);
l_node_client->client, dap_stream_ch_chain_net_get_id()),
DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_ADDR, l_net->pub.id, dap_chain_id_t l_chain_id_null = {};
dap_chain_net_get_cur_addr(l_net), dap_chain_cell_id_t l_chain_cell_id_null = {};
sizeof (dap_chain_node_addr_t) ); l_chain_id_null.uint64 = l_net->pub.id.uint64;
}*/ l_chain_cell_id_null.uint64 = dap_chain_net_get_cur_cell(l_net) ? dap_chain_net_get_cur_cell(l_net)->uint64 : 0;
l_pvt_net->state = NET_STATE_SYNC_GDB;
}break; log_it(L_DEBUG, "Prepared request to gdb sync from %llu to %llu", l_sync_gdb.id_start, l_sync_gdb.id_end);
case NODE_ROLE_CELL_MASTER: // find dap_chain_id_t
case NODE_ROLE_MASTER:{ dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_net, "gdb");
l_pvt_net->state = NET_STATE_SYNC_GDB;//NET_STATE_ADDR_REQUEST; dap_chain_id_t l_chain_id = l_chain ? l_chain->id : (dap_chain_id_t ) {};
} break;
default:{ size_t l_res = dap_stream_ch_chain_pkt_write(dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id()),
// get addr for current node if it absent DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB, l_net->pub.id, l_chain_id,
if(!dap_chain_net_get_cur_addr_int(l_net)) l_net->pub.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
l_pvt_net->state = NET_STATE_ADDR_REQUEST; if (l_res == 0) {
else log_it(L_WARNING, "Can't send GDB sync request");
PVT( l_net)->state = NET_STATE_SYNC_GDB; continue;
}
}
} }
break;
case NET_STATE_SYNC_GDB: // we need only to sync gdb
l_pvt_net->state = NET_STATE_SYNC_GDB ;
if ( l_pvt_net->addr_request_attempts >=10 && l_pvt_net->state == NET_STATE_ADDR_REQUEST){
l_pvt_net->addr_request_attempts = 0;
switch( l_pvt_net->state_target){
case NET_STATE_ONLINE:
case NET_STATE_SYNC_GDB:
l_pvt_net->state = NET_STATE_SYNC_GDB;
break;
case NET_STATE_SYNC_CHAINS: // wait for finishing of request
l_pvt_net->state = NET_STATE_SYNC_CHAINS; int timeout_ms = 300000; // 5 min = 300 sec = 300 000 ms
break; // TODO add progress info to console
default: { l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
l_pvt_net->state = NET_STATE_OFFLINE; switch (l_res) {
l_pvt_net->state_target = NET_STATE_OFFLINE; case -1:
} log_it(L_WARNING,"Timeout with link sync");
}
}
break;
case NET_STATE_SYNC_CHAINS:
l_pvt_net->state = (l_pvt_net->node_info && l_pvt_net->node_info->hdr.address.uint64)?
NET_STATE_SYNC_CHAINS : NET_STATE_ADDR_REQUEST;
break; break;
case 0:
case NET_STATE_ADDR_REQUEST : log_it(L_INFO, "Node sync completed");
l_pvt_net->state = NET_STATE_ADDR_REQUEST;
break; break;
default: break; default:
} log_it(L_INFO, "Node sync error %d",l_res);
} break; }
// get addr for remote node l_res = dap_stream_ch_chain_pkt_write(dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id()),
case NET_STATE_ADDR_REQUEST: { DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS, l_net->pub.id, l_chain_id,
int l_is_addr_leased = 0; l_net->pub.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
dap_chain_node_client_t *l_node_client = l_pvt_net->links; l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
uint8_t l_ch_id = dap_stream_ch_chain_net_get_id(); // Channel id for chain net request switch (l_res) {
dap_stream_ch_t *l_ch_chain = dap_client_get_stream_ch(l_node_client->client, l_ch_id);
// set callback for l_ch_id
dap_chain_node_client_set_callbacks(l_node_client->client, l_ch_id);
// send request for new address
size_t res = dap_stream_ch_chain_net_pkt_write(l_ch_chain,
DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_ADDR_LEASE_REQUEST,
//DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_ADDR_REQUEST,
l_net->pub.id, NULL, 0);
if (res == 0) {
log_it(L_WARNING,"Can't send NODE_ADDR_REQUEST packet");
dap_chain_node_client_close(l_node_client);
l_pvt_net->links = NULL;
l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
break; // try with another link
}
// wait for finishing of request
int timeout_ms = 5000; // 5 sec = 5 000 ms
// TODO add progress info to console
l_pvt_net->addr_request_attempts++;
int l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_NODE_ADDR_LEASED, timeout_ms);
switch (l_res) {
case -1: case -1:
log_it(L_WARNING,"Timeout with addr leasing"); log_it(L_WARNING,"Timeout with link sync");
// try again 3 times break;
if (l_pvt_net->addr_request_attempts < 3) {
break;
}
l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
break; // try with another link
case 0: case 0:
log_it(L_INFO, "Node address leased"); log_it(L_INFO, "Node sync completed");
l_is_addr_leased++;
l_pvt_net->addr_request_attempts = 0;
break; break;
default: default:
if (l_node_client->last_error[0]) { log_it(L_INFO, "Node sync error %d",l_res);
log_it(L_INFO, "Node address request error %d: \"%s\"", l_res, l_node_client->last_error); }
l_node_client->last_error[0] = '\0';
}
log_it(L_INFO, "Node address request error %d", l_res);
l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
break;
}
if (l_is_addr_leased > 0) {
l_pvt_net->state = NET_STATE_SYNC_GDB;
}
}
break;
case NET_STATE_SYNC_GDB:{
// send request
dap_chain_node_client_t *l_node_client = l_pvt_net->links;
dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
// Get last timestamp in log
l_sync_gdb.id_start = (uint64_t) dap_db_log_get_last_id_remote(l_node_client->remote_node_addr.uint64);
// no limit
l_sync_gdb.id_end = (uint64_t)0;
l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr(l_net) ?
dap_chain_net_get_cur_addr(l_net)->uint64 :
dap_db_get_cur_node_addr(l_net->pub.name);
dap_chain_id_t l_chain_id_null = {};
dap_chain_cell_id_t l_chain_cell_id_null = {};
l_chain_id_null.uint64 = l_net->pub.id.uint64;
l_chain_cell_id_null.uint64 = dap_chain_net_get_cur_cell(l_net) ? dap_chain_net_get_cur_cell(l_net)->uint64 : 0;
log_it(L_DEBUG, "Prepared request to gdb sync from %llu to %llu", l_sync_gdb.id_start, l_sync_gdb.id_end);
// find dap_chain_id_t
dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_net, "gdb");
dap_chain_id_t l_chain_id = l_chain ? l_chain->id : (dap_chain_id_t ) {};
size_t l_res = dap_stream_ch_chain_pkt_write(dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id()),
DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB, l_net->pub.id, l_chain_id,
l_net->pub.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
if (l_res == 0) {
log_it(L_WARNING, "Can't send GDB sync request");
dap_chain_node_client_close(l_node_client);
l_pvt_net->links = NULL;
l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
break; //try another link
}
// wait for finishing of request
int timeout_ms = 300000; // 5 min = 300 sec = 300 000 ms
// TODO add progress info to console
l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
switch (l_res) {
case -1:
log_it(L_WARNING,"Timeout with link sync");
break;
case 0:
log_it(L_INFO, "Node sync completed");
break;
default:
log_it(L_INFO, "Node sync error %d",l_res);
}
if (l_res) { // try another link
break;
} }
if(l_pvt_net->state_target >= NET_STATE_SYNC_CHAINS){ if (l_pvt_net->state_target >= NET_STATE_SYNC_CHAINS){
l_pvt_net->state = NET_STATE_SYNC_CHAINS; l_pvt_net->state = NET_STATE_SYNC_CHAINS;
} else { } else { // Synchronization done, go offline
l_pvt_net->links_success++; l_pvt_net->state = l_pvt_net->state_target = NET_STATE_OFFLINE;
l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
} }
} }
break; break;
case NET_STATE_SYNC_CHAINS: { case NET_STATE_SYNC_CHAINS: {
dap_chain_node_client_t *l_node_client = l_pvt_net->links; for (dap_list_t *l_tmp = l_pvt_net->links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
uint8_t l_ch_id = dap_stream_ch_chain_get_id(); // Channel id for global_db and chains sync dap_chain_node_client_t *l_node_client = (dap_chain_node_client_t *)l_tmp->data;
dap_stream_ch_t *l_ch_chain = dap_client_get_stream_ch(l_node_client->client, l_ch_id); uint8_t l_ch_id = dap_stream_ch_chain_get_id(); // Channel id for global_db and chains sync
if(!l_ch_chain) { dap_stream_ch_t *l_ch_chain = dap_client_get_stream_ch(l_node_client->client, l_ch_id);
log_it(L_DEBUG,"Can't get stream_ch for id='%c' ", l_ch_id); if (!l_ch_chain) {
l_pvt_net->state = NET_STATE_LINKS_CONNECTING; log_it(L_DEBUG,"Can't get stream_ch for id='%c' ", l_ch_id);
break; continue;
} }
dap_chain_t * l_chain = NULL; dap_chain_t * l_chain = NULL;
int l_sync_errors = 0; DL_FOREACH (l_net->pub.chains, l_chain) {
DL_FOREACH(l_net->pub.chains, l_chain ){
//size_t l_lasts_size = 0;
//dap_chain_atom_ptr_t * l_lasts;
//dap_chain_atom_iter_t * l_atom_iter = l_chain->callback_atom_iter_create(l_chain);
//l_lasts = l_chain->callback_atom_iter_get_lasts(l_atom_iter, &l_lasts_size);
//if( l_lasts ) {
l_node_client->state = NODE_CLIENT_STATE_CONNECTED; l_node_client->state = NODE_CLIENT_STATE_CONNECTED;
dap_stream_ch_chain_sync_request_t l_request ; dap_stream_ch_chain_sync_request_t l_request ;
memset(&l_request, 0, sizeof (l_request)); memset(&l_request, 0, sizeof (l_request));
//dap_hash_fast(l_lasts[0], l_chain->callback_atom_get_size(l_lasts[0]), &l_request.hash_from); dap_stream_ch_chain_pkt_write(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS, l_net->pub.id,
dap_stream_ch_chain_pkt_write(l_ch_chain, l_chain->id, l_net->pub.cell_id, &l_request, sizeof(l_request));
DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS, l_net->pub.id, l_chain->id,
l_net->pub.cell_id, &l_request, sizeof(l_request));
//
// dap_chain_node_client_send_ch_pkt(l_node_client,l_ch_id,
// DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS,
// &l_request,sizeof (l_request) );
// wait for finishing of request // wait for finishing of request
int timeout_ms = 120000; // 2 min = 120 sec = 120 000 ms int timeout_ms = 120000; // 2 min = 120 sec = 120 000 ms
// TODO add progress info to console // TODO add progress info to console
int l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms); int l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
switch (l_res) { switch (l_res) {
case -1:
log_it(L_WARNING,"Timeout with sync of chain '%s' ", l_chain->name);
break;
case 0:
// flush global_db
dap_chain_global_db_flush();
log_it(L_INFO, "sync of chain '%s' completed ", l_chain->name);
break;
default:
log_it(L_ERROR, "sync of chain '%s' error %d", l_chain->name,l_res);
}
dap_stream_ch_chain_pkt_write(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS, l_net->pub.id,
l_chain->id, l_net->pub.cell_id, &l_request, sizeof(l_request));
l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
switch (l_res) {
case -1: case -1:
log_it(L_WARNING,"Timeout with sync of chain '%s' ", l_chain->name); log_it(L_WARNING,"Timeout with sync of chain '%s' ", l_chain->name);
break; break;
...@@ -759,29 +548,22 @@ static int s_net_states_proc(dap_chain_net_t * l_net) ...@@ -759,29 +548,22 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
// set time of last sync // set time of last sync
{ {
struct timespec l_to; struct timespec l_to;
clock_gettime( CLOCK_MONOTONIC, &l_to); clock_gettime(CLOCK_MONOTONIC, &l_to);
l_pvt_net->last_sync = l_to.tv_sec; l_pvt_net->last_sync = l_to.tv_sec;
} }
break; break;
default: default:
log_it(L_ERROR, "sync of chain '%s' error %d", l_chain->name,l_res); log_it(L_ERROR, "sync of chain '%s' error %d", l_chain->name,l_res);
} }
if (l_res) { }
l_sync_errors++;
}
//DAP_DELETE( l_lasts );
//}
//DAP_DELETE( l_atom_iter );
} }
dap_chain_node_client_close(l_node_client); if (l_pvt_net->state_target == NET_STATE_ONLINE){
l_pvt_net->links = NULL; l_pvt_net->state = NET_STATE_ONLINE;
if (!l_sync_errors) { } else { // Synchronization done, go offline
l_pvt_net->links_success++; l_pvt_net->state = l_pvt_net->state_target = NET_STATE_OFFLINE;
} }
l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
break; break;
} } break;
break;
case NET_STATE_ONLINE: { case NET_STATE_ONLINE: {
if (l_pvt_net->flags & F_DAP_CHAIN_NET_GO_SYNC) if (l_pvt_net->flags & F_DAP_CHAIN_NET_GO_SYNC)
...@@ -795,7 +577,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net) ...@@ -795,7 +577,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
case NET_STATE_ONLINE: case NET_STATE_ONLINE:
case NET_STATE_SYNC_GDB: case NET_STATE_SYNC_GDB:
case NET_STATE_SYNC_CHAINS: case NET_STATE_SYNC_CHAINS:
l_pvt_net->state = NET_STATE_LINKS_CONNECTING; l_pvt_net->state = NET_STATE_SYNC_GDB;
break; break;
default: break; default: break;
} }
...@@ -1222,16 +1004,16 @@ static int s_cli_net( int argc, char **argv, void *arg_func, char **a_str_reply) ...@@ -1222,16 +1004,16 @@ static int s_cli_net( int argc, char **argv, void *arg_func, char **a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply, dap_chain_node_cli_set_reply_text(a_str_reply,
"Network \"%s\" has state %s (target state %s), active links %u from %u, cur node address not defined", "Network \"%s\" has state %s (target state %s), active links %u from %u, cur node address not defined",
l_net->pub.name, c_net_states[PVT(l_net)->state], l_net->pub.name, c_net_states[PVT(l_net)->state],
c_net_states[PVT(l_net)->state_target], PVT(l_net)->links_count, c_net_states[PVT(l_net)->state_target], dap_list_length(PVT(l_net)->links),
PVT(l_net)->links_addrs_count dap_list_length(PVT(l_net)->links_info)
); );
} }
else { else {
dap_chain_node_cli_set_reply_text(a_str_reply, dap_chain_node_cli_set_reply_text(a_str_reply,
"Network \"%s\" has state %s (target state %s), active links %u from %u, cur node address " NODE_ADDR_FP_STR, "Network \"%s\" has state %s (target state %s), active links %u from %u, cur node address " NODE_ADDR_FP_STR,
l_net->pub.name, c_net_states[PVT(l_net)->state], l_net->pub.name, c_net_states[PVT(l_net)->state],
c_net_states[PVT(l_net)->state_target], PVT(l_net)->links_count, c_net_states[PVT(l_net)->state_target], dap_list_length(PVT(l_net)->links),
PVT(l_net)->links_addrs_count, dap_list_length(PVT(l_net)->links_info),
NODE_ADDR_FP_ARGS_S(l_cur_node_addr) NODE_ADDR_FP_ARGS_S(l_cur_node_addr)
); );
} }
......
modules/net/dap_chain_node_client.c
View file @ 1ceb8c13
...@@ -278,8 +278,8 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha ...@@ -278,8 +278,8 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
#endif #endif
case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_ALL: case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_ALL:
case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB: case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB:
case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS: { case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS: {
dap_stream_ch_chain_sync_request_t * l_request = NULL; dap_stream_ch_chain_sync_request_t * l_request = NULL;
if(a_pkt_data_size == sizeof(*l_request)) if(a_pkt_data_size == sizeof(*l_request))
l_request = (dap_stream_ch_chain_sync_request_t*) a_pkt->data; l_request = (dap_stream_ch_chain_sync_request_t*) a_pkt->data;
......
modules/net/dap_dns_server.c
View file @ 1ceb8c13
...@@ -102,13 +102,16 @@ void dap_dns_buf_put_uint64(dap_dns_buf_t *buf, uint64_t val) { ...@@ -102,13 +102,16 @@ void dap_dns_buf_put_uint64(dap_dns_buf_t *buf, uint64_t val) {
dap_chain_node_info_t *dap_dns_resolve_hostname(char *str) { dap_chain_node_info_t *dap_dns_resolve_hostname(char *str) {
log_it(L_DEBUG, "DNS parser retrieve hostname %s", str); log_it(L_DEBUG, "DNS parser retrieve hostname %s", str);
uint16_t l_nets_count; dap_chain_net_t *l_net = dap_chain_net_by_name(str);
dap_chain_net_t **l_nets = dap_chain_net_list(&l_nets_count); if (l_net == NULL) {
if (!l_nets_count) { uint16_t l_nets_count;
log_it(L_WARNING, "No chain network present"); dap_chain_net_t **l_nets = dap_chain_net_list(&l_nets_count);
return 0; if (!l_nets_count) {
log_it(L_WARNING, "No chain network present");
return 0;
}
l_net = l_nets[rand() % l_nets_count];
} }
dap_chain_net_t *l_net = l_nets[rand() % l_nets_count];
// get nodes list from global_db // get nodes list from global_db
dap_global_db_obj_t *l_objs = NULL; dap_global_db_obj_t *l_objs = NULL;
size_t l_nodes_count = 0; size_t l_nodes_count = 0;
...@@ -294,8 +297,8 @@ void dap_dns_client_read(dap_client_remote_t *client, void * arg) { ...@@ -294,8 +297,8 @@ void dap_dns_client_read(dap_client_remote_t *client, void * arg) {
} }
} }
if (l_node_info) { if (l_node_info) {
// Compose DNS answer // Compose DNS answer
block_len = DNS_ANSWER_SIZE * 2; block_len = DNS_ANSWER_SIZE * 2 - sizeof(uint16_t) + sizeof(uint64_t);
dns_reply->data = DAP_REALLOC(dns_reply->data, dns_reply->ptr + block_len); dns_reply->data = DAP_REALLOC(dns_reply->data, dns_reply->ptr + block_len);
val = 0xc000 | DNS_HEADER_SIZE; // Link to host name val = 0xc000 | DNS_HEADER_SIZE; // Link to host name
dap_dns_buf_put_uint16(dns_reply, val); dap_dns_buf_put_uint16(dns_reply, val);
...@@ -368,7 +371,7 @@ void dap_dns_server_stop() { ...@@ -368,7 +371,7 @@ void dap_dns_server_stop() {
DAP_DELETE(s_dns_server); DAP_DELETE(s_dns_server);
} }
int s_dns_get_ip(uint32_t a_addr, char *a_name, uint32_t *a_result) int dap_dns_client_get_addr(uint32_t a_addr, char *a_name, dap_chain_node_info_t *a_result)
{ {
const size_t l_buf_size = 1024; const size_t l_buf_size = 1024;
uint8_t l_buf[l_buf_size]; uint8_t l_buf[l_buf_size];
...@@ -463,17 +466,20 @@ int s_dns_get_ip(uint32_t a_addr, char *a_name, uint32_t *a_result) ...@@ -463,17 +466,20 @@ int s_dns_get_ip(uint32_t a_addr, char *a_name, uint32_t *a_result)
} }
l_cur = l_buf + l_addr_point; l_cur = l_buf + l_addr_point;
if (a_result) { if (a_result) {
*a_result = ntohl(*(uint32_t *)l_cur); a_result->hdr.ext_addr_v4.s_addr = ntohl(*(uint32_t *)l_cur);
}
l_cur = l_buf + 5 * sizeof(uint16_t);
int l_additions_count = ntohs(*(uint16_t *)l_cur);
if (l_additions_count == 1) {
l_cur = l_buf + l_addr_point + DNS_ANSWER_SIZE;
if (a_result) {
a_result->hdr.ext_port = ntohs(*(uint16_t *)l_cur);
}
l_cur += sizeof(uint16_t);
if (a_result) {
a_result->hdr.address.uint64 = be64toh(*(uint64_t *)l_cur);
}
} }
closesocket(l_sock); closesocket(l_sock);
return 0; return 0;
} }
uint32_t dap_dns_client_get_addr(uint32_t a_dns_addr)
{
uint32_t l_res;
if (s_dns_get_ip(a_dns_addr, "kelvin.sync", &l_res)) {
return 0;
}
return l_res;
}
modules/net/include/dap_dns_server.h
View file @ 1ceb8c13
...@@ -124,4 +124,4 @@ void dap_dns_server_start(); ...@@ -124,4 +124,4 @@ void dap_dns_server_start();
void dap_dns_server_stop(); void dap_dns_server_stop();
int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback); int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback);
int dap_dns_zone_unregister(char *zone); int dap_dns_zone_unregister(char *zone);
uint32_t dap_dns_client_get_addr(uint32_t a_dns_addr); int dap_dns_client_get_addr(uint32_t a_addr, char *a_name, dap_chain_node_info_t *a_result);