Merge pull request #10231 from taosdata/feature/privilege

serialize mnode msg

include/common/tmsg.h

@@ -394,8 +394,8 @@ typedef struct {
   SHashObj* writeDbs;
 } SGetUserAuthRsp;
 
-int32_t tSerializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pReq);
-int32_t tDeserializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pReq);
+int32_t tSerializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pRsp);
+int32_t tDeserializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pRsp);
 
 typedef struct {
   int16_t colId;     // column id
@@ -570,6 +570,9 @@ typedef struct {
   int8_t  ignoreExist;
 } SCreateDbReq;
 
+int32_t tSerializeSCreateDbReq(void* buf, int32_t bufLen, SCreateDbReq* pReq);
+int32_t tDeserializeSCreateDbReq(void* buf, int32_t bufLen, SCreateDbReq* pReq);
+
 typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   int32_t totalBlocks;
@@ -582,28 +585,39 @@ typedef struct {
   int8_t  cacheLastRow;
 } SAlterDbReq;
 
+int32_t tSerializeSAlterDbReq(void* buf, int32_t bufLen, SAlterDbReq* pReq);
+int32_t tDeserializeSAlterDbReq(void* buf, int32_t bufLen, SAlterDbReq* pReq);
+
 typedef struct {
   char   db[TSDB_DB_FNAME_LEN];
   int8_t ignoreNotExists;
 } SDropDbReq;
 
+int32_t tSerializeSDropDbReq(void* buf, int32_t bufLen, SDropDbReq* pReq);
+int32_t tDeserializeSDropDbReq(void* buf, int32_t bufLen, SDropDbReq* pReq);
+
 typedef struct {
   char     db[TSDB_DB_FNAME_LEN];
   uint64_t uid;
 } SDropDbRsp;
 
+int32_t tSerializeSDropDbRsp(void* buf, int32_t bufLen, SDropDbRsp* pRsp);
+int32_t tDeserializeSDropDbRsp(void* buf, int32_t bufLen, SDropDbRsp* pRsp);
+
 typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   int32_t vgVersion;
 } SUseDbReq;
 
-typedef struct {
-  char db[TSDB_DB_FNAME_LEN];
-} SSyncDbReq;
+int32_t tSerializeSUseDbReq(void* buf, int32_t bufLen, SUseDbReq* pReq);
+int32_t tDeserializeSUseDbReq(void* buf, int32_t bufLen, SUseDbReq* pReq);
 
 typedef struct {
   char db[TSDB_DB_FNAME_LEN];
-} SCompactDbReq;
+} SSyncDbReq, SCompactDbReq;
+
+int32_t tSerializeSSyncDbReq(void* buf, int32_t bufLen, SSyncDbReq* pReq);
+int32_t tDeserializeSSyncDbReq(void* buf, int32_t bufLen, SSyncDbReq* pReq);
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -616,22 +630,31 @@ typedef struct {
   int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
-  char    pCont[];
+  char    pComment[TSDB_FUNC_COMMENT_LEN];
+  char    pCode[TSDB_FUNC_CODE_LEN];
 } SCreateFuncReq;
 
+int32_t tSerializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq);
+int32_t tDeserializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq);
+
 typedef struct {
   char   name[TSDB_FUNC_NAME_LEN];
   int8_t igNotExists;
 } SDropFuncReq;
 
+int32_t tSerializeSDropFuncReq(void* buf, int32_t bufLen, SDropFuncReq* pReq);
+int32_t tDeserializeSDropFuncReq(void* buf, int32_t bufLen, SDropFuncReq* pReq);
+
 typedef struct {
   int32_t numOfFuncs;
-  char    pFuncNames[];
+  SArray* pFuncNames;
 } SRetrieveFuncReq;
 
+int32_t tSerializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq);
+int32_t tDeserializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq);
+
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
-  int8_t  align;
   int8_t  funcType;
   int8_t  scriptType;
   int8_t  outputType;
@@ -640,14 +663,18 @@ typedef struct {
   int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
-  char    pCont[];
+  char    pComment[TSDB_FUNC_COMMENT_LEN];
+  char    pCode[TSDB_FUNC_CODE_LEN];
 } SFuncInfo;
 
 typedef struct {
   int32_t numOfFuncs;
-  char    pFuncInfos[];
+  SArray* pFuncInfos;
 } SRetrieveFuncRsp;
 
+int32_t tSerializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp);
+int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp);
+
 typedef struct {
   int32_t statusInterval;
   int64_t checkTime;                    // 1970-01-01 00:00:00.000

source/common/src/tmsg.c

@@ -753,29 +753,29 @@ int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *
   return 0;
 }
 
-int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pReq) {
+int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
 
   if (tStartEncode(&encoder) < 0) return -1;
-  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->superAuth) < 0) return -1;
+  if (tEncodeCStr(&encoder, pRsp->user) < 0) return -1;
+  if (tEncodeI8(&encoder, pRsp->superAuth) < 0) return -1;
 
-  int32_t numOfReadDbs = taosHashGetSize(pReq->readDbs);
-  int32_t numOfWriteDbs = taosHashGetSize(pReq->writeDbs);
+  int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs);
+  int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs);
   if (tEncodeI32(&encoder, numOfReadDbs) < 0) return -1;
   if (tEncodeI32(&encoder, numOfWriteDbs) < 0) return -1;
 
-  char *db = taosHashIterate(pReq->readDbs, NULL);
+  char *db = taosHashIterate(pRsp->readDbs, NULL);
   while (db != NULL) {
     if (tEncodeCStr(&encoder, db) < 0) return -1;
-    db = taosHashIterate(pReq->readDbs, db);
+    db = taosHashIterate(pRsp->readDbs, db);
   }
 
-  db = taosHashIterate(pReq->writeDbs, NULL);
+  db = taosHashIterate(pRsp->writeDbs, NULL);
   while (db != NULL) {
     if (tEncodeCStr(&encoder, db) < 0) return -1;
-    db = taosHashIterate(pReq->writeDbs, db);
+    db = taosHashIterate(pRsp->writeDbs, db);
   }
 
   tEndEncode(&encoder);
@@ -785,10 +785,10 @@ int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pR
   return tlen;
 }
 
-int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pReq) {
-  pReq->readDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-  pReq->writeDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-  if (pReq->readDbs == NULL || pReq->writeDbs == NULL) {
+int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
+  pRsp->readDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  pRsp->writeDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  if (pRsp->readDbs == NULL || pRsp->writeDbs == NULL) {
     return -1;
   }
 
@@ -796,8 +796,8 @@ int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *
   tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
 
   if (tStartDecode(&decoder) < 0) return -1;
-  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->superAuth) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pRsp->user) < 0) return -1;
+  if (tDecodeI8(&decoder, &pRsp->superAuth) < 0) return -1;
 
   int32_t numOfReadDbs = 0;
   int32_t numOfWriteDbs = 0;
@@ -808,14 +808,14 @@ int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *
     char db[TSDB_DB_FNAME_LEN] = {0};
     if (tDecodeCStrTo(&decoder, db) < 0) return -1;
     int32_t len = strlen(db) + 1;
-    taosHashPut(pReq->readDbs, db, len, db, len);
+    taosHashPut(pRsp->readDbs, db, len, db, len);
   }
 
   for (int32_t i = 0; i < numOfWriteDbs; ++i) {
     char db[TSDB_DB_FNAME_LEN] = {0};
     if (tDecodeCStrTo(&decoder, db) < 0) return -1;
     int32_t len = strlen(db) + 1;
-    taosHashPut(pReq->writeDbs, db, len, db, len);
+    taosHashPut(pRsp->writeDbs, db, len, db, len);
   }
 
   tEndDecode(&decoder);
@@ -920,3 +920,390 @@ int32_t tDeserializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *
   tCoderClear(&decoder);
   return 0;
 }
+
+int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->funcType) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->scriptType) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->outputType) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1;
+  if (tEncodeI64(&encoder, pReq->signature) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->commentSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->codeSize) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->funcType) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->scriptType) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->outputType) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1;
+  if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->commentSize) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->codeSize) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1;
+
+  if (pReq->numOfFuncs != (int32_t)taosArrayGetSize(pReq->pFuncNames)) return -1;
+  for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
+    char *fname = taosArrayGet(pReq->pFuncNames, i);
+    if (tEncodeCStr(&encoder, fname) < 0) return -1;
+  }
+
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1;
+
+  pReq->pFuncNames = taosArrayInit(pReq->numOfFuncs, TSDB_FUNC_NAME_LEN);
+  if (pReq->pFuncNames == NULL) return -1;
+
+  for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
+    char fname[TSDB_FUNC_NAME_LEN] = {0};
+    if (tDecodeCStrTo(&decoder, fname) < 0) return -1;
+    taosArrayPush(pReq->pFuncNames, fname);
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->numOfFuncs) < 0) return -1;
+
+  if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncInfos)) return -1;
+  for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
+    SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i);
+
+    if (tEncodeCStr(&encoder, pInfo->name) < 0) return -1;
+    if (tEncodeI8(&encoder, pInfo->funcType) < 0) return -1;
+    if (tEncodeI8(&encoder, pInfo->scriptType) < 0) return -1;
+    if (tEncodeI8(&encoder, pInfo->outputType) < 0) return -1;
+    if (tEncodeI32(&encoder, pInfo->outputLen) < 0) return -1;
+    if (tEncodeI32(&encoder, pInfo->bufSize) < 0) return -1;
+    if (tEncodeI64(&encoder, pInfo->signature) < 0) return -1;
+    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
+    if (tEncodeI32(&encoder, pInfo->codeSize) < 0) return -1;
+    if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
+    if (tEncodeCStr(&encoder, pInfo->pCode) < 0) return -1;
+  }
+
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->numOfFuncs) < 0) return -1;
+
+  pRsp->pFuncInfos = taosArrayInit(pRsp->numOfFuncs, sizeof(SFuncInfo));
+  if (pRsp->pFuncInfos == NULL) return -1;
+
+  for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
+    SFuncInfo fInfo = {0};
+    if (tDecodeCStrTo(&decoder, fInfo.name) < 0) return -1;
+    if (tDecodeI8(&decoder, &fInfo.funcType) < 0) return -1;
+    if (tDecodeI8(&decoder, &fInfo.scriptType) < 0) return -1;
+    if (tDecodeI8(&decoder, &fInfo.outputType) < 0) return -1;
+    if (tDecodeI32(&decoder, &fInfo.outputLen) < 0) return -1;
+    if (tDecodeI32(&decoder, &fInfo.bufSize) < 0) return -1;
+    if (tDecodeI64(&decoder, &fInfo.signature) < 0) return -1;
+    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
+    if (tDecodeI32(&decoder, &fInfo.codeSize) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1;
+    taosArrayPush(pRsp->pFuncInfos, &fInfo);
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->numOfVgroups) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->cacheBlockSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->totalBlocks) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->maxRows) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->commitTime) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->fsyncPeriod) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->precision) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->replications) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->quorum) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->update) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->ignoreExist) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->numOfVgroups) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->cacheBlockSize) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->totalBlocks) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->maxRows) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->commitTime) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->fsyncPeriod) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->quorum) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->update) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->ignoreExist) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->totalBlocks) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->fsyncPeriod) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->quorum) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->totalBlocks) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->fsyncPeriod) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->quorum) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->ignoreNotExists) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->ignoreNotExists) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pRsp->db) < 0) return -1;
+  if (tEncodeU64(&encoder, pRsp->uid) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pRsp->db) < 0) return -1;
+  if (tDecodeU64(&decoder, &pRsp->uid) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSSyncDbReq(void *buf, int32_t bufLen, SSyncDbReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSSyncDbReq(void *buf, int32_t bufLen, SSyncDbReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
\ No newline at end of file

source/dnode/mnode/impl/inc/mndAuth.h

@@ -29,9 +29,12 @@ int32_t mndCheckCreateUserAuth(SUserObj *pOperUser);
 int32_t mndCheckAlterUserAuth(SUserObj *pOperUser, SUserObj *pUser, SDbObj *pDb, SAlterUserReq *pAlter);
 int32_t mndCheckDropUserAuth(SUserObj *pOperUser);
 
-int32_t mndCheckCreateNodeAuth(SUserObj *pOperUser);
-int32_t mndCheckDropNodeAuth(SUserObj *pOperUser);
-int32_t mndCheckAlterNodeAuth(SUserObj *pOperUser);
+int32_t mndCheckNodeAuth(SUserObj *pOperUser);
+int32_t mndCheckFuncAuth(SUserObj *pOperUser);
+
+int32_t mndCheckCreateDbAuth(SUserObj *pOperUser);
+int32_t mndCheckAlterDropCompactSyncDbAuth(SUserObj *pOperUser, SDbObj *pDb);
+int32_t mndCheckUseDbAuth(SUserObj *pOperUser, SDbObj *pDb);
 
 #ifdef __cplusplus
 }

source/dnode/mnode/impl/src/mndAuth.c

@@ -111,7 +111,7 @@ int32_t mndCheckDropUserAuth(SUserObj *pOperUser) {
   return -1;
 }
 
-int32_t mndCheckCreateNodeAuth(SUserObj *pOperUser) {
+int32_t mndCheckNodeAuth(SUserObj *pOperUser) {
   if (pOperUser->superUser) {
     return 0;
   }
@@ -120,6 +120,24 @@ int32_t mndCheckCreateNodeAuth(SUserObj *pOperUser) {
   return -1;
 }
 
-int32_t mndCheckDropNodeAuth(SUserObj *pOperUser) { return mndCheckCreateNodeAuth(pOperUser); }
+int32_t mndCheckFuncAuth(SUserObj *pOperUser) {
+  if (pOperUser->superUser) {
+    return 0;
+  }
+
+  terrno = TSDB_CODE_MND_NO_RIGHTS;
+  return -1;
+}
+
+int32_t mndCheckCreateDbAuth(SUserObj *pOperUser) { return 0; }
+
+int32_t mndCheckAlterDropCompactSyncDbAuth(SUserObj *pOperUser, SDbObj *pDb) {
+  if (pOperUser->superUser || strcmp(pOperUser->user, pDb->createUser) == 0) {
+    return 0;
+  }
+
+  terrno = TSDB_CODE_MND_NO_RIGHTS;
+  return -1;
+}
 
-int32_t mndCheckAlterNodeAuth(SUserObj *pOperUser) { return mndCheckCreateNodeAuth(pOperUser); }
+int32_t mndCheckUseDbAuth(SUserObj *pOperUser, SDbObj *pDb) { return 0; }

source/dnode/mnode/impl/src/mndBnode.c

@@ -293,7 +293,7 @@ static int32_t mndProcessCreateBnodeReq(SMnodeMsg *pReq) {
     goto CREATE_BNODE_OVER;
   }
 
-  if (mndCheckDropNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto CREATE_BNODE_OVER;
   }
 
@@ -400,7 +400,7 @@ static int32_t mndProcessDropBnodeReq(SMnodeMsg *pReq) {
     goto DROP_BNODE_OVER;
   }
 
-  if (mndCheckCreateNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto DROP_BNODE_OVER;
   }
 

source/dnode/mnode/impl/src/mndDnode.c

@@ -496,7 +496,7 @@ static int32_t mndProcessCreateDnodeReq(SMnodeMsg *pReq) {
     goto CREATE_DNODE_OVER;
   }
 
-  if (mndCheckDropNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto CREATE_DNODE_OVER;
   }
 
@@ -506,7 +506,6 @@ static int32_t mndProcessCreateDnodeReq(SMnodeMsg *pReq) {
 CREATE_DNODE_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, terrstr());
-    return -1;
   }
 
   mndReleaseDnode(pMnode, pDnode);
@@ -545,9 +544,9 @@ static int32_t mndProcessDropDnodeReq(SMnodeMsg *pReq) {
   int32_t        code = -1;
   SUserObj      *pUser = NULL;
   SDnodeObj     *pDnode = NULL;
-  SDropDnodeReq dropReq = {0};
+  SMDropMnodeReq dropReq = {0};
 
-  if (tDeserializeSDropDnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSMCreateDropMnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto DROP_DNODE_OVER;
   }
@@ -571,7 +570,7 @@ static int32_t mndProcessDropDnodeReq(SMnodeMsg *pReq) {
     goto DROP_DNODE_OVER;
   }
 
-  if (mndCheckCreateNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto DROP_DNODE_OVER;
   }
 
@@ -581,7 +580,6 @@ static int32_t mndProcessDropDnodeReq(SMnodeMsg *pReq) {
 DROP_DNODE_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("dnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr());
-    return -1;
   }
 
   mndReleaseDnode(pMnode, pDnode);
@@ -592,13 +590,17 @@ DROP_DNODE_OVER:
 
 static int32_t mndProcessConfigDnodeReq(SMnodeMsg *pReq) {
   SMnode *pMnode = pReq->pMnode;
-  SMCfgDnodeReq *pCfg = pReq->rpcMsg.pCont;
-  pCfg->dnodeId = htonl(pCfg->dnodeId);
 
-  SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCfg->dnodeId);
+  SMCfgDnodeReq cfgReq = {0};
+  if (tDeserializeSMCfgDnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &cfgReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  SDnodeObj *pDnode = mndAcquireDnode(pMnode, cfgReq.dnodeId);
   if (pDnode == NULL) {
     terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-    mError("dnode:%d, failed to config since %s ", pCfg->dnodeId, terrstr());
+    mError("dnode:%d, failed to config since %s ", cfgReq.dnodeId, terrstr());
     return -1;
   }
 
@@ -606,15 +608,15 @@ static int32_t mndProcessConfigDnodeReq(SMnodeMsg *pReq) {
   mndReleaseDnode(pMnode, pDnode);
 
   SDCfgDnodeReq *pCfgDnode = rpcMallocCont(sizeof(SDCfgDnodeReq));
-  pCfgDnode->dnodeId = htonl(pCfg->dnodeId);
-  memcpy(pCfgDnode->config, pCfg->config, TSDB_DNODE_CONFIG_LEN);
+  pCfgDnode->dnodeId = htonl(cfgReq.dnodeId);
+  memcpy(pCfgDnode->config, cfgReq.config, TSDB_DNODE_CONFIG_LEN);
 
   SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE,
                     .pCont = pCfgDnode,
                     .contLen = sizeof(SDCfgDnodeReq),
                     .ahandle = pReq->rpcMsg.ahandle};
 
-  mInfo("dnode:%d, app:%p config:%s req send to dnode", pCfg->dnodeId, rpcMsg.ahandle, pCfg->config);
+  mInfo("dnode:%d, app:%p config:%s req send to dnode", cfgReq.dnodeId, rpcMsg.ahandle, cfgReq.config);
   mndSendReqToDnode(pMnode, &epSet, &rpcMsg);
 
   return 0;

source/dnode/mnode/impl/src/mndFunc.c

@@ -15,9 +15,11 @@
 
 #define _DEFAULT_SOURCE
 #include "mndFunc.h"
+#include "mndAuth.h"
 #include "mndShow.h"
 #include "mndSync.h"
 #include "mndTrans.h"
+#include "mndUser.h"
 
 #define SDB_FUNC_VER 1
 #define SDB_FUNC_RESERVE_SIZE 64
@@ -201,8 +203,8 @@ static int32_t mndCreateFunc(SMnode *pMnode, SMnodeMsg *pReq, SCreateFuncReq *pC
     goto CREATE_FUNC_OVER;
   }
 
-  memcpy(func.pComment, pCreate->pCont, pCreate->commentSize);
-  memcpy(func.pCode, pCreate->pCont + pCreate->commentSize, func.codeSize);
+  memcpy(func.pComment, pCreate->pComment, pCreate->commentSize);
+  memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pReq->rpcMsg);
   if (pTrans == NULL) goto CREATE_FUNC_OVER;
@@ -262,163 +264,201 @@ DROP_FUNC_OVER:
 
 static int32_t mndProcessCreateFuncReq(SMnodeMsg *pReq) {
   SMnode        *pMnode = pReq->pMnode;
+  int32_t        code = -1;
+  SUserObj      *pUser = NULL;
+  SFuncObj      *pFunc = NULL;
+  SCreateFuncReq createReq = {0};
 
-  SCreateFuncReq *pCreate = pReq->rpcMsg.pCont;
-  pCreate->outputLen = htonl(pCreate->outputLen);
-  pCreate->bufSize = htonl(pCreate->bufSize);
-  pCreate->signature = htobe64(pCreate->signature);
-  pCreate->commentSize = htonl(pCreate->commentSize);
-  pCreate->codeSize = htonl(pCreate->codeSize);
+  if (tDeserializeSCreateFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto CREATE_FUNC_OVER;
+  }
 
-  mDebug("func:%s, start to create", pCreate->name);
+  mDebug("func:%s, start to create", createReq.name);
 
-  SFuncObj *pFunc = mndAcquireFunc(pMnode, pCreate->name);
+  pFunc = mndAcquireFunc(pMnode, createReq.name);
   if (pFunc != NULL) {
-    mndReleaseFunc(pMnode, pFunc);
-    if (pCreate->igExists) {
-      mDebug("stb:%s, already exist, ignore exist is set", pCreate->name);
-      return 0;
+    if (createReq.igExists) {
+      mDebug("func:%s, already exist, ignore exist is set", createReq.name);
+      code = 0;
+      goto CREATE_FUNC_OVER;
     } else {
       terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
-      mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-      return -1;
+      goto CREATE_FUNC_OVER;
     }
   } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
-    mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    goto CREATE_FUNC_OVER;
   }
 
-  if (pCreate->name[0] == 0) {
+  if (createReq.name[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    goto CREATE_FUNC_OVER;
   }
 
-  if (pCreate->commentSize <= 0 || pCreate->commentSize > TSDB_FUNC_COMMENT_LEN) {
+  if (createReq.commentSize <= 0 || createReq.commentSize > TSDB_FUNC_COMMENT_LEN) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    goto CREATE_FUNC_OVER;
   }
 
-  if (pCreate->codeSize <= 0 || pCreate->codeSize > TSDB_FUNC_CODE_LEN) {
+  if (createReq.codeSize <= 0 || createReq.codeSize > TSDB_FUNC_CODE_LEN) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    goto CREATE_FUNC_OVER;
   }
 
-  if (pCreate->pCont[0] == 0) {
+  if (createReq.pCode[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    goto CREATE_FUNC_OVER;
   }
 
-  if (pCreate->bufSize <= 0 || pCreate->bufSize > TSDB_FUNC_BUF_SIZE) {
+  if (createReq.bufSize <= 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    goto CREATE_FUNC_OVER;
   }
 
-  int32_t code = mndCreateFunc(pMnode, pReq, pCreate);
-  if (code != 0) {
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto CREATE_FUNC_OVER;
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  if (mndCheckFuncAuth(pUser)) {
+    goto CREATE_FUNC_OVER;
+  }
+
+  code = mndCreateFunc(pMnode, pReq, &createReq);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+CREATE_FUNC_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("func:%s, failed to create since %s", createReq.name, terrstr());
+  }
+
+  mndReleaseFunc(pMnode, pFunc);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndProcessDropFuncReq(SMnodeMsg *pReq) {
   SMnode      *pMnode = pReq->pMnode;
-  SDropFuncReq *pDrop = pReq->rpcMsg.pCont;
+  int32_t      code = -1;
+  SUserObj    *pUser = NULL;
+  SFuncObj    *pFunc = NULL;
+  SDropFuncReq dropReq = {0};
+
+  if (tDeserializeSDropFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto DROP_FUNC_OVER;
+  }
 
-  mDebug("func:%s, start to drop", pDrop->name);
+  mDebug("func:%s, start to drop", dropReq.name);
 
-  if (pDrop->name[0] == 0) {
+  if (dropReq.name[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
-    mError("func:%s, failed to drop since %s", pDrop->name, terrstr());
-    return -1;
+    goto DROP_FUNC_OVER;
   }
 
-  SFuncObj *pFunc = mndAcquireFunc(pMnode, pDrop->name);
+  pFunc = mndAcquireFunc(pMnode, dropReq.name);
   if (pFunc == NULL) {
-    if (pDrop->igNotExists) {
-      mDebug("func:%s, not exist, ignore not exist is set", pDrop->name);
-      return 0;
+    if (dropReq.igNotExists) {
+      mDebug("func:%s, not exist, ignore not exist is set", dropReq.name);
+      code = 0;
+      goto DROP_FUNC_OVER;
     } else {
       terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
-      mError("func:%s, failed to drop since %s", pDrop->name, terrstr());
-      return -1;
+      goto DROP_FUNC_OVER;
     }
   }
 
-  int32_t code = mndDropFunc(pMnode, pReq, pFunc);
-  mndReleaseFunc(pMnode, pFunc);
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto DROP_FUNC_OVER;
+  }
 
-  if (code != 0) {
-    mError("func:%s, failed to drop since %s", pDrop->name, terrstr());
-    return -1;
+  if (mndCheckFuncAuth(pUser)) {
+    goto DROP_FUNC_OVER;
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  code = mndDropFunc(pMnode, pReq, pFunc);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+DROP_FUNC_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("func:%s, failed to drop since %s", dropReq.name, terrstr());
+  }
+
+  mndReleaseFunc(pMnode, pFunc);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndProcessRetrieveFuncReq(SMnodeMsg *pReq) {
-  int32_t code = -1;
   SMnode          *pMnode = pReq->pMnode;
+  int32_t          code = -1;
+  SRetrieveFuncReq retrieveReq = {0};
+  SRetrieveFuncRsp retrieveRsp = {0};
 
-  SRetrieveFuncReq *pRetrieve = pReq->rpcMsg.pCont;
-  pRetrieve->numOfFuncs = htonl(pRetrieve->numOfFuncs);
-  if (pRetrieve->numOfFuncs <= 0 || pRetrieve->numOfFuncs > TSDB_FUNC_MAX_RETRIEVE) {
-    terrno = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE;
-    return -1;
+  if (tDeserializeSRetrieveFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &retrieveReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto RETRIEVE_FUNC_OVER;
   }
 
-  int32_t fsize = sizeof(SFuncInfo) + TSDB_FUNC_CODE_LEN + TSDB_FUNC_COMMENT_LEN;
-  int32_t size = sizeof(SRetrieveFuncRsp) + fsize * pRetrieve->numOfFuncs;
+  if (retrieveReq.numOfFuncs <= 0 || retrieveReq.numOfFuncs > TSDB_FUNC_MAX_RETRIEVE) {
+    terrno = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE;
+    goto RETRIEVE_FUNC_OVER;
+  }
 
-  SRetrieveFuncRsp *pRetrieveRsp = rpcMallocCont(size);
-  if (pRetrieveRsp == NULL) {
+  retrieveRsp.numOfFuncs = retrieveReq.numOfFuncs;
+  retrieveRsp.pFuncInfos = taosArrayInit(retrieveReq.numOfFuncs, sizeof(SFuncInfo));
+  if (retrieveRsp.pFuncInfos == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto FUNC_RETRIEVE_OVER;
+    goto RETRIEVE_FUNC_OVER;
   }
 
-  pRetrieveRsp->numOfFuncs = htonl(pRetrieve->numOfFuncs);
-  char *pOutput = pRetrieveRsp->pFuncInfos;
-
-  for (int32_t i = 0; i < pRetrieve->numOfFuncs; ++i) {
-    char funcName[TSDB_FUNC_NAME_LEN] = {0};
-    memcpy(funcName, pRetrieve->pFuncNames + i * TSDB_FUNC_NAME_LEN, TSDB_FUNC_NAME_LEN);
+  for (int32_t i = 0; i < retrieveReq.numOfFuncs; ++i) {
+    char *funcName = taosArrayGet(retrieveReq.pFuncNames, i);
 
     SFuncObj *pFunc = mndAcquireFunc(pMnode, funcName);
     if (pFunc == NULL) {
       terrno = TSDB_CODE_MND_INVALID_FUNC;
-      mError("func:%s, failed to retrieve since %s", funcName, terrstr());
-      goto FUNC_RETRIEVE_OVER;
-    }
-
-    SFuncInfo *pFuncInfo = (SFuncInfo *)pOutput;
-    memcpy(pFuncInfo->name, pFunc->name, TSDB_FUNC_NAME_LEN);
-    pFuncInfo->funcType = pFunc->funcType;
-    pFuncInfo->scriptType = pFunc->scriptType;
-    pFuncInfo->outputType = pFunc->outputType;
-    pFuncInfo->outputLen = htonl(pFunc->outputLen);
-    pFuncInfo->bufSize = htonl(pFunc->bufSize);
-    pFuncInfo->signature = htobe64(pFunc->signature);
-    pFuncInfo->commentSize = htonl(pFunc->commentSize);
-    pFuncInfo->codeSize = htonl(pFunc->codeSize);
-    memcpy(pFuncInfo->pCont, pFunc->pComment, pFunc->commentSize);
-    memcpy(pFuncInfo->pCont + pFunc->commentSize, pFunc->pCode, pFunc->codeSize);
-    pOutput += (sizeof(SFuncInfo) + pFunc->commentSize + pFunc->codeSize);
+      goto RETRIEVE_FUNC_OVER;
+    }
+
+    SFuncInfo funcInfo = {0};
+    memcpy(funcInfo.name, pFunc->name, TSDB_FUNC_NAME_LEN);
+    funcInfo.funcType = pFunc->funcType;
+    funcInfo.scriptType = pFunc->scriptType;
+    funcInfo.outputType = pFunc->outputType;
+    funcInfo.outputLen = pFunc->outputLen;
+    funcInfo.bufSize = pFunc->bufSize;
+    funcInfo.signature = pFunc->signature;
+    funcInfo.commentSize = pFunc->commentSize;
+    funcInfo.codeSize = pFunc->codeSize;
+    memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
+    memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
+    taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo);
     mndReleaseFunc(pMnode, pFunc);
   }
 
-  pReq->pCont = pRetrieveRsp;
-  pReq->contLen = (int32_t)(pOutput - (char *)pRetrieveRsp);
+  int32_t contLen = tSerializeSRetrieveFuncRsp(NULL, 0, &retrieveRsp);
+  void   *pRsp = rpcMallocCont(contLen);
+  if (pRsp == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto RETRIEVE_FUNC_OVER;
+  }
+
+  tSerializeSRetrieveFuncRsp(pRsp, contLen, &retrieveRsp);
+
+  pReq->pCont = pRsp;
+  pReq->contLen = contLen;
 
   code = 0;
 
-FUNC_RETRIEVE_OVER:
-  if (code != 0) rpcFreeCont(pRetrieveRsp);
+RETRIEVE_FUNC_OVER:
+  taosArrayDestroy(retrieveReq.pFuncNames);
+  taosArrayDestroy(retrieveRsp.pFuncInfos);
 
   return code;
 }

source/dnode/mnode/impl/src/mndMnode.c

@@ -15,9 +15,11 @@
 
 #define _DEFAULT_SOURCE
 #include "mndMnode.h"
+#include "mndAuth.h"
 #include "mndDnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
+#include "mndUser.h"
 
 #define TSDB_MNODE_VER_NUMBER 1
 #define TSDB_MNODE_RESERVE_SIZE 64
@@ -380,39 +382,56 @@ CREATE_MNODE_OVER:
 
 static int32_t mndProcessCreateMnodeReq(SMnodeMsg *pReq) {
   SMnode          *pMnode = pReq->pMnode;
-  SMCreateMnodeReq *pCreate = pReq->rpcMsg.pCont;
+  int32_t          code = -1;
+  SMnodeObj       *pObj = NULL;
+  SDnodeObj       *pDnode = NULL;
+  SUserObj        *pUser = NULL;
+  SMCreateMnodeReq createReq = {0};
 
-  pCreate->dnodeId = htonl(pCreate->dnodeId);
+  if (tDeserializeSMCreateDropMnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto CREATE_MNODE_OVER;
+  }
 
-  mDebug("mnode:%d, start to create", pCreate->dnodeId);
+  mDebug("mnode:%d, start to create", createReq.dnodeId);
 
-  SMnodeObj *pObj = mndAcquireMnode(pMnode, pCreate->dnodeId);
+  pObj = mndAcquireMnode(pMnode, createReq.dnodeId);
   if (pObj != NULL) {
-    mndReleaseMnode(pMnode, pObj);
-    mError("mnode:%d, mnode already exist", pObj->id);
     terrno = TSDB_CODE_MND_MNODE_ALREADY_EXIST;
-    return -1;
+    goto CREATE_MNODE_OVER;
   } else if (terrno != TSDB_CODE_MND_MNODE_NOT_EXIST) {
-    mError("qnode:%d, failed to create mnode since %s", pCreate->dnodeId, terrstr());
-    return -1;
+    goto CREATE_MNODE_OVER;
   }
 
-  SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId);
+  pDnode = mndAcquireDnode(pMnode, createReq.dnodeId);
   if (pDnode == NULL) {
-    mError("mnode:%d, dnode not exist", pCreate->dnodeId);
     terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-    return -1;
+    goto CREATE_MNODE_OVER;
   }
 
-  int32_t code = mndCreateMnode(pMnode, pReq, pDnode, pCreate);
-  mndReleaseDnode(pMnode, pDnode);
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto CREATE_MNODE_OVER;
+  }
 
-  if (code != 0) {
-    mError("mnode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
-    return -1;
+  if (mndCheckNodeAuth(pUser)) {
+    goto CREATE_MNODE_OVER;
+  }
+
+  code = mndCreateMnode(pMnode, pReq, pDnode, &createReq);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+CREATE_MNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("mnode:%d, failed to create since %s", createReq.dnodeId, terrstr());
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  mndReleaseMnode(pMnode, pObj);
+  mndReleaseDnode(pMnode, pDnode);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndSetDropMnodeRedoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) {
@@ -535,31 +554,50 @@ DROP_MNODE_OVER:
 
 static int32_t mndProcessDropMnodeReq(SMnodeMsg *pReq) {
   SMnode        *pMnode = pReq->pMnode;
-  SMDropMnodeReq *pDrop = pReq->rpcMsg.pCont;
-  pDrop->dnodeId = htonl(pDrop->dnodeId);
+  int32_t        code = -1;
+  SUserObj      *pUser = NULL;
+  SMnodeObj     *pObj = NULL;
+  SMDropMnodeReq dropReq = {0};
+
+  if (tDeserializeSMCreateDropMnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto DROP_MNODE_OVER;
+  }
 
-  mDebug("mnode:%d, start to drop", pDrop->dnodeId);
+  mDebug("mnode:%d, start to drop", dropReq.dnodeId);
 
-  if (pDrop->dnodeId <= 0) {
+  if (dropReq.dnodeId <= 0) {
     terrno = TSDB_CODE_SDB_APP_ERROR;
-    mError("mnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_MNODE_OVER;
   }
 
-  SMnodeObj *pObj = mndAcquireMnode(pMnode, pDrop->dnodeId);
+  pObj = mndAcquireMnode(pMnode, dropReq.dnodeId);
   if (pObj == NULL) {
-    mError("mnode:%d, not exist", pDrop->dnodeId);
-    return -1;
+    goto DROP_MNODE_OVER;
   }
 
-  int32_t code = mndDropMnode(pMnode, pReq, pObj);
-  if (code != 0) {
-    mError("mnode:%d, failed to drop since %s", pMnode->dnodeId, terrstr());
-    return -1;
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto DROP_MNODE_OVER;
   }
 
-  sdbRelease(pMnode->pSdb, pObj);
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  if (mndCheckNodeAuth(pUser)) {
+    goto DROP_MNODE_OVER;
+  }
+
+  code = mndDropMnode(pMnode, pReq, pObj);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+DROP_MNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("mnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr());
+  }
+
+  mndReleaseMnode(pMnode, pObj);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndProcessCreateMnodeRsp(SMnodeMsg *pRsp) {

source/dnode/mnode/impl/src/mndQnode.c

@@ -293,7 +293,7 @@ static int32_t mndProcessCreateQnodeReq(SMnodeMsg *pReq) {
     goto CREATE_QNODE_OVER;
   }
 
-  if (mndCheckDropNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto CREATE_QNODE_OVER;
   }
 
@@ -303,7 +303,6 @@ static int32_t mndProcessCreateQnodeReq(SMnodeMsg *pReq) {
 CREATE_QNODE_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("qnode:%d, failed to create since %s", createReq.dnodeId, terrstr());
-    return -1;
   }
 
   mndReleaseQnode(pMnode, pObj);
@@ -401,7 +400,7 @@ static int32_t mndProcessDropQnodeReq(SMnodeMsg *pReq) {
     goto DROP_QNODE_OVER;
   }
 
-  if (mndCheckCreateNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto DROP_QNODE_OVER;
   }
 
@@ -411,7 +410,6 @@ static int32_t mndProcessDropQnodeReq(SMnodeMsg *pReq) {
 DROP_QNODE_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("qnode:%d, failed to drop since %s", pMnode->dnodeId, terrstr());
-    return -1;
   }
 
   mndReleaseQnode(pMnode, pObj);

source/dnode/mnode/impl/src/mndSnode.c

@@ -294,7 +294,7 @@ static int32_t mndProcessCreateSnodeReq(SMnodeMsg *pReq) {
     goto CREATE_SNODE_OVER;
   }
 
-  if (mndCheckDropNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto CREATE_SNODE_OVER;
   }
 
@@ -403,7 +403,7 @@ static int32_t mndProcessDropSnodeReq(SMnodeMsg *pReq) {
     goto DROP_SNODE_OVER;
   }
 
-  if (mndCheckCreateNodeAuth(pUser)) {
+  if (mndCheckNodeAuth(pUser)) {
     goto DROP_SNODE_OVER;
   }
 
@@ -413,7 +413,6 @@ static int32_t mndProcessDropSnodeReq(SMnodeMsg *pReq) {
 DROP_SNODE_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("snode:%d, failed to drop since %s", pMnode->dnodeId, terrstr());
-    return -1;
   }
 
   mndReleaseSnode(pMnode, pObj);

source/dnode/mnode/impl/test/dnode/dnode.cpp

@@ -75,11 +75,14 @@ TEST_F(MndTestDnode, 01_ShowDnode) {
 }
 
 TEST_F(MndTestDnode, 02_ConfigDnode) {
-  int32_t contLen = sizeof(SMCfgDnodeReq);
+  SMCfgDnodeReq cfgReq = {0};
+  cfgReq.dnodeId = 1;
+  strcpy(cfgReq.config, "ddebugflag");
+  strcpy(cfgReq.value, "131");
 
-  SMCfgDnodeReq* pReq = (SMCfgDnodeReq*)rpcMallocCont(contLen);
-  pReq->dnodeId = htonl(1);
-  strcpy(pReq->config, "ddebugflag 131");
+  int32_t contLen = tSerializeSMCfgDnodeReq(NULL, 0, &cfgReq);
+  void*   pReq = rpcMallocCont(contLen);
+  tSerializeSMCfgDnodeReq(pReq, contLen, &cfgReq);
 
   SRpcMsg* pRsp = test.SendReq(TDMT_MND_CONFIG_DNODE, pReq, contLen);
   ASSERT_NE(pRsp, nullptr);

source/dnode/mnode/impl/test/mnode/mnode.cpp

@@ -60,10 +60,12 @@ TEST_F(MndTestMnode, 01_ShowDnode) {
 
 TEST_F(MndTestMnode, 02_Create_Mnode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateMnodeReq);
+    SMCreateMnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -73,10 +75,12 @@ TEST_F(MndTestMnode, 02_Create_Mnode_Invalid_Id) {
 
 TEST_F(MndTestMnode, 03_Create_Mnode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateMnodeReq);
+    SMCreateMnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -107,10 +111,12 @@ TEST_F(MndTestMnode, 04_Create_Mnode) {
 
   {
     // create mnode
-    int32_t contLen = sizeof(SMCreateMnodeReq);
+    SMCreateMnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -134,10 +140,12 @@ TEST_F(MndTestMnode, 04_Create_Mnode) {
 
   {
     // drop mnode
-    int32_t contLen = sizeof(SMDropMnodeReq);
+    SMDropMnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropMnodeReq* pReq = (SMDropMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -156,10 +164,12 @@ TEST_F(MndTestMnode, 04_Create_Mnode) {
 
   {
     // drop mnode
-    int32_t contLen = sizeof(SMDropMnodeReq);
+    SMDropMnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropMnodeReq* pReq = (SMDropMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -170,10 +180,12 @@ TEST_F(MndTestMnode, 04_Create_Mnode) {
 TEST_F(MndTestMnode, 03_Create_Mnode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMCreateMnodeReq);
+    SMCreateMnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
@@ -183,10 +195,12 @@ TEST_F(MndTestMnode, 03_Create_Mnode_Rollback) {
 
   {
     // continue send message, mnode is creating
-    int32_t contLen = sizeof(SMCreateMnodeReq);
+    SMCreateMnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -195,10 +209,12 @@ TEST_F(MndTestMnode, 03_Create_Mnode_Rollback) {
 
   {
     // continue send message, mnode is creating
-    int32_t contLen = sizeof(SMDropMnodeReq);
+    SMDropMnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropMnodeReq* pReq = (SMDropMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -214,10 +230,12 @@ TEST_F(MndTestMnode, 03_Create_Mnode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateMnodeReq);
+      SMCreateMnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);
@@ -232,10 +250,12 @@ TEST_F(MndTestMnode, 03_Create_Mnode_Rollback) {
 TEST_F(MndTestMnode, 04_Drop_Mnode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMDropMnodeReq);
+    SMDropMnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropMnodeReq* pReq = (SMDropMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &dropReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_MNODE, pReq, contLen);
@@ -245,10 +265,12 @@ TEST_F(MndTestMnode, 04_Drop_Mnode_Rollback) {
 
   {
     // continue send message, mnode is dropping
-    int32_t contLen = sizeof(SMCreateMnodeReq);
+    SMCreateMnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -257,10 +279,12 @@ TEST_F(MndTestMnode, 04_Drop_Mnode_Rollback) {
 
   {
     // continue send message, mnode is dropping
-    int32_t contLen = sizeof(SMDropMnodeReq);
+    SMDropMnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropMnodeReq* pReq = (SMDropMnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropMnodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_MNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -276,10 +300,12 @@ TEST_F(MndTestMnode, 04_Drop_Mnode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateMnodeReq);
+      SMCreateMnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateMnodeReq* pReq = (SMCreateMnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropMnodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_MNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);