From 9812e3d3ba40a3bb40ccf8289af00a6c0c94f282 Mon Sep 17 00:00:00 2001 From: "xiang.zhou" Date: Mon, 19 May 2025 15:49:44 +0800 Subject: [PATCH] refactor the array type --- .github/workflows/check.yml | 11 +-- include/neuron/msg.h | 9 ++ include/neuron/plugin.h | 1 + include/neuron/type.h | 57 +++++++----- plugins/ekuiper/read_write.c | 21 +++-- plugins/mqtt/mqtt_handle.c | 29 +++--- plugins/restful/rw_handle.c | 110 ++++++++++++----------- src/adapter/driver/cache.c | 78 +++++++++++++++- src/adapter/driver/driver.c | 168 ++++++++++++++++++++--------------- 9 files changed, 311 insertions(+), 173 deletions(-) diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index b898a6ad..2bd57d84 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -9,7 +9,7 @@ on: jobs: clang_format_check: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: # checkout @@ -26,7 +26,8 @@ jobs: clangFormatVersion: 10 cppcheck: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 + container: ghcr.io/neugates/build:x86_64-v2.10 steps: - uses: actions/checkout@v4 @@ -35,12 +36,12 @@ jobs: - name: cppcheck run: | - sudo apt install cppcheck + sudo apt install -y cppcheck cppcheck --enable=all --error-exitcode=2 --inline-suppr --suppress=missingInclude --suppress=unusedFunction --suppress=*:src/otel/trace.pb-c.c --suppress=*:src/otel/common.pb-c.c --suppress=*:src/otel/resource.pb-c.c ./plugins ./src cppcheck --enable=all --error-exitcode=2 --inline-suppr --suppress=missingInclude --suppress=variableScope ./simulator ut: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 container: ghcr.io/neugates/build:x86_64-v2.10 steps: @@ -61,7 +62,7 @@ jobs: ctest --output-on-failure pft: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 container: ghcr.io/neugates/build:x86_64-v2.10 strategy: matrix: diff --git a/include/neuron/msg.h b/include/neuron/msg.h index e13e95ce..b42f9c7d 100644 --- a/include/neuron/msg.h +++ b/include/neuron/msg.h @@ -772,6 +772,9 @@ static inline void neu_resp_read_free(neu_resp_read_group_t *resp) { if (tag_value->value.type == NEU_TYPE_PTR) { free(tag_value->value.value.ptr.ptr); + } else if (NEU_TYPE_ARRAY_CHAR < tag_value->value.type && + tag_value->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(tag_value->value.value.bools.bools); } } free(resp->driver); @@ -786,6 +789,9 @@ neu_resp_read_paginate_free(neu_resp_read_group_paginate_t *resp) { if (tag_value->value.type == NEU_TYPE_PTR) { free(tag_value->value.value.ptr.ptr); + } else if (NEU_TYPE_ARRAY_CHAR < tag_value->value.type && + tag_value->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(tag_value->value.value.bools.bools); } } free(resp->driver); @@ -854,6 +860,9 @@ static inline void neu_trans_data_free(neu_reqresp_trans_data_t *data) { if (tag_value->value.type == NEU_TYPE_PTR) { free(tag_value->value.value.ptr.ptr); + } else if (NEU_TYPE_ARRAY_CHAR < tag_value->value.type && + tag_value->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(tag_value->value.value.bools.bools); } } utarray_free(data->tags); diff --git a/include/neuron/plugin.h b/include/neuron/plugin.h index 188cce56..aaa55d59 100644 --- a/include/neuron/plugin.h +++ b/include/neuron/plugin.h @@ -77,6 +77,7 @@ typedef int (*neu_plugin_tag_validator_t)(const neu_datatag_t *tag); typedef struct { neu_datatag_t *tag; neu_value_u value; + neu_type_e type; } neu_plugin_tag_value_t; typedef struct neu_plugin_intf_funs { diff --git a/include/neuron/type.h b/include/neuron/type.h index 6ef75713..4d268479 100644 --- a/include/neuron/type.h +++ b/include/neuron/type.h @@ -29,6 +29,7 @@ extern "C" { #include #include #include +#include typedef enum { NEU_TYPE_INT8 = 1, @@ -154,58 +155,58 @@ typedef struct { } neu_value_bytes_t; typedef struct { - int8_t i8s[NEU_VALUE_SIZE]; - uint8_t length; + int8_t * i8s; + uint32_t length; } neu_value_array_int8_t; typedef struct { - uint8_t u8s[NEU_VALUE_SIZE]; - uint8_t length; + uint8_t *u8s; + uint32_t length; } neu_value_array_uint8_t; typedef struct { - int16_t i16s[NEU_VALUE_SIZE]; - uint8_t length; + int16_t *i16s; + uint32_t length; } neu_value_array_int16_t; typedef struct { - uint16_t u16s[NEU_VALUE_SIZE]; - uint8_t length; + uint16_t *u16s; + uint32_t length; } neu_value_array_uint16_t; typedef struct { - int32_t i32s[NEU_VALUE_SIZE]; - uint8_t length; + int32_t *i32s; + uint32_t length; } neu_value_array_int32_t; typedef struct { - uint32_t u32s[NEU_VALUE_SIZE]; - uint8_t length; + uint32_t *u32s; + uint32_t length; } neu_value_array_uint32_t; typedef struct { - int64_t i64s[NEU_VALUE_SIZE]; - uint8_t length; + int64_t *i64s; + uint32_t length; } neu_value_array_int64_t; typedef struct { - uint64_t u64s[NEU_VALUE_SIZE]; - uint8_t length; + uint64_t *u64s; + uint32_t length; } neu_value_array_uint64_t; typedef struct { - float f32s[NEU_VALUE_SIZE]; - uint8_t length; + float * f32s; + uint32_t length; } neu_value_array_float_t; typedef struct { - double f64s[NEU_VALUE_SIZE]; - uint8_t length; + double * f64s; + uint32_t length; } neu_value_array_double_t; typedef struct { - bool bools[NEU_VALUE_SIZE]; - uint8_t length; + bool * bools; + uint32_t length; } neu_value_array_bool_t; typedef union { @@ -316,6 +317,18 @@ typedef struct { neu_value_u value; uint8_t precision; } neu_dvalue_t; + +static inline void neu_free_dvalue(neu_dvalue_t *dvalue) +{ + if (dvalue->type > NEU_TYPE_ARRAY_CHAR && + dvalue->type <= NEU_TYPE_ARRAY_BOOL) { + if (dvalue->value.bools.bools != NULL) { + free(dvalue->value.bools.bools); + dvalue->value.bools.bools = NULL; + } + } +} + typedef union neu_value8 { uint8_t value; struct { diff --git a/plugins/ekuiper/read_write.c b/plugins/ekuiper/read_write.c index 4ddced85..ee99ef0f 100644 --- a/plugins/ekuiper/read_write.c +++ b/plugins/ekuiper/read_write.c @@ -272,23 +272,26 @@ static int json_value_to_tag_value(union neu_json_value *req, case NEU_JSON_ARRAY_BOOL: value->type = NEU_TYPE_ARRAY_BOOL; value->value.bools.length = req->val_array_bool.length; - for (int i = 0; i < req->val_array_bool.length; i++) { - value->value.bools.bools[i] = req->val_array_bool.bools[i]; - } + value->value.bools.bools = + calloc(req->val_array_bool.length, sizeof(bool)); + memcpy(value->value.bools.bools, req->val_array_bool.bools, + sizeof(bool) * req->val_array_bool.length); break; case NEU_JSON_ARRAY_INT64: value->type = NEU_TYPE_ARRAY_INT64; value->value.i64s.length = req->val_array_int64.length; - for (int i = 0; i < req->val_array_int64.length; i++) { - value->value.i64s.i64s[i] = req->val_array_int64.i64s[i]; - } + value->value.i64s.i64s = + calloc(req->val_array_int64.length, sizeof(int64_t)); + memcpy(value->value.i64s.i64s, req->val_array_int64.i64s, + sizeof(int64_t) * req->val_array_int64.length); break; case NEU_JSON_ARRAY_DOUBLE: value->type = NEU_TYPE_ARRAY_DOUBLE; value->value.f64s.length = req->val_array_double.length; - for (int i = 0; i < req->val_array_double.length; i++) { - value->value.f64s.f64s[i] = req->val_array_double.f64s[i]; - } + value->value.f64s.f64s = + calloc(req->val_array_double.length, sizeof(double)); + memcpy(value->value.f64s.f64s, req->val_array_double.f64s, + sizeof(double) * req->val_array_double.length); break; default: return -1; diff --git a/plugins/mqtt/mqtt_handle.c b/plugins/mqtt/mqtt_handle.c index 07311ba3..fcd9976f 100644 --- a/plugins/mqtt/mqtt_handle.c +++ b/plugins/mqtt/mqtt_handle.c @@ -232,23 +232,26 @@ static int json_value_to_tag_value(union neu_json_value *req, case NEU_JSON_ARRAY_BOOL: value->type = NEU_TYPE_ARRAY_BOOL; value->value.bools.length = req->val_array_bool.length; - for (int i = 0; i < req->val_array_bool.length; i++) { - value->value.bools.bools[i] = req->val_array_bool.bools[i]; - } - break; - case NEU_JSON_ARRAY_DOUBLE: - value->type = NEU_TYPE_ARRAY_DOUBLE; - value->value.f64s.length = req->val_array_double.length; - for (int i = 0; i < req->val_array_double.length; i++) { - value->value.f64s.f64s[i] = req->val_array_double.f64s[i]; - } + value->value.bools.bools = + calloc(req->val_array_bool.length, sizeof(bool)); + memcpy(value->value.bools.bools, req->val_array_bool.bools, + sizeof(bool) * req->val_array_bool.length); break; case NEU_JSON_ARRAY_INT64: value->type = NEU_TYPE_ARRAY_INT64; value->value.i64s.length = req->val_array_int64.length; - for (int i = 0; i < req->val_array_int64.length; i++) { - value->value.i64s.i64s[i] = req->val_array_int64.i64s[i]; - } + value->value.i64s.i64s = + calloc(req->val_array_int64.length, sizeof(int64_t)); + memcpy(value->value.i64s.i64s, req->val_array_int64.i64s, + sizeof(int64_t) * req->val_array_int64.length); + break; + case NEU_JSON_ARRAY_DOUBLE: + value->type = NEU_TYPE_ARRAY_DOUBLE; + value->value.f64s.length = req->val_array_double.length; + value->value.f64s.f64s = + calloc(req->val_array_double.length, sizeof(double)); + memcpy(value->value.f64s.f64s, req->val_array_double.f64s, + sizeof(double) * req->val_array_double.length); break; default: return -1; diff --git a/plugins/restful/rw_handle.c b/plugins/restful/rw_handle.c index 364225c0..ad97bde0 100644 --- a/plugins/restful/rw_handle.c +++ b/plugins/restful/rw_handle.c @@ -283,21 +283,6 @@ void handle_write(nng_aio *aio) return; } - if (req->t == NEU_JSON_ARRAY_INT64 && - req->value.val_array_int64.length > 128) { - NEU_JSON_RESPONSE_ERROR(NEU_ERR_STRING_TOO_LONG, { - neu_http_response(aio, NEU_ERR_STRING_TOO_LONG, - result_error); - }); - if (neu_otel_control_is_started() && trace_flag) { - neu_otel_scope_set_status_code2( - scope, NEU_OTEL_STATUS_ERROR, NEU_ERR_STRING_TOO_LONG); - neu_otel_scope_set_span_end_time(scope, neu_time_ns()); - neu_otel_trace_set_final(trace); - } - return; - } - if (req->node && strlen(req->node) >= NEU_NODE_NAME_LEN) { err_type = NEU_ERR_NODE_NAME_TOO_LONG; goto error; @@ -341,7 +326,9 @@ void handle_write(nng_aio *aio) case NEU_JSON_ARRAY_INT64: cmd.value.type = NEU_TYPE_ARRAY_INT64; cmd.value.value.i64s.length = req->value.val_array_int64.length; - for (int i = 0; i < req->value.val_array_int64.length; i++) { + cmd.value.value.i64s.i64s = + calloc(req->value.val_array_int64.length, sizeof(int64_t)); + for (size_t i = 0; i < req->value.val_array_int64.length; i++) { cmd.value.value.i64s.i64s[i] = req->value.val_array_int64.i64s[i]; } @@ -350,7 +337,10 @@ void handle_write(nng_aio *aio) cmd.value.type = NEU_TYPE_ARRAY_DOUBLE; cmd.value.value.f64s.length = req->value.val_array_double.length; - for (int i = 0; i < req->value.val_array_double.length; i++) { + cmd.value.value.f64s.f64s = + calloc(req->value.val_array_double.length, sizeof(double)); + for (size_t i = 0; i < req->value.val_array_double.length; + i++) { cmd.value.value.f64s.f64s[i] = req->value.val_array_double.f64s[i]; } @@ -358,7 +348,9 @@ void handle_write(nng_aio *aio) case NEU_JSON_ARRAY_BOOL: cmd.value.type = NEU_TYPE_ARRAY_BOOL; cmd.value.value.bools.length = req->value.val_array_bool.length; - for (int i = 0; i < req->value.val_array_bool.length; i++) { + cmd.value.value.bools.bools = + calloc(req->value.val_array_bool.length, sizeof(bool)); + for (size_t i = 0; i < req->value.val_array_bool.length; i++) { cmd.value.value.bools.bools[i] = req->value.val_array_bool.bools[i]; } @@ -534,31 +526,36 @@ void handle_write_tags(nng_aio *aio) cmd.tags[i].value.type = NEU_TYPE_ARRAY_INT64; cmd.tags[i].value.value.i64s.length = req->tags[i].value.val_array_int64.length; - for (int k = 0; - k < req->tags[i].value.val_array_int64.length; k++) { - cmd.tags[i].value.value.i64s.i64s[k] = - req->tags[i].value.val_array_int64.i64s[k]; - } + cmd.tags[i].value.value.i64s.i64s = + calloc(req->tags[i].value.val_array_int64.length, + sizeof(int64_t)); + memcpy(cmd.tags[i].value.value.i64s.i64s, + req->tags[i].value.val_array_int64.i64s, + sizeof(int64_t) * + req->tags[i].value.val_array_int64.length); break; case NEU_JSON_ARRAY_DOUBLE: cmd.tags[i].value.type = NEU_TYPE_ARRAY_DOUBLE; cmd.tags[i].value.value.f64s.length = req->tags[i].value.val_array_double.length; - for (int k = 0; - k < req->tags[i].value.val_array_double.length; k++) { - cmd.tags[i].value.value.f64s.f64s[k] = - req->tags[i].value.val_array_double.f64s[k]; - } + cmd.tags[i].value.value.f64s.f64s = + calloc(req->tags[i].value.val_array_double.length, + sizeof(double)); + memcpy(cmd.tags[i].value.value.f64s.f64s, + req->tags[i].value.val_array_double.f64s, + sizeof(double) * + req->tags[i].value.val_array_double.length); break; case NEU_JSON_ARRAY_BOOL: cmd.tags[i].value.type = NEU_TYPE_ARRAY_BOOL; cmd.tags[i].value.value.bools.length = req->tags[i].value.val_array_bool.length; - for (int k = 0; - k < req->tags[i].value.val_array_bool.length; k++) { - cmd.tags[i].value.value.bools.bools[k] = - req->tags[i].value.val_array_bool.bools[k]; - } + cmd.tags[i].value.value.bools.bools = calloc( + req->tags[i].value.val_array_bool.length, sizeof(bool)); + memcpy(cmd.tags[i].value.value.bools.bools, + req->tags[i].value.val_array_bool.bools, + sizeof(bool) * + req->tags[i].value.val_array_bool.length); break; default: assert(false); @@ -642,34 +639,45 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd) cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_INT64; cmd->groups[i].tags[k].value.value.i64s.length = req->groups[i].tags[k].value.val_array_int64.length; - for (int j = 0; - j < req->groups[i].tags[k].value.val_array_int64.length; - j++) { - cmd->groups[i].tags[k].value.value.i64s.i64s[j] = - req->groups[i].tags[k].value.val_array_int64.i64s[j]; - } + + cmd->groups[i].tags[k].value.value.i64s.i64s = + calloc(sizeof(int64_t), + req->groups[i].tags[k].value.val_array_int64.length); + + memcpy(cmd->groups[i].tags[k].value.value.i64s.i64s, + req->groups[i].tags[k].value.val_array_int64.i64s, + sizeof(int64_t) * + req->groups[i].tags[k].value.val_array_int64.length); + break; case NEU_JSON_ARRAY_DOUBLE: cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_DOUBLE; cmd->groups[i].tags[k].value.value.f64s.length = req->groups[i].tags[k].value.val_array_double.length; - for (int j = 0; - j < req->groups[i].tags[k].value.val_array_double.length; - j++) { - cmd->groups[i].tags[k].value.value.f64s.f64s[j] = - req->groups[i].tags[k].value.val_array_double.f64s[j]; - } + + cmd->groups[i].tags[k].value.value.f64s.f64s = calloc( + sizeof(double), + req->groups[i].tags[k].value.val_array_double.length); + memcpy( + cmd->groups[i].tags[k].value.value.f64s.f64s, + req->groups[i].tags[k].value.val_array_double.f64s, + sizeof(double) * + req->groups[i].tags[k].value.val_array_double.length); + break; case NEU_JSON_ARRAY_BOOL: cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_BOOL; cmd->groups[i].tags[k].value.value.bools.length = req->groups[i].tags[k].value.val_array_bool.length; - for (int j = 0; - j < req->groups[i].tags[k].value.val_array_bool.length; - j++) { - cmd->groups[i].tags[k].value.value.bools.bools[j] = - req->groups[i].tags[k].value.val_array_bool.bools[j]; - } + + cmd->groups[i].tags[k].value.value.bools.bools = + calloc(sizeof(bool), + req->groups[i].tags[k].value.val_array_bool.length); + memcpy(cmd->groups[i].tags[k].value.value.bools.bools, + req->groups[i].tags[k].value.val_array_bool.bools, + sizeof(bool) * + req->groups[i].tags[k].value.val_array_bool.length); + break; default: assert(false); diff --git a/src/adapter/driver/cache.c b/src/adapter/driver/cache.c index 7ad9a455..bdb7461b 100644 --- a/src/adapter/driver/cache.c +++ b/src/adapter/driver/cache.c @@ -97,6 +97,9 @@ void neu_driver_cache_destroy(neu_driver_cache_t *cache) free(elem->value.value.ptr.ptr); elem->value.value.ptr.ptr = NULL; } + } else if (NEU_TYPE_ARRAY_CHAR < elem->value.type && + elem->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(elem->value.value.bools.bools); } free(elem); } @@ -638,8 +641,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache, elem->changed = true; } - elem->value.type = value.type; - if (elem->value.type == NEU_TYPE_PTR) { + if (value.type == NEU_TYPE_PTR) { elem->value.value.ptr.length = value.value.ptr.length; elem->value.value.ptr.type = value.value.ptr.type; if (elem->value.value.ptr.ptr != NULL) { @@ -648,9 +650,34 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache, elem->value.value.ptr.ptr = calloc(1, value.value.ptr.length); memcpy(elem->value.value.ptr.ptr, value.value.ptr.ptr, value.value.ptr.length); + } else if (NEU_TYPE_ARRAY_CHAR < value.type && + value.type <= NEU_TYPE_ARRAY_BOOL) { + if (NEU_TYPE_ARRAY_CHAR < elem->value.type && + elem->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(elem->value.value.bools.bools); + } + elem->value.value.bools.length = value.value.bools.length; + elem->value.value.bools.bools = value.value.bools.bools; + } else if (value.type == NEU_TYPE_ERROR) { + + if (elem->value.type == NEU_TYPE_PTR) { + if (elem->value.value.ptr.ptr != NULL) { + free(elem->value.value.ptr.ptr); + elem->value.value.ptr.ptr = NULL; + } + } + + if (NEU_TYPE_ARRAY_CHAR < elem->value.type && + elem->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(elem->value.value.bools.bools); + elem->value.value.bools.bools = NULL; + } + + elem->value.value = value.value; } else { elem->value.value = value.value; } + elem->value.type = value.type; memset(elem->metas, 0, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE); for (int i = 0; i < n_meta; i++) { @@ -731,57 +758,79 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group, break; case NEU_TYPE_ARRAY_BOOL: value->value.value.bools.length = elem->value.value.bools.length; + value->value.value.bools.bools = + calloc(elem->value.value.bools.length, sizeof(bool)); memcpy(value->value.value.bools.bools, elem->value.value.bools.bools, elem->value.value.bools.length); break; case NEU_TYPE_ARRAY_INT8: value->value.value.i8s.length = elem->value.value.i8s.length; + value->value.value.i8s.i8s = + calloc(elem->value.value.i8s.length, sizeof(int8_t)); memcpy(value->value.value.i8s.i8s, elem->value.value.i8s.i8s, elem->value.value.i8s.length); break; case NEU_TYPE_ARRAY_UINT8: value->value.value.u8s.length = elem->value.value.u8s.length; + value->value.value.u8s.u8s = + calloc(elem->value.value.u8s.length, sizeof(uint8_t)); memcpy(value->value.value.u8s.u8s, elem->value.value.u8s.u8s, elem->value.value.u8s.length); break; case NEU_TYPE_ARRAY_INT16: value->value.value.i16s.length = elem->value.value.i16s.length; + value->value.value.i16s.i16s = + calloc(elem->value.value.i16s.length, sizeof(int16_t)); memcpy(value->value.value.i16s.i16s, elem->value.value.i16s.i16s, elem->value.value.i16s.length * sizeof(int16_t)); break; case NEU_TYPE_ARRAY_UINT16: value->value.value.u16s.length = elem->value.value.u16s.length; + value->value.value.u16s.u16s = + calloc(elem->value.value.u16s.length, sizeof(uint16_t)); memcpy(value->value.value.u16s.u16s, elem->value.value.u16s.u16s, elem->value.value.u16s.length * sizeof(uint16_t)); break; case NEU_TYPE_ARRAY_INT32: value->value.value.i32s.length = elem->value.value.i32s.length; + value->value.value.i32s.i32s = + calloc(elem->value.value.i32s.length, sizeof(int32_t)); memcpy(value->value.value.i32s.i32s, elem->value.value.i32s.i32s, elem->value.value.i32s.length * sizeof(int32_t)); break; case NEU_TYPE_ARRAY_UINT32: value->value.value.u32s.length = elem->value.value.u32s.length; + value->value.value.u32s.u32s = + calloc(elem->value.value.u32s.length, sizeof(uint32_t)); memcpy(value->value.value.u32s.u32s, elem->value.value.u32s.u32s, elem->value.value.u32s.length * sizeof(uint32_t)); break; case NEU_TYPE_ARRAY_INT64: value->value.value.i64s.length = elem->value.value.i64s.length; + value->value.value.i64s.i64s = + calloc(elem->value.value.i64s.length, sizeof(int64_t)); memcpy(value->value.value.i64s.i64s, elem->value.value.i64s.i64s, elem->value.value.i64s.length * sizeof(int64_t)); break; case NEU_TYPE_ARRAY_UINT64: value->value.value.u64s.length = elem->value.value.u64s.length; + value->value.value.u64s.u64s = + calloc(elem->value.value.u64s.length, sizeof(uint64_t)); memcpy(value->value.value.u64s.u64s, elem->value.value.u64s.u64s, elem->value.value.u64s.length * sizeof(uint64_t)); break; case NEU_TYPE_ARRAY_FLOAT: value->value.value.f32s.length = elem->value.value.f32s.length; + value->value.value.f32s.f32s = + calloc(elem->value.value.f32s.length, sizeof(float)); memcpy(value->value.value.f32s.f32s, elem->value.value.f32s.f32s, elem->value.value.f32s.length * sizeof(float)); break; case NEU_TYPE_ARRAY_DOUBLE: value->value.value.f64s.length = elem->value.value.f64s.length; + value->value.value.f64s.f64s = + calloc(elem->value.value.f64s.length, sizeof(double)); memcpy(value->value.value.f64s.f64s, elem->value.value.f64s.f64s, elem->value.value.f64s.length * sizeof(double)); break; @@ -872,57 +921,79 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache, break; case NEU_TYPE_ARRAY_BOOL: value->value.value.bools.length = elem->value.value.bools.length; + value->value.value.bools.bools = + calloc(elem->value.value.bools.length, sizeof(bool)); memcpy(value->value.value.bools.bools, elem->value.value.bools.bools, elem->value.value.bools.length); break; case NEU_TYPE_ARRAY_INT8: value->value.value.i8s.length = elem->value.value.i8s.length; + value->value.value.i8s.i8s = + calloc(elem->value.value.i8s.length, sizeof(int8_t)); memcpy(value->value.value.i8s.i8s, elem->value.value.i8s.i8s, elem->value.value.i8s.length); break; case NEU_TYPE_ARRAY_UINT8: value->value.value.u8s.length = elem->value.value.u8s.length; + value->value.value.u8s.u8s = + calloc(elem->value.value.u8s.length, sizeof(uint8_t)); memcpy(value->value.value.u8s.u8s, elem->value.value.u8s.u8s, elem->value.value.u8s.length); break; case NEU_TYPE_ARRAY_INT16: value->value.value.i16s.length = elem->value.value.i16s.length; + value->value.value.i16s.i16s = + calloc(elem->value.value.i16s.length, sizeof(int16_t)); memcpy(value->value.value.i16s.i16s, elem->value.value.i16s.i16s, elem->value.value.i16s.length * sizeof(int16_t)); break; case NEU_TYPE_ARRAY_UINT16: value->value.value.u16s.length = elem->value.value.u16s.length; + value->value.value.u16s.u16s = + calloc(elem->value.value.u16s.length, sizeof(uint16_t)); memcpy(value->value.value.u16s.u16s, elem->value.value.u16s.u16s, elem->value.value.u16s.length * sizeof(uint16_t)); break; case NEU_TYPE_ARRAY_INT32: value->value.value.i32s.length = elem->value.value.i32s.length; + value->value.value.i32s.i32s = + calloc(elem->value.value.i32s.length, sizeof(int32_t)); memcpy(value->value.value.i32s.i32s, elem->value.value.i32s.i32s, elem->value.value.i32s.length * sizeof(int32_t)); break; case NEU_TYPE_ARRAY_UINT32: value->value.value.u32s.length = elem->value.value.u32s.length; + value->value.value.u32s.u32s = + calloc(elem->value.value.u32s.length, sizeof(uint32_t)); memcpy(value->value.value.u32s.u32s, elem->value.value.u32s.u32s, elem->value.value.u32s.length * sizeof(uint32_t)); break; case NEU_TYPE_ARRAY_INT64: value->value.value.i64s.length = elem->value.value.i64s.length; + value->value.value.i64s.i64s = + calloc(elem->value.value.i64s.length, sizeof(int64_t)); memcpy(value->value.value.i64s.i64s, elem->value.value.i64s.i64s, elem->value.value.i64s.length * sizeof(int64_t)); break; case NEU_TYPE_ARRAY_UINT64: value->value.value.u64s.length = elem->value.value.u64s.length; + value->value.value.u64s.u64s = + calloc(elem->value.value.u64s.length, sizeof(uint64_t)); memcpy(value->value.value.u64s.u64s, elem->value.value.u64s.u64s, elem->value.value.u64s.length * sizeof(uint64_t)); break; case NEU_TYPE_ARRAY_FLOAT: value->value.value.f32s.length = elem->value.value.f32s.length; + value->value.value.f32s.f32s = + calloc(elem->value.value.f32s.length, sizeof(float)); memcpy(value->value.value.f32s.f32s, elem->value.value.f32s.f32s, elem->value.value.f32s.length * sizeof(float)); break; case NEU_TYPE_ARRAY_DOUBLE: value->value.value.f64s.length = elem->value.value.f64s.length; + value->value.value.f64s.f64s = + calloc(elem->value.value.f64s.length, sizeof(double)); memcpy(value->value.value.f64s.f64s, elem->value.value.f64s.f64s, elem->value.value.f64s.length * sizeof(double)); break; @@ -970,6 +1041,9 @@ void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group, free(elem->value.value.ptr.ptr); elem->value.value.ptr.ptr = NULL; } + } else if (NEU_TYPE_ARRAY_CHAR < elem->value.type && + elem->value.type <= NEU_TYPE_ARRAY_BOOL) { + free(elem->value.value.bools.bools); } free(elem); } diff --git a/src/adapter/driver/driver.c b/src/adapter/driver/driver.c index 08107685..57daf3a4 100644 --- a/src/adapter/driver/driver.c +++ b/src/adapter/driver/driver.c @@ -360,6 +360,8 @@ static void update_im(neu_adapter_t *adapter, const char *group, { if (tag_value->value.type == NEU_TYPE_PTR) { free(tag_value->value.value.ptr.ptr); + } else { + neu_free_dvalue(&tag_value->value); } } utarray_free(data->tags); @@ -373,6 +375,8 @@ static void update_im(neu_adapter_t *adapter, const char *group, { if (tag_value->value.type == NEU_TYPE_PTR) { free(tag_value->value.value.ptr.ptr); + } else { + neu_free_dvalue(&tag_value->value); } } utarray_free(data->tags); @@ -834,128 +838,116 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type, break; case NEU_TYPE_BYTES: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.bytes.bytes[i] = - (uint8_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + uint32_t i64s_len = value->value.i64s.length > NEU_VALUE_SIZE + ? NEU_VALUE_SIZE + : value->value.i64s.length; + for (size_t i = 0; i < i64s_len; i++) { + value->value.bytes.bytes[i] = (uint8_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { + for (int i = i64s_len; i < NEU_VALUE_SIZE; i++) { value->value.bytes.bytes[i] = 0; } - value->value.bytes.length = value->value.i64s.length; + value->value.bytes.length = i64s_len; + free(i64s); } break; case NEU_TYPE_ARRAY_INT8: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.i8s.i8s[i] = (int8_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.i8s.i8s = calloc(value->value.i64s.length, 1); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.i8s.i8s[i] = (int8_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.i8s.i8s[i] = 0; - } - value->value.i8s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_UINT8: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.u8s.u8s[i] = (uint8_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.u8s.u8s = calloc(value->value.i64s.length, 1); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.u8s.u8s[i] = (uint8_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.u8s.u8s[i] = 0; - } - value->value.u8s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_INT16: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.i16s.i16s[i] = (int16_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.i16s.i16s = calloc(value->value.i64s.length, 2); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.i16s.i16s[i] = (int16_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.i16s.i16s[i] = 0; - } - value->value.i16s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_UINT16: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.u16s.u16s[i] = - (uint16_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.u16s.u16s = calloc(value->value.i64s.length, 2); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.u16s.u16s[i] = (uint16_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.u16s.u16s[i] = 0; - } - value->value.u16s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_INT32: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.i32s.i32s[i] = (int32_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.i32s.i32s = calloc(value->value.i64s.length, 4); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.i32s.i32s[i] = (int32_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.i32s.i32s[i] = 0; - } - value->value.i32s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_UINT32: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.u32s.u32s[i] = - (uint32_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.u32s.u32s = calloc(value->value.i64s.length, 4); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.u32s.u32s[i] = (uint32_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.u32s.u32s[i] = 0; - } - value->value.u32s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_UINT64: if (value->type == NEU_TYPE_ARRAY_INT64) { - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.u64s.u64s[i] = - (uint64_t) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.u64s.u64s = calloc(value->value.i64s.length, 8); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.u64s.u64s[i] = (uint64_t) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.u64s.u64s[i] = 0; - } - value->value.u64s.length = value->value.i64s.length; + free(i64s); } break; case NEU_TYPE_ARRAY_FLOAT: if (value->type == NEU_TYPE_ARRAY_INT64) { - - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.f32s.f32s[i] = (float) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.f32s.f32s = calloc(value->value.i64s.length, 4); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.f32s.f32s[i] = (float) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.f32s.f32s[i] = 0; - } - value->value.f32s.length = value->value.i64s.length; + free(i64s); } if (value->type == NEU_TYPE_ARRAY_DOUBLE) { - - for (int i = 0; i < value->value.f64s.length; i++) { - value->value.f32s.f32s[i] = (float) value->value.f64s.f64s[i]; + double *f64s = value->value.f64s.f64s; + value->value.f32s.f32s = calloc(value->value.f64s.length, 4); + for (size_t i = 0; i < value->value.f64s.length; i++) { + value->value.f32s.f32s[i] = (float) f64s[i]; } - for (int i = value->value.f64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.f32s.f32s[i] = 0; - } - value->value.f32s.length = value->value.f64s.length; + free(f64s); } break; case NEU_TYPE_ARRAY_DOUBLE: if (value->type == NEU_TYPE_ARRAY_INT64) { - - for (int i = 0; i < value->value.i64s.length; i++) { - value->value.f64s.f64s[i] = (double) value->value.i64s.i64s[i]; + int64_t *i64s = value->value.i64s.i64s; + value->value.f64s.f64s = calloc(value->value.i64s.length, 8); + for (size_t i = 0; i < value->value.i64s.length; i++) { + value->value.f64s.f64s[i] = (double) i64s[i]; } - for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) { - value->value.f64s.f64s[i] = 0; - } - value->value.f64s.length = value->value.i64s.length; + free(i64s); } break; default: @@ -1187,6 +1179,27 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d, } else { return NEU_ERR_SUCCESS; } + case NEU_TYPE_ARRAY_UINT8: + case NEU_TYPE_ARRAY_INT8: + case NEU_TYPE_ARRAY_UINT16: + case NEU_TYPE_ARRAY_INT16: + case NEU_TYPE_ARRAY_UINT32: + case NEU_TYPE_ARRAY_INT32: + case NEU_TYPE_ARRAY_UINT64: + case NEU_TYPE_ARRAY_INT64: + if (write_type != NEU_TYPE_ARRAY_INT64) { + return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH; + } else { + return NEU_ERR_SUCCESS; + } + case NEU_TYPE_ARRAY_FLOAT: + case NEU_TYPE_ARRAY_DOUBLE: + if (write_type != NEU_TYPE_ARRAY_DOUBLE && + write_type != NEU_TYPE_ARRAY_INT64) { + return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH; + } else { + return NEU_ERR_SUCCESS; + } default: return NEU_ERR_SUCCESS; } @@ -1255,6 +1268,7 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver, neu_plugin_tag_value_t tv = { .tag = neu_tag_dup(tag), .value = cmd->tags[i].value.value, + .type = cmd->tags[i].value.type, }; utarray_push_back(tags, &tv); } else { @@ -1271,6 +1285,8 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver, utarray_foreach(tags, neu_plugin_tag_value_t *, tv) { neu_tag_free(tv->tag); + neu_dvalue_t dvalue = { .type = tv->type, .value = tv->value }; + neu_free_dvalue(&dvalue); } utarray_free(tags); return value_err; @@ -1282,6 +1298,8 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver, utarray_foreach(tags, neu_plugin_tag_value_t *, tv) { neu_tag_free(tv->tag); + neu_dvalue_t dvalue = { .type = tv->type, .value = tv->value }; + neu_free_dvalue(&dvalue); } utarray_free(tags); return NEU_ERR_TAG_NOT_EXIST; @@ -2179,6 +2197,8 @@ static int report_callback(void *usr_data) { if (tag_value->value.type == NEU_TYPE_PTR) { free(tag_value->value.value.ptr.ptr); + } else { + neu_free_dvalue(&tag_value->value); } } utarray_free(data->tags); @@ -2502,6 +2522,8 @@ static void read_report_group(int64_t timestamp, int64_t timeout, (timestamp - value.timestamp) > timeout && timeout > 0) { if (value.value.type == NEU_TYPE_PTR) { free(value.value.value.ptr.ptr); + } else { + neu_free_dvalue(&value.value); } tag_value.value.type = NEU_TYPE_ERROR; tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED; @@ -2667,6 +2689,8 @@ static void read_group(int64_t timestamp, int64_t timeout, (timestamp - value.timestamp) > timeout) { if (value.value.type == NEU_TYPE_PTR) { free(value.value.value.ptr.ptr); + } else { + neu_free_dvalue(&value.value); } tag_value.value.type = NEU_TYPE_ERROR; tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED; @@ -2846,6 +2870,8 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout, (timestamp - value.timestamp) > timeout) { if (value.value.type == NEU_TYPE_PTR) { free(value.value.value.ptr.ptr); + } else { + neu_free_dvalue(&value.value); } tag_value.value.type = NEU_TYPE_ERROR; tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;