dap-sdk/core/include/dap_common.h

@@ -40,6 +40,19 @@
 
 typedef uint8_t byte_t;
 
+// Stuffs an integer into a pointer type
+#define DAP_INT_TO_POINTER(i) ((void*) (long) (i))
+// Extracts an integer from a pointer
+#define DAP_POINTER_TO_INT(p) ((int)  (long) (p))
+// Stuffs an unsigned integer into a pointer type
+#define DAP_UINT_TO_POINTER(u) ((void*) (unsigned long) (u))
+// Extracts an unsigned integer from a pointer
+#define DAP_POINTER_TO_UINT(p) ((unsigned int) (unsigned long) (p))
+// Stuffs a size_t into a pointer type
+#define DAP_SIZE_TO_POINTER(s) ((void*) (size_t) (s))
+// Extracts a size_t from a pointer
+#define DAP_POINTER_TO_SIZE(p) ((size_t) (p))
+
 #if defined(__GNUC__) ||defined (__clang__)
   #define DAP_ALIGN_PACKED  __attribute__((aligned(1),packed))
 #else

dap-sdk/crypto/src/dap_enc_iaes.c

@@ -76,7 +76,7 @@ void dap_enc_aes_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
 
 size_t dap_enc_iaes256_cbc_decrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
 {
-    if (a_in_size % 16) {
+    if (a_in_size % IAES_BLOCK_SIZE) {
         log_it(L_ERROR, "Bad in data size");
         return 0;
     }
@@ -100,10 +100,13 @@ size_t dap_enc_iaes256_cbc_decrypt_fast(struct dap_enc_key * a_key, const void *
     size_t block_in32_size = IAES_BLOCK_SIZE/sizeof(uint32_t);
     uint32_t round_decrypt_key[60];
     uint32_t feedback[block_in32_size];
+    uint8_t priv_key_swapped_endian[IAES_KEYSIZE];
 
     memcpy(&feedback[0], DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE);
-    swap_endian((uint32_t *)a_key->priv_key_data, IAES_KEYSIZE/sizeof(uint32_t));
-    Key_Shedule_for_decrypT((uint32_t *)a_key->priv_key_data, round_decrypt_key);
+    memcpy(priv_key_swapped_endian, a_key->priv_key_data, sizeof(priv_key_swapped_endian));
+
+    swap_endian(priv_key_swapped_endian, sizeof(priv_key_swapped_endian)/sizeof(uint32_t));
+    Key_Shedule_for_decrypT(priv_key_swapped_endian, round_decrypt_key);
 
     void *data = buf_out;
     const void *cdata = a_in;
@@ -120,10 +123,14 @@ size_t dap_enc_iaes256_cbc_decrypt_fast(struct dap_enc_key * a_key, const void *
 //    for(int i = 0; i < 16; ++i)
 //    {printf("%.2x ", ((uint8_t*)data)[i]);}
 //    printf("\n");fflush(stdout);
-    swap_endian((uint32_t *)a_key->priv_key_data, IAES_KEYSIZE/sizeof(uint32_t));
-
-    return a_in_size - ((uint8_t *)data)[a_in_size - 1];
 
+    size_t l_padding_size = ((uint8_t *)data)[a_in_size - 1];
+    if(l_padding_size > a_in_size){
+        log_it(L_WARNING, "%s: padding size is %u while whole message is just %u", __PRETTY_FUNCTION__, l_padding_size, a_in_size);
+        return 0;
+    }else{
+        return a_in_size - l_padding_size;
+    }
 }
 
 size_t dap_enc_iaes256_cbc_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
@@ -161,9 +168,11 @@ size_t dap_enc_iaes256_cbc_encrypt_fast(struct dap_enc_key * a_key, const void *
 
     size_t block_in32_size = IAES_BLOCK_SIZE/sizeof(uint32_t);
     uint32_t feedback[block_in32_size];
+    uint8_t priv_key_swapped_endian[IAES_KEYSIZE];
+    memcpy(priv_key_swapped_endian, a_key->priv_key_data, sizeof(priv_key_swapped_endian));
 
     memcpy(&feedback[0], DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE);
-    swap_endian((uint32_t *)a_key->priv_key_data, IAES_KEYSIZE/sizeof(uint32_t));
+    swap_endian((uint32_t *)priv_key_swapped_endian, IAES_KEYSIZE/sizeof(uint32_t));
 
     size_t count_block, count32_word;
     const void *data = a_in;
@@ -174,7 +183,7 @@ size_t dap_enc_iaes256_cbc_encrypt_fast(struct dap_enc_key * a_key, const void *
            *((uint32_t *)cdata + count_block * block_in32_size + count32_word) =
                 *((uint32_t *)data + count_block * block_in32_size + count32_word) ^ feedback[count32_word];
 
-        AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)a_key->priv_key_data);
+        AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)priv_key_swapped_endian);
 
         memcpy ((uint32_t *)cdata + count_block * block_in32_size, &feedback[0], IAES_BLOCK_SIZE);
     }
@@ -190,10 +199,9 @@ size_t dap_enc_iaes256_cbc_encrypt_fast(struct dap_enc_key * a_key, const void *
        *((uint32_t *)cdata + count_block * block_in32_size + count32_word) =
             *((uint32_t *)tmp_in + count32_word) ^ feedback[count32_word];
 
-    AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)a_key->priv_key_data);
+    AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)priv_key_swapped_endian);
 
     memcpy ((uint32_t *)cdata + count_block * block_in32_size, &feedback[0], IAES_BLOCK_SIZE);
-    swap_endian((uint32_t *)a_key->priv_key_data,IAES_KEYSIZE/sizeof(uint32_t));
 
 
 //    IAES_256_CBC_encrypt(a_in, buf_out, DAP_ENC_AES_KEY(a_key)->ivec, a_in_size - last_block_from_in, a_key->priv_key_data);

dap-sdk/crypto/src/dap_enc_key.c

@@ -650,14 +650,19 @@ dap_enc_key_t* dap_enc_key_deserealize(const void *buf, size_t buf_size)
     result->priv_key_data_size = in_key->priv_key_data_size;
     result->pub_key_data_size = in_key->pub_key_data_size;
     result->_inheritor_size = in_key->inheritor_size;
+    DAP_DEL_Z(result->priv_key_data)
+    DAP_DEL_Z(result->pub_key_data)
+    result->priv_key_data = DAP_NEW_Z_SIZE(uint8_t, result->priv_key_data_size);
     memcpy(result->priv_key_data, in_key->priv_key_data, result->priv_key_data_size);
+    result->pub_key_data = DAP_NEW_Z_SIZE(uint8_t, result->pub_key_data_size);
     memcpy(result->pub_key_data, in_key->pub_key_data, result->pub_key_data_size);
-
-    if(in_key->inheritor_size)
+    if(in_key->inheritor_size) {
+        DAP_DEL_Z(result->_inheritor)
+        result->_inheritor = DAP_NEW_Z(dap_enc_key_t);
         memcpy(result->_inheritor, in_key->inheritor, in_key->inheritor_size);
-    else
+    } else {
         result->_inheritor = NULL;
-
+    }
     return result;
 }
 

dap-sdk/net/client/dap_client_http.c

@@ -341,6 +341,10 @@ void* dap_client_http_request_custom(const char *a_uplink_addr, uint16_t a_uplin
 
     // create socket
     int l_socket = socket( PF_INET, SOCK_STREAM, 0);
+    if (l_socket == -1) {
+        log_it(L_ERROR, "Error %d with socket create", errno);
+        return NULL;
+    }
     // set socket param
     int buffsize = DAP_CLIENT_HTTP_RESPONSE_SIZE_MAX;
 #ifdef _WIN32

dap-sdk/net/client/dap_client_pvt.c

@@ -452,6 +452,11 @@ static void s_stage_status_after(dap_client_pvt_t * a_client_pvt)
             log_it(L_INFO, "Go to stage STREAM_SESSION: process the state ops");
 
             a_client_pvt->stream_socket = socket( PF_INET, SOCK_STREAM, 0);
+            if (a_client_pvt->stream_socket == -1) {
+                log_it(L_ERROR, "Error %d with socket create", errno);
+                a_client_pvt->stage_status = STAGE_STATUS_ERROR;
+                break;
+            }
 #ifdef _WIN32 
             {
               int buffsize = 65536;

dap-sdk/net/core/dap_events.c

@@ -418,14 +418,16 @@ static void *thread_worker_function(void *arg)
                     //log_it(L_DEBUG, "Output: %u from %u bytes are sent ", total_sent,sa_cur->buf_out_size);
                 }
                 //log_it(L_DEBUG,"Output: sent %u bytes",total_sent);
-                pthread_mutex_lock(&cur->write_hold);
-                cur->buf_out_size -= total_sent;
-                if (cur->buf_out_size) {
-                    memmove(cur->buf_out, &cur->buf_out[total_sent], cur->buf_out_size);
-                } else {
-                    cur->flags &= ~DAP_SOCK_READY_TO_WRITE;
+                if (total_sent) {
+                    pthread_mutex_lock(&cur->write_hold);
+                    cur->buf_out_size -= total_sent;
+                    if (cur->buf_out_size) {
+                        memmove(cur->buf_out, &cur->buf_out[total_sent], cur->buf_out_size);
+                    } else {
+                        cur->flags &= ~DAP_SOCK_READY_TO_WRITE;
+                    }
+                    pthread_mutex_unlock(&cur->write_hold);
                 }
-                pthread_mutex_unlock(&cur->write_hold);
             }
 
             pthread_mutex_lock(&w->locker_on_count);

dap-sdk/net/core/dap_events_socket.c

@@ -118,7 +118,7 @@ void dap_events_socket_create_after( dap_events_socket_t *a_es )
   HASH_ADD_INT( a_es->events->sockets, socket, a_es );
   pthread_rwlock_unlock( &a_es->events->sockets_rwlock );
 
-  a_es->ev.events = EPOLLIN | EPOLLERR | EPOLLOUT;
+  a_es->ev.events = EPOLLIN | EPOLLERR;
   a_es->ev.data.ptr = a_es;
 
   if ( epoll_ctl( a_es->dap_worker->epoll_fd, EPOLL_CTL_ADD, a_es->socket, &a_es->ev ) == 1 )

dap-sdk/net/core/dap_timerfd.c

+/*
+ * Authors:
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc.   https://demlabs.net
+ * Kelvin Project https://github.com/kelvinblockchain
+ * Copyright  (c) 2020
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/timerfd.h>
+#include <inttypes.h>
+
+#include "dap_common.h"
+#include "dap_events_socket.h"
+#include "dap_timerfd.h"
+
+#define LOG_TAG "dap_timerfd"
+
+void callback_timerfd_read(struct dap_events_socket *a_event_sock, void * arg)
+{
+    uint64_t l_ptiu64;
+    size_t l_read_ret;
+    do {
+        l_read_ret = dap_events_socket_read(a_event_sock, &l_ptiu64, sizeof(l_ptiu64));
+
+        if(l_read_ret > 0) {
+            dap_timerfd_t *l_timerfd = a_event_sock->_inheritor;
+            //printf("\nread() returned %d, %d\n", l_ptiu64, l_read_ret);
+            struct itimerspec l_ts;
+            // first expiration in 0 seconds after times start
+            l_ts.it_interval.tv_sec = 0;
+            l_ts.it_interval.tv_nsec = 0;
+            // timeout for timer
+            l_ts.it_value.tv_sec = l_timerfd->timeout_ms / 1000;
+            l_ts.it_value.tv_nsec = (l_timerfd->timeout_ms % 1000) * 1000000;
+            if(timerfd_settime(l_timerfd->tfd, 0, &l_ts, NULL) < 0) {
+                log_it(L_WARNING, "callback_timerfd_read() failed: timerfd_settime() errno=%d\n", errno);
+            }
+            // run user's callback
+            if(l_timerfd->callback)
+                l_timerfd->callback(l_timerfd->callback_arg);
+        }
+    } while(l_read_ret > 0);
+    dap_events_socket_set_readable(a_event_sock, true);
+}
+
+/**
+ * @brief dap_events_socket_init Init clients module
+ * @return Zero if ok others if no
+ */
+int dap_timerfd_init()
+{
+    log_it(L_NOTICE, "Initialized timerfd");
+    return 0;
+}
+
+/**
+ * @brief dap_timerfd_start
+ * @param a_timeout_ms
+ * @param a_callback
+ * @return new allocated dap_timerfd_t structure or NULL if error
+ */
+dap_timerfd_t* dap_timerfd_start(uint64_t a_timeout_ms, dap_timerfd_callback_t *a_callback, void *a_callback_arg)
+{
+    struct itimerspec l_ts;
+    int l_tfd = timerfd_create(CLOCK_MONOTONIC, 0);
+    if(l_tfd == -1) {
+        log_it(L_WARNING, "dap_timerfd_start() failed: timerfd_create() errno=%d\n", errno);
+        return NULL;
+    }
+    // first expiration in 0 seconds after times start
+    l_ts.it_interval.tv_sec = 0;
+    l_ts.it_interval.tv_nsec = 0;
+    // timeout for timer
+    l_ts.it_value.tv_sec = a_timeout_ms / 1000;
+    l_ts.it_value.tv_nsec = (a_timeout_ms % 1000) * 1000000;
+    if(timerfd_settime(l_tfd, 0, &l_ts, NULL) < 0) {
+        log_it(L_WARNING, "dap_timerfd_start() failed: timerfd_settime() errno=%d\n", errno);
+        close(l_tfd);
+        return NULL;
+    }
+
+    // create dap_timerfd_t structure
+    dap_timerfd_t *l_timerfd = DAP_NEW(dap_timerfd_t);
+
+    // create events_socket for timer file descriptor
+    static dap_events_socket_callbacks_t l_s_callbacks = {
+        .read_callback = callback_timerfd_read,
+        .write_callback = NULL,
+        .error_callback = NULL,
+        .delete_callback = NULL
+    };
+    dap_events_socket_t * l_events_socket = dap_events_socket_wrap_no_add(NULL, l_tfd, &l_s_callbacks);
+    l_events_socket->type = DESCRIPTOR_TYPE_FILE;
+    dap_events_socket_create_after(l_events_socket);
+    // pass l_timerfd to events_socket
+    l_events_socket->_inheritor = l_timerfd;
+
+    // fill out dap_timerfd_t structure
+    l_timerfd->timeout_ms = a_timeout_ms;
+    l_timerfd->tfd = l_tfd;
+    l_timerfd->events_socket = l_events_socket;
+    l_timerfd->callback = a_callback;
+    l_timerfd->callback_arg = a_callback_arg;
+    return l_timerfd;
+}
+
+/**
+ * @brief dap_timerfd_stop
+ * @param a_tfd
+ * @param a_callback
+ * @return 0 or <0 if error
+ */
+int dap_timerfd_delete(dap_timerfd_t *l_timerfd)
+{
+    if(!l_timerfd || l_timerfd->tfd < 1 || !l_timerfd->events_socket) {
+        return -1;
+    }
+
+    if(close(l_timerfd->tfd) == -1) {
+        log_it(L_WARNING, "dap_timerfd_stop() failed to close timerfd: errno=%d\n", errno);
+        return -2;
+    }
+
+    dap_events_socket_kill_socket(l_timerfd->events_socket);
+    l_timerfd->events_socket = NULL;
+    DAP_DELETE(l_timerfd);
+    return 0;
+}
+

dap-sdk/net/core/include/dap_timerfd.h

+/*
+ * Authors:
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc.   https://demlabs.net
+ * Kelvin Project https://github.com/kelvinblockchain
+ * Copyright  (c) 2020
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/timerfd.h>
+#include <inttypes.h>
+
+#include "dap_common.h"
+#include "dap_events_socket.h"
+
+typedef void (*dap_timerfd_callback_t)(void * arg); // Callback for timer
+
+typedef struct dap_timerfd {
+    uint64_t timeout_ms;
+    int tfd; //timer file descriptor
+    dap_events_socket_t *events_socket;
+    dap_timerfd_callback_t callback;
+    void *callback_arg;
+} dap_timerfd_t;
+
+int dap_timerfd_init();
+dap_timerfd_t* dap_timerfd_start(uint64_t a_timeout_ms, dap_timerfd_callback_t *a_callback, void *callback_arg);
+int dap_timerfd_delete(dap_timerfd_t *l_timerfd);
+

dap-sdk/net/stream/ch/dap_stream_ch.c

@@ -133,10 +133,15 @@ bool dap_stream_ch_valid(dap_stream_ch_t *a_ch)
 void dap_stream_ch_delete(dap_stream_ch_t *a_ch)
 {
     pthread_mutex_lock(&s_ch_table_lock);
-    struct dap_stream_ch_table_t *l_ret;
+    struct dap_stream_ch_table_t *l_ret;;
     HASH_FIND_PTR(s_ch_table, &a_ch, l_ret);
+    if (!l_ret) {
+        pthread_mutex_unlock(&s_ch_table_lock);
+        return;
+    }
     HASH_DEL(s_ch_table, l_ret);
     pthread_mutex_unlock(&s_ch_table_lock);
+    DAP_DELETE(l_ret);
 
     pthread_mutex_lock(&a_ch->mutex);
     if (a_ch->proc)

modules/chain/dap_chain.c

@@ -200,6 +200,9 @@ static dap_chain_type_t s_chain_type_from_str(const char *a_type_str)
     if(!dap_strcmp(a_type_str, "transaction")) {
         return CHAIN_TYPE_TX;
     }
+    if(!dap_strcmp(a_type_str, "ca")) {
+        return CHAIN_TYPE_CA;
+    }
     return CHAIN_TYPE_LAST;
 }
 
@@ -252,9 +255,9 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
 
             // Recognize chains id
             if ( (l_chain_id_str = dap_config_get_item_str(l_cfg,"chain","id")) != NULL ){
-                if ( sscanf(l_chain_id_str,"0x%016lX",& l_chain_id_u ) !=1 ){
-                    if ( sscanf(l_chain_id_str,"0x%016lx",&l_chain_id_u) !=1 ) {
-                        if ( sscanf(l_chain_id_str,"%lu",&l_chain_id_u ) !=1 ){
+                if ( sscanf(l_chain_id_str,"0x%016llX",& l_chain_id_u ) !=1 ){
+                    if ( sscanf(l_chain_id_str,"0x%016llx",&l_chain_id_u) !=1 ) {
+                        if ( sscanf(l_chain_id_str,"%llu",&l_chain_id_u ) !=1 ){
                             log_it (L_ERROR,"Can't recognize '%s' string as chain net id, hex or dec",l_chain_id_str);
                             dap_config_close(l_cfg);
                             return NULL;

modules/chain/dap_chain_cell.c

@@ -213,7 +213,7 @@ int dap_chain_cell_file_append( dap_chain_cell_t * a_cell, const void* a_atom, s
             l_total_wrote_bytes += a_atom_size;
             // change in chain happened -> nodes synchronization required
             if(a_cell->chain && a_cell->chain->callback_notify)
-                a_cell->chain->callback_notify(a_cell->chain->callback_notify_arg, a_cell->chain, a_cell->id);
+                a_cell->chain->callback_notify(a_cell->chain->callback_notify_arg, a_cell->chain, a_cell->id, (void *)a_atom, a_atom_size);
         } else {
             log_it (L_ERROR, "Can't write data from cell 0x%016X to the file \"%s\"",
                             a_cell->id.uint64,

modules/chain/include/dap_chain.h

@@ -83,7 +83,7 @@ typedef void (*dap_chain_callback_atom_iter_delete_t)(dap_chain_atom_iter_t *  )
 typedef size_t (*dap_chain_datum_callback_datum_pool_proc_add_t)(dap_chain_t * , dap_chain_datum_t **, size_t );
 typedef size_t (*dap_chain_datum_callback_datum_pool_proc_add_with_group_t)(dap_chain_t * , dap_chain_datum_t **, size_t, const char *);
 
-typedef void (*dap_chain_callback_notify_t)(void * a_arg, dap_chain_t *a_chain, dap_chain_cell_id_t a_id); //change in chain happened
+typedef void (*dap_chain_callback_notify_t)(void * a_arg, dap_chain_t *a_chain, dap_chain_cell_id_t a_id, void* a_atom, size_t a_atom_size); //change in chain happened
 
 typedef  enum dap_chain_type
 {
@@ -91,6 +91,7 @@ typedef  enum dap_chain_type
     CHAIN_TYPE_TOKEN,
     CHAIN_TYPE_EMISSION,
     CHAIN_TYPE_TX,
+    CHAIN_TYPE_CA,
     CHAIN_TYPE_LAST
 } dap_chain_type_t;
 

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

@@ -21,7 +21,11 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/licenses/>.
 */
+
+#include <sys/time.h>
 #include "dap_common.h"
+#include "dap_hash.h"
+#include "rand/dap_rand.h"
 
 #include "dap_chain.h"
 #include "dap_chain_datum_tx.h"
@@ -42,17 +46,16 @@ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/lic
 #include "dap_stream_ch_pkt.h"
 #include "dap_stream_ch_chain_net_srv.h"
 #include "dap_stream_ch_chain_net_srv_pkt.h"
-
 #include "dap_stream_ch_proc.h"
+#include "dap_stream_ch_chain_net_srv.h"
 
 #define LOG_TAG "dap_stream_ch_chain_net_srv"
 
-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) )
+uint8_t dap_stream_ch_chain_net_srv_get_id()
+{
+    return 'R';
+}
 
 static void s_stream_ch_new(dap_stream_ch_t* ch , void* arg);
 static void s_stream_ch_delete(dap_stream_ch_t* ch , void* arg);
@@ -146,6 +149,61 @@ 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) {
+            // for send test data
+            case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_CHECK_REQUEST:{
+                int l_err_code = 0;
+                dap_stream_ch_chain_net_srv_pkt_test_t *l_request = (dap_stream_ch_chain_net_srv_pkt_request_t*) l_ch_pkt->data;
+                size_t l_request_size = l_request->data_size + sizeof(dap_stream_ch_chain_net_srv_pkt_test_t);
+                if(l_ch_pkt->hdr.size != l_request_size) {
+                    log_it(L_WARNING, "Wrong request size, less or more than required");
+                    break;
+                }
+
+                gettimeofday(&l_request->recv_time2, NULL);
+                //printf("\n%lu.%06lu \n", (unsigned long) l_request->recv_time2.tv_sec, (unsigned long) l_request->recv_time2.tv_usec);
+                dap_chain_hash_fast_t l_data_hash;
+                dap_hash_fast(l_request->data, l_request->data_size, &l_data_hash);
+                if(l_request->data_size>0 && !dap_hash_fast_compare(&l_data_hash, &(l_request->data_hash))){
+                    l_err_code+=2;
+                }
+
+                // create data to send back
+                dap_stream_ch_chain_net_srv_pkt_test_t *l_request_out = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_test_t, sizeof(dap_stream_ch_chain_net_srv_pkt_test_t) + l_request->data_size_recv);
+                // copy info from recv message
+                memcpy(l_request_out,l_request, sizeof(dap_stream_ch_chain_net_srv_pkt_test_t));
+                l_request_out->data_size = l_request->data_size_recv;
+                randombytes(l_request_out->data, l_request_out->data_size);
+                l_request_out->err_code = l_err_code;
+                dap_hash_fast(l_request_out->data, l_request_out->data_size, &l_request_out->data_hash);
+                memcpy(l_request_out->ip_send, a_ch->stream->conn->s_ip, sizeof(l_request_out->ip_send));
+                gettimeofday(&l_request_out->send_time2, NULL);
+
+                // send response
+                if(dap_stream_ch_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_CHECK_RESPONSE, l_request_out, l_request_out->data_size + sizeof(dap_stream_ch_chain_net_srv_pkt_test_t))) {
+                        dap_stream_ch_set_ready_to_write(a_ch, true);
+                    }
+                DAP_DELETE(l_request_out);
+
+                }
+            break;
+            // for receive test data.
+            case DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_CHECK_RESPONSE: {
+                dap_stream_ch_chain_net_srv_pkt_test_t *l_request = (dap_stream_ch_chain_net_srv_pkt_request_t *) l_ch_pkt->data;
+                size_t l_request_size = l_request->data_size + sizeof(dap_stream_ch_chain_net_srv_pkt_test_t);
+                if(l_ch_pkt->hdr.size != l_request_size) {
+                    log_it(L_WARNING, "Wrong request size, less or more than required");
+                    break;
+                }
+                gettimeofday(&l_request->recv_time1, NULL);
+                dap_chain_hash_fast_t l_data_hash;
+                dap_hash_fast(l_request->data, l_request->data_size, &l_data_hash);
+                if(!dap_hash_fast_compare(&l_data_hash, &(l_request->data_hash))) {
+                    l_request->err_code += 4;
+                }
+                dap_stream_ch_set_ready_to_write(a_ch, false);
+            }
+            break;
+
         	// 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) ){
@@ -577,6 +635,8 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
             } break;
             default: log_it( L_WARNING, "Unknown packet type 0x%02X", l_ch_pkt->hdr.type);
         }
+        if(l_ch_chain_net_srv->notify_callback)
+            l_ch_chain_net_srv->notify_callback(l_ch_chain_net_srv, l_ch_pkt->hdr.type, l_ch_pkt, l_ch_chain_net_srv->notify_callback_arg);
     }
 
 }

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

+/*
+ * Authors:
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * Cellframe       https://cellframe.net
+ * DeM Labs Inc.   https://demlabs.net
+ * Copyright  (c) 2020
+ * All rights reserved.
+
+ This file is part of CellFrame SDK the open source project
+
+ CellFrame SDK is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ CellFrame SDK is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <pthread.h>
+#include "dap_stream_ch.h"
+#include "dap_stream_ch_pkt.h"
+
+typedef struct dap_stream_ch_chain_net_srv dap_stream_ch_chain_net_srv_t;
+
+typedef void (*dap_stream_ch_chain_net_srv_callback_packet_t)(dap_stream_ch_chain_net_srv_t *, uint8_t,
+        dap_stream_ch_pkt_t *, void *);
+
+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_callback_packet_t notify_callback;
+    void *notify_callback_arg;
+} dap_stream_ch_chain_net_srv_t;
+
+#define DAP_STREAM_CH_CHAIN_NET_SRV(a) ((dap_stream_ch_chain_net_srv_t *) ((a)->internal) )
+
+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);
+uint8_t dap_stream_ch_chain_net_srv_get_id();
+

modules/channel/chain/dap_stream_ch_chain.c

@@ -310,7 +310,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                                 l_ch_chain->request_net_id, l_ch_chain->request_chain_id,
                                 l_ch_chain->request_cell_id, &l_node_addr, sizeof(dap_chain_node_addr_t));
 
-                        dap_stream_ch_chain_sync_request_t l_request = { { 0 } };
+                        dap_stream_ch_chain_sync_request_t l_request = {};
                         //log_it(L_DEBUG, "No items to sync from %u", l_request->id_start + 1);
                         l_request.node_addr.uint64 = l_net ? dap_db_get_cur_node_addr(l_net->pub.name) : 0;
                         l_request.id_start = dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);
@@ -353,27 +353,33 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                 if(l_chain) {
                     // Expect atom element in
                     if(l_chain_pkt_data_size > 0) {
-                        dap_chain_atom_ptr_t l_atom_copy = DAP_CALLOC(1, l_chain_pkt_data_size);
-                        memcpy(l_atom_copy, l_chain_pkt->data, l_chain_pkt_data_size);
-                        dap_chain_atom_verify_res_t l_atom_add_res = l_chain->callback_atom_add(l_chain, l_atom_copy);
-                        if(l_atom_add_res == ATOM_ACCEPT && dap_chain_has_file_store(l_chain)) {
-                            // append to file
-                            dap_chain_cell_id_t l_cell_id;
-                            l_cell_id.uint64 = l_chain_pkt->hdr.cell_id.uint64;
-                            dap_chain_cell_t *l_cell = dap_chain_cell_create_fill(l_chain, l_cell_id);
-                            // add one atom only
-                            int l_res = dap_chain_cell_file_append(l_cell, l_chain_pkt->data, l_chain_pkt_data_size);
-                            // rewrite all file
-                            //l_res = dap_chain_cell_file_update(l_cell);
-                            if(!l_cell || l_res < 0) {
-                                log_it(L_ERROR, "Can't save event 0x%x to the file '%s'", l_chain_pkt->data,
-                                        l_cell ? l_cell->file_storage_path : "[null]");
+                        dap_chain_hash_fast_t l_atom_hash = {};
+                        dap_hash_fast(l_chain_pkt->data, l_chain_pkt_data_size, &l_atom_hash);
+                        dap_chain_atom_iter_t *l_atom_iter = l_chain->callback_atom_iter_create(l_chain);
+                        if (!l_chain->callback_atom_find_by_hash(l_atom_iter, &l_atom_hash)) {
+                            dap_chain_atom_ptr_t l_atom_copy = DAP_CALLOC(1, l_chain_pkt_data_size);
+                            memcpy(l_atom_copy, l_chain_pkt->data, l_chain_pkt_data_size);
+                            dap_chain_atom_verify_res_t l_atom_add_res = l_chain->callback_atom_add(l_chain, l_atom_copy);
+                            if(l_atom_add_res == ATOM_ACCEPT && dap_chain_has_file_store(l_chain)) {
+                                // append to file
+                                dap_chain_cell_id_t l_cell_id;
+                                l_cell_id.uint64 = l_chain_pkt->hdr.cell_id.uint64;
+                                dap_chain_cell_t *l_cell = dap_chain_cell_create_fill(l_chain, l_cell_id);
+                                // add one atom only
+                                int l_res = dap_chain_cell_file_append(l_cell, l_chain_pkt->data, l_chain_pkt_data_size);
+                                // rewrite all file
+                                //l_res = dap_chain_cell_file_update(l_cell);
+                                if(!l_cell || l_res < 0) {
+                                    log_it(L_ERROR, "Can't save event 0x%x to the file '%s'", l_chain_pkt->data,
+                                            l_cell ? l_cell->file_storage_path : "[null]");
+                                }
+                                // delete cell and close file
+                                dap_chain_cell_delete(l_cell);
                             }
-                            // delete cell and close file
-                            dap_chain_cell_delete(l_cell);
+                            if(l_atom_add_res == ATOM_PASS)
+                                DAP_DELETE(l_atom_copy);
                         }
-                        if(l_atom_add_res == ATOM_PASS)
-                            DAP_DELETE(l_atom_copy);
+                        l_chain->callback_atom_iter_delete(l_atom_iter);
                     } else {
                         log_it(L_WARNING, "Empty chain packet");
                         dap_stream_ch_chain_pkt_write_error(a_ch, l_chain_pkt->hdr.net_id,
@@ -398,19 +404,11 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                 //log_it(L_INFO, "In: GLOBAL_DB data_size=%d", l_chain_pkt_data_size);
                 // get transaction and save it to global_db
                 if(l_chain_pkt_data_size > 0) {
-
                     //session_data_t *l_data = session_data_find(a_ch->stream->session->id);
                     size_t l_data_obj_count = 0;
-
                     // deserialize data
                     dap_store_obj_t *l_store_obj = dap_db_log_unpack((uint8_t*) l_chain_pkt->data,
                             l_chain_pkt_data_size, &l_data_obj_count); // Parse data from dap_db_log_pack()
-                    //dap_store_obj_t * l_store_obj_reversed = NULL;
-                    //if ( dap_log_level_get()== L_DEBUG  )
-                    //if ( l_data_obj_count && l_store_obj )
-                    //   l_store_obj_reversed = DAP_NEW_Z_SIZE(dap_store_obj_t,l_data_obj_count+1);
-
-
 //                    log_it(L_INFO, "In: l_data_obj_count = %d", l_data_obj_count );
 
                     for(size_t i = 0; i < l_data_obj_count; i++) {
@@ -466,10 +464,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                         /*log_it(L_DEBUG, "Unpacked log history: type='%c' (0x%02hhX) group=\"%s\" key=\"%s\""
                                 " timestamp=\"%s\" value_len=%u  ",
                                 (char ) l_store_obj[i].type, l_store_obj[i].type, l_store_obj[i].group,
-                                l_store_obj[i].key,
-                                l_ts_str,
-                                l_store_obj[i].value_len);*/
-
+                                l_store_obj[i].key, l_ts_str, l_store_obj[i].value_len);*/
                         // apply received transaction
                         dap_chain_t *l_chain = dap_chain_find_by_id(l_chain_pkt->hdr.net_id, l_chain_pkt->hdr.chain_id);
                         if(l_chain) {
@@ -478,36 +473,6 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                                         (dap_chain_datum_t**) &(l_store_obj->value), 1,
                                         l_store_obj[i].group);
                         }
-                        /*else {
-                         // read net_name
-                         if(!s_net_name)
-                         {
-                         static dap_config_t *l_cfg = NULL;
-                         if((l_cfg = dap_config_open("network/default")) == NULL) {
-                         log_it(L_ERROR, "Can't open default network config");
-                         } else {
-                         s_net_name = dap_strdup(dap_config_get_item_str(l_cfg, "general", "name"));
-                         dap_config_close(l_cfg);
-                         }
-                         }
-                         // add datum in ledger if necessary
-                         {
-                         dap_chain_net_t *l_net = dap_chain_net_by_name(s_net_name);
-                         dap_chain_t * l_chain;
-                         if(l_net) {
-                         DL_FOREACH(l_net->pub.chains, l_chain)
-                         {
-                         const char *l_chain_name = l_chain->name; //l_chain_name = dap_strdup("gdb");
-                         dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_name);
-                         //const char *l_group_name = "chain-gdb.kelvin-testnet.chain-F00000000000000F";//dap_chain_gdb_get_group(l_chain);
-                         if(l_chain->callback_datums_pool_proc_with_group)
-                         l_chain->callback_datums_pool_proc_with_group(l_chain,
-                         (dap_chain_datum_t**) &(l_store_obj->value), 1,
-                         l_store_obj[i].group);
-                         }
-                         }
-                         }
-                         }*/
                         // save data to global_db
                         if(!dap_chain_global_db_obj_save(l_obj, 1)) {
                             dap_stream_ch_chain_pkt_write_error(a_ch, l_chain_pkt->hdr.net_id,
@@ -531,9 +496,28 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                 }
             }
                 break;
-                default:{
+            case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS: {
+                dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
+                memcpy(&l_sync_gdb, l_chain_pkt->data, l_chain_pkt_data_size);
+                dap_chain_net_t *l_net = dap_chain_net_by_id(l_chain_pkt->hdr.net_id);
+                l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr(l_net) ?
+                                                  dap_chain_net_get_cur_addr(l_net)->uint64 :
+                                                  dap_db_get_cur_node_addr(l_net->pub.name);
+                // Get last timestamp in log
+                l_sync_gdb.id_start = (uint64_t) dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);
+                // no limit
+                l_sync_gdb.id_end = (uint64_t)0;
+                dap_stream_ch_chain_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB, l_chain_pkt->hdr.net_id,
+                                              l_chain_pkt->hdr.chain_id, l_chain_pkt->hdr.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
+            }
+            case DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS: {
+                dap_stream_ch_chain_sync_request_t l_sync_chains = {};
+                dap_stream_ch_chain_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS, l_chain_pkt->hdr.net_id,
+                                              l_chain_pkt->hdr.chain_id, l_chain_pkt->hdr.cell_id, &l_sync_chains, sizeof(l_sync_chains));
+            }
+            default: {
                     //log_it(L_INFO, "Get %s packet", c_dap_stream_ch_chain_pkt_type_str[l_ch_pkt->hdr.type]);
-                }
+                     }
             }
             if(l_ch_chain->callback_notify_packet_in)
                 l_ch_chain->callback_notify_packet_in(l_ch_chain, l_ch_pkt->hdr.type, l_chain_pkt,
@@ -668,7 +652,7 @@ void s_stream_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
 
                         // last message
 
-                        dap_stream_ch_chain_sync_request_t l_request = { { 0 } };
+                        dap_stream_ch_chain_sync_request_t l_request = {};
                         dap_chain_net_t *l_net = dap_chain_net_by_id(l_ch_chain->request_net_id);
                         l_request.node_addr.uint64 = l_net ? dap_db_get_cur_node_addr(l_net->pub.name) : 0;
                         l_request.id_start = dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);

modules/channel/chain/include/dap_stream_ch_chain_pkt.h

@@ -44,6 +44,8 @@
 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB            0x12
 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_ALL                  0x22
 
+#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS          0x04
+#define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS       0x14
 
 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_CHAINS             0x03
 #define DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB          0x13

modules/consensus/dag-pos/dap_chain_cs_dag_pos.c

@@ -275,7 +275,7 @@ static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_
                 char *l_addr_str = dap_chain_addr_to_str(&l_addr);
                 log_it(L_WARNING, "Verify of event is false, because bal is not enough for addr=%s", l_addr_str);
                 DAP_DELETE(l_addr_str);
-                return 0; //-1;
+                return -1;
             }
         }
 

modules/consensus/none/dap_chain_cs_none.c

@@ -134,13 +134,12 @@ int dap_chain_gdb_init(void)
 static void s_history_callback_notify(void * a_arg, const char a_op_code, const char * a_prefix, const char * a_group,
         const char * a_key, const void * a_value, const size_t a_value_size)
 {
-    (void) a_value;
-    (void) a_prefix;
     if (a_arg){
         dap_chain_gdb_t * l_gdb = (dap_chain_gdb_t *) a_arg;
         dap_chain_net_t *l_net = dap_chain_net_by_id( l_gdb->chain->net_id);
         log_it(L_DEBUG,"%s.%s: op_code='%c' group=\"%s\" key=\"%s\" value_size=%u",l_net->pub.name,
                l_gdb->chain->name, a_op_code, a_group, a_key, a_value_size);
+        dap_chain_net_sync_gdb_broadcast((void *)l_net, a_op_code, a_prefix, a_group, a_key, a_value, a_value_size);
     }
 }
 

modules/modules_dynamic/cdb/dap_modules_dynamic_cdb.c

@@ -51,7 +51,7 @@ int dap_modules_dynamic_load_cdb(dap_http_t * a_server){
     *(void **) (&dap_chain_net_srv_vpn_cdb_init) = dlsym(l_cdb_handle, l_init_func_name);
     char* error;
     if (( error = dlerror()) != NULL) {
-        log_it(L_ERROR,"%s module: %s error loading %s (%s)", l_cdb_so_name, l_init_func_name, error);
+        log_it(L_ERROR,"%s module: %s error loading (%s)", l_cdb_so_name, l_init_func_name, error);
         return -2;
      }