From 215208a985b80d070ca57ebf3a08e708b76b58fe Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 13:35:11 +0800
Subject: [PATCH 01/25] Replace unsafe memory functions with safe versions

---
 include/os/osString.h                  |  25 ++--
 source/client/test/clientTests.cpp     |   8 +-
 source/common/src/tmisce.c             |  17 +--
 source/dnode/mnode/impl/src/mndDb.c    |  28 +++--
 source/dnode/mnode/impl/src/mndDnode.c |  57 +++++----
 source/dnode/vnode/src/vnd/vnodeOpen.c |   9 +-
 source/libs/parser/src/parAstCreater.c |  17 +--
 source/os/src/osString.c               | 161 +++++++++++++++++--------
 source/util/src/tconfig.c              |  38 ++++--
 source/util/src/tversion.c             |  12 +-
 10 files changed, 249 insertions(+), 123 deletions(-)

diff --git a/include/os/osString.h b/include/os/osString.h
index 995aa4a591..f22d22b327 100644
--- a/include/os/osString.h
+++ b/include/os/osString.h
@@ -25,7 +25,7 @@ typedef int32_t TdUcs4;
 #if !defined(DISALLOW_NCHAR_WITHOUT_ICONV) && defined(DARWIN)
 #include "iconv.h"
 #else
-typedef void   *iconv_t;
+typedef void *iconv_t;
 #endif
 typedef enum { M2C = 0, C2M } ConvType;
 
@@ -55,29 +55,34 @@ typedef enum { M2C = 0, C2M } ConvType;
 #ifdef strndup
 #undef strndup
 #endif
-#define strndup     STR_TO_F_FUNC_TAOS_FORBID
+#define strndup STR_TO_F_FUNC_TAOS_FORBID
 
 #endif
 
 #define tstrncpy(dst, src, size)         \
   do {                                   \
     (void)strncpy((dst), (src), (size)); \
-    (dst)[(size) - 1] = 0;               \
+    (dst)[(size)-1] = 0;                 \
   } while (0)
 
 int64_t tsnprintf(char *dst, int64_t size, const char *format, ...);
-#define TAOS_STRCPY(_dst, _src) ((void)strcpy(_dst, _src))
+#define TAOS_STRCPY(_dst, _src)         ((void)strcpy(_dst, _src))
 #define TAOS_STRNCPY(_dst, _src, _size) ((void)strncpy(_dst, _src, _size))
-#define TAOS_STRCAT(_dst, _src) ((void)strcat(_dst, _src))
-#define TAOS_STRNCAT(_dst, _src, len) ((void)strncat(_dst, _src, len))
+#define TAOS_STRCAT(_dst, _src)         ((void)strcat(_dst, _src))
+#define TAOS_STRNCAT(_dst, _src, len)   ((void)strncat(_dst, _src, len))
 
 char   *tstrdup(const char *src);
 int32_t taosUcs4len(TdUcs4 *ucs4);
 int32_t taosStr2int64(const char *str, int64_t *val);
-int32_t taosStr2int16(const char *str, int16_t *val);
 int32_t taosStr2int32(const char *str, int32_t *val);
+int32_t taosStr2int16(const char *str, int16_t *val);
 int32_t taosStr2int8(const char *str, int8_t *val);
 
+int32_t taosStr2Uint64(const char *str, uint64_t *val);
+int32_t taosStr2Uint32(const char *str, uint32_t *val);
+int32_t taosStr2Uint16(const char *str, uint16_t *val);
+int32_t taosStr2Uint8(const char *str, uint8_t *val);
+
 int32_t taosConvInit(void);
 void    taosConvDestroy();
 iconv_t taosAcquireConv(int32_t *idx, ConvType type);
@@ -112,9 +117,9 @@ float    taosStr2Float(const char *str, char **pEnd);
 int32_t  taosHex2Ascii(const char *z, uint32_t n, void **data, uint32_t *size);
 int32_t  taosAscii2Hex(const char *z, uint32_t n, void **data, uint32_t *size);
 char    *taosStrndup(const char *s, int n);
-//int32_t  taosBin2Ascii(const char *z, uint32_t n, void** data, uint32_t* size);
-bool isHex(const char* z, uint32_t n);
-bool isValidateHex(const char* z, uint32_t n);
+// int32_t  taosBin2Ascii(const char *z, uint32_t n, void** data, uint32_t* size);
+bool isHex(const char *z, uint32_t n);
+bool isValidateHex(const char *z, uint32_t n);
 
 #ifdef __cplusplus
 }
diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp
index 307ef7e06f..7cb7640907 100644
--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -300,7 +300,13 @@ void* doConsumeData(void* param) {
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   if (argc > 1) {
-    numOfThreads = atoi(argv[1]);
+    //numOfThreads = atoi(argv[1]);
+    int32_t code = taosStr2int32(argv[1], &numOfThreads);
+    if (code != 0) {
+      return code;
+    }
+     
+    
   }
 
   numOfThreads = TMAX(numOfThreads, 1);
diff --git a/source/common/src/tmisce.c b/source/common/src/tmisce.c
index 8988fab56a..3bd05a8e92 100644
--- a/source/common/src/tmisce.c
+++ b/source/common/src/tmisce.c
@@ -27,7 +27,10 @@ int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp) {
   char* temp = strchr(pEp->fqdn, ':');
   if (temp) {
     *temp = 0;
-    pEp->port = atoi(temp + 1);
+    pEp->port = taosStr2UInt16(temp + 1, NULL, 10);
+    if (pEp->port < 0) {
+      return TSDB_CODE_INVALID_PARA;
+    }
   }
 
   if (pEp->port == 0) {
@@ -282,7 +285,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
   locked = 1;
 
   while ((pItem = cfgNextIter(pIter)) != NULL) {
-_start:
+  _start:
     col = startCol;
 
     // GRANT_CFG_SKIP;
@@ -297,11 +300,11 @@ _start:
 
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);
 
-    char    value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
-    int32_t valueLen = 0;
+    char      value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
+    int32_t   valueLen = 0;
     SDiskCfg* pDiskCfg = NULL;
     if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {
-      char*     buf = &value[VARSTR_HEADER_SIZE];
+      char* buf = &value[VARSTR_HEADER_SIZE];
       pDiskCfg = taosArrayGet(pItem->array, index);
       valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);
       index++;
@@ -334,7 +337,7 @@ _start:
     if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {
       char* buf = &info[VARSTR_HEADER_SIZE];
       valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,
-                              pDiskCfg->primary, pDiskCfg->disable);
+                           pDiskCfg->primary, pDiskCfg->disable);
     } else {
       valueLen = 0;
     }
@@ -351,7 +354,7 @@ _start:
     if (index > 0 && index <= exSize) {
       goto _start;
     }
-}
+  }
   pBlock->info.rows = numOfRows;
 _exit:
   if (locked) cfgUnLock(pConf);
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 0d17ccd0b0..cff5bd4321 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -16,6 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "mndDb.h"
 #include "audit.h"
+#include "command.h"
 #include "mndArbGroup.h"
 #include "mndCluster.h"
 #include "mndDnode.h"
@@ -34,7 +35,6 @@
 #include "systable.h"
 #include "thttp.h"
 #include "tjson.h"
-#include "command.h"
 
 #define DB_VER_NUMBER   1
 #define DB_RESERVE_SIZE 27
@@ -416,7 +416,12 @@ static int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {
     return TSDB_CODE_MND_INVALID_DB;
   }
 
-  int32_t acctId = atoi(dbName);
+  int32_t acctId;
+  int32_t code = taosStr2int32(dbName, &acctId);
+  if (code != 0) {
+    return code;
+  }
+
   if (acctId != pUser->acctId) {
     return TSDB_CODE_MND_INVALID_DB_ACCT;
   }
@@ -1560,8 +1565,8 @@ static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *
 
 static int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
   int32_t code = 0;
-  SSdb *pSdb = pMnode->pSdb;
-  void *pIter = NULL;
+  SSdb   *pSdb = pMnode->pSdb;
+  void   *pIter = NULL;
 
   while (1) {
     SVgObj *pVgroup = NULL;
@@ -1941,9 +1946,9 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       continue;
     } else {
       mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64
-            " numOfTables:%d, changed to vgVersion:%d cfgVersion:%d stateTs:%" PRId64 " numOfTables:%d",
-            pDbCacheInfo->dbFName, pDbCacheInfo->vgVersion, pDbCacheInfo->cfgVersion, pDbCacheInfo->stateTs,
-            pDbCacheInfo->numOfTable, pDb->vgVersion, pDb->cfgVersion, pDb->stateTs, numOfTable);
+             " numOfTables:%d, changed to vgVersion:%d cfgVersion:%d stateTs:%" PRId64 " numOfTables:%d",
+             pDbCacheInfo->dbFName, pDbCacheInfo->vgVersion, pDbCacheInfo->cfgVersion, pDbCacheInfo->stateTs,
+             pDbCacheInfo->numOfTable, pDb->vgVersion, pDb->cfgVersion, pDb->stateTs, numOfTable);
     }
 
     if (pDbCacheInfo->cfgVersion < pDb->cfgVersion) {
@@ -1955,7 +1960,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       rsp.pTsmaRsp = taosMemoryCalloc(1, sizeof(STableTSMAInfoRsp));
       if (rsp.pTsmaRsp) rsp.pTsmaRsp->pTsmas = taosArrayInit(4, POINTER_BYTES);
       if (rsp.pTsmaRsp && rsp.pTsmaRsp->pTsmas) {
-        bool exist = false;
+        bool    exist = false;
         int32_t code = mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist);
         if (TSDB_CODE_SUCCESS != code) {
           mndReleaseDb(pMnode, pDb);
@@ -2386,7 +2391,8 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);
 
     char    durationVstr[128] = {0};
-    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE, pDb->cfg.daysPerFile);
+    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,
+                                       pDb->cfg.daysPerFile);
 
     varDataSetLen(durationVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
@@ -2402,9 +2408,9 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);
 
     if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
-        len = sprintf(&keepVstr[VARSTR_HEADER_SIZE], "%s,%s,%s", keep1Str, keep2Str, keep0Str);
+      len = sprintf(&keepVstr[VARSTR_HEADER_SIZE], "%s,%s,%s", keep1Str, keep2Str, keep0Str);
     } else {
-        len = sprintf(&keepVstr[VARSTR_HEADER_SIZE], "%s,%s,%s", keep0Str, keep1Str, keep2Str);
+      len = sprintf(&keepVstr[VARSTR_HEADER_SIZE], "%s,%s,%s", keep0Str, keep1Str, keep2Str);
     }
     varDataSetLen(keepVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index 8931558874..eb691b9dff 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -462,7 +462,7 @@ int32_t mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) {
       dInfo.isMnode = 0;
     }
 
-    if(taosArrayPush(pDnodeInfo, &dInfo) == NULL){
+    if (taosArrayPush(pDnodeInfo, &dInfo) == NULL) {
       code = terrno;
       sdbCancelFetch(pSdb, pIter);
       break;
@@ -471,12 +471,12 @@ int32_t mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) {
   TAOS_RETURN(code);
 }
 
-#define CHECK_MONITOR_PARA(para,err) \
-if (pCfg->monitorParas.para != para) { \
-  mError("dnode:%d, para:%d inconsistent with cluster:%d", pDnode->id, pCfg->monitorParas.para, para); \
-  terrno = err; \
-  return err;\
-}
+#define CHECK_MONITOR_PARA(para, err)                                                                    \
+  if (pCfg->monitorParas.para != para) {                                                                 \
+    mError("dnode:%d, para:%d inconsistent with cluster:%d", pDnode->id, pCfg->monitorParas.para, para); \
+    terrno = err;                                                                                        \
+    return err;                                                                                          \
+  }
 
 static int32_t mndCheckClusterCfgPara(SMnode *pMnode, SDnodeObj *pDnode, const SClusterCfg *pCfg) {
   CHECK_MONITOR_PARA(tsEnableMonitor, DND_REASON_STATUS_MONITOR_SWITCH_NOT_MATCH);
@@ -487,7 +487,8 @@ static int32_t mndCheckClusterCfgPara(SMnode *pMnode, SDnodeObj *pDnode, const S
   CHECK_MONITOR_PARA(tsSlowLogScope, DND_REASON_STATUS_MONITOR_SLOW_LOG_SCOPE_NOT_MATCH);
 
   if (0 != strcasecmp(pCfg->monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb)) {
-    mError("dnode:%d, tsSlowLogExceptDb:%s inconsistent with cluster:%s", pDnode->id, pCfg->monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb);
+    mError("dnode:%d, tsSlowLogExceptDb:%s inconsistent with cluster:%s", pDnode->id,
+           pCfg->monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb);
     terrno = TSDB_CODE_DNODE_INVALID_MONITOR_PARAS;
     return DND_REASON_STATUS_MONITOR_NOT_MATCH;
   }
@@ -583,8 +584,8 @@ static bool mndUpdateMnodeState(SMnodeObj *pObj, SMnodeLoad *pMload) {
   return stateChanged;
 }
 
-extern char* tsMonFwUri;
-extern char* tsMonSlowLogUri;
+extern char   *tsMonFwUri;
+extern char   *tsMonSlowLogUri;
 static int32_t mndProcessStatisReq(SRpcMsg *pReq) {
   SMnode    *pMnode = pReq->info.node;
   SStatisReq statisReq = {0};
@@ -596,9 +597,9 @@ static int32_t mndProcessStatisReq(SRpcMsg *pReq) {
     mInfo("process statis req,\n %s", statisReq.pCont);
   }
 
-  if (statisReq.type == MONITOR_TYPE_COUNTER){
+  if (statisReq.type == MONITOR_TYPE_COUNTER) {
     monSendContent(statisReq.pCont, tsMonFwUri);
-  }else if(statisReq.type == MONITOR_TYPE_SLOW_LOG){
+  } else if (statisReq.type == MONITOR_TYPE_SLOW_LOG) {
     monSendContent(statisReq.pCont, tsMonSlowLogUri);
   }
 
@@ -1058,27 +1059,27 @@ _OVER:
   TAOS_RETURN(code);
 }
 
-static void getSlowLogScopeString(int32_t scope, char* result){
-  if(scope == SLOW_LOG_TYPE_NULL) {
+static void getSlowLogScopeString(int32_t scope, char *result) {
+  if (scope == SLOW_LOG_TYPE_NULL) {
     (void)strcat(result, "NONE");
     return;
   }
-  while(scope > 0){
-    if(scope & SLOW_LOG_TYPE_QUERY) {
+  while (scope > 0) {
+    if (scope & SLOW_LOG_TYPE_QUERY) {
       (void)strcat(result, "QUERY");
       scope &= ~SLOW_LOG_TYPE_QUERY;
-    } else if(scope & SLOW_LOG_TYPE_INSERT) {
+    } else if (scope & SLOW_LOG_TYPE_INSERT) {
       (void)strcat(result, "INSERT");
       scope &= ~SLOW_LOG_TYPE_INSERT;
-    } else if(scope & SLOW_LOG_TYPE_OTHERS) {
+    } else if (scope & SLOW_LOG_TYPE_OTHERS) {
       (void)strcat(result, "OTHERS");
       scope &= ~SLOW_LOG_TYPE_OTHERS;
-    } else{
+    } else {
       (void)printf("invalid slow log scope:%d", scope);
       return;
     }
 
-    if(scope > 0) {
+    if (scope > 0) {
       (void)strcat(result, "|");
     }
   }
@@ -1440,7 +1441,7 @@ _OVER:
 
 static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) {
   int32_t code = 0;
-  char *p = pMCfgReq->config;
+  char   *p = pMCfgReq->config;
   while (*p) {
     if (*p == ' ') {
       break;
@@ -1538,7 +1539,7 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
     snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%d", flag);
 #endif
   } else {
-    TAOS_CHECK_GOTO (mndMCfg2DCfg(&cfgReq, &dcfgReq), NULL, _err_out);
+    TAOS_CHECK_GOTO(mndMCfg2DCfg(&cfgReq, &dcfgReq), NULL, _err_out);
     if (strlen(dcfgReq.config) > TSDB_DNODE_CONFIG_LEN) {
       mError("dnode:%d, failed to config since config is too long", cfgReq.dnodeId);
       code = TSDB_CODE_INVALID_CFG;
@@ -1881,11 +1882,19 @@ static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32
   if (' ' == pMCfgReq->config[optLen]) {
     // 'key value'
     if (strlen(pMCfgReq->value) != 0) goto _err;
-    *pOutValue = atoi(pMCfgReq->config + optLen + 1);
+    code = taosStr2int32(pMCfgReq->config + optLen + 1, pOutValue);
+    if (code != 0) {
+      mError("dnode:%d, failed to get cfg since code: %s", pMCfgReq->dnodeId, tstrerror(code));
+      goto _err;
+    }
   } else {
     // 'key' 'value'
     if (strlen(pMCfgReq->value) == 0) goto _err;
-    *pOutValue = atoi(pMCfgReq->value);
+    code = taosStr2int32(pMCfgReq->value, pOutValue);
+    if (code != 0) {
+      mError("dnode:%d, failed to get cfg since code: %s", pMCfgReq->dnodeId, tstrerror(code));
+      goto _err;
+    }
   }
 
   TAOS_RETURN(code);
diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c
index 53365303b0..3eb4c89dc1 100644
--- a/source/dnode/vnode/src/vnd/vnodeOpen.c
+++ b/source/dnode/vnode/src/vnd/vnodeOpen.c
@@ -190,7 +190,14 @@ int32_t vnodeRenameVgroupId(const char *srcPath, const char *dstPath, int32_t sr
     char *tsdbFilePrefixPos = strstr(oldRname, tsdbFilePrefix);
     if (tsdbFilePrefixPos == NULL) continue;
 
-    int32_t tsdbFileVgId = atoi(tsdbFilePrefixPos + prefixLen);
+    int32_t tsdbFileVgId = 0;  // atoi(tsdbFilePrefixPos + prefixLen);
+    ret = taosStr2int32(tsdbFilePrefixPos + prefixLen, &tsdbFileVgId);
+    if (ret != 0) {
+      vError("vgId:%d, failed to get tsdb file vgid since %s", dstVgId, tstrerror(ret));
+      tfsClosedir(tsdbDir);
+      return ret;
+    }
+
     if (tsdbFileVgId == srcVgId) {
       char *tsdbFileSurfixPos = tsdbFilePrefixPos + prefixLen + vnodeVgroupIdLen(srcVgId);
 
diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c
index 43f7b5a4ea..422f94ece4 100644
--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@@ -2872,13 +2872,16 @@ static int32_t getIpV4RangeFromWhitelistItem(char* ipRange, SIpV4Range* pIpRange
     *slash = '\0';
     struct in_addr addr;
     if (uv_inet_pton(AF_INET, ipCopy, &addr) == 0) {
-      int prefix = atoi(slash + 1);
-      if (prefix < 0 || prefix > 32) {
-        code = TSDB_CODE_PAR_INVALID_IP_RANGE;
-      } else {
-        pIpRange->ip = addr.s_addr;
-        pIpRange->mask = prefix;
-        code = TSDB_CODE_SUCCESS;
+      int32_t prefix = 0;
+      code = taosStr2int32(slash + 1, &prefix);
+      if (code == 0) {
+        if (prefix < 0 || prefix > 32) {
+          code = TSDB_CODE_PAR_INVALID_IP_RANGE;
+        } else {
+          pIpRange->ip = addr.s_addr;
+          pIpRange->mask = prefix;
+          code = TSDB_CODE_SUCCESS;
+        }
       }
     } else {
       code = TSDB_CODE_PAR_INVALID_IP_RANGE;
diff --git a/source/os/src/osString.c b/source/os/src/osString.c
index 0ee4f1c496..f6de06f4e9 100644
--- a/source/os/src/osString.c
+++ b/source/os/src/osString.c
@@ -132,6 +132,20 @@ int32_t taosStr2int64(const char *str, int64_t *val) {
   }
 }
 
+int32_t taosStr2int32(const char *str, int32_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
+  int64_t tmp = 0;
+  int32_t code = taosStr2int64(str, &tmp);
+  if (code) {
+    return code;
+  } else if (tmp > INT32_MAX || tmp < INT32_MIN) {
+    return TAOS_SYSTEM_ERROR(ERANGE);
+  } else {
+    *val = (int32_t)tmp;
+    return 0;
+  }
+}
 int32_t taosStr2int16(const char *str, int16_t *val) {
   OS_PARAM_CHECK(str);
   OS_PARAM_CHECK(val);
@@ -147,21 +161,6 @@ int32_t taosStr2int16(const char *str, int16_t *val) {
   }
 }
 
-int32_t taosStr2int32(const char *str, int32_t *val) {
-  OS_PARAM_CHECK(str);
-  OS_PARAM_CHECK(val);
-  int64_t tmp = 0;
-  int32_t code = taosStr2int64(str, &tmp);
-  if (code) {
-    return code;
-  } else if (tmp > INT32_MAX || tmp < INT32_MIN) {
-    return TAOS_SYSTEM_ERROR(ERANGE);
-  } else {
-    *val = (int32_t)tmp;
-    return 0;
-  }
-}
-
 int32_t taosStr2int8(const char *str, int8_t *val) {
   OS_PARAM_CHECK(str);
   OS_PARAM_CHECK(val);
@@ -177,6 +176,67 @@ int32_t taosStr2int8(const char *str, int8_t *val) {
   }
 }
 
+int32_t taosStr2Uint64(const char *str, uint64_t *val) {
+  if (str == NULL || val == NULL) {
+    return TSDB_CODE_INVALID_PARA;
+  }
+  char    *endptr = NULL;
+  uint64_t ret = strtoull(str, &endptr, 10);
+  if (errno == ERANGE && (ret == ULLONG_MAX)) {
+    return TAOS_SYSTEM_ERROR(errno);
+  } else if (errno == EINVAL && ret == 0) {
+    return TSDB_CODE_INVALID_PARA;
+  } else {
+    *val = ret;
+    return 0;
+  }
+}
+
+int32_t taosStr2Uint32(const char *str, uint32_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
+  uint64_t tmp = 0;
+  int32_t  code = taosStr2Uint64(str, &tmp);
+  if (code) {
+    return code;
+  } else if (tmp > UINT32_MAX) {
+    return TAOS_SYSTEM_ERROR(ERANGE);
+  } else {
+    *val = (int32_t)tmp;
+    return 0;
+  }
+}
+
+int32_t taosStr2Uint16(const char *str, uint16_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
+  uint64_t tmp = 0;
+  int32_t  code = taosStr2Uint64(str, &tmp);
+  if (code) {
+    return code;
+  } else if (tmp > UINT16_MAX) {
+    return TAOS_SYSTEM_ERROR(ERANGE);
+  } else {
+    *val = (int16_t)tmp;
+    return 0;
+  }
+}
+
+int32_t taosStr2Uint8(const char *str, uint8_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
+  uint64_t tmp = 0;
+  int32_t  code = taosStr2Uint64(str, &tmp);
+  if (code) {
+    return code;
+  } else if (tmp > UINT8_MAX) {
+    return TAOS_SYSTEM_ERROR(ERANGE);
+  } else {
+    *val = (int8_t)tmp;
+    return 0;
+  }
+}
+
 int32_t tasoUcs4Compare(TdUcs4 *f1_ucs4, TdUcs4 *f2_ucs4, int32_t bytes) {
   if ((f1_ucs4 == NULL || f2_ucs4 == NULL)) {
     return TSDB_CODE_INVALID_PARA;
@@ -223,7 +283,7 @@ int32_t tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4)
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
   }
-  
+
   (void)memcpy(target_ucs4, source_ucs4, len_ucs4 * sizeof(TdUcs4));
 
   return TSDB_CODE_SUCCESS;
@@ -289,7 +349,7 @@ void taosConvDestroy() {
 }
 
 iconv_t taosAcquireConv(int32_t *idx, ConvType type) {
-  if(idx == NULL) {
+  if (idx == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return (iconv_t)-1;
   }
@@ -356,7 +416,7 @@ bool taosMbsToUcs4(const char *mbs, size_t mbsLength, TdUcs4 *ucs4, int32_t ucs4
   if (ucs4_max_len == 0) {
     return true;
   }
-  if(ucs4_max_len < 0 || mbs == NULL || ucs4 == NULL) {
+  if (ucs4_max_len < 0 || mbs == NULL || ucs4 == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return false;
   }
@@ -372,9 +432,9 @@ bool taosMbsToUcs4(const char *mbs, size_t mbsLength, TdUcs4 *ucs4, int32_t ucs4
   if ((iconv_t)-1 == conv) {
     return false;
   }
-  
-  size_t  ucs4_input_len = mbsLength;
-  size_t  outLeft = ucs4_max_len;
+
+  size_t ucs4_input_len = mbsLength;
+  size_t outLeft = ucs4_max_len;
   if (iconv(conv, (char **)&mbs, &ucs4_input_len, (char **)&ucs4, &outLeft) == -1) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     taosReleaseConv(idx, conv, M2C);
@@ -401,7 +461,7 @@ int32_t taosUcs4ToMbs(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs) {
   if (ucs4_max_len == 0) {
     return 0;
   }
-  if(ucs4_max_len < 0 || ucs4 == NULL || mbs == NULL) {
+  if (ucs4_max_len < 0 || ucs4 == NULL || mbs == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
   }
@@ -417,18 +477,18 @@ int32_t taosUcs4ToMbs(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs) {
   if ((iconv_t)-1 == conv) {
     return terrno;
   }
-  
-  size_t  ucs4_input_len = ucs4_max_len;
-  size_t  outLen = ucs4_max_len;
+
+  size_t ucs4_input_len = ucs4_max_len;
+  size_t outLen = ucs4_max_len;
   if (iconv(conv, (char **)&ucs4, &ucs4_input_len, &mbs, &outLen) == -1) {
     code = TAOS_SYSTEM_ERROR(errno);
     taosReleaseConv(idx, conv, C2M);
-    terrno = code;    
+    terrno = code;
     return code;
   }
-  
+
   taosReleaseConv(idx, conv, C2M);
-  
+
   return (int32_t)(ucs4_max_len - outLen);
 #endif
 }
@@ -439,7 +499,7 @@ int32_t taosUcs4ToMbsEx(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs, iconv_t c
   if (ucs4_max_len == 0) {
     return 0;
   }
-  if(ucs4_max_len < 0 || ucs4 == NULL || mbs == NULL) {
+  if (ucs4_max_len < 0 || ucs4 == NULL || mbs == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
   }
@@ -455,13 +515,13 @@ int32_t taosUcs4ToMbsEx(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs, iconv_t c
     terrno = TAOS_SYSTEM_ERROR(errno);
     return terrno;
   }
-  
+
   return (int32_t)(ucs4_max_len - outLen);
 #endif
 }
 
 bool taosValidateEncodec(const char *encodec) {
-  if(encodec == NULL) {
+  if (encodec == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return false;
   }
@@ -513,7 +573,7 @@ int32_t taosHexEncode(const unsigned char *src, char *dst, int32_t len, int32_t
 }
 
 int32_t taosHexDecode(const char *src, char *dst, int32_t len) {
-  if(!src || !dst || len <= 0) {
+  if (!src || !dst || len <= 0) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
   }
@@ -556,9 +616,10 @@ int32_t taosMbsToWchars(TdWchar *pWchars, const char *pStrs, int32_t size) {
   return mbstowcs(pWchars, pStrs, size);
 }
 
-int32_t taosWcharToMb(char *pStr, TdWchar wchar) { 
+int32_t taosWcharToMb(char *pStr, TdWchar wchar) {
   OS_PARAM_CHECK(pStr);
-  return wctomb(pStr, wchar); }
+  return wctomb(pStr, wchar);
+}
 
 char *taosStrCaseStr(const char *str, const char *pattern) {
   if (str == NULL) {
@@ -580,7 +641,7 @@ char *taosStrCaseStr(const char *str, const char *pattern) {
 }
 
 int64_t taosStr2Int64(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -592,7 +653,7 @@ int64_t taosStr2Int64(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint64_t taosStr2UInt64(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -604,7 +665,7 @@ uint64_t taosStr2UInt64(const char *str, char **pEnd, int32_t radix) {
 }
 
 int32_t taosStr2Int32(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -616,7 +677,7 @@ int32_t taosStr2Int32(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint32_t taosStr2UInt32(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -628,7 +689,7 @@ uint32_t taosStr2UInt32(const char *str, char **pEnd, int32_t radix) {
 }
 
 int16_t taosStr2Int16(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -640,7 +701,7 @@ int16_t taosStr2Int16(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint16_t taosStr2UInt16(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -652,7 +713,7 @@ uint16_t taosStr2UInt16(const char *str, char **pEnd, int32_t radix) {
 }
 
 int8_t taosStr2Int8(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -661,7 +722,7 @@ int8_t taosStr2Int8(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint8_t taosStr2UInt8(const char *str, char **pEnd, int32_t radix) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -673,7 +734,7 @@ uint8_t taosStr2UInt8(const char *str, char **pEnd, int32_t radix) {
 }
 
 double taosStr2Double(const char *str, char **pEnd) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -682,7 +743,7 @@ double taosStr2Double(const char *str, char **pEnd) {
 }
 
 float taosStr2Float(const char *str, char **pEnd) {
-  if(str == NULL) {
+  if (str == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -698,7 +759,7 @@ bool isHex(const char *z, uint32_t n) {
 }
 
 bool isValidateHex(const char *z, uint32_t n) {
-  if(!z) {
+  if (!z) {
     terrno = TSDB_CODE_INVALID_PARA;
     return false;
   }
@@ -724,12 +785,12 @@ int32_t taosHex2Ascii(const char *z, uint32_t n, void **data, uint32_t *size) {
     }
     return 0;
   }
-  
+
   uint8_t *tmp = (uint8_t *)taosMemoryCalloc(*size, 1);
   if (tmp == NULL) {
     return terrno;
   }
-  
+
   int8_t   num = 0;
   uint8_t *byte = tmp + *size - 1;
 
@@ -749,7 +810,7 @@ int32_t taosHex2Ascii(const char *z, uint32_t n, void **data, uint32_t *size) {
     }
   }
   *data = tmp;
-  
+
   return 0;
 }
 
@@ -825,7 +886,7 @@ int32_t taosAscii2Hex(const char *z, uint32_t n, void **data, uint32_t *size) {
   if (tmp == NULL) {
     return terrno;
   }
-  
+
   *data = tmp;
   *(tmp++) = '\\';
   *(tmp++) = 'x';
@@ -834,7 +895,7 @@ int32_t taosAscii2Hex(const char *z, uint32_t n, void **data, uint32_t *size) {
     tmp[i * 2] = valueOf(val >> 4);
     tmp[i * 2 + 1] = valueOf(val & 0x0F);
   }
-  
+
   return 0;
 }
 
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index d2a2b1fb9a..549d50b4d0 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -151,17 +151,19 @@ static int32_t cfgCheckAndSetDir(SConfigItem *pItem, const char *inputDir) {
 }
 
 static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
-  bool tmp = false;
+  int32_t code = 0;
+  bool    tmp = false;
   if (strcasecmp(value, "true") == 0) {
     tmp = true;
   }
-  if (atoi(value) > 0) {
+  int32_t val = 0;
+  if ((code = taosStr2int32(value, &val)) == 0 && val > 0) {
     tmp = true;
   }
 
   pItem->bval = tmp;
   pItem->stype = stype;
-  return 0;
+  return code;
 }
 
 static int32_t cfgSetInt32(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
@@ -258,6 +260,7 @@ static int32_t cfgSetTimezone(SConfigItem *pItem, const char *value, ECfgSrcType
 
 static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value, const char *level, const char *primary,
                              const char *disable, ECfgSrcType stype) {
+  int32_t code = 0;
   (void)taosThreadMutexLock(&pCfg->lock);
 
   SConfigItem *pItem = cfgGetItem(pCfg, name);
@@ -278,9 +281,21 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
 
   SDiskCfg cfg = {0};
   tstrncpy(cfg.dir, pItem->str, sizeof(cfg.dir));
-  cfg.level = level ? atoi(level) : 0;
-  cfg.primary = primary ? atoi(primary) : 1;
-  cfg.disable = disable ? atoi(disable) : 0;
+
+  code = taosStr2int32(level, &cfg.level);
+  if (code != 0) {
+    cfg.level = 0;
+  }
+  code = taosStr2int32(primary, &cfg.primary);
+  if (code != 0) {
+    cfg.primary = 1;
+  }
+
+  code = taosStr2int8(primary, &cfg.disable);
+  if (code != 0) {
+    cfg.disable = 0;
+  }
+
   void *ret = taosArrayPush(pItem->array, &cfg);
   if (ret == NULL) {
     (void)taosThreadMutexUnlock(&pCfg->lock);
@@ -412,6 +427,7 @@ void cfgLock(SConfig *pCfg) {
 void cfgUnLock(SConfig *pCfg) { (void)taosThreadMutexUnlock(&pCfg->lock); }
 
 int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *pVal, bool isServer) {
+  int32_t     code = 0;
   ECfgDynType dynType = isServer ? CFG_DYN_SERVER : CFG_DYN_CLIENT;
 
   cfgLock(pCfg);
@@ -443,8 +459,9 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
       }
     } break;
     case CFG_DTYPE_BOOL: {
-      int32_t ival = (int32_t)atoi(pVal);
-      if (ival != 0 && ival != 1) {
+      int32_t ival = 0;
+      code = taosStr2int32(pVal, &ival);
+      if (code != 0 || (ival != 0 && ival != 1)) {
         uError("cfg:%s, type:%s value:%d out of range[0, 1]", pItem->name, cfgDtypeStr(pItem->dtype), ival);
         cfgUnLock(pCfg);
         TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
@@ -887,9 +904,10 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
             for (size_t j = 0; j < sz; ++j) {
               SDiskCfg *pCfg = taosArrayGet(pItem->array, j);
               if (dump) {
-                (void)printf("%s %s %s l:%d p:%d d:%"PRIi8"\n", src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
+                (void)printf("%s %s %s l:%d p:%d d:%" PRIi8 "\n", src, name, pCfg->dir, pCfg->level, pCfg->primary,
+                             pCfg->disable);
               } else {
-                uInfo("%s %s %s l:%d p:%d d:%"PRIi8, src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
+                uInfo("%s %s %s l:%d p:%d d:%" PRIi8, src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
               }
             }
             break;
diff --git a/source/util/src/tversion.c b/source/util/src/tversion.c
index d1a2ecf827..8978ae6b66 100644
--- a/source/util/src/tversion.c
+++ b/source/util/src/tversion.c
@@ -18,6 +18,7 @@
 #include "taoserror.h"
 
 int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
+  int32_t code = 0;
   if (vstr == NULL) {
     return terrno = TSDB_CODE_INVALID_VERSION_STRING;
   }
@@ -31,7 +32,11 @@ int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
     if (vstr[spos] != '.') {
       tmp[spos - tpos] = vstr[spos];
     } else {
-      vnum[vpos] = atoi(tmp);
+      code = taosStr2int32(tmp, &vnum[vpos]);
+      if (code != 0) {
+        return code;
+      }
+      // vnum[vpos] = atoi(tmp);
       memset(tmp, 0, sizeof(tmp));
       vpos++;
       tpos = spos + 1;
@@ -39,7 +44,10 @@ int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
   }
 
   if ('\0' != tmp[0] && vpos < 4) {
-    vnum[vpos] = atoi(tmp);
+    code = taosStr2int32(tmp, &vnum[vpos]);
+    if (code != 0) {
+      return code;
+    }
   }
 
   if (vnum[0] <= 0) {

From 9b24082d313a381949df9052f9c522f394b9f630 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 13:35:17 +0800
Subject: [PATCH 02/25] Replace unsafe memory functions with safe versions

---
 source/util/src/tversion.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/source/util/src/tversion.c b/source/util/src/tversion.c
index 8978ae6b66..1a8d8f2d23 100644
--- a/source/util/src/tversion.c
+++ b/source/util/src/tversion.c
@@ -36,7 +36,6 @@ int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
       if (code != 0) {
         return code;
       }
-      // vnum[vpos] = atoi(tmp);
       memset(tmp, 0, sizeof(tmp));
       vpos++;
       tpos = spos + 1;

From a2ed0bf0b41458f63511edfd455ee1e3a049241e Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 14:38:16 +0800
Subject: [PATCH 03/25] Replace unsafe memory functions with safe versions

---
 source/os/src/osString.c         |   7 +
 source/os/test/osStringTests.cpp | 430 +++++++++++++++++++++++++++++++
 2 files changed, 437 insertions(+)

diff --git a/source/os/src/osString.c b/source/os/src/osString.c
index f6de06f4e9..9a681d9d75 100644
--- a/source/os/src/osString.c
+++ b/source/os/src/osString.c
@@ -120,6 +120,7 @@ int32_t taosStr2int64(const char *str, int64_t *val) {
   if (str == NULL || val == NULL) {
     return TSDB_CODE_INVALID_PARA;
   }
+  errno = 0;
   char   *endptr = NULL;
   int64_t ret = strtoll(str, &endptr, 10);
   if (errno == ERANGE && (ret == LLONG_MAX || ret == LLONG_MIN)) {
@@ -127,6 +128,9 @@ int32_t taosStr2int64(const char *str, int64_t *val) {
   } else if (errno == EINVAL && ret == 0) {
     return TSDB_CODE_INVALID_PARA;
   } else {
+    if (endptr == str) {
+      return TSDB_CODE_INVALID_PARA;
+    }
     *val = ret;
     return 0;
   }
@@ -187,6 +191,9 @@ int32_t taosStr2Uint64(const char *str, uint64_t *val) {
   } else if (errno == EINVAL && ret == 0) {
     return TSDB_CODE_INVALID_PARA;
   } else {
+    if (str == endptr) {
+      return TSDB_CODE_INVALID_PARA;
+    }
     *val = ret;
     return 0;
   }
diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index de07d21959..d4ab6a097f 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -154,3 +154,433 @@ TEST(osStringTests, ostsnprintfTests) {
     EXPECT_EQ(ret, 11);
     EXPECT_STREQ(buffer, "Float: 3.14");
 }
+TEST(osStringTests, osStr2Int64) {
+    int64_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2int64(NULL, &val);
+    assert(result == TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int64("123", NULL);
+    assert(result == TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2int64("abc", &val);
+    assert(result == TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int64("", &val);
+    assert(result == TSDB_CODE_INVALID_PARA);
+   char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%lld", LLONG_MAX);
+    result = taosStr2int64(large_num, &val);
+    assert(result == 0);
+    assert(val == LLONG_MAX);
+
+    snprintf(large_num, sizeof(large_num), "%lld", LLONG_MIN);
+    result = taosStr2int64(large_num, &val);
+    assert(result == 0);
+    assert(val == LLONG_MIN);
+
+    // 测试有效的整数字符串
+    result = taosStr2int64("12345", &val);
+    assert(result == 0);
+    assert(val == 12345);
+
+    result = taosStr2int64("-12345", &val);
+    assert(result == 0);
+    assert(val == -12345);
+
+    result = taosStr2int64("0", &val);
+    assert(result == 0);
+    assert(val == 0);
+
+    // 测试带空格的字符串
+    result = taosStr2int64("  12345", &val);
+    assert(result == 0);
+    assert(val == 12345);
+
+    result = taosStr2int64("12345  ", &val);
+    assert(result == 0);
+    assert(val == 12345);
+}
+TEST(osStringTests, osStr2int32) {
+    int32_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2int32(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int32("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2int32("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int32("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试超出范围的值
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%d", INT_MAX);
+     result = taosStr2int32(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, INT_MAX);
+
+    snprintf(large_num, sizeof(large_num), "%d", INT_MIN);
+    result = taosStr2int32(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, INT_MIN);
+
+     // 测试大于 INT32 范围的值
+    snprintf(large_num, sizeof(large_num), "%lld", (long long)INT_MAX + 1);
+    result = taosStr2int32(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    snprintf(large_num, sizeof(large_num), "%lld", (long long)INT_MIN - 1);
+    result = taosStr2int32(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    
+
+    // 测试有效的整数字符串
+    result = taosStr2int32("12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2int32("-12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, -12345);
+
+    result = taosStr2int32("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2int32("  12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2int32("12345  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+}
+
+TEST(osStringTests, taosStr2int16) {
+    int16_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2int16(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int16("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2int16("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int16("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试超出范围的值
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%d", INT16_MAX);
+    result = taosStr2int16(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, INT16_MAX);
+
+    snprintf(large_num, sizeof(large_num), "%d", INT16_MIN);
+    result = taosStr2int16(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, INT16_MIN);
+
+    // 测试大于 INT16 范围的值
+    snprintf(large_num, sizeof(large_num), "%lld", (long long)INT16_MAX + 1);
+    result = taosStr2int16(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    snprintf(large_num, sizeof(large_num), "%lld", (long long)INT16_MIN - 1);
+    result = taosStr2int16(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    // 测试有效的整数字符串
+    result = taosStr2int16("12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2int16("-12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, -12345);
+
+    result = taosStr2int16("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2int16("  12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2int16("12345  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+}
+
+
+TEST(osStringTests, taosStr2int8) {
+    int8_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2int8(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int8("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2int8("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2int8("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试超出范围的值
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%d", INT8_MAX);
+    result = taosStr2int8(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, INT8_MAX);
+
+    snprintf(large_num, sizeof(large_num), "%d", INT8_MIN);
+    result = taosStr2int8(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, INT8_MIN);
+
+    // 测试大于 INT8 范围的值
+    snprintf(large_num, sizeof(large_num), "%lld", (long long)INT8_MAX + 1);
+    result = taosStr2int8(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    snprintf(large_num, sizeof(large_num), "%lld", (long long)INT8_MIN - 1);
+    result = taosStr2int8(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    // 测试有效的整数字符串
+    result = taosStr2int8("123", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2int8("-123", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, -123);
+
+    result = taosStr2int8("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2int8("  123", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2int8("123  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 123);
+}
+
+TEST(osStringTests, osStr2Uint64) {
+   uint64_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2Uint64(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint64("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2Uint64("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint64("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%llu", ULLONG_MAX);
+    result = taosStr2Uint64(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, ULLONG_MAX);
+
+    // 测试有效的整数字符串
+    result = taosStr2Uint64("12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2Uint64("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2Uint64("  12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2Uint64("12345  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+}
+
+TEST(osStringTests, taosStr2Uint32) {
+    uint32_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2Uint32(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint32("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2Uint32("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint32("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试超出范围的值
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%u", UINT32_MAX);
+    result = taosStr2Uint32(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, UINT32_MAX);
+
+    // 测试大于 UINT32 范围的值
+    snprintf(large_num, sizeof(large_num), "%llu", (unsigned long long)UINT32_MAX + 1);
+    result = taosStr2Uint32(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    // 测试有效的整数字符串
+    result = taosStr2Uint32("12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2Uint32("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2Uint32("  12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2Uint32("12345  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+}
+
+TEST(osStringTests, taosStr2Uint16) {
+    uint16_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2Uint16(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint16("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2Uint16("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint16("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试超出范围的值
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%u", UINT16_MAX);
+    result = taosStr2Uint16(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, UINT16_MAX);
+
+    // 测试大于 UINT16 范围的值
+    snprintf(large_num, sizeof(large_num), "%llu", (unsigned long long)UINT16_MAX + 1);
+    result = taosStr2Uint16(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    // 测试有效的整数字符串
+    result = taosStr2Uint16("12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2Uint16("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2Uint16("  12345", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+
+    result = taosStr2Uint16("12345  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 12345);
+}
+
+TEST(osStringTests, taosStr2Uint8) {
+    uint8_t val;
+    int32_t result;
+
+    // 测试空指针输入
+    result = taosStr2Uint8(NULL, &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint8("123", NULL);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试无效输入
+    result = taosStr2Uint8("abc", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    result = taosStr2Uint8("", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+
+    // 测试超出范围的值
+    char large_num[50];
+    snprintf(large_num, sizeof(large_num), "%u", UINT8_MAX);
+    result = taosStr2Uint8(large_num, &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, UINT8_MAX);
+
+    // 测试大于 UINT8 范围的值
+    snprintf(large_num, sizeof(large_num), "%llu", (unsigned long long)UINT8_MAX + 1);
+    result = taosStr2Uint8(large_num, &val);
+    ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
+
+    // 测试有效的整数字符串
+    result = taosStr2Uint8("123", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2Uint8("0", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 0);
+
+    // 测试带空格的字符串
+    result = taosStr2Uint8("  123", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2Uint8("123  ", &val);
+    ASSERT_EQ(result, 0);
+    ASSERT_EQ(val, 123);
+}
+

From ffa126da2a7f75bab710ae499465cf6b32359572 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 15:16:42 +0800
Subject: [PATCH 04/25] Replace unsafe memory functions with safe versions

---
 source/os/test/osStringTests.cpp | 49 ++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index d4ab6a097f..dcb17990e7 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -182,6 +182,12 @@ TEST(osStringTests, osStr2Int64) {
     assert(result == 0);
     assert(val == LLONG_MIN);
 
+    result = taosStr2int64("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2int64("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
     // 测试有效的整数字符串
     result = taosStr2int64("12345", &val);
     assert(result == 0);
@@ -244,6 +250,12 @@ TEST(osStringTests, osStr2int32) {
     ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
 
     
+    result = taosStr2int32("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2int32("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
 
     // 测试有效的整数字符串
     result = taosStr2int32("12345", &val);
@@ -307,6 +319,12 @@ TEST(osStringTests, taosStr2int16) {
     result = taosStr2int16(large_num, &val);
     ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
 
+    result = taosStr2int16("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2int16("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
     // 测试有效的整数字符串
     result = taosStr2int16("12345", &val);
     ASSERT_EQ(result, 0);
@@ -370,6 +388,13 @@ TEST(osStringTests, taosStr2int8) {
     result = taosStr2int8(large_num, &val);
     ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
 
+    result = taosStr2int8("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2int8("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    
     // 测试有效的整数字符串
     result = taosStr2int8("123", &val);
     ASSERT_EQ(result, 0);
@@ -417,6 +442,12 @@ TEST(osStringTests, osStr2Uint64) {
     ASSERT_EQ(result, 0);
     ASSERT_EQ(val, ULLONG_MAX);
 
+    result = taosStr2Uint64("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2Uint64("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
     // 测试有效的整数字符串
     result = taosStr2Uint64("12345", &val);
     ASSERT_EQ(result, 0);
@@ -467,6 +498,12 @@ TEST(osStringTests, taosStr2Uint32) {
     result = taosStr2Uint32(large_num, &val);
     ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
 
+    result = taosStr2Uint32("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2Uint32("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
     // 测试有效的整数字符串
     result = taosStr2Uint32("12345", &val);
     ASSERT_EQ(result, 0);
@@ -516,6 +553,12 @@ TEST(osStringTests, taosStr2Uint16) {
     result = taosStr2Uint16(large_num, &val);
     ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
 
+    result = taosStr2Uint16("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2Uint16("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
     // 测试有效的整数字符串
     result = taosStr2Uint16("12345", &val);
     ASSERT_EQ(result, 0);
@@ -565,6 +608,12 @@ TEST(osStringTests, taosStr2Uint8) {
     result = taosStr2Uint8(large_num, &val);
     ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
 
+    result = taosStr2Uint8("123abc", &val);
+    ASSERT_EQ(result, 0);     
+    ASSERT_EQ(val, 123);
+
+    result = taosStr2Uint8("abc123", &val);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
     // 测试有效的整数字符串
     result = taosStr2Uint8("123", &val);
     ASSERT_EQ(result, 0);

From 4d193bcf5d607c3327d8f63436a495c57007a9c5 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 15:29:54 +0800
Subject: [PATCH 05/25] Replace unsafe memory functions with safe versions

---
 source/common/src/cos.c                       | 24 +++++++++++--------
 source/libs/monitorfw/src/taos_monitor_util.c |  5 ++--
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/source/common/src/cos.c b/source/common/src/cos.c
index a7e69ddc4c..3c72e21a4f 100644
--- a/source/common/src/cos.c
+++ b/source/common/src/cos.c
@@ -261,7 +261,7 @@ static void responseCompleteCallback(S3Status status, const S3ErrorDetails *erro
       for (int i = 0; i < error->extraDetailsCount; i++) {
         if (elen - len > 0) {
           len += tsnprintf(&(cbd->err_msg[len]), elen - len, "    %s: %s\n", error->extraDetails[i].name,
-                          error->extraDetails[i].value);
+                           error->extraDetails[i].value);
         }
       }
     }
@@ -742,9 +742,9 @@ upload:
       TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(EIO), &lino, _exit);
     }
     n = tsnprintf(buf, sizeof(buf),
-                 "<Part><PartNumber>%d</PartNumber>"
-                 "<ETag>%s</ETag></Part>",
-                 i + 1, manager.etags[i]);
+                  "<Part><PartNumber>%d</PartNumber>"
+                  "<ETag>%s</ETag></Part>",
+                  i + 1, manager.etags[i]);
     size += growbuffer_append(&(manager.gb), buf, n);
   }
   size += growbuffer_append(&(manager.gb), "</CompleteMultipartUpload>", strlen("</CompleteMultipartUpload>"));
@@ -908,10 +908,10 @@ upload:
   int  n;
   for (int i = 0; i < cp.part_num; ++i) {
     n = tsnprintf(buf, sizeof(buf),
-                 "<Part><PartNumber>%d</PartNumber>"
-                 "<ETag>%s</ETag></Part>",
-                 // i + 1, manager.etags[i]);
-                 cp.parts[i].index + 1, cp.parts[i].etag);
+                  "<Part><PartNumber>%d</PartNumber>"
+                  "<ETag>%s</ETag></Part>",
+                  // i + 1, manager.etags[i]);
+                  cp.parts[i].index + 1, cp.parts[i].etag);
     size += growbuffer_append(&(manager.gb), buf, n);
   }
   size += growbuffer_append(&(manager.gb), "</CompleteMultipartUpload>", strlen("</CompleteMultipartUpload>"));
@@ -1916,7 +1916,8 @@ void s3EvictCache(const char *path, long object_size) {
 }
 
 long s3Size(const char *object_name) {
-  long size = 0;
+  int32_t code = 0;
+  long    size = 0;
 
   cos_pool_t            *p = NULL;
   int                    is_cname = 0;
@@ -1941,7 +1942,10 @@ long s3Size(const char *object_name) {
   if (cos_status_is_ok(s)) {
     char *content_length_str = (char *)apr_table_get(resp_headers, COS_CONTENT_LENGTH);
     if (content_length_str != NULL) {
-      size = atol(content_length_str);
+      code = taosStr2Int64(content_length_str, &size);
+      if (code != 0) {
+        cos_warn_log("parse content length failed since %s\n", tstrerror(code));
+      }
     }
     cos_warn_log("head object succeeded: %ld\n", size);
   } else {
diff --git a/source/libs/monitorfw/src/taos_monitor_util.c b/source/libs/monitorfw/src/taos_monitor_util.c
index b0eff27507..1240526d48 100644
--- a/source/libs/monitorfw/src/taos_monitor_util.c
+++ b/source/libs/monitorfw/src/taos_monitor_util.c
@@ -41,10 +41,11 @@ void taos_monitor_split_str_metric(char** arr, taos_metric_t* metric, const char
   memset(name, 0, size + 1);
   memcpy(name, metric->name, size);
 
-  char* s = strtok(name, del);
+  char* saveptr;
+  char* s = strtok_r(name, del, &saveptr);
   while (s != NULL) {
     *arr++ = s;
-    s = strtok(NULL, del);
+    s = strtok_r(NULL, del, &saveptr);
   }
 
   *buf = name;

From 4d51e218dcb62ac7a732e642acbddce2f4b049a5 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 16:39:56 +0800
Subject: [PATCH 06/25] use safe func

---
 source/libs/stream/src/streamBackendRocksdb.c | 21 +++++++++++--------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 68c99aa1b3..4be541abdd 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -3386,7 +3386,8 @@ int32_t streamStateGetFirst_rocksdb(SStreamState* pState, SWinKey* key) {
   return streamStateDel_rocksdb(pState, &tmp);
 }
 
-int32_t streamStateFillGetGroupKVByCur_rocksdb(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen) {
+int32_t streamStateFillGetGroupKVByCur_rocksdb(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal,
+                                               int32_t* pVLen) {
   if (!pCur) {
     return -1;
   }
@@ -4343,7 +4344,7 @@ int32_t streamStatePutParTag_rocksdb(SStreamState* pState, int64_t groupId, cons
 
 void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t groupId, SStreamStateCur* pCur) {
   if (pCur == NULL) {
-    return ;
+    return;
   }
   STaskDbWrapper* wrapper = pState->pTdbState->pOwner->pBackend;
   pCur->number = pState->number;
@@ -4353,13 +4354,13 @@ void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t gr
   int i = streamStateGetCfIdx(pState, "partag");
   if (i < 0) {
     stError("streamState failed to put to cf name:%s", "partag");
-    return ;
+    return;
   }
 
   char    buf[128] = {0};
   int32_t klen = ginitDict[i].enFunc((void*)&groupId, buf);
   if (!streamStateIterSeekAndValid(pCur->iter, buf, klen)) {
-    return ;
+    return;
   }
   // skip ttl expired data
   while (rocksdb_iter_valid(pCur->iter) && iterValueIsStale(pCur->iter)) {
@@ -4371,13 +4372,14 @@ void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t gr
     size_t  kLen = 0;
     char*   keyStr = (char*)rocksdb_iter_key(pCur->iter, &kLen);
     TAOS_UNUSED(parKeyDecode((void*)&curGroupId, keyStr));
-    if (curGroupId > groupId) return ;
+    if (curGroupId > groupId) return;
 
     rocksdb_iter_next(pCur->iter);
   }
 }
 
-int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal, int32_t* pVLen) {
+int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal,
+                                            int32_t* pVLen) {
   stDebug("streamStateFillGetKVByCur_rocksdb");
   if (!pCur) {
     return -1;
@@ -4714,7 +4716,7 @@ int32_t compareHashTableImpl(SHashObj* p1, SHashObj* p2, SArray* diff) {
       if (fname == NULL) {
         return terrno;
       }
-      TAOS_UNUSED(strncpy(fname, name, len));
+      tstrncpy(fname, name, strlen(name));
       if (taosArrayPush(diff, &fname) == NULL) {
         taosMemoryFree(fname);
         return terrno;
@@ -4876,7 +4878,7 @@ int32_t dbChkpGetDelta(SDbChkp* p, int64_t chkpId, SArray* list) {
           return terrno;
         }
 
-        TAOS_UNUSED(strncpy(fname, name, len));
+        tstrncpy(fname, name, strlen(name));
         if (taosArrayPush(p->pAdd, &fname) == NULL) {
           taosMemoryFree(fname);
           TAOS_UNUSED(taosThreadRwlockUnlock(&p->rwLock));
@@ -5351,7 +5353,8 @@ SStreamStateCur* streamStateSeekKeyPrev_rocksdb(SStreamState* pState, const SWin
   return NULL;
 }
 
-int32_t streamStateGetGroupKVByCur_rocksdb(SStreamState* pState, SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen) {
+int32_t streamStateGetGroupKVByCur_rocksdb(SStreamState* pState, SStreamStateCur* pCur, SWinKey* pKey,
+                                           const void** pVal, int32_t* pVLen) {
   if (!pCur) {
     return -1;
   }

From 42519e95526b5843ecbebdce563e9cd249cbd9ce Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 17:56:18 +0800
Subject: [PATCH 07/25] use safe func

---
 source/libs/stream/src/streamBackendRocksdb.c | 147 +++++++++++++-----
 1 file changed, 104 insertions(+), 43 deletions(-)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 4be541abdd..742b8a9e7c 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -1156,13 +1156,17 @@ int32_t chkpMayDelObsolete(void* arg, int64_t chkpId, char* path) {
 
   taosArrayDestroy(pBackend->chkpSaved);
   pBackend->chkpSaved = chkpDup;
+  chkpDup = NULL;
 
   TAOS_UNUSED(taosThreadRwlockUnlock(&pBackend->chkpDirLock));
 
   for (int i = 0; i < taosArrayGetSize(chkpDel); i++) {
     int64_t id = *(int64_t*)taosArrayGet(chkpDel, i);
     char    tbuf[256] = {0};
-    sprintf(tbuf, "%s%scheckpoint%" PRId64 "", path, TD_DIRSEP, id);
+    if (snprintf(tbuf, sizeof(tbuf), "%s%scheckpoint%" PRId64 "", path, TD_DIRSEP, id) >= sizeof(tbuf)) {
+      code = TSDB_CODE_OUT_OF_RANGE;
+      TAOS_CHECK_GOTO(code, NULL, _exception);
+    }
 
     stInfo("backend remove obsolete checkpoint: %s", tbuf);
     if (taosIsDir(tbuf)) {
@@ -1187,12 +1191,17 @@ int chkpIdComp(const void* a, const void* b) {
 }
 int32_t taskDbLoadChkpInfo(STaskDbWrapper* pBackend) {
   int32_t code = 0;
-  char*   pChkpDir = taosMemoryCalloc(1, 256);
+  int32_t nBytes = 0;
+  int32_t cap = 256;
+  char*   pChkpDir = taosMemoryCalloc(1, cap);
   if (pChkpDir == NULL) {
     return terrno;
   }
 
-  sprintf(pChkpDir, "%s%s%s", pBackend->path, TD_DIRSEP, "checkpoints");
+  nBytes = snprintf(pChkpDir, cap, "%s%s%s", pBackend->path, TD_DIRSEP, "checkpoints");
+  if (nBytes >= cap) {
+    return TSDB_CODE_OUT_OF_RANGE;
+  }
   if (!taosIsDir(pChkpDir)) {
     taosMemoryFree(pChkpDir);
     return 0;
@@ -1413,12 +1422,18 @@ int32_t taskDbDestroySnap(void* arg, SArray* pSnapInfo) {
   if (pSnapInfo == NULL) return 0;
   SStreamMeta* pMeta = arg;
   int32_t      code = 0;
+  int32_t      cap = 256;
+  int32_t      nBytes = 0;
   streamMutexLock(&pMeta->backendMutex);
 
-  char buf[128] = {0};
+  char buf[256] = {0};
   for (int i = 0; i < taosArrayGetSize(pSnapInfo); i++) {
     SStreamTaskSnap* pSnap = taosArrayGet(pSnapInfo, i);
-    sprintf(buf, "0x%" PRIx64 "-0x%x", pSnap->streamId, (int32_t)pSnap->taskId);
+    nBytes = snprintf(buf, cap, "0x%" PRIx64 "-0x%x", pSnap->streamId, (int32_t)pSnap->taskId);
+    if (nBytes <= 0 || nBytes >= cap) {
+      code = TSDB_CODE_OUT_OF_RANGE;
+      break;
+    }
     STaskDbWrapper** pTaskDb = taosHashGet(pMeta->pTaskDbUnique, buf, strlen(buf));
     if (pTaskDb == NULL || *pTaskDb == NULL) {
       stWarn("stream backend:%p failed to find task db, streamId:% " PRId64 "", pMeta, pSnap->streamId);
@@ -1430,7 +1445,7 @@ int32_t taskDbDestroySnap(void* arg, SArray* pSnapInfo) {
     taskDbUnRefChkp(*pTaskDb, pSnap->chkpId);
   }
   streamMutexUnlock(&pMeta->backendMutex);
-  return 0;
+  return code;
 }
 #ifdef BUILD_NO_CALL
 int32_t streamBackendAddInUseChkp(void* arg, int64_t chkpId) {
@@ -2447,43 +2462,50 @@ void taskDbDestroyChkpOpt(STaskDbWrapper* pTaskDb) {
 
 int32_t taskDbBuildFullPath(char* path, char* key, char** dbFullPath, char** stateFullPath) {
   int32_t code = 0;
-  char*   statePath = taosMemoryCalloc(1, strlen(path) + 128);
+  int32_t cap = strlen(path) + 128, nBytes = 0;
+  char*   statePath = NULL;
+  char*   dbPath = NULL;
+
+  statePath = taosMemoryCalloc(1, cap);
   if (statePath == NULL) {
-    return terrno;
+    TAOS_CHECK_GOTO(terrno, NULL, _err);
+  }
+
+  nBytes = snprintf(statePath, cap, "%s%s%s", path, TD_DIRSEP, key);
+  if (nBytes < 0 || nBytes >= cap) {
+    code = TSDB_CODE_OUT_OF_RANGE;
+    TAOS_CHECK_GOTO(code, NULL, _err);
   }
 
-  sprintf(statePath, "%s%s%s", path, TD_DIRSEP, key);
   if (!taosDirExist(statePath)) {
     code = taosMulMkDir(statePath);
-    if (code != 0) {
-      code = TAOS_SYSTEM_ERROR(errno);
-      stError("failed to create dir: %s, reason:%s", statePath, tstrerror(code));
-      taosMemoryFree(statePath);
-      return code;
-    }
+    TAOS_CHECK_GOTO(code, NULL, _err);
   }
 
-  char* dbPath = taosMemoryCalloc(1, strlen(statePath) + 128);
+  dbPath = taosMemoryCalloc(1, cap);
   if (dbPath == NULL) {
-    taosMemoryFree(statePath);
-    return terrno;
+    TAOS_CHECK_GOTO(terrno, NULL, _err);
+  }
+  nBytes = snprintf(dbPath, cap, "%s%s%s", statePath, TD_DIRSEP, "state");
+  if (nBytes < 0 || nBytes >= cap) {
+    code = TSDB_CODE_OUT_OF_RANGE;
+    TAOS_CHECK_GOTO(code, NULL, _err);
   }
 
-  sprintf(dbPath, "%s%s%s", statePath, TD_DIRSEP, "state");
   if (!taosDirExist(dbPath)) {
     code = taosMulMkDir(dbPath);
-    if (code != 0) {
-      code = TAOS_SYSTEM_ERROR(errno);
-      stError("failed to create dir: %s, reason:%s", dbPath, tstrerror(code));
-      taosMemoryFree(statePath);
-      taosMemoryFree(dbPath);
-      return code;
-    }
+    TAOS_CHECK_GOTO(code, NULL, _err);
   }
 
   *dbFullPath = dbPath;
   *stateFullPath = statePath;
   return 0;
+_err:
+  stError("failed to create dir: %s, reason:%s", dbPath, tstrerror(code));
+
+  taosMemoryFree(statePath);
+  taosMemoryFree(dbPath);
+  return code;
 }
 
 void taskDbUpdateChkpId(void* pTaskDb, int64_t chkpId) {
@@ -2864,6 +2886,7 @@ int32_t streamStateOpenBackendCf(void* backend, char* name, char** cfs, int32_t
   int64_t          streamId;
   int32_t          taskId, dummy = 0;
   char             suffix[64] = {0};
+  int32_t          code = 0;
 
   rocksdb_options_t**              cfOpts = taosMemoryCalloc(nCf, sizeof(rocksdb_options_t*));
   RocksdbCfParam*                  params = taosMemoryCalloc(nCf, sizeof(RocksdbCfParam));
@@ -2873,6 +2896,7 @@ int32_t streamStateOpenBackendCf(void* backend, char* name, char** cfs, int32_t
   for (int i = 0; i < nCf; i++) {
     char* cf = cfs[i];
     char  funcname[64] = {0};
+
     cfOpts[i] = rocksdb_options_create_copy(handle->dbOpt);
     if (i == 0) continue;
     if (3 == sscanf(cf, "0x%" PRIx64 "-%d_%s", &streamId, &taskId, funcname)) {
@@ -2909,7 +2933,7 @@ int32_t streamStateOpenBackendCf(void* backend, char* name, char** cfs, int32_t
     taosMemoryFree(params);
     taosMemoryFree(cfOpts);
     // fix other leak
-    return -1;
+    return TSDB_CODE_THIRDPARTY_ERROR;
   } else {
     stDebug("succ to open rocksdb cf");
   }
@@ -2929,8 +2953,13 @@ int32_t streamStateOpenBackendCf(void* backend, char* name, char** cfs, int32_t
 
     char funcname[64] = {0};
     if (3 == sscanf(cf, "0x%" PRIx64 "-%d_%s", &streamId, &taskId, funcname)) {
-      char idstr[128] = {0};
-      sprintf(idstr, "0x%" PRIx64 "-%d", streamId, taskId);
+      char    idstr[128] = {0};
+      int32_t nBytes = snprintf(idstr, sizeof(idstr), "0x%" PRIx64 "-%d", streamId, taskId);
+      if (nBytes <= 0 || nBytes >= sizeof(idstr)) {
+        code = TSDB_CODE_OUT_OF_RANGE;
+        stError("failed to open cf since %s", tstrerror(code));
+        return code;
+      }
 
       int idx = streamStateGetCfIdx(NULL, funcname);
 
@@ -4740,17 +4769,32 @@ int32_t compareHashTable(SHashObj* p1, SHashObj* p2, SArray* add, SArray* del) {
 void hashTableToDebug(SHashObj* pTbl, char** buf) {
   size_t  sz = taosHashGetSize(pTbl);
   int32_t total = 0;
-  char*   p = taosMemoryCalloc(1, sz * 16 + 4);
-  void*   pIter = taosHashIterate(pTbl, NULL);
+  int32_t cap = sz * 16 + 4;
+
+  char* p = taosMemoryCalloc(1, cap);
+  if (p == NULL) {
+    stError("failed to alloc memory for stream snapshot debug info");
+    return;
+  }
+
+  void* pIter = taosHashIterate(pTbl, NULL);
   while (pIter) {
     size_t len = 0;
     char*  name = taosHashGetKey(pIter, &len);
-    char*  tname = taosMemoryCalloc(1, len + 1);
-    memcpy(tname, name, len);
-    total += sprintf(p + total, "%s,", tname);
+    if (name == NULL || len <= 0) {
+      pIter = taosHashIterate(pTbl, pIter);
+      continue;
+    }
+    int32_t left = cap - strlen(p);
+    int32_t nBytes = snprintf(p + total, left, "%s,", name);
+    if (nBytes <= 0 || nBytes >= left) {
+      stError("failed to debug snapshot info since %s", tstrerror(TSDB_CODE_OUT_OF_RANGE));
+      taosMemoryFree(p);
+      return;
+    }
 
     pIter = taosHashIterate(pTbl, pIter);
-    taosMemoryFree(tname);
+    total += nBytes;
   }
   if (total > 0) {
     p[total - 1] = 0;
@@ -4761,13 +4805,30 @@ void strArrayDebugInfo(SArray* pArr, char** buf) {
   int32_t sz = taosArrayGetSize(pArr);
   if (sz <= 0) return;
 
-  char*   p = (char*)taosMemoryCalloc(1, 64 + sz * 64);
-  int32_t total = 0;
+  int32_t code = 0;
+  int32_t total = 0, nBytes = 0;
+  int32_t cap = 64 + sz * 64;
+
+  char* p = (char*)taosMemoryCalloc(1, cap);
+  if (p == NULL) {
+    stError("failed to alloc memory for stream snapshot debug info");
+    return;
+  }
 
   for (int i = 0; i < sz; i++) {
-    char* name = taosArrayGetP(pArr, i);
-    total += sprintf(p + total, "%s,", name);
+    char*   name = taosArrayGetP(pArr, i);
+    int32_t left = cap - strlen(p);
+    nBytes = snprintf(p + total, left, "%s,", name);
+    if (nBytes <= 0 || nBytes >= left) {
+      code = TSDB_CODE_OUT_OF_RANGE;
+      stError("failed to debug snapshot info since %s", tstrerror(code));
+      taosMemoryFree(p);
+      return;
+    }
+
+    total += nBytes;
   }
+
   p[total - 1] = 0;
 
   *buf = p;
@@ -4777,16 +4838,16 @@ void dbChkpDebugInfo(SDbChkp* pDb) {
     char* p[4] = {NULL};
 
     hashTableToDebug(pDb->pSstTbl[pDb->idx], &p[0]);
-    stTrace("chkp previous file: [%s]", p[0]);
+    if (p[0]) stTrace("chkp previous file: [%s]", p[0]);
 
     hashTableToDebug(pDb->pSstTbl[1 - pDb->idx], &p[1]);
-    stTrace("chkp curr file: [%s]", p[1]);
+    if (p[1]) stTrace("chkp curr file: [%s]", p[1]);
 
     strArrayDebugInfo(pDb->pAdd, &p[2]);
-    stTrace("chkp newly addded file: [%s]", p[2]);
+    if (p[2]) stTrace("chkp newly addded file: [%s]", p[2]);
 
     strArrayDebugInfo(pDb->pDel, &p[3]);
-    stTrace("chkp newly deleted file: [%s]", p[3]);
+    if (p[3]) stTrace("chkp newly deleted file: [%s]", p[3]);
 
     for (int i = 0; i < 4; i++) {
       taosMemoryFree(p[i]);

From a58d975fae6300fc8cb553157eadb86ddaa88524 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Wed, 4 Dec 2024 19:19:17 +0800
Subject: [PATCH 08/25] use safe func

---
 source/libs/stream/src/streamBackendRocksdb.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 742b8a9e7c..c14de8766b 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -153,7 +153,6 @@ void taskDbUnRefChkp(STaskDbWrapper* pTaskDb, int64_t chkp);
 int32_t chkpAddExtraInfo(char* pChkpIdDir, int64_t chkpId, int64_t processId);
 int32_t chkpLoadExtraInfo(char* pChkpIdDir, int64_t* chkpId, int64_t* processId);
 
-#define GEN_COLUMN_FAMILY_NAME(name, idstr, SUFFIX) sprintf(name, "%s_%s", idstr, (SUFFIX));
 int32_t  copyFiles(const char* src, const char* dst);
 uint32_t nextPow2(uint32_t x);
 
@@ -1727,7 +1726,7 @@ void destroyRocksdbCfInst(RocksdbCfInst* inst) {
 }
 
 // |key|-----value------|
-// |key|ttl|len|userData|
+// |key|ttl|len|userData
 
 int defaultKeyComp(void* state, const char* aBuf, size_t aLen, const char* bBuf, size_t bLen) {
   int len = aLen < bLen ? aLen : bLen;

From 9879453d16aad146a71e120df2390ae5ca94892d Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Thu, 5 Dec 2024 14:19:36 +0800
Subject: [PATCH 09/25] use safe func

---
 source/util/src/tconfig.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 549d50b4d0..1cce67c06e 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -163,7 +163,7 @@ static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType sty
 
   pItem->bval = tmp;
   pItem->stype = stype;
-  return code;
+  return 0;
 }
 
 static int32_t cfgSetInt32(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
@@ -291,7 +291,7 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
     cfg.primary = 1;
   }
 
-  code = taosStr2int8(primary, &cfg.disable);
+  code = taosStr2int8(disable, &cfg.disable);
   if (code != 0) {
     cfg.disable = 0;
   }

From bc546e27bc46672d5f3c93139612649a876c83ea Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Thu, 5 Dec 2024 15:21:03 +0800
Subject: [PATCH 10/25] use safe func

---
 source/os/src/osString.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/source/os/src/osString.c b/source/os/src/osString.c
index 9a681d9d75..fd2c44a49e 100644
--- a/source/os/src/osString.c
+++ b/source/os/src/osString.c
@@ -184,7 +184,8 @@ int32_t taosStr2Uint64(const char *str, uint64_t *val) {
   if (str == NULL || val == NULL) {
     return TSDB_CODE_INVALID_PARA;
   }
-  char    *endptr = NULL;
+  char *endptr = NULL;
+  errno = 0;
   uint64_t ret = strtoull(str, &endptr, 10);
   if (errno == ERANGE && (ret == ULLONG_MAX)) {
     return TAOS_SYSTEM_ERROR(errno);

From ffed7a3c67c765c550f071c661f87cd87612d82b Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Thu, 5 Dec 2024 16:28:40 +0800
Subject: [PATCH 11/25] remove unused code

---
 source/libs/stream/inc/streamBackendRocksdb.h |  13 +-
 source/libs/stream/src/streamBackendRocksdb.c | 113 ------------------
 source/libs/stream/src/streamState.c          |  19 ++-
 3 files changed, 14 insertions(+), 131 deletions(-)

diff --git a/source/libs/stream/inc/streamBackendRocksdb.h b/source/libs/stream/inc/streamBackendRocksdb.h
index d313acc61d..d053a52832 100644
--- a/source/libs/stream/inc/streamBackendRocksdb.h
+++ b/source/libs/stream/inc/streamBackendRocksdb.h
@@ -166,10 +166,12 @@ int32_t streamStateDel_rocksdb(SStreamState* pState, const SWinKey* key);
 int32_t streamStateClear_rocksdb(SStreamState* pState);
 void    streamStateCurNext_rocksdb(SStreamStateCur* pCur);
 int32_t streamStateGetFirst_rocksdb(SStreamState* pState, SWinKey* key);
-int32_t streamStateGetGroupKVByCur_rocksdb(SStreamState* pState, SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
+int32_t streamStateGetGroupKVByCur_rocksdb(SStreamState* pState, SStreamStateCur* pCur, SWinKey* pKey,
+                                           const void** pVal, int32_t* pVLen);
 int32_t streamStateAddIfNotExist_rocksdb(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
 void    streamStateCurPrev_rocksdb(SStreamStateCur* pCur);
-int32_t streamStateGetKVByCur_rocksdb(SStreamState* pState, SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
+int32_t streamStateGetKVByCur_rocksdb(SStreamState* pState, SStreamStateCur* pCur, SWinKey* pKey, const void** pVal,
+                                      int32_t* pVLen);
 SStreamStateCur* streamStateGetAndCheckCur_rocksdb(SStreamState* pState, SWinKey* key);
 SStreamStateCur* streamStateSeekKeyNext_rocksdb(SStreamState* pState, const SWinKey* key);
 SStreamStateCur* streamStateSeekKeyPrev_rocksdb(SStreamState* pState, const SWinKey* key);
@@ -217,15 +219,14 @@ int32_t streamStateFillGetGroupKVByCur_rocksdb(SStreamStateCur* pCur, SWinKey* p
 // partag cf
 int32_t streamStatePutParTag_rocksdb(SStreamState* pState, int64_t groupId, const void* tag, int32_t tagLen);
 int32_t streamStateGetParTag_rocksdb(SStreamState* pState, int64_t groupId, void** tagVal, int32_t* tagLen);
-void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t groupId, SStreamStateCur* pCur);
-int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal, int32_t* pVLen);
+void    streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t groupId, SStreamStateCur* pCur);
+int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal,
+                                            int32_t* pVLen);
 
 // parname cf
 int32_t streamStatePutParName_rocksdb(SStreamState* pState, int64_t groupId, const char tbname[TSDB_TABLE_NAME_LEN]);
 int32_t streamStateGetParName_rocksdb(SStreamState* pState, int64_t groupId, void** pVal);
 
-void streamStateDestroy_rocksdb(SStreamState* pState, bool remove);
-
 // default cf
 int32_t streamDefaultPut_rocksdb(SStreamState* pState, const void* key, void* pVal, int32_t pVLen);
 int32_t streamDefaultGet_rocksdb(SStreamState* pState, const void* key, void** pVal, int32_t* pVLen);
diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index c14de8766b..11d2385d1c 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -1699,9 +1699,6 @@ void streamBackendDelCompare(void* backend, void* arg) {
     taosMemoryFree(node);
   }
 }
-#ifdef BUILD_NO_CALL
-void streamStateDestroy_rocksdb(SStreamState* pState, bool remove) { streamStateCloseBackend(pState, remove); }
-#endif
 void destroyRocksdbCfInst(RocksdbCfInst* inst) {
   int cfLen = sizeof(ginitDict) / sizeof(ginitDict[0]);
   if (inst->pHandle) {
@@ -3025,117 +3022,7 @@ int32_t streamStateOpenBackendCf(void* backend, char* name, char** cfs, int32_t
   taosMemoryFree(cfOpts);
   return 0;
 }
-#ifdef BUILD_NO_CALL
-int streamStateOpenBackend(void* backend, SStreamState* pState) {
-  taosAcquireRef(streamBackendId, pState->streamBackendRid);
-  SBackendWrapper*   handle = backend;
-  SBackendCfWrapper* pBackendCfWrapper = taosMemoryCalloc(1, sizeof(SBackendCfWrapper));
 
-  streamMutexLock(&handle->cfMutex);
-  RocksdbCfInst** ppInst = taosHashGet(handle->cfInst, pState->pTdbState->idstr, strlen(pState->pTdbState->idstr) + 1);
-  if (ppInst != NULL && *ppInst != NULL) {
-    RocksdbCfInst* inst = *ppInst;
-    pBackendCfWrapper->rocksdb = inst->db;
-    pBackendCfWrapper->pHandle = (void**)inst->pHandle;
-    pBackendCfWrapper->writeOpts = inst->wOpt;
-    pBackendCfWrapper->readOpts = inst->rOpt;
-    pBackendCfWrapper->cfOpts = (void**)(inst->cfOpt);
-    pBackendCfWrapper->dbOpt = handle->dbOpt;
-    pBackendCfWrapper->param = inst->param;
-    pBackendCfWrapper->pBackend = handle;
-    pBackendCfWrapper->pComparNode = inst->pCompareNode;
-    streamMutexUnlock(&handle->cfMutex);
-    pBackendCfWrapper->backendId = pState->streamBackendRid;
-    memcpy(pBackendCfWrapper->idstr, pState->pTdbState->idstr, sizeof(pState->pTdbState->idstr));
-
-    int64_t id = taosAddRef(streamBackendCfWrapperId, pBackendCfWrapper);
-    pState->pTdbState->backendCfWrapperId = id;
-    pState->pTdbState->pBackendCfWrapper = pBackendCfWrapper;
-    stInfo("succ to open state %p on backendWrapper, %p, %s", pState, pBackendCfWrapper, pBackendCfWrapper->idstr);
-
-    inst->pHandle = NULL;
-    inst->cfOpt = NULL;
-    inst->param = NULL;
-
-    inst->wOpt = NULL;
-    inst->rOpt = NULL;
-    return 0;
-  }
-  streamMutexUnlock(&handle->cfMutex);
-
-  char* err = NULL;
-  int   cfLen = sizeof(ginitDict) / sizeof(ginitDict[0]);
-
-  RocksdbCfParam*           param = taosMemoryCalloc(cfLen, sizeof(RocksdbCfParam));
-  const rocksdb_options_t** cfOpt = taosMemoryCalloc(cfLen, sizeof(rocksdb_options_t*));
-  for (int i = 0; i < cfLen; i++) {
-    cfOpt[i] = rocksdb_options_create_copy(handle->dbOpt);
-    // refactor later
-    rocksdb_block_based_table_options_t* tableOpt = rocksdb_block_based_options_create();
-    rocksdb_block_based_options_set_block_cache(tableOpt, handle->cache);
-    rocksdb_block_based_options_set_partition_filters(tableOpt, 1);
-
-    rocksdb_filterpolicy_t* filter = rocksdb_filterpolicy_create_bloom(15);
-    rocksdb_block_based_options_set_filter_policy(tableOpt, filter);
-
-    rocksdb_options_set_block_based_table_factory((rocksdb_options_t*)cfOpt[i], tableOpt);
-
-    param[i].tableOpt = tableOpt;
-  };
-
-  rocksdb_comparator_t** pCompare = taosMemoryCalloc(cfLen, sizeof(rocksdb_comparator_t*));
-  for (int i = 0; i < cfLen; i++) {
-    SCfInit* cf = &ginitDict[i];
-
-    rocksdb_comparator_t* compare = rocksdb_comparator_create(NULL, cf->destroyCmp, cf->cmpKey, cf->cmpName);
-    rocksdb_options_set_comparator((rocksdb_options_t*)cfOpt[i], compare);
-    pCompare[i] = compare;
-  }
-  rocksdb_column_family_handle_t** cfHandle = taosMemoryCalloc(cfLen, sizeof(rocksdb_column_family_handle_t*));
-  pBackendCfWrapper->rocksdb = handle->db;
-  pBackendCfWrapper->pHandle = (void**)cfHandle;
-  pBackendCfWrapper->writeOpts = rocksdb_writeoptions_create();
-  pBackendCfWrapper->readOpts = rocksdb_readoptions_create();
-  pBackendCfWrapper->cfOpts = (void**)cfOpt;
-  pBackendCfWrapper->dbOpt = handle->dbOpt;
-  pBackendCfWrapper->param = param;
-  pBackendCfWrapper->pBackend = handle;
-  pBackendCfWrapper->backendId = pState->streamBackendRid;
-  taosThreadRwlockInit(&pBackendCfWrapper->rwLock, NULL);
-  SCfComparator compare = {.comp = pCompare, .numOfComp = cfLen};
-  pBackendCfWrapper->pComparNode = streamBackendAddCompare(handle, &compare);
-  rocksdb_writeoptions_disable_WAL(pBackendCfWrapper->writeOpts, 1);
-  memcpy(pBackendCfWrapper->idstr, pState->pTdbState->idstr, sizeof(pState->pTdbState->idstr));
-
-  int64_t id = taosAddRef(streamBackendCfWrapperId, pBackendCfWrapper);
-  pState->pTdbState->backendCfWrapperId = id;
-  pState->pTdbState->pBackendCfWrapper = pBackendCfWrapper;
-  stInfo("succ to open state %p on backendWrapper %p %s", pState, pBackendCfWrapper, pBackendCfWrapper->idstr);
-  return 0;
-}
-
-void streamStateCloseBackend(SStreamState* pState, bool remove) {
-  SBackendCfWrapper* wrapper = pState->pTdbState->pBackendCfWrapper;
-  SBackendWrapper*   pHandle = wrapper->pBackend;
-
-  stInfo("start to close state on backend: %p", pHandle);
-
-  streamMutexLock(&pHandle->cfMutex);
-  RocksdbCfInst** ppInst = taosHashGet(pHandle->cfInst, wrapper->idstr, strlen(pState->pTdbState->idstr) + 1);
-  if (ppInst != NULL && *ppInst != NULL) {
-    RocksdbCfInst* inst = *ppInst;
-    taosMemoryFree(inst);
-    taosHashRemove(pHandle->cfInst, pState->pTdbState->idstr, strlen(pState->pTdbState->idstr) + 1);
-  }
-  streamMutexUnlock(&pHandle->cfMutex);
-
-  char* status[] = {"close", "drop"};
-  stInfo("start to %s state %p on backendWrapper %p %s", status[remove == false ? 0 : 1], pState, wrapper,
-         wrapper->idstr);
-  wrapper->remove |= remove;  // update by other pState
-  taosReleaseRef(streamBackendCfWrapperId, pState->pTdbState->backendCfWrapperId);
-}
-#endif
 void streamStateDestroyCompar(void* arg) {
   SCfComparator* comp = (SCfComparator*)arg;
   for (int i = 0; i < comp->numOfComp; i++) {
diff --git a/source/libs/stream/src/streamState.c b/source/libs/stream/src/streamState.c
index 794fc346bf..a69ee5448d 100644
--- a/source/libs/stream/src/streamState.c
+++ b/source/libs/stream/src/streamState.c
@@ -120,7 +120,8 @@ SStreamState* streamStateOpen(const char* path, void* pTask, int64_t streamId, i
   SStreamTask* pStreamTask = pTask;
   pState->streamId = streamId;
   pState->taskId = taskId;
-  TAOS_UNUSED(tsnprintf(pState->pTdbState->idstr, sizeof(pState->pTdbState->idstr), "0x%" PRIx64 "-0x%x", pState->streamId, pState->taskId));
+  TAOS_UNUSED(tsnprintf(pState->pTdbState->idstr, sizeof(pState->pTdbState->idstr), "0x%" PRIx64 "-0x%x",
+                        pState->streamId, pState->taskId));
 
   code = streamTaskSetDb(pStreamTask->pMeta, pTask, pState->pTdbState->idstr);
   QUERY_CHECK_CODE(code, lino, _end);
@@ -527,7 +528,6 @@ _end:
 
 void streamStateDestroy(SStreamState* pState, bool remove) {
   streamFileStateDestroy(pState->pFileState);
-  // streamStateDestroy_rocksdb(pState, remove);
   tSimpleHashCleanup(pState->parNameMap);
   // do nothong
   taosMemoryFreeClear(pState->pTdbState);
@@ -572,7 +572,8 @@ int32_t streamStateCountWinAddIfNotExist(SStreamState* pState, SSessionKey* pKey
   return getCountWinResultBuff(pState->pFileState, pKey, winCount, ppVal, pVLen, pWinCode);
 }
 
-int32_t streamStateCountWinAdd(SStreamState* pState, SSessionKey* pKey, COUNT_TYPE winCount, void** pVal, int32_t* pVLen) {
+int32_t streamStateCountWinAdd(SStreamState* pState, SSessionKey* pKey, COUNT_TYPE winCount, void** pVal,
+                               int32_t* pVLen) {
   return createCountWinResultBuff(pState->pFileState, pKey, winCount, pVal, pVLen);
 }
 
@@ -593,9 +594,7 @@ SStreamStateCur* streamStateGroupGetCur(SStreamState* pState) {
   return pCur;
 }
 
-void streamStateGroupCurNext(SStreamStateCur* pCur) {
-  streamFileStateGroupCurNext(pCur);
-}
+void streamStateGroupCurNext(SStreamStateCur* pCur) { streamFileStateGroupCurNext(pCur); }
 
 int32_t streamStateGroupGetKVByCur(SStreamStateCur* pCur, int64_t* pKey, void** pVal, int32_t* pVLen) {
   if (pVal != NULL) {
@@ -604,13 +603,9 @@ int32_t streamStateGroupGetKVByCur(SStreamStateCur* pCur, int64_t* pKey, void**
   return streamFileStateGroupGetKVByCur(pCur, pKey, pVal, pVLen);
 }
 
-void streamStateClearExpiredState(SStreamState* pState) {
-  clearExpiredState(pState->pFileState);
-}
+void streamStateClearExpiredState(SStreamState* pState) { clearExpiredState(pState->pFileState); }
 
-void streamStateSetFillInfo(SStreamState* pState) {
-  setFillInfo(pState->pFileState);
-}
+void streamStateSetFillInfo(SStreamState* pState) { setFillInfo(pState->pFileState); }
 
 int32_t streamStateGetPrev(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal, int32_t* pVLen,
                            int32_t* pWinCode) {

From c5c56606c4a5d49e17b90caf0d7ddd8120781688 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Thu, 5 Dec 2024 16:35:45 +0800
Subject: [PATCH 12/25] use safe sys func

---
 source/common/src/tcol.c                      |   8 +-
 source/common/src/tmisce.c                    |   2 +-
 source/dnode/mgmt/mgmt_vnode/src/vmHandle.c   |   8 +-
 source/dnode/mgmt/node_mgmt/src/dmMgmt.c      |  82 +++---
 source/dnode/mgmt/node_util/src/dmFile.c      |   6 +-
 source/dnode/mnode/impl/src/mndArbGroup.c     |   2 +-
 source/dnode/mnode/impl/src/mndCompact.c      |   6 +-
 source/dnode/mnode/impl/src/mndDnode.c        |   2 +-
 source/dnode/mnode/impl/src/mndMain.c         |   4 +-
 source/dnode/mnode/impl/src/mndSma.c          | 261 +++++++++---------
 source/dnode/mnode/impl/src/mndUser.c         |   2 +-
 source/dnode/mnode/sdb/src/sdbFile.c          |   4 +-
 source/dnode/vnode/src/tsdb/tsdbFS2.c         |   2 +-
 .../dnode/vnode/src/tsdb/tsdbReaderWriter.c   |   4 +-
 source/dnode/vnode/src/vnd/vnodeCfg.c         |   6 +-
 source/dnode/vnode/src/vnd/vnodeSvr.c         |   2 +-
 source/libs/sync/src/syncMain.c               |   4 +-
 source/libs/tdb/src/db/tdbDb.c                |   2 +-
 source/libs/tdb/src/db/tdbPager.c             |   4 +-
 source/libs/tfs/src/tfs.c                     |   6 +-
 source/libs/wal/src/walWrite.c                |   2 +-
 source/util/src/tconfig.c                     |   8 +-
 22 files changed, 214 insertions(+), 213 deletions(-)

diff --git a/source/common/src/tcol.c b/source/common/src/tcol.c
index a23385aba0..6a8fca0c48 100644
--- a/source/common/src/tcol.c
+++ b/source/common/src/tcol.c
@@ -251,7 +251,7 @@ bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
 }
 bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
   if (0 == strlen(encode)) {
-    strncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    tstrncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
     return true;
   }
   return checkColumnEncode(encode) && validColEncode(type, columnEncodeVal(encode));
@@ -268,7 +268,7 @@ bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
 }
 bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
   if (0 == strlen(compress)) {
-    strncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    tstrncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
     return true;
   }
 
@@ -290,7 +290,7 @@ bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
 }
 bool checkColumnLevelOrSetDefault(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
   if (0 == strlen(level)) {
-    strncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    tstrncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
     return true;
   }
   return checkColumnLevel(level) && validColCompressLevel(type, columnLevelVal(level));
@@ -314,7 +314,7 @@ void setColLevel(uint32_t* compress, uint8_t level) {
 
 int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,
                                uint32_t* compress) {
-  if(compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+  if (compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
   if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
   setColEncode(compress, encode);
 
diff --git a/source/common/src/tmisce.c b/source/common/src/tmisce.c
index 3bd05a8e92..5ed0c78569 100644
--- a/source/common/src/tmisce.c
+++ b/source/common/src/tmisce.c
@@ -22,7 +22,7 @@
 int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp) {
   pEp->port = 0;
   memset(pEp->fqdn, 0, TSDB_FQDN_LEN);
-  strncpy(pEp->fqdn, ep, TSDB_FQDN_LEN - 1);
+  tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);
 
   char* temp = strchr(pEp->fqdn, ':');
   if (temp) {
diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
index 90b3f0025d..60440916d8 100644
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -186,7 +186,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 #if defined(TD_ENTERPRISE)
   pCfg->tsdbCfg.encryptAlgorithm = pCreate->encryptAlgorithm;
   if (pCfg->tsdbCfg.encryptAlgorithm == DND_CA_SM4) {
-    strncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
   }
 #else
   pCfg->tsdbCfg.encryptAlgorithm = 0;
@@ -202,7 +202,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 #if defined(TD_ENTERPRISE)
   pCfg->walCfg.encryptAlgorithm = pCreate->encryptAlgorithm;
   if (pCfg->walCfg.encryptAlgorithm == DND_CA_SM4) {
-    strncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
   }
 #else
   pCfg->walCfg.encryptAlgorithm = 0;
@@ -211,7 +211,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 #if defined(TD_ENTERPRISE)
   pCfg->tdbEncryptAlgorithm = pCreate->encryptAlgorithm;
   if (pCfg->tdbEncryptAlgorithm == DND_CA_SM4) {
-    strncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
   }
 #else
   pCfg->tdbEncryptAlgorithm = 0;
@@ -898,7 +898,7 @@ int32_t vmProcessArbHeartBeatReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   size_t size = taosArrayGetSize(arbHbReq.hbMembers);
 
   arbHbRsp.dnodeId = pMgmt->pData->dnodeId;
-  strncpy(arbHbRsp.arbToken, arbHbReq.arbToken, TSDB_ARB_TOKEN_SIZE);
+  tstrncpy(arbHbRsp.arbToken, arbHbReq.arbToken, TSDB_ARB_TOKEN_SIZE);
   arbHbRsp.hbMembers = taosArrayInit(size, sizeof(SVArbHbRspMember));
   if (arbHbRsp.hbMembers == NULL) {
     goto _OVER;
diff --git a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
index 9f1c292a90..a189251378 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
@@ -179,7 +179,7 @@ int32_t dmInitVars(SDnode *pDnode) {
 
       //code = taosGetCryptKey(tsAuthCode, pData->machineId, tsCryptKey);
       code = 0;
-      strncpy(tsEncryptKey, tsAuthCode, 16);
+      tstrncpy(tsEncryptKey, tsAuthCode, 16);
 
       if (code != 0) {
         if(code == -1){
@@ -220,62 +220,62 @@ int32_t dmInitVars(SDnode *pDnode) {
 }
 
 extern SMonVloadInfo tsVinfo;
-void dmClearVars(SDnode *pDnode) {
-  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-    taosMemoryFreeClear(pWrapper->path);
-    (void)taosThreadRwlockDestroy(&pWrapper->lock);
+void                 dmClearVars(SDnode *pDnode) {
+                  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
+                    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+                    taosMemoryFreeClear(pWrapper->path);
+                    (void)taosThreadRwlockDestroy(&pWrapper->lock);
   }
-  if (pDnode->lockfile != NULL) {
-    if (taosUnLockFile(pDnode->lockfile) != 0) {
-      dError("failed to unlock file");
+                  if (pDnode->lockfile != NULL) {
+                    if (taosUnLockFile(pDnode->lockfile) != 0) {
+                      dError("failed to unlock file");
     }
 
-    (void)taosCloseFile(&pDnode->lockfile);
-    pDnode->lockfile = NULL;
+                    (void)taosCloseFile(&pDnode->lockfile);
+                    pDnode->lockfile = NULL;
   }
 
-  SDnodeData *pData = &pDnode->data;
-  (void)taosThreadRwlockWrlock(&pData->lock);
-  if (pData->oldDnodeEps != NULL) {
-    if (dmWriteEps(pData) == 0) {
-      dmRemoveDnodePairs(pData);
+                  SDnodeData *pData = &pDnode->data;
+                  (void)taosThreadRwlockWrlock(&pData->lock);
+                  if (pData->oldDnodeEps != NULL) {
+                    if (dmWriteEps(pData) == 0) {
+                      dmRemoveDnodePairs(pData);
     }
-    taosArrayDestroy(pData->oldDnodeEps);
-    pData->oldDnodeEps = NULL;
+                    taosArrayDestroy(pData->oldDnodeEps);
+                    pData->oldDnodeEps = NULL;
   }
-  if (pData->dnodeEps != NULL) {
-    taosArrayDestroy(pData->dnodeEps);
-    pData->dnodeEps = NULL;
+                  if (pData->dnodeEps != NULL) {
+                    taosArrayDestroy(pData->dnodeEps);
+                    pData->dnodeEps = NULL;
   }
-  if (pData->dnodeHash != NULL) {
-    taosHashCleanup(pData->dnodeHash);
-    pData->dnodeHash = NULL;
+                  if (pData->dnodeHash != NULL) {
+                    taosHashCleanup(pData->dnodeHash);
+                    pData->dnodeHash = NULL;
   }
-  (void)taosThreadRwlockUnlock(&pData->lock);
+                  (void)taosThreadRwlockUnlock(&pData->lock);
 
-  (void)taosThreadRwlockDestroy(&pData->lock);
+                  (void)taosThreadRwlockDestroy(&pData->lock);
 
-  dDebug("begin to lock status info when thread exit");
-  if (taosThreadMutexLock(&pData->statusInfolock) != 0) {
-    dError("failed to lock status info lock");
-    return;
+                  dDebug("begin to lock status info when thread exit");
+                  if (taosThreadMutexLock(&pData->statusInfolock) != 0) {
+                    dError("failed to lock status info lock");
+                    return;
   }
-  if (tsVinfo.pVloads != NULL) {
-    taosArrayDestroy(tsVinfo.pVloads);
-    tsVinfo.pVloads = NULL;
+                  if (tsVinfo.pVloads != NULL) {
+                    taosArrayDestroy(tsVinfo.pVloads);
+                    tsVinfo.pVloads = NULL;
   }
-  if (taosThreadMutexUnlock(&pData->statusInfolock) != 0) {
-    dError("failed to unlock status info lock");
-    return;
+                  if (taosThreadMutexUnlock(&pData->statusInfolock) != 0) {
+                    dError("failed to unlock status info lock");
+                    return;
   }
-  if (taosThreadMutexDestroy(&pData->statusInfolock) != 0) {
-    dError("failed to destroy status info lock");
+                  if (taosThreadMutexDestroy(&pData->statusInfolock) != 0) {
+                    dError("failed to destroy status info lock");
   }
-  memset(&pData->statusInfolock, 0, sizeof(pData->statusInfolock));
+                  memset(&pData->statusInfolock, 0, sizeof(pData->statusInfolock));
 
-  (void)taosThreadMutexDestroy(&pDnode->mutex);
-  memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
+                  (void)taosThreadMutexDestroy(&pDnode->mutex);
+                  memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
 }
 
 void dmSetStatus(SDnode *pDnode, EDndRunStatus status) {
diff --git a/source/dnode/mgmt/node_util/src/dmFile.c b/source/dnode/mgmt/node_util/src/dmFile.c
index 1da13f72cd..65af5481be 100644
--- a/source/dnode/mgmt/node_util/src/dmFile.c
+++ b/source/dnode/mgmt/node_util/src/dmFile.c
@@ -230,7 +230,7 @@ static int32_t dmWriteCheckCodeFile(char *file, char *realfile, char *key, bool
   }
 
   SCryptOpts opts;
-  strncpy(opts.key, key, ENCRYPT_KEY_LEN);
+  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN);
   opts.len = len;
   opts.source = DM_KEY_INDICATOR;
   opts.result = result;
@@ -349,7 +349,7 @@ static int32_t dmCompareEncryptKey(char *file, char *key, bool toLogFile) {
   }
 
   SCryptOpts opts = {0};
-  strncpy(opts.key, key, ENCRYPT_KEY_LEN);
+  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN);
   opts.len = len;
   opts.source = content;
   opts.result = result;
@@ -551,7 +551,7 @@ int32_t dmGetEncryptKey() {
     goto _OVER;
   }
 
-  strncpy(tsEncryptKey, encryptKey, ENCRYPT_KEY_LEN);
+  tstrncpy(tsEncryptKey, encryptKey, ENCRYPT_KEY_LEN);
   taosMemoryFreeClear(encryptKey);
   tsEncryptionKeyChksum = taosCalcChecksum(0, tsEncryptKey, strlen(tsEncryptKey));
   tsEncryptionKeyStat = ENCRYPT_KEY_STAT_LOADED;
diff --git a/source/dnode/mnode/impl/src/mndArbGroup.c b/source/dnode/mnode/impl/src/mndArbGroup.c
index 0192044e67..3879e8e6e2 100644
--- a/source/dnode/mnode/impl/src/mndArbGroup.c
+++ b/source/dnode/mnode/impl/src/mndArbGroup.c
@@ -1315,7 +1315,7 @@ static int32_t mndRetrieveArbGroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
       continue;
     }
     char dbNameInGroup[TSDB_DB_FNAME_LEN];
-    strncpy(dbNameInGroup, pVgObj->dbName, TSDB_DB_FNAME_LEN);
+    tstrncpy(dbNameInGroup, pVgObj->dbName, TSDB_DB_FNAME_LEN);
     sdbRelease(pSdb, pVgObj);
 
     char dbname[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
diff --git a/source/dnode/mnode/impl/src/mndCompact.c b/source/dnode/mnode/impl/src/mndCompact.c
index 106680da7f..c27818011d 100644
--- a/source/dnode/mnode/impl/src/mndCompact.c
+++ b/source/dnode/mnode/impl/src/mndCompact.c
@@ -244,7 +244,7 @@ int32_t mndCompactGetDbName(SMnode *pMnode, int32_t compactId, char *dbname, int
     TAOS_RETURN(code);
   }
 
-  (void)strncpy(dbname, pCompact->dbname, len);
+  tstrncpy(dbname, pCompact->dbname, len);
   mndReleaseCompact(pMnode, pCompact);
   TAOS_RETURN(code);
 }
@@ -321,7 +321,7 @@ int32_t mndRetrieveCompact(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock,
       TAOS_CHECK_GOTO(tNameFromString(&name, pCompact->dbname, T_NAME_ACCT | T_NAME_DB), &lino, _OVER);
       (void)tNameGetDbName(&name, varDataVal(tmpBuf));
     } else {
-      (void)strncpy(varDataVal(tmpBuf), pCompact->dbname, TSDB_SHOW_SQL_LEN);
+      tstrncpy(varDataVal(tmpBuf), pCompact->dbname, TSDB_SHOW_SQL_LEN);
     }
     varDataSetLen(tmpBuf, strlen(varDataVal(tmpBuf)));
     RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)tmpBuf, false), pCompact, &lino, _OVER);
@@ -641,7 +641,7 @@ void mndCompactSendProgressReq(SMnode *pMnode, SCompactObj *pCompact) {
 
       char    detail[1024] = {0};
       int32_t len = tsnprintf(detail, sizeof(detail), "msgType:%s numOfEps:%d inUse:%d",
-                             TMSG_INFO(TDMT_VND_QUERY_COMPACT_PROGRESS), epSet.numOfEps, epSet.inUse);
+                              TMSG_INFO(TDMT_VND_QUERY_COMPACT_PROGRESS), epSet.numOfEps, epSet.inUse);
       for (int32_t i = 0; i < epSet.numOfEps; ++i) {
         len += tsnprintf(detail + len, sizeof(detail) - len, " ep:%d-%s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
       }
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index eb691b9dff..1eefb024a2 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -1450,7 +1450,7 @@ static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) {
   }
 
   size_t optLen = p - pMCfgReq->config;
-  (void)strncpy(pDCfgReq->config, pMCfgReq->config, optLen);
+  tstrncpy(pDCfgReq->config, pMCfgReq->config, optLen + 1);
   pDCfgReq->config[optLen] = 0;
 
   if (' ' == pMCfgReq->config[optLen]) {
diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c
index 9dd43225b1..5acfcf6ac1 100644
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@@ -15,8 +15,8 @@
 
 #define _DEFAULT_SOURCE
 #include "mndAcct.h"
-#include "mndArbGroup.h"
 #include "mndAnode.h"
+#include "mndArbGroup.h"
 #include "mndCluster.h"
 #include "mndCompact.h"
 #include "mndCompactDetail.h"
@@ -530,7 +530,7 @@ static int32_t mndInitWal(SMnode *pMnode) {
       code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
       TAOS_RETURN(code);
     } else {
-      (void)strncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
     }
   }
 #endif
diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c
index a54c7f1b14..9150c676bf 100644
--- a/source/dnode/mnode/impl/src/mndSma.c
+++ b/source/dnode/mnode/impl/src/mndSma.c
@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "mndSma.h"
+#include "functionMgt.h"
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndIndex.h"
@@ -31,7 +32,6 @@
 #include "mndVgroup.h"
 #include "parser.h"
 #include "tname.h"
-#include "functionMgt.h"
 
 #define TSDB_SMA_VER_NUMBER   1
 #define TSDB_SMA_RESERVE_SIZE 64
@@ -48,8 +48,8 @@ static int32_t  mndProcessGetTbSmaReq(SRpcMsg *pReq);
 static int32_t  mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndDestroySmaObj(SSmaObj *pSmaObj);
 
-static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq);
-static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq);
+static int32_t mndProcessCreateTSMAReq(SRpcMsg *pReq);
+static int32_t mndProcessDropTSMAReq(SRpcMsg *pReq);
 
 // sma and tag index comm func
 static int32_t mndProcessDropIdxReq(SRpcMsg *pReq);
@@ -61,11 +61,11 @@ static void    mndCancelRetrieveTSMA(SMnode *pMnode, void *pIter);
 static int32_t mndProcessGetTbTSMAReq(SRpcMsg *pReq);
 
 typedef struct SCreateTSMACxt {
-  SMnode *       pMnode;
+  SMnode        *pMnode;
   const SRpcMsg *pRpcReq;
   union {
     const SMCreateSmaReq *pCreateSmaReq;
-    const SMDropSmaReq *  pDropSmaReq;
+    const SMDropSmaReq   *pDropSmaReq;
   };
   SDbObj             *pDb;
   SStbObj            *pSrcStb;
@@ -298,16 +298,13 @@ void mndReleaseSma(SMnode *pMnode, SSmaObj *pSma) {
   sdbRelease(pSdb, pSma);
 }
 
-SDbObj *mndAcquireDbBySma(SMnode *pMnode, const char *db) {
-
-  return mndAcquireDb(pMnode, db);
-}
+SDbObj *mndAcquireDbBySma(SMnode *pMnode, const char *db) { return mndAcquireDb(pMnode, db); }
 
 static void *mndBuildVCreateSmaReq(SMnode *pMnode, SVgObj *pVgroup, SSmaObj *pSma, int32_t *pContLen) {
   SEncoder encoder = {0};
   int32_t  contLen = 0;
   SName    name = {0};
-  int32_t code = tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  int32_t  code = tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
   if (TSDB_CODE_SUCCESS != code) {
     return NULL;
   }
@@ -368,7 +365,7 @@ static void *mndBuildVDropSmaReq(SMnode *pMnode, SVgObj *pVgroup, SSmaObj *pSma,
   SEncoder encoder = {0};
   int32_t  contLen;
   SName    name = {0};
-  int32_t code = tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  int32_t  code = tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
   if (TSDB_CODE_SUCCESS != code) {
     terrno = code;
     return NULL;
@@ -424,9 +421,9 @@ static int32_t mndSetCreateSmaRedoLogs(SMnode *pMnode, STrans *pTrans, SSmaObj *
   TAOS_RETURN(code);
 }
 
-static int32_t mndSetCreateSmaUndoLogs(SMnode* pMnode, STrans* pTrans, SSmaObj* pSma) {
-  int32_t   code = 0;
-  SSdbRaw * pUndoRaw = mndSmaActionEncode(pSma);
+static int32_t mndSetCreateSmaUndoLogs(SMnode *pMnode, STrans *pTrans, SSmaObj *pSma) {
+  int32_t  code = 0;
+  SSdbRaw *pUndoRaw = mndSmaActionEncode(pSma);
   if (!pUndoRaw) {
     code = TSDB_CODE_MND_RETURN_VALUE_NULL;
     if (terrno != 0) code = terrno;
@@ -670,7 +667,8 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   // check the maxDelay
   if (streamObj.conf.triggerParam < TSDB_MIN_ROLLUP_MAX_DELAY) {
     int64_t msInterval = -1;
-    int32_t code = convertTimeFromPrecisionToUnit(pCreate->interval, pDb->cfg.precision, TIME_UNIT_MILLISECOND, &msInterval);
+    int32_t code =
+        convertTimeFromPrecisionToUnit(pCreate->interval, pDb->cfg.precision, TIME_UNIT_MILLISECOND, &msInterval);
     if (TSDB_CODE_SUCCESS != code) {
       mError("sma:%s, failed to create since convert time failed: %s", smaObj.name, tstrerror(code));
       return code;
@@ -792,7 +790,7 @@ static int32_t mndCheckCreateSmaReq(SMCreateSmaReq *pCreate) {
 }
 
 static int32_t mndGetStreamNameFromSmaName(char *streamName, char *smaName) {
-  SName n;
+  SName   n;
   int32_t code = tNameFromString(&n, smaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -984,10 +982,10 @@ static int32_t mndSetDropSmaVgroupRedoActions(SMnode *pMnode, STrans *pTrans, SD
 }
 
 static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *pSma) {
-  int32_t  code = -1;
-  SVgObj  *pVgroup = NULL;
-  SStbObj *pStb = NULL;
-  STrans  *pTrans = NULL;
+  int32_t     code = -1;
+  SVgObj     *pVgroup = NULL;
+  SStbObj    *pStb = NULL;
+  STrans     *pTrans = NULL;
   SStreamObj *pStream = NULL;
 
   pVgroup = mndAcquireVgroup(pMnode, pSma->dstVgId);
@@ -1023,7 +1021,6 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
     goto _OVER;
   }
 
-
   code = mndAcquireStream(pMnode, streamName, &pStream);
   if (pStream == NULL || pStream->smaId != pSma->uid || code != 0) {
     sdbRelease(pMnode->pSdb, pStream);
@@ -1124,8 +1121,8 @@ _OVER:
 
 int32_t mndDropSmasByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
   int32_t code = 0;
-  SSdb *pSdb = pMnode->pSdb;
-  void *pIter = NULL;
+  SSdb   *pSdb = pMnode->pSdb;
+  void   *pIter = NULL;
 
   while (1) {
     SSmaObj *pSma = NULL;
@@ -1232,7 +1229,7 @@ static int32_t mndGetSma(SMnode *pMnode, SUserIndexReq *indexReq, SUserIndexRsp
     FOREACH(node, pList) {
       SFunctionNode *pFunc = (SFunctionNode *)node;
       extOffset += tsnprintf(rsp->indexExts + extOffset, sizeof(rsp->indexExts) - extOffset - 1, "%s%s",
-                            (extOffset ? "," : ""), pFunc->functionName);
+                             (extOffset ? "," : ""), pFunc->functionName);
     }
 
     *exist = true;
@@ -1439,8 +1436,8 @@ static int32_t mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
 
     SName smaName = {0};
     SName stbName = {0};
-    char n2[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    char n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    char  n2[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    char  n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
     code = tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
     char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
     if (TSDB_CODE_SUCCESS == code) {
@@ -1448,7 +1445,7 @@ static int32_t mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
       STR_TO_VARSTR(n2, (char *)mndGetDbStr(pSma->db));
       code = tNameFromString(&stbName, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
     }
-    SColumnInfoData* pColInfo = NULL;
+    SColumnInfoData *pColInfo = NULL;
     if (TSDB_CODE_SUCCESS == code) {
       STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName));
 
@@ -1540,7 +1537,7 @@ static void mndCancelRetrieveIdx(SMnode *pMnode, void *pIter) {
   taosMemoryFree(p);
 }
 
-static void initSMAObj(SCreateTSMACxt* pCxt) {
+static void initSMAObj(SCreateTSMACxt *pCxt) {
   memcpy(pCxt->pSma->name, pCxt->pCreateSmaReq->name, TSDB_TABLE_FNAME_LEN);
   memcpy(pCxt->pSma->stb, pCxt->pCreateSmaReq->stb, TSDB_TABLE_FNAME_LEN);
   memcpy(pCxt->pSma->db, pCxt->pDb->name, TSDB_DB_FNAME_LEN);
@@ -1549,7 +1546,7 @@ static void initSMAObj(SCreateTSMACxt* pCxt) {
   pCxt->pSma->uid = mndGenerateUid(pCxt->pCreateSmaReq->name, TSDB_TABLE_FNAME_LEN);
 
   memcpy(pCxt->pSma->dstTbName, pCxt->targetStbFullName, TSDB_TABLE_FNAME_LEN);
-  pCxt->pSma->dstTbUid = 0; // not used
+  pCxt->pSma->dstTbUid = 0;  // not used
   pCxt->pSma->stbUid = pCxt->pSrcStb ? pCxt->pSrcStb->uid : pCxt->pCreateSmaReq->normSourceTbUid;
   pCxt->pSma->dbUid = pCxt->pDb->uid;
   pCxt->pSma->interval = pCxt->pCreateSmaReq->interval;
@@ -1598,7 +1595,7 @@ static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
   if (!pCxt->pCreateStreamReq->pTags) {
     return terrno;
   }
-  SField f = {0};
+  SField  f = {0};
   int32_t code = 0;
   if (pCxt->pSrcStb) {
     for (int32_t idx = 0; idx < pCxt->pCreateStreamReq->numOfTags - 1; ++idx) {
@@ -1626,9 +1623,9 @@ static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
 
   if (TSDB_CODE_SUCCESS == code) {
     // construct output cols
-    SNode* pNode;
+    SNode *pNode;
     FOREACH(pNode, pCxt->pProjects) {
-      SExprNode* pExprNode = (SExprNode*)pNode;
+      SExprNode *pExprNode = (SExprNode *)pNode;
       f.bytes = pExprNode->resType.bytes;
       f.type = pExprNode->resType.type;
       f.flags = COL_SMA_ON;
@@ -1642,7 +1639,7 @@ static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
   return code;
 }
 
-static int32_t mndCreateTSMABuildDropStreamReq(SCreateTSMACxt* pCxt) {
+static int32_t mndCreateTSMABuildDropStreamReq(SCreateTSMACxt *pCxt) {
   tstrncpy(pCxt->pDropStreamReq->name, pCxt->streamName, TSDB_STREAM_FNAME_LEN);
   pCxt->pDropStreamReq->igNotExists = false;
   pCxt->pDropStreamReq->sql = taosStrdup(pCxt->pDropSmaReq->name);
@@ -1685,14 +1682,13 @@ static int32_t mndSetUpdateDbTsmaVersionCommitLogs(SMnode *pMnode, STrans *pTran
   TAOS_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
 }
 
-static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
+static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt *pCxt) {
   int32_t      code = -1;
   STransAction createStreamRedoAction = {0};
   STransAction createStreamUndoAction = {0};
   STransAction dropStbUndoAction = {0};
   SMDropStbReq dropStbReq = {0};
-  STrans      *pTrans =
-      mndTransCreate(pCxt->pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_TSMA, pCxt->pRpcReq, "create-tsma");
+  STrans *pTrans = mndTransCreate(pCxt->pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_TSMA, pCxt->pRpcReq, "create-tsma");
   if (!pTrans) {
     code = terrno;
     goto _OVER;
@@ -1713,7 +1709,9 @@ static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
     code = terrno;
     goto _OVER;
   }
-  if (createStreamRedoAction.contLen != tSerializeSCMCreateStreamReq(createStreamRedoAction.pCont, createStreamRedoAction.contLen, pCxt->pCreateStreamReq)) {
+  if (createStreamRedoAction.contLen != tSerializeSCMCreateStreamReq(createStreamRedoAction.pCont,
+                                                                     createStreamRedoAction.contLen,
+                                                                     pCxt->pCreateStreamReq)) {
     mError("sma: %s, failed to create due to create stream req encode failure", pCxt->pCreateSmaReq->name);
     code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
@@ -1728,14 +1726,15 @@ static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
     code = terrno;
     goto _OVER;
   }
-  if (createStreamUndoAction.contLen != tSerializeSMDropStreamReq(createStreamUndoAction.pCont, createStreamUndoAction.contLen, pCxt->pDropStreamReq)) {
+  if (createStreamUndoAction.contLen !=
+      tSerializeSMDropStreamReq(createStreamUndoAction.pCont, createStreamUndoAction.contLen, pCxt->pDropStreamReq)) {
     mError("sma: %s, failed to create due to drop stream req encode failure", pCxt->pCreateSmaReq->name);
     code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   dropStbReq.igNotExists = true;
-  strncpy(dropStbReq.name, pCxt->targetStbFullName, TSDB_TABLE_FNAME_LEN);
+  tstrncpy(dropStbReq.name, pCxt->targetStbFullName, TSDB_TABLE_FNAME_LEN);
   dropStbUndoAction.epSet = createStreamRedoAction.epSet;
   dropStbUndoAction.acceptableCode = TSDB_CODE_MND_STB_NOT_EXIST;
   dropStbUndoAction.retryCode = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
@@ -1746,7 +1745,8 @@ static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
     code = terrno;
     goto _OVER;
   }
-  if (dropStbUndoAction.contLen != tSerializeSMDropStbReq(dropStbUndoAction.pCont, dropStbUndoAction.contLen, &dropStbReq)) {
+  if (dropStbUndoAction.contLen !=
+      tSerializeSMDropStbReq(dropStbUndoAction.pCont, dropStbUndoAction.contLen, &dropStbReq)) {
     mError("sma: %s, failed to create due to drop stb req encode failure", pCxt->pCreateSmaReq->name);
     code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
@@ -1781,7 +1781,7 @@ static int32_t mndCreateTSMA(SCreateTSMACxt *pCxt) {
   pCxt->pSma = &sma;
   initSMAObj(pCxt);
 
-  SNodeList* pProjects = NULL;
+  SNodeList *pProjects = NULL;
   code = nodesStringToList(pCxt->pCreateSmaReq->expr, &pProjects);
   if (TSDB_CODE_SUCCESS != code) {
     goto _OVER;
@@ -1830,28 +1830,28 @@ _OVER:
   TAOS_RETURN(code);
 }
 
-static int32_t mndTSMAGenerateOutputName(const char* tsmaName, char* streamName, char* targetStbName) {
-  SName smaName;
+static int32_t mndTSMAGenerateOutputName(const char *tsmaName, char *streamName, char *targetStbName) {
+  SName   smaName;
   int32_t code = tNameFromString(&smaName, tsmaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
   sprintf(streamName, "%d.%s", smaName.acctId, smaName.tname);
-  snprintf(targetStbName, TSDB_TABLE_FNAME_LEN, "%s"TSMA_RES_STB_POSTFIX, tsmaName);
+  snprintf(targetStbName, TSDB_TABLE_FNAME_LEN, "%s" TSMA_RES_STB_POSTFIX, tsmaName);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) {
+static int32_t mndProcessCreateTSMAReq(SRpcMsg *pReq) {
 #ifdef WINDOWS
   TAOS_RETURN(TSDB_CODE_MND_INVALID_PLATFORM);
 #endif
-  SMnode *       pMnode = pReq->info.node;
+  SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
-  SDbObj *       pDb = NULL;
-  SStbObj *      pStb = NULL;
-  SSmaObj *      pSma = NULL;
-  SSmaObj *      pBaseTsma = NULL;
-  SStreamObj *   pStream = NULL;
+  SDbObj        *pDb = NULL;
+  SStbObj       *pStb = NULL;
+  SSmaObj       *pSma = NULL;
+  SSmaObj       *pBaseTsma = NULL;
+  SStreamObj    *pStream = NULL;
   int64_t        mTraceId = TRACE_GET_ROOTID(&pReq->info.traceId);
   SMCreateSmaReq createReq = {0};
 
@@ -1941,16 +1941,16 @@ static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) {
   }
 
   SCreateTSMACxt cxt = {
-    .pMnode = pMnode,
-    .pCreateSmaReq = &createReq,
-    .pCreateStreamReq = NULL,
-    .streamName = streamName,
-    .targetStbFullName = streamTargetStbFullName,
-    .pDb = pDb,
-    .pRpcReq = pReq,
-    .pSma = NULL,
-    .pBaseSma = pBaseTsma,
-    .pSrcStb = pStb,
+      .pMnode = pMnode,
+      .pCreateSmaReq = &createReq,
+      .pCreateStreamReq = NULL,
+      .streamName = streamName,
+      .targetStbFullName = streamTargetStbFullName,
+      .pDb = pDb,
+      .pRpcReq = pReq,
+      .pSma = NULL,
+      .pBaseSma = pBaseTsma,
+      .pSrcStb = pStb,
   };
 
   code = mndCreateTSMA(&cxt);
@@ -1971,10 +1971,10 @@ _OVER:
   TAOS_RETURN(code);
 }
 
-static int32_t mndDropTSMA(SCreateTSMACxt* pCxt) {
-  int32_t code = -1;
+static int32_t mndDropTSMA(SCreateTSMACxt *pCxt) {
+  int32_t      code = -1;
   STransAction dropStreamRedoAction = {0};
-  STrans *pTrans = mndTransCreate(pCxt->pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_TSMA, pCxt->pRpcReq, "drop-tsma");
+  STrans      *pTrans = mndTransCreate(pCxt->pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_TSMA, pCxt->pRpcReq, "drop-tsma");
   if (!pTrans) {
     code = terrno;
     goto _OVER;
@@ -2021,7 +2021,8 @@ static int32_t mndDropTSMA(SCreateTSMACxt* pCxt) {
     code = terrno;
     goto _OVER;
   }
-  if (dropStbRedoAction.contLen != tSerializeSMDropStbReq(dropStbRedoAction.pCont, dropStbRedoAction.contLen, &dropStbReq)) {
+  if (dropStbRedoAction.contLen !=
+      tSerializeSMDropStbReq(dropStbRedoAction.pCont, dropStbRedoAction.contLen, &dropStbReq)) {
     mError("tsma: %s, failedto drop due to drop stb req encode failure", pCxt->pDropSmaReq->name);
     code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
@@ -2044,9 +2045,9 @@ _OVER:
   TAOS_RETURN(code);
 }
 
-static bool hasRecursiveTsmasBasedOnMe(SMnode* pMnode, const SSmaObj* pSma) {
+static bool hasRecursiveTsmasBasedOnMe(SMnode *pMnode, const SSmaObj *pSma) {
   SSmaObj *pSmaObj = NULL;
-  void *   pIter = NULL;
+  void    *pIter = NULL;
   while (1) {
     pIter = sdbFetch(pMnode->pSdb, SDB_SMA, pIter, (void **)&pSmaObj);
     if (pIter == NULL) break;
@@ -2060,25 +2061,25 @@ static bool hasRecursiveTsmasBasedOnMe(SMnode* pMnode, const SSmaObj* pSma) {
   return false;
 }
 
-static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq) {
+static int32_t mndProcessDropTSMAReq(SRpcMsg *pReq) {
   int32_t      code = -1;
   SMDropSmaReq dropReq = {0};
-  SSmaObj *    pSma = NULL;
-  SDbObj *     pDb = NULL;
-  SMnode *     pMnode = pReq->info.node;
+  SSmaObj     *pSma = NULL;
+  SDbObj      *pDb = NULL;
+  SMnode      *pMnode = pReq->info.node;
   if (tDeserializeSMDropSmaReq(pReq->pCont, pReq->contLen, &dropReq) != TSDB_CODE_SUCCESS) {
     code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
-  char  streamName[TSDB_TABLE_FNAME_LEN] = {0};
-  char  streamTargetStbFullName[TSDB_TABLE_FNAME_LEN] = {0};
+  char streamName[TSDB_TABLE_FNAME_LEN] = {0};
+  char streamTargetStbFullName[TSDB_TABLE_FNAME_LEN] = {0};
   code = mndTSMAGenerateOutputName(dropReq.name, streamName, streamTargetStbFullName);
   if (TSDB_CODE_SUCCESS != code) {
     goto _OVER;
   }
 
-  SStbObj* pStb = mndAcquireStb(pMnode, streamTargetStbFullName);
+  SStbObj *pStb = mndAcquireStb(pMnode, streamTargetStbFullName);
 
   pSma = mndAcquireSma(pMnode, dropReq.name);
   if (!pSma && dropReq.igNotExists) {
@@ -2113,13 +2114,13 @@ static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq) {
   }
 
   SCreateTSMACxt cxt = {
-    .pDb = pDb,
-    .pMnode = pMnode,
-    .pRpcReq = pReq,
-    .pSma = pSma,
-    .streamName = streamName,
-    .targetStbFullName = streamTargetStbFullName,
-    .pDropSmaReq = &dropReq,
+      .pDb = pDb,
+      .pMnode = pMnode,
+      .pRpcReq = pReq,
+      .pSma = pSma,
+      .streamName = streamName,
+      .targetStbFullName = streamTargetStbFullName,
+      .pDropSmaReq = &dropReq,
   };
 
   code = mndDropTSMA(&cxt);
@@ -2134,10 +2135,10 @@ _OVER:
 }
 
 static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SDbObj *         pDb = NULL;
+  SDbObj          *pDb = NULL;
   int32_t          numOfRows = 0;
-  SSmaObj *        pSma = NULL;
-  SMnode *         pMnode = pReq->info.node;
+  SSmaObj         *pSma = NULL;
+  SMnode          *pMnode = pReq->info.node;
   int32_t          code = 0;
   SColumnInfoData *pColInfo;
   if (pShow->pIter == NULL) {
@@ -2153,7 +2154,7 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
   while (numOfRows < rows) {
     pIter->pSmaIter = sdbFetch(pMnode->pSdb, SDB_SMA, pIter->pSmaIter, (void **)&pSma);
     if (pIter->pSmaIter == NULL) break;
-    SDbObj* pSrcDb = mndAcquireDb(pMnode, pSma->db);
+    SDbObj *pSrcDb = mndAcquireDb(pMnode, pSma->db);
 
     if ((pDb && pSma->dbUid != pDb->uid) || !pSrcDb) {
       sdbRelease(pMnode->pSdb, pSma);
@@ -2176,7 +2177,7 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
     if (TSDB_CODE_SUCCESS == code) {
       STR_TO_VARSTR(db, (char *)mndGetDbStr(pSma->db));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      code = colDataSetVal(pColInfo, numOfRows, (const char*)db, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)db, false);
     }
 
     if (TSDB_CODE_SUCCESS == code) {
@@ -2186,12 +2187,12 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
     if (TSDB_CODE_SUCCESS == code) {
       STR_TO_VARSTR(srcTb, (char *)tNameGetTableName(&n));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      code = colDataSetVal(pColInfo, numOfRows, (const char*)srcTb, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)srcTb, false);
     }
 
     if (TSDB_CODE_SUCCESS == code) {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      code = colDataSetVal(pColInfo, numOfRows, (const char*)db, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)db, false);
     }
 
     if (TSDB_CODE_SUCCESS == code) {
@@ -2200,29 +2201,29 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
 
     if (TSDB_CODE_SUCCESS == code) {
       char targetTb[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-      STR_TO_VARSTR(targetTb, (char*)tNameGetTableName(&n));
+      STR_TO_VARSTR(targetTb, (char *)tNameGetTableName(&n));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      code = colDataSetVal(pColInfo, numOfRows, (const char*)targetTb, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)targetTb, false);
     }
 
     if (TSDB_CODE_SUCCESS == code) {
       // stream name
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      code = colDataSetVal(pColInfo, numOfRows, (const char*)smaName, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)smaName, false);
     }
 
     if (TSDB_CODE_SUCCESS == code) {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      code = colDataSetVal(pColInfo, numOfRows, (const char*)(&pSma->createdTime), false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)(&pSma->createdTime), false);
     }
 
     // interval
-    char interval[64 + VARSTR_HEADER_SIZE] = {0};
+    char    interval[64 + VARSTR_HEADER_SIZE] = {0};
     int32_t len = 0;
     if (TSDB_CODE_SUCCESS == code) {
       if (!IS_CALENDAR_TIME_DURATION(pSma->intervalUnit)) {
         len = tsnprintf(interval + VARSTR_HEADER_SIZE, 64, "%" PRId64 "%c", pSma->interval,
-            getPrecisionUnit(pSrcDb->cfg.precision));
+                        getPrecisionUnit(pSrcDb->cfg.precision));
       } else {
         len = tsnprintf(interval + VARSTR_HEADER_SIZE, 64, "%" PRId64 "%c", pSma->interval, pSma->intervalUnit);
       }
@@ -2243,17 +2244,17 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
     // func list
     len = 0;
     SNode *pNode = NULL, *pFunc = NULL;
-    if (TSDB_CODE_SUCCESS  == code) {
+    if (TSDB_CODE_SUCCESS == code) {
       code = nodesStringToNode(pSma->ast, &pNode);
     }
     if (TSDB_CODE_SUCCESS == code) {
-      char * start = buf + VARSTR_HEADER_SIZE;
+      char *start = buf + VARSTR_HEADER_SIZE;
       FOREACH(pFunc, ((SSelectStmt *)pNode)->pProjectionList) {
         if (nodeType(pFunc) == QUERY_NODE_FUNCTION) {
           SFunctionNode *pFuncNode = (SFunctionNode *)pFunc;
           if (!fmIsTSMASupportedFunc(pFuncNode->funcId)) continue;
           len += tsnprintf(start, TSDB_MAX_SAVED_SQL_LEN - len, "%s%s", start != buf + VARSTR_HEADER_SIZE ? "," : "",
-                          ((SExprNode *)pFunc)->userAlias);
+                           ((SExprNode *)pFunc)->userAlias);
           if (len >= TSDB_MAX_SAVED_SQL_LEN) {
             len = TSDB_MAX_SAVED_SQL_LEN;
             break;
@@ -2297,7 +2298,8 @@ static void mndCancelRetrieveTSMA(SMnode *pMnode, void *pIter) {
   taosMemoryFree(p);
 }
 
-int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, const SStbObj* pDestStb, STableTSMAInfo* pInfo, const SSmaObj* pBaseTsma) {
+int32_t dumpTSMAInfoFromSmaObj(const SSmaObj *pSma, const SStbObj *pDestStb, STableTSMAInfo *pInfo,
+                               const SSmaObj *pBaseTsma) {
   int32_t code = 0;
   pInfo->interval = pSma->interval;
   pInfo->unit = pSma->intervalUnit;
@@ -2336,7 +2338,7 @@ int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, const SStbObj* pDestStb, STa
     SSelectStmt *pSelect = (SSelectStmt *)pNode;
     FOREACH(pFunc, pSelect->pProjectionList) {
       STableTSMAFuncInfo funcInfo = {0};
-      SFunctionNode *    pFuncNode = (SFunctionNode *)pFunc;
+      SFunctionNode     *pFuncNode = (SFunctionNode *)pFunc;
       if (!fmIsTSMASupportedFunc(pFuncNode->funcId)) continue;
       funcInfo.funcId = pFuncNode->funcId;
       funcInfo.colId = ((SColumnNode *)pFuncNode->pParameterList->pHead->pNode)->colId;
@@ -2383,9 +2385,9 @@ int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, const SStbObj* pDestStb, STa
 }
 
 // @note remember to mndReleaseSma(*ppOut)
-static int32_t mndGetDeepestBaseForTsma(SMnode* pMnode, SSmaObj* pSma, SSmaObj** ppOut) {
-  int32_t code = 0;
-  SSmaObj* pRecursiveTsma = NULL;
+static int32_t mndGetDeepestBaseForTsma(SMnode *pMnode, SSmaObj *pSma, SSmaObj **ppOut) {
+  int32_t  code = 0;
+  SSmaObj *pRecursiveTsma = NULL;
   if (pSma->baseSmaName[0]) {
     pRecursiveTsma = mndAcquireSma(pMnode, pSma->baseSmaName);
     if (!pRecursiveTsma) {
@@ -2393,7 +2395,7 @@ static int32_t mndGetDeepestBaseForTsma(SMnode* pMnode, SSmaObj* pSma, SSmaObj**
       return TSDB_CODE_MND_SMA_NOT_EXIST;
     }
     while (pRecursiveTsma->baseSmaName[0]) {
-      SSmaObj* pTmpSma = pRecursiveTsma;
+      SSmaObj *pTmpSma = pRecursiveTsma;
       pRecursiveTsma = mndAcquireSma(pMnode, pTmpSma->baseSmaName);
       if (!pRecursiveTsma) {
         mError("base tsma: %s for tsma: %s not found", pTmpSma->baseSmaName, pTmpSma->name);
@@ -2407,7 +2409,6 @@ static int32_t mndGetDeepestBaseForTsma(SMnode* pMnode, SSmaObj* pSma, SSmaObj**
   return code;
 }
 
-
 static int32_t mndGetTSMA(SMnode *pMnode, char *tsmaFName, STableTSMAInfoRsp *rsp, bool *exist) {
   int32_t  code = -1;
   SSmaObj *pSma = NULL;
@@ -2450,17 +2451,17 @@ static int32_t mndGetTSMA(SMnode *pMnode, char *tsmaFName, STableTSMAInfoRsp *rs
   TAOS_RETURN(code);
 }
 
-typedef bool (*tsmaFilter)(const SSmaObj* pSma, void* param);
+typedef bool (*tsmaFilter)(const SSmaObj *pSma, void *param);
 
-static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilter filtered, void* param, bool* exist) {
-  int32_t        code = 0;
-  SSmaObj *      pSma = NULL;
-  SSmaObj *      pBaseTsma = NULL;
-  SSdb *         pSdb = pMnode->pSdb;
-  void *         pIter = NULL;
-  SStreamObj *   pStream = NULL;
-  SStbObj *      pStb = NULL;
-  bool           shouldRetry = false;
+static int32_t mndGetSomeTsmas(SMnode *pMnode, STableTSMAInfoRsp *pRsp, tsmaFilter filtered, void *param, bool *exist) {
+  int32_t     code = 0;
+  SSmaObj    *pSma = NULL;
+  SSmaObj    *pBaseTsma = NULL;
+  SSdb       *pSdb = pMnode->pSdb;
+  void       *pIter = NULL;
+  SStreamObj *pStream = NULL;
+  SStbObj    *pStb = NULL;
+  bool        shouldRetry = false;
 
   while (1) {
     pIter = sdbFetch(pSdb, SDB_SMA, pIter, (void **)&pSma);
@@ -2479,7 +2480,7 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt
     }
 
     SName smaName;
-    char streamName[TSDB_TABLE_FNAME_LEN] = {0};
+    char  streamName[TSDB_TABLE_FNAME_LEN] = {0};
     code = tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
     if (TSDB_CODE_SUCCESS != code) {
       sdbRelease(pSdb, pSma);
@@ -2541,8 +2542,8 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt
   return TSDB_CODE_SUCCESS;
 }
 
-static bool tsmaTbFilter(const SSmaObj* pSma, void* param) {
-  const char* tbFName = param;
+static bool tsmaTbFilter(const SSmaObj *pSma, void *param) {
+  const char *tbFName = param;
   return pSma->stb[0] != tbFName[0] || strcmp(pSma->stb, tbFName) != 0;
 }
 
@@ -2550,7 +2551,7 @@ static int32_t mndGetTableTSMA(SMnode *pMnode, char *tbFName, STableTSMAInfoRsp
   return mndGetSomeTsmas(pMnode, pRsp, tsmaTbFilter, tbFName, exist);
 }
 
-static bool tsmaDbFilter(const SSmaObj* pSma, void* param) {
+static bool tsmaDbFilter(const SSmaObj *pSma, void *param) {
   uint64_t *dbUid = param;
   return pSma->dbUid != *dbUid;
 }
@@ -2564,7 +2565,7 @@ static int32_t mndProcessGetTbTSMAReq(SRpcMsg *pReq) {
   int32_t           code = -1;
   STableTSMAInfoReq tsmaReq = {0};
   bool              exist = false;
-  SMnode *          pMnode = pReq->info.node;
+  SMnode           *pMnode = pReq->info.node;
 
   TAOS_CHECK_GOTO(tDeserializeTableTSMAInfoReq(pReq->pCont, pReq->contLen, &tsmaReq), NULL, _OVER);
 
@@ -2635,12 +2636,12 @@ static int32_t mkNonExistTSMAInfo(const STSMAVersion *pTsmaVer, STableTSMAInfo *
 
 int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t numOfTsmas, void **ppRsp,
                             int32_t *pRspLen) {
-  int32_t            code = -1;
-  STSMAHbRsp         hbRsp = {0};
-  int32_t            rspLen = 0;
-  void *             pRsp = NULL;
-  char               tsmaFName[TSDB_TABLE_FNAME_LEN] = {0};
-  STableTSMAInfo *   pTsmaInfo = NULL;
+  int32_t         code = -1;
+  STSMAHbRsp      hbRsp = {0};
+  int32_t         rspLen = 0;
+  void           *pRsp = NULL;
+  char            tsmaFName[TSDB_TABLE_FNAME_LEN] = {0};
+  STableTSMAInfo *pTsmaInfo = NULL;
 
   hbRsp.pTsmas = taosArrayInit(numOfTsmas, POINTER_BYTES);
   if (!hbRsp.pTsmas) {
@@ -2649,13 +2650,13 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
   }
 
   for (int32_t i = 0; i < numOfTsmas; ++i) {
-    STSMAVersion* pTsmaVer = &pTsmaVersions[i];
+    STSMAVersion *pTsmaVer = &pTsmaVersions[i];
     pTsmaVer->dbId = be64toh(pTsmaVer->dbId);
     pTsmaVer->tsmaId = be64toh(pTsmaVer->tsmaId);
     pTsmaVer->version = ntohl(pTsmaVer->version);
 
     snprintf(tsmaFName, sizeof(tsmaFName), "%s.%s", pTsmaVer->dbFName, pTsmaVer->name);
-    SSmaObj* pSma = mndAcquireSma(pMnode, tsmaFName);
+    SSmaObj *pSma = mndAcquireSma(pMnode, tsmaFName);
     if (!pSma) {
       code = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
       if (code) goto _OVER;
@@ -2683,7 +2684,7 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
       continue;
     }
 
-    SStbObj* pDestStb = mndAcquireStb(pMnode, pSma->dstTbName);
+    SStbObj *pDestStb = mndAcquireStb(pMnode, pSma->dstTbName);
     if (!pDestStb) {
       mInfo("tsma: %s.%" PRIx64 " dest stb: %s not found, maybe dropped", tsmaFName, pTsmaVer->tsmaId, pSma->dstTbName);
       code = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
@@ -2698,7 +2699,7 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
     }
 
     // dump smaObj into rsp
-    STableTSMAInfo *   pInfo = NULL;
+    STableTSMAInfo *pInfo = NULL;
     pInfo = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
     if (!pInfo) {
       code = terrno;
@@ -2707,7 +2708,7 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
       goto _OVER;
     }
 
-    SSmaObj* pBaseSma = NULL;
+    SSmaObj *pBaseSma = NULL;
     code = mndGetDeepestBaseForTsma(pMnode, pSma, &pBaseSma);
     if (code == 0) code = dumpTSMAInfoFromSmaObj(pSma, pDestStb, pInfo, pBaseSma);
 
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index 63390d4772..c1a240c3f4 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -1707,7 +1707,7 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate
     taosEncryptPass_c((uint8_t *)pCreate->pass, strlen(pCreate->pass), userObj.pass);
   } else {
     // mInfo("pCreate->pass:%s", pCreate->pass)
-    strncpy(userObj.pass, pCreate->pass, TSDB_PASSWORD_LEN);
+    tstrncpy(userObj.pass, pCreate->pass, TSDB_PASSWORD_LEN);
   }
   tstrncpy(userObj.user, pCreate->user, TSDB_USER_LEN);
   tstrncpy(userObj.acct, acct, TSDB_USER_LEN);
diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c
index 474b22cca0..bd4be7431f 100644
--- a/source/dnode/mnode/sdb/src/sdbFile.c
+++ b/source/dnode/mnode/sdb/src/sdbFile.c
@@ -370,7 +370,7 @@ static int32_t sdbReadFileImp(SSdb *pSdb) {
       opts.source = pRaw->pData;
       opts.result = plantContent;
       opts.unitLen = 16;
-      strncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN);
 
       count = CBC_Decrypt(&opts);
 
@@ -510,7 +510,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb, int32_t skip_type) {
           opts.source = pRaw->pData;
           opts.result = newData;
           opts.unitLen = 16;
-          strncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN);
+          tstrncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN);
 
           int32_t count = CBC_Encrypt(&opts);
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c
index 0c9d9e56cf..d3495422b0 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFS2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c
@@ -396,7 +396,7 @@ static int32_t tsdbFSAddEntryToFileObjHash(STFileHash *hash, const char *fname)
   STFileHashEntry *entry = taosMemoryMalloc(sizeof(*entry));
   if (entry == NULL) return terrno;
 
-  strncpy(entry->fname, fname, TSDB_FILENAME_LEN);
+  tstrncpy(entry->fname, fname, TSDB_FILENAME_LEN);
 
   uint32_t idx = MurmurHash3_32(fname, strlen(fname)) % hash->numBucket;
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
index 53e1c57f14..af5e45c279 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -175,7 +175,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e
         opts.result = PacketData;
         opts.unitLen = 128;
         // strncpy(opts.key, tsEncryptKey, 16);
-        strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+        tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
 
         NewLen = CBC_Encrypt(&opts);
 
@@ -249,7 +249,7 @@ static int32_t tsdbReadFilePage(STsdbFD *pFD, int64_t pgno, int32_t encryptAlgor
       opts.result = PacketData;
       opts.unitLen = 128;
       // strncpy(opts.key, tsEncryptKey, 16);
-      strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
 
       NewLen = CBC_Decrypt(&opts);
 
diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c
index 7c789e84ae..791c2bae80 100644
--- a/source/dnode/vnode/src/vnd/vnodeCfg.c
+++ b/source/dnode/vnode/src/vnd/vnodeCfg.c
@@ -265,7 +265,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
     if (tsEncryptKey[0] == 0) {
       return terrno = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
     } else {
-      strncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
     }
   }
 #endif
@@ -292,7 +292,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
     if (tsEncryptKey[0] == 0) {
       return terrno = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
     } else {
-      strncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
     }
   }
 #endif
@@ -303,7 +303,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
     if (tsEncryptKey[0] == 0) {
       return terrno = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
     } else {
-      strncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
     }
   }
 #endif
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 546cd6c3ae..aece557091 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -1024,7 +1024,7 @@ static int32_t vnodeProcessFetchTtlExpiredTbs(SVnode *pVnode, int64_t ver, void
     expiredTb.suid = *uid;
     terrno = metaReaderGetTableEntryByUid(&mr, *uid);
     if (terrno < 0) goto _end;
-    strncpy(buf, mr.me.name, TSDB_TABLE_NAME_LEN);
+    tstrncpy(buf, mr.me.name, TSDB_TABLE_NAME_LEN);
     void *p = taosArrayPush(pNames, buf);
     if (p == NULL) {
       goto _end;
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index 3d37cdb560..6dce0cf481 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -691,7 +691,7 @@ int32_t syncGetArbToken(int64_t rid, char* outToken) {
 
   memset(outToken, 0, TSDB_ARB_TOKEN_SIZE);
   (void)taosThreadMutexLock(&pSyncNode->arbTokenMutex);
-  strncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE);
+  tstrncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE);
   (void)taosThreadMutexUnlock(&pSyncNode->arbTokenMutex);
 
   syncNodeRelease(pSyncNode);
@@ -2901,7 +2901,7 @@ void syncNodeLogConfigInfo(SSyncNode* ths, SSyncCfg* cfg, char* str) {
     n += tsnprintf(buf + n, len - n, "%s", "{");
     for (int i = 0; i < ths->peersEpset->numOfEps; i++) {
       n += tsnprintf(buf + n, len - n, "%s:%d%s", ths->peersEpset->eps[i].fqdn, ths->peersEpset->eps[i].port,
-                    (i + 1 < ths->peersEpset->numOfEps ? ", " : ""));
+                     (i + 1 < ths->peersEpset->numOfEps ? ", " : ""));
     }
     n += tsnprintf(buf + n, len - n, "%s", "}");
 
diff --git a/source/libs/tdb/src/db/tdbDb.c b/source/libs/tdb/src/db/tdbDb.c
index 02ab997f69..1431533a30 100644
--- a/source/libs/tdb/src/db/tdbDb.c
+++ b/source/libs/tdb/src/db/tdbDb.c
@@ -52,7 +52,7 @@ int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, i
 
   pDb->encryptAlgorithm = encryptAlgorithm;
   if (encryptKey != NULL) {
-    strncpy(pDb->encryptKey, encryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pDb->encryptKey, encryptKey, ENCRYPT_KEY_LEN);
   }
 
   ret = tdbPCacheOpen(szPage, pages, &(pDb->pCache));
diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c
index 2753fe30d6..9a2cd8e8de 100644
--- a/source/libs/tdb/src/db/tdbPager.c
+++ b/source/libs/tdb/src/db/tdbPager.c
@@ -459,7 +459,7 @@ static char *tdbEncryptPage(SPager *pPager, char *pPageData, int32_t pageSize, c
       opts.source = pPageData + count;
       opts.result = packetData;
       opts.unitLen = 128;
-      strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
 
       int32_t newLen = CBC_Encrypt(&opts);
 
@@ -927,7 +927,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage
           opts.source = pPage->pData + count;
           opts.result = packetData;
           opts.unitLen = 128;
-          strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+          tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
 
           int newLen = CBC_Decrypt(&opts);
 
diff --git a/source/libs/tfs/src/tfs.c b/source/libs/tfs/src/tfs.c
index 51fda85f0a..2c97a9ac85 100644
--- a/source/libs/tfs/src/tfs.c
+++ b/source/libs/tfs/src/tfs.c
@@ -200,8 +200,8 @@ bool tfsIsSameFile(const STfsFile *pFile1, const STfsFile *pFile2) {
   if (pFile1->did.level != pFile2->did.level) return false;
   if (pFile1->did.id != pFile2->did.id) return false;
   char nameBuf1[TMPNAME_LEN], nameBuf2[TMPNAME_LEN];
-  (void)strncpy(nameBuf1, pFile1->rname, TMPNAME_LEN);
-  (void)strncpy(nameBuf2, pFile2->rname, TMPNAME_LEN);
+  tstrncpy(nameBuf1, pFile1->rname, TMPNAME_LEN);
+  tstrncpy(nameBuf2, pFile2->rname, TMPNAME_LEN);
   nameBuf1[TMPNAME_LEN - 1] = 0;
   nameBuf2[TMPNAME_LEN - 1] = 0;
   TAOS_UNUSED(taosRealPath(nameBuf1, NULL, TMPNAME_LEN));
@@ -573,7 +573,7 @@ static int32_t tfsCheckAndFormatCfg(STfs *pTfs, SDiskCfg *pCfg) {
     TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
   }
 
-  strncpy(pCfg->dir, dirName, TSDB_FILENAME_LEN);
+  tstrncpy(pCfg->dir, dirName, TSDB_FILENAME_LEN);
 
   TAOS_RETURN(0);
 }
diff --git a/source/libs/wal/src/walWrite.c b/source/libs/wal/src/walWrite.c
index 66ead2fd26..30ac137f66 100644
--- a/source/libs/wal/src/walWrite.c
+++ b/source/libs/wal/src/walWrite.c
@@ -638,7 +638,7 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
     opts.source = newBody;
     opts.result = newBodyEncrypted;
     opts.unitLen = 16;
-    TAOS_UNUSED(strncpy((char *)opts.key, pWal->cfg.encryptKey, ENCRYPT_KEY_LEN));
+    tstrncpy((char *)opts.key, pWal->cfg.encryptKey, ENCRYPT_KEY_LEN);
 
     int32_t count = CBC_Encrypt(&opts);
 
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 1cce67c06e..b3fd6455b6 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -330,7 +330,7 @@ static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool rese
   if (pDebugFlagItem == NULL) return -1;
   if (pDebugFlagItem->array != NULL) {
     SLogVar logVar = {0};
-    (void)strncpy(logVar.name, name, TSDB_LOG_VAR_LEN - 1);
+    tstrncpy(logVar.name, name, TSDB_LOG_VAR_LEN);
     if (NULL == taosArrayPush(pDebugFlagItem->array, &logVar)) {
       TAOS_RETURN(terrno);
     }
@@ -942,7 +942,7 @@ int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
     name = value = value2 = value3 = value4 = NULL;
     olen = vlen = vlen2 = vlen3 = vlen4 = 0;
 
-    strncpy(line, *pEnv, sizeof(line) - 1);
+    tstrncpy(line, *pEnv, sizeof(line));
     pEnv++;
     if (taosEnvToCfg(line, line) < 0) {
       uTrace("failed to convert env to cfg:%s", line);
@@ -987,7 +987,7 @@ int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
   int32_t index = 0;
   if (envCmd == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
   while (envCmd[index] != NULL) {
-    strncpy(buf, envCmd[index], sizeof(buf) - 1);
+    tstrncpy(buf, envCmd[index], sizeof(buf));
     buf[sizeof(buf) - 1] = 0;
     if (taosEnvToCfg(buf, buf) < 0) {
       uTrace("failed to convert env to cfg:%s", buf);
@@ -1438,7 +1438,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
   char **pEnv = environ;
   line[1023] = 0;
   while (*pEnv != NULL) {
-    strncpy(line, *pEnv, sizeof(line) - 1);
+    tstrncpy(line, *pEnv, sizeof(line));
     pEnv++;
     if (strncmp(line, "TAOS_APOLLO_URL", 14) == 0) {
       char *p = strchr(line, '=');

From 9e7da45d3781e733b895d8b0e34120304b58049e Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Thu, 5 Dec 2024 16:54:10 +0800
Subject: [PATCH 13/25] use safe sys func

---
 source/dnode/mnode/impl/src/mndCompact.c | 13 ++++++++-----
 source/dnode/mnode/impl/src/mndMnode.c   | 13 ++++++++-----
 source/dnode/mnode/impl/src/mndProfile.c | 13 ++++++++-----
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/source/dnode/mnode/impl/src/mndCompact.c b/source/dnode/mnode/impl/src/mndCompact.c
index c27818011d..4c2ff9befc 100644
--- a/source/dnode/mnode/impl/src/mndCompact.c
+++ b/source/dnode/mnode/impl/src/mndCompact.c
@@ -516,11 +516,14 @@ int32_t mndProcessKillCompactReq(SRpcMsg *pReq) {
 
   code = TSDB_CODE_ACTION_IN_PROGRESS;
 
-  char obj[TSDB_INT32_ID_LEN] = {0};
-  (void)sprintf(obj, "%d", pCompact->compactId);
-
-  auditRecord(pReq, pMnode->clusterId, "killCompact", pCompact->dbname, obj, killCompactReq.sql, killCompactReq.sqlLen);
-
+  char    obj[TSDB_INT32_ID_LEN] = {0};
+  int32_t nBytes = snprintf(obj, sizeof(obj), "%d", pCompact->compactId);
+  if ((uint32_t)nBytes < sizeof(obj)) {
+    auditRecord(pReq, pMnode->clusterId, "killCompact", pCompact->dbname, obj, killCompactReq.sql,
+                killCompactReq.sqlLen);
+  } else {
+    mError("compact:%" PRId32 " failed to audit since %s", pCompact->compactId, tstrerror(TSDB_CODE_OUT_OF_RANGE));
+  }
 _OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
     mError("failed to kill compact %" PRId32 " since %s", killCompactReq.compactId, terrstr());
diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c
index 6b1c97b399..c89fc26fb5 100644
--- a/source/dnode/mnode/impl/src/mndMnode.c
+++ b/source/dnode/mnode/impl/src/mndMnode.c
@@ -14,10 +14,10 @@
  */
 
 #define _DEFAULT_SOURCE
+#include "mndMnode.h"
 #include "audit.h"
 #include "mndCluster.h"
 #include "mndDnode.h"
-#include "mndMnode.h"
 #include "mndPrivilege.h"
 #include "mndShow.h"
 #include "mndSync.h"
@@ -722,10 +722,13 @@ static int32_t mndProcessCreateMnodeReq(SRpcMsg *pReq) {
   code = mndCreateMnode(pMnode, pReq, pDnode, &createReq);
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
-  char obj[40] = {0};
-  sprintf(obj, "%d", createReq.dnodeId);
-
-  auditRecord(pReq, pMnode->clusterId, "createMnode", "", obj, createReq.sql, createReq.sqlLen);
+  char    obj[40] = {0};
+  int32_t bytes = snprintf(obj, sizeof(obj), "%d", createReq.dnodeId);
+  if ((uint32_t)bytes < sizeof(obj)) {
+    auditRecord(pReq, pMnode->clusterId, "createMnode", "", obj, createReq.sql, createReq.sqlLen);
+  } else {
+    mError("mnode:%d, failed to audit create req since %s", createReq.dnodeId, tstrerror(TSDB_CODE_OUT_OF_RANGE));
+  }
 
 _OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c
index 21aba8df10..f7e0f5349f 100644
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@@ -14,12 +14,12 @@
  */
 
 #define _DEFAULT_SOURCE
+#include "mndProfile.h"
 #include "audit.h"
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndMnode.h"
 #include "mndPrivilege.h"
-#include "mndProfile.h"
 #include "mndQnode.h"
 #include "mndShow.h"
 #include "mndSma.h"
@@ -336,10 +336,13 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
 
   code = 0;
 
-  char detail[1000] = {0};
-  (void)sprintf(detail, "app:%s", connReq.app);
-
-  auditRecord(pReq, pMnode->clusterId, "login", "", "", detail, strlen(detail));
+  char    detail[1000] = {0};
+  int32_t nBytes = snprintf(detail, sizeof(detail), "app:%s", connReq.app);
+  if ((uint32_t)nBytes < sizeof(detail)) {
+    auditRecord(pReq, pMnode->clusterId, "login", "", "", detail, strlen(detail));
+  } else {
+    mError("failed to audit logic since %s", tstrerror(TSDB_CODE_OUT_OF_RANGE));
+  }
 
 _OVER:
 

From b9d92bd7b713e84b6ad4cb749bd7c28742a389d6 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Fri, 6 Dec 2024 21:44:23 +0800
Subject: [PATCH 14/25] use safe sys func

---
 source/dnode/mgmt/node_mgmt/src/dmMgmt.c | 81 ++++++++++++------------
 source/dnode/mnode/impl/src/mndDnode.c   |  4 +-
 source/dnode/mnode/impl/src/mndMain.c    |  2 +-
 source/libs/wal/src/walWrite.c           |  2 +-
 source/os/src/osString.c                 | 11 ++--
 source/util/src/tconfig.c                | 21 +++---
 6 files changed, 57 insertions(+), 64 deletions(-)

diff --git a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
index a189251378..02cfa2d43b 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
@@ -220,62 +220,63 @@ int32_t dmInitVars(SDnode *pDnode) {
 }
 
 extern SMonVloadInfo tsVinfo;
-void                 dmClearVars(SDnode *pDnode) {
-                  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
-                    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-                    taosMemoryFreeClear(pWrapper->path);
-                    (void)taosThreadRwlockDestroy(&pWrapper->lock);
+
+void dmClearVars(SDnode *pDnode) {
+  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+    taosMemoryFreeClear(pWrapper->path);
+    (void)taosThreadRwlockDestroy(&pWrapper->lock);
   }
-                  if (pDnode->lockfile != NULL) {
-                    if (taosUnLockFile(pDnode->lockfile) != 0) {
-                      dError("failed to unlock file");
+  if (pDnode->lockfile != NULL) {
+    if (taosUnLockFile(pDnode->lockfile) != 0) {
+      dError("failed to unlock file");
     }
 
-                    (void)taosCloseFile(&pDnode->lockfile);
-                    pDnode->lockfile = NULL;
+    (void)taosCloseFile(&pDnode->lockfile);
+    pDnode->lockfile = NULL;
   }
 
-                  SDnodeData *pData = &pDnode->data;
-                  (void)taosThreadRwlockWrlock(&pData->lock);
-                  if (pData->oldDnodeEps != NULL) {
-                    if (dmWriteEps(pData) == 0) {
-                      dmRemoveDnodePairs(pData);
+  SDnodeData *pData = &pDnode->data;
+  (void)taosThreadRwlockWrlock(&pData->lock);
+  if (pData->oldDnodeEps != NULL) {
+    if (dmWriteEps(pData) == 0) {
+      dmRemoveDnodePairs(pData);
     }
-                    taosArrayDestroy(pData->oldDnodeEps);
-                    pData->oldDnodeEps = NULL;
+    taosArrayDestroy(pData->oldDnodeEps);
+    pData->oldDnodeEps = NULL;
   }
-                  if (pData->dnodeEps != NULL) {
-                    taosArrayDestroy(pData->dnodeEps);
-                    pData->dnodeEps = NULL;
+  if (pData->dnodeEps != NULL) {
+    taosArrayDestroy(pData->dnodeEps);
+    pData->dnodeEps = NULL;
   }
-                  if (pData->dnodeHash != NULL) {
-                    taosHashCleanup(pData->dnodeHash);
-                    pData->dnodeHash = NULL;
+  if (pData->dnodeHash != NULL) {
+    taosHashCleanup(pData->dnodeHash);
+    pData->dnodeHash = NULL;
   }
-                  (void)taosThreadRwlockUnlock(&pData->lock);
+  (void)taosThreadRwlockUnlock(&pData->lock);
 
-                  (void)taosThreadRwlockDestroy(&pData->lock);
+  (void)taosThreadRwlockDestroy(&pData->lock);
 
-                  dDebug("begin to lock status info when thread exit");
-                  if (taosThreadMutexLock(&pData->statusInfolock) != 0) {
-                    dError("failed to lock status info lock");
-                    return;
+  dDebug("begin to lock status info when thread exit");
+  if (taosThreadMutexLock(&pData->statusInfolock) != 0) {
+    dError("failed to lock status info lock");
+    return;
   }
-                  if (tsVinfo.pVloads != NULL) {
-                    taosArrayDestroy(tsVinfo.pVloads);
-                    tsVinfo.pVloads = NULL;
+  if (tsVinfo.pVloads != NULL) {
+    taosArrayDestroy(tsVinfo.pVloads);
+    tsVinfo.pVloads = NULL;
   }
-                  if (taosThreadMutexUnlock(&pData->statusInfolock) != 0) {
-                    dError("failed to unlock status info lock");
-                    return;
+  if (taosThreadMutexUnlock(&pData->statusInfolock) != 0) {
+    dError("failed to unlock status info lock");
+    return;
   }
-                  if (taosThreadMutexDestroy(&pData->statusInfolock) != 0) {
-                    dError("failed to destroy status info lock");
+  if (taosThreadMutexDestroy(&pData->statusInfolock) != 0) {
+    dError("failed to destroy status info lock");
   }
-                  memset(&pData->statusInfolock, 0, sizeof(pData->statusInfolock));
+  memset(&pData->statusInfolock, 0, sizeof(pData->statusInfolock));
 
-                  (void)taosThreadMutexDestroy(&pDnode->mutex);
-                  memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
+  (void)taosThreadMutexDestroy(&pDnode->mutex);
+  memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
 }
 
 void dmSetStatus(SDnode *pDnode, EDndRunStatus status) {
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index 1eefb024a2..9ed5861d50 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -1884,7 +1884,7 @@ static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32
     if (strlen(pMCfgReq->value) != 0) goto _err;
     code = taosStr2int32(pMCfgReq->config + optLen + 1, pOutValue);
     if (code != 0) {
-      mError("dnode:%d, failed to get cfg since code: %s", pMCfgReq->dnodeId, tstrerror(code));
+      mError("dnode:%d, failed to get cfg since %s", pMCfgReq->dnodeId, tstrerror(code));
       goto _err;
     }
   } else {
@@ -1892,7 +1892,7 @@ static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32
     if (strlen(pMCfgReq->value) == 0) goto _err;
     code = taosStr2int32(pMCfgReq->value, pOutValue);
     if (code != 0) {
-      mError("dnode:%d, failed to get cfg since code: %s", pMCfgReq->dnodeId, tstrerror(code));
+      mError("dnode:%d, failed to get cfg since %s", pMCfgReq->dnodeId, tstrerror(code));
       goto _err;
     }
   }
diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c
index 5acfcf6ac1..573a4f62eb 100644
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@@ -530,7 +530,7 @@ static int32_t mndInitWal(SMnode *pMnode) {
       code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
       TAOS_RETURN(code);
     } else {
-      tstrncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
     }
   }
 #endif
diff --git a/source/libs/wal/src/walWrite.c b/source/libs/wal/src/walWrite.c
index 30ac137f66..abd11c3f65 100644
--- a/source/libs/wal/src/walWrite.c
+++ b/source/libs/wal/src/walWrite.c
@@ -638,7 +638,7 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
     opts.source = newBody;
     opts.result = newBodyEncrypted;
     opts.unitLen = 16;
-    tstrncpy((char *)opts.key, pWal->cfg.encryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy((char *)opts.key, pWal->cfg.encryptKey, ENCRYPT_KEY_LEN + 1);
 
     int32_t count = CBC_Encrypt(&opts);
 
diff --git a/source/os/src/osString.c b/source/os/src/osString.c
index fd2c44a49e..40bc464519 100644
--- a/source/os/src/osString.c
+++ b/source/os/src/osString.c
@@ -123,10 +123,8 @@ int32_t taosStr2int64(const char *str, int64_t *val) {
   errno = 0;
   char   *endptr = NULL;
   int64_t ret = strtoll(str, &endptr, 10);
-  if (errno == ERANGE && (ret == LLONG_MAX || ret == LLONG_MIN)) {
+  if (errno != 0) {
     return TAOS_SYSTEM_ERROR(errno);
-  } else if (errno == EINVAL && ret == 0) {
-    return TSDB_CODE_INVALID_PARA;
   } else {
     if (endptr == str) {
       return TSDB_CODE_INVALID_PARA;
@@ -187,12 +185,11 @@ int32_t taosStr2Uint64(const char *str, uint64_t *val) {
   char *endptr = NULL;
   errno = 0;
   uint64_t ret = strtoull(str, &endptr, 10);
-  if (errno == ERANGE && (ret == ULLONG_MAX)) {
+
+  if (errno != 0) {
     return TAOS_SYSTEM_ERROR(errno);
-  } else if (errno == EINVAL && ret == 0) {
-    return TSDB_CODE_INVALID_PARA;
   } else {
-    if (str == endptr) {
+    if (endptr == str) {
       return TSDB_CODE_INVALID_PARA;
     }
     *val = ret;
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index b3fd6455b6..4b2b4d6fec 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -283,30 +283,25 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
   tstrncpy(cfg.dir, pItem->str, sizeof(cfg.dir));
 
   code = taosStr2int32(level, &cfg.level);
-  if (code != 0) {
-    cfg.level = 0;
-  }
+  TAOS_CHECK_GOTO(code, NULL, _err);
   code = taosStr2int32(primary, &cfg.primary);
-  if (code != 0) {
-    cfg.primary = 1;
-  }
-
+  TAOS_CHECK_GOTO(code, NULL, _err);
   code = taosStr2int8(disable, &cfg.disable);
-  if (code != 0) {
-    cfg.disable = 0;
-  }
+  TAOS_CHECK_GOTO(code, NULL, _err);
 
   void *ret = taosArrayPush(pItem->array, &cfg);
   if (ret == NULL) {
-    (void)taosThreadMutexUnlock(&pCfg->lock);
-
-    TAOS_RETURN(terrno);
+    code = terrno;
+    TAOS_CHECK_GOTO(code, NULL, _err);
   }
 
   pItem->stype = stype;
   (void)taosThreadMutexUnlock(&pCfg->lock);
 
   TAOS_RETURN(TSDB_CODE_SUCCESS);
+_err:
+  (void)taosThreadMutexUnlock(&pCfg->lock);
+  TAOS_RETURN(code);
 }
 
 static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool resetArray) {

From 32b5ec1da7becfd4ca0158c7cf7d65e0b44a7e55 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Mon, 9 Dec 2024 14:35:12 +0800
Subject: [PATCH 15/25] opt code

---
 source/dnode/mgmt/mgmt_vnode/src/vmHandle.c    | 6 +++---
 source/dnode/mgmt/node_util/src/dmFile.c       | 4 ++--
 source/dnode/mnode/impl/src/mndUser.c          | 4 ++--
 source/dnode/mnode/sdb/src/sdbFile.c           | 2 +-
 source/dnode/vnode/src/tsdb/tsdbReaderWriter.c | 2 +-
 source/dnode/vnode/src/vnd/vnodeCfg.c          | 6 +++---
 source/libs/stream/src/streamBackendRocksdb.c  | 1 +
 source/libs/sync/src/syncMain.c                | 2 +-
 source/libs/tdb/src/db/tdbDb.c                 | 2 +-
 source/libs/tdb/src/db/tdbPager.c              | 4 ++--
 10 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
index 60440916d8..3b399e10d4 100644
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -186,7 +186,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 #if defined(TD_ENTERPRISE)
   pCfg->tsdbCfg.encryptAlgorithm = pCreate->encryptAlgorithm;
   if (pCfg->tsdbCfg.encryptAlgorithm == DND_CA_SM4) {
-    tstrncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
   }
 #else
   pCfg->tsdbCfg.encryptAlgorithm = 0;
@@ -202,7 +202,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 #if defined(TD_ENTERPRISE)
   pCfg->walCfg.encryptAlgorithm = pCreate->encryptAlgorithm;
   if (pCfg->walCfg.encryptAlgorithm == DND_CA_SM4) {
-    tstrncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
   }
 #else
   pCfg->walCfg.encryptAlgorithm = 0;
@@ -211,7 +211,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 #if defined(TD_ENTERPRISE)
   pCfg->tdbEncryptAlgorithm = pCreate->encryptAlgorithm;
   if (pCfg->tdbEncryptAlgorithm == DND_CA_SM4) {
-    tstrncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+    strncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
   }
 #else
   pCfg->tdbEncryptAlgorithm = 0;
diff --git a/source/dnode/mgmt/node_util/src/dmFile.c b/source/dnode/mgmt/node_util/src/dmFile.c
index 65af5481be..0b856f83c4 100644
--- a/source/dnode/mgmt/node_util/src/dmFile.c
+++ b/source/dnode/mgmt/node_util/src/dmFile.c
@@ -349,7 +349,7 @@ static int32_t dmCompareEncryptKey(char *file, char *key, bool toLogFile) {
   }
 
   SCryptOpts opts = {0};
-  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN);
+  strncpy(opts.key, key, ENCRYPT_KEY_LEN);
   opts.len = len;
   opts.source = content;
   opts.result = result;
@@ -551,7 +551,7 @@ int32_t dmGetEncryptKey() {
     goto _OVER;
   }
 
-  tstrncpy(tsEncryptKey, encryptKey, ENCRYPT_KEY_LEN);
+  strncpy(tsEncryptKey, encryptKey, ENCRYPT_KEY_LEN + 1);
   taosMemoryFreeClear(encryptKey);
   tsEncryptionKeyChksum = taosCalcChecksum(0, tsEncryptKey, strlen(tsEncryptKey));
   tsEncryptionKeyStat = ENCRYPT_KEY_STAT_LOADED;
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index c1a240c3f4..0be302a383 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -1706,8 +1706,8 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate
   if (pCreate->isImport != 1) {
     taosEncryptPass_c((uint8_t *)pCreate->pass, strlen(pCreate->pass), userObj.pass);
   } else {
-    // mInfo("pCreate->pass:%s", pCreate->pass)
-    tstrncpy(userObj.pass, pCreate->pass, TSDB_PASSWORD_LEN);
+    // mInfo("pCreate->pass:%s", pCreate->eass)
+    memcpy(userObj.pass, pCreate->pass, TSDB_PASSWORD_LEN);
   }
   tstrncpy(userObj.user, pCreate->user, TSDB_USER_LEN);
   tstrncpy(userObj.acct, acct, TSDB_USER_LEN);
diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c
index bd4be7431f..eaf49c2926 100644
--- a/source/dnode/mnode/sdb/src/sdbFile.c
+++ b/source/dnode/mnode/sdb/src/sdbFile.c
@@ -370,7 +370,7 @@ static int32_t sdbReadFileImp(SSdb *pSdb) {
       opts.source = pRaw->pData;
       opts.result = plantContent;
       opts.unitLen = 16;
-      tstrncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
 
       count = CBC_Decrypt(&opts);
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
index af5e45c279..c9925be061 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -175,7 +175,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e
         opts.result = PacketData;
         opts.unitLen = 128;
         // strncpy(opts.key, tsEncryptKey, 16);
-        tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+        tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN + 1);
 
         NewLen = CBC_Encrypt(&opts);
 
diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c
index 791c2bae80..2ceeeca160 100644
--- a/source/dnode/vnode/src/vnd/vnodeCfg.c
+++ b/source/dnode/vnode/src/vnd/vnodeCfg.c
@@ -265,7 +265,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
     if (tsEncryptKey[0] == 0) {
       return terrno = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
     } else {
-      tstrncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(pCfg->tsdbCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
     }
   }
 #endif
@@ -292,7 +292,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
     if (tsEncryptKey[0] == 0) {
       return terrno = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
     } else {
-      tstrncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(pCfg->walCfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
     }
   }
 #endif
@@ -303,7 +303,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
     if (tsEncryptKey[0] == 0) {
       return terrno = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
     } else {
-      tstrncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
+      strncpy(pCfg->tdbEncryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
     }
   }
 #endif
diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 11d2385d1c..edf6e7ce96 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -1199,6 +1199,7 @@ int32_t taskDbLoadChkpInfo(STaskDbWrapper* pBackend) {
 
   nBytes = snprintf(pChkpDir, cap, "%s%s%s", pBackend->path, TD_DIRSEP, "checkpoints");
   if (nBytes >= cap) {
+    taosMemoryFree(pChkpDir);
     return TSDB_CODE_OUT_OF_RANGE;
   }
   if (!taosIsDir(pChkpDir)) {
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index 6dce0cf481..9a03128f01 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -691,7 +691,7 @@ int32_t syncGetArbToken(int64_t rid, char* outToken) {
 
   memset(outToken, 0, TSDB_ARB_TOKEN_SIZE);
   (void)taosThreadMutexLock(&pSyncNode->arbTokenMutex);
-  tstrncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE);
+  strncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE);
   (void)taosThreadMutexUnlock(&pSyncNode->arbTokenMutex);
 
   syncNodeRelease(pSyncNode);
diff --git a/source/libs/tdb/src/db/tdbDb.c b/source/libs/tdb/src/db/tdbDb.c
index 1431533a30..aeec8f93f0 100644
--- a/source/libs/tdb/src/db/tdbDb.c
+++ b/source/libs/tdb/src/db/tdbDb.c
@@ -52,7 +52,7 @@ int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, i
 
   pDb->encryptAlgorithm = encryptAlgorithm;
   if (encryptKey != NULL) {
-    tstrncpy(pDb->encryptKey, encryptKey, ENCRYPT_KEY_LEN);
+    tstrncpy(pDb->encryptKey, encryptKey, ENCRYPT_KEY_LEN + 1);
   }
 
   ret = tdbPCacheOpen(szPage, pages, &(pDb->pCache));
diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c
index 9a2cd8e8de..c2f97982f5 100644
--- a/source/libs/tdb/src/db/tdbPager.c
+++ b/source/libs/tdb/src/db/tdbPager.c
@@ -459,7 +459,7 @@ static char *tdbEncryptPage(SPager *pPager, char *pPageData, int32_t pageSize, c
       opts.source = pPageData + count;
       opts.result = packetData;
       opts.unitLen = 128;
-      tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN + 1);
 
       int32_t newLen = CBC_Encrypt(&opts);
 
@@ -927,7 +927,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage
           opts.source = pPage->pData + count;
           opts.result = packetData;
           opts.unitLen = 128;
-          tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+          tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN + 1);
 
           int newLen = CBC_Decrypt(&opts);
 

From abc4a3768ff8b5df6b5a071e3251fd918dd51174 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Mon, 9 Dec 2024 14:48:21 +0800
Subject: [PATCH 16/25] opt code

---
 source/dnode/mgmt/exe/dmMain.c                 | 2 +-
 source/dnode/mgmt/node_util/src/dmFile.c       | 4 ++--
 source/dnode/mnode/sdb/src/sdbFile.c           | 2 +-
 source/dnode/vnode/src/tsdb/tsdbReaderWriter.c | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/source/dnode/mgmt/exe/dmMain.c b/source/dnode/mgmt/exe/dmMain.c
index ade5e16894..a30a79fa73 100644
--- a/source/dnode/mgmt/exe/dmMain.c
+++ b/source/dnode/mgmt/exe/dmMain.c
@@ -251,7 +251,7 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
           printf("ERROR: Encrypt key overflow, it should be at most %d characters\n", ENCRYPT_KEY_LEN);
           return TSDB_CODE_INVALID_CFG;
         }
-        tstrncpy(global.encryptKey, argv[i], ENCRYPT_KEY_LEN);
+        tstrncpy(global.encryptKey, argv[i], ENCRYPT_KEY_LEN + 1);
       } else {
         printf("'-y' requires a parameter\n");
         return TSDB_CODE_INVALID_CFG;
diff --git a/source/dnode/mgmt/node_util/src/dmFile.c b/source/dnode/mgmt/node_util/src/dmFile.c
index 0b856f83c4..26f45d2fb8 100644
--- a/source/dnode/mgmt/node_util/src/dmFile.c
+++ b/source/dnode/mgmt/node_util/src/dmFile.c
@@ -230,7 +230,7 @@ static int32_t dmWriteCheckCodeFile(char *file, char *realfile, char *key, bool
   }
 
   SCryptOpts opts;
-  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN);
+  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN + 1);
   opts.len = len;
   opts.source = DM_KEY_INDICATOR;
   opts.result = result;
@@ -349,7 +349,7 @@ static int32_t dmCompareEncryptKey(char *file, char *key, bool toLogFile) {
   }
 
   SCryptOpts opts = {0};
-  strncpy(opts.key, key, ENCRYPT_KEY_LEN);
+  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN + 1);
   opts.len = len;
   opts.source = content;
   opts.result = result;
diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c
index eaf49c2926..948aa870bd 100644
--- a/source/dnode/mnode/sdb/src/sdbFile.c
+++ b/source/dnode/mnode/sdb/src/sdbFile.c
@@ -510,7 +510,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb, int32_t skip_type) {
           opts.source = pRaw->pData;
           opts.result = newData;
           opts.unitLen = 16;
-          tstrncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN);
+          tstrncpy(opts.key, tsEncryptKey, ENCRYPT_KEY_LEN + 1);
 
           int32_t count = CBC_Encrypt(&opts);
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
index c9925be061..6dba1825ad 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -249,7 +249,7 @@ static int32_t tsdbReadFilePage(STsdbFD *pFD, int64_t pgno, int32_t encryptAlgor
       opts.result = PacketData;
       opts.unitLen = 128;
       // strncpy(opts.key, tsEncryptKey, 16);
-      tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+      tstrncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN + 1);
 
       NewLen = CBC_Decrypt(&opts);
 

From a5e3f54ca24e4dcce5666fb9bde506cb4e56869f Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Mon, 9 Dec 2024 15:44:57 +0800
Subject: [PATCH 17/25] remove invalid ptr

---
 source/dnode/mgmt/mgmt_dnode/src/dmHandle.c | 2 +-
 source/dnode/mnode/impl/src/mndMain.c       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
index 78cc35a62c..82f29ac40b 100644
--- a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
+++ b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
@@ -114,7 +114,7 @@ static void dmMayShouldUpdateAnalFunc(SDnodeMgmt *pMgmt, int64_t newVer) {
       .pCont = pHead,
       .contLen = contLen,
       .msgType = TDMT_MND_RETRIEVE_ANAL_ALGO,
-      .info.ahandle = (void *)0x9527,
+      .info.ahandle = 0,
       .info.refId = 0,
       .info.noResp = 0,
       .info.handle = 0,
diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c
index 573a4f62eb..83e8abf05e 100644
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@@ -254,7 +254,7 @@ static void mndIncreaseUpTime(SMnode *pMnode) {
                       .pCont = pReq,
                       .contLen = contLen,
                       .info.notFreeAhandle = 1,
-                      .info.ahandle = (void *)0x9527};
+                      .info.ahandle = 0};
     // TODO check return value
     if (tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg) < 0) {
       mError("failed to put into write-queue since %s, line:%d", terrstr(), __LINE__);

From 91d0fe5c8bafb4c7b263e5040608bf86284203bb Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Mon, 9 Dec 2024 19:11:48 +0800
Subject: [PATCH 18/25] fix deadlock

---
 source/libs/stream/src/streamBackendRocksdb.c |  5 +++-
 source/libs/stream/src/streamMeta.c           | 28 +++++++++----------
 2 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index edf6e7ce96..f56a3c4852 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -1199,7 +1199,6 @@ int32_t taskDbLoadChkpInfo(STaskDbWrapper* pBackend) {
 
   nBytes = snprintf(pChkpDir, cap, "%s%s%s", pBackend->path, TD_DIRSEP, "checkpoints");
   if (nBytes >= cap) {
-    taosMemoryFree(pChkpDir);
     return TSDB_CODE_OUT_OF_RANGE;
   }
   if (!taosIsDir(pChkpDir)) {
@@ -4294,9 +4293,13 @@ void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t gr
   }
 }
 
+<<<<<<< HEAD
 int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal,
                                             int32_t* pVLen) {
   stDebug("streamStateFillGetKVByCur_rocksdb");
+=======
+int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal, int32_t* pVLen) {
+>>>>>>> origin/main
   if (!pCur) {
     return -1;
   }
diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c
index 23a98ef3ae..8e8e300ee6 100644
--- a/source/libs/stream/src/streamMeta.c
+++ b/source/libs/stream/src/streamMeta.c
@@ -99,7 +99,7 @@ int32_t metaRefMgtInit() {
 void metaRefMgtCleanup() {
   void* pIter = taosHashIterate(gMetaRefMgt.pTable, NULL);
   while (pIter) {
-    int64_t* p = *(int64_t**) pIter;
+    int64_t* p = *(int64_t**)pIter;
     taosMemoryFree(p);
     pIter = taosHashIterate(gMetaRefMgt.pTable, pIter);
   }
@@ -118,14 +118,14 @@ int32_t metaRefMgtAdd(int64_t vgId, int64_t* rid) {
   if (p == NULL) {
     code = taosHashPut(gMetaRefMgt.pTable, &rid, sizeof(rid), &rid, sizeof(void*));
     if (code) {
-      stError("vgId:%d failed to put into refId mgt, refId:%" PRId64" %p, code:%s", (int32_t)vgId, *rid, rid,
+      stError("vgId:%d failed to put into refId mgt, refId:%" PRId64 " %p, code:%s", (int32_t)vgId, *rid, rid,
               tstrerror(code));
       return code;
-    } else { // not
-//      stInfo("add refId:%"PRId64" vgId:%d, %p", *rid, (int32_t)vgId, rid);
+    } else {  // not
+              //      stInfo("add refId:%"PRId64" vgId:%d, %p", *rid, (int32_t)vgId, rid);
     }
   } else {
-    stFatal("try to add refId:%"PRId64" vgId:%d, %p that already added into mgt", *rid, (int32_t) vgId, rid);
+    stFatal("try to add refId:%" PRId64 " vgId:%d, %p that already added into mgt", *rid, (int32_t)vgId, rid);
   }
 
   streamMutexUnlock(&gMetaRefMgt.mutex);
@@ -292,6 +292,7 @@ int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key)
     void* p = taskDbAddRef(*ppBackend);
     if (p == NULL) {
       stError("s-task:0x%x failed to ref backend", pTask->id.taskId);
+      streamMutexUnlock(&pMeta->backendMutex);
       return TSDB_CODE_FAILED;
     }
 
@@ -669,7 +670,7 @@ int32_t streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask) {
     int64_t refId = pTask->id.refId;
     int32_t ret = taosRemoveRef(streamTaskRefPool, pTask->id.refId);
     if (ret != 0) {
-      stError("s-task:0x%x failed to remove ref, refId:%"PRId64, (int32_t) id[1], refId);
+      stError("s-task:0x%x failed to remove ref, refId:%" PRId64, (int32_t)id[1], refId);
     }
   } else {
     stDebug("s-task:%s vgId:%d refId:%" PRId64 " task meta save to disk", pTask->id.idStr, vgId, pTask->id.refId);
@@ -727,14 +728,14 @@ int32_t streamMetaRegisterTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTa
 
     int32_t ret = taosRemoveRef(streamTaskRefPool, refId);
     if (ret != 0) {
-      stError("s-task:0x%x failed to remove ref, refId:%"PRId64, (int32_t) id.taskId, refId);
+      stError("s-task:0x%x failed to remove ref, refId:%" PRId64, (int32_t)id.taskId, refId);
     }
     return code;
   }
 
   if ((code = streamMetaSaveTask(pMeta, pTask)) != 0) {
     int32_t unused = taosHashRemove(pMeta->pTasksMap, &id, sizeof(id));
-    void* pUnused = taosArrayPop(pMeta->pTaskList);
+    void*   pUnused = taosArrayPop(pMeta->pTaskList);
 
     int32_t ret = taosRemoveRef(streamTaskRefPool, refId);
     if (ret) {
@@ -745,7 +746,7 @@ int32_t streamMetaRegisterTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTa
 
   if ((code = streamMetaCommit(pMeta)) != 0) {
     int32_t unused = taosHashRemove(pMeta->pTasksMap, &id, sizeof(id));
-    void* pUnused = taosArrayPop(pMeta->pTaskList);
+    void*   pUnused = taosArrayPop(pMeta->pTaskList);
 
     int32_t ret = taosRemoveRef(streamTaskRefPool, refId);
     if (ret) {
@@ -783,7 +784,7 @@ int32_t streamMetaAcquireTaskNoLock(SStreamMeta* pMeta, int64_t streamId, int32_
 
   SStreamTask* p = taosAcquireRef(streamTaskRefPool, *pTaskRefId);
   if (p == NULL) {
-    stDebug("s-task:%x failed to acquire task refId:%"PRId64", may have been destoried", taskId, *pTaskRefId);
+    stDebug("s-task:%x failed to acquire task refId:%" PRId64 ", may have been destoried", taskId, *pTaskRefId);
     return TSDB_CODE_STREAM_TASK_NOT_EXIST;
   }
 
@@ -946,11 +947,10 @@ int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t t
       pTask->info.delaySchedParam = 0;
     }
 
-
     int64_t refId = pTask->id.refId;
     int32_t ret = taosRemoveRef(streamTaskRefPool, refId);
     if (ret != 0) {
-      stError("s-task:0x%x failed to remove ref, refId:%"PRId64, (int32_t) id.taskId, refId);
+      stError("s-task:0x%x failed to remove ref, refId:%" PRId64, (int32_t)id.taskId, refId);
     }
 
     streamMetaReleaseTask(pMeta, pTask);
@@ -1115,7 +1115,7 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) {
       STaskId id = streamTaskGetTaskId(pTask);
 
       tFreeStreamTask(pTask);
-      void*   px = taosArrayPush(pRecycleList, &id);
+      void* px = taosArrayPush(pRecycleList, &id);
       if (px == NULL) {
         stError("s-task:0x%x failed record the task into recycle list due to out of memory", taskId);
       }
@@ -1165,7 +1165,7 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) {
       continue;
     }
 
-    stInfo("s-task:0x%x vgId:%d set refId:%"PRId64, (int32_t) id.taskId, vgId, pTask->id.refId);
+    stInfo("s-task:0x%x vgId:%d set refId:%" PRId64, (int32_t)id.taskId, vgId, pTask->id.refId);
     if (pTask->info.fillHistory == 0) {
       int32_t val = atomic_add_fetch_32(&pMeta->numOfStreamTasks, 1);
     }

From 0617120f8bc3c5b3f22dc3a0eb70966aea4402cc Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Mon, 9 Dec 2024 19:13:01 +0800
Subject: [PATCH 19/25] fix deadlock

---
 source/libs/stream/src/streamBackendRocksdb.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index f56a3c4852..11d2385d1c 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -4293,13 +4293,9 @@ void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t gr
   }
 }
 
-<<<<<<< HEAD
 int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal,
                                             int32_t* pVLen) {
   stDebug("streamStateFillGetKVByCur_rocksdb");
-=======
-int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal, int32_t* pVLen) {
->>>>>>> origin/main
   if (!pCur) {
     return -1;
   }

From 811f27d39f0aedef3e8c92a2dcad9e76511c7101 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Tue, 10 Dec 2024 09:58:45 +0800
Subject: [PATCH 20/25] opt code

---
 source/util/src/tconfig.c | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 4b2b4d6fec..18c2d0a500 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -282,13 +282,26 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
   SDiskCfg cfg = {0};
   tstrncpy(cfg.dir, pItem->str, sizeof(cfg.dir));
 
-  code = taosStr2int32(level, &cfg.level);
-  TAOS_CHECK_GOTO(code, NULL, _err);
-  code = taosStr2int32(primary, &cfg.primary);
-  TAOS_CHECK_GOTO(code, NULL, _err);
-  code = taosStr2int8(disable, &cfg.disable);
-  TAOS_CHECK_GOTO(code, NULL, _err);
+  if (level == NULL || strlen(level) == 0) {
+    cfg.level = 0;
+  } else {
+    code = taosStr2int32(level, &cfg.level);
+    TAOS_CHECK_GOTO(code, NULL, _err);
+  }
 
+  if (primary == NULL || strlen(primary) == 0) {
+    cfg.primary = 1;
+  } else {
+    code = taosStr2int32(primary, &cfg.primary);
+    TAOS_CHECK_GOTO(code, NULL, _err);
+  }
+
+  if (disable == NULL || strlen(disable) == 0) {
+    cfg.disable = 0;
+  } else {
+    code = taosStr2int8(disable, &cfg.disable);
+    TAOS_CHECK_GOTO(code, NULL, _err);
+  }
   void *ret = taosArrayPush(pItem->array, &cfg);
   if (ret == NULL) {
     code = terrno;

From 3884fcdf34653b96c92268150d4dd38e96a8693c Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Tue, 10 Dec 2024 18:00:49 +0800
Subject: [PATCH 21/25] fix test case

---
 source/os/test/osStringTests.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index dcb17990e7..8a2dff4d46 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -163,14 +163,15 @@ TEST(osStringTests, osStr2Int64) {
     assert(result == TSDB_CODE_INVALID_PARA);
 
     result = taosStr2int64("123", NULL);
-    assert(result == TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);     
 
     // 测试无效输入
     result = taosStr2int64("abc", &val);
-    assert(result == TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);     
 
     result = taosStr2int64("", &val);
-    assert(result == TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);     
+
    char large_num[50];
     snprintf(large_num, sizeof(large_num), "%lld", LLONG_MAX);
     result = taosStr2int64(large_num, &val);
@@ -187,7 +188,7 @@ TEST(osStringTests, osStr2Int64) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2int64("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);     
     // 测试有效的整数字符串
     result = taosStr2int64("12345", &val);
     assert(result == 0);
@@ -223,10 +224,10 @@ TEST(osStringTests, osStr2int32) {
 
     // 测试无效输入
     result = taosStr2int32("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2int32("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试超出范围的值
     char large_num[50];
@@ -293,10 +294,10 @@ TEST(osStringTests, taosStr2int16) {
 
     // 测试无效输入
     result = taosStr2int16("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2int16("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试超出范围的值
     char large_num[50];
@@ -362,10 +363,10 @@ TEST(osStringTests, taosStr2int8) {
 
     // 测试无效输入
     result = taosStr2int8("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2int8("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试超出范围的值
     char large_num[50];

From 465125e3b95c2e1bac4bbc0645b05ab3b00043c3 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Tue, 10 Dec 2024 18:07:36 +0800
Subject: [PATCH 22/25] fix test case

---
 source/os/test/osStringTests.cpp | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index 8a2dff4d46..4938594e70 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -220,7 +220,7 @@ TEST(osStringTests, osStr2int32) {
     ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
 
     result = taosStr2int32("123", NULL);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, TSDB_CODE_INVALID_PARA);
 
     // 测试无效输入
     result = taosStr2int32("abc", &val);
@@ -256,7 +256,7 @@ TEST(osStringTests, osStr2int32) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2int32("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试有效的整数字符串
     result = taosStr2int32("12345", &val);
@@ -325,7 +325,7 @@ TEST(osStringTests, taosStr2int16) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2int16("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
     // 测试有效的整数字符串
     result = taosStr2int16("12345", &val);
     ASSERT_EQ(result, 0);
@@ -394,7 +394,7 @@ TEST(osStringTests, taosStr2int8) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2int8("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
     
     // 测试有效的整数字符串
     result = taosStr2int8("123", &val);
@@ -432,10 +432,10 @@ TEST(osStringTests, osStr2Uint64) {
 
     // 测试无效输入
     result = taosStr2Uint64("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2Uint64("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     char large_num[50];
     snprintf(large_num, sizeof(large_num), "%llu", ULLONG_MAX);
@@ -448,7 +448,7 @@ TEST(osStringTests, osStr2Uint64) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2Uint64("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
     // 测试有效的整数字符串
     result = taosStr2Uint64("12345", &val);
     ASSERT_EQ(result, 0);
@@ -482,10 +482,10 @@ TEST(osStringTests, taosStr2Uint32) {
 
     // 测试无效输入
     result = taosStr2Uint32("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2Uint32("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试超出范围的值
     char large_num[50];
@@ -537,10 +537,10 @@ TEST(osStringTests, taosStr2Uint16) {
 
     // 测试无效输入
     result = taosStr2Uint16("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2Uint16("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试超出范围的值
     char large_num[50];
@@ -592,10 +592,10 @@ TEST(osStringTests, taosStr2Uint8) {
 
     // 测试无效输入
     result = taosStr2Uint8("abc", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     result = taosStr2Uint8("", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
 
     // 测试超出范围的值
     char large_num[50];
@@ -614,7 +614,7 @@ TEST(osStringTests, taosStr2Uint8) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2Uint8("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
     // 测试有效的整数字符串
     result = taosStr2Uint8("123", &val);
     ASSERT_EQ(result, 0);

From becadebea1ec5ba4d68bd769ef1212aa7f21362a Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Tue, 10 Dec 2024 18:09:21 +0800
Subject: [PATCH 23/25] fix test case

---
 source/os/test/osStringTests.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index 4938594e70..454986c60b 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -559,7 +559,7 @@ TEST(osStringTests, taosStr2Uint16) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2Uint16("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
     // 测试有效的整数字符串
     result = taosStr2Uint16("12345", &val);
     ASSERT_EQ(result, 0);

From 7710e739769f37773c532ab970a691d2e9e35724 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Tue, 10 Dec 2024 18:11:01 +0800
Subject: [PATCH 24/25] fix test case

---
 source/os/test/osStringTests.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index 454986c60b..949094d2ba 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -504,7 +504,7 @@ TEST(osStringTests, taosStr2Uint32) {
     ASSERT_EQ(val, 123);
 
     result = taosStr2Uint32("abc123", &val);
-    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_NE(result, 0);
     // 测试有效的整数字符串
     result = taosStr2Uint32("12345", &val);
     ASSERT_EQ(result, 0);

From 4145db25e8ece11d77ee858bd1bd0f00bd329025 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Tue, 10 Dec 2024 18:53:42 +0800
Subject: [PATCH 25/25] fix test case

---
 source/os/test/osStringTests.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/os/test/osStringTests.cpp b/source/os/test/osStringTests.cpp
index 949094d2ba..36f5207346 100644
--- a/source/os/test/osStringTests.cpp
+++ b/source/os/test/osStringTests.cpp
@@ -220,7 +220,7 @@ TEST(osStringTests, osStr2int32) {
     ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
 
     result = taosStr2int32("123", NULL);
-    ASSERT_NE(result, TSDB_CODE_INVALID_PARA);
+    ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
 
     // 测试无效输入
     result = taosStr2int32("abc", &val);