diff --git a/core/include/dap_common.h b/core/include/dap_common.h
index 4dc1f451bd37f8c1be95b62397a803b670c0e1eb..614e69c5c2e13811c53a6f7ac760e1d7d4f14e30 100755
--- a/core/include/dap_common.h
+++ b/core/include/dap_common.h
@@ -115,6 +115,7 @@
#endif
#define UNUSED_ARG __attribute__((__unused__))
+#define LAST_ERROR_MAX 256
// TODO pipelines fix to enable this macros
/*#ifndef likely
@@ -139,18 +140,20 @@
#endif
#ifdef __cplusplus
-#define DAP_CAST_PTR(t,v) reinterpret_cast<t*>(v)
+#define DAP_CAST(t,v) reinterpret_cast<t>(v)
+#define DAP_CAST_PTR(t,v) DAP_CAST(t*,v)
#else
-#define DAP_CAST_PTR(t,v) (t*)(v)
+#define DAP_CAST(t,v) v
+#define DAP_CAST_PTR(t,v) v
#endif
#define HASH_LAST(head) ( (head) ? ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail) : NULL );
-extern const char *c_error_memory_alloc;
-extern const char *c_error_sanity_check;
-void dap_delete_multy(int a_count, ...);
-uint8_t *dap_serialize_multy(uint8_t *a_data, uint64_t a_size, int a_count, ...);
-int dap_deserialize_multy(const uint8_t *a_data, uint64_t a_size, int a_count, ...);
+extern const char *c_error_memory_alloc, *c_error_sanity_check, doof;
+/* Don't use these function directly! Rather use the corresponding macro's */
+void dap_delete_multy(size_t, ...);
+uint8_t *dap_serialize_multy(uint8_t *a_data, uint64_t a_size, ...);
+int dap_deserialize_multy(const uint8_t *a_data, uint64_t a_size, ...);
#if DAP_SYS_DEBUG
#include <assert.h>
@@ -202,57 +205,75 @@ static inline void *s_vm_extend(const char *a_rtn_name, int a_rtn_line, void *a_
#ifdef DAP_USE_RPMALLOC
#include "rpmalloc.h"
#endif
-#define DAP_MALLOC(p) malloc(p)
-#define DAP_FREE(p) free(p)
-#define DAP_CALLOC(p, s) ({ size_t s1 = (size_t)(s); s1 > 0 ? calloc(p, s1) : DAP_CAST_PTR(void, NULL); })
-#define DAP_ALMALLOC(p, s) ({ size_t s1 = (size_t)(s); s1 > 0 ? _dap_aligned_alloc(p, s1) : DAP_CAST_PTR(void, NULL); })
-#define DAP_ALREALLOC(p, s) ({ size_t s1 = (size_t)(s); s1 > 0 ? _dap_aligned_realloc(p, s1) : DAP_CAST_PTR(void, NULL); })
+#define DAP_TYPE_SIZE(p) (intmax_t)sizeof( *(__typeof__(p)){ 0 } )
+#define DAP_MALLOC(s) ({ intmax_t _s = (intmax_t)(s); _s > 0 ? malloc(_s) : NULL; })
+#define DAP_FREE(p) free((void*)(p))
+#define DAP_CALLOC(n, s) ({ intmax_t _s = (intmax_t)(s), _n = (intmax_t)(n); _s > 0 && _n > 0 ? calloc(_n, _s) : NULL; })
+#define DAP_REALLOC(p, s) ({ intmax_t _s = (intmax_t)(s); _s >= DAP_TYPE_SIZE(p) ? realloc(p, _s) : NULL; })
+#define DAP_ALMALLOC(a, s) ({ intmax_t _s = (intmax_t)(s), _a = (intmax_t)(a); _s > 0 && _a >= 0 ? _dap_aligned_alloc(_a, _s) : NULL; })
+#define DAP_ALREALLOC(p, s) ({ intmax_t _s = (intmax_t)(s); _s >= DAP_TYPE_SIZE(p) ? _dap_aligned_realloc(p, _s) : NULL; })
#define DAP_ALFREE(p) _dap_aligned_free(p)
#define DAP_PAGE_ALMALLOC(p) _dap_page_aligned_alloc(p)
#define DAP_PAGE_ALFREE(p) _dap_page_aligned_free(p)
-#define DAP_NEW(t) DAP_CAST_PTR(t, malloc(sizeof(t)))
-#define DAP_NEW_SIZE(t, s) ({ size_t s1 = (size_t)(s); s1 > 0 ? DAP_CAST_PTR(t, malloc(s1)) : DAP_CAST_PTR(t, NULL); })
+#define DAP_NEW(t) DAP_CAST_PTR( t, malloc(sizeof(t)) )
+#define DAP_NEW_SIZE(t, s) ({ intmax_t _s = (intmax_t)(s); _s >= (intmax_t)(sizeof(t)) ? DAP_CAST_PTR(t, malloc(_s)) : NULL; })
/* Auto memory! Do not inline! Do not modify the size in-call! */
-#define DAP_NEW_STACK(t) DAP_CAST_PTR(t, alloca(sizeof(t)))
-#define DAP_NEW_STACK_SIZE(t, s) DAP_CAST_PTR(t, (size_t)(s) > 0 ? alloca((size_t)(s)) : NULL)
+#define DAP_NEW_STACK(t) &(t){ }
+#define DAP_NEW_STACK_SIZE(t, s) DAP_CAST_PTR( t, (intmax_t)(s) >= (intmax_t)(sizeof(t)) && (intmax_t)(s) < (1 << 15) ? alloca((intmax_t)(s)) : NULL )
/* ... */
-#define DAP_NEW_Z(t) DAP_CAST_PTR(t, calloc(1, sizeof(t)))
-#define DAP_NEW_Z_SIZE(t, s) ({ size_t s1 = (size_t)(s); s1 > 0 ? DAP_CAST_PTR(t, calloc(1, s1)) : DAP_CAST_PTR(t, NULL); })
-#define DAP_NEW_Z_COUNT(t, c) ({ size_t c1 = (size_t)(c); c1 > 0 ? DAP_CAST_PTR(t, calloc(c1, sizeof(t))) : DAP_CAST_PTR(t, NULL); })
-#define DAP_REALLOC(p, s) ({ size_t s1 = (size_t)(s); s1 > 0 ? realloc(p, s1) : ({ DAP_DEL_Z(p); DAP_CAST_PTR(void, NULL); }); })
-#define DAP_REALLOC_COUNT(p, c) ({ size_t s1 = sizeof(*(p)); size_t c1 = (size_t)(c); c1 > 0 ? realloc(p, c1 * s1) : ({ DAP_DEL_Z(p); DAP_CAST_PTR(void, NULL); }); })
+#define DAP_NEW_Z(t) DAP_CAST_PTR( t, calloc(1, sizeof(t)) )
+#define DAP_NEW_Z_SIZE(t, s) DAP_CAST_PTR( t, DAP_CALLOC(1, s) )
+#define DAP_NEW_Z_COUNT(t, c) DAP_CAST_PTR( t, DAP_CALLOC(c, sizeof(t)) )
+#define DAP_REALLOC_COUNT(p, c) DAP_CAST_PTR( t, DAP_REALLOC(p, (c) * DAP_TYPE_SIZE(p)) )
#define DAP_DELETE(p) free((void*)(p))
-#define DAP_DELETE_COUNT(p,c) for (size_t c1 = p ? (size_t)(c) : 0; c1; DAP_DELETE(p[--c1]));
-#define DAP_DUP(p) ({ void *p1 = (uintptr_t)(p) != 0 ? calloc(1, sizeof(*(p))) : NULL; p1 ? memcpy(p1, (p), sizeof(*(p))) : DAP_CAST_PTR(void, NULL); })
-#define DAP_DUP_SIZE(p, s) ({ size_t s1 = (p) ? (size_t)(s) : 0; void *p1 = (p) && (s1 > 0) ? calloc(1, s1) : NULL; p1 ? memcpy(p1, (p), s1) : DAP_CAST_PTR(void, NULL); })
+#define DAP_DEL_Z(p) do { DAP_FREE(p); (p) = NULL; } while (0);
+#define DAP_DEL_ARRAY(p, c) for ( intmax_t _c = p ? (intmax_t)(c) : 0; _c > 0; DAP_DELETE(p[--_c]) );
+#define DAP_DUP_SIZE(p, s) ({ intmax_t _s = (intmax_t)(s); __typeof__(p) _p = ( (uintptr_t)(p) && _s >= DAP_TYPE_SIZE(p) ) ? DAP_CAST(__typeof__(p), calloc(1, _s)) : NULL; _p ? DAP_CAST(__typeof__(p), memcpy(_p, (p), _s)) : NULL; })
+#define DAP_DUP(p) ({ __typeof__(p) _p = (uintptr_t)(p) ? calloc(1, sizeof(*(p))) : NULL; if (_p) *_p = *(p); _p; })
+
#endif
-#define VA_NARGS_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-#define VA_NARGS(...) VA_NARGS_IMPL(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
-#define DAP_DEL_MULTY(...) dap_delete_multy(VA_NARGS(__VA_ARGS__), __VA_ARGS__)
-
-#define DAP_DEL_Z(a) do if (a) { DAP_DELETE(a); (a) = NULL; } while (0);
-// a - pointer to alloc
-// t - type return pointer
-// s - size to alloc
-// c - count element
-// val - return value if error
-// ... what need free if error, if nothing write NULL
-#define DAP_NEW_Z_RET(a, t, ...) do { if (!(a = DAP_NEW_Z(t))) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return; } } while (0);
-#define DAP_NEW_Z_RET_VAL(a, t, ret_val, ...) do { if (!(a = DAP_NEW_Z(t))) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return ret_val; } } while (0);
-#define DAP_NEW_Z_SIZE_RET(a, t, s, ...) do { if (!(a = DAP_NEW_Z_SIZE(t, s))) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return; } } while (0);
-#define DAP_NEW_Z_SIZE_RET_VAL(a, t, s, ret_val, ...) do { if (!(a = DAP_NEW_Z_SIZE(t, s))) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return ret_val; } } while (0);
-#define DAP_NEW_Z_COUNT_RET(a, t, c, ...) do { if (!(a = DAP_NEW_Z_COUNT(t, c))) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return; } } while (0);
-#define DAP_NEW_Z_COUNT_RET_VAL(a, t, c, ret_val, ...) do { if (!(a = DAP_NEW_Z_COUNT(t, c))) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return ret_val; } } while (0);
-
-#define dap_return_if_pass(expr) dap_return_if_pass_err(expr,c_error_sanity_check)
-#define dap_return_val_if_pass(expr,val) dap_return_val_if_pass_err(expr,val,c_error_sanity_check)
-#define dap_return_if_pass_err(expr,err_str) {if(expr) {_log_it(__FUNCTION__, __LINE__, LOG_TAG, L_WARNING, "%s", err_str); return;}}
-#define dap_return_val_if_pass_err(expr,val,err_str) {if(expr) {_log_it(__FUNCTION__, __LINE__, LOG_TAG, L_WARNING, "%s", err_str); return (val);}}
-#define dap_return_if_fail(expr) dap_return_if_pass(!(expr));
-#define dap_return_val_if_fail(expr,val) dap_return_val_if_pass(!(expr),val)
-#define dap_return_if_fail_err(expr,err_str) dap_return_if_pass_err(!(expr),err_str)
-#define dap_return_val_if_fail_err(expr,val,err_str) dap_return_val_if_pass_err(!(expr),val,err_str)
+#define DOOF_PTR (void*)&doof
+#define DAP_NARGS_PTRS(...) ( sizeof( (void*[]){NULL, ##__VA_ARGS__} ) / sizeof(void*) - 1 )
+#define DAP_DEL_MULTY(...) dap_delete_multy(DAP_NARGS_PTRS(__VA_ARGS__), ##__VA_ARGS__)
+#define DAP_VA_SERIALIZE(data, size, ...) dap_serialize_multy(data, size, ##__VA_ARGS__, DOOF_PTR)
+#define DAP_VA_SERIALIZE_NEW(size, ...) DAP_VA_SERIALIZE(NULL, size, __VA_ARGS__)
+#define DAP_VA_DESERIALIZE(data, size, ...) dap_deserialize_multy(data, size, ##__VA_ARGS__, DOOF_PTR)
+
+#define DAP_NEW_Z_RET_VAL_IF_FAIL(t, r, ...) ({ \
+ t *_p = DAP_NEW_Z(t); if (!_p) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return r; } _p; \
+})
+#define DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(t, s, r, ...) ({ \
+ t *_p = DAP_NEW_Z_SIZE(t, s); if (!_p) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return r; } _p; \
+})
+#define DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(t, c, r, ...) ({ \
+ t *_p = DAP_NEW_Z_COUNT(t, c); if (!_p) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return r; } _p; \
+})
+#define DAP_DUP_SIZE_RET_VAL_IF_FAIL(p, s, r, ...) ({ \
+ void *_p = DAP_DUP_SIZE(p, s); if (!_p) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return r; } _p; \
+})
+#define DAP_REALLOC_RET_VAL_IF_FAIL(p, s, r, ...) ({ \
+ void *_p = DAP_REALLOC(p, s); if (!_p) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return r; } _p; \
+})
+#define DAP_REALLOC_COUNT_RET_VAL_IF_FAIL(p, c, r, ...) ({ \
+ void *_p = DAP_REALLOC_COUNT(p, c); if (!_p) { log_it(L_CRITICAL, "%s", c_error_memory_alloc); DAP_DEL_MULTY(__VA_ARGS__); return r; } _p; \
+})
+
+#define DAP_NEW_Z_RET_IF_FAIL(t, ...) DAP_NEW_Z_RET_VAL_IF_FAIL(t, , __VA_ARGS__)
+#define DAP_NEW_Z_SIZE_RET_IF_FAIL(t, s, ...) DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(t, s, , __VA_ARGS__)
+#define DAP_NEW_Z_COUNT_RET_IF_FAIL(t, c, ...) DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(t, c, , __VA_ARGS__)
+#define DAP_DUP_SIZE_RET_IF_FAIL(p, s, ...) DAP_DUP_SIZE_RET_VAL_IF_FAIL(p, s, , __VA_ARGS__)
+#define DAP_REALLOC_RET_IF_FAIL(p, s, ...) DAP_REALLOC_RET_VAL_IF_FAIL(p, s, , __VA_ARGS__)
+#define DAP_REALLOC_COUNT_RET_IF_FAIL(p, c, ...) DAP_REALLOC_COUNT_RET_VAL_IF_FAIL(p, c, , __VA_ARGS__)
+
+#define dap_return_val_if_pass_err(e, r, s) do { if (e) { _log_it(__FUNCTION__, __LINE__, LOG_TAG, L_WARNING, "%s", s); return r; } } while(0);
+#define dap_return_val_if_fail_err(e, r, s) dap_return_val_if_pass_err(!(e), r, s)
+#define dap_return_val_if_pass(e, r) dap_return_val_if_pass_err(e, r, c_error_sanity_check)
+#define dap_return_val_if_fail(e, r) dap_return_val_if_fail_err(e, r, c_error_sanity_check)
+#define dap_return_if_pass_err(e, s) dap_return_val_if_pass_err(e, , s)
+#define dap_return_if_fail_err(e, s) dap_return_val_if_fail_err(e, , s)
+#define dap_return_if_pass(e) dap_return_if_pass_err(e, c_error_sanity_check)
+#define dap_return_if_fail(e) dap_return_if_fail_err(e, c_error_sanity_check)
#ifndef __cplusplus
#define DAP_IS_ALIGNED(p) !((uintptr_t)DAP_CAST_PTR(void, p) % _Alignof(typeof(p)))
@@ -306,6 +327,10 @@ DAP_STATIC_INLINE uint64_t dap_page_rounddown(uint64_t a) {
return a & ( ~(dap_pagesize() - 1) );
}
+typedef union dap_error_str {
+ const char s[LAST_ERROR_MAX];
+} dap_error_str_t;
+
#ifdef DAP_OS_WINDOWS
#define SIZE_64KB ( 1 << 16 )
DAP_STATIC_INLINE uint64_t dap_64k_rounddown(uint64_t a) {
@@ -345,7 +370,7 @@ DAP_STATIC_INLINE void *_dap_aligned_alloc( uintptr_t alignment, uintptr_t size
DAP_STATIC_INLINE void *_dap_aligned_realloc( uintptr_t alignment, void *bptr, uintptr_t size )
{
- uintptr_t ptr = (uintptr_t) DAP_REALLOC( bptr, size + (alignment * 2) + sizeof(void *) );
+ uintptr_t ptr = (uintptr_t) DAP_REALLOC((uint8_t*)bptr, size + (alignment * 2) + sizeof(void *) );
if ( !ptr )
return (void *)ptr;
@@ -865,8 +890,8 @@ DAP_INLINE uint64_t dap_hex_to_uint(const char *arr, short size) {
extern char *g_sys_dir_path;
//int dap_common_init( const char * a_log_file );
-int dap_common_init( const char *console_title, const char *a_log_file, const char *a_log_dirpath );
-int wdap_common_init( const char *console_title, const wchar_t *a_wlog_file);
+int dap_common_init( const char *console_title, const char *a_log_file );
+int wdap_common_init( const char *console_title, const wchar_t *a_wlog_file );
typedef enum
{
@@ -1003,9 +1028,12 @@ void *l_ptr;
#define dump_it(v,s,l)
#endif
-char *dap_strerror(long long err);
+dap_error_str_t dap_strerror_(long long err);
+#define dap_strerror(e) dap_strerror_(e).s
+
#ifdef DAP_OS_WINDOWS
-char *dap_str_ntstatus(DWORD err);
+dap_error_str_t dap_str_ntstatus_(DWORD err);
+#define dap_str_ntstatus(e) dap_str_ntstatus_(e).s
#endif
void dap_log_level_set(enum dap_log_level ll);
enum dap_log_level dap_log_level_get(void);
@@ -1014,7 +1042,12 @@ void dap_set_log_tag_width(size_t width);
const char * dap_get_appname();
void dap_set_appname(const char * a_appname);
-char *dap_itoa(long long i);
+#define INT_DIGITS 19 /* enough for 64 bit integer */
+typedef union dap_maxint_str {
+ const char s[INT_DIGITS + 2];
+} dap_maxint_str_t;
+dap_maxint_str_t dap_itoa_(long long i);
+#define dap_itoa(i) (char*)dap_itoa_(i).s
unsigned dap_gettid();
@@ -1039,7 +1072,7 @@ void dap_interval_timer_deinit();
static inline void *dap_mempcpy(void *a_dest, const void *a_src, size_t n)
{
- return ((byte_t *)memcpy(a_dest, a_src, n)) + n;
+ return n ? (byte_t*)memcpy(a_dest, a_src, n) + n : a_dest;
}
DAP_STATIC_INLINE int dap_is_letter(char c) { return dap_ascii_isalpha(c); }
@@ -1106,18 +1139,21 @@ int exec_silent(const char *a_cmd);
DAP_STATIC_INLINE int dap_stream_node_addr_from_str(dap_stream_node_addr_t *a_addr, const char *a_addr_str)
{
- if (!a_addr || !a_addr_str){
- return -1;
- }
- if (sscanf(a_addr_str, NODE_ADDR_FP_STR, NODE_ADDR_FPS_ARGS(a_addr)) == 4)
- return 0;
- if (sscanf(a_addr_str, "0x%016" DAP_UINT64_FORMAT_x, &a_addr->uint64) == 1)
- return 0;
- return -1;
+ if (!a_addr || !a_addr_str)
+ return -2;
+ return sscanf(a_addr_str, NODE_ADDR_FP_STR, NODE_ADDR_FPS_ARGS(a_addr)) == 4
+ || sscanf(a_addr_str, "0x%016" DAP_UINT64_FORMAT_x, (uint64_t*)a_addr) == 1
+ || sscanf(a_addr_str, "0x%016" DAP_UINT64_FORMAT_X, (uint64_t*)a_addr) == 1
+ ? 0 : -1;
}
DAP_STATIC_INLINE bool dap_stream_node_addr_is_blank(dap_stream_node_addr_t *a_addr) { return !a_addr->uint64; }
-const char *dap_stream_node_addr_to_str_static(dap_stream_node_addr_t a_address);
+#define DAP_NODE_ADDR_LEN 23
+typedef union dap_node_addr_str {
+ const char s[DAP_NODE_ADDR_LEN];
+} dap_node_addr_str_t;
+dap_node_addr_str_t dap_stream_node_addr_to_str_static_(dap_stream_node_addr_t a_address);
+#define dap_stream_node_addr_to_str_static(a) dap_stream_node_addr_to_str_static_(a).s
void dap_common_enable_cleaner_log(size_t a_timeout, size_t a_max_size);
diff --git a/core/include/dap_config.h b/core/include/dap_config.h
index 2e60bdf465a98dd77454962ff6cb6cd6c95e2f55..b42d960e46a4d3a6e1a0db132a3d9dac425b0d60 100644
--- a/core/include/dap_config.h
+++ b/core/include/dap_config.h
@@ -46,7 +46,7 @@ const char *dap_config_get_item_str_default(dap_config_t *a_config, const char *
char *dap_config_get_item_str_path_default(dap_config_t *a_config, const char *a_section, const char *a_item_name, const char *a_default);
const char** dap_config_get_array_str(dap_config_t *a_config, const char *a_section, const char *a_item_name, uint16_t *array_length);
char **dap_config_get_item_str_path_array(dap_config_t *a_config, const char *a_section, const char *a_item_name, uint16_t *array_length);
-void dap_config_get_item_str_path_array_free(char **paths_array, uint16_t *array_length);
+void dap_config_get_item_str_path_array_free(char **paths_array, uint16_t array_length);
double dap_config_get_item_double_default(dap_config_t *a_config, const char *a_section, const char *a_item_name, double a_default);
int dap_config_stream_addrs_parse(dap_config_t *a_cfg, const char *a_config, const char *a_section, dap_stream_node_addr_t **a_addrs, uint16_t *a_addrs_count);
diff --git a/core/include/dap_file_utils.h b/core/include/dap_file_utils.h
index 237815d51b697c4de28e7d7ea6346b3454421e28..965803002e10017b584f28c975ca1b6a5c39aa5d 100755
--- a/core/include/dap_file_utils.h
+++ b/core/include/dap_file_utils.h
@@ -129,8 +129,8 @@ void dap_subs_free(dap_list_name_directories_t *subs_list);
/*
* Reads an entire file into allocated memory, with error checking.
*/
-bool dap_file_get_contents(const char *filename, char **contents, size_t *length);
-
+//bool dap_file_get_contents(const char *filename, char **contents, size_t *length);
+char *dap_file_get_contents2(const char *filename, size_t *length);
/*
* Creates a path from a series of elements using @separator as the
* separator between elements. At the boundary between two elements,
@@ -169,6 +169,7 @@ char *dap_build_filename (const char *first_element, ...);
*/
char* dap_canonicalize_filename(const char *filename, const char *relative_to);
+char* dap_canonicalize_path(const char *a_filename, const char *a_path);
/*
* Gets the current directory
* Returns: (type filename) (transfer full): the current directory
diff --git a/core/include/dap_math_ops.h b/core/include/dap_math_ops.h
index 9ff44cd5ef9e95264aa9bf737bc29851ef23b019..af8397bb000ad0ae804c055fc2360129ab1155a8 100755
--- a/core/include/dap_math_ops.h
+++ b/core/include/dap_math_ops.h
@@ -470,7 +470,7 @@ static inline int SUM_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t*
overflow_flag=SUM_128_128(carry_in_128,a_256_bit.hi,&intermediate_value);
overflow_flag_intermediate=SUM_128_128(intermediate_value,b_256_bit.hi,&intermediate_value);
c_256_bit->hi = intermediate_value;
- overflow_flag=overflow_flag||overflow_flag_intermediate;
+ overflow_flag |= overflow_flag_intermediate;
#else
uint256_t tmp = uint256_0;
overflow_flag=SUM_128_128(a_256_bit.lo,b_256_bit.lo,&tmp.lo);
@@ -484,7 +484,7 @@ static inline int SUM_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t*
overflow_flag_bis=SUM_128_128(intermediate_value,b_256_bit.hi,&tmp.hi);
c_256_bit->hi = tmp.hi;
c_256_bit->lo = tmp.lo;
- overflow_flag=overflow_flag||overflow_flag_bis;
+ overflow_flag |= overflow_flag_bis;
#endif
return overflow_flag;
}
diff --git a/core/include/dap_tsd.h b/core/include/dap_tsd.h
index 5b972f814477ad9e613d358a5e3c251e5cf97630..304f38fa3a1924451ebd6c6fe8ce4969242b6633 100644
--- a/core/include/dap_tsd.h
+++ b/core/include/dap_tsd.h
@@ -40,7 +40,7 @@ dap_list_t *dap_tsd_find_all(byte_t *a_data, size_t a_data_size, uint16_t a_type
#define dap_tsd_get_object(a,typeconv) ( a->size >= sizeof(typeconv) ? ((typeconv*) a->data) : (typeconv *) {0})
#define _dap_tsd_get_scalar(tsd,dest) ({ tsd->size >= sizeof(*dest) ? memcpy(dest, tsd->data, sizeof(*dest)) : NULL; *dest; })
-#define _dap_tsd_get_object(tsd,desttype) ( tsd->size >= sizeof(desttype) ? DAP_CAST_PTR(desttype,tsd->data) : DAP_CAST_PTR(desttype, NULL) )
+#define _dap_tsd_get_object(tsd,desttype) ( tsd->size >= sizeof(desttype) ? (desttype*)tsd->data : NULL )
#define DAP_TSD_CORRUPTED_STRING "<CORRUPTED STRING>"
// NULL-terminated string
diff --git a/core/src/dap_common.c b/core/src/dap_common.c
index 8b8401ca623a46935c883ad5c346d6d530fed892..b1cd1d83c354b9fd7c79fa0c9fd8c5822d183aee 100755
--- a/core/src/dap_common.c
+++ b/core/src/dap_common.c
@@ -50,8 +50,6 @@
#define DAP_LOG_USE_SPINLOCK 0
#define DAP_LOG_HISTORY 1
-#define LAST_ERROR_MAX 255
-
#define LOG_TAG "dap_common"
typedef void (*print_callback) (unsigned a_off, const char *a_fmt, va_list va);
@@ -77,10 +75,11 @@ const uint256_t uint256_max = {.hi = uint128_max, .lo = uint128_max};
const uint512_t uint512_0 = {};
-const char *c_error_memory_alloc = "Memory allocation error";
-const char *c_error_sanity_check = "Sanity check error";
+const char *c_error_memory_alloc = "Memory allocation error",
+ *c_error_sanity_check = "Sanity check error",
+ doof = 0;
-static const char *s_log_level_tag[ 16 ] = {
+static const char *s_log_level_tag[ ] = {
" [DBG] ", // L_DEBUG = 0
" [INF] ", // L_INFO = 1,
" [ * ] ", // L_NOTICE = 2,
@@ -103,7 +102,7 @@ static const char *s_log_level_tag[ 16 ] = {
#endif
};
-const char *s_ansi_seq_color[ 16 ] = {
+const char *s_ansi_seq_color[ ] = {
"\x1b[0;37;40m", // L_DEBUG = 0
"\x1b[1;32;40m", // L_INFO = 2,
@@ -127,10 +126,10 @@ const char *s_ansi_seq_color[ 16 ] = {
#endif
};
-static unsigned int s_ansi_seq_color_len[16] = {0};
+static unsigned int s_ansi_seq_color_len[ sizeof(s_ansi_seq_color) / sizeof(char*) ] = { };
-#ifdef _WIN32
- WORD log_level_colors[ 16 ] = {
+#ifdef DAP_OS_WINDOWS
+ WORD log_level_colors[ ] = {
7, // L_DEBUG
10, // L_INFO
2, // L_NOTICE
@@ -153,9 +152,7 @@ static unsigned int s_ansi_seq_color_len[16] = {0};
static volatile bool s_log_term_signal = false;
char* g_sys_dir_path = NULL;
-static char s_log_file_path[MAX_PATH] = {'\0'},
- s_log_dir_path[MAX_PATH] = {'\0'},
- s_log_tag_fmt_str[10] = {'\0'};
+static char s_log_file_path[MAX_PATH + 1], s_log_tag_fmt_str[10];
static enum dap_log_level s_dap_log_level = L_DEBUG;
static FILE *s_log_file = NULL;
@@ -168,7 +165,7 @@ static void print_it_none (unsigned a_off, const char *a_fmt, va_list va){}
static void print_it_alog (unsigned a_off, const char *a_fmt, va_list va);
#endif
-#define LOG_FORMAT_LEN 4096
+#define LOG_FORMAT_LEN 2048
#define LOG_BUF_SIZE 32768
static print_callback s_print_callback = print_it_none;
@@ -239,7 +236,7 @@ void dap_log_set_external_output(LOGGER_EXTERNAL_OUTPUT output, void *param)
}
}
-static char* s_appname = NULL;
+static char s_appname[32];
DAP_STATIC_INLINE int s_update_log_time(char *a_datetime_str) {
time_t t = time(NULL);
@@ -261,7 +258,7 @@ void dap_log_level_set( enum dap_log_level a_ll ) {
*/
const char * dap_get_appname()
{
- return s_appname?s_appname: "dap";
+ return *s_appname ? s_appname : "dap";
}
/**
@@ -271,8 +268,7 @@ const char * dap_get_appname()
*/
void dap_set_appname(const char * a_appname)
{
- s_appname = dap_strdup(a_appname);
-
+ dap_strncpy(s_appname, a_appname, sizeof(s_appname) - 1);
}
enum dap_log_level dap_log_level_get( void ) {
@@ -299,19 +295,11 @@ void dap_set_log_tag_width(size_t a_width) {
* @param int a_count - count deleted args
* @param void* a_to_delete
*/
-void dap_delete_multy(int a_count, ...)
+void dap_delete_multy(size_t a_count, ...)
{
- if (a_count <= 0) {
- log_it(L_ERROR, "Wrong count in DAP_DELETE macros, maybe many args?");
- return;
- }
va_list l_args_list;
va_start(l_args_list, a_count);
- while (a_count > 0) {
- void *l_to_delete = va_arg(l_args_list, void*);
- DAP_DEL_Z(l_to_delete);
- a_count--;
- }
+ for ( void *l_cur; a_count-- && (( l_cur = va_arg(l_args_list, void*) ), 1); DAP_DELETE(l_cur) );
va_end(l_args_list);
}
@@ -322,27 +310,31 @@ void dap_delete_multy(int a_count, ...)
* @param a_count - args count, should be even
* @return pointer if pass, else NULL
*/
-uint8_t *dap_serialize_multy(uint8_t *a_data, uint64_t a_size, int a_count, ...)
+uint8_t *dap_serialize_multy(uint8_t *a_data, uint64_t a_size, ...)
{
- dap_return_val_if_pass(!a_size || a_count % 2, NULL);
-
- uint8_t *l_ret = a_data;
- // allocate memory, if need
- if (!l_ret)
- DAP_NEW_Z_SIZE_RET_VAL(l_ret, uint8_t, a_size, NULL, NULL);
- uint64_t l_shift_mem = 0;
+ dap_return_val_if_pass( !a_size, NULL );
+ uint8_t *l_ret = a_data ? a_data : DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, a_size, NULL),
+ *l_pos = l_ret,
+ *l_end = l_pos + a_size;
+ uint64_t l_size = 0;
va_list l_args;
- va_start(l_args, a_count);
- for (int i = 0; i < a_count / 2; ++i) {
- uint8_t *l_arg = va_arg(l_args, uint8_t *);
- uint64_t l_size = va_arg(l_args, uint64_t);
- memcpy(l_ret + l_shift_mem, l_arg, l_size);
- l_shift_mem += l_size;
- }
- if (l_shift_mem != a_size) {
- log_it(L_WARNING, "Error size in the object serialize. %"DAP_UINT64_FORMAT_U" != %"DAP_UINT64_FORMAT_U"", l_shift_mem, a_size);
+ va_start(l_args, a_size);
+ for (uint8_t *l_arg; ( l_arg = va_arg(l_args, uint8_t*) ) != DOOF_PTR; ) {
+ l_size = va_arg(l_args, uint64_t);
+ if (!l_arg || !l_size)
+ continue;
+ else if (l_pos + l_size > l_end)
+ break;
+ l_pos = dap_mempcpy(l_pos, l_arg, l_size);
}
va_end(l_args);
+ l_size = (uint64_t)(l_pos - l_ret);
+ if ( l_size != a_size ) {
+ log_it(L_ERROR, "Serialized data size mismatch");
+ if (!a_data)
+ DAP_DELETE(l_ret);
+ l_ret = NULL;
+ }
return l_ret;
}
@@ -353,28 +345,26 @@ uint8_t *dap_serialize_multy(uint8_t *a_data, uint64_t a_size, int a_count, ...)
* @param a_count - args count, should be even, memory NOT allocating
* @return 0 if pass, other if error
*/
-int dap_deserialize_multy(const uint8_t *a_data, uint64_t a_size, int a_count, ...)
+int dap_deserialize_multy(const uint8_t *a_data, uint64_t a_size, ...)
{
- dap_return_val_if_pass(!a_size || a_count % 2, -1);
+ dap_return_val_if_pass(!a_data || !a_size, -1);
- uint64_t l_shift_mem = 0;
+ uint64_t l_size = 0, l_shift = 0;
va_list l_args;
- va_start(l_args, a_count);
- for (int i = 0; i < a_count / 2; ++i) {
- uint8_t *l_arg = va_arg(l_args, uint8_t *);
- uint64_t l_size = va_arg(l_args, uint64_t);
- if (l_shift_mem + l_size > a_size) {
- log_it(L_ERROR, "Error size in the object deserialize. %"DAP_UINT64_FORMAT_U" > %"DAP_UINT64_FORMAT_U"", l_shift_mem + l_size, a_size);
+ va_start(l_args, a_size);
+ for (uint8_t *l_arg; ( l_arg = va_arg(l_args, uint8_t*) ) != DOOF_PTR; ) {
+ l_size = va_arg(l_args, uint64_t);
+ if (l_shift + l_size > a_size) {
+ log_it(L_ERROR, "Objects sizes exeed total buffer size: %"DAP_UINT64_FORMAT_U" > %"DAP_UINT64_FORMAT_U"", l_shift + l_size, a_size);
va_end(l_args);
return -2;
}
- memcpy(l_arg, a_data + l_shift_mem, l_size);
- l_shift_mem += l_size;
- }
- if (l_shift_mem != a_size) {
- log_it(L_WARNING, "Error size in the object deserialize. %"DAP_UINT64_FORMAT_U" != %"DAP_UINT64_FORMAT_U"", l_shift_mem, a_size);
+ memcpy(l_arg, a_data + l_shift, l_size);
+ l_shift += l_size;
}
va_end(l_args);
+ if (l_shift < a_size)
+ log_it(L_WARNING, "Unprocessed %"DAP_UINT64_FORMAT_U" bytes after deserialization", a_size - l_shift);
return 0;
}
@@ -392,19 +382,16 @@ static int s_dap_log_open(const char *a_log_file_path, bool a_new) {
* @param a_log_dirpath const char *: path to log directory. Saved in s_log_dir_path variable. For example. C:\\Users\\Public\\Document\\cellframe-node\\var\\log
* @return int. (0 if succcess, -1 if error)
*/
-int dap_common_init( const char *a_console_title, const char *a_log_file_path, const char *a_log_dirpath) {
+int dap_common_init( const char UNUSED_ARG *a_console_title, const char *a_log_file_path ) {
// init randomer
srand( (unsigned int)time(NULL) );
- (void) a_console_title;
strncpy( s_log_tag_fmt_str, "[%s]\t",sizeof (s_log_tag_fmt_str));
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, false))
return -1;
- if (a_log_dirpath != s_log_dir_path)
- dap_stpcpy(s_log_dir_path, a_log_dirpath);
if (a_log_file_path != s_log_file_path)
dap_stpcpy(s_log_file_path, a_log_file_path);
}
@@ -448,7 +435,7 @@ static void print_it(unsigned a_off, const char *a_fmt, va_list va) {
va_copy(va_file, va);
s_print_callback(a_off, a_fmt, va);
if (!s_log_file) {
- if (dap_common_init(dap_get_appname(), s_log_file_path, s_log_dir_path) || !s_log_file) {
+ if ( dap_common_init(dap_get_appname(), s_log_file_path ) || !s_log_file) {
va_end(va_file);
return;
}
@@ -478,7 +465,7 @@ void _log_it(const char * func_name, int line_num, const char *a_log_tag, enum d
}
}
#endif
- static _Thread_local char s_format[LOG_FORMAT_LEN] = { '\0' };
+ char s_format[LOG_FORMAT_LEN] = { '\0' };
unsigned offset = s_ansi_seq_color_len[a_ll];
memcpy(s_format, s_ansi_seq_color[a_ll], offset);
offset += s_update_log_time(s_format + offset);
@@ -774,10 +761,10 @@ char *dap_log_get_item(time_t a_start_time, int a_limit)
* @brief log_error Error log
* @return
*/
-char *dap_strerror(long long err) {
- static _Thread_local char s_error[LAST_ERROR_MAX] = {'\0'};
+dap_error_str_t dap_strerror_(long long err) {
+ dap_error_str_t l_ret = { };
+ char *s_error = (char*)&l_ret;
#ifdef DAP_OS_WINDOWS
- *s_error = '\0';
DWORD l_len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK,
NULL, err, MAKELANGID (LANG_ENGLISH, SUBLANG_DEFAULT), s_error, LAST_ERROR_MAX, NULL);
if (l_len)
@@ -787,52 +774,50 @@ char *dap_strerror(long long err) {
if ( strerror_r(err, s_error, LAST_ERROR_MAX) )
#endif
snprintf(s_error, LAST_ERROR_MAX, "Unknown error code %lld", err);
- return s_error;
+ return l_ret;
}
#ifdef DAP_OS_WINDOWS
-char *dap_str_ntstatus(DWORD err) {
- static _Thread_local char s_nterror[LAST_ERROR_MAX] = {'\0'};
+dap_error_str_t dap_str_ntstatus_(DWORD err) {
+ dap_error_str_t l_ret = { };
+ char *s_nterror = (char*)&l_ret;
HMODULE ntdll = GetModuleHandle("ntdll.dll");
if (!ntdll)
- return log_it(L_CRITICAL, "NtDll error \"%s\"", dap_strerror(GetLastError())), s_nterror;
- *s_nterror = '\0';
+ return log_it(L_CRITICAL, "NtDll error \"%s\"", dap_strerror(GetLastError())), l_ret;
DWORD l_len = FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK,
ntdll, err, MAKELANGID (LANG_ENGLISH, SUBLANG_DEFAULT), s_nterror, LAST_ERROR_MAX, NULL);
return ( l_len
? *(s_nterror + l_len - 1) = '\0'
- : snprintf(s_nterror, LAST_ERROR_MAX, "Unknown error code %lld", err) ), s_nterror;
+ : snprintf(s_nterror, LAST_ERROR_MAX, "Unknown error code %lld", err) ), l_ret;
}
#endif
#if 1
-#define INT_DIGITS 19 /* enough for 64 bit integer */
/**
* @brief itoa The function converts an integer num to a string equivalent and places the result in a string
* @param[in] i number
* @return
*/
-char *dap_itoa(long long i)
+dap_maxint_str_t dap_itoa_(long long i)
{
/* Room for INT_DIGITS digits, - and '\0' */
- static _Thread_local char buf[INT_DIGITS + 2];
- char *p = buf + INT_DIGITS + 1; /* points to terminating '\0' */
+ char buf[INT_DIGITS + 2], *p = buf + INT_DIGITS + 1; /* points to terminating '\0' */
if (i >= 0) {
do {
*--p = '0' + (i % 10);
i /= 10;
} while (i != 0);
- return p;
- }
- else { /* i < 0 */
+ } else { /* i < 0 */
do {
*--p = '0' - (i % 10);
i /= 10;
} while (i != 0);
*--p = '-';
}
- return p;
+ dap_maxint_str_t l_ret = { };
+ memcpy(&l_ret, p, (size_t)(buf + sizeof(buf) - p - 1));
+ return l_ret;
}
#endif
@@ -989,8 +974,7 @@ static const char l_possible_chars[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop
*/
void dap_random_string_fill(char *str, size_t length) {
for(size_t i = 0; i < length; i++)
- str[i] = l_possible_chars[
- rand() % (sizeof(l_possible_chars) - 1)];
+ str[i] = l_possible_chars[rand() % (sizeof(l_possible_chars) - 1)];
}
/**
@@ -1563,11 +1547,13 @@ void dap_common_enable_cleaner_log(size_t a_timeout, size_t a_max_size){
#ifdef __cplusplus
extern "C" {
#endif
-const char *dap_stream_node_addr_to_str_static(dap_stream_node_addr_t a_address)
+
+
+dap_node_addr_str_t dap_stream_node_addr_to_str_static_(dap_stream_node_addr_t a_address)
{
- static _Thread_local char s_buf[23] = { '\0' };
- snprintf(s_buf, sizeof(s_buf), NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(a_address));
- return s_buf;
+ dap_node_addr_str_t l_ret = { };
+ snprintf((char*)&l_ret, sizeof(l_ret), NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(a_address));
+ return l_ret;
}
#ifdef __cplusplus
}
diff --git a/core/src/dap_config.c b/core/src/dap_config.c
index 08ea8c1ded7ddb80bcabb8b5f2e8b9c3851118c7..d3848f3622449e606ee40f065b2e4b373b5c4f3e 100644
--- a/core/src/dap_config.c
+++ b/core/src/dap_config.c
@@ -295,7 +295,7 @@ dap_config_t *dap_config_open(const char* a_file_path) {
return NULL;
}
log_it(L_DEBUG, "Looking for config name %s...", a_file_path);
- char l_path[MAX_PATH] = { '\0' };
+ char l_path[MAX_PATH + 1] = "";
int l_pos = dap_strncmp(a_file_path, s_configs_path, strlen(s_configs_path) - 4)
? snprintf(l_path, MAX_PATH, "%s/%s.cfg", s_configs_path, a_file_path)
: snprintf(l_path, MAX_PATH, "%s.cfg", a_file_path);
@@ -445,10 +445,12 @@ const char *dap_config_get_item_str_default(dap_config_t *a_config, const char *
return l_item->val.val_str;
case DAP_CONFIG_ITEM_ARRAY:
return *l_item->val.val_arr;
- case DAP_CONFIG_ITEM_DECIMAL:
- return dap_itoa(l_item->val.val_int);
case DAP_CONFIG_ITEM_BOOL:
return l_item->val.val_bool ? "true" : "false";
+ case DAP_CONFIG_ITEM_DECIMAL: {
+ static _Thread_local char s_ret[sizeof(dap_maxint_str_t)];
+ return (const char*)memcpy(s_ret, dap_itoa(l_item->val.val_int), sizeof(dap_maxint_str_t));
+ }
default:
log_it(L_ERROR, "Parameter \"%s\" '%c' is not string", l_item->name, l_item->type);
return a_default;
@@ -456,14 +458,12 @@ const char *dap_config_get_item_str_default(dap_config_t *a_config, const char *
}
char *dap_config_get_item_str_path_default(dap_config_t *a_config, const char *a_section, const char *a_item_name, const char *a_default) {
- dap_config_item_t *l_item = dap_config_get_item(a_config, a_section, a_item_name);
- if (!l_item)
+ const char *l_val = dap_config_get_item_str(a_config, a_section, a_item_name);
+ if (!l_val)
return dap_strdup(a_default);
- if (l_item->type != DAP_CONFIG_ITEM_STRING) {
- log_it(L_ERROR, "Parameter \"%s\" '%c' is not string", l_item->name, l_item->type);
- return dap_strdup(a_default);
- }
- char *l_dir = dap_path_get_dirname(a_config->path), *l_ret = dap_canonicalize_filename(l_item->val.val_str, l_dir);
+ if ( dap_path_is_absolute(l_val) )
+ return dap_strdup(l_val);
+ char *l_dir = dap_path_get_dirname(a_config->path), *l_ret = dap_canonicalize_path(l_val, l_dir);
//log_it(L_DEBUG, "Config-path item: %s: composed from %s and %s", l_ret, l_item->val.val_str, l_dir);
return DAP_DELETE(l_dir), l_ret;
}
@@ -478,7 +478,7 @@ const char **dap_config_get_array_str(dap_config_t *a_config, const char *a_sect
log_it(L_WARNING, "Parameter \"%s\" '%c' is not array", l_item->name, l_item->type);
if (array_length)
*array_length = 1;
- static _Thread_local const char* s_ret = NULL;
+ static _Thread_local const char* s_ret;
return s_ret = dap_config_get_item_str(a_config, a_section, a_item_name), &s_ret;
}
if (array_length)
@@ -487,25 +487,21 @@ const char **dap_config_get_array_str(dap_config_t *a_config, const char *a_sect
}
char **dap_config_get_item_str_path_array(dap_config_t *a_config, const char *a_section, const char *a_item_name, uint16_t *array_length) {
- if (!array_length)
+ if ( !array_length )
return NULL;
- const char ** conf_relative = dap_config_get_array_str(a_config, a_section, a_item_name, array_length);
- char ** addrs_relative = DAP_NEW_Z_COUNT(char*, *array_length);
- for (int i = 0; i < *array_length; ++i)
- {
- char * l_cfgpath = dap_path_get_dirname(a_config->path);
- addrs_relative[i] = dap_canonicalize_filename(conf_relative[i], l_cfgpath);
- DAP_DELETE(l_cfgpath);
+ const char **l_paths_cfg = dap_config_get_array_str(a_config, a_section, a_item_name, array_length);
+ if ( !l_paths_cfg || !*array_length )
+ return NULL;
+ char *l_cfg_path = dap_path_get_dirname(a_config->path), **l_paths = DAP_NEW_Z_COUNT(char*, *array_length);
+ for (int i = 0; i < *array_length; ++i) {
+ l_paths[i] = dap_path_is_absolute(l_paths_cfg[i]) ? dap_strdup(l_paths_cfg[i]) : dap_canonicalize_path(l_paths_cfg[i], l_cfg_path);
}
- return addrs_relative;
+ return DAP_DELETE(l_cfg_path), l_paths;
}
-void dap_config_get_item_str_path_array_free(char **paths_array, uint16_t *array_length) {
- if (!array_length)
- return;
- for (int i = 0; i < *array_length; ++i)
- DAP_DEL_Z(paths_array[i]);
- DAP_DEL_Z(paths_array);
+void dap_config_get_item_str_path_array_free(char **paths_array, uint16_t array_length) {
+ DAP_DEL_ARRAY(paths_array, array_length);
+ DAP_DELETE(paths_array);
}
double dap_config_get_item_double_default(dap_config_t *a_config, const char *a_section, const char *a_item_name, double a_default) {
@@ -547,7 +543,7 @@ int dap_config_stream_addrs_parse(dap_config_t *a_cfg, const char *a_config, con
const char **l_nodes_addrs = dap_config_get_array_str(a_cfg, a_config, a_section, a_addrs_count);
if (*a_addrs_count) {
log_it(L_DEBUG, "Start parse stream addrs in cofnig %s section %s", a_config, a_section);
- DAP_NEW_Z_COUNT_RET_VAL(*a_addrs, dap_stream_node_addr_t, *a_addrs_count, -2, NULL);
+ *a_addrs = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_stream_node_addr_t, *a_addrs_count, -2);
for (uint16_t i = 0; i < *a_addrs_count; ++i) {
if (dap_stream_node_addr_from_str(*a_addrs + i, l_nodes_addrs[i])) {
log_it(L_ERROR, "Incorrect format of %s address \"%s\", fix net config and restart node", a_section, l_nodes_addrs[i]);
diff --git a/core/src/dap_file_utils.c b/core/src/dap_file_utils.c
index c7085846fce8ac4809e3fd387c631caeaa236c11..4f5641f113fa8b30808734261d081f65b6a02cbb 100755
--- a/core/src/dap_file_utils.c
+++ b/core/src/dap_file_utils.c
@@ -46,6 +46,7 @@
#ifdef DAP_OS_WINDOWS
#include <windows.h>
#include <io.h>
+#define realpath(abs_path, rel_path) _fullpath((rel_path), (abs_path), PATH_MAX)
#endif
#include "dap_common.h"
@@ -166,14 +167,12 @@ bool dap_dir_test(const char * a_dir_path)
int dap_mkdir_with_parents(const char *a_dir_path)
{
// validation of a pointer
- if(a_dir_path == NULL || a_dir_path[0] == '\0') {
+ if (!a_dir_path || !*a_dir_path) {
errno = EINVAL;
return -1;
}
- char path[strlen(a_dir_path) + 1];
- memset(path, '\0', strlen(a_dir_path) + 1);
- memcpy(path, a_dir_path, strlen(a_dir_path));
- char *p;
+ char path[strlen(a_dir_path) + 1], *p;
+ dap_strncpy(path, a_dir_path, sizeof(path) - 1);
// skip the root component if it is present, i.e. the "/" in Unix or "C:\" in Windows
#ifdef DAP_OS_WINDOWS
if(((path[0] >= 'a' && path[0] <= 'z') || (path[0] >= 'A' && path[0] <= 'Z'))
@@ -299,19 +298,12 @@ char* dap_path_get_basename(const char *a_file_name)
*/
bool dap_path_is_absolute(const char *a_file_name)
{
- dap_return_val_if_fail(a_file_name != NULL, false);
-
- if(DAP_IS_DIR_SEPARATOR(a_file_name[0]))
- return true;
-
#ifdef DAP_OS_WINDOWS
- // Recognize drive letter on native Windows
- if (dap_ascii_isalpha(a_file_name[0]) &&
- a_file_name[1] == ':' && DAP_IS_DIR_SEPARATOR (a_file_name[2]))
- return true;
+ return dap_strlen(a_file_name) > 2
+ && dap_ascii_isalpha(a_file_name[0]) && a_file_name[1] == ':' && DAP_IS_DIR_SEPARATOR (a_file_name[2]);
+#else
+ return a_file_name && ( DAP_IS_DIR_SEPARATOR(*a_file_name) || !dap_strncmp(a_file_name, "~/", 2) );
#endif
-
- return false;
}
/**
@@ -395,7 +387,6 @@ const char *dap_path_skip_root (const char *file_name)
*/
char* dap_path_get_dirname(const char *a_file_name)
{
- log_it(L_DEBUG,"dap_path_get_dirname(a_file_name=\"%s\")", a_file_name);
char *l_base;
size_t l_len;
@@ -464,7 +455,7 @@ char* dap_path_get_dirname(const char *a_file_name)
{
l_len = (uint32_t) strlen (a_file_name) + 1;
l_base = DAP_NEW_SIZE (char, l_len + 1);
- strcpy (l_base, a_file_name);
+ strncpy (l_base, a_file_name, l_len - 1);
l_base[l_len-1] = DAP_DIR_SEPARATOR;
l_base[l_len] = 0;
return l_base;
@@ -484,7 +475,6 @@ char* dap_path_get_dirname(const char *a_file_name)
l_base = DAP_NEW_SIZE(char, l_len + 1);
memcpy(l_base, a_file_name, l_len);
l_base[l_len] = 0;
- log_it(L_DEBUG,"l_base=%s",l_base);
return l_base;
}
@@ -571,6 +561,7 @@ const char* dap_path_get_ext(const char *a_filename)
return NULL ;
}
+#if 0
static bool get_contents_stdio(const char *filename, FILE *f, char **contents, size_t *length)
{
char buf[4096];
@@ -767,7 +758,46 @@ bool dap_file_get_contents(const char *filename, char **contents, size_t *length
return dap_get_contents_posix(filename, contents, length);
#endif
}
+#endif
+char *dap_file_get_contents2(const char *a_filename, size_t *length)
+{
+ dap_return_val_if_fail(length, NULL);
+ if ( !dap_file_test(a_filename) )
+ return log_it(L_ERROR, "File \"%s\" not found", a_filename), NULL;
+ int l_err = 0;
+ FILE *f = fopen(a_filename, "rb");
+ if (!f) {
+#ifdef DAP_OS_WINDOWS
+ l_err = GetLastError();
+#else
+ l_err = errno;
+#endif
+ return log_it(L_ERROR, "Can't open file \"%s\", error %d: %s", a_filename, l_err, dap_strerror(l_err)), NULL;
+ }
+ off_t l_size = fseeko(f, 0, SEEK_END) ? ftello(f) : -1;
+ char *l_buffer = NULL;
+ if (l_size <= 0) {
+ log_it(L_ERROR, "Can't get file %s size or file is empty", a_filename);
+ l_err = -3;
+ } else if (!( l_buffer = DAP_NEW_Z_SIZE(char, l_size)) ) {
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+ l_err = -4;
+ } else {
+ rewind(f);
+ if ( fread(l_buffer, 1, l_size, f) < (size_t)l_size ) {
+ log_it(L_ERROR, "Can't read full file %s", a_filename);
+ l_err = -5;
+ }
+ }
+ fclose(f);
+ if (l_err) {
+ DAP_DEL_Z(l_buffer);
+ *length = 0;
+ } else
+ *length = l_size;
+ return l_err ? ( DAP_DELETE(l_buffer), NULL ) : l_buffer;
+}
@@ -1124,8 +1154,118 @@ char* dap_build_filename(const char *first_element, ...)
* Returns: (type filename) (transfer full): a newly allocated string with the
* canonical file path
*/
+char* dap_canonicalize_path(const char *a_filename, const char *a_path) {
+ if (!a_path)
+ a_path = "";
+ if (!a_filename)
+ a_filename = "";
+ char *path = dap_strdup_printf("%s/%s", a_path, a_filename);
+ size_t i = 0, j = 0, k = 0;
+
+ //Replace backslashes with forward slashes
+ while (path[i] != '\0') {
+ //Forward slash or backslash separator found?
+ if (path[i] == '/' || path[i] == '\\') {
+ path[k++] = '/';
+ while (path[i] == '/' || path[i] == '\\')
+ i++;
+ } else
+ path[k++] = path[i++];
+ }
+ path[k] = '\0';
+
+ i = j = k = 0;
+
+ do {
+ //Forward slash separator found
+ if ( path[i] == '/' || path[i] == '\0' ) {
+ //"." element found?
+ if ( (i - j) == 1 && path[j] == '.' ) {
+ //Check whether the pathname is empty
+ if (!k) {
+ if (path[i] == '\0')
+ path[k++] = '.';
+ else if (path[i] == '/' && path[i + 1] == '\0') {
+ strcpy(path + k, "./");
+ k += 2;
+ }
+ } else if (k > 1) {
+ //Remove the final slash if necessary
+ if ( path[i] == '\0' )
+ k--;
+ }
+ }
+ //".." element found?
+ else if ( (i - j) == 2 && !strncmp(path + j, "..", 2) ) {
+ //Check whether the pathname is empty
+ if (!k) {
+ strcpy(path + k, "..");
+ k += 2;
+ //Append a slash if necessary
+ if (path[i] == '/')
+ path[k++] = '/';
+ } else if (k > 1) {
+ //Search the path for the previous slash
+ for (j = 1; j < k; ++j) {
+ if ( path[k - j - 1] == '/' )
+ break;
+ }
+ //Slash separator found?
+ if (j < k) {
+ if (!strncmp(path + k - j, "..", 2)) {
+ strcpy(path + k, "..");
+ k += 2;
+ } else
+ k -= (j + 1);
+
+ //Append a slash if necessary
+ if ((k == 0 && path[0] == '/') || path[i] == '/')
+ path[k++] = '/';
+ } else { //No slash separator found?
+ if (k == 3 && !strncmp (path, "..", 2)) {
+ strcpy(path + k, "..");
+ k += 2;
+ //Append a slash if necessary
+ if (path[i] == '/')
+ path[k++] = '/';
+ } else if (path[i] == '\0') {
+ *path = '.';
+ k = 1;
+ } else if (path[i] == '/' && path[i + 1] == '\0') {
+ strcpy(path + k, "./");
+ k = 2;
+ } else
+ k = 0;
+ }
+ }
+ } else {
+ //Copy directory name
+ memmove (path + k, path + j, i - j);
+ //Advance write pointer
+ k += i - j;
+
+ //Append a slash if necessary
+ if (path[i] == '/')
+ path[k++] = '/';
+ }
+
+ //Move to the next token
+ while (path[i] == '/')
+ i++;
+ j = i;
+ } else if (!k)
+ for ( ; path[i] == '.' || path[i] == '/'; ++i, ++j);
+ } while (path[i++] != '\0');
+ path[k] = '\0';
+ return path;
+}
+
char* dap_canonicalize_filename(const char *filename, const char *relative_to)
{
+ char buf[MAX_PATH + 1];
+ snprintf(buf, sizeof(buf), "%s/%s", relative_to, filename);
+ return realpath(buf, NULL);
+#if 0
char *canon, *input, *output, *after_root, *output_start;
dap_return_val_if_fail(relative_to == NULL || dap_path_is_absolute (relative_to), NULL);
@@ -1238,6 +1378,7 @@ char* dap_canonicalize_filename(const char *filename, const char *relative_to)
*output = '\0';
return canon;
+#endif
}
@@ -1598,9 +1739,9 @@ static bool s_tar_file_add(int a_outfile, const char *a_fname, const char *a_fpa
union tar_buffer l_buffer;
if(!a_outfile)
return false;
- char *l_filebuf = NULL;
size_t l_filelen = 0;
- if(dap_file_get_contents(a_fpath, &l_filebuf, &l_filelen)) {
+ char *l_filebuf = dap_file_get_contents2(a_fpath, &l_filelen);
+ if(l_filebuf) {
struct stat l_stat_info;
int remaining = l_filelen; // how much is left to write
// fill header
diff --git a/core/src/dap_json_rpc_errors.c b/core/src/dap_json_rpc_errors.c
index 57d95256f265b1da0337551c45652c6297f69286..c0c9e4dc8094858ee169271277c3225f0f244b60 100644
--- a/core/src/dap_json_rpc_errors.c
+++ b/core/src/dap_json_rpc_errors.c
@@ -57,7 +57,7 @@ int dap_json_rpc_error_add(json_object* a_json_arr_reply, int a_code_error, cons
{
va_list args;
va_start(args, msg);
- const char *l_msg = dap_strdup_vprintf(msg, args);
+ char *l_msg = dap_strdup_vprintf(msg, args);
va_end(args);
if (!a_json_arr_reply || !json_object_is_type(a_json_arr_reply, json_type_array)) {
diff --git a/core/src/dap_list.c b/core/src/dap_list.c
index 50b753218d4a5331c3ce5e12002f0a4d5ad91470..223e3399108cf09ebf4c96f19763952a6a3fdd72 100755
--- a/core/src/dap_list.c
+++ b/core/src/dap_list.c
@@ -73,8 +73,7 @@ dap_list_t *dap_list_append(dap_list_t *a_list, void *a_data)
{
if(!a_data)
return a_list;
- dap_list_t *l_el = NULL;
- DAP_NEW_Z_RET_VAL(l_el, dap_list_t, a_list, NULL);
+ dap_list_t *l_el = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_list_t, a_list);
l_el->data = a_data;
return ({ DL_APPEND(a_list, l_el); a_list; });
}
@@ -105,11 +104,8 @@ dap_list_t *dap_list_append(dap_list_t *a_list, void *a_data)
*/
dap_list_t *dap_list_prepend(dap_list_t *a_list, void *a_data)
{
-// sanity check
dap_return_val_if_pass(!a_data, a_list);
-//func work
- dap_list_t *l_el = NULL;
- DAP_NEW_Z_RET_VAL(l_el, dap_list_t, a_list, NULL);
+ dap_list_t *l_el = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_list_t, a_list);
l_el->data = a_data;
return ({ DL_PREPEND(a_list, l_el); a_list; });
}
@@ -130,8 +126,7 @@ dap_list_t *dap_list_insert(dap_list_t *a_list, void* a_data, uint64_t a_positio
{
if (!a_position)
return dap_list_prepend(a_list, a_data);
- dap_list_t *l_el = NULL;
- DAP_NEW_Z_RET_VAL(l_el, dap_list_t, a_list, NULL);
+ dap_list_t *l_el = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_list_t, a_list);
dap_list_t *l_pos = dap_list_nth(a_list, a_position);
l_el->data = a_data;
return ({ DL_PREPEND_ELEM(a_list, l_pos, l_el); a_list; });
diff --git a/core/src/dap_math_convert.c b/core/src/dap_math_convert.c
index 3695ad1ed44bf33ac286f490aa857fd72d44f365..113253952995d2ab07ea892c19990e8e88d7716f 100644
--- a/core/src/dap_math_convert.c
+++ b/core/src/dap_math_convert.c
@@ -393,9 +393,8 @@ uint256_t dap_uint256_scan_decimal(const char *a_str_decimal)
return log_it(L_WARNING, "Incorrect balance format of '%s' - no precision mark", a_str_decimal),
uint256_0;
- l_pos = l_len - (l_point - l_buf); /* Check number of decimals after dot */
- l_pos--;
- if ( (l_pos ) > DATOSHI_DEGREE )
+ l_pos = l_len - (l_point - l_buf) - 1; /* Check number of decimals after dot */
+ if ( l_pos > DATOSHI_DEGREE )
return log_it(L_WARNING, "Incorrect balance format of '%s' - too much precision", l_buf), uint256_0;
/* "123.456" -> "123456" */
@@ -474,7 +473,9 @@ char *dap_uint256_decimal_to_char(uint256_t a_decimal){ //dap_chain_balance_to_c
const char *dap_uint256_decimal_to_round_char(uint256_t a_uint256, uint8_t a_round_position, bool is_round)
{
- return dap_uint256_char_to_round_char(dap_uint256_decimal_to_char(a_uint256), a_round_position, is_round);
+ char *l_uint256_str = dap_uint256_decimal_to_char(a_uint256);
+ const char *l_ret = dap_uint256_char_to_round_char(l_uint256_str, a_round_position, is_round);
+ return DAP_DELETE(l_uint256_str), l_ret;
}
const char *dap_uint256_char_to_round_char(char* a_str_decimal, uint8_t a_round_pos, bool is_round)
@@ -482,10 +483,8 @@ const char *dap_uint256_char_to_round_char(char* a_str_decimal, uint8_t a_round_
_Thread_local static char s_buf[DATOSHI_POW256 + 3];
char *l_dot_pos = strchr(a_str_decimal, '.'), *l_res = s_buf;
int l_len = strlen(a_str_decimal);
- if (!l_dot_pos || a_round_pos >= DATOSHI_DEGREE || ( l_len - (l_dot_pos - a_str_decimal) <= a_round_pos )) {
- memcpy(l_res, a_str_decimal, l_len + 1);
- return l_res;
- }
+ if (!l_dot_pos || a_round_pos >= DATOSHI_DEGREE || ( l_len - (l_dot_pos - a_str_decimal) <= a_round_pos ))
+ return memcpy(l_res, a_str_decimal, l_len + 1);
int l_new_len = (l_dot_pos - a_str_decimal) + a_round_pos + 1;
*l_res = '0';
diff --git a/core/src/dap_strfuncs.c b/core/src/dap_strfuncs.c
index b0ca9f809ef384f6cf6c98497a0576be911e13e9..0ceee9dae9b11a6a73326a31fe3e23d95a08a59e 100755
--- a/core/src/dap_strfuncs.c
+++ b/core/src/dap_strfuncs.c
@@ -43,29 +43,14 @@ bool dap_isstralnum(const char *c)
*/
char* dap_strcat2(const char* s1, const char* s2)
{
- size_t size1 = 0;
- size_t size2 = 0;
- if (!s1)
- size1 = 0;
- else
- size1 = strlen(s1);
- if (!s2)
- size2 = 0;
- else
- size2 = strlen(s2);
-
- char* result = malloc(size1 + size2 + 1);
-
- if(result == NULL)
- {
- exit(EXIT_FAILURE);
- }
-
- memcpy(result, s1, size1);
- memcpy(result+size1, s2, size2);
- free((void*)s1);
- result[size1 + size2] = '\0';
- return result;
+ size_t size1 = s1 ? strlen(s1) : 0, size2 = s2 ? strlen(s2) : 0;
+ char *l_ret = (char*)s1;
+ if (size2) {
+ l_ret = DAP_REALLOC_RET_VAL_IF_FAIL((char*)s1, size1 + size2 + 1, (char*)s1);
+ char *l_pos = (char*)dap_mempcpy(l_ret + size1, s2, size2);
+ *l_pos = '\0';
+ }
+ return l_ret;
}
@@ -200,8 +185,7 @@ int128_t dap_strtoi128(const char *p, char **endp, int base)
*/
char *dap_utoa128(char *dest, uint128_t v, int base)
{
- char buf[129];
- char *p = buf + 128;
+ char buf[129], *p = buf + 128;
const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
*p = '\0';
@@ -302,7 +286,7 @@ int dap_strncmp(const char *a_str1, const char *a_str2, size_t a_n)
char* dap_strdup(const char *a_str)
{
- return a_str ? DAP_DUP_SIZE(a_str, strlen(a_str) + 1) : NULL;
+ return a_str ? DAP_DUP_SIZE((char*)a_str, strlen(a_str) + 1) : NULL;
}
/**
@@ -718,8 +702,7 @@ char **dap_str_appv(char **a_dst, char **a_src, size_t *a_count) {
return a_dst;
}
l_count = l_count_dst + l_count_src + 1;
- char **l_res = DAP_REALLOC_COUNT(a_dst, l_count);
- char **l_src = a_src;
+ char **l_res = DAP_REALLOC_COUNT(a_dst, l_count), **l_src = a_src, **l_new;
while (l_src && l_count_src--) {
if (**l_src)
l_res[l_count_dst++] = *l_src;
@@ -730,8 +713,10 @@ char **dap_str_appv(char **a_dst, char **a_src, size_t *a_count) {
l_src++;
}
l_res[l_count_dst] = NULL;
- if (l_count > l_count_dst + 1)
- l_res = DAP_REALLOC_COUNT(l_res, l_count_dst + 1);
+ if (l_count > l_count_dst + 1) {
+ l_new = DAP_REALLOC_COUNT_RET_VAL_IF_FAIL(l_res, l_count_dst + 1, NULL, l_res);
+ l_res = l_new;
+ }
if (a_count)
*a_count = l_count_dst;
return l_res;
@@ -827,8 +812,7 @@ char* dap_strchug(char *a_string)
dap_return_val_if_fail(a_string != NULL, NULL);
- for(l_start = (unsigned char*) a_string; *l_start && dap_ascii_isspace(*l_start); l_start++)
- ;
+ for (l_start = (unsigned char*) a_string; *l_start && dap_ascii_isspace(*l_start); l_start++);
memmove(a_string, l_start, strlen((char *) l_start) + 1);
diff --git a/core/src/dap_string.c b/core/src/dap_string.c
index 21932fabef758fef8bdfb03f3d82d66b9de38f23..beb4a1588b7e18571d0a3d2cba3f8b3c4bdb22d1 100755
--- a/core/src/dap_string.c
+++ b/core/src/dap_string.c
@@ -857,7 +857,7 @@ void dap_string_append_vprintf(dap_string_t *string, const char *format, va_list
memcpy(string->str + string->len, buf, len + 1);
string->len += len;
} else {
- len = sprintf(l_buf, l_oom, __func__ );
+ len = snprintf(l_buf, sizeof(buf), l_oom, __func__ );
if ( (string->str = DAP_NEW_SIZE(char, sizeof(l_buf ))) )
memcpy(string->str, l_buf , len);
}
@@ -878,7 +878,6 @@ void dap_string_append_vprintf(dap_string_t *string, const char *format, va_list
*/
void dap_string_prepend_vprintf(dap_string_t *a_string, const char *a_format, va_list a_args)
{
- const char l_oom [] = { "Out of memory@%s!" };
char *buf, l_buf[128];
size_t len;
diff --git a/core/src/unix/dap_process_memory.c b/core/src/unix/dap_process_memory.c
index dc14f0b32c99e0b292a6d9ef393ab654750e423d..7bd6a13c17711b8ba6a7500a15458d3979603503 100755
--- a/core/src/unix/dap_process_memory.c
+++ b/core/src/unix/dap_process_memory.c
@@ -58,7 +58,7 @@ dap_process_memory_t get_proc_mem_current(void)
dap_process_memory_t get_proc_mem_by_pid(pid_t pid)
{
- char buf[126] = {0};
- sprintf(buf, "/proc/%d/status", pid);
+ char buf[64];
+ snprintf(buf, sizeof(buf), "/proc/%d/status", pid);
return _get_process_memory(buf);
}
diff --git a/core/src/unix/linux/dap_network_monitor.c b/core/src/unix/linux/dap_network_monitor.c
index ec6ddaac872d612c8399d83603d066cb5932a1d4..a52c7d32e6cd03065da82a16fb7efda7c88dd536 100755
--- a/core/src/unix/linux/dap_network_monitor.c
+++ b/core/src/unix/linux/dap_network_monitor.c
@@ -136,7 +136,7 @@ static void _ip_addr_msg_handler(struct nlmsghdr *nlh,
/* fill result */
result->addr.ip = htonl(*((uint32_t *)RTA_DATA(rth)));
- strcpy(result->addr.s_ip, inet_str);
+ strncpy(result->addr.s_ip, inet_str, MAX_IP_STR_LEN);
if_indextoname(ifa->ifa_index, result->addr.interface_name);
}
}
diff --git a/core/test/dap_common_test.c b/core/test/dap_common_test.c
index 95e581fbca99af8e8323759c21ff74c7f3595a19..c89d0f46e43a7b21430a7059a9613422640815f3 100755
--- a/core/test/dap_common_test.c
+++ b/core/test/dap_common_test.c
@@ -56,11 +56,12 @@ DAP_STATIC_INLINE void s_randombytes(unsigned char *a_array, uint64_t a_len)
static void s_test_put_int()
{
dap_print_module_name("dap_common");
- const int INT_VAL = 10;
- const char * EXPECTED_RESULT = "10";
- char * result_arr = dap_itoa(INT_VAL);
- dap_assert(strcmp(result_arr, EXPECTED_RESULT) == 0,
- "Check string result from itoa");
+
+ const long long ten = 10, minus_twenty = -20, maxv = LLONG_MAX, minv = LLONG_MIN;
+ const char ten_str[] = "10", minus_twenty_str[] = "-20", maxv_str[] = "9223372036854775807", minv_str[] = "-9223372036854775808";
+ char *res_ten = dap_itoa(ten), *res_minus_20 = dap_itoa(minus_twenty), *res_maxv = dap_itoa(maxv), *res_minv = dap_itoa(minv);
+ dap_assert(!strcmp(res_ten, ten_str) && !strcmp(minus_twenty_str, res_minus_20)
+ && !strcmp(maxv_str, res_maxv) && !strcmp(minv_str, res_minv), "Check string result from itoa");
}
DAP_STATIC_INLINE void s_overflow_add_custom(void *a_array_a, void *a_array_b, uint64_t a_pos, s_data_type a_type)
@@ -1077,12 +1078,7 @@ static void s_test_overflow_diff_types_boundary_max(unsigned long long *l_a, uns
static void s_test_overflow_diff_types_boundary()
{
- unsigned long long
- *l_a = NULL,
- *l_b = NULL;
- DAP_NEW_Z_COUNT_RET(l_a, unsigned long long, 2, NULL);
- l_b = l_a + 1;
-
+ unsigned long long l_a[2], *l_b = l_a + 1;
dap_print_module_name("dap_overflow_add_diff_types_boundary_min");
*l_b = 0;
s_test_overflow_diff_types_boundary_min(l_a, l_b);
@@ -1180,38 +1176,27 @@ static void s_test_overflow_diff_types_boundary()
(*(signed char *)l_b) = dap_maxval((signed char)0);
s_test_overflow_diff_types_boundary_max(l_a, l_b);
dap_assert(true, "b = max");
-
- DAP_DELETE(l_a);
}
static void s_test_overflow_diff_types_rand(uint64_t a_times)
{
dap_print_module_name("dap_overflow_add_diff_types_rand");
- unsigned long long
- *l_a = NULL,
- *l_b = NULL;
- DAP_NEW_Z_COUNT_RET(l_a, unsigned long long, 2, NULL);
- l_b = l_a + 1;
+ unsigned long long l_a[2], *l_b = l_a + 1;
for (uint64_t i = 0; i < a_times; ++i) {
- s_randombytes((unsigned char *)l_a, sizeof(l_a) * 2);
+ s_randombytes((unsigned char*)l_a, sizeof(l_a) * 2);
s_test_overflow_diff_types(l_a, l_b);
}
char l_msg[100];
- sprintf(l_msg, "ADD SUB MUL %"DAP_UINT64_FORMAT_U" times", a_times);
+ snprintf(l_msg, sizeof(l_msg), "ADD SUB MUL %"DAP_UINT64_FORMAT_U" times", a_times);
dap_assert(true, l_msg);
- DAP_DELETE(l_a);
}
static void s_test_benchmark_overflow_one(uint64_t a_times, benchmark_callback a_custom_func, benchmark_callback a_builtin_func)
{
char l_msg[120] = {0};
int l_cur_1 = 0, l_cur_2 = 0, l_custom = 0, l_builtin = 0;
- unsigned char
- *l_chars_array_a = NULL,
- *l_chars_array_b = NULL;
- DAP_NEW_Z_SIZE_RET(l_chars_array_a, unsigned char, s_array_size, NULL);
- DAP_NEW_Z_SIZE_RET(l_chars_array_b, unsigned char, s_array_size, l_chars_array_a);
-
+ unsigned char l_chars_array_a[s_array_size + 1], l_chars_array_b[s_array_size + 1];
+ l_chars_array_a[s_array_size] = l_chars_array_b[s_array_size] = '\0';
for (s_data_type t = 0; t < TYPE_COUNT; ++t) {
// if (t == TYPE_CHAR || t == TYPE_INT || t == TYPE_LONG_LONG || t == TYPE_UCHAR || t == TYPE_ULONG_LONG) {
l_custom = 0;
@@ -1234,7 +1219,6 @@ static void s_test_benchmark_overflow_one(uint64_t a_times, benchmark_callback a
benchmark_mgs_time(l_msg, l_builtin);
// }
}
- DAP_DEL_MULTY(l_chars_array_a, l_chars_array_b);
}
static void s_test_benchmark_overflow(uint64_t a_times)
diff --git a/crypto/include/dap_cert.h b/crypto/include/dap_cert.h
index a2f7f0a7bc2005daff15a8a3b3b550cf0e443cf1..e2d12de38f89f77f00455ac9f5742ea9b458cf35 100755
--- a/crypto/include/dap_cert.h
+++ b/crypto/include/dap_cert.h
@@ -39,7 +39,7 @@ typedef enum dap_cert_metadata_type {
DAP_CERT_META_DATETIME_PERIOD,
DAP_CERT_META_SIGN,
DAP_CERT_META_CUSTOM
-} dap_cert_metadata_type_t;
+} DAP_PACKED dap_cert_metadata_type_t;
typedef struct dap_cert_metadata {
const char *key;
diff --git a/crypto/include/dap_enc_base58.h b/crypto/include/dap_enc_base58.h
index 9a497d3cf61e5f1dc93231fd2c7c8945be0ba58f..308cf89d857cae803c5bd22bcd00ceb5ef04aab9 100755
--- a/crypto/include/dap_enc_base58.h
+++ b/crypto/include/dap_enc_base58.h
@@ -48,7 +48,12 @@ DAP_INLINE char *dap_enc_base58_encode_hash_to_str(dap_chain_hash_fast_t *a_in_h
return dap_enc_base58_encode_to_str(a_in_hash->raw, sizeof(dap_chain_hash_fast_t));
}
-const char *dap_enc_base58_encode_hash_to_str_static(const dap_chain_hash_fast_t *a_in_hash);
+typedef union dap_enc_b58_hash_str {
+ const char s[ DAP_ENC_BASE58_ENCODE_SIZE(sizeof(dap_chain_hash_fast_t)) ];
+} dap_enc_b58_hash_str_t;
+
+dap_enc_b58_hash_str_t dap_enc_base58_encode_hash_to_str_static_(const dap_chain_hash_fast_t *a_in_hash);
+#define dap_enc_base58_encode_hash_to_str_static(hash) dap_enc_base58_encode_hash_to_str_static_(hash).s
// convert from "0xA21F1E865B6740A28E8708798ECF25D2C0AA596DF5EB1FD724186B6AD7FF2199" to "Bura1HFrKsqbdytEXQVrxpbovtvLhR1VbrJs65JBx3gc"
char* dap_enc_base58_from_hex_str_to_str(const char *a_in_str);
diff --git a/crypto/include/dap_enc_base64.h b/crypto/include/dap_enc_base64.h
index 84bdca0a551c25269a42e94ad2bf20e613c783b3..2c167db5f206b486ec7e626d82f38d009c92a880 100755
--- a/crypto/include/dap_enc_base64.h
+++ b/crypto/include/dap_enc_base64.h
@@ -34,7 +34,8 @@ extern "C" {
/*
* Calculates encode size from input size
*/
-#define DAP_ENC_BASE64_ENCODE_SIZE(in_size) (size_t)(((4 * in_size / 3) + 3) & ~3)
+#define DAP_ENC_BASE64_ENCODE_SIZE(in_size) (size_t)(((4 * (in_size) / 3) + 3) & ~3)
+#define DAP_ENC_BASE64_DECODE_SIZE(in_size) (size_t)((in_size) * 3 / 4)
size_t dap_enc_base64_decode(const char * in, size_t in_size, void * out, dap_enc_data_type_t standard);
size_t dap_enc_base64_encode(const void * in, size_t in_size, char * out, dap_enc_data_type_t standard);
diff --git a/crypto/include/dap_guuid.h b/crypto/include/dap_guuid.h
index 93690960620db5b93c99b06957996a98864c6b6d..44cb53e08baab7b30ceb880366e1ff55d059a871 100644
--- a/crypto/include/dap_guuid.h
+++ b/crypto/include/dap_guuid.h
@@ -33,6 +33,10 @@ typedef union dap_guuid {
uint128_t raw;
} DAP_ALIGN_PACKED dap_guuid_t;
+typedef union dap_guuid_str {
+ const char s[ 2 * sizeof(uint128_t) + 3 ];
+} dap_guuid_str_t;
+
static inline dap_guuid_t dap_guuid_new()
{
uint128_t l_ret = dap_uuid_generate_uint128();
@@ -43,5 +47,6 @@ DAP_STATIC_INLINE dap_guuid_t dap_guuid_compose(uint64_t a_net_id, uint64_t a_se
{
return (dap_guuid_t){ .net_id = a_net_id, .srv_id = a_service_id };
}
-const char *dap_guuid_to_hex_str(dap_guuid_t a_guuid);
+dap_guuid_str_t dap_guuid_to_hex_str_(dap_guuid_t a_guuid);
+#define dap_guuid_to_hex_str(guid) dap_guuid_to_hex_str_(guid).s
dap_guuid_t dap_guuid_from_hex_str(const char *a_hex_str, bool *success);
diff --git a/crypto/src/dap_cert.c b/crypto/src/dap_cert.c
index 9044414eea734c8d56c2a1514e1bacfa3199afe8..ac269286e4a826fe63ee13165a8d7a5ea13621df 100755
--- a/crypto/src/dap_cert.c
+++ b/crypto/src/dap_cert.c
@@ -80,7 +80,7 @@ int dap_cert_init() // TODO deinit too
for (uint16_t i=0; i < l_ca_folders_size; i++) {
dap_cert_add_folder(l_ca_folders[i]);
}
- dap_config_get_item_str_path_array_free(l_ca_folders, &l_ca_folders_size);
+ dap_config_get_item_str_path_array_free(l_ca_folders, l_ca_folders_size);
return 0;
}
@@ -342,7 +342,7 @@ dap_cert_t *dap_cert_find_by_name(const char *a_cert_name)
if (l_ret)
break;
}
- dap_config_get_item_str_path_array_free(l_ca_folders, &l_ca_folders_size);
+ dap_config_get_item_str_path_array_free(l_ca_folders, l_ca_folders_size);
}
}
if (!l_ret)
@@ -368,37 +368,21 @@ dap_list_t *dap_cert_get_all_mem()
*/
dap_cert_t * dap_cert_new(const char * a_name)
{
- dap_cert_t * l_ret = DAP_NEW_Z(dap_cert_t);
- if (!l_ret) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
- l_ret->_pvt = DAP_NEW_Z(dap_cert_pvt_t);
- if(!l_ret->_pvt) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
- DAP_DELETE(l_ret);
- return NULL;
- }
- snprintf(l_ret->name,sizeof(l_ret->name),"%s",a_name);
+ dap_cert_t *l_ret = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_cert_t, NULL);
+ l_ret->_pvt = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_cert_pvt_t, NULL, l_ret);
+ strncpy(l_ret->name, a_name, sizeof(l_ret->name) - 1);
return l_ret;
}
int dap_cert_add(dap_cert_t *a_cert)
{
- if (!a_cert)
- return -2;
+ dap_return_val_if_fail(a_cert, -1);
dap_cert_item_t *l_cert_item = NULL;
HASH_FIND_STR(s_certs, a_cert->name, l_cert_item);
- if (l_cert_item) {
- log_it(L_WARNING, "Certificate with name %s already present in memory", a_cert->name);
- return -1;
- }
- l_cert_item = DAP_NEW_Z(dap_cert_item_t);
- if (!l_cert_item) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return -2;
- }
- snprintf(l_cert_item->name, sizeof(l_cert_item->name), "%s", a_cert->name);
+ if (l_cert_item)
+ return log_it(L_WARNING, "Certificate with name %s already present in memory", a_cert->name), -2;
+ l_cert_item = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_cert_item_t, -3);
+ dap_strncpy(l_cert_item->name, a_cert->name, sizeof(l_cert_item->name) - 1);
l_cert_item->cert = a_cert;
HASH_ADD_STR(s_certs, name, l_cert_item);
return 0;
@@ -431,17 +415,14 @@ void dap_cert_delete(dap_cert_t * a_cert)
static int s_make_cert_path(const char *a_cert_name, const char *a_folder_path, bool a_check_access, char *a_cert_path)
{
- size_t l_cert_path_length = strlen(a_cert_name) + strlen(a_folder_path) + strlen("/.dcert") + 1;
- if (l_cert_path_length > MAX_PATH) {
- log_it(L_ERROR, "Path size %zu exeeds maximum", l_cert_path_length);
+ int l_ret = snprintf(a_cert_path, MAX_PATH, "%s/%s.dcert", a_folder_path, a_cert_name);
+ if (l_ret < 0) {
+ *a_cert_path = '\0';
return -1;
- }
- snprintf(a_cert_path, l_cert_path_length, "%s/%s.dcert", a_folder_path, a_cert_name);
- if (a_check_access && access(a_cert_path, F_OK) == -1) {
- log_it (L_ERROR, "File %s does not exist", a_cert_path);
- return -2;
- }
- return 0;
+ } else
+ return a_check_access && access(a_cert_path, F_OK) == -1
+ ? ( log_it (L_ERROR, "File %s does not exist", a_cert_path), -2 )
+ : 0;
}
/**
@@ -453,15 +434,13 @@ static int s_make_cert_path(const char *a_cert_name, const char *a_folder_path,
*/
dap_cert_t *dap_cert_add_file(const char *a_cert_name, const char *a_folder_path)
{
- char l_cert_path[MAX_PATH];
- if (s_make_cert_path(a_cert_name, a_folder_path, true, l_cert_path))
- return NULL;
- return dap_cert_file_load(l_cert_path);
+ char l_cert_path[MAX_PATH + 1];
+ return s_make_cert_path(a_cert_name, a_folder_path, true, l_cert_path) ? NULL : dap_cert_file_load(l_cert_path);
}
int dap_cert_delete_file(const char *a_cert_name, const char *a_folder_path)
{
- char l_cert_path[MAX_PATH];
+ char l_cert_path[MAX_PATH + 1];
int ret = s_make_cert_path(a_cert_name, a_folder_path, true, l_cert_path);
return ret ? ret : remove(l_cert_path);
}
@@ -476,7 +455,7 @@ int dap_cert_delete_file(const char *a_cert_name, const char *a_folder_path)
*/
int dap_cert_save_to_folder(dap_cert_t *a_cert, const char *a_file_dir_path)
{
- char l_cert_path[MAX_PATH];
+ char l_cert_path[MAX_PATH + 1];
int ret = s_make_cert_path(a_cert->name, a_file_dir_path, false, l_cert_path);
return ret ? ret : dap_cert_file_save(a_cert, l_cert_path);
}
@@ -496,14 +475,11 @@ dap_pkey_t *dap_cert_to_pkey(dap_cert_t *a_cert)
int dap_cert_get_pkey_hash(dap_cert_t *a_cert, dap_hash_fast_t *a_out_hash)
{
dap_return_val_if_fail(a_cert && a_cert->enc_key && a_cert->enc_key->pub_key_data &&
- a_cert->enc_key->pub_key_data_size && a_out_hash , -1);
- size_t l_pub_key_size;
+ a_cert->enc_key->pub_key_data_size && a_out_hash, -1);
+ size_t l_pub_key_size = 0;
uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(a_cert->enc_key, &l_pub_key_size);
- if (!l_pub_key || !l_pub_key_size)
- return -2;
- dap_hash_fast(l_pub_key, l_pub_key_size, a_out_hash);
- DAP_DELETE(l_pub_key);
- return 0;
+ int l_ret = !dap_hash_fast(l_pub_key, l_pub_key_size, a_out_hash);
+ return DAP_DELETE(l_pub_key), l_ret;
}
/**
@@ -661,17 +637,11 @@ dap_cert_metadata_t *dap_cert_new_meta(const char *a_key, dap_cert_metadata_type
log_it(L_WARNING, "Incorrect arguments for dap_cert_new_meta()");
return NULL;
}
- size_t l_meta_item_size = sizeof(dap_cert_metadata_t) + a_value_size + strlen(a_key) + 1;
- dap_cert_metadata_t *l_new_meta = DAP_NEW_SIZE(void, l_meta_item_size);
- if(!l_new_meta) {
- log_it(L_ERROR, "Memory allocation error in %s, line %d", __PRETTY_FUNCTION__, __LINE__);
- return NULL;
- }
+ size_t l_keylen = strlen(a_key), l_meta_item_size = sizeof(dap_cert_metadata_t) + a_value_size + l_keylen + 1;
+ dap_cert_metadata_t *l_new_meta = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_cert_metadata_t, l_meta_item_size, NULL);
l_new_meta->length = a_value_size;
l_new_meta->type = a_type;
- memcpy((void *)l_new_meta->value, a_value, a_value_size);
- dap_stpcpy((char *)&l_new_meta->value[a_value_size], a_key);
- l_new_meta->key = (const char *)&l_new_meta->value[a_value_size];
+ l_new_meta->key = dap_strncpy( (char*)dap_mempcpy(l_new_meta->value, a_value, a_value_size), a_key, l_keylen );
return l_new_meta;
}
@@ -686,12 +656,10 @@ dap_cert_metadata_t *dap_cert_new_meta(const char *a_key, dap_cert_metadata_type
*/
void dap_cert_add_meta(dap_cert_t *a_cert, const char *a_key, dap_cert_metadata_type_t a_type, void *a_value, size_t a_value_size)
{
- if (!a_cert) {
- log_it(L_WARNING, "Certificate pointer to add metadata is NULL");
- return;
- }
+ dap_return_if_fail(a_cert);
dap_cert_metadata_t *l_new_meta = dap_cert_new_meta(a_key, a_type, a_value, a_value_size);
- dap_binary_tree_t *l_new_root = dap_binary_tree_insert(a_cert->metadata, l_new_meta->key, (void *)l_new_meta);
+ dap_return_if_fail_err(l_new_meta, "Can't create metadata item");
+ dap_binary_tree_t *l_new_root = dap_binary_tree_insert(a_cert->metadata, l_new_meta->key, l_new_meta);
if (!a_cert->metadata) {
a_cert->metadata = l_new_root;
}
@@ -708,40 +676,33 @@ void dap_cert_add_meta(dap_cert_t *a_cert, const char *a_key, dap_cert_metadata_
*/
void dap_cert_add_meta_scalar(dap_cert_t *a_cert, const char *a_key, dap_cert_metadata_type_t a_type, uint64_t a_value, size_t a_value_size)
{
- void *l_value;
- byte_t l_tmp8;
- uint16_t l_tmp16;
- uint32_t l_tmp32;
- uint64_t l_tmp64;
+ void *l_value = NULL;
+ union { byte_t l_tmp8; uint16_t l_tmp16; uint32_t l_tmp32; uint64_t l_tmp64; } uval = { };
switch (a_type) {
case DAP_CERT_META_STRING:
case DAP_CERT_META_SIGN:
case DAP_CERT_META_CUSTOM:
- log_it(L_WARNING, "incoorect metadata type for dap_cert_add_meta_scalar()");
+ log_it(L_WARNING, "Incorrect metadata type for dap_cert_add_meta_scalar()");
return;
default:
switch (a_value_size) {
case 1:
- l_tmp8 = a_value;
- l_value = &l_tmp8;
+ uval.l_tmp8 = a_value;
break;
case 2:
- l_tmp16 = a_value;
- l_value = (void *)&l_tmp16;
+ uval.l_tmp16 = a_value;
break;
case 4:
- l_tmp32 = a_value;
- l_value = (void *)&l_tmp32;
+ uval.l_tmp32 = a_value;
break;
case 8:
default:
- l_tmp64 = a_value;
- l_value = (void *)&l_tmp64;
+ uval.l_tmp64 = a_value;
break;
}
break;
}
- dap_cert_add_meta(a_cert, a_key, a_type, l_value, a_value_size);
+ dap_cert_add_meta(a_cert, a_key, a_type, &uval, a_value_size);
}
/**
@@ -941,8 +902,7 @@ dap_enc_key_t *dap_cert_get_keys_from_certs(dap_cert_t **a_certs, size_t a_count
return dap_enc_key_dup(a_certs[0]->enc_key);
// memory alloc
size_t l_keys_count = 0;
- dap_enc_key_t **l_keys = NULL;
- DAP_NEW_Z_COUNT_RET_VAL(l_keys, dap_enc_key_t *, a_count, NULL, NULL);
+ dap_enc_key_t *l_keys[a_count];
// func work
for(size_t i = a_key_start_index; i < a_count; ++i) {
if (a_certs[i]) {
@@ -952,9 +912,7 @@ dap_enc_key_t *dap_cert_get_keys_from_certs(dap_cert_t **a_certs, size_t a_count
log_it(L_WARNING, "Certs with NULL value");
}
}
- dap_enc_key_t *l_ret = dap_enc_merge_keys_to_multisign_key(l_keys, l_keys_count);
- DAP_DELETE(l_keys);
- return l_ret;
+ return dap_enc_merge_keys_to_multisign_key(l_keys, l_keys_count);
}
DAP_INLINE const char *dap_cert_get_str_recommended_sign(){
diff --git a/crypto/src/dap_cert_file.c b/crypto/src/dap_cert_file.c
index d13a96b954f888a92a28aab8f8a40fc562667364..aeaa0eab8cb81b1768a2c052570e729af3e2e37c 100755
--- a/crypto/src/dap_cert_file.c
+++ b/crypto/src/dap_cert_file.c
@@ -29,6 +29,7 @@
#include "dap_enc.h"
#include "dap_enc_key.h"
#include "dap_file_utils.h"
+#include "dap_strfuncs.h"
#include "dap_cert_file.h"
#define LOG_TAG "dap_cert_file"
@@ -44,33 +45,34 @@ static const char s_key_inheritor[] = "inheritor";
int dap_cert_file_save(dap_cert_t * a_cert, const char * a_cert_file_path)
{
char * l_file_dir = dap_path_get_dirname(a_cert_file_path);
- dap_mkdir_with_parents(l_file_dir);
+ int l_err = dap_mkdir_with_parents(l_file_dir);
DAP_DELETE(l_file_dir);
-
- FILE * l_file = fopen(a_cert_file_path,"wb");
- if( l_file ){
- uint32_t l_data_size = 0;
- void * l_data = dap_cert_mem_save(a_cert, &l_data_size);
- if ( l_data ){
- size_t l_retbytes;
- if ( (l_retbytes = fwrite(l_data,1,l_data_size,l_file)) != l_data_size ){
- log_it(L_ERROR, "Can't write %u bytes on disk (processed only %zu)!", l_data_size,l_retbytes);
- fclose(l_file);
- return -3;
- }
- fclose(l_file);
- DAP_DELETE(l_data);
- return 0;
- }else{
- log_it(L_ERROR,"Can't serialize certificate in memory");
- fclose(l_file);
- remove(a_cert_file_path);
- return -4;
- }
- }else{
- log_it(L_ERROR, "Can't open file '%s' for write: %s", a_cert_file_path, strerror(errno));
- return -2;
+ if ( l_err )
+ return log_it(L_ERROR, "Can't create dir \"%s\"", a_cert_file_path), -1;
+ FILE *l_file = fopen(a_cert_file_path, "wb");
+ if (!l_file) {
+#ifdef DAP_OS_WINDOWS
+ l_err = GetLastError();
+#else
+ l_err = errno;
+#endif
+ return log_it(L_ERROR, "Can't open file '%s' for write, error %d: \"%s\"",
+ a_cert_file_path, l_err, dap_strerror(l_err)), -2;
+ }
+ uint32_t l_data_size;
+ byte_t *l_data = dap_cert_mem_save(a_cert, &l_data_size);
+ if ( !l_data ) {
+ l_err = -3;
+ log_it(L_ERROR,"Can't serialize certificate in memory");
+ } else if ( l_data_size -= fwrite(l_data, 1, l_data_size, l_file) ) {
+ l_err = -4;
+ log_it(L_ERROR, "Can't write cert to disk, unprocessed %u bytes", l_data_size);
}
+ fclose(l_file);
+ DAP_DELETE(l_data);
+ if (l_err)
+ remove(a_cert_file_path);
+ return l_err;
}
// balance the binary tree
@@ -105,36 +107,42 @@ void s_balance_the_tree(dap_cert_file_aux_t *a_reorder, size_t a_left_idx, size_
*/
void dap_cert_deserialize_meta(dap_cert_t *a_cert, const uint8_t *a_data, size_t a_size)
{
- dap_cert_metadata_t **l_meta_arr = NULL;
- size_t l_mem_shift = 0;
- size_t l_meta_items_count = 0;
- while (l_mem_shift < a_size) {
- const char *l_key_str = (const char *)&a_data[l_mem_shift];
- if (!l_key_str) {
+ dap_cert_metadata_t **l_meta_arr = NULL, **l_newer_arr;
+ int l_err = 0, q = 0;
+ uint8_t *l_pos = (uint8_t*)a_data, *l_end = l_pos + a_size;
+ while (!l_err && l_pos < l_end) {
+ char *l_key_str = (char*)l_pos;
+ if (!( l_pos = memchr(l_pos, '\0', (size_t)(l_end - l_pos)) ) || ++l_pos == l_end) {
+ //l_pos = (uint8_t*)l_key_str;
break;
}
- l_mem_shift += strlen(l_key_str) + 1;
- uint32_t l_value_size = le32toh(a_data[l_mem_shift]);
- l_mem_shift += sizeof(uint32_t);
- dap_cert_metadata_type_t l_meta_type = (dap_cert_metadata_type_t)a_data[l_mem_shift++];
- const uint8_t *l_value = &a_data[l_mem_shift];
- uint16_t l_tmp16;
- uint32_t l_tmp32;
- uint64_t l_tmp64;
- switch (l_meta_type) {
+ uint32_t l_value_size = le32toh(*l_pos);
+ if (l_pos + sizeof(uint32_t) + /* sizeof(dap_cert_metadata_type_t) */ + 1 + l_value_size > l_end) {
+ //l_pos = (uint8_t*)l_key_str;
+ break;
+ }
+ l_pos += sizeof(uint32_t);
+ dap_cert_metadata_type_t l_meta_type = *(dap_cert_metadata_type_t*)l_pos;
+ l_pos += /*sizeof(dap_cert_metadata_type_t)*/ 1;
+ union { uint16_t l_tmp16; uint32_t l_tmp32; uint64_t l_tmp64; } l_tmp = { };
+ uint8_t *l_value = l_pos;
+ switch ( l_meta_type ) {
case DAP_CERT_META_STRING:
case DAP_CERT_META_SIGN:
break;
case DAP_CERT_META_CUSTOM:
- if(!strcmp(l_key_str, s_key_inheritor)) {
+ if ( !strcmp(l_key_str, s_key_inheritor) ) {
if (a_cert->enc_key->_inheritor) {
log_it(L_DEBUG, "Few inheritor records in cert metadata");
+ l_err = -2;
+ break;
+ }
+ if (!( a_cert->enc_key->_inheritor = DAP_DUP_SIZE(l_pos, l_value_size) )) {
+ l_err = -3;
break;
}
- DAP_NEW_Z_SIZE_RET(a_cert->enc_key->_inheritor, byte_t, l_value_size, NULL);
a_cert->enc_key->_inheritor_size = l_value_size;
- a_cert->enc_key->_inheritor = DAP_DUP_SIZE(a_data + l_mem_shift, a_cert->enc_key->_inheritor_size);
- l_mem_shift += l_value_size;
+ l_pos += l_value_size;
continue;
}
break;
@@ -143,45 +151,40 @@ void dap_cert_deserialize_meta(dap_cert_t *a_cert, const uint8_t *a_data, size_t
case 1:
break;
case 2:
- l_tmp16 = le16toh(*l_value);
- l_value = (const uint8_t *)&l_tmp16;
- break;
+ l_tmp.l_tmp16 = le16toh(*l_value);
case 4:
- l_tmp32 = le32toh(*l_value);
- l_value = (const uint8_t *)&l_tmp32;
+ l_tmp.l_tmp32 = le32toh(*l_value);
break;
case 8:
default:
- l_tmp64 = le64toh(*l_value);
- l_value = (const uint8_t *)&l_tmp64;
+ l_tmp.l_tmp64 = le64toh(*l_value);
break;
}
+ l_value = (uint8_t*)&l_tmp;
break;
}
- dap_cert_metadata_t *l_new_meta = dap_cert_new_meta(l_key_str, l_meta_type, (void *)l_value, l_value_size);
- if (l_meta_arr == NULL) {
- l_meta_arr = DAP_NEW(dap_cert_metadata_t *);
- if (!l_meta_arr) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
- } else {
- l_meta_arr = DAP_REALLOC_COUNT(l_meta_arr, l_meta_items_count + 1);
- if (!l_meta_arr) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
+ if (l_err) {
+ //l_pos = (uint8_t*)l_key_str;
+ break;
}
- l_mem_shift += l_value_size;
- l_meta_arr[l_meta_items_count++] = l_new_meta;
+ l_pos += l_value_size;
+ dap_cert_metadata_t *l_new_meta = dap_cert_new_meta(l_key_str, l_meta_type, l_value, l_value_size);
+ if ( !l_new_meta )
+ break;
+ if (l_meta_arr) {
+ l_newer_arr = DAP_REALLOC_COUNT_RET_IF_FAIL(l_meta_arr, q + 1, l_meta_arr);
+ l_meta_arr = l_newer_arr;
+ } else
+ l_meta_arr = DAP_NEW_Z_RET_IF_FAIL(dap_cert_metadata_t*);
+ l_meta_arr[q++] = l_new_meta;
}
- if(l_meta_items_count){
- size_t l_reorder_arr[l_meta_items_count];
+ if (q) {
+ size_t l_reorder_arr[q];
dap_cert_file_aux_t l_reorder = {l_reorder_arr, 0};
- s_balance_the_tree(&l_reorder, 0, l_meta_items_count - 1);
+ s_balance_the_tree(&l_reorder, 0, q - 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++) {
+ a_cert->metadata = dap_binary_tree_insert(NULL, l_meta_arr[n]->key, (void*)l_meta_arr[n]);
+ for (int i = 1; i < q; ++i) {
n = l_reorder_arr[i];
dap_binary_tree_insert(a_cert->metadata, l_meta_arr[n]->key, (void *)l_meta_arr[n]);
}
@@ -198,14 +201,11 @@ void dap_cert_deserialize_meta(dap_cert_t *a_cert, const uint8_t *a_data, size_t
*/
uint8_t *dap_cert_serialize_meta(dap_cert_t *a_cert, size_t *a_buflen_out)
{
- if (!a_cert) {
- return NULL;
- }
- if ( a_cert->enc_key->_inheritor_size) {
+ dap_return_val_if_fail(a_cert, NULL);
+ if ( a_cert->enc_key->_inheritor_size)
dap_cert_add_meta_custom(a_cert, s_key_inheritor, a_cert->enc_key->_inheritor, a_cert->enc_key->_inheritor_size);
- }
dap_list_t *l_meta_list = dap_binary_tree_inorder_list(a_cert->metadata);
- if (!l_meta_list) {
+ if ( !l_meta_list ) {
return NULL;
}
dap_list_t *l_meta_list_item = dap_list_first(l_meta_list);
@@ -214,10 +214,14 @@ uint8_t *dap_cert_serialize_meta(dap_cert_t *a_cert, size_t *a_buflen_out)
while (l_meta_list_item) {
dap_cert_metadata_t *l_meta_item = l_meta_list_item->data;
size_t l_meta_item_size = sizeof(uint32_t) + 1 + l_meta_item->length + strlen(l_meta_item->key) + 1;
- if (l_buf) {
- l_buf = DAP_REALLOC(l_buf, l_mem_shift + l_meta_item_size);
+ if (!l_buf) {
+ if (!( l_buf = DAP_NEW_Z_SIZE(uint8_t, l_meta_item_size) ))
+ return dap_list_free(l_meta_list), log_it(L_CRITICAL, "%s", "Insufficient memory"), NULL;
} else {
- l_buf = DAP_NEW_SIZE(uint8_t, l_meta_item_size);
+ uint8_t *l_new_buf = DAP_REALLOC(l_buf, l_mem_shift + l_meta_item_size);
+ if (!l_new_buf)
+ return DAP_DELETE(l_buf), dap_list_free(l_meta_list), log_it(L_CRITICAL, "%s", "Insufficient memory"), NULL;
+ l_buf = l_new_buf;
}
strcpy((char *)&l_buf[l_mem_shift], l_meta_item->key);
l_mem_shift += strlen(l_meta_item->key) + 1;
@@ -269,84 +273,32 @@ uint8_t *dap_cert_serialize_meta(dap_cert_t *a_cert, size_t *a_buflen_out)
*/
uint8_t* dap_cert_mem_save(dap_cert_t * a_cert, uint32_t *a_cert_size_out)
{
- dap_cert_file_hdr_t l_hdr={0};
- uint32_t l_data_offset = 0;
- dap_enc_key_t * l_key = a_cert->enc_key;
- uint8_t *l_data = NULL;
-
- size_t l_priv_key_data_size = a_cert->enc_key->priv_key_data_size;
- size_t l_pub_key_data_size = a_cert->enc_key->pub_key_data_size;
- size_t l_metadata_size = l_key->_inheritor_size;
- uint8_t *l_pub_key_data = a_cert->enc_key->pub_key_data_size ?
- dap_enc_key_serialize_pub_key(l_key, &l_pub_key_data_size) :
- NULL;
- uint8_t *l_priv_key_data = a_cert->enc_key->priv_key_data ?
- dap_enc_key_serialize_priv_key(l_key, &l_priv_key_data_size) :
- NULL;
-
- uint8_t *l_metadata = dap_cert_serialize_meta(a_cert, &l_metadata_size);
-
- l_hdr.sign = dap_cert_FILE_HDR_SIGN;
- l_hdr.type = dap_cert_FILE_TYPE_PUBLIC;
- if ( l_priv_key_data ){
- l_hdr.type = dap_cert_FILE_TYPE_PRIVATE;
- //log_it(L_DEBUG,"Private key size %u",l_priv_key_data_size);
- }
- if (l_pub_key_data){
- //log_it(L_DEBUG,"Public key size %u",l_pub_key_data_size);
- }else{
- log_it(L_ERROR,"No public or private key in certificate, nothing to save");
- goto lb_exit;
- }
- //log_it(L_DEBUG,"Key private data size %u",l_key->_inheritor_size);
-
- l_hdr.version = dap_cert_FILE_VERSION;
- l_hdr.data_size = l_pub_key_data_size;
- l_hdr.data_pvt_size = l_priv_key_data_size;
- l_hdr.metadata_size = l_metadata_size;
-
- l_hdr.ts_last_used = l_key->last_used_timestamp;
- l_hdr.sign_type = dap_sign_type_from_key_type ( l_key->type );
-
-
- l_data = DAP_NEW_SIZE(void, sizeof(l_hdr) + DAP_CERT_ITEM_NAME_MAX + l_priv_key_data_size + l_pub_key_data_size + l_metadata_size);
- if (!l_data) {
- log_it(L_ERROR,"Certificate \"%s\" was not serialized",a_cert->name);
- goto lb_exit;
- }
-
- memcpy(l_data +l_data_offset, &l_hdr ,sizeof(l_hdr) );
- l_data_offset += sizeof(l_hdr);
-
- memcpy(l_data +l_data_offset, a_cert->name, DAP_CERT_ITEM_NAME_MAX );//save cert name
- l_data_offset += DAP_CERT_ITEM_NAME_MAX;
-
- 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 && 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;
- }
-
- if (l_metadata_size) {
- memcpy(l_data + l_data_offset, l_metadata, l_metadata_size);
- l_data_offset += l_metadata_size;
- }
-lb_exit:
- DAP_DELETE(l_pub_key_data);
- if ( l_priv_key_data_size ) {
- DAP_DELETE(l_priv_key_data);
- }
- if ( l_metadata_size ) {
- DAP_DELETE(l_metadata);
- }
-
- //log_it(L_NOTICE,"Certificate \"%s\" successfully serialized",a_cert->name);
-
- if(a_cert_size_out)
- *a_cert_size_out = l_data_offset;
- return l_data;
+ dap_enc_key_t *l_key = a_cert->enc_key;
+
+ uint64_t l_priv_key_data_size = a_cert->enc_key->priv_key_data_size,
+ l_pub_key_data_size = a_cert->enc_key->pub_key_data_size,
+ l_metadata_size = l_key->_inheritor_size;
+
+ uint8_t *l_pub_key_data = dap_enc_key_serialize_pub_key(l_key, &l_pub_key_data_size),
+ *l_priv_key_data = dap_enc_key_serialize_priv_key(l_key, &l_priv_key_data_size),
+ *l_metadata = dap_cert_serialize_meta(a_cert, &l_metadata_size);
+ if (!l_pub_key_data && !l_priv_key_data)
+ return log_it(L_ERROR, "Neither pvt, nor pub key in certificate, nothing to do"), DAP_DELETE(l_metadata), NULL;
+ uint64_t l_total_size = sizeof(dap_cert_file_hdr_t) + DAP_CERT_ITEM_NAME_MAX + l_priv_key_data_size + l_pub_key_data_size + l_metadata_size;
+
+ dap_cert_file_hdr_t l_hdr = {
+ .sign = dap_cert_FILE_HDR_SIGN, .version = dap_cert_FILE_VERSION,
+ .type = l_priv_key_data ? dap_cert_FILE_TYPE_PRIVATE : dap_cert_FILE_TYPE_PUBLIC,
+ .sign_type = dap_sign_type_from_key_type( l_key->type ),
+ .data_size = l_pub_key_data_size, .data_pvt_size = l_priv_key_data_size, .metadata_size = l_metadata_size,
+ .ts_last_used = l_key->last_used_timestamp
+ };
+ uint8_t *l_data = DAP_VA_SERIALIZE_NEW(l_total_size, &l_hdr, (uint64_t)sizeof(l_hdr), a_cert->name, (uint64_t)sizeof(a_cert->name),
+ l_pub_key_data, l_pub_key_data_size, l_priv_key_data, l_priv_key_data_size,
+ l_metadata, l_metadata_size );
+ if (a_cert_size_out)
+ *a_cert_size_out = l_data ? l_total_size : 0;
+ return DAP_DEL_MULTY(l_pub_key_data, l_priv_key_data, l_metadata), l_data;
}
/**
@@ -357,27 +309,32 @@ lb_exit:
dap_cert_t* dap_cert_file_load(const char * a_cert_file_path)
{
dap_cert_t * l_ret = NULL;
- FILE * l_file = fopen(a_cert_file_path,"rb");
-
- if( l_file ){
- fseek(l_file, 0L, SEEK_END);
- uint64_t l_file_size = ftell(l_file);
- rewind(l_file);
- uint8_t * l_data = DAP_NEW_SIZE(uint8_t,l_file_size);
- if ( fread(l_data,1,l_file_size,l_file ) != l_file_size ){
- log_it(L_ERROR, "Can't read %"DAP_UINT64_FORMAT_U" bytes from the disk!", l_file_size);
- DAP_DELETE (l_data);
- goto lb_exit;
- }else{
- l_ret = dap_cert_mem_load(l_data,l_file_size);
- if (l_ret)
- dap_cert_add(l_ret);
- }
- DAP_DELETE(l_data);
+ int l_err = 0;
+ FILE *l_file = fopen(a_cert_file_path, "rb");
+ if ( !l_file ) {
+#ifdef DAP_OS_WINDOWS
+ l_err = GetLastError();
+#else
+ l_err = errno;
+#endif
+ return log_it(L_ERROR, "Can't open cert file '%s', error %d: \"%s\"", a_cert_file_path, l_err, dap_strerror(l_err)), NULL;
}
-lb_exit:
- if( l_file )
- fclose(l_file);
+ fseeko(l_file, 0L, SEEK_END);
+ size_t l_file_size = ftello(l_file);
+ rewind(l_file);
+ byte_t *l_data = DAP_NEW_Z_SIZE(byte_t, l_file_size);
+ if ( fread(l_data, 1, l_file_size, l_file) != l_file_size ) {
+ l_err = -1;
+ log_it(L_ERROR, "Can't read %"DAP_UINT64_FORMAT_U" bytes from the disk!", l_file_size);
+ } else if (!( l_ret = dap_cert_mem_load(l_data, l_file_size) )) {
+ log_it(L_ERROR, "Can't load cert from file");
+ l_err = -2;
+ } else
+ dap_cert_add( l_ret );
+ fclose(l_file);
+ DAP_DELETE(l_data);
+ if (l_err)
+ DAP_DEL_Z(l_ret);
return l_ret;
}
@@ -389,67 +346,51 @@ lb_exit:
* @param a_data_size - size of certificate
* @return dap_cert_t*
*/
-dap_cert_t* dap_cert_mem_load(const void * a_data, size_t a_data_size)
+dap_cert_t* dap_cert_mem_load(const void *a_data, size_t a_data_size)
{
- if (!a_data)
- return NULL;
- dap_cert_t * l_ret = NULL;
- const uint8_t * l_data = (const uint8_t *) a_data;
- uint32_t l_data_offset = 0;
+ dap_return_val_if_fail_err(!!a_data, NULL, "No data provided to load cert from");
+ dap_return_val_if_fail_err(a_data_size > sizeof(dap_cert_file_hdr_t), NULL, "Inconsistent cert data");
+ dap_cert_t *l_ret = NULL;
+ const uint8_t *l_data = (const uint8_t*)a_data;
dap_cert_file_hdr_t l_hdr = *(dap_cert_file_hdr_t*)l_data;
- l_data_offset += sizeof(l_hdr);
- if (l_hdr.sign != dap_cert_FILE_HDR_SIGN ){
- log_it(L_ERROR, "Wrong cert signature, corrupted header!");
- goto l_exit;
+ l_data += sizeof(l_hdr);
+ if ( l_hdr.sign != dap_cert_FILE_HDR_SIGN )
+ return log_it(L_ERROR, "Wrong cert signature, corrupted header!"), NULL;
+ else if ( l_hdr.version < 1 )
+ return log_it(L_ERROR, "Unrecognizable certificate version, corrupted file or your software is deprecated"), NULL;
+ debug_if( dap_enc_debug_more(), L_DEBUG,"sizeof(l_hdr)=%zu "
+ "l_hdr.data_pvt_size=%"DAP_UINT64_FORMAT_U" "
+ "l_hdr.data_size=%"DAP_UINT64_FORMAT_U" "
+ "l_hdr.metadata_size=%"DAP_UINT64_FORMAT_U" "
+ "a_data_size=%zu ",
+ sizeof(l_hdr), l_hdr.data_pvt_size, l_hdr.data_size,
+ l_hdr.metadata_size, a_data_size );
+ size_t l_size_req = sizeof(l_hdr) + DAP_CERT_ITEM_NAME_MAX + l_hdr.data_size + l_hdr.data_pvt_size + l_hdr.metadata_size;
+
+ if ( l_size_req > a_data_size )
+ return log_it(L_ERROR, "Cert data size exeeds file size, %zu > %zu", l_size_req, a_data_size), NULL;
+
+ char l_name[DAP_CERT_ITEM_NAME_MAX];
+ dap_strncpy(l_name, (const char*)l_data, DAP_CERT_ITEM_NAME_MAX - 1);
+ l_data += DAP_CERT_ITEM_NAME_MAX;
+ if (!( l_ret = dap_cert_new(l_name) ))
+ return log_it(L_ERROR, "Can't create cert '%s'", l_name), NULL;
+ else if (!( l_ret->enc_key = dap_enc_key_new(dap_sign_type_to_key_type(l_hdr.sign_type)) ))
+ return log_it(L_ERROR, "Can't init new key with sign type %s",
+ dap_sign_type_to_str(l_hdr.sign_type)),
+ dap_cert_delete(l_ret), NULL;
+ l_ret->enc_key->last_used_timestamp = l_hdr.ts_last_used;
+
+ if ( l_hdr.data_size ) {
+ dap_enc_key_deserialize_pub_key(l_ret->enc_key, l_data, l_hdr.data_size);
+ l_data += l_hdr.data_size;
}
- if (l_hdr.version >= 1 ){
- if (dap_enc_debug_more()) {
- log_it(L_DEBUG,"sizeof(l_hdr)=%zu "
- "l_hdr.data_pvt_size=%"DAP_UINT64_FORMAT_U" "
- "l_hdr.data_size=%"DAP_UINT64_FORMAT_U" "
- "l_hdr.metadata_size=%"DAP_UINT64_FORMAT_U" "
- "a_data_size=%zu ",
- sizeof(l_hdr), l_hdr.data_pvt_size, l_hdr.data_size, l_hdr.metadata_size, a_data_size);
- }
- if ( (sizeof(l_hdr) + l_hdr.data_size+l_hdr.data_pvt_size +l_hdr.metadata_size) > a_data_size ){
- log_it(L_ERROR,"Corrupted cert data, data sections size is smaller than exists on the disk! (%"DAP_UINT64_FORMAT_U" expected, %zu on disk)",
- sizeof(l_hdr)+l_hdr.data_pvt_size+l_hdr.data_size+l_hdr.metadata_size, a_data_size);
- goto l_exit;
- }
-
- char l_name[DAP_CERT_ITEM_NAME_MAX];
- memcpy(l_name, l_data +l_data_offset, DAP_CERT_ITEM_NAME_MAX );//save cert name
- l_data_offset += DAP_CERT_ITEM_NAME_MAX;
-
- //l_ret = DAP_NEW_Z(dap_cert_t);
- l_ret = dap_cert_new(l_name);
- l_ret->enc_key = dap_enc_key_new( dap_sign_type_to_key_type( l_hdr.sign_type ));
- if(l_ret->enc_key == NULL){
- log_it(L_ERROR,"Can't init new private key with sign type %s", dap_sign_type_to_str(l_hdr.sign_type));
- dap_cert_delete(l_ret);
- l_ret = NULL;
- goto l_exit;
- }
-
- l_ret->enc_key->last_used_timestamp = l_hdr.ts_last_used;
-
- if ( l_hdr.data_size > 0 ){
- dap_enc_key_deserialize_pub_key(l_ret->enc_key, l_data + l_data_offset, l_hdr.data_size);
- l_data_offset += l_hdr.data_size;
- }
- if ( l_hdr.data_pvt_size > 0 ){
- dap_enc_key_deserialize_priv_key(l_ret->enc_key, l_data + l_data_offset, l_hdr.data_pvt_size);
- l_data_offset += l_hdr.data_pvt_size;
- }
- if ( l_hdr.metadata_size > 0 ){
- dap_cert_deserialize_meta(l_ret, l_data + l_data_offset, l_hdr.metadata_size);
- l_data_offset += l_hdr.metadata_size;
- }
- dap_enc_key_update(l_ret->enc_key);
- //log_it(L_NOTICE,"Successfully loaded certificate %s", l_ret->name);
- }else
- log_it(L_ERROR,"Unrecognizable certificate version, corrupted file or you have too old software");
-
-l_exit:
+ if ( l_hdr.data_pvt_size ) {
+ dap_enc_key_deserialize_priv_key(l_ret->enc_key, l_data, l_hdr.data_pvt_size);
+ l_data += l_hdr.data_pvt_size;
+ }
+ if ( l_hdr.metadata_size )
+ dap_cert_deserialize_meta(l_ret, l_data, l_hdr.metadata_size);
+ dap_enc_key_update(l_ret->enc_key);
return l_ret;
}
diff --git a/crypto/src/dap_enc.c b/crypto/src/dap_enc.c
index e630662f9ea3719896530198995276213f2b7633..2d0b83c0d44a9626e1c52e3c28cfd4afd83db4e5 100755
--- a/crypto/src/dap_enc.c
+++ b/crypto/src/dap_enc.c
@@ -78,15 +78,8 @@ bool dap_enc_debug_more()
*/
size_t dap_enc_code_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
- size_t raw_encode_data_size = dap_enc_key_get_enc_size(a_key->type, a_buf_in_size);
- if(raw_encode_data_size == 0) {
- log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
- return 0;
- }
- if(type != DAP_ENC_DATA_TYPE_RAW) {
- return (size_t)DAP_ENC_BASE64_ENCODE_SIZE(raw_encode_data_size);
- }
- return raw_encode_data_size;
+ size_t l_size = dap_enc_key_get_enc_size(a_key->type, a_buf_in_size);
+ return type == DAP_ENC_DATA_TYPE_RAW ? l_size : DAP_ENC_BASE64_ENCODE_SIZE(l_size);
}
/**
@@ -97,22 +90,12 @@ size_t dap_enc_code_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, d
*/
size_t dap_enc_decode_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
- size_t raw_decode_data_size = dap_enc_key_get_dec_size(a_key->type, a_buf_in_size);
- if(raw_decode_data_size == 0) {
- log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
- return 0;
- }
-
- if(type != DAP_ENC_DATA_TYPE_RAW) {
- return (size_t)DAP_ENC_BASE64_ENCODE_SIZE(raw_decode_data_size);
- }
- return raw_decode_data_size;
+ size_t l_size = type == DAP_ENC_DATA_TYPE_RAW ? a_buf_in_size : DAP_ENC_BASE64_DECODE_SIZE(a_buf_in_size);
+ return l_size ? dap_enc_key_get_dec_size(a_key->type, l_size) : 0;
}
-
-
/**
- * @brief dap_enc_code Encode data with key
+ * @brief Encode data with key
* @param a_key Private key
* @param a_buf Input buffer
* @param a_buf_size Input buffer size
@@ -120,44 +103,35 @@ size_t dap_enc_decode_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size,
* @param a_buf_out_size_max
* @return bytes actualy written in the output buffer
*/
-size_t dap_enc_code(dap_enc_key_t *a_key,const void * a_buf_in,const size_t a_buf_size,
- void * a_buf_out, const size_t a_buf_out_size_max, dap_enc_data_type_t a_data_type_out)
+size_t dap_enc_code(dap_enc_key_t *a_key,
+ const void *a_buf_in, const size_t a_buf_size,
+ void *a_buf_out, const size_t a_buf_out_size_max,
+ dap_enc_data_type_t a_data_type_out)
{
- if(!a_key) {
- log_it(L_ERROR, "key in dap_enc_code() is NULL");
- return 0;
- }
- if(a_key->enc_na) {
- if(a_data_type_out == DAP_ENC_DATA_TYPE_RAW) {
- return a_key->enc_na(a_key, a_buf_in, a_buf_size, a_buf_out, a_buf_out_size_max);
- }else{
- void *l_proc_buf;
- l_proc_buf = DAP_NEW_SIZE (void, a_buf_out_size_max );
- size_t l_proc_buf_size = a_key->enc_na(a_key, a_buf_in, a_buf_size, l_proc_buf,a_buf_out_size_max);
- if(a_data_type_out == DAP_ENC_DATA_TYPE_B64 || a_data_type_out == DAP_ENC_DATA_TYPE_B64_URLSAFE) {
- if(DAP_ENC_BASE64_ENCODE_SIZE(l_proc_buf_size) <= a_buf_out_size_max) {
- size_t l_buf_out_size=dap_enc_base64_encode(l_proc_buf, l_proc_buf_size, a_buf_out, a_data_type_out);
- DAP_DELETE(l_proc_buf);
- return l_buf_out_size;
- } else {
- DAP_DELETE(l_proc_buf);
- log_it(L_ERROR, "a_buf_out_size_max less than result size");
- return 0;
- }
- } else {
- log_it(L_ERROR, "Unknown dap_enc_data_type");
- DAP_DELETE(l_proc_buf);
- return 0;
- }
- }
- } else {
- log_it(L_ERROR, "key->enc_na is NULL");
- return 0;
+ dap_return_val_if_fail_err(a_key && a_key->enc_na && a_buf_in && a_buf_out, 0, "Invalid params");
+ size_t l_ret = dap_enc_code_out_size(a_key, a_buf_size, a_data_type_out);
+ if ( !l_ret || l_ret > a_buf_out_size_max )
+ return log_it(L_ERROR, "Insufficient out buffer size: %zu < %zu", a_buf_out_size_max, l_ret), 0;
+ switch ( a_data_type_out ) {
+ case DAP_ENC_DATA_TYPE_RAW:
+ l_ret = a_key->enc_na(a_key, a_buf_in, a_buf_size, a_buf_out, a_buf_out_size_max);
+ break;
+ case DAP_ENC_DATA_TYPE_B64:
+ case DAP_ENC_DATA_TYPE_B64_URLSAFE: {
+ char *l_tmp_buf = DAP_NEW_Z_SIZE(char, l_ret);
+ size_t l_tmp_size = a_key->enc_na(a_key, a_buf_in, a_buf_size, l_tmp_buf, l_ret);
+ l_ret = dap_enc_base64_encode(l_tmp_buf, l_tmp_size, a_buf_out, a_data_type_out);
+ DAP_DELETE(l_tmp_buf);
+ } break;
+ default:
+ log_it(L_ERROR, "Unknown enc type %d", (int)a_data_type_out);
+ l_ret = 0;
}
+ return l_ret;
}
/**
- * @brief dap_enc_decode Decode data with key
+ * @brief Decode data with key
* @param key_public Public key
* @param buf Input buffer
* @param buf_size Input buffer size
@@ -165,39 +139,29 @@ size_t dap_enc_code(dap_enc_key_t *a_key,const void * a_buf_in,const size_t a_bu
* @param buf_out_max Maximum size of output buffer
* @return bytes actualy written in the output buffer
*/
-size_t dap_enc_decode(dap_enc_key_t *a_key,const void * a_buf_in, const size_t a_buf_in_size,
- void * a_buf_out, const size_t a_buf_out_size_max, dap_enc_data_type_t a_data_type_in)
+size_t dap_enc_decode(dap_enc_key_t *a_key,
+ const void *a_buf_in, const size_t a_buf_in_size,
+ void *a_buf_out, const size_t a_buf_out_size_max,
+ dap_enc_data_type_t a_data_type_in)
{
- void *l_proc_buf = NULL;
- const void *l_proc_buf_const = NULL;
- size_t l_proc_buf_size = 0;
- switch(a_data_type_in){
- case DAP_ENC_DATA_TYPE_B64:
- case DAP_ENC_DATA_TYPE_B64_URLSAFE:
- l_proc_buf=DAP_NEW_SIZE(void,DAP_ENC_BASE64_ENCODE_SIZE(a_buf_in_size));
- l_proc_buf_size= dap_enc_base64_decode((const char*) a_buf_in,a_buf_in_size,l_proc_buf,a_data_type_in);
- l_proc_buf_const=l_proc_buf;
+ dap_return_val_if_fail_err(a_key && a_key->enc_na && a_buf_in && a_buf_out, 0, "Invalid params");
+ size_t l_ret = dap_enc_decode_out_size(a_key, a_buf_in_size, a_data_type_in);
+ if ( !l_ret || l_ret > a_buf_out_size_max )
+ return log_it(L_ERROR, "Insufficient out buffer size: %zu < %zu", a_buf_out_size_max, l_ret), 0;
+ switch ( a_data_type_in ) {
+ case DAP_ENC_DATA_TYPE_RAW:
+ l_ret = a_key->dec_na(a_key, a_buf_in, a_buf_in_size, a_buf_out, a_buf_out_size_max);
break;
- case DAP_ENC_DATA_TYPE_RAW:{
- l_proc_buf_const=a_buf_in;
- l_proc_buf_size=a_buf_in_size;
- }break;
- }
-
- if(a_key->dec_na) {
- if(l_proc_buf_size == 0) {
- log_it(L_ERROR, "Buf is null. dap_enc_base64_decode is failed");
- return 0;
- }
- size_t ret = a_key->dec_na(a_key,l_proc_buf_const,l_proc_buf_size, a_buf_out,a_buf_out_size_max);
-
- if(a_data_type_in==DAP_ENC_DATA_TYPE_B64 || a_data_type_in == DAP_ENC_DATA_TYPE_B64_URLSAFE)
- free(l_proc_buf);
- return ret;
- } else {
- log_it(L_WARNING, "key->dec_na is NULL");
- if(l_proc_buf_size)
- free(l_proc_buf);
- return 0;
+ case DAP_ENC_DATA_TYPE_B64:
+ case DAP_ENC_DATA_TYPE_B64_URLSAFE: {
+ char *l_tmp_buf = DAP_NEW_Z_SIZE(char, DAP_ENC_BASE64_DECODE_SIZE(a_buf_in_size));
+ size_t l_tmp_size = dap_enc_base64_decode(a_buf_in, a_buf_in_size, l_tmp_buf, a_data_type_in);
+ l_ret = a_key->dec_na(a_key, l_tmp_buf, l_tmp_size, a_buf_out, a_buf_out_size_max);
+ DAP_DELETE(l_tmp_buf);
+ } break;
+ default:
+ log_it(L_ERROR, "Unknown enc type %d", (int)a_data_type_in);
+ l_ret = 0;
}
+ return l_ret;
}
diff --git a/crypto/src/dap_enc_base58.c b/crypto/src/dap_enc_base58.c
index a8b5b5141d191a30bcfe1fb13dad19a3af68568c..8d99ab69ec6bc234dfd138af85547901cb073297 100755
--- a/crypto/src/dap_enc_base58.c
+++ b/crypto/src/dap_enc_base58.c
@@ -250,8 +250,8 @@ char* dap_enc_base58_to_hex_str_from_str(const char *a_in_str)
return l_out_str;
}
-const char *dap_enc_base58_encode_hash_to_str_static(const dap_chain_hash_fast_t *a_in_hash)
+dap_enc_b58_hash_str_t dap_enc_base58_encode_hash_to_str_static_(const dap_chain_hash_fast_t *a_in_hash)
{
- _Thread_local static char s_buf[DAP_ENC_BASE58_ENCODE_SIZE(sizeof(dap_chain_hash_fast_t))] = { '\0' };
- return dap_enc_base58_encode(a_in_hash, sizeof(dap_chain_hash_fast_t), s_buf) ? s_buf : NULL;
+ dap_enc_b58_hash_str_t l_ret = { };
+ return dap_enc_base58_encode(a_in_hash, sizeof(dap_chain_hash_fast_t), (char*)&l_ret), l_ret;
}
diff --git a/crypto/src/dap_enc_base64.c b/crypto/src/dap_enc_base64.c
index 025adafb4ad7bebc4c183a79643b02090d949716..dc3471edd8948206018f31da409e6f4593bcb2cd 100755
--- a/crypto/src/dap_enc_base64.c
+++ b/crypto/src/dap_enc_base64.c
@@ -284,20 +284,14 @@ char *dap_enc_strdup_to_base64(const char * a_string){
}
char * dap_enc_strdup_from_base64(const char * a_string_base64){
- if(!a_string_base64)
+ if(!a_string_base64 || !*a_string_base64)
return NULL;
-
- size_t l_string_base64_len = strlen(a_string_base64);
- if(!l_string_base64_len)
+ size_t l_string_base64_len = strlen(a_string_base64), l_decoded_len = DAP_ENC_BASE64_DECODE_SIZE(l_string_base64_len);
+ if(!l_decoded_len)
return NULL;
- char * l_string = DAP_NEW_Z_SIZE(char, l_string_base64_len * 2);
- size_t l_string_len = dap_enc_base64_decode(a_string_base64, l_string_base64_len, l_string, DAP_ENC_DATA_TYPE_B64_URLSAFE);
-
- if(!l_string_len){
- DAP_DELETE(l_string);
- return NULL;
- }
+ char * l_string = DAP_NEW_Z_SIZE(char, l_decoded_len + 1);
+ l_decoded_len = dap_enc_base64_decode(a_string_base64, l_string_base64_len, l_string, DAP_ENC_DATA_TYPE_B64_URLSAFE);
return l_string;
}
diff --git a/crypto/src/dap_enc_bliss.c b/crypto/src/dap_enc_bliss.c
index a5a95f615814add2bdf3d5697f1c5a1e2ef60c27..964bf1b489e0b1665cf1dd3118be7b4f73ed20fd 100755
--- a/crypto/src/dap_enc_bliss.c
+++ b/crypto/src/dap_enc_bliss.c
@@ -154,12 +154,12 @@ uint8_t *dap_enc_sig_bliss_write_signature(const void *a_sign, size_t *a_buflen_
// func work
uint64_t l_buflen = dap_enc_sig_bliss_ser_sig_size(a_sign);
uint32_t l_kind = l_sign->kind;
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 10,
- &l_buflen, (uint64_t)sizeof(uint64_t),
- &l_kind, (uint64_t)sizeof(uint32_t),
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
+ &l_buflen, (uint64_t)sizeof(uint64_t),
+ &l_kind, (uint64_t)sizeof(uint32_t),
l_sign->z1, (uint64_t)(p.n * sizeof(int32_t)),
l_sign->z2, (uint64_t)(p.n * sizeof(int32_t)),
- l_sign->c, (uint64_t)(p.kappa * sizeof(int32_t))
+ l_sign->c, (uint64_t)(p.kappa * sizeof(int32_t))
);
// out work
(a_buflen_out && l_buf) ? *a_buflen_out = (size_t)l_buflen : 0;
@@ -210,7 +210,7 @@ uint8_t *dap_enc_sig_bliss_write_private_key(const void *a_private_key, size_t *
// func work
uint64_t l_buflen = dap_enc_sig_bliss_ser_private_key_size(a_private_key);
uint32_t l_kind = l_private_key->kind;
- uint8_t *l_buf = dap_serialize_multy( NULL, l_buflen, 10,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
l_private_key->s1, (uint64_t)(p.n * sizeof(int32_t)),
@@ -233,7 +233,7 @@ uint8_t *dap_enc_sig_bliss_write_public_key(const void *a_public_key, size_t *a_
// func work
uint64_t l_buflen = dap_enc_sig_bliss_ser_public_key_size(a_public_key);
uint32_t l_kind = l_public_key->kind;
- uint8_t *l_buf = dap_serialize_multy( NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
l_public_key->a, p.n * (uint64_t)sizeof(int32_t)
diff --git a/crypto/src/dap_enc_dilithium.c b/crypto/src/dap_enc_dilithium.c
index 87a1ef2c47822e36e52719dabf5adf7adc16bcc9..c80b3805f5fc90a090ae4cc56cf02f60a555a521 100755
--- a/crypto/src/dap_enc_dilithium.c
+++ b/crypto/src/dap_enc_dilithium.c
@@ -108,7 +108,7 @@ uint8_t *dap_enc_sig_dilithium_write_signature(const void *a_sign, size_t *a_buf
dilithium_signature_t *l_sign = (dilithium_signature_t *)a_sign;
// func work
uint64_t l_buflen = dap_enc_sig_dilithium_ser_sig_size(l_sign);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 8,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_sign->kind, (uint64_t)sizeof(uint32_t),
&l_sign->sig_len, (uint64_t)sizeof(uint64_t),
@@ -192,7 +192,7 @@ uint8_t *dap_enc_sig_dilithium_write_private_key(const void *a_private_key, size
dap_return_val_if_pass(!l_private_key || !dilithium_params_init(&p, l_private_key->kind), NULL);
// func work
uint64_t l_buflen = dap_enc_sig_dilithium_ser_private_key_size(a_private_key);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_private_key->kind, (uint64_t)sizeof(uint32_t),
l_private_key->data, (uint64_t)p.CRYPTO_SECRETKEYBYTES);
@@ -211,7 +211,7 @@ uint8_t *dap_enc_sig_dilithium_write_public_key(const void *a_public_key, size_t
dap_return_val_if_pass(!l_public_key || !dilithium_params_init(&p, l_public_key->kind), NULL);
// func work
uint64_t l_buflen = dap_enc_sig_dilithium_ser_public_key_size(a_public_key);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_public_key->kind, (uint64_t)sizeof(uint32_t),
l_public_key->data, (uint64_t)p.CRYPTO_PUBLICKEYBYTES);
diff --git a/crypto/src/dap_enc_ecdsa.c b/crypto/src/dap_enc_ecdsa.c
index 4892b24354299608d07f730acedaa3780797ee70..a6ebc9504091a4dafc40793f3f6d08a37413b1d1 100644
--- a/crypto/src/dap_enc_ecdsa.c
+++ b/crypto/src/dap_enc_ecdsa.c
@@ -77,8 +77,8 @@ void dap_enc_sig_ecdsa_key_new_generate(dap_enc_key_t *a_key, UNUSED_ARG const v
// sanity check
dap_return_if_pass(!a_key);
// memory alloc
- DAP_NEW_Z_RET(a_key->priv_key_data, ecdsa_private_key_t, NULL);
- DAP_NEW_Z_RET(a_key->pub_key_data, ecdsa_public_key_t, a_key->priv_key_data);
+ a_key->priv_key_data = DAP_NEW_Z_RET_IF_FAIL(ecdsa_private_key_t);
+ a_key->pub_key_data = DAP_NEW_Z_RET_IF_FAIL(ecdsa_public_key_t, a_key->priv_key_data);
ecdsa_context_t *l_ctx = s_context_create();
if (!l_ctx) {
log_it(L_ERROR, "Error creating ECDSA context in generating key pair");
@@ -157,8 +157,7 @@ int dap_enc_sig_ecdsa_verify_sign(struct dap_enc_key *l_key, const void *a_msg,
uint8_t *dap_enc_sig_ecdsa_write_public_key(const void *a_public_key, size_t *a_buflen_out)
{
dap_return_val_if_pass(!a_public_key, NULL);
- byte_t *l_buf = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_buf, byte_t, ECDSA_PKEY_SERIALIZED_SIZE, NULL, NULL);
+ byte_t *l_buf = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(byte_t, ECDSA_PKEY_SERIALIZED_SIZE, NULL);
ecdsa_context_t *l_ctx = s_context_create();
@@ -182,12 +181,11 @@ void *dap_enc_sig_ecdsa_read_public_key(const uint8_t* a_buf, size_t a_buflen) {
// sanity check
dap_return_val_if_pass(!a_buf || a_buflen != ECDSA_PKEY_SERIALIZED_SIZE, NULL);
// memory alloc
- ecdsa_public_key_t *l_public_key = NULL;
- DAP_NEW_Z_RET_VAL(l_public_key, ecdsa_public_key_t, NULL, NULL);
+ ecdsa_public_key_t *l_public_key = DAP_NEW_Z_RET_VAL_IF_FAIL(ecdsa_public_key_t, NULL);
ecdsa_context_t *l_ctx = s_context_create();
if (!l_ctx || secp256k1_ec_pubkey_parse(l_ctx, l_public_key, a_buf, a_buflen ) != 1) {
log_it(L_CRITICAL, "Failed to deserialize pkey");
- DAP_DEL_Z(l_public_key);
+ DAP_DELETE(l_public_key);
}
return l_public_key;
}
@@ -195,8 +193,7 @@ void *dap_enc_sig_ecdsa_read_public_key(const uint8_t* a_buf, size_t a_buflen) {
uint8_t *dap_enc_sig_ecdsa_write_signature(const void *a_sign, size_t *a_sign_len)
{
dap_return_val_if_pass(!a_sign || !a_sign_len, NULL);
- byte_t *l_ret = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_ret, byte_t, sizeof(ecdsa_signature_t), NULL, NULL);
+ byte_t *l_ret = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(byte_t, sizeof(ecdsa_signature_t), NULL);
ecdsa_context_t *l_ctx = s_context_create();
if (!l_ctx || secp256k1_ecdsa_signature_serialize_compact(l_ctx, l_ret, (const ecdsa_signature_t*)a_sign) != 1) {
log_it(L_ERROR, "Failed to serialize sign");
@@ -208,9 +205,7 @@ uint8_t *dap_enc_sig_ecdsa_write_signature(const void *a_sign, size_t *a_sign_le
void *dap_enc_sig_ecdsa_read_signature(const uint8_t *a_buf, size_t a_buflen)
{
dap_return_val_if_pass(!a_buf || a_buflen != sizeof(ecdsa_signature_t), NULL);
- ecdsa_signature_t *l_ret = NULL;
- DAP_NEW_Z_RET_VAL(l_ret, ecdsa_signature_t, NULL, NULL);
-
+ ecdsa_signature_t *l_ret = DAP_NEW_Z_RET_VAL_IF_FAIL(ecdsa_signature_t, NULL);
ecdsa_context_t *l_ctx = s_context_create();
if (!l_ctx || secp256k1_ecdsa_signature_parse_compact(l_ctx, l_ret, a_buf) != 1) {
log_it(L_ERROR, "Failed to deserialize sign");
diff --git a/crypto/src/dap_enc_falcon.c b/crypto/src/dap_enc_falcon.c
index 3c2c28141f3f51a30a34acca3e4f736da5f53ece..51749aeee7b07f07cf96c9be025286acbfb02e6c 100644
--- a/crypto/src/dap_enc_falcon.c
+++ b/crypto/src/dap_enc_falcon.c
@@ -85,10 +85,10 @@ void dap_enc_sig_falcon_key_new_generate(dap_enc_key_t *a_key, const void *kex_b
a_key->pub_key_data_size = sizeof(falcon_public_key_t);
a_key->priv_key_data_size = sizeof(falcon_private_key_t);
- DAP_NEW_Z_SIZE_RET(l_skey, falcon_private_key_t, a_key->priv_key_data_size, NULL);
- DAP_NEW_Z_SIZE_RET(l_pkey, falcon_public_key_t, a_key->pub_key_data_size, l_skey);
- DAP_NEW_Z_SIZE_RET(l_skey->data, uint8_t, FALCON_PRIVKEY_SIZE(l_logn), l_skey, l_pkey);
- DAP_NEW_Z_SIZE_RET(l_pkey->data, uint8_t, FALCON_PUBKEY_SIZE(l_logn), l_skey->data, l_skey, l_pkey);
+ l_skey = DAP_NEW_Z_SIZE_RET_IF_FAIL(falcon_private_key_t, a_key->priv_key_data_size);
+ l_pkey = DAP_NEW_Z_SIZE_RET_IF_FAIL(falcon_public_key_t, a_key->pub_key_data_size, l_skey);
+ l_skey->data = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, FALCON_PRIVKEY_SIZE(l_logn), l_skey, l_pkey);
+ l_pkey->data = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, FALCON_PUBKEY_SIZE(l_logn), l_skey->data, l_skey, l_pkey);
l_skey->degree = s_falcon_sign_degree;
l_skey->kind = s_falcon_kind;
@@ -170,7 +170,7 @@ int dap_enc_sig_falcon_get_sign(dap_enc_key_t *a_key, const void *a_msg, const s
}
if (l_sig_len)
- DAP_NEW_Z_SIZE_RET_VAL(l_sig->sig_data, byte_t, l_sig_len, -1, NULL);
+ l_sig->sig_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(byte_t, l_sig_len, -1);
l_ret = falcon_sign_dyn(
&l_rng,
@@ -241,7 +241,7 @@ uint8_t *dap_enc_sig_falcon_write_public_key(const void *a_public_key, size_t *a
// func work
falcon_public_key_t *l_public_key = (falcon_public_key_t *)a_public_key;
uint64_t l_buflen = dap_enc_sig_falcon_ser_public_key_size(a_public_key);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 10,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_public_key->degree, (uint64_t)sizeof(uint32_t),
&l_public_key->kind, (uint64_t)sizeof(uint32_t),
@@ -266,7 +266,7 @@ uint8_t *dap_enc_sig_falcon_write_private_key(const void *a_private_key, size_t
// func work
falcon_private_key_t *l_private_key = (falcon_private_key_t *)a_private_key;
uint64_t l_buflen = dap_enc_sig_falcon_ser_private_key_size(a_private_key);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 10,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_private_key->degree, (uint64_t)sizeof(uint32_t),
&l_private_key->kind, (uint64_t)sizeof(uint32_t),
@@ -286,11 +286,10 @@ void *dap_enc_sig_falcon_read_private_key(const uint8_t *a_buf, size_t a_buflen)
uint64_t l_buflen = 0;
uint64_t l_skey_len = a_buflen - sizeof(uint64_t) - sizeof(uint32_t) * 3;
- falcon_private_key_t *l_skey = NULL;
- DAP_NEW_Z_RET_VAL(l_skey, falcon_private_key_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_skey->data, uint8_t, l_skey_len, NULL, l_skey);
+ falcon_private_key_t *l_skey = DAP_NEW_Z_RET_VAL_IF_FAIL(falcon_private_key_t, NULL);
+ l_skey->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_skey_len, NULL, l_skey);
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 10,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_skey->degree, (uint64_t)sizeof(uint32_t),
&l_skey->kind, (uint64_t)sizeof(uint32_t),
@@ -320,11 +319,10 @@ void *dap_enc_sig_falcon_read_public_key(const uint8_t *a_buf, size_t a_buflen)
uint64_t l_buflen = 0;
uint64_t l_pkey_len = a_buflen - sizeof(uint64_t) - sizeof(uint32_t) * 3;
- falcon_public_key_t *l_pkey = NULL;
- DAP_NEW_Z_RET_VAL(l_pkey, falcon_public_key_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_pkey->data, uint8_t, l_pkey_len, NULL, l_pkey);
+ falcon_public_key_t *l_pkey = DAP_NEW_Z_RET_VAL_IF_FAIL(falcon_public_key_t, NULL);
+ l_pkey->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_pkey_len, NULL, l_pkey);
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 10,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_pkey->degree, (uint64_t)sizeof(uint32_t),
&l_pkey->kind, (uint64_t)sizeof(uint32_t),
@@ -354,7 +352,7 @@ uint8_t *dap_enc_sig_falcon_write_signature(const void *a_sign, size_t *a_buflen
falcon_signature_t *l_sign = (falcon_signature_t*)a_sign;
// func work
uint64_t l_buflen = dap_enc_sig_falcon_ser_sig_size(a_sign);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 12,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_sign->degree, (uint64_t)sizeof(uint32_t),
&l_sign->kind, (uint64_t)sizeof(uint32_t),
@@ -375,11 +373,10 @@ void *dap_enc_sig_falcon_read_signature(const uint8_t* a_buf, size_t a_buflen)
uint64_t l_buflen = 0;
uint64_t l_sig_len = a_buflen - sizeof(uint64_t) * 2 - sizeof(uint32_t) * 3;
- falcon_signature_t *l_sign = NULL;
- DAP_NEW_Z_RET_VAL(l_sign, falcon_signature_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->sig_data, uint8_t, l_sig_len, NULL, l_sign);
+ falcon_signature_t *l_sign = DAP_NEW_Z_RET_VAL_IF_FAIL(falcon_signature_t, NULL);
+ l_sign->sig_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_sig_len, NULL, l_sign);
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 12,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_sign->degree, (uint64_t)sizeof(uint32_t),
&l_sign->kind, (uint64_t)sizeof(uint32_t),
diff --git a/crypto/src/dap_enc_key.c b/crypto/src/dap_enc_key.c
index d07154bc2c65d14459fce6ec0fae588dc378691a..6d03ea5276f6cceb32701c49cb08769196dbeb81 100755
--- a/crypto/src/dap_enc_key.c
+++ b/crypto/src/dap_enc_key.c
@@ -633,9 +633,7 @@ uint8_t *dap_enc_key_serialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_si
l_data = s_callbacks[a_key_type].ser_sign(a_sign, a_sign_len);
break;
default:
- dap_return_val_if_pass(!a_sign || !a_sign_len || !(*a_sign_len), NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, *a_sign_len, NULL, NULL);
- memcpy(l_data, a_sign, *a_sign_len);
+ dap_return_val_if_fail(a_sign && a_sign_len && *a_sign_len && ( l_data = DAP_DUP_SIZE(a_sign, *a_sign_len) ), NULL);
}
return l_data;
}
@@ -670,9 +668,7 @@ uint8_t* dap_enc_key_deserialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_
*a_sign_len = s_callbacks[a_key_type].deser_sign_size(NULL);
break;
default:
- dap_return_val_if_pass(!a_sign || !(*a_sign_len), NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, *a_sign_len, NULL, NULL);
- memcpy(l_data, a_sign, *a_sign_len);
+ dap_return_val_if_fail(a_sign && *a_sign_len && ( l_data = DAP_DUP_SIZE(a_sign, *a_sign_len) ), NULL);
}
return l_data;
}
@@ -687,7 +683,7 @@ uint8_t* dap_enc_key_deserialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_
*/
uint8_t* dap_enc_key_serialize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_out)
{
- dap_return_val_if_pass(!a_key || !a_key->priv_key_data_size, NULL);
+ dap_return_val_if_pass(!a_key || !a_key->priv_key_data_size || !a_key->priv_key_data, NULL);
uint8_t *l_data = NULL;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
@@ -702,10 +698,9 @@ uint8_t* dap_enc_key_serialize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_o
l_data = s_callbacks[a_key->type].ser_priv_key(a_key->priv_key_data, a_buflen_out);
break;
default:
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, a_key->priv_key_data_size, NULL, NULL);
- memcpy(l_data, a_key->priv_key_data, a_key->priv_key_data_size);
+ l_data = DAP_DUP_SIZE(a_key->priv_key_data, a_key->priv_key_data_size);
if(a_buflen_out)
- *a_buflen_out = a_key->priv_key_data_size;
+ *a_buflen_out = l_data ? a_key->priv_key_data_size : 0;
}
return l_data;
}
@@ -720,7 +715,7 @@ uint8_t* dap_enc_key_serialize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_o
uint8_t* dap_enc_key_serialize_pub_key(dap_enc_key_t *a_key, size_t *a_buflen_out)
{
// sanity check
- dap_return_val_if_pass(!a_key || !a_key->pub_key_data, NULL);
+ dap_return_val_if_pass(!a_key || !a_key->pub_key_data || !a_key->pub_key_data_size, NULL);
// func work
uint8_t *l_data = NULL;
switch (a_key->type) {
@@ -737,10 +732,9 @@ uint8_t* dap_enc_key_serialize_pub_key(dap_enc_key_t *a_key, size_t *a_buflen_ou
l_data = s_callbacks[a_key->type].ser_pub_key(a_key->pub_key_data, a_buflen_out);
break;
default:
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, a_key->pub_key_data_size, NULL, NULL);
- memcpy(l_data, a_key->pub_key_data, a_key->pub_key_data_size);
+ l_data = DAP_DUP_SIZE(a_key->pub_key_data, a_key->pub_key_data_size);
if(a_buflen_out)
- *a_buflen_out = a_key->pub_key_data_size;
+ *a_buflen_out = l_data ? a_key->pub_key_data_size : 0;
}
return l_data;
}
@@ -789,10 +783,14 @@ int dap_enc_key_deserialize_priv_key(dap_enc_key_t *a_key, const uint8_t *a_buf,
}
break;
default:
- DAP_DEL_Z(a_key->priv_key_data);
- a_key->priv_key_data_size = a_buflen;
- DAP_NEW_Z_SIZE_RET_VAL(a_key->priv_key_data, uint8_t, a_key->priv_key_data_size, -4, NULL);
- memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
+ if (!a_key->priv_key_data || a_key->priv_key_data_size != a_buflen) {
+ void *l_new_key = DAP_REALLOC((byte_t*)a_key->priv_key_data, a_buflen);
+ if ( !l_new_key )
+ return log_it(L_CRITICAL, "%s", c_error_memory_alloc), -1;
+ a_key->priv_key_data = l_new_key;
+ a_key->priv_key_data_size = a_buflen;
+ }
+ memcpy(a_key->priv_key_data, a_buf, a_buflen);
}
dap_enc_key_update(a_key);
return 0;
@@ -844,10 +842,14 @@ int dap_enc_key_deserialize_pub_key(dap_enc_key_t *a_key, const uint8_t *a_buf,
}
break;
default:
- DAP_DEL_Z(a_key->pub_key_data);
- a_key->pub_key_data_size = a_buflen;
- DAP_NEW_Z_SIZE_RET_VAL(a_key->pub_key_data, uint8_t, a_key->pub_key_data_size, -1, NULL);
- memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
+ if (!a_key->pub_key_data || a_key->pub_key_data_size != a_buflen) {
+ void *l_new_pkey = DAP_REALLOC((byte_t*)a_key->pub_key_data, a_buflen);
+ if ( !l_new_pkey )
+ return log_it(L_CRITICAL, "%s", c_error_memory_alloc), -1;
+ a_key->pub_key_data = l_new_pkey;
+ a_key->pub_key_data_size = a_buflen;
+ }
+ memcpy(a_key->pub_key_data, a_buf, a_buflen);
}
dap_enc_key_update(a_key);
return 0;
@@ -867,7 +869,7 @@ uint8_t *dap_enc_key_serialize(dap_enc_key_t *a_key, size_t *a_buflen)
uint8_t *l_ser_skey = dap_enc_key_serialize_priv_key(a_key, (size_t *)&l_ser_skey_size);
uint8_t *l_ser_pkey = dap_enc_key_serialize_pub_key(a_key, (size_t *)&l_ser_pkey_size);
uint64_t l_buflen = sizeof(uint64_t) * 5 + sizeof(int32_t) + l_ser_skey_size + l_ser_pkey_size + a_key->_inheritor_size;
- uint8_t *l_ret = dap_serialize_multy(NULL, l_buflen, 18,
+ uint8_t *l_ret = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_ser_skey_size, (uint64_t)sizeof(uint64_t),
&l_ser_pkey_size, (uint64_t)sizeof(uint64_t),
@@ -900,7 +902,7 @@ dap_enc_key_t *dap_enc_key_deserialize(const void *buf, size_t a_buf_size)
uint64_t l_timestamp = 0, l_ser_skey_size = 0, l_ser_pkey_size = 0, l_ser_inheritor_size = 0, l_buflen = 0;
uint8_t *l_ser_skey = NULL, *l_ser_pkey = NULL;
// get sizes
- int l_res_des = dap_deserialize_multy((const uint8_t *)buf, l_sizes_len, 12,
+ int l_res_des = DAP_VA_DESERIALIZE(buf, l_sizes_len,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_ser_skey_size, (uint64_t)sizeof(uint64_t),
&l_ser_pkey_size, (uint64_t)sizeof(uint64_t),
@@ -919,22 +921,25 @@ dap_enc_key_t *dap_enc_key_deserialize(const void *buf, size_t a_buf_size)
return NULL;
}
if (l_ser_skey_size)
- DAP_NEW_Z_SIZE_RET_VAL(l_ser_skey, uint8_t, l_ser_skey_size, NULL, l_ret);
+ l_ser_skey = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_ser_skey_size, NULL, l_ret);
if (l_ser_pkey_size)
- DAP_NEW_Z_SIZE_RET_VAL(l_ser_pkey, uint8_t, l_ser_pkey_size, NULL, l_ser_skey, l_ret);
+ l_ser_pkey = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_ser_pkey_size, NULL, l_ser_skey, l_ret);
if (l_ser_inheritor_size)
- DAP_NEW_Z_SIZE_RET_VAL(l_ret->_inheritor, void, l_ser_inheritor_size, NULL, l_ser_pkey, l_ser_skey, l_ret);
+ l_ret->_inheritor = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(void, l_ser_inheritor_size, NULL, l_ser_pkey, l_ser_skey, l_ret);
// deser keys
- l_res_des = dap_deserialize_multy((const uint8_t *)(buf + l_sizes_len), (uint64_t)(a_buf_size - l_sizes_len), 6,
+ l_res_des = DAP_VA_DESERIALIZE( ((uint8_t*)buf) + l_sizes_len, (uint64_t)(a_buf_size - l_sizes_len),
l_ser_skey, (uint64_t)l_ser_skey_size,
l_ser_pkey, (uint64_t)l_ser_pkey_size,
(uint8_t *)l_ret->_inheritor, (uint64_t)l_ser_inheritor_size
);
- if (l_res_des || (l_ser_pkey_size && dap_enc_key_deserialize_pub_key(l_ret, l_ser_pkey, l_ser_pkey_size)) || (l_ser_skey_size && dap_enc_key_deserialize_priv_key(l_ret, l_ser_skey, l_ser_skey_size)) ) {
- DAP_DEL_MULTY(l_ret->_inheritor, l_ser_pkey, l_ser_skey, l_ret);
- log_it(L_ERROR, "Enc_key pub and priv keys deserialisation error");
- return NULL;
- }
+ if (l_res_des
+ || (l_ser_pkey_size && dap_enc_key_deserialize_pub_key(l_ret, l_ser_pkey, l_ser_pkey_size))
+ || (l_ser_skey_size && dap_enc_key_deserialize_priv_key(l_ret, l_ser_skey, l_ser_skey_size)) )
+ {
+ DAP_DEL_MULTY(l_ret->_inheritor, l_ser_pkey, l_ser_skey, l_ret);
+ log_it(L_ERROR, "Enc_key pub and priv keys deserialisation error");
+ return NULL;
+ }
// out work
l_ret->last_used_timestamp = l_timestamp;
l_ret->_inheritor_size = l_ser_inheritor_size;
@@ -966,12 +971,8 @@ dap_enc_key_t *dap_enc_key_dup(dap_enc_key_t *a_key)
*/
dap_enc_key_t *dap_enc_key_new(dap_enc_key_type_t a_key_type)
{
-// sanity check
dap_return_val_if_pass(DAP_ENC_KEY_TYPE_INVALID == a_key_type, NULL);
-// memory alloc
- dap_enc_key_t * l_ret = NULL;
- DAP_NEW_Z_RET_VAL(l_ret, dap_enc_key_t, NULL, NULL);
-// func work
+ dap_enc_key_t * l_ret = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_enc_key_t, NULL);
if(s_callbacks[a_key_type].new_callback){
s_callbacks[a_key_type].new_callback(l_ret);
} else {
@@ -1124,11 +1125,9 @@ void dap_enc_key_delete(dap_enc_key_t * a_key)
*/
size_t dap_enc_key_get_enc_size(dap_enc_key_type_t a_key_type, const size_t a_buf_in_size)
{
- if(s_callbacks[a_key_type].enc_out_size) {
- return s_callbacks[a_key_type].enc_out_size(a_buf_in_size);
- }
- log_it(L_ERROR, "No callback for enc_out_size to %s enc key", dap_enc_get_type_name(a_key_type));
- return 0;
+ return a_buf_in_size && s_callbacks[a_key_type].enc_out_size
+ ? s_callbacks[a_key_type].enc_out_size(a_buf_in_size)
+ : ( log_it(L_ERROR, "No enc_out_size() function for key %s", dap_enc_get_type_name(a_key_type)), 0 );
}
/**
@@ -1139,25 +1138,19 @@ size_t dap_enc_key_get_enc_size(dap_enc_key_type_t a_key_type, const size_t a_bu
*/
size_t dap_enc_key_get_dec_size(dap_enc_key_type_t a_key_type, const size_t a_buf_in_size)
{
- if(s_callbacks[a_key_type].dec_out_size) {
- return s_callbacks[a_key_type].dec_out_size(a_buf_in_size);
- }
- log_it(L_ERROR, "No callback for dec_out_size to %s enc key", dap_enc_get_type_name(a_key_type));
- return 0;
+ return a_buf_in_size && s_callbacks[a_key_type].dec_out_size
+ ? s_callbacks[a_key_type].dec_out_size(a_buf_in_size)
+ : ( log_it(L_ERROR, "No dec_out_size() function for key %s", dap_enc_get_type_name(a_key_type)), 0 );
}
const char *dap_enc_get_type_name(dap_enc_key_type_t a_key_type)
{
- if(a_key_type >= DAP_ENC_KEY_TYPE_NULL && a_key_type <= DAP_ENC_KEY_TYPE_LAST) {
- if(s_callbacks[a_key_type].name) {
- return s_callbacks[a_key_type].name;
- }
- }
- log_it(L_WARNING, "Name was not set for key type %d", a_key_type);
- return "UNDEFINED";
+ return a_key_type >= DAP_ENC_KEY_TYPE_NULL && a_key_type <= DAP_ENC_KEY_TYPE_LAST && *s_callbacks[a_key_type].name
+ ? s_callbacks[a_key_type].name
+ : ( log_it(L_WARNING, "Name was not set for key type %d", a_key_type), "undefined");
}
-dap_enc_key_type_t dap_enc_key_type_find_by_name(const char * a_name){
+dap_enc_key_type_t dap_enc_key_type_find_by_name(const char * a_name){ // TODO: use uthash
for(dap_enc_key_type_t i = 0; i <= DAP_ENC_KEY_TYPE_LAST; i++){
const char * l_current_key_name = dap_enc_get_type_name(i);
if(l_current_key_name && !strcmp(a_name, l_current_key_name))
@@ -1192,7 +1185,6 @@ size_t dap_enc_calc_signature_unserialized_size(dap_enc_key_t *a_key)
#endif
default :
log_it(L_ERROR, "Can't signature deserialize size calc to %s enc key", dap_enc_get_type_name(a_key->type));
- return 0;
}
return 0;
}
diff --git a/crypto/src/dap_enc_kyber.c b/crypto/src/dap_enc_kyber.c
index 6263463d6ed49e2cbdeed17959ebec3ee389033d..23c969e9a70055631089cfb085c534940e728966 100644
--- a/crypto/src/dap_enc_kyber.c
+++ b/crypto/src/dap_enc_kyber.c
@@ -47,18 +47,13 @@ void dap_enc_kyber512_key_generate(dap_enc_key_t *a_key, UNUSED_ARG const void *
UNUSED_ARG size_t a_kex_size, UNUSED_ARG const void *a_seed,
UNUSED_ARG size_t a_seed_size, UNUSED_ARG size_t a_key_size)
{
-// input check
dap_return_if_pass(!a_key);
-// memory alloc
- uint8_t *l_skey, *l_pkey;
- DAP_NEW_Z_SIZE_RET(l_skey, uint8_t, CRYPTO_SECRETKEYBYTES, NULL);
- DAP_NEW_Z_SIZE_RET(l_pkey, uint8_t, CRYPTO_PUBLICKEYBYTES, l_skey);
-// crypto calc
+ uint8_t *l_skey = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, CRYPTO_SECRETKEYBYTES),
+ *l_pkey = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, CRYPTO_PUBLICKEYBYTES, l_skey);
if (crypto_kem_keypair(l_pkey, l_skey)) {
DAP_DEL_MULTY(l_pkey, l_skey);
return;
}
-// post func work, change in args only after all pass
DAP_DEL_MULTY(a_key->_inheritor, a_key->pub_key_data);
a_key->_inheritor = l_skey;
a_key->pub_key_data = l_pkey;
@@ -95,9 +90,8 @@ size_t dap_enc_kyber512_gen_bob_shared_key (dap_enc_key_t *a_bob_key, const void
// sanity check
dap_return_val_if_pass(!a_bob_key || !a_alice_pub || !a_cypher_msg || a_alice_pub_size < CRYPTO_PUBLICKEYBYTES, 0);
// memory alloc
- uint8_t *l_shared_key, *l_cypher_msg;
- DAP_NEW_Z_SIZE_RET_VAL(l_shared_key, uint8_t, CRYPTO_BYTES, 0, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_cypher_msg, uint8_t, CRYPTO_CIPHERTEXTBYTES, 0, l_shared_key);
+ uint8_t *l_shared_key = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, CRYPTO_BYTES, 0),
+ *l_cypher_msg = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, CRYPTO_CIPHERTEXTBYTES, 0, l_shared_key);
// crypto calc
if(crypto_kem_enc(l_cypher_msg, l_shared_key, a_alice_pub)) {
DAP_DEL_MULTY(l_cypher_msg, l_shared_key);
@@ -126,13 +120,10 @@ size_t dap_enc_kyber512_gen_alice_shared_key(dap_enc_key_t *a_alice_key, UNUSED_
// sanity check
dap_return_val_if_pass(!a_alice_key || !a_cypher_msg || a_cypher_msg_size < CRYPTO_CIPHERTEXTBYTES, 0);
// memory alloc
- uint8_t *l_shared_key = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_shared_key, uint8_t, CRYPTO_BYTES, 0, NULL);
+ uint8_t *l_shared_key = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, CRYPTO_BYTES, 0);
// crypto calc
- if (crypto_kem_dec(l_shared_key, a_cypher_msg, a_alice_key->_inheritor) ) {
- DAP_DEL_Z(l_shared_key);
- return 0;
- }
+ if ( crypto_kem_dec(l_shared_key, a_cypher_msg, a_alice_key->_inheritor) )
+ return DAP_DELETE(l_shared_key), 0;
// post func work
DAP_DEL_Z(a_alice_key->shared_key);
a_alice_key->shared_key = l_shared_key;
diff --git a/crypto/src/dap_enc_msrln.c b/crypto/src/dap_enc_msrln.c
index 037b25d6aa0c975cf070512ce55a9f6ed2e57406..59a2482d6f08a300fb24fb53420d3762e80a4c23 100755
--- a/crypto/src/dap_enc_msrln.c
+++ b/crypto/src/dap_enc_msrln.c
@@ -58,11 +58,8 @@ void dap_enc_msrln_key_generate(dap_enc_key_t *a_key, UNUSED_ARG const void *a_k
{
// sanity check
dap_return_if_pass(!a_key);
-// memory alloc
- uint8_t *l_skey, *l_pkey;
- DAP_NEW_Z_SIZE_RET(l_skey, uint8_t, MSRLN_PKA_BYTES * sizeof(uint32_t), NULL);
- DAP_NEW_Z_SIZE_RET(l_pkey, uint8_t, MSRLN_PKA_BYTES, l_skey);
-// crypto calc
+ uint8_t *l_skey = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, MSRLN_PKA_BYTES * sizeof(int32_t)),
+ *l_pkey = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, MSRLN_PKA_BYTES, l_skey);
PLatticeCryptoStruct PLCS = LatticeCrypto_allocate();
LatticeCrypto_initialize(PLCS, (RandomBytes)randombytes, MSRLN_generate_a, MSRLN_get_error);
if (MSRLN_KeyGeneration_A((int32_t *) l_skey, l_pkey, PLCS) != CRYPTO_MSRLN_SUCCESS) {
@@ -93,9 +90,8 @@ size_t dap_enc_msrln_gen_bob_shared_key(dap_enc_key_t *a_bob_key, const void *a_
// sanity check
dap_return_val_if_pass(!a_bob_key || !a_alice_pub || !a_cypher_msg || a_alice_pub_size != MSRLN_PKA_BYTES, 0);
// memory alloc
- uint8_t *l_shared_key, *l_cypher_msg;
- DAP_NEW_Z_SIZE_RET_VAL(l_shared_key, uint8_t, MSRLN_SHAREDKEY_BYTES, 0, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_cypher_msg, uint8_t, MSRLN_PKB_BYTES, 0, l_shared_key);
+ uint8_t *l_shared_key = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, MSRLN_SHAREDKEY_BYTES, 0),
+ *l_cypher_msg = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, MSRLN_PKB_BYTES, 0, l_shared_key);
// crypto calc
PLatticeCryptoStruct PLCS = LatticeCrypto_allocate();
LatticeCrypto_initialize(PLCS, (RandomBytes)randombytes, MSRLN_generate_a, MSRLN_get_error);
@@ -129,8 +125,7 @@ size_t dap_enc_msrln_gen_alice_shared_key(dap_enc_key_t *a_alice_key, const void
// sanity check
dap_return_val_if_pass(!a_alice_key || !a_alice_priv || !a_cypher_msg || a_cypher_msg_size < MSRLN_PKB_BYTES, 0);
// memory alloc
- uint8_t *l_shared_key = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_shared_key, uint8_t, MSRLN_SHAREDKEY_BYTES, 0, NULL);
+ uint8_t *l_shared_key = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, MSRLN_SHAREDKEY_BYTES, 0);
// crypto calc
if (MSRLN_SecretAgreement_A(a_cypher_msg, (int32_t *) a_alice_priv, l_shared_key) != CRYPTO_MSRLN_SUCCESS) {
DAP_DEL_Z(l_shared_key);
diff --git a/crypto/src/dap_enc_multisign.c b/crypto/src/dap_enc_multisign.c
index 143a1756c18bf6161af97627277f78a7117f6070..e7914b477e6452d67681867fd159f961e36ff4ab 100755
--- a/crypto/src/dap_enc_multisign.c
+++ b/crypto/src/dap_enc_multisign.c
@@ -61,11 +61,9 @@ void dap_enc_sig_multisign_key_new_generate(dap_enc_key_t *a_key, const void *a_
void dap_enc_sig_multisign_key_delete(dap_enc_key_t *a_key)
{
dap_return_if_pass(!a_key);
- DAP_DEL_Z(a_key->priv_key_data);
- DAP_DEL_Z(a_key->pub_key_data);
- a_key->priv_key_data_size = 0;
- a_key->pub_key_data_size = 0;
- dap_multi_sign_params_delete((dap_multi_sign_params_t *)a_key->_pvt);
+ DAP_DEL_MULTY(a_key->priv_key_data, a_key->pub_key_data);
+ a_key->priv_key_data_size = a_key->pub_key_data_size = 0;
+ dap_multi_sign_params_delete((dap_multi_sign_params_t*)a_key->_pvt);
}
/**
@@ -111,8 +109,8 @@ int dap_enc_sig_multisign_forming_keys(dap_enc_key_t *a_key, const dap_multi_sig
l_skey_len += dap_enc_ser_priv_key_size(a_params->keys[i]);
l_pkey_len += dap_enc_ser_pub_key_size(a_params->keys[i]);
}
- DAP_NEW_Z_SIZE_RET_VAL(l_skey, dap_multisign_private_key_t, l_skey_len, -1, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_pkey, dap_multisign_public_key_t, l_pkey_len, -1, l_skey);
+ l_skey = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_multisign_private_key_t, l_skey_len, -1);
+ l_pkey = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_multisign_public_key_t, l_pkey_len, -1, l_skey);
// func work
uint64_t l_mem_bias_skey = 0;
uint64_t l_mem_bias_pkey = 0;
@@ -153,7 +151,7 @@ uint8_t *dap_enc_sig_multisign_write_signature(const void *a_sign, size_t *a_out
uint64_t l_signes_size, l_pkeys_hashes_size;
uint64_t l_out_len = s_multi_sign_calc_size(l_sign, &l_signes_size, &l_pkeys_hashes_size) + sizeof(uint64_t) * 3;
*a_out_len = l_out_len;
- uint8_t *l_ret = dap_serialize_multy(NULL, l_out_len, 20,
+ uint8_t *l_ret = DAP_VA_SERIALIZE_NEW(l_out_len,
&l_out_len, (uint64_t)sizeof(uint64_t),
&l_pkeys_hashes_size, (uint64_t)sizeof(uint64_t),
&l_signes_size, (uint64_t)sizeof(uint64_t),
@@ -176,16 +174,11 @@ uint8_t *dap_enc_sig_multisign_write_signature(const void *a_sign, size_t *a_out
*/
void *dap_enc_sig_multisign_read_signature(const uint8_t *a_sign, size_t a_sign_len)
{
-// sanity check
uint64_t l_mem_shift = sizeof(uint64_t) * 3 + sizeof(dap_sign_type_t) + sizeof(uint8_t) * 2;
dap_return_val_if_pass(!a_sign || a_sign_len < l_mem_shift, NULL);
-// func work
- dap_multi_sign_t *l_sign = NULL;
+ dap_multi_sign_t *l_sign = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_multi_sign_t, NULL);
uint64_t l_sign_len = 0, l_pkeys_size = 0, l_signes_size = 0, l_pkeys_hashes_size = 0;
-// base allocate memory
- DAP_NEW_Z_RET_VAL(l_sign, dap_multi_sign_t, NULL, NULL);
-// get sizes
- int l_res_des = dap_deserialize_multy(a_sign, l_mem_shift, 12,
+ int l_res_des = DAP_VA_DESERIALIZE(a_sign, l_mem_shift,
&l_sign_len, (uint64_t)sizeof(uint64_t),
&l_pkeys_hashes_size, (uint64_t)sizeof(uint64_t),
&l_signes_size, (uint64_t)sizeof(uint64_t),
@@ -199,12 +192,12 @@ void *dap_enc_sig_multisign_read_signature(const uint8_t *a_sign, size_t a_sign_
return NULL;
}
// addtional allocation memory
- DAP_NEW_Z_COUNT_RET_VAL(l_sign->key_seq, uint8_t, l_sign->sign_count, NULL, l_sign);
- DAP_NEW_Z_COUNT_RET_VAL(l_sign->meta, dap_multi_sign_meta_t, l_sign->sign_count, NULL, l_sign->key_seq, l_sign);
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->key_hashes, dap_hash_fast_t, l_pkeys_hashes_size, NULL, l_sign->meta, l_sign->key_seq, l_sign);
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->sign_data, uint8_t, l_signes_size, NULL, l_sign->key_hashes, l_sign->meta, l_sign->key_seq, l_sign);
+ l_sign->key_seq = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_sign->sign_count, NULL, l_sign);
+ l_sign->meta = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_multi_sign_meta_t, l_sign->sign_count, NULL, l_sign->key_seq, l_sign);
+ l_sign->key_hashes = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_hash_fast_t, l_pkeys_hashes_size, NULL, l_sign->meta, l_sign->key_seq, l_sign);
+ l_sign->sign_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_signes_size, NULL, l_sign->key_hashes, l_sign->meta, l_sign->key_seq, l_sign);
// get data
- l_res_des = dap_deserialize_multy(a_sign + l_mem_shift, l_sign_len - l_mem_shift, 8,
+ l_res_des = DAP_VA_DESERIALIZE(a_sign + l_mem_shift, l_sign_len - l_mem_shift,
l_sign->key_seq, (uint64_t)(sizeof(uint8_t) * l_sign->sign_count),
l_sign->meta, (uint64_t)(sizeof(dap_multi_sign_meta_t) * l_sign->sign_count),
l_sign->key_hashes, (uint64_t)l_pkeys_hashes_size,
@@ -232,10 +225,9 @@ dap_multi_sign_params_t *dap_multi_sign_params_make(dap_sign_type_enum_t a_type,
// sanity check
dap_return_val_if_pass(a_type != SIG_TYPE_MULTI_CHAINED && a_type != SIG_TYPE_MULTI_COMBINED, NULL);
// memory alloc
- dap_multi_sign_params_t *l_params = NULL;
- DAP_NEW_Z_RET_VAL(l_params, dap_multi_sign_params_t, NULL, NULL);
- DAP_NEW_Z_COUNT_RET_VAL(l_params->keys, dap_enc_key_t *, a_key_count, NULL, l_params);
- DAP_NEW_Z_COUNT_RET_VAL(l_params->key_seq, uint8_t, a_sign_count, NULL, l_params->keys, l_params);
+ dap_multi_sign_params_t *l_params = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_multi_sign_params_t, NULL);
+ l_params->keys = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_enc_key_t*, a_key_count, NULL, l_params);
+ l_params->key_seq = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, a_sign_count, NULL, l_params->keys, l_params);
// func work
l_params->type.type = a_type;
l_params->key_count = a_key_count;
@@ -259,7 +251,8 @@ dap_multi_sign_params_t *dap_multi_sign_params_make(dap_sign_type_enum_t a_type,
*/
void dap_multi_sign_params_delete(dap_multi_sign_params_t *a_params)
{
- dap_return_if_pass(!a_params);
+ if (!a_params)
+ return;
for (size_t i = 0; i < a_params->key_count; ++i) {
dap_enc_key_delete(a_params->keys[i]);
}
@@ -276,27 +269,19 @@ void dap_multi_sign_params_delete(dap_multi_sign_params_t *a_params)
*/
bool dap_multi_sign_hash_data(dap_multi_sign_t *a_sign, const void *a_data, const size_t a_data_size, dap_chain_hash_fast_t *a_hash)
{
-// sanity check
dap_return_val_if_pass(!a_sign, false);
-// memory alloc
- uint8_t *l_meta_data = NULL;
- uint8_t *l_concatenated_hash = NULL;
uint32_t l_meta_data_size = sizeof(dap_sign_type_t) + 2 * sizeof(uint8_t) + a_sign->sign_count * sizeof(uint8_t);
- DAP_NEW_Z_SIZE_RET_VAL(l_concatenated_hash, uint8_t, 3 * sizeof(dap_chain_hash_fast_t), false, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_meta_data, uint8_t, l_meta_data_size, false, l_concatenated_hash);
-// func work
- bool l_ret = (bool)dap_serialize_multy(l_meta_data, l_meta_data_size, 8,
- &a_sign->type, (uint64_t)sizeof(dap_sign_type_t),
- &a_sign->key_count, (uint64_t)sizeof(uint8_t),
- &a_sign->sign_count, (uint64_t)sizeof(uint8_t),
- a_sign->key_seq, (uint64_t)(a_sign->sign_count * sizeof(uint8_t))
- );
+ uint8_t l_meta_data[l_meta_data_size], l_concatenated_hash[ 3 * sizeof(dap_chain_hash_fast_t) ] = { };
+
+ bool l_ret = !!DAP_VA_SERIALIZE(l_meta_data, l_meta_data_size,
+ &a_sign->type, (uint64_t)sizeof(dap_sign_type_t),
+ &a_sign->key_count, (uint64_t)sizeof(uint8_t),
+ &a_sign->sign_count, (uint64_t)sizeof(uint8_t),
+ a_sign->key_seq, (uint64_t)(a_sign->sign_count * sizeof(uint8_t)));
l_ret ? l_ret &= dap_hash_fast(a_data, a_data_size, (dap_chain_hash_fast_t *)l_concatenated_hash) : 0; // get data hash
- l_ret ? l_ret &= dap_hash_fast(l_meta_data, l_meta_data_size, (dap_chain_hash_fast_t *)(l_concatenated_hash + sizeof(dap_chain_hash_fast_t))) : 0; // get metadata hash
+ l_ret ? l_ret &= dap_hash_fast(l_meta_data, l_meta_data_size, (dap_chain_hash_fast_t*)(l_concatenated_hash + sizeof(dap_chain_hash_fast_t))) : 0; // get metadata hash
l_ret ? l_ret &= dap_hash_fast(a_sign->key_hashes, a_sign->key_count * sizeof(dap_chain_hash_fast_t), (dap_chain_hash_fast_t *)(l_concatenated_hash + 2 * sizeof(dap_chain_hash_fast_t))) : 0; // get key_hashes hash
l_ret ? l_ret &= dap_hash_fast(l_concatenated_hash, 3 * sizeof(dap_chain_hash_fast_t), a_hash) : 0; // get out hash of calculated hashes
-// out work
- DAP_DEL_MULTY(l_meta_data, l_concatenated_hash);
return l_ret;
}
@@ -315,9 +300,9 @@ int dap_enc_sig_multisign_get_sign(dap_enc_key_t *a_key, const void *a_msg_in, c
dap_return_val_if_pass(!l_params || !l_params->key_count || l_params->type.type != SIG_TYPE_MULTI_CHAINED, -1);
// memory alloc
dap_multi_sign_t *l_sign = a_sign_out;
- DAP_NEW_Z_COUNT_RET_VAL(l_sign->key_hashes, dap_chain_hash_fast_t, l_params->key_count, -6, NULL);
- DAP_NEW_Z_COUNT_RET_VAL(l_sign->key_seq, uint8_t, l_params->sign_count, -4, l_sign->key_hashes);
- DAP_NEW_Z_COUNT_RET_VAL(l_sign->meta, dap_multi_sign_meta_t, l_params->sign_count, -5, l_sign->key_seq, l_sign->key_hashes);
+ l_sign->key_hashes = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_chain_hash_fast_t, l_params->key_count, -6);
+ l_sign->key_seq = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_params->sign_count, -4, l_sign->key_hashes);
+ l_sign->meta = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_multi_sign_meta_t, l_params->sign_count, -5, l_sign->key_seq, l_sign->key_hashes);
// data prepare
l_sign->type = l_params->type;
l_sign->key_count = l_params->key_count;
@@ -398,15 +383,13 @@ int dap_enc_sig_multisign_verify_sign(dap_enc_key_t *a_key, const void *a_msg, c
dap_multisign_public_key_t *l_pkeys = a_key->pub_key_data;
size_t l_pkey_size = l_sign->meta[i].sign_header.sign_pkey_size;
size_t l_sign_size = l_sign->meta[i].sign_header.sign_size;
- dap_sign_t *l_step_sign = NULL;
+ dap_sign_t *l_step_sign = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_sign_t, sizeof(dap_sign_hdr_t) + l_pkey_size + l_sign_size, -1);
int l_verified = 0;
// get multisign hash data
if (!i && !dap_multi_sign_hash_data(l_sign, a_msg, a_msg_size, &l_data_hash)) {
log_it (L_ERROR, "Can't create multi-signature hash");
- return -3;
+ return DAP_DELETE(l_step_sign), -3;
}
- // create step sign and verify data
- DAP_NEW_Z_SIZE_RET_VAL(l_step_sign, dap_sign_t, sizeof(dap_sign_hdr_t) + l_pkey_size + l_sign_size, -1, NULL);
l_step_sign->header = l_sign->meta[i].sign_header;
memcpy(l_step_sign->pkey_n_sign, l_pkeys->data + l_pkeys_mem_shift, l_pkey_size);
memcpy(l_step_sign->pkey_n_sign + l_pkey_size, l_sign->sign_data + l_signs_mem_shift, l_sign_size);
diff --git a/crypto/src/dap_enc_newhope.c b/crypto/src/dap_enc_newhope.c
index f9aa999a2db6b4a6d1a6931b0bdc55c4518a5cbe..a10e0d746a1c2c86568a129c5dc323e96ea910b0 100644
--- a/crypto/src/dap_enc_newhope.c
+++ b/crypto/src/dap_enc_newhope.c
@@ -30,7 +30,6 @@
#include <unistd.h>
#include "dap_enc_newhope.h"
-#include "dap_common.h"
#include "rand/dap_rand.h"
#include "newhope/newhope_cpapke.h"
#include "newhope/newhope_params.h"
@@ -67,18 +66,12 @@ void dap_enc_newhope_kem_key_new_generate(dap_enc_key_t *a_key, UNUSED_ARG const
UNUSED_ARG size_t a_kex_size, UNUSED_ARG const void *a_seed,
UNUSED_ARG size_t a_seed_size, UNUSED_ARG size_t a_key_size)
{
-// sanity check
dap_return_if_pass(!a_key);
-// work prepare
DAP_NEWHOPE_SIGN_SECURITY newhope_type = NEWHOPE_1024;
dap_enc_newhope_pke_set_type(newhope_type);
-// memory alloc
- uint8_t *l_skey, *l_pkey;
- DAP_NEW_Z_SIZE_RET(l_skey, uint8_t, NEWHOPE_CPAPKE_SECRETKEYBYTES, NULL);
- DAP_NEW_Z_SIZE_RET(l_pkey, uint8_t, NEWHOPE_CPAPKE_PUBLICKEYBYTES, l_skey);
-// crypto calc
+ uint8_t *l_skey = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, NEWHOPE_CPAPKE_SECRETKEYBYTES),
+ *l_pkey = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, NEWHOPE_CPAPKE_PUBLICKEYBYTES, l_skey);
cpapke_keypair(l_pkey, l_skey);
-// post func work
DAP_DEL_MULTY(a_key->_inheritor, a_key->pub_key_data);
a_key->_inheritor = l_skey;
a_key->pub_key_data = l_pkey;
@@ -109,9 +102,8 @@ size_t dap_enc_newhope_gen_bob_shared_key(dap_enc_key_t *a_bob_key, const void *
// sanity check
dap_return_val_if_pass(!a_bob_key || !a_alice_pub || !a_cypher_msg || a_alice_pub_size < NEWHOPE_CPAPKE_PUBLICKEYBYTES, 0)
// memory alloc
- uint8_t *l_shared_key, *l_cypher_msg;
- DAP_NEW_Z_SIZE_RET_VAL(l_shared_key, uint8_t, NEWHOPE_SYMBYTES, 0, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_cypher_msg, uint8_t, NEWHOPE_CPAKEM_CIPHERTEXTBYTES, 0, l_shared_key);
+ uint8_t *l_shared_key = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, NEWHOPE_SYMBYTES, false),
+ *l_cypher_msg = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, NEWHOPE_CPAKEM_CIPHERTEXTBYTES, false, l_shared_key);
// crypto calc
if (crypto_kem_enc(l_cypher_msg, l_shared_key, a_alice_pub)) {
DAP_DEL_MULTY(l_cypher_msg, l_shared_key);
@@ -131,8 +123,7 @@ size_t dap_enc_newhope_gen_alice_shared_key(dap_enc_key_t *a_alice_key, UNUSED_A
// sanity check
dap_return_val_if_pass(!a_alice_key || !a_cypher_msg || a_cypher_msg_size < NEWHOPE_CPAKEM_CIPHERTEXTBYTES, 0);
// memory alloc
- uint8_t *l_shared_key = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_shared_key, uint8_t, NEWHOPE_SYMBYTES, 0, NULL);
+ uint8_t *l_shared_key = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, NEWHOPE_SYMBYTES, 0);
// crypto calc
if (crypto_kem_dec(l_shared_key, a_cypher_msg, a_alice_key->_inheritor)) {
DAP_DELETE(l_shared_key);
diff --git a/crypto/src/dap_enc_picnic.c b/crypto/src/dap_enc_picnic.c
index 0c3e894bc49b974e245a03a44769de373e81439b..57e3f2fe7d2e23bdd8d82c4fd5b066f5df8d9e15 100755
--- a/crypto/src/dap_enc_picnic.c
+++ b/crypto/src/dap_enc_picnic.c
@@ -110,9 +110,7 @@ int dap_enc_sig_picnic_get_sign(dap_enc_key_t *a_key, const void *a_msg, const s
picnic_privatekey_t* sk = a_key->priv_key_data;
paramset_t paramset;
dap_return_val_if_pass((l_ret = get_param_set(sk->params, ¶mset)) != EXIT_SUCCESS, l_ret);
- // memory alloc
- signature_t *l_sig = NULL;
- DAP_NEW_Z_RET_VAL(l_sig, signature_t, -1, NULL);
+ signature_t *l_sig = DAP_NEW_Z_RET_VAL_IF_FAIL(signature_t, -1);
allocateSignature(l_sig, ¶mset);
dap_return_val_if_pass(!l_sig, -1);
@@ -146,13 +144,8 @@ int dap_enc_sig_picnic_verify_sign(dap_enc_key_t *a_key, const void *a_msg, cons
paramset_t paramset;
dap_return_val_if_pass((l_ret = get_param_set(pk->params, ¶mset)) != EXIT_SUCCESS, l_ret);
// memory alloc
- signature_t *l_sig = NULL;
- DAP_NEW_Z_RET_VAL(l_sig, signature_t, -1, NULL);
-
+ signature_t *l_sig = DAP_NEW_Z_RET_VAL_IF_FAIL(signature_t, -1);
allocateSignature(l_sig, ¶mset);
- if(!l_sig) {
- return -1;
- }
l_ret = deserializeSignature(l_sig, (const uint8_t*)a_sig, a_sig_len, ¶mset);
if(l_ret != EXIT_SUCCESS) {
diff --git a/crypto/src/dap_enc_shipovnik.c b/crypto/src/dap_enc_shipovnik.c
index de117f9b75382e8df8b6acd3d1796c6758175b59..0b7482d67b9ea2d282348cc793e1eac211909177 100644
--- a/crypto/src/dap_enc_shipovnik.c
+++ b/crypto/src/dap_enc_shipovnik.c
@@ -22,8 +22,8 @@ void dap_enc_sig_shipovnik_key_new_generate(dap_enc_key_t * key, UNUSED_ARG cons
UNUSED_ARG size_t kex_size, const void *seed, size_t seed_size,
UNUSED_ARG size_t key_size)
{
- DAP_NEW_Z_SIZE_RET(key->priv_key_data, void, SHIPOVNIK_SECRETKEYBYTES, NULL);
- DAP_NEW_Z_SIZE_RET(key->pub_key_data, void, SHIPOVNIK_PUBLICKEYBYTES, key->priv_key_data);
+ key->priv_key_data = DAP_NEW_Z_SIZE_RET_IF_FAIL(void, SHIPOVNIK_SECRETKEYBYTES);
+ key->pub_key_data = DAP_NEW_Z_SIZE_RET_IF_FAIL(void, SHIPOVNIK_PUBLICKEYBYTES, key->priv_key_data);
key->priv_key_data_size = SHIPOVNIK_SECRETKEYBYTES;
key->pub_key_data_size = SHIPOVNIK_PUBLICKEYBYTES;
if (!seed || !seed_size) {
diff --git a/crypto/src/dap_enc_sphincsplus.c b/crypto/src/dap_enc_sphincsplus.c
index d62b94e5e25afb9973e357c266652b413b1242f8..6fef44fff5f63cf778cbcb13b32b97e8356b6df4 100644
--- a/crypto/src/dap_enc_sphincsplus.c
+++ b/crypto/src/dap_enc_sphincsplus.c
@@ -32,7 +32,6 @@ void dap_enc_sig_sphincsplus_key_new_generate(dap_enc_key_t *a_key, UNUSED_ARG c
sphincsplus_private_key_t *l_skey = NULL;
sphincsplus_public_key_t *l_pkey = NULL;
sphincsplus_base_params_t l_params = {0};
- unsigned char *l_seed_buf = NULL;
if (sphincsplus_set_config(s_default_config) || sphincsplus_get_params(s_default_config, &l_params)) {
log_it(L_CRITICAL, "Error load sphincsplus config");
@@ -41,7 +40,7 @@ void dap_enc_sig_sphincsplus_key_new_generate(dap_enc_key_t *a_key, UNUSED_ARG c
// seed norming
size_t l_seed_buf_size = dap_enc_sig_sphincsplus_crypto_sign_seedbytes();
- DAP_NEW_Z_SIZE_RET(l_seed_buf, unsigned char, l_seed_buf_size, NULL);
+ unsigned char *l_seed_buf = DAP_NEW_Z_SIZE_RET_IF_FAIL(unsigned char, l_seed_buf_size, NULL);
if(a_seed && a_seed_size > 0) {
shake256(l_seed_buf, l_seed_buf_size, (const unsigned char *) a_seed, a_seed_size);
} else {
@@ -52,10 +51,10 @@ void dap_enc_sig_sphincsplus_key_new_generate(dap_enc_key_t *a_key, UNUSED_ARG c
a_key->priv_key_data_size = sizeof(sphincsplus_private_key_t);
a_key->pub_key_data_size = sizeof(sphincsplus_public_key_t);
- DAP_NEW_Z_SIZE_RET(l_skey, sphincsplus_private_key_t, a_key->priv_key_data_size, l_seed_buf);
- DAP_NEW_Z_SIZE_RET(l_pkey, sphincsplus_public_key_t, a_key->pub_key_data_size, l_seed_buf, l_skey);
- DAP_NEW_Z_SIZE_RET(l_skey->data, uint8_t, dap_enc_sig_sphincsplus_crypto_sign_secretkeybytes(), l_seed_buf, l_skey, l_pkey);
- DAP_NEW_Z_SIZE_RET(l_pkey->data, uint8_t, dap_enc_sig_sphincsplus_crypto_sign_publickeybytes(), l_seed_buf, l_skey->data, l_skey, l_pkey);
+ l_skey = DAP_NEW_Z_SIZE_RET_IF_FAIL(sphincsplus_private_key_t, a_key->priv_key_data_size, l_seed_buf);
+ l_pkey = DAP_NEW_Z_SIZE_RET_IF_FAIL(sphincsplus_public_key_t, a_key->pub_key_data_size, l_seed_buf, l_skey);
+ l_skey->data = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, dap_enc_sig_sphincsplus_crypto_sign_secretkeybytes(), l_seed_buf, l_skey, l_pkey);
+ l_pkey->data = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, dap_enc_sig_sphincsplus_crypto_sign_publickeybytes(), l_seed_buf, l_skey->data, l_skey, l_pkey);
if(sphincsplus_crypto_sign_seed_keypair(l_pkey->data, l_skey->data, l_seed_buf)) {
log_it(L_CRITICAL, "Error generating Sphincs key pair");
@@ -86,8 +85,7 @@ int dap_enc_sig_sphincsplus_get_sign(dap_enc_key_t *a_key, const void *a_msg_in,
return -3;
}
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->sig_data, uint8_t, dap_enc_sig_sphincsplus_crypto_sign_bytes(), -3, NULL);
-
+ l_sign->sig_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, dap_enc_sig_sphincsplus_crypto_sign_bytes(), -3);
l_sign->sig_params = l_skey->params;
return sphincsplus_crypto_sign_signature(l_sign->sig_data, &l_sign->sig_len, (const unsigned char *)a_msg_in, a_msg_size, l_skey->data);
}
@@ -109,7 +107,7 @@ size_t dap_enc_sig_sphincsplus_get_sign_msg(dap_enc_key_t *a_key, const void *a_
}
sphincsplus_signature_t *l_sign = (sphincsplus_signature_t *)a_sign_out;
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->sig_data, uint8_t, l_sign_bytes + a_msg_size, 0, NULL);
+ l_sign->sig_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_sign_bytes + a_msg_size, 0);
l_sign->sig_params = l_skey->params;
int l_ret = sphincsplus_crypto_sign(l_sign->sig_data, &l_sign->sig_len, (const unsigned char *)a_msg, a_msg_size, l_skey->data);
@@ -191,7 +189,7 @@ uint8_t *dap_enc_sig_sphincsplus_write_private_key(const void *a_private_key, si
sphincsplus_set_params(&l_private_key->params);
uint64_t l_secret_length = dap_enc_sig_sphincsplus_crypto_sign_secretkeybytes();
uint64_t l_buflen = dap_enc_sig_sphincsplus_ser_private_key_size((void *)l_private_key);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_private_key->params, (uint64_t)sizeof(sphincsplus_base_params_t),
l_private_key->data, (uint64_t)l_secret_length
@@ -210,11 +208,10 @@ void *dap_enc_sig_sphincsplus_read_private_key(const uint8_t *a_buf, size_t a_bu
uint64_t l_buflen = 0;
uint64_t l_skey_len = a_buflen - sizeof(uint64_t) - sizeof(sphincsplus_base_params_t);
- sphincsplus_private_key_t *l_skey = NULL;
- DAP_NEW_Z_RET_VAL(l_skey, sphincsplus_private_key_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_skey->data, uint8_t, l_skey_len, NULL, l_skey);
+ sphincsplus_private_key_t *l_skey = DAP_NEW_Z_RET_VAL_IF_FAIL(sphincsplus_private_key_t, NULL);
+ l_skey->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_skey_len, NULL, l_skey);
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 6,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_skey->params, (uint64_t)sizeof(sphincsplus_base_params_t),
l_skey->data, (uint64_t)l_skey_len
@@ -246,7 +243,7 @@ uint8_t *dap_enc_sig_sphincsplus_write_public_key(const void* a_public_key, size
sphincsplus_set_params(&l_public_key->params);
uint64_t l_public_length = dap_enc_sig_sphincsplus_crypto_sign_publickeybytes(&l_public_key->params);
uint64_t l_buflen = dap_enc_sig_sphincsplus_ser_public_key_size(a_public_key);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_public_key->params, (uint64_t)sizeof(sphincsplus_base_params_t),
l_public_key->data, (uint64_t)l_public_length
@@ -265,11 +262,10 @@ void *dap_enc_sig_sphincsplus_read_public_key(const uint8_t *a_buf, size_t a_buf
uint64_t l_buflen = 0;
uint64_t l_pkey_len = a_buflen - sizeof(uint64_t) - sizeof(sphincsplus_base_params_t);
- sphincsplus_public_key_t *l_pkey = NULL;
- DAP_NEW_Z_RET_VAL(l_pkey, sphincsplus_public_key_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_pkey->data, uint8_t, l_pkey_len, NULL, l_pkey);
+ sphincsplus_public_key_t *l_pkey = DAP_NEW_Z_RET_VAL_IF_FAIL(sphincsplus_public_key_t, NULL);
+ l_pkey->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_pkey_len, NULL, l_pkey);
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 6,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_pkey->params, (uint64_t)sizeof(sphincsplus_base_params_t),
l_pkey->data, (uint64_t)l_pkey_len
@@ -299,7 +295,7 @@ uint8_t *dap_enc_sig_sphincsplus_write_signature(const void *a_sign, size_t *a_b
sphincsplus_signature_t *l_sign = (sphincsplus_signature_t *)a_sign;
// func work
uint64_t l_buflen = dap_enc_sig_sphincsplus_ser_sig_size(a_sign);
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 8,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_sign->sig_params, (uint64_t)sizeof(sphincsplus_base_params_t),
&l_sign->sig_len, (uint64_t)sizeof(uint64_t),
@@ -318,11 +314,10 @@ void *dap_enc_sig_sphincsplus_read_signature(const uint8_t *a_buf, size_t a_bufl
// func work
uint64_t l_buflen;
uint64_t l_sig_len = a_buflen - sizeof(uint64_t) * 2 - sizeof(sphincsplus_base_params_t);
- sphincsplus_signature_t* l_sign = NULL;
- DAP_NEW_Z_RET_VAL(l_sign, sphincsplus_signature_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->sig_data, uint8_t, l_sig_len, NULL, l_sign);
+ sphincsplus_signature_t* l_sign = DAP_NEW_Z_RET_VAL_IF_FAIL(sphincsplus_signature_t, NULL);
+ l_sign->sig_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_sig_len, NULL, l_sign);
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 8,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_sign->sig_params, (uint64_t)sizeof(sphincsplus_base_params_t),
&l_sign->sig_len, (uint64_t)sizeof(uint64_t),
diff --git a/crypto/src/dap_enc_tesla.c b/crypto/src/dap_enc_tesla.c
index 4f5a1318a19239cb06f49512b189e296132ba500..2dff8dba7b7d3418f618890e3894097980814726 100755
--- a/crypto/src/dap_enc_tesla.c
+++ b/crypto/src/dap_enc_tesla.c
@@ -111,7 +111,7 @@ uint8_t *dap_enc_sig_tesla_write_signature(const void *a_sign, size_t *a_buflen_
// func work
uint64_t l_buflen = dap_enc_sig_tesla_ser_sig_size(l_sign);
uint32_t l_kind = l_sign->kind;
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 8,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
&l_sign->sig_len, (uint64_t)sizeof(uint64_t),
@@ -130,11 +130,10 @@ void *dap_enc_sig_tesla_read_signature(const uint8_t *a_buf, size_t a_buflen)
// func work
uint64_t l_buflen;
uint64_t l_sig_len = a_buflen - sizeof(uint64_t) * 2 - sizeof(uint32_t);
- tesla_signature_t* l_sign = NULL;
- DAP_NEW_Z_RET_VAL(l_sign, tesla_signature_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_sign->sig_data, uint8_t, l_sig_len, NULL, l_sign);
+ tesla_signature_t* l_sign = DAP_NEW_Z_RET_VAL_IF_FAIL(tesla_signature_t, NULL);
+ l_sign->sig_data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_sig_len, NULL, l_sign);
uint32_t l_kind = 0;
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 8,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
&l_sign->sig_len, (uint64_t)sizeof(uint64_t),
@@ -163,7 +162,7 @@ uint8_t *dap_enc_sig_tesla_write_private_key(const void *a_private_key, size_t *
// func work
uint64_t l_buflen = dap_enc_sig_tesla_ser_private_key_size(a_private_key); //CRYPTO_PUBLICKEYBYTES;
uint32_t l_kind = l_private_key->kind;
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
l_private_key->data, (uint64_t)p.CRYPTO_SECRETKEYBYTES
@@ -181,11 +180,10 @@ void *dap_enc_sig_tesla_read_private_key(const uint8_t *a_buf, size_t a_buflen)
// func work
uint64_t l_buflen;
uint64_t l_skey_len = a_buflen - sizeof(uint64_t) - sizeof(uint32_t);
- tesla_private_key_t* l_skey = NULL;
- DAP_NEW_Z_RET_VAL(l_skey, tesla_private_key_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_skey->data, uint8_t, l_skey_len, NULL, l_skey);
+ tesla_private_key_t* l_skey = DAP_NEW_Z_RET_VAL_IF_FAIL(tesla_private_key_t, NULL);
+ l_skey->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_skey_len, NULL, l_skey);
uint32_t l_kind = 0;
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 6,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
l_skey->data, (uint64_t)l_skey_len
@@ -214,7 +212,7 @@ uint8_t *dap_enc_sig_tesla_write_public_key(const void *a_public_key, size_t *a_
// func work
uint64_t l_buflen = dap_enc_sig_tesla_ser_public_key_size(a_public_key);
uint32_t l_kind = l_public_key->kind;
- uint8_t *l_buf = dap_serialize_multy(NULL, l_buflen, 6,
+ uint8_t *l_buf = DAP_VA_SERIALIZE_NEW(l_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
l_public_key->data, (uint64_t)p.CRYPTO_PUBLICKEYBYTES
@@ -232,11 +230,10 @@ void *dap_enc_sig_tesla_read_public_key(const uint8_t *a_buf, size_t a_buflen)
// func work
uint64_t l_buflen;
uint64_t l_pkey_len = a_buflen - sizeof(uint64_t) - sizeof(uint32_t);
- tesla_public_key_t* l_pkey = NULL;
- DAP_NEW_Z_RET_VAL(l_pkey, tesla_public_key_t, NULL, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_pkey->data, uint8_t, l_pkey_len, NULL, l_pkey);
+ tesla_public_key_t* l_pkey = DAP_NEW_Z_RET_VAL_IF_FAIL(tesla_public_key_t, NULL);
+ l_pkey->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_pkey_len, NULL, l_pkey);
uint32_t l_kind = 0;
- int l_res_des = dap_deserialize_multy(a_buf, a_buflen, 6,
+ int l_res_des = DAP_VA_DESERIALIZE(a_buf, a_buflen,
&l_buflen, (uint64_t)sizeof(uint64_t),
&l_kind, (uint64_t)sizeof(uint32_t),
l_pkey->data, (uint64_t)l_pkey_len
diff --git a/crypto/src/dap_pkey.c b/crypto/src/dap_pkey.c
index c0e46ff6fbc7f39e75d876def05b4c2132004a02..1b61b0433b9e8c0ea235e6ab89c9b9f64afe59de 100755
--- a/crypto/src/dap_pkey.c
+++ b/crypto/src/dap_pkey.c
@@ -36,43 +36,32 @@
*/
dap_pkey_t *dap_pkey_from_enc_key(dap_enc_key_t *a_key)
{
- if (a_key->pub_key_data_size > 0) {
- dap_pkey_type_t l_type = dap_pkey_type_from_enc_key_type(a_key->type);
- if (l_type.type == DAP_PKEY_TYPE_NULL) {
- log_it(L_WARNING, "No serialization preset");
- return NULL;
- }
- size_t l_pub_key_size;
- uint8_t *l_pkey = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_size);
- if (!l_pkey) {
- log_it(L_WARNING, "Serialization failed");
- return NULL;
- }
- dap_pkey_t *l_ret = DAP_NEW_SIZE(dap_pkey_t, sizeof(dap_pkey_t) + l_pub_key_size);
- l_ret->header.type = l_type;
- l_ret->header.size = (uint32_t)l_pub_key_size;
- memcpy(&l_ret->pkey, l_pkey, l_pub_key_size);
- DAP_DELETE(l_pkey);
- return l_ret;
- } else {
- log_it(L_WARNING, "No public key in the input enc_key object");
- return NULL;
- }
- return NULL;
+ dap_return_val_if_fail(a_key, NULL);
+ dap_return_val_if_fail_err(a_key->pub_key_data_size, NULL, "No public key in the input enc_key object");
+ dap_pkey_type_t l_type = dap_pkey_type_from_enc_key_type(a_key->type);
+ dap_return_val_if_pass_err(l_type.type == DAP_PKEY_TYPE_NULL, NULL, "Undefined pkey type");
+ dap_pkey_t *l_ret = NULL;
+ size_t l_pub_key_size = 0;
+ uint8_t *l_pkey = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_size);
+ if ( l_pkey && l_pub_key_size ) {
+ l_ret = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_pkey_t, sizeof(dap_pkey_t) + l_pub_key_size, NULL, l_pkey);
+ *l_ret = (dap_pkey_t) { .header.type = l_type, .header.size = l_pub_key_size };
+ memcpy(l_ret->pkey, l_pkey, l_pub_key_size);
+ } else
+ log_it(L_ERROR, "Pub key serialization failed");
+ return DAP_DELETE(l_pkey), l_ret;
}
bool dap_pkey_get_hash(dap_pkey_t *a_pkey, dap_chain_hash_fast_t *a_out_hash)
{
- if (!a_pkey || !a_out_hash)
- return false;
- return dap_hash_fast(a_pkey->pkey, a_pkey->header.size, a_out_hash);
+ return a_pkey ? dap_hash_fast(a_pkey->pkey, a_pkey->header.size, a_out_hash) : false;
}
dap_pkey_t *dap_pkey_get_from_sign(dap_sign_t *a_sign)
{
- dap_pkey_t *l_pkey = DAP_NEW_SIZE(dap_pkey_t, sizeof(dap_pkey_t) + a_sign->header.sign_pkey_size);
- l_pkey->header.size = a_sign->header.sign_pkey_size;
- l_pkey->header.type = dap_pkey_type_from_sign_type(a_sign->header.type);
+ dap_return_val_if_fail(a_sign, NULL);
+ dap_pkey_t *l_pkey = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_pkey_t, sizeof(dap_pkey_t) + a_sign->header.sign_pkey_size, NULL);
+ *l_pkey = (dap_pkey_t) { .header.size = a_sign->header.sign_pkey_size, .header.type = dap_pkey_type_from_sign_type(a_sign->header.type) };
memcpy(l_pkey->pkey, a_sign->pkey_n_sign, l_pkey->header.size);
return l_pkey;
}
diff --git a/crypto/src/dap_sign.c b/crypto/src/dap_sign.c
index e104ab530dce7dac4fddfe82c0bda5034171ea9a..e3fb32c0f6a37737214c576d469ed2f731aa054b 100755
--- a/crypto/src/dap_sign.c
+++ b/crypto/src/dap_sign.c
@@ -268,11 +268,8 @@ dap_sign_t * dap_sign_create(dap_enc_key_t *a_key, const void * a_data,
size_t l_sign_unserialized_size = dap_sign_create_output_unserialized_calc_size(a_key, a_output_wish_size);
if(l_sign_unserialized_size > 0) {
size_t l_pub_key_size = 0;
- uint8_t* l_sign_unserialized = NULL;
- uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_size);
-
- // dap_return_val_if_pass(!l_pub_key, NULL);
- DAP_NEW_Z_SIZE_RET_VAL(l_sign_unserialized, uint8_t, l_sign_unserialized_size, NULL, l_pub_key);
+ uint8_t *l_sign_unserialized = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_sign_unserialized_size, NULL),
+ *l_pub_key = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_size);
// calc signature [sign_size may decrease slightly]
if( dap_sign_create_output(a_key, l_sign_data, l_sign_data_size,
l_sign_unserialized, &l_sign_unserialized_size) != 0) {
@@ -282,8 +279,7 @@ dap_sign_t * dap_sign_create(dap_enc_key_t *a_key, const void * a_data,
size_t l_sign_ser_size = l_sign_unserialized_size;
uint8_t *l_sign_ser = dap_enc_key_serialize_sign(a_key->type, l_sign_unserialized, &l_sign_ser_size);
if ( l_sign_ser ){
- dap_sign_t *l_ret = NULL;
- DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_sign_t, sizeof(dap_sign_hdr_t) + l_sign_ser_size + l_pub_key_size, NULL, l_sign_unserialized, l_pub_key, l_sign_ser);
+ dap_sign_t *l_ret = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_sign_t, sizeof(dap_sign_hdr_t) + l_sign_ser_size + l_pub_key_size, NULL, l_sign_unserialized, l_pub_key, l_sign_ser);
// write serialized public key to dap_sign_t
memcpy(l_ret->pkey_n_sign, l_pub_key, l_pub_key_size);
l_ret->header.type = dap_sign_type_from_key_type(a_key->type);
@@ -524,17 +520,14 @@ dap_sign_t **dap_sign_get_unique_signs(void *a_data, size_t a_data_size, size_t
if (l_dup)
continue;
} else
- DAP_NEW_Z_COUNT_RET_VAL(ret, dap_sign_t *, l_signs_count, NULL, NULL);
+ ret = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_sign_t*, l_signs_count, NULL);
ret[i++] = l_sign;
if (*a_signs_count && i == *a_signs_count)
break;
if (i == l_signs_count) {
l_signs_count += l_realloc_count;
- ret = DAP_REALLOC_COUNT(ret, l_signs_count);
- if (!ret) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
+ dap_sign_t **l_ret_new = DAP_REALLOC_COUNT_RET_VAL_IF_FAIL(ret, l_signs_count, NULL, ret);
+ ret = l_ret_new;
}
}
*a_signs_count = i;
diff --git a/crypto/src/dap_uuid.c b/crypto/src/dap_uuid.c
index c749c11bacf598c7f82025d7cd12338f7d550194..96698279c2d3ba50a01feb78e369450be9091cd6 100644
--- a/crypto/src/dap_uuid.c
+++ b/crypto/src/dap_uuid.c
@@ -96,12 +96,11 @@ void dap_uuid_generate_nonce(void *a_nonce, size_t a_nonce_size)
SHAKE128((unsigned char *)a_nonce, a_nonce_size, (unsigned char *)l_input, sizeof(l_input));
}
-_Thread_local static char s_buf[sizeof(uint128_t) * 2 + 3];
-
-const char *dap_guuid_to_hex_str(dap_guuid_t a_guuid)
+dap_guuid_str_t dap_guuid_to_hex_str_(dap_guuid_t a_guuid)
{
- sprintf(s_buf, "0x%016" DAP_UINT64_FORMAT_X "%016" DAP_UINT64_FORMAT_X, a_guuid.net_id, a_guuid.srv_id);
- return (const char *)s_buf;
+ dap_guuid_str_t l_ret;
+ return snprintf((char*)&l_ret, sizeof(l_ret), "0x%016" DAP_UINT64_FORMAT_X "%016" DAP_UINT64_FORMAT_X,
+ a_guuid.net_id, a_guuid.srv_id), l_ret;
}
@@ -117,9 +116,10 @@ dap_guuid_t dap_guuid_from_hex_str(const char *a_hex_str, bool *succsess)
if (succsess) *succsess = false;
return ret;
}
- sprintf(s_buf, "0x%s", a_hex_str + 16 + 2);
+ dap_guuid_str_t l_str;
+ snprintf((char*)&l_str, sizeof(l_str), "0x%s", a_hex_str + 16 + 2);
uint64_t l_net_id, l_srv_id;
- if (dap_id_uint64_parse(a_hex_str, &l_net_id) || dap_id_uint64_parse(s_buf, &l_srv_id))
+ if (dap_id_uint64_parse(a_hex_str, &l_net_id) || dap_id_uint64_parse(l_str.s, &l_srv_id))
{
if (succsess) *succsess = false;
return ret;
diff --git a/crypto/test/crypto/dap_enc_benchmark_test.c b/crypto/test/crypto/dap_enc_benchmark_test.c
index 814bfb99fc719a79faf8284281c8995a46a62998..e6a46601d27c38fd0c1c5257015c3e0227c9f521 100644
--- a/crypto/test/crypto/dap_enc_benchmark_test.c
+++ b/crypto/test/crypto/dap_enc_benchmark_test.c
@@ -10,11 +10,8 @@
/*--------------------------TRANSFER TEST BLOCK--------------------------*/
static void s_transfer_test(dap_enc_key_type_t a_key_type, int a_times, int *a_gen_time, int *a_alice_shared, int *a_bob_shared)
{
- dap_enc_key_t **l_alice_keys = NULL;
- dap_enc_key_t **l_bob_keys = NULL;
-
- DAP_NEW_Z_COUNT_RET(l_alice_keys, dap_enc_key_t*, a_times, NULL);
- DAP_NEW_Z_COUNT_RET(l_bob_keys, dap_enc_key_t*, a_times, l_alice_keys);
+ dap_enc_key_t **l_alice_keys = DAP_NEW_Z_COUNT_RET_IF_FAIL(dap_enc_key_t*, a_times);
+ dap_enc_key_t **l_bob_keys = DAP_NEW_Z_COUNT_RET_IF_FAIL(dap_enc_key_t*, a_times, l_alice_keys);
int l_t1 = get_cur_time_msec();
@@ -75,18 +72,13 @@ static void s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *
size_t seed_size = sizeof(uint8_t);
uint8_t seed[sizeof(uint8_t)];
randombytes(seed, seed_size);
- uint8_t **l_signs = NULL;
- uint8_t **l_source = NULL;
- dap_enc_key_t **l_keys = NULL;
+ uint8_t *l_signs[a_times], *l_source[a_times];
+ dap_enc_key_t *l_keys[a_times];
size_t l_source_size[a_times];
dap_enc_key_t *l_key_temp = dap_enc_key_new_generate(a_key_type, NULL, 0, seed, seed_size, 0);
size_t max_signature_size = dap_sign_create_output_unserialized_calc_size(l_key_temp, 0);
dap_enc_key_delete(l_key_temp);
- DAP_NEW_Z_COUNT_RET(l_signs, uint8_t*, a_times, NULL);
- DAP_NEW_Z_COUNT_RET(l_source, uint8_t*, a_times, l_signs);
- DAP_NEW_Z_COUNT_RET(l_keys, dap_enc_key_t*, a_times, l_source, l_signs);
-
int l_t1 = 0;
*a_sig_time = 0;
for (int i = 0; i < a_times; ++i) {
@@ -99,9 +91,9 @@ static void s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *
}
// ----------
- DAP_NEW_Z_SIZE_RET(l_signs[i], uint8_t, max_signature_size, NULL);
+ l_signs[i] = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, max_signature_size);
l_source_size[i] = 1 + random_uint32_t(20);
- DAP_NEW_Z_SIZE_RET(l_source[i], uint8_t, l_source_size[i], NULL);
+ l_source[i] = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, l_source_size[i]);
randombytes(l_source[i], l_source_size[i]);
l_t1 = get_cur_time_msec();
@@ -137,20 +129,16 @@ static void s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *
dap_enc_key_delete(l_keys[i]);
DAP_DELETE(l_source[i]);
}
- DAP_DEL_MULTY(l_signs, l_source, l_keys);
}
static void s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, int *a_sig_time, int *a_verify_time)
{
size_t seed_size = sizeof(uint8_t);
uint8_t seed[seed_size];
- dap_sign_t **l_signs = NULL;
- uint8_t **l_source = NULL;
+ dap_sign_t *l_signs[a_times];
+ uint8_t *l_source[a_times];
size_t l_source_size[a_times];
- DAP_NEW_Z_COUNT_RET(l_signs, dap_sign_t*, a_times, NULL);
- DAP_NEW_Z_COUNT_RET(l_source, uint8_t*, a_times, l_signs);
-
int l_t1 = 0;
*a_sig_time = 0;
for (int i = 0; i < a_times; ++i) {
@@ -164,7 +152,7 @@ static void s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, i
}
// ----------
l_source_size[i] = 1 + random_uint32_t(20);
- DAP_NEW_Z_SIZE_RET(l_source[i], uint8_t, l_source_size[i], NULL);
+ l_source[i] = DAP_NEW_Z_SIZE_RET_IF_FAIL(uint8_t, l_source_size[i]);
randombytes(l_source[i], l_source_size[i]);
l_t1 = get_cur_time_msec();
@@ -199,7 +187,6 @@ static void s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, i
for(int i = 0; i < a_times; ++i) {
DAP_DEL_MULTY(l_signs[i], l_source[i]);
}
- DAP_DEL_MULTY(l_signs, l_source);
}
static void s_sign_verify_test_becnhmark(const char *a_name, dap_enc_key_type_t a_key_type, int a_times) {
diff --git a/crypto/test/crypto/dap_enc_multithread_test.c b/crypto/test/crypto/dap_enc_multithread_test.c
index 4f004882d6cc32f4f48421240be8dba1b6cd059f..e17f94b9f9ed0a6994e6debb041630daf14b4ce0 100644
--- a/crypto/test/crypto/dap_enc_multithread_test.c
+++ b/crypto/test/crypto/dap_enc_multithread_test.c
@@ -23,19 +23,16 @@ static int s_test_thread(dap_enc_key_type_t a_key_type, int a_times)
int l_ret = 0;
size_t seed_size = sizeof(uint8_t);
uint8_t seed[seed_size];
- dap_sign_t **l_signs = NULL;
- uint8_t **l_source = NULL;
+ dap_sign_t *l_signs[a_times];
+ uint8_t *l_source[a_times];
size_t l_source_size[a_times];
- DAP_NEW_Z_COUNT_RET_VAL(l_signs, dap_sign_t*, a_times, 1, NULL);
- DAP_NEW_Z_COUNT_RET_VAL(l_source, uint8_t*, a_times, 1, l_signs);
-
for (int i = 0; i < a_times; ++i) {
randombytes(seed, seed_size);
// ----------
l_source_size[i] = 1 + random_uint32_t(20);
- DAP_NEW_Z_SIZE_RET_VAL(l_source[i], uint8_t, l_source_size[i], 1, NULL);
+ l_source[i] = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(uint8_t, l_source_size[i], 1, NULL);
randombytes(l_source[i], l_source_size[i]);
dap_enc_key_t *key = s_enc_key_new_generate(a_key_type, NULL, 0, seed, seed_size, 0);
@@ -64,11 +61,8 @@ static int s_test_thread(dap_enc_key_type_t a_key_type, int a_times)
dap_assert_PIF(!l_verified, "Deserialize and verifying signature");
l_ret |= l_verified;
}
-
- for(int i = 0; i < a_times; ++i) {
- DAP_DEL_MULTY(l_signs[i], l_source[i]);
- }
- DAP_DEL_MULTY(l_signs, l_source);
+ DAP_DEL_ARRAY(l_signs, a_times);
+ DAP_DEL_ARRAY(l_source, a_times);
return l_ret;
}
diff --git a/global-db/dap_global_db.c b/global-db/dap_global_db.c
index 712ed9e2f29343bc3d2f50362cb601e154ea6f7d..98f1dd33e7d979623e1cf519b9db0c22faf034e2 100644
--- a/global-db/dap_global_db.c
+++ b/global-db/dap_global_db.c
@@ -219,9 +219,7 @@ void dap_global_db_instance_deinit()
dap_return_if_fail(s_dbi)
dap_list_free_full(s_dbi->blacklist, NULL);
dap_list_free_full(s_dbi->whitelist, NULL);
- DAP_DEL_Z(s_dbi->driver_name);
- DAP_DEL_Z(s_dbi->storage_path);
- DAP_DEL_Z(s_dbi);
+ DAP_DEL_MULTY(s_dbi->driver_name, s_dbi->storage_path, s_dbi);
}
inline dap_global_db_instance_t *dap_global_db_instance_get_default()
@@ -430,8 +428,7 @@ byte_t *dap_global_db_get_sync(const char *a_group,
int dap_global_db_get(const char * a_group, const char *a_key, dap_global_db_callback_result_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group && a_key, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET;
l_msg->group = dap_strdup(a_group);
@@ -504,8 +501,7 @@ dap_store_obj_t *dap_global_db_get_raw_sync(const char *a_group, const char *a_k
int dap_global_db_get_raw(const char *a_group, const char *a_key, dap_global_db_callback_result_raw_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group && a_key, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET_RAW;
l_msg->group = dap_strdup(a_group);
@@ -575,8 +571,7 @@ dap_nanotime_t dap_global_db_get_del_ts_sync(const char *a_group, const char *a_
int dap_global_db_get_del_ts(const char *a_group, const char *a_key, dap_global_db_callback_result_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group && a_key, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET_DEL_TS;
l_msg->group = dap_strdup(a_group);
@@ -663,8 +658,7 @@ byte_t *dap_global_db_get_last_sync(const char *a_group, char **a_key, size_t *a
int dap_global_db_get_last(const char * a_group, dap_global_db_callback_result_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET_LAST;
l_msg->group = dap_strdup(a_group);
@@ -728,9 +722,7 @@ dap_store_obj_t *dap_global_db_get_last_raw_sync(const char *a_group)
int dap_global_db_get_last_raw(const char * a_group, dap_global_db_callback_result_raw_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group, DAP_GLOBAL_DB_RC_ERROR);
-
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET_LAST_RAW;
l_msg->group = dap_strdup(a_group);
@@ -791,8 +783,7 @@ dap_global_db_obj_t *dap_global_db_get_all_sync(const char *a_group, size_t *a_o
int dap_global_db_get_all(const char *a_group, size_t a_results_page_size, dap_global_db_callback_results_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET_ALL;
l_msg->group = dap_strdup(a_group);
@@ -891,8 +882,7 @@ dap_store_obj_t *dap_global_db_get_all_raw_sync(const char* a_group, size_t *a_o
int dap_global_db_get_all_raw(const char *a_group, size_t a_results_page_size, dap_global_db_callback_results_raw_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_GET_ALL_RAW;
l_msg->group = dap_strdup(a_group);
@@ -1013,8 +1003,7 @@ int dap_global_db_set_sync(const char *a_group, const char *a_key, const void *a
int dap_global_db_set(const char * a_group, const char *a_key, const void * a_value, const size_t a_value_length, bool a_pin_value, dap_global_db_callback_result_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group && a_key, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_SET;
l_msg->group = dap_strdup(a_group);
@@ -1029,12 +1018,7 @@ int dap_global_db_set(const char * a_group, const char *a_key, const void * a_va
DAP_DEL_MULTY(l_msg->group, l_msg);
return DAP_GLOBAL_DB_RC_CRITICAL;
}
- l_msg->value = DAP_DUP_SIZE(a_value, a_value_length);
- if (!l_msg->value && a_value) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_MULTY(l_msg->key, l_msg->group, l_msg);
- return DAP_GLOBAL_DB_RC_CRITICAL;
- }
+ l_msg->value = DAP_DUP_SIZE_RET_VAL_IF_FAIL((char*)a_value, a_value_length, DAP_GLOBAL_DB_RC_CRITICAL, l_msg->key, l_msg->group, l_msg);
l_msg->value_length = a_value_length;
l_msg->value_is_pinned = a_pin_value;
l_msg->callback_arg = a_arg;
@@ -1104,8 +1088,7 @@ int dap_global_db_set_raw_sync(dap_store_obj_t *a_store_objs, size_t a_store_obj
int dap_global_db_set_raw(dap_store_obj_t *a_store_objs, size_t a_store_objs_count, dap_global_db_callback_results_raw_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_store_objs && a_store_objs_count, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_SET_RAW;
l_msg->callback_arg = a_arg;
@@ -1161,8 +1144,7 @@ static void s_msg_opcode_set_raw(struct queue_io_msg * a_msg)
int dap_global_db_set_multiple_zc(const char *a_group, dap_global_db_obj_t *a_values, size_t a_values_count, dap_global_db_callback_results_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group && a_values && a_values_count, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_SET_MULTIPLE;
l_msg->group = dap_strdup(a_group);
@@ -1198,7 +1180,8 @@ static void s_msg_opcode_set_multiple_zc(struct queue_io_msg * a_msg)
size_t i=0;
#ifdef DAP_TPS_TEST
FILE *l_mempool_file = fopen("/opt/cellframe-node/share/ca/mempool_start.txt", "a");
- fclose(l_mempool_file);
+ if (l_mempool_file)
+ fclose(l_mempool_file);
log_it(L_TPS, "Start write %zu records to mempool", a_msg->values_count);
#endif
if(a_msg->values_count>0) {
@@ -1216,7 +1199,8 @@ static void s_msg_opcode_set_multiple_zc(struct queue_io_msg * a_msg)
dap_global_db_objs_delete( a_msg->values, a_msg->values_count);
#ifdef DAP_TPS_TEST
l_mempool_file = fopen("/opt/cellframe-node/share/ca/mempool_finish.txt", "a");
- fclose(l_mempool_file);
+ if (l_mempool_file)
+ fclose(l_mempool_file);
log_it(L_TPS, "Finish write %zu records to mempool ", a_msg->values_count);
#endif
}
@@ -1256,8 +1240,7 @@ int dap_global_db_unpin_sync(const char *a_group, const char *a_key)
int s_db_object_pin(const char *a_group, const char *a_key, dap_global_db_callback_result_t a_callback, void *a_arg, bool a_pin)
{
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_PIN;
l_msg->group = dap_strdup(a_group);
@@ -1337,8 +1320,8 @@ int dap_global_db_unpin(const char *a_group, const char *a_key, dap_global_db_ca
static int s_del_sync_with_dbi(dap_global_db_instance_t *a_dbi, const char *a_group, const char *a_key)
{
dap_store_obj_t l_store_obj = {
- .key = a_key,
- .group = (char *)a_group,
+ .key = (char*)a_key,
+ .group = (char*)a_group,
.flags = DAP_GLOBAL_DB_RECORD_NEW | (a_key ? DAP_GLOBAL_DB_RECORD_DEL : DAP_GLOBAL_DB_RECORD_ERASE),
.timestamp = dap_nanotime_now()
};
@@ -1376,8 +1359,7 @@ inline int dap_global_db_del_sync(const char *a_group, const char *a_key)
int dap_global_db_del(const char * a_group, const char *a_key, dap_global_db_callback_result_t a_callback, void *a_arg)
{
dap_return_val_if_fail(s_dbi && a_group, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_DELETE;
l_msg->group = dap_strdup(a_group);
@@ -1454,8 +1436,7 @@ int dap_global_db_flush_sync()
int dap_global_db_flush(dap_global_db_callback_result_t a_callback, void * a_arg)
{
dap_return_val_if_fail(s_dbi, DAP_GLOBAL_DB_RC_ERROR);
- struct queue_io_msg *l_msg;
- DAP_NEW_Z_RET_VAL(l_msg, struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL, NULL);
+ struct queue_io_msg *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(struct queue_io_msg, DAP_GLOBAL_DB_RC_CRITICAL);
l_msg->dbi = s_dbi;
l_msg->opcode = MSG_OPCODE_FLUSH;
l_msg->callback_arg = a_arg;
@@ -1496,8 +1477,7 @@ dap_global_db_obj_t *dap_global_db_objs_copy(const dap_global_db_obj_t *a_objs_s
/* Run over array's elements */
const dap_global_db_obj_t *l_obj = a_objs_src;
- dap_global_db_obj_t *l_objs_dest;
- DAP_NEW_Z_COUNT_RET_VAL(l_objs_dest, dap_global_db_obj_t, a_count, NULL, NULL);
+ dap_global_db_obj_t *l_objs_dest = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_global_db_obj_t, a_count, NULL);
for (dap_global_db_obj_t *l_cur = l_objs_dest; a_count--; l_cur++, l_obj++) {
*l_cur = *l_obj;
if (l_obj->key) {
@@ -1533,19 +1513,11 @@ dap_global_db_obj_t *dap_global_db_objs_copy(const dap_global_db_obj_t *a_objs_s
*/
void dap_global_db_objs_delete(dap_global_db_obj_t *a_objs, size_t a_count)
{
-dap_global_db_obj_t *l_obj;
-
- if (!a_objs && !a_count)
- return;
-
- dap_return_if_fail(a_objs && a_count) /* Sanity checks */
-
- for(l_obj = a_objs; a_count--; l_obj++) { /* Run over array's elements */
- DAP_DEL_Z(l_obj->key);
- DAP_DEL_Z(l_obj->value);
+ if (a_objs && a_count) {
+ for (dap_global_db_obj_t *l_obj = a_objs; --a_count; ++l_obj)
+ DAP_DEL_MULTY(l_obj->key, l_obj->value);
}
-
- DAP_DELETE(a_objs); /* Finaly kill the the array */
+ DAP_DELETE(a_objs);
}
/**
diff --git a/global-db/dap_global_db_ch.c b/global-db/dap_global_db_ch.c
index 23fe998c9e86100c3a29c4bad91c5dd9daf81716..56f4f5e4759f06abf0d40792f1eb327d806ecc1e 100644
--- a/global-db/dap_global_db_ch.c
+++ b/global-db/dap_global_db_ch.c
@@ -76,9 +76,8 @@ void s_stream_ch_new(dap_stream_ch_t *a_ch, void *a_arg)
* @param ch
* @param arg
*/
-static void s_stream_ch_delete(dap_stream_ch_t *a_ch, void *a_arg)
+static void s_stream_ch_delete(dap_stream_ch_t *a_ch, void UNUSED_ARG *a_arg)
{
- UNUSED(a_arg);
dap_stream_ch_gdb_t *l_ch_gdb = DAP_STREAM_CH_GDB(a_ch);
debug_if(g_dap_global_db_debug_more, L_NOTICE, "Destroyed GDB sync channel %p with internal data %p", a_ch, l_ch_gdb);
DAP_DEL_Z(a_ch->internal);
@@ -148,12 +147,11 @@ bool s_proc_thread_reader(void *a_arg)
DAP_DELETE(l_hashes_pkt);
} else if (l_type != DAP_STREAM_CH_GLOBAL_DB_MSG_TYPE_GROUP_REQUEST) {
debug_if(g_dap_global_db_debug_more, L_INFO, "OUT: GLOBAL_DB_GROUP_REQUEST packet for group %s from first record", l_group);
- size_t l_pkt_size = dap_global_db_start_pkt_get_size(l_pkt);
- dap_global_db_start_pkt_t *l_oncoming_pkt = DAP_DUP_SIZE(l_pkt, l_pkt_size);
- l_oncoming_pkt->last_hash = c_dap_global_db_driver_hash_blank;
+ dap_global_db_driver_hash_t l_tmp_hash = l_pkt->last_hash;
+ l_pkt->last_hash = c_dap_global_db_driver_hash_blank;
dap_stream_ch_pkt_send_by_addr(l_sender_addr, DAP_STREAM_CH_GDB_ID, DAP_STREAM_CH_GLOBAL_DB_MSG_TYPE_GROUP_REQUEST,
- l_oncoming_pkt, l_pkt_size);
- DAP_DEL_Z(l_oncoming_pkt);
+ l_pkt, dap_global_db_start_pkt_get_size(l_pkt));
+ l_pkt->last_hash = l_tmp_hash;
}
if (!l_ret)
DAP_DELETE(a_arg);
diff --git a/global-db/dap_global_db_cluster.c b/global-db/dap_global_db_cluster.c
index 51c17b1ba080f8e2c8612eaf540eb825254e01c7..478cae199b77e6adde90c5ff6cd193d43fa8de15 100644
--- a/global-db/dap_global_db_cluster.c
+++ b/global-db/dap_global_db_cluster.c
@@ -217,6 +217,7 @@ int dap_global_db_cluster_add_notify_callback(dap_global_db_cluster_t *a_cluster
static void s_ch_in_pkt_callback(dap_stream_ch_t *a_ch, uint8_t a_type, const void *a_data, size_t a_data_size, void *a_arg)
{
+ dap_return_if_fail(a_arg);
debug_if(g_dap_global_db_debug_more, L_DEBUG, "Got packet with message type %hhu size %zu from addr " NODE_ADDR_FP_STR,
a_type, a_data_size, NODE_ADDR_FP_ARGS_S(a_ch->stream->node));
dap_global_db_cluster_t *l_cluster = a_arg;
diff --git a/global-db/dap_global_db_driver.c b/global-db/dap_global_db_driver.c
index c2431830e8005e1e014b557dac8e05306fb14c9b..d269e1eb91a9120e6b22609041768b829fe1c681 100644
--- a/global-db/dap_global_db_driver.c
+++ b/global-db/dap_global_db_driver.c
@@ -88,10 +88,10 @@ int dap_global_db_driver_init(const char *a_driver_name, const char *a_filename_
dap_global_db_driver_deinit();
// Fill callbacks with zeros
- memset(&s_drv_callback, 0, sizeof(dap_global_db_driver_callbacks_t));
+ s_drv_callback = (dap_global_db_driver_callbacks_t){ };
// Setup driver name
- strncpy( s_used_driver, a_driver_name, sizeof(s_used_driver) - 1);
+ dap_strncpy( s_used_driver, a_driver_name, sizeof(s_used_driver) - 1);
dap_mkdir_with_parents(a_filename_db);
@@ -156,32 +156,22 @@ static inline void s_store_obj_copy_one(dap_store_obj_t *a_store_obj_dst, const
{
*a_store_obj_dst = *a_store_obj_src;
a_store_obj_dst->group = dap_strdup(a_store_obj_src->group);
- if (a_store_obj_src->group && !a_store_obj_dst->group) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
+ if (a_store_obj_src->group && !a_store_obj_dst->group)
+ return log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+
a_store_obj_dst->key = dap_strdup(a_store_obj_src->key);
if (a_store_obj_src->key && !a_store_obj_dst->key) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
- if (a_store_obj_src->sign) {
- a_store_obj_dst->sign = DAP_DUP_SIZE(a_store_obj_src->sign, dap_sign_get_size(a_store_obj_src->sign));
- if (!a_store_obj_dst->sign) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
+ return DAP_DELETE(a_store_obj_dst->group), log_it(L_CRITICAL, "%s", c_error_memory_alloc);
}
+ if (a_store_obj_src->sign)
+ a_store_obj_dst->sign = DAP_DUP_SIZE_RET_IF_FAIL(a_store_obj_src->sign, dap_sign_get_size(a_store_obj_src->sign),
+ a_store_obj_dst->group, a_store_obj_dst->key);
if (a_store_obj_src->value) {
if (!a_store_obj_src->value_len)
log_it(L_WARNING, "Inconsistent global DB object copy requested");
- else {
- a_store_obj_dst->value = DAP_DUP_SIZE(a_store_obj_src->value, a_store_obj_src->value_len);
- if (!a_store_obj_dst->value) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
- }
+ else
+ a_store_obj_dst->value = DAP_DUP_SIZE_RET_IF_FAIL(a_store_obj_src->value, a_store_obj_src->value_len,
+ a_store_obj_dst->group, a_store_obj_dst->key, a_store_obj_dst->sign);
}
}
@@ -212,8 +202,7 @@ dap_store_obj_t *l_store_obj, *l_store_obj_dst, *l_store_obj_src;
dap_store_obj_t *dap_store_obj_copy_ext(dap_store_obj_t *a_store_obj, void *a_ext, size_t a_ext_size)
{
- dap_store_obj_t *l_ret;
- DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_store_obj_t, sizeof(dap_store_obj_t) + a_ext_size, NULL, NULL);
+ dap_store_obj_t *l_ret = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_store_obj_t, sizeof(dap_store_obj_t) + a_ext_size, NULL);
s_store_obj_copy_one(l_ret, a_store_obj);
if (a_ext_size)
memcpy(l_ret->ext, a_ext, a_ext_size);
@@ -242,12 +231,10 @@ void dap_store_obj_free(dap_store_obj_t *a_store_obj, size_t a_store_count)
if(!a_store_obj || !a_store_count)
return;
- dap_store_obj_t *l_store_obj_cur = a_store_obj;
-
- for ( ; a_store_count--; l_store_obj_cur++ ) {
- DAP_DEL_MULTY(l_store_obj_cur->group, l_store_obj_cur->key, l_store_obj_cur->value, l_store_obj_cur->sign);
+ for ( dap_store_obj_t *l_cur = a_store_obj; --a_store_count; ++l_cur ) {
+ DAP_DEL_MULTY(l_cur->group, l_cur->key, l_cur->value, l_cur->sign);
}
- DAP_DEL_Z(a_store_obj);
+ DAP_DELETE(a_store_obj);
}
/**
diff --git a/global-db/dap_global_db_driver_mdbx.c b/global-db/dap_global_db_driver_mdbx.c
index bd9da77051c25cb79538e6ea9646f3a847aba623..d5294b173fc190f2f645226a1191bd9d76a4957f 100644
--- a/global-db/dap_global_db_driver_mdbx.c
+++ b/global-db/dap_global_db_driver_mdbx.c
@@ -550,7 +550,7 @@ int s_fill_store_obj(const char *a_group, MDBX_val *a_key, MDBX_val *a_data, dap
DAP_DELETE(a_obj->group);
return log_it(L_ERROR, "Ivalid driver record with zero text key length"), -9;
}
- if ( !(a_obj->key = DAP_DUP_SIZE(l_record->key_n_value_n_sign, l_record->key_len)) ) {
+ if ( !(a_obj->key = DAP_DUP_SIZE((char*)l_record->key_n_value_n_sign, l_record->key_len)) ) {
DAP_DELETE(a_obj->group);
return log_it(L_CRITICAL, "Cannot allocate a memory for store object key"), -5;
}
@@ -565,7 +565,7 @@ int s_fill_store_obj(const char *a_group, MDBX_val *a_key, MDBX_val *a_data, dap
if (l_record->sign_len >= sizeof(dap_sign_t)) {
dap_sign_t *l_sign = (dap_sign_t *)(l_record->key_n_value_n_sign + l_record->key_len + l_record->value_len);
if (dap_sign_get_size(l_sign) != l_record->sign_len ||
- !(a_obj->sign = (dap_sign_t *)DAP_DUP_SIZE(l_sign, l_record->sign_len))) {
+ !(a_obj->sign = DAP_DUP_SIZE(l_sign, l_record->sign_len))) {
DAP_DELETE(a_obj->group);
DAP_DELETE(a_obj->key);
DAP_DEL_Z(a_obj->value);
@@ -763,14 +763,16 @@ static dap_global_db_pkt_pack_t *s_db_mdbx_get_by_hash(const char *a_group, dap_
}
size_t l_data_len = l_record->key_len + l_record->value_len + l_record->sign_len + l_db_ctx->namelen + 1;
size_t l_add_size = l_data_len + sizeof(dap_global_db_pkt_t);
- l_ret = l_ret ? DAP_REALLOC(l_ret, l_ret->data_size + sizeof(dap_global_db_pkt_pack_t) + l_add_size)
- : DAP_NEW_Z_SIZE(dap_global_db_pkt_pack_t, sizeof(dap_global_db_pkt_pack_t) + l_add_size);
- if (!l_ret) {
+ dap_global_db_pkt_pack_t *l_new_pack = l_ret
+ ? DAP_REALLOC(l_ret, l_ret->data_size + sizeof(dap_global_db_pkt_pack_t) + l_add_size)
+ : DAP_NEW_Z_SIZE(dap_global_db_pkt_pack_t, sizeof(dap_global_db_pkt_pack_t) + l_add_size);
+ if (!l_new_pack) {
log_it(L_CRITICAL, "Cannot allocate a memory for store object packet");
rc = MDBX_PROBLEM;
break;
}
- dap_global_db_pkt_t *l_pkt = (dap_global_db_pkt_t *)(l_ret->data + l_ret->data_size);
+ l_ret = l_new_pack;
+ dap_global_db_pkt_t *l_pkt = (dap_global_db_pkt_t*)(l_ret->data + l_ret->data_size);
/* Fill packet header */
if (l_key.iov_len != sizeof(dap_global_db_driver_hash_t)) {
@@ -897,10 +899,14 @@ static void *s_db_mdbx_read_cond(const char *a_group, dap_global_db_driver_hash_
DAP_DEL_Z(l_obj_arr);
} else {
// Add blank object to the end as marker of final itreation
- l_count_current++;
- if (l_count_current < l_count_out &&
- !(l_obj_arr = DAP_REALLOC(l_obj_arr, l_element_size * l_count_current + l_addition_size)))
- log_it(L_ERROR, "Cannot cut area to keep %zu <store objects>", l_count_current);
+ ++l_count_current;
+ if (l_count_current < l_count_out) {
+ byte_t *l_obj_arr_cut = DAP_REALLOC(l_obj_arr, l_element_size * l_count_current + l_addition_size);
+ if (!l_obj_arr_cut)
+ log_it(L_ERROR, "Cannot cut area to keep %zu <store objects>", l_count_current);
+ else
+ l_obj_arr = l_obj_arr_cut;
+ }
}
}
if ( (MDBX_SUCCESS != rc) && (rc != MDBX_NOTFOUND) )
@@ -1056,9 +1062,7 @@ static int s_db_mdbx_apply_store_obj_with_txn(dap_store_obj_t *a_store_obj, MDBX
size_t l_record_len = sizeof(struct driver_record) + a_store_obj->value_len + l_key_len;
if (a_store_obj->sign)
l_record_len += dap_sign_get_size(a_store_obj->sign);
- struct driver_record *l_record = DAP_NEW_Z_SIZE(struct driver_record, l_record_len);
- if (!l_record)
- return log_it(L_CRITICAL, "Cannot allocate memory for new records, %zu bytes, errno=%d", l_record_len, errno), MDBX_PANIC;
+ struct driver_record *l_record = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(struct driver_record, l_record_len, MDBX_PANIC);
dap_strncpy((char *)l_record->key_n_value_n_sign, a_store_obj->key, DAP_GLOBAL_DB_KEY_SIZE_MAX);
l_record->key_len = l_key_len;
l_record->value_len = a_store_obj->value_len;
@@ -1069,12 +1073,12 @@ static int s_db_mdbx_apply_store_obj_with_txn(dap_store_obj_t *a_store_obj, MDBX
if (a_store_obj->sign) {
/* Put the authorization sign */
l_record->sign_len = dap_sign_get_size(a_store_obj->sign);
- memcpy(l_record->key_n_value_n_sign + l_key_len + a_store_obj->value_len, a_store_obj->sign, l_record->sign_len);
if (!l_record->sign_len) {
DAP_DELETE(l_record);
log_it(L_ERROR, "Global DB store object sign corrupted");
return MDBX_EINVAL;
}
+ memcpy(l_record->key_n_value_n_sign + l_key_len + a_store_obj->value_len, a_store_obj->sign, l_record->sign_len);
}
/* So, finaly: do INSERT, COMMIT or ABORT ... */
l_data.iov_base = l_record; /* Fill IOV for MDBX data */
@@ -1240,9 +1244,11 @@ MDBX_txn *l_txn = s_txn;
if (!l_count_current) {
DAP_DEL_Z(l_obj_arr);
} else if (l_count_current < l_count_out) {
- l_obj_arr = DAP_REALLOC(l_obj_arr, l_count_current * sizeof(dap_store_obj_t));
- if (!l_obj_arr)
+ dap_store_obj_t *l_obj_arr_cut = DAP_REALLOC_COUNT(l_obj_arr, l_count_current);
+ if (!l_obj_arr_cut)
log_it(L_ERROR, "Cannot cut area to keep %zu <store objects>", l_count_current);
+ else
+ l_obj_arr = l_obj_arr_cut;
}
}
safe_ret:
diff --git a/global-db/dap_global_db_driver_pgsql.c b/global-db/dap_global_db_driver_pgsql.c
index a46f176dc0f60a79c648b325b69ed075332ff876..68eb21f53c927b6e7f64b2efe0bd2dc6d0e45b78 100644
--- a/global-db/dap_global_db_driver_pgsql.c
+++ b/global-db/dap_global_db_driver_pgsql.c
@@ -359,17 +359,22 @@ int dap_db_driver_pgsql_apply_store_obj(dap_store_obj_t *a_store_obj)
static void s_pgsql_fill_object(const char *a_group, dap_store_obj_t *a_obj, PGresult *a_res, int a_row)
{
a_obj->group = dap_strdup(a_group);
-
- for (int i = 0; i < PQnfields(a_res); i++) {
- if (i == PQfnumber(a_res, "obj_id")) {
- a_obj->id = be64toh(*(uint64_t *)PQgetvalue(a_res, a_row, i));
- } else if (i == PQfnumber(a_res, "obj_ts")) {
- a_obj->timestamp = be64toh(*(time_t *)PQgetvalue(a_res, a_row, i));
- } else if ((i == PQfnumber(a_res, "obj_key"))) {
- a_obj->key = dap_strdup(PQgetvalue(a_res, a_row, i));
- } else if ((i == PQfnumber(a_res, "obj_val"))) {
- a_obj->value_len = PQgetlength(a_res, a_row, i);
- a_obj->value = DAP_DUP_SIZE(PQgetvalue(a_res, a_row, i), a_obj->value_len);
+ int q = PQnfields(a_res);
+ while (q-- > 0) {
+ switch (q) {
+ case PQfnumber(a_res, "obj_val"):
+ a_obj->value_len = PQgetlength(a_res, a_row, q);
+ a_obj->value = DAP_DUP_SIZE(PQgetvalue(a_res, a_row, q), a_obj->value_len);
+ break;
+ case PQfnumber(a_res, "obj_key"):
+ a_obj->key = dap_strdup(PQgetvalue(a_res, a_row, q));
+ break;
+ case PQfnumber(a_res, "obj_ts"):
+ a_obj->timestamp = be64toh(*(time_t*)PQgetvalue(a_res, a_row, q));
+ break;
+ case PQfnumber(a_res, "obj_id"):
+ a_obj->id = be64toh(*(uint64_t*)PQgetvalue(a_res, a_row, q));
+ break;
}
}
}
@@ -414,11 +419,16 @@ dap_store_obj_t *dap_db_driver_pgsql_read_store_obj(const char *a_group, const c
// parse reply
size_t l_count = PQntuples(l_res);
- dap_store_obj_t *l_obj = l_count ? DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * l_count) : NULL;
- for (int i = 0; i < l_count; i++) {
- // fill currrent item
- dap_store_obj_t *l_obj_cur = l_obj + i;
- s_pgsql_fill_object(a_group, l_obj_cur, l_res, i);
+ if (l_count) {
+ dap_store_obj_t *l_obj = DAP_NEW_Z_COUNT(dap_store_obj_t, l_count);
+ if (!l_obj) {
+ log_it(L_ERROR, "Memory allocation error");
+ l_count = 0;
+ } else {
+ for (int i = 0; i < l_count; ++i) {
+ s_pgsql_fill_object(a_group, (dap_store_obj_t*)(l_obj + i), l_res, i);
+ }
+ }
}
PQclear(l_res);
s_pgsql_free_connection(l_conn);
@@ -499,11 +509,16 @@ dap_store_obj_t *dap_db_driver_pgsql_read_cond_store_obj(const char *a_group, ui
// parse reply
size_t l_count = PQntuples(l_res);
- dap_store_obj_t *l_obj = l_count ? DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * l_count) : NULL;
- for (int i = 0; i < l_count; i++) {
- // fill currrent item
- dap_store_obj_t *l_obj_cur = l_obj + i;
- s_pgsql_fill_object(a_group, l_obj_cur, l_res, i);
+ if (l_count) {
+ dap_store_obj_t *l_obj = DAP_NEW_Z_COUNT(dap_store_obj_t, l_count);
+ if (!l_obj) {
+ log_it(L_ERROR, "Memory allocation error");
+ l_count = 0;
+ } else {
+ for (int i = 0; i < l_count; ++i) {
+ s_pgsql_fill_object(a_group, (dap_store_obj_t*)(l_obj + i), l_res, i);
+ }
+ }
}
PQclear(l_res);
s_pgsql_free_connection(l_conn);
diff --git a/global-db/dap_global_db_driver_sqlite.c b/global-db/dap_global_db_driver_sqlite.c
index c19319e4346af0ed142709656ab7cd5a5e69f4ae..1a53bbec787caefdfcf7f053438c8718953e3324 100644
--- a/global-db/dap_global_db_driver_sqlite.c
+++ b/global-db/dap_global_db_driver_sqlite.c
@@ -243,7 +243,7 @@ static conn_list_item_t *s_db_sqlite_get_connection(bool a_trans)
// func work
static int l_conn_idx = 0;
if (!s_conn) {
- DAP_NEW_Z_RET_VAL(s_conn, conn_list_item_t, NULL, NULL);
+ s_conn = DAP_NEW_Z_RET_VAL_IF_FAIL(conn_list_item_t, NULL);
pthread_key_t s_destructor_key;
pthread_key_create(&s_destructor_key, s_connection_destructor);
pthread_setspecific(s_destructor_key, (const void *)s_conn);
@@ -300,12 +300,11 @@ static int s_db_sqlite_create_group_table(const char *a_table_name, conn_list_it
{
// sanity check
dap_return_val_if_pass(!a_table_name || !a_conn, -EINVAL);
- char l_query[512];
-
- snprintf(l_query, sizeof(l_query) - 1,
- "CREATE TABLE IF NOT EXISTS '%s'(driver_key BLOB UNIQUE NOT NULL PRIMARY KEY ON CONFLICT REPLACE, key TEXT UNIQUE NOT NULL, flags INTEGER, value BLOB, sign BLOB)",
- a_table_name);
- return s_db_sqlite_exec(a_conn->conn, l_query, NULL, NULL, 0, NULL);
+ char *l_query = dap_strdup_printf("CREATE TABLE IF NOT EXISTS '%s'"
+ "(driver_key BLOB UNIQUE NOT NULL PRIMARY KEY ON CONFLICT REPLACE, key TEXT UNIQUE NOT NULL, flags INTEGER, value BLOB, sign BLOB)",
+ a_table_name);
+ int l_ret = s_db_sqlite_exec(a_conn->conn, l_query, NULL, NULL, 0, NULL);
+ return DAP_DELETE(l_query), l_ret;
}
/**
@@ -326,8 +325,7 @@ int s_db_sqlite_apply_store_obj(dap_store_obj_t *a_store_obj)
return -2;
int l_ret = 0;
- char *l_query = NULL;
- char *l_table_name = dap_str_replace_char(a_store_obj->group, '.', '_');
+ char *l_query = NULL, *l_table_name = dap_str_replace_char(a_store_obj->group, '.', '_');
if (!l_type_erase) {
if (!a_store_obj->key) {
log_it(L_ERROR, "Global DB store object unsigned");
@@ -377,29 +375,28 @@ static int s_db_sqlite_fill_one_item(const char *a_group, dap_store_obj_t *a_obj
goto clean_and_ret;
a_obj->group = dap_strdup(a_group);
size_t l_count_col = sqlite3_column_count(a_stmt);
- for(size_t i = 0; i < l_count_col; ++i) {
- if (i == 0 && sqlite3_column_type(a_stmt, i) == SQLITE_BLOB) {
- dap_global_db_driver_hash_t *l_driver_key = (dap_global_db_driver_hash_t *)sqlite3_column_blob(a_stmt, i);
- a_obj->timestamp = be64toh(l_driver_key->bets);
- a_obj->crc = be64toh(l_driver_key->becrc);
- continue;
- }
- if (i == 1 && sqlite3_column_type(a_stmt, i) == SQLITE_TEXT) {
- a_obj->key = dap_strdup((const char *)sqlite3_column_text(a_stmt, i));
- continue;
- }
- if (i == 2 && sqlite3_column_type(a_stmt, i) == SQLITE_INTEGER) {
- a_obj->flags = sqlite3_column_int64(a_stmt, i);
- continue;
- }
- if (i == 3 && sqlite3_column_type(a_stmt, i) == SQLITE_BLOB) {
- a_obj->value_len = sqlite3_column_bytes(a_stmt, i);
- a_obj->value = DAP_DUP_SIZE(sqlite3_column_blob(a_stmt, i), a_obj->value_len);
- continue;
- }
- if (i == 4 && sqlite3_column_type(a_stmt, i) == SQLITE_BLOB) {
- a_obj->sign = DAP_DUP_SIZE(sqlite3_column_blob(a_stmt, i), sqlite3_column_bytes(a_stmt, i));
- continue;
+ for (size_t i = 0; i < l_count_col; ++i) {
+ switch ( sqlite3_column_type(a_stmt, i) ) {
+ case SQLITE_BLOB:
+ if ( i == 0 ) {
+ dap_global_db_driver_hash_t *l_driver_key = (dap_global_db_driver_hash_t *)sqlite3_column_blob(a_stmt, i);
+ a_obj->timestamp = be64toh(l_driver_key->bets);
+ a_obj->crc = be64toh(l_driver_key->becrc);
+ } else if ( i == 3 ) {
+ a_obj->value_len = sqlite3_column_bytes(a_stmt, i);
+ a_obj->value = DAP_DUP_SIZE((byte_t*)sqlite3_column_blob(a_stmt, i), a_obj->value_len);
+ } else if ( i == 4 ) {
+ a_obj->sign = DAP_DUP_SIZE((dap_sign_t*)sqlite3_column_blob(a_stmt, i), sqlite3_column_bytes(a_stmt, i));
+ } continue;
+ case SQLITE_TEXT:
+ if ( i == 1 ) {
+ a_obj->key = dap_strdup((const char*)sqlite3_column_text(a_stmt, i));
+ } continue;
+ case SQLITE_INTEGER:
+ if ( i == 2 ) {
+ a_obj->flags = sqlite3_column_int64(a_stmt, i);
+ } continue;
+ default: continue;
}
}
clean_and_ret:
@@ -471,19 +468,15 @@ static dap_global_db_pkt_pack_t *s_db_sqlite_get_by_hash(const char *a_group, da
const char *l_error_msg = "get by hash";
dap_global_db_pkt_pack_t *l_ret = NULL;
sqlite3_stmt *l_stmt_count = NULL, *l_stmt = NULL, *l_stmt_size = NULL;
- char *l_blob_str = DAP_NEW_Z_SIZE(char, a_count * 2);
- char *l_table_name = dap_str_replace_char(a_group, '.', '_');
+ char *l_table_name = dap_str_replace_char(a_group, '.', '_'), *l_blob_str = DAP_NEW_Z_SIZE(char, a_count * 2);
if (!l_blob_str || !l_table_name) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
DAP_DEL_MULTY(l_table_name, l_blob_str);
return NULL;
}
- for (size_t i = 0; i < a_count * 2; i += 2) {
- l_blob_str[i] = '?';
- }
- for (size_t i = 1; i + 1 < a_count * 2; i += 2) {
- l_blob_str[i] = ',';
- }
+ for (size_t k = 0; k < a_count; memcpy(l_blob_str + 2 * (k++), "?,", 2));
+ l_blob_str[2 * a_count - 1] = '\0';
+
char *l_str_query_count = sqlite3_mprintf("SELECT COUNT(*) FROM '%s' "
" WHERE driver_key IN (%s)",
l_table_name, l_blob_str);
@@ -493,94 +486,111 @@ static dap_global_db_pkt_pack_t *s_db_sqlite_get_by_hash(const char *a_group, da
char *l_str_query = sqlite3_mprintf("SELECT * FROM '%s'"
" WHERE driver_key IN (%s) ORDER BY driver_key",
l_table_name, l_blob_str);
+ DAP_DEL_MULTY(l_table_name, l_blob_str);
if (!l_str_query_count || !l_str_query) {
log_it(L_ERROR, "Error in SQL request forming");
goto clean_and_ret;
}
- if(s_db_sqlite_prepare(l_conn->conn, l_str_query_count, &l_stmt_count, l_error_msg)!= SQLITE_OK ||
- s_db_sqlite_prepare(l_conn->conn, l_str_query_size, &l_stmt_size, l_error_msg)!= SQLITE_OK ||
- s_db_sqlite_prepare(l_conn->conn, l_str_query, &l_stmt, l_error_msg)!= SQLITE_OK)
+ if( s_db_sqlite_prepare(l_conn->conn, l_str_query_count, &l_stmt_count, l_error_msg)!= SQLITE_OK ||
+ s_db_sqlite_prepare(l_conn->conn, l_str_query_size, &l_stmt_size, l_error_msg) != SQLITE_OK ||
+ s_db_sqlite_prepare(l_conn->conn, l_str_query, &l_stmt, l_error_msg) != SQLITE_OK )
{
goto clean_and_ret;
}
for (size_t i = 1; i <= a_count; ++i) {
- if( s_db_sqlite_bind_blob64(l_stmt_count, i, a_hashes + i - 1, sizeof(*a_hashes), SQLITE_STATIC, l_error_msg) != SQLITE_OK ||
+ if( s_db_sqlite_bind_blob64(l_stmt_count, i,a_hashes + i - 1, sizeof(*a_hashes), SQLITE_STATIC, l_error_msg) != SQLITE_OK ||
s_db_sqlite_bind_blob64(l_stmt_size, i, a_hashes + i - 1, sizeof(*a_hashes), SQLITE_STATIC, l_error_msg) != SQLITE_OK ||
- s_db_sqlite_bind_blob64(l_stmt, i, a_hashes + i - 1, sizeof(*a_hashes), SQLITE_STATIC, l_error_msg) != SQLITE_OK)
+ s_db_sqlite_bind_blob64(l_stmt, i, a_hashes + i - 1, sizeof(*a_hashes), SQLITE_STATIC, l_error_msg) != SQLITE_OK )
{
goto clean_and_ret;
}
}
- if (s_db_sqlite_step(l_stmt_count, l_error_msg) != SQLITE_ROW || s_db_sqlite_step(l_stmt_size, l_error_msg) != SQLITE_ROW) {
+ if ( s_db_sqlite_step(l_stmt_count, l_error_msg) != SQLITE_ROW || s_db_sqlite_step(l_stmt_size, l_error_msg) != SQLITE_ROW ) {
goto clean_and_ret;
}
// memory alloc
- uint64_t l_count = sqlite3_column_int64(l_stmt_count, 0);
- uint64_t l_size = sqlite3_column_int64(l_stmt_size, 0);
- if (!l_count || !l_size) {
+ int64_t i, j, l_count = sqlite3_column_int64(l_stmt_count, 0), l_size = sqlite3_column_int64(l_stmt_size, 0);
+ if ( l_count <= 0 || l_size <= 0 ) {
log_it(L_INFO, "There are no records satisfying the get by hash request");
goto clean_and_ret;
}
size_t l_group_name_len = strlen(a_group) + 1;
size_t l_data_size = l_count * (sizeof(dap_global_db_pkt_t) + l_group_name_len + 1) + l_size;
- DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_global_db_pkt_pack_t, sizeof(dap_global_db_pkt_pack_t) + l_data_size, NULL, l_str_query_count, l_str_query);
-// data forming
- for (size_t i = 0; i < l_count && l_ret->data_size < l_data_size && s_db_sqlite_step(l_stmt, l_error_msg) == SQLITE_ROW; ++i) {
- dap_global_db_pkt_t *l_cur_pkt = (dap_global_db_pkt_t *)(l_ret->data + l_ret->data_size);
- size_t l_count_col = sqlite3_column_count(l_stmt);
- l_cur_pkt->group_len = l_group_name_len;
- memcpy(l_cur_pkt->data, a_group, l_cur_pkt->group_len);
- l_cur_pkt->data_len += l_cur_pkt->group_len;
- for (size_t j = 0; j < l_count_col; ++j) {
- if (j == 0 && sqlite3_column_type(l_stmt, j) == SQLITE_BLOB) {
- if (sqlite3_column_bytes(l_stmt, j)) {
- dap_global_db_driver_hash_t *l_driver_key = (dap_global_db_driver_hash_t *)sqlite3_column_blob(l_stmt, j);
+ l_ret = DAP_NEW_Z_SIZE(dap_global_db_pkt_pack_t, sizeof(dap_global_db_pkt_pack_t) + l_data_size);
+ if ( !l_ret ) {
+ log_it(L_CRITICAL, "Memory allocation error!");
+ goto clean_and_ret;
+ }
+ byte_t *l_data_pos = l_ret->data, *l_data_end = l_data_pos + l_data_size;
+ for (i = 0; i < l_count && s_db_sqlite_step(l_stmt, l_error_msg) == SQLITE_ROW; ++i) {
+ dap_global_db_pkt_t *l_cur_pkt = (dap_global_db_pkt_t*)(l_data_pos);
+ l_data_pos = l_cur_pkt->data;
+ if ( l_data_pos + l_group_name_len > l_data_end )
+ break;
+ l_data_pos = dap_mempcpy(l_data_pos, a_group, l_cur_pkt->group_len = l_group_name_len);
+ int l_count_col = sqlite3_column_count(l_stmt);
+ for (j = 0; j < l_count_col; ++j) {
+ switch ( sqlite3_column_type(l_stmt, j) ) {
+ case SQLITE_BLOB:
+ if ( j == 0 ) {
+ dap_global_db_driver_hash_t *l_driver_key = (dap_global_db_driver_hash_t*)sqlite3_column_blob(l_stmt, j);
l_cur_pkt->timestamp = be64toh(l_driver_key->bets);
l_cur_pkt->crc = be64toh(l_driver_key->becrc);
- }
- continue;
- }
- if (j == 1 && sqlite3_column_type(l_stmt, j) == SQLITE_TEXT) {
- l_cur_pkt->key_len = sqlite3_column_bytes(l_stmt, j);
- memcpy(l_cur_pkt->data + l_cur_pkt->data_len, sqlite3_column_text(l_stmt, j), l_cur_pkt->key_len);
- l_cur_pkt->key_len++;
- l_cur_pkt->data_len += l_cur_pkt->key_len;
- continue;
- }
- if (j == 2 && sqlite3_column_type(l_stmt, j) == SQLITE_INTEGER) {
- if (sqlite3_column_bytes(l_stmt, j))
- l_cur_pkt->flags = sqlite3_column_int64(l_stmt, j) & DAP_GLOBAL_DB_RECORD_DEL;
- continue;
- }
- if (j == 3 && sqlite3_column_type(l_stmt, j) == SQLITE_BLOB) {
- l_cur_pkt->value_len = sqlite3_column_bytes(l_stmt, j);
- memcpy(l_cur_pkt->data + l_cur_pkt->data_len, sqlite3_column_blob(l_stmt, j), l_cur_pkt->value_len);
- l_cur_pkt->data_len += l_cur_pkt->value_len;
- continue;
- }
- if (j == 4 && sqlite3_column_type(l_stmt, j) == SQLITE_BLOB) {
- size_t l_sign_size = sqlite3_column_bytes(l_stmt, j);
- if (l_sign_size) {
- dap_sign_t *l_sign = (dap_sign_t *)sqlite3_column_blob(l_stmt, j);
- if (l_sign_size != dap_sign_get_size(l_sign)) {
- log_it(L_ERROR, "Wrong sign size from global_db");
- goto clean_and_ret;
+ } else if ( j == 3 ) {
+ l_cur_pkt->value_len = sqlite3_column_bytes(l_stmt, j);
+ if ( l_data_pos + l_cur_pkt->value_len > l_data_end )
+ break;
+ l_data_pos = dap_mempcpy(l_data_pos, sqlite3_column_blob(l_stmt, j), l_cur_pkt->value_len);
+ } else if ( j == 4 ) {
+ size_t l_sign_size = sqlite3_column_bytes(l_stmt, j);
+ if (l_sign_size) {
+ dap_sign_t *l_sign = (dap_sign_t*)sqlite3_column_blob(l_stmt, j);
+ if ( dap_sign_get_size(l_sign) != l_sign_size || l_data_pos + l_sign_size > l_data_end ) {
+ log_it(L_ERROR, "Wrong sign size in GDB group %s", a_group);
+ break;
+ }
+ l_data_pos = dap_mempcpy(l_data_pos, sqlite3_column_blob(l_stmt, j), l_sign_size);
}
- memcpy(l_cur_pkt->data + l_cur_pkt->data_len, sqlite3_column_blob(l_stmt, j), l_sign_size);
- l_cur_pkt->data_len += l_sign_size;
- }
+ } continue;
+ case SQLITE_TEXT:
+ if ( j == 1 ) {
+ l_cur_pkt->key_len = sqlite3_column_bytes(l_stmt, j);
+ if ( l_data_pos + l_cur_pkt->key_len > l_data_end )
+ break;
+ l_data_pos = dap_mempcpy(l_data_pos, sqlite3_column_text(l_stmt, j), l_cur_pkt->key_len++) + 1;
+ } continue;
+ case SQLITE_INTEGER:
+ if ( j == 2 ) {
+ if (sqlite3_column_bytes(l_stmt, j))
+ l_cur_pkt->flags = sqlite3_column_int64(l_stmt, j) & DAP_GLOBAL_DB_RECORD_DEL;
+ } continue;
+ default:
continue;
}
+ // Some break occured, escape from loops
+ j = -1;
+ break;
}
- l_ret->data_size += sizeof(dap_global_db_pkt_t) + l_cur_pkt->data_len;
- l_ret->obj_count++;
+ if ( j == -1 ) {
+ l_data_pos = (byte_t*)l_cur_pkt;
+ break;
+ }
+ l_cur_pkt->data_len = (uint32_t)(l_data_pos - l_cur_pkt->data);
+ l_ret->data_size = (uint64_t)(l_data_pos - l_ret->data);
}
- if (l_ret->data_size != l_data_size) {
- log_it(L_ERROR, "Wrong pkt pack size %"DAP_UINT64_FORMAT_U", expected %zu", l_ret->data_size, l_data_size);
+ l_ret->obj_count = i;
+ if (i < l_count) {
+ log_it(L_ERROR, "Invalid pack size, only %ld / %ld pkts (%zu / %zu bytes) fit the storage",
+ i, l_count, l_ret->data_size, l_data_size);
+ size_t l_new_size = (size_t)(l_data_pos - (byte_t*)l_ret);
+ dap_global_db_pkt_pack_t *l_new_pack = DAP_REALLOC(l_ret, l_new_size);
+ if (l_new_pack)
+ l_ret = l_new_pack;
+ else
+ DAP_DEL_Z(l_ret);
}
clean_and_ret:
s_db_sqlite_clean(l_conn, 3, l_str_query, l_str_query_count, l_str_query_size, l_stmt, l_stmt_count, l_stmt_size);
- DAP_DEL_MULTY(l_table_name, l_blob_str);
return l_ret;
}
@@ -632,17 +642,26 @@ static dap_global_db_hash_pkt_t *s_db_sqlite_read_hashes(const char *a_group, da
l_blank_add = l_count == l_blank_add;
l_count += l_blank_add;
size_t l_group_name_len = strlen(a_group) + 1;
- DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_global_db_hash_pkt_t, sizeof(dap_global_db_hash_pkt_t) + l_count * sizeof(dap_global_db_driver_hash_t) + l_group_name_len, NULL, l_str_query_count, l_str_query);
+ l_ret = DAP_NEW_Z_SIZE(dap_global_db_hash_pkt_t, sizeof(dap_global_db_hash_pkt_t) + l_count * sizeof(dap_global_db_driver_hash_t) + l_group_name_len);
+ if (!l_ret) {
+ log_it(L_CRITICAL, "Memory allocation error!");
+ goto clean_and_ret;
+ }
// data forming
- size_t l_count_out = 0;
+ size_t l_count_out;
l_ret->group_name_len = l_group_name_len;
- byte_t *l_curr_point = l_ret->group_n_hashses + l_ret->group_name_len;
- memcpy(l_ret->group_n_hashses, a_group, l_group_name_len);
- int l_count_col = sqlite3_column_count(l_stmt);
- for(;l_count_out < l_count && s_db_sqlite_step(l_stmt, l_error_msg) == SQLITE_ROW && sqlite3_column_type(l_stmt, 0) == SQLITE_BLOB; ++l_count_out) {
- byte_t *l_current_hash = (byte_t*) sqlite3_column_blob(l_stmt, 0);
- memcpy(l_curr_point, l_current_hash, sizeof(dap_global_db_driver_hash_t));
- l_curr_point += sizeof(dap_global_db_driver_hash_t);
+ byte_t *l_pos = dap_mempcpy(l_ret->group_n_hashses, a_group, l_group_name_len);
+
+ for ( l_count_out = 0; l_count_out < l_count
+ && s_db_sqlite_step(l_stmt, l_error_msg) == SQLITE_ROW
+ && sqlite3_column_type(l_stmt, 0) == SQLITE_BLOB;
+ ++l_count_out )
+ {
+ if ( sqlite3_column_bytes(l_stmt, 0) != sizeof(dap_global_db_driver_hash_t) ) {
+ log_it(L_ERROR, "Invalid hash size, skip record");
+ continue;
+ }
+ l_pos = dap_mempcpy(l_pos, sqlite3_column_blob(l_stmt, 0), sizeof(dap_global_db_driver_hash_t));
}
l_ret->hashes_count = l_count_out + l_blank_add;
clean_and_ret:
@@ -679,23 +698,22 @@ static dap_store_obj_t* s_db_sqlite_read_cond_store_obj(const char *a_group, dap
l_table_name, DAP_GLOBAL_DB_RECORD_DEL,
a_with_holes ? ">=" : "=",
a_count_out && *a_count_out ? (int)*a_count_out : (int)DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT);
- DAP_DEL_Z(l_table_name);
+ DAP_DELETE(l_table_name);
if (!l_str_query_count || !l_str_query) {
log_it(L_ERROR, "Error in SQL request forming");
goto clean_and_ret;
}
- if(s_db_sqlite_prepare(l_conn->conn, l_str_query_count, &l_stmt_count, l_error_msg)!= SQLITE_OK ||
+ if( s_db_sqlite_prepare(l_conn->conn, l_str_query_count, &l_stmt_count, l_error_msg) != SQLITE_OK ||
s_db_sqlite_bind_blob64(l_stmt_count, 1, &a_hash_from, sizeof(a_hash_from), SQLITE_STATIC, l_error_msg) != SQLITE_OK ||
- s_db_sqlite_prepare(l_conn->conn, l_str_query, &l_stmt, l_error_msg)!= SQLITE_OK ||
- s_db_sqlite_bind_blob64(l_stmt, 1, &a_hash_from, sizeof(a_hash_from), SQLITE_STATIC, l_error_msg) != SQLITE_OK ||
- s_db_sqlite_step(l_stmt_count, l_error_msg) != SQLITE_ROW)
+ s_db_sqlite_prepare(l_conn->conn, l_str_query, &l_stmt, l_error_msg) != SQLITE_OK ||
+ s_db_sqlite_bind_blob64(l_stmt, 1, &a_hash_from, sizeof(a_hash_from), SQLITE_STATIC, l_error_msg) != SQLITE_OK ||
+ s_db_sqlite_step(l_stmt_count, l_error_msg) != SQLITE_ROW )
{
goto clean_and_ret;
}
// memory alloc
- uint64_t l_count = sqlite3_column_int64(l_stmt_count, 0);
- uint64_t l_blank_add = l_count;
+ uint64_t l_count = sqlite3_column_int64(l_stmt_count, 0), l_blank_add = l_count;
l_count = a_count_out && *a_count_out ? dap_min(l_count, *a_count_out) : dap_min(l_count, DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT);
if (!l_count) {
log_it(L_INFO, "There are no records satisfying the conditional read request");
@@ -703,16 +721,16 @@ static dap_store_obj_t* s_db_sqlite_read_cond_store_obj(const char *a_group, dap
}
l_blank_add = l_count == l_blank_add;
l_count += l_blank_add;
- DAP_NEW_Z_COUNT_RET_VAL(l_ret, dap_store_obj_t, l_count, NULL, l_str_query_count, l_str_query);
+ if (!( l_ret = DAP_NEW_Z_COUNT(dap_store_obj_t, l_count) )) {
+ log_it(L_CRITICAL, "Memory allocation error");
+ goto clean_and_ret;
+ }
// data forming
size_t l_count_out = 0;
- int l_ret_code = 0;
- for (l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt);
- l_ret_code == SQLITE_ROW && l_count_out < l_count;
- ++l_count_out, l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt)) {}
- if(l_ret_code != SQLITE_DONE) {
+ int rc;
+ for ( rc = 0; l_count_out < l_count && SQLITE_ROW == ( rc = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt) ); ++l_count_out );
+ if ( rc != SQLITE_DONE )
log_it(L_ERROR, "SQLite conditional read error %d(%s)", sqlite3_errcode(l_conn->conn), sqlite3_errmsg(l_conn->conn));
- }
if (a_count_out)
*a_count_out = l_count_out + l_blank_add;
clean_and_ret:
@@ -769,16 +787,17 @@ static dap_store_obj_t* s_db_sqlite_read_store_obj(const char *a_group, const ch
log_it(L_INFO, "There are no records satisfying the read request");
goto clean_and_ret;
}
- DAP_NEW_Z_COUNT_RET_VAL(l_ret, dap_store_obj_t, l_count, NULL, l_str_query_count, l_str_query);
+ if (!( l_ret = DAP_NEW_Z_COUNT(dap_store_obj_t, l_count) )) {
+ log_it(L_CRITICAL, "Memory allocation error");
+ goto clean_and_ret;
+ }
+
// data forming
size_t l_count_out = 0;
- int l_ret_code = 0;
- for (l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt);
- l_ret_code == SQLITE_ROW && l_count_out < l_count;
- ++l_count_out, l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt)) {}
- if(l_ret_code != SQLITE_DONE) {
+ int rc;
+ for ( rc = 0; l_count_out < l_count && SQLITE_ROW == ( rc = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt) ); ++l_count_out );
+ if ( rc != SQLITE_DONE )
log_it(L_ERROR, "SQLite read error %d(%s)", sqlite3_errcode(l_conn->conn), sqlite3_errmsg(l_conn->conn));
- }
if (a_count_out)
*a_count_out = l_count_out;
clean_and_ret:
@@ -794,8 +813,8 @@ clean_and_ret:
static dap_list_t *s_db_sqlite_get_groups_by_mask(const char *a_group_mask)
{
// sanity check
- conn_list_item_t *l_conn = NULL;
- dap_return_val_if_pass(!a_group_mask || !(l_conn = s_db_sqlite_get_connection(false)), NULL);
+ conn_list_item_t *l_conn = s_db_sqlite_get_connection(false);
+ dap_return_val_if_pass(!a_group_mask || !l_conn, NULL);
// preparing
const char *l_error_msg = "get groups";
dap_list_t* l_ret = NULL;
@@ -811,15 +830,14 @@ static dap_list_t *s_db_sqlite_get_groups_by_mask(const char *a_group_mask)
goto clean_and_ret;
}
l_mask = dap_str_replace_char(a_group_mask, '.', '_');
- int l_ret_code = 0;
- for (l_ret_code = s_db_sqlite_step(l_stmt, l_error_msg); l_ret_code == SQLITE_ROW && sqlite3_column_type(l_stmt, 0) == SQLITE_TEXT; l_ret_code = s_db_sqlite_step(l_stmt, l_error_msg)) {
- const char *l_table_name = (const char *)sqlite3_column_text(l_stmt, 0);
+ int rc = 0;
+ while ( SQLITE_ROW == ( rc = s_db_sqlite_step(l_stmt, l_error_msg) ) && sqlite3_column_type(l_stmt, 0) == SQLITE_TEXT ) {
+ const char *l_table_name = (const char*)sqlite3_column_text(l_stmt, 0);
if (dap_global_db_group_match_mask(l_table_name, l_mask))
l_ret = dap_list_prepend(l_ret, dap_str_replace_char(l_table_name, '_', '.'));
}
- if(l_ret_code != SQLITE_DONE) {
+ if ( rc != SQLITE_DONE )
log_it(L_ERROR, "SQLite read error %d(%s)", sqlite3_errcode(l_conn->conn), sqlite3_errmsg(l_conn->conn));
- }
clean_and_ret:
s_db_sqlite_clean(l_conn, 1, l_str_query, l_stmt);
DAP_DEL_Z(l_mask);
@@ -1022,8 +1040,8 @@ int dap_global_db_driver_sqlite_init(const char *a_filename_db, dap_global_db_dr
dap_return_val_if_pass(!a_filename_db, -1);
dap_return_val_if_pass_err(s_db_inited, -2, "SQLite driver already init")
// func work
- int l_ret = -1, l_errno = errno;
- char l_errbuf[255] = {0}, *l_error_message = NULL;
+ int l_ret = -1;
+ char l_errbuf[255] = "", *l_error_message = NULL;
if ( sqlite3_threadsafe() && !sqlite3_config(SQLITE_CONFIG_MULTITHREAD) )
l_ret = sqlite3_initialize();
@@ -1040,13 +1058,12 @@ int dap_global_db_driver_sqlite_init(const char *a_filename_db, dap_global_db_dr
log_it(L_NOTICE, "No directory %s, trying to create...",l_filename_dir);
int l_mkdir_ret = dap_mkdir_with_parents(l_filename_dir);
- l_errno = errno;
if(!dap_dir_test(l_filename_dir)){
- strerror_r(l_errno,l_errbuf,sizeof(l_errbuf));
- log_it(L_ERROR, "Can't create directory, error code %d, error string \"%s\"", l_mkdir_ret, l_errbuf);
+ log_it(L_ERROR, "Can't create directory, error code %d, error %d: \"%s\"",
+ l_mkdir_ret, errno, dap_strerror(errno));
DAP_DELETE(l_filename_dir);
- return -l_errno;
+ return -errno;
}else
log_it(L_NOTICE, "Directory created");
}
diff --git a/global-db/dap_global_db_legacy.c b/global-db/dap_global_db_legacy.c
index f5cc9e010572788674fe13a6216d72d9a5c58297..7a89f1187ddbc738e94f1e60cda55c222d7c05fe 100644
--- a/global-db/dap_global_db_legacy.c
+++ b/global-db/dap_global_db_legacy.c
@@ -68,8 +68,7 @@ dap_global_db_legacy_list_t *dap_global_db_legacy_list_start(const char *a_net_n
if (!l_items_number)
return NULL;
- dap_global_db_legacy_list_t *l_db_legacy_list;
- DAP_NEW_Z_RET_VAL(l_db_legacy_list, dap_global_db_legacy_list_t, NULL, NULL);
+ dap_global_db_legacy_list_t *l_db_legacy_list = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_global_db_legacy_list_t, NULL);
l_db_legacy_list->groups = l_db_legacy_list->current_group = l_groups;
l_db_legacy_list->items_rest = l_db_legacy_list->items_number = l_items_number;
@@ -154,13 +153,10 @@ dap_global_db_pkt_old_t *dap_global_db_pkt_pack_old(dap_global_db_pkt_old_t *a_o
{
if (!a_new_pkt)
return a_old_pkt;
- a_old_pkt = a_old_pkt
- ? DAP_REALLOC(a_old_pkt, sizeof(dap_global_db_pkt_old_t) + a_old_pkt->data_size + a_new_pkt->data_size)
- : DAP_NEW_Z_SIZE(dap_global_db_pkt_old_t, sizeof(dap_global_db_pkt_old_t) + a_new_pkt->data_size);
- if (!a_old_pkt) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
+ dap_global_db_pkt_old_t *l_old_pkt_new = a_old_pkt
+ ? DAP_REALLOC_RET_VAL_IF_FAIL(a_old_pkt, sizeof(dap_global_db_pkt_old_t) + a_old_pkt->data_size + a_new_pkt->data_size, NULL)
+ : DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_global_db_pkt_old_t, sizeof(dap_global_db_pkt_old_t) + a_new_pkt->data_size, NULL);
+ a_old_pkt = l_old_pkt_new;
memcpy(a_old_pkt->data + a_old_pkt->data_size, a_new_pkt->data, a_new_pkt->data_size);
a_old_pkt->data_size += a_new_pkt->data_size;
++a_old_pkt->obj_count;
diff --git a/global-db/dap_global_db_pkt.c b/global-db/dap_global_db_pkt.c
index ef832a4f85beb4ce7319fca355c09a6e53d07491..5565c4a9c464c12c0926a004000015e3040443b6 100644
--- a/global-db/dap_global_db_pkt.c
+++ b/global-db/dap_global_db_pkt.c
@@ -41,14 +41,12 @@ dap_global_db_pkt_pack_t *dap_global_db_pkt_pack(dap_global_db_pkt_pack_t *a_old
if (!a_new_pkt)
return a_old_pkt;
size_t l_add_size = dap_global_db_pkt_get_size(a_new_pkt);
- dap_global_db_pkt_pack_t *l_old_pkt;
- if (a_old_pkt)
- l_old_pkt = (dap_global_db_pkt_pack_t *)DAP_REALLOC(a_old_pkt, a_old_pkt->data_size + sizeof(dap_global_db_pkt_pack_t) + l_add_size);
- else
- DAP_NEW_Z_SIZE_RET_VAL(l_old_pkt, dap_global_db_pkt_pack_t, sizeof(dap_global_db_pkt_pack_t) + l_add_size, a_old_pkt, NULL);
+ dap_global_db_pkt_pack_t *l_old_pkt = !a_old_pkt
+ ? DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_global_db_pkt_pack_t, sizeof(dap_global_db_pkt_pack_t) + l_add_size, NULL)
+ : DAP_REALLOC_RET_VAL_IF_FAIL(a_old_pkt, a_old_pkt->data_size + sizeof(dap_global_db_pkt_pack_t) + l_add_size, NULL);
memcpy(l_old_pkt->data + l_old_pkt->data_size, a_new_pkt, l_add_size);
l_old_pkt->data_size += l_add_size;
- l_old_pkt->obj_count++;
+ ++l_old_pkt->obj_count;
return l_old_pkt;
}
@@ -60,16 +58,11 @@ dap_global_db_pkt_pack_t *dap_global_db_pkt_pack(dap_global_db_pkt_pack_t *a_old
dap_global_db_pkt_t *dap_global_db_pkt_serialize(dap_store_obj_t *a_store_obj)
{
dap_return_val_if_fail(a_store_obj, NULL);
-
size_t l_group_len = dap_strlen(a_store_obj->group);
size_t l_key_len = dap_strlen(a_store_obj->key);
size_t l_sign_len = a_store_obj->sign ? dap_sign_get_size(a_store_obj->sign) : 0;
size_t l_data_size_out = l_group_len + l_key_len + a_store_obj->value_len + l_sign_len;
- dap_global_db_pkt_t *l_pkt = DAP_NEW_Z_SIZE(dap_global_db_pkt_t, l_data_size_out + sizeof(dap_global_db_pkt_t));
- if (!l_pkt) {
- log_it(L_CRITICAL, "Insufficient memory");
- return NULL;
- }
+ dap_global_db_pkt_t *l_pkt = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_global_db_pkt_t, l_data_size_out + sizeof(dap_global_db_pkt_t), NULL);
/* Fill packet header */
l_pkt->timestamp = a_store_obj->timestamp;
@@ -115,12 +108,8 @@ dap_sign_t *dap_store_obj_sign(dap_store_obj_t *a_obj, dap_enc_key_t *a_key, uin
if (a_checksum) {
if (a_key) {
size_t l_sign_len = dap_sign_get_size(l_sign);
- l_pkt = DAP_REALLOC(l_pkt, dap_global_db_pkt_get_size(l_pkt) + l_sign_len);
- if (!l_pkt) {
- log_it(L_CRITICAL, "Not enough memory");
- DAP_DELETE(l_sign);
- return NULL;
- }
+ dap_global_db_pkt_t *l_new_pkt = DAP_REALLOC_RET_VAL_IF_FAIL(l_pkt, dap_global_db_pkt_get_size(l_pkt) + l_sign_len, NULL, l_sign);
+ l_pkt = l_new_pkt;
memcpy(l_pkt->data + l_pkt->data_len, l_sign, l_sign_len);
l_pkt->data_len += l_sign_len;
}
diff --git a/global-db/include/dap_global_db.h b/global-db/include/dap_global_db.h
index b020cfaa0df74d2d9cbf3ef60d660771da0d8a0a..664a8e8e8f82447addef2017ffcec53179ec7799 100644
--- a/global-db/include/dap_global_db.h
+++ b/global-db/include/dap_global_db.h
@@ -36,9 +36,9 @@ typedef struct dap_global_db_cluster dap_global_db_cluster_t;
// Global DB instance with settings data
typedef struct dap_global_db_instance {
- uint32_t version; // Current GlobalDB version
- const char *storage_path; // GlobalDB storage path
- const char *driver_name; // GlobalDB driver name
+ uint32_t version; // Current GlobalDB version
+ char *storage_path; // GlobalDB storage path
+ char *driver_name; // GlobalDB driver name
dap_list_t *whitelist;
dap_list_t *blacklist;
uint64_t store_time_limit;
@@ -48,7 +48,7 @@ typedef struct dap_global_db_instance {
} dap_global_db_instance_t;
typedef struct dap_global_db_obj {
- const char *key;
+ char *key;
uint8_t *value;
size_t value_len;
dap_nanotime_t timestamp;
diff --git a/global-db/include/dap_global_db_cluster.h b/global-db/include/dap_global_db_cluster.h
index 642803433b44ca16c80ba3d101360753d93bc175..a20956a8af138989594c461fdab37db91724611f 100644
--- a/global-db/include/dap_global_db_cluster.h
+++ b/global-db/include/dap_global_db_cluster.h
@@ -74,7 +74,7 @@ typedef struct dap_global_db_sync_context {
} dap_global_db_sync_context_t;
typedef struct dap_global_db_cluster {
- const char *groups_mask; // GDB cluster coverage area
+ char *groups_mask; // GDB cluster coverage area
dap_cluster_t *links_cluster; // Cluster container for network links
dap_cluster_t *role_cluster; // Cluster container for members with especial roles
dap_global_db_role_t default_role; // Role assined for new membersadded with default one
diff --git a/global-db/include/dap_global_db_driver.h b/global-db/include/dap_global_db_driver.h
index 4c1ae70ace3346b6d1687de6f93834820615cafc..811ead5eaf8569474afb18bac821b4eb52c4a6a7 100644
--- a/global-db/include/dap_global_db_driver.h
+++ b/global-db/include/dap_global_db_driver.h
@@ -56,7 +56,7 @@ typedef struct dap_global_db_driver_hash {
typedef struct dap_store_obj {
char *group; // Name of database table analogue (key-value DB have no 'table' defined)
- const char *key; // Unique database key
+ char *key; // Unique database key
byte_t *value; // Database value corresponsing with database key
size_t value_len; // Length of database value
uint8_t flags; // Record flags
diff --git a/global-db/test/dap_global_db_test.c b/global-db/test/dap_global_db_test.c
index 16c6e35ed7e8531488f8297c36ab03400e6c5506..eacb804b33d46c875f1f581f715842dad04dcbc0 100644
--- a/global-db/test/dap_global_db_test.c
+++ b/global-db/test/dap_global_db_test.c
@@ -91,7 +91,7 @@ static int s_test_write(size_t a_count)
log_it(L_DEBUG, "Write %zu record in GDB", i);
l_store_obj.group = DAP_DB$T_GROUP;
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i); // add bad to check rewrite /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i); // add bad to check rewrite /* Generate a key of record */
clock_gettime(CLOCK_REALTIME, &now); /* Get and save record's timestamp */
l_store_obj.timestamp = ((uint64_t)now.tv_sec << 32) | ((uint32_t) (now.tv_nsec));
@@ -136,7 +136,7 @@ static int s_test_write(size_t a_count)
l_store_obj.group = DAP_DB$T_GROUP_WRONG;
l_store_obj.crc = i + 1;
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%09zx", i);
+ snprintf(l_key, sizeof(l_key), "KEY$%09zx", i);
l_time = get_cur_time_msec();
ret = dap_global_db_driver_add(&l_store_obj, 1);
@@ -157,7 +157,7 @@ static int s_test_read(size_t a_count)
dap_chain_hash_fast_t csum = { 0 };;
dap_db_test_record_t *prec = NULL;
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i); /* Generate a key of record */
l_time = get_cur_time_msec();
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, true);
@@ -199,7 +199,7 @@ static void s_test_read_cond_store(size_t a_count)
dap_assert_PIF(l_count <= DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT + dap_global_db_driver_hash_is_blank(&l_blank_check), "Wrong finded records count");
for (size_t j = i, k = 0; j < a_count && k < l_count; ++j, ++k) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", j); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", j); /* Generate a key of record */
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, true);
dap_assert_PIF(l_store_obj, "Record-Not-Found");
dap_assert_PIF(!strcmp(DAP_DB$T_GROUP, (l_objs + k)->group), "Wrong group");
@@ -253,7 +253,7 @@ static void s_test_count(size_t a_count)
int l_time = 0;
for (size_t i = 0; i < a_count; ++i) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i);
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i);
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, true);
dap_assert_PIF(l_store_obj, "Records-Not-Found");
@@ -272,7 +272,7 @@ static void s_test_count(size_t a_count)
if (i >= a_count)
break;
}
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i);
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i);
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, false);
dap_assert_PIF(l_store_obj, "Records-Not-Found");
@@ -295,14 +295,14 @@ static void s_test_is_obj(size_t a_count)
{
for (size_t i = 0; i < a_count; ++i) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i); /* Generate a key of record */
dap_assert_PIF(dap_global_db_driver_is(DAP_DB$T_GROUP, l_key), "Key not finded")
dap_assert_PIF(!dap_global_db_driver_is(DAP_DB$T_GROUP_WRONG, l_key), "Key finded in wrong group")
dap_assert_PIF(!dap_global_db_driver_is(DAP_DB$T_GROUP_NOT_EXISTED, l_key), "Key finded in not existed group")
}
for (size_t i = a_count; i < a_count * 2; ++i) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i); /* Generate a key of record */
dap_assert_PIF(!dap_global_db_driver_is(DAP_DB$T_GROUP, l_key), "Finded not existed key")
dap_assert_PIF(!dap_global_db_driver_is(DAP_DB$T_GROUP_WRONG, l_key), "Finded not existed key in wrong group")
dap_assert_PIF(!dap_global_db_driver_is(DAP_DB$T_GROUP_NOT_EXISTED, l_key), "Finded not existed key in not existed group")
@@ -314,7 +314,7 @@ static void s_test_is_hash(size_t a_count)
{
for (size_t i = 0; i < a_count; ++i) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i); /* Generate a key of record */
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, true);
dap_assert_PIF(l_store_obj, "Record-Not-Found");
dap_global_db_driver_hash_t l_driver_key = dap_global_db_driver_hash_get(l_store_obj);
@@ -338,7 +338,7 @@ static void s_test_last(size_t a_count)
{
char l_key[64] = { 0 };
// with holes
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", a_count - 1);
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", a_count - 1);
dap_store_obj_t *l_store_obj = dap_global_db_driver_read_last(DAP_DB$T_GROUP, true);
dap_assert_PIF(l_store_obj && !strcmp(l_key, l_store_obj->key), "Last with holes");
dap_store_obj_free_one(l_store_obj);
@@ -350,7 +350,7 @@ static void s_test_last(size_t a_count)
l_store_obj = dap_global_db_driver_read_last(DAP_DB$T_GROUP_NOT_EXISTED, true);
dap_assert_PIF(!l_store_obj, "Last with holes in not existed group");
// without holes
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", a_count - 1 - a_count % DAP_DB$SZ_HOLES);
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", a_count - 1 - a_count % DAP_DB$SZ_HOLES);
l_store_obj = dap_global_db_driver_read_last(DAP_DB$T_GROUP, false);
dap_assert_PIF(l_store_obj && !strcmp(l_key, l_store_obj->key), "Last without holes");
dap_store_obj_free_one(l_store_obj);
@@ -381,7 +381,7 @@ static void s_test_read_hashes(size_t a_count)
size_t l_bias = l_hashes->group_name_len;
for (size_t j = i, k = 0; j < a_count && k < DAP_GLOBAL_DB_COND_READ_KEYS_DEFAULT; ++j, ++k) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", j); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", j); /* Generate a key of record */
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, true);
dap_assert_PIF(l_store_obj, "Record-Not-Found");
dap_global_db_driver_hash_t l_driver_key_current = dap_global_db_driver_hash_get(l_store_obj);
@@ -414,7 +414,7 @@ static void s_test_get_by_hash(size_t a_count)
size_t l_total_data = 0;
for (size_t j = 0; j < l_hashes->hashes_count - dap_global_db_driver_hash_is_blank((dap_global_db_driver_hash_t *)(l_hashes->group_n_hashses + l_hashes->group_name_len) + l_hashes->hashes_count - 1); ++j) {
char l_key[64] = { 0 };
- snprintf(l_key, sizeof(l_key) - 1, "KEY$%08zx", i + j); /* Generate a key of record */
+ snprintf(l_key, sizeof(l_key), "KEY$%08zx", i + j); /* Generate a key of record */
dap_store_obj_t *l_store_obj = dap_global_db_driver_read(DAP_DB$T_GROUP, l_key, NULL, true);
dap_assert_PIF(l_store_obj, "Record-Not-Found");
dap_global_db_pkt_t *l_cur_pkt = (dap_global_db_pkt_t *)(l_objs->data + l_total_data);
diff --git a/io/dap_context.c b/io/dap_context.c
index db352198212efec227f9495da4de81fc89891c2a..0334ccba30c4ea22bbe87d72815d7493bb071b6f 100644
--- a/io/dap_context.c
+++ b/io/dap_context.c
@@ -730,8 +730,7 @@ int dap_worker_thread_loop(dap_context_t * a_context)
#ifdef DAP_OS_WINDOWS
log_it(L_ERROR, "Context thread %d got errno %d", a_context->id, WSAGetLastError());
#else
- strerror_r(l_errno, l_error_buf, sizeof (l_error_buf) - 1);
- log_it(L_ERROR, "Context thread %d got errno:\"%s\" (%d)", a_context->id, l_error_buf, l_errno);
+ log_it(L_ERROR, "Context thread %d got error: %d: \"%s\"", a_context->id, errno, dap_strerror(errno));
assert(l_errno);
#endif
break;
@@ -1031,9 +1030,7 @@ int dap_worker_thread_loop(dap_context_t * a_context)
if( l_errno == EAGAIN || l_errno == EWOULDBLOCK){// Everything is good, we'll receive ACCEPT on next poll
continue;
}else{
- char l_errbuf[128];
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_WARNING,"accept() on socket %d error:\"%s\"(%d)",l_cur->socket, l_errbuf,l_errno);
+ log_it(L_WARNING,"accept() on socket %d error %d: \"%s\"",l_cur->socket, l_errno, dap_strerror(l_errno));
break;
}
}
@@ -1165,14 +1162,12 @@ int dap_worker_thread_loop(dap_context_t * a_context)
#endif
} else {
l_error_len = sizeof(l_errno);
-
getsockopt(l_cur->socket, SOL_SOCKET, SO_ERROR, (void *)&l_errno, &l_error_len);
if(l_errno == EINPROGRESS) {
log_it(L_DEBUG, "Connecting with %s in progress...", l_cur->remote_addr_str);
}else if (l_errno){
- strerror_r(l_errno, l_error_buf, sizeof (l_error_buf));
- log_it(L_ERROR,"Connecting error with %s: \"%s\" (code %d)", l_cur->remote_addr_str,
- l_error_buf, l_errno);
+ log_it(L_ERROR,"Connecting with %s failed, error %d: \"%s\"", l_cur->remote_addr_str,
+ l_errno, dap_strerror(l_errno));
if ( l_cur->callbacks.error_callback )
l_cur->callbacks.error_callback(l_cur, l_errno);
}else{
@@ -1657,11 +1652,8 @@ lb_exit:
#ifdef DAP_EVENTS_CAPS_IOCP
log_it(L_ERROR, "IOCP update failed, errno %lu %llu", l_errno, a_es->socket);
#else
- char l_errbuf[128];
- l_errbuf[0]=0;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_ERROR,"Can't update client socket state on poll/epoll/kqueue fd %" DAP_FORMAT_SOCKET ": \"%s\" (%d)",
- a_es->socket, l_errbuf, l_errno);
+ log_it(L_ERROR,"Can't update client socket state on poll/epoll/kqueue fd %" DAP_FORMAT_SOCKET ", error %d: \"%s\"",
+ a_es->socket, l_errno, dap_strerror(l_errno) );
#endif
return l_errno;
}
@@ -1869,25 +1861,13 @@ dap_events_socket_t *dap_context_find(dap_context_t * a_context, dap_events_sock
#if defined(DAP_EVENTS_CAPS_QUEUE_PIPE2) || defined(DAP_EVENTS_CAPS_QUEUE_PIPE)
int l_pipe[2];
- char l_errbuf[255];
- int l_errno;
- l_errbuf[0]=0;
#if defined(DAP_EVENTS_CAPS_QUEUE_PIPE2)
if( pipe2(l_pipe,O_DIRECT | O_NONBLOCK ) < 0 ){
#elif defined(DAP_EVENTS_CAPS_QUEUE_PIPE)
if( pipe(l_pipe) < 0 ){
#endif
- l_errno = errno;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- switch (l_errno) {
- case EINVAL: log_it(L_CRITICAL, "Too old linux version thats doesn't support O_DIRECT flag for pipes (%s)", l_errbuf); break;
- default: log_it( L_ERROR, "Error detected, can't create pipe(): '%s' (%d)", l_errbuf, l_errno);
- }
- DAP_DELETE(l_es);
- return NULL;
+ return DAP_DELETE(l_es), log_it(L_ERROR, "pipe() failed, error %d: '%s'", errno, dap_strerror(errno)), NULL;
}
- //else
- // log_it(L_DEBUG, "Created one-way unnamed packet pipe %d->%d", l_pipe[0], l_pipe[1]);
l_es->fd = l_pipe[0];
l_es->fd2 = l_pipe[1];
@@ -1910,10 +1890,8 @@ dap_events_socket_t *dap_context_find(dap_context_t * a_context, dap_events_sock
#if !defined (DAP_OS_ANDROID)
FILE* l_sys_max_pipe_size_fd = fopen("/proc/sys/fs/pipe-max-size", "r");
if (l_sys_max_pipe_size_fd) {
- const int l_file_buf_size = 64;
- char l_file_buf[l_file_buf_size];
- memset(l_file_buf, 0, l_file_buf_size);
- fread(l_file_buf, l_file_buf_size, 1, l_sys_max_pipe_size_fd);
+ char l_file_buf[64] = "";
+ fread(l_file_buf, sizeof(l_file_buf), 1, l_sys_max_pipe_size_fd);
uint64_t l_sys_max_pipe_size = strtoull(l_file_buf, 0, 10);
fcntl(l_pipe[0], F_SETPIPE_SZ, l_sys_max_pipe_size);
fclose(l_sys_max_pipe_size_fd);
@@ -2027,25 +2005,9 @@ dap_events_socket_t * dap_context_create_event(dap_context_t * a_context, dap_ev
#endif
#ifdef DAP_EVENTS_CAPS_EVENT_EVENTFD
- if((l_es->fd = eventfd(0,EFD_NONBLOCK) ) < 0 ){
- int l_errno = errno;
- char l_errbuf[128];
- l_errbuf[0]=0;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- switch (l_errno) {
- case EINVAL: log_it(L_CRITICAL, "An unsupported value was specified in flags: \"%s\" (%d)", l_errbuf, l_errno); break;
- case EMFILE: log_it(L_CRITICAL, "The per-process limit on the number of open file descriptors has been reached: \"%s\" (%d)", l_errbuf, l_errno); break;
- case ENFILE: log_it(L_CRITICAL, "The system-wide limit on the total number of open files has been reached: \"%s\" (%d)", l_errbuf, l_errno); break;
- case ENODEV: log_it(L_CRITICAL, "Could not mount (internal) anonymous inode device: \"%s\" (%d)", l_errbuf, l_errno); break;
- case ENOMEM: log_it(L_CRITICAL, "There was insufficient memory to create a new eventfd file descriptor: \"%s\" (%d)", l_errbuf, l_errno); break;
- default: log_it( L_ERROR, "Error detected, can't create eventfd: '%s' (%d)", l_errbuf, l_errno);
- }
- DAP_DELETE(l_es);
- return NULL;
- }else {
- l_es->fd2 = l_es->fd;
- //log_it(L_DEBUG, "Created eventfd descriptor %d", l_es->fd );
- }
+ if ( (l_es->fd = eventfd(0,EFD_NONBLOCK) ) < 0 )
+ return DAP_DELETE(l_es), log_it(L_ERROR, "Can't create eventfd, error %d: '%s'", errno, dap_strerror(errno)), NULL;
+ l_es->fd2 = l_es->fd;
#elif defined DAP_EVENTS_CAPS_WEPOLL
l_es->socket = socket(AF_INET, SOCK_DGRAM, 0);
@@ -2128,17 +2090,8 @@ dap_events_socket_t * dap_context_create_pipe(dap_context_t * a_context, dap_eve
#if defined(DAP_EVENTS_CAPS_PIPE_POSIX)
int l_pipe[2];
- int l_errno;
- char l_errbuf[128];
- l_errbuf[0]=0;
- if( pipe(l_pipe) < 0 ){
- l_errno = errno;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it( L_ERROR, "Error detected, can't create pipe(): '%s' (%d)", l_errbuf, l_errno);
- DAP_DELETE(l_es);
- return NULL;
- }//else
- // log_it(L_DEBUG, "Created one-way unnamed bytestream pipe %d->%d", l_pipe[0], l_pipe[1]);
+ if( pipe(l_pipe) < 0 )
+ return DAP_DELETE(l_es), log_it( L_ERROR, "Error detected, can't create pipe(), error %d: '%s'", errno, dap_strerror(errno)), NULL;
l_es->fd = l_pipe[0];
l_es->fd2 = l_pipe[1];
#if defined DAP_OS_UNIX
diff --git a/io/dap_events.c b/io/dap_events.c
index c80756a8bb506d1a552545a82998ab5f04abaa29..5f6dfb4a718ffa01270d5ea75a220aa40e6ef886 100644
--- a/io/dap_events.c
+++ b/io/dap_events.c
@@ -89,8 +89,6 @@ typedef cpuset_t cpu_set_t; // Adopt BSD CPU setstructure to POSIX variant
#include <pthread.h>
#include "dap_common.h"
-#include "dap_strfuncs.h"
-#include "dap_server.h"
#include "dap_events.h"
#include "dap_context.h"
#include "dap_events_socket.h"
@@ -199,16 +197,7 @@ void dap_cpu_assign_thread_on(uint32_t a_cpu_id)
if(l_retcode != 0)
#endif
{
- char l_errbuf[128]={0};
- switch (l_retcode) {
- 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_ERROR, "Worker #%u: error in set affinity thread call: %s (%d)",a_cpu_id, l_errbuf , l_retcode);
- //abort();
+ log_it(L_ERROR, "Set affinity error %d: \"%s\"", l_retcode, dap_strerror(l_retcode));
}
#endif
#else
diff --git a/io/dap_events_socket.c b/io/dap_events_socket.c
index 1bb6c32a5d9091adf481133af8a0641830c5cb7b..979519dc4520fe0cd56161fed84b3214d867076e 100644
--- a/io/dap_events_socket.c
+++ b/io/dap_events_socket.c
@@ -202,7 +202,7 @@ int dap_events_socket_queue_data_send(dap_events_socket_t *a_es, const void *a_d
queue_entry_t *l_entry = DAP_ALMALLOC(MEMORY_ALLOCATION_ALIGNMENT, sizeof(queue_entry_t));
*l_entry = (queue_entry_t) {
.size = a_size,
- .data = a_size ? DAP_DUP_SIZE(a_data, a_size) : (void*)a_data
+ .data = a_size ? DAP_DUP_SIZE((char*)a_data, a_size) : (void*)a_data
};
if (g_debug_reactor) {
if (a_size)
@@ -590,13 +590,8 @@ dap_events_socket_t * dap_events_socket_queue_ptr_create_input(dap_events_socket
if ( 0 >= (l_es->mqd = mq_open(l_mq_name, O_CREAT|O_WRONLY |O_NONBLOCK, 0700, &l_mq_attr)) )
{
- log_it(L_CRITICAL,"Can't create mqueue descriptor %s: \"%s\" code %d (%s)", l_mq_name, l_errbuf, errno,
- (strerror_r(errno, l_errbuf, sizeof (l_errbuf)), l_errbuf) );
-
- DAP_DELETE(l_es->buf_in);
- DAP_DELETE(l_es->buf_out);
- DAP_DELETE(l_es);
- return NULL;
+ log_it(L_CRITICAL,"Can't create mqueue descriptor %s, error %d: \"%s\"", l_mq_name, errno, dap_strerror(errno));
+ return DAP_DEL_MULTY(l_es->buf_in, l_es->buf_out, l_es), NULL;
}
#elif defined (DAP_EVENTS_CAPS_QUEUE_PIPE2) || defined (DAP_EVENTS_CAPS_QUEUE_PIPE)
@@ -681,30 +676,14 @@ int dap_events_socket_queue_proc_input_unsafe(dap_events_socket_t * a_esocket)
a_esocket->callbacks.queue_ptr_callback(a_esocket, l_queue_ptr);
}
if (l_ret == -1) {
- int l_errno = errno;
- switch (l_errno) {
+ switch (errno) {
case EAGAIN:
debug_if(g_debug_reactor, L_INFO, "Received and processed %lu callbacks in 1 pass", l_shift / 8);
break;
- default: {
- char l_errbuf[128];
- l_errbuf[0]=0;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_ERROR, "mq_receive error in esocket queue_ptr:\"%s\" code %d", l_errbuf, l_errno);
- return -1;
- }
+ default:
+ return log_it(L_ERROR, "mq_receive error in esocket queue_ptr:\"%s\" code %d", dap_strerror(errno), errno), -1;
}
}
- ssize_t l_ret = mq_receive(a_esocket->mqd,(char*) &l_queue_ptr, sizeof (l_queue_ptr),NULL);
- if (l_ret == -1){
- int l_errno = errno;
- char l_errbuf[128];
- l_errbuf[0]=0;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_ERROR, "Error in esocket queue_ptr:\"%s\" code %d", l_errbuf, l_errno);
- return -1;
- }
- a_esocket->callbacks.queue_ptr_callback (a_esocket, l_queue_ptr);
#elif defined DAP_EVENTS_CAPS_WEPOLL
if(l_read > 0) {
debug_if(g_debug_reactor, L_NOTICE, "Got %ld bytes from socket", l_read);
@@ -1187,7 +1166,7 @@ void dap_events_socket_descriptor_close(dap_events_socket_t *a_esocket)
}
if ( a_esocket->fd2 > 0 )
closesocket(a_esocket->fd2);
- a_esocket->fd = a_esocket->fd2 = INVALID_SOCKET;
+ a_esocket->socket = a_esocket->socket2 = INVALID_SOCKET;
}
/**
@@ -1489,9 +1468,6 @@ void dap_events_socket_set_readable_unsafe( dap_events_socket_t *a_esocket, bool
int l_kevent_ret = kevent(l_kqueue_fd,&l_event,1,NULL,0,NULL);
int l_errno = errno;
if ( l_kevent_ret == -1 && l_errno != EINPROGRESS ){
- char l_errbuf[128];
- l_errbuf[0]=0;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
if (l_errno == EBADF){
log_it(L_ATT,"Set readable: socket %d (%p ) disconnected, rise CLOSE flag to remove from queue, lost %"DAP_UINT64_FORMAT_U":%" DAP_UINT64_FORMAT_U
" bytes",a_esocket->socket,a_esocket,a_esocket->buf_in_size,a_esocket->buf_out_size);
@@ -1499,7 +1475,7 @@ void dap_events_socket_set_readable_unsafe( dap_events_socket_t *a_esocket, bool
a_esocket->buf_in_size = a_esocket->buf_out_size = 0; // Reset everything from buffer, we close it now all
}else{
log_it(L_ERROR,"Can't update client socket %d state on kqueue fd for set_read op %d: \"%s\" (%d)",
- a_esocket->socket, l_kqueue_fd, l_errbuf, l_errno);
+ a_esocket->socket, l_kqueue_fd, dap_strerror(l_errno), l_errno);
}
}
}
@@ -1540,9 +1516,6 @@ void dap_events_socket_set_writable_unsafe( dap_events_socket_t *a_esocket, bool
int l_kevent_ret=kevent(l_kqueue_fd,&l_event,1,NULL,0,NULL);
int l_errno = errno;
if ( l_kevent_ret == -1 && l_errno != EINPROGRESS && l_errno != ENOENT ){
- char l_errbuf[128];
- l_errbuf[0]=0;
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
if (l_errno == EBADF){
log_it(L_ATT,"Set writable: socket %d (%p ) disconnected, rise CLOSE flag to remove from queue, lost %"DAP_UINT64_FORMAT_U":%" DAP_UINT64_FORMAT_U
" bytes",a_esocket->socket,a_esocket,a_esocket->buf_in_size,a_esocket->buf_out_size);
@@ -1550,7 +1523,7 @@ void dap_events_socket_set_writable_unsafe( dap_events_socket_t *a_esocket, bool
a_esocket->buf_in_size = a_esocket->buf_out_size = 0; // Reset everything from buffer, we close it now all
}else{
log_it(L_ERROR,"Can't update client socket %d state on kqueue fd for set_write op %d: \"%s\" (%d)",
- a_esocket->socket, l_kqueue_fd, l_errbuf, l_errno);
+ a_esocket->socket, l_kqueue_fd, dap_strerror(l_errno), l_errno);
}
}
}
@@ -1595,12 +1568,9 @@ int dap_events_socket_queue_ptr_send( dap_events_socket_t *a_es, void *a_arg)
log_it(L_ERROR, "Number of pending messages: %ld", a_es->buf_out_size);
s_add_ptr_to_buf(a_es, a_arg);
return 0;
- default: {
- char l_errbuf[128] = { '\0' };
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_ERROR, "Can't send ptr to queue:\"%s\" code %d", l_errbuf, l_errno);
- return l_errno;
- }}
+ default:
+ return log_it(L_ERROR, "Can't send ptr to queue, error %d:\"%s\"", l_errno, dap_strerror(l_errno)), l_errno;
+ }
l_ret = mq_send(a_es->mqd, (const char *)&a_arg, sizeof (a_arg), 0);
l_errno = errno;
if ( l_ret == EPERM){
@@ -1833,7 +1803,7 @@ size_t dap_events_socket_write_inter(dap_events_socket_t * a_es_input, dap_event
dap_worker_msg_io_t * l_msg = DAP_NEW_Z(dap_worker_msg_io_t); if( !l_msg) return 0;
l_msg->esocket_uuid = a_es_uuid;
if (a_data && a_data_size)
- l_msg->data = DAP_DUP_SIZE(a_data ,a_data_size);
+ l_msg->data = DAP_DUP_SIZE((char*)a_data, a_data_size);
l_msg->data_size = a_data_size;
l_msg->flags_set = DAP_SOCK_READY_TO_WRITE;
@@ -1927,7 +1897,7 @@ size_t dap_events_socket_write(dap_events_socket_uuid_t a_es_uuid, const void *
* @param l_data_size
* @return
*/
-size_t dap_events_socket_write_mt(dap_worker_t * a_w,dap_events_socket_uuid_t a_es_uuid, const void *a_data, size_t a_data_size)
+size_t dap_events_socket_write_mt(dap_worker_t * a_w,dap_events_socket_uuid_t a_es_uuid, void *a_data, size_t a_data_size)
{
#ifdef DAP_EVENTS_CAPS_IOCP
dap_overlapped_t *ol = DAP_NEW_SIZE(dap_overlapped_t, sizeof(dap_overlapped_t) + a_data_size);
@@ -1939,21 +1909,17 @@ size_t dap_events_socket_write_mt(dap_worker_t * a_w,dap_events_socket_uuid_t a_
: ( DAP_DELETE(ol), log_it(L_ERROR, "Can't schedule writing to %"DAP_UINT64_FORMAT_U" in context #%d, error %d",
a_es_uuid, a_w->context->id, GetLastError()), 0 );
#else
- dap_worker_msg_io_t * l_msg = DAP_NEW_Z(dap_worker_msg_io_t); if (!l_msg) return 0;
+ dap_worker_msg_io_t * l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_worker_msg_io_t, 0);
l_msg->esocket_uuid = a_es_uuid;
if (a_data && a_data_size)
l_msg->data = (char*)a_data; // DAP_DUP_SIZE(a_data, a_data_size);
l_msg->data_size = a_data_size;
l_msg->flags_set = DAP_SOCK_READY_TO_WRITE;
- int l_ret= dap_events_socket_queue_ptr_send(a_w->queue_es_io, l_msg );
- if (l_ret!=0){
- log_it(L_ERROR, "wite mt: wasn't send pointer to queue: code %d", l_ret);
- DAP_DEL_Z(l_msg->data);
- DAP_DELETE(l_msg);
- return 0;
- }
- return a_data_size;
+ int l_ret = dap_events_socket_queue_ptr_send(a_w->queue_es_io, l_msg);
+ return l_ret
+ ? log_it(L_ERROR, "wite mt: wasn't send pointer to queue: code %d", l_ret), DAP_DEL_MULTY(l_msg->data, l_msg), 0
+ : a_data_size;
#endif
}
@@ -2037,10 +2003,12 @@ size_t dap_events_socket_write_unsafe(dap_events_socket_t *a_es, const void *a_d
return dap_events_socket_queue_data_send(a_es, a_data, a_data_size);
#endif
static const size_t l_basic_buf_size = DAP_EVENTS_SOCKET_BUF_LIMIT / 4;
-
+ byte_t *l_buf_out;
if (a_es->buf_out_size_max < a_es->buf_out_size + a_data_size) {
a_es->buf_out_size_max += dap_max(l_basic_buf_size, a_data_size);
- a_es->buf_out = DAP_REALLOC(a_es->buf_out, a_es->buf_out_size_max);
+ if (!( l_buf_out = DAP_REALLOC(a_es->buf_out, a_es->buf_out_size_max) ))
+ return log_it(L_ERROR, "Can't increase capacity: OOM!"), 0;
+ a_es->buf_out = l_buf_out;
debug_if(g_debug_reactor, L_MSG, "[!] Socket %"DAP_FORMAT_SOCKET": increase capacity to %zu, actual size: %zu", a_es->fd, a_es->buf_out_size_max, a_es->buf_out_size);
} else if ((a_es->buf_out_size + a_data_size <= l_basic_buf_size / 4) && (a_es->buf_out_size_max > l_basic_buf_size)) {
a_es->buf_out_size_max = l_basic_buf_size;
diff --git a/io/dap_server.c b/io/dap_server.c
index 5e6dcff9f550fce8dfe58e78248c59de1a72ef7e..abf37f29c12411dca3dc217018be3d3e967f24b9 100644
--- a/io/dap_server.c
+++ b/io/dap_server.c
@@ -245,8 +245,7 @@ int dap_server_callbacks_set(dap_server_t* a_server, dap_events_socket_callbacks
*/
dap_server_t *dap_server_new(const char *a_cfg_section, dap_events_socket_callbacks_t *a_server_callbacks, dap_events_socket_callbacks_t *a_client_callbacks)
{
- dap_server_t *l_server = NULL;
- DAP_NEW_Z_RET_VAL(l_server, dap_server_t, NULL, NULL);
+ dap_server_t *l_server = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_server_t, NULL);
dap_events_socket_callbacks_t l_callbacks = {
.accept_callback = s_es_server_accept,
.new_callback = s_es_server_new,
@@ -270,7 +269,7 @@ dap_server_t *dap_server_new(const char *a_cfg_section, dap_events_socket_callba
log_it(L_ERROR, "chmod() on socket path failed, errno %d: \"%s\"",
errno, dap_strerror(errno));
}
- dap_config_get_item_str_path_array_free(l_paths, &l_count);
+ dap_config_get_item_str_path_array_free(l_paths, l_count);
#endif
const char **l_addrs = dap_config_get_array_str(g_config, a_cfg_section, DAP_CFG_PARAM_LISTEN_ADDRS, &l_count);
for (i = 0; i < l_count; ++i) {
diff --git a/io/dap_worker.c b/io/dap_worker.c
index 5abfa68a9fc088b33b1e4fdfc4180779284d4b03..2024282788669f16a13cdb4f23faaac23f3fd6c6 100644
--- a/io/dap_worker.c
+++ b/io/dap_worker.c
@@ -104,7 +104,9 @@ int dap_worker_context_callback_started(dap_context_t * a_context, void *a_arg)
dap_worker_t *l_worker = (dap_worker_t*) a_arg;
assert(l_worker);
if (s_worker)
- return log_it(L_ERROR, "Worker %d is already assigned to current thread %u", s_worker->id), -1;
+ return log_it(L_ERROR, "Worker %d is already assigned to current thread %ld",
+ s_worker->id, s_worker->context->thread_id),
+ -1;
s_worker = l_worker;
#if defined(DAP_EVENTS_CAPS_KQUEUE)
a_context->kqueue_fd = kqueue();
@@ -283,8 +285,6 @@ static void s_queue_es_reassign_callback( dap_events_socket_t * a_es, void * a_a
assert(a_es);
dap_context_t * l_context = a_es->context;
assert(l_context);
- dap_worker_t * l_worker = a_es->worker;
- assert(l_worker);
dap_worker_msg_reassign_t * l_msg = (dap_worker_msg_reassign_t*) a_arg;
assert(l_msg);
dap_events_socket_t * l_es_reassign;
diff --git a/io/include/dap_events.h b/io/include/dap_events.h
index 6daa2b0dafb4c77536f868f067d812882c2361f4..19d5b1d4f5f1b9d8a91390729b6d92d867d62999 100644
--- a/io/include/dap_events.h
+++ b/io/include/dap_events.h
@@ -23,8 +23,6 @@
*/
#pragma once
#include <pthread.h>
-#include "uthash.h"
-#include "dap_server.h"
#include "dap_worker.h"
#define DAP_MAX_EVENTS_COUNT 8192
diff --git a/io/include/dap_events_socket.h b/io/include/dap_events_socket.h
index e67cc20e6e95cc68181282595038901bed787eed..4d174e21dfb9e6c1f8e8fe0e0023c223c5cbd5a1 100644
--- a/io/include/dap_events_socket.h
+++ b/io/include/dap_events_socket.h
@@ -30,7 +30,6 @@ typedef int SOCKET;
#else
#include <ws2tcpip.h>
#include <mq.h>
-#define INVALID_SOCKET (SOCKET)(~0)
#endif
#include <pthread.h>
@@ -417,7 +416,7 @@ size_t dap_events_socket_write(dap_events_socket_uuid_t a_es_uuid, const void *
dap_events_socket_callback_error_t a_callback_error, void * a_arg);
-size_t dap_events_socket_write_mt(dap_worker_t * a_w, dap_events_socket_uuid_t a_es_uuid, const void * a_data, size_t a_data_size);
+size_t dap_events_socket_write_mt(dap_worker_t * a_w, dap_events_socket_uuid_t a_es_uuid, void * a_data, size_t a_data_size);
DAP_PRINTF_ATTR(3, 4) size_t dap_events_socket_write_f_mt(dap_worker_t * a_w, dap_events_socket_uuid_t a_es_uuid, const char * a_format,...);
void dap_events_socket_delete_unsafe( dap_events_socket_t * a_esocket , bool a_preserve_inheritor);
void dap_events_socket_remove_and_delete_unsafe( dap_events_socket_t *a_es, bool preserve_inheritor );
diff --git a/net/app-cli/dap_app_cli.c b/net/app-cli/dap_app_cli.c
index c7619ed096f8b3244231dbb0e6d565dbcd1d8f33..ad4bd8b674ee5fc585e3a27465ca3fe017faf8e8 100644
--- a/net/app-cli/dap_app_cli.c
+++ b/net/app-cli/dap_app_cli.c
@@ -225,18 +225,14 @@ JNIEXPORT jstring JNICALL Java_com_CellframeWallet_Node_cellframeNodeCliMain(JNI
#endif
int dap_app_cli_main(const char *a_app_name, int a_argc, const char **a_argv)
{
- char l_config_dir[MAX_PATH] = {'\0'};
- sprintf(l_config_dir, "%s/etc", g_sys_dir_path);
- dap_config_init(l_config_dir);
- if ( !(g_config = dap_config_open(a_app_name)) ) {
- printf("Can't init general configurations %s/%s.cfg\n", l_config_dir, a_app_name);
- return -3;
+ {
+ char l_config_dir[MAX_PATH + 1];
+ snprintf(l_config_dir, MAX_PATH, "%s/etc", g_sys_dir_path);
+ if ( dap_config_init(l_config_dir) || !(g_config = dap_config_open(a_app_name)) )
+ return printf("Can't init general config \"%s/%s.cfg\"\n", l_config_dir, a_app_name), -3;
}
-
-
int l_res = -1;
-
- if (a_argc > 1){
+ if (a_argc > 1) {
// Call the function
dap_app_cli_cmd_state_t cmd = {
.cmd_name = (char *)a_argv[1],
diff --git a/net/app-cli/dap_app_cli_net.c b/net/app-cli/dap_app_cli_net.c
index e92d46c0e5aa105474d6d00dec46d7d32183bae1..0be52cb644af934e53c0fde718b1b10ddae0c5cd 100644
--- a/net/app-cli/dap_app_cli_net.c
+++ b/net/app-cli/dap_app_cli_net.c
@@ -89,8 +89,12 @@ static int dap_app_cli_http_read(dap_app_cli_connect_param_t socket, dap_app_cli
break;
l_hdr_end_token += ( sizeof(l_head_end_str) - 1 );
l_cmd->hdr_len = l_hdr_end_token - l_cmd->cmd_res;
- if (l_cmd->cmd_res_len + l_cmd->hdr_len > l_cmd->cmd_res_cur)
- l_cmd->cmd_res = DAP_REALLOC(l_cmd->cmd_res, l_cmd->cmd_res_len + l_cmd->hdr_len + 1);
+ if (l_cmd->cmd_res_len + l_cmd->hdr_len > l_cmd->cmd_res_cur) {
+ char *l_res = DAP_REALLOC(l_cmd->cmd_res, l_cmd->cmd_res_len + l_cmd->hdr_len + 1);
+ if (!l_res)
+ return printf("Error: out of memory!"), DAP_CLI_ERROR_INCOMPLETE;
+ l_cmd->cmd_res = l_res;
+ }
++a_status;
}
case 3:
@@ -116,40 +120,32 @@ dap_app_cli_connect_param_t dap_app_cli_connect()
int l_arg_len = 0;
uint16_t l_array_count;
struct sockaddr_storage l_saddr = { };
- char **l_addrs = dap_config_get_item_str_path_array(g_config, "cli-server", DAP_CFG_PARAM_SOCK_PATH, &l_array_count);
- char *l_addr = l_addrs ? l_addrs[0] : NULL;
- if (l_addr) {
- l_addrs[0] = NULL;
- dap_config_get_item_str_path_array_free(l_addrs, &l_array_count);
+ char *l_addr = NULL;
+ if (( l_addr = dap_config_get_item_str_path_default(g_config, "cli-server", DAP_CFG_PARAM_SOCK_PATH, NULL) )) {
#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);
- return ~0;
- }
+ if ( -1 == (l_socket = socket(AF_UNIX, SOCK_STREAM, 0)) )
+ return printf ("socket() error %d: \"%s\"\r\n", errno, dap_strerror(errno)), ~0;
struct sockaddr_un l_saddr_un = { .sun_family = AF_UNIX };
strncpy(l_saddr_un.sun_path, l_addr, sizeof(l_saddr_un.sun_path) - 1);
l_arg_len = SUN_LEN(&l_saddr_un);
memcpy(&l_saddr, &l_saddr_un, l_arg_len);
- DAP_DEL_Z(l_addr);
+ DAP_DELETE(l_addr);
#endif
- } else if ( !!(l_addr = (char *)dap_config_get_item_str(g_config, "cli-server", DAP_CFG_PARAM_LISTEN_ADDRS)) ) {
+ } else if (( l_addr = (char*)dap_config_get_item_str(g_config, "cli-server", DAP_CFG_PARAM_LISTEN_ADDRS) )) {
if ( -1 == (l_socket = socket(AF_INET, SOCK_STREAM, 0)) ) {
#ifdef DAP_OS_WINDOWS
_set_errno( WSAGetLastError() );
#endif
- printf ("socket() error %d", errno);
- return ~0;
+ return printf ("socket() error %d: \"%s\"\r\n", errno, dap_strerror(errno)), ~0;
}
char l_ip[INET6_ADDRSTRLEN] = { '\0' }; uint16_t l_port = 0;
if ( 0 > (l_arg_len = dap_net_parse_config_address(l_addr, l_ip, &l_port, &l_saddr, NULL)) ) {
printf ("Incorrect address \"%s\" format\n", l_addr);
return ~0;
}
- } else {
- printf("CLI server is not set, check config");
- return ~0;
- }
+ } else
+ return printf("CLI server is not set, check config"), ~0;
if ( connect(l_socket, (struct sockaddr*)&l_saddr, l_arg_len) == SOCKET_ERROR ) {
#ifdef DAP_OS_WINDOWS
diff --git a/net/client/dap_client.c b/net/client/dap_client.c
index 471f4ed624f7f775835d62218b1343bb02fd0fb3..1a8d27fe13515b7ed692c82a0e71e4c7c8b19ce9 100644
--- a/net/client/dap_client.c
+++ b/net/client/dap_client.c
@@ -73,11 +73,8 @@ void dap_client_deinit()
*/
dap_client_t *dap_client_new(dap_client_callback_t a_stage_status_error_callback, void *a_callbacks_arg)
{
-// memory alloc
- dap_client_t *l_client = NULL;
- DAP_NEW_Z_RET_VAL(l_client, dap_client_t, NULL, NULL);
- DAP_NEW_Z_RET_VAL(l_client->_internal, dap_client_pvt_t, NULL, l_client);
-// func work
+ dap_client_t *l_client = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_client_t, NULL);
+ l_client->_internal = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_client_pvt_t, NULL, l_client);
l_client->stage_status_error_callback = a_stage_status_error_callback;
l_client->callbacks_arg = a_callbacks_arg;
// CONSTRUCT dap_client object
diff --git a/net/client/dap_client_http.c b/net/client/dap_client_http.c
index 66aca4e1d577fd729edf0e38de22d6018652cc41..cdbbc9b24619f8e9d0516fbabd59ca425b7e35bd 100644
--- a/net/client/dap_client_http.c
+++ b/net/client/dap_client_http.c
@@ -235,7 +235,8 @@ static void s_http_connected(dap_events_socket_t * a_esocket)
ssize_t l_out_buf_size = l_header_size;
if (l_client_http->request && l_client_http->request_size){
l_out_buf_size += l_client_http->request_size + 1;
- l_out_buf = DAP_REALLOC(l_out_buf, l_out_buf_size);
+ char *l_out_new = DAP_REALLOC_RET_IF_FAIL(l_out_buf, l_out_buf_size, l_out_buf);
+ l_out_buf = l_out_new;
memcpy(l_out_buf + l_header_size, l_client_http->request, l_client_http->request_size);
}
@@ -385,25 +386,22 @@ static void s_http_read(dap_events_socket_t * a_es, void * arg)
l_client_http->is_header_read = false;
// received not enough data
- if(l_client_http->content_length
- > (l_client_http->response_size - l_client_http->header_length)) {
+ if ( l_client_http->content_length > l_client_http->response_size - l_client_http->header_length )
return;
- }else{
- // process data
- if(l_client_http->response_callback)
- l_client_http->response_callback(
- l_client_http->response + l_client_http->header_length,
- l_client_http->content_length,
- l_client_http->callbacks_arg, s_extract_http_code(
- l_client_http->response, l_client_http->response_size));
- l_client_http->response_size -= l_client_http->header_length;
- l_client_http->response_size -= l_client_http->content_length;
- l_client_http->header_length = 0;
- l_client_http->content_length = 0;
- l_client_http->were_callbacks_called = true;
- a_es->flags |= DAP_SOCK_SIGNAL_CLOSE;
- }
-
+ // process data
+ l_client_http->response[dap_min(l_client_http->response_size, l_client_http->response_size_max - 1)] = '\0';
+ if(l_client_http->response_callback)
+ l_client_http->response_callback(
+ l_client_http->response + l_client_http->header_length,
+ l_client_http->content_length,
+ l_client_http->callbacks_arg, s_extract_http_code(
+ l_client_http->response, l_client_http->response_size));
+ l_client_http->response_size -= l_client_http->header_length;
+ l_client_http->response_size -= l_client_http->content_length;
+ l_client_http->header_length = 0;
+ l_client_http->content_length = 0;
+ l_client_http->were_callbacks_called = true;
+ a_es->flags |= DAP_SOCK_SIGNAL_CLOSE;
}
}
@@ -755,16 +753,12 @@ dap_client_http_t * dap_client_http_request_custom (
}
dap_worker_add_events_socket(l_client_http->worker, l_ev_socket);
return l_client_http;
- }
- else{
- char l_errbuf[128];
- l_errbuf[0] = '\0';
- strerror_r(errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_ERROR, "Connecting error: \"%s\" (code %d)", l_errbuf, errno);
+ } else {
+ log_it(L_ERROR, "Connecting error %d: \"%s\"", errno, dap_strerror(errno));
s_client_http_delete( l_client_http);
l_ev_socket->_inheritor = NULL;
dap_events_socket_delete_unsafe( l_ev_socket, true);
- if(a_error_callback)
+ if (a_error_callback)
a_error_callback(errno, a_callbacks_arg);
return NULL;
}
diff --git a/net/client/dap_client_pvt.c b/net/client/dap_client_pvt.c
index eb7aea285c6596fa5e7380787972f29172875a18..4a830e06be7239668f2ec967bd591f1d8163879e 100644
--- a/net/client/dap_client_pvt.c
+++ b/net/client/dap_client_pvt.c
@@ -302,7 +302,7 @@ static bool s_stream_timer_timeout_after_connected_check(void * a_arg)
void dap_client_pvt_queue_add(dap_client_pvt_t *a_client_pvt, const char a_ch_id, uint8_t a_type, void *a_data, size_t a_data_size)
{
- dap_client_pkt_queue_elm_t *l_pkt = DAP_NEW_SIZE(dap_client_pkt_queue_elm_t, sizeof(dap_client_pkt_queue_elm_t) + a_data_size);
+ dap_client_pkt_queue_elm_t *l_pkt = DAP_NEW_Z_SIZE(dap_client_pkt_queue_elm_t, sizeof(dap_client_pkt_queue_elm_t) + a_data_size);
l_pkt->ch_id = a_ch_id;
l_pkt->type = a_type;
l_pkt->data_size = a_data_size;
@@ -340,18 +340,13 @@ int s_add_cert_sign_to_data(const dap_cert_t *a_cert, uint8_t **a_data, size_t *
dap_return_val_if_pass(!a_cert || !a_size || !a_data, 0);
dap_sign_t *l_sign = dap_sign_create(a_cert->enc_key, a_signing_data, a_signing_size, 0);
- dap_return_val_if_pass(!l_sign, 0);
-
- size_t l_sign_size = dap_sign_get_size(l_sign);
- *a_data = DAP_REALLOC(*a_data, (*a_size + l_sign_size) * sizeof(uint8_t));
- if (!*a_data) {
- DAP_DELETE(l_sign);
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return 0;
- }
- memcpy(*a_data + *a_size, l_sign, l_sign_size);
- *a_size += l_sign_size;
+ dap_return_val_if_fail(l_sign, 0);
+ size_t l_sign_size = dap_sign_get_size(l_sign), l_size = *a_size;
+ byte_t *l_data = DAP_REALLOC_RET_VAL_IF_FAIL(*a_data, l_size + l_sign_size, 0, l_sign);
+ memcpy(l_data + l_size, l_sign, l_sign_size);
DAP_DELETE(l_sign);
+ *a_data = l_data;
+ *a_size = l_size + l_sign_size;
return 1;
}
@@ -401,9 +396,11 @@ static void s_stage_status_after(dap_client_pvt_t *a_client_pvt)
break;
}
size_t l_data_size = a_client_pvt->session_key_open->pub_key_data_size;
- uint8_t *l_data = DAP_NEW_Z_SIZE(uint8_t, l_data_size);
- memcpy(l_data, a_client_pvt->session_key_open->pub_key_data, a_client_pvt->session_key_open->pub_key_data_size);
-
+ uint8_t *l_data = DAP_DUP_SIZE(a_client_pvt->session_key_open->pub_key_data, l_data_size);
+ if (!l_data) {
+ a_client_pvt->stage_status = STAGE_STATUS_ERROR;
+ break;
+ }
dap_cert_t *l_node_cert = dap_cert_find_by_name(DAP_STREAM_NODE_ADDR_CERT_NAME);
size_t l_sign_count = 0;
if (a_client_pvt->client->auth_cert)
@@ -589,15 +586,9 @@ static void s_stage_status_after(dap_client_pvt_t *a_client_pvt)
s_stream_timer_timeout_check,l_stream_es_uuid_ptr);
}
else if (l_err != EINPROGRESS && l_err != -1){
- char l_errbuf[128] = {0};
-
- if (l_err)
- strerror_r(l_err,l_errbuf,sizeof (l_errbuf));
- else
- strncpy(l_errbuf,"Unknown Error",sizeof(l_errbuf)-1);
log_it(L_ERROR, "Remote address can't connect (%s:%hu) with sock_id %"DAP_FORMAT_SOCKET": \"%s\" (code %d)",
- a_client_pvt->client->link_info.uplink_addr, a_client_pvt->client->link_info.uplink_port,
- l_es->socket, l_errbuf, l_err);
+ a_client_pvt->client->link_info.uplink_addr, a_client_pvt->client->link_info.uplink_port,
+ l_es->socket, dap_strerror(l_err), l_err);
dap_events_socket_delete_unsafe(l_es, true);
a_client_pvt->stage_status = STAGE_STATUS_ERROR;
a_client_pvt->last_error = ERROR_STREAM_CONNECT;
@@ -636,7 +627,7 @@ static void s_stage_status_after(dap_client_pvt_t *a_client_pvt)
dap_stream_ch_new(a_client_pvt->stream, (uint8_t)a_client_pvt->client->active_channels[i]);
char l_full_path[2048];
- snprintf(l_full_path, sizeof(l_full_path) - 1, "%s/globaldb?session_id=%u", DAP_UPLINK_PATH_STREAM,
+ snprintf(l_full_path, sizeof(l_full_path), "%s/globaldb?session_id=%u", DAP_UPLINK_PATH_STREAM,
dap_client_get_stream_id(a_client_pvt->client));
dap_events_socket_write_f_unsafe( a_client_pvt->stream_es, "GET /%s HTTP/1.1\r\n"
@@ -801,99 +792,55 @@ int dap_client_pvt_request(dap_client_pvt_t * a_client_internal, const char * a_
* @param a_response_proc
* @param a_response_error
*/
-void dap_client_pvt_request_enc(dap_client_pvt_t * a_client_internal, const char * a_path,
- const char * a_sub_url, const char * a_query
- , void * a_request, size_t a_request_size
- , dap_client_callback_data_size_t a_response_proc
- , dap_client_callback_int_t a_response_error)
+void dap_client_pvt_request_enc(dap_client_pvt_t * a_client_internal, const char *a_path,
+ const char *a_sub_url, const char * a_query, void *a_request, size_t a_request_size,
+ dap_client_callback_data_size_t a_response_proc, dap_client_callback_int_t a_response_error)
{
bool is_query_enc = true; // if true, then encode a_query string [Why do we even need this?]
-
- debug_if(s_debug_more, L_DEBUG, "Encrypted request: sub_url '%s' query '%s'", a_sub_url ? a_sub_url : "NULL",
- a_query ? a_query : "NULL");
-
- size_t l_sub_url_size = a_sub_url ? strlen(a_sub_url) : 0;
- size_t l_query_size = a_query ? strlen(a_query) : 0;
-// size_t l_url_size;
-// char l_url[1024] = { 0 };
-// snprintf(l_url, 1024, "http://%s:%u", a_client_internal->uplink_addr, a_client_internal->uplink_port);
-// l_url_size = strlen(l_url);
-
- size_t l_sub_url_enc_size_max = l_sub_url_size ? (5 * l_sub_url_size + 16) : 0;
- char *l_sub_url_enc = l_sub_url_size ? DAP_NEW_Z_SIZE(char, l_sub_url_enc_size_max + 1) : NULL;
-
- size_t l_query_enc_size_max = (is_query_enc) ? (l_query_size * 5 + 16) : l_query_size;
- char *l_query_enc =
- (is_query_enc) ? (l_query_size ? DAP_NEW_Z_SIZE(char, l_query_enc_size_max + 1) : NULL) : (char*) a_query;
-
-// size_t l_url_full_size_max = 5 * l_sub_url_size + 5 * l_query_size + 16 + l_url_size + 2;
-// char * l_url_full = DAP_NEW_Z_SIZE(char, l_url_full_size_max + 1);
-
- size_t l_request_enc_size_max = a_request_size ? a_request_size * 2 + 16 : 0;
- char * l_request_enc = a_request_size ? DAP_NEW_Z_SIZE(char, l_request_enc_size_max + 1) : NULL;
- size_t l_request_enc_size = 0;
-
- a_client_internal->request_response_callback = a_response_proc;
- a_client_internal->request_error_callback = a_response_error;
- a_client_internal->is_encrypted = true;
- dap_enc_data_type_t l_enc_type;
-
- if(a_client_internal->uplink_protocol_version >= 21)
- l_enc_type = DAP_ENC_DATA_TYPE_B64_URLSAFE;
- else
- l_enc_type = DAP_ENC_DATA_TYPE_B64;
-
- if(l_sub_url_size)
- dap_enc_code(a_client_internal->session_key,
- a_sub_url, l_sub_url_size,
- l_sub_url_enc, l_sub_url_enc_size_max,
- l_enc_type);
-
- if(is_query_enc && l_query_size)
- dap_enc_code(a_client_internal->session_key,
- a_query, l_query_size,
- l_query_enc, l_query_enc_size_max,
- l_enc_type);
-
- if(a_request_size)
- l_request_enc_size = dap_enc_code(a_client_internal->session_key,
- a_request, a_request_size,
- l_request_enc, l_request_enc_size_max,
- DAP_ENC_DATA_TYPE_RAW);
-
- size_t l_path_size= l_query_enc_size_max + l_sub_url_enc_size_max + 1;
- char *l_path = DAP_NEW_Z_SIZE(char, l_path_size);
- l_path[0] = '\0';
- if(a_path) {
- if(l_sub_url_size){
- if(l_query_size){
- snprintf(l_path, l_path_size, "%s/%s?%s", a_path?a_path:"",
- l_sub_url_enc?l_sub_url_enc:"",
- l_query_enc?l_query_enc:"");
- }else{
- snprintf(l_path, l_path_size, "%s/%s", a_path, l_sub_url_enc);
+ debug_if (s_debug_more, L_DEBUG, "Encrypt request: sub_url '%s' query '%s'",
+ a_sub_url ? a_sub_url : "", a_query ? a_query : "");
+ dap_enc_data_type_t l_enc_type = a_client_internal->uplink_protocol_version >= 21
+ ? DAP_ENC_DATA_TYPE_B64_URLSAFE : DAP_ENC_DATA_TYPE_B64;
+ char *l_path = NULL, *l_request_enc = NULL;
+ if (a_path && *a_path) {
+ size_t l_suburl_len = a_sub_url && *a_sub_url ? dap_strlen(a_sub_url) : 0,
+ l_suburl_enc_size = dap_enc_code_out_size(a_client_internal->session_key, l_suburl_len, l_enc_type),
+ l_query_len = a_query && *a_query ? dap_strlen(a_query) : 0,
+ l_query_enc_size = dap_enc_code_out_size(a_client_internal->session_key, l_query_len, l_enc_type),
+ l_path_size = dap_strlen(a_path) + l_suburl_enc_size + l_query_enc_size + 3;
+ l_path = DAP_NEW_Z_SIZE(char, l_path_size);
+ char *l_offset = dap_strncpy(l_path, a_path, l_path_size);
+ *l_offset++ = '/';
+ if (l_suburl_enc_size) {
+ l_offset += dap_enc_code(a_client_internal->session_key, a_sub_url, l_suburl_len,
+ l_offset, l_suburl_enc_size, l_enc_type);
+ if (l_query_enc_size) {
+ *l_offset++ = '?';
+ dap_enc_code(a_client_internal->session_key, a_query, l_query_len,
+ l_offset, l_query_enc_size, l_enc_type);
}
- } else {
- dap_stpcpy(l_path, a_path);
}
}
-
- size_t l_size_required = a_client_internal->session_key_id ? strlen(a_client_internal->session_key_id) + 40 : 40;
- char *l_custom = DAP_NEW_Z_SIZE(char, l_size_required);
- size_t l_off = snprintf(l_custom, l_size_required, "KeyID: %s\r\n", a_client_internal->session_key_id ? a_client_internal->session_key_id : "NULL");
- if (a_client_internal->is_close_session)
- snprintf(l_custom + l_off, l_size_required - l_off, "%s\r\n", "SessionCloseAfterRequest: true");
-
- a_client_internal->http_client = dap_client_http_request(a_client_internal->worker, a_client_internal->client->link_info.uplink_addr,
- a_client_internal->client->link_info.uplink_port,
- a_request ? "POST" : "GET", "text/text",
- l_path, l_request_enc, l_request_enc_size, NULL,
- s_request_response, s_request_error, a_client_internal, l_custom);
- DAP_DEL_Z(l_sub_url_enc);
- DAP_DEL_Z(l_custom);
- DAP_DEL_Z(l_query_enc);
- DAP_DEL_Z(l_path);
- DAP_DEL_Z(l_request_enc);
+ size_t l_req_enc_size = 0;
+ if (a_request && a_request_size) {
+ l_req_enc_size = dap_enc_code_out_size(a_client_internal->session_key, a_request_size, l_enc_type) + 1;
+ l_request_enc = DAP_NEW_Z_SIZE(char, l_req_enc_size);
+ dap_enc_code(a_client_internal->session_key, a_request, a_request_size,
+ l_request_enc, l_req_enc_size, DAP_ENC_DATA_TYPE_RAW);
+ }
+ char *l_custom = dap_strdup_printf("KeyID: %s\r\n%s",
+ a_client_internal->session_key_id ? a_client_internal->session_key_id : "NULL",
+ a_client_internal->is_close_session ? "SessionCloseAfterRequest: true\r\n" : "");
+
+ a_client_internal->request_response_callback = a_response_proc;
+ a_client_internal->request_error_callback = a_response_error;
+ a_client_internal->is_encrypted = true;
+ a_client_internal->http_client = dap_client_http_request(a_client_internal->worker,
+ a_client_internal->client->link_info.uplink_addr, a_client_internal->client->link_info.uplink_port,
+ a_request ? "POST" : "GET", "text/text", l_path, l_request_enc, l_req_enc_size, NULL,
+ s_request_response, s_request_error, a_client_internal, l_custom);
+
+ DAP_DEL_MULTY(l_path, l_request_enc, l_custom);
}
/**
@@ -920,34 +867,27 @@ static void s_request_error(int a_err_code, void * a_obj)
* @param a_response_size
* @param a_obj
*/
-static void s_request_response(void * a_response, size_t a_response_size, void * a_obj, http_status_code_t a_http_code)
+static void s_request_response(void * a_response, size_t a_response_size, void * a_obj, UNUSED_ARG http_status_code_t a_http_code)
{
- (void)a_http_code;
dap_client_pvt_t * l_client_pvt = (dap_client_pvt_t *) a_obj;
assert(l_client_pvt);
+ if ( !l_client_pvt->request_response_callback )
+ return log_it(L_ERROR, "No request_response_callback in encrypted client!");
l_client_pvt->http_client = NULL;
- if (l_client_pvt->is_encrypted && l_client_pvt->session_key) {
- size_t l_response_dec_size_max = a_response_size ? a_response_size * 2 + 16 : 0;
- char * l_response_dec = a_response_size ? DAP_NEW_Z_SIZE(char, l_response_dec_size_max) : NULL;
- size_t l_response_dec_size = 0;
- if(a_response_size)
- l_response_dec_size = dap_enc_decode(l_client_pvt->session_key,
- a_response, a_response_size,
- l_response_dec, l_response_dec_size_max,
- DAP_ENC_DATA_TYPE_RAW);
-
- if ( l_client_pvt->request_response_callback )
- l_client_pvt->request_response_callback(l_client_pvt->client, l_response_dec, l_response_dec_size);
- else
- log_it(L_ERROR, "NULL request_response_callback for encrypted client %p", l_client_pvt->client );
-
- if(l_response_dec)
- DAP_DELETE(l_response_dec);
- } else {
- if ( l_client_pvt->request_response_callback )
+
+ if (a_response && a_response_size) {
+ if (l_client_pvt->is_encrypted) {
+ if (!l_client_pvt->session_key)
+ return log_it(L_ERROR, "No session key in encrypted client!");
+ size_t l_len = dap_enc_decode_out_size(l_client_pvt->session_key, a_response_size, DAP_ENC_DATA_TYPE_RAW);
+ char *l_response = DAP_NEW_Z_SIZE(char, l_len + 1);
+ l_len = dap_enc_decode(l_client_pvt->session_key, a_response, a_response_size,
+ l_response, l_len, DAP_ENC_DATA_TYPE_RAW);
+ l_response[l_len] = '\0';
+ l_client_pvt->request_response_callback(l_client_pvt->client, l_response, l_len);
+ DAP_DELETE(l_response);
+ } else
l_client_pvt->request_response_callback(l_client_pvt->client, a_response, a_response_size);
- else
- log_it(L_ERROR, "NULL request_response_callback for unencrypted client %p", l_client_pvt->client );
}
}
@@ -983,16 +923,14 @@ int s_json_multy_obj_parse_str(const char *a_key, const char *a_val, int a_count
* @param a_response
* @param a_response_size
*/
-static void s_enc_init_response(dap_client_t *a_client, void * a_data, size_t a_data_size)
+static void s_enc_init_response(dap_client_t *a_client, void *a_data, size_t a_data_size)
{
// sanity check
dap_client_pvt_t * l_client_pvt = DAP_CLIENT_PVT(a_client);
dap_return_if_pass(!l_client_pvt || !a_data);
// func work
- char *l_session_id_b64 = NULL;
- char *l_bob_message_b64 = NULL;
- char *l_node_sign_b64 = NULL;
- char *l_bob_message = NULL;
+ char *l_data = (char*)a_data, *l_session_id_b64 = NULL,
+ *l_bob_message_b64 = NULL, *l_node_sign_b64 = NULL, *l_bob_message = NULL;
l_client_pvt->last_error = ERROR_NO_ERROR;
while(l_client_pvt->last_error == ERROR_NO_ERROR) {
// first checks
@@ -1002,14 +940,14 @@ static void s_enc_init_response(dap_client_t *a_client, void * a_data, size_t a_
break;
}
if (a_data_size <= 10) {
- log_it(L_ERROR, "ENC: Wrong response (size %zu data '%s')", a_data_size, (char* )a_data);
+ log_it(L_ERROR, "ENC: Wrong response (size %zu data '%s')", a_data_size, l_data);
l_client_pvt->last_error = ERROR_ENC_NO_KEY;
break;
}
size_t l_bob_message_size = 0;
int l_json_parse_count = 0;
// parse data
- struct json_object *jobj = json_tokener_parse((const char *) a_data);
+ struct json_object *jobj = json_tokener_parse(l_data);
if(jobj) {
// parse encrypt_id & encrypt_msg
json_object_object_foreach(jobj, key, val)
@@ -1037,7 +975,7 @@ static void s_enc_init_response(dap_client_t *a_client, void * a_data, size_t a_
// check data
if (l_json_parse_count < 2 || l_json_parse_count > 4) {
l_client_pvt->last_error = ERROR_ENC_NO_KEY;
- log_it(L_ERROR, "ENC: Wrong response (size %zu data '%s')", a_data_size, (char* ) a_data);
+ log_it(L_ERROR, "ENC: Wrong response (size %zu data '%s')", a_data_size, l_data);
break;
}
if (!l_session_id_b64 || !l_bob_message_b64) {
@@ -1046,18 +984,14 @@ static void s_enc_init_response(dap_client_t *a_client, void * a_data, size_t a_
break;
}
// decode session key id
- DAP_NEW_Z_SIZE_RET(l_client_pvt->session_key_id, char, strlen(l_session_id_b64) + 1, l_session_id_b64, l_bob_message_b64, l_node_sign_b64);
- if (!dap_enc_base64_decode(l_session_id_b64, strlen(l_session_id_b64),
- l_client_pvt->session_key_id, DAP_ENC_DATA_TYPE_B64)) {
- log_it(L_WARNING, "ENC: Can't decode session id from base64");
- l_client_pvt->last_error = ERROR_ENC_WRONG_KEY;
- } else {
- log_it(L_DEBUG, "ENC: session Key ID %s", l_client_pvt->session_key_id);
- }
+ size_t l_len = strlen(l_session_id_b64), l_decoded_len;
+ l_client_pvt->session_key_id = DAP_NEW_Z_SIZE_RET_IF_FAIL(char, DAP_ENC_BASE64_DECODE_SIZE(l_len) + 1, l_session_id_b64, l_bob_message_b64, l_node_sign_b64);
+ l_decoded_len = dap_enc_base64_decode(l_session_id_b64, l_len, l_client_pvt->session_key_id, DAP_ENC_DATA_TYPE_B64);
+ log_it(L_DEBUG, "ENC: session Key ID %s", l_client_pvt->session_key_id);
// decode bob message
- DAP_NEW_Z_SIZE_RET(l_bob_message, char, strlen(l_bob_message_b64) + 1, l_session_id_b64, l_bob_message_b64, l_node_sign_b64, l_client_pvt->session_key_id);
- l_bob_message_size = dap_enc_base64_decode(l_bob_message_b64, strlen(l_bob_message_b64),
- l_bob_message, DAP_ENC_DATA_TYPE_B64);
+ l_len = strlen(l_bob_message_b64);
+ l_bob_message = DAP_NEW_Z_SIZE_RET_IF_FAIL(char, DAP_ENC_BASE64_DECODE_SIZE(l_len) + 1, l_session_id_b64, l_bob_message_b64, l_node_sign_b64, l_client_pvt->session_key_id);
+ l_bob_message_size = dap_enc_base64_decode(l_bob_message_b64, l_len, l_bob_message, DAP_ENC_DATA_TYPE_B64);
if (!l_bob_message_size) {
log_it(L_WARNING, "ENC: Can't decode bob message from base64");
l_client_pvt->last_error = ERROR_ENC_WRONG_KEY;
@@ -1075,7 +1009,7 @@ static void s_enc_init_response(dap_client_t *a_client, void * a_data, size_t a_
l_client_pvt->session_key = dap_enc_key_new_generate(l_client_pvt->session_key_type,
l_client_pvt->session_key_open->priv_key_data, // shared key
l_client_pvt->session_key_open->priv_key_data_size,
- l_client_pvt->session_key_id, strlen(l_client_pvt->session_key_id), l_client_pvt->session_key_block_size);
+ l_client_pvt->session_key_id, l_decoded_len, l_client_pvt->session_key_block_size);
if (l_client_pvt->stage != STAGE_ENC_INIT) { // We are in wrong stage
l_client_pvt->last_error = ERROR_WRONG_STAGE;
@@ -1085,10 +1019,11 @@ static void s_enc_init_response(dap_client_t *a_client, void * a_data, size_t a_
}
// verify node sign
if (l_node_sign_b64) {
- dap_sign_t *l_sign = NULL;
- DAP_NEW_Z_SIZE_RET(l_sign, dap_sign_t, strlen(l_node_sign_b64) + 1, l_session_id_b64, l_bob_message_b64, l_node_sign_b64, l_bob_message, l_client_pvt->session_key_id);
- size_t l_decode_len = dap_enc_base64_decode(l_node_sign_b64, strlen(l_node_sign_b64), l_sign, DAP_ENC_DATA_TYPE_B64);
- if (!dap_sign_verify_all(l_sign, l_decode_len, l_bob_message, l_bob_message_size)) {
+ l_len = strlen(l_node_sign_b64);
+ dap_sign_t *l_sign = DAP_NEW_Z_SIZE_RET_IF_FAIL(dap_sign_t, DAP_ENC_BASE64_DECODE_SIZE(l_len) + 1,
+ l_session_id_b64, l_bob_message_b64, l_node_sign_b64, l_bob_message, l_client_pvt->session_key_id);
+ l_decoded_len = dap_enc_base64_decode(l_node_sign_b64, l_len, l_sign, DAP_ENC_DATA_TYPE_B64);
+ if ( !dap_sign_verify_all(l_sign, l_decoded_len, l_bob_message, l_bob_message_size) ) {
dap_stream_node_addr_t l_sign_node_addr = dap_stream_node_addr_from_sign(l_sign);
if (l_sign_node_addr.uint64 != a_client->link_info.node_addr.uint64) {
log_it(L_WARNING, "Unverified stream to node "NODE_ADDR_FP_STR" signed by "NODE_ADDR_FP_STR"\n", NODE_ADDR_FP_ARGS_S(a_client->link_info.node_addr), NODE_ADDR_FP_ARGS_S(l_sign_node_addr));
@@ -1146,58 +1081,48 @@ static void s_enc_init_error(dap_client_t * a_client, UNUSED_ARG void *a_arg, in
* @param a_data
* @param a_data_size
*/
-static void s_stream_ctl_response(dap_client_t * a_client, void * a_data, size_t a_data_size)
+static void s_stream_ctl_response(dap_client_t * a_client, void *a_data, size_t a_data_size)
{
dap_client_pvt_t *l_client_pvt = DAP_CLIENT_PVT(a_client);
if (!l_client_pvt) return;
if(s_debug_more)
log_it(L_DEBUG, "STREAM_CTL response %zu bytes length recieved", a_data_size);
- char * l_response_str = DAP_NEW_Z_SIZE(char, a_data_size + 1);
- if (!l_response_str) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
- memcpy(l_response_str, a_data, (uint32_t)a_data_size);
-
+ char *l_response_str = (char*)a_data; // The caller must ensure it's a null-terminated string
+
if(a_data_size < 4) {
log_it(L_ERROR, "STREAM_CTL Wrong reply: '%s'", l_response_str);
l_client_pvt->last_error = ERROR_STREAM_CTL_ERROR_RESPONSE_FORMAT;
l_client_pvt->stage_status = STAGE_STATUS_ERROR;
s_stage_status_after(l_client_pvt);
- } else if(strcmp(l_response_str, "ERROR") == 0) {
+ } else if ( !strncmp(l_response_str, "ERROR", a_data_size) ) {
log_it(L_WARNING, "STREAM_CTL Got ERROR from the remote site,expecting thats ERROR_AUTH");
l_client_pvt->last_error = ERROR_STREAM_CTL_ERROR_AUTH;
l_client_pvt->stage_status = STAGE_STATUS_ERROR;
s_stage_status_after(l_client_pvt);
} else {
int l_arg_count;
- char *l_stream_key = DAP_NEW_Z_SIZE(char, 4096 * 3);
- if (!l_stream_key) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(l_response_str);
- return;
- }
+ char l_stream_key[4096 + 1] = { '\0' };
uint32_t l_remote_protocol_version;
dap_enc_key_type_t l_enc_type = l_client_pvt->session_key_type;
int l_enc_headers = 0;
uint32_t l_stream_id_int = 0;
- l_arg_count = sscanf(l_response_str, "%u %4096s %u %d %d"
- , &l_stream_id_int, l_stream_key, &l_remote_protocol_version, &l_enc_type, &l_enc_headers);
+ l_arg_count = sscanf(l_response_str, "%u %4096s %u %d %d",
+ &l_stream_id_int, l_stream_key,
+ &l_remote_protocol_version,
+ &l_enc_type, &l_enc_headers);
if(l_arg_count < 2) {
log_it(L_WARNING, "STREAM_CTL Need at least 2 arguments in reply (got %d)", l_arg_count);
l_client_pvt->last_error = ERROR_STREAM_CTL_ERROR_RESPONSE_FORMAT;
l_client_pvt->stage_status = STAGE_STATUS_ERROR;
s_stage_status_after(l_client_pvt);
} else {
-
if(l_arg_count > 2) {
l_client_pvt->uplink_protocol_version = l_remote_protocol_version;
log_it(L_DEBUG, "Uplink protocol version %u", l_remote_protocol_version);
} else
- log_it(L_WARNING, "No uplink protocol version, use default version %d"
- , l_client_pvt->uplink_protocol_version = DAP_PROTOCOL_VERSION_DEFAULT);
-
+ log_it(L_WARNING, "No uplink protocol version, use default version %d",
+ l_client_pvt->uplink_protocol_version = DAP_PROTOCOL_VERSION_DEFAULT);
if(l_stream_id_int) {
//log_it(L_DEBUG, "Stream server id %s, stream key length(base64 encoded) %u"
// ,l_stream_id,strlen(l_stream_key) );
@@ -1209,8 +1134,7 @@ static void s_stream_ctl_response(dap_client_t * a_client, void * a_data, size_t
l_client_pvt->stream_id = l_stream_id_int;
l_client_pvt->stream_key =
- dap_enc_key_new_generate(l_enc_type, l_stream_key, strlen(l_stream_key), NULL, 0,
- 32);
+ dap_enc_key_new_generate(l_enc_type, l_stream_key, strlen(l_stream_key), NULL, 0, 32);
l_client_pvt->is_encrypted_headers = l_enc_headers;
@@ -1228,11 +1152,8 @@ static void s_stream_ctl_response(dap_client_t * a_client, void * a_data, size_t
l_client_pvt->stage_status = STAGE_STATUS_ERROR;
s_stage_status_after(l_client_pvt);
}
-
}
- DAP_DELETE(l_stream_key);
}
- DAP_DELETE(l_response_str);
}
/**
diff --git a/net/link_manager/dap_link_manager.c b/net/link_manager/dap_link_manager.c
index 12ee05a34405ac775b7c0227d3ffb0f1d55c5aaa..6b9c41bdb334e3eac85cd20fc3fa92447fe79198 100644
--- a/net/link_manager/dap_link_manager.c
+++ b/net/link_manager/dap_link_manager.c
@@ -255,12 +255,8 @@ void dap_link_manager_deinit()
*/
dap_link_manager_t *dap_link_manager_new(const dap_link_manager_callbacks_t *a_callbacks)
{
-// sanity check
dap_return_val_if_pass_err(!a_callbacks || !a_callbacks->fill_net_info, NULL, "Needed link manager callbacks not filled, please check it");
-// memory alloc
- dap_link_manager_t *l_ret = NULL;
- DAP_NEW_Z_RET_VAL(l_ret, dap_link_manager_t, NULL, NULL);
-// func work
+ dap_link_manager_t *l_ret = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_link_manager_t, NULL);
l_ret->callbacks = *a_callbacks;
if(!l_ret->callbacks.link_request)
log_it(L_WARNING, "Link manager link_request callback is NULL");
@@ -341,8 +337,7 @@ int dap_link_manager_add_net(uint64_t a_net_id, dap_cluster_t *a_link_cluster, u
return -3;
}
}
- dap_managed_net_t *l_net = NULL;
- DAP_NEW_Z_RET_VAL(l_net, dap_managed_net_t, -3, NULL);
+ dap_managed_net_t *l_net = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_managed_net_t, -3);
l_net->id = a_net_id;
l_net->min_links_num = a_min_links_number;
l_net->link_clusters = dap_list_append(l_net->link_clusters, a_link_cluster);
@@ -571,16 +566,11 @@ bool s_link_drop_callback(void *a_arg)
*/
void s_client_error_callback(dap_client_t *a_client, void *a_arg)
{
-// sanity check
dap_return_if_pass(!a_client || !DAP_LINK(a_client));
dap_link_t *l_link = DAP_LINK(a_client);
assert(l_link->uplink.client == a_client);
-// memory alloc
- struct link_drop_args *l_args = NULL;
- DAP_NEW_Z_RET(l_args, struct link_drop_args, NULL);
-// func work
+ struct link_drop_args *l_args = DAP_NEW_Z_RET_IF_FAIL(struct link_drop_args);
*l_args = (struct link_drop_args) { .addr = l_link->addr, .disconnected = a_arg };
-
dap_proc_thread_callback_add_pri(s_query_thread, s_link_drop_callback, l_args, DAP_QUEUE_MSG_PRIORITY_HIGH);
}
@@ -896,10 +886,7 @@ int dap_link_manager_link_update(dap_stream_node_addr_t *a_node_addr, const char
return -6;
}
-// memory alloc
- struct link_update_args *l_args = NULL;
- DAP_NEW_Z_RET_VAL(l_args, struct link_update_args, -7, NULL);
-// func work
+ struct link_update_args *l_args = DAP_NEW_Z_RET_VAL_IF_FAIL(struct link_update_args, -7);
l_args->host = dap_strdup(a_host);
if (!l_args->host) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
@@ -995,12 +982,8 @@ static bool s_stream_add_callback(void *a_arg)
*/
int dap_link_manager_stream_add(dap_stream_node_addr_t *a_node_addr, bool a_uplink)
{
-// sanity check
dap_return_val_if_pass(!a_node_addr || !s_link_manager->active, -1);
-// memory alloc
- struct link_moving_args *l_args = NULL;
- DAP_NEW_Z_RET_VAL(l_args, struct link_moving_args, -2, NULL);
-// func work
+ struct link_moving_args *l_args = DAP_NEW_Z_RET_VAL_IF_FAIL(struct link_moving_args, -2);
*l_args = (struct link_moving_args) { .addr = *a_node_addr, .uplink = a_uplink };
return dap_proc_thread_callback_add_pri(s_query_thread, s_stream_add_callback, l_args, DAP_QUEUE_MSG_PRIORITY_HIGH);
}
@@ -1036,13 +1019,9 @@ static bool s_stream_replace_callback(void *a_arg)
void dap_link_manager_stream_replace(dap_stream_node_addr_t *a_addr, bool a_new_is_uplink)
{
-// sanity check
dap_return_if_fail(a_addr);
-// memory alloc
- struct link_moving_args *l_args = NULL;
- DAP_NEW_Z_RET(l_args, struct link_moving_args, NULL);
+ struct link_moving_args *l_args = DAP_NEW_Z_RET_IF_FAIL(struct link_moving_args);
*l_args = (struct link_moving_args) { .addr = *a_addr, .uplink = a_new_is_uplink };
-// func work
dap_proc_thread_callback_add_pri(s_query_thread, s_stream_replace_callback, l_args, DAP_QUEUE_MSG_PRIORITY_HIGH);
}
@@ -1143,13 +1122,9 @@ static bool s_link_accounting_callback(void *a_arg)
*/
void dap_link_manager_accounting_link_in_net(uint64_t a_net_id, dap_stream_node_addr_t *a_node_addr, bool a_no_error)
{
-// sanity check
dap_managed_net_t *l_net = s_find_net_by_id(a_net_id);
dap_return_if_pass(!l_net);
-// memory alloc
- struct link_accounting_args *l_args = NULL;
- DAP_NEW_Z_RET(l_args, struct link_accounting_args, NULL);
-// func work
+ struct link_accounting_args *l_args = DAP_NEW_Z_RET_IF_FAIL(struct link_accounting_args);
*l_args = (struct link_accounting_args) { .addr = *a_node_addr, .net = l_net, .no_error = a_no_error };
dap_proc_thread_callback_add_pri(s_query_thread, s_link_accounting_callback, l_args, DAP_QUEUE_MSG_PRIORITY_NORMAL);
}
@@ -1253,13 +1228,12 @@ dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id,
return NULL;
}
// memory alloc
- dap_stream_node_addr_t *l_ret = NULL;
- DAP_NEW_Z_COUNT_RET_VAL(l_ret, dap_stream_node_addr_t, l_count, NULL, NULL);
+ dap_stream_node_addr_t *l_ret = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_stream_node_addr_t, l_count, NULL);
// func work
pthread_rwlock_rdlock(&s_link_manager->links_lock);
- size_t l_cur_count = 0;
+ size_t i, l_cur_count = 0;
dap_stream_node_addr_t *l_links_addrs = dap_cluster_get_all_members_addrs((dap_cluster_t *)l_net->link_clusters->data, &l_cur_count, -1);
- for (size_t i = 0; i < l_cur_count; ++i) {
+ for (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 && a_established_only && l_link->uplink.state != LINK_STATE_ESTABLISHED)) {
@@ -1275,10 +1249,8 @@ dap_stream_node_addr_t *dap_link_manager_get_net_links_addrs(uint64_t a_net_id,
}
DAP_DEL_Z(l_links_addrs);
pthread_rwlock_unlock(&s_link_manager->links_lock);
- if (!l_uplinks_count && !l_downlinks_count) {
- DAP_DELETE(l_ret);
- return NULL;
- }
+ if (!l_uplinks_count && !l_downlinks_count)
+ DAP_DEL_Z(l_ret);
if (a_uplinks_count)
*a_uplinks_count = l_uplinks_count;
if (a_downlinks_count)
diff --git a/net/server/enc_server/dap_enc_http.c b/net/server/enc_server/dap_enc_http.c
index b380707c90c96f90624ff8f91993f1d35ee1641d..c8d41cc257a3192ea9b0a6836d608991ddea2e47 100644
--- a/net/server/enc_server/dap_enc_http.c
+++ b/net/server/enc_server/dap_enc_http.c
@@ -71,14 +71,15 @@ void enc_http_deinit()
}
static void _enc_http_write_reply(struct dap_http_simple *a_cl_st,
- const char* a_encrypt_id,
- const char* a_encrypt_msg, const char *a_node_sign)
+ const char* a_encrypt_id, int a_id_len,
+ const char* a_encrypt_msg,int a_msg_len,
+ const char* a_node_sign, int a_sign_len)
{
struct json_object *l_jobj = json_object_new_object();
- json_object_object_add(l_jobj, "encrypt_id", json_object_new_string(a_encrypt_id));
- json_object_object_add(l_jobj, "encrypt_msg", json_object_new_string(a_encrypt_msg));
+ json_object_object_add(l_jobj, "encrypt_id", json_object_new_string_len(a_encrypt_id, a_id_len));
+ json_object_object_add(l_jobj, "encrypt_msg", json_object_new_string_len(a_encrypt_msg, a_msg_len));
if (a_node_sign)
- json_object_object_add(l_jobj, "node_sign", json_object_new_string(a_node_sign));
+ json_object_object_add(l_jobj, "node_sign", json_object_new_string_len(a_node_sign, a_sign_len));
json_object_object_add(l_jobj, "dap_protocol_version", json_object_new_int(DAP_PROTOCOL_VERSION));
const char* l_json_str = json_object_to_json_string(l_jobj);
dap_http_simple_reply(a_cl_st, (void*) l_json_str, (size_t) strlen(l_json_str));
@@ -114,8 +115,10 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg)
log_it(L_DEBUG, "Stream encryption: %s\t public key exchange: %s",dap_enc_get_type_name(l_enc_block_type),
dap_enc_get_type_name(l_pkey_exchange_type));
- uint8_t alice_msg[cl_st->request_size];
- size_t l_decode_len = dap_enc_base64_decode(cl_st->request, cl_st->request_size, alice_msg, DAP_ENC_DATA_TYPE_B64);
+ size_t l_decode_len = DAP_ENC_BASE64_DECODE_SIZE(cl_st->request_size);
+ uint8_t alice_msg[l_decode_len + 1];
+ l_decode_len = dap_enc_base64_decode(cl_st->request, cl_st->request_size, alice_msg, DAP_ENC_DATA_TYPE_B64);
+ alice_msg[l_decode_len] = '\0';
dap_chain_hash_fast_t l_sign_hash = {0};
if (!l_protocol_version && !l_sign_count) {
if (l_decode_len > l_pkey_exchange_size + sizeof(dap_sign_hdr_t)) {
@@ -176,7 +179,9 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg)
char *encrypt_msg = DAP_NEW_Z_SIZE(char, DAP_ENC_BASE64_ENCODE_SIZE(l_pkey_exchange_key->pub_key_data_size) + 1),
encrypt_id[DAP_ENC_BASE64_ENCODE_SIZE(DAP_ENC_KS_KEY_ID_SIZE) + 1] = { '\0' };
- dap_enc_base64_encode(l_pkey_exchange_key->pub_key_data, l_pkey_exchange_key->pub_key_data_size, encrypt_msg, DAP_ENC_DATA_TYPE_B64);
+ int l_enc_msg_len = (int)dap_enc_base64_encode( l_pkey_exchange_key->pub_key_data,
+ l_pkey_exchange_key->pub_key_data_size,
+ encrypt_msg, DAP_ENC_DATA_TYPE_B64);
l_enc_key_ks->key = dap_enc_key_new_generate(l_enc_block_type,
l_pkey_exchange_key->priv_key_data, // shared key
@@ -184,7 +189,9 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg)
l_enc_key_ks->id, DAP_ENC_KS_KEY_ID_SIZE, l_block_key_size);
dap_enc_ks_save_in_storage(l_enc_key_ks);
- dap_enc_base64_encode(l_enc_key_ks->id, sizeof (l_enc_key_ks->id), encrypt_id, DAP_ENC_DATA_TYPE_B64);
+ int l_enc_id_len = (int)dap_enc_base64_encode(l_enc_key_ks->id, sizeof (l_enc_key_ks->id),
+ encrypt_id, DAP_ENC_DATA_TYPE_B64),
+ l_node_msg_len = 0;
// save verified node addr and generate own sign
char* l_node_sign_msg = NULL;
@@ -211,11 +218,11 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg)
DAP_DELETE(l_node_sign);
return;
}
- dap_enc_base64_encode(l_node_sign, l_node_sign_size, l_node_sign_msg, DAP_ENC_DATA_TYPE_B64);
+ l_node_msg_len = (int)dap_enc_base64_encode(l_node_sign, l_node_sign_size, l_node_sign_msg, DAP_ENC_DATA_TYPE_B64);
DAP_DELETE(l_node_sign);
}
- _enc_http_write_reply(cl_st, encrypt_id, encrypt_msg, l_node_sign_msg);
+ _enc_http_write_reply(cl_st, encrypt_id, l_enc_id_len, encrypt_msg, l_enc_msg_len, l_node_sign_msg, l_node_msg_len);
DAP_DELETE(encrypt_msg);
dap_enc_key_delete(l_pkey_exchange_key);
DAP_DEL_Z(l_node_sign_msg);
@@ -249,12 +256,7 @@ enc_http_delegate_t *enc_http_request_decode(struct dap_http_simple *a_http_simp
dap_enc_key_t * l_key= dap_enc_ks_find_http(a_http_simple->http_client);
if(l_key){
- enc_http_delegate_t * dg = DAP_NEW_Z(enc_http_delegate_t);
- if (!dg) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(dg);
- return NULL;
- }
+ enc_http_delegate_t * dg = DAP_NEW_Z_RET_VAL_IF_FAIL(enc_http_delegate_t, NULL);
dg->key=l_key;
dg->http=a_http_simple->http_client;
// dg->isOk=true;
@@ -391,10 +393,10 @@ size_t enc_http_reply_f(enc_http_delegate_t *a_http_delegate, const char *a_data
char *l_buf = DAP_NEW_SIZE(char, mem_size);
if (!l_buf) {
va_end(ap_copy);
- log_it(L_ERROR, "Can not allocate memory");
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
return 0;
}
- vsprintf(l_buf, a_data, ap_copy);
+ vsnprintf(l_buf, mem_size, a_data, ap_copy);
va_end(ap_copy);
size_t l_ret = enc_http_reply(a_http_delegate, l_buf, mem_size);
DAP_DELETE(l_buf);
diff --git a/net/server/http_server/dap_http_simple.c b/net/server/http_server/dap_http_simple.c
index d73c26c2a11f094814494a30439ffcedf9e841a5..d96035564ae4b78e61244e16143da53e3e14711f 100644
--- a/net/server/http_server/dap_http_simple.c
+++ b/net/server/http_server/dap_http_simple.c
@@ -289,8 +289,7 @@ inline static void s_copy_reply_and_mime_to_response( dap_http_simple_t *a_simpl
return log_it( L_WARNING, " cl_sh->reply_size equal 0" );
a_simple->http_client->out_content_length = a_simple->reply_size;
- strcpy( a_simple->http_client->out_content_type, a_simple->reply_mime );
-
+ dap_strncpy( a_simple->http_client->out_content_type, a_simple->reply_mime, sizeof(a_simple->http_client->out_content_type) - 1 );
return;
}
@@ -309,7 +308,7 @@ inline static void s_write_response_bad_request( dap_http_simple_t * a_http_simp
const char* json_str = json_object_to_json_string( jobj );
dap_http_simple_reply(a_http_simple, (void*) json_str, (size_t) strlen(json_str) );
- strcpy( a_http_simple->reply_mime, "application/json" );
+ dap_strncpy( a_http_simple->reply_mime, "application/json", sizeof(a_http_simple->reply_mime) - 1 );
s_copy_reply_and_mime_to_response( a_http_simple );
@@ -451,10 +450,16 @@ void s_http_client_data_read( dap_http_client_t *a_http_client, void * a_arg )
if( bytes_to_read ) {
// Oops! The client sent more data than write in the CONTENT_LENGTH header
if(l_http_simple->request_size + bytes_to_read > l_http_simple->request_size_max){
- log_it(L_WARNING, "Oops! Client sent more data length=%zu than in content-length=%zu in request", l_http_simple->request_size + bytes_to_read, a_http_client->in_content_length);
+ log_it(L_WARNING, "Client sent more data length=%zu than in content-length=%zu in request", l_http_simple->request_size + bytes_to_read, a_http_client->in_content_length);
l_http_simple->request_size_max = l_http_simple->request_size + bytes_to_read + 1;
// increase input buffer
- l_http_simple->request = DAP_REALLOC(l_http_simple->request, l_http_simple->request_size_max);
+ byte_t *l_req_new = DAP_REALLOC((byte_t*)l_http_simple->request, l_http_simple->request_size_max);
+ if (!l_req_new) {
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+ dap_events_socket_set_readable_unsafe(a_http_client->esocket, false);
+ return;
+ }
+ l_http_simple->request = l_req_new;
}
if(l_http_simple->request){// request_byte=request
memcpy( l_http_simple->request_byte + l_http_simple->request_size, a_http_client->esocket->buf_in, bytes_to_read );
@@ -527,7 +532,7 @@ size_t dap_http_simple_reply_f(dap_http_simple_t *a_http_simple, const char *a_f
return 0;
}
char *l_buf = DAP_NEW_SIZE(char, l_buf_size);
- vsprintf(l_buf, a_format, ap_copy);
+ vsnprintf(l_buf, l_buf_size, a_format, ap_copy);
va_end(ap_copy);
size_t l_ret = dap_http_simple_reply(a_http_simple, l_buf, l_buf_size);
diff --git a/net/server/http_server/http_client/dap_http_user_agent.c b/net/server/http_server/http_client/dap_http_user_agent.c
index 733ea7aaf0d65add55c88c73ea13b626c0b2c5ea..09770e1f7845f2cb43959f32d113a4774432eccf 100644
--- a/net/server/http_server/http_client/dap_http_user_agent.c
+++ b/net/server/http_server/http_client/dap_http_user_agent.c
@@ -80,7 +80,7 @@ dap_http_user_agent_ptr_t dap_http_user_agent_new_from_str(const char* a_user_ag
char* l_major = strtok(l_version, ".");
char* l_minor = strtok(NULL, ".");
- if(l_minor == NULL) {
+ if(!l_major || !l_minor) {
log_it(L_ERROR, "Wrong input value %s", a_user_agent_str);
goto END;
}
diff --git a/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c b/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c
index 2a25a56a7891e1ac641e961ae4cc55d41fd0c97e..39d1c320a64207209a3126b0a356a98720e71554 100644
--- a/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c
+++ b/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c
@@ -150,12 +150,12 @@ static int dap_chain_exec_cmd_list_wait(struct exec_cmd_request *a_exec_cmd_requ
#ifdef DAP_OS_WINDOWS
EnterCriticalSection(&a_exec_cmd_request->wait_crit_sec);
if (a_exec_cmd_request->response)
- return LeaveCriticalSection(&a_exec_cmd_request->wait_crit_sec), a_exec_cmd_request->response;
+ return LeaveCriticalSection(&a_exec_cmd_request->wait_crit_sec), EXEC_CMD_OK;
while (!a_exec_cmd_request->response) {
if ( !SleepConditionVariableCS(&a_exec_cmd_request->wait_cond, &a_exec_cmd_request->wait_crit_sec, a_timeout_ms) )
- a_exec_cmd_request->response = GetLastError() == ERROR_TIMEOUT ? EXEC_CMD_ERR_WAIT_TIMEOUT : EXEC_CMD_ERR_UNKNOWN;
+ a_exec_cmd_request->error_code = GetLastError() == ERROR_TIMEOUT ? EXEC_CMD_ERR_WAIT_TIMEOUT : EXEC_CMD_ERR_UNKNOWN;
}
- return LeaveCriticalSection(&a_exec_cmd_request->wait_crit_sec), a_exec_cmd_request->response;
+ return LeaveCriticalSection(&a_exec_cmd_request->wait_crit_sec), a_exec_cmd_request->error_code;
#else
pthread_mutex_lock(&a_exec_cmd_request->wait_mutex);
if(a_exec_cmd_request->response)
@@ -175,14 +175,17 @@ static int dap_chain_exec_cmd_list_wait(struct exec_cmd_request *a_exec_cmd_requ
pthread_cond_timedwait(&a_exec_cmd_request->wait_cond, &a_exec_cmd_request->wait_mutex, &l_cond_timeout)
#endif
) {
+ case 0:
+ break;
case ETIMEDOUT:
- a_exec_cmd_request->response = dap_strdup("ERR_WAIT_TIMEOUT");
- return EXEC_CMD_ERR_WAIT_TIMEOUT;
+ a_exec_cmd_request->error_code = EXEC_CMD_ERR_WAIT_TIMEOUT;
+ break;
default:
+ a_exec_cmd_request->error_code = EXEC_CMD_ERR_UNKNOWN;
break;
}
}
- return pthread_mutex_unlock(&a_exec_cmd_request->wait_mutex), EXEC_CMD_OK;
+ return pthread_mutex_unlock(&a_exec_cmd_request->wait_mutex), a_exec_cmd_request->error_code;
#endif
}
@@ -484,7 +487,6 @@ dap_json_rpc_http_request_t *dap_json_rpc_request_sign_by_cert(dap_json_rpc_requ
}
char* dap_json_rpc_request_to_http_str(dap_json_rpc_request_t *a_request, size_t*output_data_size){
- uint64_t l_id_response = dap_json_rpc_response_registration(a_request);
a_request->id = 0;
dap_cert_t *l_cert = dap_cert_find_by_name("node-addr");
if (!l_cert) {
@@ -502,23 +504,17 @@ int dap_json_rpc_request_send(dap_client_pvt_t* a_client_internal, dap_json_rpc
char* l_custom_header = NULL, *l_path = NULL;
char* l_request_data_str = dap_json_rpc_request_to_http_str(a_request, &l_request_data_size);
- if (!l_request_data_str) {
+ if (!l_request_data_str)
return -1;
- }
+
char * l_enc_request = dap_json_rpc_enc_request(a_client_internal, l_request_data_str, l_request_data_size, &l_path, &l_enc_request_size, &l_custom_header);
- DAP_DEL_Z(l_request_data_str);
- if (!l_enc_request || !l_path) {
- DAP_DEL_Z(l_request_data_str);
- DAP_DEL_Z(l_custom_header);
- return -2;
- }
+ DAP_DELETE(l_request_data_str);
+ if (!l_enc_request || !l_path)
+ return DAP_DEL_MULTY(l_custom_header, l_enc_request, l_path), -1;
+
struct exec_cmd_request* l_exec_cmd_request = s_exec_cmd_request_init(a_client_internal);
- if (!l_exec_cmd_request) {
- DAP_DEL_Z(l_custom_header);
- DAP_DEL_Z(l_path);
- DAP_DEL_Z(l_enc_request);
- return -3;
- }
+ if (!l_exec_cmd_request)
+ return DAP_DEL_MULTY(l_custom_header, l_enc_request, l_path), -1;
log_it(L_DEBUG, "Send enc json-rpc request to %s:%d, path = %s, request size = %lu",
a_client_internal->client->link_info.uplink_addr, a_client_internal->client->link_info.uplink_port, l_path, l_enc_request_size);
diff --git a/net/server/json_rpc/rpc_core/src/dap_json_rpc_response_handler.c b/net/server/json_rpc/rpc_core/src/dap_json_rpc_response_handler.c
index 941b56bd8acfb4c2e223c768879ed6a1f640cd0c..ab521f7dbc2b416015872b23610c952b1587b1e4 100644
--- a/net/server/json_rpc/rpc_core/src/dap_json_rpc_response_handler.c
+++ b/net/server/json_rpc/rpc_core/src/dap_json_rpc_response_handler.c
@@ -78,21 +78,19 @@ uint64_t dap_json_rpc_response_get_new_id(void)
return l_ret;
}
-void dap_json_rpc_response_accepted(void *a_data, size_t a_size_data, void *a_obj, http_status_code_t http_status)
+void dap_json_rpc_response_accepted(void *a_data, size_t a_size_data, UNUSED_ARG void *a_obj, http_status_code_t http_status)
{
- if(http_status == Http_Status_OK) {
- (void)http_status;
- (void)a_obj;
- log_it(L_NOTICE, "Pre handling response");
- char *l_str = DAP_NEW_SIZE(char, a_size_data);
- memcpy(l_str, a_data, a_size_data);
- dap_json_rpc_response_t *l_response = dap_json_rpc_response_from_string(l_str);
- DAP_FREE(l_str);
- dap_json_rpc_response_handler(l_response);
- dap_json_rpc_response_free(l_response);
- return;
- } else {
- log_it(L_ERROR, "Response error code: %d", http_status);
- return;
- }
-}
+ if (http_status != Http_Status_OK)
+ return log_it(L_ERROR, "Reponse error %d", (int)http_status);
+ log_it(L_NOTICE, "Pre handling response");
+ dap_json_rpc_response_t *l_response;
+ if ( *((char*)a_data + a_size_data) ) {
+ char *l_dup = DAP_NEW_Z_SIZE_RET_IF_FAIL(char, a_size_data + 1);
+ memcpy(l_dup, a_data, a_size_data);
+ l_response = dap_json_rpc_response_from_string(l_dup);
+ DAP_DELETE(l_dup);
+ } else
+ l_response = dap_json_rpc_response_from_string((char*)a_data);
+ dap_json_rpc_response_handler(l_response);
+ dap_json_rpc_response_free(l_response);
+}
\ No newline at end of file
diff --git a/net/server/json_rpc/src/dap_json_rpc.c b/net/server/json_rpc/src/dap_json_rpc.c
index 4356696412f0c9132bc8dbd10d80c31765e10220..303ac918a052c8fcfe5c430bbea7e8488b4da316 100644
--- a/net/server/json_rpc/src/dap_json_rpc.c
+++ b/net/server/json_rpc/src/dap_json_rpc.c
@@ -56,7 +56,7 @@ bool dap_check_node_pkey_in_map(dap_hash_fast_t *a_pkey){
}
dap_client_http_callback_error_t * dap_json_rpc_error_callback() {
-
+ return NULL;
}
int dap_json_rpc_init(dap_server_t* a_http_server, dap_config_t *a_config)
diff --git a/net/server/notify_server/include/dap_notify_srv.h b/net/server/notify_server/include/dap_notify_srv.h
index 7041fac8d1d63ff57820990f5150203bae328498..b703afe117131d93266bbb792020b0fe6ddfa656 100644
--- a/net/server/notify_server/include/dap_notify_srv.h
+++ b/net/server/notify_server/include/dap_notify_srv.h
@@ -32,6 +32,6 @@ int dap_notify_server_send_mt(const char * a_data);
DAP_PRINTF_ATTR(1, 2) int dap_notify_server_send_f_mt(const char *a_format, ...);
typedef bool (*dap_notify_data_user_callback_t)(const char *data);
-void dap_notify_data_set_user_callback(dap_notify_data_user_callback_t callback);
+void dap_notify_data_set_user_callback(dap_notify_data_user_callback_t a_cb);
-void dap_notify_srv_set_callback_new(dap_events_socket_callback_t);
\ No newline at end of file
+void dap_notify_srv_set_callback_new(dap_events_socket_callback_t a_cb);
diff --git a/net/server/notify_server/src/dap_notify_srv.c b/net/server/notify_server/src/dap_notify_srv.c
index e8d82ded1754e269bd81f2550bb1580c41573329..30728be945c44394d5631ecf13dd6c78efd4d0b8 100644
--- a/net/server/notify_server/src/dap_notify_srv.c
+++ b/net/server/notify_server/src/dap_notify_srv.c
@@ -78,7 +78,7 @@ int dap_notify_server_init()
}
s_notify_server_queue = dap_events_socket_create_type_queue_ptr_mt(dap_events_worker_get_auto(), s_notify_server_callback_queue);
uint32_t l_workers_count = dap_events_thread_get_count();
- DAP_NEW_Z_COUNT_RET_VAL(s_notify_server_queue_inter, dap_events_socket_t*, l_workers_count, -2, NULL);
+ s_notify_server_queue_inter = DAP_NEW_Z_COUNT_RET_VAL_IF_FAIL(dap_events_socket_t*, l_workers_count, -2);
for (uint32_t i = 0; i < l_workers_count; ++i) {
s_notify_server_queue_inter[i] = dap_events_socket_queue_ptr_create_input(s_notify_server_queue);
dap_events_socket_assign_on_worker_mt(s_notify_server_queue_inter[i], dap_events_worker_get(i));
@@ -136,7 +136,7 @@ int dap_notify_server_send_f_inter(uint32_t a_worker_id, const char * a_format,.
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
return -1;
}
- vsprintf(l_str, a_format, ap_copy);
+ vsnprintf(l_str, l_str_size, a_format, ap_copy);
va_end(ap_copy);
int l_ret = dap_events_socket_queue_ptr_send_to_input(l_input, l_str);
DAP_DELETE(l_str);
@@ -184,15 +184,12 @@ int dap_notify_server_send_f_mt(const char *a_format, ...)
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
return -1;
}
- vsprintf(l_str, a_format, ap_copy);
+ vsnprintf(l_str, l_str_size, a_format, ap_copy);
va_end(ap_copy);
- if (s_notify_data_user_callback) s_notify_data_user_callback(l_str);
+ if (s_notify_data_user_callback)
+ s_notify_data_user_callback(l_str);
-
- if(!s_notify_server_queue) // If not initialized - nothing to notify
- return 0;
-
int l_ret = dap_events_socket_queue_ptr_send(s_notify_server_queue, l_str);
DAP_DELETE(l_str);
return l_ret;
@@ -224,7 +221,7 @@ static void s_notify_server_callback_queue(dap_events_socket_t * a_es, void * a_
#endif
dap_events_socket_write_mt( dap_events_worker_get(l_worker_id),
- l_socket_handler->uuid, l_arg, l_str_len + 1 );
+ l_socket_handler->uuid, l_arg, l_str_len + 1 );
}
pthread_rwlock_unlock(&s_notify_server_clients_mutex);
DAP_DELETE(a_arg);
diff --git a/net/stream/ch/dap_stream_ch.c b/net/stream/ch/dap_stream_ch.c
index 85ae37e2eea85d126295136b5b62149c3adc4aeb..ca0b15da3ae47dfffd64e07042e43812d5529ce8 100644
--- a/net/stream/ch/dap_stream_ch.c
+++ b/net/stream/ch/dap_stream_ch.c
@@ -209,7 +209,8 @@ dap_stream_ch_t* dap_stream_ch_new(dap_stream_t* a_stream, uint8_t a_id)
{
dap_stream_ch_proc_t * proc=dap_stream_ch_proc_find(a_id);
if(proc){
-
+ dap_stream_ch_t **l_channels = DAP_REALLOC_COUNT_RET_VAL_IF_FAIL(a_stream->channel, a_stream->channel_count + 1, NULL);
+ a_stream->channel = l_channels;
dap_stream_ch_t* l_ch_new = dap_stream_ch_alloc();
l_ch_new->me = l_ch_new;
@@ -232,7 +233,6 @@ dap_stream_ch_t* dap_stream_ch_new(dap_stream_t* a_stream, uint8_t a_id)
if(l_ch_new->proc->new_callback)
l_ch_new->proc->new_callback(l_ch_new,NULL);
- a_stream->channel = DAP_REALLOC(a_stream->channel, sizeof(dap_stream_ch_t *) * (a_stream->channel_count + 1));
a_stream->channel[l_ch_new->stream->channel_count++] = l_ch_new;
return l_ch_new;
diff --git a/net/stream/ch/dap_stream_ch_pkt.c b/net/stream/ch/dap_stream_ch_pkt.c
index aaa80e54072cde562f943d274fe31a9c4592012a..1632bc51a2ab0253d7a68c73416afeaa7f61eac4 100644
--- a/net/stream/ch/dap_stream_ch_pkt.c
+++ b/net/stream/ch/dap_stream_ch_pkt.c
@@ -107,7 +107,7 @@ size_t dap_stream_ch_pkt_write_f_mt(dap_stream_worker_t * a_worker , dap_stream_
}
l_msg->data_size = l_data_size;
l_msg->flags_set = DAP_SOCK_READY_TO_WRITE;
- l_data_size = vsprintf(l_msg->data, a_format, ap_copy);
+ l_data_size = vsnprintf(l_msg->data, l_data_size, a_format, ap_copy);
va_end(ap_copy);
va_end(ap);
@@ -160,7 +160,7 @@ size_t dap_stream_ch_pkt_write_f_inter(dap_events_socket_t * a_queue , dap_stre
}
l_msg->data_size = l_data_size;
l_msg->flags_set = DAP_SOCK_READY_TO_WRITE;
- l_data_size = vsprintf(l_msg->data, a_format, ap_copy);
+ l_data_size = vsnprintf(l_msg->data, l_data_size, a_format, ap_copy);
va_end(ap_copy);
int l_ret= dap_events_socket_queue_ptr_send_to_input(a_queue , l_msg );
@@ -196,7 +196,7 @@ size_t dap_stream_ch_pkt_write_mt(dap_stream_worker_t * a_worker , dap_stream_ch
l_msg->ch_uuid = a_ch_uuid;
l_msg->ch_pkt_type = a_type;
if (a_data && a_data_size)
- l_msg->data = DAP_DUP_SIZE(a_data, a_data_size);
+ l_msg->data = DAP_DUP_SIZE((char*)a_data, a_data_size);
l_msg->flags_set = DAP_SOCK_READY_TO_WRITE;
l_msg->data_size = a_data_size;
@@ -222,7 +222,7 @@ int dap_stream_ch_pkt_send_mt(dap_stream_worker_t *a_worker, dap_events_socket_u
l_msg->ch_pkt_type = a_type;
l_msg->ch_id = a_ch_id;
if (a_data && a_data_size) {
- l_msg->data = DAP_DUP_SIZE(a_data, a_data_size);
+ l_msg->data = DAP_DUP_SIZE((char*)a_data, a_data_size);
if (!l_msg->data) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
DAP_DELETE(l_msg);
@@ -269,7 +269,7 @@ size_t dap_stream_ch_pkt_write_inter(dap_events_socket_t * a_queue_input, dap_st
l_msg->ch_uuid = a_ch_uuid;
l_msg->ch_pkt_type = a_type;
if (a_data && a_data_size)
- l_msg->data = DAP_DUP_SIZE(a_data, a_data_size);
+ l_msg->data = DAP_DUP_SIZE((char*)a_data, a_data_size);
l_msg->data_size = a_data_size;
l_msg->flags_set = DAP_SOCK_READY_TO_WRITE;
@@ -389,7 +389,7 @@ ssize_t dap_stream_ch_pkt_write_f_unsafe(dap_stream_ch_t *a_ch, uint8_t a_type,
va_end(ap_copy);
return l_data_size--;
}
- vsprintf(l_data, a_format, ap_copy);
+ vsnprintf(l_data, l_data_size, a_format, ap_copy);
va_end(ap_copy);
size_t l_ret = dap_stream_ch_pkt_write_unsafe(a_ch, a_type, l_data, l_data_size);
DAP_DELETE(l_data);
diff --git a/net/stream/stream/dap_stream.c b/net/stream/stream/dap_stream.c
index 085d40a5226ffd99ae16f021a26a3b10ce57a91e..23f7ab17615ca89a27bad94bd8708e7759f3060c 100644
--- a/net/stream/stream/dap_stream.c
+++ b/net/stream/stream/dap_stream.c
@@ -1063,39 +1063,36 @@ dap_list_t *dap_stream_find_all_by_addr(dap_stream_node_addr_t *a_addr)
*/
dap_stream_node_addr_t dap_stream_node_addr_from_sign(dap_sign_t *a_sign)
{
- dap_stream_node_addr_t l_ret = {0};
+ dap_stream_node_addr_t l_ret = { };
dap_return_val_if_pass(!a_sign, l_ret);
dap_hash_fast_t l_node_addr_hash;
- dap_sign_get_pkey_hash(a_sign, &l_node_addr_hash);
- dap_stream_node_addr_from_hash(&l_node_addr_hash, &l_ret);
-
+ if ( dap_sign_get_pkey_hash(a_sign, &l_node_addr_hash) )
+ dap_stream_node_addr_from_hash(&l_node_addr_hash, &l_ret);
return l_ret;
}
dap_stream_node_addr_t dap_stream_node_addr_from_cert(dap_cert_t *a_cert)
{
- dap_stream_node_addr_t l_ret = {0};
+ dap_stream_node_addr_t l_ret = { };
dap_return_val_if_pass(!a_cert, l_ret);
// Get certificate public key hash
dap_hash_fast_t l_node_addr_hash;
- dap_cert_get_pkey_hash(a_cert, &l_node_addr_hash);
- dap_stream_node_addr_from_hash(&l_node_addr_hash, &l_ret);
-
+ if ( !dap_cert_get_pkey_hash(a_cert, &l_node_addr_hash) )
+ dap_stream_node_addr_from_hash(&l_node_addr_hash, &l_ret);
return l_ret;
}
dap_stream_node_addr_t dap_stream_node_addr_from_pkey(dap_pkey_t *a_pkey)
{
- dap_stream_node_addr_t l_ret = {0};
+ dap_stream_node_addr_t l_ret = { };
dap_return_val_if_pass(!a_pkey, l_ret);
// Get certificate public key hash
dap_hash_fast_t l_node_addr_hash;
- dap_pkey_get_hash(a_pkey, &l_node_addr_hash);
- dap_stream_node_addr_from_hash(&l_node_addr_hash, &l_ret);
-
+ if ( dap_pkey_get_hash(a_pkey, &l_node_addr_hash) )
+ dap_stream_node_addr_from_hash(&l_node_addr_hash, &l_ret);
return l_ret;
}
@@ -1104,7 +1101,7 @@ static void s_stream_fill_info(dap_stream_t *a_stream, dap_stream_info_t *a_out_
a_out_info->node_addr = a_stream->node;
a_out_info->remote_addr_str = dap_strdup_printf("%-*s", INET_ADDRSTRLEN - 1, a_stream->esocket->remote_addr_str);
a_out_info->remote_port = a_stream->esocket->remote_port;
- a_out_info->channels = DAP_NEW_Z_SIZE(char, a_stream->channel_count + 1);
+ a_out_info->channels = DAP_NEW_Z_SIZE_RET_IF_FAIL(char, a_stream->channel_count + 1, a_out_info->remote_addr_str);
for (size_t i = 0; i < a_stream->channel_count; i++)
a_out_info->channels[i] = a_stream->channel[i]->proc->id;
a_out_info->total_packets_sent = a_stream->seq_id;
diff --git a/net/stream/stream/dap_stream_cluster.c b/net/stream/stream/dap_stream_cluster.c
index 159531d245ee6c626b71aed9b9ce3d63baebc76f..391ee52398812e2af82573bf65db824ecf5745bf 100644
--- a/net/stream/stream/dap_stream_cluster.c
+++ b/net/stream/stream/dap_stream_cluster.c
@@ -422,7 +422,7 @@ dap_stream_node_addr_t *dap_cluster_get_all_members_addrs(dap_cluster_t *a_clust
}
}
if (l_bias < l_count)
- ret = DAP_REALLOC(ret, sizeof(dap_stream_node_addr_t) * l_bias);
+ ret = DAP_REALLOC_COUNT(ret, l_bias);
}
pthread_rwlock_unlock(&a_cluster->members_lock);
if (a_count)
diff --git a/net/stream/stream/dap_stream_pkt.c b/net/stream/stream/dap_stream_pkt.c
index 9d482f34dd732d46bf0bf5d8723595b32b077bdf..f92a12da5c7d8e8a7050fdd789ed10a95418262f 100644
--- a/net/stream/stream/dap_stream_pkt.c
+++ b/net/stream/stream/dap_stream_pkt.c
@@ -88,33 +88,19 @@ size_t dap_stream_pkt_write_mt(dap_worker_t * a_w,dap_events_socket_uuid_t a_es_
memcpy(l_pkt_hdr->sig, c_dap_stream_sig, sizeof(l_pkt_hdr->sig));
return dap_events_socket_write_mt(a_w, a_es_uuid, s_pkt_buf, l_full_size);
#else
- dap_worker_msg_io_t * l_msg = DAP_NEW_Z(dap_worker_msg_io_t);
- if (!l_msg) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return 0;
- }
- dap_stream_pkt_hdr_t *l_pkt_hdr;
+ dap_worker_msg_io_t *l_msg = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_worker_msg_io_t, 0);
l_msg->esocket_uuid = a_es_uuid;
- l_msg->data_size = 16-a_data_size%16+a_data_size+sizeof(*l_pkt_hdr);
- l_msg->data = DAP_NEW_SIZE(void,l_msg->data_size);
- if (!l_msg) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(l_msg);
- return 0;
- }
- l_pkt_hdr=(dap_stream_pkt_hdr_t*) l_msg->data;
- memset(l_pkt_hdr,0,sizeof(*l_pkt_hdr));
- memcpy(l_pkt_hdr->sig,c_dap_stream_sig,sizeof(l_pkt_hdr->sig));
- l_msg->data_size=sizeof (*l_pkt_hdr) +dap_enc_code(a_key, a_data,a_data_size, ((byte_t*)l_msg->data)+sizeof (*l_pkt_hdr),l_msg->data_size-sizeof (*l_pkt_hdr),DAP_ENC_DATA_TYPE_RAW);
+ l_msg->data_size = dap_enc_code_out_size(a_key, a_data_size, DAP_ENC_DATA_TYPE_RAW);
+ l_msg->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(void, l_msg->data_size, 0, l_msg);
+ dap_stream_pkt_hdr_t *l_pkt_hdr = (dap_stream_pkt_hdr_t*)l_msg->data;
+ memcpy(l_pkt_hdr->sig, c_dap_stream_sig, sizeof(l_pkt_hdr->sig));
+ l_msg->data_size = sizeof(*l_pkt_hdr) + dap_enc_code(a_key, a_data, a_data_size,
+ ((byte_t*)l_msg->data) + sizeof(*l_pkt_hdr), l_msg->data_size, DAP_ENC_DATA_TYPE_RAW);
- int l_ret= dap_events_socket_queue_ptr_send(a_w->queue_es_io, l_msg );
- if (l_ret!=0){
- log_it(L_ERROR, "Wasn't send pointer to queue: code %d", l_ret);
- DAP_DELETE(l_msg->data);
- DAP_DELETE(l_msg);
- return 0;
- }
- return a_data_size;
+ int l_ret = dap_events_socket_queue_ptr_send(a_w->queue_es_io, l_msg);
+ return l_ret
+ ? log_it(L_ERROR, "Can't send msg to queue %d, error %d", a_w->queue_es_io->fd, l_ret), DAP_DEL_MULTY(l_msg->data, l_msg), 0
+ : a_data_size;
#endif
}
diff --git a/net/stream/stream/include/dap_stream_cluster.h b/net/stream/stream/include/dap_stream_cluster.h
index 8e99f963cff1df8e3f45b119cb9989dbfd3c8299..4c29a9d165df8cbf463536b9bd1cd7da127e464a 100644
--- a/net/stream/stream/include/dap_stream_cluster.h
+++ b/net/stream/stream/include/dap_stream_cluster.h
@@ -62,7 +62,7 @@ typedef enum dap_cluster_status {
} dap_cluster_status_t;
typedef struct dap_cluster {
- const char *mnemonim; // Field for alternative cluster finding, unique
+ char *mnemonim; // Field for alternative cluster finding, unique
dap_guuid_t guuid; // Unique global cluster id
dap_cluster_type_t type; // Link management type
dap_cluster_status_t status; // Active or inactive for now
diff --git a/net/stream/stream/include/dap_stream_worker.h b/net/stream/stream/include/dap_stream_worker.h
index e868eb8853835ceaa3c5fb092d01cf7c12b4a408..f2f2a039f37bd511b3bcf09c1ae457e10c6d3ba7 100644
--- a/net/stream/stream/include/dap_stream_worker.h
+++ b/net/stream/stream/include/dap_stream_worker.h
@@ -50,7 +50,7 @@ typedef struct dap_stream_worker_msg_send {
dap_events_socket_uuid_t uuid;
char ch_id;
uint8_t ch_pkt_type;
- const void *data;
+ void *data;
size_t data_size;
} dap_stream_worker_msg_send_t;
diff --git a/plugin/src/dap_plugin_manifest.c b/plugin/src/dap_plugin_manifest.c
index 642beea46df02953d2ee75d5a40afaad07fa6198..ae6de2de5746c47a2175a548b9fe32ecce4b7d90 100644
--- a/plugin/src/dap_plugin_manifest.c
+++ b/plugin/src/dap_plugin_manifest.c
@@ -105,7 +105,7 @@ dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path
if(!json_object_is_type(l_json, json_type_object)) {
log_it(L_ERROR, "Invalid manifest structure, shoud be a json object: %s", a_file_path);
json_object_put(l_json);
- return NULL;
+ return NULL;
}
json_object *j_name = json_object_object_get(l_json, "name");
@@ -128,27 +128,25 @@ dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path
if (!l_name || !l_version || !l_author || !l_description || !l_type)
{
log_it(L_ERROR, "Invalid manifest structure, insuficient fields %s", a_file_path);
+
return NULL;
}
dap_plugin_manifest_t *l_manifest = NULL;
HASH_FIND_STR(s_manifests, l_name, l_manifest);
- if(l_manifest){
- log_it(L_ERROR, "Plugin name \"%s\" is already present", l_name);
- return NULL;
- }
+ if (l_manifest)
+ return json_object_put(l_json), log_it(L_ERROR, "Plugin name \"%s\" is already present", l_name), l_manifest;
+
size_t l_dependencies_count = j_dependencies ? (size_t)json_object_array_length(j_dependencies) : 0;
size_t l_params_count = j_params ? (size_t)json_object_array_length(j_params) : 0;
- char ** l_dependencies_names = NULL, **l_params = NULL;
+ char **l_dependencies_names = NULL, **l_params = NULL;
// Read dependencies;
if(l_dependencies_count)
{
- l_dependencies_names = DAP_NEW_SIZE(char*, sizeof(char*)* l_dependencies_count );
- if (!l_dependencies_names) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
+ if (!( l_dependencies_names = DAP_NEW_Z_COUNT(char*, l_dependencies_count) ))
+ return json_object_put(l_json), log_it(L_CRITICAL, "%s", c_error_memory_alloc), NULL;
+
for (size_t i = 0; i < l_dependencies_count; i++){
l_dependencies_names[i] = dap_strdup(json_object_get_string(json_object_array_get_idx(j_dependencies, i)));
}
@@ -157,10 +155,11 @@ dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path
// Read additional params
if(l_params_count)
{
- l_params = DAP_NEW_SIZE(char*, sizeof(char*)* l_params_count );
- if (!l_params) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
+ if (!( l_params = DAP_NEW_Z_COUNT(char*, l_params_count) )) {
+ json_object_put(l_json);
+ DAP_DEL_ARRAY(l_dependencies_names, l_dependencies_count);
+ DAP_DELETE(l_dependencies_names);
+ return log_it(L_CRITICAL, "%s", c_error_memory_alloc), NULL;
}
for (size_t i = 0; i < l_params_count; i++){
l_params[i] = dap_strdup(json_object_get_string(json_object_array_get_idx(j_params, i)));
@@ -168,10 +167,12 @@ dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path
}
// Create manifest itself
- l_manifest = DAP_NEW_Z(dap_plugin_manifest_t);
- if (!l_manifest) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
+ if (!( l_manifest = DAP_NEW_Z(dap_plugin_manifest_t) )) {
+ json_object_put(l_json);
+ DAP_DEL_ARRAY(l_dependencies_names, l_dependencies_count);
+ DAP_DEL_ARRAY(l_params, l_params_count);
+ DAP_DEL_MULTY(l_dependencies_names, l_params);
+ return log_it(L_CRITICAL, "%s", c_error_memory_alloc), NULL;
}
strncpy(l_manifest->name,l_name, sizeof(l_manifest->name)-1);
@@ -183,22 +184,14 @@ dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path
l_manifest->dependencies_count = l_dependencies_count;
l_manifest->params_count = l_params_count;
l_manifest->params = l_params;
+ l_manifest->path = l_path ? dap_strdup(l_path) : dap_path_get_dirname(a_file_path);
- if(l_path){ // If targeted manualy plugin's path
- l_manifest->path = l_path;
- }else{ // Compose it from plugin root path
- l_manifest->path = dap_path_get_dirname(a_file_path);
- }
-
- char * l_config_path = dap_strdup_printf("%s/%s", l_manifest->path,l_manifest->name );
- char * l_config_path_test = dap_strdup_printf("%s.cfg", l_config_path);
+ char *l_config_path = dap_strdup_printf("%s/%s", l_manifest->path, l_manifest->name),
+ *l_config_path_test = dap_strdup_printf("%s.cfg", l_config_path);
if(dap_file_test(l_config_path_test)) // If present custom config
l_manifest->config = dap_config_open(l_config_path);
- DAP_DELETE(l_config_path);
- DAP_DELETE(l_config_path_test);
-
- HASH_ADD_STR(s_manifests,name,l_manifest);
-
+ DAP_DEL_MULTY(l_config_path, l_config_path_test);
+ HASH_ADD_STR(s_manifests, name, l_manifest);
json_object_put(l_json);
return l_manifest;
}
@@ -253,15 +246,10 @@ char* dap_plugin_manifests_get_list_dependencies(dap_plugin_manifest_t *a_elemen
*/
static void s_manifest_delete(dap_plugin_manifest_t *a_manifest)
{
- DAP_DELETE(a_manifest->name);
- DAP_DELETE(a_manifest->version);
- DAP_DELETE(a_manifest->author);
- DAP_DELETE(a_manifest->description);
- if(a_manifest->dependencies_names){
- for(size_t i = 0; i< a_manifest->dependencies_count; i++)
- DAP_DELETE(a_manifest->dependencies_names[i]);
- DAP_DELETE(a_manifest->dependencies_names);
- }
+ DAP_DEL_ARRAY(a_manifest->dependencies_names, a_manifest->dependencies_count);
+ DAP_DEL_ARRAY(a_manifest->params, a_manifest->params_count);
+ DAP_DEL_MULTY(a_manifest->name, a_manifest->version, a_manifest->author, a_manifest->description,
+ a_manifest->type, (char*)a_manifest->path, a_manifest->dependencies_names, a_manifest->params);
dap_plugin_manifest_dependence_t * l_dep, *l_tmp;
HASH_ITER(hh,a_manifest->dependencies,l_dep,l_tmp){
HASH_DELETE(hh, a_manifest->dependencies, l_dep);