From b337fa628b58cd7d4ec6602c957b64071b163ca7 Mon Sep 17 00:00:00 2001 From: kailixu Date: Mon, 22 Jul 2024 15:29:37 +0800 Subject: [PATCH] enh: return error code --- include/util/tbase58.h | 4 +- include/util/tbase64.h | 4 +- source/dnode/mgmt/node_util/src/dmFile.c | 5 +- source/dnode/mnode/impl/inc/mndDnode.h | 2 +- source/dnode/mnode/impl/inc/mndUser.h | 2 +- source/dnode/mnode/impl/src/mndDnode.c | 18 +- source/dnode/mnode/impl/src/mndUser.c | 404 ++++++++++++++++++----- source/util/src/tbase58.c | 56 ++-- source/util/src/tbase64.c | 30 +- source/util/test/tbaseCodecTest.cpp | 12 +- 10 files changed, 397 insertions(+), 140 deletions(-) diff --git a/include/util/tbase58.h b/include/util/tbase58.h index ab62e1926e..8210cbf4ba 100644 --- a/include/util/tbase58.h +++ b/include/util/tbase58.h @@ -25,8 +25,8 @@ extern "C" { #define TBASE_MAX_ILEN 4096 #define TBASE_MAX_OLEN 5653 -uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen); -char *base58_encode(const uint8_t *value, int32_t vlen); +int32_t base58_decode(const char *value, size_t inlen, int32_t *outlen, uint8_t **result); +int32_t base58_encode(const uint8_t *value, int32_t vlen, char **result); #ifdef __cplusplus } diff --git a/include/util/tbase64.h b/include/util/tbase64.h index 22b8f95c5a..e342e6a0fa 100644 --- a/include/util/tbase64.h +++ b/include/util/tbase64.h @@ -22,8 +22,8 @@ extern "C" { #endif -uint8_t *base64_decode(const char *value, int32_t inlen, int32_t *outlen); -char *base64_encode(const uint8_t *value, int32_t vlen); +int32_t base64_decode(const char *value, int32_t inlen, int32_t *outlen, uint8_t **result); +int32_t base64_encode(const uint8_t *value, int32_t vlen, char **result); #ifdef __cplusplus } diff --git a/source/dnode/mgmt/node_util/src/dmFile.c b/source/dnode/mgmt/node_util/src/dmFile.c index 752abb83a2..a062b96a3d 100644 --- a/source/dnode/mgmt/node_util/src/dmFile.c +++ b/source/dnode/mgmt/node_util/src/dmFile.c @@ -308,6 +308,7 @@ _OVER: int32_t dmUpdateEncryptKey(char *key, bool toLogFile) { #ifdef TD_ENTERPRISE int32_t code = -1; + int32_t lino = 0; char *machineId = NULL; char *encryptCode = NULL; @@ -344,9 +345,7 @@ int32_t dmUpdateEncryptKey(char *key, bool toLogFile) { goto _OVER; } - if (generateEncryptCode(key, machineId, &encryptCode) != 0) { - goto _OVER; - } + TAOS_CHECK_GOTO(generateEncryptCode(key, machineId, &encryptCode), &lino, _OVER); if(dmWriteEncryptCodeFile(encryptFile, realEncryptFile, encryptCode, toLogFile) != 0){ goto _OVER; diff --git a/source/dnode/mnode/impl/inc/mndDnode.h b/source/dnode/mnode/impl/inc/mndDnode.h index ab104e316e..7708b954b7 100644 --- a/source/dnode/mnode/impl/inc/mndDnode.h +++ b/source/dnode/mnode/impl/inc/mndDnode.h @@ -30,7 +30,7 @@ SEpSet mndGetDnodeEpset(SDnodeObj *pDnode); SEpSet mndGetDnodeEpsetById(SMnode *pMnode, int32_t dnodeId); int32_t mndGetDnodeSize(SMnode *pMnode); bool mndIsDnodeOnline(SDnodeObj *pDnode, int64_t curMs); -void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo); +int32_t mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo); #ifdef __cplusplus } diff --git a/source/dnode/mnode/impl/inc/mndUser.h b/source/dnode/mnode/impl/inc/mndUser.h index 5043f6da3d..0048a0badd 100644 --- a/source/dnode/mnode/impl/inc/mndUser.h +++ b/source/dnode/mnode/impl/inc/mndUser.h @@ -49,7 +49,7 @@ void mndUserFreeObj(SUserObj *pUser); int64_t mndGetIpWhiteVer(SMnode *pMnode); -void mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock); +int32_t mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock); int32_t mndRefreshUserIpWhiteList(SMnode *pMnode); diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index 73addea6fe..879f533635 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -175,7 +175,7 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) { if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; - mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); + mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value _OVER: mndTransDrop(pTrans); @@ -417,8 +417,9 @@ static void mndGetDnodeEps(SMnode *pMnode, SArray *pDnodeEps) { } } -void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) { - SSdb *pSdb = pMnode->pSdb; +int32_t mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) { + SSdb *pSdb = pMnode->pSdb; + int32_t code = 0; int32_t numOfEps = 0; void *pIter = NULL; @@ -440,8 +441,13 @@ void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) { dInfo.isMnode = 0; } - taosArrayPush(pDnodeInfo, &dInfo); + if(taosArrayPush(pDnodeInfo, &dInfo) == NULL){ + code = TSDB_CODE_OUT_OF_MEMORY; + sdbCancelFetch(pSdb, pIter); + break; + } } + TAOS_RETURN(code); } #define CHECK_MONITOR_PARA(para,err) \ @@ -883,7 +889,7 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; - mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); + mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value _OVER: mndTransDrop(pTrans); sdbFreeRaw(pRaw); @@ -1165,7 +1171,7 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; - mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1); + mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1); // TODO: check the return value code = 0; _OVER: diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c index 2335bf7bf8..bae617013c 100644 --- a/source/dnode/mnode/impl/src/mndUser.c +++ b/source/dnode/mnode/impl/src/mndUser.c @@ -96,7 +96,7 @@ (ALTER_USER_DEL_PRIVS(_type) && ALTER_USER_SUBSCRIBE_PRIV(_priv)) static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList); -SIpWhiteList *createIpWhiteList(void *buf, int32_t len); +static int32_t createIpWhiteList(void *buf, int32_t len, SIpWhiteList **ppWhiteList); static bool updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew); static bool isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b); static bool isIpRangeEqual(SIpV4Range *a, SIpV4Range *b); @@ -121,11 +121,11 @@ static int32_t mndRetrieveUsersFull(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock static void mndCancelGetNextUser(SMnode *pMnode, void *pIter); static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextPrivileges(SMnode *pMnode, void *pIter); -SHashObj *mndFetchAllIpWhite(SMnode *pMnode); +static int32_t mndFetchAllIpWhite(SMnode *pMnode, SHashObj **ppIpWhiteTab); static int32_t mndProcesSRetrieveIpWhiteReq(SRpcMsg *pReq); -static int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8_t type, int8_t *pUpdate); +static int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8_t type, bool *pUpdate); -void ipWhiteMgtUpdateAll(SMnode *pMnode); +static int32_t ipWhiteMgtUpdateAll(SMnode *pMnode); typedef struct { SHashObj *pIpWhiteTab; int64_t ver; @@ -159,9 +159,11 @@ int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) { if (ppList == NULL || *ppList == NULL) { SIpWhiteList *p = cloneIpWhiteList(pNew); if (p == NULL) { + update = false; TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); } if ((code = taosHashPut(ipWhiteMgt.pIpWhiteTab, user, strlen(user), &p, sizeof(void *))) != 0) { + update = false; taosMemoryFree(p); TAOS_CHECK_GOTO(code, &lino, _OVER); } @@ -173,20 +175,26 @@ int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) { taosMemoryFree(pOld); SIpWhiteList *p = cloneIpWhiteList(pNew); if (p == NULL) { + update = false; TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); } if ((code = taosHashPut(ipWhiteMgt.pIpWhiteTab, user, strlen(user), &p, sizeof(void *))) != 0) { + update = false; taosMemoryFree(p); TAOS_CHECK_GOTO(code, &lino, _OVER); } } } - SArray *fqdns = mndGetAllDnodeFqdns(pMnode); + SArray *fqdns = mndGetAllDnodeFqdns(pMnode); // TODO: update this line after refactor api for (int i = 0; i < taosArrayGetSize(fqdns); i++) { char *fqdn = taosArrayGetP(fqdns, i); - update |= mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, TSDB_DEFAULT_USER, fqdn, IP_WHITE_ADD); - update |= mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, user, fqdn, IP_WHITE_ADD); + bool upd = false; + TAOS_CHECK_GOTO(mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, TSDB_DEFAULT_USER, fqdn, IP_WHITE_ADD, &upd), &lino, + _OVER); + update |= upd; + TAOS_CHECK_GOTO(mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, user, fqdn, IP_WHITE_ADD, &upd), &lino, _OVER); + update |= upd; } for (int i = 0; i < taosArrayGetSize(fqdns); i++) { @@ -204,7 +212,10 @@ int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) { _OVER: taosThreadRwlockUnlock(&ipWhiteMgt.rw); - return 0; + if (code != 0) { + mError("failed to update ip white list for user: %s at line %d since %s", user, lino, tstrerror(code)); + } + TAOS_RETURN(code); } int32_t ipWhiteMgtRemove(char *user) { bool update = true; @@ -277,14 +288,17 @@ int32_t ipWhiteUpdateForAllUser(SIpWhiteList *pList) { } #endif -void ipWhiteMgtUpdateAll(SMnode *pMnode) { - ipWhiteMgt.ver++; - SHashObj *pNew = mndFetchAllIpWhite(pMnode); +static int32_t ipWhiteMgtUpdateAll(SMnode *pMnode) { + SHashObj *pNew = NULL; + TAOS_CHECK_RETURN(mndFetchAllIpWhite(pMnode, &pNew)); + SHashObj *pOld = ipWhiteMgt.pIpWhiteTab; ipWhiteMgt.pIpWhiteTab = pNew; + ipWhiteMgt.ver++; destroyIpWhiteTab(pOld); + TAOS_RETURN(0); } void ipWhiteMgtUpdate2(SMnode *pMnode) { taosThreadRwlockWrlock(&ipWhiteMgt.rw); @@ -313,6 +327,8 @@ int64_t mndGetIpWhiteVer(SMnode *pMnode) { } int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8_t type, bool *pUpdate) { + int32_t code = 0; + int32_t lino = 0; bool update = false; SIpV4Range range = {.ip = taosGetIpv4FromFqdn(fqdn), .mask = 32}; mDebug("ip-white-list may update for user: %s, fqdn: %s", user, fqdn); @@ -325,22 +341,34 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8 if (type == IP_WHITE_ADD) { if (pList == NULL) { SIpWhiteList *pNewList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range)); + if(pNewList == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memcpy(pNewList->pIpRange, &range, sizeof(SIpV4Range)); pNewList->num = 1; - taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *)); + if (taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *)) != 0) { + taosMemoryFree(pNewList); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } update = true; } else { if (!isRangeInWhiteList(pList, &range)) { int32_t sz = sizeof(SIpWhiteList) + sizeof(SIpV4Range) * (pList->num + 1); SIpWhiteList *pNewList = taosMemoryCalloc(1, sz); + if (pNewList == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memcpy(pNewList->pIpRange, pList->pIpRange, sizeof(SIpV4Range) * (pList->num)); pNewList->pIpRange[pList->num].ip = range.ip; pNewList->pIpRange[pList->num].mask = range.mask; pNewList->num = pList->num + 1; - taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *)); + if (taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *)) != 0) { + taosMemoryFree(pNewList); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(pList); update = true; } @@ -355,6 +383,9 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8 int32_t idx = 0; int32_t sz = sizeof(SIpWhiteList) + sizeof(SIpV4Range) * (pList->num - 1); SIpWhiteList *pNewList = taosMemoryCalloc(1, sz); + if(pNewList == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } for (int i = 0; i < pList->num; i++) { SIpV4Range *e = &pList->pIpRange[i]; if (!isIpRangeEqual(e, &range)) { @@ -364,7 +395,10 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8 } } pNewList->num = idx; - taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *)); + if (taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *) != 0)) { + taosMemoryFree(pNewList); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(pList); } update = true; @@ -375,29 +409,44 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8 mDebug("ip-white-list update for user: %s, fqdn: %s", user, fqdn); } - return update; +_OVER: + if (pUpdate) *pUpdate = update; + if (code != 0) { + mError("failed to update ip-white-list for user: %s, fqdn: %s at line %d since %s", user, fqdn, lino, + tstrerror(code)); + } + TAOS_RETURN(code); } int32_t mndRefreshUserIpWhiteList(SMnode *pMnode) { + int32_t code = 0; taosThreadRwlockWrlock(&ipWhiteMgt.rw); - ipWhiteMgtUpdateAll(pMnode); + if ((code = ipWhiteMgtUpdateAll(pMnode)) != 0) { + taosThreadRwlockUnlock(&ipWhiteMgt.rw); + TAOS_RETURN(code); + } ipWhiteMgt.ver = taosGetTimestampMs(); taosThreadRwlockUnlock(&ipWhiteMgt.rw); - return 0; + TAOS_RETURN(code); } -void mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock) { + +int32_t mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock) { + int32_t code = 0; + int32_t lino = 0; + bool update = false; + if (lock) { taosThreadRwlockWrlock(&ipWhiteMgt.rw); if (ipWhiteMgt.ver == 0) { - ipWhiteMgtUpdateAll(pMnode); + TAOS_CHECK_GOTO(ipWhiteMgtUpdateAll(pMnode), &lino, _OVER); ipWhiteMgt.ver = taosGetTimestampMs(); - mInfo("ip-white-list, user: %" PRId64 "", ipWhiteMgt.ver); + mInfo("update ip-white-list, user: %s, ver: %" PRId64, user, ipWhiteMgt.ver); } } - bool update = mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, user, fqdn, type); + TAOS_CHECK_GOTO(mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, user, fqdn, type, &update), &lino, _OVER); void *pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, NULL); while (pIter) { @@ -405,24 +454,43 @@ void mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t t char *key = taosHashGetKey(pIter, &klen); char *keyDup = taosMemoryCalloc(1, klen + 1); + if (keyDup == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memcpy(keyDup, key, klen); - update |= mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, keyDup, fqdn, type); + code = mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, keyDup, fqdn, type, &update); + if (code != 0) { + update = false; + taosMemoryFree(keyDup); + TAOS_CHECK_GOTO(code, &lino, _OVER); + } taosMemoryFree(keyDup); pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, pIter); } +_OVER: if (update) ipWhiteMgt.ver++; - if (lock) taosThreadRwlockUnlock(&ipWhiteMgt.rw); + if (code != 0) { + mError("failed to update ip-white-list for user: %s, fqdn: %s at line %d since %s", user, fqdn, lino, + tstrerror(code)); + } + + TAOS_RETURN(code); } -int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) { + +static int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) { int64_t ver = 0; taosThreadRwlockWrlock(&ipWhiteMgt.rw); ver = ipWhiteMgt.ver; int32_t num = taosHashGetSize(ipWhiteMgt.pIpWhiteTab); pUpdate->pUserIpWhite = taosMemoryCalloc(1, num * sizeof(SUpdateUserIpWhite)); + if (pUpdate->pUserIpWhite == NULL) { + taosThreadRwlockUnlock(&ipWhiteMgt.rw); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } void *pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, NULL); int32_t i = 0; @@ -437,6 +505,11 @@ int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) { memcpy(pUser->user, key, klen); pUser->numOfRange = list->num; pUser->pIpRanges = taosMemoryCalloc(1, list->num * sizeof(SIpV4Range)); + if (pUser->pIpRanges == NULL) { + taosThreadRwlockUnlock(&ipWhiteMgt.rw); + tFreeSUpdateIpWhiteReq(pUpdate); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } memcpy(pUser->pIpRanges, list->pIpRange, list->num * sizeof(SIpV4Range)); i++; } @@ -446,7 +519,7 @@ int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) { pUpdate->ver = ver; taosThreadRwlockUnlock(&ipWhiteMgt.rw); - return 0; + TAOS_RETURN(0); } void destroyIpWhiteTab(SHashObj *pIpWhiteTab) { @@ -461,22 +534,54 @@ void destroyIpWhiteTab(SHashObj *pIpWhiteTab) { taosHashCleanup(pIpWhiteTab); } -SHashObj *mndFetchAllIpWhite(SMnode *pMnode) { +int32_t mndFetchAllIpWhite(SMnode *pMnode, SHashObj **ppIpWhiteTab) { + int32_t code = 0; + int32_t lino = 0; SSdb *pSdb = pMnode->pSdb; void *pIter = NULL; - SHashObj *pIpWhiteTab = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), 1, HASH_ENTRY_LOCK); + SHashObj *pIpWhiteTab = NULL; + SArray *pUserNames = NULL; + SArray *fqdns = NULL; + + pIpWhiteTab = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), 1, HASH_ENTRY_LOCK); + if (pIpWhiteTab == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } + pUserNames = taosArrayInit(8, sizeof(void *)); + if(pUserNames == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } - SArray *pUserNames = taosArrayInit(8, sizeof(void *)); while (1) { SUserObj *pUser = NULL; pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser); if (pIter == NULL) break; SIpWhiteList *pWhiteList = cloneIpWhiteList(pUser->pIpWhiteList); - taosHashPut(pIpWhiteTab, pUser->user, strlen(pUser->user), &pWhiteList, sizeof(void *)); + if (pWhiteList == NULL) { + sdbRelease(pSdb, pUser); + sdbCancelFetch(pSdb, pIter); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } + if(taosHashPut(pIpWhiteTab, pUser->user, strlen(pUser->user), &pWhiteList, sizeof(void *)) != 0) { + taosMemoryFree(pWhiteList); + sdbRelease(pSdb, pUser); + sdbCancelFetch(pSdb, pIter); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } char *name = taosStrdup(pUser->user); - taosArrayPush(pUserNames, &name); + if(name == NULL) { + sdbRelease(pSdb, pUser); + sdbCancelFetch(pSdb, pIter); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } + if(taosArrayPush(pUserNames, &name) == NULL){ + taosMemoryFree(name); + sdbRelease(pSdb, pUser); + sdbCancelFetch(pSdb, pIter); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } sdbRelease(pSdb, pUser); } @@ -491,20 +596,27 @@ SHashObj *mndFetchAllIpWhite(SMnode *pMnode) { } if (found == false) { char *name = taosStrdup(TSDB_DEFAULT_USER); - taosArrayPush(pUserNames, &name); + if (name == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } + if (taosArrayPush(pUserNames, &name) == NULL) { + taosMemoryFree(name); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } } - SArray *fqdns = mndGetAllDnodeFqdns(pMnode); + fqdns = mndGetAllDnodeFqdns(pMnode); // TODO: refactor this line after refactor api for (int i = 0; i < taosArrayGetSize(fqdns); i++) { char *fqdn = taosArrayGetP(fqdns, i); for (int j = 0; j < taosArrayGetSize(pUserNames); j++) { char *name = taosArrayGetP(pUserNames, j); - mndUpdateIpWhiteImpl(pIpWhiteTab, name, fqdn, IP_WHITE_ADD); + TAOS_CHECK_GOTO(mndUpdateIpWhiteImpl(pIpWhiteTab, name, fqdn, IP_WHITE_ADD, NULL), &lino, _OVER); } } +_OVER: for (int i = 0; i < taosArrayGetSize(fqdns); i++) { char *fqdn = taosArrayGetP(fqdns, i); taosMemoryFree(fqdn); @@ -516,11 +628,17 @@ SHashObj *mndFetchAllIpWhite(SMnode *pMnode) { } taosArrayDestroy(pUserNames); - return pIpWhiteTab; + if (code != 0) { + mError("failed to fetch all ip white list at line %d since %s", lino, tstrerror(code)); + destroyIpWhiteTab(pIpWhiteTab); + pIpWhiteTab = NULL; + } + *ppIpWhiteTab = pIpWhiteTab; + TAOS_RETURN(code); } int32_t mndInitUser(SMnode *pMnode) { - TAOS_CHECK_REUTNR(ipWhiteMgtInit()); + TAOS_CHECK_RETURN(ipWhiteMgtInit()); SSdbTable table = { .sdbType = SDB_USER, @@ -634,34 +752,50 @@ int32_t tSerializeIpWhiteList(void *buf, int32_t len, SIpWhiteList *pList) { } int32_t tDerializeIpWhileList(void *buf, int32_t len, SIpWhiteList *pList) { + int32_t code = 0; + int32_t lino = 0; SDecoder decoder = {0}; tDecoderInit(&decoder, buf, len); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pList->num) < 0) return -1; + TAOS_CHECK_GOTO(tStartDecode(&decoder), &lino, _OVER); + TAOS_CHECK_GOTO(tDecodeI32(&decoder, &pList->num), &lino, _OVER); for (int i = 0; i < pList->num; i++) { SIpV4Range *pRange = &(pList->pIpRange[i]); - if (tDecodeU32(&decoder, &pRange->ip) < 0) return -1; - if (tDecodeU32(&decoder, &pRange->mask) < 0) return -1; + TAOS_CHECK_GOTO(tDecodeU32(&decoder, &pRange->ip), &lino, _OVER); + TAOS_CHECK_GOTO(tDecodeU32(&decoder, &pRange->mask), &lino, _OVER); } + +_OVER: tEndDecode(&decoder); tDecoderClear(&decoder); + if(code != 0) { + mError("failed to deserialize ip white list at line %d since %s", lino, tstrerror(code)); + } - return 0; + TAOS_RETURN(code); } -SIpWhiteList *createIpWhiteList(void *buf, int32_t len) { - int32_t num = 0; - SDecoder decoder = {0}; + +static int32_t createIpWhiteList(void *buf, int32_t len, SIpWhiteList **ppList) { + int32_t code = 0; + int32_t lino = 0; + int32_t num = 0; + SIpWhiteList *p = NULL; + SDecoder decoder = {0}; tDecoderInit(&decoder, buf, len); - if (tStartDecode(&decoder) < 0) return NULL; - if (tDecodeI32(&decoder, &num) < 0) return NULL; + TAOS_CHECK_GOTO(tStartDecode(&decoder), &lino, _OVER), &lino, _OVER); + TAOS_CHECK_GOTO(tDecodeI32(&decoder, &num), &lino, _OVER), &lino, _OVER); + + p = taosMemoryCalloc(1, sizeof(SIpWhiteList) + num * sizeof(SIpV4Range)); + if(p == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } + TAOS_CHECK_GOTO(tDerializeIpWhileList(buf, len, p), &lino, _OVER); + +_OVER: tEndDecode(&decoder); tDecoderClear(&decoder); - - SIpWhiteList *p = taosMemoryCalloc(1, sizeof(SIpWhiteList) + num * sizeof(SIpV4Range)); - tDerializeIpWhileList(buf, len, p); return p; } @@ -1027,23 +1161,29 @@ _OVER: } static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + int32_t code = 0; + int32_t lino = 0; SSdbRow *pRow = NULL; SUserObj *pUser = NULL; int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) { + TAOS_CHECK_GOTO(TSDB_CODE_INVALID_PTR, &lino, _OVER); + } if (sver < 1 || sver > USER_VER_NUMBER) { - terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - goto _OVER; + TAOS_CHECK_GOTO(TSDB_CODE_SDB_INVALID_DATA_VER, &lino, _OVER); } pRow = sdbAllocRow(sizeof(SUserObj)); - if (pRow == NULL) goto _OVER; + if (pRow == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } pUser = sdbGetRowObj(pRow); - if (pUser == NULL) goto _OVER; + if (pUser == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } int32_t dataPos = 0; SDB_GET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, _OVER) @@ -1074,20 +1214,23 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { pUser->writeDbs = taosHashInit(numOfWriteDbs, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); pUser->topics = taosHashInit(numOfTopics, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); - if (pUser->readDbs == NULL || pUser->writeDbs == NULL || pUser->topics == NULL) goto _OVER; + if (pUser->readDbs == NULL || pUser->writeDbs == NULL || pUser->topics == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + goto _OVER; + } for (int32_t i = 0; i < numOfReadDbs; ++i) { char db[TSDB_DB_FNAME_LEN] = {0}; SDB_GET_BINARY(pRaw, dataPos, db, TSDB_DB_FNAME_LEN, _OVER) int32_t len = strlen(db) + 1; - taosHashPut(pUser->readDbs, db, len, db, TSDB_DB_FNAME_LEN); + TAOS_CHECK_GOTO(taosHashPut(pUser->readDbs, db, len, db, TSDB_DB_FNAME_LEN), &lino, _OVER); } for (int32_t i = 0; i < numOfWriteDbs; ++i) { char db[TSDB_DB_FNAME_LEN] = {0}; SDB_GET_BINARY(pRaw, dataPos, db, TSDB_DB_FNAME_LEN, _OVER) int32_t len = strlen(db) + 1; - taosHashPut(pUser->writeDbs, db, len, db, TSDB_DB_FNAME_LEN); + TAOS_CHECK_GOTO(taosHashPut(pUser->writeDbs, db, len, db, TSDB_DB_FNAME_LEN), &lino, _OVER); } if (sver >= 2) { @@ -1095,7 +1238,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { char topic[TSDB_TOPIC_FNAME_LEN] = {0}; SDB_GET_BINARY(pRaw, dataPos, topic, TSDB_TOPIC_FNAME_LEN, _OVER) int32_t len = strlen(topic) + 1; - taosHashPut(pUser->topics, topic, len, topic, TSDB_TOPIC_FNAME_LEN); + TAOS_CHECK_GOTO(taosHashPut(pUser->topics, topic, len, topic, TSDB_TOPIC_FNAME_LEN), &lino, _OVER); } } @@ -1133,21 +1276,38 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { pUser->useDbs = taosHashInit(numOfUseDbs, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); + if (pUser->readTbs == NULL || pUser->writeTbs == NULL || pUser->alterTbs == NULL || pUser->readViews == NULL || + pUser->writeViews == NULL || pUser->alterViews == NULL || pUser->useDbs == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + goto _OVER; + } + for (int32_t i = 0; i < numOfReadTbs; ++i) { int32_t keyLen = 0; SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t valuelen = 0; SDB_GET_INT32(pRaw, dataPos, &valuelen, _OVER); char *value = taosMemoryCalloc(valuelen, sizeof(char)); + if (value == NULL) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(value, 0, valuelen); SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER) - taosHashPut(pUser->readTbs, key, keyLen, value, valuelen); + if (taosHashPut(pUser->readTbs, key, keyLen, value, valuelen) != 0) { + taosMemoryFree(key); + taosMemoryFree(value); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); taosMemoryFree(value); @@ -1158,16 +1318,27 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t valuelen = 0; SDB_GET_INT32(pRaw, dataPos, &valuelen, _OVER); char *value = taosMemoryCalloc(valuelen, sizeof(char)); + if (value == NULL) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(value, 0, valuelen); SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER) - taosHashPut(pUser->writeTbs, key, keyLen, value, valuelen); + if (taosHashPut(pUser->writeTbs, key, keyLen, value, valuelen) != 0) { + taosMemoryFree(key); + taosMemoryFree(value); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); taosMemoryFree(value); @@ -1179,16 +1350,27 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t valuelen = 0; SDB_GET_INT32(pRaw, dataPos, &valuelen, _OVER); char *value = taosMemoryCalloc(valuelen, sizeof(char)); + if (value == NULL) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(value, 0, valuelen); SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER) - taosHashPut(pUser->alterTbs, key, keyLen, value, valuelen); + if (taosHashPut(pUser->alterTbs, key, keyLen, value, valuelen) != 0) { + taosMemoryFree(key); + taosMemoryFree(value); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); taosMemoryFree(value); @@ -1199,16 +1381,27 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t valuelen = 0; SDB_GET_INT32(pRaw, dataPos, &valuelen, _OVER); char *value = taosMemoryCalloc(valuelen, sizeof(char)); + if (value == NULL) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(value, 0, valuelen); SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER) - taosHashPut(pUser->readViews, key, keyLen, value, valuelen); + if (taosHashPut(pUser->readViews, key, keyLen, value, valuelen) != 0) { + taosMemoryFree(key); + taosMemoryFree(value); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); taosMemoryFree(value); @@ -1219,16 +1412,27 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t valuelen = 0; SDB_GET_INT32(pRaw, dataPos, &valuelen, _OVER); char *value = taosMemoryCalloc(valuelen, sizeof(char)); + if (value == NULL) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(value, 0, valuelen); SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER) - taosHashPut(pUser->writeViews, key, keyLen, value, valuelen); + if (taosHashPut(pUser->writeViews, key, keyLen, value, valuelen) != 0) { + taosMemoryFree(key); + taosMemoryFree(value); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); taosMemoryFree(value); @@ -1239,16 +1443,27 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t valuelen = 0; SDB_GET_INT32(pRaw, dataPos, &valuelen, _OVER); char *value = taosMemoryCalloc(valuelen, sizeof(char)); + if (value == NULL) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(value, 0, valuelen); SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER) - taosHashPut(pUser->alterViews, key, keyLen, value, valuelen); + if (taosHashPut(pUser->alterViews, key, keyLen, value, valuelen) != 0) { + taosMemoryFree(key); + taosMemoryFree(value); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); taosMemoryFree(value); @@ -1260,13 +1475,19 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &keyLen, _OVER); char *key = taosMemoryCalloc(keyLen, sizeof(char)); + if (key == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } memset(key, 0, keyLen); SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER); int32_t ref = 0; SDB_GET_INT32(pRaw, dataPos, &ref, _OVER); - taosHashPut(pUser->useDbs, key, keyLen, &ref, sizeof(ref)); + if (taosHashPut(pUser->useDbs, key, keyLen, &ref, sizeof(ref)) != 0) { + taosMemoryFree(key); + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } taosMemoryFree(key); } } @@ -1276,17 +1497,19 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { SDB_GET_INT32(pRaw, dataPos, &len, _OVER); char *buf = taosMemoryMalloc(len); - if (buf == NULL) goto _OVER; + if(buf == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } SDB_GET_BINARY(pRaw, dataPos, buf, len, _OVER); - pUser->pIpWhiteList = createIpWhiteList(buf, len); + code = createIpWhiteList(buf, len, &pUser->pIpWhiteList); taosMemoryFree(buf); SDB_GET_INT64(pRaw, dataPos, &pUser->ipWhiteListVer, _OVER); } if (pUser->pIpWhiteList == NULL) { - pUser->pIpWhiteList = createDefaultIpWhiteList(); + createDefaultIpWhiteList(&pUser->pIpWhiteList); pUser->ipWhiteListVer = taosGetTimestampMs(); } @@ -1724,29 +1947,50 @@ _OVER: } int32_t mndProcesSRetrieveIpWhiteReq(SRpcMsg *pReq) { + int32_t code = 0; + int32_t lino = 0; + int32_t len = 0; + void *pRsp = NULL; + SUpdateIpWhite ipWhite = {0}; + // impl later SRetrieveIpWhiteReq req = {0}; if (tDeserializeRetrieveIpWhite(pReq->pCont, pReq->contLen, &req) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; + code = TSDB_CODE_INVALID_MSG; + TAOS_CHECK_GOTO(code, &lino, _OVER); } - SUpdateIpWhite ipWhite = {0}; - ipWhiteMgtFillMsg(&ipWhite); + TAOS_CHECK_GOTO(ipWhiteMgtFillMsg(&ipWhite), &lino, _OVER); - int32_t len = tSerializeSUpdateIpWhite(NULL, 0, &ipWhite); + len = tSerializeSUpdateIpWhite(NULL, 0, &ipWhite); + if (len < 0) { + code = TSDB_CODE_OUT_OF_MEMORY; + TAOS_CHECK_GOTO(code, &lino, _OVER); + } - void *pRsp = rpcMallocCont(len); - tSerializeSUpdateIpWhite(pRsp, len, &ipWhite); + pRsp = rpcMallocCont(len); + if (!pRsp) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + } + len = tSerializeSUpdateIpWhite(pRsp, len, &ipWhite); + if (len < 0) { + code = TSDB_CODE_OUT_OF_MEMORY; + TAOS_CHECK_GOTO(code, &lino, _OVER); + } +_OVER: + if (code != 0) { + mError("failed to process retrieve ip white request at line %d since %s", lino, tstrerror(code)); + rpcFreeCont(pRsp); + pRsp = NULL; + len = 0; + } + pReq->code = code; pReq->info.rsp = pRsp; pReq->info.rspLen = len; - //} - tFreeSUpdateIpWhiteReq(&ipWhite); - return 0; -_OVER: - return -1; + tFreeSUpdateIpWhiteReq(&ipWhite); + TAOS_RETURN(code); } static int32_t mndAlterUser(SMnode *pMnode, SUserObj *pOld, SUserObj *pNew, SRpcMsg *pReq) { diff --git a/source/util/src/tbase58.c b/source/util/src/tbase58.c index 5eb72879c3..274249badf 100644 --- a/source/util/src/tbase58.c +++ b/source/util/src/tbase58.c @@ -21,7 +21,7 @@ #define TBASE_BUF_SIZE 256 static const char *basis_58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; -char *base58_encode(const uint8_t *value, int32_t vlen) { +int32_t base58_encode(const uint8_t *value, int32_t vlen, char **result) { const uint8_t *pb = value; const uint8_t *pe = pb + vlen; uint8_t buf[TBASE_BUF_SIZE] = {0}; @@ -29,9 +29,10 @@ char *base58_encode(const uint8_t *value, int32_t vlen) { bool bfree = false; int32_t nz = 0, size = 0, len = 0; + *result = NULL; + if (vlen > TBASE_MAX_ILEN) { - terrno = TSDB_CODE_INVALID_PARA; - return NULL; + return TSDB_CODE_INVALID_PARA; } while (pb != pe && *pb == 0) { @@ -42,8 +43,7 @@ char *base58_encode(const uint8_t *value, int32_t vlen) { size = (pe - pb) * 69 / 50 + 1; if (size > TBASE_BUF_SIZE) { if (!(pbuf = taosMemoryCalloc(1, size))) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } bfree = true; } @@ -62,17 +62,17 @@ char *base58_encode(const uint8_t *value, int32_t vlen) { const uint8_t *pi = pbuf + (size - len); while (pi != pbuf + size && *pi == 0) ++pi; - uint8_t *result = taosMemoryCalloc(1, nz + (pbuf + size - pi) + 1); - if (!result) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + uint8_t *pResult = taosMemoryCalloc(1, nz + (pbuf + size - pi) + 1); + if (!pResult) { if (bfree) taosMemoryFree(pbuf); - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } - memset(result, '1', nz); - while (pi != pbuf + size) result[nz++] = basis_58[*pi++]; + memset(pResult, '1', nz); + while (pi != pbuf + size) pResult[nz++] = basis_58[*pi++]; if (bfree) taosMemoryFree(pbuf); - return result; + *result = pResult; + return 0; } static const signed char index_58[256] = { @@ -86,7 +86,7 @@ static const signed char index_58[256] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; -uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen) { +int32_t base58_decode(const char *value, size_t inlen, int32_t *outlen, uint8_t **result) { const char *pb = value; const char *pe = value + inlen; uint8_t buf[TBASE_BUF_SIZE] = {0}; @@ -94,15 +94,15 @@ uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen) { bool bfree = false; int32_t nz = 0, size = 0, len = 0; + *result = NULL; + if (inlen > TBASE_MAX_OLEN) { - terrno = TSDB_CODE_INVALID_PARA; - return NULL; + return TSDB_CODE_INVALID_PARA; } while (pb != pe) { if (*pb == 0) { - terrno = TSDB_CODE_INVALID_PARA; - return NULL; + return TSDB_CODE_INVALID_PARA; } ++pb; } @@ -117,8 +117,7 @@ uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen) { size = (int32_t)(pe - pb) * 733 / 1000 + 1; if (size > TBASE_BUF_SIZE) { if (!(pbuf = taosMemoryCalloc(1, size))) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } bfree = true; } @@ -126,9 +125,8 @@ uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen) { while (pb != pe && *pb && !isspace(*pb)) { int32_t num = index_58[(uint8_t)*pb]; if (num == -1) { - terrno = TSDB_CODE_INVALID_PARA; if (bfree) taosMemoryFree(pbuf); - return NULL; + return TSDB_CODE_INVALID_PARA; } int32_t i = 0; for (int32_t j = size - 1; (num != 0 || i < len) && (j >= 0); --j, ++i) { @@ -143,23 +141,23 @@ uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen) { while (pb != pe && isspace(*pb)) ++pb; if (*pb != 0) { if (bfree) taosMemoryFree(pbuf); - return NULL; + return TSDB_CODE_INVALID_DATA_FMT; } const uint8_t *it = pbuf + (size - len); while (it != pbuf + size && *it == 0) ++it; - uint8_t *result = taosMemoryCalloc(1, nz + (pbuf + size - it) + 1); - if (!result) { + uint8_t *pResult = taosMemoryCalloc(1, nz + (pbuf + size - it) + 1); + if (!pResult) { if (bfree) taosMemoryFree(pbuf); - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } - memset(result, 0, nz); - while (it != pbuf + size) result[nz++] = *it++; + memset(pResult, 0, nz); + while (it != pbuf + size) pResult[nz++] = *it++; if (outlen) *outlen = nz; if (bfree) taosMemoryFree(pbuf); - return result; + *result = pResult; + return 0; } \ No newline at end of file diff --git a/source/util/src/tbase64.c b/source/util/src/tbase64.c index a2f4ddbc51..86b069b853 100644 --- a/source/util/src/tbase64.c +++ b/source/util/src/tbase64.c @@ -18,10 +18,13 @@ static char basis_64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -char *base64_encode(const uint8_t *value, int32_t vlen) { +int32_t base64_encode(const uint8_t *value, int32_t vlen, char **result) { uint8_t oval = 0; - char *result = (char *)taosMemoryMalloc((size_t)(vlen * 4) / 3 + 10); - char *out = result; + *result = (char *)taosMemoryMalloc((size_t)(vlen * 4) / 3 + 10); + if (*result == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + char *out = *result; while (vlen >= 3) { *out++ = basis_64[value[0] >> 2]; *out++ = basis_64[((value[0] << 4) & 0x30) | (value[1] >> 4)]; @@ -39,7 +42,7 @@ char *base64_encode(const uint8_t *value, int32_t vlen) { *out++ = '='; } *out = '\0'; - return result; + return 0; } #define CHAR64(c) (((c) < 0 || (c) > 127) ? -1 : index_64[(c)]) @@ -51,17 +54,20 @@ static signed char index_64[128] = { 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1}; -uint8_t *base64_decode(const char *value, int32_t inlen, int32_t *outlen) { - int32_t c1, c2, c3, c4; - uint8_t *result = (uint8_t *)taosMemoryMalloc((size_t)(inlen * 3) / 4 + 1); - uint8_t *out = result; +int32_t base64_decode(const char *value, int32_t inlen, int32_t *outlen, uint8_t **result) { + int32_t c1, c2, c3, c4; + *result = (uint8_t *)taosMemoryMalloc((size_t)(inlen * 3) / 4 + 1); + if (*result == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + uint8_t *out = *result; *outlen = 0; while (1) { if (value[0] == 0) { *out = '\0'; - return result; + return 0; } // skip \r\n @@ -93,9 +99,9 @@ uint8_t *base64_decode(const char *value, int32_t inlen, int32_t *outlen) { } base64_decode_error: - taosMemoryFree(result); - result = 0; + taosMemoryFree(*result); + *result = 0; *outlen = 0; - return result; + return TSDB_CODE_INVALID_DATA_FMT; } diff --git a/source/util/test/tbaseCodecTest.cpp b/source/util/test/tbaseCodecTest.cpp index 63bbfcaa68..da6135ea66 100644 --- a/source/util/test/tbaseCodecTest.cpp +++ b/source/util/test/tbaseCodecTest.cpp @@ -19,14 +19,16 @@ using namespace std; static void checkBase58Codec(uint8_t *pRaw, int32_t rawLen, int32_t index) { int64_t start = taosGetTimestampUs(); - char *pEnc = base58_encode((const uint8_t *)pRaw, rawLen); + char *pEnc = NULL; + (void)base58_encode((const uint8_t *)pRaw, rawLen, &pEnc); ASSERT_NE(nullptr, pEnc); int32_t encLen = strlen(pEnc); int64_t endOfEnc = taosGetTimestampUs(); std::cout << "index:" << index << ", encLen is " << encLen << ", cost:" << endOfEnc - start << " us" << std::endl; int32_t decLen = 0; - char *pDec = (char *)base58_decode((const char *)pEnc, encLen, &decLen); + char *pDec = NULL; + (void)base58_decode((const char *)pEnc, encLen, &decLen, (uint8_t**)&pDec); std::cout << "index:" << index << ", decLen is " << decLen << ", cost:" << taosGetTimestampUs() - endOfEnc << " us" << std::endl; ASSERT_NE(nullptr, pDec); @@ -68,9 +70,11 @@ TEST(TD_BASE_CODEC_TEST, tbase58_test) { // 2. overflow case char tmp[1]; - char *pEnc = base58_encode((const uint8_t *)tmp, TBASE_MAX_ILEN + 1); + char *pEnc = NULL; + (void)base58_encode((const uint8_t *)tmp, TBASE_MAX_ILEN + 1, &pEnc); ASSERT_EQ(nullptr, pEnc); - char *pDec = (char *)base58_decode((const char *)tmp, TBASE_MAX_OLEN + 1, NULL); + char *pDec = NULL; + (void)base58_decode((const char *)tmp, TBASE_MAX_OLEN + 1, NULL, (uint8_t**)&pDec); ASSERT_EQ(nullptr, pDec); taosMemoryFreeClear(pRaw);