xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #27639 from taosdata/enh/TD-31803-3 

enh: improve error handle in message encode and decode
This commit is contained in:
Hongze Cheng 2024-09-03 16:30:56 +08:00 committed by GitHub
parent 01c801cbd3 4de971c19b
commit 0104ddf02d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 309 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

552
source/common/src/tmsg.c
View File

@ -1662,185 +1662,179 @@ _exit:
int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) { int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
// status // status
if (tEncodeI64(&encoder, pRsp->dnodeVer) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->dnodeVer));
// dnode cfg // dnode cfg
if (tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId));
if (tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId));
// dnode eps // dnode eps
int32_t dlen = (int32_t)taosArrayGetSize(pRsp->pDnodeEps); int32_t dlen = (int32_t)taosArrayGetSize(pRsp->pDnodeEps);
if (tEncodeI32(&encoder, dlen) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, dlen));
for (int32_t i = 0; i < dlen; ++i) { for (int32_t i = 0; i < dlen; ++i) {
SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i); SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i);
if (tEncodeI32(&encoder, pDnodeEp->id) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pDnodeEp->id));
if (tEncodeI8(&encoder, pDnodeEp->isMnode) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pDnodeEp->isMnode));
if (tEncodeCStr(&encoder, pDnodeEp->ep.fqdn) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pDnodeEp->ep.fqdn));
if (tEncodeU16(&encoder, pDnodeEp->ep.port) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU16(&encoder, pDnodeEp->ep.port));
} }
if (tEncodeI32(&encoder, pRsp->statusSeq) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->statusSeq));
if (tEncodeI64(&encoder, pRsp->ipWhiteVer) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ipWhiteVer));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) { int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
// status // status
if (tDecodeI64(&decoder, &pRsp->dnodeVer) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->dnodeVer));
// cluster cfg // cluster cfg
if (tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId));
if (tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId));
// dnode eps // dnode eps
int32_t dlen = 0; int32_t dlen = 0;
if (tDecodeI32(&decoder, &dlen) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &dlen));
pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp)); pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp));
if (pRsp->pDnodeEps == NULL) { if (pRsp->pDnodeEps == NULL) {
return -1; TAOS_CHECK_EXIT(terrno);
} }
for (int32_t i = 0; i < dlen; ++i) { for (int32_t i = 0; i < dlen; ++i) {
SDnodeEp dnodeEp = {0}; SDnodeEp dnodeEp = {0};
if (tDecodeI32(&decoder, &dnodeEp.id) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &dnodeEp.id));
if (tDecodeI8(&decoder, &dnodeEp.isMnode) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &dnodeEp.isMnode));
if (tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn));
if (tDecodeU16(&decoder, &dnodeEp.ep.port) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU16(&decoder, &dnodeEp.ep.port));
if (taosArrayPush(pRsp->pDnodeEps, &dnodeEp) == NULL) { if (taosArrayPush(pRsp->pDnodeEps, &dnodeEp) == NULL) {
return -1; TAOS_CHECK_EXIT(terrno);
} }
} }
if (tDecodeI32(&decoder, &pRsp->statusSeq) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->statusSeq));
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI64(&decoder, &pRsp->ipWhiteVer) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ipWhiteVer));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSStatusRsp(SStatusRsp *pRsp) { taosArrayDestroy(pRsp->pDnodeEps); } void tFreeSStatusRsp(SStatusRsp *pRsp) { taosArrayDestroy(pRsp->pDnodeEps); }
int32_t tSerializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) { int32_t tSerializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->contLen));
if (tEncodeI32(&encoder, pReq->contLen) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pCont));
if (tEncodeCStr(&encoder, pReq->pCont) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->type));
if (tEncodeI8(&encoder, pReq->type) < 0) return -1;
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) { int32_t tDeserializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->contLen));
if (tDecodeI32(&decoder, &pReq->contLen) < 0) return -1;
if (pReq->contLen > 0) { if (pReq->contLen > 0) {
pReq->pCont = taosMemoryMalloc(pReq->contLen + 1); pReq->pCont = taosMemoryMalloc(pReq->contLen + 1);
if (pReq->pCont == NULL) return -1; if (pReq->pCont == NULL) {
if (tDecodeCStrTo(&decoder, pReq->pCont) < 0) return -1; TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pCont));
} }
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI8(&decoder, (int8_t *)&pReq->type) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, (int8_t *)&pReq->type));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSStatisReq(SStatisReq *pReq) { taosMemoryFreeClear(pReq->pCont); } void tFreeSStatisReq(SStatisReq *pReq) { taosMemoryFreeClear(pReq->pCont); }
// int32_t tSerializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) {
// SEncoder encoder = {0};
// tEncoderInit(&encoder, buf, bufLen);
// if (tStartEncode(&encoder) < 0) return -1;
// if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
// if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1;
// if (tEncodeI32(&encoder, pReq->maxUsers) < 0) return -1;
// if (tEncodeI32(&encoder, pReq->maxDbs) < 0) return -1;
// if (tEncodeI32(&encoder, pReq->maxTimeSeries) < 0) return -1;
// if (tEncodeI32(&encoder, pReq->maxStreams) < 0) return -1;
// if (tEncodeI32(&encoder, pReq->accessState) < 0) return -1;
// if (tEncodeI64(&encoder, pReq->maxStorage) < 0) return -1;
// tEndEncode(&encoder);
// int32_t tlen = encoder.pos;
// tEncoderClear(&encoder);
// return tlen;
// }
// int32_t tDeserializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) {
// SDecoder decoder = {0};
// tDecoderInit(&decoder, buf, bufLen);
// if (tStartDecode(&decoder) < 0) return -1;
// if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
// if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->maxUsers) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->maxDbs) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->maxTimeSeries) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->maxStreams) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->accessState) < 0) return -1;
// if (tDecodeI64(&decoder, &pReq->maxStorage) < 0) return -1;
// tEndDecode(&decoder);
// tDecoderClear(&decoder);
// return 0;
// }
int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
ENCODESQL(); ENCODESQL();
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
DECODESQL(); DECODESQL();
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSDropUserReq(SDropUserReq *pReq) { FREESQL(); } void tFreeSDropUserReq(SDropUserReq *pReq) { FREESQL(); }
@ -1858,113 +1852,143 @@ SIpWhiteList *cloneIpWhiteList(SIpWhiteList *pIpWhiteList) {
int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeI8(&encoder, pReq->createType) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createType));
if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->superUser));
if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->sysInfo));
if (tEncodeI8(&encoder, pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->enable));
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pass));
if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numIpRanges));
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].ip));
if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].mask));
} }
ENCODESQL(); ENCODESQL();
if (tEncodeI8(&encoder, pReq->isImport) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isImport));
if (tEncodeI8(&encoder, pReq->createDb) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createDb));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeI8(&decoder, &pReq->createType) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createType));
if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->superUser));
if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->sysInfo));
if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->enable));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pass));
if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numIpRanges));
pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range)); pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range));
if (pReq->pIpRanges == NULL) return -1; if (pReq->pIpRanges == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)));
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)));
} }
DECODESQL(); DECODESQL();
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI8(&decoder, &pReq->createDb) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createDb));
if (tDecodeI8(&decoder, &pReq->isImport) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isImport));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
int32_t tSerializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) { int32_t tSerializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) {
// impl later
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeI64(&encoder, pReq->ver) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->ver));
if (tEncodeI32(&encoder, pReq->numOfUser) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfUser));
for (int i = 0; i < pReq->numOfUser; i++) { for (int i = 0; i < pReq->numOfUser; i++) {
SUpdateUserIpWhite *pUser = &(pReq->pUserIpWhite[i]); SUpdateUserIpWhite *pUser = &(pReq->pUserIpWhite[i]);
if (tEncodeI64(&encoder, pUser->ver) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pUser->ver));
if (tEncodeCStr(&encoder, pUser->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pUser->user));
if (tEncodeI32(&encoder, pUser->numOfRange) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pUser->numOfRange));
for (int j = 0; j < pUser->numOfRange; j++) { for (int j = 0; j < pUser->numOfRange; j++) {
SIpV4Range *pRange = &pUser->pIpRanges[j]; SIpV4Range *pRange = &pUser->pIpRanges[j];
if (tEncodeU32(&encoder, pRange->ip) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRange->ip));
if (tEncodeU32(&encoder, pRange->mask) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRange->mask));
} }
} }
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) { int32_t tDeserializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
// impl later // impl later
if (tDecodeI64(&decoder, &pReq->ver) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->ver));
if (tDecodeI32(&decoder, &pReq->numOfUser) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfUser));
if ((pReq->pUserIpWhite = taosMemoryCalloc(1, sizeof(SUpdateUserIpWhite) * pReq->numOfUser)) == NULL) return -1; if ((pReq->pUserIpWhite = taosMemoryCalloc(1, sizeof(SUpdateUserIpWhite) * pReq->numOfUser)) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int i = 0; i < pReq->numOfUser; i++) { for (int i = 0; i < pReq->numOfUser; i++) {
SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i]; SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i];
if (tDecodeI64(&decoder, &pUserWhite->ver) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pUserWhite->ver));
if (tDecodeCStrTo(&decoder, pUserWhite->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pUserWhite->user));
if (tDecodeI32(&decoder, &pUserWhite->numOfRange) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pUserWhite->numOfRange));
if ((pUserWhite->pIpRanges = taosMemoryCalloc(1, pUserWhite->numOfRange * sizeof(SIpV4Range))) == NULL) return -1; if ((pUserWhite->pIpRanges = taosMemoryCalloc(1, pUserWhite->numOfRange * sizeof(SIpV4Range))) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int j = 0; j < pUserWhite->numOfRange; j++) { for (int j = 0; j < pUserWhite->numOfRange; j++) {
SIpV4Range *pRange = &pUserWhite->pIpRanges[j]; SIpV4Range *pRange = &pUserWhite->pIpRanges[j];
if (tDecodeU32(&decoder, &pRange->ip) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pRange->ip));
if (tDecodeU32(&decoder, &pRange->mask) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pRange->mask));
} }
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSUpdateIpWhiteReq(SUpdateIpWhite *pReq) { void tFreeSUpdateIpWhiteReq(SUpdateIpWhite *pReq) {
if (pReq == NULL) return; if (pReq == NULL) return;
@ -2023,29 +2047,39 @@ _return:
} }
int32_t tSerializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) { int32_t tSerializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeI64(&encoder, pReq->ipWhiteVer) < 0) { TAOS_CHECK_EXIT(tStartEncode(&encoder));
return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->ipWhiteVer));
}
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) { int32_t tDeserializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
// impl later TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->ipWhiteVer));
if (tDecodeI64(&decoder, &pReq->ipWhiteVer) < 0) return -1;
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSCreateUserReq(SCreateUserReq *pReq) { void tFreeSCreateUserReq(SCreateUserReq *pReq) {
@ -2055,77 +2089,90 @@ void tFreeSCreateUserReq(SCreateUserReq *pReq) {
int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->alterType));
if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->superUser));
if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->sysInfo));
if (tEncodeI8(&encoder, pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->enable));
if (tEncodeI8(&encoder, pReq->isView) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isView));
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pass));
if (tEncodeCStr(&encoder, pReq->objname) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->objname));
int32_t len = strlen(pReq->tabName); int32_t len = strlen(pReq->tabName);
if (tEncodeI32(&encoder, len) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, len));
if (len > 0) { if (len > 0) {
if (tEncodeCStr(&encoder, pReq->tabName) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->tabName));
} }
if (tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen) < 0) return -1; TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen));
if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numIpRanges));
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].ip));
if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].mask));
} }
if (tEncodeI64(&encoder, pReq->privileges) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->privileges));
ENCODESQL(); ENCODESQL();
if (tEncodeU8(&encoder, pReq->flag) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU8(&encoder, pReq->flag));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->alterType));
if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->superUser));
if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->sysInfo));
if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->enable));
if (tDecodeI8(&decoder, &pReq->isView) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isView));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pass));
if (tDecodeCStrTo(&decoder, pReq->objname) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->objname));
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
int32_t len = 0; int32_t len = 0;
if (tDecodeI32(&decoder, &len) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &len));
if (len > 0) { if (len > 0) {
if (tDecodeCStrTo(&decoder, pReq->tabName) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->tabName));
} }
uint64_t tagCondLen = 0; uint64_t tagCondLen = 0;
if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->tagCond, &tagCondLen) < 0) return -1; TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->tagCond, &tagCondLen));
pReq->tagCondLen = tagCondLen; pReq->tagCondLen = tagCondLen;
} }
if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numIpRanges));
pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range)); pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range));
if (pReq->pIpRanges == NULL) return -1; if (pReq->pIpRanges == NULL) {
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { TAOS_CHECK_EXIT(terrno);
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1;
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1;
} }
if (tDecodeI64(&decoder, &pReq->privileges) < 0) return -1; for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)));
TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)));
}
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->privileges));
DECODESQL(); DECODESQL();
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeU8(&decoder, &pReq->flag) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU8(&decoder, &pReq->flag));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSAlterUserReq(SAlterUserReq *pReq) { void tFreeSAlterUserReq(SAlterUserReq *pReq) {
@ -2136,60 +2183,71 @@ void tFreeSAlterUserReq(SAlterUserReq *pReq) {
int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen); int32_t code = 0;
int32_t lino;
int32_t tlen;
if (tStartEncode(&encoder) < 0) return -1; tEncoderInit(&encoder, buf, bufLen);
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) { int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) {
if (tEncodeCStr(pEncoder, pRsp->user) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->user));
if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->superAuth));
if (tEncodeI8(pEncoder, pRsp->sysInfo) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->sysInfo));
if (tEncodeI8(pEncoder, pRsp->enable) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->enable));
if (tEncodeI8(pEncoder, pRsp->dropped) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->dropped));
if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->version));
int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs); int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs);
int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs); int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs);
int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs); int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs);
if (tEncodeI32(pEncoder, numOfCreatedDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfCreatedDbs));
if (tEncodeI32(pEncoder, numOfReadDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadDbs));
if (tEncodeI32(pEncoder, numOfWriteDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteDbs));
char *db = taosHashIterate(pRsp->createdDbs, NULL); char *db = taosHashIterate(pRsp->createdDbs, NULL);
while (db != NULL) { while (db != NULL) {
if (tEncodeCStr(pEncoder, db) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db));
db = taosHashIterate(pRsp->createdDbs, db); db = taosHashIterate(pRsp->createdDbs, db);
} }
db = taosHashIterate(pRsp->readDbs, NULL); db = taosHashIterate(pRsp->readDbs, NULL);
while (db != NULL) { while (db != NULL) {
if (tEncodeCStr(pEncoder, db) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db));
db = taosHashIterate(pRsp->readDbs, db); db = taosHashIterate(pRsp->readDbs, db);
} }
db = taosHashIterate(pRsp->writeDbs, NULL); db = taosHashIterate(pRsp->writeDbs, NULL);
while (db != NULL) { while (db != NULL) {
if (tEncodeCStr(pEncoder, db) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db));
db = taosHashIterate(pRsp->writeDbs, db); db = taosHashIterate(pRsp->writeDbs, db);
} }
@ -2200,25 +2258,25 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
int32_t numOfWriteViews = taosHashGetSize(pRsp->writeViews); int32_t numOfWriteViews = taosHashGetSize(pRsp->writeViews);
int32_t numOfAlterViews = taosHashGetSize(pRsp->alterViews); int32_t numOfAlterViews = taosHashGetSize(pRsp->alterViews);
int32_t numOfUseDbs = taosHashGetSize(pRsp->useDbs); int32_t numOfUseDbs = taosHashGetSize(pRsp->useDbs);
if (tEncodeI32(pEncoder, numOfReadTbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadTbs));
if (tEncodeI32(pEncoder, numOfWriteTbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteTbs));
if (tEncodeI32(pEncoder, numOfAlterTbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfAlterTbs));
if (tEncodeI32(pEncoder, numOfReadViews) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadViews));
if (tEncodeI32(pEncoder, numOfWriteViews) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteViews));
if (tEncodeI32(pEncoder, numOfAlterViews) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfAlterViews));
if (tEncodeI32(pEncoder, numOfUseDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfUseDbs));
char *tb = taosHashIterate(pRsp->readTbs, NULL); char *tb = taosHashIterate(pRsp->readTbs, NULL);
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->readTbs, tb); tb = taosHashIterate(pRsp->readTbs, tb);
} }
@ -2227,13 +2285,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->writeTbs, tb); tb = taosHashIterate(pRsp->writeTbs, tb);
} }
@ -2242,13 +2300,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->alterTbs, tb); tb = taosHashIterate(pRsp->alterTbs, tb);
} }
@ -2257,13 +2315,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->readViews, tb); tb = taosHashIterate(pRsp->readViews, tb);
} }
@ -2272,13 +2330,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->writeViews, tb); tb = taosHashIterate(pRsp->writeViews, tb);
} }
@ -2287,13 +2345,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->alterViews, tb); tb = taosHashIterate(pRsp->alterViews, tb);
} }
@ -2302,30 +2360,36 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (useDb != NULL) { while (useDb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(useDb, &keyLen); void *key = taosHashGetKey(useDb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, *useDb));
if (tEncodeI32(pEncoder, *useDb) < 0) return -1;
useDb = taosHashIterate(pRsp->useDbs, useDb); useDb = taosHashIterate(pRsp->useDbs, useDb);
} }
// since 3.0.7.0 // since 3.0.7.0
if (tEncodeI32(pEncoder, pRsp->passVer) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->passVer));
if (tEncodeI64(pEncoder, pRsp->whiteListVer) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->whiteListVer));
return 0; return 0;
} }
int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) { int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tSerializeSGetUserAuthRspImpl(&encoder, pRsp));
if (tSerializeSGetUserAuthRspImpl(&encoder, pRsp) < 0) return -1;
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
@ -2558,16 +2622,18 @@ _err:
int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) { int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDeserializeSGetUserAuthRspImpl(&decoder, pRsp));
if (tDeserializeSGetUserAuthRspImpl(&decoder, pRsp) < 0) return -1;
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) { void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) {