CMakeLists.txt

@@ -2,7 +2,7 @@ project(cellframe-sdk C)
 cmake_minimum_required(VERSION 3.0)
 
 set(CMAKE_C_STANDARD 11)
-set(CELLFRAME_SDK_NATIVE_VERSION "2.9-43")
+set(CELLFRAME_SDK_NATIVE_VERSION "2.9-45")
 add_definitions ("-DCELLFRAME_SDK_VERSION=\"${CELLFRAME_SDK_NATIVE_VERSION}\"")
 set(DAPSDK_MODULES "")
 message("Cellframe modules: ${CELLFRAME_MODULES}")

dap-sdk/crypto/include/dap_sign.h

@@ -127,7 +127,7 @@ uint8_t* dap_sign_get_sign(dap_sign_t *a_sign, size_t *a_sign_out);
 uint8_t* dap_sign_get_pkey(dap_sign_t *a_sign, size_t *a_pub_key_out);
 bool dap_sign_get_pkey_hash(dap_sign_t *a_sign, dap_chain_hash_fast_t * a_sign_hash);
 
-bool dap_sign_verify_size(dap_sign_t *a_sign, size_t a_key_size_max);
+bool dap_sign_verify_size(dap_sign_t *a_sign, size_t a_max_key_size);
 dap_enc_key_t *dap_sign_to_enc_key(dap_sign_t * a_chain_sign);
 const char * dap_sign_type_to_str(dap_sign_type_t a_chain_sign_type);
 dap_sign_type_t dap_sign_type_from_str(const char * a_type_str);

dap-sdk/crypto/src/dap_sign.c

@@ -315,9 +315,13 @@ bool dap_sign_get_pkey_hash(dap_sign_t *a_sign, dap_chain_hash_fast_t * a_sign_h
 }
 
 
-bool dap_sign_verify_size(dap_sign_t *a_sign, size_t a_key_size_max)
+bool dap_sign_verify_size(dap_sign_t *a_sign, size_t a_max_key_size)
 {
-    if (a_sign->header.sign_pkey_size > a_key_size_max)
+    if (a_sign->header.sign_pkey_size > a_max_key_size)
+        return false;
+    if (a_sign->header.sign_size > a_max_key_size)
+        return false;
+    if (a_sign->header.sign_pkey_size > a_sign->header.sign_size)
         return false;
     return true;
 }
@@ -349,7 +353,7 @@ dap_enc_key_t *dap_sign_to_enc_key(dap_sign_t * a_chain_sign)
  */
 int dap_sign_verify(dap_sign_t * a_chain_sign, const void * a_data, const size_t a_data_size)
 {
-    if (!a_chain_sign || !a_data || !dap_sign_verify_size(a_chain_sign, a_data_size))
+    if (!a_chain_sign || !a_data)
         return -2;
 
     dap_enc_key_t * l_key = dap_sign_to_enc_key(a_chain_sign);

modules/chain/dap_chain.c

@@ -336,10 +336,15 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
                 if ( dap_config_get_item_str_default(l_cfg , "files","storage_dir",NULL ) ) {
                     DAP_CHAIN_PVT ( l_chain)->file_storage_dir = strdup (
                                 dap_config_get_item_str( l_cfg , "files","storage_dir" ) ) ;
-                    if ( dap_chain_load_all( l_chain ) != 0 ){
-                        dap_chain_save_all( l_chain );
+                    if (dap_chain_load_all(l_chain) == 0) {
+                        if (l_chain->callback_atom_add_from_treshold) {
+                            while (l_chain->callback_atom_add_from_treshold(l_chain, NULL)) {
+                                log_it(L_DEBUG, "Added atom from treshold");
+                            }
+                        }
+                        dap_chain_save_all( l_chain );  // Save only the valid chain, throw all garbage out!
                         log_it (L_NOTICE, "Loaded chain files");
-                    }else {
+                    } else {
                         dap_chain_save_all( l_chain );
                         log_it (L_NOTICE, "Initialized chain files");
                     }

modules/chain/dap_chain_cell.c

@@ -22,7 +22,7 @@
     along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "uthash.h"
-
+#include <unistd.h>
 #include "dap_common.h"
 #include "dap_config.h"
 #include "dap_strfuncs.h"
@@ -170,15 +170,15 @@ int dap_chain_cell_load(dap_chain_t * a_chain, const char * a_cell_file_path)
     }
     size_t l_el_size = 0;
     unsigned long q = 0;
-    volatile dap_chain_cell_t *l_dummy;
-    for (fread(&l_el_size, 1, sizeof(l_el_size), l_f); !feof(l_f); l_el_size = 0, fread(&l_el_size, 1, sizeof(l_el_size), l_f))
+    volatile int l_dummy;
+    for (l_dummy = fread(&l_el_size, 1, sizeof(l_el_size), l_f); !feof(l_f); l_el_size = 0, l_dummy = fread(&l_el_size, 1, sizeof(l_el_size), l_f))
     {
         if (!l_el_size) {
             log_it(L_ERROR, "Zero element size, chain %s is corrupted", l_file_path);
             ret = -4;
             break;
         }
-        dap_chain_atom_ptr_t l_element = DAP_NEW_Z_SIZE(dap_chain_atom_ptr_t, l_el_size);
+        dap_chain_atom_ptr_t l_element = DAP_NEW_SIZE(dap_chain_atom_ptr_t, l_el_size);
         if (!l_element) {
             log_it(L_ERROR, "Out of memory");
             ret = -5;
@@ -188,7 +188,6 @@ int dap_chain_cell_load(dap_chain_t * a_chain, const char * a_cell_file_path)
         if(l_read == l_el_size) {
             a_chain->callback_atom_add(a_chain, l_element, l_el_size); // !!! blocking GDB call !!!
             ++q;
-            DAP_DELETE(l_element);
         } else {
             log_it(L_ERROR, "Read only %zd of %zd bytes, stop cell loading", l_read, l_el_size);
             ret = -6;
@@ -200,7 +199,7 @@ int dap_chain_cell_load(dap_chain_t * a_chain, const char * a_cell_file_path)
         log_it(L_INFO, "Couldn't load all atoms, %d only", q);
     } else {
         log_it(L_INFO, "Loaded all %d atoms in cell %s", q, a_cell_file_path);
-        l_dummy = dap_chain_cell_create_fill2(a_chain, a_cell_file_path);
+        dap_chain_cell_create_fill2(a_chain, a_cell_file_path);
     }
     fclose(l_f);
     return ret;
@@ -263,7 +262,10 @@ int dap_chain_cell_file_append( dap_chain_cell_t * a_cell, const void* a_atom, s
     // if no atom provided in arguments, we flush all the atoms in given chain
     size_t l_atom_size = a_atom_size ? a_atom_size : 0;
     int l_total_wrote_bytes = 0;
-    dap_chain_atom_iter_t *l_atom_iter = a_atom ? a_cell->chain->callback_atom_iter_create(a_cell->chain) : NULL;
+    dap_chain_atom_iter_t *l_atom_iter = a_atom ? NULL : a_cell->chain->callback_atom_iter_create(a_cell->chain);
+    if (!a_atom) {
+        fseek(a_cell->file_storage, sizeof(dap_chain_cell_file_header_t), SEEK_SET);
+    }
     for (dap_chain_atom_ptr_t l_atom = a_atom ? (dap_chain_atom_ptr_t)a_atom : a_cell->chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
          l_atom;
          l_atom = a_atom ? NULL : a_cell->chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size))
@@ -293,6 +295,11 @@ int dap_chain_cell_file_append( dap_chain_cell_t * a_cell, const void* a_atom, s
                                            (void *)l_atom,
                                            l_atom_size);
     }
+    if (l_total_wrote_bytes > 0) {
+        fflush(a_cell->file_storage);
+        if (!a_atom)
+            ftruncate(fileno(a_cell->file_storage), l_total_wrote_bytes + sizeof(dap_chain_cell_file_header_t));
+    }
     if (l_atom_iter) {
         a_cell->chain->callback_atom_iter_delete(l_atom_iter);
     }

modules/chain/dap_chain_ledger.c

@@ -1113,12 +1113,16 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
                                 dap_sign_get_pkey_hash(l_sign,&l_sign_pkey_hash);
                                 // Find pkey in auth hashes
                                 for(uint16_t k=0; k< l_token_item->auth_signs_total; k++  ){
-                                    if ( dap_hash_fast_compare(&l_sign_pkey_hash, &l_token_item->auth_signs_pkey_hash[k]))
+                                    if ( dap_hash_fast_compare(&l_sign_pkey_hash, &l_token_item->auth_signs_pkey_hash[k])) {
                                         // Verify if its token emission header signed
+                                        if (!dap_sign_verify_size(l_sign, a_token_emission_size)) {
+                                            break;
+                                        }
                                         if( dap_sign_verify(l_sign,&a_token_emission->hdr, sizeof (a_token_emission) ) ){
                                             l_aproves++;
                                             break;
                                         }
+                                    }
                                 }
                                 l_offset+=l_sign_size;
                             }else
@@ -2596,8 +2600,11 @@ uint128_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
         if(l_out_item_count >= MAX_OUT_ITEMS) {
             if(s_debug_more)
                 log_it(L_ERROR, "Too many 'out' items=%d in transaction (max=%d)", l_out_item_count, MAX_OUT_ITEMS);
-            if (l_out_item_count >= MAX_OUT_ITEMS)
-                return 0;
+            if (l_out_item_count >= MAX_OUT_ITEMS){
+                uint128_t l_ret;
+                memset(&l_ret,0,sizeof(l_ret));
+                return l_ret;
+            }
         }
         int l_out_idx_tmp = 0;
         for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_out_idx_tmp++) {

modules/channel/chain/dap_stream_ch_chain.c

@@ -265,7 +265,10 @@ static void s_sync_out_chains_last_worker_callback(dap_worker_t *a_worker, void
             l_sync_request->request_hdr.net_id.uint64, l_sync_request->request_hdr.chain_id.uint64,
             l_sync_request->request_hdr.cell_id.uint64, &l_request, sizeof(l_request));
     if (l_ch_chain->request_atom_iter)
+    {
         l_ch_chain->request_atom_iter->chain->callback_atom_iter_delete(l_ch_chain->request_atom_iter);
+        l_ch_chain->request_atom_iter = NULL;
+    }
 
     l_ch_chain->state = CHAIN_STATE_IDLE;
     if (l_ch_chain->callback_notify_packet_out)
@@ -595,10 +598,6 @@ static void s_gdb_sync_tsd_worker_callback(dap_worker_t *a_worker, void *a_arg)
         memcpy(l_data_ptr, &l_sync_request->request.id_end, sizeof(uint64_t));
         l_data_ptr += sizeof(uint64_t);
         memcpy(l_data_ptr, l_sync_request->gdb.sync_group, l_gr_len);
-        log_it(L_INFO, "Allocated %d bytes, copied %d bytes, sent %d bytes",
-               l_data_size + sizeof(dap_tsd_t),
-               (long int)((byte_t *)l_data_ptr - l_tsd_rec->data) + l_gr_len,
-               l_tsd_rec->size + sizeof(dap_tsd_t));
         dap_stream_ch_chain_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_UPDATE_GLOBAL_DB_TSD,
                                              l_sync_request->request_hdr.net_id.uint64,
                                              l_sync_request->request_hdr.chain_id.uint64,
@@ -634,22 +633,22 @@ static bool s_gdb_in_pkt_proc_callback(dap_proc_thread_t *a_thread, void *a_arg)
                  log_it(L_WARNING, "In: GLOBAL_DB parse: packet in list with NULL data(pkt_data_size:%zd)", l_pkt_item->pkt_data_size);
         }
 
-        uint64_t l_last_id = 0;
-        char *l_last_group = NULL;
-        char l_last_type = '\0';
+        uint64_t l_last_id = l_store_obj->id;
+        char *l_last_group = l_store_obj->group;
+        char l_last_type = l_store_obj->type;
         bool l_group_changed = false;
 
         for (size_t i = 0; i < l_data_obj_count; i++) {
             // obj to add
             dap_store_obj_t *l_obj = l_store_obj + i;
-            l_group_changed = l_last_group && (strcmp(l_last_group, l_obj->group) || l_last_type != l_obj->type);
+            l_group_changed = strcmp(l_last_group, l_obj->group) || l_last_type != l_obj->type;
             // Send remote side notification about received obj
             if (l_sync_request->request.node_addr.uint64 &&
                     (l_group_changed || i == l_data_obj_count - 1)) {
                 struct sync_request *l_sync_req_tsd = DAP_DUP(l_sync_request);
                 l_sync_req_tsd->request.id_end = l_last_id;
-                l_sync_req_tsd->gdb.sync_group = l_obj->type == 'a' ? dap_strdup(l_obj->group) :
-                                                                      dap_strdup_printf("%s.del", l_obj->group);
+                l_sync_req_tsd->gdb.sync_group = l_obj->type == 'a' ? dap_strdup(l_last_group) :
+                                                                      dap_strdup_printf("%s.del", l_last_group);
                 dap_proc_thread_worker_exec_callback(a_thread, l_sync_request->worker->id,
                                                      s_gdb_sync_tsd_worker_callback, l_sync_req_tsd);
             }
@@ -839,6 +838,12 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                 l_data_ptr += sizeof(uint64_t);
                 char *l_group = (char *)l_data_ptr;
                 dap_db_set_last_id_remote(l_node_addr, l_last_id, l_group);
+                if (s_debug_more) {
+                    dap_chain_node_addr_t l_addr;
+                    l_addr.uint64 = l_node_addr;
+                    log_it(L_INFO, "Set last_id %"DAP_UINT64_FORMAT_U" for group %s for node "NODE_ADDR_FP_STR,
+                                    l_last_id, l_group, NODE_ADDR_FP_ARGS_S(l_addr));
+                }
             } else if (s_debug_more)
                 log_it(L_DEBUG, "Global DB TSD packet detected");
         } break;
@@ -874,12 +879,16 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                    (size_t) (((byte_t*)l_element) - l_chain_pkt->data ) < l_chain_pkt_data_size;
                   l_element++){
                 dap_stream_ch_chain_hash_item_t * l_hash_item = NULL;
-                HASH_FIND(hh,l_ch_chain->remote_gdbs, &l_element->hash, sizeof (l_element->hash), l_hash_item );
-                if( ! l_hash_item ){
+                unsigned l_hash_item_hashv;
+                HASH_VALUE(&l_element->hash, sizeof(l_element->hash), l_hash_item_hashv);
+                HASH_FIND_BYHASHVALUE(hh, l_ch_chain->remote_gdbs, &l_element->hash, sizeof(l_element->hash),
+                                      l_hash_item_hashv, l_hash_item);
+                if (!l_hash_item) {
                     l_hash_item = DAP_NEW(dap_stream_ch_chain_hash_item_t);
                     memcpy(&l_hash_item->hash, &l_element->hash, sizeof (l_element->hash));
                     l_hash_item->size = l_element->size;
-                    HASH_ADD(hh, l_ch_chain->remote_gdbs, hash, sizeof (l_hash_item->hash), l_hash_item);
+                    HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_gdbs, hash, sizeof(l_hash_item->hash),
+                                         l_hash_item_hashv, l_hash_item);
                     /*if (s_debug_more){
                         char l_hash_str[72]={ [0]='\0'};
                         dap_chain_hash_fast_to_str(&l_hash_item->hash,l_hash_str,sizeof (l_hash_str));
@@ -1078,12 +1087,16 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                    (size_t) (((byte_t*)l_element) - l_chain_pkt->data ) < l_chain_pkt_data_size;
                   l_element++){
                 dap_stream_ch_chain_hash_item_t * l_hash_item = NULL;
-                HASH_FIND(hh,l_ch_chain->remote_atoms , &l_element->hash, sizeof (l_element->hash), l_hash_item );
+                unsigned l_hash_item_hashv;
+                HASH_VALUE(&l_element->hash, sizeof(l_element->hash), l_hash_item_hashv);
+                HASH_FIND_BYHASHVALUE(hh, l_ch_chain->remote_atoms, &l_element->hash, sizeof(l_element->hash),
+                                      l_hash_item_hashv, l_hash_item);
                 if( ! l_hash_item ){
                     l_hash_item = DAP_NEW(dap_stream_ch_chain_hash_item_t);
                     memcpy(&l_hash_item->hash, &l_element->hash, sizeof (l_element->hash));
                     l_hash_item->size = l_element->size;
-                    HASH_ADD(hh, l_ch_chain->remote_atoms, hash, sizeof (l_hash_item->hash), l_hash_item);
+                    HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_atoms, hash, sizeof(l_hash_item->hash),
+                                         l_hash_item_hashv, l_hash_item);
                     l_count_added++;
                     /*
                     if (s_debug_more){
@@ -1136,7 +1149,6 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                         log_it(L_INFO, "In: SYNC_CHAINS pkt");
                 }
                 struct sync_request *l_sync_request = dap_stream_ch_chain_create_sync_request(l_chain_pkt, a_ch);
-                l_ch_chain->state = CHAIN_STATE_SYNC_CHAINS;
                 l_ch_chain->stats_request_atoms_processed = 0;
                 if (l_ch_pkt->hdr.type == DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS) {
                     char *l_hash_from_str = dap_chain_hash_fast_to_str_new(&l_ch_chain->request.hash_from);
@@ -1298,14 +1310,10 @@ void dap_stream_ch_chain_go_idle ( dap_stream_ch_chain_t * a_ch_chain)
     // Cleanup after request
     memset(&a_ch_chain->request, 0, sizeof(a_ch_chain->request));
     memset(&a_ch_chain->request_hdr, 0, sizeof(a_ch_chain->request_hdr));
-    if(a_ch_chain->request_atom_iter) {
-        if(a_ch_chain->request_atom_iter->chain)
-            if(a_ch_chain->request_atom_iter->chain->callback_atom_iter_delete){
+    if (a_ch_chain->request_atom_iter && a_ch_chain->request_atom_iter->chain &&
+            a_ch_chain->request_atom_iter->chain->callback_atom_iter_delete) {
                 a_ch_chain->request_atom_iter->chain->callback_atom_iter_delete(a_ch_chain->request_atom_iter);
                 a_ch_chain->request_atom_iter = NULL;
-                return;
-            }
-        a_ch_chain->request_atom_iter->chain->callback_atom_iter_delete(a_ch_chain->request_atom_iter);
     }
     // free log list
     dap_db_log_list_delete(a_ch_chain->request_db_log);
@@ -1319,6 +1327,7 @@ void dap_stream_ch_chain_go_idle ( dap_stream_ch_chain_t * a_ch_chain)
         HASH_DEL(a_ch_chain->remote_atoms, l_hash_item);
         DAP_DELETE(l_hash_item);
     }
+    a_ch_chain->remote_atoms = a_ch_chain->remote_gdbs = NULL;
 }
 
 /**
@@ -1379,7 +1388,10 @@ void s_stream_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
                 if (!l_obj)
                     break;
                 dap_stream_ch_chain_hash_item_t *l_hash_item = NULL;
-                HASH_FIND(hh, l_ch_chain->remote_gdbs, &l_obj->hash, sizeof(dap_hash_fast_t), l_hash_item);
+                unsigned l_hash_item_hashv = 0;
+                HASH_VALUE(&l_obj->hash, sizeof(dap_chain_hash_fast_t), l_hash_item_hashv);
+                HASH_FIND_BYHASHVALUE(hh, l_ch_chain->remote_gdbs, &l_obj->hash, sizeof(dap_hash_fast_t),
+                                      l_hash_item_hashv, l_hash_item);
                 if (l_hash_item) { // If found - skip it
                     /*if (s_debug_more) {
                         char l_request_atom_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
@@ -1392,7 +1404,8 @@ void s_stream_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
                     l_hash_item = DAP_NEW(dap_stream_ch_chain_hash_item_t);
                     memcpy(&l_hash_item->hash, &l_obj->hash, sizeof(dap_chain_hash_fast_t));
                     l_hash_item->size = l_obj->pkt->data_size;
-                    HASH_ADD(hh, l_ch_chain->remote_gdbs, hash, sizeof(dap_chain_hash_fast_t), l_hash_item);
+                    HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_gdbs, hash, sizeof(dap_chain_hash_fast_t),
+                                         l_hash_item_hashv, l_hash_item);
                     l_pkt = dap_store_packet_multiple(l_pkt, l_obj->pkt);
                     l_ch_chain->stats_request_gdb_processed++;
                     l_pkt_size = sizeof(dap_store_obj_pkt_t) + l_pkt->data_size;
@@ -1475,8 +1488,11 @@ void s_stream_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
                                    l_ch_chain->request_atom_iter &&
                                    l_ch_chain->request_atom_iter->cur; k++){
                 // Check if present and skip if present
-                dap_stream_ch_chain_hash_item_t * l_hash_item = NULL;
-                HASH_FIND(hh,l_ch_chain->remote_atoms, l_ch_chain->request_atom_iter->cur_hash , sizeof (l_hash_item->hash), l_hash_item );
+                dap_stream_ch_chain_hash_item_t *l_hash_item = NULL;
+                unsigned l_hash_item_hashv = 0;
+                HASH_VALUE(l_ch_chain->request_atom_iter->cur_hash, sizeof(dap_chain_hash_fast_t), l_hash_item_hashv);
+                HASH_FIND_BYHASHVALUE(hh, l_ch_chain->remote_atoms, l_ch_chain->request_atom_iter->cur_hash,
+                                      sizeof(dap_chain_hash_fast_t), l_hash_item_hashv, l_hash_item);
                 if( l_hash_item ){ // If found - skip it
                     if(s_debug_more){
                         char l_request_atom_hash_str[81]={[0]='\0'};
@@ -1485,9 +1501,8 @@ void s_stream_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
                                         l_request_atom_hash_str);
                     }
                 }else{
-                    l_hash_item = DAP_NEW_Z(dap_stream_ch_chain_hash_item_t);
-                    dap_hash_fast(l_ch_chain->request_atom_iter->cur, l_ch_chain->request_atom_iter->cur_size,
-                                  &l_hash_item->hash);
+                    l_hash_item = DAP_NEW(dap_stream_ch_chain_hash_item_t);
+                    memcpy(&l_hash_item->hash, l_ch_chain->request_atom_iter->cur_hash, sizeof(dap_chain_hash_fast_t));
                     if(s_debug_more){
                         char *l_atom_hash_str= dap_chain_hash_fast_to_str_new(&l_hash_item->hash);
                         log_it(L_INFO, "Out CHAIN pkt: atom hash %s (size %zd) ", l_atom_hash_str, l_ch_chain->request_atom_iter->cur_size);
@@ -1500,21 +1515,9 @@ void s_stream_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
                     l_ch_chain->stats_request_atoms_processed++;
 
                     l_hash_item->size = l_ch_chain->request_atom_iter->cur_size;
-
-                    unsigned l_hash_item_hashv =0;
-                    dap_stream_ch_chain_hash_item_t *l_hash_item_check = NULL;
-
-                    HASH_VALUE(&l_hash_item->hash ,sizeof (l_hash_item->hash),
-                               l_hash_item_hashv);
-                    HASH_FIND_BYHASHVALUE(hh, l_ch_chain->remote_atoms,&l_hash_item->hash ,sizeof (l_hash_item->hash),
-                                          l_hash_item_hashv,  l_hash_item_check);
-                    if (l_hash_item_check ==NULL ){
-                        // Because we sent this atom to remote - we record it to not to send it twice
-                        HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_atoms, hash, sizeof (l_hash_item->hash),l_hash_item_hashv,
-                                             l_hash_item);
-                    }else
-                        DAP_DELETE(l_hash_item);
-
+                    // Because we sent this atom to remote - we record it to not to send it twice
+                    HASH_ADD_BYHASHVALUE(hh, l_ch_chain->remote_atoms, hash, sizeof(l_hash_item->hash), l_hash_item_hashv,
+                                         l_hash_item);
                 }
                 // Then get next atom and populate new last
                 l_ch_chain->request_atom_iter->chain->callback_atom_iter_get_next(l_ch_chain->request_atom_iter, NULL);

modules/consensus/dag-pos/dap_chain_cs_dag_pos.c

@@ -238,8 +238,9 @@ static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_
             }
             size_t l_dag_event_size_without_sign = dap_chain_cs_dag_event_calc_size_excl_signs(a_dag_event,a_dag_event_size);
 
-            int l_sign_verify_ret = dap_sign_verify(l_sign,a_dag_event,l_dag_event_size_without_sign);
-            if ( l_sign_verify_ret != 0){
+            bool l_sign_verify_ret = dap_sign_verify_size(l_sign, a_dag_event_size) &&
+                    dap_sign_verify(l_sign,a_dag_event,l_dag_event_size_without_sign) == 0;
+            if ( !l_sign_verify_ret ){
                 log_it(L_WARNING, "Event's sign is incorrect: code %d", l_sign_verify_ret);
                 return -41;
 

modules/net/dap_chain_net.c

@@ -572,8 +572,6 @@ static void s_node_link_callback_delete(dap_chain_node_client_t * a_node_client,
         }
     }
     pthread_rwlock_unlock(&l_net_pvt->rwlock);
-    dap_chain_node_client_close(a_node_client);
-
     dap_notify_server_send_f_mt("{"
                             "class:\"NetLinkDelete\","
                             "net_id:0x%016" DAP_UINT64_FORMAT_X ","
@@ -581,6 +579,7 @@ static void s_node_link_callback_delete(dap_chain_node_client_t * a_node_client,
                             "address:\""NODE_ADDR_FP_STR"\""
                         "}\n", a_node_client->net->pub.id.uint64, a_node_client->info->hdr.cell_id.uint64,
                                 NODE_ADDR_FP_ARGS_S(a_node_client->info->hdr.address));
+    dap_chain_node_client_close(a_node_client);
 }
 
 /**

modules/net/srv/dap_chain_net_srv_order.c

@@ -34,7 +34,7 @@
 #if DAP_SRV_STAKE_USED
 #include "dap_chain_net_srv_stake.h"
 #else
-static bool dap_chain_net_srv_stake_key_delegated() { return false; }
+static bool dap_chain_net_srv_stake_key_delegated(dap_chain_addr_t *a_addr) { UNUSED(a_addr); return false; }
 #endif
 //#include "dap_chain_net_srv_geoip.h"
 
@@ -535,7 +535,8 @@ static void s_srv_order_callback_notify(void *a_arg, const char a_op_code, const
             dap_chain_global_db_gr_del(dap_strdup(a_key), a_group);
         } else {
             dap_sign_t *l_sign = (dap_sign_t *)&l_order->ext[l_order->ext_size];
-            if (!dap_sign_verify(l_sign, l_order, sizeof(dap_chain_net_srv_order_t) + l_order->ext_size)) {
+            if (!dap_sign_verify_size(l_sign, a_value_len) ||
+                    dap_sign_verify(l_sign, l_order, sizeof(dap_chain_net_srv_order_t) + l_order->ext_size) != 1) {
                 dap_chain_global_db_gr_del(dap_strdup(a_key), a_group);
                 DAP_DELETE(l_gdb_group_str);
                 return;

modules/type/dag/dap_chain_cs_dag.c

@@ -24,6 +24,7 @@
 #include <stdlib.h>
 #include <time.h>
 #include <pthread.h>
+#include "errno.h"
 #include "uthash.h"
 
 #ifdef _WIN32
@@ -300,12 +301,12 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
         case DAP_CHAIN_DATUM_TOKEN_DECL: {
             dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
             return dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
-            }
+        }
         break;
         case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
             dap_chain_datum_token_emission_t *l_token_emission = (dap_chain_datum_token_emission_t*) l_datum->data;
             return dap_chain_ledger_token_emission_load(a_ledger, l_token_emission, l_datum->header.data_size);
-            }
+        }
         break;
         case DAP_CHAIN_DATUM_TX: {
             dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
@@ -319,10 +320,12 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
             l_tx_event->event = a_event_item->event;
             l_tx_event->event_size = a_event_item->event_size;
             memcpy(&l_tx_event->hash, &a_event_item->hash, sizeof (l_tx_event->hash) );
-            pthread_rwlock_wrlock(l_events_rwlock);
+            int l_err = pthread_rwlock_wrlock(l_events_rwlock);
             HASH_ADD(hh,PVT(a_dag)->tx_events, hash, sizeof (l_tx_event->hash), l_tx_event);
-            pthread_rwlock_unlock(l_events_rwlock);
+            if (l_err != EDEADLK) {
+                pthread_rwlock_unlock(l_events_rwlock);
             }
+        }
         break;
         default:
             return -1;
@@ -376,9 +379,9 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
     l_event_item->event_size = a_atom_size;
     l_event_item->ts_added = time(NULL);
 
-    dap_hash_fast(l_event, a_atom_size,&l_event_item->hash );
     dap_chain_hash_fast_t l_event_hash;
-    dap_chain_cs_dag_event_calc_hash(l_event, a_atom_size,&l_event_hash);
+    dap_chain_cs_dag_event_calc_hash(l_event, a_atom_size, &l_event_hash);
+    memcpy(&l_event_item->hash, &l_event_hash, sizeof(dap_chain_hash_fast_t));
 
     char * l_event_hash_str;
     if(s_debug_more) {
@@ -421,10 +424,10 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
     case ATOM_ACCEPT: {
         int l_consensus_check = s_dap_chain_add_atom_to_events_table(l_dag, a_chain->ledger, l_event_item);
         //All correct, no matter for result
-        pthread_rwlock_wrlock(&PVT(l_dag)->events_rwlock);
+        pthread_rwlock_wrlock(l_events_rwlock);
         HASH_ADD(hh, PVT(l_dag)->events,hash,sizeof (l_event_item->hash), l_event_item);
         s_dag_events_lasts_process_new_last_event(l_dag, l_event_item);
-        pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
+        pthread_rwlock_unlock(l_events_rwlock);
         switch (l_consensus_check) {
         case 0:
             if(s_debug_more)
@@ -439,7 +442,8 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
             ret = ATOM_MOVE_TO_THRESHOLD;
             break;
         default:
-            log_it(L_WARNING, "Atom %s (size %zd) error adding (code %d)", l_event_hash_str,a_atom_size, l_consensus_check);
+            l_event_hash_str = dap_chain_hash_fast_to_str_new(&l_event_item->hash);
+            log_it(L_WARNING, "Atom %s (size %zd) error adding (code %d)", l_event_hash_str, a_atom_size, l_consensus_check);
             ret = ATOM_REJECT;
             break;
         }
@@ -730,7 +734,9 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_
                 DAP_DELETE(l_event_hash_str);
                 DAP_DELETE(l_genesis_event_hash_str);
                 return ATOM_REJECT;
-            }else{
+            } else {
+                if (s_debug_more)
+                    log_it(L_INFO, "Accepting static genesis event");
                 return ATOM_ACCEPT;
             }
         }
@@ -739,9 +745,9 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_
     //chain coherence
     if (! PVT(l_dag)->events ){
         res = ATOM_MOVE_TO_THRESHOLD;
-        log_it(L_DEBUG, "*** event %p goes to threshold", l_event);
+        //log_it(L_DEBUG, "*** event %p goes to threshold", l_event);
     } else {
-        log_it(L_DEBUG, "*** event %p hash count %d",l_event, l_event->header.hash_count);
+        //log_it(L_DEBUG, "*** event %p hash count %d",l_event, l_event->header.hash_count);
         for (size_t i = 0; i< l_event->header.hash_count; i++) {
             dap_chain_hash_fast_t * l_hash =  ((dap_chain_hash_fast_t *) l_event->hashes_n_datum_n_signs) + i;
             dap_chain_cs_dag_event_item_t * l_event_search = NULL;
@@ -878,7 +884,6 @@ dap_chain_cs_dag_event_item_t* dap_chain_cs_dag_proc_treshold(dap_chain_cs_dag_t
                 char * l_event_hash_str = dap_chain_hash_fast_to_str_new(&l_event_item->hash);
                 if(s_debug_more)
                     log_it(L_DEBUG, "Processing event (threshold): %s...", l_event_hash_str);
-
                 int l_add_res = s_dap_chain_add_atom_to_events_table(a_dag, a_ledger, l_event_item);
                 HASH_ADD(hh, PVT(a_dag)->events,hash,sizeof (l_event_item->hash), l_event_item);
                 s_dag_events_lasts_process_new_last_event(a_dag, l_event_item);