.gitlab-ci.yml

@@ -20,8 +20,13 @@ tests:amd64.debian:
     image: demlabs/debian/amd64:qt5
     before_script: /opt/buildtools/prepare_environment.sh amd64-linux
     script:
+      - pwd
       - mkdir build
-      - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_WITH_ECDSA=ON && make -j$(nproc) && ctest --verbose
+      - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_WITH_ECDSA=ON && make -j$(nproc) && ctest --verbose && make cppcheck
+      - cd /opt/buildtools/ && python3 -m cppcheck_codequality  --input-file=${CI_PROJECT_DIR}/build/cppcheck_results.xml --output-file=${CI_PROJECT_DIR}/build/cppcheck.json
+    artifacts:
+      reports:
+         codequality: build/cppcheck.json
 
 tests:arm32.debian:
     extends: .tests

cmake/OS_Detection.cmake

@@ -257,3 +257,28 @@ if ( CELLFRAME_NO_OPTIMIZATION)
     set(DAP_CRYPTO_XKCP_PLAINC ON)
 endif ()
 
+FIND_PROGRAM(CPPCHECK "cppcheck")
+IF(CPPCHECK)
+    # Set export commands on
+    message("[!] CPPCHECK FOUND, ADDED TARGET CPPCHECK")
+
+    SET(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+    ADD_CUSTOM_TARGET(
+        cppcheck
+        COMMAND
+            ${CPPCHECK} --enable=all --project=${CMAKE_BINARY_DIR}/compile_commands.json --std=c++11 --verbose --quiet
+            --xml-version=2 --language=c++ --suppress=missingIncludeSystem
+            --output-file=${CMAKE_BINARY_DIR}/cppcheck_results.xml ${CHECK_CXX_SOURCE_FILES}
+        COMMENT "Generate cppcheck report for the project")
+
+    FIND_PROGRAM(CPPCHECK_HTML "cppcheck-htmlreport")
+    IF(CPPCHECK_HTML)
+        ADD_CUSTOM_TARGET(
+            cppcheck-html
+            COMMAND ${CPPCHECK_HTML} --title=${CMAKE_PROJECT_NAME} --file=${CMAKE_BINARY_DIR}/cppcheck_results.xml
+                    --report-dir=${CMAKE_BINARY_DIR}/cppcheck_results --source-dir=${CMAKE_SOURCE_DIR}
+            COMMENT "Convert cppcheck report to HTML output")
+        ADD_DEPENDENCIES(cppcheck-html cppcheck)
+    ENDIF()
+ENDIF()

core/include/dap_common.h

@@ -1120,4 +1120,4 @@ DAP_STATIC_INLINE bool dap_stream_node_addr_is_blank(dap_stream_node_addr_t *a_a
 
 const char *dap_stream_node_addr_to_str_static(dap_stream_node_addr_t a_address);
 
-void dap_common_enable_cleaner_log(size_t a_timeout, size_t *a_max_size);
+void dap_common_enable_cleaner_log(size_t a_timeout, size_t a_max_size);

core/include/dap_json_rpc_errors.h

@@ -58,7 +58,7 @@ dap_json_rpc_error_JSON_t * dap_json_rpc_error_JSON_create();
 void dap_json_rpc_error_JSON_free(dap_json_rpc_error_JSON_t *a_error_json);
 dap_json_rpc_error_JSON_t * dap_json_rpc_error_JSON_add_data(int code, const char *msg);
 
-int dap_json_rpc_error_add(int a_code_error, const char *msg, ...);
+int dap_json_rpc_error_add(json_object* a_json_arr_reply, int a_code_error, const char *msg, ...);
 
 json_object * dap_json_rpc_error_get();
 
@@ -73,7 +73,11 @@ dap_json_rpc_error_t *dap_json_rpc_create_from_json_object(json_object *a_jobj);
 
 void dap_json_rpc_add_standart_erros(void);
 
-#define dap_json_rpc_allocation_error log_it(L_CRITICAL, "%s", c_error_memory_alloc); dap_json_rpc_error_add(DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED, "[%s] %s",  LOG_TAG, c_error_memory_alloc)
+#define dap_json_rpc_allocation_error(a_json_arr_reply) \
+    do {    \
+        log_it(L_CRITICAL, "%s", c_error_memory_alloc); \
+        dap_json_rpc_error_add(a_json_arr_reply, DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED, "[%s] %s",  LOG_TAG, c_error_memory_alloc); \
+    } while (0)
 
 #ifdef __cplusplus
 }

core/src/dap_common.c

@@ -196,16 +196,16 @@ static void print_it_stderr(unsigned a_off, const char *a_fmt, va_list va)
 {
     vfprintf(s_print_param, a_fmt, va);
 }
-
+*/
 #if ANDROID
 #include <android/log.h>
 
 static void print_it_alog (unsigned a_off, const char *a_fmt, va_list va)
 {
-    __android_log_vprint(ANDROID_LOG_INFO, s_print_param, a_fmt, va);
+    __android_log_vprint(ANDROID_LOG_INFO, "CellframeNodeNative", a_fmt, va);
 }
 
-#endif*/
+#endif
 
 void dap_log_set_external_output(LOGGER_EXTERNAL_OUTPUT output, void *param)
 {
@@ -230,10 +230,9 @@ void dap_log_set_external_output(LOGGER_EXTERNAL_OUTPUT output, void *param)
         s_print_callback = print_it_none;
         break;
     #ifdef ANDROID
-    /*case LOGGER_OUTPUT_ALOG:
+    case LOGGER_OUTPUT_ALOG:
         s_print_callback = print_it_alog;
-        s_print_param = param;
-        break;*/
+        break;
     #endif
 
   default:
@@ -380,8 +379,8 @@ int dap_deserialize_multy(const uint8_t *a_data, uint64_t a_size, int a_count, .
     return 0;
 }
 
-int s_dap_log_open(const char *a_log_file_path) {
-    if (! (s_log_file = s_log_file ? freopen(a_log_file_path, "w", s_log_file) : fopen( a_log_file_path , "a" )) )
+static int s_dap_log_open(const char *a_log_file_path, bool a_new) {
+    if (! (s_log_file = s_log_file ? freopen(a_log_file_path, a_new ? "w" : "a", s_log_file) : fopen( a_log_file_path, a_new ? "w" : "a" )) )
         return fprintf( stderr, "Can't open log file %s \n", a_log_file_path ), -1;
     static char s_buf_file[LOG_BUF_SIZE];
     return setvbuf(s_log_file, s_buf_file, _IOLBF, LOG_BUF_SIZE);
@@ -403,7 +402,7 @@ int dap_common_init( const char *a_console_title, const char *a_log_file_path, c
     for (int i = 0; i < 16; ++i)
             s_ansi_seq_color_len[i] =(unsigned int) strlen(s_ansi_seq_color[i]);
     if ( a_log_file_path && a_log_file_path[0] ) {
-        if (s_dap_log_open(a_log_file_path))
+        if (s_dap_log_open(a_log_file_path, false))
             return -1;
         if (a_log_dirpath != s_log_dir_path)
             dap_stpcpy(s_log_dir_path,  a_log_dirpath);
@@ -1564,26 +1563,19 @@ ssize_t dap_writev(dap_file_handle_t a_hf, const char* a_filename, iovec_t const
 }
 
 static void s_dap_common_log_cleanner_interval(void *a_max_size) {
-    size_t l_max_size = *((size_t*)a_max_size);
-    size_t l_log_size = ftell(s_log_file);
-    if (l_log_size == 0){
-        log_it(L_ERROR, "The size of the log file could not be determined; cleaning is impossible.");
-    } else {
-        size_t l_size_mb = l_log_size / 1048576;
-        if (l_size_mb > l_max_size) {
-            char *l_new_file = dap_strdup_printf("%s.old", s_log_file_path);
-            rename(s_log_file_path, l_new_file);
-            if (s_dap_log_open(s_log_file_path)) {
-                log_it(L_CRITICAL, "An error occurred The logging thread was not reopened.");
-            }
-            log_it(L_NOTICE, "log file overwritten.");
-            remove(l_new_file);
-            DAP_DELETE(l_new_file);
-        }
+    size_t  l_max_size = DAP_POINTER_TO_SIZE(a_max_size),
+            l_log_size = ftello(s_log_file);
+    switch (l_log_size) {
+        case -1:    return log_it(L_ERROR, "Can't tell log file size, error %d :\"%s\"", errno, dap_strerror(errno));
+        case 0:     return log_it(L_ERROR, "Log file is empty");
+        default:
+            if ( l_log_size / 1048576 > l_max_size && s_dap_log_open(s_log_file_path, true) )
+                return log_it(L_ERROR, "Can't reopen log file \"%s\"", s_log_file_path);
     }
+    
 }
-void dap_common_enable_cleaner_log(size_t a_timeout, size_t *a_max_size){
-    dap_interval_timer_create(a_timeout, s_dap_common_log_cleanner_interval, a_max_size);
+void dap_common_enable_cleaner_log(size_t a_timeout, size_t a_max_size){
+    dap_interval_timer_create(a_timeout, s_dap_common_log_cleanner_interval, DAP_SIZE_TO_POINTER(a_max_size));
 }
 
 #ifdef __cplusplus

core/src/dap_config.c

@@ -42,7 +42,7 @@ int dap_config_init(const char *a_configs_path)
         return -1;
     }
 #endif
-    if(dap_dir_test(a_configs_path) || !dap_mkdir_with_parents(a_configs_path)) {
+    if(dap_dir_test(a_configs_path)) {
         DAP_DEL_Z(s_configs_path);
         s_configs_path = dap_strdup(a_configs_path);
         return 0;
@@ -527,6 +527,8 @@ double dap_config_get_item_double_default(dap_config_t *a_config, const char *a_
 }
 
 void dap_config_close(dap_config_t *a_conf) {
+    if (!a_conf)
+        return;
     DAP_DELETE(a_conf->path);
     dap_config_item_t *l_item = NULL, *l_tmp = NULL;
     HASH_ITER(hh, a_conf->items, l_item, l_tmp) {

core/src/dap_json_rpc_errors.c

@@ -2,26 +2,26 @@
 
 #define LOG_TAG "dap_json_rpc_errors"
 
-static _Thread_local dap_json_rpc_error_t *s_errors;
-int _dap_json_rpc_error_cmp_by_code(dap_json_rpc_error_t *a_error, int a_code_error);
+// static _Thread_local dap_json_rpc_error_t *s_errors;
+// int _dap_json_rpc_error_cmp_by_code(dap_json_rpc_error_t *a_error, int a_code_error);
 
 int dap_json_rpc_error_init(void)
 {
-    s_errors = NULL;
+    // s_errors = NULL;
     return  0;
 }
 
 void dap_json_rpc_error_deinit(void)
 {
-    dap_json_rpc_error_t *err, *tmp;
-    if (s_errors != NULL){
-        LL_FOREACH_SAFE(s_errors, err, tmp){
-            LL_DELETE(s_errors, err);
-            DAP_FREE(err->msg);
-            DAP_FREE(err);
-        }
-    }
-    s_errors = NULL;
+    // dap_json_rpc_error_t *err, *tmp;
+    // if (s_errors != NULL){
+    //     LL_FOREACH_SAFE(s_errors, err, tmp){
+    //         LL_DELETE(s_errors, err);
+    //         DAP_FREE(err->msg);
+    //         DAP_FREE(err);
+    //     }
+    // }
+    // s_errors = NULL;
 }
 
 dap_json_rpc_error_JSON_t * dap_json_rpc_error_JSON_create()
@@ -53,86 +53,105 @@ dap_json_rpc_error_JSON_t * dap_json_rpc_error_JSON_add_data(int code, const cha
     return l_json_err;
 }
 
-int dap_json_rpc_error_add(int a_code_error, const char *msg, ...)
+int dap_json_rpc_error_add(json_object* a_json_arr_reply, int a_code_error, const char *msg, ...)
 {
     va_list args;
     va_start(args, msg);
-    const char *a_msg = dap_strdup_vprintf(msg, args); //*str_reply = dap_strdup(str);
+    const char *l_msg = dap_strdup_vprintf(msg, args);
     va_end(args);
 
-    dap_json_rpc_error_t *l_el_search =dap_json_rpc_error_search_by_code(a_code_error);
-    if (l_el_search != NULL)
-        return 1;
-    dap_json_rpc_error_t *l_error = DAP_NEW(dap_json_rpc_error_t);
-    if(!l_error) {
-        log_it(L_CRITICAL, "%s", c_error_memory_alloc);
-        return 2;
+    if (!a_json_arr_reply || !json_object_is_type(a_json_arr_reply, json_type_array)) {
+        log_it(L_CRITICAL, "Reply is not json array");
+        return -1;
     }
-    l_error->code_error = a_code_error;
-    l_error->msg = dap_strdup(a_msg);
-    LL_APPEND(s_errors, l_error);
-    log_it(L_ERROR, "Registration type error. Code error: %d message: %s", a_code_error, a_msg);
-    return 0;
-}
 
-json_object * dap_json_rpc_error_get(){
-    json_object* json_arr_errors = json_object_new_array();
-    dap_json_rpc_error_t * error = NULL;
-    LL_FOREACH(s_errors, error) {
-        json_object_array_add(json_arr_errors, dap_json_rpc_error_get_json(error));
-    }
-    if (json_object_array_length(json_arr_errors) > 0) {
-        return json_arr_errors;
-    } else {
-        json_object_put(json_arr_errors);
-        return NULL;
+    int l_array_length = json_object_array_length(a_json_arr_reply);
+    json_object *l_json_obj_errors = NULL, *l_json_arr_errors = NULL;
+    for (int i = 0; i < l_array_length; i++) {
+        json_object *l_json_obj = json_object_array_get_idx(a_json_arr_reply, i);
+        if (l_json_obj && json_object_get_type(l_json_obj) == json_type_object) {
+            if (json_object_object_get_ex(l_json_obj, "errors", &l_json_arr_errors)) {
+                l_json_obj_errors = l_json_obj;
+                break;
+            }
+        }
     }
-}
-
-int _dap_json_rpc_error_cmp_by_code(dap_json_rpc_error_t *a_error, int a_code_error)
-{
-    if (a_error->code_error == a_code_error)
-        return 0;
-    else if (a_error->code_error < a_code_error)
-        return -1;
-    else
-        return 1;
-}
 
+    if (!l_json_obj_errors) {
+        l_json_obj_errors = json_object_new_object();
+        l_json_arr_errors = json_object_new_array();
+        json_object_object_add(l_json_obj_errors, "errors", l_json_arr_errors);
+        json_object_array_add(a_json_arr_reply, l_json_obj_errors);
+    } 
 
-dap_json_rpc_error_t *dap_json_rpc_error_search_by_code(int a_code_error)
-{
-    dap_json_rpc_error_t *l_element = NULL;
-    LL_SEARCH(s_errors, l_element, a_code_error, _dap_json_rpc_error_cmp_by_code);
-    return l_element;
-}
+    json_object* l_obj_error = json_object_new_object();
+    json_object_object_add(l_obj_error, "code", json_object_new_int(a_code_error));
+    json_object_object_add(l_obj_error, "message", json_object_new_string(l_msg));
+    json_object_array_add(l_json_arr_errors, l_obj_error);
 
-json_object *dap_json_rpc_error_get_json(dap_json_rpc_error_t *a_error)
-{
-    json_object *l_jobj_code = json_object_new_int64(a_error->code_error);
-    json_object *l_jobj_msg = json_object_new_string(a_error->msg);
-    json_object *l_jobj = json_object_new_object();
-    json_object_object_add(l_jobj, "code", l_jobj_code);
-    json_object_object_add(l_jobj, "message", l_jobj_msg);
-    json_object *l_jobj_err = json_object_new_object();
-    json_object_object_add(l_jobj_err, "error", l_jobj);
-    return l_jobj_err;
+    log_it(L_ERROR, "Registration type error. Code error: %d message: %s", a_code_error, l_msg);
+    DAP_DEL_Z(l_msg);
+    return 0;
 }
 
-char *dap_json_rpc_error_get_json_str(dap_json_rpc_error_t *a_error)
-{
-    log_it(L_NOTICE, "Translation JSON string to struct dap_json_rpc_error");
-    json_object *l_jobj_code = json_object_new_int64(a_error->code_error);
-    json_object *l_jobj_msg = json_object_new_string(a_error->msg);
-    json_object *l_jobj = json_object_new_object();
-    json_object_object_add(l_jobj, "code", l_jobj_code);
-    json_object_object_add(l_jobj, "message", l_jobj_msg);
-    json_object *l_jobj_err = json_object_new_object();
-    json_object_object_add(l_jobj_err, "error", l_jobj);
-    char *l_json_str = dap_strdup(json_object_to_json_string(l_jobj_err));
-    json_object_put(l_jobj);
-    return l_json_str;
-}
+// json_object * dap_json_rpc_error_get(){
+//     json_object* json_arr_errors = json_object_new_array();
+//     dap_json_rpc_error_t * error = NULL;
+//     LL_FOREACH(s_errors, error) {
+//         json_object_array_add(json_arr_errors, dap_json_rpc_error_get_json(error));
+//     }
+//     if (json_object_array_length(json_arr_errors) > 0) {
+//         return json_arr_errors;
+//     } else {
+//         json_object_put(json_arr_errors);
+//         return NULL;
+//     }
+// }
+
+// int _dap_json_rpc_error_cmp_by_code(dap_json_rpc_error_t *a_error, int a_code_error)
+// {
+//     if (a_error->code_error == a_code_error)
+//         return 0;
+//     else if (a_error->code_error < a_code_error)
+//         return -1;
+//     else
+//         return 1;
+// }
+
+
+// dap_json_rpc_error_t *dap_json_rpc_error_search_by_code(int a_code_error)
+// {
+//     dap_json_rpc_error_t *l_element = NULL;
+//     LL_SEARCH(s_errors, l_element, a_code_error, _dap_json_rpc_error_cmp_by_code);
+//     return l_element;
+// }
+
+// json_object *dap_json_rpc_error_get_json(dap_json_rpc_error_t *a_error)
+// {
+//     json_object *l_jobj_code = json_object_new_int64(a_error->code_error);
+//     json_object *l_jobj_msg = json_object_new_string(a_error->msg);
+//     json_object *l_jobj = json_object_new_object();
+//     json_object_object_add(l_jobj, "code", l_jobj_code);
+//     json_object_object_add(l_jobj, "message", l_jobj_msg);
+//     json_object *l_jobj_err = json_object_new_object();
+//     json_object_object_add(l_jobj_err, "error", l_jobj);
+//     return l_jobj_err;
+// }
+
+// char *dap_json_rpc_error_get_json_str(dap_json_rpc_error_t *a_error)
+// {
+//     log_it(L_NOTICE, "Translation JSON string to struct dap_json_rpc_error");
+//     json_object *l_jobj_code = json_object_new_int64(a_error->code_error);
+//     json_object *l_jobj_msg = json_object_new_string(a_error->msg);
+//     json_object *l_jobj = json_object_new_object();
+//     json_object_object_add(l_jobj, "code", l_jobj_code);
+//     json_object_object_add(l_jobj, "message", l_jobj_msg);
+//     json_object *l_jobj_err = json_object_new_object();
+//     json_object_object_add(l_jobj_err, "error", l_jobj);
+//     char *l_json_str = dap_strdup(json_object_to_json_string(l_jobj_err));
+//     json_object_put(l_jobj);
+//     return l_json_str;
+// }
 
 dap_json_rpc_error_t *dap_json_rpc_create_from_json(const char *a_json)
 {
@@ -143,12 +162,12 @@ dap_json_rpc_error_t *dap_json_rpc_create_from_json(const char *a_json)
     return l_error;
 }
 
-void dap_json_rpc_add_standart_erros(void)
-{
-    log_it(L_DEBUG, "Registration standart type erros");
-    dap_json_rpc_error_add(0, "Unknown error");
-    dap_json_rpc_error_add(1, "Not found handler for this request");
-}
+// void dap_json_rpc_add_standart_erros(void)
+// {
+//     log_it(L_DEBUG, "Registration standart type erros");
+//     dap_json_rpc_error_add(*a_json_arr_reply, 0, "Unknown error");
+//     dap_json_rpc_error_add(*a_json_arr_reply, 1, "Not found handler for this request");
+// }
 
 dap_json_rpc_error_t *dap_json_rpc_create_from_json_object(json_object *a_jobj)
 {

crypto/include/dap_hash.h

@@ -127,8 +127,13 @@ DAP_STATIC_INLINE int dap_chain_hash_fast_to_str(const dap_hash_fast_t *a_hash,
     return DAP_CHAIN_HASH_FAST_STR_SIZE;
 }
 
-const char *dap_chain_hash_fast_to_str_static(const dap_hash_fast_t *a_hash);
+DAP_STATIC_INLINE dap_hash_str_t dap_chain_hash_fast_to_hash_str(const dap_hash_fast_t *a_hash) {
+    dap_hash_str_t l_ret = { };
+    dap_chain_hash_fast_to_str(a_hash, l_ret.s, DAP_CHAIN_HASH_FAST_STR_SIZE);
+    return l_ret;
+}
 
+#define dap_chain_hash_fast_to_str_static(hash) dap_chain_hash_fast_to_hash_str(hash).s
 #define dap_hash_fast_to_str dap_chain_hash_fast_to_str
 #define dap_hash_fast_to_str_static dap_chain_hash_fast_to_str_static
 
@@ -164,13 +169,14 @@ DAP_STATIC_INLINE char *dap_hash_fast_str_new( const void *a_data, size_t a_data
     return NULL;
 }
 
-#define dap_get_data_hash_str_static(data,data_size,strname) \
-do { \
-    strname = DAP_NEW_STACK_SIZE(char, DAP_CHAIN_HASH_FAST_STR_SIZE); \
-    dap_hash_fast_t dummy_hash; \
-    dap_hash_fast(data,data_size,&dummy_hash); \
-    dap_chain_hash_fast_to_str(&dummy_hash,strname,DAP_CHAIN_HASH_FAST_STR_SIZE); \
-} while (0)
+DAP_STATIC_INLINE dap_hash_str_t dap_get_data_hash_str(const void *a_data, size_t a_data_size)
+{
+    dap_hash_str_t l_ret = { };
+    dap_hash_fast_t dummy_hash;
+    dap_hash_fast(a_data, a_data_size, &dummy_hash);
+    dap_chain_hash_fast_to_str(&dummy_hash, l_ret.s, DAP_CHAIN_HASH_FAST_STR_SIZE);
+    return l_ret;
+}
 
 #ifdef __cplusplus
 }

crypto/include/dap_sign.h

@@ -154,7 +154,7 @@ bool dap_sign_type_is_depricated(dap_sign_type_t a_sign_type);
 dap_sign_t **dap_sign_get_unique_signs(void *a_data, size_t a_data_size, size_t *a_signs_count);
 
 void dap_sign_get_information(dap_sign_t *a_sign, dap_string_t *a_str_out, const char *a_hash_out_type);
-void dap_sign_get_information_json(dap_sign_t* a_sign, json_object *a_json_out, const char *a_hash_out_type);
+void dap_sign_get_information_json(json_object* a_json_arr_reply, dap_sign_t* a_sign, json_object *a_json_out, const char *a_hash_out_type);
 
 #ifdef __cplusplus
 }

crypto/src/dap_cert.c

@@ -236,11 +236,8 @@ dap_cert_t * dap_cert_generate_mem_with_seed(const char * a_cert_name, dap_enc_k
     if (l_enc_key) {
         dap_cert_t * l_cert = dap_cert_new(a_cert_name);
         l_cert->enc_key = l_enc_key;
-        if (a_seed && a_seed_size) {
-            char *l_hash_str;
-            dap_get_data_hash_str_static(a_seed, a_seed_size, l_hash_str);
-            log_it(L_DEBUG, "Certificate generated with seed hash %s", l_hash_str);
-        }
+        if (a_seed && a_seed_size)
+            log_it(L_DEBUG, "Certificate generated with seed hash %s", dap_get_data_hash_str(a_seed, a_seed_size).s);
         return l_cert;
     } else {
         log_it(L_ERROR,"Can't generate key in memory!");
@@ -607,7 +604,7 @@ char *dap_cert_dump(dap_cert_t *a_cert)
 const char *dap_cert_get_folder(int a_n_folder_path)
 {
     char **l_p = utarray_eltptr(s_cert_folders, (u_int)a_n_folder_path);
-    return *l_p;
+    return l_p ? *l_p : ( log_it(L_ERROR, "No default cert path, check \"ca_folders\" in cellframe-node.cfg"), NULL );
 }
 
 

crypto/src/dap_hash.c

@@ -78,10 +78,3 @@ int dap_chain_hash_fast_from_str( const char *a_hash_str, dap_chain_hash_fast_t
 {
     return dap_chain_hash_fast_from_hex_str(a_hash_str, a_hash) && dap_chain_hash_fast_from_base58_str(a_hash_str, a_hash);
 }
-
-const char *dap_chain_hash_fast_to_str_static(const dap_hash_fast_t *a_hash)
-{
-    _Thread_local static char s_hash_str[DAP_HASH_FAST_STR_SIZE];
-    return dap_chain_hash_fast_to_str(a_hash, s_hash_str, sizeof(s_hash_str)) == DAP_CHAIN_HASH_FAST_STR_SIZE
-           ? s_hash_str : NULL;
-}

crypto/src/dap_sign.c

@@ -549,11 +549,11 @@ void dap_sign_get_information(dap_sign_t* a_sign, dap_string_t *a_str_out, const
  * @param a_sign Signature can be NULL
  * @param a_json_out The output string pointer
  */
-void dap_sign_get_information_json(dap_sign_t* a_sign, json_object *a_json_out, const char *a_hash_out_type)
+void dap_sign_get_information_json(json_object* a_json_arr_reply, dap_sign_t* a_sign, json_object *a_json_out, const char *a_hash_out_type)
 {
     json_object_object_add(a_json_out,"Signature", json_object_new_string(""));
     if (!a_sign) {
-        dap_json_rpc_error_add(-1, "Corrupted signature data");
+        dap_json_rpc_error_add(a_json_arr_reply, -1, "Corrupted signature data");
         return;
     }
     dap_chain_hash_fast_t l_hash_pkey;

io/dap_proc_thread.c

@@ -220,25 +220,24 @@ struct timer_arg {
     dap_proc_thread_t *thread;
     dap_thread_timer_callback_t callback;
     void *callback_arg;
+    bool oneshot;
     dap_queue_msg_priority_t priority;
 };
 
 static bool s_thread_timer_callback(void *a_arg)
 {
     struct timer_arg *l_arg = a_arg;
-    l_arg->callback(l_arg->callback_arg);
-    return false;
+    return l_arg->callback(l_arg->callback_arg), false;
 }
 
 static bool s_timer_callback(void *a_arg)
 {
     struct timer_arg *l_arg = a_arg;
-    dap_proc_thread_callback_add_pri(l_arg->thread, s_thread_timer_callback, l_arg, l_arg->priority);
-    // Repeat after exit
-    return true;
+    // Repeat after exit, if not oneshot
+    return dap_proc_thread_callback_add_pri(l_arg->thread, s_thread_timer_callback, l_arg, l_arg->priority), !l_arg->oneshot;
 }
 
-int dap_proc_thread_timer_add_pri(dap_proc_thread_t *a_thread, dap_thread_timer_callback_t a_callback, void *a_callback_arg, uint64_t a_timeout_ms, dap_queue_msg_priority_t a_priority)
+int dap_proc_thread_timer_add_pri(dap_proc_thread_t *a_thread, dap_thread_timer_callback_t a_callback, void *a_callback_arg, uint64_t a_timeout_ms, bool a_oneshot, dap_queue_msg_priority_t a_priority)
 {
     dap_return_val_if_fail(a_callback && a_timeout_ms, -1);
     dap_proc_thread_t *l_thread = a_thread ? a_thread : dap_proc_thread_get_auto();
@@ -248,7 +247,9 @@ int dap_proc_thread_timer_add_pri(dap_proc_thread_t *a_thread, dap_thread_timer_
         return -2;
     }
     struct timer_arg *l_timer_arg = DAP_NEW_Z(struct timer_arg);
-    *l_timer_arg = (struct timer_arg){ .thread = l_thread, .callback = a_callback, .callback_arg = a_callback_arg, .priority = a_priority };
+    *l_timer_arg = (struct timer_arg){  .thread = l_thread, .callback = a_callback,
+                                        .callback_arg = a_callback_arg,
+                                        .oneshot = a_oneshot, .priority = a_priority };
     dap_timerfd_start_on_worker(l_worker, a_timeout_ms, s_timer_callback, l_timer_arg);
     return 0;
 }

io/include/dap_proc_thread.h

@@ -72,9 +72,9 @@ DAP_STATIC_INLINE int dap_proc_thread_callback_add(dap_proc_thread_t *a_thread,
 {
     return dap_proc_thread_callback_add_pri(a_thread, a_callback, a_callback_arg, DAP_QUEUE_MSG_PRIORITY_NORMAL);
 }
-int dap_proc_thread_timer_add_pri(dap_proc_thread_t *a_thread, dap_thread_timer_callback_t a_callback, void *a_callback_arg, uint64_t a_timeout_ms, dap_queue_msg_priority_t a_priority);
+int dap_proc_thread_timer_add_pri(dap_proc_thread_t *a_thread, dap_thread_timer_callback_t a_callback, void *a_callback_arg, uint64_t a_timeout_ms, bool a_oneshot, dap_queue_msg_priority_t a_priority);
 DAP_STATIC_INLINE int dap_proc_thread_timer_add(dap_proc_thread_t *a_thread, dap_thread_timer_callback_t a_callback, void *a_callback_arg, uint64_t a_timeout_ms)
 {
-    return dap_proc_thread_timer_add_pri(a_thread, a_callback, a_callback_arg, a_timeout_ms, DAP_QUEUE_MSG_PRIORITY_NORMAL);
+    return dap_proc_thread_timer_add_pri(a_thread, a_callback, a_callback_arg, a_timeout_ms, false, DAP_QUEUE_MSG_PRIORITY_NORMAL);
 }
 size_t dap_proc_thread_get_avg_queue_size();

net/app-cli/dap_app_cli.c

@@ -34,10 +34,10 @@
 #include "dap_app_cli.h"
 #include "dap_app_cli_net.h"
 #include "dap_app_cli_shell.h"
-
-#ifdef DAP_OS_ANDROID
 #include "dap_json_rpc_params.h"
 #include "dap_json_rpc_request.h"
+
+#ifdef DAP_OS_ANDROID
 #include <android/log.h>
 #include <jni.h>
 static dap_config_t *cli_config;
@@ -154,6 +154,28 @@ static int shell_reader_loop()
     return 0;
 }
 
+
+char *dap_cli_exec(int argc, char **argv) {
+
+    dap_app_cli_cmd_state_t cmd = {
+            .cmd_name           = (char*)argv[0],
+            .cmd_param_count    = argc - 2,
+            .cmd_param          = argc - 2 > 0 ? (char**)(argv + 1) : NULL
+    };
+
+    char *l_cmd_str = dap_app_cli_form_command(&cmd);
+    dap_json_rpc_params_t *params = dap_json_rpc_params_create();
+    dap_json_rpc_params_add_data(params, l_cmd_str, TYPE_PARAM_STRING);
+    DAP_DELETE(l_cmd_str);
+    dap_json_rpc_request_t *a_request = dap_json_rpc_request_creation(cmd.cmd_name, params, 0);
+    char    *req_str = dap_json_rpc_request_to_json_string(a_request),
+            *res = dap_cli_cmd_exec(req_str);
+    dap_json_rpc_request_free(a_request);
+    return res;
+
+
+}
+
 #ifdef DAP_OS_ANDROID
 JNIEXPORT jstring JNICALL Java_com_CellframeWallet_Node_cellframeNodeCliMain(JNIEnv *javaEnv, jobject __unused jobj, jobjectArray argvStr)
 {

net/app-cli/dap_app_cli_net.c

@@ -121,9 +121,7 @@ dap_app_cli_connect_param_t dap_app_cli_connect()
     if (l_addr) {
         l_addrs[0] = NULL;
         dap_config_get_item_str_path_array_free(l_addrs, &l_array_count);
-#ifdef DAP_OS_WINDOWS
-        printf("Unix socket-based server is not yet implemented, consider localhost usage\n"); // TODO
-        return ~0;
+#if defined(DAP_OS_WINDOWS) || defined(DAP_OS_ANDROID)
 #else
         if ( -1 == (l_socket = socket(AF_UNIX, SOCK_STREAM, 0)) ) {
             printf ("socket() error %d", errno);

net/app-cli/include/dap_app_cli.h

@@ -42,6 +42,8 @@ typedef struct dap_app_cli_cmd_state {
 extern "C" {
 #endif
 int dap_app_cli_main(const char *a_app_name, int argc, const char **argv);
+char *dap_cli_exec(int argc, char **argv);
+
 #ifdef __cplusplus
 }
 #endif

net/client/dap_client_pvt.c

@@ -144,7 +144,9 @@ static void s_client_internal_clean(dap_client_pvt_t *a_client_pvt)
     }
     if (a_client_pvt->stream_es) {
         dap_stream_delete_unsafe(a_client_pvt->stream);
-        a_client_pvt->stream = a_client_pvt->stream_es = a_client_pvt->stream_key = NULL;
+        a_client_pvt->stream = NULL;
+        a_client_pvt->stream_es = NULL;
+        a_client_pvt->stream_key = NULL;
         a_client_pvt->stream_id = 0;
     }
 
@@ -1335,16 +1337,16 @@ static void s_stream_es_callback_read(dap_events_socket_t * a_es, void * arg)
                         l_client_pvt->stage_status = STAGE_STATUS_DONE;
                         s_stage_status_after(l_client_pvt);
 
-                        dap_stream_data_proc_read(l_client_pvt->stream);
-                        dap_events_socket_shrink_buf_in(a_es, a_es->buf_in_size);
+                        size_t l_bytes_read = dap_stream_data_proc_read(l_client_pvt->stream);
+                        dap_events_socket_shrink_buf_in(a_es, l_bytes_read);
                     }
                 }
             }
         }
             break;
         case STAGE_STREAM_STREAMING: { // if streaming - process data with stream processor
-            dap_stream_data_proc_read(l_client_pvt->stream);
-            dap_events_socket_shrink_buf_in(a_es, a_es->buf_in_size);
+            size_t l_bytes_read = dap_stream_data_proc_read(l_client_pvt->stream);
+            dap_events_socket_shrink_buf_in(a_es, l_bytes_read);
         }
             break;
         default: {

net/link_manager/dap_link_manager.c

@@ -50,8 +50,8 @@ typedef struct dap_managed_net {
 
 static bool s_debug_more = false;
 static const char *s_init_error = "Link manager not inited";
-static uint32_t s_timer_update_states = 2000;
-static uint32_t s_max_attempts_num = 3;
+static uint32_t s_timer_update_states = 5000;
+static uint32_t s_max_attempts_num = 1;
 static uint32_t s_reconnect_delay = 20; // sec
 static dap_link_manager_t *s_link_manager = NULL;
 static dap_proc_thread_t *s_query_thread = NULL;
@@ -167,15 +167,24 @@ DAP_STATIC_INLINE void s_debug_accounting_link_in_net(bool a_uplink, dap_stream_
 DAP_STATIC_INLINE void s_link_manager_print_links_info(dap_link_manager_t *a_link_manager)
 {
     dap_link_t *l_link = NULL, *l_tmp = NULL;
-    printf("| Uplink |\tNode addr\t|Active Clusters|Static clusters|\n"
+    dap_string_t *l_report = dap_string_new("\n| Uplink |\tNode addr\t|Active Clusters|Static clusters|\tNet IDs\t\n"
             "-----------------------------------------------------------------\n");
-    HASH_ITER(hh, a_link_manager->links, l_link, l_tmp)
-        printf("| %5s  |"NODE_ADDR_FP_STR"|\t%"DAP_UINT64_FORMAT_U
-                                            "\t|\t%"DAP_UINT64_FORMAT_U"\t|\n",
+    HASH_ITER(hh, a_link_manager->links, l_link, l_tmp) {
+        dap_string_append_printf(l_report, "| %5s  |"NODE_ADDR_FP_STR"|\t%"DAP_UINT64_FORMAT_U
+                                            "\t|\t%"DAP_UINT64_FORMAT_U"\t| ",
                                  l_link->is_uplink ? "True" : "False",
                                  NODE_ADDR_FP_ARGS_S(l_link->addr),
                                  dap_list_length(l_link->active_clusters),
                                  dap_list_length(l_link->static_clusters));
+        dap_list_t *it, *tmp;
+        DL_FOREACH_SAFE(l_link->uplink.associated_nets, it, tmp) {
+            dap_managed_net_t *l_net = it->data;
+            dap_string_append_printf(l_report, " %"DAP_UINT64_FORMAT_x, l_net->id);
+        }
+        dap_string_append_printf(l_report, "%s", "\n");
+    }
+    log_it(L_DEBUG, "%s", l_report->str);
+    dap_string_free(l_report, true);
 }
 
 // General functional
@@ -400,7 +409,6 @@ void dap_link_manager_set_net_condition(uint64_t a_net_id, bool a_new_condition)
     }
     if (a_new_condition)
         return;
-    l_net->uplinks = 0;
     pthread_rwlock_wrlock(&s_link_manager->links_lock);
     dap_link_t *l_link_it, *l_link_tmp;
     HASH_ITER(hh, s_link_manager->links, l_link_it, l_link_tmp) {
@@ -514,7 +522,6 @@ void s_link_drop(dap_link_t *a_link, bool a_disconnected)
                 if (l_is_permanent_link)
                     continue;
                 DL_DELETE(a_link->uplink.associated_nets, it);
-                l_net->uplinks--;
             }
         }
         if (!a_link->active_clusters && !a_link->uplink.associated_nets && !a_link->static_clusters) {
@@ -713,9 +720,11 @@ void s_links_request(dap_link_manager_t *a_link_manager)
     dap_list_t *l_item = NULL;
     DL_FOREACH(a_link_manager->nets, l_item) {
         dap_managed_net_t *l_net = (dap_managed_net_t *)l_item->data;
-        if (l_net->active && a_link_manager->callbacks.link_request &&
-                l_net->uplinks < l_net->min_links_num)
-            a_link_manager->callbacks.link_request(l_net->id);
+        if (l_net->active ) {
+            l_net->uplinks = dap_link_manager_links_count(l_net->id);
+            if (a_link_manager->callbacks.link_request && l_net->uplinks < l_net->min_links_num)
+                    a_link_manager->callbacks.link_request(l_net->id);
+        }
     }
 }
 
@@ -760,7 +769,9 @@ static dap_link_t *s_link_manager_link_create(dap_stream_node_addr_t *a_node_add
         l_link->addr.uint64 = a_node_addr->uint64;
         l_link->link_manager = s_link_manager;
         HASH_ADD(hh, s_link_manager->links, addr, sizeof(*a_node_addr), l_link);
-    }
+    }   
+    if (s_debug_more)
+        s_link_manager_print_links_info(s_link_manager);
     if (a_with_client) {
         if (!l_link->uplink.client)
             l_link->uplink.client = dap_client_new(s_client_error_callback, NULL);
@@ -778,11 +789,8 @@ static dap_link_t *s_link_manager_link_create(dap_stream_node_addr_t *a_node_add
                     return NULL;
                 }
             l_link->uplink.associated_nets = dap_list_append(l_link->uplink.associated_nets, l_net);
-            l_net->uplinks++;
         }
     }
-    if (s_debug_more)
-        s_link_manager_print_links_info(s_link_manager);
     return l_link;
 }
 
@@ -1120,7 +1128,6 @@ static bool s_link_accounting_callback(void *a_arg)
             }
         }
         l_link->uplink.associated_nets = dap_list_remove(l_link->uplink.associated_nets, l_net);
-        l_net->uplinks--;
         if (l_link->uplink.client && !l_link->uplink.associated_nets && !l_link->static_clusters)
             s_link_delete(&l_link, false, false);
     }
@@ -1234,7 +1241,7 @@ void dap_link_manager_remove_static_links_cluster(dap_cluster_member_t *a_member
  * @param a_downlinks_count output count of finded downlinks
  * @return pointer to dap_stream_node_addr_t array, first uplinks, second downlinks, or NULL
  */
-dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id, size_t *a_uplinks_count, size_t *a_downlinks_count, bool a_uplinks_only)
+dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id, size_t *a_uplinks_count, size_t *a_downlinks_count, bool a_established_only)
 {
 // sanity check
     dap_managed_net_t *l_net = s_find_net_by_id(a_net_id);
@@ -1255,13 +1262,13 @@ dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id,
     for (size_t i =  0; i < l_cur_count; ++i) {
         dap_link_t *l_link = NULL;
         HASH_FIND(hh, s_link_manager->links, l_links_addrs + i, sizeof(l_links_addrs[i]), l_link);
-        if (!l_link || (l_link->is_uplink && l_link->uplink.state != LINK_STATE_ESTABLISHED)) {
+        if (!l_link || (l_link->is_uplink && a_established_only && l_link->uplink.state != LINK_STATE_ESTABLISHED)) {
             continue;
         } else if (l_link->is_uplink) {  // first uplinks, second downlinks
             l_ret[l_uplinks_count + l_downlinks_count].uint64 = l_ret[l_uplinks_count].uint64;
             l_ret[l_uplinks_count].uint64 = l_link->addr.uint64;
             ++l_uplinks_count;
-        } else if (!a_uplinks_only) {
+        } else {
             l_ret[l_uplinks_count + l_downlinks_count].uint64 = l_link->addr.uint64;
             ++l_downlinks_count;
         }

net/link_manager/include/dap_link_manager.h

@@ -111,6 +111,6 @@ size_t dap_link_manager_needed_links_count(uint64_t a_net_id);
 void dap_link_manager_set_condition(bool a_new_condition);
 bool dap_link_manager_get_condition();
 char *dap_link_manager_get_links_info();
-dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id, size_t *a_uplinks_count, size_t *a_downlinks_count, bool a_uplinks_only);
+dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id, size_t *a_uplinks_count, size_t *a_downlinks_count, bool a_established_only);
 dap_stream_node_addr_t *dap_link_manager_get_ignored_addrs(size_t *a_ignored_count, uint64_t a_net_id);
 void dap_link_manager_stream_replace(dap_stream_node_addr_t *a_addr, bool a_new_is_uplink);