#4729

Committed 12 Sep 2025 02:34AM UTC coverage: 58.085% (-1.0%) from 59.125%

Build # #4729

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

docs: optimize taosd config parameters doc better (#32964)

Run Details

133518 of 292959 branches covered (45.58%)

Branch coverage included in aggregate %.

201933 of 284559 relevant lines covered (70.96%)

5466318.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

42.66

/source/dnode/mgmt/node_util/src/dmFile.c

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

#define _DEFAULT_SOURCE
#include "crypt.h"
#include "dmUtil.h"
#include "tchecksum.h"
#include "tgrant.h"
#include "tjson.h"

#define MAXLEN               1024
#define DM_KEY_INDICATOR     "this indicator!"
#define DM_ENCRYPT_CODE_FILE "encryptCode.cfg"
#define DM_CHECK_CODE_FILE   "checkCode.bin"

static int32_t dmDecodeFile(SJson *pJson, bool *deployed) {
  int32_t code = 0;
  int32_t value = 0;

  tjsonGetInt32ValueFromDouble(pJson, "deployed", value, code);
  if (code < 0) return code;

  *deployed = (value != 0);
  return code;
}

int32_t dmReadFile(const char *path, const char *name, bool *pDeployed) {
  int32_t   code = -1;
  TdFilePtr pFile = NULL;
  char     *content = NULL;
  SJson    *pJson = NULL;
  char      file[PATH_MAX] = {0};
  int32_t   nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    goto _OVER;
  }

  if (taosStatFile(file, NULL, NULL, NULL) < 0) {
    dInfo("file:%s not exist", file);
    code = 0;
    goto _OVER;
  }

  pFile = taosOpenFile(file, TD_FILE_READ);
  if (pFile == NULL) {
    code = terrno;
    dError("failed to open file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  int64_t size = 0;
  code = taosFStatFile(pFile, &size, NULL);
  if (code != 0) {
    dError("failed to fstat file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content = taosMemoryMalloc(size + 1);
  if (content == NULL) {
    code = terrno;
    goto _OVER;
  }

  if (taosReadFile(pFile, content, size) != size) {
    code = terrno;
    dError("failed to read file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content[size] = '\0';

  pJson = tjsonParse(content);
  if (pJson == NULL) {
    code = TSDB_CODE_INVALID_JSON_FORMAT;
    goto _OVER;
  }

  if (dmDecodeFile(pJson, pDeployed) < 0) {
    code = TSDB_CODE_INVALID_JSON_FORMAT;
    goto _OVER;
  }

  code = 0;
  dInfo("succceed to read mnode file %s", file);

_OVER:
  if (content != NULL) taosMemoryFree(content);
  if (pJson != NULL) cJSON_Delete(pJson);
  if (pFile != NULL) taosCloseFile(&pFile);

  if (code != 0) {
    dError("failed to read dnode file:%s since %s", file, tstrerror(code));
  }
  return code;
}

int32_t dmReadFileJson(const char *path, const char *name, SJson **ppJson, bool* deployed) {
  int32_t   code = -1;
  TdFilePtr pFile = NULL;
  char     *content = NULL;
  char      file[PATH_MAX] = {0};
  int32_t   nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    goto _OVER;
  }

  if (taosStatFile(file, NULL, NULL, NULL) < 0) {
    dInfo("file:%s not exist", file);
    code = 0;
    goto _OVER;
  }

  pFile = taosOpenFile(file, TD_FILE_READ);
  if (pFile == NULL) {
    code = terrno;
    dError("failed to open file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  int64_t size = 0;
  code = taosFStatFile(pFile, &size, NULL);
  if (code != 0) {
    dError("failed to fstat file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content = taosMemoryMalloc(size + 1);
  if (content == NULL) {
    code = terrno;
    goto _OVER;
  }

  if (taosReadFile(pFile, content, size) != size) {
    code = terrno;
    dError("failed to read file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content[size] = '\0';

  *ppJson = tjsonParse(content);
  if (*ppJson == NULL) {
    code = TSDB_CODE_INVALID_JSON_FORMAT;
    goto _OVER;
  }

  if (dmDecodeFile(*ppJson, deployed) < 0) {
    code = TSDB_CODE_INVALID_JSON_FORMAT;
    goto _OVER;
  }

  code = 0;
  dInfo("succceed to read mnode file %s", file);

_OVER:
  if (content != NULL) taosMemoryFree(content);
  if (pFile != NULL) taosCloseFile(&pFile);

  if (code != 0) {
    if (*ppJson != NULL) cJSON_Delete(*ppJson);
    dError("failed to read dnode file:%s since %s", file, tstrerror(code));
  }
  return code;
}


static int32_t dmEncodeFile(SJson *pJson, bool deployed) {
  if (tjsonAddDoubleToObject(pJson, "deployed", deployed) < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
  return 0;
}

int32_t dmWriteFile(const char *path, const char *name, bool deployed) {
  int32_t   code = -1;
  char     *buffer = NULL;
  SJson    *pJson = NULL;
  TdFilePtr pFile = NULL;
  char      file[PATH_MAX] = {0};
  char      realfile[PATH_MAX] = {0};

  int32_t nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    goto _OVER;
  }

  nBytes = snprintf(realfile, sizeof(realfile), "%s%s%s.json", path, TD_DIRSEP, name);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    goto _OVER;
  }

  pJson = tjsonCreateObject();
  if (pJson == NULL) {
    code = terrno;
    goto _OVER;
  }

  if ((code = dmEncodeFile(pJson, deployed)) != 0) goto _OVER;

  buffer = tjsonToString(pJson);
  if (buffer == NULL) {
    code = TSDB_CODE_INVALID_JSON_FORMAT;
    goto _OVER;
  }

  pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
  if (pFile == NULL) {
    code = terrno;
    goto _OVER;
  }

  int32_t len = strlen(buffer);
  if (taosWriteFile(pFile, buffer, len) <= 0) {
    code = terrno;
    goto _OVER;
  }
  if (taosFsyncFile(pFile) < 0) {
    code = terrno;
    goto _OVER;
  }

  if (taosCloseFile(&pFile) != 0) {
    code = TAOS_SYSTEM_ERROR(ERRNO);
    goto _OVER;
  }
  TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);

  dInfo("succeed to write file:%s", realfile);

_OVER:

  if (pJson != NULL) tjsonDelete(pJson);
  if (buffer != NULL) taosMemoryFree(buffer);
  if (pFile != NULL) taosCloseFile(&pFile);

  if (code != 0) {
    dError("failed to write file:%s since %s", realfile, tstrerror(code));
  }
  return code;
}

int32_t dmWriteFileJson(const char *path, const char *name, SJson *pJson) {
  int32_t   code = -1;
  char     *buffer = NULL;
  TdFilePtr pFile = NULL;
  char      file[PATH_MAX] = {0};
  char      realfile[PATH_MAX] = {0};

  int32_t nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    goto _OVER;
  }

  nBytes = snprintf(realfile, sizeof(realfile), "%s%s%s.json", path, TD_DIRSEP, name);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    goto _OVER;
  }

  buffer = tjsonToString(pJson);
  if (buffer == NULL) {
    code = TSDB_CODE_INVALID_JSON_FORMAT;
    goto _OVER;
  }

  pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
  if (pFile == NULL) {
    code = terrno;
    goto _OVER;
  }

  int32_t len = strlen(buffer);
  if (taosWriteFile(pFile, buffer, len) <= 0) {
    code = terrno;
    goto _OVER;
  }
  if (taosFsyncFile(pFile) < 0) {
    code = terrno;
    goto _OVER;
  }

  if (taosCloseFile(&pFile) != 0) {
    code = TAOS_SYSTEM_ERROR(ERRNO);
    goto _OVER;
  }
  TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);

  dInfo("succeed to write file:%s", realfile);

_OVER:

  if (pJson != NULL) tjsonDelete(pJson);
  if (buffer != NULL) taosMemoryFree(buffer);
  if (pFile != NULL) taosCloseFile(&pFile);

  if (code != 0) {
    dError("failed to write file:%s since %s", realfile, tstrerror(code));
  }
  return code;
}


int32_t dmCheckRunning(const char *dataDir, TdFilePtr *pFile) {
  int32_t code = 0;
  char    filepath[PATH_MAX] = {0};
  snprintf(filepath, sizeof(filepath), "%s%s.running", dataDir, TD_DIRSEP);

  *pFile = taosOpenFile(filepath, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_CLOEXEC);
  if (*pFile == NULL) {
    code = terrno;
    dError("failed to open file:%s since %s", filepath, tstrerror(code));
    return code;
  }

  int32_t retryTimes = 0;
  int32_t ret = 0;
  do {
    ret = taosLockFile(*pFile);
    if (ret == 0) break;

    code = terrno;
    taosMsleep(1000);
    retryTimes++;
    dError("failed to lock file:%s since %s, retryTimes:%d", filepath, tstrerror(code), retryTimes);
  } while (retryTimes < 12);

  if (ret < 0) {
    code = TAOS_SYSTEM_ERROR(ERRNO);
    (void)taosCloseFile(pFile);
    *pFile = NULL;
    return code;
  }

  dDebug("lock file:%s to prevent repeated starts", filepath);
  return code;
}

extern int32_t generateEncryptCode(const char *key, const char *machineId, char **encryptCode);

static int32_t dmWriteCheckCodeFile(char *file, char *realfile, char *key, bool toLogFile) {
  TdFilePtr pFile = NULL;
  char     *result = NULL;
  int32_t   code = -1;

  int32_t len = ENCRYPTED_LEN(sizeof(DM_KEY_INDICATOR));
  result = taosMemoryMalloc(len);
  if (result == NULL) {
    return terrno;
  }

  SCryptOpts opts;
  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN + 1);
  opts.len = len;
  opts.source = DM_KEY_INDICATOR;
  opts.result = result;
  opts.unitLen = 16;
  (void)CBC_Encrypt(&opts);

  pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
  if (pFile == NULL) {
    code = terrno;
    goto _OVER;
  }

  if (taosWriteFile(pFile, opts.result, len) <= 0) {
    code = terrno;
    goto _OVER;
  }

  if (taosFsyncFile(pFile) < 0) {
    code = TAOS_SYSTEM_ERROR(ERRNO);
    goto _OVER;
  }

  if (taosCloseFile(&pFile) != 0) {
    code = TAOS_SYSTEM_ERROR(ERRNO);
    goto _OVER;
  }

  TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);

  encryptDebug("succeed to write checkCode file:%s", realfile);

  code = 0;
_OVER:
  if (pFile != NULL) taosCloseFile(&pFile);
  if (result != NULL) taosMemoryFree(result);

  return code;
}

static int32_t dmWriteEncryptCodeFile(char *file, char *realfile, char *encryptCode, bool toLogFile) {
  TdFilePtr pFile = NULL;
  int32_t   code = -1;

  pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
  if (pFile == NULL) {
    code = terrno;
    goto _OVER;
  }

  int32_t len = strlen(encryptCode);
  if (taosWriteFile(pFile, encryptCode, len) <= 0) {
    code = terrno;
    goto _OVER;
  }
  if (taosFsyncFile(pFile) < 0) {
    code = terrno;
    goto _OVER;
  }

  if (taosCloseFile(&pFile) != 0) {
    code = TAOS_SYSTEM_ERROR(ERRNO);
    goto _OVER;
  }

  TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);

  encryptDebug("succeed to write encryptCode file:%s", realfile);

  code = 0;
_OVER:
  if (pFile != NULL) taosCloseFile(&pFile);

  return code;
}

static int32_t dmCompareEncryptKey(char *file, char *key, bool toLogFile) {
  char     *content = NULL;
  int64_t   size = 0;
  TdFilePtr pFile = NULL;
  char     *result = NULL;
  int32_t   code = -1;

  pFile = taosOpenFile(file, TD_FILE_READ);
  if (pFile == NULL) {
    code = terrno;
    encryptError("failed to open dnode file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  code = taosFStatFile(pFile, &size, NULL);
  if (code != 0) {
    encryptError("failed to fstat dnode file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content = taosMemoryMalloc(size);
  if (content == NULL) {
    code = terrno;
    goto _OVER;
  }

  if (taosReadFile(pFile, content, size) != size) {
    code = terrno;
    encryptError("failed to read dnode file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  encryptDebug("succeed to read checkCode file:%s", file);

  int len = ENCRYPTED_LEN(size);
  result = taosMemoryMalloc(len);
  if (result == NULL) {
    code = terrno;
    encryptError("failed to alloc memory file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  SCryptOpts opts = {0};
  tstrncpy(opts.key, key, ENCRYPT_KEY_LEN + 1);
  opts.len = len;
  opts.source = content;
  opts.result = result;
  opts.unitLen = 16;
  (void)CBC_Decrypt(&opts);

  if (strcmp(opts.result, DM_KEY_INDICATOR) != 0) {
    code = TSDB_CODE_DNODE_ENCRYPTKEY_CHANGED;
    encryptError("failed to compare decrypted result");
    goto _OVER;
  }

  encryptDebug("succeed to compare checkCode file:%s", file);
  code = 0;
_OVER:
  if (result != NULL) taosMemoryFree(result);
  if (content != NULL) taosMemoryFree(content);
  if (pFile != NULL) taosCloseFile(&pFile);

  return code;
}

int32_t dmUpdateEncryptKey(char *key, bool toLogFile) {
#if defined(TD_ENTERPRISE) || defined(TD_ASTRA_TODO)
  int32_t code = -1;
  int32_t lino = 0;
  char   *machineId = NULL;
  char   *encryptCode = NULL;

  char folder[PATH_MAX] = {0};

  char encryptFile[PATH_MAX] = {0};
  char realEncryptFile[PATH_MAX] = {0};

  char checkFile[PATH_MAX] = {0};
  char realCheckFile[PATH_MAX] = {0};

  int32_t nBytes = snprintf(folder, sizeof(folder), "%s%sdnode", tsDataDir, TD_DIRSEP);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }

  nBytes = snprintf(encryptFile, sizeof(realEncryptFile), "%s%s%s.bak", folder, TD_DIRSEP, DM_ENCRYPT_CODE_FILE);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }

  nBytes = snprintf(realEncryptFile, sizeof(realEncryptFile), "%s%s%s", folder, TD_DIRSEP, DM_ENCRYPT_CODE_FILE);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }

  nBytes = snprintf(checkFile, sizeof(checkFile), "%s%s%s.bak", folder, TD_DIRSEP, DM_CHECK_CODE_FILE);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }

  snprintf(realCheckFile, sizeof(realCheckFile), "%s%s%s", folder, TD_DIRSEP, DM_CHECK_CODE_FILE);
  if (nBytes <= 0 || nBytes >= PATH_MAX) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }

  if (taosMkDir(folder) != 0) {
    code = terrno;
    encryptError("failed to create dir:%s since %s", folder, tstrerror(code));
    goto _OVER;
  }

  if (taosCheckExistFile(realCheckFile)) {
    if ((code = dmCompareEncryptKey(realCheckFile, key, toLogFile)) != 0) {
      goto _OVER;
    }
  }

  TAOS_CHECK_GOTO(tGetMachineId(&machineId), &lino, _OVER);

  TAOS_CHECK_GOTO(generateEncryptCode(key, machineId, &encryptCode), &lino, _OVER);

  if ((code = dmWriteEncryptCodeFile(encryptFile, realEncryptFile, encryptCode, toLogFile)) != 0) {
    goto _OVER;
  }

  if ((code = dmWriteCheckCodeFile(checkFile, realCheckFile, key, toLogFile)) != 0) {
    goto _OVER;
  }

  encryptInfo("Succeed to update encrypt key\n");

  code = 0;
_OVER:
  taosMemoryFree(encryptCode);
  taosMemoryFree(machineId);
  if (code != 0) {
    encryptError("failed to update encrypt key at line %d since %s", lino, tstrerror(code));
  }
  TAOS_RETURN(code);
#else
  return 0;
#endif
}

extern int32_t checkAndGetCryptKey(const char *encryptCode, const char *machineId, char **key);

static int32_t dmReadEncryptCodeFile(char *file, char **output) {
  TdFilePtr pFile = NULL;
  int32_t   code = -1;
  char     *content = NULL;

  pFile = taosOpenFile(file, TD_FILE_READ);
  if (pFile == NULL) {
    code = terrno;
    dError("failed to open dnode file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  int64_t size = 0;
  code = taosFStatFile(pFile, &size, NULL);
  if (code != 0) {
    dError("failed to fstat dnode file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content = taosMemoryMalloc(size + 1);
  if (content == NULL) {
    code = terrno;
    goto _OVER;
  }

  if (taosReadFile(pFile, content, size) != size) {
    code = terrno;
    dError("failed to read dnode file:%s since %s", file, tstrerror(code));
    goto _OVER;
  }

  content[size] = '\0';

  *output = content;
  content = NULL;

  dInfo("succeed to read encryptCode file:%s", file);
  code = 0;
_OVER:
  if (pFile != NULL) taosCloseFile(&pFile);
  taosMemoryFree(content);

  return code;
}

int32_t dmGetEncryptKey() {
#if defined(TD_ENTERPRISE) || defined(TD_ASTRA_TODO)
  int32_t code = -1;
  char    encryptFile[PATH_MAX] = {0};
  char    checkFile[PATH_MAX] = {0};
  char   *machineId = NULL;
  char   *encryptKey = NULL;
  char   *content = NULL;

  int32_t nBytes = snprintf(encryptFile, sizeof(encryptFile), "%s%sdnode%s%s", tsDataDir, TD_DIRSEP, TD_DIRSEP,
                            DM_ENCRYPT_CODE_FILE);
  if (nBytes <= 0 || nBytes >= sizeof(encryptFile)) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    return code;
  }

  nBytes = snprintf(checkFile, sizeof(checkFile), "%s%sdnode%s%s", tsDataDir, TD_DIRSEP, TD_DIRSEP, DM_CHECK_CODE_FILE);
  if (nBytes <= 0 || nBytes >= sizeof(checkFile)) {
    code = TSDB_CODE_OUT_OF_BUFFER;
    return code;
  }

  if (!taosCheckExistFile(encryptFile)) {
    code = TSDB_CODE_DNODE_INVALID_ENCRYPT_CONFIG;
    dInfo("no exist, checkCode file:%s", encryptFile);
    return 0;
  }

  if ((code = dmReadEncryptCodeFile(encryptFile, &content)) != 0) {
    goto _OVER;
  }

  if ((code = tGetMachineId(&machineId)) != 0) {
    goto _OVER;
  }

  if ((code = checkAndGetCryptKey(content, machineId, &encryptKey)) != 0) {
    goto _OVER;
  }

  taosMemoryFreeClear(machineId);
  taosMemoryFreeClear(content);

  if (encryptKey[0] == '\0') {
    code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;
    dError("failed to read key since %s", tstrerror(code));
    goto _OVER;
  }

  if ((code = dmCompareEncryptKey(checkFile, encryptKey, true)) != 0) {
    goto _OVER;
  }

  tstrncpy(tsEncryptKey, encryptKey, ENCRYPT_KEY_LEN + 1);
  taosMemoryFreeClear(encryptKey);
  tsEncryptionKeyChksum = taosCalcChecksum(0, tsEncryptKey, strlen(tsEncryptKey));
  tsEncryptionKeyStat = ENCRYPT_KEY_STAT_LOADED;

  code = 0;
_OVER:
  if (content != NULL) taosMemoryFree(content);
  if (encryptKey != NULL) taosMemoryFree(encryptKey);
  if (machineId != NULL) taosMemoryFree(machineId);
  if (code != 0) {
    dError("failed to get encrypt key since %s", tstrerror(code));
  }
  TAOS_RETURN(code);
#else
  return 0;
#endif
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http:www.gnu.org/licenses/>.
14	*/
15
16	#define _DEFAULT_SOURCE
17	#include "crypt.h"
18	#include "dmUtil.h"
19	#include "tchecksum.h"
20	#include "tgrant.h"
21	#include "tjson.h"
22
23	#define MAXLEN 1024
24	#define DM_KEY_INDICATOR "this indicator!"
25	#define DM_ENCRYPT_CODE_FILE "encryptCode.cfg"
26	#define DM_CHECK_CODE_FILE "checkCode.bin"
27
28	static int32_t dmDecodeFile(SJson pJson, bool deployed) {	60✔
29	int32_t code = 0;	60✔
30	int32_t value = 0;	60✔
31
32	tjsonGetInt32ValueFromDouble(pJson, "deployed", value, code);	60✔
33	if (code < 0) return code;	60!
34
35	*deployed = (value != 0);	60✔
36	return code;	60✔
37	}
38
39	int32_t dmReadFile(const char path, const char name, bool *pDeployed) {	4,766✔
40	int32_t code = -1;	4,766✔
41	TdFilePtr pFile = NULL;	4,766✔
42	char *content = NULL;	4,766✔
43	SJson *pJson = NULL;	4,766✔
44	char file[PATH_MAX] = {0};	4,766✔
45	int32_t nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);	4,766✔
46	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	4,766!
47	code = TSDB_CODE_OUT_OF_BUFFER;	×
48	goto _OVER;	×
49	}
50
51	if (taosStatFile(file, NULL, NULL, NULL) < 0) {	4,766✔
52	dInfo("file:%s not exist", file);	4,717!
53	code = 0;	4,717✔
54	goto _OVER;	4,717✔
55	}
56
57	pFile = taosOpenFile(file, TD_FILE_READ);	49✔
58	if (pFile == NULL) {	49!
59	code = terrno;	×
60	dError("failed to open file:%s since %s", file, tstrerror(code));	×
61	goto _OVER;	×
62	}
63
64	int64_t size = 0;	49✔
65	code = taosFStatFile(pFile, &size, NULL);	49✔
66	if (code != 0) {	49!
67	dError("failed to fstat file:%s since %s", file, tstrerror(code));	×
68	goto _OVER;	×
69	}
70
71	content = taosMemoryMalloc(size + 1);	49!
72	if (content == NULL) {	49!
73	code = terrno;	×
74	goto _OVER;	×
75	}
76
77	if (taosReadFile(pFile, content, size) != size) {	49!
78	code = terrno;	×
79	dError("failed to read file:%s since %s", file, tstrerror(code));	×
80	goto _OVER;	×
81	}
82
83	content[size] = '\0';	49✔
84
85	pJson = tjsonParse(content);	49✔
86	if (pJson == NULL) {	49!
87	code = TSDB_CODE_INVALID_JSON_FORMAT;	×
88	goto _OVER;	×
89	}
90
91	if (dmDecodeFile(pJson, pDeployed) < 0) {	49!
92	code = TSDB_CODE_INVALID_JSON_FORMAT;	×
93	goto _OVER;	×
94	}
95
96	code = 0;	49✔
97	dInfo("succceed to read mnode file %s", file);	49!
98
99	_OVER:	×
100	if (content != NULL) taosMemoryFree(content);	4,766!
101	if (pJson != NULL) cJSON_Delete(pJson);	4,766✔
102	if (pFile != NULL) taosCloseFile(&pFile);	4,766✔
103
104	if (code != 0) {	4,766!
105	dError("failed to read dnode file:%s since %s", file, tstrerror(code));	×
106	}
107	return code;	4,766✔
108	}
109
110	int32_t dmReadFileJson(const char path, const char name, SJson *ppJson, bool deployed) {	2,383✔
111	int32_t code = -1;	2,383✔
112	TdFilePtr pFile = NULL;	2,383✔
113	char *content = NULL;	2,383✔
114	char file[PATH_MAX] = {0};	2,383✔
115	int32_t nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);	2,383✔
116	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	2,383!
117	code = TSDB_CODE_OUT_OF_BUFFER;	×
118	goto _OVER;	×
119	}
120
121	if (taosStatFile(file, NULL, NULL, NULL) < 0) {	2,383✔
122	dInfo("file:%s not exist", file);	2,372!
123	code = 0;	2,372✔
124	goto _OVER;	2,372✔
125	}
126
127	pFile = taosOpenFile(file, TD_FILE_READ);	11✔
128	if (pFile == NULL) {	11!
129	code = terrno;	×
130	dError("failed to open file:%s since %s", file, tstrerror(code));	×
131	goto _OVER;	×
132	}
133
134	int64_t size = 0;	11✔
135	code = taosFStatFile(pFile, &size, NULL);	11✔
136	if (code != 0) {	11!
137	dError("failed to fstat file:%s since %s", file, tstrerror(code));	×
138	goto _OVER;	×
139	}
140
141	content = taosMemoryMalloc(size + 1);	11!
142	if (content == NULL) {	11!
143	code = terrno;	×
144	goto _OVER;	×
145	}
146
147	if (taosReadFile(pFile, content, size) != size) {	11!
148	code = terrno;	×
149	dError("failed to read file:%s since %s", file, tstrerror(code));	×
150	goto _OVER;	×
151	}
152
153	content[size] = '\0';	11✔
154
155	*ppJson = tjsonParse(content);	11✔
156	if (*ppJson == NULL) {	11!
157	code = TSDB_CODE_INVALID_JSON_FORMAT;	×
158	goto _OVER;	×
159	}
160
161	if (dmDecodeFile(*ppJson, deployed) < 0) {	11!
162	code = TSDB_CODE_INVALID_JSON_FORMAT;	×
163	goto _OVER;	×
164	}
165
166	code = 0;	11✔
167	dInfo("succceed to read mnode file %s", file);	11!
168
169	_OVER:	×
170	if (content != NULL) taosMemoryFree(content);	2,383!
171	if (pFile != NULL) taosCloseFile(&pFile);	2,383✔
172
173	if (code != 0) {	2,383!
174	if (ppJson != NULL) cJSON_Delete(ppJson);	×
175	dError("failed to read dnode file:%s since %s", file, tstrerror(code));	×
176	}
177	return code;	2,383✔
178	}
179
180
181	static int32_t dmEncodeFile(SJson *pJson, bool deployed) {	693✔
182	if (tjsonAddDoubleToObject(pJson, "deployed", deployed) < 0) return TSDB_CODE_INVALID_JSON_FORMAT;	693!
183	return 0;	693✔
184	}
185
186	int32_t dmWriteFile(const char path, const char name, bool deployed) {	693✔
187	int32_t code = -1;	693✔
188	char *buffer = NULL;	693✔
189	SJson *pJson = NULL;	693✔
190	TdFilePtr pFile = NULL;	693✔
191	char file[PATH_MAX] = {0};	693✔
192	char realfile[PATH_MAX] = {0};	693✔
193
194	int32_t nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);	693✔
195	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	693!
196	code = TSDB_CODE_OUT_OF_BUFFER;	×
197	goto _OVER;	×
198	}
199
200	nBytes = snprintf(realfile, sizeof(realfile), "%s%s%s.json", path, TD_DIRSEP, name);	693✔
201	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	693!
202	code = TSDB_CODE_OUT_OF_BUFFER;	×
203	goto _OVER;	×
204	}
205
206	pJson = tjsonCreateObject();	693✔
207	if (pJson == NULL) {	693!
208	code = terrno;	×
209	goto _OVER;	×
210	}
211
212	if ((code = dmEncodeFile(pJson, deployed)) != 0) goto _OVER;	693!
213
214	buffer = tjsonToString(pJson);	693✔
215	if (buffer == NULL) {	693!
216	code = TSDB_CODE_INVALID_JSON_FORMAT;	×
217	goto _OVER;	×
218	}
219
220	pFile = taosOpenFile(file, TD_FILE_CREATE \| TD_FILE_WRITE \| TD_FILE_TRUNC \| TD_FILE_WRITE_THROUGH);	693✔
221	if (pFile == NULL) {	693!
222	code = terrno;	×
223	goto _OVER;	×
224	}
225
226	int32_t len = strlen(buffer);	693✔
227	if (taosWriteFile(pFile, buffer, len) <= 0) {	693!
228	code = terrno;	×
229	goto _OVER;	×
230	}
231	if (taosFsyncFile(pFile) < 0) {	693!
232	code = terrno;	×
233	goto _OVER;	×
234	}
235
236	if (taosCloseFile(&pFile) != 0) {	693!
237	code = TAOS_SYSTEM_ERROR(ERRNO);	×
238	goto _OVER;	×
239	}
240	TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);	693!
241
242	dInfo("succeed to write file:%s", realfile);	693!
243
244	_OVER:	×
245
246	if (pJson != NULL) tjsonDelete(pJson);	693!
247	if (buffer != NULL) taosMemoryFree(buffer);	693!
248	if (pFile != NULL) taosCloseFile(&pFile);	693!
249
250	if (code != 0) {	693!
251	dError("failed to write file:%s since %s", realfile, tstrerror(code));	×
252	}
253	return code;	693✔
254	}
255
256	int32_t dmWriteFileJson(const char path, const char name, SJson *pJson) {	654✔
257	int32_t code = -1;	654✔
258	char *buffer = NULL;	654✔
259	TdFilePtr pFile = NULL;	654✔
260	char file[PATH_MAX] = {0};	654✔
261	char realfile[PATH_MAX] = {0};	654✔
262
263	int32_t nBytes = snprintf(file, sizeof(file), "%s%s%s.json", path, TD_DIRSEP, name);	654✔
264	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	654!
265	code = TSDB_CODE_OUT_OF_BUFFER;	×
266	goto _OVER;	×
267	}
268
269	nBytes = snprintf(realfile, sizeof(realfile), "%s%s%s.json", path, TD_DIRSEP, name);	654✔
270	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	654!
271	code = TSDB_CODE_OUT_OF_BUFFER;	×
272	goto _OVER;	×
273	}
274
275	buffer = tjsonToString(pJson);	654✔
276	if (buffer == NULL) {	654!
277	code = TSDB_CODE_INVALID_JSON_FORMAT;	×
278	goto _OVER;	×
279	}
280
281	pFile = taosOpenFile(file, TD_FILE_CREATE \| TD_FILE_WRITE \| TD_FILE_TRUNC \| TD_FILE_WRITE_THROUGH);	654✔
282	if (pFile == NULL) {	654!
283	code = terrno;	×
284	goto _OVER;	×
285	}
286
287	int32_t len = strlen(buffer);	654✔
288	if (taosWriteFile(pFile, buffer, len) <= 0) {	654!
289	code = terrno;	×
290	goto _OVER;	×
291	}
292	if (taosFsyncFile(pFile) < 0) {	654!
293	code = terrno;	×
294	goto _OVER;	×
295	}
296
297	if (taosCloseFile(&pFile) != 0) {	654!
298	code = TAOS_SYSTEM_ERROR(ERRNO);	×
299	goto _OVER;	×
300	}
301	TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);	654!
302
303	dInfo("succeed to write file:%s", realfile);	654!
304
305	_OVER:	×
306
307	if (pJson != NULL) tjsonDelete(pJson);	654!
308	if (buffer != NULL) taosMemoryFree(buffer);	654!
309	if (pFile != NULL) taosCloseFile(&pFile);	654!
310
311	if (code != 0) {	654!
312	dError("failed to write file:%s since %s", realfile, tstrerror(code));	×
313	}
314	return code;	654✔
315	}
316
317
318	int32_t dmCheckRunning(const char dataDir, TdFilePtr pFile) {	2,384✔
319	int32_t code = 0;	2,384✔
320	char filepath[PATH_MAX] = {0};	2,384✔
321	snprintf(filepath, sizeof(filepath), "%s%s.running", dataDir, TD_DIRSEP);	2,384✔
322
323	*pFile = taosOpenFile(filepath, TD_FILE_CREATE \| TD_FILE_WRITE \| TD_FILE_TRUNC \| TD_FILE_CLOEXEC);	2,384✔
324	if (*pFile == NULL) {	2,384!
325	code = terrno;	×
326	dError("failed to open file:%s since %s", filepath, tstrerror(code));	×
327	return code;	×
328	}
329
330	int32_t retryTimes = 0;	2,384✔
331	int32_t ret = 0;	2,384✔
332	do {
333	ret = taosLockFile(*pFile);	2,394✔
334	if (ret == 0) break;	2,394✔
335
336	code = terrno;	10✔
337	taosMsleep(1000);	10✔
338	retryTimes++;	10✔
339	dError("failed to lock file:%s since %s, retryTimes:%d", filepath, tstrerror(code), retryTimes);	10!
340	} while (retryTimes < 12);	10!
341
342	if (ret < 0) {	2,384!
343	code = TAOS_SYSTEM_ERROR(ERRNO);	×
344	(void)taosCloseFile(pFile);	×
345	*pFile = NULL;	×
346	return code;	×
347	}
348
349	dDebug("lock file:%s to prevent repeated starts", filepath);	2,384✔
350	return code;	2,384✔
351	}
352
353	extern int32_t generateEncryptCode(const char key, const char machineId, char **encryptCode);
354
355	static int32_t dmWriteCheckCodeFile(char file, char realfile, char *key, bool toLogFile) {	6✔
356	TdFilePtr pFile = NULL;	6✔
357	char *result = NULL;	6✔
358	int32_t code = -1;	6✔
359
360	int32_t len = ENCRYPTED_LEN(sizeof(DM_KEY_INDICATOR));	6✔
361	result = taosMemoryMalloc(len);	6!
362	if (result == NULL) {	6!
363	return terrno;	×
364	}
365
366	SCryptOpts opts;
367	tstrncpy(opts.key, key, ENCRYPT_KEY_LEN + 1);	6✔
368	opts.len = len;	6✔
369	opts.source = DM_KEY_INDICATOR;	6✔
370	opts.result = result;	6✔
371	opts.unitLen = 16;	6✔
372	(void)CBC_Encrypt(&opts);	6✔
373
374	pFile = taosOpenFile(file, TD_FILE_CREATE \| TD_FILE_WRITE \| TD_FILE_TRUNC \| TD_FILE_WRITE_THROUGH);	6✔
375	if (pFile == NULL) {	6!
376	code = terrno;	×
377	goto _OVER;	×
378	}
379
380	if (taosWriteFile(pFile, opts.result, len) <= 0) {	6!
381	code = terrno;	×
382	goto _OVER;	×
383	}
384
385	if (taosFsyncFile(pFile) < 0) {	6!
386	code = TAOS_SYSTEM_ERROR(ERRNO);	×
387	goto _OVER;	×
388	}
389
390	if (taosCloseFile(&pFile) != 0) {	6!
391	code = TAOS_SYSTEM_ERROR(ERRNO);	×
392	goto _OVER;	×
393	}
394
395	TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);	6!
396
397	encryptDebug("succeed to write checkCode file:%s", realfile);	6!
398
399	code = 0;	6✔
400	_OVER:	6✔
401	if (pFile != NULL) taosCloseFile(&pFile);	6!
402	if (result != NULL) taosMemoryFree(result);	6!
403
404	return code;	6✔
405	}
406
407	static int32_t dmWriteEncryptCodeFile(char file, char realfile, char *encryptCode, bool toLogFile) {	6✔
408	TdFilePtr pFile = NULL;	6✔
409	int32_t code = -1;	6✔
410
411	pFile = taosOpenFile(file, TD_FILE_CREATE \| TD_FILE_WRITE \| TD_FILE_TRUNC \| TD_FILE_WRITE_THROUGH);	6✔
412	if (pFile == NULL) {	6!
413	code = terrno;	×
414	goto _OVER;	×
415	}
416
417	int32_t len = strlen(encryptCode);	6✔
418	if (taosWriteFile(pFile, encryptCode, len) <= 0) {	6!
419	code = terrno;	×
420	goto _OVER;	×
421	}
422	if (taosFsyncFile(pFile) < 0) {	6!
423	code = terrno;	×
424	goto _OVER;	×
425	}
426
427	if (taosCloseFile(&pFile) != 0) {	6!
428	code = TAOS_SYSTEM_ERROR(ERRNO);	×
429	goto _OVER;	×
430	}
431
432	TAOS_CHECK_GOTO(taosRenameFile(file, realfile), NULL, _OVER);	6!
433
434	encryptDebug("succeed to write encryptCode file:%s", realfile);	6!
435
436	code = 0;	6✔
437	_OVER:	6✔
438	if (pFile != NULL) taosCloseFile(&pFile);	6!
439
440	return code;	6✔
441	}
442
443	static int32_t dmCompareEncryptKey(char file, char key, bool toLogFile) {	×
444	char *content = NULL;	×
445	int64_t size = 0;	×
446	TdFilePtr pFile = NULL;	×
447	char *result = NULL;	×
448	int32_t code = -1;	×
449
450	pFile = taosOpenFile(file, TD_FILE_READ);	×
451	if (pFile == NULL) {	×
452	code = terrno;	×
453	encryptError("failed to open dnode file:%s since %s", file, tstrerror(code));	×
454	goto _OVER;	×
455	}
456
457	code = taosFStatFile(pFile, &size, NULL);	×
458	if (code != 0) {	×
459	encryptError("failed to fstat dnode file:%s since %s", file, tstrerror(code));	×
460	goto _OVER;	×
461	}
462
463	content = taosMemoryMalloc(size);	×
464	if (content == NULL) {	×
465	code = terrno;	×
466	goto _OVER;	×
467	}
468
469	if (taosReadFile(pFile, content, size) != size) {	×
470	code = terrno;	×
471	encryptError("failed to read dnode file:%s since %s", file, tstrerror(code));	×
472	goto _OVER;	×
473	}
474
475	encryptDebug("succeed to read checkCode file:%s", file);	×
476
477	int len = ENCRYPTED_LEN(size);	×
478	result = taosMemoryMalloc(len);	×
479	if (result == NULL) {	×
480	code = terrno;	×
481	encryptError("failed to alloc memory file:%s since %s", file, tstrerror(code));	×
482	goto _OVER;	×
483	}
484
485	SCryptOpts opts = {0};	×
486	tstrncpy(opts.key, key, ENCRYPT_KEY_LEN + 1);	×
487	opts.len = len;	×
488	opts.source = content;	×
489	opts.result = result;	×
490	opts.unitLen = 16;	×
491	(void)CBC_Decrypt(&opts);	×
492
493	if (strcmp(opts.result, DM_KEY_INDICATOR) != 0) {	×
494	code = TSDB_CODE_DNODE_ENCRYPTKEY_CHANGED;	×
495	encryptError("failed to compare decrypted result");	×
496	goto _OVER;	×
497	}
498
499	encryptDebug("succeed to compare checkCode file:%s", file);	×
500	code = 0;	×
501	_OVER:	×
502	if (result != NULL) taosMemoryFree(result);	×
503	if (content != NULL) taosMemoryFree(content);	×
504	if (pFile != NULL) taosCloseFile(&pFile);	×
505
506	return code;	×
507	}
508
509	int32_t dmUpdateEncryptKey(char *key, bool toLogFile) {	6✔
510	#if defined(TD_ENTERPRISE) \|\| defined(TD_ASTRA_TODO)
511	int32_t code = -1;	6✔
512	int32_t lino = 0;	6✔
513	char *machineId = NULL;	6✔
514	char *encryptCode = NULL;	6✔
515
516	char folder[PATH_MAX] = {0};	6✔
517
518	char encryptFile[PATH_MAX] = {0};	6✔
519	char realEncryptFile[PATH_MAX] = {0};	6✔
520
521	char checkFile[PATH_MAX] = {0};	6✔
522	char realCheckFile[PATH_MAX] = {0};	6✔
523
524	int32_t nBytes = snprintf(folder, sizeof(folder), "%s%sdnode", tsDataDir, TD_DIRSEP);	6✔
525	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	6!
526	return TSDB_CODE_OUT_OF_BUFFER;	×
527	}
528
529	nBytes = snprintf(encryptFile, sizeof(realEncryptFile), "%s%s%s.bak", folder, TD_DIRSEP, DM_ENCRYPT_CODE_FILE);	6✔
530	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	6!
531	return TSDB_CODE_OUT_OF_BUFFER;	×
532	}
533
534	nBytes = snprintf(realEncryptFile, sizeof(realEncryptFile), "%s%s%s", folder, TD_DIRSEP, DM_ENCRYPT_CODE_FILE);	6✔
535	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	6!
536	return TSDB_CODE_OUT_OF_BUFFER;	×
537	}
538
539	nBytes = snprintf(checkFile, sizeof(checkFile), "%s%s%s.bak", folder, TD_DIRSEP, DM_CHECK_CODE_FILE);	6✔
540	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	6!
541	return TSDB_CODE_OUT_OF_BUFFER;	×
542	}
543
544	snprintf(realCheckFile, sizeof(realCheckFile), "%s%s%s", folder, TD_DIRSEP, DM_CHECK_CODE_FILE);	6✔
545	if (nBytes <= 0 \|\| nBytes >= PATH_MAX) {	6!
546	return TSDB_CODE_OUT_OF_BUFFER;	×
547	}
548
549	if (taosMkDir(folder) != 0) {	6!
550	code = terrno;	×
551	encryptError("failed to create dir:%s since %s", folder, tstrerror(code));	×
552	goto _OVER;	×
553	}
554
555	if (taosCheckExistFile(realCheckFile)) {	6!
556	if ((code = dmCompareEncryptKey(realCheckFile, key, toLogFile)) != 0) {	×
557	goto _OVER;	×
558	}
559	}
560
561	TAOS_CHECK_GOTO(tGetMachineId(&machineId), &lino, _OVER);	6!
562
563	TAOS_CHECK_GOTO(generateEncryptCode(key, machineId, &encryptCode), &lino, _OVER);	6!
564
565	if ((code = dmWriteEncryptCodeFile(encryptFile, realEncryptFile, encryptCode, toLogFile)) != 0) {	6!
566	goto _OVER;	×
567	}
568
569	if ((code = dmWriteCheckCodeFile(checkFile, realCheckFile, key, toLogFile)) != 0) {	6!
570	goto _OVER;	×
571	}
572
573	encryptInfo("Succeed to update encrypt key\n");	6✔
574
575	code = 0;	6✔
576	_OVER:	6✔
577	taosMemoryFree(encryptCode);	6!
578	taosMemoryFree(machineId);	6!
579	if (code != 0) {	6!
580	encryptError("failed to update encrypt key at line %d since %s", lino, tstrerror(code));	×
581	}
582	TAOS_RETURN(code);	6✔
583	#else
584	return 0;
585	#endif
586	}
587
588	extern int32_t checkAndGetCryptKey(const char encryptCode, const char machineId, char **key);
589
590	static int32_t dmReadEncryptCodeFile(char file, char *output) {	×
591	TdFilePtr pFile = NULL;	×
592	int32_t code = -1;	×
593	char *content = NULL;	×
594
595	pFile = taosOpenFile(file, TD_FILE_READ);	×
596	if (pFile == NULL) {	×
597	code = terrno;	×
598	dError("failed to open dnode file:%s since %s", file, tstrerror(code));	×
599	goto _OVER;	×
600	}
601
602	int64_t size = 0;	×
603	code = taosFStatFile(pFile, &size, NULL);	×
604	if (code != 0) {	×
605	dError("failed to fstat dnode file:%s since %s", file, tstrerror(code));	×
606	goto _OVER;	×
607	}
608
609	content = taosMemoryMalloc(size + 1);	×
610	if (content == NULL) {	×
611	code = terrno;	×
612	goto _OVER;	×
613	}
614
615	if (taosReadFile(pFile, content, size) != size) {	×
616	code = terrno;	×
617	dError("failed to read dnode file:%s since %s", file, tstrerror(code));	×
618	goto _OVER;	×
619	}
620
621	content[size] = '\0';	×
622
623	*output = content;	×
624	content = NULL;	×
625
626	dInfo("succeed to read encryptCode file:%s", file);	×
627	code = 0;	×
628	_OVER:	×
629	if (pFile != NULL) taosCloseFile(&pFile);	×
630	taosMemoryFree(content);	×
631
632	return code;	×
633	}
634
635	int32_t dmGetEncryptKey() {	2,374✔
636	#if defined(TD_ENTERPRISE) \|\| defined(TD_ASTRA_TODO)
637	int32_t code = -1;	2,374✔
638	char encryptFile[PATH_MAX] = {0};	2,374✔
639	char checkFile[PATH_MAX] = {0};	2,374✔
640	char *machineId = NULL;	2,374✔
641	char *encryptKey = NULL;	2,374✔
642	char *content = NULL;	2,374✔
643
644	int32_t nBytes = snprintf(encryptFile, sizeof(encryptFile), "%s%sdnode%s%s", tsDataDir, TD_DIRSEP, TD_DIRSEP,	2,374✔
645	DM_ENCRYPT_CODE_FILE);
646	if (nBytes <= 0 \|\| nBytes >= sizeof(encryptFile)) {	2,374!
647	code = TSDB_CODE_OUT_OF_BUFFER;	×
648	return code;	×
649	}
650
651	nBytes = snprintf(checkFile, sizeof(checkFile), "%s%sdnode%s%s", tsDataDir, TD_DIRSEP, TD_DIRSEP, DM_CHECK_CODE_FILE);	2,374✔
652	if (nBytes <= 0 \|\| nBytes >= sizeof(checkFile)) {	2,374!
653	code = TSDB_CODE_OUT_OF_BUFFER;	×
654	return code;	×
655	}
656
657	if (!taosCheckExistFile(encryptFile)) {	2,374!
658	code = TSDB_CODE_DNODE_INVALID_ENCRYPT_CONFIG;	2,374✔
659	dInfo("no exist, checkCode file:%s", encryptFile);	2,374!
660	return 0;	2,374✔
661	}
662
663	if ((code = dmReadEncryptCodeFile(encryptFile, &content)) != 0) {	×
664	goto _OVER;	×
665	}
666
667	if ((code = tGetMachineId(&machineId)) != 0) {	×
668	goto _OVER;	×
669	}
670
671	if ((code = checkAndGetCryptKey(content, machineId, &encryptKey)) != 0) {	×
672	goto _OVER;	×
673	}
674
675	taosMemoryFreeClear(machineId);	×
676	taosMemoryFreeClear(content);	×
677
678	if (encryptKey[0] == '\0') {	×
679	code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;	×
680	dError("failed to read key since %s", tstrerror(code));	×
681	goto _OVER;	×
682	}
683
684	if ((code = dmCompareEncryptKey(checkFile, encryptKey, true)) != 0) {	×
685	goto _OVER;	×
686	}
687
688	tstrncpy(tsEncryptKey, encryptKey, ENCRYPT_KEY_LEN + 1);	×
689	taosMemoryFreeClear(encryptKey);	×
690	tsEncryptionKeyChksum = taosCalcChecksum(0, tsEncryptKey, strlen(tsEncryptKey));	×
691	tsEncryptionKeyStat = ENCRYPT_KEY_STAT_LOADED;	×
692
693	code = 0;	×
694	_OVER:	×
695	if (content != NULL) taosMemoryFree(content);	×
696	if (encryptKey != NULL) taosMemoryFree(encryptKey);	×
697	if (machineId != NULL) taosMemoryFree(machineId);	×
698	if (code != 0) {	×
699	dError("failed to get encrypt key since %s", tstrerror(code));	×
700	}
701	TAOS_RETURN(code);	×
702	#else
703	return 0;
704	#endif
705	}

taosdata / TDengine / #4729

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous