Merge pull request #2667 from fengzeroz/v2.10

write tag log
2026-10-31 00:19:15 +08:00 · 2026-01-19 15:03:46 +08:00 · 2026-01-19 06:57:31 +00:00 · 2025-12-25 10:06:58 +08:00 · 2025-12-25 02:03:43 +00:00 · 2025-12-19 15:03:47 +08:00
26 changed files with 652 additions and 220 deletions
@@ -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:
@@ -1,4 +1,4 @@
-name: compile
+20.04name: compile

 on: 
  push:
@@ -8,13 +8,13 @@ on:
      - published

 env:
-  VERSION: 2.10.3
+  VERSION: 2.10.4
  UI_VERSION: 2.6.1
  BRANCH: v2.10

 jobs:
  cross-build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    strategy:
      matrix:
        arch:
@@ -59,7 +59,7 @@ jobs:
            neuron-sdk-*.tar.gz

  build-debug-sdk:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    strategy:
      matrix:
        arch:
@@ -303,4 +303,6 @@ int neu_conn_tcp_server_wait_msg(neu_conn_t *conn, int fd, void *context,
 int is_ipv4(const char *ip);
 int is_ipv6(const char *ip);

+uint16_t neu_conn_udp_act_port(neu_conn_t *conn);
+
 #endif
@@ -24,7 +24,7 @@

 #define NEU_VERSION_MAJOR 2
 #define NEU_VERSION_MINOR 10
-#define NEU_VERSION_FIX 3
+#define NEU_VERSION_FIX 4

 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)
 #define NEU_GET_VERSION_MINOR(V) ((0x0000ff00 & V) >> 8)
@@ -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);
@@ -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 {
@@ -44,6 +44,10 @@ typedef enum {
    NEU_DATATAG_ENDIAN_BL32 = 5, // #BL 2,1,4,3
    NEU_DATATAG_ENDIAN_L64  = 6, // #L  8,7,6,5,4,3,2,1
    NEU_DATATAG_ENDIAN_B64  = 7, // #B  1,2,3,4,5,6,7,8
+    NEU_DATATAG_ENDIAN_LL64 = 8,
+    NEU_DATATAG_ENDIAN_LB64 = 9,
+    NEU_DATATAG_ENDIAN_BB64 = 10,
+    NEU_DATATAG_ENDIAN_BL64 = 11,
 } neu_datatag_endian_e;

 typedef enum {
@@ -63,6 +67,7 @@ typedef union {
    } value32;
    struct {
        neu_datatag_endian_e endian;
+        bool                 is_default;
    } value64;
    struct {
        uint16_t                  length;
@@ -29,6 +29,7 @@ extern "C" {
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>

 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 {
@@ -840,6 +853,42 @@ static inline uint64_t neu_htonll(uint64_t u)
    return ret;
 }

+static inline uint64_t neu_htonlb(uint64_t u)
+{
+    uint8_t *in        = (uint8_t *) &u;
+    uint64_t out       = 0;
+    uint8_t *out_bytes = (uint8_t *) &out;
+
+    out_bytes[0] = in[1];
+    out_bytes[1] = in[0];
+    out_bytes[2] = in[3];
+    out_bytes[3] = in[2];
+    out_bytes[4] = in[5];
+    out_bytes[5] = in[4];
+    out_bytes[6] = in[7];
+    out_bytes[7] = in[6];
+
+    return out;
+}
+
+static inline uint64_t neu_htonbl(uint64_t u)
+{
+    uint8_t *in        = (uint8_t *) &u;
+    uint64_t out       = 0;
+    uint8_t *out_bytes = (uint8_t *) &out;
+
+    out_bytes[0] = in[6];
+    out_bytes[1] = in[7];
+    out_bytes[2] = in[4];
+    out_bytes[3] = in[5];
+    out_bytes[4] = in[2];
+    out_bytes[5] = in[3];
+    out_bytes[6] = in[0];
+    out_bytes[7] = in[1];
+
+    return out;
+}
+
 static inline uint64_t neu_ntohll(uint64_t u)
 {
    return neu_htonll(u);
@@ -195,10 +195,21 @@ static int decode_write_req_json(void *json_obj, neu_json_write_req_t *req)
            .name = "value",
            .t    = NEU_JSON_VALUE,
        },
+        {
+            .name      = "precision",
+            .t         = NEU_JSON_INT,
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        },
    };
-    ret       = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
+    ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
                                  req_elems);
-    req->node = req_elems[0].v.val_str;
+
+    if (req_elems[4].v.val_int > 0) {
+        req_elems[3].t            = NEU_JSON_DOUBLE;
+        req_elems[3].v.val_double = (double_t) req_elems[3].v.val_int;
+    }
+
+    req->node  = req_elems[0].v.val_str;
    req->group = req_elems[1].v.val_str;
    req->tag   = req_elems[2].v.val_str;
    req->t     = req_elems[3].t;
@@ -259,10 +270,21 @@ static int decode_write_tags_req_json(void *                     json_obj,
                .name = "value",
                .t    = NEU_JSON_VALUE,
            },
+            {
+                .name      = "precision",
+                .t         = NEU_JSON_INT,
+                .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+            },
        };

        ret = neu_json_decode_array_by_json(
            json_obj, "tags", i, NEU_JSON_ELEM_SIZE(v_elems), v_elems);
+
+        if (v_elems[2].v.val_int > 0) {
+            v_elems[1].t            = NEU_JSON_DOUBLE;
+            v_elems[1].v.val_double = (double_t) v_elems[1].v.val_int;
+        }
+
        req->tags[i].tag   = v_elems[0].v.val_str;
        req->tags[i].t     = v_elems[1].t;
        req->tags[i].value = v_elems[1].v;
@@ -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;
@@ -18,11 +18,11 @@
 		},
 		{
 			"type": 7,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 8,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 9,
@@ -30,7 +30,7 @@
 		},
 		{
 			"type": 10,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 11,
@@ -158,8 +158,8 @@
 		}
 	},
 	"endianess": {
-		"name": "Endianess",
-		"name_zh": "字节序",
+		"name": "Endianess of 4-Byte Data",
+		"name_zh": "4 字节数据字节序",
 		"description": "Tag byte order, ABCD corresponds to 1234",
 		"description_zh": "点位字节序，ABCD 对应 1234",
 		"attribute": "required",
@@ -186,6 +186,35 @@
 			]
 		}
 	},
+	"endianess_64": {
+		"name": "Endianess of 8-Byte Data",
+		"name_zh": "8 字节数据字节序",
+		"description": "Tag byte order, applicable to int64, uint64 and double types",
+		"description_zh": "点位字节序，适用于 int64，uint64 和 double 类型",
+		"attribute": "required",
+		"type": "map",
+		"default": 1,
+		"valid": {
+			"map": [
+				{
+					"key": "12 34 56 78",
+					"value": 1
+				},
+				{
+					"key": "21 43 65 87",
+					"value": 2
+				},
+				{
+					"key": "87 65 43 21",
+					"value": 3
+				},
+				{
+					"key": "78 56 34 12",
+					"value": 4
+				}
+			]
+		}
+	},
 	"address_base": {
 		"name": "Start Address",
 		"name_zh": "开始地址",
@@ -18,11 +18,11 @@
 		},
 		{
 			"type": 7,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 8,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 9,
@@ -30,7 +30,7 @@
 		},
 		{
 			"type": 10,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 11,
@@ -166,8 +166,8 @@
 		}
 	},
 	"endianess": {
-		"name": "Endianess",
-		"name_zh": "字节序",
+		"name": "Endianess of 4-Byte Data",
+		"name_zh": "4 字节数据字节序",
 		"description": "Tag byte order, ABCD corresponds to 1234",
 		"description_zh": "点位字节序，ABCD 对应 1234",
 		"attribute": "required",
@@ -194,6 +194,35 @@
 			]
 		}
 	},
+	"endianess_64": {
+		"name": "Endianess of 8-Byte Data",
+		"name_zh": "8 字节数据字节序",
+		"description": "Tag byte order, applicable to int64, uint64 and double types",
+		"description_zh": "点位字节序，适用于 int64，uint64 和 double 类型",
+		"attribute": "required",
+		"type": "map",
+		"default": 1,
+		"valid": {
+			"map": [
+				{
+					"key": "12 34 56 78",
+					"value": 1
+				},
+				{
+					"key": "21 43 65 87",
+					"value": 2
+				},
+				{
+					"key": "87 65 43 21",
+					"value": 3
+				},
+				{
+					"key": "78 56 34 12",
+					"value": 4
+				}
+			]
+		}
+	},
 	"address_base": {
 		"name": "Start Address",
 		"name_zh": "开始地址",
@@ -73,6 +73,13 @@ typedef enum modbus_endianess {
    MODBUS_CDAB = 4,
 } modbus_endianess;

+typedef enum modbus_endianess_64 {
+    MODBUS_LL = 1, // 12 34 56 78
+    MODBUS_LB = 2, // 21 43 65 87
+    MODBUS_BB = 3, // 87 65 43 21
+    MODBUS_BL = 4, // 78 56 34 12
+} modbus_endianess_64;
+
 typedef enum modbus_address_base {
    base_0 = 0,
    base_1 = 1,
@@ -238,7 +238,8 @@ modbus_read_cmd_sort_t *modbus_tag_sort(UT_array *tags, uint16_t max_byte)
 }

 int cal_n_byte(int type, neu_value_u *value, neu_datatag_addr_option_u option,
-               modbus_endianess endianess, bool default_tag_endian)
+               modbus_endianess endianess, bool default_tag_endian,
+               modbus_endianess_64 endianess_64, bool default_tag_endian_64)
 {
    int n = 0;
    switch (type) {
@@ -260,6 +261,9 @@ int cal_n_byte(int type, neu_value_u *value, neu_datatag_addr_option_u option,
    case NEU_TYPE_DOUBLE:
    case NEU_TYPE_INT64:
    case NEU_TYPE_UINT64:
+        if (default_tag_endian_64) {
+            modbus_convert_endianess_64(value, endianess_64);
+        }
        n          = sizeof(uint64_t);
        value->u64 = neu_htonll(value->u64);
        break;
@@ -293,8 +297,9 @@ int cal_n_byte(int type, neu_value_u *value, neu_datatag_addr_option_u option,
    return n;
 }

-modbus_write_cmd_sort_t *modbus_write_tags_sort(UT_array *       tags,
-                                                modbus_endianess endianess)
+modbus_write_cmd_sort_t *
+modbus_write_tags_sort(UT_array *tags, modbus_endianess endianess,
+                       modbus_endianess_64 endianess_64)
 {
    neu_tag_sort_result_t *result =
        neu_tag_sort(tags, tag_sort_write, tag_cmp_write);
@@ -316,17 +321,18 @@ modbus_write_cmd_sort_t *modbus_write_tags_sort(UT_array *       tags,
        utarray_foreach(result->sorts[i].tags, modbus_point_write_t **, tag_s)
        {
            if ((*tag_s)->point.area == MODBUS_AREA_COIL) {
-                n_byte_tag =
-                    cal_n_byte((*tag_s)->point.type, &(*tag_s)->value,
-                               (*tag_s)->point.option, endianess, true);
+                n_byte_tag = cal_n_byte((*tag_s)->point.type, &(*tag_s)->value,
+                                        (*tag_s)->point.option, endianess, true,
+                                        endianess_64, true);
                data_bit[k / 8] += ((*tag_s)->value.i8) << k % 8;
                n_byte += n_byte_tag;
                k++;
            } else {
-                n_byte_tag =
-                    cal_n_byte((*tag_s)->point.type, &(*tag_s)->value,
-                               (*tag_s)->point.option, endianess,
-                               (*tag_s)->point.option.value32.is_default);
+                n_byte_tag = cal_n_byte(
+                    (*tag_s)->point.type, &(*tag_s)->value,
+                    (*tag_s)->point.option, endianess,
+                    (*tag_s)->point.option.value32.is_default, endianess_64,
+                    (*tag_s)->point.option.value64.is_default);
                memcpy(sort_result->cmd[i].bytes +
                           2 *
                               ((*tag_s)->point.start_address -
@@ -558,4 +564,24 @@ void modbus_convert_endianess(neu_value_u *value, modbus_endianess endianess)
    default:
        break;
    }
+}
+
+void modbus_convert_endianess_64(neu_value_u *       value,
+                                 modbus_endianess_64 endianess_64)
+{
+    switch (endianess_64) {
+    case MODBUS_LL:
+        break;
+    case MODBUS_BB:
+        value->u64 = neu_htonll(value->u64);
+        break;
+    case MODBUS_LB:
+        value->u64 = neu_htonlb(value->u64);
+        break;
+    case MODBUS_BL:
+        value->u64 = neu_htonbl(value->u64);
+        break;
+    default:
+        break;
+    }
 }
@@ -81,12 +81,15 @@ typedef struct modbus_write_cmd_sort {
    modbus_write_cmd_t *cmd;
 } modbus_write_cmd_sort_t;

-modbus_read_cmd_sort_t * modbus_tag_sort(UT_array *tags, uint16_t max_byte);
-modbus_write_cmd_sort_t *modbus_write_tags_sort(UT_array *       tags,
-                                                modbus_endianess endianess);
-void                     modbus_tag_sort_free(modbus_read_cmd_sort_t *cs);
+modbus_read_cmd_sort_t *modbus_tag_sort(UT_array *tags, uint16_t max_byte);
+modbus_write_cmd_sort_t *
+     modbus_write_tags_sort(UT_array *tags, modbus_endianess endianess,
+                            modbus_endianess_64 endianess_64);
+void modbus_tag_sort_free(modbus_read_cmd_sort_t *cs);

 void modbus_convert_endianess(neu_value_u *value, modbus_endianess endianess);
+void modbus_convert_endianess_64(neu_value_u *       value,
+                                 modbus_endianess_64 endianess_64);

 #ifdef __cplusplus
 }
@@ -455,6 +455,10 @@ int modbus_value_handle(void *ctx, uint8_t slave_id, uint16_t n_byte,
            case NEU_TYPE_DOUBLE:
            case NEU_TYPE_INT64:
            case NEU_TYPE_UINT64:
+                if ((*p_tag)->option.value64.is_default) {
+                    modbus_convert_endianess_64(&dvalue.value,
+                                                plugin->endianess_64);
+                }
                dvalue.value.u64 = neu_ntohll(dvalue.value.u64);
                break;
            case NEU_TYPE_BIT: {
@@ -712,6 +716,9 @@ static uint8_t convert_value(neu_plugin_t *plugin, neu_value_u *value,
    case NEU_TYPE_DOUBLE:
    case NEU_TYPE_INT64:
    case NEU_TYPE_UINT64:
+        if (tag->option.value64.is_default) {
+            modbus_convert_endianess_64(value, plugin->endianess_64);
+        }
        value->u64 = neu_htonll(value->u64);
        n_byte     = sizeof(uint64_t);
        break;
@@ -804,7 +811,8 @@ int modbus_write_tags(neu_plugin_t *plugin, void *req, UT_array *tags)

        utarray_push_back(gtags->tags, &p);
    }
-    gtags->cmd_sort = modbus_write_tags_sort(gtags->tags, plugin->endianess);
+    gtags->cmd_sort = modbus_write_tags_sort(gtags->tags, plugin->endianess,
+                                             plugin->endianess_64);
    for (uint16_t i = 0; i < gtags->cmd_sort->n_cmd; i++) {
        ret = write_modbus_points(plugin, &gtags->cmd_sort->cmd[i], req);
        if (ret <= 0) {
@@ -40,6 +40,7 @@ struct neu_plugin {

    modbus_protocol_e   protocol;
    modbus_endianess    endianess;
+    modbus_endianess_64 endianess_64;
    modbus_address_base address_base;

    uint16_t interval;
@@ -178,6 +178,9 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
    neu_json_elem_t address_base = { .name = "address_base",
                                     .t    = NEU_JSON_INT };

+    neu_json_elem_t endianess_64 = { .name = "endianess_64",
+                                     .t    = NEU_JSON_INT };
+
    ret = neu_parse_param((char *) config, &err_param, 3, &link, &timeout,
                          &interval);
    if (ret != 0) {
@@ -239,6 +242,12 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
        address_base.v.val_int = base_1;
    }

+    ret = neu_parse_param((char *) config, &err_param, 1, &endianess_64);
+    if (ret != 0) {
+        free(err_param);
+        endianess_64.v.val_int = MODBUS_LL;
+    }
+
    param.log              = plugin->common.log;
    plugin->max_retries    = max_retries.v.val_int;
    plugin->retry_interval = retry_interval.v.val_int;
@@ -247,6 +256,7 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
    plugin->degrade_time   = degrade_time.v.val_int;
    plugin->endianess      = endianess.v.val_int;
    plugin->address_base   = address_base.v.val_int;
+    plugin->endianess_64   = endianess_64.v.val_int;

    if (link.v.val_int == 0) {
        param.type = NEU_CONN_TTY_CLIENT;
@@ -174,6 +174,8 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
    neu_json_elem_t endianess    = { .name = "endianess", .t = NEU_JSON_INT };
    neu_json_elem_t address_base = { .name = "address_base",
                                     .t    = NEU_JSON_INT };
+    neu_json_elem_t endianess_64 = { .name = "endianess_64",
+                                     .t    = NEU_JSON_INT };

    ret = neu_parse_param((char *) config, &err_param, 5, &port, &host, &mode,
                          &timeout, &interval);
@@ -229,6 +231,12 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
        address_base.v.val_int = base_1;
    }

+    ret = neu_parse_param((char *) config, &err_param, 1, &endianess_64);
+    if (ret != 0) {
+        free(err_param);
+        endianess_64.v.val_int = MODBUS_LL;
+    }
+
    param.log              = plugin->common.log;
    plugin->interval       = interval.v.val_int;
    plugin->max_retries    = max_retries.v.val_int;
@@ -238,6 +246,7 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
    plugin->degrade_cycle  = degrade_cycle.v.val_int;
    plugin->degrade_time   = degrade_time.v.val_int;
    plugin->endianess      = endianess.v.val_int;
+    plugin->endianess_64   = endianess_64.v.val_int;
    plugin->address_base   = address_base.v.val_int;

    if (mode.v.val_int == 1) {
@@ -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;
@@ -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);
@@ -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);
    }
@@ -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);
@@ -825,137 +829,133 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
    case NEU_TYPE_LWORD:
        switch (tag->option.value64.endian) {
        case NEU_DATATAG_ENDIAN_B64:
+        case NEU_DATATAG_ENDIAN_BB64:
            value->value.u64 = neu_ntohll(value->value.u64);
            break;
+        case NEU_DATATAG_ENDIAN_LB64:
+            value->value.u64 = neu_htonlb(value->value.u64);
+            break;
+        case NEU_DATATAG_ENDIAN_BL64:
+            value->value.u64 = neu_htonbl(value->value.u64);
+            break;
        case NEU_DATATAG_ENDIAN_L64:
+        case NEU_DATATAG_ENDIAN_LL64:
        default:
            break;
        }
        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:
@@ -1112,12 +1112,18 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
            }
        case NEU_TYPE_FLOAT:
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            }
            if (result < (int64_t) -FLT_MAX || result > (int64_t) FLT_MAX) {
                return NEU_ERR_PLUGIN_TAG_VALUE_OUT_OF_RANGE;
            } else {
                return NEU_ERR_SUCCESS;
            }
        case NEU_TYPE_DOUBLE:
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            }
            return NEU_ERR_SUCCESS;
        case NEU_TYPE_STRING:
        case NEU_TYPE_BOOL:
@@ -1162,12 +1168,18 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
            }
        case NEU_TYPE_FLOAT:
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            }
            if (value < (int64_t) -FLT_MAX || value > (int64_t) FLT_MAX) {
                return NEU_ERR_PLUGIN_TAG_VALUE_OUT_OF_RANGE;
            } else {
                return NEU_ERR_SUCCESS;
            }
        case NEU_TYPE_DOUBLE:
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            }
            return NEU_ERR_SUCCESS;
        case NEU_TYPE_STRING:
            if (write_type != NEU_TYPE_STRING) {
@@ -1175,6 +1187,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;
        }
@@ -1201,6 +1234,8 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
    group_t *g = find_group(driver, cmd->group);

    if (g == NULL) {
+        nlog_warn("driver write tags group not exist, driver: %s, group: %s",
+                  driver->adapter.name, cmd->group);
        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
                                                      NEU_ERR_GROUP_NOT_EXIST);
        return NEU_ERR_GROUP_NOT_EXIST;
@@ -1221,6 +1256,9 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
                                  cmd->tags[i].value.value.d64,
                                  cmd->tags[i].value.type, tag->decimal);
        } else {
+            nlog_warn("driver write tags not exist, driver: %s, group: %s, "
+                      "tag: %s",
+                      driver->adapter.name, cmd->group, cmd->tags[i].tag);
            value_check = NEU_ERR_TAG_NOT_EXIST;
        }

@@ -1243,6 +1281,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 {
@@ -1254,22 +1293,31 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
    }

    if (value_err != NEU_ERR_SUCCESS) {
+        nlog_warn("driver write tags value error(%d), driver: %s, group: %s",
+                  value_err, driver->adapter.name, cmd->group);
        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
                                                      value_err);
        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;
    }

    if (utarray_len(tags) != (unsigned int) cmd->n_tag) {
+        nlog_warn("driver write tags some tag not exist, driver: %s, group: "
+                  "%s",
+                  driver->adapter.name, cmd->group);
        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
                                                      NEU_ERR_TAG_NOT_EXIST);
        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;
@@ -1423,6 +1471,8 @@ int neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
    group_t *            g   = find_group(driver, cmd->group);

    if (g == NULL) {
+        nlog_warn("driver write tag group not exist, driver: %s, group: %s",
+                  driver->adapter.name, cmd->group);
        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
                                                      NEU_ERR_GROUP_NOT_EXIST);
        return NEU_ERR_GROUP_NOT_EXIST;
@@ -1430,11 +1480,16 @@ int neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
    neu_datatag_t *tag = neu_group_find_tag(g->group, cmd->tag);

    if (tag == NULL) {
+        nlog_warn("driver write tag not exist, driver: %s, group: %s, tag: %s",
+                  driver->adapter.name, cmd->group, cmd->tag);
        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
                                                      NEU_ERR_TAG_NOT_EXIST);
        return NEU_ERR_TAG_NOT_EXIST;
    } else {
        if ((tag->attribute & NEU_ATTRIBUTE_WRITE) != NEU_ATTRIBUTE_WRITE) {
+            nlog_warn("driver write tag not allow write, driver: %s, group: "
+                      "%s, tag: %s",
+                      driver->adapter.name, cmd->group, cmd->tag);
            driver->adapter.cb_funs.driver.write_response(
                &driver->adapter, req, NEU_ERR_PLUGIN_TAG_NOT_ALLOW_WRITE);
            neu_tag_free(tag);
@@ -1446,6 +1501,9 @@ int neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
                                            cmd->value.type, tag->decimal);

        if (value_check != NEU_ERR_SUCCESS) {
+            nlog_warn("driver write tag value error(%d), driver: %s, group: "
+                      "%s, tag: %s",
+                      value_check, driver->adapter.name, cmd->group, cmd->tag);
            driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
                                                          value_check);
            neu_tag_free(tag);
@@ -1582,6 +1640,10 @@ int neu_adapter_driver_update_group(neu_adapter_driver_t *driver,
    if (NULL != new_name && 0 != strcmp(name, new_name)) {
        char *new_name_cp1 = strdup(new_name);
        char *new_name_cp2 = strdup(new_name);
+        if (find->grp.group_free != NULL) {
+            find->grp.group_free(&find->grp);
+            find->grp.group_free = NULL;
+        }
        if (new_name_cp1 && new_name_cp2 &&
            0 == neu_group_set_name(find->group, new_name)) {
            HASH_DEL(driver->groups, find);
@@ -2098,6 +2160,7 @@ static int report_callback(void *usr_data)
    data->driver = strdup(group->driver->adapter.name);
    data->group  = strdup(group->name);
    utarray_new(data->tags, neu_resp_tag_value_meta_icd());
+    utarray_reserve(data->tags, utarray_len(tags));

    void *trace_ctx =
        neu_driver_cache_get_trace(group->driver->cache, group->name);
@@ -2167,6 +2230,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);
@@ -2474,9 +2539,17 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
        case NEU_TYPE_UINT64:
            switch (tag->option.value64.endian) {
            case NEU_DATATAG_ENDIAN_B64:
+            case NEU_DATATAG_ENDIAN_BB64:
                value.value.value.u64 = neu_htonll(value.value.value.u64);
                break;
+            case NEU_DATATAG_ENDIAN_LB64:
+                value.value.value.u64 = neu_htonlb(value.value.value.u64);
+                break;
+            case NEU_DATATAG_ENDIAN_BL64:
+                value.value.value.u64 = neu_htonbl(value.value.value.u64);
+                break;
            case NEU_DATATAG_ENDIAN_L64:
+            case NEU_DATATAG_ENDIAN_LL64:
            default:
                break;
            }
@@ -2490,6 +2563,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;
@@ -2639,9 +2714,17 @@ static void read_group(int64_t timestamp, int64_t timeout,
        case NEU_TYPE_UINT64:
            switch (tag->option.value64.endian) {
            case NEU_DATATAG_ENDIAN_B64:
+            case NEU_DATATAG_ENDIAN_BB64:
                value.value.value.u64 = neu_htonll(value.value.value.u64);
                break;
+            case NEU_DATATAG_ENDIAN_LB64:
+                value.value.value.u64 = neu_htonlb(value.value.value.u64);
+                break;
+            case NEU_DATATAG_ENDIAN_BL64:
+                value.value.value.u64 = neu_htonbl(value.value.value.u64);
+                break;
            case NEU_DATATAG_ENDIAN_L64:
+            case NEU_DATATAG_ENDIAN_LL64:
            default:
                break;
            }
@@ -2655,6 +2738,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;
@@ -2818,9 +2903,17 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout,
        case NEU_TYPE_UINT64:
            switch (tag->option.value64.endian) {
            case NEU_DATATAG_ENDIAN_B64:
+            case NEU_DATATAG_ENDIAN_BB64:
                value.value.value.u64 = neu_htonll(value.value.value.u64);
                break;
+            case NEU_DATATAG_ENDIAN_LB64:
+                value.value.value.u64 = neu_htonlb(value.value.value.u64);
+                break;
+            case NEU_DATATAG_ENDIAN_BL64:
+                value.value.value.u64 = neu_htonbl(value.value.value.u64);
+                break;
            case NEU_DATATAG_ENDIAN_L64:
+            case NEU_DATATAG_ENDIAN_LL64:
            default:
                break;
            }
@@ -2834,6 +2927,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;
@@ -255,21 +255,35 @@ int neu_datatag_parse_addr_option(const neu_datatag_t *      datatag,
    case NEU_TYPE_UINT64: {
        char *op = find_last_character(datatag->address, '#');

-        option->value64.endian = NEU_DATATAG_ENDIAN_L64;
+        option->value64.endian     = NEU_DATATAG_ENDIAN_L64;
+        option->value64.is_default = true;
        if (op != NULL) {
-            char e = 0;
-            sscanf(op, "#%c", &e);
+            char e1 = 0;
+            char e2 = 0;
+            int  n  = sscanf(op, "#%c%c", &e1, &e2);

-            switch (e) {
-            case 'B':
-                option->value64.endian = NEU_DATATAG_ENDIAN_B64;
-                break;
-            case 'L':
-                option->value64.endian = NEU_DATATAG_ENDIAN_L64;
-                break;
-            default:
-                option->value64.endian = NEU_DATATAG_ENDIAN_L64;
-                break;
+            if (n == 2) {
+                if (e1 == 'B' && e2 == 'B') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_BB64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'B' && e2 == 'L') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_BL64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'L' && e2 == 'L') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_LL64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'L' && e2 == 'B') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_LB64;
+                    option->value64.is_default = false;
+                }
+            } else if (n == 1) {
+                if (e1 == 'B') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_B64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'L') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_L64;
+                    option->value64.is_default = false;
+                }
            }
        }

@@ -69,6 +69,8 @@ struct neu_conn {
    uint8_t *buf;
    uint16_t buf_size;
    uint16_t offset;
+
+    uint16_t udp_act_port;
 };

 static void conn_tcp_server_add_client(neu_conn_t *conn, int fd,
@@ -503,7 +505,8 @@ ssize_t neu_conn_recv(neu_conn_t *conn, uint8_t *buf, ssize_t len)
                conn->param.log,
                "tcp conn fd: %d, recv buf len %zd, ret: %zd, errno: %s(%d)",
                conn->fd, len, ret, strerror(errno), errno);
-            if (ret == 0 || (ret == -1 && errno != EAGAIN)) {
+            if (ret == 0 || (ret == -1 && errno != EAGAIN) ||
+                (conn->connection_ok && ret == -1 && errno == EAGAIN)) {
                conn_disconnect(conn);
            }
        }
@@ -868,6 +871,7 @@ static void conn_connect(neu_conn_t *conn)
        } else {
            zlog_error(conn->param.log, "invalid ip: %s",
                       conn->param.params.tcp_server.ip);
+            close(fd);
            return;
        }

@@ -938,6 +942,7 @@ static void conn_connect(neu_conn_t *conn)
        } else {
            zlog_error(conn->param.log, "invalid ip: %s",
                       conn->param.params.tcp_server.ip);
+            close(fd);
            return;
        }

@@ -950,6 +955,13 @@ static void conn_connect(neu_conn_t *conn)
            return;
        }

+        struct sockaddr_in local_addr     = { 0 };
+        socklen_t          local_addr_len = sizeof(local_addr);
+        if (getsockname(fd, (struct sockaddr *) &local_addr, &local_addr_len) ==
+            0) {
+            conn->udp_act_port = ntohs(local_addr.sin_port);
+        }
+
        if (is_ipv4(conn->param.params.udp.dst_ip)) {
            struct sockaddr_in remote = {
                .sin_family      = AF_INET,
@@ -1053,6 +1065,13 @@ static void conn_connect(neu_conn_t *conn)
            return;
        }

+        struct sockaddr_in local_addr     = { 0 };
+        socklen_t          local_addr_len = sizeof(local_addr);
+        if (getsockname(fd, (struct sockaddr *) &local_addr, &local_addr_len) ==
+            0) {
+            conn->udp_act_port = ntohs(local_addr.sin_port);
+        }
+
        conn->is_connected = true;
        conn->fd           = fd;

@@ -1459,4 +1478,9 @@ int is_ipv6(const char *ip)
 {
    struct sockaddr_in6 sa;
    return inet_pton(AF_INET6, ip, &(sa.sin6_addr)) != 0;
+}
+
+uint16_t neu_conn_udp_act_port(neu_conn_t *conn)
+{
+    return conn->udp_act_port;
 }
@@ -1 +1 @@
-2.10.3
+2.10.4
Author	SHA1	Message	Date
fengzeroz	c51ba72ef4	Merge pull request #2667 from fengzeroz/v2.10 write tag log	2026-01-19 15:03:46 +08:00
fengzero	b146dfb834	write tag log	2026-01-19 06:57:31 +00:00
fengzeroz	c56216c589	Merge pull request #2650 from fengzeroz/v2.10 fix(group): free group context with old group	2025-12-25 10:06:58 +08:00
fengzero	cc5028ea83	fix(group): free group context with old group	2025-12-25 02:03:43 +00:00
fengzeroz	775c8199af	Merge pull request #2639 from fengzeroz/v2.10 fix(connection): close fd if ip invalid	2025-12-19 15:03:47 +08:00
fengzero	556011f152	fix(connection): close fd if ip invalid	2025-12-19 07:02:26 +00:00
fengzeroz	3ffa126f7d	Merge pull request #2576 from fengzeroz/v2.10 connect(udpto): get local port	2025-10-14 11:05:39 +08:00
fengzero	1b28606084	connect(udpto): get local port	2025-10-14 03:04:26 +00:00
fengzeroz	f33f5d1079	Merge pull request #2571 from fengzeroz/v2.10 connect: get udp bind port	2025-10-13 15:14:04 +08:00
fengzero	8094b53f20	connect: get udp bind port	2025-10-13 07:07:34 +00:00
fengzeroz	5c0d83e032	Merge pull request #2557 from fengzeroz/v2.10 conn: disconnect when connected and recv error eagain	2025-08-29 09:49:24 +08:00
fengzero	fa9af816e8	conn: disconnect when connected and recv error eagain	2025-08-29 01:48:35 +00:00
fengzeroz	7fcd30cae6	Merge pull request #2550 from fengzeroz/v2.10 conn: disconnect when connected and recv error	2025-08-27 13:54:10 +08:00
fengzero	a90a8584e5	conn: disconnect when connected and recv error	2025-08-27 05:52:14 +00:00
fengzeroz	d66d022d50	Merge pull request #2508 from fengzeroz/v2.10 report: pre alloc memory	2025-06-26 11:10:05 +08:00
fengzero	4072a70aec	report: pre alloc memory	2025-06-26 03:09:27 +00:00
fengzeroz	6618bae8ee	Merge pull request #2492 from hxy7yx/v2.10-1 [v2.10]feat(modbus):support endianess of 8-Byte data	2025-06-16 10:56:04 +08:00
hxy7yx	bf6c7aa65f	feat(modbus):support endianess of 8-Byte data	2025-06-15 19:25:30 -07:00
fengzeroz	1c917c4b13	Merge pull request #2459 from ZhouBox/v2.10 [v2.10]refactor the array type	2025-05-22 17:18:26 +08:00
xiang.zhou	b8fa86be44	ci:update os version	2025-05-22 16:37:49 +08:00
xiang.zhou	9812e3d3ba	refactor the array type	2025-05-22 16:29:54 +08:00
fengzeroz	93f0c51797	Merge pull request #2423 from fengzeroz/v2.10 Revert "write int64/uint64 with string"	2025-04-02 13:50:57 +08:00
fengzero	7eacfb8521	Revert "write int64/uint64 with string" This reverts commit `c1e541ecb1`.	2025-04-02 05:50:13 +00:00
fengzeroz	bf023f1e69	Merge pull request #2416 from fengzeroz/v2.10 write int64/uint64 with string	2025-03-26 16:15:35 +08:00
fengzero	c1e541ecb1	write int64/uint64 with string	2025-03-26 08:14:50 +00:00
fengzeroz	b6fcf2a8be	Merge pull request #2413 from ZhouBox/v2.10 [v2.10]ekuiper:support precision	2025-03-19 15:59:53 +08:00
fengzeroz	d84158d885	Merge pull request #2411 from hxy7yx/v2.10-1 [v2.10]fix(allow float-tag to write integers)	2025-03-19 15:59:28 +08:00
xiang.zhou	a63c31101f	Merge branch 'v2.10' of github.com:ZhouBox/neuron into v2.10	2025-03-19 13:23:24 +08:00
xiang.zhou	c3428138f7	ekuiper:support precision	2025-03-19 13:23:10 +08:00
hxy7yx	64f643d3c4	fix(allow float-tag to write integers)	2025-03-18 20:28:36 -07:00
fengzeroz	c58908a0bb	Merge pull request #2408 from fengzeroz/v2.10 version: 2.10.4	2025-03-18 17:16:59 +08:00
fengzero	5dbc6be038	version: 2.10.4	2025-03-18 08:50:47 +00:00
@@ -1 +1 @@
 .10.3
 .10.4