dap-sdk/core/src/dap_common.c

@@ -166,8 +166,9 @@ static char* s_appname = NULL;
 
 DAP_STATIC_INLINE void s_update_log_time(char *a_datetime_str) {
     time_t t = time(NULL);
-    struct tm *tmptime = localtime(&t);
-    strftime(a_datetime_str, 32, "[%x-%X]", tmptime);
+    struct tm tmptime;
+    if(localtime_r(&t, &tmptime))
+        strftime(a_datetime_str, 32, "[%x-%X]", &tmptime);
 }
 
 /**

dap-sdk/crypto/include/dap_sign.h

@@ -110,6 +110,8 @@ int dap_sign_verify (dap_sign_t * a_chain_sign, const void * a_data, const size_
 
 dap_sign_t * dap_sign_create(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size
                                          ,  size_t a_output_wish_size );
+dap_sign_t * dap_sign_pack(dap_enc_key_t *a_key, const void * a_sign_ser, const size_t a_sign_ser_size, const void * a_pkey, const size_t a_pub_key_size);
+
 size_t dap_sign_create_output_unserialized_calc_size(dap_enc_key_t * a_key,size_t a_output_wish_size );
 //int dap_sign_create_output(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size
 //                                 , void * a_output, size_t a_output_size );

dap-sdk/crypto/src/dap_sign.c

@@ -243,6 +243,27 @@ dap_sign_t * dap_sign_create(dap_enc_key_t *a_key, const void * a_data,
     }
     return NULL;
 }
+/**
+ * @brief dap_sign_pack
+ * @param a_key
+ * @param a_sign_ser
+ * @param a_sign_ser_size
+ * @param a_pkey
+ * @param a_pub_key_size
+ * @return dap_sign_t*
+ */
+dap_sign_t * dap_sign_pack(dap_enc_key_t *a_key, const void * a_sign_ser, const size_t a_sign_ser_size, const void * a_pkey, const size_t a_pub_key_size)
+{
+    dap_sign_t * l_ret = DAP_NEW_Z_SIZE(dap_sign_t, sizeof(dap_sign_hdr_t) + a_sign_ser_size + a_pub_key_size);
+    // write serialized public key to dap_sign_t
+    memcpy(l_ret->pkey_n_sign, a_pkey, a_pub_key_size);
+    l_ret->header.type = dap_sign_type_from_key_type(a_key->type);
+    // write serialized signature to dap_sign_t
+    memcpy(l_ret->pkey_n_sign + a_pub_key_size, a_sign_ser, a_sign_ser_size);
+    l_ret->header.sign_pkey_size = (uint32_t) a_pub_key_size;
+    l_ret->header.sign_size = (uint32_t) a_sign_ser_size;
+    return l_ret;
+}
 
 /**
  * @brief dap_sign_get_sign

dap-sdk/net/client/dap_client_pvt.c

@@ -408,8 +408,12 @@ static void s_stage_status_after(dap_client_pvt_t * a_client_pvt)
                     l_key_str, DAP_ENC_DATA_TYPE_B64);
 
             log_it(L_DEBUG, "ENC request size %u", l_key_str_enc_size);
-            dap_client_pvt_request(a_client_pvt, DAP_UPLINK_PATH_ENC_INIT "/gd4y5yh78w42aaagh",
+            int l_res = dap_client_pvt_request(a_client_pvt, DAP_UPLINK_PATH_ENC_INIT "/gd4y5yh78w42aaagh",
                     l_key_str, l_key_str_enc_size, m_enc_init_response, m_enc_init_error);
+            // bad request
+            if(l_res<0){
+            	a_client_pvt->stage_status = STAGE_STATUS_ERROR;
+            }
             DAP_DELETE(l_key_str);
         }
             break;
@@ -668,7 +672,7 @@ void dap_client_pvt_stage_transaction_begin(dap_client_pvt_t * a_client_internal
  * @param a_request_size
  * @param a_response_proc
  */
-void dap_client_pvt_request(dap_client_pvt_t * a_client_internal, const char * a_path, void * a_request,
+int dap_client_pvt_request(dap_client_pvt_t * a_client_internal, const char * a_path, void * a_request,
         size_t a_request_size, dap_client_callback_data_size_t a_response_proc,
         dap_client_callback_int_t a_response_error)
 {
@@ -689,11 +693,14 @@ void dap_client_pvt_request(dap_client_pvt_t * a_client_internal, const char * a
 //        l_url = DAP_NEW_Z_SIZE(char, l_url_size_max);
 //        snprintf(l_url, l_url_size_max, "http://%s:%u", a_client_internal->uplink_addr, a_client_internal->uplink_port);
 //    }
-    dap_client_http_request(a_client_internal->uplink_addr,a_client_internal->uplink_port, a_request ? "POST" : "GET", "text/text", a_path, a_request,
+    void *l_ret = dap_client_http_request(a_client_internal->uplink_addr,a_client_internal->uplink_port, a_request ? "POST" : "GET", "text/text", a_path, a_request,
             a_request_size, NULL, m_request_response, m_request_error, a_client_internal, NULL);
 //    a_client_internal->curl = dap_http_client_simple_request(l_url, a_request ? "POST" : "GET", "text/text", a_request,
 //            a_request_size, NULL, m_request_response, m_request_error, &a_client_internal->curl_sockfd, a_client_internal, NULL);
 //    DAP_DELETE(l_url);
+    if(l_ret)
+    	return 0;
+    return -1;
 }
 
 /**

dap-sdk/net/client/include/dap_client_pvt.h

@@ -89,7 +89,7 @@ void dap_client_pvt_deinit();
 void dap_client_pvt_stage_transaction_begin(dap_client_pvt_t * dap_client_pvt_t, dap_client_stage_t a_stage_next,
                                                  dap_client_callback_t a_done_callback);
 
-void dap_client_pvt_request(dap_client_pvt_t * a_client_internal, const char * a_path, void * a_request,
+int dap_client_pvt_request(dap_client_pvt_t * a_client_internal, const char * a_path, void * a_request,
                     size_t a_request_size,  dap_client_callback_data_size_t a_response_proc, dap_client_callback_int_t a_response_error);
 
 void dap_client_pvt_request_enc(dap_client_pvt_t * a_client_internal, const char * a_path, const char * a_sub_url,

dap-sdk/net/core/dap_events_socket.c

@@ -272,12 +272,11 @@ int dap_events_socket_kill_socket( dap_events_socket_t *a_es )
 
   uint32_t tn = a_es->dap_worker->number_thread;
 
-  dap_worker_t *w = a_es->dap_worker;
   //dap_events_t *d_ev = w->events;
 
-  pthread_mutex_lock( &w->locker_on_count );
+  pthread_mutex_lock( &a_es->dap_worker->locker_on_count );
   if ( a_es->kill_signal ) {
-    pthread_mutex_unlock( &w->locker_on_count );
+    pthread_mutex_unlock( &a_es->dap_worker ->locker_on_count );
     return 0;
   }
 
@@ -286,7 +285,7 @@ int dap_events_socket_kill_socket( dap_events_socket_t *a_es )
   a_es->kill_signal = true;
   //DL_LIST_ADD_NODE_HEAD( d_ev->to_kill_sockets, a_es, kprev, knext, w->event_to_kill_count );
 
-  pthread_mutex_unlock( &w->locker_on_count );
+  pthread_mutex_unlock( &a_es->dap_worker->locker_on_count );
   return 0;
 }
 

modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c

@@ -33,6 +33,7 @@ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/lic
 #include "dap_chain_mempool.h"
 
 #include "dap_chain_net_srv.h"
+#include "dap_chain_net_srv_common.h"
 #include "dap_chain_net_srv_stream_session.h"
 
 
@@ -48,6 +49,7 @@ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/lic
 
 typedef struct dap_stream_ch_chain_net_srv {
     pthread_mutex_t mutex;
+    dap_chain_net_srv_uid_t srv_uid;
 } dap_stream_ch_chain_net_srv_t;
 
 #define DAP_STREAM_CH_CHAIN_NET_SRV(a) ((dap_stream_ch_chain_net_srv_t *) ((a)->internal) )
@@ -57,7 +59,6 @@ static void s_stream_ch_delete(dap_stream_ch_t* ch , void* arg);
 static void s_stream_ch_packet_in(dap_stream_ch_t* ch , void* arg);
 static void s_stream_ch_packet_out(dap_stream_ch_t* ch , void* arg);
 
-
 /**
  * @brief dap_stream_ch_chain_net_init
  * @return
@@ -65,7 +66,7 @@ static void s_stream_ch_packet_out(dap_stream_ch_t* ch , void* arg);
 int dap_stream_ch_chain_net_srv_init(void)
 {
     log_it(L_NOTICE,"Chain network services channel initialized");
-    dap_stream_ch_proc_add('R',s_stream_ch_new,s_stream_ch_delete,s_stream_ch_packet_in,s_stream_ch_packet_out);
+    dap_stream_ch_proc_add(dap_stream_ch_chain_net_srv_get_id(),s_stream_ch_new,s_stream_ch_delete,s_stream_ch_packet_in,s_stream_ch_packet_out);
 
     return 0;
 }
@@ -78,6 +79,16 @@ void dap_stream_ch_chain_net_srv_deinit(void)
 
 }
 
+/**
+ * @brief Set srv uid - for client
+ */
+void dap_stream_ch_chain_net_srv_set_srv_uid(dap_stream_ch_t* a_ch, dap_chain_net_srv_uid_t a_srv_uid)
+{
+    // save srv id
+    dap_stream_ch_chain_net_srv_t * l_ch_chain_net_srv = DAP_STREAM_CH_CHAIN_NET_SRV(a_ch);
+    l_ch_chain_net_srv->srv_uid.uint64 = a_srv_uid.uint64;
+}
+
 /**
  * @brief s_stream_ch_new
  * @param a_ch
@@ -135,6 +146,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
 
     if(l_ch_pkt ) {
         switch (l_ch_pkt->hdr.type) {
+        	// only for server
             case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_REQUEST:{
                 if (l_ch_pkt->hdr.size < sizeof(dap_stream_ch_chain_net_srv_pkt_request_hdr_t) ){
                     log_it( L_WARNING, "Wrong request size, less than minimum");
@@ -312,10 +324,35 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
                 //if(l_receipt)
                 //    DAP_DELETE(l_receipt);
             } break;
+            // only for client
             case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_SIGN_REQUEST:{
                 log_it( L_NOTICE, "Requested smth to sign");
+                dap_chain_datum_tx_receipt_t * l_receipt = (dap_chain_datum_tx_receipt_t *) l_ch_pkt->data;
+                size_t l_receipt_size = l_ch_pkt->hdr.size;
+                // create receipt copy, because l_receipt may be reallocated inside dap_chain_datum_tx_receipt_create()!
+                dap_chain_datum_tx_receipt_t *l_receipt_new = dap_chain_datum_tx_receipt_create(l_receipt->receipt_info.srv_uid,
+                        l_receipt->receipt_info.units_type,
+                        l_receipt->receipt_info.units,
+                        l_receipt->receipt_info.value_datoshi,
+                        l_receipt->exts_n_signs, l_receipt->exts_size);
+
+
+                //l_srv_session->usages
+                ///l_usage->service->uid.uint64;
+                //dap_chain_net_srv_usage_t * l_usage = dap_chain_net_srv_usage_find( l_srv_session, l_pkt->hdr.usage_id );
+                dap_chain_net_srv_t * l_srv = dap_chain_net_srv_get(l_ch_chain_net_srv->srv_uid);
+            if(l_srv && l_srv->callback_client_sign_request) {
+                // Sign receipt
+                l_srv->callback_client_sign_request(l_srv, 0, NULL, &l_receipt_new, l_receipt_size);
+                if(dap_stream_ch_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_SIGN_RESPONSE,
+                        l_receipt_new, l_receipt_new->size)) {
+                    dap_stream_ch_set_ready_to_write(a_ch, true);
+                }
+            }
+                DAP_DELETE(l_receipt_new);
                 // TODO sign smth
             } break;
+            // only for server
             case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_SIGN_RESPONSE:{
                 if ( l_ch_pkt->hdr.size > sizeof(dap_chain_receipt_info_t)+1 ){
                     dap_chain_datum_tx_receipt_t * l_receipt = (dap_chain_datum_tx_receipt_t *) l_ch_pkt->data;
@@ -485,6 +522,17 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
             case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_SUCCESS:{
                 log_it( L_NOTICE, "Responsed with success");
                 // TODO code for service client mode
+                dap_stream_ch_chain_net_srv_pkt_success_t * l_success = (dap_stream_ch_chain_net_srv_pkt_success_t*)l_ch_pkt->data;
+                size_t l_success_size = l_ch_pkt->hdr.size;
+                dap_chain_net_srv_t * l_srv = dap_chain_net_srv_get(l_success->hdr.srv_uid);
+                if ( l_srv && l_srv->callback_client_success){
+                    // Create client for client)
+                    dap_chain_net_srv_client_t *l_clients = DAP_NEW_Z( dap_chain_net_srv_client_t);
+                    l_clients->ch = a_ch;
+                    l_clients->ts_created = time(NULL);
+                    l_srv->callback_client_success(l_srv, l_success->hdr.usage_id,  l_clients, l_success, l_success_size );
+                    //l_success->hdr.net_id, l_success->hdr.srv_uid, l_success->hdr.usage_id
+                }
             } break;
             case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_DATA:{
                 if (l_ch_pkt->hdr.size < sizeof(dap_stream_ch_chain_net_srv_pkt_data_hdr_t) ){

modules/channel/chain-net-srv/include/dap_stream_ch_chain_net_srv.h

@@ -25,6 +25,9 @@
 
 #pragma once
 
+#include "dap_chain_common.h"
+
 int dap_stream_ch_chain_net_srv_init(void);
 void dap_stream_ch_chain_net_srv_deinit(void);
 
+void dap_stream_ch_chain_net_srv_set_srv_uid(dap_stream_ch_t* a_ch, dap_chain_net_srv_uid_t a_srv_uid);

modules/net/CMakeLists.txt

@@ -39,13 +39,13 @@ 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_wallet dap_chain_net_srv
+  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 dap_chain_net_srv_stake)
 endif()
 
 if(UNIX)
     target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_chain
-      dap_chain_wallet dap_chain_net_srv dap_chain_mempool dap_chain_global_db dap_chain_net_srv_stake
+      dap_chain_crypto dap_chain_wallet dap_chain_net_srv dap_chain_net_srv_vpn dap_chain_mempool dap_chain_global_db dap_chain_net_srv_stake
       resolv
       )
 endif()

modules/net/dap_chain_net.c

@@ -120,10 +120,11 @@ typedef struct dap_chain_net_pvt{
     dap_chain_node_info_t * node_info; // Current node's info
 
     dap_chain_node_client_t * links;
-    size_t links_count;
 
     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;
@@ -424,7 +425,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                                 l_links_addrs_count * sizeof(dap_chain_node_addr_t));
 
                         // add linked nodes for connect
-                        for(uint16_t i = 0; i < min(4, l_cur_node_info->hdr.links_number); i++) {
+                        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);
@@ -442,8 +443,8 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                     }
                     // if no links then add 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);
+                        // 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));
 
@@ -484,13 +485,19 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                 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_links_count >= s_required_links_count || (l_links_count + 1) >= s_max_links_count) {
-                // TODO what if other failed and we want more?
+            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++;
@@ -521,7 +528,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                 }else {
                     log_it(L_DEBUG, "Cant establish link %u", l_links_count);
                     dap_chain_node_client_close(l_node_client);
-                    l_node_client = NULL;
+                    l_pvt_net->links = NULL;
                 }
             }
         }
@@ -609,7 +616,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
             if (res == 0) {
                 log_it(L_WARNING,"Can't send NODE_ADDR_REQUEST packet");
                 dap_chain_node_client_close(l_node_client);
-                l_node_client = NULL;
+                l_pvt_net->links = NULL;
                 l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
                 break; // try with another link
             }
@@ -675,7 +682,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
             if (l_res == 0) {
                 log_it(L_WARNING, "Can't send GDB sync request");
                 dap_chain_node_client_close(l_node_client);
-                l_node_client = NULL;
+                l_pvt_net->links = NULL;
                 l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
                 break;  //try another link
             }
@@ -700,8 +707,8 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
             if(l_pvt_net->state_target >= NET_STATE_SYNC_CHAINS){
                 l_pvt_net->state = NET_STATE_SYNC_CHAINS;
             } else {
-                l_pvt_net->flags &= ~F_DAP_CHAIN_NET_GO_SYNC;
-                l_pvt_net->state = NET_STATE_ONLINE;
+                l_pvt_net->links_success++;
+                l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
             }
         }
         break;
@@ -765,15 +772,12 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                 //DAP_DELETE( l_atom_iter );
             }
             dap_chain_node_client_close(l_node_client);
-            l_node_client = NULL;
-            if (l_sync_errors) {
-                l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
-                break;
+            l_pvt_net->links = NULL;
+            if (!l_sync_errors) {
+                l_pvt_net->links_success++;
             }
-            log_it(L_INFO, "Synchronization done");
-            l_pvt_net->flags &= ~F_DAP_CHAIN_NET_GO_SYNC;
-            l_pvt_net->state = NET_STATE_ONLINE;
-            l_pvt_net->links_count = 0;
+            l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
+            break;
         }
         break;
 

modules/net/dap_chain_net_bugreport.c

@@ -33,6 +33,7 @@
 #include "dap_strfuncs.h"
 #include "dap_file_utils.h"
 #include "dap_config.h"
+#include "rand/dap_rand.h"
 
 #include "http_status_code.h"
 #include "dap_http_simple.h"
@@ -43,9 +44,9 @@
 
 #define BUGREPORT_URL "/bugreport"
 
-static int bugreport_write_to_file(byte_t *a_request_byte, size_t a_request_size)
+static int64_t bugreport_write_to_file(byte_t *a_request_byte, size_t a_request_size)
 {
-    int l_ret = -2;
+    int64_t l_report_number = -2;
     if(!a_request_byte || !a_request_size)
         return -1;
     char *l_dir_str = dap_strdup_printf("%s/var/bugreport", g_sys_dir_path);
@@ -54,20 +55,30 @@ static int bugreport_write_to_file(byte_t *a_request_byte, size_t a_request_size
     const time_t l_timer = time(NULL);
     struct tm l_tm;
     localtime_r(&l_timer, &l_tm);
-    char *l_filename_str = dap_strdup_printf("%s/%02d-%02d-%02d_%02d:%02d:%02d.brt", l_dir_str,
+    randombytes(&l_report_number, sizeof(int64_t));
+    if(l_report_number<0)
+        l_report_number = -l_report_number;
+    // create unique number for bugreport
+    l_report_number -= l_report_number%1000000000000ll;
+    l_report_number+=(int64_t)(l_tm.tm_year - 100)*10000000000;
+    l_report_number+=(int64_t)(l_tm.tm_mon)*100000000;
+    l_report_number+=(int64_t)(l_tm.tm_mday)*1000000;
+    l_report_number+=(int64_t)(l_tm.tm_hour)*10000;
+    l_report_number+=(int64_t)(l_tm.tm_min)*100;
+    l_report_number+=(int64_t)(l_tm.tm_sec);
+    char *l_filename_str = dap_strdup_printf("%s/%02d-%02d-%02d_%02d:%02d:%02d_%08lld.brt", l_dir_str,
             l_tm.tm_year - 100, l_tm.tm_mon, l_tm.tm_mday,
-            l_tm.tm_hour, l_tm.tm_min, l_tm.tm_sec);
+            l_tm.tm_hour, l_tm.tm_min, l_tm.tm_sec,
+            l_report_number);
     FILE *l_fp;
     if((l_fp = fopen(l_filename_str, "wb")) != NULL) {
-        if(fwrite(a_request_byte, 1, a_request_size, l_fp) == a_request_size)
-            l_ret = 0;
-        else
-            l_ret = -3;
+        if(fwrite(a_request_byte, 1, a_request_size, l_fp) != a_request_size)
+            l_report_number = -3;
         fclose(l_fp);
     }
     DAP_DELETE(l_filename_str);
     DAP_DELETE(l_dir_str);
-    return l_ret;
+    return l_report_number;
 }
 
 /**
@@ -82,16 +93,29 @@ static void bugreport_http_proc(struct dap_http_simple *a_http_simple, void * a_
     log_it(L_DEBUG, "bugreport_http_proc request");
     http_status_code_t * return_code = (http_status_code_t*) a_arg;
     //if(dap_strcmp(cl_st->http->url_path, BUGREPORT_URL) == 0 )
+    if(dap_strcmp(a_http_simple->http->action, "GET") == 0) {
+        size_t l_url_len = dap_strlen(a_http_simple->http->url_path);
+        if(!l_url_len) {
+                    a_http_simple->reply = dap_strdup_printf("Unique Bug Report number required)");
+                    *return_code = Http_Status_NotFound;
+                }
+        else{
+            *return_code = Http_Status_OK;
+        }
+        a_http_simple->reply_size = strlen(a_http_simple->reply);
+        *return_code = Http_Status_NotFound;
+    }
     if(dap_strcmp(a_http_simple->http->action, "POST") == 0) {
         //a_http_simple->request_byte;
         //a_http_simple->request_size;
         //a_http_simple->http->in_content_length;
 
-        if(!bugreport_write_to_file(a_http_simple->request_byte, a_http_simple->request_size)) {
-            a_http_simple->reply = dap_strdup_printf("Bug Report saved successfully)");
+        int64_t l_bugreport_number = bugreport_write_to_file(a_http_simple->request_byte, a_http_simple->request_size);
+        if(l_bugreport_number >= 0) {
+            a_http_simple->reply = dap_strdup_printf("Bug Report #%020lld saved successfully)", l_bugreport_number);
         }
         else {
-            a_http_simple->reply = dap_strdup_printf("Bug Report not saved(");
+            a_http_simple->reply = dap_strdup_printf("Bug Report not saved( code=%lld", l_bugreport_number);
         }
         a_http_simple->reply_size = strlen(a_http_simple->reply);
         *return_code = Http_Status_OK;

modules/net/dap_chain_node_cli.c

@@ -684,6 +684,7 @@ int dap_chain_node_cli_find_option_val( char** argv, int arg_start, int arg_end,
 {
     int arg_index = arg_start;
     const char *arg_string;
+    int l_ret_pos = 0;
 
     while(arg_index < arg_end)
     {
@@ -698,6 +699,9 @@ int dap_chain_node_cli_find_option_val( char** argv, int arg_start, int arg_end,
                     *opt_value = arg_string;
                     return arg_index;
                 }
+                // for case if opt_name exist without value
+                else
+                    l_ret_pos = arg_index;
             }
             else
                 // need only opt_name
@@ -705,7 +709,7 @@ int dap_chain_node_cli_find_option_val( char** argv, int arg_start, int arg_end,
         }
         arg_index++;
     }
-    return 0;
+    return l_ret_pos;
 }
 
 /**
@@ -944,6 +948,10 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
     dap_chain_node_cli_cmd_item_create("tx_history", com_tx_history, NULL, "Transaction history (for address or by hash)",
             "tx_history  [-addr <addr> | -w <wallet name> | -tx <tx_hash>] -net <net name> -chain <chain name>\n");
 
+    // vpn client
+    dap_chain_node_cli_cmd_item_create ("vpn_client", com_vpn_client, NULL, "VPN client control",
+    "vpn_client [start -addr <server address> -port <server port>| stop | status] -net <net name>\n");
+
 
     // Log
     dap_chain_node_cli_cmd_item_create ("print_log", com_print_log, NULL, "Print log info",

modules/net/dap_chain_node_cli_cmd.c

@@ -77,6 +77,7 @@
 #include "dap_chain_net_srv.h"
 #ifndef _WIN32
 #include "dap_chain_net_news.h"
+#include "dap_chain_net_vpn_client.h"
 #endif
 #include "dap_chain_cell.h"
 
@@ -3799,3 +3800,162 @@ int com_news(int a_argc, char ** a_argv, void *a_arg_func, char **a_str_reply)
     dap_chain_node_cli_set_reply_text(a_str_reply, "News added from %s successfully", l_from);
     return 0;
 }
+
+/**
+ * vpn_client command
+ *
+ * VPN client control
+ */
+int com_vpn_client(int a_argc, char ** a_argv, void *arg_func, char **a_str_reply)
+{
+#ifndef _WIN32
+    enum {
+        CMD_NONE, CMD_INIT, CMD_START, CMD_STOP, CMD_STATUS
+    };
+    int l_arg_index = 1;
+    // find net
+    dap_chain_net_t *l_net = NULL;
+    if(dap_chain_node_cli_cmd_values_parse_net_chain(&l_arg_index, a_argc, a_argv, a_str_reply, NULL, &l_net) < 0)
+        return -2;
+
+    int cmd_num = CMD_NONE;
+    if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "init", NULL)) {
+        cmd_num = CMD_INIT;
+    }
+    if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "start", NULL)) {
+            cmd_num = CMD_START;
+        }
+    else if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "stop", NULL)) {
+        cmd_num = CMD_STOP;
+    }
+    else if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "status", NULL)) {
+        cmd_num = CMD_STATUS;
+    }
+    if(cmd_num == CMD_NONE) {
+        if(!a_argv[1])
+            dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameters");
+        else
+            dap_chain_node_cli_set_reply_text(a_str_reply, "parameter %s not recognized", a_argv[1]);
+        return -1;
+    }
+
+    switch (cmd_num)
+    {
+    case CMD_INIT: {
+            const char * l_str_token = NULL; // token name
+            const char * l_str_value_datoshi = NULL;
+            const char * l_str_wallet = NULL; // wallet name
+            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_str_wallet);
+            if(!l_str_wallet)
+                dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-w", &l_str_wallet);
+
+            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_str_token);
+            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-value", &l_str_value_datoshi);
+
+            if(!l_str_wallet) {
+                dap_chain_node_cli_set_reply_text(a_str_reply, "Wallet not defined, use -w <wallet_name> or -wallet <wallet_name> parameter");
+                break;
+            }
+            if(!l_str_token) {
+                dap_chain_node_cli_set_reply_text(a_str_reply, "Token not defined, use -token <token_name> parameter");
+                break;
+            }
+            if(!l_str_value_datoshi) {
+                dap_chain_node_cli_set_reply_text(a_str_reply, "Value of datoshi not defined, use -value <value of datoshi> parameter");
+                break;
+            }
+            uint64_t l_a_value_datoshi = strtoull(l_str_value_datoshi, NULL, 10);
+            if(!l_a_value_datoshi)
+                l_a_value_datoshi = strtoull(l_str_value_datoshi, NULL, 16);
+            if(!l_a_value_datoshi) {
+                dap_chain_node_cli_set_reply_text(a_str_reply, "Value of datoshi have to be more then 0");
+                break;
+            }
+            int l_res = dap_chain_net_vpn_client_update(l_net, l_str_wallet, l_str_token, l_a_value_datoshi);
+            if(!l_res)
+                dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client init successfully");
+            else{
+                if(l_res==-3)
+                    dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client init successfully, but probably not enough founds in the wallet");
+                else
+                    dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client not init");
+            }
+            return l_res;
+    }
+        break;
+    case CMD_START: {
+        const char * l_str_addr = NULL; // for example, "192.168.100.93"
+        const char * l_str_port = NULL; // for example, "8079"
+        dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_str_addr);
+        if(!l_str_addr) {
+            dap_chain_node_cli_set_reply_text(a_str_reply,
+                    "VPN server address not defined, use -addr <vpn server ipv4 address> parameter");
+            break;
+        }
+        dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-port", &l_str_port);
+        int l_srv_port = (l_str_port) ? (int) strtoll(l_str_port, 0, 10) : 0;
+        if(!l_srv_port) {
+            dap_chain_node_cli_set_reply_text(a_str_reply,
+                    "VPN server port not defined, use -port <vpn server port>  parameter");
+            break;
+        }
+        int l_res = dap_chain_net_vpn_client_start(l_net, l_str_addr, NULL, l_srv_port);
+        switch (l_res) {
+        case 0:
+            dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client started successfully");
+            break;
+        case 1:
+            dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client already started");
+            break;
+        case -2:
+        case -3:
+            dap_chain_node_cli_set_reply_text(a_str_reply, "Can't connect to VPN server");
+            break;
+        default:
+            dap_chain_node_cli_set_reply_text(a_str_reply, "Can't start VPN client");
+            break;
+        }
+        return l_res;
+    }
+        break;
+    case CMD_STOP: {
+        int res = dap_chain_net_vpn_client_stop();
+        if(!res)
+            dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client stopped successfully");
+        else
+            dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client not stopped");
+        return res;
+    }
+        break;
+    case CMD_STATUS:
+        {
+        char *l_wallet_name = NULL, *l_str_token = NULL;
+        uint64_t l_value_datoshi = 0;
+        dap_chain_net_vpn_client_get_wallet_info(l_net, &l_wallet_name, &l_str_token, &l_value_datoshi);
+
+        const char *l_status_txt = "";
+        switch (dap_chain_net_vpn_client_status()) {
+        case VPN_CLIENT_STATUS_NOT_STARTED:
+            l_status_txt = "VPN client not started";
+            break;
+        case VPN_CLIENT_STATUS_STARTED:
+            l_status_txt = "VPN client started";
+            break;
+        case VPN_CLIENT_STATUS_STOPPED:
+            l_status_txt = "VPN client stopped";
+            break;
+        case VPN_CLIENT_STATUS_CONN_LOST:
+            l_status_txt = "VPN client lost connection";
+            break;
+        default:
+            l_status_txt = "VPN client status unknown";
+            break;
+        }
+        dap_chain_node_cli_set_reply_text(a_str_reply, "%s\nused:\nwallet:%s\nreceipt:%u*1e-9 %s", l_status_txt,
+                l_wallet_name, l_value_datoshi, l_str_token);
+        break;
+    }
+    }
+#endif
+    return 0;
+}

modules/net/dap_chain_node_client.c

@@ -160,22 +160,31 @@ static void s_stage_connected_callback(dap_client_t *a_client, void *a_arg)
                 NODE_ADDR_FP_ARGS_S( l_node_client->remote_node_addr));
         pthread_mutex_lock(&l_node_client->wait_mutex);
         l_node_client->state = NODE_CLIENT_STATE_CONNECTED;
-        // find current channel code
+        pthread_mutex_unlock(&l_node_client->wait_mutex);
+        // set callbacks for C and N channels; for R and S it is not needed
         dap_client_pvt_t * l_client_internal = DAP_CLIENT_PVT(a_client);
-        dap_stream_ch_t * l_ch = NULL;
-        if(l_client_internal && l_client_internal->active_channels)
-            l_ch = dap_client_get_stream_ch(a_client, l_client_internal->active_channels[0]);
+        if(l_client_internal && l_client_internal->active_channels) {
+            size_t l_channels_count = dap_strlen(l_client_internal->active_channels);
+            for(size_t i = 0; i < l_channels_count; i++) {
+                if(dap_chain_node_client_set_callbacks(a_client, l_client_internal->active_channels[i]) == -1) {
+                    log_it(L_WARNING, "No ch_chain channel, can't init notify callback for pkt type CH_CHAIN");
+                }
+            }
+        }
+        /*
+             // find current channel code
+             dap_stream_ch_t * l_ch = NULL;
+             l_ch = dap_client_get_stream_ch(a_client, l_client_internal->active_channels[0]);
         //dap_stream_ch_t * l_ch = dap_client_get_stream_ch(a_client, dap_stream_ch_chain_get_id());
         if(l_ch) {
+            dap_chain_node_client_set_callbacks(dap_client_t *a_client, uint8_t a_ch_id)
             dap_stream_ch_chain_t * l_ch_chain = DAP_STREAM_CH_CHAIN(l_ch);
             l_ch_chain->callback_notify_packet_out = s_ch_chain_callback_notify_packet_out;
             l_ch_chain->callback_notify_packet_in = s_ch_chain_callback_notify_packet_in;
             l_ch_chain->callback_notify_arg = l_node_client;
         } else {
             log_it(L_WARNING, "No ch_chain channel, can't init notify callback for pkt type CH_CHAIN");
-        }
-
-        pthread_mutex_unlock(&l_node_client->wait_mutex);
+        }*/
         if(l_node_client->callback_connected)
             l_node_client->callback_connected(l_node_client, a_arg);
         l_node_client->keep_connection = true;
@@ -494,6 +503,11 @@ dap_chain_node_client_t* dap_chain_client_connect(dap_chain_node_info_t *a_node_
     //dap_client_pvt_ref(DAP_CLIENT_PVT(l_node_client->client));
     // Handshake & connect
     dap_client_go_stage(l_node_client->client, a_stage_target, s_stage_connected_callback);
+    dap_client_pvt_t *l_client_internal = DAP_CLIENT_PVT(l_node_client->client);
+    if(!l_client_internal || l_client_internal->stage_status == STAGE_STATUS_ERROR){
+    	dap_chain_node_client_close(l_node_client);
+    	return NULL;
+    }
     return l_node_client;
 }
 

modules/net/srv/dap_chain_net_srv.c

@@ -512,6 +512,7 @@ dap_chain_net_srv_t* dap_chain_net_srv_add(dap_chain_net_srv_uid_t a_uid,dap_cha
         HASH_ADD(hh, s_srv_list, uid, sizeof(l_srv->uid), l_sdata);
     }else{
         log_it(L_ERROR, "Already present service with 0x%016llX ", a_uid.uint64);
+        //l_srv = l_sdata->srv;
     }
     pthread_mutex_unlock(&s_srv_list_mutex);
     return l_srv;

modules/net/srv/dap_chain_net_srv_client.c

@@ -24,7 +24,36 @@ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/lic
 
 #include "dap_common.h"
 
+#include "dap_chain_net_srv.h"
 #include "dap_chain_net_srv_client.h"
 
 
 #define LOG_TAG "dap_chain_net_srv_client"
+
+/*
+ * Init service client
+ * l_uid service id
+ * a_callback_client_success callback to start client service
+ */
+//
+int dap_chain_net_srv_client_init(dap_chain_net_srv_uid_t a_uid,
+        dap_chain_net_srv_callback_data_t a_callback_request,
+        dap_chain_net_srv_callback_data_t a_callback_response_success,
+        dap_chain_net_srv_callback_data_t a_callback_response_error,
+        dap_chain_net_srv_callback_data_t a_callback_receipt_next_success,
+        dap_chain_net_srv_callback_data_t a_callback_client_success,
+        dap_chain_net_srv_callback_data_t a_callback_client_sign_request,
+        void *a_inhertor) {
+
+    dap_chain_net_srv_t *l_srv_custom = dap_chain_net_srv_get(a_uid);
+    if(!l_srv_custom) {
+        l_srv_custom = dap_chain_net_srv_add(a_uid, a_callback_request,
+                a_callback_response_success, a_callback_response_error,
+                a_callback_receipt_next_success);
+    }
+    l_srv_custom->callback_client_success = a_callback_client_success;
+    l_srv_custom->callback_client_sign_request = a_callback_client_sign_request;
+    if(a_inhertor)
+        l_srv_custom->_inhertor = a_inhertor;
+    return 0;
+}

modules/net/srv/dap_chain_net_srv_common.c

@@ -45,3 +45,8 @@
 #include "dap_chain_datum_tx_items.h"
 #include "dap_stream.h"
 #include "dap_chain_net_srv_common.h"
+
+uint8_t dap_stream_ch_chain_net_srv_get_id()
+{
+    return 'R';
+}

modules/net/srv/include/dap_chain_net_srv.h

@@ -60,6 +60,11 @@ typedef struct dap_chain_net_srv
     dap_chain_net_srv_callback_ch_t callback_stream_ch_write;
     dap_chain_net_srv_callback_ch_t      callback_stream_ch_closed;
 
+    // Client have to start service
+    dap_chain_net_srv_callback_data_t callback_client_success;
+    // Client have to sign receipt
+    dap_chain_net_srv_callback_data_t callback_client_sign_request;
+
     // Pointer to inheritor object
     void * _inhertor;
 } dap_chain_net_srv_t;
@@ -96,3 +101,12 @@ dap_chain_datum_tx_receipt_t * dap_chain_net_srv_issue_receipt(dap_chain_net_srv
                 dap_chain_net_srv_price_t * a_price, const void * a_ext, size_t a_ext_size
                 );
 
+
+int dap_chain_net_srv_client_init(dap_chain_net_srv_uid_t a_uid,
+        dap_chain_net_srv_callback_data_t a_callback_request,
+        dap_chain_net_srv_callback_data_t a_callback_response_success,
+        dap_chain_net_srv_callback_data_t a_callback_response_error,
+        dap_chain_net_srv_callback_data_t a_callback_receipt_next_success,
+        dap_chain_net_srv_callback_data_t a_callback_client_success,
+        dap_chain_net_srv_callback_data_t a_callback_client_sign_request,
+        void *a_inhertor);

modules/net/srv/include/dap_chain_net_srv_client.h

@@ -23,9 +23,14 @@ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/lic
 */
 #pragma once
 
+#include <stdint.h>
+#include <time.h>
+
+
 #include "dap_chain_net_srv_common.h"
 #include "dap_chain_net_remote.h"
 
+
 typedef struct dap_chain_net_srv_client
 {
     time_t ts_created;

modules/net/srv/include/dap_chain_net_srv_common.h

@@ -177,3 +177,6 @@ DAP_STATIC_INLINE const char * dap_chain_net_srv_price_unit_uid_to_str( dap_chai
         default: return "UNKNOWN";
     }
 }
+
+uint8_t dap_stream_ch_chain_net_srv_get_id();
+