dap_chain_net.c

@@ -56,6 +56,8 @@
 #include "dap_file_utils.h"
 #include "dap_config.h"
 #include "dap_hash.h"
+#include "dap_cert.h"
+#include "dap_chain_common.h"
 #include "dap_chain_net.h"
 #include "dap_chain_node_client.h"
 #include "dap_chain_node_cli.h"
@@ -1300,9 +1302,63 @@ int s_net_load(const char * a_net_name)
         char ** l_seed_nodes_port = dap_config_get_array_str( l_cfg , "general" ,"seed_nodes_port"
                                                                      ,&l_seed_nodes_port_len);
 
-        //const char * l_node_ipv4_str = dap_config_get_item_str(l_cfg , "general" ,"node-ipv4");
-        const char * l_node_addr_str = dap_config_get_item_str(l_cfg , "general" ,"node-addr");
-        const char * l_node_alias_str = dap_config_get_item_str(l_cfg , "general" , "node-alias");
+        const char * l_node_addr_type = dap_config_get_item_str_default(l_cfg , "general" ,"node_addr_type","auto");
+
+        const char * l_node_addr_str = NULL;
+        const char * l_node_alias_str = NULL;
+
+        // use unique addr from pub key
+        if(!dap_strcmp(l_node_addr_type, "auto")) {
+            size_t l_pub_key_data_size = 0;
+            uint8_t *l_pub_key_data = NULL;
+
+            // read pub key
+            l_pub_key_data = dap_chain_global_db_gr_get("cur-node-addr-pkey", &l_pub_key_data_size, GROUP_LOCAL_NODE_ADDR);
+            // generate new pub key
+            if(!l_pub_key_data || !l_pub_key_data_size){
+
+                const char * l_certs_name_str = "node-addr";
+                dap_cert_t ** l_certs = NULL;
+                size_t l_certs_size = 0;
+                dap_cert_t * l_cert = NULL;
+                // Load certs or create if not found
+                if(!dap_cert_parse_str_list(l_certs_name_str, &l_certs, &l_certs_size)) { // Load certs
+                    const char *l_cert_folder = dap_cert_get_folder(0);
+                    // create new cert
+                    if(l_cert_folder) {
+                        char *l_cert_path = dap_strdup_printf("%s/%s.dcert", l_cert_folder, l_certs_name_str);
+                        l_cert = dap_cert_generate(l_certs_name_str, l_cert_path, DAP_ENC_KEY_TYPE_SIG_DILITHIUM);
+                        DAP_DELETE(l_cert_path);
+                    }
+                }
+                if(l_certs_size > 0)
+                    l_cert = l_certs[0];
+                if(l_cert) {
+                    l_pub_key_data = dap_enc_key_serealize_pub_key(l_cert->enc_key, &l_pub_key_data_size);
+                    // save pub key
+                    if(l_pub_key_data && l_pub_key_data_size > 0)
+                        dap_chain_global_db_gr_set(dap_strdup("cur-node-addr-pkey"), (uint8_t*) l_pub_key_data, l_pub_key_data_size,
+                        GROUP_LOCAL_NODE_ADDR);
+                }
+            }
+            // generate addr from pub_key
+            dap_chain_hash_fast_t l_hash;
+            if(l_pub_key_data_size > 0 && dap_hash_fast(l_pub_key_data, l_pub_key_data_size, &l_hash) == 1) {
+                l_node_addr_str = dap_strdup_printf("%04X::%04X::%04X::%04X",
+                        (uint16_t) *(uint16_t*) (l_hash.raw),
+                        (uint16_t) *(uint16_t*) (l_hash.raw + 2),
+                        (uint16_t) *(uint16_t*) (l_hash.raw + DAP_CHAIN_HASH_FAST_SIZE - 4),
+                        (uint16_t) *(uint16_t*) (l_hash.raw + DAP_CHAIN_HASH_FAST_SIZE - 2));
+            }
+            DAP_DELETE(l_pub_key_data);
+        }
+        // use static addr from setting
+        else if(!dap_strcmp(l_node_addr_type, "static")) {
+            //const char * l_node_ipv4_str = dap_config_get_item_str(l_cfg , "general" ,"node-ipv4");
+            l_node_addr_str = dap_strdup(dap_config_get_item_str(l_cfg, "general", "node-addr"));
+            l_node_alias_str = dap_config_get_item_str(l_cfg, "general", "node-alias");
+        }
+
         log_it (L_DEBUG, "Read %u aliases, %u address and %u ipv4 addresses, check them",
                 PVT(l_net)->seed_aliases_count,l_seed_nodes_addrs_len, l_seed_nodes_ipv4_len );
         // save new nodes from cfg file to db
@@ -1398,16 +1454,16 @@ int s_net_load(const char * a_net_name)
                     parse_succesfully = true;
                 }
                 if ( !parse_succesfully && dap_chain_node_addr_from_str(l_node_addr, l_node_addr_str) == 0) {
-                    log_it(L_DEBUG, "Parse node address with format " NODE_ADDR_FP_STR);
+                    log_it(L_DEBUG, "Parse node address with format 04hX::04hX::04hX::04hX");
                     parse_succesfully = true;
                 }
 
                 if (!parse_succesfully){
-                    log_it(L_ERROR,"Can't parse node address");
+                    log_it(L_ERROR,"Can't parse node address %s", l_node_addr_str);
                     DAP_DELETE(l_node_addr);
                     l_node_addr = NULL;
                 }
-                log_it(L_NOTICE, "Parse node addr %s successfully", l_node_addr_str);
+                log_it(L_NOTICE, "Parse node addr " NODE_ADDR_FP_STR " successfully", NODE_ADDR_FP_ARGS(l_node_addr));
                 PVT(l_net)->node_addr = l_node_addr;
                 //}
             }

dap_chain_node_cli_cmd.c

@@ -991,7 +991,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
                 return -1;
             }
             // wait connected
-            int timeout_ms = 7000; //5 sec = 5000 ms
+            int timeout_ms = 7000; // 7 sec = 7000 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){
@@ -1027,7 +1027,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
             dap_chain_node_cli_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);
+            dap_chain_node_client_close(l_node_client);
             //DAP_DELETE(l_remote_node_info);
             return -1;
         }
@@ -1131,7 +1131,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
         }
         dap_stream_ch_set_ready_to_write(l_ch_chain, true);
         // wait for finishing of request
-        int timeout_ms = 1200000; // 20 min = 1200 sec = 1 200 000 ms
+        int timeout_ms = 420000; // 7 min = 420 sec = 420 000 ms
         // TODO add progress info to console
         res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
         if(res < 0) {
@@ -1173,9 +1173,9 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
         }
         log_it(L_INFO, "Chains and gdb are synced");
         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);
+        //dap_client_disconnect(l_node_client->client);
+        //l_node_client->client = NULL;
+        dap_chain_node_client_close(l_node_client);
         dap_chain_node_cli_set_reply_text(a_str_reply, "Node sync completed: Chains and gdb are synced");
         return 0;
 

dap_chain_node_client.c

@@ -487,13 +487,13 @@ void dap_chain_node_client_close(dap_chain_node_client_t *a_client)
 {
     if(a_client) {
 
-        pthread_mutex_lock(&a_client->wait_mutex);
-        a_client->client->_inheritor = NULL; // because client->_inheritor == a_client
-        pthread_mutex_unlock(&a_client->wait_mutex);
+        //pthread_mutex_lock(&a_client->wait_mutex);
+        //a_client->client->_inheritor = NULL; // because client->_inheritor == a_client
+        //pthread_mutex_unlock(&a_client->wait_mutex);
 
         // clean client
         dap_client_delete(a_client->client);
-        a_client->client = NULL;
+        //a_client->client = NULL;
 
 #ifndef _WIN32
         pthread_cond_destroy(&a_client->wait_cond);