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/libdap-chain-net
1 result
Show changes
Commits on Source (25)
Hide whitespace changes
Inline Side-by-side
CMakeLists.txt
View file @ 0c4b45ab
cmake_minimum_required(VERSION 3.0)
project (dap_chain_net)
set(DAP_CHAIN_NET_SRCS
dap_chain_net.c
dap_chain_net_remote.c
......@@ -66,17 +67,17 @@ endif()
add_library(${PROJECT_NAME} STATIC ${DAP_CHAIN_NET_SRCS} ${DAP_CHAIN_NET_HEADERS} ${IPUTILS_SRCS} ${IPUTILS_HEADERS})
if(WIN32)
target_link_libraries(dap_chain_net dap_core dap_crypto dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_chain dap_chain_gdb dap_chain_crypto dap_chain_wallet dap_chain_net_srv dap_chain_mempool dap_chain_global_db )
target_link_libraries(dap_chain_net dap_core dap_crypto dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_chain dap_chain_crypto dap_chain_wallet dap_chain_net_srv dap_chain_mempool dap_chain_global_db )
endif()
if(UNIX)
target_link_libraries(dap_chain_net dap_core dap_crypto dap_client dap_stream_ch_chain dap_chain_gdb dap_stream_ch_chain_net dap_chain
target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_chain
dap_chain_crypto dap_chain_wallet dap_chain_net_srv dap_chain_net_srv_vpn dap_chain_mempool dap_chain_global_db
resolv
)
endif()
target_include_directories(dap_chain_net INTERFACE . PUBLIC ${IPUTILS_INCLUDE_DIRS})
target_include_directories(${PROJECT_NAME} INTERFACE . PUBLIC ${IPUTILS_INCLUDE_DIRS})
set(${PROJECT_NAME}_DEFINITIONS CACHE INTERNAL "${PROJECT_NAME}: Definitions" FORCE)
......
dap_chain_net.c
View file @ 0c4b45ab
......@@ -86,6 +86,12 @@
#define LOG_TAG "chain_net"
#define F_DAP_CHAIN_NET_SHUTDOWN ( 1 << 9 )
#define F_DAP_CHAIN_NET_GO_SYNC ( 1 << 10 )
// maximum number of connections
static size_t s_max_links_count = 5;// by default 5
// number of required connections
static size_t s_required_links_count = 3;// by default 3
/**
* @struct dap_chain_net_pvt
......@@ -100,13 +106,13 @@ typedef struct dap_chain_net_pvt{
#endif
pthread_mutex_t state_mutex;
dap_chain_node_role_t node_role;
uint32_t flags;
uint32_t flags;
time_t last_sync;
dap_chain_node_addr_t * node_addr;
dap_chain_node_info_t * node_info; // Current node's info
dap_chain_node_client_t * links;
size_t link_cur;
size_t links_count;
dap_chain_node_addr_t *links_addrs;
......@@ -121,7 +127,6 @@ typedef struct dap_chain_net_pvt{
uint16_t seed_aliases_count;
dap_chain_net_state_t state;
dap_chain_net_state_t state_prev;
dap_chain_net_state_t state_target;
} dap_chain_net_pvt_t;
......@@ -164,6 +169,19 @@ static void s_gbd_history_callback_notify (void * a_arg,const char a_op_code, co
static int s_cli_net(int argc, char ** argv, char **str_reply);
static bool s_seed_mode = false;
/**
* @brief s_net_set_go_sync
* @param a_net
* @return
*/
void s_net_set_go_sync(dap_chain_net_t * a_net)
{
if(a_net)
PVT(a_net)->flags |= F_DAP_CHAIN_NET_GO_SYNC;
}
/**
* @brief s_net_state_to_str
* @param l_state
......@@ -236,9 +254,9 @@ lb_proc_state:
pthread_mutex_lock(&PVT(l_net)->state_mutex );
switch ( PVT(l_net)->state ){
case NET_STATE_OFFLINE:{
log_it(L_NOTICE,"%s.state: NET_STATE_OFFLINE",l_net->pub.name);
//log_it(L_DEBUG,"%s.state: NET_STATE_OFFLINE",l_net->pub.name);
// reset current link
PVT(l_net)->link_cur = 0;
PVT(l_net)->links_count = 0;
// delete all links
dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL;
HASH_ITER(hh,PVT(l_net)->links,l_node_client,l_node_client_tmp){
......@@ -276,6 +294,42 @@ lb_proc_state:
}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(!PVT(l_net)->links_addrs_count)
{
// use no more then 4 root node
int l_use_root_nodes = min(4, PVT(l_net)->seed_aliases_count);
if(!PVT(l_net)->links_addrs_count) {
PVT(l_net)->links_addrs = DAP_NEW_Z_SIZE(dap_chain_node_addr_t,
l_use_root_nodes * sizeof(dap_chain_node_addr_t));
}
else{
PVT(l_net)->links_addrs = DAP_REALLOC(PVT(l_net)->links_addrs,
(PVT(l_net)->links_addrs_count+l_use_root_nodes) * sizeof(dap_chain_node_addr_t));
memset(PVT(l_net)->links_addrs + PVT(l_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, PVT(l_net)->seed_aliases[i]);
if(l_node_addr) {
PVT(l_net)->links_addrs[PVT(l_net)->links_addrs_count].uint64 = l_node_addr->uint64;
PVT(l_net)->links_addrs_count++;
}
}
}
// shuffle the order of the nodes
for(size_t i = 0; i < PVT(l_net)->links_addrs_count; i++) {
unsigned int l_new_node_pos = rand() % (PVT(l_net)->links_addrs_count);
if(i == l_new_node_pos)
continue;
uint64_t l_tmp_uint64 = PVT(l_net)->links_addrs[i].uint64;
PVT(l_net)->links_addrs[i].uint64 = PVT(l_net)->links_addrs[l_new_node_pos].uint64;
PVT(l_net)->links_addrs[l_new_node_pos].uint64 = l_tmp_uint64;
}
} break;
case NODE_ROLE_FULL:
case NODE_ROLE_MASTER:
......@@ -326,6 +380,15 @@ lb_proc_state:
}
}
}
// shuffle the order of the nodes
for(size_t i = 0; i < PVT(l_net)->links_addrs_count; i++) {
unsigned int l_new_node_pos = rand() % (PVT(l_net)->links_addrs_count);
if(i==l_new_node_pos)
continue;
uint64_t l_tmp_uint64 = PVT(l_net)->links_addrs[i].uint64;
PVT(l_net)->links_addrs[i].uint64 = PVT(l_net)->links_addrs[l_new_node_pos].uint64;
PVT(l_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
......@@ -349,13 +412,12 @@ lb_proc_state:
} pthread_mutex_unlock(&PVT(l_net)->state_mutex ); goto lb_proc_state;
case NET_STATE_LINKS_CONNECTING:{
log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_CONNECTING",l_net->pub.name);
size_t l_links_established = 0;
//for (size_t i =0 ; i < PVT(l_net)->links_addrs_count ; i++ )
for (size_t i = PVT(l_net)->link_cur ; i < PVT(l_net)->links_addrs_count ; i++ )
{
//size_t l_links_established = 0;
for(size_t j = PVT(l_net)->links_count; j < PVT(l_net)->links_addrs_count; j++) {
//size_t j =
log_it(L_INFO,"Establishing connection with " NODE_ADDR_FP_STR,
NODE_ADDR_FP_ARGS_S( PVT(l_net)->links_addrs[i]) );
dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, &PVT(l_net)->links_addrs[i] );
NODE_ADDR_FP_ARGS_S( PVT(l_net)->links_addrs[j]) );
dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, &PVT(l_net)->links_addrs[j] );
if ( l_link_node_info ) {
dap_chain_node_client_t *l_node_client = dap_chain_node_client_connect(l_link_node_info );
if(!l_node_client) {
......@@ -364,22 +426,22 @@ lb_proc_state:
break;
}
// wait connected
int timeout_ms = 5000; //15 sec = 15000 ms
int timeout_ms = 5000; //5 sec = 5000 ms
int res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_CONNECTED, timeout_ms);
if (res == 0 ){
log_it(L_NOTICE, "Connected link %u",i);
l_links_established++;
HASH_ADD(hh,PVT(l_net)->links, remote_node_addr,sizeof(l_node_client->remote_node_addr), l_node_client);
PVT(l_net)->link_cur++;
break;
log_it(L_NOTICE, "Connected link %u",j);
HASH_ADD(hh, PVT(l_net)->links, remote_node_addr, sizeof(l_node_client->remote_node_addr), l_node_client);
PVT(l_net)->links_count++;
if(PVT(l_net)->links_count >= s_required_links_count || (PVT(l_net)->links_count + 1) >= s_max_links_count)
break;
}else {
log_it(L_NOTICE, "Cant establish link %u",i);
log_it(L_NOTICE, "Cant establish link %u",j);
dap_chain_node_client_close(l_node_client);
}
}
}
if (l_links_established >0 ){
log_it(L_NOTICE, "Established %u links",l_links_established);
if (PVT(l_net)->links_count >0 ){
log_it(L_NOTICE, "Established %u links",PVT(l_net)->links_count);
PVT(l_net)->state = NET_STATE_LINKS_ESTABLISHED;
}else {
log_it(L_NOTICE, "Can't establish links, go to offline");
......@@ -405,6 +467,7 @@ lb_proc_state:
dap_chain_net_get_cur_addr(l_net),
sizeof (dap_chain_node_addr_t) );
}
PVT(l_net)->state = NET_STATE_SYNC_GDB;
}break;
case NODE_ROLE_CELL_MASTER:
case NODE_ROLE_MASTER:{
......@@ -412,7 +475,7 @@ lb_proc_state:
} break;
default:{
// get addr for current node if it absent
if(dap_chain_net_get_cur_addr_int(l_net))
if(!dap_chain_net_get_cur_addr_int(l_net))
PVT(l_net)->state = NET_STATE_ADDR_REQUEST;
else
PVT( l_net)->state = NET_STATE_SYNC_GDB;
......@@ -452,7 +515,9 @@ lb_proc_state:
}break;
// get addr for remote node
case NET_STATE_ADDR_REQUEST:{
int l_is_addr_leased = 0;
dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL;
HASH_ITER(hh,PVT(l_net)->links,l_node_client,l_node_client_tmp){
uint8_t l_ch_id = dap_stream_ch_chain_net_get_id(); // Channel id for chain net request
dap_stream_ch_t * l_ch_chain = dap_client_get_stream_ch(l_node_client->client, l_ch_id);
......@@ -486,8 +551,10 @@ lb_proc_state:
continue; // try with another link
case 0:
log_it(L_INFO, "Node address leased");
PVT(l_net)->state = NET_STATE_SYNC_GDB;
pthread_mutex_unlock(&PVT(l_net)->state_mutex ); goto lb_proc_state;
l_is_addr_leased++;
//PVT(l_net)->state = NET_STATE_SYNC_GDB;
//pthread_mutex_unlock(&PVT(l_net)->state_mutex ); goto lb_proc_state;
break;
default:
if ( l_node_client->last_error[0] ){
log_it(L_INFO, "Node address request error %d: \"%s\"",l_res, l_node_client->last_error );
......@@ -496,12 +563,20 @@ lb_proc_state:
log_it(L_INFO, "Node address request error %d",l_res);
continue;
}
}
if(l_is_addr_leased > 0) {
PVT(l_net)->state = NET_STATE_SYNC_GDB;
pthread_mutex_unlock(&PVT(l_net)->state_mutex);
goto lb_proc_state;
}
else{
log_it(L_WARNING,"Haven't received address from any links, return back to LINKS_ESTABLISHED");
PVT(l_net)->state = NET_STATE_LINKS_ESTABLISHED;
pthread_mutex_unlock(&PVT(l_net)->state_mutex );goto lb_proc_state; // One address assigned its enought for now
}
}break;
}
break;
case NET_STATE_SYNC_GDB:{
// send request
dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL;
......@@ -563,18 +638,25 @@ lb_proc_state:
case NET_STATE_SYNC_CHAINS:{
dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL;
uint8_t l_ch_id = dap_stream_ch_chain_get_id(); // Channel id for global_db sync
uint8_t l_ch_id = dap_stream_ch_chain_get_id(); // Channel id for global_db and chains sync
HASH_ITER(hh,PVT(l_net)->links,l_node_client,l_node_client_tmp){
dap_stream_ch_t * l_ch_chain = dap_client_get_stream_ch(l_node_client->client, l_ch_id);
if(!l_ch_chain){
log_it(L_DEBUG,"Can't get stream_ch for id='%c' ", l_ch_id);
continue;
}
dap_chain_t * l_chain = NULL;
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 ) {
//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;
dap_stream_ch_chain_sync_request_t l_request = { { 0 } };
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(dap_client_get_stream_ch(l_node_client->client, l_ch_id),
//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, l_chain->id,
l_net->pub.cell_id, &l_request, sizeof(l_request));
//
......@@ -588,18 +670,24 @@ lb_proc_state:
int 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");
log_it(L_WARNING,"Timeout with sync of chain '%s' ", l_chain->name);
break;
case 0:
log_it(L_INFO, "Node sync completed");
log_it(L_INFO, "sync of chain '%s' completed ", l_chain->name);
// set time of last sync
{
struct timespec l_to;
clock_gettime( CLOCK_MONOTONIC, &l_to);
PVT(l_net)->last_sync = l_to.tv_sec;
}
break;
default:
log_it(L_INFO, "Node sync error %d",l_res);
log_it(L_INFO, "sync of chain '%s' error %d", l_chain->name,l_res);
}
DAP_DELETE( l_lasts );
}
DAP_DELETE( l_atom_iter );
//DAP_DELETE( l_lasts );
//}
//DAP_DELETE( l_atom_iter );
}
}
......@@ -612,18 +700,29 @@ lb_proc_state:
goto lb_proc_state;
case NET_STATE_ONLINE: {
log_it(L_NOTICE, "State online");
//log_it(L_NOTICE, "State online");
switch ( PVT(l_net)->state_target) {
// disconnect
case NET_STATE_OFFLINE:
PVT(l_net)->state = NET_STATE_OFFLINE;
pthread_mutex_unlock(&PVT(l_net)->state_mutex);
goto lb_proc_state;
// sync
case NET_STATE_SYNC_GDB:
PVT(l_net)->state = NET_STATE_SYNC_GDB;
pthread_mutex_unlock(&PVT(l_net)->state_mutex);
goto lb_proc_state;
// disconnect
case NET_STATE_OFFLINE:
PVT(l_net)->state = NET_STATE_OFFLINE;
log_it(L_NOTICE, "Going to disconnet");
pthread_mutex_unlock(&PVT(l_net)->state_mutex);
goto lb_proc_state;
case NET_STATE_ONLINE:
// if flag set then go to SYNC_GDB
if(PVT(l_net)->flags & F_DAP_CHAIN_NET_GO_SYNC)
PVT(l_net)->flags &= ~F_DAP_CHAIN_NET_GO_SYNC;
else
break;
// sync
case NET_STATE_SYNC_GDB:
PVT(l_net)->state = NET_STATE_SYNC_GDB;
pthread_mutex_unlock(&PVT(l_net)->state_mutex);
goto lb_proc_state;
PVT(l_net)->state = NET_STATE_SYNC_GDB;
pthread_mutex_unlock(&PVT(l_net)->state_mutex);
goto lb_proc_state;
}
}
break;
......@@ -655,8 +754,9 @@ static void *s_net_proc_thread ( void *a_net )
// prepare for signal waiting
struct timespec l_to;
clock_gettime( CLOCK_MONOTONIC, &l_to );
int64_t l_nsec_new = l_to.tv_nsec + l_timeout_ms * 10000000ll;
int64_t l_nsec_new = l_to.tv_nsec + l_timeout_ms * 1000000ll;
// if the new number of nanoseconds is more than a second
if(l_nsec_new > (long) 1e9) {
......@@ -669,7 +769,12 @@ static void *s_net_proc_thread ( void *a_net )
// signal waiting
pthread_cond_timedwait( &p_net->state_proc_cond, &p_net->state_mutex, &l_to );
//pthread_cond_wait(&PVT(l_net)->state_proc_cond,&PVT(l_net)->state_mutex);
// checking whether new sync is needed
time_t l_sync_timeout = 300;// 300 sec = 5 min
clock_gettime( CLOCK_MONOTONIC, &l_to );
if(l_to.tv_sec >= p_net->last_sync + l_sync_timeout)
p_net->flags |= F_DAP_CHAIN_NET_GO_SYNC;
pthread_mutex_unlock( &p_net->state_mutex );
#else // WIN32
......@@ -829,6 +934,13 @@ int dap_chain_net_init()
dap_chain_global_db_add_history_group_prefix("global");
dap_chain_global_db_add_history_callback_notify("global", s_gbd_history_callback_notify, NULL );
// maximum number of connections to other nodes
s_max_links_count = dap_config_get_item_int32_default(g_config, "general", "max_links", s_max_links_count);
// required number of connections to other nodes
s_required_links_count = dap_config_get_item_int32_default(g_config, "general", "require_links", s_required_links_count);
dap_chain_net_load_all();
return 0;
}
......@@ -1752,7 +1864,8 @@ void dap_chain_net_proc_mempool (dap_chain_net_t * a_net)
// Delete processed objects
size_t l_objs_processed_tmp = (l_objs_processed > 15) ? min(l_objs_processed, 10) : l_objs_processed;
for(size_t i = 0; i < l_objs_processed; i++) {
dap_chain_global_db_gr_del(l_objs[i].key, l_gdb_group_mempool);
if(dap_chain_global_db_gr_del(dap_strdup(l_objs[i].key), l_gdb_group_mempool))
s_net_set_go_sync(a_net);
if(i < l_objs_processed_tmp) {
dap_string_append_printf(l_str_tmp, "New event created, removed datum 0x%s from mempool \n",
l_objs[i].key);
......
dap_chain_net.h
View file @ 0c4b45ab
......@@ -84,6 +84,7 @@ void dap_chain_net_deinit(void);
void dap_chain_net_load_all();
void s_net_set_go_sync(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);
inline static int dap_chain_net_start(dap_chain_net_t * a_net){ return dap_chain_net_state_go_to(a_net,NET_STATE_ONLINE); }
......
dap_chain_node.c
View file @ 0c4b45ab
......@@ -84,12 +84,16 @@ bool dap_chain_node_check_addr(dap_chain_net_t * a_net,dap_chain_node_addr_t *ad
bool dap_chain_node_alias_register(dap_chain_net_t * a_net,const char *alias, dap_chain_node_addr_t *addr)
{
char *a_key = strdup(alias);
dap_chain_node_addr_t *l_addr = DAP_NEW_Z(dap_chain_node_addr_t);
memcpy(l_addr,addr,sizeof (*l_addr));
// char a_value[2 * sizeof(dap_chain_node_addr_t) + 1];
// if(bin2hex(a_value, (const unsigned char *) addr, sizeof(dap_chain_node_addr_t)) == -1)
// return false;
// a_value[2 * sizeof(dap_chain_node_addr_t)] = '\0';
bool res = dap_chain_global_db_gr_set(a_key, addr, sizeof(dap_chain_node_addr_t)
bool res = dap_chain_global_db_gr_set( dap_strdup(a_key), l_addr, sizeof(dap_chain_node_addr_t)
, a_net->pub.gdb_nodes_aliases);
if(res)
s_net_set_go_sync(a_net);
return res;
}
......@@ -113,6 +117,8 @@ bool dap_chain_node_alias_delete(dap_chain_net_t * a_net,const char *a_alias)
{
char *a_key = strdup(a_alias);
bool res = dap_chain_global_db_gr_del(a_key, a_net->pub.gdb_nodes_aliases);
if(res)
s_net_set_go_sync(a_net);
return res;
}
......@@ -136,21 +142,25 @@ size_t dap_chain_node_info_get_size(dap_chain_node_info_t *node_info)
* @param node_info
* @return
*/
int dap_chain_node_info_save(dap_chain_net_t * a_net, dap_chain_node_info_t *node_info)
int dap_chain_node_info_save(dap_chain_net_t * a_net, dap_chain_node_info_t *a_node_info)
{
if(!node_info || !node_info->hdr.address.uint64){
log_it(L_ERROR,"Can't save node info: %s", node_info? "null address":"null object" );
if(!a_node_info || !a_node_info->hdr.address.uint64){
log_it(L_ERROR,"Can't save node info: %s", a_node_info? "null address":"null object" );
return -1;
}
char *l_key = dap_chain_node_addr_to_hash_str(&node_info->hdr.address);
char *l_key = dap_chain_node_addr_to_hash_str(&a_node_info->hdr.address);
if(!l_key){
log_it(L_ERROR,"Can't produce key to save node info ");
return -2;
}
//char *a_value = dap_chain_node_info_serialize(node_info, NULL);
size_t node_info_size = dap_chain_node_info_get_size(node_info);
bool res = dap_chain_global_db_gr_set(l_key, node_info, node_info_size, a_net->pub.gdb_nodes);
size_t l_node_info_size = dap_chain_node_info_get_size(a_node_info);
dap_chain_node_info_t *l_node_info = DAP_NEW_Z_SIZE(dap_chain_node_info_t, l_node_info_size);
memcpy(l_node_info, a_node_info, sizeof (*a_node_info) );
bool res = dap_chain_global_db_gr_set( dap_strdup(l_key), l_node_info, l_node_info_size, a_net->pub.gdb_nodes);
if(res)
s_net_set_go_sync(a_net);
DAP_DELETE(l_key);
//DAP_DELETE(a_value);
return res?0:-3;
......
dap_chain_node_cli_cmd.c
View file @ 0c4b45ab
......@@ -72,9 +72,9 @@
#include "dap_chain_node_cli_cmd_tx.h"
#include "dap_chain_node_ping.h"
#include "dap_chain_net_srv.h"
#include "dap_chain_net_vpn_client.h"
#include "dap_chain_cell.h"
#include "dap_chain_common.h"
#include "dap_chain_datum.h"
#include "dap_chain_datum_token.h"
#include "dap_chain_datum_tx_items.h"
......@@ -82,7 +82,7 @@
#include "dap_chain_mempool.h"
#include "dap_chain_global_db.h"
#include "dap_chain_global_db_remote.h"
#include "dap_chain_gdb.h"
//#include "dap_chain_gdb.h"
#include "dap_stream_ch_chain_net.h"
#include "dap_stream_ch_chain.h"
......@@ -204,23 +204,28 @@ static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net,
/**
* Save node to base
*/
static bool node_info_save_and_reply(dap_chain_net_t * a_net, dap_chain_node_info_t *node_info, char **str_reply)
static bool node_info_save_and_reply(dap_chain_net_t * a_net, dap_chain_node_info_t *a_node_info, char **str_reply)
{
if(!node_info || !node_info->hdr.address.uint64) {
if(!a_node_info || !a_node_info->hdr.address.uint64) {
dap_chain_node_cli_set_reply_text(str_reply, "node addr not found");
return false;
}
char *a_key = dap_chain_node_addr_to_hash_str(&node_info->hdr.address);
char *a_key = dap_chain_node_addr_to_hash_str(&a_node_info->hdr.address);
if(!a_key)
{
dap_chain_node_cli_set_reply_text(str_reply, "can't calculate hash for addr");
return NULL;
}
//char *a_value = dap_chain_node_info_serialize(node_info, NULL);
size_t node_info_size = dap_chain_node_info_get_size(node_info);
bool res = dap_chain_global_db_gr_set(a_key, (uint8_t *) node_info, node_info_size,a_net->pub.gdb_nodes);
size_t l_node_info_size = dap_chain_node_info_get_size(a_node_info);
dap_chain_node_info_t *l_node_info = DAP_NEW_Z_SIZE(dap_chain_node_info_t, l_node_info_size);
memcpy(l_node_info, a_node_info, sizeof (*a_node_info) );
bool res = dap_chain_global_db_gr_set(a_key, (uint8_t *) l_node_info, l_node_info_size,a_net->pub.gdb_nodes);
DAP_DELETE(a_key);
//DAP_DELETE(a_value);
if(res)
s_net_set_go_sync(a_net);
return res;
}
......@@ -305,7 +310,7 @@ static int node_info_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
if(a_key)
{
// delete node
bool res = dap_chain_global_db_gr_del(a_key, a_net->pub.gdb_nodes);
bool res = dap_chain_global_db_gr_del(dap_strdup(a_key), a_net->pub.gdb_nodes);
if(res) {
// delete all aliases for node address
{
......@@ -321,6 +326,7 @@ static int node_info_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
}
// set text response
dap_chain_node_cli_set_reply_text(str_reply, "node deleted");
s_net_set_go_sync(a_net);
}
else
dap_chain_node_cli_set_reply_text(str_reply, "node not deleted");
......@@ -967,7 +973,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
return -1;
}
// wait connected
int timeout_ms = 100; //5 sec = 5000 ms
int timeout_ms = 7000; //5 sec = 5000 ms
res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_CONNECTED, timeout_ms);
// select new node addr
if(l_is_auto && res){
......@@ -1099,7 +1105,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
if(0 == dap_stream_ch_chain_pkt_write(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB,
l_net->pub.id, l_chain_id_null, l_chain_cell_id_null, &l_sync_request,
sizeof(l_sync_request))) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Error: Cant send sync chains request");
dap_chain_node_cli_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
// clean client struct
dap_chain_node_client_close(l_node_client);
DAP_DELETE(l_remote_node_info);
......@@ -1756,7 +1762,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
if(l_datum->header.type_id == DAP_CHAIN_DATUM_TOKEN_DECL) {
dap_chain_datum_token_t * l_datum_token = (dap_chain_datum_token_t *) l_datum->data;
size_t l_datum_token_size = l_datum->header.data_size;
size_t l_signs_size = l_datum_token_size - sizeof(l_datum_token->header);
size_t l_signs_size = l_datum_token_size - sizeof(l_datum_token->header_auth);
// Check for signatures, are they all in set and are good enought?
size_t l_signs_count = 0;
......@@ -1764,7 +1770,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
for(size_t l_offset = 0; l_offset < l_signs_size; l_signs_count++) {
dap_sign_t * l_sign = (dap_sign_t *) l_datum_token->signs + l_offset;
l_offset += dap_sign_get_size(l_sign);
if( dap_sign_verify(l_sign, l_datum_token, sizeof(l_datum_token->header)) != 1) {
if( dap_sign_verify(l_sign, l_datum_token, sizeof(l_datum_token->header_auth)) != 1) {
log_it(L_WARNING, "Wrong signature %u for datum_token with key %s in mempool!", l_signs_count, l_datum_hash_str);
dap_chain_node_cli_set_reply_text(a_str_reply,
"Datum %s with datum token has wrong signature %u, break process and exit",
......@@ -1781,7 +1787,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
l_signs_count, l_signs_size);
// Check if all signs are present
if(l_signs_count == l_datum_token->header.signs_total) {
if(l_signs_count == l_datum_token->header_auth.signs_total) {
dap_chain_node_cli_set_reply_text(a_str_reply,
"Datum %s with datum token has all signs on board. Can't add anything in it");
DAP_DELETE(l_datum);
......@@ -1789,21 +1795,21 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_gdb_group_mempool);
return -7;
} // Check if more signs that could be (corrupted datum)
else if(l_signs_count > l_datum_token->header.signs_total) {
else if(l_signs_count > l_datum_token->header_auth.signs_total) {
dap_chain_node_cli_set_reply_text(a_str_reply,
"Warning! Datum %s with datum token has more signs on board (%u) than its possible to have (%u)!",
l_signs_count, l_datum_token->header.signs_total);
l_signs_count, l_datum_token->header_auth.signs_total);
DAP_DELETE(l_datum);
//DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
return -8;
} // Check if we have enough place to sign the datum token declaration
else if(l_datum_token->header.signs_total >= l_signs_count + l_certs_count) {
else if(l_datum_token->header_auth.signs_total >= l_signs_count + l_certs_count) {
size_t l_offset = 0;
for(size_t i = 0; i < l_certs_count; i++) {
dap_sign_t * l_sign = dap_sign_create(l_certs[i]->enc_key,
l_datum_token,
sizeof(l_datum_token->header), 0);
sizeof(l_datum_token->header_auth), 0);
size_t l_sign_size = dap_sign_get_size(l_sign);
......@@ -1835,10 +1841,12 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
char * l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
// Add datum to mempool with datum_token hash as a key
if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool)) {
if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool)) {
s_net_set_go_sync(l_net);
char* l_hash_str = strdup(l_datum_hash_str);
// Remove old datum from pool
if(dap_chain_global_db_gr_del( l_hash_str, l_gdb_group_mempool)) {
if( dap_chain_global_db_gr_del( dap_strdup(l_hash_str) , l_gdb_group_mempool)) {
dap_chain_node_cli_set_reply_text(a_str_reply,
"datum %s produced from %s is replacing the %s in datum pool",
l_key_str, l_datum_hash_str, l_datum_hash_str);
......@@ -1846,6 +1854,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_datum);
//DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
s_net_set_go_sync(l_net);
return 0;
} else {
dap_chain_node_cli_set_reply_text(a_str_reply,
......@@ -1857,7 +1866,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
return 1;
}
DAP_DELETE(l_hash_str);
DAP_DELETE(l_key_str);
}
else {
dap_chain_node_cli_set_reply_text(a_str_reply,
......@@ -1866,13 +1875,14 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_datum);
//DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
DAP_DELETE(l_key_str);
return -2;
}
} else {
dap_chain_node_cli_set_reply_text(a_str_reply,
"Error! Not enought place for new signature (%u is left when we need %u signatures)",
l_datum_token->header.signs_total - l_signs_count, l_certs_count);
l_datum_token->header_auth.signs_total - l_signs_count, l_certs_count);
return -6;
}
} else {
......@@ -1947,9 +1957,9 @@ int com_mempool_list(int argc, char ** argv, char ** a_str_reply)
if ( l_datum->header.type_id == DAP_CHAIN_DATUM_TOKEN_DECL ){
dap_chain_datum_token_t * l_datum_token = (dap_chain_datum_token_t *) l_datum->data;
dap_string_append_printf(l_str_tmp,
"\tDAP_CHAIN_DATUM_TOKEN_DECL: version=%u ticker=\"%s\" signs_total=%u signs_valid=%u\n",
l_datum_token->header.version, l_datum_token->header.ticker,
l_datum_token->header.signs_total, l_datum_token->header.signs_valid );
"\tDAP_CHAIN_DATUM_TOKEN_DECL: type=%u ticker=\"%s\" signs_total=%u signs_valid=%u\n",
l_datum_token->header_auth.type, l_datum_token->header_auth.ticker,
l_datum_token->header_auth.signs_total, l_datum_token->header_auth.signs_valid );
}
}
// Clean up
......@@ -1996,9 +2006,10 @@ int com_mempool_delete(int argc, char ** argv, char ** a_str_reply)
if(l_datum_hash_str) {
char * l_datum_hash_str2 = strdup(l_datum_hash_str);
char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
if(dap_chain_global_db_gr_del(l_datum_hash_str2, l_gdb_group_mempool)) {
if(dap_chain_global_db_gr_del( dap_strdup(l_datum_hash_str2), l_gdb_group_mempool)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s deleted", l_datum_hash_str);
DAP_DELETE( l_datum_hash_str2);
s_net_set_go_sync(l_net);
return 0;
} else {
dap_chain_node_cli_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_str);
......@@ -2074,12 +2085,24 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
if(l_objs_size > 15) {
dap_string_append_printf(l_str_tmp, "...\n");
}
size_t l_objs_processed = l_chain->callback_datums_pool_proc(l_chain, l_datums, l_datums_size);
size_t l_objs_processed = 0;
bool l_procecced[l_objs_size];
for(size_t i = 0; i < l_objs_size; i++) {
int l_is_processed = l_chain->callback_datums_pool_proc(l_chain, l_datums + i, 1); //l_datums_size
l_objs_processed += l_is_processed;
l_procecced[i] = l_is_processed;
}
// Delete processed objects
size_t l_objs_processed_tmp = (l_objs_processed > 15) ? min(l_objs_processed, 10) : l_objs_processed;
for(size_t i = 0; i < l_objs_processed; i++) {
dap_chain_global_db_gr_del(l_objs[i].key, l_gdb_group_mempool);
if(i < l_objs_processed_tmp) {
size_t l_objs_processed_cur = 0;
for(size_t i = 0; i < l_datums_size; i++) {
if(l_procecced[i]!=1)
continue;
if(dap_chain_global_db_gr_del( dap_strdup(l_objs[i].key), l_gdb_group_mempool_tmp))
s_net_set_go_sync(l_net);
l_objs_processed_cur++;
if(l_objs_processed_cur < l_objs_processed_tmp) {
dap_string_append_printf(l_str_tmp, "New event created, removed datum 0x%s from mempool \n",
l_objs[i].key);
}
......@@ -2115,6 +2138,10 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
int com_token_decl(int argc, char ** argv, char ** a_str_reply)
{
int arg_index = 1;
const char * l_type_str = NULL;
uint16_t l_type =0;
const char * l_ticker = NULL;
const char * l_total_supply_str = NULL;
......@@ -2159,6 +2186,9 @@ int com_token_decl(int argc, char ** argv, char ** a_str_reply)
// Signs minimum number thats need to authorize the emission
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-signs_emission", &l_signs_emission_str);
// Token type
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-type", &l_type_str);
if(!l_total_supply_str) {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-total_supply'");
return -11;
......@@ -2222,12 +2252,12 @@ int com_token_decl(int argc, char ** argv, char ** a_str_reply)
l_certs_size = l_signs_total;
// Create new datum token
dap_chain_datum_token_t * l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(l_datum_token->header));
l_datum_token->header.version = 1; // Current version
dap_snprintf(l_datum_token->header.ticker, sizeof(l_datum_token->header.ticker), "%s", l_ticker);
l_datum_token->header.total_supply = l_total_supply;
l_datum_token->header.signs_total = l_signs_total;
l_datum_token->header.signs_valid = l_signs_emission;
dap_chain_datum_token_t * l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(l_datum_token->header_auth));
l_datum_token->header_auth.type = 1; // Current version
dap_snprintf(l_datum_token->header_auth.ticker, sizeof(l_datum_token->header_auth.ticker), "%s", l_ticker);
l_datum_token->header_auth.total_supply = l_total_supply;
l_datum_token->header_auth.signs_total = l_signs_total;
l_datum_token->header_auth.signs_valid = l_signs_emission;
size_t l_signs_offset = 0;
// Sign header with all certificates in the list and add signs to the end of ticker declaration
......@@ -2235,16 +2265,16 @@ int com_token_decl(int argc, char ** argv, char ** a_str_reply)
for(size_t i = 0; i < l_certs_size; i++) {
dap_sign_t * l_sign = dap_cert_sign(l_certs[i],
l_datum_token,
sizeof(l_datum_token->header),
sizeof(l_datum_token->header_auth),
0);
size_t l_sign_size = dap_sign_get_size(l_sign);
l_datum_token = DAP_REALLOC(l_datum_token, sizeof(l_datum_token->header) + l_signs_offset + l_sign_size);
l_datum_token = DAP_REALLOC(l_datum_token, sizeof(l_datum_token->header_auth) + l_signs_offset + l_sign_size);
memcpy(l_datum_token->signs + l_signs_offset, l_sign, l_sign_size);
l_signs_offset += l_sign_size;
DAP_DELETE(l_sign);
}
dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_DECL, l_datum_token,
sizeof(l_datum_token->header) + l_signs_offset);
sizeof(l_datum_token->header_auth) + l_signs_offset);
size_t l_datum_size = dap_chain_datum_size(l_datum);
// Calc datum's hash
......@@ -2261,12 +2291,14 @@ int com_token_decl(int argc, char ** argv, char ** a_str_reply)
l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_by_chain_type(l_net, CHAIN_TYPE_TOKEN);
}
if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool)) {
if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool)) {
s_net_set_go_sync(l_net);
dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s with token %s is placed in datum pool ", l_key_str,
l_ticker);
DAP_DELETE(l_datum);
DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
DAP_DELETE(l_key_str);
return 0;
}
else {
......@@ -2274,6 +2306,7 @@ int com_token_decl(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_datum);
DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
DAP_DELETE(l_key_str);
return -2;
}
......@@ -2472,16 +2505,19 @@ int com_token_emit(int argc, char ** argv, char ** str_reply)
// char * l_key_str = dap_chain_hash_fast_to_str_new(&l_datum_emission_hash);
// Add to mempool emission token
if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum_emission, l_datum_emission_size
if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum_emission, l_datum_emission_size
, l_gdb_group_mempool_emission)) {
s_net_set_go_sync(l_net);
str_reply_tmp = dap_strdup_printf("datum emission %s is placed in datum pool ", l_key_str);
DAP_DELETE(l_key_str);
}
else {
dap_chain_node_cli_set_reply_text(str_reply, "datum emission %s is not placed in datum pool ", l_key_str);
DAP_DELETE(l_key_str);
DAP_DELETE(l_datum_emission);
return -1;
}
DAP_DELETE(l_key_str);
DAP_DELETE(l_datum_emission);
// create first transaction (with tx_token)
dap_chain_datum_tx_t *l_tx = DAP_NEW_Z_SIZE(dap_chain_datum_tx_t, sizeof(dap_chain_datum_tx_t));
......@@ -2526,18 +2562,20 @@ int com_token_emit(int argc, char ** argv, char ** str_reply)
DAP_DELETE(l_tx);
// Add to mempool tx token
if(dap_chain_global_db_gr_set(l_key_str, l_datum_tx, l_datum_tx_size
if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), l_datum_tx, l_datum_tx_size
, l_gdb_group_mempool_base_tx)) {
s_net_set_go_sync(l_net);
dap_chain_node_cli_set_reply_text(str_reply, "%s\ndatum tx %s is placed in datum pool ", str_reply_tmp,
l_key_str);
}
else {
DAP_DELETE(l_key_str);
} else {
dap_chain_node_cli_set_reply_text(str_reply, "%s\ndatum tx %s is not placed in datum pool ", str_reply_tmp,
l_key_str);
DAP_DELETE(l_key_str);
return -2;
}
DAP_DELETE(str_reply_tmp);
DAP_DELETE(l_key_str);
DAP_DELETE(l_datum_tx);
DAP_DELETE(l_addr);
return 0;
......@@ -2551,24 +2589,122 @@ int com_token_emit(int argc, char ** argv, char ** str_reply)
int com_tx_cond_create(int argc, char ** argv, char **str_reply)
{
(void) argc;
// test
/*
const char * l_token_ticker = NULL;
int arg_index = 1;
const char *c_wallets_path = dap_chain_wallet_get_path(g_config);
const char *c_wallet_name_from = "w_tesla"; // where to take coins for service
const char *c_wallet_name_cond = "w_picnic"; // who will be use service, usually the same address (addr_from)
uint64_t l_value = 50;
const char * l_token_ticker = NULL;
const char * l_wallet_from_str = NULL;
const char * l_wallet_to_str = NULL; //l_addr_to_str
const char * l_value_datoshi_str = NULL;
const char * l_net_name = NULL;
const char * l_unit_str = NULL;
const char * l_service_str = NULL;
uint64_t l_value_datoshi = 0;
// Token ticker
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-token", &l_token_ticker);
// Wallet name - from
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-wallet_f", &l_wallet_from_str);
// Wallet address - to
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-wallet_t", &l_wallet_to_str);
// value datoshi
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-value", &l_value_datoshi_str);
// net
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-net", &l_net_name);
// unit
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-unit", &l_unit_str);
// service
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-service", &l_service_str);
if(!l_token_ticker) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-token'");
return -1;
}
if(!l_wallet_from_str) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-wallet_f'");
return -2;
}
if(!l_wallet_to_str) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-wallet_t'");
return -3;
}
if(!l_value_datoshi_str) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-value'");
return -4;
}
dap_chain_wallet_t *l_wallet_from = dap_chain_wallet_open(c_wallet_name_from, c_wallets_path);
dap_enc_key_t *l_key = dap_chain_wallet_get_key(l_wallet_from, 0);
dap_chain_wallet_t *l_wallet_cond = dap_chain_wallet_open(c_wallet_name_cond, c_wallets_path);
if(!l_net_name) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-net'");
return -5;
}
if(!l_unit_str) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-unit={mb|kb|b|sec|day}'");
return -6;
}
if(!l_service_str) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_cond_create requires parameter '-service={vpn}'");
return -7;
}
dap_chain_net_srv_uid_t l_srv_uid = { 0 };
if(!dap_strcmp(l_service_str, "vpn"))
l_srv_uid.uint64 = 0x0000000000000001;
//dap_chain_addr_t *addr_to = dap_chain_addr_from_str(l_addr_to_str);
if(!l_srv_uid.uint64) {
dap_chain_node_cli_set_reply_text(str_reply, "can't recognize service='%s' unit must look like {vpn}",
l_service_str);
return -8;
}
dap_chain_net_srv_price_unit_uid_t l_price_unit = { .enm = SERV_UNIT_UNDEFINED };
if(!dap_strcmp(l_unit_str, "mb"))
l_price_unit.enm = SERV_UNIT_MB;
else if(!dap_strcmp(l_unit_str, "sec"))
l_price_unit.enm = SERV_UNIT_SEC;
else if(!dap_strcmp(l_unit_str, "day"))
l_price_unit.enm = SERV_UNIT_DAY;
else if(!dap_strcmp(l_unit_str, "kb"))
l_price_unit.enm = SERV_UNIT_KB;
else if(!dap_strcmp(l_unit_str, "b"))
l_price_unit.enm = SERV_UNIT_B;
if(l_price_unit.enm == SERV_UNIT_UNDEFINED) {
dap_chain_node_cli_set_reply_text(str_reply, "can't recognize unit='%s' unit must look like {mb|kb|b|sec|day}",
l_unit_str);
return -9;
}
l_value_datoshi = strtoll(l_value_datoshi_str, NULL, 10);
if(!l_value_datoshi) {
dap_chain_node_cli_set_reply_text(str_reply, "can't recognize value='%s' as a number", l_value_datoshi_str);
return -10;
}
dap_chain_net_t * l_net = l_net_name ? dap_chain_net_by_name(l_net_name) : NULL;
if(!l_net) {
dap_chain_node_cli_set_reply_text(str_reply, "can't find net '%s'", l_net_name);
return -11;
}
dap_chain_wallet_t *l_wallet_from = dap_chain_wallet_open(l_wallet_from_str, c_wallets_path);
if(!l_wallet_from) {
dap_chain_node_cli_set_reply_text(str_reply, "can't open wallet '%s'", l_wallet_from);
return -12;
}
dap_chain_wallet_t *l_wallet_cond = dap_chain_wallet_open(l_wallet_to_str, c_wallets_path);
if(!l_wallet_to_str) {
dap_chain_wallet_close(l_wallet_from);
dap_chain_node_cli_set_reply_text(str_reply, "can't open wallet '%s'", l_wallet_to_str);
return -13;
}
dap_enc_key_t *l_key_from = dap_chain_wallet_get_key(l_wallet_from, 0);
dap_enc_key_t *l_key_cond = dap_chain_wallet_get_key(l_wallet_cond, 0);
// where to take coins for service
const dap_chain_addr_t *addr_from = dap_chain_wallet_get_addr(l_wallet_from);
const dap_chain_addr_t *l_addr_from = dap_chain_wallet_get_addr(l_wallet_from, l_net->pub.id);
// who will be use service, usually the same address (addr_from)
const dap_chain_addr_t *addr_cond = dap_chain_wallet_get_addr(l_wallet_cond);
//const dap_chain_addr_t *l_addr_cond = dap_chain_wallet_get_addr(l_wallet_cond, l_net->pub.id);
dap_chain_net_srv_abstract_t l_cond;
/* //dap_chain_net_srv_abstract_t l_cond;
// dap_chain_net_srv_abstract_set(&l_cond, SERV_CLASS_PERMANENT, SERV_ID_VPN, l_value, SERV_UNIT_MB,
// "test vpn service");
// dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name((const char *) c_net_name);
......@@ -2576,14 +2712,33 @@ int com_tx_cond_create(int argc, char ** argv, char **str_reply)
int res = dap_chain_mempool_tx_create_cond(NULL, l_key, l_key_cond, addr_from,
addr_cond,
NULL, l_token_ticker, l_value, 0, (const void*) &l_cond, sizeof(dap_chain_net_srv_abstract_t));
*/
dap_chain_hash_fast_t *l_tx_cond_hash = dap_chain_mempool_tx_create_cond(l_net, l_key_from, l_key_cond, l_addr_from, l_token_ticker,
l_value_datoshi, 0, l_price_unit, l_srv_uid, 0, NULL, 0);
dap_chain_wallet_close(l_wallet_from);
dap_chain_wallet_close(l_wallet_cond);
dap_chain_node_cli_set_reply_text(str_reply, "cond create=%s\n",
char *l_hash_str = l_tx_cond_hash ? dap_chain_hash_fast_to_str_new(l_tx_cond_hash) : NULL;
/*dap_chain_node_cli_set_reply_text(str_reply, "cond create=%s\n",
(res == 0) ? "Ok" : (res == -2) ? "False, not enough funds for service fee" : "False");
return res;
*/
return -1;
return res;*/
int l_ret;
// example: cond create succefully hash=0x4AA303EB7C10430C0AAC42F399D265BC7DD09E3983E088E02B8CED38DA22EDA9
if(l_hash_str){
dap_chain_node_cli_set_reply_text(str_reply, "cond create succefully hash=%s\n", l_hash_str);
l_ret = 0;
}
else{
dap_chain_node_cli_set_reply_text(str_reply, "cond can't create\n");
l_ret = -1;
}
DAP_DELETE(l_hash_str);
return l_ret;
}
/**
......
dap_chain_node_client.c
View file @ 0c4b45ab
......@@ -59,9 +59,6 @@
#define LOG_TAG "dap_chain_node_client"
#define DAP_APP_NAME NODE_NETNAME"-node"
#define SYSTEM_PREFIX "/opt/"DAP_APP_NAME
#define SYSTEM_CONFIGS_DIR SYSTEM_PREFIX"/etc"
//static int listen_port_tcp = 8079;
......@@ -79,21 +76,6 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
*/
int dap_chain_node_client_init(void)
{
dap_config_t *g_config;
// read listen_port_tcp from settings
memcpy( s_sys_dir_path + l_sys_dir_path_len, SYSTEM_CONFIGS_DIR, sizeof(SYSTEM_CONFIGS_DIR) );
dap_config_init(s_sys_dir_path);
memset(s_sys_dir_path + l_sys_dir_path_len, '\0', MAX_PATH - l_sys_dir_path_len);
if((g_config = dap_config_open(DAP_APP_NAME)) == NULL) {
return -1;
}
/*else {
const char *port_str = dap_config_get_item_str(g_config, "server", "listen_port_tcp");
listen_port_tcp = (port_str) ? atoi(port_str) : 8079;
}*/
if(g_config)
dap_config_close(g_config);
return 0;
}
......@@ -295,18 +277,24 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
if(l_request) {
uint64_t l_id_last_here = 1;
// for sync chain not used time
if(a_pkt_type != DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS)
l_id_last_here =(uint64_t) dap_db_log_get_last_id();
if(l_request->id_start < l_id_last_here) {
//if(a_pkt_type != DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS)
// l_id_last_here =(uint64_t) dap_db_log_get_last_id();
if(1) {//if(l_request->id_start < l_id_last_here) {
log_it(L_INFO, "Remote is synced but we have updates for it");
bool l_is_sync = true;
// Get log diff
a_ch_chain->request_last_ts = dap_db_log_get_last_id();
dap_list_t *l_list = dap_db_log_get_list((time_t) l_request->id_start);
if(l_list) {
// Add it to outgoing list
l_list->prev = a_ch_chain->request_global_db_trs;
a_ch_chain->request_global_db_trs = l_list;
if(a_pkt_type == DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB) {
a_ch_chain->request_last_ts = dap_db_log_get_last_id();
dap_list_t *l_list = dap_db_log_get_list(l_request->id_start + 1);
if(l_list) {
// Add it to outgoing list
l_list->prev = a_ch_chain->request_global_db_trs;
a_ch_chain->request_global_db_trs = l_list;
}
else
l_is_sync = false;
}
if(l_is_sync) {
a_ch_chain->request_net_id.uint64 = a_pkt->hdr.net_id.uint64;
a_ch_chain->request_cell_id.uint64 = a_pkt->hdr.cell_id.uint64;
a_ch_chain->request_chain_id.uint64 = a_pkt->hdr.chain_id.uint64;
......@@ -329,8 +317,7 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
for(size_t i = 0; i < l_lasts_size; i++) {
dap_chain_atom_item_t * l_item = NULL;
dap_chain_hash_fast_t l_atom_hash;
dap_hash_fast(l_lasts[i], l_chain->callback_atom_get_size(l_lasts[i]),
&l_atom_hash);
dap_hash_fast(l_lasts[i], l_chain->callback_atom_get_size(l_lasts[i]), &l_atom_hash);
HASH_FIND(hh, a_ch_chain->request_atoms_lasts, &l_atom_hash, sizeof(l_atom_hash), l_item);
if(l_item == NULL) { // Not found, add new lasts
l_item = DAP_NEW_Z(dap_chain_atom_item_t);
......@@ -338,8 +325,8 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
memcpy(&l_item->atom_hash, &l_atom_hash, sizeof(l_atom_hash));
HASH_ADD(hh, a_ch_chain->request_atoms_lasts, atom_hash, sizeof(l_atom_hash), l_item);
}
else
DAP_DELETE(l_lasts[i]);
//else
// DAP_DELETE(l_lasts[i]);
}
DAP_DELETE(l_lasts);
DAP_DELETE(l_iter);
......@@ -351,20 +338,21 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
a_ch_chain->request_net_id, a_ch_chain->request_chain_id,
a_ch_chain->request_cell_id, &l_node_addr, sizeof(dap_chain_node_addr_t));
log_it(L_INFO, "Sync for remote tr_count=%d", dap_list_length(l_list));
log_it(L_INFO, "Sync for remote tr type=%d", a_pkt_type);//_count=%d", dap_list_length(l_list));
dap_stream_ch_set_ready_to_write(a_ch_chain->ch, true);
}
} else {
log_it(L_INFO, "Remote node has lastes ts for us");
pthread_mutex_lock(&l_node_client->wait_mutex);
l_node_client->state = NODE_CLIENT_STATE_SYNCED;
pthread_mutex_unlock(&l_node_client->wait_mutex);
else {
log_it(L_INFO, "Remote node has lastes timestamp for us type=%d", a_pkt_type);
pthread_mutex_lock(&l_node_client->wait_mutex);
l_node_client->state = NODE_CLIENT_STATE_SYNCED;
pthread_mutex_unlock(&l_node_client->wait_mutex);
#ifndef _WIN32
pthread_cond_signal(&l_node_client->wait_cond);
pthread_cond_signal(&l_node_client->wait_cond);
#else
SetEvent( l_node_client->wait_cond );
#endif
}
}
} else {
log_it(L_INFO, "Sync notify without request to sync back, stay in SYNCED state");
......
dap_chain_node_ping.c
View file @ 0c4b45ab
......@@ -165,7 +165,7 @@ int wait_node_ping(pthread_t l_thread, int timeout_ms)
timeout_ms *= 1000;
l_wait_time.tv_sec += timeout_ms / DAP_USEC_PER_SEC;
l_wait_time.tv_nsec += 1000 * (timeout_ms % DAP_USEC_PER_SEC);
#ifndef _WIN32
#if !defined(_WIN32) && !defined(__ANDROID__)
int res = pthread_timedjoin_np(l_thread, (void **) &l_ping_time, &l_wait_time);
#else
int res = pthread_join(l_thread, (void **) &l_ping_time);
......
iputils/iputils.h
View file @ 0c4b45ab
......@@ -20,6 +20,7 @@
#define uid_t uint32_t
#endif
#include <setjmp.h>
#include <sys/time.h>
#ifdef __cplusplus
extern "C" {
......