[*] More leaks, double free and other such issues are fixed

dap-sdk/core/src/dap_binary_tree.c

@@ -138,15 +138,15 @@ static dap_binary_tree_t *s_tree_delete(dap_binary_tree_t *a_elm, dap_binary_tre
         a_elm->data = l_tmp->data;
         a_elm->right = s_tree_delete(a_elm->right, a_elm->key);
     } else if (a_elm->left) {
-        dap_binary_tree_t * l_elm_old = a_elm;
+        dap_binary_tree_t * l_elm_old_left = a_elm->left;
         DAP_DELETE(a_elm->data);
         DAP_DELETE(a_elm);
-        a_elm = l_elm_old->left;
+        a_elm = l_elm_old_left;
     } else if (a_elm->right) {
-        dap_binary_tree_t * l_elm_old = a_elm;
+        dap_binary_tree_t * l_elm_old_right = a_elm->right;
         DAP_DELETE(a_elm->data);
         DAP_DELETE(a_elm);
-        a_elm = l_elm_old->right;
+        a_elm = l_elm_old_right;
     } else {
         DAP_DELETE(a_elm->data);
         DAP_DELETE(a_elm);

dap-sdk/core/src/darwin/macos/dap_network_monitor.c

@@ -313,9 +313,15 @@ static OSStatus CopyIPAddressListSCF(CFArrayRef *addrList)
     }
     // Clean up.
 
-    CFQRelease(ref);
-    CFQRelease(pattern);
-    CFQRelease(patternList);
+    if(valueDict)
+        CFQRelease(valueDict);
+    if(ref)
+        CFQRelease(ref);
+    if(pattern)
+        CFQRelease(pattern);
+    if(patternList)
+        CFQRelease(patternList);
+
     if (err != noErr && result != NULL) {
         CFQRelease(result);
         result = NULL;

dap-sdk/crypto/include/dap_hash.h

@@ -100,7 +100,12 @@ static inline bool dap_hash_fast_is_blank( dap_hash_fast_t *a_hash )
 
 DAP_STATIC_INLINE int dap_chain_hash_fast_to_str( dap_hash_fast_t *a_hash, char *a_str, size_t a_str_max )
 {
-    assert(a_str_max >= (DAP_CHAIN_HASH_FAST_SIZE * 2 + 2));
+    if(!a_str )
+        return -1;
+    if(! a_str )
+        return -2;
+    if( a_str_max < (DAP_CHAIN_HASH_FAST_SIZE * 2 + 2) )
+        return -3;
     a_str[0] = '0';
     a_str[1] = 'x';
     a_str[ DAP_CHAIN_HASH_FAST_SIZE * 2 + 2] = 0;
@@ -116,7 +121,8 @@ DAP_STATIC_INLINE char *dap_chain_hash_fast_to_str_new(dap_hash_fast_t * a_hash)
 {
     const size_t c_hash_str_size = sizeof(*a_hash)*2 +1 /*trailing zero*/ +2 /* heading 0x */+4/*just to be sure*/ ;
     char * ret = DAP_NEW_Z_SIZE(char, c_hash_str_size);
-    dap_chain_hash_fast_to_str( a_hash, ret, c_hash_str_size );
+    if(dap_chain_hash_fast_to_str( a_hash, ret, c_hash_str_size ) < 0 )
+        DAP_DEL_Z(ret);
     return ret;
 }
 

dap-sdk/crypto/src/dap_cert_file.c

@@ -138,14 +138,16 @@ void dap_cert_deserialize_meta(dap_cert_t *a_cert, const uint8_t *a_data, size_t
         }
         l_meta_arr[l_meta_items_count++] = l_new_meta;
     }
-    size_t l_reorder_arr[l_meta_items_count];
-    dap_cert_file_aux_t l_reorder = {l_reorder_arr, 0};
-    s_balance_the_tree(&l_reorder, 0, l_meta_items_count - 1);
-    size_t n = l_reorder_arr[0];
-    a_cert->metadata = dap_binary_tree_insert(NULL, l_meta_arr[n]->key, (void *)l_meta_arr[n]);
-    for (size_t i = 1; i < l_meta_items_count; i++) {
-        n = l_reorder_arr[i];
-        dap_binary_tree_insert(a_cert->metadata, l_meta_arr[n]->key, (void *)l_meta_arr[n]);
+    if(l_meta_items_count){
+        size_t l_reorder_arr[l_meta_items_count];
+        dap_cert_file_aux_t l_reorder = {l_reorder_arr, 0};
+        s_balance_the_tree(&l_reorder, 0, l_meta_items_count - 1);
+        size_t n = l_reorder_arr[0];
+        a_cert->metadata = dap_binary_tree_insert(NULL, l_meta_arr[n]->key, (void *)l_meta_arr[n]);
+        for (size_t i = 1; i < l_meta_items_count; i++) {
+            n = l_reorder_arr[i];
+            dap_binary_tree_insert(a_cert->metadata, l_meta_arr[n]->key, (void *)l_meta_arr[n]);
+        }
     }
     DAP_DELETE(l_meta_arr);
 }
@@ -277,7 +279,7 @@ uint8_t* dap_cert_mem_save(dap_cert_t * a_cert, uint32_t *a_cert_size_out)
     memcpy(l_data +l_data_offset, l_pub_key_data ,l_pub_key_data_size );
     l_data_offset += l_pub_key_data_size;
 
-    if ( l_priv_key_data_size ) {
+    if ( l_priv_key_data_size && l_priv_key_data ) {
         memcpy(l_data +l_data_offset, l_priv_key_data ,l_priv_key_data_size );
         l_data_offset += l_priv_key_data_size;
     }

dap-sdk/crypto/src/dap_enc_dilithium.c

@@ -179,22 +179,26 @@ dilithium_signature_t* dap_enc_dilithium_read_signature(uint8_t *a_buf, size_t a
 
     if( l_sign->sig_len> (UINT64_MAX - l_shift_mem ) ){
             log_it(L_ERROR,"::read_signature() Buflen inside signature %"DAP_UINT64_FORMAT_u" is too big ", l_sign->sig_len);
+            DAP_DELETE(l_sign);
             return NULL;
     }
 
     // Dirty hack for old 32 bit version serializations
     if( l_sign->sig_len + l_shift_mem + 8 == (uint64_t) a_buflen  ){
+            DAP_DELETE(l_sign);
             return dap_enc_dilithium_read_signature_old(a_buf,a_buflen);
     }
 
     // Dirty hack for old 32 bit version serializations
     if( l_sign->sig_len + l_shift_mem + 4 == (uint64_t) a_buflen  ){
+            DAP_DELETE(l_sign);
             return dap_enc_dilithium_read_signature_old2(a_buf,a_buflen);
     }
 
     if( (uint64_t) a_buflen < (l_shift_mem + l_sign->sig_len) ){
         log_it(L_ERROR,"::read_signature() Buflen %zd is smaller than all fields together(%"DAP_UINT64_FORMAT_u")", a_buflen,
                l_shift_mem + l_sign->sig_len  );
+        DAP_DELETE(l_sign);
         return NULL;
     }
 

dap-sdk/crypto/src/dap_enc_oaes.c

@@ -47,7 +47,10 @@ void dap_enc_oaes_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
     a_key->last_used_timestamp = time(NULL);
 
     oaes_ctx *ctx = get_oaes_ctx(a_key);
-
+    if(ctx == NULL){
+        log_it(L_ERROR,"OAES ctx can't be NULL");
+        return;
+    }
     if(kex_size < key_size) {
         log_it(L_ERROR, "kex_size can't be less than key_size");
         return;

dap-sdk/crypto/src/dap_sign.c

@@ -541,20 +541,24 @@ dap_multi_sign_t *dap_multi_sign_deserialize(dap_sign_type_enum_t a_type, uint8_
         }
     }
     uint32_t l_data_shift = 0, l_data_size = 0;
-    l_sign->pub_keys = DAP_NEW_Z_SIZE(uint8_t, l_pkeys_size);
-    for (int i = 0; i < l_sign->sign_count; i++) {
-        l_data_size = l_sign->meta[i].pkey_size;
-        memcpy( &l_sign->pub_keys[l_data_shift], &a_sign[l_mem_shift],l_data_size);
-        l_mem_shift += l_data_size;
-        l_data_shift += l_data_size;
+    if(l_pkeys_size){
+        l_sign->pub_keys = DAP_NEW_Z_SIZE(uint8_t, l_pkeys_size);
+        for (int i = 0; i < l_sign->sign_count; i++) {
+            l_data_size = l_sign->meta[i].pkey_size;
+            memcpy( &l_sign->pub_keys[l_data_shift], &a_sign[l_mem_shift],l_data_size);
+            l_mem_shift += l_data_size;
+            l_data_shift += l_data_size;
+        }
+        l_data_shift = l_data_size = 0;
     }
-    l_data_shift = l_data_size = 0;
-    l_sign->sign_data = DAP_NEW_Z_SIZE(uint8_t, l_signes_size);
-    for (int i = 0; i < l_sign->sign_count; i++) {
-        l_data_size = l_sign->meta[i].sign_size;
-        memcpy(&l_sign->sign_data[l_data_shift], &a_sign[l_mem_shift], l_data_size);
-        l_mem_shift += l_data_size;
-        l_data_shift += l_data_size;
+    if(l_signes_size){
+        l_sign->sign_data = DAP_NEW_Z_SIZE(uint8_t, l_signes_size);
+        for (int i = 0; i < l_sign->sign_count; i++) {
+            l_data_size = l_sign->meta[i].sign_size;
+            memcpy(&l_sign->sign_data[l_data_shift], &a_sign[l_mem_shift], l_data_size);
+            l_mem_shift += l_data_size;
+            l_data_shift += l_data_size;
+        }
     }
     return l_sign;
 }
@@ -782,6 +786,7 @@ int dap_multi_sign_verify(dap_multi_sign_t *a_sign, const void *a_data, const si
         }
         if (!l_hashed) {
             log_it (L_ERROR, "Can't create multi-signature hash");
+            DAP_DELETE(l_step_sign);
             return -1;
         }
         l_verified = dap_sign_verify(l_step_sign, &l_data_hash, sizeof(dap_chain_hash_fast_t));

dap-sdk/crypto/src/oaes/oaes_lib.c

@@ -615,7 +615,9 @@ static OAES_RET oaes_key_gen( OAES_CTX * ctx, size_t key_size )
 		return OAES_RET_ARG1;
 	
 	oaes_key_destroy( &(_ctx->key_flat) );
-	
+    if(_key == NULL)
+        return OAES_RET_ARG1;
+
 	_key->data_len = key_size;
 	
 	for( _i = 0; _i < key_size; _i++ )

dap-sdk/crypto/src/ringct20/ring.c

@@ -630,8 +630,9 @@ int MIMO_LRCT_SigVer(poly_ringct20 *c1, poly_ringct20 *tList, poly_ringct20 *hLi
 		poly_frombytes(&ctmp, bpoly);
 		poly_serial(&ctmp);//
 	}
-	if (poly_equal(&ctmp, c1) == 1)
-	{
+    DAP_DELETE(H2q);
+    DAP_DELETE(A2qp);
+    if (poly_equal(&ctmp, c1) == 1){
 		return 1;
 	}
 	return 0;	

dap-sdk/crypto/src/sig_dilithium/dilithium_sign.c

@@ -109,7 +109,7 @@ static int32_t dilithium_private_and_public_keys_init(dilithium_private_key_t *p
 
     unsigned char *f = NULL, *g = NULL;
 
-    f = calloc(p->CRYPTO_PUBLICKEYBYTES, sizeof(char));
+    f = calloc(p->CRYPTO_PUBLICKEYBYTES, sizeof(unsigned char));
     if (f == NULL) {
         free(f);
         free(g);
@@ -118,7 +118,7 @@ static int32_t dilithium_private_and_public_keys_init(dilithium_private_key_t *p
     public_key->kind = p->kind;
     public_key->data = f;
 
-    g = calloc(p->CRYPTO_SECRETKEYBYTES, sizeof(char));
+    g = calloc(p->CRYPTO_SECRETKEYBYTES, sizeof(unsigned char));
     if (g == NULL) {
         free(f);
         free(g);

dap-sdk/net/client/dap_client_pvt.c

@@ -951,11 +951,13 @@ static void s_enc_init_response(dap_client_t * a_client, void * a_response, size
                 if(json_object_get_type(val) == json_type_string) {
                     char *str = (char *) json_object_get_string(val);
                     if(!strcmp(key, "encrypt_id")) {
+                        DAP_DELETE (l_session_id_b64);
                         l_session_id_b64 = DAP_NEW_Z_SIZE(char, strlen(str) + 1);
                         strcpy(l_session_id_b64, str);
                         json_parse_count++;
                     }
                     if(!strcmp(key, "encrypt_msg")) {
+                        DAP_DELETE(l_bob_message_b64);
                         l_bob_message_b64 = DAP_NEW_Z_SIZE(char, strlen(str) + 1);
                         strcpy(l_bob_message_b64, str);
                         json_parse_count++;
@@ -1017,6 +1019,7 @@ static void s_enc_init_response(dap_client_t * a_client, void * a_response, size
             l_client_pvt->stage_status = STAGE_STATUS_ERROR;
             s_stage_status_after(l_client_pvt);
         }
+
         DAP_DELETE(l_session_id_b64);
         DAP_DELETE(l_bob_message_b64);
     } else if(a_response_size > 1) {

dap-sdk/net/core/dap_events.c

@@ -173,10 +173,11 @@ void dap_cpu_assign_thread_on(uint32_t a_cpu_id)
             case EFAULT: strncpy(l_errbuf,"A supplied memory address was invalid.",sizeof (l_errbuf)-1); break;
             case EINVAL: strncpy(l_errbuf,"The affinity bit mask mask contains no processors that are currently physically on the system and permitted to the thread",sizeof (l_errbuf)-1); break;
             case ESRCH:  strncpy(l_errbuf,"No thread with the ID thread could be found",sizeof (l_errbuf)-1); break;
+            case EPFNOSUPPORT: strncpy(l_errbuf,"System doesn't support thread affinity set",sizeof (l_errbuf)-1); break;
             default:     strncpy(l_errbuf,"Unknown error",sizeof (l_errbuf)-1);
         }
-        log_it(L_CRITICAL, "Worker #%u: error pthread_setaffinity_np(): %s (%d)", l_errbuf , l_retcode);
-        abort();
+        log_it(L_ERROR, "Worker #%u: error in set affinity thread call: %s (%d)",a_cpu_id, l_errbuf , l_retcode);
+        //abort();
     }
 #endif
 #else

dap-sdk/net/core/dap_proc_thread.c

@@ -806,7 +806,7 @@ static void * s_proc_thread_function(void * a_arg)
                                     else{
                                         l_errno = errno;
                                         log_it(L_WARNING,"queue ptr send error: kevent %p errno: %d", l_es_w_data->ptr, l_errno);
-                                        DAP_DELETE(l_es_w_data->ptr);
+                                        DAP_DELETE(l_es_w_data);
                                     }
                                 #else
                                     #error "Not implemented dap_events_socket_queue_ptr_send() for this platform"
@@ -992,7 +992,11 @@ int dap_proc_thread_esocket_write_f_inter(dap_proc_thread_t * a_thread,dap_worke
     }
 
     dap_events_socket_t * l_es_io_input = a_thread->queue_io_input[a_worker->id];
-    char * l_data = DAP_NEW_SIZE(char,l_data_size+1); if (!l_data) return -1;
+    char * l_data = DAP_NEW_SIZE(char,l_data_size+1);
+    if (!l_data){
+        va_end(ap_copy);
+        return -1;
+    }
     l_data_size = dap_vsprintf(l_data,a_format,ap_copy);
     va_end(ap_copy);
 

dap-sdk/net/server/http_server/dap_http_simple.c

@@ -196,6 +196,7 @@ bool dap_http_simple_set_supported_user_agents( const char *user_agents, ... )
 
     if ( user_agent == NULL ) {
       log_it(L_ERROR, "Can't parse user agent string");
+      va_end(argptr);
        _free_user_agents_list();
        return NULL;
     }

dap-sdk/net/server/json_rpc/src/dap_json_rpc_params.c

@@ -5,7 +5,8 @@
 dap_json_rpc_params_t* dap_json_rpc_params_create(void)
 {
     dap_json_rpc_params_t *l_params = DAP_NEW(dap_json_rpc_params_t);
-    l_params->lenght = 0;
+    if(l_params)
+        l_params->lenght = 0;
     return l_params;
 }
 
@@ -47,7 +48,8 @@ void dap_json_rpc_params_add_param(dap_json_rpc_params_t *a_params, dap_json_rpc
 {
     uint32_t l_len_new_params = a_params->lenght + 1;
     dap_json_rpc_param_t **l_new_params = DAP_NEW_SIZE(dap_json_rpc_param_t*, l_len_new_params);
-    memcpy(l_new_params, a_params->params, sizeof(dap_json_rpc_param_t*) * a_params->lenght);
+    if(a_params->lenght && a_params->params)
+       memcpy(l_new_params, a_params->params, sizeof(dap_json_rpc_param_t*) * a_params->lenght);
     memcpy(l_new_params+a_params->lenght, &a_param, sizeof(dap_json_rpc_param_t*));
     if (a_params->lenght != 0)
         DAP_FREE(a_params->params);

dap-sdk/net/server/json_rpc/src/dap_json_rpc_request.c

@@ -30,7 +30,7 @@ dap_json_rpc_request_t *dap_json_rpc_request_from_json(const char *a_data)
     json_object *l_jobj_id = NULL;
     json_object *l_jobj_method = NULL;
     json_object *l_jobj_params = NULL;
-    dap_json_rpc_request_t *l_request = DAP_NEW(dap_json_rpc_request_t);
+    dap_json_rpc_request_t *l_request = DAP_NEW_Z(dap_json_rpc_request_t);
     l_request->params = NULL;
     bool l_err_parse_request = false;
     if (l_jterr == json_tokener_success){

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

@@ -80,6 +80,7 @@ size_t dap_stream_ch_pkt_write_f_mt(dap_stream_worker_t * a_worker , dap_stream_
     int l_data_size = dap_vsnprintf(NULL,0,a_format,ap);
     if (l_data_size <0 ){
         log_it(L_ERROR,"Can't write out formatted data '%s' with values",a_format);
+        va_end(ap);
         return 0;
     }
     l_data_size++; // To calc trailing zero
@@ -121,6 +122,7 @@ size_t dap_stream_ch_pkt_write_f_inter(dap_events_socket_t * a_queue  , dap_stre
     int l_data_size = dap_vsnprintf(NULL,0,a_format,ap);
     if (l_data_size <0 ){
         log_it(L_ERROR,"Can't write out formatted data '%s' with values",a_format);
+        va_end(ap);
         return 0;
     }
     l_data_size++; // To calc trailing zero

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

@@ -173,7 +173,11 @@ size_t dap_proc_thread_stream_ch_write_f_inter(dap_proc_thread_t * a_thread,dap_
     }
 
     dap_events_socket_t * l_es_io_input = l_thread_stream->queue_ch_io_input[a_worker->id];
-    char * l_data = DAP_NEW_SIZE(char,l_data_size+1); if (!l_data) return -1;
+    char * l_data = DAP_NEW_SIZE(char,l_data_size+1);
+    if (!l_data){
+        va_end(ap_copy);
+        return -1;
+    }
     l_data_size = dap_vsprintf(l_data,a_format,ap_copy);
     va_end(ap_copy);
 

modules/app-cli/dap_app_cli.c

@@ -107,10 +107,13 @@ int execute_line(dap_app_cli_connect_param_t *cparam, char *line)
             cmd.cmd_param = (char**) (argv + 1);
         // Send command
         int res = dap_app_cli_post_command(cparam, &cmd);
+        DAP_DELETE(argv);
         return res;
+    }else{
+        DAP_DELETE(argv);
+        fprintf(stderr, "No command\n");
+        return -1;
     }
-    fprintf(stderr, "No command\n");
-    return -1;
 }
 
 /**

modules/chain/dap_chain.c

@@ -361,7 +361,7 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
                 //return NULL;
             }
             // add datum types
-            if(l_chain && l_datum_types_count > 0) {
+            if(l_chain && l_datum_types && l_datum_types_count > 0) {
                 l_chain->datum_types = DAP_NEW_SIZE(dap_chain_type_t, l_datum_types_count * sizeof(dap_chain_type_t));
                 uint16_t l_count_recognized = 0;
                 for(uint16_t i = 0; i < l_datum_types_count; i++) {
@@ -377,7 +377,7 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger, const char * a_cha
                 log_it(L_WARNING, "Can't read chain mempool auto types ", l_chain_id_str);
             }
             // add datum types
-            if(l_chain && l_datum_types_count) {
+            if(l_chain && l_datum_types && l_datum_types_count) {
                 l_chain->autoproc_datum_types = DAP_NEW_SIZE(uint16_t, l_datum_types_count * sizeof(uint16_t));
                 uint16_t l_count_recognized = 0;
                 for(uint16_t i = 0; i < l_datum_types_count; i++) {