CMakeLists.txt

@@ -2,7 +2,7 @@ project(cellframe-sdk C)
 cmake_minimum_required(VERSION 2.8)
 
 set(CMAKE_C_STANDARD 11)
-set(CELLFRAME_SDK_NATIVE_VERSION "2.6-79")
+set(CELLFRAME_SDK_NATIVE_VERSION "2.6-80")
 add_definitions ("-DCELLFRAME_SDK_VERSION=\"${CELLFRAME_SDK_NATIVE_VERSION}\"")
 set(DAPSDK_MODULES "")
 

dap-sdk/core/include/dap_file_utils.h

@@ -100,6 +100,7 @@ int dap_mkdir_with_parents(const char *a_dir_path);
 char* dap_path_get_basename(const char *a_file_name);
 bool  dap_path_is_absolute(const char *a_file_name);
 char* dap_path_get_dirname(const char *a_file_name);
+const char* dap_path_get_ext(const char *a_filename);
 
 /**
  * Get list of subdirectories

dap-sdk/core/libdap.pri

 QMAKE_CFLAGS_RELEASE += -std=gnu11
-QMAKE_CFLAGS_DEBUG = -std=gnu11 -DDAP_DEBUG
+QMAKE_CFLAGS_DEBUG = -std=gnu11
+-DDAP_DEBUG
 QMAKE_CXXFLAGS +=  -std=c++11
 unix {
-    QMAKE_CFLAGS_DEBUG += -Wall -Wno-deprecated-declarations -Wno-unused-local-typedefs -Wno-unused-function -Wno-implicit-fallthrough -Wno-unused-variable -Wno-unused-parameter -Wno-unused-but-set-variable -pg -g3 -ggdb -fno-eliminate-unused-debug-symbols -fno-strict-aliasing
-    QMAKE_LFLAGS_DEBUG += -pg
     include(src/unix/unix.pri)
     DEFINES += DAP_OS_UNIX
 }
-DEFINES += _GNU_SOURCE
 android {
     DEFINES += DAP_OS_ANDROID
 }
 
 unix: !android {
+    QMAKE_CFLAGS_DEBUG += -Wall -Wno-deprecated-declarations -Wno-unused-local-typedefs -Wno-unused-function -Wno-implicit-fallthrough -Wno-unused-variable -Wno-unused-parameter -Wno-unused-but-set-variable -pg -g3 -ggdb -fno-eliminate-unused-debug-symbols -fno-strict-aliasing
+    QMAKE_LFLAGS_DEBUG += -pg
+    DEFINES += _GNU_SOURCE
     LIBS += -lrt
 }
 darwin {

dap-sdk/core/src/dap_file_utils.c

@@ -409,6 +409,34 @@ dap_list_name_directories_t *dap_get_subs(const char *a_path_dir){
     return list;
 }
 
+
+
+
+/**
+ * dap_path_get_ext:
+ * @a_file_name: the name of the file
+ *
+ * Gets the extension components of a file name.
+ *
+ * Returns: the extension components of the file
+ */
+const char* dap_path_get_ext(const char *a_filename)
+{
+    size_t l_len = dap_strlen(a_filename);
+    const char *l_p = a_filename + l_len - 1;
+    if(l_len < 2)
+        return NULL ;
+
+    while(l_p > a_filename)
+    {
+        if(*l_p == '.') {
+            return ++l_p;
+        }
+        l_p--;
+    }
+    return NULL ;
+}
+
 static bool get_contents_stdio(const char *filename, FILE *f, char **contents, size_t *length)
 {
     char buf[4096];

dap-sdk/net/core/dap_events_socket.c

@@ -361,10 +361,12 @@ dap_events_socket_t * dap_events_socket_queue_ptr_create_input(dap_events_socket
     l_es->mqh_recv  = a_es->mqh_recv;
 
     l_es->socket        = a_es->socket;
+    l_es->port          = a_es->port;
+    l_es->mq_num        = a_es->mq_num;
 
     WCHAR l_direct_name[MQ_MAX_Q_NAME_LEN + 1] = { 0 };
     size_t l_sz_in_words = sizeof(l_direct_name)/sizeof(l_direct_name[0]);
-    int pos = _snwprintf_s(l_direct_name, l_sz_in_words, l_sz_in_words - 1, L"DIRECT=OS:.\\PRIVATE$\\DapEventSocketQueue%d", l_es->socket);
+    int pos = _snwprintf_s(l_direct_name, l_sz_in_words, l_sz_in_words - 1, L"DIRECT=OS:.\\PRIVATE$\\DapEventSocketQueue%d", l_es->mq_num);
     if (pos < 0) {
         log_it(L_ERROR, "Message queue path error");
         DAP_DELETE(l_es);
@@ -508,13 +510,16 @@ dap_events_socket_t * s_create_type_queue_ptr(dap_worker_t * a_w, dap_events_soc
     l_addr.sin_family = AF_INET;
     IN_ADDR _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
     l_addr.sin_addr = _in_addr;
-    l_addr.sin_port = l_es->socket  + 32768;
+    l_addr.sin_port = 0; //l_es->socket  + 32768;
     l_addr_len = sizeof(struct sockaddr_in);
 
     if (bind(l_es->socket, (struct sockaddr*)&l_addr, sizeof(l_addr)) < 0) {
         log_it(L_ERROR, "Bind error: %d", WSAGetLastError());
     } else {
-        log_it(L_INFO, "Binded %d", l_es->socket);
+        int dummy = 100;
+        getsockname(l_es->socket, (struct sockaddr*)&l_addr, &dummy);
+        l_es->port = l_addr.sin_port;
+        //log_it(L_DEBUG, "Bound to port %d", l_addr.sin_port);
     }
 
     MQQUEUEPROPS   l_qps;
@@ -523,8 +528,9 @@ dap_events_socket_t * s_create_type_queue_ptr(dap_worker_t * a_w, dap_events_soc
     HRESULT        l_q_status[1];
 
     WCHAR l_pathname[MAX_PATH] = { 0 };
+    static atomic_uint s_queue_num = 0;
     size_t l_sz_in_words = sizeof(l_pathname)/sizeof(l_pathname[0]);
-    int pos = _snwprintf_s(l_pathname, l_sz_in_words, l_sz_in_words - 1, L".\\PRIVATE$\\DapEventSocketQueue%d", l_es->socket);
+    int pos = _snwprintf_s(l_pathname, l_sz_in_words, l_sz_in_words - 1, L".\\PRIVATE$\\DapEventSocketQueue%d", l_es->mq_num = s_queue_num++);
     if (pos < 0) {
         log_it(L_ERROR, "Message queue path error");
         DAP_DELETE(l_es);
@@ -574,6 +580,10 @@ dap_events_socket_t * s_create_type_queue_ptr(dap_worker_t * a_w, dap_events_soc
         MQDeleteQueue(l_format_name);
         return NULL;
     }
+    hr = MQPurgeQueue(l_es->mqh_recv);
+    if (hr != MQ_OK) {
+        log_it(L_DEBUG, "Message queue %d NOT purged, possible data corruption, err %d", l_es->mq_num, hr);
+    }
 
 #else
 #error "Not implemented s_create_type_queue_ptr() on your platform"
@@ -779,13 +789,16 @@ dap_events_socket_t * s_create_type_event(dap_worker_t * a_w, dap_events_socket_
     l_addr.sin_family = AF_INET;
     IN_ADDR _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
     l_addr.sin_addr = _in_addr;
-    l_addr.sin_port = l_es->socket + 32768;
+    l_addr.sin_port = 0; //l_es->socket + 32768;
     l_addr_len = sizeof(struct sockaddr_in);
 
     if (bind(l_es->socket, (struct sockaddr*)&l_addr, sizeof(l_addr)) < 0) {
         log_it(L_ERROR, "Bind error: %d", WSAGetLastError());
     } else {
-        log_it(L_INFO, "Binded %d", l_es->socket);
+        int dummy = 100;
+        getsockname(l_es->socket, (struct sockaddr*)&l_addr, &dummy);
+        l_es->port = l_addr.sin_port;
+        //log_it(L_DEBUG, "Bound to port %d", l_addr.sin_port);
     }
 #endif
     return l_es;
@@ -1035,7 +1048,7 @@ int dap_events_socket_queue_ptr_send( dap_events_socket_t * a_es, void* a_arg)
         return hr;
     }
     
-    if(dap_sendto(a_es->socket, NULL, 0) == SOCKET_ERROR) {
+    if(dap_sendto(a_es->socket, a_es->port, NULL, 0) == SOCKET_ERROR) {
         return WSAGetLastError();
     } else {
         return 0;
@@ -1079,7 +1092,7 @@ int dap_events_socket_event_signal( dap_events_socket_t * a_es, uint64_t a_value
         return 1;
 #elif defined DAP_OS_WINDOWS
     a_es->buf_out[0] = (u_short)a_value;
-    if(dap_sendto(a_es->socket, a_es->buf_out, sizeof(uint64_t)) == SOCKET_ERROR) {
+    if(dap_sendto(a_es->socket, a_es->port, a_es->buf_out, sizeof(uint64_t)) == SOCKET_ERROR) {
         return WSAGetLastError();
     } else {
         return 0;
@@ -1130,7 +1143,11 @@ dap_events_socket_t * dap_events_socket_wrap2( dap_server_t *a_server, struct da
   ret->last_time_active = ret->last_ping_request = time( NULL );
 
   pthread_rwlock_wrlock( &a_events->sockets_rwlock );
-  HASH_ADD_INT( a_events->sockets, socket, ret );
+#ifdef DAP_OS_WINDOWS
+  HASH_ADD(hh,a_events->sockets, socket, sizeof(SOCKET), ret);
+#else
+  HASH_ADD_INT(a_events->sockets, socket, ret);
+#endif
   pthread_rwlock_unlock( &a_events->sockets_rwlock );
 
   return ret;
@@ -1149,12 +1166,15 @@ dap_events_socket_t *dap_events_socket_find_unsafe( int sock, struct dap_events
     dap_events_socket_t *ret = NULL;
     if(!a_events)
         return NULL;
-    if(a_events->sockets)
+    if(a_events->sockets) {
+        pthread_rwlock_rdlock(&a_events->sockets_rwlock);
 #ifdef DAP_OS_WINDOWS
         HASH_FIND(hh, a_events->sockets, &sock, sizeof(SOCKET), ret );
 #else
         HASH_FIND_INT( a_events->sockets, &sock, ret );
 #endif
+        pthread_rwlock_unlock(&a_events->sockets_rwlock);
+    }
 
     return ret;
 }
@@ -1285,16 +1305,16 @@ void dap_events_socket_remove_and_delete_unsafe( dap_events_socket_t *a_es, bool
 void dap_events_socket_delete_unsafe( dap_events_socket_t * a_esocket , bool a_preserve_inheritor)
 {
     if (a_esocket->events){ // It could be socket NOT from events
-        pthread_rwlock_wrlock( &a_esocket->events->sockets_rwlock );
         if(!dap_events_socket_find_unsafe(a_esocket->socket, a_esocket->events)){
             log_it( L_ERROR, "dap_events_socket 0x%x already deleted", a_esocket);
-            pthread_rwlock_unlock( &a_esocket->events->sockets_rwlock );
             return ;
         }
 
-        if(a_esocket->events->sockets)
+        if(a_esocket->events->sockets) {
+            pthread_rwlock_wrlock( &a_esocket->events->sockets_rwlock );
             HASH_DEL( a_esocket->events->sockets, a_esocket );
-        pthread_rwlock_unlock( &a_esocket->events->sockets_rwlock );
+            pthread_rwlock_unlock( &a_esocket->events->sockets_rwlock );
+        }
     }
 
     if (!a_preserve_inheritor )
@@ -1304,7 +1324,7 @@ void dap_events_socket_delete_unsafe( dap_events_socket_t * a_esocket , bool a_p
     DAP_DEL_Z(a_esocket->buf_in)
     DAP_DEL_Z(a_esocket->buf_out)
 #ifdef DAP_OS_WINDOWS
-    if ( a_esocket->socket && a_esocket->socket != SOCKET_ERROR) {
+    if ( a_esocket->socket && a_esocket->socket != INVALID_SOCKET) {
         closesocket( a_esocket->socket );
 #else
         if ( a_esocket->socket && a_esocket->socket != -1) {
@@ -1668,13 +1688,13 @@ inline int dap_recvfrom(SOCKET s, void* buf_in, size_t buf_size) {
     return ret;
 }
 
-inline int dap_sendto(SOCKET s, void* buf_out, size_t buf_out_size) {
+inline int dap_sendto(SOCKET s, u_short port, void* buf_out, size_t buf_out_size) {
     int l_addr_len;
     struct sockaddr_in l_addr;
     l_addr.sin_family = AF_INET;
     IN_ADDR _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
     l_addr.sin_addr = _in_addr;
-    l_addr.sin_port = s + 32768;
+    l_addr.sin_port = port;
     l_addr_len = sizeof(struct sockaddr_in);
     int ret;
     if (buf_out) {

dap-sdk/net/core/dap_proc_thread.c

@@ -475,7 +475,7 @@ static void * s_proc_thread_function(void * a_arg)
                                     log_it(L_ERROR, "An error occured on sending message to queue, errno: 0x%x", hr);
                                     break;
                                 } else {
-                                    if(dap_sendto(l_cur->socket, NULL, 0) == SOCKET_ERROR) {
+                                    if(dap_sendto(l_cur->socket, l_cur->port, NULL, 0) == SOCKET_ERROR) {
                                         log_it(L_ERROR, "Write to sock error: %d", WSAGetLastError());
                                     }
                                     l_cur->buf_out_size = 0;

dap-sdk/net/core/dap_timerfd.c

@@ -69,7 +69,7 @@ void __stdcall TimerAPCb(void* arg, DWORD low, DWORD high) {  // Timer high valu
     UNREFERENCED_PARAMETER(low)
     UNREFERENCED_PARAMETER(high)
     dap_timerfd_t *l_timerfd = (dap_timerfd_t *)arg;
-    if (dap_sendto(l_timerfd->tfd, NULL, 0) == SOCKET_ERROR) {
+    if (dap_sendto(l_timerfd->tfd, l_timerfd->port, NULL, 0) == SOCKET_ERROR) {
         log_it(L_CRITICAL, "Error occured on writing into socket from APC, errno: %d", WSAGetLastError());
     }
 }
@@ -128,13 +128,15 @@ dap_timerfd_t* dap_timerfd_start_on_worker(dap_worker_t * a_worker, uint64_t a_t
     l_addr.sin_family = AF_INET;
     IN_ADDR _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
     l_addr.sin_addr = _in_addr;
-    l_addr.sin_port = l_tfd + 32768;
+    l_addr.sin_port = 0; //l_tfd + 32768;
     l_addr_len = sizeof(struct sockaddr_in);
-
     if (bind(l_tfd, (struct sockaddr*)&l_addr, sizeof(l_addr)) < 0) {
         log_it(L_ERROR, "Bind error: %d", WSAGetLastError());
     } else {
-        log_it(L_INFO, "Binded %d", l_tfd);
+        int dummy = 100;
+        getsockname(l_tfd, (struct sockaddr*)&l_addr, &dummy);
+        l_timerfd->port = l_addr.sin_port;
+        //log_it(L_DEBUG, "Bound to port %d", l_addr.sin_port);
     }
 
     LARGE_INTEGER l_due_time;

dap-sdk/net/core/dap_worker.c

@@ -529,7 +529,7 @@ void *dap_worker_thread(void *arg)
                                  } else {
                                      l_errno = WSAGetLastError();
 
-                                     if(dap_sendto(l_cur->socket, NULL, 0) == SOCKET_ERROR) {
+                                     if(dap_sendto(l_cur->socket, l_cur->port, NULL, 0) == SOCKET_ERROR) {
                                          log_it(L_ERROR, "Write to socket error: %d", WSAGetLastError());
                                      }
                                      l_cur->buf_out_size = 0;

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

@@ -153,6 +153,8 @@ typedef struct dap_events_socket {
 #elif defined DAP_EVENTS_CAPS_MSMQ
     };
     QUEUEHANDLE mqh, mqh_recv;
+    u_int mq_num;
+    u_short port;
     HANDLE ev_timeout, ev_recv;
 #endif
 
@@ -299,7 +301,7 @@ void dap_events_socket_shrink_buf_in(dap_events_socket_t * cl, size_t shrink_siz
 
 #ifdef DAP_OS_WINDOWS
 extern inline int dap_recvfrom(SOCKET s, void* buf_in, size_t buf_size);
-extern inline int dap_sendto(SOCKET s, void* buf_in, size_t buf_size);
+extern inline int dap_sendto(SOCKET s, u_short port, void* buf_in, size_t buf_size);
 #endif
 
 

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

@@ -44,6 +44,7 @@ typedef struct dap_timerfd {
     uint64_t timeout_ms;
 #ifdef DAP_OS_WINDOWS
 	SOCKET tfd;
+    u_short port;
 #else
     int tfd; //timer file descriptor
 #endif

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

@@ -135,18 +135,19 @@ void dap_stream_ch_delete(dap_stream_ch_t *a_ch)
     HASH_DELETE(hh_worker,l_stream_worker->channels, a_ch);
     pthread_rwlock_unlock(&l_stream_worker->channels_rwlock);
 
-    pthread_rwlock_wrlock(&s_ch_table_lock);
     struct dap_stream_ch_table_t *l_ret;
+    pthread_rwlock_rdlock(&s_ch_table_lock);
     HASH_FIND_PTR(s_ch_table, &a_ch, l_ret);
+    pthread_rwlock_unlock(&s_ch_table_lock);
     if (!l_ret) {
-        pthread_rwlock_unlock(&s_ch_table_lock);
         return;
     }
+    pthread_rwlock_wrlock(&s_ch_table_lock);
     HASH_DEL(s_ch_table, l_ret);
-    pthread_mutex_lock(&a_ch->mutex);
     pthread_rwlock_unlock(&s_ch_table_lock);
     DAP_DELETE(l_ret);
 
+    pthread_mutex_lock(&a_ch->mutex);
     if (a_ch->proc)
         if (a_ch->proc->delete_callback)
             a_ch->proc->delete_callback(a_ch, NULL);

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

@@ -143,7 +143,7 @@ bool dap_stream_ch_check_unsafe(dap_stream_worker_t * a_worker,dap_stream_ch_t *
     if (a_ch){
         if ( a_worker->channels){
             dap_stream_ch_t * l_ch = NULL;
-            pthread_rwlock_wrlock(&a_worker->channels_rwlock);
+            pthread_rwlock_rdlock(&a_worker->channels_rwlock);
             HASH_FIND(hh_worker,a_worker->channels ,&a_ch, sizeof(a_ch), l_ch );
             pthread_rwlock_unlock(&a_worker->channels_rwlock);
             return l_ch == a_ch;

dap-sdk/net/stream/stream/dap_stream_worker.c

@@ -52,7 +52,6 @@ int dap_stream_worker_init()
         l_stream_worker->worker = l_worker;
         pthread_rwlock_init( &l_stream_worker->channels_rwlock, NULL);
         l_stream_worker->queue_ch_io = dap_events_socket_create_type_queue_ptr_mt( l_worker, s_ch_io_callback);
-        log_it(L_WARNING, "Queue ch io socket: %d, worker %p", l_stream_worker->queue_ch_io->socket, l_stream_worker->worker);
     }
     return 0;
 }
@@ -69,7 +68,7 @@ static void s_ch_io_callback(dap_events_socket_t * a_es, void * a_msg)
 
     // Check if it was removed from the list
     dap_stream_ch_t *l_msg_ch = NULL;
-    pthread_rwlock_wrlock(&l_stream_worker->channels_rwlock);
+    pthread_rwlock_rdlock(&l_stream_worker->channels_rwlock);
     HASH_FIND(hh_worker, l_stream_worker->channels , &l_msg->ch , sizeof (void*), l_msg_ch );
     pthread_rwlock_unlock(&l_stream_worker->channels_rwlock);
     if ( l_msg_ch == NULL){

modules/chain/dap_chain.c

@@ -93,11 +93,9 @@ int dap_chain_init(void)
 void dap_chain_deinit(void)
 {
     dap_chain_item_t * l_item = NULL, *l_tmp = NULL;
-    pthread_rwlock_wrlock(&s_chain_items_rwlock);
     HASH_ITER(hh, s_chain_items, l_item, l_tmp) {
           dap_chain_delete(l_item->chain);
     }
-    pthread_rwlock_unlock(&s_chain_items_rwlock);
 }
 
 
@@ -111,7 +109,7 @@ dap_chain_t* dap_chain_enum(void** a_item)
     dap_chain_item_t *l_item_start = (*a_item == 0x1) ? s_chain_items : (dap_chain_item_t*) *a_item;
     dap_chain_item_t *l_item = NULL;
     dap_chain_item_t *l_item_tmp = NULL;
-    pthread_rwlock_wrlock(&s_chain_items_rwlock);
+    pthread_rwlock_rdlock(&s_chain_items_rwlock);
     HASH_ITER(hh, l_item_start, l_item, l_item_tmp) {
         *a_item = l_item_tmp;
         return l_item->chain;
@@ -223,14 +221,10 @@ dap_chain_t * dap_chain_find_by_id(dap_chain_net_id_t a_chain_net_id,dap_chain_i
         .net_id = a_chain_net_id,
     };
     dap_chain_item_t * l_ret_item = NULL;
-
-    pthread_rwlock_wrlock(&s_chain_items_rwlock);
+    pthread_rwlock_rdlock(&s_chain_items_rwlock);
     HASH_FIND(hh,s_chain_items,&l_chain_item_id,sizeof(dap_chain_item_id_t),l_ret_item);
     pthread_rwlock_unlock(&s_chain_items_rwlock);
-    if ( l_ret_item ){
-        return l_ret_item->chain;
-    }else
-        return NULL;
+    return l_ret_item ? l_ret_item->chain : NULL;
 }
 
 static dap_chain_type_t s_chain_type_from_str(const char *a_type_str)

modules/chain/dap_chain_ledger.c

@@ -175,6 +175,7 @@ typedef struct dap_ledger_private {
 
     pthread_rwlock_t treshold_txs_rwlock;
     pthread_rwlock_t treshold_emissions_rwlock;
+    pthread_rwlock_t balance_accounts_rwlock;
 
     uint16_t check_flags;
     bool check_ds;
@@ -213,7 +214,7 @@ static dap_ledger_t * dap_chain_ledger_handle_new(void)
     pthread_rwlock_init(&PVT(l_ledger)->tokens_rwlock, NULL);
     pthread_rwlock_init(&PVT(l_ledger)->treshold_txs_rwlock , NULL);
     pthread_rwlock_init(&PVT(l_ledger)->treshold_emissions_rwlock , NULL);
-
+    pthread_rwlock_init(&PVT(l_ledger)->balance_accounts_rwlock , NULL);
     return l_ledger;
 }
 
@@ -229,6 +230,7 @@ void dap_chain_ledger_handle_free(dap_ledger_t *a_ledger)
     pthread_rwlock_destroy(&PVT(a_ledger)->tokens_rwlock);
     pthread_rwlock_destroy(&PVT(a_ledger)->treshold_txs_rwlock );
     pthread_rwlock_destroy(&PVT(a_ledger)->treshold_emissions_rwlock );
+    pthread_rwlock_destroy(&PVT(a_ledger)->balance_accounts_rwlock );
     DAP_DELETE(PVT(a_ledger));
     DAP_DELETE(a_ledger);
 }
@@ -260,7 +262,9 @@ int dap_chain_ledger_token_decl_add_check(dap_ledger_t * a_ledger,  dap_chain_da
     }
 
     dap_chain_ledger_token_item_t * l_token_item;
+    pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
     HASH_FIND_STR(PVT(a_ledger)->tokens,a_token->ticker,l_token_item);
+    pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
     if ( l_token_item != NULL ){
         log_it(L_WARNING,"Duplicate token declaration for ticker '%s' ", a_token->ticker);
         return -3;
@@ -282,7 +286,9 @@ int dap_chain_ledger_token_ticker_check(dap_ledger_t * a_ledger, const char *a_t
         return  -2;
     }
     dap_chain_ledger_token_item_t *l_token_item;
+    pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
     HASH_FIND_STR(PVT(a_ledger)->tokens, a_token_ticker, l_token_item);
+    pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
     return (size_t)l_token_item;
 }
 
@@ -300,59 +306,67 @@ int dap_chain_ledger_token_add(dap_ledger_t * a_ledger,  dap_chain_datum_token_t
     }
 
     dap_chain_ledger_token_item_t * l_token_item;
+    pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
     HASH_FIND_STR(PVT(a_ledger)->tokens,a_token->ticker,l_token_item);
+    pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
 
-    if ( l_token_item == NULL ){
-        l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
-        dap_snprintf(l_token_item->ticker,sizeof (l_token_item->ticker),"%s",a_token->ticker);
-        pthread_rwlock_init(&l_token_item->token_emissions_rwlock,NULL);
-        l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
-        memcpy(l_token_item->datum_token, a_token,a_token_size);
-        HASH_ADD_STR(PVT(a_ledger)->tokens, ticker, l_token_item);
-        // Add it to cache
-        dap_chain_datum_token_t *l_token_cache = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
-        memcpy(l_token_cache, a_token, a_token_size);
-        char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TOKENS_STR);
-        if (!dap_chain_global_db_gr_set(dap_strdup(a_token->ticker), l_token_cache, a_token_size, l_gdb_group)) {
-            log_it(L_WARNING, "Ledger cache mismatch");
-            DAP_DELETE(l_token_cache);
-        }
-        DAP_DELETE(l_gdb_group);
-        l_token_item->type = a_token->type;
-        switch(a_token->type){
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: {
-                l_token_item->total_supply = a_token->header_private.total_supply;
-                l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
+    if (l_token_item) {
+        log_it(L_WARNING,"Duplicate token declaration for ticker '%s' ", a_token->ticker);
+        return -3;
+    }
+
+    l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
+    dap_snprintf(l_token_item->ticker,sizeof (l_token_item->ticker),"%s",a_token->ticker);
+    pthread_rwlock_init(&l_token_item->token_emissions_rwlock,NULL);
+    l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
+    memcpy(l_token_item->datum_token, a_token,a_token_size);
+    pthread_rwlock_wrlock(&PVT(a_ledger)->tokens_rwlock);
+    HASH_ADD_STR(PVT(a_ledger)->tokens, ticker, l_token_item);
+    pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
+    // Add it to cache
+    dap_chain_datum_token_t *l_token_cache = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
+    memcpy(l_token_cache, a_token, a_token_size);
+    char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TOKENS_STR);
+    if (!dap_chain_global_db_gr_set(dap_strdup(a_token->ticker), l_token_cache, a_token_size, l_gdb_group)) {
+        log_it(L_WARNING, "Ledger cache mismatch");
+        DAP_DELETE(l_token_cache);
+    }
+    DAP_DELETE(l_gdb_group);
+    l_token_item->type = a_token->type;
+    switch(a_token->type){
+    case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: {
+        l_token_item->total_supply = a_token->header_private.total_supply;\
+        l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
                                                                                    &l_token_item->auth_signs_total,
-                                                                                    &l_token_item->auth_signs_valid );
-                if(l_token_item->auth_signs_total)
-                    l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,sizeof (dap_chain_hash_fast_t)* l_token_item->auth_signs_total);
-                for(uint16_t k=0; k<l_token_item->auth_signs_total;k++){
-                    dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
-                }
-                log_it( L_NOTICE, "Simple token %s added (total_supply = %.1llf total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_PRIVATE )",
-                        a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_private.total_supply),
-                        a_token->header_private.signs_valid, a_token->header_private.signs_total);
-            }
-            break;
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
-                log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_PRIVATE_DECL ", a_token->ticker);
-                s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
-            break;
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
-                log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
+                                                                                   &l_token_item->auth_signs_valid );
+        if(l_token_item->auth_signs_total)
+            l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,sizeof (dap_chain_hash_fast_t)* l_token_item->auth_signs_total);
+        for(uint16_t k=0; k<l_token_item->auth_signs_total;k++){
+            dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
+        }
+        log_it(L_NOTICE, "Simple token %s added (total_supply = %.1llf total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_PRIVATE )",
+               a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_private.total_supply),
+               a_token->header_private.signs_valid, a_token->header_private.signs_total);
+        break;
+    }
+
+    case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: {
+        log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_PRIVATE_DECL ", a_token->ticker);
+        s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
+        break;
+    }
+    case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: {
+        log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
                 // TODO: Check authorithy
                 //s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
-            break;
-            default:
-                log_it(L_WARNING,"Unknown token declaration type 0x%04X", a_token->type );
-        }
-        // Proc emissions tresholds
-        s_treshold_emissions_proc( a_ledger);
-    }else{
-        log_it(L_WARNING,"Duplicate token declaration for ticker '%s' ", a_token->ticker);
-        return -3;
+        break;
     }
+    default:
+        log_it(L_WARNING,"Unknown token declaration type 0x%04X", a_token->type );
+    }
+        // Proc emissions tresholds
+    s_treshold_emissions_proc( a_ledger);
+
     return  0;
 }
 
@@ -776,18 +790,18 @@ static void s_treshold_emissions_proc(dap_ledger_t * a_ledger)
     do {
         l_success = false;
         dap_chain_ledger_token_emission_item_t *l_emission_item, *l_emission_tmp;
+        pthread_rwlock_wrlock(&PVT(a_ledger)->treshold_emissions_rwlock);
         HASH_ITER(hh, PVT(a_ledger)->treshold_emissions, l_emission_item, l_emission_tmp) {
             int l_res = dap_chain_ledger_token_emission_add(a_ledger, l_emission_item->datum_token_emission,
                                                             l_emission_item->datum_token_emission_size);
             if (!l_res) {
-                pthread_rwlock_wrlock(&PVT(a_ledger)->treshold_emissions_rwlock);
                 HASH_DEL(PVT(a_ledger)->treshold_emissions, l_emission_item);
-                pthread_rwlock_unlock(&PVT(a_ledger)->treshold_emissions_rwlock);
                 DAP_DELETE(l_emission_item->datum_token_emission);
                 DAP_DELETE(l_emission_item);
                 l_success = true;
             }
         }
+        pthread_rwlock_unlock(&PVT(a_ledger)->treshold_emissions_rwlock);
     } while (l_success); 
 }
 
@@ -801,17 +815,17 @@ static void s_treshold_txs_proc( dap_ledger_t *a_ledger)
     do {
         l_success = false;
         dap_chain_ledger_tx_item_t *l_tx_item, *l_tx_tmp;
+        pthread_rwlock_wrlock(&PVT(a_ledger)->treshold_txs_rwlock);
         HASH_ITER(hh, PVT(a_ledger)->treshold_txs, l_tx_item, l_tx_tmp) {
             int l_res = dap_chain_ledger_tx_add(a_ledger, l_tx_item->tx, true);
             if (l_res == 1) {
-                pthread_rwlock_wrlock(&PVT(a_ledger)->treshold_txs_rwlock);
                 HASH_DEL(PVT(a_ledger)->treshold_txs, l_tx_item);
-                pthread_rwlock_unlock(&PVT(a_ledger)->treshold_txs_rwlock);
                 DAP_DELETE(l_tx_item->tx);
                 DAP_DELETE(l_tx_item);
                 l_success = true;
             }
         }
+        pthread_rwlock_unlock(&PVT(a_ledger)->treshold_txs_rwlock);
     } while (l_success);
 }
 
@@ -832,7 +846,7 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
         if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE) {
             l_token_item->total_supply = l_token_item->datum_token->header_private.total_supply;
         }
-        HASH_ADD_STR(PVT(a_ledger)->tokens, ticker, l_token_item);
+        HASH_ADD_STR(l_ledger_pvt->tokens, ticker, l_token_item);
         if (i == l_objs_count - 1) {
             l_ledger_pvt->last_ticker.key = l_token_item->ticker;
         }
@@ -957,7 +971,7 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
 
     const char * c_token_ticker = a_token_emission->hdr.ticker;
     dap_chain_ledger_token_item_t * l_token_item = NULL;
-    pthread_rwlock_wrlock(&l_ledger_priv->tokens_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
     HASH_FIND_STR(l_ledger_priv->tokens, c_token_ticker, l_token_item);
     pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
 
@@ -968,17 +982,18 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
     //dap_chain_hash_fast_t * l_token_emission_hash_ptr = &l_token_emission_hash;
     dap_hash_fast(a_token_emission, a_token_emission_size, &l_token_emission_hash);
     char * l_hash_str = dap_chain_hash_fast_to_str_new(&l_token_emission_hash);
-    pthread_rwlock_wrlock( l_token_item ?
-                               &l_token_item->token_emissions_rwlock :
-                               &l_ledger_priv->treshold_emissions_rwlock
-                               );
+    pthread_rwlock_rdlock(l_token_item ? &l_token_item->token_emissions_rwlock
+                                       : &l_ledger_priv->treshold_emissions_rwlock);
     HASH_FIND(hh,l_token_item ? l_token_item->token_emissions : l_ledger_priv->treshold_emissions,
               &l_token_emission_hash, sizeof(l_token_emission_hash), l_token_emission_item);
+    unsigned long long l_threshold_emissions_count = HASH_COUNT( l_ledger_priv->treshold_emissions);
+    pthread_rwlock_unlock(l_token_item ? &l_token_item->token_emissions_rwlock
+                                       : &l_ledger_priv->treshold_emissions_rwlock);
     if(l_token_emission_item ) {
         log_it(L_ERROR, "Can't add token emission datum of %llu %s ( %s ): already present in cache",
                 a_token_emission->hdr.value, c_token_ticker, l_hash_str);
         ret = -1;
-    }else if ( (! l_token_item) && ( HASH_COUNT( l_ledger_priv->treshold_emissions) >= s_treshold_emissions_max  )) {
+    }else if ( (! l_token_item) && ( l_threshold_emissions_count >= s_treshold_emissions_max)) {
         log_it(L_WARNING,"Treshold for emissions is overfulled (%lu max)",
                s_treshold_emissions_max);
         ret = -2;
@@ -986,7 +1001,9 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
         switch (a_token_emission->hdr.type){
             case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:{
                 dap_chain_ledger_token_item_t *l_token_item=NULL;
+                pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
                 HASH_FIND_STR(PVT(a_ledger)->tokens, a_token_emission->hdr.ticker, l_token_item);
+                pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
                 if (l_token_item){
                     assert(l_token_item->datum_token);
                     if( PVT(a_ledger)->net->pub.token_emission_signs_verify  ){
@@ -1028,10 +1045,6 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
             default:{}
         }
     }
-
-    pthread_rwlock_unlock(l_token_item ?
-                              &l_token_item->token_emissions_rwlock :
-                              &l_ledger_priv->treshold_emissions_rwlock);
     DAP_DELETE(l_hash_str);
 
     return ret;
@@ -1051,24 +1064,24 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
 
     const char * c_token_ticker = a_token_emission->hdr.ticker;
     dap_chain_ledger_token_item_t * l_token_item = NULL;
-    pthread_rwlock_wrlock(&l_ledger_priv->tokens_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
     HASH_FIND_STR(l_ledger_priv->tokens, c_token_ticker, l_token_item);
     pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
-
     dap_chain_ledger_token_emission_item_t * l_token_emission_item = NULL;
     // check if such emission is already present in table
     dap_chain_hash_fast_t l_token_emission_hash={0};
     dap_chain_hash_fast_t * l_token_emission_hash_ptr = &l_token_emission_hash;
     dap_hash_fast(a_token_emission, a_token_emission_size, &l_token_emission_hash);
     char * l_hash_str = dap_chain_hash_fast_to_str_new(&l_token_emission_hash);
-    pthread_rwlock_wrlock( l_token_item ?
-                               &l_token_item->token_emissions_rwlock :
-                               &l_ledger_priv->treshold_emissions_rwlock
-                               );
+    pthread_rwlock_rdlock( l_token_item ? &l_token_item->token_emissions_rwlock
+                                        : &l_ledger_priv->treshold_emissions_rwlock);
     HASH_FIND(hh,l_token_item ? l_token_item->token_emissions : l_ledger_priv->treshold_emissions,
               &l_token_emission_hash, sizeof(l_token_emission_hash), l_token_emission_item);
+    unsigned long long l_threshold_emissions_count = HASH_COUNT( l_ledger_priv->treshold_emissions);
+    pthread_rwlock_unlock(l_token_item ? &l_token_item->token_emissions_rwlock
+                                       : &l_ledger_priv->treshold_emissions_rwlock);
     if(l_token_emission_item == NULL ) {
-        if ( l_token_item || HASH_COUNT( l_ledger_priv->treshold_emissions) < s_treshold_emissions_max  ) {
+        if ( l_token_item || l_threshold_emissions_count < s_treshold_emissions_max  ) {
             l_token_emission_item = DAP_NEW_Z(dap_chain_ledger_token_emission_item_t);
             l_token_emission_item->datum_token_emission =
                     DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, a_token_emission_size);
@@ -1076,6 +1089,8 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
             memcpy(&l_token_emission_item->datum_token_emission_hash,
                     l_token_emission_hash_ptr, sizeof(l_token_emission_hash));
             l_token_emission_item->datum_token_emission_size = a_token_emission_size;
+            pthread_rwlock_wrlock( l_token_item ? &l_token_item->token_emissions_rwlock
+                                                : &l_ledger_priv->treshold_emissions_rwlock);
             if (l_token_item) {
                 HASH_ADD(hh, l_token_item->token_emissions, datum_token_emission_hash,
                          sizeof(l_token_emission_hash), l_token_emission_item);
@@ -1083,6 +1098,8 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
                 HASH_ADD(hh, l_ledger_priv->treshold_emissions, datum_token_emission_hash,
                          sizeof(l_token_emission_hash), l_token_emission_item);
             }
+            pthread_rwlock_unlock( l_token_item ? &l_token_item->token_emissions_rwlock
+                                                : &l_ledger_priv->treshold_emissions_rwlock);
             // Add it to cache
             dap_chain_datum_token_emission_t *l_emission_cache = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, a_token_emission_size);
             memcpy(l_emission_cache, a_token_emission, a_token_emission_size);
@@ -1112,11 +1129,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
         }
         ret = -1;
     }
-    pthread_rwlock_unlock(l_token_item ?
-                              &l_token_item->token_emissions_rwlock :
-                              &l_ledger_priv->treshold_emissions_rwlock);
     DAP_DELETE(l_hash_str);
-
     return ret;
 }
 
@@ -1146,19 +1159,19 @@ dap_chain_datum_token_emission_t * dap_chain_ledger_token_emission_find(dap_ledg
     dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
     dap_chain_datum_token_emission_t * l_token_emission = NULL;
     dap_chain_ledger_token_item_t * l_token_item = NULL;
-    pthread_rwlock_wrlock(&l_ledger_priv->tokens_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
     HASH_FIND_STR(l_ledger_priv->tokens, a_token_ticker, l_token_item);
+    pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
 
     if(l_token_item) {
         dap_chain_ledger_token_emission_item_t * l_token_emission_item = NULL;
-        pthread_rwlock_wrlock( &l_token_item->token_emissions_rwlock);
+        pthread_rwlock_rdlock(&l_token_item->token_emissions_rwlock);
         HASH_FIND(hh, l_token_item->token_emissions, a_token_emission_hash, sizeof(*a_token_emission_hash),
                 l_token_emission_item);
+        pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
         if( l_token_emission_item)
             l_token_emission = l_token_emission_item->datum_token_emission;
-        pthread_rwlock_unlock( &l_token_item->token_emissions_rwlock);
     }
-    pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
     return l_token_emission;
 }
 
@@ -1277,15 +1290,14 @@ static dap_chain_datum_tx_t* s_find_datum_tx_by_hash(dap_ledger_t *a_ledger,
     dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
     dap_chain_datum_tx_t *l_tx_ret = NULL;
     dap_chain_ledger_tx_item_t *l_tx_item;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_FIND(hh, l_ledger_priv->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_item); // tx_hash already in the hash?
+    pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
     if(l_tx_item) {
         l_tx_ret = l_tx_item->tx;
         if(a_item_out)
             *a_item_out = l_tx_item;
     }
-    pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
-
     return l_tx_ret;
 }
 
@@ -1592,7 +1604,9 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
                 // 5b. Call verificator for conditional output
                 dap_chain_ledger_verificator_t *l_verificator;
                 int l_tmp = (int)l_tx_prev_out_cond->header.subtype;
+                pthread_rwlock_rdlock(&s_verificators_rwlock);
                 HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
+                pthread_rwlock_unlock(&s_verificators_rwlock);
                 if (!l_verificator || !l_verificator->callback) {
                     log_it(L_ERROR, "No verificator set for conditional output subtype %d", l_tmp);
                     l_err_num = -13;
@@ -1620,6 +1634,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
         l_token_item = NULL;
         pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
         HASH_FIND_STR(l_ledger_priv->tokens,l_token, l_token_item);
+        pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
         if (! l_token_item){
             log_it(L_WARNING, "No token permissions found for token %s", l_token);
             l_err_num = -15;
@@ -1635,7 +1650,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
                 log_it(L_WARNING, "No permission for addr %s", l_tmp_tx_in_from?l_tmp_tx_in_from:"(null)");
                 DAP_DELETE(l_tmp_tx_in_from);
                 l_err_num = -20;
-                pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
                 break;
             }
         }
@@ -1647,13 +1661,10 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
                 log_it(L_WARNING, "No permission for addr %s", l_tmp_tx_in_from?l_tmp_tx_in_from:"(null)");
                 DAP_DELETE(l_tmp_tx_in_from);
                 l_err_num = -20;
-                pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
                 break;
             }
         }
 
-        pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
-
         HASH_FIND_STR(l_values_from_prev_tx, l_token, l_value_cur);
         if (!l_value_cur) {
             l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
@@ -1745,6 +1756,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
         l_token_item = NULL;
         pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
         HASH_FIND_STR(l_ledger_priv->tokens,l_token, l_token_item);
+        pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
         if (! l_token_item){
             log_it(L_WARNING, "No token permissions found for token %s", l_token);
             l_err_num = -15;
@@ -1760,7 +1772,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
                 log_it(L_WARNING, "No permission for addr %s", l_tmp_tx_out_to?l_tmp_tx_out_to:"(null)");
                 DAP_DELETE(l_tmp_tx_out_to);
                 l_err_num = -20;
-                pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
                 break;
             }
         }
@@ -1773,7 +1784,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
                 log_it(L_WARNING, "No permission for addr %s", l_tmp_tx_out_to?l_tmp_tx_out_to:"(null)");
                 DAP_DELETE(l_tmp_tx_out_to);
                 l_err_num = -20;
-                pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
                 break;
             }
         }
@@ -1893,8 +1903,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
     dap_chain_hash_fast_t *l_tx_hash = dap_chain_node_datum_tx_calc_hash(a_tx);
     char l_tx_hash_str[70];
     dap_chain_hash_fast_to_str(l_tx_hash,l_tx_hash_str,sizeof(l_tx_hash_str));
-
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_FIND(hh, l_ledger_priv->ledger_items, l_tx_hash, sizeof(dap_chain_hash_fast_t), l_item_tmp);
     pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
     // transaction already present in the cache list
@@ -1909,9 +1918,12 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
     if( (l_ret_check = dap_chain_ledger_tx_cache_check(
              a_ledger, a_tx, &l_list_bound_items, &l_list_tx_out)) < 0) {
         if (l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS) {
+            pthread_rwlock_rdlock(&l_ledger_priv->treshold_txs_rwlock);
             HASH_FIND(hh, l_ledger_priv->treshold_txs, l_tx_hash, sizeof(*l_tx_hash), l_item_tmp);
+            unsigned long long l_threshold_txs_count = HASH_COUNT(l_ledger_priv->treshold_txs);
+            pthread_rwlock_unlock(&l_ledger_priv->treshold_txs_rwlock);
             if (!l_item_tmp) {
-                if (HASH_COUNT(l_ledger_priv->treshold_txs) >= s_treshold_txs_max) {
+                if (l_threshold_txs_count >= s_treshold_txs_max) {
                     log_it(L_WARNING,"Treshold for tranactions is overfulled (%lu max), dropping down new data, added nothing",
                                    s_treshold_txs_max);
                 } else {
@@ -1943,27 +1955,28 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
     }
     log_it ( L_DEBUG, "dap_chain_ledger_tx_add() check passed for tx %s",l_tx_hash_str);
 
-    char *l_token_ticker = NULL, *l_token_ticker_old = NULL;
+    char l_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX]      = { '\0'},
+         l_token_ticker_old[DAP_CHAIN_TICKER_SIZE_MAX]  = { '\0'};
+
+    //char *l_token_ticker = NULL, *l_token_ticker_old = NULL;
     bool l_multichannel = false;
     // Mark 'out' items in cache if they were used & delete previous transactions from cache if it need
     // find all bound pairs 'in' and 'out'
     dap_list_t *l_list_tmp = l_list_bound_items;
-
+    char *l_ticker_trl = NULL, *l_ticker_old_trl = NULL;
     // Update balance: deducts
     while(l_list_tmp) {
         dap_chain_ledger_tx_bound_t *bound_item = l_list_tmp->data;
         void *l_item_in = *(void **)&bound_item->in;
         dap_chain_tx_item_type_t l_type = *(uint8_t *)l_item_in;
         dap_chain_ledger_tx_item_t *l_prev_item_out = bound_item->item_out;
-        if (*l_prev_item_out->cache_data.token_tiker) {
-            l_token_ticker = l_prev_item_out->cache_data.token_tiker;
-        } else { // Previous multichannel transaction
-            l_token_ticker = bound_item->out.tx_prev_out_ext->token;
-        }
-        if (!l_multichannel && l_token_ticker_old && strcmp(l_token_ticker, l_token_ticker_old)) {
+        l_ticker_trl = *l_prev_item_out->cache_data.token_tiker
+                ? dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_tiker)
+                : dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext->token);
+        if (!l_multichannel && l_ticker_old_trl && strcmp(l_token_ticker, l_token_ticker_old)) {
             l_multichannel = true;
         }
-        l_token_ticker_old = l_token_ticker;
+        l_ticker_old_trl = dap_stpcpy(l_token_ticker_old, l_token_ticker);
         dap_chain_hash_fast_t *l_tx_prev_hash;
         if (l_type == TX_ITEM_TYPE_IN) {
             dap_chain_tx_in_t *l_tx_in = bound_item->in.tx_cur_in;
@@ -2039,14 +2052,14 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
         dap_list_free_full(l_list_bound_items, free);
 
     // Try to find token ticker if wasn't
-    if ( l_token_ticker == NULL){
-        int l_base_tx_count = 0;
-        dap_list_t *l_base_tx_list = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_TOKEN, &l_base_tx_count );
-        if (l_base_tx_count >=1  && l_base_tx_list){
-            dap_chain_tx_token_t * l_tx_token =(dap_chain_tx_token_t *) l_base_tx_list->data;
-            if ( l_tx_token )
-                l_token_ticker = l_tx_token->header.ticker;
-        }
+    if (!l_ticker_trl){
+        //int l_base_tx_count = 0;
+        //dap_list_t *l_base_tx_list = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_TOKEN, &l_base_tx_count );
+        //if (l_base_tx_count >=1  && l_base_tx_list){
+        dap_chain_tx_token_t * l_tx_token = (dap_chain_tx_token_t *) dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_TOKEN, NULL);
+        if (l_tx_token)
+            l_ticker_trl = dap_stpcpy(l_token_ticker, l_tx_token->header.ticker);
+        //}
     }
 
     //Update balance : raise
@@ -2062,7 +2075,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
         } else {
             l_out_item_ext = l_tx_out->data;
         }
-        if (l_out_item && l_token_ticker) {
+        if (l_out_item && l_ticker_trl) {
              dap_chain_addr_t *l_addr = (l_type == TX_ITEM_TYPE_OUT) ?
                                         &l_out_item->addr :
                                         &l_out_item_ext->addr;
@@ -2072,12 +2085,14 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
             //        l_token_ticker, l_addr_str);
             dap_ledger_wallet_balance_t *wallet_balance = NULL;
             if (l_multichannel) {
-                l_token_ticker = l_out_item_ext->token;
+                l_ticker_trl = dap_stpcpy(l_token_ticker, l_out_item_ext->token);
             }
             char *l_wallet_balance_key = dap_strjoin(" ", l_addr_str, l_token_ticker, (char*)NULL);
             uint64_t l_value =  (l_type == TX_ITEM_TYPE_OUT) ? l_out_item->header.value : l_out_item_ext->header.value;
             //log_it (L_DEBUG,"GOT %lu to addr: %s", l_value, l_wallet_balance_key);
+            pthread_rwlock_rdlock(&l_ledger_priv->balance_accounts_rwlock);
             HASH_FIND_STR(PVT(a_ledger)->balance_accounts, l_wallet_balance_key, wallet_balance);
+            pthread_rwlock_unlock(&l_ledger_priv->balance_accounts_rwlock);
             if (wallet_balance) {
                 //log_it(L_DEBUG, "Balance item is present in cache");
                 uint128_t l_add = dap_chain_uint128_from(l_value);
@@ -2091,8 +2106,10 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
                 uint128_t l_add = dap_chain_uint128_from(l_value);
                 wallet_balance->balance = dap_chain_balance_add(wallet_balance->balance, l_add);
                 //log_it(L_DEBUG,"!!! Create new balance item: %s %s", l_addr_str, l_token_ticker);
+                pthread_rwlock_wrlock(&l_ledger_priv->balance_accounts_rwlock);
                 HASH_ADD_KEYPTR(hh, PVT(a_ledger)->balance_accounts, wallet_balance->key,
                                 strlen(l_wallet_balance_key), wallet_balance);
+                pthread_rwlock_unlock(&l_ledger_priv->balance_accounts_rwlock);
                 // Add it to cache
                 dap_chain_ledger_balance_cache_update(a_ledger, wallet_balance);
             }
@@ -2130,18 +2147,22 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
             }
         }
 
-        if ( l_token_ticker == NULL) { //No token ticker in previous txs
+        if (!l_ticker_trl) { //No token ticker in previous txs
             //log_it(L_DEBUG, "No token ticker in previous txs");
-            int l_tokens_count = 0;
-            dap_list_t *l_tokens_list = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_TOKEN, &l_tokens_count );
-            if ( l_tokens_count>0 ){
-                dap_chain_tx_token_t * l_token = (dap_chain_tx_token_t*) l_tokens_list->data;
-                l_token_ticker = dap_strdup (l_token->header.ticker);
-                dap_list_free(l_tokens_list);
-            }
-        }
-        if (l_token_ticker && !l_multichannel)
-            strncpy(l_item_tmp->cache_data.token_tiker, l_token_ticker, sizeof(l_item_tmp->cache_data.token_tiker) - 1);
+            //int l_tokens_count = 0;
+            //dap_list_t *l_tokens_list = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_TOKEN, &l_tokens_count );
+            //if ( l_tokens_count>0 ){
+                //dap_chain_tx_token_t * l_token = (dap_chain_tx_token_t*) l_tokens_list->data;
+            dap_chain_tx_token_t *l_token = (dap_chain_tx_token_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_TOKEN, NULL);
+            l_ticker_trl = l_token
+                    ? dap_stpcpy(l_token_ticker, l_token->header.ticker)
+                    : NULL;
+                //dap_list_free(l_tokens_list);
+            //}
+        }
+        if (l_ticker_trl && !l_multichannel)
+            dap_stpcpy(l_item_tmp->cache_data.token_tiker, l_token_ticker);
+
         size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
         memcpy(l_item_tmp->tx, a_tx, l_tx_size);
         pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
@@ -2198,10 +2219,13 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
     int l_ret = -1;
     dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
     dap_chain_ledger_tx_item_t *l_item_tmp;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_FIND(hh, l_ledger_priv->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_item_tmp);
+    pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
     if(l_item_tmp != NULL) {
+        pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
         HASH_DEL(l_ledger_priv->ledger_items, l_item_tmp);
+        pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
         // delete transaction
         DAP_DELETE(l_item_tmp->tx);
         // del struct for hash
@@ -2215,7 +2239,6 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
     else
         // hash not found in the cache
         l_ret = -2;
-    pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
     return l_ret;
 }
 
@@ -2231,6 +2254,7 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
     pthread_rwlock_wrlock(&l_ledger_priv->tokens_rwlock);
     pthread_rwlock_wrlock(&l_ledger_priv->treshold_emissions_rwlock);
     pthread_rwlock_wrlock(&l_ledger_priv->treshold_txs_rwlock);
+    pthread_rwlock_wrlock(&l_ledger_priv->balance_accounts_rwlock);
 
     // delete transactions
     dap_chain_ledger_tx_item_t *l_item_current, *l_item_tmp;
@@ -2282,6 +2306,7 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
     l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TOKENS_STR);
     HASH_ITER(hh, l_ledger_priv->tokens, l_token_current, l_token_tmp) {
         HASH_DEL(l_ledger_priv->tokens, l_token_current);
+        pthread_rwlock_wrlock(&l_token_current->token_emissions_rwlock);
         HASH_ITER(hh, l_token_current->token_emissions, l_emission_current, l_emission_tmp) {
             HASH_DEL(l_token_current->token_emissions, l_emission_current);
             dap_chain_hash_fast_to_str(&l_emission_current->datum_token_emission_hash, l_hash_str, l_hash_str_size);
@@ -2289,6 +2314,7 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
             DAP_DELETE(l_emission_current->datum_token_emission);
             DAP_DELETE(l_emission_current);
         }
+        pthread_rwlock_unlock(&l_token_current->token_emissions_rwlock);
         dap_chain_global_db_gr_del(l_token_current->ticker, l_gdb_group);
         DAP_DELETE(l_token_current->datum_token);
         pthread_rwlock_destroy(&l_token_current->token_emissions_rwlock);
@@ -2301,6 +2327,7 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
     pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
     pthread_rwlock_unlock(&l_ledger_priv->treshold_emissions_rwlock);
     pthread_rwlock_unlock(&l_ledger_priv->treshold_txs_rwlock);
+    pthread_rwlock_unlock(&l_ledger_priv->balance_accounts_rwlock);
 }
 
 /**
@@ -2309,7 +2336,10 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
  */
 unsigned dap_chain_ledger_count(dap_ledger_t *a_ledger)
 {
-    return HASH_COUNT(PVT(a_ledger)->ledger_items);
+    pthread_rwlock_rdlock(&PVT(a_ledger)->ledger_rwlock);
+    unsigned long ret = HASH_COUNT(PVT(a_ledger)->ledger_items);
+    pthread_rwlock_unlock(&PVT(a_ledger)->ledger_rwlock);
+    return ret;
 }
 
 /**
@@ -2324,7 +2354,7 @@ uint64_t dap_chain_ledger_count_from_to(dap_ledger_t * a_ledger, time_t a_ts_fro
     uint64_t l_ret = 0;
     dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
     dap_chain_ledger_tx_item_t *l_iter_current, *l_item_tmp;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     if ( a_ts_from && a_ts_to) {
         HASH_ITER(hh, l_ledger_priv->ledger_items , l_iter_current, l_item_tmp){
             if ( l_iter_current->cache_data.ts_created >= a_ts_from && l_iter_current->cache_data.ts_created <= a_ts_to )
@@ -2408,7 +2438,7 @@ uint128_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
     */
     dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
     dap_chain_ledger_tx_item_t *l_iter_current, *l_item_tmp;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_ITER(hh, l_ledger_priv->ledger_items , l_iter_current, l_item_tmp)
     {
         dap_chain_datum_tx_t *l_cur_tx = l_iter_current->tx;
@@ -2485,7 +2515,7 @@ static dap_chain_ledger_tx_item_t* tx_item_find_by_addr(dap_ledger_t *a_ledger,
     bool is_null_hash = dap_hash_fast_is_blank(a_tx_first_hash);
     bool is_search_enable = is_null_hash;
     dap_chain_ledger_tx_item_t *l_iter_current, *l_item_tmp;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_ITER(hh, l_ledger_priv->ledger_items , l_iter_current, l_item_tmp)
     {
         // If a_token is setup we check if its not our token - miss it
@@ -2577,7 +2607,7 @@ const dap_chain_datum_tx_t* dap_chain_ledger_tx_find_by_pkey(dap_ledger_t *a_led
     bool is_null_hash = dap_hash_fast_is_blank(a_tx_first_hash);
     bool is_search_enable = is_null_hash;
     dap_chain_ledger_tx_item_t *l_iter_current, *l_item_tmp;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_ITER(hh, l_ledger_priv->ledger_items , l_iter_current, l_item_tmp)
     {
         dap_chain_datum_tx_t *l_tx_tmp = l_iter_current->tx;
@@ -2624,7 +2654,7 @@ dap_chain_datum_tx_t* dap_chain_ledger_tx_cache_find_out_cond(dap_ledger_t *a_le
     dap_chain_ledger_tx_item_t *l_iter_current, *l_item_tmp;
     dap_chain_tx_out_cond_t *l_tx_out_cond;
     int l_tx_out_cond_idx;
-    pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
+    pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
     HASH_ITER(hh, l_ledger_priv->ledger_items, l_iter_current, l_item_tmp)
     {
         dap_chain_datum_tx_t *l_tx_tmp = l_iter_current->tx;
@@ -2769,7 +2799,9 @@ int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype,
 {
     dap_chain_ledger_verificator_t *l_new_verificator;
     int l_tmp = (int)a_subtype;
+    pthread_rwlock_rdlock(&s_verificators_rwlock);
     HASH_FIND_INT(s_verificators, &l_tmp, l_new_verificator);
+    pthread_rwlock_unlock(&s_verificators_rwlock);
     if (l_new_verificator) {
         l_new_verificator->callback = a_callback;
         return 1;
@@ -2782,3 +2814,7 @@ int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype,
     pthread_rwlock_unlock(&s_verificators_rwlock);
     return 0;
 }
+
+int dap_chain_ledger_verificator_rwlock_init(void) {
+    return pthread_rwlock_init(&s_verificators_rwlock, NULL);
+}

modules/chain/include/dap_chain_ledger.h

@@ -209,5 +209,6 @@ uint64_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, da
 // Put this summary value to a_value_transfer
 dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, const char *a_token_ticker, const dap_chain_addr_t *a_addr_from,
                                                        uint64_t a_value_need, uint64_t *a_value_transfer);
+int dap_chain_ledger_verificator_rwlock_init(void);
 // Add new verificator callback with associated subtype. Returns 1 if callback replaced, overwise returns 0
 int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_chain_ledger_verificator_callback_t a_callback);

modules/channel/chain-net/dap_stream_ch_chain_net.c

@@ -196,10 +196,10 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
         pthread_mutex_lock(&l_ch_chain_net->mutex);
         dap_stream_ch_pkt_t *l_ch_pkt = (dap_stream_ch_pkt_t *) a_arg;
         dap_stream_ch_chain_net_pkt_t *l_ch_chain_net_pkt = (dap_stream_ch_chain_net_pkt_t *) l_ch_pkt->data;
-        uint8_t l_acl_idx = dap_chain_net_acl_idx_by_id(l_ch_chain_net_pkt->hdr.net_id);
+        uint16_t l_acl_idx = dap_chain_net_acl_idx_by_id(l_ch_chain_net_pkt->hdr.net_id);
         bool l_error = false;
         char l_err_str[64];
-        if (l_acl_idx == (uint8_t)-1) {
+        if (l_acl_idx == (uint16_t)-1) {
             log_it(L_ERROR, "Invalid net id in packet");
             strcpy(l_err_str, "ERROR_NET_INVALID_ID");
             l_error = true;

modules/channel/chain/dap_stream_ch_chain.c

@@ -471,8 +471,8 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
         return;
     }
     size_t l_chain_pkt_data_size = l_ch_pkt->hdr.size - sizeof(l_chain_pkt->hdr);
-    uint8_t l_acl_idx = dap_chain_net_acl_idx_by_id(l_chain_pkt->hdr.net_id);
-    if (l_acl_idx == (uint8_t)-1) {
+    uint16_t l_acl_idx = dap_chain_net_acl_idx_by_id(l_chain_pkt->hdr.net_id);
+    if (l_acl_idx == (uint16_t)-1) {
         log_it(L_ERROR, "Invalid net id 0x%016x in packet", l_chain_pkt->hdr.net_id);
         if (l_ch_pkt->hdr.type == DAP_STREAM_CH_CHAIN_PKT_TYPE_ERROR) {
             if(l_ch_chain->callback_notify_packet_in) {

modules/global-db/dap_chain_global_db_driver_cdb.c

@@ -55,6 +55,7 @@ typedef struct _cdb_instance {
 static char *s_cdb_path = NULL;
 static pcdb_instance s_cdb = NULL;
 static pthread_mutex_t cdb_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_rwlock_t cdb_rwlock = PTHREAD_RWLOCK_INITIALIZER;
 
 static inline void dap_cdb_uint_to_hex(char *arr, uint64_t val, short size) {
     short i = 0;
@@ -241,9 +242,9 @@ int dap_db_driver_cdb_init(const char *a_cdb_path, dap_db_driver_callbacks_t *a_
 
 pcdb_instance dap_cdb_get_db_by_group(const char *a_group) {
     pcdb_instance l_cdb_i = NULL;
-    pthread_mutex_lock(&cdb_mutex);
+    pthread_rwlock_rdlock(&cdb_rwlock);
     HASH_FIND_STR(s_cdb, a_group, l_cdb_i);
-    pthread_mutex_unlock(&cdb_mutex);
+    pthread_rwlock_unlock(&cdb_rwlock);
     return l_cdb_i;
 }
 
@@ -261,17 +262,15 @@ int dap_cdb_add_group(const char *a_group) {
 
 int dap_db_driver_cdb_deinit() {
     pcdb_instance cur_cdb, tmp;
-    pthread_mutex_lock(&cdb_mutex);
+    pthread_rwlock_wrlock(&cdb_rwlock);
     HASH_ITER(hh, s_cdb, cur_cdb, tmp) {
         DAP_DELETE(cur_cdb->local_group);
         cdb_destroy(cur_cdb->cdb);
         HASH_DEL(s_cdb, cur_cdb);
         DAP_DELETE(cur_cdb);
     }
-    pthread_mutex_unlock(&cdb_mutex);
-    if (s_cdb_path) {
-        DAP_DELETE(s_cdb_path);
-    }
+    pthread_rwlock_unlock(&cdb_rwlock);
+    DAP_DEL_Z(s_cdb_path)
     return CDB_SUCCESS;
 }
 
@@ -279,7 +278,7 @@ int dap_db_driver_cdb_flush(void) {
     int ret = 0;
     log_it(L_DEBUG, "Flushing CDB to disk");
     cdb_instance *cur_cdb, *tmp;
-    pthread_mutex_lock(&cdb_mutex);
+    pthread_rwlock_rdlock(&cdb_rwlock);
     HASH_ITER(hh, s_cdb, cur_cdb, tmp) {
         cdb_close(cur_cdb->cdb);
         char l_cdb_path[strlen(s_cdb_path) + strlen(cur_cdb->local_group) + 2];
@@ -300,7 +299,7 @@ int dap_db_driver_cdb_flush(void) {
     }
     log_it(L_DEBUG, "All data dumped");
 RET:
-    pthread_mutex_unlock(&cdb_mutex);
+    pthread_rwlock_unlock(&cdb_rwlock);
     return ret;
 }
 
@@ -468,14 +467,14 @@ dap_list_t* dap_db_driver_cdb_get_groups_by_mask(const char *a_group_mask)
     if(!a_group_mask)
         return NULL;
     cdb_instance *cur_cdb, *tmp;
-    pthread_mutex_lock(&cdb_mutex);
+    pthread_rwlock_rdlock(&cdb_rwlock);
     HASH_ITER(hh, s_cdb, cur_cdb, tmp)
     {
         if(!dap_fnmatch(a_group_mask, cur_cdb->local_group, 0))
             if(dap_fnmatch("*.del", cur_cdb->local_group, 0))
                 l_ret_list = dap_list_prepend(l_ret_list, dap_strdup(cur_cdb->local_group));
     }
-    pthread_mutex_unlock(&cdb_mutex);
+    pthread_rwlock_unlock(&cdb_rwlock);
     return l_ret_list;
 }
 

modules/net/dap_chain_net.c

@@ -1832,10 +1832,7 @@ dap_chain_net_t * dap_chain_net_by_name( const char * a_name)
     dap_chain_net_item_t * l_net_item = NULL;
     if(a_name)
         HASH_FIND_STR(s_net_items,a_name,l_net_item );
-    if ( l_net_item )
-        return l_net_item->chain_net;
-    else
-        return NULL;
+    return l_net_item ? l_net_item->chain_net : NULL;
 }
 
 /**
@@ -1846,9 +1843,7 @@ dap_chain_net_t * dap_chain_net_by_name( const char * a_name)
 dap_ledger_t * dap_chain_ledger_by_net_name( const char * a_net_name)
 {
     dap_chain_net_t *l_net = dap_chain_net_by_name(a_net_name);
-    if(l_net)
-        return l_net->pub.ledger;
-    return NULL;
+    return l_net ? l_net->pub.ledger : NULL;
 }
 
 /**
@@ -1860,11 +1855,7 @@ dap_chain_net_t * dap_chain_net_by_id( dap_chain_net_id_t a_id)
 {
     dap_chain_net_item_t * l_net_item = NULL;
     HASH_FIND(hh,s_net_items_ids,&a_id,sizeof (a_id), l_net_item );
-    if ( l_net_item )
-        return l_net_item->chain_net;
-    else
-        return NULL;
-
+    return l_net_item ? l_net_item->chain_net : NULL;
 }
 
 /**
@@ -1876,10 +1867,7 @@ uint16_t dap_chain_net_acl_idx_by_id(dap_chain_net_id_t a_id)
 {
     dap_chain_net_item_t * l_net_item = NULL;
     HASH_FIND(hh,s_net_items_ids,&a_id,sizeof (a_id), l_net_item );
-    if (l_net_item)
-        return PVT(l_net_item->chain_net)->acl_idx;
-    else
-        return -1;
+    return l_net_item ? PVT(l_net_item->chain_net)->acl_idx : (uint16_t)-1;
 
 }
 
@@ -1962,10 +1950,7 @@ char * dap_chain_net_get_gdb_group_mempool_by_chain_type(dap_chain_net_t * l_net
  */
 dap_chain_node_addr_t * dap_chain_net_get_cur_addr( dap_chain_net_t * l_net)
 {
-    if (!l_net) {
-        return NULL;
-    }
-    return  PVT(l_net)->node_info ? &PVT(l_net)->node_info->hdr.address : PVT(l_net)->node_addr;
+    return l_net ? (PVT(l_net)->node_info ? &PVT(l_net)->node_info->hdr.address : PVT(l_net)->node_addr) : NULL;
 }
 
 uint64_t dap_chain_net_get_cur_addr_int(dap_chain_net_t * l_net)
@@ -1976,7 +1961,7 @@ uint64_t dap_chain_net_get_cur_addr_int(dap_chain_net_t * l_net)
 
 dap_chain_cell_id_t * dap_chain_net_get_cur_cell( dap_chain_net_t * l_net)
 {
-    return  PVT(l_net)->node_info? &PVT(l_net)->node_info->hdr.cell_id: 0;
+    return  PVT(l_net)->node_info ? &PVT(l_net)->node_info->hdr.cell_id: 0;
 }