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

enh: return error code

This commit is contained in:
kailixu 2024-07-22 15:29:37 +08:00
parent 98a1145091
commit b337fa628b
10 changed files with 397 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/util/tbase58.h
View File

@ -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
}

4
include/util/tbase64.h
View File

@ -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
}

5
source/dnode/mgmt/node_util/src/dmFile.c
View File

@ -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;

2
source/dnode/mnode/impl/inc/mndDnode.h
View File

@ -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
}

2
source/dnode/mnode/impl/inc/mndUser.h
View File

@ -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);

18
source/dnode/mnode/impl/src/mndDnode.c
View File

@ -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:

404
source/dnode/mnode/impl/src/mndUser.c
View File

@ -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) {

56
source/util/src/tbase58.c
View File

@ -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;
}

30
source/util/src/tbase64.c
View File

@ -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;
}

12
source/util/test/tbaseCodecTest.cpp
View File

@ -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);