Merge pull request #2780 from fengzeroz/v2.13

version: 2.13.1

.github/workflows/check.yml

@@ -13,7 +13,7 @@ jobs:
 
     steps:
       # checkout
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
 
@@ -27,7 +27,7 @@ jobs:
 
   cppcheck:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -40,9 +40,21 @@ jobs:
           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
 
+  flawfinder:
+    name: Flawfinder Scan
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: flawfinder_scan
+        uses: david-a-wheeler/flawfinder@2.0.20
+        with:
+          arguments: '--minlevel=3 .'
+
   build:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -65,7 +77,7 @@ jobs:
 
   ut:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
     needs: [build]
 
     steps:
@@ -85,25 +97,9 @@ jobs:
           cmake -DUSE_GCOV=1 .. -DCMAKE_TOOLCHAIN_FILE=../cmake/x86_64-linux-gnu.cmake
           ctest --output-on-failure
 
-      - name: create cov report
-        run: |
-            sudo apt-get update
-            sudo apt-get -y install lcov
-            mkdir -p cov_report
-            ./create_cov_report.sh ut
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          verbose: true
-          fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }}
-          directory: ./cov_report/
-          files: ./cov_report/cov-ut.info
-
   pft:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
     needs: [build]
     strategy:
       matrix:
@@ -149,19 +145,3 @@ jobs:
           else
             pytest -s -v tests/ft/metrics/"test_metrics.py"          
           fi
-
-      - name: create cov report
-        run: |
-            sudo apt-get update
-            sudo apt-get -y install lcov
-            mkdir -p cov_report
-            ./create_cov_report.sh ${{ matrix.plugin }}
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          verbose: true
-          fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }}
-          directory: ./cov_report/
-          files: ./cov_report/cov-${{ matrix.plugin }}.info

.github/workflows/ci.yml

@@ -8,9 +8,9 @@ on:
       - published
 
 env:
-  VERSION: 2.12.0
+  VERSION: 2.13.2
   UI_VERSION: 2.6.1
-  BRANCH: main
+  BRANCH: v2.13
 
 jobs:
   cross-build:
@@ -19,7 +19,7 @@ jobs:
       matrix:
         arch:
           - [x86_64-linux-gnu, x86_64, amd64]
-    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-main
+    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -62,7 +62,7 @@ jobs:
       matrix:
         arch:
           - [x86_64-linux-gnu, x86_64, amd64]
-    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-main
+    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-v2.13
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/manual-unused-plugins.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   build:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -33,7 +33,7 @@ jobs:
 
   unused_plugins_test:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
     needs: [build]
     strategy:
       matrix:

cmake/aarch64-linux-gnu.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX aarch64-linux-gnu)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.13/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/arm-linux-gnueabi.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX arm-linux-gnueabi)
 set(CMAKE_SYSTEM_PROCESSOR armv5tejl)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.13/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/arm-linux-gnueabihf.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX arm-linux-gnueabihf)
 set(CMAKE_SYSTEM_PROCESSOR armv7l)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.13/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/x86_64-linux-gnu.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX x86_64-linux-gnu)
 set(CMAKE_SYSTEM_PROCESSOR x86_64)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.13/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

dev.conf

@@ -10,6 +10,5 @@ syslog = "<P>%d(%Y-%m-%dT%T%z) %H neuron[%p]: level=%v msg="[%c] %m" file="%f:%L
 
 [rules]
 
-*.*     "./logs/%c.log", 25MB * 1 ~ "./logs/%c.#2r.log"; file_format
+*.*     "./logs/%c.log", 50MB * 2 ~ "./logs/%c.#2r.log"; file_format
 *.*    	>stdout; stdout_format
-*.*     $remote_syslog,"%V"; syslog

include/neuron/adapter.h

@@ -86,6 +86,9 @@ typedef struct adapter_callbacks {
             void (*update_im)(neu_adapter_t *adapter, const char *group,
                               const char *tag, neu_dvalue_t value,
                               neu_tag_meta_t *metas, int n_meta);
+            void (*update_im_f_m)(neu_adapter_t *adapter, const char *group,
+                                  const char *tag, neu_dvalue_t value,
+                                  neu_tag_meta_t *metas, int n_meta);
             void (*scan_tags_response)(neu_adapter_t *adapter, void *r,
                                        neu_resp_scan_tags_t *resp_scan);
             void (*test_read_tag_response)(neu_adapter_t *adapter, void *r,

include/neuron/define.h

@@ -23,8 +23,8 @@
 #include <stdbool.h>
 
 #define NEU_VERSION_MAJOR 2
-#define NEU_VERSION_MINOR 12
-#define NEU_VERSION_FIX 0
+#define NEU_VERSION_MINOR 13
+#define NEU_VERSION_FIX 2
 
 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)
 #define NEU_GET_VERSION_MINOR(V) ((0x0000ff00 & V) >> 8)
@@ -67,7 +67,7 @@
 #define NEU_LOG_LEVEL_FATAL "fatal"
 
 #define NEU_CID_LNCLASS_LEN 12
-#define NEU_CID_LNTYPE_LEN 32
+#define NEU_CID_LNTYPE_LEN 40
 #define NEU_CID_LNPREFIX_LEN 10
 #define NEU_CID_LNINST_LEN 4
 #define NEU_CID_LDEVICE_LEN 32
@@ -85,7 +85,7 @@
 #define NEU_CID_DATASET_NAME_LEN 32
 #define NEU_CID_REPORT_NAME_LEN 32
 #define NEU_CID_REPORT_ID_LEN 64
-#define NEU_CID_ID_LEN 32
+#define NEU_CID_ID_LEN 40
 #define NEU_CID_REF_TYPE_LEN 32
 #define NEU_CID_IED_NAME_LEN 32
 #define NEU_CID_ACCESS_POINT_NAME_LEN 16
@@ -96,6 +96,9 @@
 #define NEU_CID_LEN32 32
 #define NEU_CID_LEN64 64
 
+#define NEU_TRACE_ID_LEN 64
+#define NEU_SPAN_ID_LEN 32
+
 #define CHECK_NODE_NAME_LENGTH_ERR                                            \
     do {                                                                      \
         NEU_JSON_RESPONSE_ERROR(NEU_ERR_NODE_NAME_TOO_LONG, {                 \

include/neuron/metrics.h

@@ -286,8 +286,8 @@ typedef struct {
 
 typedef struct {
     char                distro[32];
-    char                kernel[32];
-    char                machine[32];
+    char                kernel[80];
+    char                machine[80];
     char                clib[32];
     char                clib_version[32];
     unsigned            cpu_percent;

include/neuron/msg.h

@@ -654,8 +654,8 @@ static inline void neu_req_add_tag_fini(neu_req_add_tag_t *req)
 static inline int neu_req_add_tag_copy(neu_req_add_tag_t *dst,
                                        neu_req_add_tag_t *src)
 {
-    strcpy(dst->driver, src->driver);
-    strcpy(dst->group, src->group);
+    strncpy(dst->driver, src->driver, NEU_NODE_NAME_LEN - 1);
+    strncpy(dst->group, src->group, NEU_GROUP_NAME_LEN - 1);
     dst->tags = (neu_datatag_t *) calloc(src->n_tag, sizeof(src->tags[0]));
     if (NULL == dst->tags) {
         return -1;
@@ -690,8 +690,8 @@ static inline void neu_req_del_tag_fini(neu_req_del_tag_t *req)
 static inline int neu_req_del_tag_copy(neu_req_del_tag_t *dst,
                                        neu_req_del_tag_t *src)
 {
-    strcpy(dst->driver, src->driver);
-    strcpy(dst->group, src->group);
+    strncpy(dst->driver, src->driver, NEU_NODE_NAME_LEN - 1);
+    strncpy(dst->group, src->group, NEU_GROUP_NAME_LEN - 1);
     dst->tags = (char **) calloc(src->n_tag, sizeof(src->tags[0]));
     if (NULL == dst->tags) {
         return -1;
@@ -704,6 +704,7 @@ static inline int neu_req_del_tag_copy(neu_req_del_tag_t *dst,
                 free(dst->tags[i]);
             }
             free(dst->tags);
+            return -1;
         }
     }
     return 0;
@@ -834,7 +835,7 @@ static inline void neu_req_node_setting_fini(neu_req_node_setting_t *req)
 static inline int neu_req_node_setting_copy(neu_req_node_setting_t *dst,
                                             neu_req_node_setting_t *src)
 {
-    strcpy(dst->node, src->node);
+    strncpy(dst->node, src->node, NEU_NODE_NAME_LEN - 1);
     dst->setting = strdup(src->setting);
     return dst->setting ? 0 : -1;
 }
@@ -1625,8 +1626,9 @@ neu_tag_value_to_json_paginate(neu_resp_tag_value_meta_paginate_t *tag_value,
         tag_json->value.val_array_str.p_strs = tag_value->value.value.strs.strs;
         break;
     case NEU_TYPE_CUSTOM:
-        tag_json->t                = NEU_JSON_OBJECT;
-        tag_json->value.val_object = tag_value->value.value.json;
+        tag_json->t = NEU_JSON_OBJECT;
+        tag_json->value.val_object =
+            json_deep_copy(tag_value->value.value.json);
         break;
     default:
         break;
@@ -1657,13 +1659,13 @@ inline static void neu_msg_exchange(neu_reqresp_head_t *header)
 {
     char tmp[NEU_NODE_NAME_LEN] = { 0 };
 
-    strcpy(tmp, header->sender);
+    strncpy(tmp, header->sender, sizeof(tmp) - 1);
 
     memset(header->sender, 0, sizeof(header->sender));
-    strcpy(header->sender, header->receiver);
+    strncpy(header->sender, header->receiver, sizeof(header->sender) - 1);
 
     memset(header->receiver, 0, sizeof(header->receiver));
-    strcpy(header->receiver, tmp);
+    strncpy(header->receiver, tmp, sizeof(header->receiver) - 1);
 }
 
 typedef struct {

include/neuron/type.h

@@ -345,6 +345,11 @@ typedef struct {
     uint8_t     precision;
 } neu_dvalue_t;
 
+static inline bool neu_dvalue_is_array(const neu_dvalue_t *dvalue)
+{
+    return dvalue->type >= NEU_TYPE_ARRAY_CHAR;
+}
+
 static inline bool neu_equal_dvalue(const neu_dvalue_t *one, neu_dvalue_t *two)
 {
     if (one == NULL || two == NULL) {

include/neuron/utils/cid.h

@@ -114,6 +114,8 @@ inline static cid_basictype_e decode_basictype(const char *btype)
         ret = VisString64;
     } else if (strcmp(btype, "VisString255") == 0) {
         ret = VisString255;
+    } else if (strcmp(btype, "VisString65") == 0) {
+        ret = Unicode255;
     } else if (strcmp(btype, "Octet64") == 0) {
         ret = Octet64;
     } else if (strcmp(btype, "Struct") == 0) {
@@ -200,6 +202,10 @@ typedef struct {
 
     cid_basictype_e btypes[NEU_TAG_FORMAT_LENGTH]; // for do-[da]
     int             n_btypes;
+    cid_basictype_e btype;
+
+    bool    is_array;
+    uint8_t array_size;
 } cid_fcda_t;
 
 typedef struct {
@@ -298,6 +304,9 @@ typedef struct {
 
     cid_basictype_e btype;
     cid_fc_e        fc;
+
+    bool    is_array;
+    uint8_t array_size;
 } cid_tm_do_da_t;
 
 typedef struct {

include/neuron/utils/uthash.h

@@ -513,7 +513,7 @@ do {
  */
 #ifdef HASH_DEBUG
 #include <stdio.h>   /* fprintf, stderr */
-#define HASH_OOPS(...) do { fprintf(stderr, __VA_ARGS__); exit(-1); } while (0)
+#define HASH_OOPS(...) do { fprintf(stderr, "%s", __VA_ARGS__); exit(-1); } while (0)
 #define HASH_FSCK(hh,head,where)                                                 \
 do {                                                                             \
   struct UT_hash_handle *_thh;                                                   \

neuron.json

@@ -1,8 +1,8 @@
 {
-	"ip": "0.0.0.0",
+	"ip": "127.0.0.1",
 	"port": 7000,
 	"disable_auth": 0,
 	"syslog_host": "",
 	"syslog_port": 541,
 	"sub_filter_error": 0
-}
+}

persistence/0002_2.3.0_node_cache.sql

@@ -1,36 +0,0 @@
-/**
-* NEURON IIoT System for Industry 4.0
-* Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
-*
-* This program is free software; you can redistribute it and/or
-* modify it under the terms of the GNU Lesser General Public
-* License as published by the Free Software Foundation; either
-* version 3 of the License, or (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public License
-* along with this program; if not, write to the Free Software Foundation,
-* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-**/
-
---- fix primary key ---
-BEGIN;
-
-DROP TABLE IF EXISTS old_node_cache;
-ALTER TABLE node_cache RENAME TO old_node_cache;
-
-CREATE TABLE IF NOT EXISTS node_cache (
-  node_name TEXT PRIMARY KEY,
-  CACHE TEXT NOT NULL,
-  FOREIGN KEY (node_name) REFERENCES nodes (name) ON UPDATE CASCADE ON DELETE CASCADE
-);
-
-INSERT OR REPLACE INTO node_cache SELECT * FROM old_node_cache;
-
-DROP TABLE old_node_cache;
-
-COMMIT;

persistence/0113_2.13.0_certificates.sql

@@ -62,7 +62,7 @@ CREATE TABLE IF NOT EXISTS client_certificates (
     valid_from DATETIME,
     valid_to DATETIME,
     serial_number TEXT,
-    fingerprint TEXT UNIQUE,
+    fingerprint TEXT,
     certificate_data BLOB NOT NULL,
     is_ca INTEGER DEFAULT 0,
     trust_status INTEGER DEFAULT 0,
@@ -75,6 +75,7 @@ CREATE TABLE IF NOT EXISTS client_certificates (
 CREATE INDEX IF NOT EXISTS idx_client_certificates_app_name ON client_certificates(app_name);
 CREATE INDEX IF NOT EXISTS idx_client_certificates_common_name ON client_certificates(common_name);
 CREATE INDEX IF NOT EXISTS idx_client_certificates_fingerprint ON client_certificates(fingerprint);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_client_certificates_app_name_fingerprint ON client_certificates(app_name, fingerprint);
 
 -- Create security policies table for northbound app security management
 CREATE TABLE IF NOT EXISTS security_policies (

plugins/ekuiper/read_write.c

@@ -234,9 +234,22 @@ void recv_data_callback(void *arg)
     if (req->singular) {
         rv = send_write_tag_req(plugin, &req->single, json_str, trace_flag,
                                 trace_id, span_id);
+        if (rv == 0) {
+            plog_notice(plugin, "write tag %s.%s on node %s", req->single.group,
+                        req->single.tag, req->single.node);
+        }
     } else {
         rv = send_write_tags_req(plugin, &req->plural, json_str, trace_flag,
                                  trace_id, span_id);
+        if (rv == 0) {
+            if (req->plural.n_tag == 0) {
+                plog_warn(plugin, "no tags to write on node %s",
+                          req->plural.node);
+            } else {
+                plog_notice(plugin, "write %d tags on node %s",
+                            req->plural.n_tag, req->plural.node);
+            }
+        }
     }
 
     if (0 != rv) {
@@ -314,7 +327,7 @@ static int send_write_tag_req(neu_plugin_t *plugin, neu_json_write_req_t *req,
         header.ctx             = calloc(1, 48 + strlen(playload) + 1);
         binary_to_hex(trace_id, 16, header.ctx);
         binary_to_hex(span_id, 8, header.ctx + 32);
-        strcpy(header.ctx + 48, playload);
+        strncpy(header.ctx + 48, playload, strlen(playload));
     }
 
     neu_req_write_tag_t cmd = {
@@ -361,7 +374,7 @@ static int send_write_tags_req(neu_plugin_t *             plugin,
         header.ctx             = calloc(1, 48 + strlen(playload) + 1);
         binary_to_hex(trace_id, 16, header.ctx);
         binary_to_hex(span_id, 8, header.ctx + 32);
-        strcpy(header.ctx + 48, playload);
+        strncpy(header.ctx + 48, playload, strlen(playload));
     }
 
     neu_req_write_tags_t cmd = { 0 };
@@ -374,7 +387,7 @@ static int send_write_tags_req(neu_plugin_t *             plugin,
     }
 
     for (int i = 0; i < cmd.n_tag; i++) {
-        strcpy(cmd.tags[i].tag, req->tags[i].tag);
+        strncpy(cmd.tags[i].tag, req->tags[i].tag, NEU_TAG_NAME_LEN - 1);
         if (0 !=
             json_value_to_tag_value(&req->tags[i].value, req->tags[i].t,
                                     &cmd.tags[i].value)) {

plugins/modbus/modbus_stack.c

@@ -99,6 +99,8 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
         return -1;
     }
 
+    void *trace_ctx = (void *) ((intptr_t) stack + (intptr_t) stack->read_seq);
+
     switch (code.function) {
     case MODBUS_READ_COIL:
     case MODBUS_READ_INPUT:
@@ -107,7 +109,7 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
         neu_otel_trace_ctx trace = NULL;
         neu_otel_scope_ctx scope = NULL;
         if (neu_otel_data_is_started()) {
-            trace = neu_otel_find_trace((void *) (intptr_t) stack->read_seq);
+            trace = neu_otel_find_trace(trace_ctx);
             if (trace) {
                 char new_span_id[36] = { 0 };
                 neu_otel_new_span_id(new_span_id);
@@ -140,14 +142,14 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
                 stack->value_fn(stack->ctx, code.slave_id,
                                 header.len - sizeof(struct modbus_code) -
                                     sizeof(struct modbus_data),
-                                bytes, 0, (void *) (intptr_t) stack->read_seq);
+                                bytes, 0, trace_ctx);
             } else {
                 bytes = neu_protocol_unpack_buf(buf, data.n_byte);
                 if (bytes == NULL) {
                     return -1;
                 }
                 stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes,
-                                0, (void *) (intptr_t) stack->read_seq);
+                                0, trace_ctx);
             }
             break;
         case MODBUS_PROTOCOL_RTU:
@@ -156,7 +158,7 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
                 return -1;
             }
             stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes, 0,
-                            (void *) (intptr_t) stack->read_seq);
+                            trace_ctx);
             break;
         }
 
@@ -374,8 +376,10 @@ int modbus_stack_read(modbus_stack_t *stack, uint8_t slave_id,
                     neu_otel_trace_ctx trace = NULL;
                     neu_otel_scope_ctx scope = NULL;
                     trace                    = neu_otel_create_trace(
-                        new_trace_id, (void *) (intptr_t) stack->read_seq, 0,
-                        trace_state);
+                        new_trace_id,
+                        (void *) ((intptr_t) stack +
+                                  (intptr_t) stack->read_seq),
+                        0, trace_state);
                     if (trace) {
                         scope = neu_otel_add_span(trace);
                         neu_otel_scope_set_span_name(scope, "driver cmd send");

plugins/mqtt/mqtt_handle.c

@@ -39,7 +39,7 @@ static void to_traceparent(uint8_t *trace_id, char *span_id, char *out)
         size += sprintf(out + size, "%02x", trace_id[i]);
     }
 
-    sprintf(out + size, "-%s-01", span_id);
+    snprintf(out + size, strlen(span_id) + 5, "-%s-01", span_id);
 }
 
 static int tag_values_to_json(UT_array *tags, mqtt_static_vt_t *s_tags,
@@ -281,7 +281,7 @@ static inline int send_driver_action(neu_plugin_t *            plugin,
     header.ctx                = NULL;
 
     neu_req_driver_action_t action = { 0 };
-    strncpy(action.driver, req->driver, NEU_NODE_NAME_LEN);
+    strncpy(action.driver, req->driver, NEU_NODE_NAME_LEN - 1);
     action.action = strdup(req->action);
 
     if (0 != neu_plugin_op(plugin, header, &action)) {
@@ -465,7 +465,7 @@ static int send_write_tags_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
     }
 
     for (int i = 0; i < cmd.n_tag; i++) {
-        strcpy(cmd.tags[i].tag, req->tags[i].tag);
+        strncpy(cmd.tags[i].tag, req->tags[i].tag, NEU_TAG_NAME_LEN - 1);
         if (0 !=
             json_value_to_tag_value(&req->tags[i].value, req->tags[i].t,
                                     &cmd.tags[i].value)) {
@@ -574,6 +574,31 @@ void handle_write_req(neu_mqtt_qos_e qos, const char *topic,
             return;
         }
 
+        if (strlen(wr->node) >= NEU_NODE_NAME_LEN ||
+            strlen(wr->group) >= NEU_GROUP_NAME_LEN) {
+            plog_error(plugin, "node or group name too long");
+            model__write_request__free_unpacked(wr, NULL);
+            return;
+        }
+
+        for (size_t i = 0; i < wr->n_tags; i++) {
+            if (strlen(wr->tags[i]->name) >= NEU_TAG_NAME_LEN) {
+                plog_error(plugin, "tag name too long");
+                model__write_request__free_unpacked(wr, NULL);
+                return;
+            }
+
+            if (wr->tags[i]->value->value_case ==
+                MODEL__DATA_ITEM_VALUE__VALUE_STRING_VALUE) {
+                if (strlen(wr->tags[i]->value->string_value) >=
+                    NEU_VALUE_SIZE) {
+                    plog_error(plugin, "string tag value too long");
+                    model__write_request__free_unpacked(wr, NULL);
+                    return;
+                }
+            }
+        }
+
         mqtt              = calloc(1, sizeof(neu_json_mqtt_t));
         mqtt->uuid        = strdup(wr->uuid);
         mqtt->payload     = NULL;
@@ -593,7 +618,7 @@ void handle_write_req(neu_mqtt_qos_e qos, const char *topic,
         }
 
         for (int i = 0; i < cmd.n_tag; i++) {
-            strcpy(cmd.tags[i].tag, wr->tags[i]->name);
+            strncpy(cmd.tags[i].tag, wr->tags[i]->name, NEU_TAG_NAME_LEN - 1);
             switch (wr->tags[i]->value->value_case) {
             case MODEL__DATA_ITEM_VALUE__VALUE_INT_VALUE:
                 cmd.tags[i].value.type      = NEU_TYPE_INT64;
@@ -610,8 +635,8 @@ void handle_write_req(neu_mqtt_qos_e qos, const char *topic,
                 break;
             case MODEL__DATA_ITEM_VALUE__VALUE_STRING_VALUE:
                 cmd.tags[i].value.type = NEU_TYPE_STRING;
-                strcpy(cmd.tags[i].value.value.str,
-                       wr->tags[i]->value->string_value);
+                strncpy(cmd.tags[i].value.value.str,
+                        wr->tags[i]->value->string_value, NEU_VALUE_SIZE - 1);
                 break;
             default:
                 break;
@@ -907,7 +932,7 @@ void handle_driver_action_req(neu_mqtt_qos_e qos, const char *topic,
         mqtt->tracestate  = NULL;
 
         header.ctx = mqtt;
-        strcpy(cmd.driver, dar->node);
+        strncpy(cmd.driver, dar->node, NEU_NODE_NAME_LEN - 1);
         cmd.action = strdup(dar->action);
 
         model__driver_action_request__free_unpacked(dar, NULL);
@@ -930,7 +955,7 @@ void handle_driver_action_req(neu_mqtt_qos_e qos, const char *topic,
         }
 
         header.ctx = mqtt;
-        strcpy(cmd.driver, req->driver);
+        strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
         cmd.action = strdup(req->action);
         neu_json_decode_driver_action_req_free(req);
         free(json_str);
@@ -1768,8 +1793,8 @@ void handle_driver_directory_req(neu_mqtt_qos_e qos, const char *topic,
         mqtt->tracestate  = NULL;
 
         header.ctx = mqtt;
-        strcpy(cmd.driver, flr->node);
-        strcpy(cmd.path, flr->path);
+        strncpy(cmd.driver, flr->node, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.path, flr->path, NEU_PATH_LEN - 1);
 
         model__file_list_request__free_unpacked(flr, NULL);
     } else {
@@ -1792,8 +1817,8 @@ void handle_driver_directory_req(neu_mqtt_qos_e qos, const char *topic,
 
         header.ctx = mqtt;
 
-        strcpy(cmd.driver, req->driver);
-        strcpy(cmd.path, req->path);
+        strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.path, req->path, NEU_PATH_LEN - 1);
 
         neu_json_decode_driver_directory_req_free(req);
         free(json_str);
@@ -1957,8 +1982,8 @@ void handle_driver_fup_open_req(neu_mqtt_qos_e qos, const char *topic,
         mqtt->tracestate  = NULL;
 
         header.ctx = mqtt;
-        strcpy(cmd.driver, fur->node);
-        strcpy(cmd.path, fur->path);
+        strncpy(cmd.driver, fur->node, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.path, fur->path, NEU_PATH_LEN - 1);
 
         model__file_upload_request__free_unpacked(fur, NULL);
     } else {
@@ -1979,8 +2004,8 @@ void handle_driver_fup_open_req(neu_mqtt_qos_e qos, const char *topic,
             return;
         }
         header.ctx = mqtt;
-        strcpy(cmd.driver, req->driver);
-        strcpy(cmd.path, req->path);
+        strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.path, req->path, NEU_PATH_LEN - 1);
 
         neu_json_decode_driver_fup_open_req_free(req);
         free(json_str);
@@ -2084,8 +2109,8 @@ void handle_driver_fup_data_req(neu_mqtt_qos_e qos, const char *topic,
 
         header.ctx = mqtt;
 
-        strcpy(cmd.driver, fudr->node);
-        strcpy(cmd.path, fudr->path);
+        strncpy(cmd.driver, fudr->node, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.path, fudr->path, NEU_PATH_LEN - 1);
 
         model__file_upload_data_request__free_unpacked(fudr, NULL);
     } else {
@@ -2108,8 +2133,8 @@ void handle_driver_fup_data_req(neu_mqtt_qos_e qos, const char *topic,
 
         header.ctx = mqtt;
 
-        strcpy(cmd.driver, req->driver);
-        strcpy(cmd.path, req->path);
+        strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.path, req->path, NEU_PATH_LEN - 1);
 
         neu_json_decode_driver_fup_data_req_free(req);
         free(json_str);
@@ -2218,9 +2243,9 @@ void handle_driver_fdown_open_req(neu_mqtt_qos_e qos, const char *topic,
         mqtt->tracestate  = NULL;
 
         header.ctx = mqtt;
-        strcpy(cmd.driver, fdr->node);
-        strcpy(cmd.src_path, fdr->src_path);
-        strcpy(cmd.dst_path, fdr->dst_path);
+        strncpy(cmd.driver, fdr->node, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.src_path, fdr->src_path, NEU_PATH_LEN - 1);
+        strncpy(cmd.dst_path, fdr->dst_path, NEU_PATH_LEN - 1);
         cmd.size = fdr->size;
 
         model__file_download_request__free_unpacked(fdr, NULL);
@@ -2242,9 +2267,9 @@ void handle_driver_fdown_open_req(neu_mqtt_qos_e qos, const char *topic,
             return;
         }
         header.ctx = mqtt;
-        strcpy(cmd.driver, req->driver);
-        strcpy(cmd.src_path, req->src_path);
-        strcpy(cmd.dst_path, req->dst_path);
+        strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.src_path, req->src_path, NEU_PATH_LEN - 1);
+        strncpy(cmd.dst_path, req->dst_path, NEU_PATH_LEN - 1);
         cmd.size = req->size;
 
         neu_json_decode_driver_fdown_open_req_free(req);
@@ -2346,8 +2371,8 @@ void handle_driver_fdown_data_req(neu_mqtt_qos_e qos, const char *topic,
         mqtt->tracestate  = NULL;
 
         header.ctx = mqtt;
-        strcpy(cmd.driver, fddr->node);
-        strcpy(cmd.src_path, fddr->path);
+        strncpy(cmd.driver, fddr->node, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.src_path, fddr->path, NEU_PATH_LEN - 1);
         cmd.more = fddr->more;
         cmd.len  = fddr->data.len;
         cmd.data = calloc(fddr->data.len, sizeof(uint8_t));
@@ -2373,8 +2398,8 @@ void handle_driver_fdown_data_req(neu_mqtt_qos_e qos, const char *topic,
         }
         header.ctx = mqtt;
 
-        strcpy(cmd.driver, req->driver);
-        strcpy(cmd.src_path, req->src_path);
+        strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+        strncpy(cmd.src_path, req->src_path, NEU_PATH_LEN - 1);
         cmd.more = req->more;
         cmd.len  = req->len;
         cmd.data = calloc(req->len, sizeof(uint8_t));

plugins/mqtt/mqtt_plugin_intf.c

@@ -167,6 +167,7 @@ int mqtt_plugin_uninit(neu_plugin_t *plugin)
 
     mqtt_config_fini(&plugin->config);
     if (plugin->client) {
+        neu_mqtt_client_remove_cache_db(plugin->client);
         neu_mqtt_client_close(plugin->client);
         neu_mqtt_client_free(plugin->client);
         plugin->client = NULL;
@@ -395,6 +396,7 @@ int mqtt_plugin_config(neu_plugin_t *plugin, const char *setting)
     }
 
     if (plugin->client != NULL) {
+        neu_mqtt_client_remove_cache_db(plugin->client);
         neu_mqtt_client_close(plugin->client);
         neu_mqtt_client_free(plugin->client);
     }

plugins/mqtt/schema.c

@@ -24,7 +24,7 @@ static int mqtt_schema_parse(json_t *root, mqtt_schema_vt_t **vts,
             mqtt_schema_vt_t *vt = &(*vts)[*vts_len - 1];
 
             memset(vt, 0, sizeof(mqtt_schema_vt_t));
-            strcpy(vt->name, key);
+            strncpy(vt->name, key, sizeof(vt->name) - 1);
 
             if (strcmp(str_val, "${timestamp}") == 0) {
                 vt->vt = MQTT_SCHEMA_TIMESTAMP;
@@ -50,7 +50,7 @@ static int mqtt_schema_parse(json_t *root, mqtt_schema_vt_t **vts,
                     return -1;
                 } else {
                     vt->vt = MQTT_SCHEMA_UD;
-                    strcpy(vt->ud, str_val);
+                    strncpy(vt->ud, str_val, sizeof(vt->ud) - 1);
                 }
             }
         } else if (json_is_object(value)) {
@@ -63,7 +63,7 @@ static int mqtt_schema_parse(json_t *root, mqtt_schema_vt_t **vts,
             mqtt_schema_vt_t *vt = &(*vts)[*vts_len - 1];
 
             memset(vt, 0, sizeof(mqtt_schema_vt_t));
-            strcpy(vt->name, key);
+            strncpy(vt->name, key, sizeof(vt->name) - 1);
 
             vt->vt = MQTT_SCHEMA_OBJECT;
             return mqtt_schema_parse(value, &vt->sub_vts, &vt->n_sub_vts,
@@ -338,7 +338,7 @@ int mqtt_static_validate(const char *static_tags, mqtt_static_vt_t **vts,
         mqtt_static_vt_t *vt = &(*vts)[*vts_len - 1];
 
         memset(vt, 0, sizeof(mqtt_static_vt_t));
-        strcpy(vt->name, key);
+        strncpy(vt->name, key, sizeof(vt->name) - 1);
 
         if (json_is_string(value)) {
             vt->jtype          = NEU_JSON_STR;

plugins/restful/adapter_handle.c

@@ -56,8 +56,8 @@ void handle_add_adapter(nng_aio *aio)
 
                 header.ctx  = aio;
                 header.type = NEU_REQ_ADD_NODE;
-                strcpy(cmd.node, req->name);
-                strcpy(cmd.plugin, req->plugin);
+                strncpy(cmd.node, req->name, NEU_NODE_NAME_LEN - 1);
+                strncpy(cmd.plugin, req->plugin, NEU_PLUGIN_NAME_LEN - 1);
                 cmd.setting  = req->setting;
                 req->setting = NULL; // moved
                 ret          = neu_plugin_op(plugin, header, &cmd);
@@ -96,8 +96,8 @@ static inline int send_node_update_req(nng_aio *                   aio,
     }
 
     neu_req_update_node_t cmd = { 0 };
-    strcpy(cmd.node, req->name);
-    strcpy(cmd.new_name, req->new_name);
+    strncpy(cmd.node, req->name, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.new_name, req->new_name, NEU_NODE_NAME_LEN - 1);
 
     neu_reqresp_head_t header = {
         .ctx             = aio,
@@ -140,7 +140,7 @@ void handle_del_adapter(nng_aio *aio)
 
                 header.ctx  = aio;
                 header.type = NEU_REQ_DEL_NODE;
-                strcpy(cmd.node, req->name);
+                strncpy(cmd.node, req->name, NEU_NODE_NAME_LEN - 1);
                 ret = neu_plugin_op(plugin, header, &cmd);
                 if (ret != 0) {
                     NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
@@ -178,16 +178,16 @@ void handle_get_adapter(nng_aio *aio)
 
     if (neu_http_get_param_str(aio, "plugin", plugin_name,
                                sizeof(plugin_name)) > 0) {
-        strcpy(cmd.plugin, plugin_name);
+        strncpy(cmd.plugin, plugin_name, NEU_PLUGIN_NAME_LEN - 1);
     }
 
     if (neu_http_get_param_str(aio, "node", node_name, sizeof(node_name)) > 0) {
-        strcpy(cmd.node, node_name);
+        strncpy(cmd.node, node_name, NEU_NODE_NAME_LEN - 1);
     }
 
     if (neu_http_get_param_str(aio, "group", group_name, sizeof(group_name)) >
         0) {
-        strcpy(cmd.query.q_group_name, group_name);
+        strncpy(cmd.query.q_group_name, group_name, NEU_GROUP_NAME_LEN - 1);
     }
 
     uintmax_t query_state = 0;
@@ -265,7 +265,7 @@ void handle_set_node_setting(nng_aio *aio)
 
                 header.ctx  = aio;
                 header.type = NEU_REQ_NODE_SETTING;
-                strcpy(cmd.node, req->node);
+                strncpy(cmd.node, req->node, NEU_NODE_NAME_LEN - 1);
                 cmd.setting  = req->setting;
                 req->setting = NULL; // ownership moved
                 ret          = neu_plugin_op(plugin, header, &cmd);
@@ -299,7 +299,7 @@ void handle_get_node_setting(nng_aio *aio)
     header.ctx             = aio;
     header.type            = NEU_REQ_GET_NODE_SETTING;
     header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
-    strcpy(cmd.node, node_name);
+    strncpy(cmd.node, node_name, NEU_NODE_NAME_LEN - 1);
 
     ret = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {
@@ -348,7 +348,7 @@ void handle_node_ctl(nng_aio *aio)
 
                 header.ctx  = aio;
                 header.type = NEU_REQ_NODE_CTL;
-                strcpy(cmd.node, req->node);
+                strncpy(cmd.node, req->node, NEU_NODE_NAME_LEN - 1);
                 cmd.ctl = req->cmd;
 
                 ret = neu_plugin_op(plugin, header, &cmd);
@@ -379,7 +379,7 @@ void handle_get_node_state(nng_aio *aio)
         header.type = NEU_REQ_GET_NODES_STATE;
     } else {
         header.type = NEU_REQ_GET_NODE_STATE;
-        strcpy(cmd.node, node_name);
+        strncpy(cmd.node, node_name, NEU_NODE_NAME_LEN - 1);
     }
 
     ret = neu_plugin_op(plugin, header, &cmd);
@@ -453,7 +453,8 @@ static int json_to_gdatatags(neu_json_gtag_array_t *gtag_array,
     }
 
     for (int i = 0; i < gtag_array->len; i++) {
-        strcpy(gdatatags[i].group, gtag_array->gtags[i].group);
+        strncpy(gdatatags[i].group, gtag_array->gtags[i].group,
+                NEU_GROUP_NAME_LEN - 1);
         gdatatags[i].n_tag    = gtag_array->gtags[i].n_tag;
         gdatatags[i].interval = gtag_array->gtags[i].interval;
         gdatatags[i].tags =

plugins/restful/cid_handle.c

@@ -17,7 +17,7 @@ void handle_cid(nng_aio *aio)
     neu_plugin_t *plugin = neu_rest_get_plugin();
     (void) plugin;
 
-    NEU_PROCESS_HTTP_REQUEST(
+    NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
         aio, neu_json_upload_cid_t, neu_json_decode_upload_cid_req, {
             cid_t cid      = { 0 };
             int   parse_re = neu_cid_parse(req->path, &cid);

plugins/restful/datatag_handle.c

@@ -76,8 +76,8 @@ void handle_add_tags(nng_aio *aio)
                 } else {
                     header.ctx  = aio;
                     header.type = NEU_REQ_ADD_TAG;
-                    strcpy(cmd.driver, req->node);
-                    strcpy(cmd.group, req->group);
+                    strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
+                    strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
                     cmd.n_tag = req->n_tag;
                     cmd.tags  = calloc(req->n_tag, sizeof(neu_datatag_t));
 
@@ -184,12 +184,13 @@ void handle_add_gtags(nng_aio *aio)
             if (add_resp.error > 0) {
                 handle_add_tags_resp(aio, &add_resp);
             } else {
-                strcpy(cmd.driver, req->node);
+                strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
                 cmd.n_group = req->n_group;
                 cmd.groups  = calloc(req->n_group, sizeof(neu_gdatatag_t));
 
                 for (int i = 0; i < req->n_group; i++) {
-                    strcpy(cmd.groups[i].group, req->groups[i].group);
+                    strncpy(cmd.groups[i].group, req->groups[i].group,
+                            NEU_GROUP_NAME_LEN - 1);
                     cmd.groups[i].n_tag    = req->groups[i].n_tag;
                     cmd.groups[i].interval = req->groups[i].interval;
                     cmd.groups[i].tags =
@@ -267,7 +268,7 @@ void handle_import_tags(nng_aio *aio)
                 header.type            = NEU_REQ_IMPORT_TAGS;
                 header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
 
-                strcpy(cmd.node, req->node);
+                strncpy(cmd.node, req->node, NEU_NODE_NAME_LEN - 1);
 
                 int ret = neu_plugin_op(plugin, header, &cmd);
                 if (ret != 0) {
@@ -318,8 +319,8 @@ void handle_del_tags(nng_aio *aio)
                 goto error;
             }
 
-            strcpy(cmd.driver, req->node);
-            strcpy(cmd.group, req->group);
+            strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
+            strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
             cmd.n_tag = req->n_tags;
 
             for (int i = 0; i < req->n_tags; i++) {
@@ -364,8 +365,8 @@ void handle_update_tags(nng_aio *aio)
             header.type            = NEU_REQ_UPDATE_TAG;
             header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
 
-            strcpy(cmd.driver, req->node);
-            strcpy(cmd.group, req->group);
+            strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
+            strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
             cmd.n_tag = req->n_tag;
             cmd.tags  = calloc(req->n_tag, sizeof(neu_datatag_t));
 
@@ -428,11 +429,11 @@ void handle_get_tags(nng_aio *aio)
     }
 
     if (neu_http_get_param_str(aio, "name", tag_name, sizeof(tag_name)) >= 0) {
-        strcpy(cmd.name, tag_name);
+        strncpy(cmd.name, tag_name, NEU_TAG_NAME_LEN - 1);
     }
 
-    strcpy(cmd.driver, node);
-    strcpy(cmd.group, group);
+    strncpy(cmd.driver, node, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, group, NEU_GROUP_NAME_LEN - 1);
 
     ret = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {

plugins/restful/global_config_handle.c

@@ -771,8 +771,8 @@ static int get_tags(context_t *ctx, neu_resp_driver_group_info_t *info)
     };
 
     neu_req_get_tag_t cmd = { 0 };
-    strcpy(cmd.driver, info->driver);
-    strcpy(cmd.group, info->group);
+    strncpy(cmd.driver, info->driver, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, info->group, NEU_GROUP_NAME_LEN - 1);
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
         rv = NEU_ERR_IS_BUSY;
@@ -925,7 +925,7 @@ static int get_subscriptions(context_t *ctx, neu_resp_node_info_t *info)
     };
 
     neu_req_get_subscribe_group_t cmd = { 0 };
-    strcpy(cmd.app, info->node);
+    strncpy(cmd.app, info->node, NEU_NODE_NAME_LEN - 1);
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
         return NEU_ERR_IS_BUSY;
@@ -1009,7 +1009,7 @@ static int get_setting(context_t *ctx, neu_resp_node_info_t *info)
     };
 
     neu_req_get_node_setting_t cmd = { 0 };
-    strcpy(cmd.node, info->node);
+    strncpy(cmd.node, info->node, NEU_NODE_NAME_LEN - 1);
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
         return NEU_ERR_IS_BUSY;
@@ -1089,7 +1089,7 @@ static int del_node(context_t *ctx, neu_resp_node_info_t *info)
     };
 
     neu_req_del_node_t cmd = { 0 };
-    strcpy(cmd.node, info->node);
+    strncpy(cmd.node, info->node, NEU_NODE_NAME_LEN - 1);
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
         return NEU_ERR_IS_BUSY;
@@ -1109,8 +1109,8 @@ static int add_node(context_t *ctx, neu_json_get_nodes_resp_node_t *req)
     };
 
     neu_req_add_node_t cmd = { 0 };
-    strcpy(cmd.node, req->name);
-    strcpy(cmd.plugin, req->plugin);
+    strncpy(cmd.node, req->name, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.plugin, req->plugin, NEU_PLUGIN_NAME_LEN - 1);
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
         return NEU_ERR_IS_BUSY;
@@ -1131,8 +1131,8 @@ static int add_group(context_t *                             ctx,
     };
 
     neu_req_add_group_t cmd = { 0 };
-    strcpy(cmd.driver, data->driver);
-    strcpy(cmd.group, data->group);
+    strncpy(cmd.driver, data->driver, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, data->group, NEU_GROUP_NAME_LEN - 1);
     cmd.interval = data->interval;
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
@@ -1154,8 +1154,8 @@ static int add_tag(context_t *ctx, neu_json_add_tags_req_t *data)
     };
 
     neu_req_add_tag_t cmd = { 0 };
-    strcpy(cmd.driver, data->node);
-    strcpy(cmd.group, data->group);
+    strncpy(cmd.driver, data->node, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, data->group, NEU_GROUP_NAME_LEN - 1);
     cmd.n_tag = data->n_tag;
     cmd.tags  = calloc(data->n_tag, sizeof(neu_datatag_t));
     if (NULL == cmd.tags) {
@@ -1207,9 +1207,9 @@ static int add_subscription(context_t *ctx, neu_json_subscribe_req_t *data)
     };
 
     neu_req_subscribe_t cmd = { 0 };
-    strcpy(cmd.app, data->app);
-    strcpy(cmd.driver, data->driver);
-    strcpy(cmd.group, data->group);
+    strncpy(cmd.app, data->app, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.driver, data->driver, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, data->group, NEU_GROUP_NAME_LEN - 1);
     cmd.params   = data->params; // ownership moved
     data->params = NULL;
 
@@ -1231,7 +1231,7 @@ static int add_setting(context_t *ctx, neu_json_node_setting_req_t *data)
     };
 
     neu_req_node_setting_t cmd = { 0 };
-    strcpy(cmd.node, data->node);
+    strncpy(cmd.node, data->node, NEU_NODE_NAME_LEN - 1);
     cmd.setting   = data->setting; // ownership moved
     data->setting = NULL;
 

plugins/restful/group_config_handle.c

@@ -48,8 +48,8 @@ void handle_add_group_config(nng_aio *aio)
                 header.ctx                 = aio;
                 header.type                = NEU_REQ_ADD_GROUP;
                 header.otel_trace_type     = NEU_OTEL_TRACE_TYPE_REST_COMM;
-                strcpy(cmd.driver, req->node);
-                strcpy(cmd.group, req->group);
+                strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
+                strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
                 cmd.interval = req->interval;
                 ret          = neu_plugin_op(plugin, header, &cmd);
                 if (ret != 0) {
@@ -92,14 +92,14 @@ static inline int send_update_group(nng_aio *                           aio,
         } else if (len >= NEU_GROUP_NAME_LEN) {
             return NEU_ERR_GROUP_NAME_TOO_LONG;
         }
-        strcpy(cmd.new_name, req->new_name);
+        strncpy(cmd.new_name, req->new_name, NEU_GROUP_NAME_LEN - 1);
     } else {
         // if `new_name` is omitted, then keep the node name
-        strcpy(cmd.new_name, req->group);
+        strncpy(cmd.new_name, req->group, NEU_GROUP_NAME_LEN - 1);
     }
 
-    strcpy(cmd.driver, req->node);
-    strcpy(cmd.group, req->group);
+    strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
     cmd.interval = req->set_interval ? req->interval : 0;
 
     neu_reqresp_head_t header = {
@@ -146,8 +146,8 @@ void handle_del_group_config(nng_aio *aio)
                 header.ctx             = aio;
                 header.type            = NEU_REQ_DEL_GROUP;
                 header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
-                strcpy(cmd.driver, req->node);
-                strcpy(cmd.group, req->group);
+                strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
+                strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
                 ret = neu_plugin_op(plugin, header, &cmd);
                 if (ret != 0) {
                     NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
@@ -174,14 +174,14 @@ void handle_get_group_config(nng_aio *aio)
     NEU_VALIDATE_JWT(aio);
 
     neu_http_get_param_str(aio, "node", node_name, sizeof(node_name));
-    strcpy(cmd.driver, node_name);
+    strncpy(cmd.driver, node_name, NEU_NODE_NAME_LEN - 1);
     if (strlen(cmd.driver) == 0) {
         header.type = NEU_REQ_GET_DRIVER_GROUP;
     }
 
     if (neu_http_get_param_str(aio, "group", group_name, sizeof(group_name)) >
         0) {
-        strcpy(cmd.q_group, group_name);
+        strncpy(cmd.q_group, group_name, NEU_GROUP_NAME_LEN - 1);
     }
 
     ret = neu_plugin_op(plugin, header, &cmd);
@@ -273,9 +273,9 @@ static inline int send_subscribe(nng_aio *aio, neu_reqresp_type_e type,
     }
 
     neu_req_subscribe_t cmd = { 0 };
-    strcpy(cmd.app, req->app);
-    strcpy(cmd.driver, req->driver);
-    strcpy(cmd.group, req->group);
+    strncpy(cmd.app, req->app, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+    strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
     cmd.params       = req->params;      // ownership moved
     cmd.static_tags  = req->static_tags; // ownership moved
     req->params      = NULL;
@@ -340,9 +340,9 @@ void handle_grp_unsubscribe(nng_aio *aio)
                 goto error;
             }
 
-            strcpy(cmd.app, req->app);
-            strcpy(cmd.driver, req->driver);
-            strcpy(cmd.group, req->group);
+            strncpy(cmd.app, req->app, NEU_NODE_NAME_LEN - 1);
+            strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+            strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
             ret = neu_plugin_op(plugin, header, &cmd);
             if (ret != 0) {
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {

plugins/restful/handle.c

@@ -121,12 +121,6 @@ static struct neu_http_handler cors_handler[] = {
     {
         .url = "/api/v2/log/level",
     },
-    {
-        .url = "/api/v2/log/list",
-    },
-    {
-        .url = "/api/v2/log/file",
-    },
     {
         .url = "/api/v2/global/config",
     },
@@ -464,18 +458,6 @@ static struct neu_http_handler rest_handlers[] = {
         .url           = "/api/v2/log/global",
         .value.handler = handle_get_global_log_level,
     },
-    {
-        .method        = NEU_HTTP_METHOD_GET,
-        .type          = NEU_HTTP_HANDLER_FUNCTION,
-        .url           = "/api/v2/log/list",
-        .value.handler = handle_log_list,
-    },
-    {
-        .method        = NEU_HTTP_METHOD_GET,
-        .type          = NEU_HTTP_HANDLER_FUNCTION,
-        .url           = "/api/v2/log/file",
-        .value.handler = handle_log_file,
-    },
     {
         .method        = NEU_HTTP_METHOD_GET,
         .type          = NEU_HTTP_HANDLER_FUNCTION,

plugins/restful/log_handle.c

@@ -90,7 +90,8 @@ void handle_log_level(nng_aio *aio)
                     cmd.core               = req->core;
                     cmd.log_level          = log_level;
                     if (req->node_name != NULL) {
-                        strcpy(cmd.node, req->node_name);
+                        strncpy(cmd.node, req->node_name,
+                                NEU_NODE_NAME_LEN - 1);
                     }
 
                     int ret = neu_plugin_op(plugin, header, &cmd);
@@ -194,121 +195,3 @@ void handle_get_global_log_level(nng_aio *aio)
 
     neu_http_ok(aio, json_response);
 }
-
-void handle_log_list(nng_aio *aio)
-{
-    NEU_VALIDATE_JWT(aio);
-
-    char log_dir[PATH_MAX] = { 0 };
-    getcwd(log_dir, PATH_MAX - 1);
-    strncat(log_dir, "/", sizeof(log_dir) - strlen(log_dir) - 1);
-    strncat(log_dir, LOG_DIR, sizeof(log_dir) - strlen(log_dir) - 1);
-    DIR *dir = opendir(log_dir);
-    if (NULL == dir) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_NOT_EXIST, {
-            neu_http_response(aio, NEU_ERR_FILE_NOT_EXIST, result_error);
-        });
-    }
-
-    UT_icd    icd       = { sizeof(neu_resp_log_file_t), NULL, NULL, NULL };
-    UT_array *log_files = NULL;
-    utarray_new(log_files, &icd);
-
-    struct dirent *entry = NULL;
-    while (NULL != (entry = readdir(dir))) {
-        if (NULL == strstr(entry->d_name, ".log")) {
-            continue;
-        }
-
-        char full_path[PATH_MAX] = { 0 };
-        strncpy(full_path, log_dir, sizeof(full_path) - 1);
-        strncat(full_path, "/", sizeof(full_path) - strlen(full_path) - 1);
-        strncat(full_path, entry->d_name,
-                sizeof(full_path) - strlen(full_path) - 1);
-        struct stat st = { 0 };
-        if (0 != stat(full_path, &st)) {
-            continue;
-        }
-
-        neu_resp_log_file_t log_file = { 0 };
-        strncpy(log_file.file, entry->d_name, sizeof(log_file.file) - 1);
-        log_file.size = st.st_size;
-        utarray_push_back(log_files, &log_file);
-    }
-    closedir(dir);
-
-    char *result = NULL;
-    neu_json_encode_by_fn(log_files, neu_json_encode_log_list_resp, &result);
-    neu_http_ok(aio, result);
-    free(result);
-    utarray_free(log_files);
-}
-
-static int response(nng_aio *aio, char *content, enum nng_http_status status)
-{
-    nng_http_res *res = NULL;
-
-    nng_http_res_alloc(&res);
-
-    nng_http_res_set_header(res, "Content-Type", "text/plain");
-    nng_http_res_set_header(res, "Access-Control-Allow-Origin", "*");
-    nng_http_res_set_header(res, "Access-Control-Allow-Methods",
-                            "POST,GET,PUT,DELETE,OPTIONS");
-    nng_http_res_set_header(res, "Access-Control-Allow-Headers", "*");
-
-    if (content != NULL && strlen(content) > 0) {
-        nng_http_res_copy_data(res, content, strlen(content));
-    }
-
-    nng_http_res_set_status(res, status);
-
-    nng_http_req *nng_req = nng_aio_get_input(aio, 0);
-    nlog_notice("<%p> %s %s [%d]", aio, nng_http_req_get_method(nng_req),
-                nng_http_req_get_uri(nng_req), status);
-
-    nng_aio_set_output(aio, 0, res);
-    nng_aio_finish(aio, 0);
-
-    return 0;
-}
-
-void handle_log_file(nng_aio *aio)
-{
-    NEU_VALIDATE_JWT(aio);
-
-    char file_name[NEU_NODE_NAME_LEN] = { 0 };
-    if (neu_http_get_param_str(aio, "name", file_name, sizeof(file_name)) <=
-        0) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_PARAM_IS_WRONG, {
-            neu_http_response(aio, error_code.error, result_error);
-        })
-        return;
-    }
-
-    char path[PATH_MAX] = { 0 };
-    getcwd(path, PATH_MAX - 1);
-    strncat(path, "/", sizeof(path) - strlen(path) - 1);
-    strncat(path, LOG_DIR, sizeof(path) - strlen(path) - 1);
-
-    strncat(path, "/", sizeof(path) - strlen(path) - 1);
-    strncat(path, file_name, sizeof(path) - strlen(path) - 1);
-
-    FILE *file = fopen(path, "r");
-    if (NULL == file) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_NOT_EXIST, {
-            neu_http_response(aio, NEU_ERR_FILE_NOT_EXIST, result_error);
-        });
-    }
-
-    fseek(file, 0, SEEK_END);
-    long file_size = ftell(file);
-    fseek(file, 0, SEEK_SET);
-
-    char *file_content = (char *) malloc(file_size + 1);
-    fread(file_content, 1, file_size, file);
-    file_content[file_size] = '\0';
-    fclose(file);
-
-    response(aio, file_content, NNG_HTTP_STATUS_OK);
-    free(file_content);
-}

plugins/restful/log_handle.h

@@ -22,11 +22,8 @@
 
 #include <nng/nng.h>
 
-// void handle_get_log(nng_aio *aio);
 void handle_log_level(nng_aio *aio);
 void handle_global_log_level(nng_aio *aio);
 void handle_get_global_log_level(nng_aio *aio);
-void handle_log_list(nng_aio *aio);
-void handle_log_file(nng_aio *aio);
 
 #endif

plugins/restful/normal_handle.c

@@ -114,7 +114,7 @@ void handle_get_user(nng_aio *aio)
     utarray_foreach(user_infos, neu_persist_user_info_t *, p_info)
     {
         neu_json_user_resp_t resp = { 0 };
-        strcpy(resp.name, p_info->name);
+        strncpy(resp.name, p_info->name, NEU_USER_NAME_MAX_LEN);
         utarray_push_back(user_list, &resp);
     }
     utarray_free(user_infos);
@@ -547,7 +547,7 @@ void handle_get_plugin_schema(nng_aio *aio)
 
     header.ctx  = aio;
     header.type = NEU_REQ_CHECK_SCHEMA;
-    strcpy(cmd.schema, schema_name);
+    strncpy(cmd.schema, schema_name, NEU_PLUGIN_NAME_LEN - 1);
 
     ret = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {
@@ -809,6 +809,7 @@ done:
 
 void handle_export_db(nng_aio *aio)
 {
+    NEU_VALIDATE_JWT(aio);
     write_csv_header();
 
     UT_array *nodes = NULL;
@@ -835,11 +836,7 @@ void handle_export_db(nng_aio *aio)
         rv             = neu_persister_load_node_setting(node->name,
                                              (const char **) &settings);
         if (rv != 0) {
-            NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                neu_http_response(aio, error_code.error, result_error);
-            });
-            utarray_free(nodes);
-            return;
+            continue;
         }
         rv = settings_write_to_csv("settings.csv", node->name, settings);
         free(settings);
@@ -858,11 +855,7 @@ void handle_export_db(nng_aio *aio)
             UT_array *subscribers = NULL;
             rv = neu_persister_load_subscriptions(node->name, &subscribers);
             if (rv != 0) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                    neu_http_response(aio, error_code.error, result_error);
-                });
-                utarray_free(nodes);
-                return;
+                continue;
             }
             rv = subscribes_write_to_csv("subscribes.csv", node->name,
                                          subscribers);
@@ -882,11 +875,7 @@ void handle_export_db(nng_aio *aio)
         UT_array *groups = NULL;
         rv               = neu_persister_load_groups(node->name, &groups);
         if (rv != 0) {
-            NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                neu_http_response(aio, error_code.error, result_error);
-            });
-            utarray_free(nodes);
-            return;
+            continue;
         }
         rv = groups_write_to_csv("groups.csv", node->name, groups);
         if (rv != 0) {
@@ -902,12 +891,7 @@ void handle_export_db(nng_aio *aio)
             UT_array *tags = NULL;
             rv = neu_persister_load_tags(node->name, group->name, &tags);
             if (rv != 0) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                    neu_http_response(aio, error_code.error, result_error);
-                });
-                utarray_free(nodes);
-                utarray_free(groups);
-                return;
+                continue;
             }
             rv = tags_write_to_csv("tags.csv", node->name, group->name, tags);
             if (rv != 0) {
@@ -925,14 +909,15 @@ void handle_export_db(nng_aio *aio)
 
     utarray_free(nodes);
 
-    system("rm -rf neuron.tar.gz");
-    system("tar -zcf neuron.tar.gz nodes.csv settings.csv groups.csv tags.csv "
+    system("rm -rf /tmp/neuron.zip");
+    system("zip /tmp/neuron.zip nodes.csv settings.csv groups.csv tags.csv "
            "subscribes.csv");
 
     void * data = NULL;
     size_t len  = 0;
 
-    rv = read_file("neuron.tar.gz", &data, &len);
+    rv = read_file("/tmp/neuron.zip", &data, &len);
+    nlog_info("read_file /tmp/neuron.zip rv=%d, len=%zu", rv, len);
     if (rv != 0) {
         NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_READ_FAILURE, {
             neu_http_response(aio, error_code.error, result_error);
@@ -940,6 +925,6 @@ void handle_export_db(nng_aio *aio)
         return;
     }
     neu_http_response_file(aio, data, len,
-                           "attachment; filename=\"neuron.tar.gz\"");
+                           "attachment; filename=\"neuron.zip\"");
     free(data);
 }

plugins/restful/plugin_handle.c

@@ -91,7 +91,7 @@ void handle_del_plugin(nng_aio *aio)
             header.type            = NEU_REQ_DEL_PLUGIN;
             header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
             if (strlen(req->plugin) <= sizeof(cmd.plugin)) {
-                strcpy(cmd.plugin, req->plugin);
+                strncpy(cmd.plugin, req->plugin, NEU_PLUGIN_NAME_LEN - 1);
                 int ret = neu_plugin_op(plugin, header, &cmd);
                 if (ret != 0) {
                     NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {

plugins/restful/rw_handle.c

@@ -171,10 +171,10 @@ void handle_test_read_tag(nng_aio *aio)
                 goto error;
             }
 
-            strcpy(cmd.driver, req->driver);
-            strcpy(cmd.group, req->group);
-            strcpy(cmd.tag, req->tag);
-            strcpy(cmd.address, req->address);
+            strncpy(cmd.driver, req->driver, NEU_NODE_NAME_LEN - 1);
+            strncpy(cmd.group, req->group, NEU_GROUP_NAME_LEN - 1);
+            strncpy(cmd.tag, req->tag, NEU_TAG_NAME_LEN - 1);
+            strncpy(cmd.address, req->address, NEU_TAG_ADDRESS_LEN - 1);
             cmd.attribute = req->attribute;
             cmd.type      = req->type;
             cmd.precision = req->precision;
@@ -316,7 +316,8 @@ void handle_write(nng_aio *aio)
                 break;
             case NEU_JSON_STR:
                 cmd.value.type = NEU_TYPE_STRING;
-                strcpy(cmd.value.value.str, req->value.val_str);
+                strncpy(cmd.value.value.str, req->value.val_str,
+                        NEU_VALUE_SIZE);
                 break;
             case NEU_JSON_DOUBLE:
                 cmd.value.type      = NEU_TYPE_DOUBLE;
@@ -522,7 +523,8 @@ void handle_write_tags(nng_aio *aio)
             req->group = NULL; // ownership moved
 
             for (int i = 0; i < cmd.n_tag; i++) {
-                strcpy(cmd.tags[i].tag, req->tags[i].tag);
+                strncpy(cmd.tags[i].tag, req->tags[i].tag,
+                        NEU_TAG_NAME_LEN - 1);
                 switch (req->tags[i].t) {
                 case NEU_JSON_INT:
                     cmd.tags[i].value.type      = NEU_TYPE_INT64;
@@ -530,8 +532,8 @@ void handle_write_tags(nng_aio *aio)
                     break;
                 case NEU_JSON_STR:
                     cmd.tags[i].value.type = NEU_TYPE_STRING;
-                    strcpy(cmd.tags[i].value.value.str,
-                           req->tags[i].value.val_str);
+                    strncpy(cmd.tags[i].value.value.str,
+                            req->tags[i].value.val_str, NEU_VALUE_SIZE);
                     break;
                 case NEU_JSON_DOUBLE:
                     cmd.tags[i].value.type      = NEU_TYPE_DOUBLE;
@@ -650,7 +652,8 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
             calloc(cmd->groups[i].n_tag, sizeof(neu_resp_tag_value_t));
 
         for (int k = 0; k < cmd->groups[i].n_tag; k++) {
-            strcpy(cmd->groups[i].tags[k].tag, req->groups[i].tags[k].tag);
+            strncpy(cmd->groups[i].tags[k].tag, req->groups[i].tags[k].tag,
+                    NEU_TAG_NAME_LEN - 1);
 
             switch (req->groups[i].tags[k].t) {
             case NEU_JSON_INT:
@@ -660,8 +663,8 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
                 break;
             case NEU_JSON_STR:
                 cmd->groups[i].tags[k].value.type = NEU_TYPE_STRING;
-                strcpy(cmd->groups[i].tags[k].value.value.str,
-                       req->groups[i].tags[k].value.val_str);
+                strncpy(cmd->groups[i].tags[k].value.value.str,
+                        req->groups[i].tags[k].value.val_str, NEU_VALUE_SIZE);
                 break;
             case NEU_JSON_DOUBLE:
                 cmd->groups[i].tags[k].value.type = NEU_TYPE_DOUBLE;
@@ -679,8 +682,8 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
                     req->groups[i].tags[k].value.val_array_int64.length;
 
                 cmd->groups[i].tags[k].value.value.i64s.i64s =
-                    calloc(sizeof(int64_t),
-                           req->groups[i].tags[k].value.val_array_int64.length);
+                    calloc(req->groups[i].tags[k].value.val_array_int64.length,
+                           sizeof(int64_t));
 
                 memcpy(cmd->groups[i].tags[k].value.value.i64s.i64s,
                        req->groups[i].tags[k].value.val_array_int64.i64s,
@@ -694,8 +697,9 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
                     req->groups[i].tags[k].value.val_array_double.length;
 
                 cmd->groups[i].tags[k].value.value.f64s.f64s = calloc(
-                    sizeof(double),
-                    req->groups[i].tags[k].value.val_array_double.length);
+
+                    req->groups[i].tags[k].value.val_array_double.length,
+                    sizeof(double));
                 memcpy(
                     cmd->groups[i].tags[k].value.value.f64s.f64s,
                     req->groups[i].tags[k].value.val_array_double.f64s,
@@ -723,8 +727,8 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
                     req->groups[i].tags[k].value.val_array_str.length;
 
                 cmd->groups[i].tags[k].value.value.strs.strs =
-                    calloc(sizeof(char *),
-                           req->groups[i].tags[k].value.val_array_str.length);
+                    calloc(req->groups[i].tags[k].value.val_array_str.length,
+                           sizeof(char *));
                 for (size_t j = 0;
                      j < req->groups[i].tags[k].value.val_array_str.length;
                      j++) {

plugins/restful/scan_handle.c

@@ -43,15 +43,15 @@ void handle_scan_tags(nng_aio *aio)
             }
 
             if (NULL != req->node) {
-                strcpy(cmd.driver, req->node);
+                strncpy(cmd.driver, req->node, NEU_NODE_NAME_LEN - 1);
             }
 
             if (NULL != req->id) {
-                strcpy(cmd.id, req->id);
+                strncpy(cmd.id, req->id, NEU_TAG_ADDRESS_LEN - 1);
             }
 
             if (NULL != req->ctx) {
-                strcpy(cmd.ctx, req->ctx);
+                strncpy(cmd.ctx, req->ctx, NEU_VALUE_SIZE);
             }
 
             if (0 != neu_plugin_op(plugin, header, &cmd)) {

plugins/restful/tpy_handle.c

@@ -17,7 +17,7 @@ void handle_tpy(nng_aio *aio)
     neu_plugin_t *plugin = neu_rest_get_plugin();
     (void) plugin;
 
-    NEU_PROCESS_HTTP_REQUEST(
+    NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
         aio, neu_json_upload_cid_t, neu_json_decode_upload_cid_req, {
             tpy_t tpy      = { 0 };
             int   parse_re = neu_tpy_parse(req->path, &tpy);

src/adapter/driver/cache.c

@@ -219,14 +219,15 @@ void *neu_driver_cache_get_trace(neu_driver_cache_t *cache, const char *group)
     return trace;
 }
 
-void neu_driver_cache_update_change(neu_driver_cache_t *cache,
+bool neu_driver_cache_update_change(neu_driver_cache_t *cache,
                                     const char *group, const char *tag,
                                     int64_t timestamp, neu_dvalue_t value,
                                     neu_tag_meta_t *metas, int n_meta,
                                     bool change)
 {
-    struct elem *elem = NULL;
-    tkey_t       key  = to_key(group, tag);
+    struct elem *elem        = NULL;
+    tkey_t       key         = to_key(group, tag);
+    bool         tag_changed = false;
 
     pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
@@ -241,6 +242,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
             (sub_filter_err && elem->value.type != value.type &&
              elem->value.type != NEU_TYPE_ERROR)) {
             elem->changed = true;
+            tag_changed   = true;
         } else if (sub_filter_err && elem->value.type != value.type &&
                    elem->value.type == NEU_TYPE_ERROR) {
             switch (value.type) {
@@ -264,17 +266,20 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (memcmp(&elem->value_old.value, &value.value,
                            sizeof(value.value)) != 0) {
                     elem->changed = true;
+                    tag_changed   = true;
                 }
                 break;
             case NEU_TYPE_BYTES:
                 if (elem->value_old.value.bytes.length !=
                     value.value.bytes.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcpy(elem->value_old.value.bytes.bytes,
                                value.value.bytes.bytes,
                                value.value.bytes.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -282,11 +287,13 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.bools.length !=
                     value.value.bools.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.bools.bools,
                                value.value.bools.bools,
                                value.value.bools.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -294,11 +301,13 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.i8s.length !=
                     value.value.i8s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.i8s.i8s,
                                value.value.i8s.i8s,
                                value.value.i8s.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -306,11 +315,13 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.u8s.length !=
                     value.value.u8s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.u8s.u8s,
                                value.value.u8s.u8s,
                                value.value.u8s.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -318,12 +329,14 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.i16s.length !=
                     value.value.i16s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.i16s.i16s,
                                value.value.i16s.i16s,
                                value.value.i16s.length * sizeof(int16_t)) !=
                         0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -331,12 +344,14 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.u16s.length !=
                     value.value.u16s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.u16s.u16s,
                                value.value.u16s.u16s,
                                value.value.u16s.length * sizeof(uint16_t)) !=
                         0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -344,12 +359,14 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.i32s.length !=
                     value.value.i32s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.i32s.i32s,
                                value.value.i32s.i32s,
                                value.value.i32s.length * sizeof(int32_t)) !=
                         0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -357,12 +374,14 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.u32s.length !=
                     value.value.u32s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.u32s.u32s,
                                value.value.u32s.u32s,
                                value.value.u32s.length * sizeof(uint32_t)) !=
                         0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -370,12 +389,14 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.i64s.length !=
                     value.value.i64s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.i64s.i64s,
                                value.value.i64s.i64s,
                                value.value.i64s.length * sizeof(int64_t)) !=
                         0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -383,12 +404,14 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.u64s.length !=
                     value.value.u64s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.u64s.u64s,
                                value.value.u64s.u64s,
                                value.value.u64s.length * sizeof(uint64_t)) !=
                         0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -396,11 +419,13 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.f32s.length !=
                     value.value.f32s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.f32s.f32s,
                                value.value.f32s.f32s,
                                value.value.f32s.length * sizeof(float)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -408,11 +433,13 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.f64s.length !=
                     value.value.f64s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.f64s.f64s,
                                value.value.f64s.f64s,
                                value.value.f64s.length * sizeof(double)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -420,18 +447,21 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.strs.length !=
                     value.value.strs.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.strs.strs,
                                value.value.strs.strs,
                                value.value.strs.length * sizeof(char *)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_CUSTOM: {
                 if (json_equal(elem->value_old.value.json, value.value.json) !=
-                    0) {
+                    1) {
                     elem->changed = true;
+                    tag_changed   = true;
                 }
                 break;
             }
@@ -439,11 +469,13 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.value.ptr.length !=
                     value.value.ptr.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value_old.value.ptr.ptr,
                                value.value.ptr.ptr,
                                value.value.ptr.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
 
@@ -453,10 +485,12 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.precision == 0) {
                     elem->changed =
                         elem->value_old.value.f32 != value.value.f32;
+                    tag_changed = elem->changed;
                 } else {
                     if (fabs(elem->value_old.value.f32 - value.value.f32) >
                         pow(0.1, elem->value_old.precision)) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -464,10 +498,12 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value_old.precision == 0) {
                     elem->changed =
                         elem->value_old.value.d64 != value.value.d64;
+                    tag_changed = elem->changed;
                 } else {
                     if (fabs(elem->value_old.value.d64 - value.value.d64) >
                         pow(0.1, elem->value_old.precision)) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
 
@@ -497,17 +533,20 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (memcmp(&elem->value.value, &value.value,
                            sizeof(value.value)) != 0) {
                     elem->changed = true;
+                    tag_changed   = true;
                 }
                 break;
             case NEU_TYPE_BYTES:
                 if (elem->value.value.bytes.length !=
                     value.value.bytes.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.bytes.bytes,
                                value.value.bytes.bytes,
                                value.value.bytes.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
@@ -515,174 +554,206 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 if (elem->value.value.bools.length !=
                     value.value.bools.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.bools.bools,
                                value.value.bools.bools,
                                value.value.bools.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_INT8:
                 if (elem->value.value.i8s.length != value.value.i8s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.i8s.i8s, value.value.i8s.i8s,
                                value.value.i8s.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_UINT8:
                 if (elem->value.value.u8s.length != value.value.u8s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.u8s.u8s, value.value.u8s.u8s,
                                value.value.u8s.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_INT16:
                 if (elem->value.value.i16s.length != value.value.i16s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(
                             elem->value.value.i16s.i16s, value.value.i16s.i16s,
                             value.value.i16s.length * sizeof(int16_t)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_UINT16:
                 if (elem->value.value.u16s.length != value.value.u16s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(
                             elem->value.value.u16s.u16s, value.value.u16s.u16s,
                             value.value.u16s.length * sizeof(uint16_t)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_INT32:
                 if (elem->value.value.i32s.length != value.value.i32s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(
                             elem->value.value.i32s.i32s, value.value.i32s.i32s,
                             value.value.i32s.length * sizeof(int32_t)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_UINT32:
                 if (elem->value.value.u32s.length != value.value.u32s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(
                             elem->value.value.u32s.u32s, value.value.u32s.u32s,
                             value.value.u32s.length * sizeof(uint32_t)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_INT64:
                 if (elem->value.value.i64s.length != value.value.i64s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(
                             elem->value.value.i64s.i64s, value.value.i64s.i64s,
                             value.value.i64s.length * sizeof(int64_t)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_UINT64:
                 if (elem->value.value.u64s.length != value.value.u64s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(
                             elem->value.value.u64s.u64s, value.value.u64s.u64s,
                             value.value.u64s.length * sizeof(uint64_t)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_FLOAT:
                 if (elem->value.value.f32s.length != value.value.f32s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.f32s.f32s,
                                value.value.f32s.f32s,
                                value.value.f32s.length * sizeof(float)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_DOUBLE:
                 if (elem->value.value.f64s.length != value.value.f64s.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.f64s.f64s,
                                value.value.f64s.f64s,
                                value.value.f64s.length * sizeof(double)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_ARRAY_STRING:
                 if (elem->value.value.strs.length != value.value.strs.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.strs.strs,
                                value.value.strs.strs,
                                value.value.strs.length * sizeof(char *)) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_PTR: {
                 if (elem->value.value.ptr.length != value.value.ptr.length) {
                     elem->changed = true;
+                    tag_changed   = true;
                 } else {
                     if (memcmp(elem->value.value.ptr.ptr, value.value.ptr.ptr,
                                value.value.ptr.length) != 0) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
 
                 break;
             }
             case NEU_TYPE_CUSTOM: {
-                if (json_equal(elem->value.value.json, value.value.json) != 0) {
+                if (json_equal(elem->value.value.json, value.value.json) != 1) {
                     elem->changed = true;
+                    tag_changed   = true;
                 }
                 break;
             }
             case NEU_TYPE_FLOAT:
                 if (elem->value.precision == 0) {
                     elem->changed = elem->value.value.f32 != value.value.f32;
+                    tag_changed   = elem->changed;
                 } else {
                     if (fabs(elem->value.value.f32 - value.value.f32) >
                         pow(0.1, elem->value.precision)) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
                 break;
             case NEU_TYPE_DOUBLE:
                 if (elem->value.precision == 0) {
                     elem->changed = elem->value.value.d64 != value.value.d64;
+                    tag_changed   = elem->changed;
                 } else {
                     if (fabs(elem->value.value.d64 - value.value.d64) >
                         pow(0.1, elem->value.precision)) {
                         elem->changed = true;
+                        tag_changed   = true;
                     }
                 }
 
                 break;
             case NEU_TYPE_ERROR:
                 elem->changed = true;
+                tag_changed   = true;
                 break;
             }
         }
@@ -778,7 +849,12 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
             }
             elem->metas = calloc(n_meta, sizeof(neu_tag_meta_t));
             for (int i = 0; i < n_meta; i++) {
-                memcpy(&elem->metas[i], &metas[i], sizeof(neu_tag_meta_t));
+                if (!neu_dvalue_is_array(&metas[i].value)) {
+                    memcpy(&elem->metas[i], &metas[i], sizeof(neu_tag_meta_t));
+                } else {
+                    neu_free_dvalue(&metas[i].value);
+                    elem->metas[i].value.type = NEU_TYPE_INT8;
+                }
             }
 
             elem->n_meta = n_meta;
@@ -786,6 +862,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
     }
 
     pthread_mutex_unlock(&cache->mtx);
+    return tag_changed;
 }
 
 void neu_driver_cache_update(neu_driver_cache_t *cache, const char *group,

src/adapter/driver/cache.h

@@ -35,7 +35,7 @@ void neu_driver_cache_update(neu_driver_cache_t *cache, const char *group,
                              const char *tag, int64_t timestamp,
                              neu_dvalue_t value, neu_tag_meta_t *metas,
                              int n_meta);
-void neu_driver_cache_update_change(neu_driver_cache_t *cache,
+bool neu_driver_cache_update_change(neu_driver_cache_t *cache,
                                     const char *group, const char *tag,
                                     int64_t timestamp, neu_dvalue_t value,
                                     neu_tag_meta_t *metas, int n_meta,

src/adapter/driver/driver.c

@@ -113,6 +113,9 @@ static void update(neu_adapter_t *adapter, const char *group, const char *tag,
 static void update_im(neu_adapter_t *adapter, const char *group,
                       const char *tag, neu_dvalue_t value,
                       neu_tag_meta_t *metas, int n_meta);
+static void update_im_f_m(neu_adapter_t *adapter, const char *group,
+                          const char *tag, neu_dvalue_t value,
+                          neu_tag_meta_t *metas, int n_meta);
 static void update_with_meta(neu_adapter_t *adapter, const char *group,
                              const char *tag, neu_dvalue_t value,
                              neu_tag_meta_t *metas, int n_meta);
@@ -175,7 +178,8 @@ static void write_responses(neu_adapter_t *adapter, void *r,
                             neu_driver_write_responses_t *response,
                             int                           n_response)
 {
-    neu_reqresp_head_t *  req   = (neu_reqresp_head_t *) r;
+    neu_reqresp_head_t *req = (neu_reqresp_head_t *) r;
+    const char *iface = (req->sender[0] != '\0') ? req->sender : "unknown";
     neu_resp_write_tags_t nresp = { 0 };
     req->type                   = NEU_RESP_WRITE_TAGS;
     UT_icd    icd   = { sizeof(neu_resp_write_tags_ele_t), NULL, NULL, NULL };
@@ -190,8 +194,18 @@ static void write_responses(neu_adapter_t *adapter, void *r,
         strcpy(ele.group, resp->group);
         strcpy(ele.tag, resp->name);
         ele.error = resp->error;
+
+        nlog_notice(
+            "driver multi write response detail, driver: %s, interface: "
+            "%s, group: %s, tag: %s, error: %d",
+            adapter->name, iface, resp->group, resp->name, resp->error);
+
         utarray_push_back(array, &ele);
     }
+    nlog_notice(
+        "driver multi write response summary, driver: %s, interface: %s, "
+        "result_count: %d",
+        adapter->name, iface, n_response);
 
     nresp.tags = array;
     adapter->cb_funs.response(adapter, req, &nresp);
@@ -199,8 +213,10 @@ static void write_responses(neu_adapter_t *adapter, void *r,
 
 static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
 {
-    neu_reqresp_head_t *req    = (neu_reqresp_head_t *) r;
-    neu_resp_error_t    nerror = { .error = error };
+    neu_reqresp_head_t *req      = (neu_reqresp_head_t *) r;
+    neu_reqresp_type_e  req_type = req->type;
+    const char *     iface = (req->sender[0] != '\0') ? req->sender : "unknown";
+    neu_resp_error_t nerror = { .error = error };
 
     neu_otel_trace_ctx trace = NULL;
     neu_otel_scope_ctx scope = NULL;
@@ -221,18 +237,55 @@ static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
         }
     }
 
-    if (NEU_REQ_WRITE_TAG == req->type) {
-        neu_req_write_tag_fini((neu_req_write_tag_t *) &req[1]);
+    if (NEU_REQ_WRITE_TAG == req_type) {
+        neu_req_write_tag_t *cmd   = (neu_req_write_tag_t *) &req[1];
+        const char *         group = cmd->group ? cmd->group : "";
+        const char *         tag   = cmd->tag ? cmd->tag : "";
+        nlog_notice("driver single write response, driver: %s, interface: %s, "
+                    "group: %s, tag: %s, %s, error: %d",
+                    adapter->name, iface, group, tag,
+                    neu_value_str(cmd->value.type, cmd->value.value), error);
+        neu_req_write_tag_fini(cmd);
         if (neu_otel_control_is_started() && trace) {
             neu_otel_scope_set_span_name(scope, "driver write tag response");
         }
-    } else if (NEU_REQ_WRITE_TAGS == req->type) {
-        neu_req_write_tags_fini((neu_req_write_tags_t *) &req[1]);
+    } else if (NEU_REQ_WRITE_TAGS == req_type) {
+        neu_req_write_tags_t *cmd   = (neu_req_write_tags_t *) &req[1];
+        const char *          group = cmd->group ? cmd->group : "";
+        nlog_notice("driver multi write response, driver: %s, interface: %s, "
+                    "group: %s, tag_count: %d, error: %d",
+                    adapter->name, iface, group, cmd->n_tag, error);
+        for (int i = 0; i < cmd->n_tag; i++) {
+            const char *tag_name = cmd->tags[i].tag;
+            nlog_notice("driver multi write response tag detail, driver: %s, "
+                        "group: %s, tag: %s, %s",
+                        adapter->name, group, tag_name ? tag_name : "",
+                        neu_value_str(cmd->tags[i].value.type,
+                                      cmd->tags[i].value.value));
+        }
+        neu_req_write_tags_fini(cmd);
         if (neu_otel_control_is_started() && trace) {
             neu_otel_scope_set_span_name(scope, "driver write tags response");
         }
-    } else if (NEU_REQ_WRITE_GTAGS == req->type) {
-        neu_req_write_gtags_fini((neu_req_write_gtags_t *) &req[1]);
+    } else if (NEU_REQ_WRITE_GTAGS == req_type) {
+        neu_req_write_gtags_t *cmd = (neu_req_write_gtags_t *) &req[1];
+        nlog_notice("driver multi write response, driver: %s, interface: %s, "
+                    "group_count: %d, error: %d",
+                    adapter->name, iface, cmd->n_group, error);
+        for (int i = 0; i < cmd->n_group; i++) {
+            const char *group_name =
+                cmd->groups[i].group ? cmd->groups[i].group : "";
+            for (int k = 0; k < cmd->groups[i].n_tag; k++) {
+                const char *tag_name = cmd->groups[i].tags[k].tag;
+                nlog_notice(
+                    "driver multi write response tag detail, driver: %s, "
+                    "group: %s, tag: %s, %s",
+                    adapter->name, group_name, tag_name ? tag_name : "",
+                    neu_value_str(cmd->groups[i].tags[k].value.type,
+                                  cmd->groups[i].tags[k].value.value));
+            }
+        }
+        neu_req_write_gtags_fini(cmd);
         if (neu_otel_control_is_started() && trace) {
             neu_otel_scope_set_span_name(scope, "driver write gtags response");
         }
@@ -389,6 +442,107 @@ static void update_with_trace(neu_adapter_t *adapter, const char *group,
     }
 }
 
+static void update_im_f_m(neu_adapter_t *adapter, const char *group,
+                          const char *tag, neu_dvalue_t value,
+                          neu_tag_meta_t *metas, int n_meta)
+{
+    neu_adapter_driver_t *driver = (neu_adapter_driver_t *) adapter;
+
+    if (tag == NULL) {
+        nlog_warn("update_im_f_m tag is null");
+        return;
+    }
+
+    group_t *find = NULL;
+
+    HASH_FIND_STR(driver->groups, group, find);
+    if (find == NULL) {
+        nlog_error(
+            "update_im_f_m group not found, driver: %s, group: %s, tag: %s",
+            driver->adapter.name, group, tag);
+        return;
+    }
+
+    bool changed = neu_driver_cache_update_change(driver->cache, group, tag,
+                                                  global_timestamp, value,
+                                                  metas, n_meta, false);
+    driver->adapter.cb_funs.update_metric(&driver->adapter,
+                                          NEU_METRIC_TAG_READS_TOTAL, 1, NULL);
+    if (value.type == NEU_TYPE_ERROR) {
+        return;
+    }
+
+    if (!changed) {
+        return;
+    }
+
+    UT_array *tags = neu_adapter_driver_get_ptag(driver, group, tag);
+    if (tags == NULL) {
+        return;
+    }
+    neu_datatag_t *first = utarray_front(tags);
+
+    if (first == NULL) {
+        utarray_free(tags);
+        nlog_debug("update immediately, driver: %s, "
+                   "group: %s, tag: %s, type: %s, "
+                   "timestamp: %" PRId64,
+                   driver->adapter.name, group, tag,
+                   neu_type_string(value.type), global_timestamp);
+        return;
+    }
+
+    nlog_debug("update and report immediately, driver: %s, "
+               "group: %s, tag: %s, type: %s, "
+               "timestamp: %" PRId64,
+               driver->adapter.name, group, tag, neu_type_string(value.type),
+               global_timestamp);
+
+    neu_reqresp_head_t header = {
+        .type = NEU_REQRESP_TRANS_DATA,
+    };
+    neu_reqresp_trans_data_t *data =
+        calloc(1, sizeof(neu_reqresp_trans_data_t));
+
+    data->driver = strdup(driver->adapter.name);
+    data->group  = strdup(group);
+    utarray_new(data->tags, neu_resp_tag_value_meta_icd());
+
+    read_report_group(global_timestamp, 0,
+                      neu_adapter_get_tag_cache_type(&driver->adapter),
+                      driver->cache, group, tags, data->tags);
+
+    if (utarray_len(data->tags) > 0) {
+
+        data->ctx        = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
+        data->ctx->index = utarray_len(find->apps);
+        pthread_mutex_init(&data->ctx->mtx, NULL);
+
+        if (utarray_len(find->apps) > 0) {
+            pthread_mutex_lock(&find->apps_mtx);
+
+            utarray_foreach(find->apps, sub_app_t *, app)
+            {
+                if (driver->adapter.cb_funs.responseto(
+                        &driver->adapter, &header, data, app->addr) != 0) {
+                    neu_trans_data_free(data);
+                }
+            }
+
+            pthread_mutex_unlock(&find->apps_mtx);
+        } else {
+            neu_trans_data_free(data);
+        }
+    } else {
+        utarray_free(data->tags);
+        free(data->group);
+        free(data->driver);
+    }
+
+    utarray_free(tags);
+    free(data);
+}
+
 static void update_im(neu_adapter_t *adapter, const char *group,
                       const char *tag, neu_dvalue_t value,
                       neu_tag_meta_t *metas, int n_meta)
@@ -530,6 +684,7 @@ neu_adapter_driver_t *neu_adapter_driver_create()
     driver->adapter.cb_funs.driver.fdown_open_response = fdown_open_response;
     driver->adapter.cb_funs.driver.fup_data_response   = fup_data_response;
     driver->adapter.cb_funs.driver.update_im           = update_im;
+    driver->adapter.cb_funs.driver.update_im_f_m       = update_im_f_m;
     driver->adapter.cb_funs.driver.update_with_trace   = update_with_trace;
     driver->adapter.cb_funs.driver.update_with_meta    = update_with_meta;
     driver->adapter.cb_funs.driver.scan_tags_response  = scan_tags_response;
@@ -1347,6 +1502,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;
@@ -1367,6 +1524,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;
         }
 
@@ -1400,6 +1560,8 @@ 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)
@@ -1413,6 +1575,9 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
     }
 
     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)
@@ -1425,6 +1590,23 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
         return NEU_ERR_TAG_NOT_EXIST;
     }
 
+    const neu_reqresp_head_t *head = (const neu_reqresp_head_t *) req;
+    const char *              iface =
+        (head && head->sender[0] != '\0') ? head->sender : "unknown";
+
+    nlog_notice("driver multi write request received, driver: %s, group: %s, "
+                "interface: %s, tag_count: %d",
+                driver->adapter.name, cmd->group, iface, cmd->n_tag);
+
+    for (int i = 0; i < cmd->n_tag; i++) {
+        const char *tag_name = cmd->tags[i].tag;
+        nlog_notice(
+            "driver multi write request tag detail, driver: %s, group: %s, "
+            "tag: %s, %s",
+            driver->adapter.name, cmd->group, tag_name ? tag_name : "",
+            neu_value_str(cmd->tags[i].value.type, cmd->tags[i].value.value));
+    }
+
     to_be_write_tag_t wtag = { 0 };
     wtag.single            = false;
     wtag.req               = (void *) req;
@@ -1549,6 +1731,29 @@ int neu_adapter_driver_write_gtags(neu_adapter_driver_t *driver,
         return NEU_ERR_TAG_NOT_EXIST;
     }
 
+    const neu_reqresp_head_t *head = (const neu_reqresp_head_t *) req;
+    const char *              iface =
+        (head && head->sender[0] != '\0') ? head->sender : "unknown";
+
+    nlog_notice(
+        "driver multi write request received, driver: %s, interface: %s, "
+        "group_count: %d, tag_count: %u",
+        driver->adapter.name, iface, cmd->n_group, n_tag);
+
+    for (int i = 0; i < cmd->n_group; i++) {
+        const char *group_name =
+            cmd->groups[i].group ? cmd->groups[i].group : "";
+        for (int k = 0; k < cmd->groups[i].n_tag; k++) {
+            const char *tag_name = cmd->groups[i].tags[k].tag;
+            nlog_notice("driver multi write request tag detail, driver: %s, "
+                        "group: %s, tag: %s, %s",
+                        driver->adapter.name, group_name,
+                        tag_name ? tag_name : "",
+                        neu_value_str(cmd->groups[i].tags[k].value.type,
+                                      cmd->groups[i].tags[k].value.value));
+        }
+    }
+
     to_be_write_tag_t wtag = { 0 };
     wtag.single            = false;
     wtag.req               = (void *) req;
@@ -1572,6 +1777,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;
@@ -1579,11 +1786,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);
@@ -1595,6 +1807,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);
@@ -1614,6 +1829,17 @@ int neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
 
         fix_value(tag, cmd->value.type, &cmd->value);
 
+        const neu_reqresp_head_t *head = (const neu_reqresp_head_t *) req;
+        const char *              iface =
+            (head && head->sender[0] != '\0') ? head->sender : "unknown";
+        const char *group_name = cmd->group ? cmd->group : "";
+        const char *tag_name   = cmd->tag ? cmd->tag : "";
+
+        nlog_notice("driver single write request received, driver: %s, group: "
+                    "%s, tag: %s, interface: %s, %s",
+                    driver->adapter.name, group_name, tag_name, iface,
+                    neu_value_str(cmd->value.type, cmd->value.value));
+
         to_be_write_tag_t wtag = { 0 };
         wtag.single            = true;
         wtag.req               = (void *) req;
@@ -1721,6 +1947,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);
@@ -2436,9 +2666,35 @@ static int write_callback(void *usr_data)
             e_time = neu_time_ns();
             neu_tag_free(wtag->tag);
         } else {
-            group->driver->adapter.module->intf_funs->driver.write_tags(
-                group->driver->adapter.plugin, (void *) wtag->req, wtag->tvs);
+            const neu_reqresp_head_t *head =
+                (const neu_reqresp_head_t *) wtag->req;
+            const char *iface =
+                (head && head->sender[0] != '\0') ? head->sender : "unknown";
+
+            size_t tag_count = utarray_len(wtag->tvs);
+            nlog_info("driver multi write request start, driver: %s, group: "
+                      "%s, interface: %s, tag_count: %zu",
+                      group->driver->adapter.name, group->name, iface,
+                      tag_count);
+            utarray_foreach(wtag->tvs, neu_plugin_tag_value_t *, tv)
+            {
+                const char *tag_name =
+                    (tv && tv->tag && tv->tag->name) ? tv->tag->name : "";
+                nlog_info("driver multi write tag detail, driver: %s, group: "
+                          "%s, tag: %s, %s",
+                          group->driver->adapter.name, group->name, tag_name,
+                          neu_value_str(tv->type, tv->value));
+            }
+
+            int ret =
+                group->driver->adapter.module->intf_funs->driver.write_tags(
+                    group->driver->adapter.plugin, (void *) wtag->req,
+                    wtag->tvs);
             e_time = neu_time_ms();
+
+            nlog_info("driver multi write request done, driver: %s, group: %s, "
+                      "interface: %s, ret: %d",
+                      group->driver->adapter.name, group->name, iface, ret);
             utarray_foreach(wtag->tvs, neu_plugin_tag_value_t *, tv)
             {
                 neu_tag_free(tv->tag);
@@ -2690,6 +2946,7 @@ static void read_group(int64_t timestamp, int64_t timeout,
         neu_driver_cache_value_t  value     = { 0 };
 
         strcpy(tag_value.tag, tag->name);
+        tag_value.datatag = *tag;
 
         tag_value.datatag.bias = tag->bias;
 

src/base/group.c

@@ -372,8 +372,10 @@ void neu_group_change_test(neu_group_t *group, int64_t timestamp, void *arg,
                            neu_group_change_fn fn)
 {
     if (group->timestamp != timestamp) {
+        pthread_mutex_lock(&group->mtx);
         UT_array *tags = to_array(group->tags);
         fn(arg, group->timestamp, tags, group->interval);
+        pthread_mutex_unlock(&group->mtx);
     }
 }
 

src/base/msg_internal.h

@@ -83,6 +83,8 @@ extern "C" {
     XX(NEU_RESP_ADD_TAG, neu_resp_add_tag_t)                                   \
     XX(NEU_REQ_ADD_GTAG, neu_req_add_gtag_t)                                   \
     XX(NEU_RESP_ADD_GTAG, neu_resp_add_tag_t)                                  \
+    XX(NEU_REQ_IMPORT_TAGS, neu_req_import_tags_t)                             \
+    XX(NEU_RESP_IMPORT_TAGS, neu_resp_add_tag_t)                               \
     XX(NEU_REQ_DEL_TAG, neu_req_del_tag_t)                                     \
     XX(NEU_REQ_UPDATE_TAG, neu_req_update_tag_t)                               \
     XX(NEU_RESP_UPDATE_TAG, neu_resp_update_tag_t)                             \
@@ -98,6 +100,8 @@ extern "C" {
     XX(NEU_REQRESP_NODE_DELETED, neu_reqresp_node_deleted_t)                   \
     XX(NEU_REQ_ADD_DRIVERS, neu_req_driver_array_t)                            \
     XX(NEU_REQ_UPDATE_LOG_LEVEL, neu_req_update_log_level_t)                   \
+    XX(NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL, neu_req_update_global_log_level_t)     \
+    XX(NEU_REQ_UPDATE_NODE_LOG_LEVEL, neu_req_update_node_log_level_t)         \
     XX(NEU_REQ_PRGFILE_UPLOAD, neu_req_prgfile_upload_t)                       \
     XX(NEU_REQ_PRGFILE_PROCESS, neu_req_prgfile_process_t)                     \
     XX(NEU_RESP_PRGFILE_PROCESS, neu_resp_prgfile_process_t)                   \
@@ -128,6 +132,7 @@ extern "C" {
     XX(NEU_REQ_DEL_TAG_EVENT, neu_req_del_tag_t)                               \
     XX(NEU_REQ_UPDATE_TAG_EVENT, neu_req_update_tag_t)                         \
     XX(NEU_REQ_ADD_GTAG_EVENT, neu_req_add_gtag_t)                             \
+    XX(NEU_REQ_IMPORT_TAGS_EVENT, neu_req_import_tags_t)                       \
     XX(NEU_REQ_ADD_PLUGIN_EVENT, neu_req_add_plugin_t)                         \
     XX(NEU_REQ_DEL_PLUGIN_EVENT, neu_req_del_plugin_t)                         \
     XX(NEU_REQ_SUBSCRIBE_GROUP_EVENT, neu_req_subscribe_t)                     \

src/connection/connection.c

@@ -871,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;
         }
 
@@ -941,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;
         }
 

src/core/manager.c

@@ -1465,7 +1465,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                         neu_msg_get_header(msg_copy);
                     neu_req_del_tag_t *cmd_copy =
                         (neu_req_del_tag_t *) &header_copy[1];
-                    neu_req_del_tag_copy(cmd, cmd_copy);
+                    neu_req_del_tag_copy(cmd_copy, cmd);
                     forward_msg(manager, header_copy, app->app_name);
                 }
 
@@ -1987,7 +1987,7 @@ inline static void notify_monitor(neu_manager_t *    manager,
     // monitor not ready, ignore
     neu_node_manager_t *mgr  = manager->node_manager;
     struct sockaddr_un  addr = neu_node_manager_get_addr(mgr, "monitor");
-    if (0 == addr.sun_path) {
+    if (0 == addr.sun_path[1]) {
         return;
     }
 

src/core/manager_internal.h

@@ -20,6 +20,8 @@
 #ifndef _NEU_MANAGER_INTERNAL_H_
 #define _NEU_MANAGER_INTERNAL_H_
 
+#include <errno.h>
+
 #include "event/event.h"
 #include "persist/persist.h"
 
@@ -109,9 +111,9 @@ inline static void forward_msg(neu_manager_t *     manager,
     if (0 == ret) {
         nlog_info("forward msg %s to %s", neu_reqresp_type_string(t), receiver);
     } else {
-        nlog_warn("forward msg %s to node (%s)%s %s %s fail",
+        nlog_warn("forward msg %s to node (%s)%s %s %s fail, errno: %s(%d)",
                   neu_reqresp_type_string(t), receiver, &addr.sun_path[1], node,
-                  header->sender);
+                  header->sender, strerror(errno), errno);
         neu_msg_free(msg);
     }
 }

src/otel/otel_manager.c

@@ -37,7 +37,7 @@
 
 #define SPAN_ID_LENGTH 16
 #define ID_CHARSET "0123456789abcdef"
-#define TRACE_TIME_OUT (3 * 60 * 1000)
+#define TRACE_TIME_OUT (60 * 1000)
 
 bool   otel_flag               = false;
 char   otel_collector_url[128] = { 0 };
@@ -1072,25 +1072,33 @@ static int otel_timer_cb(void *data)
 
     HASH_ITER(hh, traces_table, el, tmp)
     {
+        bool should_send = false;
+        bool is_timeout  = false;
+
         if (neu_time_ms() - el->ctx->ts >= TRACE_TIME_OUT) {
-            nlog_debug("trace:%s time out", (char *) el->ctx->trace_id);
-            HASH_DEL(traces_table, el);
-            neu_otel_free_trace(el->ctx);
-            free(el);
+            should_send = true;
+            is_timeout  = true;
+            nlog_debug("trace:%s time out, reporting incomplete trace",
+                       (char *) el->ctx->trace_id);
         } else if (el->ctx->final &&
                    el->ctx->span_num ==
                        el->ctx->trace_data.resource_spans[0]
                            ->scope_spans[0]
                            ->n_spans &&
                    el->ctx->expected_span_num <= 0) {
-            int data_size = neu_otel_trace_pack_size(el->ctx);
+            should_send = true;
+        }
 
-            uint8_t *data_buf = calloc(1, data_size);
+        if (should_send) {
+            int      data_size = neu_otel_trace_pack_size(el->ctx);
+            uint8_t *data_buf  = calloc(1, data_size);
             neu_otel_trace_pack(el->ctx, data_buf);
             int status = neu_http_post_otel_trace(data_buf, data_size);
             free(data_buf);
-            nlog_debug("send trace:%s status:%d", (char *) el->ctx->trace_id,
+            nlog_debug("send %strace:%s status:%d",
+                       is_timeout ? "timeout " : "", (char *) el->ctx->trace_id,
                        status);
+
             if (status == 200 || status == 400) {
                 HASH_DEL(traces_table, el);
                 neu_otel_free_trace(el->ctx);

src/utils/cid.c

@@ -307,7 +307,8 @@ static int find_da_basic_type(cid_template_t *template, const char *datype_id,
 
 static int find_basic_type(cid_template_t *template, const char *type_id,
                            const char *do_name, const char *da_name,
-                           cid_fc_e fc, cid_basictype_e **btypes)
+                           cid_fc_e fc, cid_basictype_e **btypes,
+                           bool *is_array, uint8_t *array_size)
 {
     *btypes                  = NULL;
     cid_tm_do_type_t *dotype = NULL;
@@ -330,6 +331,8 @@ static int find_basic_type(cid_template_t *template, const char *type_id,
             (*btypes)[index - 1] = dotype->das[i].btype;
             continue;
         }
+        *is_array   = dotype->das[i].is_array;
+        *array_size = dotype->das[i].array_size;
 
         da_basic_type_t da_types[32] = { 0 };
         int n_da_types = find_da_basic_type(template, dotype->das[i].ref_type,
@@ -362,15 +365,28 @@ static void update_dataset(cid_dataset_t *dataset, cid_ldevice_t *ldev,
             find_type_id(ldev, dataset->fcdas[i].prefix,
                          dataset->fcdas[i].lnclass, dataset->fcdas[i].lninst);
         if (type_id != NULL) {
-            cid_basictype_e *bs  = NULL;
-            int              ret = find_basic_type(
-                template, type_id, dataset->fcdas[i].do_name,
-                dataset->fcdas[i].da_name, dataset->fcdas[i].fc, &bs);
+            cid_basictype_e *bs         = NULL;
+            bool             is_array   = false;
+            uint8_t          array_size = 0;
+
+            int ret =
+                find_basic_type(template, type_id, dataset->fcdas[i].do_name,
+                                dataset->fcdas[i].da_name, dataset->fcdas[i].fc,
+                                &bs, &is_array, &array_size);
             if (ret > 0) {
                 if (ret <= 16) {
                     memcpy(dataset->fcdas[i].btypes, bs,
                            ret * sizeof(cid_basictype_e));
-                    dataset->fcdas[i].n_btypes = ret;
+                    dataset->fcdas[i].btype = bs[0];
+                    for (int j = 1; j < ret; j++) {
+                        if ((bs[j] & 0x7f) != 15 && (bs[j] & 0x7f) != 16) {
+                            dataset->fcdas[i].btype = bs[j];
+                        }
+                    }
+
+                    dataset->fcdas[i].n_btypes   = ret;
+                    dataset->fcdas[i].is_array   = is_array;
+                    dataset->fcdas[i].array_size = array_size;
                 } else {
                     nlog_warn(
                         "Too many basic types for %s %s %s %s %s %d %s",
@@ -987,6 +1003,8 @@ static int parse_template(xmlNode *xml_template, cid_template_t *template)
                             (char *) xmlGetProp(da, (const xmlChar *) "name");
                         char *ref_type =
                             (char *) xmlGetProp(da, (const xmlChar *) "type");
+                        char *count =
+                            (char *) xmlGetProp(da, (const xmlChar *) "count");
 
                         if (btype != NULL && fc != NULL && name != NULL) {
                             tm_do->n_das += 1;
@@ -1014,6 +1032,14 @@ static int parse_template(xmlNode *xml_template, cid_template_t *template)
                                 nlog_warn("Unknown fc %s, %d", fc,
                                           (int) da->line);
                             }
+
+                            if (count != NULL) {
+                                tm_da->is_array   = true;
+                                tm_da->array_size = atoi(count);
+                            } else {
+                                tm_da->is_array   = false;
+                                tm_da->array_size = 0;
+                            }
                         }
 
                         if (btype != NULL) {
@@ -1028,6 +1054,9 @@ static int parse_template(xmlNode *xml_template, cid_template_t *template)
                         if (ref_type != NULL) {
                             xmlFree(ref_type);
                         }
+                        if (count != NULL) {
+                            xmlFree(count);
+                        }
                     }
 
                     da = da->next;
@@ -1475,7 +1504,7 @@ static void ln_dataset_to_group(const char *ied_name, const char *ap_name,
                                  fc_to_str(ln->datasets[j].fcdas[k].fc),
                                  ln->datasets[j].fcdas[k].do_name);
                     }
-                    switch (ln->datasets[j].fcdas[k].btypes[0] & 0x7f) {
+                    switch (ln->datasets[j].fcdas[k].btype & 0x7f) {
                     case BOOLEAN:
                         tag->type = NEU_TYPE_BOOL;
                         break;
@@ -1506,9 +1535,15 @@ static void ln_dataset_to_group(const char *ied_name, const char *ap_name,
                     case INT32U:
                         tag->type = NEU_TYPE_UINT32;
                         break;
-                    case FLOAT32:
-                        tag->type = NEU_TYPE_FLOAT;
-                        break;
+                    case FLOAT32: {
+                        if (ln->datasets[j].fcdas[k].is_array) {
+                            tag->type = NEU_TYPE_ARRAY_FLOAT;
+                            break;
+                        } else {
+                            tag->type = NEU_TYPE_FLOAT;
+                            break;
+                        }
+                    }
                     case FLOAT64:
                         tag->type = NEU_TYPE_DOUBLE;
                         break;

src/utils/tpy.c

@@ -211,7 +211,7 @@ void neu_tpy_to_msg(char *driver, tpy_t *tpy, neu_req_add_gtag_t *cmd)
                 to_neu_type(tpy->statics[i].vars[k].type);
             cmd->groups[i].tags[k].attribute =
                 NEU_ATTRIBUTE_READ | NEU_ATTRIBUTE_WRITE;
-            snprintf(address, sizeof(address) - 1, "%ld,%ld",
+            snprintf(address, sizeof(address) - 1, "%" PRIi64 ",%" PRIi64,
                      tpy->statics[i].vars[k].igroup,
                      tpy->statics[i].vars[k].ioffset);
             cmd->groups[i].tags[k].address     = strdup(address);

tests/ft/log/test_log.py

@@ -126,15 +126,4 @@ class TestLog:
         response = api.get_nodes_state(node='')
         assert 200 == response.status_code
         assert "notice" == response.json()['neuron_core']
-    
-    @description(given="neuron started", when="get log list", then="success")
-    def test_get_log_list(self):
-        response = api.get_log_list()
-        assert 200 == response.status_code
-        print(response.json())
-        assert "neuron.log" in [item['file'] for item in response.json()["files"]]
-
-    @description(given="neuron started", when="get log file", then="success")
-    def test_get_log_file(self):
-        response = api.get_log_file(file_name='neuron.log')
-        assert 200 == response.status_code
+    

tests/ft/plugin/test_plugin.py

@@ -244,7 +244,7 @@ class TestPlugin:
         assert 200 == response.status_code
         for plugin in response.json().get("plugins"):
             if plugin['name'] == 'c1':
-                assert plugin['version'] == '2.12.99'
+                assert plugin['version'] == '2.13.99'
 
     @description(given="incorrect configuration", when="update plugin", then="fail")
     def test_10_update_plugin_fail3(self):

tests/plugins/c1/c1_2.c

@@ -63,7 +63,7 @@ static const neu_plugin_intf_funs_t plugin_intf_funs = {
 };
 
 const neu_plugin_module_t neu_plugin_module = {
-    .version         = NEU_VERSION(2, 12, 99),
+    .version         = NEU_VERSION(2, 13, 99),
     .schema          = "c1",
     .module_name     = "c1",
     .module_descr    = "c1 v2",

tests/ut/CMakeLists.txt

@@ -24,14 +24,14 @@ target_include_directories(jwt_test PRIVATE
     ${CMAKE_SOURCE_DIR}/src 
 	${CMAKE_SOURCE_DIR}/include
 	${CMAKE_SOURCE_DIR}/src/utils)
-target_link_libraries(jwt_test neuron-base gtest_main gtest jansson ssl crypto jwt libzlog.so)
+target_link_libraries(jwt_test neuron-base gtest_main gtest jansson OpenSSL::SSL OpenSSL::Crypto jwt libzlog.so)
 
 add_executable(base64_test base64_test.cc ${CMAKE_SOURCE_DIR}/src/utils/base64.c)
 target_include_directories(base64_test PRIVATE 
 	${CMAKE_SOURCE_DIR}/src
 	${CMAKE_SOURCE_DIR}/include       
 )
-target_link_libraries(base64_test neuron-base gtest_main gtest crypto)
+target_link_libraries(base64_test neuron-base gtest_main gtest OpenSSL::Crypto)
 
 aux_source_directory(${CMAKE_SOURCE_DIR}/src/base/tag_sort.c SRC_SORT)
 add_executable(tag_sort_test tag_sort_test.cc ${SRC_SORT})

version

@@ -1 +1 @@
-2.12.0-alpha
+2.13.1

zlog.conf

@@ -9,5 +9,4 @@ syslog = "<P>%d(%Y-%m-%dT%T%z) %H neuron[%p]: level=%v msg="[%c] %m" file="%f:%L
 
 [rules]
 
-*.*     "./logs/%c.log", 25MB * 1 ~ "./logs/%c.#2r.log"; simple
-*.*     $remote_syslog,"%V"; syslog
+*.*     "./logs/%c.log", 50MB * 2 ~ "./logs/%c.#2r.log"; simple