diff --git a/global-db/dap_global_db_driver_sqlite.c b/global-db/dap_global_db_driver_sqlite.c
index 1a53bbec787caefdfcf7f053438c8718953e3324..65fbda0732bcac27e93a0c20dfc082176c086173 100644
--- a/global-db/dap_global_db_driver_sqlite.c
+++ b/global-db/dap_global_db_driver_sqlite.c
@@ -813,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 = s_db_sqlite_get_connection(false);
- dap_return_val_if_pass(!a_group_mask || !l_conn, NULL);
+ conn_list_item_t *l_conn = NULL;
+ dap_return_val_if_pass(!a_group_mask || !(l_conn = s_db_sqlite_get_connection(false)), NULL);
// preparing
const char *l_error_msg = "get groups";
dap_list_t* l_ret = NULL;
diff --git a/global-db/dap_global_db_pkt.c b/global-db/dap_global_db_pkt.c
index 5565c4a9c464c12c0926a004000015e3040443b6..ef24b1ca95524338c664daeb4ebba933a57ccbd0 100644
--- a/global-db/dap_global_db_pkt.c
+++ b/global-db/dap_global_db_pkt.c
@@ -184,13 +184,7 @@ static byte_t *s_fill_one_store_obj(dap_global_db_pkt_t *a_pkt, dap_store_obj_t
l_data_ptr += a_pkt->key_len;
if (a_pkt->value_len) {
- a_obj->value = DAP_DUP_SIZE(l_data_ptr, a_pkt->value_len);
- if (!a_obj->value) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DELETE(a_obj->group);
- DAP_DELETE(a_obj->key);
- return NULL;
- }
+ a_obj->value = DAP_DUP_SIZE_RET_VAL_IF_FAIL(l_data_ptr, a_pkt->value_len, NULL, a_obj->group, a_obj->key);
l_data_ptr += a_pkt->value_len;
}
@@ -205,14 +199,7 @@ static byte_t *s_fill_one_store_obj(dap_global_db_pkt_t *a_pkt, dap_store_obj_t
DAP_DEL_Z(a_obj->value);
return NULL;
}
- a_obj->sign = (dap_sign_t *)DAP_DUP_SIZE(l_sign, l_sign_size);
- if (!a_obj->sign) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DELETE(a_obj->group);
- DAP_DELETE(a_obj->key);
- DAP_DEL_Z(a_obj->value);
- return NULL;
- }
+ a_obj->sign = DAP_DUP_SIZE_RET_VAL_IF_FAIL(l_sign, l_sign_size, NULL, a_obj->group, a_obj->key, a_obj->value);
}
if (a_addr)
diff --git a/io/dap_net.c b/io/dap_net.c
index 6d865590592556d63fa22654eb10fc6f0e9284d0..a26f1695b8cef426b477a5824509dad1b0e8776f 100644
--- a/io/dap_net.c
+++ b/io/dap_net.c
@@ -33,7 +33,7 @@
int dap_net_resolve_host(const char *a_host, const char *a_port, bool a_numeric_only, struct sockaddr_storage *a_addr_out, int *a_family)
{
dap_return_val_if_fail_err(a_addr_out, -1, "Required storage is not provided");
- memset(a_addr_out, 0, sizeof(*a_addr_out));
+ *a_addr_out = (struct sockaddr_storage){ };
int l_ret = 0;
diff --git a/io/dap_worker.c b/io/dap_worker.c
index 2024282788669f16a13cdb4f23faaac23f3fd6c6..a6e1659e1aee340ef788cb8d85d1c6cba63c38aa 100644
--- a/io/dap_worker.c
+++ b/io/dap_worker.c
@@ -449,8 +449,11 @@ static bool s_socket_all_check_activity( void * a_arg)
void dap_worker_add_events_socket(dap_worker_t *a_worker, dap_events_socket_t *a_events_socket)
{
dap_return_if_fail(a_worker && a_events_socket);
-#ifdef DAP_EVENTS_CAPS_IOCP
int l_ret = 0;
+ const char *l_type_str = dap_events_socket_get_type_str(a_events_socket);
+ SOCKET l_s = a_events_socket->socket;
+ dap_events_socket_uuid_t l_uuid = a_events_socket->uuid;
+#ifdef DAP_EVENTS_CAPS_IOCP
a_events_socket->worker = a_worker;
if ( dap_worker_get_current() == a_worker )
s_es_assign_to_context(a_worker->context, &(OVERLAPPED){ .Pointer = a_events_socket });
@@ -462,30 +465,20 @@ void dap_worker_add_events_socket(dap_worker_t *a_worker, dap_events_socket_t *a
l_ret = PostQueuedCompletionStatus(a_worker->context->iocp, 0, (ULONG_PTR)s_es_assign_to_context, (OVERLAPPED*)ol)
? 0 : ( DAP_DELETE(ol), GetLastError() );
}
- if (l_ret)
- log_it(L_ERROR, "Can't assign esocket to worker, error %d", l_ret);
- else
- debug_if(g_debug_reactor, L_DEBUG,
- "Sent es "DAP_FORMAT_ESOCKET_UUID" \"%s\" [%s] to worker #%d",
- a_events_socket->uuid, dap_events_socket_get_type_str(a_events_socket),
- a_events_socket->socket == INVALID_SOCKET ? "" : dap_itoa(a_events_socket->socket),
- a_worker->id);
#else
- int l_ret = dap_worker_get_current() == a_worker
- ? s_queue_es_add(a_worker->queue_es_new, a_events_socket)
- : dap_events_socket_queue_ptr_send(a_worker->queue_es_new, a_events_socket);
-
+ l_ret = dap_worker_get_current() == a_worker
+ ? s_queue_es_add(a_worker->queue_es_new, a_events_socket)
+ : dap_events_socket_queue_ptr_send(a_worker->queue_es_new, a_events_socket);
+#endif
if (l_ret)
- log_it(L_ERROR, dap_worker_get_current() == a_worker
- ? "Can't assign esocket to worker: \"%s\"(code %d)"
- : "Can't send pointer in queue: \"%s\"(code %d)", dap_strerror(l_ret), l_ret);
+ log_it(L_ERROR, "Can't %s es \"%s\" [%s], uuid %"DAP_FORMAT_ESOCKET_UUID" to worker #%d, error %d: \"%s\"",
+ dap_worker_get_current() == a_worker ? "assign" : "send",
+ l_type_str, dap_itoa(l_s), l_uuid, a_worker->id, l_ret, dap_strerror(l_ret));
else
debug_if(g_debug_reactor, L_DEBUG,
- "Sent es %p \"%s\" [%s] to worker #%d",
- a_events_socket, dap_events_socket_get_type_str(a_events_socket),
- a_events_socket->socket == INVALID_SOCKET ? "" : dap_itoa(a_events_socket->socket),
- a_worker->id);
-#endif
+ "%s es \"%s\" [%s], uuid %"DAP_FORMAT_ESOCKET_UUID" to worker #%d",
+ dap_worker_get_current() == a_worker ? "Assigned" : "Sent",
+ l_type_str, dap_itoa(l_s), l_uuid, a_worker->id);
}
#ifndef DAP_EVENTS_CAPS_IOCP
diff --git a/net/client/dap_client_pvt.c b/net/client/dap_client_pvt.c
index 4a830e06be7239668f2ec967bd591f1d8163879e..97a94e04767edae3c490cfcb17c1f5b35cf857c5 100644
--- a/net/client/dap_client_pvt.c
+++ b/net/client/dap_client_pvt.c
@@ -396,7 +396,7 @@ 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_DUP_SIZE(a_client_pvt->session_key_open->pub_key_data, l_data_size);
+ uint8_t *l_data = DAP_DUP_SIZE((uint8_t*)a_client_pvt->session_key_open->pub_key_data, l_data_size);
if (!l_data) {
a_client_pvt->stage_status = STAGE_STATUS_ERROR;
break;
@@ -429,8 +429,8 @@ static void s_stage_status_after(dap_client_pvt_t *a_client_pvt)
// bad request
if (l_res < 0)
a_client_pvt->stage_status = STAGE_STATUS_ERROR;
- DAP_DEL_Z(l_data);
- DAP_DEL_Z(l_data_str);
+ DAP_DELETE(l_data);
+ DAP_DELETE(l_data_str);
} break;
case STAGE_STREAM_CTL: {
diff --git a/net/server/http_server/dap_http_cache.c b/net/server/http_server/dap_http_cache.c
index 6275a0b46e05e529e5573acfd176d5146c62b731..dfe36e2dcdd3e5deb4ebc3406e75326f90ac7158 100644
--- a/net/server/http_server/dap_http_cache.c
+++ b/net/server/http_server/dap_http_cache.c
@@ -41,24 +41,12 @@ dap_http_cache_t * dap_http_cache_update(struct dap_http_url_proc * a_url_proc,
dap_http_header_t * a_headers, const char * a_response_phrase, int a_respoonse_code,
time_t a_ts_expire )
{
- dap_http_cache_t * l_ret = DAP_NEW_Z(dap_http_cache_t);
- if (!l_ret) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
- if(a_body_size){
- l_ret->body = DAP_NEW_SIZE(byte_t,a_body_size);
- if (!l_ret->body) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(l_ret);
- return NULL;
- }
- memcpy(l_ret->body,a_body,a_body_size);
+ dap_http_cache_t * l_ret = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_http_cache_t, NULL);
+ if (a_body_size) {
+ l_ret->body = DAP_DUP_SIZE_RET_VAL_IF_FAIL(a_body, a_body_size, NULL, l_ret);
l_ret->body_size = a_body_size;
}
l_ret->headers = dap_http_headers_dup( a_headers);
-
-
l_ret->ts_expire = a_ts_expire;
l_ret->url_proc = a_url_proc;
if(a_response_phrase)
@@ -70,7 +58,6 @@ dap_http_cache_t * dap_http_cache_update(struct dap_http_url_proc * a_url_proc,
if(l_hdr_date)
dap_http_header_remove(&l_ret->headers,l_hdr_date);
-
// Reset current cache for url_proc and replace with our own
pthread_rwlock_wrlock(&a_url_proc->cache_rwlock);
dap_http_cache_delete(a_url_proc->cache);
diff --git a/net/server/http_server/http_client/dap_http_client.c b/net/server/http_server/http_client/dap_http_client.c
index a8db7e472e094d99ef3848227a4841ef16d8de98..a0f330ae7b968108c5e77a5cdc479b21a5142950 100644
--- a/net/server/http_server/http_client/dap_http_client.c
+++ b/net/server/http_server/http_client/dap_http_client.c
@@ -534,7 +534,6 @@ void dap_http_client_read( dap_events_socket_t *a_esocket, void *a_arg )
*/
void dap_http_client_write(dap_http_client_t *a_http_client)
{
- dap_http_header_t *hdr = a_http_client->out_headers;
if ( a_http_client->proc ) {
// We check out_headers because if they are - we send only cached headers and don't call headers_write_callback at all
if (!a_http_client->out_headers) {
@@ -554,11 +553,11 @@ void dap_http_client_write(dap_http_client_t *a_http_client)
a_http_client->reply_status_code, a_http_client->reply_reason_phrase[0] ?
a_http_client->reply_reason_phrase : http_status_reason_phrase(a_http_client->reply_status_code) );
/* Write HTTP headres */
- char l_buf[128];
+ char l_buf[32];
dap_time_to_str_rfc822( l_buf, sizeof(l_buf) - 1, time( NULL ) );
dap_http_header_add( &a_http_client->out_headers, "Date", l_buf );
- for ( hdr = a_http_client->out_headers; hdr; hdr = a_http_client->out_headers ) {
+ for ( dap_http_header_t *hdr = a_http_client->out_headers; hdr; hdr = a_http_client->out_headers ) {
a_http_client->esocket->buf_out_size += snprintf((char *) a_http_client->esocket->buf_out + a_http_client->esocket->buf_out_size,
a_http_client->esocket->buf_out_size_max - a_http_client->esocket->buf_out_size,
"%s: %s" CRLF, hdr->name, hdr->value);
diff --git a/net/server/http_server/http_client/dap_http_header.c b/net/server/http_server/http_client/dap_http_header.c
index dfbcb6b6b97191c6d7a0f1a5095ae52769b17fe7..8977514c563a587df9451647255b1bc717dde5f1 100644
--- a/net/server/http_server/http_client/dap_http_header.c
+++ b/net/server/http_server/http_client/dap_http_header.c
@@ -201,11 +201,7 @@ dap_http_header_t *l_new_header;
*/
inline dap_http_header_t *dap_http_header_add(dap_http_header_t **a_top, const char *a_name, const char *a_value)
{
- dap_http_header_t *l_new_header = DAP_NEW_Z(dap_http_header_t);
- if (!l_new_header) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
+ dap_http_header_t *l_new_header = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_http_header_t, NULL);
l_new_header->namesz = strnlen(a_name, DAP_HTTP$SZ_FIELD_NAME);
memcpy(l_new_header->name, a_name, l_new_header->namesz);
@@ -285,17 +281,10 @@ dap_http_header_t * dap_http_headers_dup(dap_http_header_t * a_top)
{
dap_http_header_t *l_hdr = NULL, *l_ret = NULL;
- DL_FOREACH(a_top,l_hdr){
- dap_http_header_t * l_hdr_copy = DAP_NEW_Z(dap_http_header_t);
- if (!l_hdr_copy) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return l_ret;
- }
-
+ DL_FOREACH(a_top, l_hdr) {
+ dap_http_header_t * l_hdr_copy = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_http_header_t, l_ret);
memcpy(l_hdr_copy->name, l_hdr->name, l_hdr_copy->namesz = l_hdr->namesz);
memcpy(l_hdr_copy->value, l_hdr->value, l_hdr_copy->valuesz = l_hdr->valuesz);
-
-
DL_APPEND(l_ret, l_hdr_copy);
}
diff --git a/net/server/json_rpc/rpc_core/src/dap_json_rpc_params.c b/net/server/json_rpc/rpc_core/src/dap_json_rpc_params.c
index 7af75a9aa230e4fad58b9026d47b70dd8e529119..65ceeaf436b54e7a73d9ff6d230d348b243ed351 100644
--- a/net/server/json_rpc/rpc_core/src/dap_json_rpc_params.c
+++ b/net/server/json_rpc/rpc_core/src/dap_json_rpc_params.c
@@ -18,63 +18,29 @@ dap_json_rpc_param_t* dap_json_rpc_create_param(void * data, dap_json_rpc_type_p
dap_json_rpc_params_t* dap_json_rpc_params_create(void)
{
- dap_json_rpc_params_t *params = DAP_NEW(dap_json_rpc_params_t);
-
- if (!params) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
-
- params->length = 0;
-
+ dap_json_rpc_params_t *params = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_json_rpc_params_t, NULL);
return params;
}
void dap_json_rpc_params_add_data(dap_json_rpc_params_t *a_params, const void *a_value,
dap_json_rpc_type_param_t a_type)
{
- dap_json_rpc_param_t *new_param = DAP_NEW(dap_json_rpc_param_t);
- if (!new_param) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return;
- }
-
+ dap_json_rpc_param_t *new_param = DAP_NEW_Z_RET_IF_FAIL(dap_json_rpc_param_t);
new_param->type = a_type;
size_t value_size;
switch (a_type) {
case TYPE_PARAM_STRING:
- new_param->value_param = dap_strdup((char *)a_value);
+ new_param->value_param = dap_strdup((char*)a_value);
break;
case TYPE_PARAM_BOOLEAN:
- value_size = sizeof(bool);
- new_param->value_param = DAP_NEW(bool);
- if (!new_param->value_param) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(new_param);
- return;
- }
- memcpy(new_param->value_param, a_value, value_size);
+ new_param->value_param = DAP_DUP((bool*)a_value);
break;
case TYPE_PARAM_INTEGER:
- value_size = sizeof(int64_t);
- new_param->value_param = DAP_NEW(int64_t);
- if (!new_param->value_param) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(new_param);
- return;
- }
- memcpy(new_param->value_param, a_value, value_size);
+ new_param->value_param = DAP_DUP((int64_t*)a_value);
break;
case TYPE_PARAM_DOUBLE:
- value_size = sizeof(double);
- new_param->value_param = DAP_NEW(double);
- if (!new_param->value_param) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- DAP_DEL_Z(new_param);
- return;
- }
- memcpy(new_param->value_param, a_value, value_size);
+ new_param->value_param = DAP_DUP((double*)a_value);
break;
default:
new_param->value_param = NULL;
@@ -85,25 +51,14 @@ void dap_json_rpc_params_add_data(dap_json_rpc_params_t *a_params, const void *a
void dap_json_rpc_params_add_param(dap_json_rpc_params_t *a_params, dap_json_rpc_param_t *a_param)
{
- uint32_t l_len_new_params = a_params->length + 1;
-
- dap_json_rpc_param_t **new_params = DAP_NEW_SIZE(dap_json_rpc_param_t*, l_len_new_params * sizeof(dap_json_rpc_param_t*));
-
- if(a_params->length && a_params->params)
- memcpy(new_params, a_params->params, sizeof(dap_json_rpc_param_t*) * a_params->length);
-
+ dap_json_rpc_param_t **new_params = DAP_REALLOC_COUNT_RET_IF_FAIL(a_params->params, a_params->length + 1);
new_params[a_params->length] = a_param;
-
- if (a_params->length != 0)
- DAP_FREE(a_params->params);
- a_params->params = new_params;
- a_params->length++;
+ ++a_params->length;
}
void dap_json_rpc_param_remove(dap_json_rpc_param_t *param)
{
- DAP_DEL_Z(param->value_param);
- DAP_DEL_Z(param);
+ DAP_DEL_MULTY(param->value_param, param);
}
void dap_json_rpc_params_remove_all(dap_json_rpc_params_t *a_params)
@@ -111,8 +66,7 @@ void dap_json_rpc_params_remove_all(dap_json_rpc_params_t *a_params)
for (uint32_t i=0x0 ; i < dap_json_rpc_params_length(a_params); i++){
dap_json_rpc_param_remove(a_params->params[i]);
}
- DAP_FREE(a_params->params);
- DAP_FREE(a_params);
+ DAP_DEL_MULTY(a_params->params, a_params);
}
uint32_t dap_json_rpc_params_length(dap_json_rpc_params_t *a_params)
@@ -122,16 +76,12 @@ uint32_t dap_json_rpc_params_length(dap_json_rpc_params_t *a_params)
void *dap_json_rpc_params_get(dap_json_rpc_params_t *a_params, uint32_t index)
{
- if (a_params->length > index)
- return a_params->params[index]->value_param;
- return NULL;
+ return a_params->length > index ? a_params->params[index]->value_param : NULL;
}
dap_json_rpc_type_param_t dap_json_rpc_params_get_type_param(dap_json_rpc_params_t *a_params, uint32_t index)
{
- if (a_params->length > index)
- return a_params->params[index]->type;
- return TYPE_PARAM_NULL;
+ return a_params->length > index ? a_params->params[index]->type : TYPE_PARAM_NULL;
}
dap_json_rpc_params_t * dap_json_rpc_params_create_from_array_list(json_object *a_array_list)
@@ -171,21 +121,16 @@ dap_json_rpc_params_t * dap_json_rpc_params_create_from_array_list(json_object *
dap_json_rpc_params_add_data(params, NULL, TYPE_PARAM_NULL);
}
}
- return params;
+ return params;
}
char *dap_json_rpc_params_get_string_json(dap_json_rpc_params_t * a_params)
{
- if (!a_params) {
- log_it(L_CRITICAL, "Invalid input parameters");
- return NULL;
- }
+ dap_return_val_if_fail(a_params, NULL);
json_object *jobj_array = json_object_new_array();
- if (!jobj_array) {
- log_it(L_CRITICAL, "Failed to create JSON array");
- return NULL;
- }
+ if (!jobj_array)
+ return log_it(L_CRITICAL, "Failed to create JSON array"), NULL;
for (uint32_t i = 0; i < a_params->length; i++){
json_object *jobj_tmp = NULL;
@@ -211,10 +156,9 @@ char *dap_json_rpc_params_get_string_json(dap_json_rpc_params_t * a_params)
json_object_put(jobj_array);
return NULL;
}
-
json_object_array_add(jobj_array, jobj_tmp);
};
- char *l_str = dap_strjoin(NULL, json_object_to_json_string(jobj_array), NULL);
+ char *l_str = dap_strdup( json_object_to_json_string(jobj_array) );
json_object_put(jobj_array);
return l_str;
}
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 39d1c320a64207209a3126b0a356a98720e71554..b7b4f95586ffa544cdcf8b5b3d67289f7d8635a4 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
@@ -28,12 +28,10 @@ enum ExecCmdRetCode {
int dap_json_rpc_request_init(const char *a_url_service)
{
- if (s_url_service == NULL)
- {
- s_url_service = dap_strdup(a_url_service);
- return 0;
- }
- return 1;
+ if (s_url_service)
+ return 1;
+ s_url_service = dap_strdup(a_url_service);
+ return 0;
}
static struct exec_cmd_request* s_exec_cmd_request_init(dap_client_pvt_t * a_client_pvt)
@@ -70,9 +68,7 @@ void s_exec_cmd_request_free(struct exec_cmd_request *a_exec_cmd_request)
pthread_mutex_destroy(&a_exec_cmd_request->wait_mutex);
pthread_cond_destroy(&a_exec_cmd_request->wait_cond);
#endif
- DAP_DELETE(a_exec_cmd_request->response); // line 73
- DAP_DELETE(a_exec_cmd_request);
-
+ DAP_DEL_MULTY(a_exec_cmd_request->response, a_exec_cmd_request);
}
static void s_exec_cmd_response_handler(void *a_response, size_t a_response_size, void *a_arg,
@@ -192,188 +188,108 @@ static int dap_chain_exec_cmd_list_wait(struct exec_cmd_request *a_exec_cmd_requ
char * dap_json_rpc_enc_request(dap_client_pvt_t* a_client_internal, char * a_request_data_str, size_t a_request_data_size,
char ** a_path, size_t * a_enc_request_size, char ** a_custom_header) {
- const char * l_sub_url = dap_strdup_printf("channels=%s,enc_type=%d,enc_key_size=%zu,enc_headers=%d",
- a_client_internal->client->active_channels,
- a_client_internal->session_key_type,
- a_client_internal->session_key_block_size, 0);
-
- bool is_query_enc = true;
- const char * a_query = "type=tcp,maxconn=4";
- size_t l_sub_url_size = l_sub_url ? strlen(l_sub_url) : 0;
- size_t l_query_size = a_query ? strlen(a_query) : 0;
-
- 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;
+ char s_query[] = "type=tcp,maxconn=4", s_suburl[128];
+ int l_query_len = sizeof(s_query) - 1,
+ l_suburl_len = snprintf(s_suburl, sizeof(s_suburl), "channels=%s,enc_type=%d,enc_key_size=%zu,enc_headers=%d",
+ a_client_internal->client->active_channels, a_client_internal->session_key_type,
+ a_client_internal->session_key_block_size, 0);
+ if (l_suburl_len >= (int)sizeof(s_suburl))
+ return NULL;
+ 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;
+ int l_suburl_enc_len = dap_enc_code_out_size(a_client_internal->session_key, l_suburl_len, l_enc_type),
+ l_query_enc_len = dap_enc_code_out_size(a_client_internal->session_key, l_query_len, l_enc_type),
+ l_req_enc_len = dap_enc_code_out_size(a_client_internal->session_key, a_request_data_size, DAP_ENC_DATA_TYPE_RAW);
- size_t l_request_enc_size_max = a_request_data_size ? a_request_data_size * 2 + 16 : 0;
- char * l_request_enc = a_request_data_size ? DAP_NEW_Z_SIZE(char, l_request_enc_size_max + 1) : NULL;
+ char l_suburl_enc[ l_suburl_enc_len + 1 ], l_query_enc[ l_query_enc_len + 1 ], *l_req_enc = DAP_NEW_Z_SIZE(char, l_req_enc_len + 1);
a_client_internal->is_encrypted = true;
- dap_enc_data_type_t l_enc_type;
+ l_suburl_enc_len = dap_enc_code(a_client_internal->session_key, s_suburl, l_suburl_len, l_suburl_enc, l_suburl_enc_len + 1, l_enc_type);
+ l_query_enc_len = dap_enc_code(a_client_internal->session_key, s_query, l_query_len, l_query_enc, l_query_enc_len + 1, l_enc_type);
+ *a_enc_request_size = dap_enc_code(a_client_internal->session_key, a_request_data_str,a_request_data_size,l_req_enc, l_req_enc_len + 1, DAP_ENC_DATA_TYPE_RAW);
- 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,
- l_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_data_size)
- *a_enc_request_size = dap_enc_code(a_client_internal->session_key,
- a_request_data_str, a_request_data_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;
- const char * path = "exec_cmd";
- *a_path = DAP_NEW_Z_SIZE(char, l_path_size);
- (*a_path)[0] = '\0';
- if(path) {
- if(l_sub_url_size){
- if(l_query_size){
- snprintf(*a_path, l_path_size, "%s/%s?%s", path?path:"",
- l_sub_url_enc?l_sub_url_enc:"",
- l_query_enc?l_query_enc:"");
- }else{
- snprintf(*a_path, l_path_size, "%s/%s", path, l_sub_url_enc);
- }
- } else {
- dap_stpcpy(*a_path, path);
- }
- }
+ l_suburl_enc[l_suburl_enc_len] = l_query_enc[l_query_enc_len] = '\0';
- size_t l_size_required = a_client_internal->session_key_id ? strlen(a_client_internal->session_key_id) + 40 : 40;
- *a_custom_header = DAP_NEW_Z_SIZE(char, l_size_required);
- size_t l_off = snprintf(*a_custom_header, 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(*a_custom_header + l_off, l_size_required - l_off, "%s\r\n", "SessionCloseAfterRequest: true");
-
- DAP_DEL_Z(l_sub_url_enc);
- DAP_DEL_Z(l_query_enc);
-
- return l_request_enc;
+ *a_path = dap_strdup_printf("exec_cmd/%s?%s", l_suburl_enc, l_query_enc);
+ *a_custom_header = 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" : "");
+ return l_req_enc;
}
dap_json_rpc_request_t *dap_json_rpc_request_creation(const char *a_method, dap_json_rpc_params_t *a_params, int64_t a_id)
{
- dap_json_rpc_request_t *request = DAP_NEW(dap_json_rpc_request_t);
- if (!request)
- {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- }
- request->method = dap_strdup(a_method);
- request->params = a_params;
- request->id = a_id;
+ dap_json_rpc_request_t *request = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_json_rpc_request_t, NULL);
+ *request = (dap_json_rpc_request_t) {
+ dap_strdup(a_method), a_params, a_id
+ };
return request;
}
void dap_json_rpc_request_free(dap_json_rpc_request_t *request)
{
- if (request)
- {
- DAP_DEL_Z(request->method);
- if (request->params)
- dap_json_rpc_params_remove_all(request->params);
- DAP_FREE(request);
- }
+ if (!request)
+ return;
+ DAP_DELETE(request->method);
+ if (request->params)
+ dap_json_rpc_params_remove_all(request->params);
+ DAP_DELETE(request);
}
dap_json_rpc_request_t *dap_json_rpc_request_from_json(const char *a_data)
{
if (!a_data)
return NULL;
+ dap_json_rpc_request_t *request = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_json_rpc_request_t, NULL);
enum json_tokener_error jterr;
- bool err_parse_request = false;
- json_object *jobj = json_tokener_parse_verbose(a_data, &jterr);
- json_object *jobj_id = NULL;
- json_object *jobj_method = NULL;
- json_object *jobj_params = NULL;
-
- dap_json_rpc_request_t *request = DAP_NEW_Z(dap_json_rpc_request_t);
- if (!request)
- {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return NULL;
- }
-
+ json_object *jobj = json_tokener_parse_verbose(a_data, &jterr),
+ *jobj_id = NULL,
+ *jobj_method = NULL,
+ *jobj_params = NULL;
if (jterr == json_tokener_success)
- {
- if (json_object_object_get_ex(jobj, "id", &jobj_id))
- {
- request->id = json_object_get_int64(jobj_id);
- }
- else
- {
- log_it(L_ERROR, "Error parse JSON string, Can't searching id request");
- err_parse_request = true;
- }
+ do {
+ if (json_object_object_get_ex(jobj, "id", &jobj_id))
+ request->id = json_object_get_int64(jobj_id);
+ else {
+ log_it(L_ERROR, "Error parse JSON string, can't find request id");
+ break;
+ }
- if (json_object_object_get_ex(jobj, "method", &jobj_method))
- {
- request->method = dap_strdup(json_object_get_string(jobj_method));
- }
- else
- {
- log_it(L_ERROR, "Error parse JSON string, Can't searching method for request with id: %" DAP_UINT64_FORMAT_U, request->id);
- err_parse_request = true;
- }
+ if (json_object_object_get_ex(jobj, "method", &jobj_method))
+ request->method = dap_strdup(json_object_get_string(jobj_method));
+ else {
+ log_it(L_ERROR, "Error parse JSON string, can't find method for request with id: %" DAP_UINT64_FORMAT_U, request->id);
+ break;
+ }
- if (json_object_object_get_ex(jobj, "params", &jobj_params) && !err_parse_request)
- {
- request->params = dap_json_rpc_params_create_from_array_list(jobj_params);
- }
- else
- {
- log_it(L_ERROR, "Error parse JSON string, Can't searching array params for request with id: %" DAP_UINT64_FORMAT_U, request->id);
- err_parse_request = true;
- }
- }
+ if (json_object_object_get_ex(jobj, "params", &jobj_params))
+ request->params = dap_json_rpc_params_create_from_array_list(jobj_params);
+ else {
+ log_it(L_ERROR, "Error parse JSON string, Can't find array params for request with id: %" DAP_UINT64_FORMAT_U, request->id);
+ break;
+ }
+ json_object_put(jobj);
+ return request;
+ } while (0);
else
- {
log_it(L_ERROR, "Error parse json tokener: %s", json_tokener_error_desc(jterr));
- err_parse_request = true;
- }
- if (err_parse_request)
- {
- DAP_FREE(request->method);
- DAP_FREE(request);
- json_object_put(jobj);
- return NULL;
- }
json_object_put(jobj);
- return request;
+ dap_json_rpc_params_remove_all(request->params);
+ DAP_DEL_MULTY(request->method, request);
+ return NULL;
}
char *dap_json_rpc_request_to_json_string(const dap_json_rpc_request_t *a_request)
{
char *params_json = dap_json_rpc_params_get_string_json(a_request->params);
if (!params_json)
- {
- log_it(L_CRITICAL, "Failed to generate JSON for params");
- return NULL;
- }
+ return log_it(L_ERROR, "Failed to generate JSON for params"), NULL;
char *l_str = dap_strdup_printf(
"{\"method\":\"%s\", \"params\":%s, \"id\":\"%" DAP_UINT64_FORMAT_U "\" }",
a_request->method, params_json, a_request->id);
-
- DAP_FREE(params_json);
+ DAP_DELETE(params_json);
return l_str;
}
@@ -381,74 +297,39 @@ char *dap_json_rpc_http_request_serialize(dap_json_rpc_http_request_t *a_request
{
*a_total_size = a_request->header.data_size + a_request->header.signs_size + sizeof(a_request->header);
- char *a_output = DAP_NEW_SIZE(char, *a_total_size);
- if (!a_output) {
- return NULL;
- }
-
- char *ptr = a_output;
-
- memcpy(ptr, &a_request->header, sizeof(a_request->header));
- ptr += sizeof(a_request->header);
+ char *a_output = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(char, *a_total_size, NULL),
+ *ptr = dap_mempcpy(a_output, &a_request->header, sizeof(a_request->header));
char *l_str = dap_json_rpc_request_to_json_string(a_request->request);
- if (!l_str) {
- DAP_DEL_Z(a_output);
- return NULL;
- }
-
- memcpy(ptr, l_str, a_request->header.data_size);
- ptr += a_request->header.data_size;
- DAP_DEL_Z(l_str);
+ if (!l_str)
+ return DAP_DELETE(a_output), NULL;
+ ptr = dap_mempcpy(ptr, l_str, a_request->header.data_size);
+ DAP_DELETE(l_str);
memcpy(ptr, a_request->tsd_n_signs, a_request->header.signs_size);
-
return a_output;
}
dap_json_rpc_http_request_t *dap_json_rpc_http_request_deserialize(const void *data, size_t data_size)
{
- char *ptr = (char *)data;
- dap_json_rpc_http_request_t *l_http_request = DAP_NEW_Z(dap_json_rpc_http_request_t);
- if (!l_http_request)
- return NULL;
-
- memcpy(&l_http_request->header, ptr, sizeof(l_http_request->header));
- ptr += sizeof(l_http_request->header);
-
- if (data_size < (sizeof(l_http_request->header) + l_http_request->header.data_size + l_http_request->header.signs_size)) {
- log_it(L_ERROR, "Wrong size of request");
- DAP_DEL_Z(l_http_request);
- return NULL;
- }
-
- char *l_request_str = DAP_NEW_Z_SIZE(char, l_http_request->header.data_size+1);
- if (!l_request_str) {
- DAP_DEL_Z(l_http_request);
- return NULL;
- }
-
- memcpy(l_request_str, ptr, l_http_request->header.data_size+1);
- l_request_str[l_http_request->header.data_size] = '\0';
- l_http_request->request = dap_json_rpc_request_from_json(l_request_str);
- DAP_DEL_Z(l_request_str);
-
- if (!l_http_request->request) {
- log_it(L_ERROR, "Can't parse request from string, length = %d", l_http_request->header.data_size);
- DAP_DEL_Z(l_http_request);
- return NULL;
- }
- ptr += l_http_request->header.data_size;
-
- if (l_http_request->header.signs_size > 0) {
- l_http_request = DAP_REALLOC(l_http_request, sizeof(dap_json_rpc_http_request_t) + l_http_request->header.signs_size);
- if (!l_http_request) {
- return NULL;
- }
- memcpy(l_http_request->tsd_n_signs, ptr, l_http_request->header.signs_size);
- }
-
- return l_http_request;
+ if (data_size < sizeof(dap_json_rpc_http_request_t))
+ return log_it(L_ERROR, "Data size is less than minimum: %zu < %zu",
+ data_size, sizeof(dap_json_rpc_http_request_t)),
+ NULL;
+ __typeof__( (dap_json_rpc_http_request_t){0}.header ) l_hdr;
+ memcpy(&l_hdr, data, sizeof(l_hdr));
+ if ( data_size < sizeof(dap_json_rpc_http_request_t) + l_hdr.data_size + l_hdr.signs_size )
+ return log_it(L_ERROR, "Data size is less than needed: %zu < %zu",
+ data_size, sizeof(dap_json_rpc_http_request_t) + l_hdr.data_size + l_hdr.signs_size),
+ NULL;
+
+ dap_json_rpc_http_request_t *l_ret
+ = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_json_rpc_http_request_t, sizeof(dap_json_rpc_http_request_t) + l_hdr.signs_size, NULL);
+ l_ret->header = l_hdr;
+ l_ret->request = dap_json_rpc_request_from_json((char*)data + sizeof(l_ret->header));
+ if (l_hdr.signs_size)
+ memcpy(l_ret->tsd_n_signs, (byte_t*)data + sizeof(l_hdr) + l_hdr.data_size, l_hdr.signs_size);
+ return l_ret;
}
void dap_json_rpc_http_request_free(dap_json_rpc_http_request_t *a_http_request)
@@ -456,54 +337,50 @@ void dap_json_rpc_http_request_free(dap_json_rpc_http_request_t *a_http_request)
if (!a_http_request)
return;
- if (a_http_request->request)
- dap_json_rpc_request_free(a_http_request->request);
-
- DAP_DEL_Z(a_http_request);
+ dap_json_rpc_request_free(a_http_request->request);
+ DAP_DELETE(a_http_request);
}
dap_json_rpc_http_request_t *dap_json_rpc_request_sign_by_cert(dap_json_rpc_request_t *a_request, dap_cert_t *a_cert)
{
char *l_str = dap_json_rpc_request_to_json_string(a_request);
- dap_sign_t *l_sign = dap_cert_sign(a_cert, l_str, sizeof(l_str), 0);
+ if (!l_str)
+ return log_it(L_ERROR, "Can't convert JSON-request to string!"), NULL;
+ int l_len = strlen(l_str);
+ dap_sign_t *l_sign = dap_cert_sign(a_cert, l_str, l_len, 0);
+ DAP_DELETE(l_str);
if (!l_sign)
- {
- log_it(L_ERROR, "Decree signing failed");
- DAP_DELETE(l_str);
- return NULL;
- }
- dap_json_rpc_http_request_t *ret = DAP_NEW_Z(dap_json_rpc_http_request_t);
+ return log_it(L_ERROR, "JSON request signing failed"), NULL;
size_t l_sign_size = dap_sign_get_size(l_sign);
- ret->request = a_request;
- ret->header.data_size = strlen(l_str);
- ret->header.signs_size = l_sign_size;
- if (ret->header.signs_size >0) {
- ret = DAP_REALLOC(ret, sizeof(dap_json_rpc_http_request_t) + ret->header.signs_size);
- memcpy(ret->tsd_n_signs, l_sign, l_sign_size);
- }
- DAP_DELETE(l_str);
- DAP_DELETE(l_sign);
- return ret;
+
+ dap_json_rpc_http_request_t *l_ret
+ = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(dap_json_rpc_http_request_t, sizeof(dap_json_rpc_http_request_t) + l_sign_size, NULL, l_sign);
+ *l_ret = (dap_json_rpc_http_request_t) {
+ .header.data_size = l_len + 1,
+ .header.signs_size = l_sign_size,
+ .request = a_request
+ };
+ memcpy(l_ret->tsd_n_signs, l_sign, l_sign_size);
+ return DAP_DELETE(l_sign), l_ret;
}
char* dap_json_rpc_request_to_http_str(dap_json_rpc_request_t *a_request, size_t*output_data_size){
a_request->id = 0;
dap_cert_t *l_cert = dap_cert_find_by_name("node-addr");
- if (!l_cert) {
- log_it(L_ERROR, "Can't load cert");
- return NULL;
- }
+ if (!l_cert)
+ return log_it(L_ERROR, "Can't load cert"), NULL;
+
dap_json_rpc_http_request_t *l_http_request = dap_json_rpc_request_sign_by_cert(a_request, l_cert);
size_t l_http_length = 0;
char *l_http_str = dap_json_rpc_http_request_serialize(l_http_request, output_data_size);
- return l_http_str;
+ return DAP_DELETE(l_http_request), l_http_str;
}
int dap_json_rpc_request_send(dap_client_pvt_t* a_client_internal, dap_json_rpc_request_t *a_request, json_object** a_response) {
- size_t l_request_data_size = 0, l_enc_request_size, l_response_size;
+ size_t l_request_data_size, l_enc_request_size, l_response_size;
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);
+ char* l_request_data_str = dap_json_rpc_request_to_http_str(a_request, &l_request_data_size);
if (!l_request_data_str)
return -1;
@@ -519,22 +396,21 @@ int dap_json_rpc_request_send(dap_client_pvt_t* a_client_internal, dap_json_rpc
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);
- 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,
- "POST", "application/json",
- l_path, l_enc_request, l_enc_request_size, NULL,
- s_exec_cmd_response_handler, s_exec_cmd_error_handler,
- l_exec_cmd_request, l_custom_header);
+ 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,
+ "POST", "application/json",
+ l_path, l_enc_request, l_enc_request_size, NULL,
+ s_exec_cmd_response_handler, s_exec_cmd_error_handler,
+ l_exec_cmd_request, l_custom_header);
int l_ret = dap_chain_exec_cmd_list_wait(l_exec_cmd_request, 15000);
switch (l_ret) {
case EXEC_CMD_OK :{
if (s_exec_cmd_request_get_response(l_exec_cmd_request, a_response, &l_response_size)) {
- char * l_err = dap_strdup_printf("Response error code: %d", l_exec_cmd_request->error_code);
+ char l_err[40] = "";
+ snprintf(l_err, sizeof(l_err), "Response error code: %d", l_exec_cmd_request->error_code);
*a_response = json_object_new_string(l_err);
- DAP_DEL_Z(l_err);
break;
}
log_it(L_DEBUG, "Get response from %s:%d, response size = %lu",
@@ -554,11 +430,7 @@ int dap_json_rpc_request_send(dap_client_pvt_t* a_client_internal, dap_json_rpc
break;
}
}
-
s_exec_cmd_request_free(l_exec_cmd_request);
-
- DAP_DEL_Z(l_custom_header);
- DAP_DEL_Z(l_path);
- DAP_DEL_Z(l_enc_request);
+ DAP_DEL_MULTY(l_custom_header, l_path, l_enc_request);
return l_ret;
}
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 ab521f7dbc2b416015872b23610c952b1587b1e4..225f66f1174f16be4aba34afe2f8c49be41c58c8 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
@@ -3,37 +3,30 @@
#define LOG_TAG "dap_json_rpc_response_handler"
static dap_json_rpc_response_handler_t *s_response_handlers = NULL;
-static uint64_t s_delta = 0;
+static _Atomic(uint64_t) s_delta = 0;
int dap_json_rpc_response_registration_with_id(uint64_t a_id, dap_json_rpc_response_handler_func_t *func)
{
dap_json_rpc_response_handler_t *l_handler = NULL;
HASH_FIND_INT(s_response_handlers, &a_id, l_handler);
- if (l_handler == NULL){
- l_handler = DAP_NEW(dap_json_rpc_response_handler_t);
- if (!l_handler) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return -1;
- }
- l_handler->id = a_id;
- l_handler->func = func;
- HASH_ADD_INT(s_response_handlers, id, l_handler);
- log_it(L_NOTICE, "Registration handler response with id: %"DAP_UINT64_FORMAT_U, a_id);
- return 0;
- }
- return 1;
+ if (l_handler)
+ return 1;
+ l_handler = DAP_NEW_Z_RET_VAL_IF_FAIL(dap_json_rpc_response_handler_t, -1);
+ l_handler->id = a_id;
+ l_handler->func = func;
+ HASH_ADD_INT(s_response_handlers, id, l_handler);
+ log_it(L_NOTICE, "Registration handler response with id: %"DAP_UINT64_FORMAT_U, a_id);
+ return 0;
}
uint64_t dap_json_rpc_response_registration(dap_json_rpc_response_handler_func_t *func)
{
- uint64_t l_id_registration_response = dap_json_rpc_response_get_new_id();
- int res = dap_json_rpc_response_registration_with_id(l_id_registration_response, func);
- return res;
+ return dap_json_rpc_response_registration_with_id(dap_json_rpc_response_get_new_id(), func);
}
void dap_json_rpc_response_unregistration(uint64_t a_id)
{
dap_json_rpc_response_handler_t *l_handler = NULL;
HASH_FIND_INT(s_response_handlers, &a_id, l_handler);
- if (l_handler != NULL){
+ if (l_handler) {
HASH_DEL(s_response_handlers, l_handler);
DAP_FREE(l_handler);
log_it(L_NOTICE, "Unregistration handler response with id: %"DAP_UINT64_FORMAT_U, a_id);
@@ -73,9 +66,7 @@ void dap_json_rpc_response_handler(dap_json_rpc_response_t *a_response)
uint64_t dap_json_rpc_response_get_new_id(void)
{
- uint64_t l_ret = s_delta;
- s_delta++;
- return l_ret;
+ return ++s_delta;
}
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)
@@ -93,4 +84,4 @@ void dap_json_rpc_response_accepted(void *a_data, size_t a_size_data, UNUSED_ARG
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/notify_server/src/dap_notify_srv.c b/net/server/notify_server/src/dap_notify_srv.c
index 30728be945c44394d5631ecf13dd6c78efd4d0b8..832fe3db7f7b9f5ee209331927b40f204411527b 100644
--- a/net/server/notify_server/src/dap_notify_srv.c
+++ b/net/server/notify_server/src/dap_notify_srv.c
@@ -217,7 +217,7 @@ static void s_notify_server_callback_queue(dap_events_socket_t * a_es, void * a_
#ifdef DAP_EVENTS_CAPS_IOCP
a_arg;
#else
- DAP_DUP_SIZE(a_arg, l_str_len + 1);
+ DAP_DUP_SIZE((char*)a_arg, l_str_len + 1);
#endif
dap_events_socket_write_mt( dap_events_worker_get(l_worker_id),
diff --git a/net/stream/stream/dap_stream_pkt.c b/net/stream/stream/dap_stream_pkt.c
index f92a12da5c7d8e8a7050fdd789ed10a95418262f..db5a9197eeb4abe233196df227db0887715df7a7 100644
--- a/net/stream/stream/dap_stream_pkt.c
+++ b/net/stream/stream/dap_stream_pkt.c
@@ -91,7 +91,7 @@ size_t dap_stream_pkt_write_mt(dap_worker_t * a_w,dap_events_socket_uuid_t a_es_
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 = 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);
+ l_msg->data = DAP_NEW_Z_SIZE_RET_VAL_IF_FAIL(byte_t, 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,