TD-2837

CMakeLists.txt

@@ -13,7 +13,7 @@ ENDIF ()
 SET(TD_ACCOUNT FALSE)
 SET(TD_ADMIN FALSE)
 SET(TD_GRANT FALSE)
-SET(TD_MQTT TRUE)
+SET(TD_MQTT FALSE)
 SET(TD_TSDB_PLUGINS FALSE)
 
 SET(TD_COVER FALSE)
@@ -29,6 +29,11 @@ MESSAGE(STATUS "Community directory: " ${TD_COMMUNITY_DIR})
 
 INCLUDE(cmake/input.inc)
 INCLUDE(cmake/platform.inc)
+
+IF (TD_WINDOWS) 
+  SET(TD_SOMODE_STATIC TRUE)
+ENDIF ()
+
 INCLUDE(cmake/define.inc)
 INCLUDE(cmake/env.inc)
 INCLUDE(cmake/version.inc)

cmake/define.inc

@@ -141,6 +141,9 @@ IF (TD_WINDOWS)
   SET(CMAKE_GENERATOR "NMake Makefiles" CACHE INTERNAL "" FORCE)
   IF (NOT TD_GODLL)
     SET(COMMON_FLAGS "/nologo /WX /wd4018 /wd2220 /Oi /Oy- /Gm- /EHsc /MT /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Gd /errorReport:prompt /analyze-")
+    IF (MSVC AND (MSVC_VERSION GREATER_EQUAL 1900))
+      SET(COMMON_FLAGS "${COMMON_FLAGS} /Wv:18")
+    ENDIF ()
     SET(DEBUG_FLAGS "/Zi /W3 /GL")
     SET(RELEASE_FLAGS "/W0 /O3 /GL")
   ENDIF ()

deps/zlib-1.2.11/src/gzlib.c

@@ -5,6 +5,10 @@
 #include <stdint.h>
 #include "gzguts.h"
 
+#ifndef O_BINARY
+  #define O_BINARY 0
+#endif
+
 #if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
 #  define LSEEK _lseeki64
 #else
@@ -240,9 +244,9 @@ local gzFile gz_open(path, fd, mode)
     /* open the file with the appropriate flags (or just use fd) */
     state->fd = fd > -1 ? fd : (
 #ifdef WIDECHAR
-        fd == -2 ? _wopen(path, oflag, 0666) :
+        fd == -2 ? _wopen(path, oflag | O_BINARY, 0666) :
 #endif
-        open((const char *)path, oflag, 0666));
+        open((const char *)path, oflag | O_BINARY, 0666));
     if (state->fd == -1) {
         free(state->path);
         free(state);

src/balance/CMakeLists.txt

@@ -8,7 +8,7 @@ INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 
-IF (TD_LINUX)
+IF (TD_LINUX OR TD_WINDOWS)
   ADD_LIBRARY(balance ${SRC})
 ENDIF ()
 

src/balance/inc/bnThread.h

@@ -24,7 +24,7 @@ extern "C" {
 int32_t bnInitThread();
 void    bnCleanupThread();
 void    bnNotify();
-void    bnStartTimer(int64_t mseconds);
+void    bnStartTimer(int32_t mseconds);
 
 #ifdef __cplusplus
 }

src/balance/src/bnMain.c

@@ -30,7 +30,7 @@
 #include "mnodeVgroup.h"
 
 extern int64_t tsDnodeRid;
-extern int64_t tsSdbRid;
+extern int32_t tsSdbRid;
 static SBnMgmt tsBnMgmt;
 static void  bnMonitorDnodeModule();
 

src/balance/src/bnScore.c

@@ -271,23 +271,23 @@ static int32_t bnRetrieveScores(SShowObj *pShow, char *data, int32_t rows, void
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = systemScore;
+    *(float *)pWrite = (float)systemScore;
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = pDnode->customScore;
+    *(float *)pWrite = (float)pDnode->customScore;
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = (int32_t)moduleScore;
+    *(float *)pWrite = (float)moduleScore;
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = (int32_t)vnodeScore;
+    *(float *)pWrite = (float)vnodeScore;
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = (int32_t)(vnodeScore + moduleScore + pDnode->customScore + systemScore);
+    *(float *)pWrite = (float)(vnodeScore + moduleScore + pDnode->customScore + systemScore);
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;

src/balance/src/bnThread.c

@@ -119,13 +119,13 @@ static void bnProcessTimer(void *handle, void *tmrId) {
   }
 }
 
-void bnStartTimer(int64_t mseconds) {
+void bnStartTimer(int32_t mseconds) {
   if (tsBnThread.stop) return;
 
   bool updateSoon = (mseconds != -1);
   if (updateSoon) {
-    mTrace("balance function will be called after %" PRId64 " ms", mseconds);
-    taosTmrReset(bnProcessTimer, mseconds, (void *)mseconds, tsMnodeTmr, &tsBnThread.timer);
+    mTrace("balance function will be called after %d ms", mseconds);
+    taosTmrReset(bnProcessTimer, mseconds, (void *)(int64_t)mseconds, tsMnodeTmr, &tsBnThread.timer);
   } else {
     taosTmrReset(bnProcessTimer, tsStatusInterval * 1000, NULL, tsMnodeTmr, &tsBnThread.timer);
   }

src/client/src/tscParseInsert.c

@@ -1548,7 +1548,7 @@ void tscImportDataFromFile(SSqlObj *pSql) {
   SSqlObj *pNew = createSubqueryObj(pSql, 0, parseFileSendDataBlock, pSupporter, TSDB_SQL_INSERT, NULL);
   pCmd->count = 1;
 
-  FILE *fp = fopen(pCmd->payload, "r");
+  FILE *fp = fopen(pCmd->payload, "rb");
   if (fp == NULL) {
     pSql->res.code = TAOS_SYSTEM_ERROR(errno);
     tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));

src/client/src/tscSub.c

@@ -313,7 +313,7 @@ static int tscLoadSubscriptionProgress(SSub* pSub) {
   char buf[TSDB_MAX_SQL_LEN];
   sprintf(buf, "%s/subscribe/%s", tsDataDir, pSub->topic);
 
-  FILE* fp = fopen(buf, "r");
+  FILE* fp = fopen(buf, "rb");
   if (fp == NULL) {
     tscDebug("subscription progress file does not exist: %s", pSub->topic);
     return 1;
@@ -368,7 +368,7 @@ void tscSaveSubscriptionProgress(void* sub) {
   }
 
   sprintf(path, "%s/subscribe/%s", tsDataDir, pSub->topic);
-  FILE* fp = fopen(path, "w+");
+  FILE* fp = fopen(path, "wb+");
   if (fp == NULL) {
     tscError("failed to create progress file for subscription: %s", pSub->topic);
     return;

src/client/src/tscSubquery.c

@@ -1018,7 +1018,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
 
   if (numOfRows > 0) {  // write the compressed timestamp to disk file
     if(pSupporter->f == NULL) {
-      pSupporter->f = fopen(pSupporter->path, "w");
+      pSupporter->f = fopen(pSupporter->path, "wb");
 
       if (pSupporter->f == NULL) {
         tscError("%p failed to create tmp file:%s, reason:%s", pSql, pSupporter->path, strerror(errno));
@@ -1066,7 +1066,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     // continue to retrieve ts-comp data from vnode
     if (!pRes->completed) {
       taosGetTmpfilePath("ts-join", pSupporter->path);
-      pSupporter->f = fopen(pSupporter->path, "w");
+      pSupporter->f = fopen(pSupporter->path, "wb");
       pRes->row = pRes->numOfRows;
 
       taos_fetch_rows_a(tres, tsCompRetrieveCallback, param);
@@ -1092,7 +1092,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     taosGetTmpfilePath("ts-join", pSupporter->path);
     
     // TODO check for failure
-    pSupporter->f = fopen(pSupporter->path, "w");
+    pSupporter->f = fopen(pSupporter->path, "wb");
     pRes->row = pRes->numOfRows;
 
     // set the callback function

src/common/inc/tdataformat.h

@@ -27,23 +27,23 @@
 extern "C" {
 #endif
 
-#define STR_TO_VARSTR(x, str)             \
-  do {                                    \
-    VarDataLenT __len = strlen(str);      \
-    *(VarDataLenT *)(x) = __len;          \
-    memcpy(varDataVal(x), (str), __len); \
+#define STR_TO_VARSTR(x, str)                     \
+  do {                                            \
+    VarDataLenT __len = (VarDataLenT)strlen(str); \
+    *(VarDataLenT *)(x) = __len;                  \
+    memcpy(varDataVal(x), (str), __len);          \
   } while (0);
 
-#define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs)      \
-  do {                                                 \
+#define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs)                         \
+  do {                                                                    \
     char *_e = stpncpy(varDataVal(x), (str), (_maxs)-VARSTR_HEADER_SIZE); \
-    varDataSetLen(x, (_e - (x)-VARSTR_HEADER_SIZE));   \
+    varDataSetLen(x, (_e - (x)-VARSTR_HEADER_SIZE));                      \
   } while (0)
 
-#define STR_WITH_SIZE_TO_VARSTR(x, str, _size) \
-  do {                                         \
-    *(VarDataLenT *)(x) = (_size);             \
-    memcpy(varDataVal(x), (str), (_size));    \
+#define STR_WITH_SIZE_TO_VARSTR(x, str, _size)  \
+  do {                                          \
+    *(VarDataLenT *)(x) = (VarDataLenT)(_size); \
+    memcpy(varDataVal(x), (str), (_size));      \
   } while (0);
 
 // ----------------- TSDB COLUMN DEFINITION
@@ -156,7 +156,7 @@ static FORCE_INLINE int tkeyComparFn(const void *tkey1, const void *tkey2) {
  * +----------+----------+---------------------------------+---------------------------------+
  * |   len    | sversion |           First part            |             Second part         |
  * +----------+----------+---------------------------------+---------------------------------+
- * 
+ *
  * NOTE: timestamp in this row structure is TKEY instead of TSKEY
  */
 typedef void *SDataRow;

src/common/inc/tglobal.h

@@ -88,8 +88,8 @@ extern int32_t tsMinRowsInFileBlock;
 extern int32_t tsMaxRowsInFileBlock;
 extern int16_t tsCommitTime;  // seconds
 extern int32_t tsTimePrecision;
-extern int16_t tsCompression;
-extern int16_t tsWAL;
+extern int8_t  tsCompression;
+extern int8_t  tsWAL;
 extern int32_t tsFsyncPeriod;
 extern int32_t tsReplications;
 extern int32_t tsQuorum;

src/common/src/tglobal.c

@@ -121,8 +121,8 @@ int32_t tsMinRowsInFileBlock = TSDB_DEFAULT_MIN_ROW_FBLOCK;
 int32_t tsMaxRowsInFileBlock = TSDB_DEFAULT_MAX_ROW_FBLOCK;
 int16_t tsCommitTime    = TSDB_DEFAULT_COMMIT_TIME;  // seconds
 int32_t tsTimePrecision = TSDB_DEFAULT_PRECISION;
-int16_t tsCompression   = TSDB_DEFAULT_COMP_LEVEL;
-int16_t tsWAL           = TSDB_DEFAULT_WAL_LEVEL;
+int8_t  tsCompression   = TSDB_DEFAULT_COMP_LEVEL;
+int8_t  tsWAL           = TSDB_DEFAULT_WAL_LEVEL;
 int32_t tsFsyncPeriod   = TSDB_DEFAULT_FSYNC_PERIOD;
 int32_t tsReplications  = TSDB_DEFAULT_DB_REPLICA_OPTION;
 int32_t tsQuorum        = TSDB_DEFAULT_DB_QUORUM_OPTION;
@@ -758,7 +758,7 @@ static void doInitGlobalConfig(void) {
 
   cfg.option = "comp";
   cfg.ptr = &tsCompression;
-  cfg.valType = TAOS_CFG_VTYPE_INT16;
+  cfg.valType = TAOS_CFG_VTYPE_INT8;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = TSDB_MIN_COMP_LEVEL;
   cfg.maxValue = TSDB_MAX_COMP_LEVEL;
@@ -768,7 +768,7 @@ static void doInitGlobalConfig(void) {
 
   cfg.option = "walLevel";
   cfg.ptr = &tsWAL;
-  cfg.valType = TAOS_CFG_VTYPE_INT16;
+  cfg.valType = TAOS_CFG_VTYPE_INT8;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = TSDB_MIN_WAL_LEVEL;
   cfg.maxValue = TSDB_MAX_WAL_LEVEL;

src/cq/CMakeLists.txt

@@ -6,7 +6,7 @@ INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRC)
 
-IF (TD_LINUX)
+IF (TD_LINUX OR TD_WINDOWS)
   ADD_LIBRARY(tcq ${SRC})
   IF (TD_SOMODE_STATIC)
     TARGET_LINK_LIBRARIES(tcq tutil common taos_static)

src/cq/src/cqMain.c

@@ -343,7 +343,7 @@ static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row) {
       char buf[TSDB_MAX_NCHAR_LEN];
       int32_t len = taos_fetch_lengths(tres)[i];
       taosMbsToUcs4(val, len, buf, sizeof(buf), &len);
-      memcpy(val + sizeof(VarDataLenT), buf, len);
+      memcpy((char *)val + sizeof(VarDataLenT), buf, len);
       varDataLen(val) = len;
     }
     tdAppendColVal(trow, val, c->type, c->bytes, c->offset);

src/cq/test/CMakeLists.txt

@@ -3,4 +3,4 @@ PROJECT(TDengine)
 
 LIST(APPEND CQTEST_SRC ./cqtest.c)
 ADD_EXECUTABLE(cqtest ${CQTEST_SRC})
-TARGET_LINK_LIBRARIES(cqtest tcq)
+TARGET_LINK_LIBRARIES(cqtest tcq taos_static)

src/dnode/CMakeLists.txt

@@ -10,7 +10,7 @@ INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 
-IF (TD_LINUX)
+IF (TD_LINUX OR TD_WINDOWS)
   ADD_EXECUTABLE(taosd ${SRC})
   TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync)
 
@@ -28,7 +28,7 @@ IF (TD_LINUX)
     TARGET_LINK_LIBRARIES(taosd grant)
   ENDIF ()
 
-  IF (TD_MQTT)
+  IF (TD_LINUX AND TD_MQTT)
     TARGET_LINK_LIBRARIES(taosd mqtt)
   ENDIF ()
 

src/dnode/src/dnodeCfg.c

@@ -97,7 +97,7 @@ static int32_t dnodeReadCfg() {
     goto PARSE_CFG_OVER;
   }
 
-  len = fread(content, 1, maxLen, fp);
+  len = (int32_t)fread(content, 1, maxLen, fp);
   if (len <= 0) {
     dError("failed to read %s, content is null", file);
     goto PARSE_CFG_OVER;
@@ -115,7 +115,7 @@ static int32_t dnodeReadCfg() {
     dError("failed to read %s, dnodeId not found", file);
     goto PARSE_CFG_OVER;
   }
-  cfg.dnodeId = dnodeId->valueint;
+  cfg.dnodeId = (int32_t)dnodeId->valueint;
 
   cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
   if (!clusterId || clusterId->type != cJSON_String) {

src/dnode/src/dnodeCheck.c

@@ -29,8 +29,8 @@ typedef struct {
 static  SCheckItem  tsCheckItem[TSDB_CHECK_ITEM_MAX] = {{0}};
 int64_t tsMinFreeMemSizeForStart = 0;
 
-static int bindTcpPort(int port) {
-  int    serverSocket;
+static int32_t bindTcpPort(int16_t port) {
+  SOCKET serverSocket;
   struct sockaddr_in server_addr;
 
   if ((serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
@@ -45,22 +45,22 @@ static int bindTcpPort(int port) {
 
   if (bind(serverSocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
     dError("port:%d tcp bind() fail: %s", port, strerror(errno));
-    close(serverSocket);
+    taosCloseSocket(serverSocket);
     return -1;
   }
 
   if (listen(serverSocket, 5) < 0) {
     dError("port:%d listen() fail: %s", port, strerror(errno));
-    close(serverSocket);
+    taosCloseSocket(serverSocket);
     return -1;
   }
 
-  close(serverSocket);
+  taosCloseSocket(serverSocket);
   return 0;
 }
 
-static int bindUdpPort(int port) {
-  int    serverSocket;
+static int32_t bindUdpPort(int16_t port) {
+  SOCKET serverSocket;
   struct sockaddr_in server_addr;
     
   if ((serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
@@ -75,19 +75,19 @@ static int bindUdpPort(int port) {
 
   if (bind(serverSocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
     dError("port:%d udp bind() fail: %s", port, strerror(errno));
-    close(serverSocket);
+    taosCloseSocket(serverSocket);
     return -1;
   }
 
-  close(serverSocket);
+  taosCloseSocket(serverSocket);
   return 0;
 }
 
-static int dnodeCheckNetwork() {
-  int ret;
-  int startPort = tsServerPort;
+static int32_t dnodeCheckNetwork() {
+  int32_t ret;
+  int16_t startPort = tsServerPort;
 
-  for (int port = startPort; port < startPort + 12; port++) {
+  for (int16_t port = startPort; port < startPort + 12; port++) {
     ret = bindTcpPort(port);
     if (0 != ret) {
       dError("failed to tcp bind port %d, quit", port);
@@ -103,7 +103,7 @@ static int dnodeCheckNetwork() {
   return 0;
 }
 
-static int dnodeCheckMem() {
+static int32_t dnodeCheckMem() {
   float  memoryUsedMB;
   float  memoryAvailMB;
   if (true != taosGetSysMemory(&memoryUsedMB)) {
@@ -121,12 +121,12 @@ static int dnodeCheckMem() {
   return 0;  
 }
 
-static int dnodeCheckCpu() {
+static int32_t dnodeCheckCpu() {
   // TODO:  
   return 0;
 }
 
-static int dnodeCheckDisk() {
+static int32_t dnodeCheckDisk() {
   taosGetDisk();
 
   if (tsAvailDataDirGB < tsMinimalDataDirGB) {
@@ -147,24 +147,24 @@ static int dnodeCheckDisk() {
   return 0;
 }
 
-static int dnodeCheckOs() {
+static int32_t dnodeCheckOs() {
   // TODO:
 
   return 0;
 }
-static int dnodeCheckAccess() {
+static int32_t dnodeCheckAccess() {
   // TODO:
 
   return 0;
 }
 
-static int dnodeCheckVersion() {
+static int32_t dnodeCheckVersion() {
   // TODO:
 
   return 0;
 }
 
-static int dnodeCheckDatafile() {
+static int32_t dnodeCheckDatafile() {
   // TODO:
 
   return 0;

src/dnode/src/dnodeEps.c

@@ -152,7 +152,7 @@ static int32_t dnodeReadEps() {
     goto PRASE_EPS_OVER;
   }
 
-  len = fread(content, 1, maxLen, fp);
+  len = (int32_t)fread(content, 1, maxLen, fp);
   if (len <= 0) {
     dError("failed to read %s, content is null", file);
     goto PRASE_EPS_OVER;
@@ -199,7 +199,7 @@ static int32_t dnodeReadEps() {
       dError("failed to read %s, dnodeId not found", file);
       goto PRASE_EPS_OVER;
     }
-    ep->dnodeId = dnodeId->valueint;
+    ep->dnodeId = (int32_t)dnodeId->valueint;
 
     cJSON *dnodeFqdn = cJSON_GetObjectItem(dnodeInfo, "dnodeFqdn");
     if (!dnodeFqdn || dnodeFqdn->type != cJSON_String || dnodeFqdn->valuestring == NULL) {

src/dnode/src/dnodeMInfos.c

@@ -80,7 +80,7 @@ void dnodeUpdateEpSetForPeer(SRpcEpSet *ep) {
 
   pthread_mutex_lock(&tsMInfosMutex);
   dInfo("minfos is changed, numOfEps:%d inUse:%d", ep->numOfEps, ep->inUse);
-  for (int i = 0; i < ep->numOfEps; ++i) {
+  for (int32_t i = 0; i < ep->numOfEps; ++i) {
     ep->port[i] -= TSDB_PORT_DNODEDNODE;
     dInfo("minfo:%d %s:%u", i, ep->fqdn[i], ep->port[i]);
   }
@@ -108,7 +108,7 @@ void dnodeGetMInfos(SMInfos *pMinfos) {
 void dnodeGetEpSetForPeer(SRpcEpSet *epSet) {
   pthread_mutex_lock(&tsMInfosMutex);
   *epSet = tsMEpSet;
-  for (int i = 0; i < epSet->numOfEps; ++i) {
+  for (int32_t i = 0; i < epSet->numOfEps; ++i) {
     epSet->port[i] += TSDB_PORT_DNODEDNODE;
   }
   pthread_mutex_unlock(&tsMInfosMutex);
@@ -171,7 +171,7 @@ static int32_t dnodeReadMInfos() {
     goto PARSE_MINFOS_OVER;
   }
 
-  len = fread(content, 1, maxLen, fp);
+  len = (int32_t)fread(content, 1, maxLen, fp);
   if (len <= 0) {
     dError("failed to read %s, content is null", file);
     goto PARSE_MINFOS_OVER;
@@ -189,14 +189,14 @@ static int32_t dnodeReadMInfos() {
     dError("failed to read mnodeEpSet.json, inUse not found");
     goto PARSE_MINFOS_OVER;
   }
-  tsMInfos.inUse = inUse->valueint;
+  tsMInfos.inUse = (int8_t)inUse->valueint;
 
   cJSON *nodeNum = cJSON_GetObjectItem(root, "nodeNum");
   if (!nodeNum || nodeNum->type != cJSON_Number) {
     dError("failed to read mnodeEpSet.json, nodeNum not found");
     goto PARSE_MINFOS_OVER;
   }
-  minfos.mnodeNum = nodeNum->valueint;
+  minfos.mnodeNum = (int8_t)nodeNum->valueint;
 
   cJSON *nodeInfos = cJSON_GetObjectItem(root, "nodeInfos");
   if (!nodeInfos || nodeInfos->type != cJSON_Array) {
@@ -204,13 +204,13 @@ static int32_t dnodeReadMInfos() {
     goto PARSE_MINFOS_OVER;
   }
 
-  int size = cJSON_GetArraySize(nodeInfos);
+  int32_t size = cJSON_GetArraySize(nodeInfos);
   if (size != minfos.mnodeNum) {
     dError("failed to read mnodeEpSet.json, nodeInfos size not matched");
     goto PARSE_MINFOS_OVER;
   }
 
-  for (int i = 0; i < size; ++i) {
+  for (int32_t i = 0; i < size; ++i) {
     cJSON *nodeInfo = cJSON_GetArrayItem(nodeInfos, i);
     if (nodeInfo == NULL) continue;
 
@@ -227,7 +227,7 @@ static int32_t dnodeReadMInfos() {
     }
 
     SMInfo *pMinfo = &minfos.mnodeInfos[i];
-    pMinfo->mnodeId = nodeId->valueint;
+    pMinfo->mnodeId = (int32_t)nodeId->valueint;
     tstrncpy(pMinfo->mnodeEp, nodeEp->valuestring, TSDB_EP_LEN);
 
     bool changed = dnodeCheckEpChanged(pMinfo->mnodeId, pMinfo->mnodeEp);

src/dnode/src/dnodeMPeer.c

@@ -60,7 +60,7 @@ int32_t dnodeInitMPeer() {
 void dnodeCleanupMPeer() {
   for (int32_t i = 0; i < tsMPeerWP.maxNum; ++i) {
     SMPeerWorker *pWorker = tsMPeerWP.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       taosQsetThreadResume(tsMPeerQset);
     }
     dDebug("dnode mpeer worker:%d is closed", i);
@@ -69,7 +69,7 @@ void dnodeCleanupMPeer() {
   for (int32_t i = 0; i < tsMPeerWP.maxNum; ++i) {
     SMPeerWorker *pWorker = tsMPeerWP.worker + i;
     dDebug("dnode mpeer worker:%d start to join", i);
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       pthread_join(pWorker->thread, NULL);
     }
     dDebug("dnode mpeer worker:%d join success", i);

src/dnode/src/dnodeMRead.c

@@ -40,7 +40,7 @@ static void *dnodeProcessMReadQueue(void *param);
 int32_t dnodeInitMRead() {
   tsMReadQset = taosOpenQset();
 
-  tsMReadWP.maxNum = tsNumOfCores * tsNumOfThreadsPerCore / 2;
+  tsMReadWP.maxNum = (int32_t)(tsNumOfCores * tsNumOfThreadsPerCore / 2);
   tsMReadWP.maxNum = MAX(2, tsMReadWP.maxNum);
   tsMReadWP.maxNum = MIN(4, tsMReadWP.maxNum);
   tsMReadWP.curNum = 0;
@@ -60,7 +60,7 @@ int32_t dnodeInitMRead() {
 void dnodeCleanupMRead() {
   for (int32_t i = 0; i < tsMReadWP.maxNum; ++i) {
     SMReadWorker *pWorker = tsMReadWP.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       taosQsetThreadResume(tsMReadQset);
     }
     dDebug("dnode mread worker:%d is closed", i);
@@ -69,7 +69,7 @@ void dnodeCleanupMRead() {
   for (int32_t i = 0; i < tsMReadWP.maxNum; ++i) {
     SMReadWorker *pWorker = tsMReadWP.worker + i;
     dDebug("dnode mread worker:%d start to join", i);
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       pthread_join(pWorker->thread, NULL);
     }
     dDebug("dnode mread worker:%d start to join", i);

src/dnode/src/dnodeMWrite.c

@@ -60,7 +60,7 @@ int32_t dnodeInitMWrite() {
 void dnodeCleanupMWrite() {
   for (int32_t i = 0; i < tsMWriteWP.maxNum; ++i) {
     SMWriteWorker *pWorker = tsMWriteWP.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       taosQsetThreadResume(tsMWriteQset);
     }
     dDebug("dnode mwrite worker:%d is closed", i);
@@ -69,7 +69,7 @@ void dnodeCleanupMWrite() {
   for (int32_t i = 0; i < tsMWriteWP.maxNum; ++i) {
     SMWriteWorker *pWorker = tsMWriteWP.worker + i;
     dDebug("dnode mwrite worker:%d start to join", i);
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       pthread_join(pWorker->thread, NULL);
     }
     dDebug("dnode mwrite worker:%d join success", i);

src/dnode/src/dnodePeer.c

@@ -90,7 +90,10 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
   };
 
   if (pMsg->pCont == NULL) return;
-  if (pMsg->msgType == TSDB_MSG_TYPE_NETWORK_TEST) return dnodeSendStartupStep(pMsg);
+  if (pMsg->msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
+    dnodeSendStartupStep(pMsg);
+    return;
+  }
 
   if (dnodeGetRunStatus() != TSDB_RUN_STATUS_RUNING) {
     rspMsg.code = TSDB_CODE_APP_NOT_READY;

src/dnode/src/dnodeShell.c

@@ -70,7 +70,7 @@ int32_t dnodeInitShell() {
 
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST]   = dnodeSendStartupStep;
 
-  int32_t numOfThreads = (tsNumOfCores * tsNumOfThreadsPerCore) / 2.0;
+  int32_t numOfThreads = (int32_t)((tsNumOfCores * tsNumOfThreadsPerCore) / 2.0);
   if (numOfThreads < 1) {
     numOfThreads = 1;
   }

src/dnode/src/dnodeStep.c

@@ -70,5 +70,5 @@ int32_t dnodeStepInit(SStep *pSteps, int32_t stepSize) {
 }
 
 void dnodeStepCleanup(SStep *pSteps, int32_t stepSize) { 
-  return taosStepCleanupImp(pSteps, stepSize - 1);
+  taosStepCleanupImp(pSteps, stepSize - 1);
 }
\ No newline at end of file

src/dnode/src/dnodeSystem.c

@@ -19,8 +19,10 @@
 #include "tconfig.h"
 #include "dnodeMain.h"
 
-static void signal_handler(int32_t signum, siginfo_t *sigInfo, void *context);
 static tsem_t exitSem;
+static void   siguser1Handler(int32_t signum, void *sigInfo, void *context);
+static void   siguser2Handler(int32_t signum, void *sigInfo, void *context);
+static void   sigintHandler(int32_t signum, void *sigInfo, void *context);
 
 int32_t main(int32_t argc, char *argv[]) {
   int dump_config = 0;
@@ -28,7 +30,7 @@ int32_t main(int32_t argc, char *argv[]) {
   // Set global configuration file
   for (int32_t i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-c") == 0) {
-      if (i < argc - 1) {        
+      if (i < argc - 1) {
         if (strlen(argv[++i]) >= TSDB_FILENAME_LEN) {
           printf("config file path overflow");
           exit(EXIT_FAILURE);
@@ -80,8 +82,8 @@ int32_t main(int32_t argc, char *argv[]) {
         taosSetRandomFileFailOutput(NULL);
       }
     } else if (strcmp(argv[i], "--random-file-fail-factor") == 0) {
-      if ( (i+1) < argc ) {
-        int factor = atoi(argv[i+1]);
+      if ((i + 1) < argc) {
+        int factor = atoi(argv[i + 1]);
         printf("The factor of random failure is %d\n", factor);
         taosSetRandomFileFailFactor(factor);
       } else {
@@ -93,7 +95,7 @@ int32_t main(int32_t argc, char *argv[]) {
   }
 
   if (0 != dump_config) {
-    tscEmbedded  = 1;
+    tscEmbedded = 1;
     taosInitGlobalCfg();
     taosReadGlobalLogCfg();
 
@@ -112,14 +114,13 @@ int32_t main(int32_t argc, char *argv[]) {
   }
 
   /* Set termination handler. */
-  struct sigaction act = {{0}};
-  act.sa_flags = SA_SIGINFO;
-  act.sa_sigaction = signal_handler;
-  sigaction(SIGTERM, &act, NULL);
-  sigaction(SIGHUP, &act, NULL);
-  sigaction(SIGINT, &act, NULL);
-  sigaction(SIGUSR1, &act, NULL);
-  sigaction(SIGUSR2, &act, NULL);
+  taosSetSignal(SIGUSR1, siguser1Handler);
+  taosSetSignal(SIGUSR2, siguser2Handler);
+  taosSetSignal(SIGTERM, sigintHandler);
+  taosSetSignal(SIGHUP, sigintHandler);
+  taosSetSignal(SIGINT, sigintHandler);
+  taosSetSignal(SIGABRT, sigintHandler);
+  taosSetSignal(SIGBREAK, sigintHandler);
 
   // Open /var/log/syslog file to record information.
   openlog("TDengine:", LOG_PID | LOG_CONS | LOG_NDELAY, LOG_LOCAL1);
@@ -144,37 +145,40 @@ int32_t main(int32_t argc, char *argv[]) {
   syslog(LOG_INFO, "Shut down TDengine service successfully");
   dInfo("TDengine is shut down!");
   closelog();
+
+#ifdef WINDOWS
+  tsem_post(&exitSem);
+#endif
   return EXIT_SUCCESS;
 }
 
-static void signal_handler(int32_t signum, siginfo_t *sigInfo, void *context) {
-  if (signum == SIGUSR1) {
-    taosCfgDynamicOptions("debugFlag 143");
-    return;
-  }
-  if (signum == SIGUSR2) {
-    taosCfgDynamicOptions("resetlog");
-    return;
-  }
+static void siguser1Handler(int32_t signum, void *sigInfo, void *context) { taosCfgDynamicOptions("debugFlag 143"); }
 
-  syslog(LOG_INFO, "Shut down signal is %d", signum);
-  syslog(LOG_INFO, "Shutting down TDengine service...");
-  // clean the system.
-#ifdef __APPLE__
-  dInfo("shut down signal is %d, sender PID:%d", signum, sigInfo->si_pid);
-#else // __APPLE__
-  dInfo("shut down signal is %d, sender PID:%d cmdline:%s", signum, sigInfo->si_pid, taosGetCmdlineByPID(sigInfo->si_pid));
-#endif // __APPLE__
+static void siguser2Handler(int32_t signum, void *sigInfo, void *context) { taosCfgDynamicOptions("resetlog"); }
 
+static void sigintHandler(int32_t signum, void *sigInfo, void *context) {
   // protect the application from receive another signal
-  struct sigaction act = {{0}};
-  act.sa_handler = SIG_IGN;
-  sigaction(SIGTERM, &act, NULL);
-  sigaction(SIGHUP, &act, NULL);
-  sigaction(SIGINT, &act, NULL);
-  sigaction(SIGUSR1, &act, NULL);
-  sigaction(SIGUSR2, &act, NULL);
+  taosIgnSignal(SIGUSR1);
+  taosIgnSignal(SIGUSR2);
+  taosIgnSignal(SIGTERM);
+  taosIgnSignal(SIGHUP);
+  taosIgnSignal(SIGINT);
+  taosIgnSignal(SIGABRT);
+  taosIgnSignal(SIGBREAK);
+
+  // clean the system.
+  dInfo("shut down signal is %d", signum);
+
+#ifndef WINDOWS
+  dInfo("sender PID:%d cmdline:%s", ((siginfo_t *)sigInfo)->si_pid, taosGetCmdlineByPID(((siginfo_t *)sigInfo)->si_pid));
+#endif
+
+  syslog(LOG_INFO, "Shut down signal is %d", signum);
+  syslog(LOG_INFO, "Shutting down TDengine service...");
 
   // inform main thread to exit
   tsem_post(&exitSem);
-}
+#ifdef WINDOWS
+  tsem_wait(&exitSem);
+#endif
+}
\ No newline at end of file

src/dnode/src/dnodeTelemetry.c

@@ -93,14 +93,14 @@ static void addStringField(SBufferWriter* bw, const char* k, const char* v) {
 static void addCpuInfo(SBufferWriter* bw) {
   char * line = NULL;
   size_t size = 0;
-  int done = 0;
+  int32_t done = 0;
 
   FILE* fp = fopen("/proc/cpuinfo", "r");
   if (fp == NULL) {
     return;
   }
 
-  while (done != 3 && (size = getline(&line, &size, fp)) != -1) {
+  while (done != 3 && (size = tgetline(&line, &size, fp)) != -1) {
     line[size - 1] = '\0';
     if (((done&1) == 0) && strncmp(line, "model name", 10) == 0) {
       const char* v = strchr(line, ':') + 2;
@@ -129,7 +129,7 @@ static void addOsInfo(SBufferWriter* bw) {
     return;
   }
 
-  while ((size = getline(&line, &size, fp)) != -1) {
+  while ((size = tgetline(&line, &size, fp)) != -1) {
     line[size - 1] = '\0';
     if (strncmp(line, "PRETTY_NAME", 11) == 0) {
       const char* p = strchr(line, '=') + 1;
@@ -155,7 +155,7 @@ static void addMemoryInfo(SBufferWriter* bw) {
     return;
   }
 
-  while ((size = getline(&line, &size, fp)) != -1) {
+  while ((size = tgetline(&line, &size, fp)) != -1) {
     line[size - 1] = '\0';
     if (strncmp(line, "MemTotal", 8) == 0) {
       const char* p = strchr(line, ':') + 1;
@@ -200,7 +200,7 @@ static void sendTelemetryReport() {
     dTrace("failed to get IP address of " TELEMETRY_SERVER ", reason:%s", strerror(errno));
     return;
   }
-  int fd = taosOpenTcpClientSocket(ip, TELEMETRY_PORT, 0);
+  SOCKET fd = taosOpenTcpClientSocket(ip, TELEMETRY_PORT, 0);
   if (fd < 0) {
     dTrace("failed to create socket for telemetry, reason:%s", strerror(errno));
     return;
@@ -222,10 +222,10 @@ static void sendTelemetryReport() {
     "Content-Type: application/json\n"
     "Content-Length: ";
 
-  taosWriteSocket(fd, header, strlen(header));
-  int contLen = tbufTell(&bw) - 1;
+  taosWriteSocket(fd, header, (int32_t)strlen(header));
+  int32_t contLen = (int32_t)(tbufTell(&bw) - 1);
   sprintf(buf, "%d\n\n", contLen);
-  taosWriteSocket(fd, buf, strlen(buf));
+  taosWriteSocket(fd, buf, (int32_t)strlen(buf));
   taosWriteSocket(fd, tbufGetData(&bw, false), contLen);
   tbufCloseWriter(&bw);
 
@@ -265,7 +265,7 @@ static void* telemetryThread(void* param) {
 }
 
 static void dnodeGetEmail(char* filepath) {
-  int fd = open(filepath, O_RDONLY);
+  int32_t fd = open(filepath, O_RDONLY);
   if (fd < 0) {
     return;
   }
@@ -274,10 +274,9 @@ static void dnodeGetEmail(char* filepath) {
     dError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
   } 
 
-  close(fd);   
+  taosClose(fd);   
 }
 
-
 int32_t dnodeInitTelemetry() {
   if (!tsEnableTelemetryReporting) {
     return 0;
@@ -310,7 +309,7 @@ void dnodeCleanupTelemetry() {
     return;
   }
 
-  if (tsTelemetryThread) {
+  if (taosCheckPthreadValid(tsTelemetryThread)) {
     tsem_post(&tsExitSem);
     pthread_join(tsTelemetryThread, NULL);
     tsem_destroy(&tsExitSem);

src/dnode/src/dnodeVWrite.c

@@ -52,14 +52,14 @@ int32_t dnodeInitVWrite() {
 void dnodeCleanupVWrite() {
   for (int32_t i = 0; i < tsVWriteWP.max; ++i) {
     SVWriteWorker *pWorker = tsVWriteWP.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       taosQsetThreadResume(pWorker->qset);
     }
   }
 
   for (int32_t i = 0; i < tsVWriteWP.max; ++i) {
     SVWriteWorker *pWorker = tsVWriteWP.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       pthread_join(pWorker->thread, NULL);
       taosFreeQall(pWorker->qall);
       taosCloseQset(pWorker->qset);

src/dnode/src/dnodeVnodes.c

@@ -157,7 +157,7 @@ int32_t dnodeInitVnodes() {
   int32_t failedVnodes = 0;
   for (int32_t t = 0; t < threadNum; ++t) {
     SOpenVnodeThread *pThread = &threads[t];
-    if (pThread->vnodeNum > 0 && pThread->thread) {
+    if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) {
       pthread_join(pThread->thread, NULL);
     }
     openVnodes += pThread->opened;
@@ -260,7 +260,7 @@ static void dnodeSendStatusMsg(void *handle, void *tmrId) {
   tstrncpy(pStatus->clusterCfg.timezone, tsTimezone, 64);
   pStatus->clusterCfg.checkTime = 0;
   char timestr[32] = "1970-01-01 00:00:00.00";
-  (void)taosParseTime(timestr, &pStatus->clusterCfg.checkTime, strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
+  (void)taosParseTime(timestr, &pStatus->clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
   tstrncpy(pStatus->clusterCfg.locale, tsLocale, TSDB_LOCALE_LEN);
   tstrncpy(pStatus->clusterCfg.charset, tsCharset, TSDB_LOCALE_LEN);
 

src/kit/shell/src/shellMain.c

@@ -21,7 +21,7 @@
 pthread_t pid;
 static tsem_t cancelSem;
 
-void shellQueryInterruptHandler(int signum) {
+void shellQueryInterruptHandler(int32_t signum, void *sigInfo, void *context) {
   tsem_post(&cancelSem);
 }
 
@@ -130,12 +130,10 @@ int main(int argc, char* argv[]) {
   pthread_create(&spid, NULL, cancelHandler, NULL);
 
   /* Interrupt handler. */
-  struct sigaction act;
-  memset(&act, 0, sizeof(struct sigaction));
-  
-  act.sa_handler = shellQueryInterruptHandler;
-  sigaction(SIGTERM, &act, NULL);
-  sigaction(SIGINT, &act, NULL);
+  taosSetSignal(SIGTERM, shellQueryInterruptHandler);
+  taosSetSignal(SIGINT, shellQueryInterruptHandler);
+  taosSetSignal(SIGHUP, shellQueryInterruptHandler);
+  taosSetSignal(SIGABRT, shellQueryInterruptHandler);
 
   /* Get grant information */
   shellGetGrantInfo(con);

src/mnode/CMakeLists.txt

 CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)
 
-IF (TD_LINUX)
+IF (TD_LINUX OR TD_WINDOWS)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/dnode/inc)
 

src/mnode/src/mnodeAcct.c

@@ -81,7 +81,7 @@ static int32_t mnodeAcctActionDecode(SSdbRow *pRow) {
 }
 
 static int32_t mnodeAcctActionRestored() {
-  int32_t numOfRows = sdbGetNumOfRows(tsAcctSdb);
+  int64_t numOfRows = sdbGetNumOfRows(tsAcctSdb);
   if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
     mInfo("dnode first deploy, create root acct");
     int32_t code = mnodeCreateRootAcct();
@@ -97,14 +97,14 @@ static int32_t mnodeAcctActionRestored() {
 
 int32_t mnodeInitAccts() {
   SAcctObj tObj;
-  tsAcctUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsAcctUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_ACCOUNT,
     .name         = "accounts",
     .hashSessions = TSDB_DEFAULT_ACCOUNTS_HASH_SIZE,
     .maxRowSize   = tsAcctUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_STRING,
     .fpInsert     = mnodeAcctActionInsert,
     .fpDelete     = mnodeAcctActionDelete,
@@ -206,7 +206,7 @@ void mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) {
 }
 
 static int32_t mnodeCreateRootAcct() {
-  int32_t numOfAccts = sdbGetNumOfRows(tsAcctSdb);
+  int64_t numOfAccts = sdbGetNumOfRows(tsAcctSdb);
   if (numOfAccts != 0) return TSDB_CODE_SUCCESS;
 
   SAcctObj *pAcct = malloc(sizeof(SAcctObj));

src/mnode/src/mnodeCluster.c

@@ -68,7 +68,7 @@ static int32_t mnodeClusterActionDecode(SSdbRow *pRow) {
 }
 
 static int32_t mnodeClusterActionRestored() {
-  int32_t numOfRows = sdbGetNumOfRows(tsClusterSdb);
+  int64_t numOfRows = sdbGetNumOfRows(tsClusterSdb);
   if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
     mInfo("dnode first deploy, create cluster");
     int32_t code = mnodeCreateCluster();
@@ -84,14 +84,14 @@ static int32_t mnodeClusterActionRestored() {
 
 int32_t mnodeInitCluster() {
   SClusterObj tObj;
-  tsClusterUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsClusterUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_CLUSTER,
     .name         = "cluster",
     .hashSessions = TSDB_DEFAULT_CLUSTER_HASH_SIZE,
     .maxRowSize   = tsClusterUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_STRING,
     .fpInsert     = mnodeClusterActionInsert,
     .fpDelete     = mnodeClusterActionDelete,
@@ -147,7 +147,7 @@ bool taosGetSystemUid(char *uid) {
 #endif // __APPLE__
 
 static int32_t mnodeCreateCluster() {
-  int32_t numOfClusters = sdbGetNumOfRows(tsClusterSdb);
+  int64_t numOfClusters = sdbGetNumOfRows(tsClusterSdb);
   if (numOfClusters != 0) return TSDB_CODE_SUCCESS;
 
   SClusterObj *pCluster = malloc(sizeof(SClusterObj));
@@ -234,7 +234,7 @@ static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows,
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *) pWrite = pCluster->createdTime;
+    *(int64_t *) pWrite = pCluster->createdTime;
     cols++;
 
     mnodeDecClusterRef(pCluster);

src/mnode/src/mnodeDb.c

@@ -143,14 +143,14 @@ static int32_t mnodeDbActionRestored() {
 
 int32_t mnodeInitDbs() {
   SDbObj tObj;
-  tsDbUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsDbUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_DB,
     .name         = "dbs",
     .hashSessions = TSDB_DEFAULT_DBS_HASH_SIZE,
     .maxRowSize   = tsDbUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_STRING,
     .fpInsert     = mnodeDbActionInsert,
     .fpDelete     = mnodeDbActionDelete,
@@ -192,11 +192,11 @@ SDbObj *mnodeGetDb(char *db) {
 }
 
 void mnodeIncDbRef(SDbObj *pDb) {
-  return sdbIncRef(tsDbSdb, pDb); 
+  sdbIncRef(tsDbSdb, pDb); 
 }
 
 void mnodeDecDbRef(SDbObj *pDb) { 
-  return sdbDecRef(tsDbSdb, pDb); 
+  sdbDecRef(tsDbSdb, pDb); 
 }
 
 SDbObj *mnodeGetDbByTableName(char *tableName) {

src/mnode/src/mnodeDnode.c

@@ -39,7 +39,7 @@
 #include "mnodeCluster.h"
 
 int32_t tsAccessSquence = 0;
-int64_t        tsDnodeRid = -1;
+int64_t         tsDnodeRid = -1;
 static void *  tsDnodeSdb = NULL;
 static int32_t tsDnodeUpdateSize = 0;
 extern void *  tsMnodeSdb;
@@ -148,7 +148,7 @@ static int32_t mnodeDnodeActionDecode(SSdbRow *pRow) {
 }
 
 static int32_t mnodeDnodeActionRestored() {
-  int32_t numOfRows = sdbGetNumOfRows(tsDnodeSdb);
+  int64_t numOfRows = sdbGetNumOfRows(tsDnodeSdb);
   if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
     mInfo("dnode first deploy, create dnode:%s", tsLocalEp);
     mnodeCreateDnode(tsLocalEp, NULL);
@@ -165,7 +165,7 @@ static int32_t mnodeDnodeActionRestored() {
 
 int32_t mnodeInitDnodes() {
   SDnodeObj tObj;
-  tsDnodeUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsDnodeUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
   pthread_mutex_init(&tsDnodeEpsMutex, NULL);
 
   SSdbTableDesc desc = {
@@ -173,7 +173,7 @@ int32_t mnodeInitDnodes() {
     .name         = "dnodes",
     .hashSessions = TSDB_DEFAULT_DNODES_HASH_SIZE,
     .maxRowSize   = tsDnodeUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_AUTO,
     .fpInsert     = mnodeDnodeActionInsert,
     .fpDelete     = mnodeDnodeActionDelete,
@@ -227,7 +227,7 @@ void mnodeCancelGetNextDnode(void *pIter) {
 }
 
 int32_t mnodeGetDnodesNum() {
-  return sdbGetNumOfRows(tsDnodeSdb);
+  return (int32_t)sdbGetNumOfRows(tsDnodeSdb);
 }
 
 int32_t mnodeGetOnlinDnodesCpuCoreNum() {
@@ -407,7 +407,7 @@ static int32_t mnodeCheckClusterCfgPara(const SClusterCfg *clusterCfg) {
 
   int64_t checkTime = 0;
   char    timestr[32] = "1970-01-01 00:00:00.00";
-  (void)taosParseTime(timestr, &checkTime, strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
+  (void)taosParseTime(timestr, &checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
   if ((0 != strncasecmp(clusterCfg->timezone, tsTimezone, strlen(tsTimezone))) &&
       (checkTime != clusterCfg->checkTime)) {
     mError("\"timezone\"[%s - %s] [%" PRId64 " - %" PRId64 "] cfg parameters inconsistent", clusterCfg->timezone,
@@ -638,9 +638,9 @@ static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg) {
 
   char *temp = strchr(dnodeEp, ':');
   if (!temp) {
-    int len = strlen(dnodeEp);
+    int32_t len = (int32_t)strlen(dnodeEp);
     if (dnodeEp[len - 1] == ';') dnodeEp[len - 1] = 0;
-    len = strlen(dnodeEp);
+    len = (int32_t)strlen(dnodeEp);
     snprintf(dnodeEp + len, TSDB_EP_LEN - len, ":%d", tsServerPort);
   }
   ep = dnodeEp;

src/mnode/src/mnodeMnode.c

@@ -136,14 +136,14 @@ int32_t mnodeInitMnodes() {
   mnodeMnodeInitLock();
 
   SMnodeObj tObj;
-  tsMnodeUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsMnodeUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_MNODE,
     .name         = "mnodes",
     .hashSessions = TSDB_DEFAULT_MNODES_HASH_SIZE,
     .maxRowSize   = tsMnodeUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_INT,
     .fpInsert     = mnodeMnodeActionInsert,
     .fpDelete     = mnodeMnodeActionDelete,
@@ -176,7 +176,7 @@ void mnodeCleanupMnodes() {
 }
 
 int32_t mnodeGetMnodesNum() { 
-  return sdbGetNumOfRows(tsMnodeSdb); 
+  return (int32_t)sdbGetNumOfRows(tsMnodeSdb); 
 }
 
 void *mnodeGetMnode(int32_t mnodeId) {

src/mnode/src/mnodeSdb.c

@@ -207,7 +207,7 @@ static void sdbRestoreTables() {
       (*pTable->fpRestored)();
     }
 
-    totalRows += pTable->numOfRows;
+    totalRows += (int32_t)pTable->numOfRows;
     numOfTables++;
     sdbInfo("vgId:1, sdb:%s is checked, rows:%" PRId64, pTable->name, pTable->numOfRows);
   }
@@ -475,7 +475,7 @@ void sdbIncRef(void *tparam, void *pRow) {
   if (pRow == NULL || tparam == NULL) return;
 
   SSdbTable *pTable = tparam;
-  int32_t *  pRefCount = (int32_t *)(pRow + pTable->refCountPos);
+  int32_t *  pRefCount = (int32_t *)((char *)pRow + pTable->refCountPos);
   int32_t    refCount = atomic_add_fetch_32(pRefCount, 1);
   sdbTrace("vgId:1, sdb:%s, inc ref to row:%p:%s:%d", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
 }
@@ -484,11 +484,11 @@ void sdbDecRef(void *tparam, void *pRow) {
   if (pRow == NULL || tparam == NULL) return;
 
   SSdbTable *pTable = tparam;
-  int32_t *  pRefCount = (int32_t *)(pRow + pTable->refCountPos);
+  int32_t *  pRefCount = (int32_t *)((char *)pRow + pTable->refCountPos);
   int32_t    refCount = atomic_sub_fetch_32(pRefCount, 1);
   sdbTrace("vgId:1, sdb:%s, dec ref to row:%p:%s:%d", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
 
-  int32_t *updateEnd = pRow + pTable->refCountPos - 4;
+  int32_t *updateEnd = (int32_t *)((char *)pRow + pTable->refCountPos - 4);
   if (refCount <= 0 && *updateEnd) {
     sdbTrace("vgId:1, sdb:%s, row:%p:%s:%d destroyed", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
     SSdbRow row = {.pObj = pRow};
@@ -501,7 +501,7 @@ static void *sdbGetRowMeta(SSdbTable *pTable, void *key) {
 
   int32_t keySize = sizeof(int32_t);
   if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    keySize = strlen((char *)key);
+    keySize = (int32_t)strlen((char *)key);
   }
 
   void **ppRow = (void **)taosHashGet(pTable->iHandle, key, keySize);
@@ -534,7 +534,7 @@ static int32_t sdbInsertHash(SSdbTable *pTable, SSdbRow *pRow) {
   int32_t keySize = sizeof(int32_t);
 
   if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    keySize = strlen((char *)key);
+    keySize =  (int32_t)strlen((char *)key);
   }
 
   pthread_mutex_lock(&pTable->mutex);
@@ -564,7 +564,7 @@ static int32_t sdbInsertHash(SSdbTable *pTable, SSdbRow *pRow) {
 }
 
 static int32_t sdbDeleteHash(SSdbTable *pTable, SSdbRow *pRow) {
-  int32_t *updateEnd = pRow->pObj + pTable->refCountPos - 4;
+  int32_t *updateEnd = (int32_t *)((char*)pRow->pObj + pTable->refCountPos - 4);
   bool set = atomic_val_compare_exchange_32(updateEnd, 0, 1) == 0;
   if (!set) {
     sdbError("vgId:1, sdb:%s, failed to delete key:%s from hash, for it already removed", pTable->name,
@@ -577,7 +577,7 @@ static int32_t sdbDeleteHash(SSdbTable *pTable, SSdbRow *pRow) {
   void *  key = sdbGetObjKey(pTable, pRow->pObj);
   int32_t keySize = sizeof(int32_t);
   if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    keySize = strlen((char *)key);
+    keySize = (int32_t)strlen((char *)key);
   }
 
   pthread_mutex_lock(&pTable->mutex);
@@ -764,7 +764,7 @@ bool sdbCheckRowDeleted(void *tparam, void *pRow) {
   SSdbTable *pTable = tparam;
   if (pTable == NULL) return false;
 
-  int32_t *updateEnd = pRow + pTable->refCountPos - 4;
+  int32_t *updateEnd =  (int32_t *)((char*)pRow + pTable->refCountPos - 4);
   return atomic_val_compare_exchange_32(updateEnd, 1, 1) == 1;
 }
 
@@ -942,14 +942,14 @@ static int32_t sdbInitWorker() {
 static void sdbCleanupWorker() {
   for (int32_t i = 0; i < tsSdbPool.num; ++i) {
     SSdbWorker *pWorker = tsSdbPool.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       taosQsetThreadResume(tsSdbWQset);
     }
   }
 
   for (int32_t i = 0; i < tsSdbPool.num; ++i) {
     SSdbWorker *pWorker = tsSdbPool.worker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       pthread_join(pWorker->thread, NULL);
     }
   }

src/mnode/src/mnodeShow.c

@@ -218,7 +218,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) {
   }
 
   pRsp->numOfRows = htonl(rowsRead);
-  pRsp->precision = htonl(TSDB_TIME_PRECISION_MILLI);  // millisecond time precision
+  pRsp->precision = (int16_t)htonl(TSDB_TIME_PRECISION_MILLI);  // millisecond time precision
 
   pMsg->rpcRsp.rsp = pRsp;
   pMsg->rpcRsp.len = size;

src/mnode/src/mnodeTable.c

@@ -222,23 +222,23 @@ static int32_t mnodeChildTableActionEncode(SSdbRow *pRow) {
   SCTableObj *pTable = pRow->pObj;
   assert(pTable != NULL && pRow->rowData != NULL);
 
-  int32_t len = strlen(pTable->info.tableId);
+  int32_t len = (int32_t)strlen(pTable->info.tableId);
   if (len >= TSDB_TABLE_FNAME_LEN) return TSDB_CODE_MND_INVALID_TABLE_ID;
 
   memcpy(pRow->rowData, pTable->info.tableId, len);
-  memset(pRow->rowData + len, 0, 1);
+  memset((char *)pRow->rowData + len, 0, 1);
   len++;
 
-  memcpy(pRow->rowData + len, (char*)pTable + sizeof(char *), tsChildTableUpdateSize);
+  memcpy((char *)pRow->rowData + len, (char *)pTable + sizeof(char *), tsChildTableUpdateSize);
   len += tsChildTableUpdateSize;
 
   if (pTable->info.type != TSDB_CHILD_TABLE) {
     int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
-    memcpy(pRow->rowData + len, pTable->schema, schemaSize);
+    memcpy((char *)pRow->rowData + len, pTable->schema, schemaSize);
     len += schemaSize;
 
     if (pTable->sqlLen != 0) {
-      memcpy(pRow->rowData + len, pTable->sql, pTable->sqlLen);
+      memcpy((char *)pRow->rowData + len, pTable->sql, pTable->sqlLen);
       len += pTable->sqlLen;
     }
   }
@@ -253,7 +253,7 @@ static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
   SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
   if (pTable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
 
-  int32_t len = strlen(pRow->rowData);
+  int32_t len = (int32_t)strlen(pRow->rowData);
   if (len >= TSDB_TABLE_FNAME_LEN) {
     free(pTable);
     return TSDB_CODE_MND_INVALID_TABLE_ID;
@@ -261,7 +261,7 @@ static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
   pTable->info.tableId = strdup(pRow->rowData);
   len++;
 
-  memcpy((char*)pTable + sizeof(char *), pRow->rowData + len, tsChildTableUpdateSize);
+  memcpy((char *)pTable + sizeof(char *), (char *)pRow->rowData + len, tsChildTableUpdateSize);
   len += tsChildTableUpdateSize;
 
   if (pTable->info.type != TSDB_CHILD_TABLE) {
@@ -271,7 +271,7 @@ static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
       mnodeDestroyChildTable(pTable);
       return TSDB_CODE_MND_INVALID_TABLE_TYPE;
     }
-    memcpy(pTable->schema, pRow->rowData + len, schemaSize);
+    memcpy(pTable->schema, (char *)pRow->rowData + len, schemaSize);
     len += schemaSize;
 
     if (pTable->sqlLen != 0) {
@@ -280,7 +280,7 @@ static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
         mnodeDestroyChildTable(pTable);
         return TSDB_CODE_MND_OUT_OF_MEMORY;
       }
-      memcpy(pTable->sql, pRow->rowData + len, pTable->sqlLen);
+      memcpy(pTable->sql, (char *)pRow->rowData + len, pTable->sqlLen);
     }
   }
 
@@ -352,14 +352,14 @@ static int32_t mnodeChildTableActionRestored() {
 
 static int32_t mnodeInitChildTables() {
   SCTableObj tObj;
-  tsChildTableUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type;
+  tsChildTableUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_CTABLE,
     .name         = "ctables",
     .hashSessions = TSDB_DEFAULT_CTABLES_HASH_SIZE,
     .maxRowSize   = sizeof(SCTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_FNAME_LEN + TSDB_CQ_SQL_SIZE,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_VAR_STRING,
     .fpInsert     = mnodeChildTableActionInsert,
     .fpDelete     = mnodeChildTableActionDelete,
@@ -501,18 +501,18 @@ static int32_t mnodeSuperTableActionEncode(SSdbRow *pRow) {
   SSTableObj *pStable = pRow->pObj;
   assert(pRow->pObj != NULL && pRow->rowData != NULL);
 
-  int32_t len = strlen(pStable->info.tableId);
+  int32_t len = (int32_t)strlen(pStable->info.tableId);
   if (len >= TSDB_TABLE_FNAME_LEN) len = TSDB_CODE_MND_INVALID_TABLE_ID;
 
   memcpy(pRow->rowData, pStable->info.tableId, len);
-  memset(pRow->rowData + len, 0, 1);
+  memset((char *)pRow->rowData + len, 0, 1);
   len++;
 
-  memcpy(pRow->rowData + len, (char*)pStable + sizeof(char *), tsSuperTableUpdateSize);
+  memcpy((char *)pRow->rowData + len, (char *)pStable + sizeof(char *), tsSuperTableUpdateSize);
   len += tsSuperTableUpdateSize;
 
   int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags);
-  memcpy(pRow->rowData + len, pStable->schema, schemaSize);
+  memcpy((char *)pRow->rowData + len, pStable->schema, schemaSize);
   len += schemaSize;
 
   pRow->rowSize = len;
@@ -525,7 +525,7 @@ static int32_t mnodeSuperTableActionDecode(SSdbRow *pRow) {
   SSTableObj *pStable = (SSTableObj *) calloc(1, sizeof(SSTableObj));
   if (pStable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
 
-  int32_t len = strlen(pRow->rowData);
+  int32_t len = (int32_t)strlen(pRow->rowData);
   if (len >= TSDB_TABLE_FNAME_LEN){
     free(pStable);
     return TSDB_CODE_MND_INVALID_TABLE_ID;
@@ -533,7 +533,7 @@ static int32_t mnodeSuperTableActionDecode(SSdbRow *pRow) {
   pStable->info.tableId = strdup(pRow->rowData);
   len++;
 
-  memcpy((char*)pStable + sizeof(char *), pRow->rowData + len, tsSuperTableUpdateSize);
+  memcpy((char *)pStable + sizeof(char *), (char *)pRow->rowData + len, tsSuperTableUpdateSize);
   len += tsSuperTableUpdateSize;
 
   int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags);
@@ -543,8 +543,7 @@ static int32_t mnodeSuperTableActionDecode(SSdbRow *pRow) {
     return TSDB_CODE_MND_NOT_SUPER_TABLE;
   }
 
-  memcpy(pStable->schema, pRow->rowData + len, schemaSize);
-
+  memcpy(pStable->schema, (char *)pRow->rowData + len, schemaSize);
   pRow->pObj = pStable;
 
   return TSDB_CODE_SUCCESS;
@@ -556,14 +555,14 @@ static int32_t mnodeSuperTableActionRestored() {
 
 static int32_t mnodeInitSuperTables() {
   SSTableObj tObj;
-  tsSuperTableUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type;
+  tsSuperTableUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_STABLE,
     .name         = "stables",
     .hashSessions = TSDB_DEFAULT_STABLES_HASH_SIZE,
     .maxRowSize   = sizeof(SSTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_FNAME_LEN,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_VAR_STRING,
     .fpInsert     = mnodeSuperTableActionInsert,
     .fpDelete     = mnodeSuperTableActionDelete,
@@ -844,6 +843,7 @@ static int32_t mnodeProcessBatchCreateTableMsg(SMnodeMsg *pMsg) {
       return TSDB_CODE_MND_ACTION_IN_PROGRESS;
     } else { // batch master replay, reprocess the whole batch
       assert(0);
+      return TSDB_CODE_MND_MSG_NOT_PROCESSED;
     }
   }
 }
@@ -1257,7 +1257,7 @@ static int32_t mnodeModifySuperTableTagName(SMnodeMsg *pMsg, char *oldTagName, c
   }
 
   // int32_t  rowSize = 0;
-  uint32_t len = strlen(newTagName);
+  uint32_t len = (int32_t)strlen(newTagName);
   if (len >= TSDB_COL_NAME_LEN) {
     return TSDB_CODE_MND_COL_NAME_TOO_LONG;
   }
@@ -1420,7 +1420,7 @@ static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg, char *oldName, char
   }
 
   // int32_t  rowSize = 0;
-  uint32_t len = strlen(newName);
+  uint32_t len = (uint32_t)strlen(newName);
   if (len >= TSDB_COL_NAME_LEN) {
     return TSDB_CODE_MND_COL_NAME_TOO_LONG;
   }
@@ -1525,7 +1525,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
 
   tstrncpy(prefix, pDb->name, 64);
   strcat(prefix, TS_PATH_DELIMITER);
-  prefixLen = strlen(prefix);
+  prefixLen = (int32_t)strlen(prefix);
 
   SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
   char stableName[TSDB_TABLE_NAME_LEN] = {0};
@@ -1550,7 +1550,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
 
-    int16_t len = strnlen(stableName, TSDB_TABLE_NAME_LEN - 1);
+    int16_t len = (int16_t)strnlen(stableName, TSDB_TABLE_NAME_LEN - 1);
     *(int16_t*) pWrite = len;
     pWrite += sizeof(int16_t); // todo refactor
 
@@ -1593,7 +1593,7 @@ void mnodeDropAllSuperTables(SDbObj *pDropDb) {
   char prefix[64] = {0};
   tstrncpy(prefix, pDropDb->name, 64);
   strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = strlen(prefix);
+  int32_t prefixLen = (int32_t)strlen(prefix);
 
   mInfo("db:%s, all super tables will be dropped from sdb", pDropDb->name);
 
@@ -1746,9 +1746,9 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
     rpcFreeCont(pRsp);
     return TSDB_CODE_MND_INVALID_TABLE_NAME;
   } else {
-    pRsp->numOfTables = htonl(pRsp->numOfTables);
+    pRsp->numOfTables = (int32_t)htonl(pRsp->numOfTables);
     pMsg->rpcRsp.rsp = pRsp;
-    pMsg->rpcRsp.len = msg - (char *)pRsp;
+    pMsg->rpcRsp.len = (int32_t)((char *)msg - (char *)pRsp);
 
     return TSDB_CODE_SUCCESS;
   }
@@ -2021,7 +2021,7 @@ static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
 
 static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
   //SCMCreateTableMsg* p1 = pMsg->rpcMsg.pCont; // there are several tables here.
-  SCreateTableMsg* pCreate = (SCreateTableMsg*)(pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
+  SCreateTableMsg* pCreate = (SCreateTableMsg*)((char *)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
 
   int32_t code = grantCheck(TSDB_GRANT_TIMESERIES);
   if (code != TSDB_CODE_SUCCESS) {
@@ -2278,7 +2278,7 @@ static int32_t mnodeChangeNormalTableColumn(SMnodeMsg *pMsg, char *oldName, char
   }
 
   // int32_t  rowSize = 0;
-  uint32_t len = strlen(newName);
+  uint32_t len = (uint32_t)strlen(newName);
   if (len >= TSDB_COL_NAME_LEN) {
     return TSDB_CODE_MND_COL_NAME_TOO_LONG;
   }
@@ -2481,7 +2481,7 @@ void mnodeDropAllChildTables(SDbObj *pDropDb) {
   char prefix[64] = {0};
   tstrncpy(prefix, pDropDb->name, 64);
   strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = strlen(prefix);
+  int32_t prefixLen = (int32_t)strlen(prefix);
 
   mInfo("db:%s, all child tables will be dropped from sdb", pDropDb->name);
 
@@ -2897,7 +2897,7 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows
   SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
 
   char prefix[64] = {0};
-  int32_t prefixLen = tableIdPrefix(pDb->name, prefix, 64);
+  int32_t prefixLen = (int32_t)tableIdPrefix(pDb->name, prefix, 64);
 
   char* pattern = NULL;
   if (pShow->payloadLen > 0) {
@@ -3133,7 +3133,7 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
   char prefix[64] = {0};
   tstrncpy(prefix, pDb->name, 64);
   strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = strlen(prefix);
+  int32_t prefixLen = (int32_t)strlen(prefix);
 
   while (numOfRows < rows) {
     pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);

src/mnode/src/mnodeUser.c

@@ -128,7 +128,7 @@ static void mnodePrintUserAuth() {
 }
 
 static int32_t mnodeUserActionRestored() {
-  int32_t numOfRows = sdbGetNumOfRows(tsUserSdb);
+  int64_t numOfRows = sdbGetNumOfRows(tsUserSdb);
   if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
     mInfo("dnode first deploy, create root user");
     SAcctObj *pAcct = mnodeGetAcct(TSDB_DEFAULT_USER);
@@ -148,14 +148,14 @@ static int32_t mnodeUserActionRestored() {
 
 int32_t mnodeInitUsers() {
   SUserObj tObj;
-  tsUserUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsUserUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_USER,
     .name         = "users",
     .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
     .maxRowSize   = tsUserUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_STRING,
     .fpInsert     = mnodeUserActionInsert,
     .fpDelete     = mnodeUserActionDelete,
@@ -204,11 +204,11 @@ void mnodeCancelGetNextUser(void *pIter) {
 }
 
 void mnodeIncUserRef(SUserObj *pUser) { 
-  return sdbIncRef(tsUserSdb, pUser); 
+  sdbIncRef(tsUserSdb, pUser); 
 }
 
 void mnodeDecUserRef(SUserObj *pUser) { 
-  return sdbDecRef(tsUserSdb, pUser); 
+  sdbDecRef(tsUserSdb, pUser); 
 }
 
 static int32_t mnodeUpdateUser(SUserObj *pUser, void *pMsg) {
@@ -561,7 +561,7 @@ static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) {
 void mnodeDropAllUsers(SAcctObj *pAcct)  {
   void *    pIter = NULL;
   int32_t   numOfUsers = 0;
-  int32_t   acctNameLen = strlen(pAcct->user);
+  int32_t   acctNameLen = (int32_t)strlen(pAcct->user);
   SUserObj *pUser = NULL;
 
   while (1) {

src/mnode/src/mnodeVgroup.c

@@ -206,14 +206,14 @@ static int32_t mnodeVgroupActionRestored() {
 
 int32_t mnodeInitVgroups() {
   SVgObj tObj;
-  tsVgUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
+  tsVgUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
 
   SSdbTableDesc desc = {
     .id           = SDB_TABLE_VGROUP,
     .name         = "vgroups",
     .hashSessions = TSDB_DEFAULT_VGROUPS_HASH_SIZE,
     .maxRowSize   = tsVgUpdateSize,
-    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
     .keyType      = SDB_KEY_AUTO,
     .fpInsert     = mnodeVgroupActionInsert,
     .fpDelete     = mnodeVgroupActionDelete,
@@ -245,11 +245,11 @@ int32_t mnodeInitVgroups() {
 }
 
 void mnodeIncVgroupRef(SVgObj *pVgroup) {
-  return sdbIncRef(tsVgroupSdb, pVgroup); 
+  sdbIncRef(tsVgroupSdb, pVgroup); 
 }
 
 void mnodeDecVgroupRef(SVgObj *pVgroup) { 
-  return sdbDecRef(tsVgroupSdb, pVgroup); 
+  sdbDecRef(tsVgroupSdb, pVgroup); 
 }
 
 SVgObj *mnodeGetVgroup(int32_t vgId) {

src/os/inc/os.h

@@ -62,6 +62,7 @@ extern "C" {
 #include "osMemory.h"
 #include "osRand.h"
 #include "osSemphone.h"
+#include "osSignal.h"
 #include "osSocket.h"
 #include "osString.h"
 #include "osSysinfo.h"

src/os/inc/osDef.h

@@ -20,6 +20,12 @@
 extern "C" {
 #endif
 
+#ifndef WINDOWS
+  #ifndef O_BINARY
+    #define O_BINARY 0
+  #endif
+#endif
+
 #ifndef STDERR_FILENO
 #define STDERR_FILENO (2)
 #endif
@@ -94,8 +100,7 @@ extern "C" {
 #elif defined(__GNUC__) && !defined(threadlocal)
   #define threadlocal __thread
 #else
-  // #define threadlocal
-  #error please follow with the thread-local implementation on the target platform 
+  #define threadlocal __declspec( thread )
 #endif
 
 #ifdef __cplusplus

src/os/inc/osFile.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+#include "osSocket.h"
+
 int64_t taosReadImp(int32_t fd, void *buf, int64_t count);
 int64_t taosWriteImp(int32_t fd, void *buf, int64_t count);
 int64_t taosLSeekImp(int32_t fd, int64_t offset, int32_t whence);
@@ -37,7 +39,7 @@ int32_t taosRenameFile(char *fullPath, char *suffix, char delimiter, char **dstP
   }
 
 // TAOS_OS_FUNC_FILE_SENDIFLE
-int64_t taosSendFile(int32_t dfd, int32_t sfd, int64_t *offset, int64_t size);
+int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t *offset, int64_t size);
 int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size);
 
 #ifdef TAOS_RANDOM_FILE_FAIL

src/os/inc/osSignal.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_SIGNAL_H
+#define TDENGINE_OS_SIGNAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "os.h"
+#include "taosdef.h"
+#include <signal.h>
+
+#ifndef SIGALRM
+  #define SIGALRM 1234
+#endif
+
+#ifndef SIGHUP
+  #define SIGHUP 1230
+#endif
+
+#ifndef SIGCHLD
+  #define SIGCHLD 1234
+#endif
+
+#ifndef SIGUSR1
+  #define SIGUSR1 1234
+#endif
+
+#ifndef SIGUSR2
+  #define SIGUSR2 1234
+#endif
+
+#ifndef SIGBREAK
+  #define SIGBREAK 1234
+#endif
+
+typedef void (*FSignalHandler)(int32_t signum, void *sigInfo, void *context);
+void taosSetSignal(int32_t signum, FSignalHandler sigfp);
+void taosIgnSignal(int32_t signum);
+void taosDflSignal(int32_t signum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_TTIME_H

src/os/inc/osSocket.h

@@ -33,11 +33,13 @@ extern "C" {
         x = FD_INITIALIZER;  \
       }                      \
     }
-  typedef int32_t SOCKET;
 #endif
 
 #ifndef TAOS_OS_DEF_EPOLL
   #define TAOS_EPOLL_WAIT_TIME 500 
+  typedef int32_t SOCKET;
+  typedef SOCKET EpollFd;
+  #define EpollClose(pollFd) taosCloseSocket(pollFd)
 #endif  
 
 #ifdef TAOS_RANDOM_NETWORK_FAIL
@@ -61,6 +63,7 @@ extern "C" {
 int32_t taosSetNonblocking(SOCKET sock, int32_t on);
 void    taosIgnSIGPIPE();
 void    taosBlockSIGPIPE();
+void    taosSetMaskSIGPIPE();
 
 // TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
 int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t optlen);

src/os/inc/osWindows.h

@@ -93,6 +93,12 @@ typedef SOCKET eventfd_t;
 
 #define TAOS_OS_DEF_EPOLL
   #define TAOS_EPOLL_WAIT_TIME 100
+  typedef SOCKET EpollFd; 
+  #define EpollClose(pollFd) epoll_close(pollFd) 
+  
+#ifndef EPOLLWAKEUP
+  #define EPOLLWAKEUP (1u << 29)
+#endif
 
 #define TAOS_OS_DEF_ZU
   #define PRIzu "ld"  
@@ -191,13 +197,7 @@ int        gettimeofday(struct timeval *ptv, void *pTimeZone);
   #define PATH_MAX 256
 #endif
 
-//for signal, not dispose
-#define SIGALRM 1234
-typedef int sigset_t;
-struct sigaction {
-  void (*sa_handler)(int);
-};
-int sigaction(int, struct sigaction *, void *);
+#define TAOS_OS_FUNC_SIGNAL
 
 typedef struct {
   int    we_wordc;
@@ -208,6 +208,12 @@ typedef struct {
 int  wordexp(const char *words, wordexp_t *pwordexp, int flags);
 void wordfree(wordexp_t *pwordexp);
 
+#define openlog(a, b, c)
+#define closelog()
+#define LOG_ERR 0
+#define LOG_INFO 1
+void syslog(int unused, const char *format, ...);
+
 #define TAOS_OS_FUNC_ATOMIC
   #define atomic_load_8(ptr) (*(char volatile*)(ptr))
   #define atomic_load_16(ptr) (*(short volatile*)(ptr))

src/os/src/darwin/darwinFile.c

@@ -51,7 +51,37 @@ int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t co
   return writeLen;
 }
 
-int64_t taosSendFile(int32_t dfd, int32_t sfd, int64_t* offset, int64_t size) {
-  uError("taosSendFile not implemented yet");
-  return -1;
-}
+int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t* offset, int64_t count) {
+  lseek(sfd, (int32_t)(*offset), 0);
+  int64_t writeLen = 0;
+  uint8_t buffer[_SEND_FILE_STEP_] = { 0 };
\ No newline at end of file
+  
+  for (int64_t len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
+    int32_t rlen = (int32_t)read(sfd, buffer, _SEND_FILE_STEP_);
+    if (rlen <= 0) {
+      return writeLen;
+    }
+    else if (rlen < _SEND_FILE_STEP_) {
+      taosWriteSocket(dfd, buffer, rlen);
+      return (int64_t)(writeLen + rlen);
+    }
+    else {
+      taosWriteSocket(dfd, buffer, _SEND_FILE_STEP_);
+      writeLen += _SEND_FILE_STEP_;
+    }
+  }
+
+  int64_t remain = count - writeLen;
+  if (remain > 0) {
+    int32_t rlen = read(sfd, buffer, (int32_t)remain);
+    if (rlen <= 0) {
+      return writeLen;
+    }
+    else {
+      taosWriteSocket(sfd, buffer, (int32_t)remain);
+      writeLen += remain;
+    }
+  }
+
+  return writeLen;
+}

src/os/src/darwin/darwinSysInfo.c

@@ -101,4 +101,6 @@ int taosSystem(const char *cmd) {
   return -1;
 }
 
-void taosSetCoreDump() {}
+void taosSetCoreDump() {}
\ No newline at end of file
+
+char *taosGetCmdlineByPID(int pid) { return ""; }
\ No newline at end of file

src/os/src/detail/osDir.c

@@ -54,6 +54,9 @@ int taosMkDir(const char *path, mode_t mode) {
 void taosRename(char* oldName, char *newName) {
   // if newName in not empty, rename return fail. 
   // the newName must be empty or does not exist
+#ifdef WINDOWS
+  remove(newName);
+#endif
   if (rename(oldName, newName)) {
     uError("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
   } else {
@@ -117,7 +120,7 @@ int32_t taosCompressFile(char *srcFileName, char *destFileName) {
     goto cmp_end;
   }
 
-  int32_t fd = open(destFileName, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
+  int32_t fd = open(destFileName, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRWXU | S_IRWXG | S_IRWXO);
   if (fd < 0) {
     ret = -2;
     goto cmp_end;

src/os/src/detail/osFile.c

@@ -121,15 +121,11 @@ int64_t taosLSeekImp(int32_t fd, int64_t offset, int32_t whence) {
 
 #ifndef TAOS_OS_FUNC_FILE_SENDIFLE
 
-int64_t taosSendFile(int32_t dfd, int32_t sfd, int64_t *offset, int64_t size) {
+int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t *offset, int64_t size) {
   int64_t leftbytes = size;
   int64_t sentbytes;
 
   while (leftbytes > 0) {
-    /*
-     * TODO : Think to check if file is larger than 1GB
-     */
-    // if (leftbytes > 1000000000) leftbytes = 1000000000;
     sentbytes = sendfile(dfd, sfd, offset, leftbytes);
     if (sentbytes == -1) {
       if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) {

src/os/src/detail/osSignal.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+#ifndef TAOS_OS_FUNC_SIGNAL
+typedef void (*FLinuxSignalHandler)(int32_t signum, siginfo_t *sigInfo, void *context);
+
+void taosSetSignal(int32_t signum, FSignalHandler sigfp) {
+  struct sigaction act = {{0}};	
+#if 1
+  act.sa_flags = SA_SIGINFO;
+  act.sa_sigaction = (FLinuxSignalHandler)sigfp;
+#else  
+  act.sa_handler = sigfp;	
+#endif  
+  sigaction(signum, &act, NULL);		
+}
+
+void taosIgnSignal(int32_t signum) {
+  signal(signum, SIG_IGN);
+}
+
+void taosDflSignal(int32_t signum) {
+  signal(signum, SIG_DFL);
+}
+
+#endif

src/os/src/detail/osSocket.c

@@ -53,6 +53,16 @@ void taosBlockSIGPIPE() {
   }
 }
 
+void taosSetMaskSIGPIPE() {
+  sigset_t signal_mask;
+  sigemptyset(&signal_mask);
+  sigaddset(&signal_mask, SIGPIPE);
+  int32_t rc = pthread_sigmask(SIG_SETMASK, &signal_mask, NULL);
+  if (rc != 0) {
+    uError("failed to setmask SIGPIPE");
+  }
+}
+
 #endif
 
 #ifndef TAOS_OS_FUNC_SOCKET_SETSOCKETOPT

src/os/src/detail/osSysinfo.c

@@ -45,6 +45,21 @@ static char  tsProcMemFile[25] = {0};
 static char  tsProcIOFile[25] = {0};
 static float tsPageSizeKB = 0;
 
+static void taosGetProcInfos() {
+  tsPageSize = sysconf(_SC_PAGESIZE);
+  tsOpenMax = sysconf(_SC_OPEN_MAX);
+  tsStreamMax = sysconf(_SC_STREAM_MAX);
+
+  tsProcId = (pid_t)syscall(SYS_gettid);
+  tsPageSizeKB = (float)(sysconf(_SC_PAGESIZE)) / 1024;
+
+  snprintf(tsProcMemFile, 25, "/proc/%d/status", tsProcId);
+  snprintf(tsProcCpuFile, 25, "/proc/%d/stat", tsProcId);
+  snprintf(tsProcIOFile, 25, "/proc/%d/io", tsProcId);
+}
+
+static int32_t taosGetTotalMemory() { return (int32_t)((float)sysconf(_SC_PHYS_PAGES) * tsPageSizeKB / 1024); }
+
 bool taosGetSysMemory(float *memoryUsedMB) {
   float memoryAvailMB = (float)sysconf(_SC_AVPHYS_PAGES) * tsPageSizeKB / 1024;
   *memoryUsedMB = (float)tsTotalMemoryMB - memoryAvailMB;
@@ -105,7 +120,8 @@ static bool taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
   }
 
   char cpu[10] = {0};
-  sscanf(line, "%s %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, cpu, &cpuInfo->user, &cpuInfo->nice, &cpuInfo->system, &cpuInfo->idle);
+  sscanf(line, "%s %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, cpu, &cpuInfo->user, &cpuInfo->nice, &cpuInfo->system,
+         &cpuInfo->idle);
 
   tfree(line);
   fclose(fp);
@@ -131,7 +147,8 @@ static bool taosGetProcCpuInfo(ProcCpuInfo *cpuInfo) {
   for (int i = 0, blank = 0; line[i] != 0; ++i) {
     if (line[i] == ' ') blank++;
     if (blank == PROCESS_ITEM) {
-      sscanf(line + i + 1, "%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, &cpuInfo->utime, &cpuInfo->stime, &cpuInfo->cutime, &cpuInfo->cstime);
+      sscanf(line + i + 1, "%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, &cpuInfo->utime, &cpuInfo->stime,
+             &cpuInfo->cutime, &cpuInfo->cstime);
       break;
     }
   }
@@ -162,12 +179,12 @@ static void taosGetSystemTimezone() {
   char  buf[68] = {0};
   if (f != NULL) {
     int len = fread(buf, 64, 1, f);
-    if(len < 64 && ferror(f)) {
+    if (len < 64 && ferror(f)) {
       fclose(f);
       uError("read /etc/timezone error, reason:%s", strerror(errno));
       return;
     }
-    
+
     fclose(f);
 
     buf[sizeof(buf) - 1] = 0;
@@ -258,6 +275,8 @@ static void taosGetSystemLocale() {  // get and set default locale
   }
 }
 
+static int32_t taosGetCpuCores() { return (int32_t)sysconf(_SC_NPROCESSORS_ONLN); }
+
 bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) {
   static uint64_t lastSysUsed = 0;
   static uint64_t lastSysTotal = 0;
@@ -300,11 +319,9 @@ bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) {
 bool taosGetDisk() {
   struct statvfs info;
   const double   unit = 1024 * 1024 * 1024;
-  
+
   if (tscEmbedded) {
     if (statvfs(tsDataDir, &info)) {
-      //tsTotalDataDirGB = 0;
-      //tsAvailDataDirGB = 0;
       uError("failed to get disk size, dataDir:%s errno:%s", tsDataDir, strerror(errno));
       return false;
     } else {
@@ -314,8 +331,6 @@ bool taosGetDisk() {
   }
 
   if (statvfs(tsLogDir, &info)) {
-    //tsTotalLogDirGB = 0;
-    //tsAvailLogDirGB = 0;
     uError("failed to get disk size, logDir:%s errno:%s", tsLogDir, strerror(errno));
     return false;
   } else {
@@ -324,8 +339,6 @@ bool taosGetDisk() {
   }
 
   if (statvfs("/tmp", &info)) {
-    //tsTotalTmpDirGB = 0;
-    //tsAvailTmpDirectorySpace = 0;
     uError("failed to get disk size, tmpDir:/tmp errno:%s", strerror(errno));
     return false;
   } else {
@@ -344,13 +357,12 @@ static bool taosGetCardInfo(int64_t *bytes) {
     return false;
   }
 
-
   size_t len = 2048;
   char * line = calloc(1, len);
 
   while (!feof(fp)) {
     memset(line, 0, len);
-    
+
     int64_t rbytes = 0;
     int64_t rpackts = 0;
     int64_t tbytes = 0;
@@ -465,7 +477,7 @@ bool taosGetProcIO(float *readKB, float *writeKB) {
   static int64_t lastReadbyte = -1;
   static int64_t lastWritebyte = -1;
 
-  int64_t curReadbyte  = 0;
+  int64_t curReadbyte = 0;
   int64_t curWritebyte = 0;
 
   if (!taosReadProcIO(&curReadbyte, &curWritebyte)) {
@@ -490,18 +502,10 @@ bool taosGetProcIO(float *readKB, float *writeKB) {
 }
 
 void taosGetSystemInfo() {
-  tsNumOfCores = (int32_t)sysconf(_SC_NPROCESSORS_ONLN);
-  tsPageSize = sysconf(_SC_PAGESIZE);
-  tsOpenMax = sysconf(_SC_OPEN_MAX);
-  tsStreamMax = sysconf(_SC_STREAM_MAX);
+  taosGetProcInfos();
 
-  tsProcId = (pid_t)syscall(SYS_gettid);
-  tsPageSizeKB = (float)(sysconf(_SC_PAGESIZE)) / 1024;
-  tsTotalMemoryMB = (int32_t)((float)sysconf(_SC_PHYS_PAGES) * tsPageSizeKB / 1024);
-
-  snprintf(tsProcMemFile, 25, "/proc/%d/status", tsProcId);
-  snprintf(tsProcCpuFile, 25, "/proc/%d/stat", tsProcId);
-  snprintf(tsProcIOFile, 25, "/proc/%d/io", tsProcId);
+  tsNumOfCores = taosGetCpuCores();
+  tsTotalMemoryMB = taosGetTotalMemory();
 
   float tmp1, tmp2;
   taosGetSysMemory(&tmp1);
@@ -573,16 +577,16 @@ void taosSetCoreDump() {
   if (0 == tsEnableCoreFile) {
     return;
   }
-  
+
   // 1. set ulimit -c unlimited
   struct rlimit rlim;
   struct rlimit rlim_new;
   if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
-    #ifndef _ALPINE
+#ifndef _ALPINE
     uInfo("the old unlimited para: rlim_cur=%" PRIu64 ", rlim_max=%" PRIu64, rlim.rlim_cur, rlim.rlim_max);
-    #else
+#else
     uInfo("the old unlimited para: rlim_cur=%llu, rlim_max=%llu", rlim.rlim_cur, rlim.rlim_max);
-    #endif
+#endif
     rlim_new.rlim_cur = RLIM_INFINITY;
     rlim_new.rlim_max = RLIM_INFINITY;
     if (setrlimit(RLIMIT_CORE, &rlim_new) != 0) {
@@ -594,57 +598,56 @@ void taosSetCoreDump() {
   }
 
   if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
-    #ifndef _ALPINE
+#ifndef _ALPINE
     uInfo("the new unlimited para: rlim_cur=%" PRIu64 ", rlim_max=%" PRIu64, rlim.rlim_cur, rlim.rlim_max);
-    #else
+#else
     uInfo("the new unlimited para: rlim_cur=%llu, rlim_max=%llu", rlim.rlim_cur, rlim.rlim_max);
-    #endif
+#endif
   }
 
 #ifndef _TD_ARM_
   // 2. set the path for saving core file
   struct __sysctl_args args;
-  int     old_usespid = 0;
-  size_t  old_len     = 0;
-  int     new_usespid = 1;
-  size_t  new_len     = sizeof(new_usespid);
-  
+
+  int    old_usespid = 0;
+  size_t old_len = 0;
+  int    new_usespid = 1;
+  size_t new_len = sizeof(new_usespid);
+
   int name[] = {CTL_KERN, KERN_CORE_USES_PID};
-  
+
   memset(&args, 0, sizeof(struct __sysctl_args));
-  args.name    = name;
-  args.nlen    = sizeof(name)/sizeof(name[0]);
-  args.oldval  = &old_usespid;
+  args.name = name;
+  args.nlen = sizeof(name) / sizeof(name[0]);
+  args.oldval = &old_usespid;
   args.oldlenp = &old_len;
-  args.newval  = &new_usespid;
-  args.newlen  = new_len;
-  
+  args.newval = &new_usespid;
+  args.newlen = new_len;
+
   old_len = sizeof(old_usespid);
-  
+
   if (syscall(SYS__sysctl, &args) == -1) {
-      uInfo("_sysctl(kern_core_uses_pid) set fail: %s", strerror(errno));
+    uInfo("_sysctl(kern_core_uses_pid) set fail: %s", strerror(errno));
   }
-  
-  uInfo("The old core_uses_pid[%" PRIu64 "]: %d", old_len, old_usespid);
 
+  uInfo("The old core_uses_pid[%" PRIu64 "]: %d", old_len, old_usespid);
 
   old_usespid = 0;
-  old_len     = 0;
+  old_len = 0;
   memset(&args, 0, sizeof(struct __sysctl_args));
-  args.name    = name;
-  args.nlen    = sizeof(name)/sizeof(name[0]);
-  args.oldval  = &old_usespid;
+  args.name = name;
+  args.nlen = sizeof(name) / sizeof(name[0]);
+  args.oldval = &old_usespid;
   args.oldlenp = &old_len;
-  
+
   old_len = sizeof(old_usespid);
-  
+
   if (syscall(SYS__sysctl, &args) == -1) {
-      uInfo("_sysctl(kern_core_uses_pid) get fail: %s", strerror(errno));
+    uInfo("_sysctl(kern_core_uses_pid) get fail: %s", strerror(errno));
   }
-  
+
   uInfo("The new core_uses_pid[%" PRIu64 "]: %d", old_len, old_usespid);
 #endif
-
 }
 
 bool taosGetSystemUid(char *uid) {

src/os/src/linux/linuxEnv.c

@@ -18,7 +18,6 @@
 #include "tglobal.h"
 
 void osInit() {
-
 #ifdef _TD_POWER_
   if (configDir[0] == 0) {
     strcpy(configDir, "/etc/power");
@@ -43,16 +42,14 @@ void osInit() {
 
 char cmdline[1024];
 
-char *taosGetCmdlineByPID(int pid)
-{
-  sprintf(cmdline, "/proc/%d/cmdline",pid);
-  FILE* f = fopen(cmdline,"r");
-  if(f){
+char* taosGetCmdlineByPID(int pid) {
+  sprintf(cmdline, "/proc/%d/cmdline", pid);
+  FILE* f = fopen(cmdline, "r");
+  if (f) {
     size_t size;
     size = fread(cmdline, sizeof(char), 1024, f);
-    if(size>0){
-      if('\n'==cmdline[size-1])
-        cmdline[size-1]='\0';
+    if (size > 0) {
+      if ('\n' == cmdline[size - 1]) cmdline[size - 1] = '\0';
     }
     fclose(f);
   }

src/os/src/windows/wFile.c

@@ -15,18 +15,19 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
-#include "tulog.h"
+#include "osSocket.h"
 #include "tglobal.h"
+#include "tulog.h"
 
 void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
-  const char* tdengineTmpFileNamePrefix = "tdengine-";
-  char tmpPath[PATH_MAX];
+  const char *tdengineTmpFileNamePrefix = "tdengine-";
+  char        tmpPath[PATH_MAX];
 
   int32_t len = (int32_t)strlen(tsTempDir);
   memcpy(tmpPath, tsTempDir, len);
 
   if (tmpPath[len - 1] != '/' && tmpPath[len - 1] != '\\') {
-      tmpPath[len++] = '\\';
+    tmpPath[len++] = '\\';
   }
 
   strcpy(tmpPath + len, tdengineTmpFileNamePrefix);
@@ -35,7 +36,7 @@ void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
     strcat(tmpPath, fileNamePrefix);
     strcat(tmpPath, "-%d-%s");
   }
-  
+
   char rand[8] = {0};
   taosRandStr(rand, tListLen(rand) - 1);
   snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
@@ -46,18 +47,16 @@ void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
 int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t count) {
   fseek(in_file, (int32_t)(*offset), 0);
   int64_t writeLen = 0;
-  uint8_t buffer[_SEND_FILE_STEP_] = { 0 };
-  
+  uint8_t buffer[_SEND_FILE_STEP_] = {0};
+
   for (int64_t len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
     size_t rlen = fread(buffer, 1, _SEND_FILE_STEP_, in_file);
     if (rlen <= 0) {
       return writeLen;
-    }
-    else if (rlen < _SEND_FILE_STEP_) {
+    } else if (rlen < _SEND_FILE_STEP_) {
       fwrite(buffer, 1, rlen, out_file);
       return (int64_t)(writeLen + rlen);
-    }
-    else {
+    } else {
       fwrite(buffer, 1, _SEND_FILE_STEP_, in_file);
       writeLen += _SEND_FILE_STEP_;
     }
@@ -65,12 +64,44 @@ int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t co
 
   int64_t remain = count - writeLen;
   if (remain > 0) {
-    size_t rlen = fread(buffer, 1, (size_t) remain, in_file);
+    size_t rlen = fread(buffer, 1, (size_t)remain, in_file);
     if (rlen <= 0) {
       return writeLen;
+    } else {
+      fwrite(buffer, 1, (size_t)remain, out_file);
+      writeLen += remain;
+    }
+  }
+
+  return writeLen;
+}
+
+int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t *offset, int64_t count) {
+  if (offset != NULL) lseek(sfd, (int32_t)(*offset), 0);
+
+  int64_t writeLen = 0;
+  uint8_t buffer[_SEND_FILE_STEP_] = {0};
+
+  for (int64_t len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
+    int32_t rlen = (int32_t)read(sfd, buffer, _SEND_FILE_STEP_);
+    if (rlen <= 0) {
+      return writeLen;
+    } else if (rlen < _SEND_FILE_STEP_) {
+      taosWriteSocket(dfd, buffer, rlen);
+      return (int64_t)(writeLen + rlen);
+    } else {
+      taosWriteSocket(dfd, buffer, _SEND_FILE_STEP_);
+      writeLen += _SEND_FILE_STEP_;
     }
-    else {
-      fwrite(buffer, 1, (size_t) remain, out_file);
+  }
+
+  int64_t remain = count - writeLen;
+  if (remain > 0) {
+    int32_t rlen = read(sfd, buffer, (int32_t)remain);
+    if (rlen <= 0) {
+      return writeLen;
+    } else {
+      taosWriteSocket(sfd, buffer, (int32_t)remain);
       writeLen += remain;
     }
   }
@@ -78,12 +109,66 @@ int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t co
   return writeLen;
 }
 
-int64_t taosSendFile(int32_t dfd, int32_t sfd, int64_t* offset, int64_t size) {
-  uError("taosSendFile no implemented yet");
+int32_t taosFtruncate(int32_t fd, int64_t l_size) {
+  if (fd < 0) {
+    errno = EBADF;
+    uError("%s\n", "fd arg was negative");
+    return -1;
+  }
+
+  HANDLE h = (HANDLE)_get_osfhandle(fd);
+
+  LARGE_INTEGER li_0;
+  li_0.QuadPart = (int64_t)0;
+  BOOL cur = SetFilePointerEx(h, li_0, NULL, FILE_CURRENT);
+  if (!cur) {
+    uError("SetFilePointerEx Error getting current position in file.\n");
+    return -1;
+  }
+
+  LARGE_INTEGER li_size;
+  li_size.QuadPart = l_size;
+  BOOL cur2 = SetFilePointerEx(h, li_size, NULL, FILE_BEGIN);
+  if (cur2 == 0) {
+    int error = GetLastError();
+    uError("SetFilePointerEx GetLastError is: %d\n", error);
+    switch (error) {
+      case ERROR_INVALID_HANDLE:
+        errno = EBADF;
+        break;
+      default:
+        errno = EIO;
+        break;
+    }
+    return -1;
+  }
+
+  if (!SetEndOfFile(h)) {
+    int error = GetLastError();
+    uError("SetEndOfFile GetLastError is:%d", error);
+    switch (error) {
+      case ERROR_INVALID_HANDLE:
+        errno = EBADF;
+        break;
+      default:
+        errno = EIO;
+        break;
+    }
+    return -1;
+  }
+
   return 0;
 }
 
-int32_t taosFtruncate(int32_t fd, int64_t length) {
-  uError("taosFtruncate no implemented yet");
-  return 0;
-}
+
+int fsync(int filedes) { 
+  if (filedes < 0) {
+    errno = EBADF;
\ No newline at end of file
+    uError("%s\n", "fd arg was negative");
+    return -1;
+  }
+
+  HANDLE h = (HANDLE)_get_osfhandle(filedes);
+  
+  return FlushFileBuffers(h);
+}

src/os/src/windows/wSignal.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include <signal.h>
+#include <windows.h>
+
+typedef void (*FWinSignalHandler)(int32_t signum);
+
+void taosSetSignal(int32_t signum, FSignalHandler sigfp) {
+  if (signum == SIGUSR1) return;
+
+  // SIGHUP doesn't exist in windows, we handle it in the way of ctrlhandler
+  if (signum == SIGHUP) {
+    SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigfp, TRUE);
+  } else {
+    signal(signum, (FWinSignalHandler)sigfp);	
+  }
+}
+
+void taosIgnSignal(int32_t signum) {
+  if (signum == SIGUSR1 || signum == SIGHUP) return;
+  signal(signum, SIG_IGN);
+}
+
+void taosDflSignal(int32_t signum) {
+  if (signum == SIGUSR1 || signum == SIGHUP) return;
+  signal(signum, SIG_DFL);
+}

src/os/src/windows/wSocket.c

@@ -48,6 +48,7 @@ int32_t taosSetNonblocking(SOCKET sock, int32_t on) {
 
 void taosIgnSIGPIPE() {}
 void taosBlockSIGPIPE() {}
+void taosSetMaskSIGPIPE() {}
 
 int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t optlen) {
   if (level == SOL_SOCKET && optname == TCP_KEEPCNT) {

src/os/src/windows/wSysLog.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+
+void syslog(int unused, const char *format, ...) {}
\ No newline at end of file

src/os/src/windows/wSysinfo.c

@@ -31,11 +31,54 @@
 #pragma comment(lib, "Mswsock.lib ")
 #endif
 
+#include <objbase.h>
+
 #pragma warning(push)
-#pragma warning(disable:4091)
+#pragma warning(disable : 4091)
 #include <DbgHelp.h>
 #pragma warning(pop)
 
+static int32_t taosGetTotalMemory() {
+  MEMORYSTATUSEX memsStat;
+  memsStat.dwLength = sizeof(memsStat);
+  if (!GlobalMemoryStatusEx(&memsStat)) {
+    return 0;
+  }
+
+  float nMemTotal = memsStat.ullTotalPhys / (1024.0f * 1024.0f);
+  return (int32_t)nMemTotal;
+}
+
+bool taosGetSysMemory(float *memoryUsedMB) {
+  MEMORYSTATUSEX memsStat;
+  memsStat.dwLength = sizeof(memsStat);
+  if (!GlobalMemoryStatusEx(&memsStat)) {
+    return false;
+  }
+
+  float nMemFree = memsStat.ullAvailPhys / (1024.0f * 1024.0f);
+  float nMemTotal = memsStat.ullTotalPhys / (1024.0f * 1024.0f);
+
+  *memoryUsedMB = nMemTotal - nMemFree;
+  return true;
+}
+
+bool taosGetProcMemory(float *memoryUsedMB) {
+  unsigned bytes_used = 0;
+
+#if defined(_WIN64) && defined(_MSC_VER)
+  PROCESS_MEMORY_COUNTERS pmc;
+  HANDLE                  cur_proc = GetCurrentProcess();
+
+  if (GetProcessMemoryInfo(cur_proc, &pmc, sizeof(pmc))) {
+    bytes_used = (unsigned)(pmc.WorkingSetSize + pmc.PagefileUsage);
+  }
+#endif
+
+  *memoryUsedMB = (float)bytes_used / 1024 / 1024;
+  return true;
+}
+
 static void taosGetSystemTimezone() {
   // get and set default timezone
   SGlobalCfg *cfg_timezone = taosGetConfigOption("timezone");
@@ -71,16 +114,16 @@ static void taosGetSystemLocale() {
   }
 }
 
-void taosPrintOsInfo() {}
-
-void taosKillSystem() {
-  uError("function taosKillSystem, exit!");
-  exit(0);
+static int32_t taosGetCpuCores() {
+  SYSTEM_INFO info;
+  GetSystemInfo(&info);
+  return (int32_t)info.dwNumberOfProcessors;
 }
 
-void taosGetSystemInfo() {
-  taosGetSystemTimezone();
-  taosGetSystemLocale();
+bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) {
+  *sysCpuUsage = 0;
+  *procCpuUsage = 0;
+  return true;
 }
 
 bool taosGetDisk() {
@@ -89,20 +132,35 @@ bool taosGetDisk() {
   unsigned _int64 i64FreeBytesToCaller;
   unsigned _int64 i64TotalBytes;
   unsigned _int64 i64FreeBytes;
-  char            dir[4] = {'C', ':', '\\', '\0'};
-  int             drive_type;
 
   if (tscEmbedded) {
-    drive_type = GetDriveTypeA(dir);
-    if (drive_type == DRIVE_FIXED) {
-      fResult = GetDiskFreeSpaceExA(dir, (PULARGE_INTEGER)&i64FreeBytesToCaller, (PULARGE_INTEGER)&i64TotalBytes,
-                                    (PULARGE_INTEGER)&i64FreeBytes);
-      if (fResult) {
-        tsTotalDataDirGB = tsTotalLogDirGB = tsTotalTmpDirGB = (float)(i64TotalBytes / unit);
-        tsAvailDataDirGB = tsAvailLogDirGB = tsAvailTmpDirectorySpace = (float)(i64FreeBytes / unit);
-      }
+    fResult = GetDiskFreeSpaceExA(tsDataDir, (PULARGE_INTEGER)&i64FreeBytesToCaller, (PULARGE_INTEGER)&i64TotalBytes,
+                                  (PULARGE_INTEGER)&i64FreeBytes);
+    if (fResult) {
+      tsTotalDataDirGB = (float)(i64TotalBytes / unit);
+      tsAvailDataDirGB = (float)(i64FreeBytes / unit);
     }
   }
+
+  fResult = GetDiskFreeSpaceExA(tsLogDir, (PULARGE_INTEGER)&i64FreeBytesToCaller, (PULARGE_INTEGER)&i64TotalBytes,
+                                (PULARGE_INTEGER)&i64FreeBytes);
+  if (fResult) {
+    tsTotalLogDirGB = (float)(i64TotalBytes / unit);
+    tsAvailLogDirGB = (float)(i64FreeBytes / unit);
+  }
+
+  fResult = GetDiskFreeSpaceExA(tsTempDir, (PULARGE_INTEGER)&i64FreeBytesToCaller, (PULARGE_INTEGER)&i64TotalBytes,
+                                (PULARGE_INTEGER)&i64FreeBytes);
+  if (fResult) {
+    tsTotalTmpDirGB = (float)(i64TotalBytes / unit);
+    tsAvailTmpDirectorySpace = (float)(i64FreeBytes / unit);
+  }
+
+  return true;
+}
+
+bool taosGetBandSpeed(float *bandSpeedKb) {
+  *bandSpeedKb = 0;
   return true;
 }
 
@@ -144,48 +202,30 @@ bool taosGetProcIO(float *readKB, float *writeKB) {
   return true;
 }
 
-bool taosGetBandSpeed(float *bandSpeedKb) {
-  *bandSpeedKb = 0;
-  return true;
-}
-
-bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) {
-  *sysCpuUsage = 0;
-  *procCpuUsage = 0;
-  return true;
-}
-
-bool taosGetProcMemory(float *memoryUsedMB) {
-  unsigned bytes_used = 0;
-#if 0
-#if defined(_WIN32) && defined(_MSC_VER)
-   PROCESS_MEMORY_COUNTERS pmc;
-   HANDLE                  cur_proc = GetCurrentProcess();
-
-   if (GetProcessMemoryInfo(cur_proc, &pmc, sizeof(pmc))) {
-     bytes_used = (unsigned)(pmc.WorkingSetSize + pmc.PagefileUsage);
-   }
-#endif
-#endif
+void taosGetSystemInfo() {
+  tsNumOfCores = taosGetCpuCores();
+  tsTotalMemoryMB = taosGetTotalMemory();
 
-  *memoryUsedMB = (float)bytes_used / 1024 / 1024;
+  float tmp1, tmp2;
+  taosGetDisk();
+  taosGetBandSpeed(&tmp1);
+  taosGetCpuUsage(&tmp1, &tmp2);
+  taosGetProcIO(&tmp1, &tmp2);
 
-  return true;
+  taosGetSystemTimezone();
+  taosGetSystemLocale();
 }
 
-bool taosGetSysMemory(float *memoryUsedMB) {
-  MEMORYSTATUSEX memsStat;
-  float          nMemFree;
-  float          nMemTotal;
+void taosPrintOsInfo() {
+  uInfo(" os numOfCores:          %d", tsNumOfCores);
+  uInfo(" os totalDisk:           %f(GB)", tsTotalDataDirGB);
+  uInfo(" os totalMemory:         %d(MB)", tsTotalMemoryMB);
+  uInfo("==================================");
+}
 
-  memsStat.dwLength = sizeof(memsStat);
-  if (!GlobalMemoryStatusEx(&memsStat)) {
-    return false;
-  }
-  nMemFree = memsStat.ullAvailPhys / (1024.0f * 1024.0f);
-  nMemTotal = memsStat.ullTotalPhys / (1024.0f * 1024.0f);
-  *memoryUsedMB = nMemTotal - nMemFree;
-  return true;
+void taosKillSystem() {
+  uError("function taosKillSystem, exit!");
+  exit(0);
 }
 
 int taosSystem(const char *cmd) {
@@ -195,10 +235,6 @@ int taosSystem(const char *cmd) {
 
 int flock(int fd, int option) { return 0; }
 
-int fsync(int filedes) { return 0; }
-
-int sigaction(int sig, struct sigaction *d, void *p) { return 0; }
-
 LONG WINAPI FlCrashDump(PEXCEPTION_POINTERS ep) {
   typedef BOOL(WINAPI * FxMiniDumpWriteDump)(IN HANDLE hProcess, IN DWORD ProcessId, IN HANDLE hFile,
                                              IN MINIDUMP_TYPE                           DumpType,
@@ -235,4 +271,22 @@ LONG WINAPI FlCrashDump(PEXCEPTION_POINTERS ep) {
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
-void taosSetCoreDump() { SetUnhandledExceptionFilter(&FlCrashDump); }
+void taosSetCoreDump() { SetUnhandledExceptionFilter(&FlCrashDump); }
\ No newline at end of file
+
+bool taosGetSystemUid(char *uid) {
+  GUID guid;
+  CoCreateGuid(&guid);
+
+  sprintf(
+    uid,
+    "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
+    guid.Data1, guid.Data2, guid.Data3,
+    guid.Data4[0], guid.Data4[1],
+    guid.Data4[2], guid.Data4[3],
+    guid.Data4[4], guid.Data4[5],
+    guid.Data4[6], guid.Data4[7]);
+
+  return true;
+}
+
+char *taosGetCmdlineByPID(int pid) { return ""; }

src/plugins/CMakeLists.txt

@@ -3,6 +3,6 @@ PROJECT(TDengine)
 
 ADD_SUBDIRECTORY(monitor)
 ADD_SUBDIRECTORY(http)
-IF (TD_MQTT)
+IF (TD_LINUX AND TD_MQTT)
   ADD_SUBDIRECTORY(mqtt)
 ENDIF ()
\ No newline at end of file

src/plugins/http/CMakeLists.txt

@@ -9,32 +9,15 @@ INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 
-IF (TD_LINUX)
-  ADD_LIBRARY(http ${SRC})
-  TARGET_LINK_LIBRARIES(http z)
+ADD_LIBRARY(http ${SRC})
+TARGET_LINK_LIBRARIES(http z)
 
-  IF (TD_SOMODE_STATIC)
-    TARGET_LINK_LIBRARIES(http taos_static)
-  ELSE ()
-    TARGET_LINK_LIBRARIES(http taos)
-  ENDIF ()
-
-  IF (TD_ADMIN)
-    TARGET_LINK_LIBRARIES(http admin)
-  ENDIF ()
+IF (TD_SOMODE_STATIC)
+  TARGET_LINK_LIBRARIES(http taos_static)
+ELSE ()
+  TARGET_LINK_LIBRARIES(http taos)
 ENDIF ()
 
-IF (TD_DARWIN)
-  ADD_LIBRARY(http ${SRC})
-  TARGET_LINK_LIBRARIES(http z)
-
-  IF (TD_SOMODE_STATIC)
-    TARGET_LINK_LIBRARIES(http taos_static)
-  ELSE ()
-    TARGET_LINK_LIBRARIES(http taos)
-  ENDIF ()
-
-  IF (TD_ADMIN)
-    TARGET_LINK_LIBRARIES(http admin)
-  ENDIF ()
+IF (TD_ADMIN)
+  TARGET_LINK_LIBRARIES(http admin)
 ENDIF ()

src/plugins/http/inc/httpContext.h

@@ -22,7 +22,7 @@ bool        httpInitContexts();
 void        httpCleanupContexts();
 const char *httpContextStateStr(HttpContextState state);
 
-HttpContext *httpCreateContext(int32_t fd);
+HttpContext *httpCreateContext(SOCKET fd);
 bool         httpInitContext(HttpContext *pContext);
 HttpContext *httpGetContext(void * pContext);
 void         httpReleaseContext(HttpContext *pContext, bool clearRes);

src/plugins/http/inc/httpInt.h

@@ -16,6 +16,7 @@
 #ifndef TDENGINE_HTTP_INT_H
 #define TDENGINE_HTTP_INT_H
 
+#include "os.h"
 #include <stdbool.h>
 #include "pthread.h"
 #include "semaphore.h"
@@ -140,7 +141,7 @@ typedef enum {
 
 typedef struct HttpContext {
   int32_t      refCount;
-  int32_t      fd;
+  SOCKET       fd;
   uint32_t     accessTimes;
   uint32_t     lastAccessTime;
   int32_t      state;
@@ -167,7 +168,7 @@ typedef struct HttpThread {
   HttpContext *   pHead;
   pthread_mutex_t threadMutex;
   bool            stop;
-  int32_t         pollFd;
+  EpollFd         pollFd;
   int32_t         numOfContexts;
   int32_t         threadId;
   char            label[HTTP_LABEL_SIZE];
@@ -178,7 +179,9 @@ typedef struct HttpServer {
   char              label[HTTP_LABEL_SIZE];
   uint32_t          serverIp;
   uint16_t          serverPort;
-  int32_t           fd;
+  int8_t            stop;
+  int8_t            reserve;
+  SOCKET            fd;
   int32_t           numOfThreads;
   int32_t           methodScannerLen;
   int32_t           requestNum;

src/plugins/http/src/httpAuth.c

@@ -26,7 +26,7 @@
 int32_t httpParseBasicAuthToken(HttpContext *pContext, char *token, int32_t len) {
   token[len] = '\0';
   int32_t outlen = 0;
-  char *base64 = (char *)base64_decode(token, len, &outlen);
+  char *  base64 = (char *)base64_decode(token, len, &outlen);
   if (base64 == NULL || outlen == 0) {
     httpError("context:%p, fd:%d, basic token:%s parsed error", pContext, pContext->fd, token);
     free(base64);
@@ -49,7 +49,7 @@ int32_t httpParseBasicAuthToken(HttpContext *pContext, char *token, int32_t len)
   strncpy(pContext->user, base64, (size_t)user_len);
   pContext->user[user_len] = 0;
 
-  char *password = user + 1;
+  char *  password = user + 1;
   int32_t pass_len = (int32_t)((base64 + outlen) - password);
   if (pass_len < 1 || pass_len >= HTTP_PASSWORD_LEN) {
     httpError("context:%p, fd:%d, basic token:%s parse password error", pContext, pContext->fd, token);
@@ -66,7 +66,7 @@ int32_t httpParseBasicAuthToken(HttpContext *pContext, char *token, int32_t len)
 
 int32_t httpParseTaosdAuthToken(HttpContext *pContext, char *token, int32_t len) {
   token[len] = '\0';
-  int32_t outlen = 0;
+  int32_t        outlen = 0;
   unsigned char *base64 = base64_decode(token, len, &outlen);
   if (base64 == NULL || outlen == 0) {
     httpError("context:%p, fd:%d, taosd token:%s parsed error", pContext, pContext->fd, token);
@@ -97,7 +97,7 @@ int32_t httpParseTaosdAuthToken(HttpContext *pContext, char *token, int32_t len)
 }
 
 int32_t httpGenTaosdAuthToken(HttpContext *pContext, char *token, int32_t maxLen) {
-  char buffer[sizeof(pContext->user) + sizeof(pContext->pass)] = {0};
+  char   buffer[sizeof(pContext->user) + sizeof(pContext->pass)] = {0};
   size_t size = sizeof(pContext->user);
   tstrncpy(buffer, pContext->user, size);
   size = sizeof(pContext->pass);

src/plugins/http/src/httpContext.c

@@ -35,20 +35,24 @@ static void httpRemoveContextFromEpoll(HttpContext *pContext) {
   HttpThread *pThread = pContext->pThread;
   if (pContext->fd >= 0) {
     epoll_ctl(pThread->pollFd, EPOLL_CTL_DEL, pContext->fd, NULL);
-    int32_t fd = atomic_val_compare_exchange_32(&pContext->fd, pContext->fd, -1);
+#ifdef WINDOWS
+    SOCKET fd = atomic_val_compare_exchange_32(&pContext->fd, pContext->fd, -1);
+#else
+    SOCKET fd = atomic_val_compare_exchange_64(&pContext->fd, pContext->fd, -1);
+#endif
     taosCloseSocket(fd);
   }
 }
 
 static void httpDestroyContext(void *data) {
   HttpContext *pContext = *(HttpContext **)data;
-  if (pContext->fd > 0) taosClose(pContext->fd);
+  if (pContext->fd > 0) taosCloseSocket(pContext->fd);
 
   HttpThread *pThread = pContext->pThread;
   httpRemoveContextFromEpoll(pContext);
   httpReleaseSession(pContext);
   atomic_sub_fetch_32(&pThread->numOfContexts, 1);
-  
+
   httpDebug("context:%p, is destroyed, refCount:%d data:%p thread:%s numOfContexts:%d", pContext, pContext->refCount,
             data, pContext->pThread->label, pContext->pThread->numOfContexts);
   pContext->pThread = 0;
@@ -100,15 +104,13 @@ const char *httpContextStateStr(HttpContextState state) {
   }
 }
 
-void httpNotifyContextClose(HttpContext *pContext) { 
-  shutdown(pContext->fd, SHUT_WR); 
-}
+void httpNotifyContextClose(HttpContext *pContext) { shutdown(pContext->fd, SHUT_WR); }
 
 bool httpAlterContextState(HttpContext *pContext, HttpContextState srcState, HttpContextState destState) {
   return (atomic_val_compare_exchange_32(&pContext->state, srcState, destState) == srcState);
 }
 
-HttpContext *httpCreateContext(int32_t fd) {
+HttpContext *httpCreateContext(SOCKET fd) {
   HttpContext *pContext = calloc(1, sizeof(HttpContext));
   if (pContext == NULL) return NULL;
 
@@ -123,8 +125,8 @@ HttpContext *httpCreateContext(int32_t fd) {
   pContext->ppContext = ppContext;
   httpDebug("context:%p, fd:%d, is created, data:%p", pContext, fd, ppContext);
 
-  // set the ref to 0 
-  taosCacheRelease(tsHttpServer.contextCache, (void**)&ppContext, false);
+  // set the ref to 0
+  taosCacheRelease(tsHttpServer.contextCache, (void **)&ppContext, false);
 
   return pContext;
 }
@@ -174,7 +176,6 @@ bool httpInitContext(HttpContext *pContext) {
   pContext->encodeMethod = NULL;
   memset(&pContext->singleCmd, 0, sizeof(HttpSqlCmd));
 
-
   httpTrace("context:%p, fd:%d, parsed:%d", pContext, pContext->fd, pContext->parsed);
   return true;
 }

src/plugins/http/src/httpGcHandle.c

@@ -192,7 +192,7 @@ bool gcProcessQueryRequest(HttpContext* pContext) {
       break;
     }
 
-    cJSON* alias = cJSON_GetObjectItem(query, "alias");
+    cJSON*  alias = cJSON_GetObjectItem(query, "alias");
     int32_t aliasBuffer = -1;
     if (!(alias == NULL || alias->valuestring == NULL || strlen(alias->valuestring) == 0)) {
       aliasBuffer = httpAddToSqlCmdBuffer(pContext, alias->valuestring);

src/plugins/http/src/httpGcJson.c

@@ -86,7 +86,7 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
   JsonBuf *jsonBuf = httpMallocJsonBuf(pContext);
   if (jsonBuf == NULL) return false;
 
-  int32_t  num_fields = taos_num_fields(result);
+  int32_t     num_fields = taos_num_fields(result);
   TAOS_FIELD *fields = taos_fetch_fields(result);
   if (num_fields == 0) {
     return false;
@@ -101,7 +101,7 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
   // such as select count(*) count(*) from sys.cpu group by ipaddr interval(1d)
   int32_t dataFields = -1;
   int32_t groupFields = -1;
-  bool hasTimestamp = fields[0].type == TSDB_DATA_TYPE_TIMESTAMP;
+  bool    hasTimestamp = fields[0].type == TSDB_DATA_TYPE_TIMESTAMP;
   if (hasTimestamp) {
     dataFields = 1;
     if (num_fields > 2) groupFields = num_fields - 1;
@@ -125,15 +125,15 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
       cmd->numOfRows--;
       continue;
     }
-    int32_t* length = taos_fetch_lengths(result);
+    int32_t *length = taos_fetch_lengths(result);
 
     // for group by
     if (groupFields != -1) {
-      char target[HTTP_GC_TARGET_SIZE] = {0};
+      char    target[HTTP_GC_TARGET_SIZE] = {0};
       int32_t len;
-      len = snprintf(target,HTTP_GC_TARGET_SIZE,"%s{",aliasBuffer);
-      for (int32_t i = dataFields + 1; i<num_fields; i++){
-          switch (fields[i].type) {
+      len = snprintf(target, HTTP_GC_TARGET_SIZE, "%s{", aliasBuffer);
+      for (int32_t i = dataFields + 1; i < num_fields; i++) {
+        switch (fields[i].type) {
           case TSDB_DATA_TYPE_BOOL:
           case TSDB_DATA_TYPE_TINYINT:
             len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, "%s:%d", fields[i].name, *((int8_t *)row[i]));
@@ -155,20 +155,19 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
             break;
           case TSDB_DATA_TYPE_BINARY:
           case TSDB_DATA_TYPE_NCHAR:
-            if (row[i]!= NULL){            
+            if (row[i] != NULL) {
               len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, "%s:", fields[i].name);
-              memcpy(target + len, (char *) row[i], length[i]);
-              len = strlen(target);
+              memcpy(target + len, (char *)row[i], length[i]);
+              len = (int32_t)strlen(target);
             }
             break;
           default:
             len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, "%s:%s", fields[i].name, "-");
             break;
         }
-        if(i < num_fields - 1 ){
-            len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, ", ");
+        if (i < num_fields - 1) {
+          len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, ", ");
         }
-
       }
       len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, "}");
 
@@ -217,10 +216,10 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
           break;
         case TSDB_DATA_TYPE_BINARY:
         case TSDB_DATA_TYPE_NCHAR:
-          httpJsonStringForTransMean(jsonBuf, (char*)row[i], fields[i].bytes);
+          httpJsonStringForTransMean(jsonBuf, (char *)row[i], fields[i].bytes);
           break;
         case TSDB_DATA_TYPE_TIMESTAMP:
-          if (precision == TSDB_TIME_PRECISION_MILLI) { //ms
+          if (precision == TSDB_TIME_PRECISION_MILLI) {  // ms
             httpJsonInt64(jsonBuf, *((int64_t *)row[i]));
           } else {
             httpJsonInt64(jsonBuf, *((int64_t *)row[i]) / 1000);

src/plugins/http/src/httpGzip.c

@@ -25,25 +25,24 @@ typedef enum {
 } EHTTP_GZIP_STATE;
 
 struct ehttp_gzip_s {
-  ehttp_gzip_conf_t       conf;
-  ehttp_gzip_callbacks_t  callbacks;
-  void                   *arg;
-  z_stream               *gzip;
-  gz_header              *header;
-  char                   *chunk;
-
-  int32_t                 state;
+  ehttp_gzip_conf_t      conf;
+  ehttp_gzip_callbacks_t callbacks;
+  void *                 arg;
+  z_stream *             gzip;
+  gz_header *            header;
+  char *                 chunk;
+  int32_t                state;
 };
 
-static void dummy_on_data(ehttp_gzip_t *gzip, void *arg, const char *buf, int32_t len) {
-}
+static void dummy_on_data(ehttp_gzip_t *gzip, void *arg, const char *buf, int32_t len) {}
 
 static void ehttp_gzip_cleanup(ehttp_gzip_t *gzip) {
-  switch(gzip->state) {
+  switch (gzip->state) {
     case EHTTP_GZIP_READY: {
       inflateEnd(gzip->gzip);
     } break;
-    default: break;
+    default:
+      break;
   }
   if (gzip->gzip) {
     free(gzip->gzip);
@@ -60,43 +59,43 @@ static void ehttp_gzip_cleanup(ehttp_gzip_t *gzip) {
   gzip->state = EHTTP_GZIP_CLOSED;
 }
 
-ehttp_gzip_t* ehttp_gzip_create_decompressor(ehttp_gzip_conf_t conf, ehttp_gzip_callbacks_t callbacks, void *arg) {
-  ehttp_gzip_t *gzip = (ehttp_gzip_t*)calloc(1, sizeof(*gzip));
+ehttp_gzip_t *ehttp_gzip_create_decompressor(ehttp_gzip_conf_t conf, ehttp_gzip_callbacks_t callbacks, void *arg) {
+  ehttp_gzip_t *gzip = (ehttp_gzip_t *)calloc(1, sizeof(*gzip));
   if (!gzip) return NULL;
 
   do {
-    gzip->conf                = conf;
-    gzip->callbacks           = callbacks;
-    gzip->arg                 = arg;
+    gzip->conf = conf;
+    gzip->callbacks = callbacks;
+    gzip->arg = arg;
     if (gzip->callbacks.on_data == NULL) gzip->callbacks.on_data = dummy_on_data;
-    gzip->gzip                = (z_stream*)calloc(1, sizeof(*gzip->gzip));
+    gzip->gzip = (z_stream *)calloc(1, sizeof(*gzip->gzip));
     if (gzip->conf.get_header) {
-      gzip->header            = (gz_header*)calloc(1, sizeof(*gzip->header));
+      gzip->header = (gz_header *)calloc(1, sizeof(*gzip->header));
     }
-    if (gzip->conf.chunk_size<=0) gzip->conf.chunk_size = EHTTP_GZIP_CHUNK_SIZE_DEFAULT;
-    gzip->chunk                 = (char*)malloc(gzip->conf.chunk_size);
+    if (gzip->conf.chunk_size <= 0) gzip->conf.chunk_size = EHTTP_GZIP_CHUNK_SIZE_DEFAULT;
+    gzip->chunk = (char *)malloc(gzip->conf.chunk_size);
     if (!gzip->gzip || (gzip->conf.get_header && !gzip->header) || !gzip->chunk) break;
-    gzip->gzip->zalloc      = Z_NULL;
-    gzip->gzip->zfree       = Z_NULL;
-    gzip->gzip->opaque      = Z_NULL;
-
-  // 863      windowBits can also be greater than 15 for optional gzip decoding.  Add
-  // 864    32 to windowBits to enable zlib and gzip decoding with automatic header
-  // 865    detection, or add 16 to decode only the gzip format (the zlib format will
-  // 866    return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
-  // 867    CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
-  // 868    below), inflate() will not automatically decode concatenated gzip streams.
-  // 869    inflate() will return Z_STREAM_END at the end of the gzip stream.  The state
-  // 870    would need to be reset to continue decoding a subsequent gzip stream.
-    int32_t ret = inflateInit2(gzip->gzip, 32); // 32/16? 32/16 + MAX_WBITS
+    gzip->gzip->zalloc = Z_NULL;
+    gzip->gzip->zfree = Z_NULL;
+    gzip->gzip->opaque = Z_NULL;
+
+    // 863    windowBits can also be greater than 15 for optional gzip decoding.  Add
+    // 864    32 to windowBits to enable zlib and gzip decoding with automatic header
+    // 865    detection, or add 16 to decode only the gzip format (the zlib format will
+    // 866    return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+    // 867    CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
+    // 868    below), inflate() will not automatically decode concatenated gzip streams.
+    // 869    inflate() will return Z_STREAM_END at the end of the gzip stream.  The state
+    // 870    would need to be reset to continue decoding a subsequent gzip stream.
+    int32_t ret = inflateInit2(gzip->gzip, 32);  // 32/16? 32/16 + MAX_WBITS
     if (ret != Z_OK) break;
     if (gzip->header) {
       ret = inflateGetHeader(gzip->gzip, gzip->header);
     }
     if (ret != Z_OK) break;
 
-    gzip->gzip->next_out           = (z_const Bytef*)gzip->chunk;
-    gzip->gzip->avail_out          = gzip->conf.chunk_size;
+    gzip->gzip->next_out = (z_const Bytef *)gzip->chunk;
+    gzip->gzip->avail_out = gzip->conf.chunk_size;
     gzip->state = EHTTP_GZIP_READY;
     return gzip;
   } while (0);
@@ -105,7 +104,7 @@ ehttp_gzip_t* ehttp_gzip_create_decompressor(ehttp_gzip_conf_t conf, ehttp_gzip_
   return NULL;
 }
 
-ehttp_gzip_t* ehttp_gzip_create_compressor(ehttp_gzip_conf_t conf, ehttp_gzip_callbacks_t callbacks, void *arg);
+ehttp_gzip_t *ehttp_gzip_create_compressor(ehttp_gzip_conf_t conf, ehttp_gzip_callbacks_t callbacks, void *arg);
 
 void ehttp_gzip_destroy(ehttp_gzip_t *gzip) {
   ehttp_gzip_cleanup(gzip);
@@ -129,16 +128,16 @@ int32_t ehttp_gzip_write(ehttp_gzip_t *gzip, const char *buf, int32_t len) {
     }
     if (ret != Z_OK && ret != Z_STREAM_END) return -1;
 
-    if (gzip->gzip->avail_out>0) {
-      if (ret!=Z_STREAM_END) continue;
+    if (gzip->gzip->avail_out > 0) {
+      if (ret != Z_STREAM_END) continue;
     }
 
-    int32_t len = gzip->gzip->next_out - (z_const Bytef*)gzip->chunk;
+    int32_t len = (int32_t)(gzip->gzip->next_out - (z_const Bytef *)gzip->chunk);
 
     gzip->gzip->next_out[0] = '\0';
     gzip->callbacks.on_data(gzip, gzip->arg, gzip->chunk, len);
-    gzip->gzip->next_out       = (z_const Bytef*)gzip->chunk;
-    gzip->gzip->avail_out      = gzip->conf.chunk_size;
+    gzip->gzip->next_out = (z_const Bytef *)gzip->chunk;
+    gzip->gzip->avail_out = gzip->conf.chunk_size;
   }
 
   return 0;
@@ -147,21 +146,20 @@ int32_t ehttp_gzip_write(ehttp_gzip_t *gzip, const char *buf, int32_t len) {
 int32_t ehttp_gzip_finish(ehttp_gzip_t *gzip) {
   if (gzip->state != EHTTP_GZIP_READY) return -1;
 
-  gzip->gzip->next_in        = NULL;
-  gzip->gzip->avail_in       = 0;
+  gzip->gzip->next_in = NULL;
+  gzip->gzip->avail_in = 0;
 
   int32_t ret;
   ret = inflate(gzip->gzip, Z_FINISH);
 
   if (ret != Z_STREAM_END) return -1;
 
-  int32_t len = gzip->gzip->next_out - (z_const Bytef*)gzip->chunk;
+  int32_t len = (int32_t)(gzip->gzip->next_out - (z_const Bytef *)gzip->chunk);
 
   gzip->gzip->next_out[0] = '\0';
   gzip->callbacks.on_data(gzip, gzip->arg, gzip->chunk, len);
-  gzip->gzip->next_out       = NULL;
-  gzip->gzip->avail_out      = 0;
+  gzip->gzip->next_out = NULL;
+  gzip->gzip->avail_out = 0;
 
   return 0;
 }
-

src/plugins/http/src/httpHandle.c

@@ -48,7 +48,7 @@ bool httpProcessData(HttpContext* pContext) {
       /*
        * httpCloseContextByApp has been called when parsing the error
        */
-      //httpCloseContextByApp(pContext);
+      // httpCloseContextByApp(pContext);
     } else {
       httpProcessRequest(pContext);
     }

src/plugins/http/src/httpJson.c

@@ -44,20 +44,21 @@ int32_t httpWriteBufByFd(struct HttpContext* pContext, const char* buf, int32_t
   int32_t writeLen = 0;
 
   do {
-    if (pContext->fd > 2){
+    if (pContext->fd > 2) {
       len = (int32_t)taosSend(pContext->fd, buf + writeLen, (size_t)(sz - writeLen), MSG_NOSIGNAL);
-    }
-    else {
+    } else {
       return sz;
     }
 
     if (len < 0) {
-      httpDebug("context:%p, fd:%d, socket write errno:%d:%s, times:%d", pContext, pContext->fd, errno, strerror(errno), countWait);
+      httpDebug("context:%p, fd:%d, socket write errno:%d:%s, times:%d", pContext, pContext->fd, errno, strerror(errno),
+                countWait);
       if (++countWait > HTTP_WRITE_RETRY_TIMES) break;
       taosMsleep(HTTP_WRITE_WAIT_TIME_MS);
       continue;
     } else if (len == 0) {
-      httpDebug("context:%p, fd:%d, socket write errno:%d:%s, connect already closed", pContext, pContext->fd, errno, strerror(errno));
+      httpDebug("context:%p, fd:%d, socket write errno:%d:%s, connect already closed", pContext, pContext->fd, errno,
+                strerror(errno));
       break;
     } else {
       countWait = 0;
@@ -80,7 +81,7 @@ int32_t httpWriteBuf(struct HttpContext* pContext, const char* buf, int32_t sz)
   return writeSz;
 }
 
-int32_t httpWriteBufNoTrace(struct HttpContext *pContext, const char *buf, int32_t sz) {
+int32_t httpWriteBufNoTrace(struct HttpContext* pContext, const char* buf, int32_t sz) {
   int32_t writeSz = httpWriteBufByFd(pContext, buf, sz);
   if (writeSz != sz) {
     httpError("context:%p, fd:%d, dataSize:%d, writeSize:%d, failed to send response", pContext, pContext->fd, sz,
@@ -92,8 +93,8 @@ int32_t httpWriteBufNoTrace(struct HttpContext *pContext, const char *buf, int32
 
 int32_t httpWriteJsonBufBody(JsonBuf* buf, bool isTheLast) {
   int32_t remain = 0;
-  char sLen[24];
-  uint64_t srcLen = (uint64_t) (buf->lst - buf->buf);
+  char    sLen[24];
+  int32_t srcLen = (int32_t)(buf->lst - buf->buf);
 
   if (buf->pContext->fd <= 0) {
     httpTrace("context:%p, fd:%d, write json body error", buf->pContext, buf->pContext->fd);
@@ -113,21 +114,21 @@ int32_t httpWriteJsonBufBody(JsonBuf* buf, bool isTheLast) {
       httpTrace("context:%p, fd:%d, no data need dump", buf->pContext, buf->pContext->fd);
       return 0;  // there is no data to dump.
     } else {
-      int32_t len = sprintf(sLen, "%" PRIx64 "\r\n", srcLen);
-      httpTrace("context:%p, fd:%d, write body, chunkSize:%" PRIu64 ", response:\n%s", buf->pContext, buf->pContext->fd,
-                srcLen, buf->buf);
+      int32_t len = sprintf(sLen, "%x\r\n", srcLen);
+      httpTrace("context:%p, fd:%d, write body, chunkSize:%d, response:\n%s", buf->pContext, buf->pContext->fd, srcLen,
+                buf->buf);
       httpWriteBufNoTrace(buf->pContext, sLen, len);
-      remain = httpWriteBufNoTrace(buf->pContext, buf->buf, (int32_t)srcLen);
+      remain = httpWriteBufNoTrace(buf->pContext, buf->buf, srcLen);
     }
   } else {
-    char compressBuf[JSON_BUFFER_SIZE] = {0};
+    char    compressBuf[JSON_BUFFER_SIZE] = {0};
     int32_t compressBufLen = JSON_BUFFER_SIZE;
     int32_t ret = httpGzipCompress(buf->pContext, buf->buf, srcLen, compressBuf, &compressBufLen, isTheLast);
     if (ret == 0) {
       if (compressBufLen > 0) {
         int32_t len = sprintf(sLen, "%x\r\n", compressBufLen);
-        httpTrace("context:%p, fd:%d, write body, chunkSize:%" PRIu64 ", compressSize:%d, last:%d, response:\n%s",
-                  buf->pContext, buf->pContext->fd, srcLen, compressBufLen, isTheLast, buf->buf);
+        httpTrace("context:%p, fd:%d, write body, chunkSize:%d, compressSize:%d, last:%d, response:\n%s", buf->pContext,
+                  buf->pContext->fd, srcLen, compressBufLen, isTheLast, buf->buf);
         httpWriteBufNoTrace(buf->pContext, sLen, len);
         remain = httpWriteBufNoTrace(buf->pContext, (const char*)compressBuf, compressBufLen);
       } else {
@@ -136,7 +137,7 @@ int32_t httpWriteJsonBufBody(JsonBuf* buf, bool isTheLast) {
         remain = 0;  // there is no data to dump.
       }
     } else {
-      httpError("context:%p, fd:%d, failed to compress data, chunkSize:%" PRIu64 ", last:%d, error:%d, response:\n%s",
+      httpError("context:%p, fd:%d, failed to compress data, chunkSize:%d, last:%d, error:%d, response:\n%s",
                 buf->pContext, buf->pContext->fd, srcLen, isTheLast, ret, buf->buf);
       remain = 0;
     }
@@ -154,8 +155,8 @@ void httpWriteJsonBufHead(JsonBuf* buf) {
     buf->pContext->fd = -1;
   }
 
-  char msg[1024] = {0};
-  int32_t  len = -1;
+  char    msg[1024] = {0};
+  int32_t len = -1;
 
   if (buf->pContext->parser->acceptEncodingGzip == 0 || !tsHttpEnableCompress) {
     len = sprintf(msg, httpRespTemplate[HTTP_RESPONSE_CHUNKED_UN_COMPRESS], httpVersionStr[buf->pContext->parser->httpVersion],
@@ -256,16 +257,16 @@ void httpJsonInt64(JsonBuf* buf, int64_t num) {
 }
 
 void httpJsonTimestamp(JsonBuf* buf, int64_t t, bool us) {
-  char ts[35] = {0};
-  struct tm *ptm;
-  int32_t precision = 1000;
+  char       ts[35] = {0};
+  struct tm* ptm;
+  int32_t    precision = 1000;
   if (us) {
     precision = 1000000;
   }
 
   time_t tt = t / precision;
   ptm = localtime(&tt);
-  int32_t length = (int32_t) strftime(ts, 35, "%Y-%m-%d %H:%M:%S", ptm);
+  int32_t length = (int32_t)strftime(ts, 35, "%Y-%m-%d %H:%M:%S", ptm);
   if (us) {
     length += snprintf(ts + length, 8, ".%06" PRId64, t % precision);
   } else {
@@ -276,9 +277,9 @@ void httpJsonTimestamp(JsonBuf* buf, int64_t t, bool us) {
 }
 
 void httpJsonUtcTimestamp(JsonBuf* buf, int64_t t, bool us) {
-  char ts[40] = {0};
-  struct tm *ptm;
-  int32_t precision = 1000;
+  char       ts[40] = {0};
+  struct tm* ptm;
+  int32_t    precision = 1000;
   if (us) {
     precision = 1000000;
   }

src/plugins/http/src/httpParser.c

@@ -130,7 +130,7 @@ static int32_t httpAppendString(HttpString *str, const char *s, int32_t len) {
 static void httpClearString(HttpString *str) {
   if (str->str) {
     str->str[0] = '\0';
-    str->pos    = 0;
+    str->pos = 0;
   }
 }
 
@@ -153,7 +153,7 @@ static int32_t httpOnRequestLine(HttpParser *pParser, char *method, char *target
   for (int32_t i = 0; i < HTTP_MAX_URL; i++) {
     char *pSeek = strchr(pStart, '/');
     if (pSeek == NULL) {
-      (void)httpAppendString(pParser->path + i, pStart, strlen(pStart));
+      (void)httpAppendString(pParser->path + i, pStart, (int32_t)strlen(pStart));
       break;
     } else {
       (void)httpAppendString(pParser->path + i, pStart, (int32_t)(pSeek - pStart));
@@ -237,7 +237,6 @@ static int32_t httpOnParseHeaderField(HttpParser *parser, const char *key, const
     }
     httpTrace("context:%p, fd:%d, keepAlive:%d", pContext, pContext->fd, pContext->parser->keepAlive);
   }
-
 #if 0
   else if (0 == strcasecmp(key, "Content-Encoding")) {
     if (0 == strcmp(val, "gzip")) {
@@ -246,7 +245,7 @@ static int32_t httpOnParseHeaderField(HttpParser *parser, const char *key, const
     }
     return 0;
   }
-  #endif
+#endif
 
   else if (0 == strcasecmp(key, "Transfer-Encoding") || 0 == strcasecmp(key, "Content-Encoding")) {
     if (strstr(val, "gzip")) {
@@ -272,20 +271,17 @@ static int32_t httpOnParseHeaderField(HttpParser *parser, const char *key, const
   }
 
   else if (0 == strcasecmp(key, "Authorization")) {
-    char *  t = NULL;
-    char *  s = NULL;
+    char   t[6] = {0};
+    char   s[129] = {0};
     int32_t bytes = 0;
-    int32_t n = sscanf(val, "%ms %ms%n", &t, &s, &bytes);
-    if (n == 2 && t && s && bytes == strlen(val)) {
+    int32_t n = sscanf(val, "%5s %128s%n", t, s, &bytes);
+    if (n == 2 && t[0] && s[0] && bytes == strlen(val)) {
       if (strcmp(t, "Basic") == 0) {
         free(parser->authContent);
-        parser->authContent = s;
+        parser->authContent = strdup(s);
         parser->authType = HTTP_BASIC_AUTH;
-        s = NULL;
-        free(t);
-        free(s);
         httpTrace("context:%p, fd:%d, basic auth:%s", pContext, pContext->fd, parser->authContent);
-        int32_t ok = httpParseBasicAuthToken(pContext, parser->authContent, strlen(parser->authContent));
+        int32_t ok = httpParseBasicAuthToken(pContext, parser->authContent, (int32_t)strlen(parser->authContent));
         if (ok != 0) {
           httpOnError(parser, 0, TSDB_CODE_HTTP_INVALID_BASIC_AUTH);
           return -1;
@@ -293,13 +289,10 @@ static int32_t httpOnParseHeaderField(HttpParser *parser, const char *key, const
         return 0;
       } else if (strcmp(t, "Taosd") == 0) {
         free(parser->authContent);
-        parser->authContent = s;
+        parser->authContent = strdup(s);
         parser->authType = HTTP_TAOSD_AUTH;
-        s = NULL;
-        free(t);
-        free(s);
         httpTrace("context:%p, fd:%d, taosd auth:%s", pContext, pContext->fd, parser->authContent);
-        int32_t ok = httpParseTaosdAuthToken(pContext, parser->authContent, strlen(parser->authContent));
+        int32_t ok = httpParseTaosdAuthToken(pContext, parser->authContent, (int32_t)strlen(parser->authContent));
         if (ok != 0) {
           httpOnError(parser, 0, TSDB_CODE_HTTP_INVALID_TAOSD_AUTH);
           return -1;
@@ -309,16 +302,12 @@ static int32_t httpOnParseHeaderField(HttpParser *parser, const char *key, const
         parser->authType = HTTP_INVALID_AUTH;
         httpError("context:%p, fd:%d, invalid auth, t:%s s:%s", pContext, pContext->fd, t, s);
         httpOnError(parser, 0, TSDB_CODE_HTTP_INVALID_AUTH_TYPE);
-        free(t);
-        free(s);
         return -1;
       }
     } else {
       parser->authType = HTTP_INVALID_AUTH;
       httpError("context:%p, fd:%d, parse auth failed, t:%s s:%s", pContext, pContext->fd, t, s);
       httpOnError(parser, 0, TSDB_CODE_HTTP_INVALID_AUTH_FORMAT);
-      free(t);
-      free(s);
       return -1;
     }
   }
@@ -349,7 +338,7 @@ static int32_t httpOnBody(HttpParser *parser, const char *chunk, int32_t len) {
     newSize = MIN(newSize, HTTP_BUFFER_SIZE);
     buf->str = realloc(buf->str, newSize);
     buf->size = newSize;
-    
+
     if (buf->str == NULL) {
       httpError("context:%p, fd:%d, failed parse body, realloc %d failed", pContext, pContext->fd, buf->size);
       httpOnError(parser, 0, TSDB_CODE_HTTP_NO_ENOUGH_MEMORY);
@@ -410,9 +399,7 @@ static int32_t httpPopStack(HttpParser *parser) {
   return 0;
 }
 
-static void httpClearStack(HttpStack *stack) {
-  stack->pos = 0;
-}
+static void httpClearStack(HttpStack *stack) { stack->pos = 0; }
 
 static int32_t httpCleanupStack(HttpStack *stack) {
   free(stack->stacks);
@@ -451,7 +438,7 @@ void httpInitParser(HttpParser *parser) {
   free(parser->key);            parser->key             = NULL;
   free(parser->val);            parser->val             = NULL;
   free(parser->authContent);    parser->authContent     = NULL;
-  
+
   httpClearStack(&parser->stacks);
   httpClearString(&parser->str);
   httpClearString(&parser->body);
@@ -497,7 +484,7 @@ void httpDestroyParser(HttpParser *parser) {
   free(parser->key);            parser->key             = NULL;
   free(parser->val);            parser->val             = NULL;
   free(parser->authContent);    parser->authContent     = NULL;
-  
+
   httpCleanupStack(&parser->stacks);
   httpCleanupString(&parser->str);
   httpCleanupString(&parser->body);
@@ -513,25 +500,36 @@ void httpDestroyParser(HttpParser *parser) {
   free(parser);
 }
 
-#define is_token(c)      (strchr("!#$%&'*+-.^_`|~", c) || isdigit(c) || isalpha(c))
+#define is_token(c) (strchr("!#$%&'*+-.^_`|~", c) || isdigit(c) || isalpha(c))
 
 char *httpDecodeUrl(const char *enc) {
-  int32_t ok = 1;
+  int32_t    ok = 1;
   HttpString str = {0};
   while (*enc) {
     char *p = strchr(enc, '%');
     if (!p) break;
     int32_t hex, cnt;
-    int32_t n = sscanf(p+1, "%2x%n", &hex, &cnt);
-    if (n!=1 && cnt !=2) { ok = 0; break; }
-    if (httpAppendString(&str, enc, p-enc)) { ok = 0; break; }
+    int32_t n = sscanf(p + 1, "%2x%n", &hex, &cnt);
+    if (n != 1 && cnt != 2) {
+      ok = 0;
+      break;
+    }
+    if (httpAppendString(&str, enc, (int32_t)(p - enc))) {
+      ok = 0;
+      break;
+    }
     char c = (char)hex;
-    if (httpAppendString(&str, &c, 1)) { ok = 0; break; }
-    enc    = p+3;
+    if (httpAppendString(&str, &c, 1)) {
+      ok = 0;
+      break;
+    }
+    enc = p + 3;
   }
   char *dec = NULL;
   if (ok && *enc) {
-    if (httpAppendString(&str, enc, strlen(enc))) { ok = 0; }
+    if (httpAppendString(&str, enc, (int32_t)strlen(enc))) {
+      ok = 0;
+    }
   }
   if (ok) {
     dec = str.str;
@@ -542,13 +540,13 @@ char *httpDecodeUrl(const char *enc) {
 }
 
 static void httpOnData(ehttp_gzip_t *gzip, void *arg, const char *buf, int32_t len) {
-  HttpParser *parser = (HttpParser*)arg;
+  HttpParser *parser = (HttpParser *)arg;
   httpOnBody(parser, buf, len);
 }
 
 static int32_t httpParserOnBegin(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (c == 'G' || c == 'P' || c == 'H' || c == 'D' || c == 'C' || c == 'O' || c == 'T') {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -570,7 +568,7 @@ static int32_t httpParserOnBegin(HttpParser *parser, HTTP_PARSER_STATE state, co
 
 static int32_t httpParserOnRquestOrResponse(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (parser->str.pos == 1) {
       if (c == 'T' && parser->str.str[0] == 'H') {
@@ -608,7 +606,7 @@ static int32_t httpParserOnRquestOrResponse(HttpParser *parser, HTTP_PARSER_STAT
 
 static int32_t httpParserOnMethod(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (isalnum(c) || strchr("!#$%&'*+-.^_`|~", c)) {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -637,7 +635,7 @@ static int32_t httpParserOnMethod(HttpParser *parser, HTTP_PARSER_STATE state, c
 
 static int32_t httpParserOnTarget(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (!isspace(c) && c != '\r' && c != '\n') {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -664,10 +662,10 @@ static int32_t httpParserOnTarget(HttpParser *parser, HTTP_PARSER_STATE state, c
 
 static int32_t httpParserOnVersion(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     const char *prefix = "HTTP/1.";
-    int32_t     len = strlen(prefix);
+    int32_t     len = (int32_t)strlen(prefix);
     if (parser->str.pos < len) {
       if (prefix[parser->str.pos] != c) {
         httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
@@ -727,7 +725,7 @@ static int32_t httpParserOnVersion(HttpParser *parser, HTTP_PARSER_STATE state,
 
 static int32_t httpParserOnSp(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (c == ' ') {
       httpPopStack(parser);
@@ -742,7 +740,7 @@ static int32_t httpParserOnSp(HttpParser *parser, HTTP_PARSER_STATE state, const
 
 static int32_t httpParserOnStatusCode(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (isdigit(c)) {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -767,7 +765,7 @@ static int32_t httpParserOnStatusCode(HttpParser *parser, HTTP_PARSER_STATE stat
 
 static int32_t httpParserOnReasonPhrase(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (c == '\r') {
       parser->reasonPhrase = strdup(parser->str.str);
@@ -808,10 +806,10 @@ static int32_t httpParserPostProcess(HttpParser *parser) {
 
 static int32_t httpParserOnCrlf(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
-    const char *s   = "\r\n";
-    int32_t   len   = strlen(s);
+    const char *s = "\r\n";
+    int32_t     len = (int32_t)strlen(s);
     if (s[parser->str.pos] != c) {
       httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
       ok = -1;
@@ -838,7 +836,7 @@ static int32_t httpParserOnCrlf(HttpParser *parser, HTTP_PARSER_STATE state, con
 
 static int32_t httpParserOnHeader(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (c == '\r') {
       httpPopStack(parser);
@@ -876,7 +874,7 @@ static int32_t httpParserOnHeader(HttpParser *parser, HTTP_PARSER_STATE state, c
 
 static int32_t httpParserOnHeaderKey(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (isalnum(c) || strchr("!#$%&'*+-.^_`|~", c)) {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -888,7 +886,7 @@ static int32_t httpParserOnHeaderKey(HttpParser *parser, HTTP_PARSER_STATE state
       break;
     }
     if (c == ':') {
-      parser->key        = strdup(parser->str.str);
+      parser->key = strdup(parser->str.str);
       if (!parser->key) {
         httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
         ok = -1;
@@ -908,7 +906,7 @@ static int32_t httpParserOnHeaderKey(HttpParser *parser, HTTP_PARSER_STATE state
 
 static int32_t httpParserOnHeaderVal(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (c != '\r' && c != '\n' && (!isspace(c) || parser->str.pos > 0)) {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -935,10 +933,10 @@ static int32_t httpParserOnHeaderVal(HttpParser *parser, HTTP_PARSER_STATE state
 
 static int32_t httpParserOnChunkSize(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
-  int32_t bytes;
-  int32_t len;
-  int32_t n;
+  int32_t      ok = 0;
+  int32_t      bytes;
+  int32_t      len;
+  int32_t      n;
   do {
     if (isxdigit(c)) {
       if (httpAppendString(&parser->str, &c, 1)) {
@@ -985,7 +983,7 @@ static int32_t httpParserOnChunkSize(HttpParser *parser, HTTP_PARSER_STATE state
 
 static int32_t httpParserOnChunk(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     if (httpAppendString(&parser->str, &c, 1)) {
       httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
@@ -1019,7 +1017,7 @@ static int32_t httpParserOnChunk(HttpParser *parser, HTTP_PARSER_STATE state, co
 
 static int32_t httpParserOnEnd(HttpParser *parser, HTTP_PARSER_STATE state, const char c, int32_t *again) {
   HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  int32_t      ok = 0;
   do {
     ok = -1;
     httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
@@ -1029,8 +1027,8 @@ static int32_t httpParserOnEnd(HttpParser *parser, HTTP_PARSER_STATE state, cons
 }
 
 static int32_t httpParseChar(HttpParser *parser, const char c, int32_t *again) {
-  HttpContext *pContext = parser->pContext;
-  int32_t ok = 0;
+  HttpContext *     pContext = parser->pContext;
+  int32_t           ok = 0;
   HTTP_PARSER_STATE state = httpTopStack(parser);
   do {
     if (state == HTTP_PARSER_BEGIN) {
@@ -1119,9 +1117,9 @@ static int32_t httpParseChar(HttpParser *parser, const char c, int32_t *again) {
 
 int32_t httpParseBuf(HttpParser *parser, const char *buf, int32_t len) {
   HttpContext *pContext = parser->pContext;
-  const char *p = buf;
-  int32_t     ret = 0;
-  int32_t     i = 0;
+  const char * p = buf;
+  int32_t      ret = 0;
+  int32_t      i = 0;
 
   while (i < len) {
     int32_t again = 0;

src/plugins/http/src/httpQueue.c

@@ -38,16 +38,16 @@ typedef struct {
 } SHttpWorkerPool;
 
 typedef struct {
-  void *  param;
-  void *  result;
-  int32_t code;
-  int32_t rows;
+  void *        param;
+  void *        result;
+  int32_t       code;
+  int32_t       rows;
   FHttpResultFp fp;
 } SHttpResult;
 
 static SHttpWorkerPool tsHttpPool;
-static taos_qset tsHttpQset;
-static taos_queue tsHttpQueue;
+static taos_qset       tsHttpQset;
+static taos_queue      tsHttpQueue;
 
 void httpDispatchToResultQueue(void *param, TAOS_RES *result, int32_t code, int32_t rows, FHttpResultFp fp) {
   if (tsHttpQueue != NULL) {
@@ -105,7 +105,7 @@ static bool httpAllocateResultQueue() {
     httpDebug("http result worker:%d is launched, total:%d", pWorker->workerId, tsHttpPool.num);
   }
 
-   httpInfo("http result queue is opened");
+  httpInfo("http result queue is opened");
   return true;
 }
 
@@ -134,14 +134,14 @@ void httpCleanupResultQueue() {
 
   for (int32_t i = 0; i < tsHttpPool.num; ++i) {
     SHttpWorker *pWorker = tsHttpPool.httpWorker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       taosQsetThreadResume(tsHttpQset);
     }
   }
 
   for (int32_t i = 0; i < tsHttpPool.num; ++i) {
     SHttpWorker *pWorker = tsHttpPool.httpWorker + i;
-    if (pWorker->thread) {
+    if (taosCheckPthreadValid(pWorker->thread)) {
       pthread_join(pWorker->thread, NULL);
     }
   }

src/plugins/http/src/httpResp.c

@@ -160,8 +160,9 @@ void httpSendTaosdInvalidSqlErrorResp(HttpContext *pContext, char *errMsg) {
     if (temp[i] == '\"') {
       temp[i] = '\'';
     } else if (temp[i] == '\n') {
-        temp[i] = ' ';
-    } else {}
+      temp[i] = ' ';
+    } else {
+    }
   }
 
   httpSendErrorRespImp(pContext, httpCode, "Bad Request", TSDB_CODE_TSC_INVALID_SQL & 0XFFFF, temp);

src/plugins/http/src/httpRestHandle.c

@@ -95,7 +95,6 @@ bool restProcessSqlRequest(HttpContext* pContext, int32_t timestampFmt) {
     return false;
   }
 
-
   /*
    * for async test
    *

src/plugins/http/src/httpRestJson.c

@@ -83,7 +83,8 @@ void restStartSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result)
   httpJsonToken(jsonBuf, JsonArrStt);
 }
 
-bool restBuildSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result, int32_t numOfRows, int32_t timestampFormat) {
+bool restBuildSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result, int32_t numOfRows,
+                      int32_t timestampFormat) {
   JsonBuf *jsonBuf = httpMallocJsonBuf(pContext);
   if (jsonBuf == NULL) return false;
 
@@ -95,7 +96,7 @@ bool restBuildSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
     if (row == NULL) {
       continue;
     }
-    int32_t* length = taos_fetch_lengths(result);
+    int32_t *length = taos_fetch_lengths(result);
 
     // data row array begin
     httpJsonItemToken(jsonBuf);
@@ -131,15 +132,17 @@ bool restBuildSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
           break;
         case TSDB_DATA_TYPE_BINARY:
         case TSDB_DATA_TYPE_NCHAR:
-          httpJsonStringForTransMean(jsonBuf, (char*)row[i], length[i]);
+          httpJsonStringForTransMean(jsonBuf, (char *)row[i], length[i]);
           break;
         case TSDB_DATA_TYPE_TIMESTAMP:
           if (timestampFormat == REST_TIMESTAMP_FMT_LOCAL_STRING) {
-            httpJsonTimestamp(jsonBuf, *((int64_t *)row[i]), taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO);
+            httpJsonTimestamp(jsonBuf, *((int64_t *)row[i]),
+                              taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO);
           } else if (timestampFormat == REST_TIMESTAMP_FMT_TIMESTAMP) {
             httpJsonInt64(jsonBuf, *((int64_t *)row[i]));
           } else {
-            httpJsonUtcTimestamp(jsonBuf, *((int64_t *)row[i]), taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO);
+            httpJsonUtcTimestamp(jsonBuf, *((int64_t *)row[i]),
+                                 taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO);
           }
           break;
         default:
@@ -148,8 +151,8 @@ bool restBuildSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
     }
 
     // data row array end
-    httpJsonToken(jsonBuf, JsonArrEnd);   
-    cmd->numOfRows ++;
+    httpJsonToken(jsonBuf, JsonArrEnd);
+    cmd->numOfRows++;
 
     if (pContext->fd <= 0) {
       httpError("context:%p, fd:%d, user:%s, conn closed, abort retrieve", pContext, pContext->fd, pContext->user);
@@ -168,15 +171,15 @@ bool restBuildSqlJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
 }
 
 bool restBuildSqlTimestampJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result, int32_t numOfRows) {
-  return restBuildSqlJson(pContext,cmd, result, numOfRows, REST_TIMESTAMP_FMT_TIMESTAMP);
+  return restBuildSqlJson(pContext, cmd, result, numOfRows, REST_TIMESTAMP_FMT_TIMESTAMP);
 }
 
 bool restBuildSqlLocalTimeStringJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result, int32_t numOfRows) {
-  return restBuildSqlJson(pContext,cmd, result, numOfRows, REST_TIMESTAMP_FMT_LOCAL_STRING);
+  return restBuildSqlJson(pContext, cmd, result, numOfRows, REST_TIMESTAMP_FMT_LOCAL_STRING);
 }
 
 bool restBuildSqlUtcTimeStringJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result, int32_t numOfRows) {
-  return restBuildSqlJson(pContext,cmd, result, numOfRows, REST_TIMESTAMP_FMT_UTC_STRING);
+  return restBuildSqlJson(pContext, cmd, result, numOfRows, REST_TIMESTAMP_FMT_UTC_STRING);
 }
 
 void restStopSqlJson(HttpContext *pContext, HttpSqlCmd *cmd) {

src/plugins/http/src/httpServer.c

@@ -25,17 +25,13 @@
 #include "httpResp.h"
 #include "httpUtil.h"
 
-#ifndef EPOLLWAKEUP
- #define EPOLLWAKEUP (1u << 29)
-#endif
-
 static bool httpReadData(HttpContext *pContext);
 
 #ifdef __APPLE__
 static int sv_dummy = 0;
-#endif // __APPLE__
+#endif
 
-static void httpStopThread(HttpThread* pThread) {
+static void httpStopThread(HttpThread *pThread) {
   pThread->stop = true;
 
   // signal the thread to stop, try graceful method first,
@@ -60,15 +56,17 @@ static void httpStopThread(HttpThread* pThread) {
   if (r) {
     pthread_cancel(pThread->thread);
   }
-#else // __APPLE__
-  struct epoll_event event = { .events = EPOLLIN };
-  eventfd_t fd = eventfd(1, 0);
+#else 
+  struct epoll_event event = {.events = EPOLLIN};
+  eventfd_t          fd = eventfd(1, 0);
   if (fd == -1) {
-    httpError("%s, failed to create eventfd, will call pthread_cancel instead, which may result in data corruption: %s", pThread->label, strerror(errno));
+    httpError("%s, failed to create eventfd, will call pthread_cancel instead, which may result in data corruption: %s",
+              pThread->label, strerror(errno));
     pThread->stop = true;
     pthread_cancel(pThread->thread);
   } else if (epoll_ctl(pThread->pollFd, EPOLL_CTL_ADD, fd, &event) < 0) {
-    httpError("%s, failed to call epoll_ctl, will call pthread_cancel instead, which may result in data corruption: %s", pThread->label, strerror(errno));
+    httpError("%s, failed to call epoll_ctl, will call pthread_cancel instead, which may result in data corruption: %s",
+              pThread->label, strerror(errno));
     pthread_cancel(pThread->thread);
   }
 #endif // __APPLE__
@@ -85,14 +83,14 @@ static void httpStopThread(HttpThread* pThread) {
   }
 #else // __APPLE__
   if (fd != -1) {
-    close(fd);
+    taosCloseSocket(fd);
   }
 #endif // __APPLE__
 
 #ifdef __APPLE__
   epoll_close(pThread->pollFd);
 #else
-  close(pThread->pollFd);
+  EpollClose(pThread->pollFd);
 #endif
   pthread_mutex_destroy(&(pThread->threadMutex));
 }
@@ -106,7 +104,7 @@ void httpCleanUpConnect() {
   }
 
   for (int32_t i = 0; i < pServer->numOfThreads; ++i) {
-    HttpThread* pThread = pServer->pThreads + i;
+    HttpThread *pThread = pServer->pThreads + i;
     if (pThread != NULL) {
       httpStopThread(pThread);
     }
@@ -116,15 +114,12 @@ void httpCleanUpConnect() {
 }
 
 static void httpProcessHttpData(void *param) {
-  HttpServer  *pServer = &tsHttpServer;
-  HttpThread  *pThread = (HttpThread *)param;
+  HttpServer * pServer = &tsHttpServer;
+  HttpThread * pThread = (HttpThread *)param;
   HttpContext *pContext;
   int32_t      fdNum;
 
-  sigset_t set;
-  sigemptyset(&set);
-  sigaddset(&set, SIGPIPE);
-  pthread_sigmask(SIG_SETMASK, &set, NULL);
+  taosSetMaskSIGPIPE();
 
   while (1) {
     struct epoll_event events[HTTP_MAX_EVENTS];
@@ -149,8 +144,8 @@ static void httpProcessHttpData(void *param) {
       pContext = httpGetContext(events[i].data.ptr);
       if (pContext == NULL) {
         httpError("context:%p, is already released, close connect", events[i].data.ptr);
-        //epoll_ctl(pThread->pollFd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
-        //taosClose(events[i].data.fd);
+        // epoll_ctl(pThread->pollFd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
+        // taosClose(events[i].data.fd);
         continue;
       }
 
@@ -207,7 +202,7 @@ static void httpProcessHttpData(void *param) {
 }
 
 static void *httpAcceptHttpConnection(void *arg) {
-  int32_t            connFd = -1;
+  SOCKET             connFd = -1;
   struct sockaddr_in clientAddr;
   int32_t            threadId = 0;
   HttpServer *       pServer = &tsHttpServer;
@@ -215,10 +210,7 @@ static void *httpAcceptHttpConnection(void *arg) {
   HttpContext *      pContext = NULL;
   int32_t            totalFds = 0;
 
-  sigset_t set;
-  sigemptyset(&set);
-  sigaddset(&set, SIGPIPE);
-  pthread_sigmask(SIG_SETMASK, &set, NULL);
+  taosSetMaskSIGPIPE();
 
   pServer->fd = taosOpenTcpServerSocket(pServer->serverIp, pServer->serverPort);
 
@@ -233,7 +225,12 @@ static void *httpAcceptHttpConnection(void *arg) {
 
   while (1) {
     socklen_t addrlen = sizeof(clientAddr);
-    connFd = (int32_t)accept(pServer->fd, (struct sockaddr *)&clientAddr, &addrlen);
+    connFd = accept(pServer->fd, (struct sockaddr *)&clientAddr, &addrlen);
+    if (pServer->stop) {
+      httpDebug("http server:%s socket stop, exiting...", pServer->label);
+      break;
+    }
+
     if (connFd == -1) {
       if (errno == EINVAL) {
         httpDebug("http server:%s socket was shutdown, exiting...", pServer->label);
@@ -255,7 +252,7 @@ static void *httpAcceptHttpConnection(void *arg) {
       taosCloseSocket(connFd);
       continue;
     }
-#endif    
+#endif
 
     taosKeepTcpAlive(connFd);
     taosSetNonblocking(connFd, 1);
@@ -265,22 +262,22 @@ static void *httpAcceptHttpConnection(void *arg) {
 
     pContext = httpCreateContext(connFd);
     if (pContext == NULL) {
-      httpError("fd:%d, ip:%s:%u, no enough resource to allocate http context", connFd, taosInetNtoa(clientAddr.sin_addr),
-                htons(clientAddr.sin_port));
+      httpError("fd:%d, ip:%s:%u, no enough resource to allocate http context", connFd,
+                taosInetNtoa(clientAddr.sin_addr), htons(clientAddr.sin_port));
       taosCloseSocket(connFd);
       continue;
     }
 
     pContext->pThread = pThread;
     sprintf(pContext->ipstr, "%s:%u", taosInetNtoa(clientAddr.sin_addr), htons(clientAddr.sin_port));
-    
+
     struct epoll_event event;
     event.events = EPOLLIN | EPOLLPRI | EPOLLWAKEUP | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
     event.data.ptr = pContext;
     if (epoll_ctl(pThread->pollFd, EPOLL_CTL_ADD, connFd, &event) < 0) {
       httpError("context:%p, fd:%d, ip:%s, thread:%s, failed to add http fd for epoll, error:%s", pContext, connFd,
                 pContext->ipstr, pThread->label, strerror(errno));
-      taosClose(pContext->fd);
+      taosCloseSocket(pContext->fd);
       httpReleaseContext(pContext, true);
       continue;
     }
@@ -295,7 +292,7 @@ static void *httpAcceptHttpConnection(void *arg) {
     threadId = threadId % pServer->numOfThreads;
   }
 
-  close(pServer->fd);
+  taosCloseSocket(pServer->fd);
   return NULL;
 }
 
@@ -318,8 +315,8 @@ bool httpInitConnect() {
       return false;
     }
 
-    pThread->pollFd = epoll_create(HTTP_MAX_EVENTS);  // size does not matter
-    if (pThread->pollFd < 0) {
+    pThread->pollFd = (EpollFd)epoll_create(HTTP_MAX_EVENTS);  // size does not matter
+    if (pThread->pollFd <= 0) {
       httpError("http thread:%s, failed to create HTTP epoll", pThread->label);
       pthread_mutex_destroy(&(pThread->threadMutex));
       return false;
@@ -331,7 +328,7 @@ bool httpInitConnect() {
     if (pthread_create(&(pThread->thread), &thattr, (void *)httpProcessHttpData, (void *)(pThread)) != 0) {
       httpError("http thread:%s, failed to create HTTP process data thread, reason:%s", pThread->label,
                 strerror(errno));
-      pthread_mutex_destroy(&(pThread->threadMutex));        
+      pthread_mutex_destroy(&(pThread->threadMutex));
       return false;
     }
     pthread_attr_destroy(&thattr);
@@ -362,7 +359,7 @@ static bool httpReadData(HttpContext *pContext) {
   }
 
   if (pParser->parsed) {
-    httpDebug("context:%p, fd:%d, not in ready state, parsed:%d", pContext, pContext->fd, pParser->parsed);    
+    httpDebug("context:%p, fd:%d, not in ready state, parsed:%d", pContext, pContext->fd, pParser->parsed);
     return false;
   }
 

src/plugins/http/src/httpSession.c

@@ -35,7 +35,8 @@ void httpCreateSession(HttpContext *pContext, void *taos) {
   session.refCount = 1;
   int32_t len = snprintf(session.id, HTTP_SESSION_ID_LEN, "%s.%s", pContext->user, pContext->pass);
 
-  pContext->session = taosCachePut(server->sessionCache, session.id, len, &session, sizeof(HttpSession), tsHttpSessionExpire * 1000);
+  pContext->session =
+      taosCachePut(server->sessionCache, session.id, len, &session, sizeof(HttpSession), tsHttpSessionExpire * 1000);
   // void *temp = pContext->session;
   // taosCacheRelease(server->sessionCache, (void **)&temp, false);
 
@@ -56,7 +57,7 @@ static void httpFetchSessionImp(HttpContext *pContext) {
   HttpServer *server = &tsHttpServer;
   pthread_mutex_lock(&server->serverMutex);
 
-  char sessionId[HTTP_SESSION_ID_LEN];
+  char    sessionId[HTTP_SESSION_ID_LEN];
   int32_t len = snprintf(sessionId, HTTP_SESSION_ID_LEN, "%s.%s", pContext->user, pContext->pass);
 
   pContext->session = taosCacheAcquireByKey(server->sessionCache, sessionId, len);

src/plugins/http/src/httpSql.c

@@ -64,7 +64,7 @@ void httpProcessMultiSqlRetrieveCallBackImp(void *param, TAOS_RES *result, int32
     }
 
     taos_free_result(result);
-    
+
     if (singleCmd->cmdReturnType == HTTP_CMD_RETURN_TYPE_WITH_RETURN && encode->stopJsonFp) {
       (encode->stopJsonFp)(pContext, singleCmd);
     }
@@ -82,7 +82,7 @@ void httpProcessMultiSqlCallBackImp(void *param, TAOS_RES *result, int32_t code,
   HttpContext *pContext = (HttpContext *)param;
   if (pContext == NULL) return;
 
-  HttpSqlCmds *multiCmds = pContext->multiCmds;
+  HttpSqlCmds *     multiCmds = pContext->multiCmds;
   HttpEncodeMethod *encode = pContext->encodeMethod;
 
   HttpSqlCmd *singleCmd = multiCmds->cmds + multiCmds->pos;
@@ -269,8 +269,8 @@ void httpProcessSingleSqlCallBackImp(void *param, TAOS_RES *result, int32_t code
                 pContext->user, tstrerror(code), pObj, taos_errstr(pObj));
       httpSendTaosdInvalidSqlErrorResp(pContext, taos_errstr(pObj));
     } else {
-      httpError("context:%p, fd:%d, user:%s, query error, code:%s, sqlObj:%p", pContext, pContext->fd,
-                pContext->user, tstrerror(code), pObj);
+      httpError("context:%p, fd:%d, user:%s, query error, code:%s, sqlObj:%p", pContext, pContext->fd, pContext->user,
+                tstrerror(code), pObj);
       httpSendErrorResp(pContext, code);
     }
     taos_free_result(result);
@@ -381,7 +381,7 @@ void httpExecCmd(HttpContext *pContext) {
 void httpProcessRequestCb(void *param, TAOS_RES *result, int32_t code) {
   HttpContext *pContext = param;
   taos_free_result(result);
-  
+
   if (pContext == NULL) return;
 
   if (code < 0) {

src/plugins/http/src/httpSystem.c

@@ -89,7 +89,12 @@ int32_t httpStartSystem() {
 
 void httpStopSystem() {
   tsHttpServer.status = HTTP_SERVER_CLOSING;
+  tsHttpServer.stop = 1;
+#ifdef WINDOWS
+  closesocket(tsHttpServer.fd);
+#else
   shutdown(tsHttpServer.fd, SHUT_RD);
+#endif
   tgCleanupHandle();
 }
 
@@ -105,10 +110,8 @@ void httpCleanUpSystem() {
   pthread_mutex_destroy(&tsHttpServer.serverMutex);
   tfree(tsHttpServer.pThreads);
   tsHttpServer.pThreads = NULL;
-  
+
   tsHttpServer.status = HTTP_SERVER_CLOSED;
 }
 
-int32_t httpGetReqCount() {
-  return atomic_exchange_32(&tsHttpServer.requestNum, 0);
-}
+int32_t httpGetReqCount() { return atomic_exchange_32(&tsHttpServer.requestNum, 0); }

src/plugins/http/src/httpTgHandle.c

@@ -137,8 +137,8 @@ void tgInitSchemas(int32_t size) {
 }
 
 void tgParseSchemaMetric(cJSON *metric) {
-  STgSchema  schema = {0};
-  bool       parsedOk = true;
+  STgSchema schema = {0};
+  bool      parsedOk = true;
 
   // name
   cJSON *name = cJSON_GetObjectItem(metric, "name");
@@ -186,7 +186,7 @@ void tgParseSchemaMetric(cJSON *metric) {
   schema.tbName = calloc(tbnameLen + 1, 1);
   strcpy(schema.tbName, tbname->valuestring);
 
-    // fields
+  // fields
   cJSON *fields = cJSON_GetObjectItem(metric, "fields");
   if (fields == NULL) {
     goto ParseEnd;
@@ -227,14 +227,14 @@ ParseEnd:
   }
 }
 
-int32_t tgParseSchema(const char *content, char*fileName) {
+int32_t tgParseSchema(const char *content, char *fileName) {
   cJSON *root = cJSON_Parse(content);
   if (root == NULL) {
     httpError("failed to parse telegraf schema file:%s, invalid json format, content:%s", fileName, content);
     return -1;
   }
   int32_t size = 0;
-  cJSON *metrics = cJSON_GetObjectItem(root, "metrics");
+  cJSON * metrics = cJSON_GetObjectItem(root, "metrics");
   if (metrics != NULL) {
     size = cJSON_GetArraySize(metrics);
     if (size <= 0) {
@@ -276,8 +276,8 @@ int32_t tgReadSchema(char *fileName) {
 
   rewind(fp);
   char *  content = (char *)calloc(contentSize + 1, 1);
-  int32_t result = fread(content, 1, contentSize, fp);
-  
+  int32_t result = (int32_t)fread(content, 1, contentSize, fp);
+
   if (result != contentSize) {
     httpError("failed to read telegraf schema file:%s", fileName);
     fclose(fp);
@@ -296,7 +296,7 @@ int32_t tgReadSchema(char *fileName) {
 }
 
 void tgInitHandle(HttpServer *pServer) {
-  char fileName[TSDB_FILENAME_LEN*2] = {0};
+  char fileName[TSDB_FILENAME_LEN * 2] = {0};
   sprintf(fileName, "%s/taos.telegraf.cfg", configDir);
   if (tgReadSchema(fileName) <= 0) {
     tgFreeSchemas();
@@ -308,9 +308,7 @@ void tgInitHandle(HttpServer *pServer) {
   httpAddMethod(pServer, &tgDecodeMethod);
 }
 
-void tgCleanupHandle() {
-  tgFreeSchemas();
-}
+void tgCleanupHandle() { tgFreeSchemas(); }
 
 bool tgGetUserFromUrl(HttpContext *pContext) {
   HttpParser *pParser = pContext->parser;
@@ -357,7 +355,7 @@ char *tgGetStableName(char *stname, cJSON *fields, int32_t fieldsSize) {
     bool schemaMatched = true;
     for (int32_t f = 0; f < schema->fieldNum; ++f) {
       char *fieldName = schema->fields[f];
-      bool fieldMatched = false;
+      bool  fieldMatched = false;
 
       for (int32_t i = 0; i < fieldsSize; i++) {
         cJSON *field = cJSON_GetArrayItem(fields, i);
@@ -469,9 +467,9 @@ bool tgProcessSingleMetric(HttpContext *pContext, cJSON *metric, char *db) {
     }
 
     /*
-    * tag size may be larget than TSDB_COL_NAME_LEN
-    * we keep the first TSDB_COL_NAME_LEN bytes
-    */
+     * tag size may be larget than TSDB_COL_NAME_LEN
+     * we keep the first TSDB_COL_NAME_LEN bytes
+     */
     if (0) {
       if (strlen(tag->string) >= TSDB_COL_NAME_LEN) {
         httpSendErrorResp(pContext, TSDB_CODE_HTTP_TG_TAG_NAME_SIZE);
@@ -540,9 +538,9 @@ bool tgProcessSingleMetric(HttpContext *pContext, cJSON *metric, char *db) {
       return false;
     }
     /*
-    * tag size may be larget than TSDB_COL_NAME_LEN
-    * we keep the first TSDB_COL_NAME_LEN bytes
-    */
+     * tag size may be larget than TSDB_COL_NAME_LEN
+     * we keep the first TSDB_COL_NAME_LEN bytes
+     */
     if (0) {
       if (strlen(field->string) >= TSDB_COL_NAME_LEN) {
         httpSendErrorResp(pContext, TSDB_CODE_HTTP_TG_FIELD_NAME_SIZE);
@@ -578,8 +576,8 @@ bool tgProcessSingleMetric(HttpContext *pContext, cJSON *metric, char *db) {
   table_cmd->cmdType = HTTP_CMD_TYPE_INSERT;
 
   // order by tag name
-  cJSON *orderedTags[TG_MAX_SORT_TAG_SIZE] = {0};
-  int32_t    orderTagsLen = 0;
+  cJSON * orderedTags[TG_MAX_SORT_TAG_SIZE] = {0};
+  int32_t orderTagsLen = 0;
   for (int32_t i = 0; i < tagsSize; ++i) {
     cJSON *tag = cJSON_GetArrayItem(tags, i);
     orderedTags[orderTagsLen++] = tag;
@@ -603,7 +601,8 @@ bool tgProcessSingleMetric(HttpContext *pContext, cJSON *metric, char *db) {
   if (tsTelegrafUseFieldNum == 0) {
     table_cmd->stable = stable_cmd->stable = httpAddToSqlCmdBuffer(pContext, "%s", stname);
   } else {
-    table_cmd->stable = stable_cmd->stable = httpAddToSqlCmdBuffer(pContext, "%s_%d_%d", stname, fieldsSize, orderTagsLen);
+    table_cmd->stable = stable_cmd->stable =
+        httpAddToSqlCmdBuffer(pContext, "%s_%d_%d", stname, fieldsSize, orderTagsLen);
   }
   table_cmd->stable = stable_cmd->stable =
       httpShrinkTableName(pContext, table_cmd->stable, httpGetCmdsString(pContext, table_cmd->stable));
@@ -627,9 +626,11 @@ bool tgProcessSingleMetric(HttpContext *pContext, cJSON *metric, char *db) {
 
   // table name
   if (tsTelegrafUseFieldNum == 0) {
-    table_cmd->table = stable_cmd->table = httpAddToSqlCmdBufferNoTerminal(pContext, "%s_%s", stname, host->valuestring);
+    table_cmd->table = stable_cmd->table =
+        httpAddToSqlCmdBufferNoTerminal(pContext, "%s_%s", stname, host->valuestring);
   } else {
-    table_cmd->table = stable_cmd->table = httpAddToSqlCmdBufferNoTerminal(pContext, "%s_%d_%d_%s", stname, fieldsSize, orderTagsLen, host->valuestring);
+    table_cmd->table = stable_cmd->table =
+        httpAddToSqlCmdBufferNoTerminal(pContext, "%s_%d_%d_%s", stname, fieldsSize, orderTagsLen, host->valuestring);
   }
   for (int32_t i = 0; i < orderTagsLen; ++i) {
     cJSON *tag = orderedTags[i];

src/plugins/http/src/httpUtil.c

@@ -37,7 +37,7 @@ void httpTimeToString(time_t t, char *buf, int32_t buflen) {
   time_t     tt = t / 1000;
   ptm = localtime(&tt);
   strftime(ts, 31, "%Y-%m-%d %H:%M:%S", ptm);
-  sprintf(buf, "%s.%03ld", ts, t % 1000);
+  sprintf(buf, "%s.%03" PRId64, ts, t % 1000);
 }
 
 int32_t httpAddToSqlCmdBuffer(HttpContext *pContext, const char *const format, ...) {
@@ -160,8 +160,7 @@ bool httpMallocMultiCmds(HttpContext *pContext, int32_t cmdSize, int32_t bufferS
     free(multiCmds->cmds);
     multiCmds->cmds = (HttpSqlCmd *)malloc((size_t)cmdSize * sizeof(HttpSqlCmd));
     if (multiCmds->cmds == NULL) {
-      httpError("context:%p, fd:%d, user:%s, malloc cmds:%d error", pContext, pContext->fd,
-                pContext->user, cmdSize);
+      httpError("context:%p, fd:%d, user:%s, malloc cmds:%d error", pContext, pContext->fd, pContext->user, cmdSize);
       return false;
     }
     multiCmds->maxSize = (int16_t)cmdSize;
@@ -350,74 +349,78 @@ char *httpGetCmdsString(HttpContext *pContext, int32_t pos) {
 }
 
 int32_t httpGzipDeCompress(char *srcData, int32_t nSrcData, char *destData, int32_t *nDestData) {
-  int32_t err = 0;
+  int32_t  err = 0;
   z_stream gzipStream = {0};
 
   static char dummyHead[2] = {
-          0x8 + 0x7 * 0x10,
-          (((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF,
+      0x8 + 0x7 * 0x10,
+      (((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF,
   };
 
-  gzipStream.zalloc = (alloc_func) 0;
-  gzipStream.zfree = (free_func) 0;
-  gzipStream.opaque = (voidpf) 0;
-  gzipStream.next_in = (Bytef *) srcData;
+  gzipStream.zalloc = (alloc_func)0;
+  gzipStream.zfree = (free_func)0;
+  gzipStream.opaque = (voidpf)0;
+  gzipStream.next_in = (Bytef *)srcData;
   gzipStream.avail_in = 0;
-  gzipStream.next_out = (Bytef *) destData;
+  gzipStream.next_out = (Bytef *)destData;
   if (inflateInit2(&gzipStream, 47) != Z_OK) {
     return -1;
   }
 
   while (gzipStream.total_out < *nDestData && gzipStream.total_in < nSrcData) {
-    gzipStream.avail_in = gzipStream.avail_out = nSrcData;  //1
+    gzipStream.avail_in = gzipStream.avail_out = nSrcData;  // 1
     if ((err = inflate(&gzipStream, Z_NO_FLUSH)) == Z_STREAM_END) {
       break;
     }
 
     if (err != Z_OK) {
       if (err == Z_DATA_ERROR) {
-        gzipStream.next_in = (Bytef *) dummyHead;
+        gzipStream.next_in = (Bytef *)dummyHead;
         gzipStream.avail_in = sizeof(dummyHead);
         if ((err = inflate(&gzipStream, Z_NO_FLUSH)) != Z_OK) {
           return -2;
         }
-      } else return -3;
+      } else {
+        return -3;
+      }
     }
   }
 
   if (inflateEnd(&gzipStream) != Z_OK) {
     return -4;
   }
-  *nDestData = gzipStream.total_out;
+  *nDestData = (int32_t)gzipStream.total_out;
 
   return 0;
 }
 
 int32_t httpGzipCompressInit(HttpContext *pContext) {
-  pContext->gzipStream.zalloc = (alloc_func) 0;
-  pContext->gzipStream.zfree = (free_func) 0;
-  pContext->gzipStream.opaque = (voidpf) 0;
-  if (deflateInit2(&pContext->gzipStream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
+  pContext->gzipStream.zalloc = (alloc_func)0;
+  pContext->gzipStream.zfree = (free_func)0;
+  pContext->gzipStream.opaque = (voidpf)0;
+  if (deflateInit2(&pContext->gzipStream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY) !=
+      Z_OK) {
     return -1;
   }
 
   return 0;
 }
 
-int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData, char *destData, int32_t *nDestData, bool isTheLast) {
+int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData, char *destData, int32_t *nDestData,
+                         bool isTheLast) {
   int32_t err = 0;
-  int32_t lastTotalLen = (int32_t) (pContext->gzipStream.total_out);
-  pContext->gzipStream.next_in = (Bytef *) srcData;
-  pContext->gzipStream.avail_in = (uLong) nSrcData;
-  pContext->gzipStream.next_out = (Bytef *) destData;
-  pContext->gzipStream.avail_out = (uLong) (*nDestData);
+  int32_t lastTotalLen = (int32_t)(pContext->gzipStream.total_out);
+  pContext->gzipStream.next_in = (Bytef *)srcData;
+  pContext->gzipStream.avail_in = (uLong)nSrcData;
+  pContext->gzipStream.next_out = (Bytef *)destData;
+  pContext->gzipStream.avail_out = (uLong)(*nDestData);
 
   while (pContext->gzipStream.avail_in != 0) {
     if (deflate(&pContext->gzipStream, Z_FULL_FLUSH) != Z_OK) {
       return -1;
     }
 
-    int32_t cacheLen = pContext->gzipStream.total_out - lastTotalLen;
+    int32_t cacheLen = (int32_t)(pContext->gzipStream.total_out - lastTotalLen);
     if (cacheLen >= *nDestData) {
       return -2;
     }
@@ -442,12 +445,12 @@ int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData,
     }
   }
 
-  *nDestData = (int32_t) (pContext->gzipStream.total_out) - lastTotalLen;
+  *nDestData = (int32_t)(pContext->gzipStream.total_out) - lastTotalLen;
   return 0;
 }
 
-bool httpUrlMatch(HttpContext* pContext, int32_t pos, char* cmp) {
-  HttpParser* pParser = pContext->parser;
+bool httpUrlMatch(HttpContext *pContext, int32_t pos, char *cmp) {
+  HttpParser *pParser = pContext->parser;
 
   if (pos < 0 || pos >= HTTP_MAX_URL) {
     return false;

src/plugins/monitor/CMakeLists.txt

@@ -6,7 +6,7 @@ INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
 AUX_SOURCE_DIRECTORY(./src SRC)
 
-IF (TD_LINUX)
+IF (TD_LINUX OR TD_WINDOWS)
   ADD_LIBRARY(monitor ${SRC})
 
   IF (TD_SOMODE_STATIC)

src/plugins/monitor/src/monMain.c

@@ -79,8 +79,8 @@ int32_t monInitSystem() {
     strcpy(tsMonitor.ep, tsLocalEp);
   }
 
-  int len = strlen(tsMonitor.ep);
-  for (int i = 0; i < len; ++i) {
+  int32_t len = (int32_t)strlen(tsMonitor.ep);
+  for (int32_t i = 0; i < len; ++i) {
     if (tsMonitor.ep[i] == ':' || tsMonitor.ep[i] == '-' || tsMonitor.ep[i] == '.') {
       tsMonitor.ep[i] = '_';
     }
@@ -148,7 +148,7 @@ static void *monThreadFunc(void *param) {
     }
 
     if (tsMonitor.state == MON_STATE_NOT_INIT) {
-      int code = 0;
+      int32_t code = 0;
 
       for (; tsMonitor.cmdIndex < MON_CMD_MAX; ++tsMonitor.cmdIndex) {
         monBuildMonitorSql(tsMonitor.sql, tsMonitor.cmdIndex);
@@ -333,7 +333,7 @@ static void monSaveSystemInfo() {
   pos += monBuildReqSql(sql + pos);
 
   void *res = taos_query(tsMonitor.conn, tsMonitor.sql);
-  int   code = taos_errno(res);
+  int32_t code = taos_errno(res);
   taos_free_result(res);
 
   if (code != 0) {

src/query/src/qTsbuf.c

@@ -23,7 +23,7 @@ STSBuf* tsBufCreate(bool autoDelete, int32_t order) {
   pTSBuf->autoDelete = autoDelete;
   
   taosGetTmpfilePath("join", pTSBuf->path);
-  pTSBuf->f = fopen(pTSBuf->path, "w+");
+  pTSBuf->f = fopen(pTSBuf->path, "wb+");
   if (pTSBuf->f == NULL) {
     free(pTSBuf);
     return NULL;
@@ -59,7 +59,7 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
   
   tstrncpy(pTSBuf->path, path, sizeof(pTSBuf->path));
   
-  pTSBuf->f = fopen(pTSBuf->path, "r+");
+  pTSBuf->f = fopen(pTSBuf->path, "rb+");
   if (pTSBuf->f == NULL) {
     free(pTSBuf);
     return NULL;

src/rpc/src/rpcTcp.c

@@ -21,21 +21,14 @@
 #include "rpcLog.h"
 #include "rpcHead.h"
 #include "rpcTcp.h"
-#ifdef WINDOWS
-#include "wepoll.h"
-#endif
-
-#ifndef EPOLLWAKEUP
-  #define EPOLLWAKEUP (1u << 29)
-#endif
 
 typedef struct SFdObj {
   void              *signature;
   SOCKET             fd;          // TCP socket FD
-  int                closedByApp; // 1: already closed by App
   void              *thandle;     // handle from upper layer, like TAOS
   uint32_t           ip;
   uint16_t           port;
+  int16_t            closedByApp; // 1: already closed by App
   struct SThreadObj *pThreadObj;
   struct SFdObj     *prev;
   struct SFdObj     *next;
@@ -47,7 +40,7 @@ typedef struct SThreadObj {
   pthread_mutex_t mutex;
   uint32_t        ip;
   bool            stop;
-  SOCKET          pollFd;
+  EpollFd         pollFd;
   int             numOfFds;
   int             threadId;
   char            label[TSDB_LABEL_LEN];
@@ -59,6 +52,8 @@ typedef struct {
   SOCKET      fd;
   uint32_t    ip;
   uint16_t    port;
+  int8_t      stop;
+  int8_t      reserve;
   char        label[TSDB_LABEL_LEN];
   int         numOfThreads;
   void *      shandle;
@@ -132,7 +127,7 @@ void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThread
       break;
     }
 
-    pThreadObj->pollFd = (int64_t)epoll_create(10);  // size does not matter
+    pThreadObj->pollFd = (EpollFd)epoll_create(10);  // size does not matter
     if (pThreadObj->pollFd < 0) {
       tError("%s failed to create TCP epoll", label);
       code = -1;
@@ -188,8 +183,15 @@ void taosStopTcpServer(void *handle) {
   SServerObj *pServerObj = handle;
 
   if (pServerObj == NULL) return;
-  if(pServerObj->fd >=0) shutdown(pServerObj->fd, SHUT_RD);
+  pServerObj->stop = 1;
 
+  if (pServerObj->fd >= 0) {
+#ifdef WINDOWS
+    closesocket(pServerObj->fd);
+#else
+    shutdown(pServerObj->fd, SHUT_RD);
+#endif
+  }
   if (taosCheckPthreadValid(pServerObj->thread)) {
     if (taosComparePthread(pServerObj->thread, pthread_self())) {
       pthread_detach(pthread_self());
@@ -230,6 +232,11 @@ static void *taosAcceptTcpConnection(void *arg) {
   while (1) {
     socklen_t addrlen = sizeof(caddr);
     connFd = accept(pServerObj->fd, (struct sockaddr *)&caddr, &addrlen);
+    if (pServerObj->stop) {
+      tDebug("%s TCP server stop accepting new connections", pServerObj->label);
+      break;
+    }
+
     if (connFd == -1) {
       if (errno == EINVAL) {
         tDebug("%s TCP server stop accepting new connections, exiting", pServerObj->label);
@@ -292,7 +299,7 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int num, void *
     return NULL;
   }
 
-  pThreadObj->pollFd = (SOCKET)epoll_create(10);  // size does not matter
+  pThreadObj->pollFd = (EpollFd)epoll_create(10);  // size does not matter
   if (pThreadObj->pollFd < 0) {
     tError("%s failed to create TCP client epoll", label);
     free(pThreadObj);
@@ -313,7 +320,7 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int num, void *
       pThreadObj->pollFd = -1;
     }
 #else // __APPLE__
-    taosCloseSocket(pThreadObj->pollFd);
+    EpollClose(pThreadObj->pollFd);
 #endif // __APPLE__
     free(pThreadObj);
     terrno = TAOS_SYSTEM_ERROR(errno); 
@@ -345,7 +352,7 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
   SThreadObj *    pThreadObj = shandle;
 
   SOCKET fd = taosOpenTcpClientSocket(ip, port, pThreadObj->ip);
-  if (fd < 0) return NULL;
+  if (fd <= 0) return NULL;
 
   struct sockaddr_in sin;
   uint16_t localPort = 0;
@@ -528,8 +535,8 @@ static void *taosProcessTcpData(void *param) {
     pThreadObj->pollFd = -1;
   }
 #else // __APPLE__
-  if (pThreadObj->pollFd >=0) taosCloseSocket(pThreadObj->pollFd);
-#endif // __APPLE__
+  if (pThreadObj->pollFd >=0) EpollClose(pThreadObj->pollFd);
+#endif
 
   while (pThreadObj->pHead) {
     SFdObj *pFdObj = pThreadObj->pHead;

src/rpc/src/rpcUdp.c

@@ -198,10 +198,12 @@ static void *taosRecvUdpData(void *param) {
 
   while (1) {
     dataLen = recvfrom(pConn->fd, pConn->buffer, RPC_MAX_UDP_SIZE, 0, (struct sockaddr *)&sourceAdd, &addLen);
-    if(dataLen <= 0) {
-      tDebug("%s UDP socket(fd:%d) receive dataLen(%d) error(%s)", pConn->label, pConn->fd, (int32_t)dataLen, strerror(errno));
+    if (dataLen <= 0) {
+      tDebug("%s UDP socket was closed, exiting(%s), dataLen:%d fd:%d", pConn->label, strerror(errno), (int32_t)dataLen,
+             pConn->fd);
+
       // for windows usage, remote shutdown also returns - 1 in windows client
-      if (-1 == pConn->fd) {
+      if (pConn->fd == -1) {
         break;
       } else {
         continue;

src/sync/CMakeLists.txt

@@ -4,28 +4,13 @@ PROJECT(TDengine)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 
-IF (TD_LINUX)
-  LIST(REMOVE_ITEM SRC src/syncArbitrator.c)
-  ADD_LIBRARY(sync ${SRC})
-  TARGET_LINK_LIBRARIES(sync tutil pthread common)
+LIST(REMOVE_ITEM SRC src/syncArbitrator.c)
+ADD_LIBRARY(sync ${SRC})
+TARGET_LINK_LIBRARIES(sync tutil pthread common)
 
-  LIST(APPEND BIN_SRC src/syncArbitrator.c)
-  LIST(APPEND BIN_SRC src/syncTcp.c)
-  ADD_EXECUTABLE(tarbitrator ${BIN_SRC})
-  TARGET_LINK_LIBRARIES(tarbitrator sync common osdetail tutil)
+LIST(APPEND BIN_SRC src/syncArbitrator.c)
+LIST(APPEND BIN_SRC src/syncTcp.c)
+ADD_EXECUTABLE(tarbitrator ${BIN_SRC})
+TARGET_LINK_LIBRARIES(tarbitrator sync common osdetail tutil)
 
-  #ADD_SUBDIRECTORY(test)
-ENDIF ()
-
-IF (TD_DARWIN)
-  LIST(REMOVE_ITEM SRC src/syncArbitrator.c)
-  ADD_LIBRARY(sync ${SRC})
-  TARGET_LINK_LIBRARIES(sync tutil pthread common)
-
-  LIST(APPEND BIN_SRC src/syncArbitrator.c)
-  LIST(APPEND BIN_SRC src/syncTcp.c)
-  ADD_EXECUTABLE(tarbitrator ${BIN_SRC})
-  TARGET_LINK_LIBRARIES(tarbitrator sync common osdetail tutil)
-
-  #ADD_SUBDIRECTORY(test)
-ENDIF ()
+#ADD_SUBDIRECTORY(test)

src/sync/inc/syncInt.h

@@ -82,8 +82,8 @@ typedef struct SsyncPeer {
   uint64_t sversion;        // track the peer version in retrieve process
   uint64_t lastFileVer;     // track the file version while retrieve
   uint64_t lastWalVer;      // track the wal version while retrieve
-  int32_t  syncFd;
-  int32_t  peerFd;          // forward FD
+  SOCKET   syncFd;
+  SOCKET   peerFd;          // forward FD
   int32_t  numOfRetrieves;  // number of retrieves tried
   int32_t  fileChanged;     // a flag to indicate file is changed during retrieving process
   int32_t  refCount;

src/sync/inc/syncTcp.h

@@ -27,12 +27,12 @@ typedef struct {
   int32_t   bufferSize;
   void    (*processBrokenLink)(int64_t handleId);
   int32_t (*processIncomingMsg)(int64_t handleId, void *buffer);
-  void    (*processIncomingConn)(int32_t fd, uint32_t ip);
+  void    (*processIncomingConn)(SOCKET fd, uint32_t ip);
 } SPoolInfo;
 
 void *syncOpenTcpThreadPool(SPoolInfo *pInfo);
 void  syncCloseTcpThreadPool(void *);
-void *syncAllocateTcpConn(void *, int64_t rid, int32_t connFd);
+void *syncAllocateTcpConn(void *, int64_t rid, SOCKET connFd);
 void  syncFreeTcpConn(void *);
 
 #ifdef __cplusplus

src/sync/src/syncArbitrator.c

@@ -27,8 +27,8 @@
 #include "syncInt.h"
 #include "syncTcp.h"
 
-static void    arbSignalHandler(int32_t signum, siginfo_t *sigInfo, void *context);
-static void    arbProcessIncommingConnection(int32_t connFd, uint32_t sourceIp);
+static void    arbSignalHandler(int32_t signum, void *sigInfo, void *context);
+static void    arbProcessIncommingConnection(SOCKET connFd, uint32_t sourceIp);
 static void    arbProcessBrokenLink(int64_t rid);
 static int32_t arbProcessPeerMsg(int64_t rid, void *buffer);
 static tsem_t  tsArbSem;
@@ -36,7 +36,7 @@ static void *  tsArbTcpPool;
 
 typedef struct {
   char    id[TSDB_EP_LEN + 24];
-  int32_t nodeFd;
+  SOCKET  nodeFd;
   void *  pConn;
 } SNodeConn;
 
@@ -69,12 +69,10 @@ int32_t main(int32_t argc, char *argv[]) {
   }
 
   /* Set termination handler. */
-  struct sigaction act = {{0}};
-  act.sa_flags = SA_SIGINFO;
-  act.sa_sigaction = arbSignalHandler;
-  sigaction(SIGTERM, &act, NULL);
-  sigaction(SIGHUP, &act, NULL);
-  sigaction(SIGINT, &act, NULL);
+  taosSetSignal(SIGTERM, arbSignalHandler);
+  taosSetSignal(SIGINT, arbSignalHandler);
+  taosSetSignal(SIGHUP, arbSignalHandler);
+  taosSetSignal(SIGABRT, arbSignalHandler);
 
   tsAsyncLog = 0;
   strcat(arbLogPath, "/arbitrator.log");
@@ -103,12 +101,12 @@ int32_t main(int32_t argc, char *argv[]) {
 
   syncCloseTcpThreadPool(tsArbTcpPool);
   sInfo("TAOS arbitrator is shut down");
-  closelog();
 
+  closelog();
   return 0;
 }
 
-static void arbProcessIncommingConnection(int32_t connFd, uint32_t sourceIp) {
+static void arbProcessIncommingConnection(SOCKET connFd, uint32_t sourceIp) {
   char ipstr[24];
   tinet_ntoa(ipstr, sourceIp);
   sDebug("peer TCP connection from ip:%s", ipstr);
@@ -172,14 +170,13 @@ static int32_t arbProcessPeerMsg(int64_t rid, void *buffer) {
   return 0;
 }
 
-static void arbSignalHandler(int32_t signum, siginfo_t *sigInfo, void *context) {
-  struct sigaction act = {{0}};
-  act.sa_handler = SIG_IGN;
-  sigaction(SIGTERM, &act, NULL);
-  sigaction(SIGHUP, &act, NULL);
-  sigaction(SIGINT, &act, NULL);
+static void arbSignalHandler(int32_t signum, void *sigInfo, void *context) {
+  taosIgnSignal(SIGTERM);
+  taosIgnSignal(SIGINT);
+  taosIgnSignal(SIGABRT);
+  taosIgnSignal(SIGHUP);
 
-  sInfo("shut down signal is %d, sender PID:%d", signum, sigInfo->si_pid);
+  sInfo("shut down signal is %d", signum);
 
   // inform main thread to exit
   tsem_post(&tsArbSem);

src/sync/src/syncMain.c

@@ -45,7 +45,7 @@ static void    syncCheckPeerConnection(void *param, void *tmrId);
 static int32_t syncSendPeersStatusMsgToPeer(SSyncPeer *pPeer, char ack, int8_t type, uint16_t tranId);
 static void    syncProcessBrokenLink(int64_t rid);
 static int32_t syncProcessPeerMsg(int64_t rid, void *buffer);
-static void    syncProcessIncommingConnection(int32_t connFd, uint32_t sourceIp);
+static void    syncProcessIncommingConnection(SOCKET connFd, uint32_t sourceIp);
 static void    syncRemovePeer(SSyncPeer *pPeer);
 static void    syncAddArbitrator(SSyncNode *pNode);
 static void    syncFreeNode(void *);
@@ -544,7 +544,7 @@ static void syncClosePeerConn(SSyncPeer *pPeer) {
   sDebug("%s, pfd:%d sfd:%d will be closed", pPeer->id, pPeer->peerFd, pPeer->syncFd);
 
   taosTmrStopA(&pPeer->timer);
-  taosClose(pPeer->syncFd);
+  taosCloseSocket(pPeer->syncFd);
   if (pPeer->peerFd >= 0) {
     pPeer->peerFd = -1;
     void *pConn = pPeer->pConn;
@@ -869,7 +869,7 @@ static void syncProcessSyncRequest(char *msg, SSyncPeer *pPeer) {
 
   if (nodeRole != TAOS_SYNC_ROLE_MASTER) {
     sError("%s, I am not master anymore", pPeer->id);
-    taosClose(pPeer->syncFd);
+    taosCloseSocket(pPeer->syncFd);
     return;
   }
 
@@ -1114,8 +1114,8 @@ static void syncSetupPeerConnection(SSyncPeer *pPeer) {
     return;
   }
 
-  int32_t connFd = taosOpenTcpClientSocket(pPeer->ip, pPeer->port, 0);
-  if (connFd < 0) {
+  SOCKET connFd = taosOpenTcpClientSocket(pPeer->ip, pPeer->port, 0);
+  if (connFd <= 0) {
     sDebug("%s, failed to open tcp socket since %s", pPeer->id, strerror(errno));
     taosTmrReset(syncCheckPeerConnection, SYNC_CHECK_INTERVAL, (void *)pPeer->rid, tsSyncTmrCtrl, &pPeer->timer);
     return;
@@ -1132,7 +1132,7 @@ static void syncSetupPeerConnection(SSyncPeer *pPeer) {
     if (pPeer->isArb) tsArbOnline = 1;
   } else {
     sDebug("%s, failed to setup peer connection to server since %s, try later", pPeer->id, strerror(errno));
-    taosClose(connFd);
+    taosCloseSocket(connFd);
     taosTmrReset(syncCheckPeerConnection, SYNC_CHECK_INTERVAL, (void *)pPeer->rid, tsSyncTmrCtrl, &pPeer->timer);
   }
 }
@@ -1171,7 +1171,7 @@ static void syncCreateRestoreDataThread(SSyncPeer *pPeer) {
     SSyncNode *pNode = pPeer->pSyncNode;
     nodeSStatus = TAOS_SYNC_STATUS_INIT;
     sError("%s, failed to create sync restore thread, set sstatus:%s", pPeer->id, syncStatus[nodeSStatus]);
-    taosClose(pPeer->syncFd);
+    taosCloseSocket(pPeer->syncFd);
     syncReleasePeer(pPeer);
   } else {
     sInfo("%s, sync restore thread:0x%08" PRIx64 " create successfully, rid:%" PRId64, pPeer->id,
@@ -1179,7 +1179,7 @@ static void syncCreateRestoreDataThread(SSyncPeer *pPeer) {
   }
 }
 
-static void syncProcessIncommingConnection(int32_t connFd, uint32_t sourceIp) {
+static void syncProcessIncommingConnection(SOCKET connFd, uint32_t sourceIp) {
   char    ipstr[24];
   int32_t i;
 

src/sync/src/syncRestore.c

@@ -128,7 +128,7 @@ static int32_t syncRestoreFile(SSyncPeer *pPeer, uint64_t *fversion) {
     minfo.name[sizeof(minfo.name) - 1] = 0;
     snprintf(name, sizeof(name), "%s/%s", pNode->path, minfo.name);
 
-    int32_t dfd = open(name, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
+    int32_t dfd = open(name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRWXU | S_IRWXG | S_IRWXO);
     if (dfd < 0) {
       sError("%s, failed to open file:%s while restore file since %s", pPeer->id, minfo.name, strerror(errno));
       break;
@@ -365,7 +365,7 @@ void *syncRestoreData(void *param) {
   SSyncNode *pNode = pPeer->pSyncNode;
 
   taosBlockSIGPIPE();
-  __sync_fetch_and_add(&tsSyncNum, 1);
+  atomic_add_fetch_32(&tsSyncNum, 1);
   sInfo("%s, start to restore data, sstatus:%s", pPeer->id, syncStatus[nodeSStatus]);
 
   (*pNode->notifyRole)(pNode->vgId, TAOS_SYNC_ROLE_SYNCING);
@@ -390,9 +390,9 @@ void *syncRestoreData(void *param) {
   nodeSStatus = TAOS_SYNC_STATUS_INIT;
   sInfo("%s, restore data over, set sstatus:%s", pPeer->id, syncStatus[nodeSStatus]);
 
-  taosClose(pPeer->syncFd);
+  taosCloseSocket(pPeer->syncFd);
   syncCloseRecvBuffer(pNode);
-  __sync_fetch_and_sub(&tsSyncNum, 1);
+  atomic_sub_fetch_32(&tsSyncNum, 1);
 
   // The ref is obtained in both the create thread and the current thread, so it is released twice
   syncReleasePeer(pPeer);

src/sync/src/syncRetrieve.c

@@ -14,7 +14,6 @@
  */
 
 #define _DEFAULT_SOURCE
-// #include <sys/inotify.h>
 #include "os.h"
 #include "taoserror.h"
 #include "tlog.h"
@@ -153,14 +152,14 @@ static int32_t syncRetrieveFile(SSyncPeer *pPeer) {
     snprintf(name, sizeof(name), "%s/%s", pNode->path, fileInfo.name);
 
     // send the file to peer
-    int32_t sfd = open(name, O_RDONLY);
+    int32_t sfd = open(name, O_RDONLY | O_BINARY);
     if (sfd < 0) {
       code = -1;
       sError("%s, failed to open file:%s while retrieve file since %s", pPeer->id, fileInfo.name, strerror(errno));
       break;
     }
 
-    ret = taosSendFile(pPeer->syncFd, sfd, NULL, fileInfo.size);
+    ret = (int32_t)taosSendFile(pPeer->syncFd, sfd, NULL, fileInfo.size);
     close(sfd);
     if (ret < 0) {
       code = -1;
@@ -222,13 +221,13 @@ static int32_t syncReadOneWalRecord(int32_t sfd, SWalHead *pHead) {
 }
 
 static int32_t syncRetrieveLastWal(SSyncPeer *pPeer, char *name, uint64_t fversion, int64_t offset) {
-  int32_t sfd = open(name, O_RDONLY);
+  int32_t sfd = open(name, O_RDONLY | O_BINARY);
   if (sfd < 0) {
     sError("%s, failed to open wal:%s for retrieve since:%s", pPeer->id, name, tstrerror(errno));
     return -1;
   }
 
-  int32_t code = taosLSeek(sfd, offset, SEEK_SET);
+  int32_t code = (int32_t)taosLSeek(sfd, offset, SEEK_SET);
   if (code < 0) {
     sError("%s, failed to seek %" PRId64 " in wal:%s for retrieve since:%s", pPeer->id, offset, name, tstrerror(errno));
     close(sfd);
@@ -322,7 +321,7 @@ static int32_t syncProcessLastWal(SSyncPeer *pPeer, char *wname, int64_t index)
     // if all data are read out, and no update
     if (bytes == 0 && !walModified) {
       // wal not closed, it means some data not flushed to disk, wait for a while
-      usleep(10000);
+      taosMsleep(10);
     }
 
     // if bytes > 0, file is updated, or fversion is not reached but file still open, read again
@@ -377,14 +376,14 @@ static int32_t syncRetrieveWal(SSyncPeer *pPeer) {
     size = fstat.st_size;
     sDebug("%s, retrieve wal:%s size:%d", pPeer->id, fname, size);
 
-    int32_t sfd = open(fname, O_RDONLY);
+    int32_t sfd = open(fname, O_RDONLY | O_BINARY);
     if (sfd < 0) {
       code = -1;
       sError("%s, failed to open wal:%s for retrieve since %s, code:0x%x", pPeer->id, fname, strerror(errno), code);
       break;
     }
 
-    code = taosSendFile(pPeer->syncFd, sfd, NULL, size);
+    code = (int32_t)taosSendFile(pPeer->syncFd, sfd, NULL, size);
     close(sfd);
     if (code < 0) {
       sError("%s, failed to send wal:%s for retrieve since %s, code:0x%x", pPeer->id, fname, strerror(errno), code);
@@ -504,7 +503,7 @@ void *syncRetrieveData(void *param) {
   if (pNode->notifyFlowCtrl) (*pNode->notifyFlowCtrl)(pNode->vgId, 0);
 
   pPeer->fileChanged = 0;
-  taosClose(pPeer->syncFd);
+  taosCloseSocket(pPeer->syncFd);
 
   // The ref is obtained in both the create thread and the current thread, so it is released twice
   sInfo("%s, sync retrieve data over, sstatus:%s", pPeer->id, syncStatus[pPeer->sstatus]);

src/sync/src/syncTcp.c

@@ -27,7 +27,7 @@
 typedef struct SThreadObj {
   pthread_t thread;
   bool      stop;
-  int32_t   pollFd;
+  SOCKET    pollFd;
   int32_t   numOfFds;
   struct SPoolObj *pPool;
 } SThreadObj;
@@ -37,13 +37,14 @@ typedef struct SPoolObj {
   SThreadObj **pThread;
   pthread_t    thread;
   int32_t      nextId;
-  int32_t      acceptFd;  // FD for accept new connection
+  SOCKET       acceptFd;  // FD for accept new connection
+  int8_t       stop;
 } SPoolObj;
 
 typedef struct {
   SThreadObj *pThread;
   int64_t     handleId;
-  int32_t     fd;
+  SOCKET      fd;
   int32_t     closedByApp;
 } SConnObj;
 
@@ -82,7 +83,7 @@ void *syncOpenTcpThreadPool(SPoolInfo *pInfo) {
   pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
   if (pthread_create(&(pPool->thread), &thattr, (void *)syncAcceptPeerTcpConnection, pPool) != 0) {
     sError("failed to create accept thread for TCP server since %s", strerror(errno));
-    close(pPool->acceptFd);
+    taosCloseSocket(pPool->acceptFd);
     tfree(pPool->pThread);
     tfree(pPool);
     return NULL;
@@ -98,7 +99,14 @@ void syncCloseTcpThreadPool(void *param) {
   SPoolObj *  pPool = param;
   SThreadObj *pThread;
 
+  pPool->stop = 1;
+
+#ifdef WINDOWS
+  closesocket(pPool->acceptFd);
+#else
   shutdown(pPool->acceptFd, SHUT_RD);
+#endif
+
   pthread_join(pPool->thread, NULL);
 
   for (int32_t i = 0; i < pPool->info.numOfThreads; ++i) {
@@ -112,7 +120,7 @@ void syncCloseTcpThreadPool(void *param) {
   tfree(pPool);
 }
 
-void *syncAllocateTcpConn(void *param, int64_t rid, int32_t connFd) {
+void *syncAllocateTcpConn(void *param, int64_t rid, SOCKET connFd) {
   struct epoll_event event;
   SPoolObj *pPool = param;
 
@@ -169,7 +177,7 @@ static void taosProcessBrokenLink(SConnObj *pConn) {
   pThread->numOfFds--;
   epoll_ctl(pThread->pollFd, EPOLL_CTL_DEL, pConn->fd, NULL);
   sDebug("%p fd:%d is removed from epoll thread, num:%d", pThread, pConn->fd, pThread->numOfFds);
-  taosClose(pConn->fd);
+  taosCloseSocket(pConn->fd);
   tfree(pConn);
 }
 
@@ -236,7 +244,7 @@ static void *syncProcessTcpData(void *param) {
 #ifdef __APPLE__
   epoll_close(pThread->pollFd);
 #else // __APPLE__
-  close(pThread->pollFd);
+  EpollClose(pThread->pollFd);
 #endif // __APPLE__
   tfree(pThread);
   tfree(buffer);
@@ -252,7 +260,12 @@ static void *syncAcceptPeerTcpConnection(void *argv) {
   while (1) {
     struct sockaddr_in clientAddr;
     socklen_t addrlen = sizeof(clientAddr);
-    int32_t connFd = accept(pPool->acceptFd, (struct sockaddr *)&clientAddr, &addrlen);
+    SOCKET connFd = accept(pPool->acceptFd, (struct sockaddr *)&clientAddr, &addrlen);
+    if (pPool->stop) {
+      sDebug("%p TCP server accept is stopped", pPool);
+      break;
+    }
+
     if (connFd < 0) {
       if (errno == EINVAL) {
         sDebug("%p TCP server accept is exiting...", pPool);
@@ -268,7 +281,7 @@ static void *syncAcceptPeerTcpConnection(void *argv) {
     (*pInfo->processIncomingConn)(connFd, clientAddr.sin_addr.s_addr);
   }
 
-  taosClose(pPool->acceptFd);
+  taosCloseSocket(pPool->acceptFd);
   return NULL;
 }
 
@@ -281,7 +294,7 @@ static SThreadObj *syncGetTcpThread(SPoolObj *pPool) {
   if (pThread == NULL) return NULL;
 
   pThread->pPool = pPool;
-  pThread->pollFd = epoll_create(10);  // size does not matter
+  pThread->pollFd = (EpollFd)epoll_create(10);  // size does not matter
   if (pThread->pollFd < 0) {
     tfree(pThread);
     return NULL;
@@ -297,8 +310,8 @@ static SThreadObj *syncGetTcpThread(SPoolObj *pPool) {
 #ifdef __APPLE__
     epoll_close(pThread->pollFd);
 #else // __APPLE__
-    close(pThread->pollFd);
-#endif // __APPLE__
+    EpollClose(pThread->pollFd);
+#endif
     tfree(pThread);
     return NULL;
   }

src/tsdb/src/tsdbCommit.c

@@ -273,11 +273,11 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
 
   pthread_rwlock_wrlock(&(pFileH->fhlock));
 
-  (void)rename(helperNewHeadF(pHelper)->fname, helperHeadF(pHelper)->fname);
+  (void)taosRename(helperNewHeadF(pHelper)->fname, helperHeadF(pHelper)->fname);
   pGroup->files[TSDB_FILE_TYPE_HEAD].info = helperNewHeadF(pHelper)->info;
 
   if (newLast) {
-    (void)rename(helperNewLastF(pHelper)->fname, helperLastF(pHelper)->fname);
+    (void)taosRename(helperNewLastF(pHelper)->fname, helperLastF(pHelper)->fname);
     pGroup->files[TSDB_FILE_TYPE_LAST].info = helperNewLastF(pHelper)->info;
   } else {
     pGroup->files[TSDB_FILE_TYPE_LAST].info = helperLastF(pHelper)->info;

src/tsdb/src/tsdbFile.c

@@ -175,7 +175,7 @@ int tsdbOpenFileH(STsdbRepo *pRepo) {
         }
         sprintf(fname2, "%s/%s_back_%" PRId64, tDataDir, dp->d_name, taosGetTimestamp(TSDB_TIME_PRECISION_MILLI));
 
-        (void)rename(fname1, fname2);
+        (void)taosRename(fname1, fname2);
 
         tsdbDebug("vgId:%d file %s exists, backup it as %s", REPO_ID(pRepo), fname1, fname2);
 
@@ -339,7 +339,7 @@ SFileGroup *tsdbGetFileGroupNext(SFileGroupIter *pIter) {
 int tsdbOpenFile(SFile *pFile, int oflag) {
   ASSERT(!TSDB_IS_FILE_OPENED(pFile));
 
-  pFile->fd = open(pFile->fname, oflag, 0755);
+  pFile->fd = open(pFile->fname, oflag | O_BINARY, 0755);
   if (pFile->fd < 0) {
     tsdbError("failed to open file %s since %s", pFile->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);