db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-15 01:04:37 +02:00
Code Issues Releases Activity

Rename strPtr()/strPtrNull() to strZ()/strZNull().

Browse Source 
We use the Z suffix in many functions to indicate that we are expecting a zero-terminated string so make this function conform to the pattern.

As a bonus the new name is a bit shorter, which is a good quality in a commonly-used function.
This commit is contained in:
David Steele
2020-07-30 07:49:06 -04:00
parent 039d314438
commit 3e9dce0d76
129 changed files with 1803 additions and 1844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CODING.md
View File

@ -12,10 +12,10 @@ With the exception of documentation code, no line of any code or test file shall
```
// CORRECT - location of line break after first function parenthesis if line length is greater than 132
StringList *removeList = infoBackupDataLabelList(
infoBackup, strNewFmt("^%s.*", strPtr(strLstGet(currentBackupList, fullIdx))));
infoBackup, strNewFmt("^%s.*", strZ(strLstGet(currentBackupList, fullIdx))));
// INCORRECT
StringList *removeList = infoBackupDataLabelList(infoBackup, strNewFmt("^%s.*", strPtr(strLstGet(currentBackupList,
StringList *removeList = infoBackupDataLabelList(infoBackup, strNewFmt("^%s.*", strZ(strLstGet(currentBackupList,
fullIdx))));
```
If a conditional, then after a completed conditional, for example:

7
CONTRIBUTING.md
View File

@ -300,7 +300,7 @@ If configuration options are required then a string list with the command and op
```
String *repoPath = strNewFmt("%s/repo", testPath()); // create a string defining the repo path on the test system
StringList *argList = strLstNew(); // create an empty string list
strLstAdd(argList, strNewFmt("--repo-path=%s/", strPtr(repoPath))); // add the --repo-path option as a formatted string
strLstAdd(argList, strNewFmt("--repo-path=%s/", strZ(repoPath))); // add the --repo-path option as a formatted string
strLstAddZ(argList, "info"); // add the command
harnessCfgLoad(cfgCmdExpire, argList); // load the command and option list into the test harness
@ -326,8 +326,9 @@ Sometimes it is necessary to store a file to the test directory. The following d
```
String *content = strNew("bad content");
TEST_RESULT_VOID(
storagePutP(storageNewWriteP(storageTest, strNewFmt("%s/backup/demo/backup.info", strPtr(repoPath))),
harnessInfoChecksum(content)), "store a corrupt backup.info file");
storagePutP(
storageNewWriteP(storageTest, strNewFmt("%s/backup/demo/backup.info", strZ(repoPath))), harnessInfoChecksum(content)),
"store a corrupt backup.info file");
```
**Testing a log message**

4
doc/xml/coding.xml
View File

@ -20,10 +20,10 @@
<code-block>
// CORRECT - location of line break after first function parenthesis if line length is greater than 132
StringList *removeList = infoBackupDataLabelList(
infoBackup, strNewFmt("^%s.*", strPtr(strLstGet(currentBackupList, fullIdx))));
infoBackup, strNewFmt("^%s.*", strZ(strLstGet(currentBackupList, fullIdx))));
// INCORRECT
StringList *removeList = infoBackupDataLabelList(infoBackup, strNewFmt("^%s.*", strPtr(strLstGet(currentBackupList,
StringList *removeList = infoBackupDataLabelList(infoBackup, strNewFmt("^%s.*", strZ(strLstGet(currentBackupList,
fullIdx))));
</code-block>

7
doc/xml/contributing.xml
View File

@ -334,7 +334,7 @@ if (testBegin("expireBackup()"))
<code-block>
String *repoPath = strNewFmt("%s/repo", testPath()); // create a string defining the repo path on the test system
StringList *argList = strLstNew(); // create an empty string list
strLstAdd(argList, strNewFmt("--repo-path=%s/", strPtr(repoPath))); // add the --repo-path option as a formatted string
strLstAdd(argList, strNewFmt("--repo-path=%s/", strZ(repoPath))); // add the --repo-path option as a formatted string
strLstAddZ(argList, "info"); // add the command
harnessCfgLoad(cfgCmdExpire, argList); // load the command and option list into the test harness
@ -358,8 +358,9 @@ TEST_RESULT_STR_Z(infoRender(), "No stanzas exist in the repository.\n", "text -
<code-block>
String *content = strNew("bad content");
TEST_RESULT_VOID(
storagePutP(storageNewWriteP(storageTest, strNewFmt("%s/backup/demo/backup.info", strPtr(repoPath))),
harnessInfoChecksum(content)), "store a corrupt backup.info file");
storagePutP(
storageNewWriteP(storageTest, strNewFmt("%s/backup/demo/backup.info", strZ(repoPath))), harnessInfoChecksum(content)),
"store a corrupt backup.info file");
</code-block>
<p><b>Testing a log message</b></p>

70
src/command/archive/common.c
View File

@ -62,8 +62,7 @@ archiveAsyncErrorClear(ArchiveMode archiveMode, const String *archiveFile)
ASSERT(archiveFile != NULL);
storageRemoveP(
storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s" STATUS_EXT_ERROR, strPtr(archiveFile)));
storageRemoveP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s" STATUS_EXT_ERROR, strZ(archiveFile)));
storageRemoveP(storageSpoolWrite(), STRDEF(STORAGE_SPOOL_ARCHIVE_OUT "/" STATUS_FILE_GLOBAL_ERROR));
FUNCTION_LOG_RETURN_VOID();
@ -90,21 +89,21 @@ archiveAsyncStatus(ArchiveMode archiveMode, const String *walSegment, bool throw
const String *spoolQueue = archiveAsyncSpoolQueue(archiveMode);
String *okFile = strNewFmt("%s" STATUS_EXT_OK, strPtr(walSegment));
bool okFileExists = storageExistsP(storageSpool(), strNewFmt("%s/%s", strPtr(spoolQueue), strPtr(okFile)));
String *okFile = strNewFmt("%s" STATUS_EXT_OK, strZ(walSegment));
bool okFileExists = storageExistsP(storageSpool(), strNewFmt("%s/%s", strZ(spoolQueue), strZ(okFile)));
// If the ok file does not exist then check to see if a file-specific or global error exists
if (!okFileExists)
{
// Check for a file-specific error first
errorFile = strNewFmt("%s" STATUS_EXT_ERROR, strPtr(walSegment));
errorFileExists = storageExistsP(storageSpool(), strNewFmt("%s/%s", strPtr(spoolQueue), strPtr(errorFile)));
errorFile = strNewFmt("%s" STATUS_EXT_ERROR, strZ(walSegment));
errorFileExists = storageExistsP(storageSpool(), strNewFmt("%s/%s", strZ(spoolQueue), strZ(errorFile)));
// If that doesn't exist then check for a global error
if (!errorFileExists)
{
errorFile = STATUS_FILE_GLOBAL_ERROR_STR;
errorFileExists = storageExistsP(storageSpool(), strNewFmt("%s/%s", strPtr(spoolQueue), strPtr(errorFile)));
errorFileExists = storageExistsP(storageSpool(), strNewFmt("%s/%s", strZ(spoolQueue), strZ(errorFile)));
}
}
@ -115,7 +114,7 @@ archiveAsyncStatus(ArchiveMode archiveMode, const String *walSegment, bool throw
const String *statusFile = okFileExists ? okFile: errorFile;
String *content = strNewBuf(
storageGetP(storageNewReadP(storageSpool(), strNewFmt("%s/%s", strPtr(spoolQueue), strPtr(statusFile)))));
storageGetP(storageNewReadP(storageSpool(), strNewFmt("%s/%s", strZ(spoolQueue), strZ(statusFile)))));
// Get the code and message if the file has content
int code = 0;
@ -124,18 +123,18 @@ archiveAsyncStatus(ArchiveMode archiveMode, const String *walSegment, bool throw
if (strSize(content) != 0)
{
// Find the line feed after the error code -- should be the first one
const char *linefeedPtr = strchr(strPtr(content), '\n');
const char *linefeedPtr = strchr(strZ(content), '\n');
// Error if linefeed not found
if (linefeedPtr == NULL)
THROW_FMT(FormatError, "%s content must have at least two lines", strPtr(statusFile));
THROW_FMT(FormatError, "%s content must have at least two lines", strZ(statusFile));
// Error if message is zero-length
if (strlen(linefeedPtr + 1) == 0)
THROW_FMT(FormatError, "%s message must be > 0", strPtr(statusFile));
THROW_FMT(FormatError, "%s message must be > 0", strZ(statusFile));
// Get contents
code = varIntForce(VARSTR(strNewN(strPtr(content), (size_t)(linefeedPtr - strPtr(content)))));
code = varIntForce(VARSTR(strNewN(strZ(content), (size_t)(linefeedPtr - strZ(content)))));
message = strTrim(strNew(linefeedPtr + 1));
}
@ -149,11 +148,11 @@ archiveAsyncStatus(ArchiveMode archiveMode, const String *walSegment, bool throw
if (code != 0)
{
message = strNewFmt(
"WAL segment '%s' was not pushed due to error [%d] and was manually skipped: %s", strPtr(walSegment),
code, strPtr(message));
"WAL segment '%s' was not pushed due to error [%d] and was manually skipped: %s", strZ(walSegment),
code, strZ(message));
}
LOG_WARN(strPtr(message));
LOG_WARN(strZ(message));
}
result = true;
@ -162,10 +161,10 @@ archiveAsyncStatus(ArchiveMode archiveMode, const String *walSegment, bool throw
{
// Error status files must have content
if (strSize(content) == 0)
THROW_FMT(AssertError, "status file '%s' has no content", strPtr(statusFile));
THROW_FMT(AssertError, "status file '%s' has no content", strZ(statusFile));
// Throw error using the code passed in the file
THROW_CODE(code, strPtr(message));
THROW_CODE(code, strZ(message));
}
}
}
@ -195,8 +194,8 @@ archiveAsyncStatusErrorWrite(ArchiveMode archiveMode, const String *walSegment,
storagePutP(
storageNewWriteP(
storageSpoolWrite(),
strNewFmt("%s/%s" STATUS_EXT_ERROR, strPtr(archiveAsyncSpoolQueue(archiveMode)), strPtr(errorFile))),
BUFSTR(strNewFmt("%d\n%s", code, strPtr(message))));
strNewFmt("%s/%s" STATUS_EXT_ERROR, strZ(archiveAsyncSpoolQueue(archiveMode)), strZ(errorFile))),
BUFSTR(strNewFmt("%d\n%s", code, strZ(message))));
}
MEM_CONTEXT_TEMP_END();
@ -220,9 +219,8 @@ archiveAsyncStatusOkWrite(ArchiveMode archiveMode, const String *walSegment, con
// Write file
storagePutP(
storageNewWriteP(
storageSpoolWrite(),
strNewFmt("%s/%s" STATUS_EXT_OK, strPtr(archiveAsyncSpoolQueue(archiveMode)), strPtr(walSegment))),
warning == NULL ? NULL : BUFSTR(strNewFmt("0\n%s", strPtr(warning))));
storageSpoolWrite(), strNewFmt("%s/%s" STATUS_EXT_OK, strZ(archiveAsyncSpoolQueue(archiveMode)), strZ(walSegment))),
warning == NULL ? NULL : BUFSTR(strNewFmt("0\n%s", strZ(warning))));
}
MEM_CONTEXT_TEMP_END();
@ -253,7 +251,7 @@ archiveAsyncExec(ArchiveMode archiveMode, const StringList *commandExec)
// Execute the binary. This statement will not return if it is successful.
THROW_ON_SYS_ERROR_FMT(
execvp(strPtr(strLstGet(commandExec, 0)), (char ** const)strLstPtr(commandExec)) == -1, ExecuteError,
execvp(strZ(strLstGet(commandExec, 0)), (char ** const)strLstPtr(commandExec)) == -1, ExecuteError,
"unable to execute asynchronous '%s'", archiveMode == archiveModeGet ? CFGCMD_ARCHIVE_GET : CFGCMD_ARCHIVE_PUSH);
}
@ -319,7 +317,7 @@ walPath(const String *walFile, const String *pgPath, const String *command)
"option '" CFGOPT_PG1_PATH "' must be specified when relative wal paths are used\n"
"HINT: is %%f passed to %s instead of %%p?\n"
"HINT: PostgreSQL may pass relative paths even with %%p depending on the environment.",
strPtr(command));
strZ(command));
}
// Get the working directory
@ -330,7 +328,7 @@ walPath(const String *walFile, const String *pgPath, const String *command)
if (!strEqZ(pgPath, currentWorkDir))
{
// If not we'll change the working directory to pgPath and see if that equals the working directory we got called with
THROW_ON_SYS_ERROR_FMT(chdir(strPtr(pgPath)) != 0, PathMissingError, "unable to chdir() to '%s'", strPtr(pgPath));
THROW_ON_SYS_ERROR_FMT(chdir(strZ(pgPath)) != 0, PathMissingError, "unable to chdir() to '%s'", strZ(pgPath));
// Get the new working directory
char newWorkDir[4096];
@ -339,10 +337,10 @@ walPath(const String *walFile, const String *pgPath, const String *command)
// Error if the new working directory is not equal to the original current working directory. This means that
// PostgreSQL and pgBackrest have a different idea about where the PostgreSQL data directory is located.
if (strcmp(currentWorkDir, newWorkDir) != 0)
THROW_FMT(AssertError, "working path '%s' is not the same path as '%s'", currentWorkDir, strPtr(pgPath));
THROW_FMT(AssertError, "working path '%s' is not the same path as '%s'", currentWorkDir, strZ(pgPath));
}
result = strNewFmt("%s/%s", strPtr(pgPath), strPtr(walFile));
result = strNewFmt("%s/%s", strZ(pgPath), strZ(walFile));
}
else
result = strDup(walFile);
@ -401,9 +399,11 @@ walSegmentFind(const Storage *storage, const String *archiveId, const String *wa
{
// Get a list of all WAL segments that match
StringList *list = storageListP(
storage, strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId), strPtr(strSubN(walSegment, 0, 16))),
.expression = strNewFmt("^%s%s-[0-f]{40}" COMPRESS_TYPE_REGEXP "{0,1}$", strPtr(strSubN(walSegment, 0, 24)),
walIsPartial(walSegment) ? WAL_SEGMENT_PARTIAL_EXT : ""), .nullOnMissing = true);
storage, strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(strSubN(walSegment, 0, 16))),
.expression = strNewFmt(
"^%s%s-[0-f]{40}" COMPRESS_TYPE_REGEXP "{0,1}$", strZ(strSubN(walSegment, 0, 24)),
walIsPartial(walSegment) ? WAL_SEGMENT_PARTIAL_EXT : ""),
.nullOnMissing = true);
// If there are results
if (list != NULL && strLstSize(list) > 0)
@ -415,7 +415,7 @@ walSegmentFind(const Storage *storage, const String *archiveId, const String *wa
ArchiveDuplicateError,
"duplicates found in archive for WAL segment %s: %s\n"
"HINT: are multiple primaries archiving to this stanza?",
strPtr(walSegment), strPtr(strLstJoin(strLstSort(list, sortOrderAsc), ", ")));
strZ(walSegment), strZ(strLstJoin(strLstSort(list, sortOrderAsc), ", ")));
}
// Copy file name of WAL segment found into the prior context
@ -437,7 +437,7 @@ walSegmentFind(const Storage *storage, const String *archiveId, const String *wa
"WAL segment %s was not archived before the %" PRIu64 "ms timeout\n"
"HINT: check the archive_command to ensure that all options are correct (especially --stanza).\n"
"HINT: check the PostgreSQL server log for errors.",
strPtr(walSegment), timeout);
strZ(walSegment), timeout);
}
FUNCTION_LOG_RETURN(STRING, result);
@ -465,9 +465,9 @@ walSegmentNext(const String *walSegment, size_t walSegmentSize, unsigned int pgV
MEM_CONTEXT_TEMP_BEGIN()
{
timeline = (uint32_t)strtol(strPtr(strSubN(walSegment, 0, 8)), NULL, 16);
major = (uint32_t)strtol(strPtr(strSubN(walSegment, 8, 8)), NULL, 16);
minor = (uint32_t)strtol(strPtr(strSubN(walSegment, 16, 8)), NULL, 16);
timeline = (uint32_t)strtol(strZ(strSubN(walSegment, 0, 8)), NULL, 16);
major = (uint32_t)strtol(strZ(strSubN(walSegment, 8, 8)), NULL, 16);
minor = (uint32_t)strtol(strZ(strSubN(walSegment, 16, 8)), NULL, 16);
// Increment minor and adjust major dir on overflow
minor++;

11
src/command/archive/get/file.c
View File

@ -71,14 +71,13 @@ archiveGetCheck(const String *archiveFile, CipherType cipherType, const String *
if (walSegmentFile != NULL)
{
archiveFileActual = strNewFmt("%s/%s", strPtr(strSubN(archiveFile, 0, 16)), strPtr(walSegmentFile));
archiveFileActual = strNewFmt("%s/%s", strZ(strSubN(archiveFile, 0, 16)), strZ(walSegmentFile));
break;
}
}
// Else if not a WAL segment, see if it exists in the archive dir
else if (
storageExistsP(
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId), strPtr(archiveFile))))
storageExistsP(storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(archiveFile))))
{
archiveFileActual = archiveFile;
break;
@ -91,14 +90,14 @@ archiveGetCheck(const String *archiveFile, CipherType cipherType, const String *
{
THROW_FMT(
ArchiveMismatchError, "unable to retrieve the archive id for database version '%s' and system-id '%" PRIu64 "'",
strPtr(pgVersionToStr(controlInfo.version)), controlInfo.systemId);
strZ(pgVersionToStr(controlInfo.version)), controlInfo.systemId);
}
if (archiveFileActual != NULL)
{
MEM_CONTEXT_PRIOR_BEGIN()
{
result.archiveFileActual = strNewFmt("%s/%s", strPtr(archiveId), strPtr(archiveFileActual));
result.archiveFileActual = strNewFmt("%s/%s", strZ(archiveId), strZ(archiveFileActual));
result.cipherPass = strDup(infoArchiveCipherPass(info));
}
MEM_CONTEXT_PRIOR_END();
@ -168,7 +167,7 @@ archiveGetFile(
// Copy the file
storageCopyP(
storageNewReadP(
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s", strPtr(archiveGetCheckResult.archiveFileActual)),
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s", strZ(archiveGetCheckResult.archiveFileActual)),
.compressible = compressible),
destination);

28
src/command/archive/get/get.c
View File

@ -66,7 +66,7 @@ queueNeed(const String *walSegment, bool found, uint64_t queueSize, size_t walSe
storageListP(storageSpool(), STORAGE_SPOOL_ARCHIVE_IN_STR, .errorOnMissing = true), sortOrderAsc);
// Only preserve files that match the ideal queue. error/ok files are deleted so the async process can try again.
RegExp *regExpPreserve = regExpNew(strNewFmt("^(%s)$", strPtr(strLstJoin(idealQueue, "|"))));
RegExp *regExpPreserve = regExpNew(strNewFmt("^(%s)$", strZ(strLstJoin(idealQueue, "|"))));
// Build a list of WAL segments that are being kept so we can later make a list of what is needed
StringList *keepQueue = strLstNew();
@ -82,7 +82,7 @@ queueNeed(const String *walSegment, bool found, uint64_t queueSize, size_t walSe
// Else delete it
else
storageRemoveP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(file)));
storageRemoveP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(file)));
}
// Generate a list of the WAL that are needed by removing kept WAL from the ideal queue
@ -152,20 +152,20 @@ cmdArchiveGet(void)
if (archiveAsyncStatus(archiveModeGet, walSegment, throwOnError))
{
storageRemoveP(
storageSpoolWrite(),
strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s" STATUS_EXT_OK, strPtr(walSegment)), .errorOnMissing = true);
storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s" STATUS_EXT_OK, strZ(walSegment)),
.errorOnMissing = true);
break;
}
// Check if the WAL segment is already in the queue
found = storageExistsP(storageSpool(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment)));
found = storageExistsP(storageSpool(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment)));
// If found then move the WAL segment to the destination directory
if (found)
{
// Source is the WAL segment in the spool queue
StorageRead *source = storageNewReadP(
storageSpool(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment)));
storageSpool(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment)));
// A move will be attempted but if the spool queue and the WAL path are on different file systems then a copy
// will be performed instead.
@ -266,9 +266,9 @@ cmdArchiveGet(void)
// Log whether or not the file was found
if (result == 0)
LOG_INFO_FMT("found %s in the archive", strPtr(walSegment));
LOG_INFO_FMT("found %s in the archive", strZ(walSegment));
else
LOG_INFO_FMT("unable to find %s in the archive", strPtr(walSegment));
LOG_INFO_FMT("unable to find %s in the archive", strZ(walSegment));
}
MEM_CONTEXT_TEMP_END();
@ -329,10 +329,10 @@ cmdArchiveGetAsync(void)
LOG_INFO_FMT(
"get %u WAL file(s) from archive: %s%s",
strLstSize(jobData.walSegmentList), strPtr(strLstGet(jobData.walSegmentList, 0)),
strLstSize(jobData.walSegmentList), strZ(strLstGet(jobData.walSegmentList, 0)),
strLstSize(jobData.walSegmentList) == 1 ?
"" :
strPtr(strNewFmt("...%s", strPtr(strLstGet(jobData.walSegmentList, strLstSize(jobData.walSegmentList) - 1)))));
strZ(strNewFmt("...%s", strZ(strLstGet(jobData.walSegmentList, strLstSize(jobData.walSegmentList) - 1)))));
// Create the parallel executor
ProtocolParallel *parallelExec = protocolParallelNew(
@ -359,12 +359,12 @@ cmdArchiveGetAsync(void)
// Get the archive file
if (varIntForce(protocolParallelJobResult(job)) == 0)
{
LOG_DETAIL_PID_FMT(processId, "found %s in the archive", strPtr(walSegment));
LOG_DETAIL_PID_FMT(processId, "found %s in the archive", strZ(walSegment));
}
// If it does not exist write an ok file to indicate that it was checked
else
{
LOG_DETAIL_PID_FMT(processId, "unable to find %s in the archive", strPtr(walSegment));
LOG_DETAIL_PID_FMT(processId, "unable to find %s in the archive", strZ(walSegment));
archiveAsyncStatusOkWrite(archiveModeGet, walSegment, NULL);
}
}
@ -373,8 +373,8 @@ cmdArchiveGetAsync(void)
{
LOG_WARN_PID_FMT(
processId,
"could not get %s from the archive (will be retried): [%d] %s", strPtr(walSegment),
protocolParallelJobErrorCode(job), strPtr(protocolParallelJobErrorMessage(job)));
"could not get %s from the archive (will be retried): [%d] %s", strZ(walSegment),
protocolParallelJobErrorCode(job), strZ(protocolParallelJobErrorMessage(job)));
archiveAsyncStatusErrorWrite(
archiveModeGet, walSegment, protocolParallelJobErrorCode(job), protocolParallelJobErrorMessage(job));

2
src/command/archive/get/protocol.c
View File

@ -45,7 +45,7 @@ archiveGetProtocol(const String *command, const VariantList *paramList, Protocol
server,
VARINT(
archiveGetFile(
storageSpoolWrite(), walSegment, strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment)), true,
storageSpoolWrite(), walSegment, strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment)), true,
cipherType(cfgOptionStr(cfgOptRepoCipherType)), cfgOptionStrNull(cfgOptRepoCipherPass))));
}
else

10
src/command/archive/push/file.c
View File

@ -55,7 +55,7 @@ archivePushFile(
THROW_FMT(
ArchiveMismatchError,
"WAL file '%s' version %s, system-id %" PRIu64 " do not match stanza version %s, system-id %" PRIu64,
strPtr(walSource), strPtr(pgVersionToStr(walInfo.version)), walInfo.systemId, strPtr(pgVersionToStr(pgVersion)),
strZ(walSource), strZ(pgVersionToStr(walInfo.version)), walInfo.systemId, strZ(pgVersionToStr(pgVersion)),
pgSystemId);
}
}
@ -89,16 +89,16 @@ archivePushFile(
result = strNewFmt(
"WAL file '%s' already exists in the archive with the same checksum"
"\nHINT: this is valid in some recovery scenarios but may also indicate a problem.",
strPtr(archiveFile));
strZ(archiveFile));
}
MEM_CONTEXT_PRIOR_END();
}
else
THROW_FMT(ArchiveDuplicateError, "WAL file '%s' already exists in the archive", strPtr(archiveFile));
THROW_FMT(ArchiveDuplicateError, "WAL file '%s' already exists in the archive", strZ(archiveFile));
}
// Append the checksum to the archive destination
strCatFmt(archiveDestination, "-%s", strPtr(walSegmentChecksum));
strCatFmt(archiveDestination, "-%s", strZ(walSegmentChecksum));
}
// Only copy if the file was not found in the archive
@ -130,7 +130,7 @@ archivePushFile(
storageCopyP(
source,
storageNewWriteP(
storageRepoWrite(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId), strPtr(archiveDestination)),
storageRepoWrite(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(archiveDestination)),
.compressible = compressible));
}
}

36
src/command/archive/push/push.c
View File

@ -42,7 +42,7 @@ archivePushDropWarning(const String *walFile, uint64_t queueMax)
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(
strNewFmt("dropped WAL file '%s' because archive queue exceeded %s", strPtr(walFile), strPtr(strSizeFormat(queueMax))));
strNewFmt("dropped WAL file '%s' because archive queue exceeded %s", strZ(walFile), strZ(strSizeFormat(queueMax))));
}
/***********************************************************************************************************************************
@ -63,7 +63,7 @@ archivePushDrop(const String *walPath, const StringList *const processList)
for (unsigned int processIdx = 0; processIdx < strLstSize(processList); processIdx++)
{
queueSize += storageInfoP(
storagePg(), strNewFmt("%s/%s", strPtr(walPath), strPtr(strLstGet(processList, processIdx)))).size;
storagePg(), strNewFmt("%s/%s", strZ(walPath), strZ(strLstGet(processList, processIdx)))).size;
if (queueSize > queueMax)
{
@ -96,7 +96,7 @@ archivePushReadyList(const String *walPath)
// Read the ready files from the archive_status directory
StringList *readyListRaw = strLstSort(
storageListP(
storagePg(), strNewFmt("%s/" PG_PATH_ARCHIVE_STATUS, strPtr(walPath)),
storagePg(), strNewFmt("%s/" PG_PATH_ARCHIVE_STATUS, strZ(walPath)),
.expression = STRDEF("\\" STATUS_EXT_READY "$"), .errorOnMissing = true),
sortOrderAsc);
@ -154,7 +154,7 @@ archivePushProcessList(const String *walPath)
else
{
storageRemoveP(
storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s", strPtr(statusFile)), .errorOnMissing = true);
storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s", strZ(statusFile)), .errorOnMissing = true);
}
}
@ -168,7 +168,7 @@ archivePushProcessList(const String *walPath)
{
storageRemoveP(
storageSpoolWrite(),
strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s" STATUS_EXT_OK, strPtr(strLstGet(okRemoveList, okRemoveIdx))),
strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s" STATUS_EXT_OK, strZ(strLstGet(okRemoveList, okRemoveIdx))),
.errorOnMissing = true);
}
@ -231,7 +231,7 @@ archivePushCheck(bool pgPathSet, CipherType cipherType, const String *cipherPass
ArchiveMismatchError,
"PostgreSQL version %s, system-id %" PRIu64 " do not match stanza version %s, system-id %" PRIu64
"\nHINT: are you archiving to the correct stanza?",
strPtr(pgVersionToStr(controlInfo.version)), controlInfo.systemId, strPtr(pgVersionToStr(archiveInfo.version)),
strZ(pgVersionToStr(controlInfo.version)), controlInfo.systemId, strZ(pgVersionToStr(archiveInfo.version)),
archiveInfo.systemId);
}
}
@ -336,11 +336,11 @@ cmdArchivePush(void)
{
THROW_FMT(
ArchiveTimeoutError, "unable to push WAL file '%s' to the archive asynchronously after %lg second(s)",
strPtr(archiveFile), cfgOptionDbl(cfgOptArchiveTimeout));
strZ(archiveFile), cfgOptionDbl(cfgOptArchiveTimeout));
}
// Log success
LOG_INFO_FMT("pushed WAL file '%s' to the archive asynchronously", strPtr(archiveFile));
LOG_INFO_FMT("pushed WAL file '%s' to the archive asynchronously", strZ(archiveFile));
}
else
{
@ -356,7 +356,7 @@ cmdArchivePush(void)
if (cfgOptionTest(cfgOptArchivePushQueueMax) &&
archivePushDrop(strPath(walFile), archivePushReadyList(strPath(walFile))))
{
LOG_WARN(strPtr(archivePushDropWarning(archiveFile, cfgOptionUInt64(cfgOptArchivePushQueueMax))));
LOG_WARN(strZ(archivePushDropWarning(archiveFile, cfgOptionUInt64(cfgOptArchivePushQueueMax))));
}
// Else push the file
else
@ -369,10 +369,10 @@ cmdArchivePush(void)
// If a warning was returned then log it
if (warning != NULL)
LOG_WARN(strPtr(warning));
LOG_WARN(strZ(warning));
// Log success
LOG_INFO_FMT("pushed WAL file '%s' to the archive", strPtr(archiveFile));
LOG_INFO_FMT("pushed WAL file '%s' to the archive", strZ(archiveFile));
}
}
}
@ -412,7 +412,7 @@ static ProtocolParallelJob *archivePushAsyncCallback(void *data, unsigned int cl
jobData->walFileIdx++;
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_ARCHIVE_PUSH_STR);
protocolCommandParamAdd(command, VARSTR(strNewFmt("%s/%s", strPtr(jobData->walPath), strPtr(walFile))));
protocolCommandParamAdd(command, VARSTR(strNewFmt("%s/%s", strZ(jobData->walPath), strZ(walFile))));
protocolCommandParamAdd(command, VARSTR(jobData->archiveInfo.archiveId));
protocolCommandParamAdd(command, VARUINT(jobData->archiveInfo.pgVersion));
protocolCommandParamAdd(command, VARUINT64(jobData->archiveInfo.pgSystemId));
@ -466,9 +466,9 @@ cmdArchivePushAsync(void)
THROW(AssertError, "no WAL files to process");
LOG_INFO_FMT(
"push %u WAL file(s) to archive: %s%s", strLstSize(jobData.walFileList), strPtr(strLstGet(jobData.walFileList, 0)),
"push %u WAL file(s) to archive: %s%s", strLstSize(jobData.walFileList), strZ(strLstGet(jobData.walFileList, 0)),
strLstSize(jobData.walFileList) == 1 ?
"" : strPtr(strNewFmt("...%s", strPtr(strLstGet(jobData.walFileList, strLstSize(jobData.walFileList) - 1)))));
"" : strZ(strNewFmt("...%s", strZ(strLstGet(jobData.walFileList, strLstSize(jobData.walFileList) - 1)))));
// Drop files if queue max has been exceeded
if (cfgOptionTest(cfgOptArchivePushQueueMax) && archivePushDrop(jobData.walPath, jobData.walFileList))
@ -479,7 +479,7 @@ cmdArchivePushAsync(void)
const String *warning = archivePushDropWarning(walFile, cfgOptionUInt64(cfgOptArchivePushQueueMax));
archiveAsyncStatusOkWrite(archiveModePush, walFile, warning);
LOG_WARN(strPtr(warning));
LOG_WARN(strZ(warning));
}
}
// Else continue processing
@ -519,7 +519,7 @@ cmdArchivePushAsync(void)
// The job was successful
if (protocolParallelJobErrorCode(job) == 0)
{
LOG_DETAIL_PID_FMT(processId, "pushed WAL file '%s' to the archive", strPtr(walFile));
LOG_DETAIL_PID_FMT(processId, "pushed WAL file '%s' to the archive", strZ(walFile));
archiveAsyncStatusOkWrite(archiveModePush, walFile, varStr(protocolParallelJobResult(job)));
}
// Else the job errored
@ -527,8 +527,8 @@ cmdArchivePushAsync(void)
{
LOG_WARN_PID_FMT(
processId,
"could not push WAL file '%s' to the archive (will be retried): [%d] %s", strPtr(walFile),
protocolParallelJobErrorCode(job), strPtr(protocolParallelJobErrorMessage(job)));
"could not push WAL file '%s' to the archive (will be retried): [%d] %s", strZ(walFile),
protocolParallelJobErrorCode(job), strZ(protocolParallelJobErrorMessage(job)));
archiveAsyncStatusErrorWrite(
archiveModePush, walFile, protocolParallelJobErrorCode(job), protocolParallelJobErrorMessage(job));

177
src/command/backup/backup.c
View File

@ -114,11 +114,11 @@ backupLabelCreate(BackupType type, const String *backupLabelPrior, time_t timest
const StringList *historyList = strLstSort(
storageListP(
storageRepo(),
strNewFmt(STORAGE_REPO_BACKUP "/" BACKUP_PATH_HISTORY "/%s", strPtr(strLstGet(historyYearList, 0))),
strNewFmt(STORAGE_REPO_BACKUP "/" BACKUP_PATH_HISTORY "/%s", strZ(strLstGet(historyYearList, 0))),
.expression = strNewFmt(
"%s\\.manifest\\.%s$",
strPtr(backupRegExpP(.full = true, .differential = true, .incremental = true, .noAnchorEnd = true)),
strPtr(compressTypeStr(compressTypeGz)))),
strZ(backupRegExpP(.full = true, .differential = true, .incremental = true, .noAnchorEnd = true)),
strZ(compressTypeStr(compressTypeGz)))),
sortOrderDesc);
if (strLstSize(historyList) > 0)
@ -147,7 +147,7 @@ backupLabelCreate(BackupType type, const String *backupLabelPrior, time_t timest
"new backup label '%s' is not later than latest backup label '%s'\n"
"HINT: has the timezone changed?\n"
"HINT: is there clock skew?",
strPtr(result), strPtr(backupLabelLatest));
strZ(result), strZ(backupLabelLatest));
}
// If adding a second worked then sleep the remainder of the current second so we don't start early
@ -211,7 +211,7 @@ backupInit(const InfoBackup *infoBackup)
{
THROW_FMT(
ConfigError, "option '" CFGOPT_BACKUP_STANDBY "' not valid for " PG_NAME " < %s",
strPtr(pgVersionToStr(PG_VERSION_BACKUP_STANDBY)));
strZ(pgVersionToStr(PG_VERSION_BACKUP_STANDBY)));
}
// Don't allow backup from standby when offline
@ -258,8 +258,8 @@ backupInit(const InfoBackup *infoBackup)
THROW_FMT(
BackupMismatchError,
PG_NAME " version %s, system-id %" PRIu64 " do not match stanza version %s, system-id %" PRIu64 "\n"
"HINT: is this the correct stanza?", strPtr(pgVersionToStr(pgControl.version)), pgControl.systemId,
strPtr(pgVersionToStr(infoPg.version)), infoPg.systemId);
"HINT: is this the correct stanza?", strZ(pgVersionToStr(pgControl.version)), pgControl.systemId,
strZ(pgVersionToStr(infoPg.version)), infoPg.systemId);
}
// Only allow stop auto in PostgreSQL >= 9.3 and <= 9.5
@ -382,21 +382,21 @@ backupBuildIncrPrior(const InfoBackup *infoBackup)
if (backupLabelPrior != NULL)
{
result = manifestLoadFile(
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabelPrior)),
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabelPrior)),
cipherType(cfgOptionStr(cfgOptRepoCipherType)), infoPgCipherPass(infoBackupPg(infoBackup)));
const ManifestData *manifestPriorData = manifestData(result);
LOG_INFO_FMT(
"last backup label = %s, version = %s", strPtr(manifestData(result)->backupLabel),
strPtr(manifestData(result)->backrestVersion));
"last backup label = %s, version = %s", strZ(manifestData(result)->backupLabel),
strZ(manifestData(result)->backrestVersion));
// Warn if compress-type option changed
if (compressTypeEnum(cfgOptionStr(cfgOptCompressType)) != manifestPriorData->backupOptionCompressType)
{
LOG_WARN_FMT(
"%s backup cannot alter " CFGOPT_COMPRESS_TYPE " option to '%s', reset to value in %s",
strPtr(cfgOptionStr(cfgOptType)),
strPtr(compressTypeStr(compressTypeEnum(cfgOptionStr(cfgOptCompressType)))), strPtr(backupLabelPrior));
strZ(cfgOptionStr(cfgOptType)), strZ(compressTypeStr(compressTypeEnum(cfgOptionStr(cfgOptCompressType)))),
strZ(backupLabelPrior));
// Set the compression type back to whatever was in the prior backup. This is not strictly needed since we
// could store compression type on a per file basis, but it seems simplest and safest for now.
@ -420,8 +420,8 @@ backupBuildIncrPrior(const InfoBackup *infoBackup)
{
LOG_WARN_FMT(
"%s backup cannot alter hardlink option to '%s', reset to value in %s",
strPtr(cfgOptionStr(cfgOptType)), cvtBoolToConstZ(cfgOptionBool(cfgOptRepoHardlink)),
strPtr(backupLabelPrior));
strZ(cfgOptionStr(cfgOptType)), cvtBoolToConstZ(cfgOptionBool(cfgOptRepoHardlink)),
strZ(backupLabelPrior));
cfgOptionSet(cfgOptRepoHardlink, cfgSourceParam, VARBOOL(manifestPriorData->backupOptionHardLink));
}
@ -442,8 +442,8 @@ backupBuildIncrPrior(const InfoBackup *infoBackup)
{
LOG_WARN_FMT(
"%s backup cannot alter '" CFGOPT_CHECKSUM_PAGE "' option to '%s', reset to '%s' from %s",
strPtr(cfgOptionStr(cfgOptType)), cvtBoolToConstZ(cfgOptionBool(cfgOptChecksumPage)),
cvtBoolToConstZ(checksumPagePrior), strPtr(manifestData(result)->backupLabel));
strZ(cfgOptionStr(cfgOptType)), cvtBoolToConstZ(cfgOptionBool(cfgOptChecksumPage)),
cvtBoolToConstZ(checksumPagePrior), strZ(manifestData(result)->backupLabel));
}
cfgOptionSet(cfgOptChecksumPage, cfgSourceParam, VARBOOL(checksumPagePrior));
@ -453,7 +453,7 @@ backupBuildIncrPrior(const InfoBackup *infoBackup)
}
else
{
LOG_WARN_FMT("no prior backup exists, %s backup has been changed to full", strPtr(cfgOptionStr(cfgOptType)));
LOG_WARN_FMT("no prior backup exists, %s backup has been changed to full", strZ(cfgOptionStr(cfgOptType)));
cfgOptionSet(cfgOptType, cfgSourceParam, VARSTR(backupTypeStr(backupTypeFull)));
}
}
@ -544,10 +544,10 @@ void backupResumeCallback(void *data, const StorageInfo *info)
// Build the name used to lookup files in the manifest
const String *manifestName = resumeData->manifestParentName != NULL ?
strNewFmt("%s/%s", strPtr(resumeData->manifestParentName), strPtr(info->name)) : info->name;
strNewFmt("%s/%s", strZ(resumeData->manifestParentName), strZ(info->name)) : info->name;
// Build the backup path used to remove files/links/paths that are invalid
const String *backupPath = strNewFmt("%s/%s", strPtr(resumeData->backupPath), strPtr(info->name));
const String *backupPath = strNewFmt("%s/%s", strZ(resumeData->backupPath), strZ(info->name));
// Process file types
switch (info->type)
@ -559,7 +559,7 @@ void backupResumeCallback(void *data, const StorageInfo *info)
// If the path was not found in the new manifest then remove it
if (manifestPathFindDefault(resumeData->manifest, manifestName, NULL) == NULL)
{
LOG_DETAIL_FMT("remove path '%s' from resumed backup", strPtr(storagePathP(storageRepo(), backupPath)));
LOG_DETAIL_FMT("remove path '%s' from resumed backup", strZ(storagePathP(storageRepo(), backupPath)));
storagePathRemoveP(storageRepoWrite(), backupPath, .recurse = true);
}
// Else recurse into the path
@ -622,7 +622,7 @@ void backupResumeCallback(void *data, const StorageInfo *info)
if (removeReason != NULL)
{
LOG_DETAIL_FMT(
"remove file '%s' from resumed backup (%s)", strPtr(storagePathP(storageRepo(), backupPath)), removeReason);
"remove file '%s' from resumed backup (%s)", strZ(storagePathP(storageRepo(), backupPath)), removeReason);
storageRemoveP(storageRepoWrite(), backupPath);
}
@ -642,7 +642,7 @@ void backupResumeCallback(void *data, const StorageInfo *info)
// -------------------------------------------------------------------------------------------------------------------------
case storageTypeSpecial:
{
LOG_WARN_FMT("remove special file '%s' from resumed backup", strPtr(storagePathP(storageRepo(), backupPath)));
LOG_WARN_FMT("remove special file '%s' from resumed backup", strZ(storagePathP(storageRepo(), backupPath)));
storageRemoveP(storageRepoWrite(), backupPath);
break;
}
@ -676,10 +676,10 @@ backupResumeFind(const Manifest *manifest, const String *cipherPassBackup)
if (strLstSize(backupList) > 0)
{
const String *backupLabel = strLstGet(backupList, 0);
const String *manifestFile = strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel));
const String *manifestFile = strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel));
// Resumable backups have a copy of the manifest but no main
if (storageExistsP(storageRepo(), strNewFmt("%s" INFO_COPY_EXT, strPtr(manifestFile))) &&
if (storageExistsP(storageRepo(), strNewFmt("%s" INFO_COPY_EXT, strZ(manifestFile))) &&
!storageExistsP(storageRepo(), manifestFile))
{
bool usable = false;
@ -690,7 +690,7 @@ backupResumeFind(const Manifest *manifest, const String *cipherPassBackup)
// then the backup will be considered unusable and a resume will not be attempted.
if (cfgOptionBool(cfgOptResume))
{
reason = strNewFmt("unable to read %s" INFO_COPY_EXT, strPtr(manifestFile));
reason = strNewFmt("unable to read %s" INFO_COPY_EXT, strZ(manifestFile));
TRY_BEGIN()
{
@ -704,31 +704,31 @@ backupResumeFind(const Manifest *manifest, const String *cipherPassBackup)
{
reason = strNewFmt(
"new " PROJECT_NAME " version '%s' does not match resumable " PROJECT_NAME " version '%s'",
strPtr(manifestData(manifest)->backrestVersion), strPtr(manifestResumeData->backrestVersion));
strZ(manifestData(manifest)->backrestVersion), strZ(manifestResumeData->backrestVersion));
}
// Check backup type because new backup label must be the same type as resume backup label
else if (manifestResumeData->backupType != backupType(cfgOptionStr(cfgOptType)))
{
reason = strNewFmt(
"new backup type '%s' does not match resumable backup type '%s'", strPtr(cfgOptionStr(cfgOptType)),
strPtr(backupTypeStr(manifestResumeData->backupType)));
"new backup type '%s' does not match resumable backup type '%s'", strZ(cfgOptionStr(cfgOptType)),
strZ(backupTypeStr(manifestResumeData->backupType)));
}
// Check prior backup label ??? Do we really care about the prior backup label?
else if (!strEq(manifestResumeData->backupLabelPrior, manifestData(manifest)->backupLabelPrior))
{
reason = strNewFmt(
"new prior backup label '%s' does not match resumable prior backup label '%s'",
manifestResumeData->backupLabelPrior ? strPtr(manifestResumeData->backupLabelPrior) : "<undef>",
manifestResumeData->backupLabelPrior ? strZ(manifestResumeData->backupLabelPrior) : "<undef>",
manifestData(manifest)->backupLabelPrior ?
strPtr(manifestData(manifest)->backupLabelPrior) : "<undef>");
strZ(manifestData(manifest)->backupLabelPrior) : "<undef>");
}
// Check compression. Compression can't be changed between backups so resume won't work either.
else if (manifestResumeData->backupOptionCompressType != compressTypeEnum(cfgOptionStr(cfgOptCompressType)))
{
reason = strNewFmt(
"new compression '%s' does not match resumable compression '%s'",
strPtr(compressTypeStr(compressTypeEnum(cfgOptionStr(cfgOptCompressType)))),
strPtr(compressTypeStr(manifestResumeData->backupOptionCompressType)));
strZ(compressTypeStr(compressTypeEnum(cfgOptionStr(cfgOptCompressType)))),
strZ(compressTypeStr(manifestResumeData->backupOptionCompressType)));
}
else
usable = true;
@ -747,10 +747,10 @@ backupResumeFind(const Manifest *manifest, const String *cipherPassBackup)
// Else warn and remove the unusable backup
else
{
LOG_WARN_FMT("backup '%s' cannot be resumed: %s", strPtr(backupLabel), strPtr(reason));
LOG_WARN_FMT("backup '%s' cannot be resumed: %s", strZ(backupLabel), strZ(reason));
storagePathRemoveP(
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s", strPtr(backupLabel)), .recurse = true);
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s", strZ(backupLabel)), .recurse = true);
}
}
}
@ -787,7 +787,7 @@ backupResume(Manifest *manifest, const String *cipherPassBackup)
LOG_WARN_FMT(
"resumable backup %s of same type exists -- remove invalid files and resume",
strPtr(manifestData(manifest)->backupLabel));
strZ(manifestData(manifest)->backupLabel));
// If resuming a full backup then copy cipher subpass since it was used to encrypt the resumable files
if (manifestData(manifest)->backupType == backupTypeFull)
@ -800,7 +800,7 @@ backupResume(Manifest *manifest, const String *cipherPassBackup)
.manifestResume = manifestResume,
.compressType = compressTypeEnum(cfgOptionStr(cfgOptCompressType)),
.delta = cfgOptionBool(cfgOptDelta),
.backupPath = strNewFmt(STORAGE_REPO_BACKUP "/%s", strPtr(manifestData(manifest)->backupLabel)),
.backupPath = strNewFmt(STORAGE_REPO_BACKUP "/%s", strZ(manifestData(manifest)->backupLabel)),
};
storageInfoListP(storageRepo(), resumeData.backupPath, backupResumeCallback, &resumeData, .sortOrder = sortOrderAsc);
@ -884,14 +884,14 @@ backupStart(BackupData *backupData)
}
MEM_CONTEXT_PRIOR_END();
LOG_INFO_FMT("backup start archive = %s, lsn = %s", strPtr(result.walSegmentName), strPtr(result.lsn));
LOG_INFO_FMT("backup start archive = %s, lsn = %s", strZ(result.walSegmentName), strZ(result.lsn));
// Wait for replay on the standby to catch up
if (cfgOptionBool(cfgOptBackupStandby))
{
LOG_INFO_FMT("wait for replay on the standby to reach %s", strPtr(result.lsn));
LOG_INFO_FMT("wait for replay on the standby to reach %s", strZ(result.lsn));
dbReplayWait(backupData->dbStandby, result.lsn, (TimeMSec)(cfgOptionDbl(cfgOptArchiveTimeout) * MSEC_PER_SEC));
LOG_INFO_FMT("replay on the standby reached %s", strPtr(result.lsn));
LOG_INFO_FMT("replay on the standby reached %s", strZ(result.lsn));
// The standby db object won't be used anymore so free it
dbFree(backupData->dbStandby);
@ -927,14 +927,14 @@ backupFilePut(BackupData *backupData, Manifest *manifest, const String *name, ti
MEM_CONTEXT_TEMP_BEGIN()
{
// Create file
const String *manifestName = strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strPtr(name));
const String *manifestName = strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strZ(name));
CompressType compressType = compressTypeEnum(cfgOptionStr(cfgOptCompressType));
StorageWrite *write = storageNewWriteP(
storageRepoWrite(),
strNewFmt(
STORAGE_REPO_BACKUP "/%s/%s%s", strPtr(manifestData(manifest)->backupLabel), strPtr(manifestName),
strPtr(compressExtStr(compressType))),
STORAGE_REPO_BACKUP "/%s/%s%s", strZ(manifestData(manifest)->backupLabel), strZ(manifestName),
strZ(compressExtStr(compressType))),
.compressible = true);
IoFilterGroup *filterGroup = ioWriteFilterGroup(storageWriteIo(write));
@ -976,12 +976,12 @@ backupFilePut(BackupData *backupData, Manifest *manifest, const String *name, ti
};
memcpy(
file.checksumSha1, strPtr(varStr(ioFilterGroupResult(filterGroup, CRYPTO_HASH_FILTER_TYPE_STR))),
file.checksumSha1, strZ(varStr(ioFilterGroupResult(filterGroup, CRYPTO_HASH_FILTER_TYPE_STR))),
HASH_TYPE_SHA1_SIZE_HEX + 1);
manifestFileAdd(manifest, &file);
LOG_DETAIL_FMT("wrote '%s' file returned from pg_stop_backup()", strPtr(name));
LOG_DETAIL_FMT("wrote '%s' file returned from pg_stop_backup()", strZ(name));
}
MEM_CONTEXT_TEMP_END();
}
@ -1031,7 +1031,7 @@ backupStop(BackupData *backupData, Manifest *manifest)
}
MEM_CONTEXT_PRIOR_END();
LOG_INFO_FMT("backup stop archive = %s, lsn = %s", strPtr(result.walSegmentName), strPtr(result.lsn));
LOG_INFO_FMT("backup stop archive = %s, lsn = %s", strZ(result.walSegmentName), strZ(result.lsn));
// Save files returned by stop backup
backupFilePut(backupData, manifest, STRDEF(PG_FILE_BACKUPLABEL), result.timestamp, dbBackupStopResult.backupLabel);
@ -1087,32 +1087,32 @@ backupJobResult(
sizeCopied += copySize;
// Create log file name
const String *fileLog = host == NULL ? fileName : strNewFmt("%s:%s", strPtr(host), strPtr(fileName));
const String *fileLog = host == NULL ? fileName : strNewFmt("%s:%s", strZ(host), strZ(fileName));
// Format log strings
const String *const logProgress =
strNewFmt(
"%s, %" PRIu64 "%%", strPtr(strSizeFormat(copySize)), sizeTotal == 0 ? 100 : sizeCopied * 100 / sizeTotal);
const String *const logChecksum = copySize != 0 ? strNewFmt(" checksum %s", strPtr(copyChecksum)) : EMPTY_STR;
"%s, %" PRIu64 "%%", strZ(strSizeFormat(copySize)), sizeTotal == 0 ? 100 : sizeCopied * 100 / sizeTotal);
const String *const logChecksum = copySize != 0 ? strNewFmt(" checksum %s", strZ(copyChecksum)) : EMPTY_STR;
// If the file is in a prior backup and nothing changed, just log it
if (copyResult == backupCopyResultNoOp)
{
LOG_DETAIL_PID_FMT(
processId, "match file from prior backup %s (%s)%s", strPtr(fileLog), strPtr(logProgress), strPtr(logChecksum));
processId, "match file from prior backup %s (%s)%s", strZ(fileLog), strZ(logProgress), strZ(logChecksum));
}
// Else if the repo matched the expect checksum, just log it
else if (copyResult == backupCopyResultChecksum)
{
LOG_DETAIL_PID_FMT(
processId, "checksum resumed file %s (%s)%s", strPtr(fileLog), strPtr(logProgress), strPtr(logChecksum));
processId, "checksum resumed file %s (%s)%s", strZ(fileLog), strZ(logProgress), strZ(logChecksum));
}
// Else if the file was removed during backup add it to the list of files to be removed from the manifest when the
// backup is complete. It can't be removed right now because that will invalidate the pointers that are being used for
// processing.
else if (copyResult == backupCopyResultSkip)
{
LOG_DETAIL_PID_FMT(processId, "skip file removed by database %s", strPtr(fileLog));
LOG_DETAIL_PID_FMT(processId, "skip file removed by database %s", strZ(fileLog));
strLstAdd(fileRemove, file->name);
}
// Else file was copied so update manifest
@ -1128,11 +1128,10 @@ backupJobResult(
" continue but this may be an issue unless the resumed backup path in the repository is known to be"
" corrupted.\n"
"NOTE: this does not indicate a problem with the PostgreSQL page checksums.",
strPtr(file->name), file->checksumSha1);
strZ(file->name), file->checksumSha1);
}
LOG_INFO_PID_FMT(
processId, "backup file %s (%s)%s", strPtr(fileLog), strPtr(logProgress), strPtr(logChecksum));
LOG_INFO_PID_FMT(processId, "backup file %s (%s)%s", strZ(fileLog), strZ(logProgress), strZ(logChecksum));
// If the file had page checksums calculated during the copy
ASSERT((!file->checksumPage && checksumPageResult == NULL) || (file->checksumPage && checksumPageResult != NULL));
@ -1154,7 +1153,7 @@ backupJobResult(
// ??? Update formatting after migration
LOG_WARN_FMT(
"page misalignment in file %s: file size %" PRIu64 " is not divisible by page size %u",
strPtr(fileLog), copySize, PG_PAGE_SIZE_DEFAULT);
strZ(fileLog), copySize, PG_PAGE_SIZE_DEFAULT);
}
else
{
@ -1199,15 +1198,15 @@ backupJobResult(
// ??? Update formatting after migration
LOG_WARN_FMT(
"invalid page checksum%s found in file %s at page%s %s", strPtr(plural), strPtr(fileLog),
strPtr(plural), strPtr(error));
"invalid page checksum%s found in file %s at page%s %s", strZ(plural), strZ(fileLog), strZ(plural),
strZ(error));
}
}
}
// Update file info and remove any reference to the file's existence in a prior backup
manifestFileUpdate(
manifest, file->name, copySize, repoSize, strPtr(copyChecksum), VARSTR(NULL), file->checksumPage,
manifest, file->name, copySize, repoSize, strZ(copyChecksum), VARSTR(NULL), file->checksumPage,
checksumPageError, checksumPageErrorList);
}
}
@ -1218,7 +1217,7 @@ backupJobResult(
}
// Else the job errored
else
THROW_CODE(protocolParallelJobErrorCode(job), strPtr(protocolParallelJobErrorMessage(job)));
THROW_CODE(protocolParallelJobErrorCode(job), strZ(protocolParallelJobErrorMessage(job)));
FUNCTION_LOG_RETURN(UINT64, sizeCopied);
}
@ -1243,7 +1242,7 @@ backupManifestSaveCopy(Manifest *const manifest, const String *cipherPassBackup)
storageNewWriteP(
storageRepoWrite(),
strNewFmt(
STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strPtr(manifestData(manifest)->backupLabel))));
STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strZ(manifestData(manifest)->backupLabel))));
// Add encryption filter if required
cipherBlockFilterGroupAdd(
@ -1309,7 +1308,7 @@ backupProcessQueue(Manifest *manifest, List **queueList)
const ManifestTarget *target = manifestTarget(manifest, targetIdx);
if (target->tablespaceId != 0)
strLstAdd(targetList, strNewFmt("%s/", strPtr(target->name)));
strLstAdd(targetList, strNewFmt("%s/", strZ(target->name)));
}
// Generate the processing queues (there is always at least one)
@ -1527,7 +1526,7 @@ backupProcess(BackupData *backupData, Manifest *manifest, const String *lsnStart
// Get backup info
const BackupType backupType = manifestData(manifest)->backupType;
const String *const backupLabel = manifestData(manifest)->backupLabel;
const String *const backupPathExp = strNewFmt(STORAGE_REPO_BACKUP "/%s", strPtr(backupLabel));
const String *const backupPathExp = strNewFmt(STORAGE_REPO_BACKUP "/%s", strZ(backupLabel));
bool hardLink = cfgOptionBool(cfgOptRepoHardlink) && storageFeature(storageRepoWrite(), storageFeatureHardLink);
bool backupStandby = cfgOptionBool(cfgOptBackupStandby);
@ -1543,7 +1542,7 @@ backupProcess(BackupData *backupData, Manifest *manifest, const String *lsnStart
{
storagePathCreateP(
storageRepoWrite(),
strNewFmt("%s/%s", strPtr(backupPathExp), strPtr(manifestPath(manifest, pathIdx)->name)));
strNewFmt("%s/%s", strZ(backupPathExp), strZ(manifestPath(manifest, pathIdx)->name)));
}
}
@ -1558,13 +1557,13 @@ backupProcess(BackupData *backupData, Manifest *manifest, const String *lsnStart
{
const String *const link = storagePathP(
storageRepo(),
strNewFmt("%s/" MANIFEST_TARGET_PGDATA "/%s", strPtr(backupPathExp), strPtr(target->name)));
strNewFmt("%s/" MANIFEST_TARGET_PGDATA "/%s", strZ(backupPathExp), strZ(target->name)));
const String *const linkDestination = strNewFmt(
"../../" MANIFEST_TARGET_PGTBLSPC "/%u", target->tablespaceId);
THROW_ON_SYS_ERROR_FMT(
symlink(strPtr(linkDestination), strPtr(link)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strPtr(link), strPtr(linkDestination));
symlink(strZ(linkDestination), strZ(link)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strZ(link), strZ(linkDestination));
}
}
}
@ -1660,7 +1659,7 @@ backupProcess(BackupData *backupData, Manifest *manifest, const String *lsnStart
manifestFileRemove(manifest, strLstGet(fileRemove, fileRemoveIdx));
// Log references or create hardlinks for all files
const char *const compressExt = strPtr(compressExtStr(jobData.compressType));
const char *const compressExt = strZ(compressExtStr(jobData.compressType));
for (unsigned int fileIdx = 0; fileIdx < manifestFileTotal(manifest); fileIdx++)
{
@ -1673,22 +1672,22 @@ backupProcess(BackupData *backupData, Manifest *manifest, const String *lsnStart
// If hardlinking is enabled then create a hardlink for files that have not changed since the last backup
if (hardLink)
{
LOG_DETAIL_FMT("hardlink %s to %s", strPtr(file->name), strPtr(file->reference));
LOG_DETAIL_FMT("hardlink %s to %s", strZ(file->name), strZ(file->reference));
const String *const linkName = storagePathP(
storageRepo(), strNewFmt("%s/%s%s", strPtr(backupPathExp), strPtr(file->name), compressExt));
storageRepo(), strNewFmt("%s/%s%s", strZ(backupPathExp), strZ(file->name), compressExt));
const String *const linkDestination = storagePathP(
storageRepo(),
strNewFmt(STORAGE_REPO_BACKUP "/%s/%s%s", strPtr(file->reference), strPtr(file->name), compressExt));
strNewFmt(STORAGE_REPO_BACKUP "/%s/%s%s", strZ(file->reference), strZ(file->name), compressExt));
THROW_ON_SYS_ERROR_FMT(
link(strPtr(linkDestination), strPtr(linkName)) == -1, FileOpenError,
"unable to create hardlink '%s' to '%s'", strPtr(linkName), strPtr(linkDestination));
link(strZ(linkDestination), strZ(linkName)) == -1, FileOpenError,
"unable to create hardlink '%s' to '%s'", strZ(linkName), strZ(linkDestination));
}
// Else log the reference. With delta, it is possible that references may have been removed if a file needed to be
// recopied.
else
LOG_DETAIL_FMT("reference %s to %s", strPtr(file->name), strPtr(file->reference));
LOG_DETAIL_FMT("reference %s to %s", strZ(file->name), strZ(file->reference));
}
}
@ -1697,14 +1696,14 @@ backupProcess(BackupData *backupData, Manifest *manifest, const String *lsnStart
{
for (unsigned int pathIdx = 0; pathIdx < manifestPathTotal(manifest); pathIdx++)
{
const String *const path = strNewFmt("%s/%s", strPtr(backupPathExp), strPtr(manifestPath(manifest, pathIdx)->name));
const String *const path = strNewFmt("%s/%s", strZ(backupPathExp), strZ(manifestPath(manifest, pathIdx)->name));
if (backupType == backupTypeFull || hardLink || storagePathExistsP(storageRepo(), path))
storagePathSyncP(storageRepoWrite(), path);
}
}
LOG_INFO_FMT("%s backup size = %s", strPtr(backupTypeStr(backupType)), strPtr(strSizeFormat(sizeTotal)));
LOG_INFO_FMT("%s backup size = %s", strZ(backupTypeStr(backupType)), strZ(strSizeFormat(sizeTotal)));
}
MEM_CONTEXT_TEMP_END();
@ -1732,13 +1731,13 @@ backupArchiveCheckCopy(Manifest *manifest, unsigned int walSegmentSize, const St
{
MEM_CONTEXT_TEMP_BEGIN()
{
unsigned int timeline = cvtZToUIntBase(strPtr(strSubN(manifestData(manifest)->archiveStart, 0, 8)), 16);
unsigned int timeline = cvtZToUIntBase(strZ(strSubN(manifestData(manifest)->archiveStart, 0, 8)), 16);
uint64_t lsnStart = pgLsnFromStr(manifestData(manifest)->lsnStart);
uint64_t lsnStop = pgLsnFromStr(manifestData(manifest)->lsnStop);
LOG_INFO_FMT(
"check archive for segment(s) %s:%s", strPtr(pgLsnToWalSegment(timeline, lsnStart, walSegmentSize)),
strPtr(pgLsnToWalSegment(timeline, lsnStop, walSegmentSize)));
"check archive for segment(s) %s:%s", strZ(pgLsnToWalSegment(timeline, lsnStart, walSegmentSize)),
strZ(pgLsnToWalSegment(timeline, lsnStop, walSegmentSize)));
// Save the backup manifest before getting archive logs in case of failure
backupManifestSaveCopy(manifest, cipherPassBackup);
@ -1771,7 +1770,7 @@ backupArchiveCheckCopy(Manifest *manifest, unsigned int walSegmentSize, const St
// Open the archive file
StorageRead *read = storageNewReadP(
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId), strPtr(archiveFile)));
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(archiveFile)));
IoFilterGroup *filterGroup = ioReadFilterGroup(storageReadIo(read));
// Decrypt with archive key if encrypted
@ -1799,15 +1798,15 @@ backupArchiveCheckCopy(Manifest *manifest, unsigned int walSegmentSize, const St
// Copy the file
const String *manifestName = strNewFmt(
MANIFEST_TARGET_PGDATA "/%s/%s", strPtr(pgWalPath(manifestData(manifest)->pgVersion)), strPtr(walSegment));
MANIFEST_TARGET_PGDATA "/%s/%s", strZ(pgWalPath(manifestData(manifest)->pgVersion)), strZ(walSegment));
storageCopyP(
read,
storageNewWriteP(
storageRepoWrite(),
strNewFmt(
STORAGE_REPO_BACKUP "/%s/%s%s", strPtr(manifestData(manifest)->backupLabel), strPtr(manifestName),
strPtr(compressExtStr(compressTypeEnum(cfgOptionStr(cfgOptCompressType)))))));
STORAGE_REPO_BACKUP "/%s/%s%s", strZ(manifestData(manifest)->backupLabel), strZ(manifestName),
strZ(compressExtStr(compressTypeEnum(cfgOptionStr(cfgOptCompressType)))))));
// Add to manifest
ManifestFile file =
@ -1822,7 +1821,7 @@ backupArchiveCheckCopy(Manifest *manifest, unsigned int walSegmentSize, const St
.timestamp = manifestData(manifest)->backupTimestampStop,
};
memcpy(file.checksumSha1, strPtr(strSubN(archiveFile, 25, 40)), HASH_TYPE_SHA1_SIZE_HEX + 1);
memcpy(file.checksumSha1, strZ(strSubN(archiveFile, 25, 40)), HASH_TYPE_SHA1_SIZE_HEX + 1);
manifestFileAdd(manifest, &file);
}
@ -1859,16 +1858,16 @@ backupComplete(InfoBackup *const infoBackup, Manifest *const manifest)
storageCopy(
storageNewReadP(
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strPtr(backupLabel))),
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strZ(backupLabel))),
storageNewWriteP(
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel))));
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel))));
// Copy a compressed version of the manifest to history. If the repo is encrypted then the passphrase to open the manifest
// is required. We can't just do a straight copy since the destination needs to be compressed and that must happen before
// encryption in order to be efficient. Compression will always be gz for compatibility and since it is always available.
// -------------------------------------------------------------------------------------------------------------------------
StorageRead *manifestRead = storageNewReadP(
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel)));
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel)));
cipherBlockFilterGroupAdd(
ioReadFilterGroup(storageReadIo(manifestRead)), cipherType(cfgOptionStr(cfgOptRepoCipherType)), cipherModeDecrypt,
@ -1877,8 +1876,8 @@ backupComplete(InfoBackup *const infoBackup, Manifest *const manifest)
StorageWrite *manifestWrite = storageNewWriteP(
storageRepoWrite(),
strNewFmt(
STORAGE_REPO_BACKUP "/" BACKUP_PATH_HISTORY "/%s/%s.manifest%s", strPtr(strSubN(backupLabel, 0, 4)),
strPtr(backupLabel), strPtr(compressExtStr(compressTypeGz))));
STORAGE_REPO_BACKUP "/" BACKUP_PATH_HISTORY "/%s/%s.manifest%s", strZ(strSubN(backupLabel, 0, 4)),
strZ(backupLabel), strZ(compressExtStr(compressTypeGz))));
ioFilterGroupAdd(ioWriteFilterGroup(storageWriteIo(manifestWrite)), compressFilter(compressTypeGz, 9));
@ -1997,7 +1996,7 @@ cmdBackup(void)
backupArchiveCheckCopy(manifest, backupData->walSegmentSize, cipherPassBackup);
// Complete the backup
LOG_INFO_FMT("new backup label = %s", strPtr(manifestData(manifest)->backupLabel));
LOG_INFO_FMT("new backup label = %s", strZ(manifestData(manifest)->backupLabel));
backupComplete(infoBackup, manifest);
}
MEM_CONTEXT_TEMP_END();

6
src/command/backup/common.c
View File

@ -104,7 +104,7 @@ backupType(const String *type)
else if (strEq(type, BACKUP_TYPE_INCR_STR))
result = backupTypeIncr;
else
THROW_FMT(AssertError, "invalid backup type '%s'", strPtr(type));
THROW_FMT(AssertError, "invalid backup type '%s'", strZ(type));
FUNCTION_TEST_RETURN(result);
}
@ -164,8 +164,8 @@ backupLinkLatest(const String *backupLabel)
if (storageFeature(storageRepoWrite(), storageFeatureSymLink))
{
THROW_ON_SYS_ERROR_FMT(
symlink(strPtr(backupLabel), strPtr(latestLink)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strPtr(latestLink), strPtr(backupLabel));
symlink(strZ(backupLabel), strZ(latestLink)) == -1, FileOpenError, "unable to create symlink '%s' to '%s'",
strZ(latestLink), strZ(backupLabel));
}
// Sync backup path if required

4
src/command/backup/file.c
View File

@ -30,7 +30,7 @@ segmentNumber(const String *pgFile)
FUNCTION_TEST_END();
// Determine which segment number this is by checking for a numeric extension. No extension means segment 0.
FUNCTION_TEST_RETURN(regExpMatchOne(STRDEF("\\.[0-9]+$"), pgFile) ? cvtZToUInt(strrchr(strPtr(pgFile), '.') + 1) : 0);
FUNCTION_TEST_RETURN(regExpMatchOne(STRDEF("\\.[0-9]+$"), pgFile) ? cvtZToUInt(strrchr(strZ(pgFile), '.') + 1) : 0);
}
/**********************************************************************************************************************************/
@ -71,7 +71,7 @@ backupFile(
{
// Generate complete repo path and add compression extension if needed
const String *repoPathFile = strNewFmt(
STORAGE_REPO_BACKUP "/%s/%s%s", strPtr(backupLabel), strPtr(repoFile), strPtr(compressExtStr(repoFileCompressType)));
STORAGE_REPO_BACKUP "/%s/%s%s", strZ(backupLabel), strZ(repoFile), strZ(compressExtStr(repoFileCompressType)));
// If checksum is defined then the file needs to be checked. If delta option then check the DB and possibly the repo, else
// just check the repo.

5
src/command/check/check.c
View File

@ -136,9 +136,8 @@ checkPrimary(const DbGetResult dbGroup)
const String *walSegmentFile = walSegmentFind(storageRepo(), archiveId, walSegment, archiveTimeout);
LOG_INFO_FMT(
"WAL segment %s successfully archived to '%s'", strPtr(walSegment),
strPtr(storagePathP(storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId),
strPtr(walSegmentFile)))));
"WAL segment %s successfully archived to '%s'", strZ(walSegment),
strZ(storagePathP(storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(walSegmentFile)))));
}
FUNCTION_LOG_RETURN_VOID();

14
src/command/check/common.c
View File

@ -27,14 +27,14 @@ checkArchiveCommand(const String *archiveCommand)
bool result = archiveCommand != NULL;
if (result && strstr(strPtr(archiveCommand), PROJECT_BIN) == NULL)
if (result && strstr(strZ(archiveCommand), PROJECT_BIN) == NULL)
result = false;
if (!result)
{
THROW_FMT(
ArchiveCommandInvalidError, "archive_command '%s' must contain %s", (archiveCommand != NULL ? strPtr(archiveCommand)
: "[" NULL_Z "]"), PROJECT_BIN);
ArchiveCommandInvalidError, "archive_command '%s' must contain %s",
archiveCommand != NULL ? strZ(archiveCommand) : "[" NULL_Z "]", PROJECT_BIN);
}
FUNCTION_TEST_RETURN(result);
@ -66,8 +66,8 @@ checkDbConfig(const unsigned int pgVersion, const unsigned int dbIdx, const Db *
THROW_FMT(
DbMismatchError, "version '%s' and path '%s' queried from cluster do not match version '%s' and '%s' read from '%s/"
PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL "'\nHINT: the %s and %s settings likely reference different clusters.",
strPtr(pgVersionToStr(dbVersion)), strPtr(dbPath), strPtr(pgVersionToStr(pgVersion)), strPtr(cfgOptionStr(pgPath)),
strPtr(cfgOptionStr(pgPath)), cfgOptionName(pgPath), cfgOptionName(cfgOptPgPort + (dbIdx - 1)));
strZ(pgVersionToStr(dbVersion)), strZ(dbPath), strZ(pgVersionToStr(pgVersion)), strZ(cfgOptionStr(pgPath)),
strZ(cfgOptionStr(pgPath)), cfgOptionName(pgPath), cfgOptionName(cfgOptPgPort + (dbIdx - 1)));
}
// Check archive configuration if option is valid for the command and set
@ -115,8 +115,8 @@ checkStanzaInfo(const InfoPgData *archiveInfo, const InfoPgData *backupInfo)
"archive: id = %u, version = %s, system-id = %" PRIu64 "\n"
"backup : id = %u, version = %s, system-id = %" PRIu64 "\n"
"HINT: this may be a symptom of repository corruption!",
archiveInfo->id, strPtr(pgVersionToStr(archiveInfo->version)), archiveInfo->systemId, backupInfo->id,
strPtr(pgVersionToStr(backupInfo->version)), backupInfo->systemId);
archiveInfo->id, strZ(pgVersionToStr(archiveInfo->version)), archiveInfo->systemId, backupInfo->id,
strZ(pgVersionToStr(backupInfo->version)), backupInfo->systemId);
}
FUNCTION_TEST_RETURN_VOID();

28
src/command/command.c
View File

@ -47,7 +47,7 @@ cmdBegin(bool logOption)
MEM_CONTEXT_TEMP_BEGIN()
{
// Basic info on command start
String *info = strNewFmt("%s command begin", strPtr(cfgCommandRoleName()));
String *info = strNewFmt("%s command begin", strZ(cfgCommandRoleName()));
if (logOption)
{
@ -70,8 +70,8 @@ cmdBegin(bool logOption)
if (commandParamIdx != 0)
strCatFmt(info, ", ");
if (strchr(strPtr(commandParam), ' ') != NULL)
commandParam = strNewFmt("\"%s\"", strPtr(commandParam));
if (strchr(strZ(commandParam), ' ') != NULL)
commandParam = strNewFmt("\"%s\"", strZ(commandParam));
strCat(info, commandParam);
}
@ -123,8 +123,8 @@ cmdBegin(bool logOption)
strLstAdd(
valueList,
strNewFmt(
"%s=%s", strPtr(varStr(varLstGet(keyList, keyIdx))),
strPtr(varStrForce(kvGet(optionKv, varLstGet(keyList, keyIdx))))));
"%s=%s", strZ(varStr(varLstGet(keyList, keyIdx))),
strZ(varStrForce(kvGet(optionKv, varLstGet(keyList, keyIdx))))));
}
}
// Generate values for list options
@ -146,17 +146,17 @@ cmdBegin(bool logOption)
strCatFmt(info, " --%s", cfgOptionName(optionId));
if (strchr(strPtr(value), ' ') != NULL)
value = strNewFmt("\"%s\"", strPtr(value));
if (strchr(strZ(value), ' ') != NULL)
value = strNewFmt("\"%s\"", strZ(value));
strCatFmt(info, "=%s", strPtr(value));
strCatFmt(info, "=%s", strZ(value));
}
}
}
}
}
LOG(cfgLogLevelDefault(), 0, strPtr(info));
LOG(cfgLogLevelDefault(), 0, strZ(info));
}
MEM_CONTEXT_TEMP_END();
}
@ -184,22 +184,22 @@ cmdEnd(int code, const String *errorMessage)
String *sckClientStat = sckClientStatStr();
if (sckClientStat != NULL)
LOG_DETAIL(strPtr(sckClientStat));
LOG_DETAIL(strZ(sckClientStat));
// Log tls statistics
String *tlsClientStat = tlsClientStatStr();
if (tlsClientStat != NULL)
LOG_DETAIL(strPtr(tlsClientStat));
LOG_DETAIL(strZ(tlsClientStat));
// Log http statistics
String *httpClientStat = httpClientStatStr();
if (httpClientStat != NULL)
LOG_INFO(strPtr(httpClientStat));
LOG_INFO(strZ(httpClientStat));
// Basic info on command end
String *info = strNewFmt("%s command end: ", strPtr(cfgCommandRoleName()));
String *info = strNewFmt("%s command end: ", strZ(cfgCommandRoleName()));
if (errorMessage == NULL)
{
@ -211,7 +211,7 @@ cmdEnd(int code, const String *errorMessage)
else
strCat(info, errorMessage);
LOG(cfgLogLevelDefault(), 0, strPtr(info));
LOG(cfgLogLevelDefault(), 0, strZ(info));
}
MEM_CONTEXT_TEMP_END();
}

5
src/command/control/common.c
View File

@ -16,8 +16,7 @@ lockStopFileName(const String *stanza)
FUNCTION_TEST_PARAM(STRING, stanza);
FUNCTION_TEST_END();
String *result = strNewFmt(
"%s/%s" STOP_FILE_EXT, strPtr(cfgOptionStr(cfgOptLockPath)), stanza != NULL ? strPtr(stanza) : "all");
String *result = strNewFmt("%s/%s" STOP_FILE_EXT, strZ(cfgOptionStr(cfgOptLockPath)), stanza != NULL ? strZ(stanza) : "all");
FUNCTION_TEST_RETURN(result);
}
@ -34,7 +33,7 @@ lockStopTest(void)
if (cfgOptionTest(cfgOptStanza))
{
if (storageExistsP(storageLocal(), lockStopFileName(cfgOptionStr(cfgOptStanza))))
THROW_FMT(StopError, "stop file exists for stanza %s", strPtr(cfgOptionStr(cfgOptStanza)));
THROW_FMT(StopError, "stop file exists for stanza %s", strZ(cfgOptionStr(cfgOptStanza)));
}
// Check all stanzas

5
src/command/control/start.c
View File

@ -28,8 +28,9 @@ cmdStart(void)
}
else
{
LOG_WARN_FMT("stop file does not exist%s",
(cfgOptionTest(cfgOptStanza) ? strPtr(strNewFmt(" for stanza %s", strPtr(cfgOptionStr(cfgOptStanza)))) : ""));
LOG_WARN_FMT(
"stop file does not exist%s",
(cfgOptionTest(cfgOptStanza) ? strZ(strNewFmt(" for stanza %s", strZ(cfgOptionStr(cfgOptStanza)))) : ""));
}
}
MEM_CONTEXT_TEMP_END();

22
src/command/control/stop.c
View File

@ -37,8 +37,8 @@ cmdStop(void)
// Create the stop file with Read/Write and Create only - do not use Truncate
int fileHandle = -1;
THROW_ON_SYS_ERROR_FMT(
((fileHandle = open(strPtr(stopFile), O_WRONLY | O_CREAT, STORAGE_MODE_FILE_DEFAULT)) == -1), FileOpenError,
"unable to open stop file '%s'", strPtr(stopFile));
((fileHandle = open(strZ(stopFile), O_WRONLY | O_CREAT, STORAGE_MODE_FILE_DEFAULT)) == -1), FileOpenError,
"unable to open stop file '%s'", strZ(stopFile));
// Close the file
close(fileHandle);
@ -53,16 +53,16 @@ cmdStop(void)
// Find each lock file and send term signals to the processes
for (unsigned int lockPathFileIdx = 0; lockPathFileIdx < strLstSize(lockPathFileList); lockPathFileIdx++)
{
String *lockFile = strNewFmt("%s/%s", strPtr(lockPath), strPtr(strLstGet(lockPathFileList, lockPathFileIdx)));
String *lockFile = strNewFmt("%s/%s", strZ(lockPath), strZ(strLstGet(lockPathFileList, lockPathFileIdx)));
// Skip any file that is not a lock file
if (!strEndsWithZ(lockFile, LOCK_FILE_EXT))
continue;
// If we cannot open the lock file for any reason then warn and continue to next file
if ((fileHandle = open(strPtr(lockFile), O_RDONLY, 0)) == -1)
if ((fileHandle = open(strZ(lockFile), O_RDONLY, 0)) == -1)
{
LOG_WARN_FMT( "unable to open lock file %s", strPtr(lockFile));
LOG_WARN_FMT( "unable to open lock file %s", strZ(lockFile));
continue;
}
@ -70,7 +70,7 @@ cmdStop(void)
// the lock file so remove it now
if (flock(fileHandle, LOCK_EX | LOCK_NB) == 0)
{
unlink(strPtr(lockFile));
unlink(strZ(lockFile));
close(fileHandle);
continue;
}
@ -83,14 +83,14 @@ cmdStop(void)
// If the process id is defined then assume this is a valid lock file
if (processId != NULL && strSize(processId) > 0)
{
if (kill(cvtZToInt(strPtr(processId)), SIGTERM) != 0)
LOG_WARN_FMT("unable to send term signal to process %s", strPtr(processId));
if (kill(cvtZToInt(strZ(processId)), SIGTERM) != 0)
LOG_WARN_FMT("unable to send term signal to process %s", strZ(processId));
else
LOG_INFO_FMT("sent term signal to process %s", strPtr(processId));
LOG_INFO_FMT("sent term signal to process %s", strZ(processId));
}
else
{
unlink(strPtr(lockFile));
unlink(strZ(lockFile));
close(fileHandle);
}
}
@ -100,7 +100,7 @@ cmdStop(void)
{
LOG_WARN_FMT(
"stop file already exists for %s",
cfgOptionTest(cfgOptStanza) ? strPtr(strNewFmt("stanza %s", strPtr(cfgOptionStr(cfgOptStanza)))) : "all stanzas");
cfgOptionTest(cfgOptStanza) ? strZ(strNewFmt("stanza %s", strZ(cfgOptionStr(cfgOptStanza)))) : "all stanzas");
}
}
MEM_CONTEXT_TEMP_END();

63
src/command/expire/expire.c
View File

@ -34,8 +34,8 @@ archiveIdComparator(const void *item1, const void *item2)
{
StringList *archiveSort1 = strLstNewSplitZ(*(String **)item1, "-");
StringList *archiveSort2 = strLstNewSplitZ(*(String **)item2, "-");
int int1 = atoi(strPtr(strLstGet(archiveSort1, 1)));
int int2 = atoi(strPtr(strLstGet(archiveSort2, 1)));
int int1 = atoi(strZ(strLstGet(archiveSort1, 1)));
int int2 = atoi(strZ(strLstGet(archiveSort2, 1)));
return (int1 - int2);
}
@ -79,10 +79,10 @@ expireBackup(InfoBackup *infoBackup, const String *backupLabel)
{
// Remove the manifest files to invalidate the backup
storageRemoveP(
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(removeBackupLabel)));
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(removeBackupLabel)));
storageRemoveP(
storageRepoWrite(),
strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strPtr(removeBackupLabel)));
strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strZ(removeBackupLabel)));
}
// Remove the backup from the info object
@ -119,14 +119,14 @@ expireAdhocBackup(InfoBackup *infoBackup, const String *backupLabel)
// If the label format is invalid, then error
if (!regExpMatchOne(backupRegExpP(.full = true, .differential = true, .incremental = true), backupLabel))
{
THROW_FMT(OptionInvalidValueError, "'%s' is not a valid backup label format", strPtr(backupLabel));
THROW_FMT(OptionInvalidValueError, "'%s' is not a valid backup label format", strZ(backupLabel));
}
// If the label is not a current backup then notify user and exit
if (infoBackupDataByLabel(infoBackup, backupLabel) == NULL)
{
LOG_WARN_FMT(
"backup %s does not exist\nHINT: run the info command and confirm the backup is listed", strPtr(backupLabel));
"backup %s does not exist\nHINT: run the info command and confirm the backup is listed", strZ(backupLabel));
}
else
{
@ -143,7 +143,7 @@ expireAdhocBackup(InfoBackup *infoBackup, const String *backupLabel)
{
THROW_FMT(
BackupSetInvalidError, "full backup %s cannot be expired until another full backup has been created",
strPtr(backupLabel));
strZ(backupLabel));
}
}
@ -167,7 +167,7 @@ expireAdhocBackup(InfoBackup *infoBackup, const String *backupLabel)
LOG_WARN_FMT(
"expiring latest backup %s - the ability to perform point-in-time-recovery (PITR) may be affected\n"
"HINT: non-default settings for '%s'/'%s' (even in prior expires) can cause gaps in the WAL.",
strPtr(latestBackup), cfgOptionName(cfgOptRepoRetentionArchive), cfgOptionName(cfgOptRepoRetentionArchiveType));
strZ(latestBackup), cfgOptionName(cfgOptRepoRetentionArchive), cfgOptionName(cfgOptRepoRetentionArchiveType));
// Adhoc expire is never performed through backup command so only check to determine if dry-run has been set or not
if (!cfgOptionBool(cfgOptDryRun))
@ -177,7 +177,7 @@ expireAdhocBackup(InfoBackup *infoBackup, const String *backupLabel)
result = strLstSize(backupExpired);
// Log the expired backup list (prepend "set:" if there were any dependents that were also expired)
LOG_INFO_FMT("expire adhoc backup %s%s", (result > 1 ? "set: " : ""), strPtr(strLstJoin(backupExpired, ", ")));
LOG_INFO_FMT("expire adhoc backup %s%s", (result > 1 ? "set: " : ""), strZ(strLstJoin(backupExpired, ", ")));
}
}
MEM_CONTEXT_TEMP_END();
@ -228,7 +228,7 @@ expireDiffBackup(InfoBackup *infoBackup)
// Log the expired backups. If there is more than one backup, then prepend "set:"
LOG_INFO_FMT(
"expire diff backup %s%s", (strLstSize(backupExpired) > 1 ? "set: " : ""),
strPtr(strLstJoin(backupExpired, ", ")));
strZ(strLstJoin(backupExpired, ", ")));
}
}
}
@ -276,7 +276,7 @@ expireFullBackup(InfoBackup *infoBackup)
// Log the expired backups. If there is more than one backup, then prepend "set:"
LOG_INFO_FMT(
"expire full backup %s%s", (strLstSize(backupExpired) > 1 ? "set: " : ""),
strPtr(strLstJoin(backupExpired, ", ")));
strZ(strLstJoin(backupExpired, ", ")));
}
}
}
@ -344,7 +344,7 @@ expireTimeBasedBackup(InfoBackup *infoBackup, const time_t minTimestamp)
// Log the expired backups. If there is more than one backup, then prepend "set:"
LOG_INFO_FMT(
"expire time-based backup %s%s", (strLstSize(backupExpired) > 1 ? "set: " : ""),
strPtr(strLstJoin(backupExpired, ", ")));
strZ(strLstJoin(backupExpired, ", ")));
}
if (strEqZ(cfgOptionStr(cfgOptRepoRetentionArchiveType), CFGOPTVAL_TMP_REPO_RETENTION_ARCHIVE_TYPE_FULL) &&
@ -370,8 +370,8 @@ logExpire(ArchiveExpired *archiveExpire, String *archiveId)
{
// Force out any remaining message
LOG_DETAIL_FMT(
"remove archive: archiveId = %s, start = %s, stop = %s", strPtr(archiveId), strPtr(archiveExpire->start),
strPtr(archiveExpire->stop));
"remove archive: archiveId = %s, start = %s, stop = %s", strZ(archiveId), strZ(archiveExpire->start),
strZ(archiveExpire->stop));
archiveExpire->start = NULL;
}
@ -404,9 +404,9 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
// Only notify user if not time-based retention
if (!timeBasedFullRetention)
LOG_INFO_FMT("option '%s' is not set %s", cfgOptionName(cfgOptRepoRetentionArchive), strPtr(msg));
LOG_INFO_FMT("option '%s' is not set %s", cfgOptionName(cfgOptRepoRetentionArchive), strZ(msg));
else
LOG_INFO_FMT("time-based archive retention not met %s", strPtr(msg));
LOG_INFO_FMT("time-based archive retention not met %s", strZ(msg));
}
else
{
@ -497,7 +497,7 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
continue;
StringList *archiveSplit = strLstNewSplitZ(archiveId, "-");
unsigned int archivePgId = cvtZToUInt(strPtr(strLstGet(archiveSplit, 1)));
unsigned int archivePgId = cvtZToUInt(strZ(strLstGet(archiveSplit, 1)));
// From the global list of backups to retain, create a list of backups, oldest to newest, associated with
// this archiveId (e.g. 9.4-1), e.g. If globalBackupRetention has 4F, 3F, 2F, 1F then
@ -527,9 +527,9 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
if (currentPg.id != archivePgId)
{
String *fullPath = storagePathP(
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s", strPtr(archiveId)));
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s", strZ(archiveId)));
LOG_INFO_FMT("remove archive path: %s", strPtr(fullPath));
LOG_INFO_FMT("remove archive path: %s", strZ(fullPath));
// Execute the real expiration and deletion only if the dry-run option is disabled
if (!cfgOptionValid(cfgOptDryRun) || !cfgOptionBool(cfgOptDryRun))
@ -622,9 +622,8 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
LOG_DETAIL_FMT(
"archive retention on backup %s, archiveId = %s, start = %s%s",
strPtr(backupData->backupLabel), strPtr(archiveId), strPtr(archiveRange.start),
archiveRange.stop != NULL ?
strPtr(strNewFmt(", stop = %s", strPtr(archiveRange.stop))) : "");
strZ(backupData->backupLabel), strZ(archiveId), strZ(archiveRange.start),
archiveRange.stop != NULL ? strZ(strNewFmt(", stop = %s", strZ(archiveRange.stop))) : "");
// Add the archive range to the list
lstAdd(archiveRangeList, &archiveRange);
@ -635,7 +634,7 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
StringList *walPathList =
strLstSort(
storageListP(
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s", strPtr(archiveId)),
storageRepo(), strNewFmt(STORAGE_REPO_ARCHIVE "/%s", strZ(archiveId)),
.expression = STRDEF(WAL_SEGMENT_DIR_REGEXP)),
sortOrderAsc);
@ -665,7 +664,7 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
{
storagePathRemoveP(
storageRepoWrite(),
strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId), strPtr(walPath)),
strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(walPath)),
.recurse = true);
}
@ -683,7 +682,7 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
strLstSort(
storageListP(
storageRepo(),
strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strPtr(archiveId), strPtr(walPath)),
strNewFmt(STORAGE_REPO_ARCHIVE "/%s/%s", strZ(archiveId), strZ(walPath)),
.expression = STRDEF("^[0-F]{24}.*$")),
sortOrderAsc);
@ -715,8 +714,8 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
storageRemoveP(
storageRepoWrite(),
strNewFmt(
STORAGE_REPO_ARCHIVE "/%s/%s/%s", strPtr(archiveId), strPtr(walPath),
strPtr(walSubPath)));
STORAGE_REPO_ARCHIVE "/%s/%s/%s", strZ(archiveId), strZ(walPath),
strZ(walSubPath)));
}
// Track that this archive was removed
@ -734,7 +733,7 @@ removeExpiredArchive(InfoBackup *infoBackup, bool timeBasedFullRetention)
// Log if no archive was expired
if (archiveExpire.total == 0)
{
LOG_DETAIL_FMT("no archive to remove, archiveId = %s", strPtr(archiveId));
LOG_DETAIL_FMT("no archive to remove, archiveId = %s", strZ(archiveId));
}
// Log if there is more to log
else
@ -780,8 +779,8 @@ removeExpiredBackup(InfoBackup *infoBackup, const String *adhocBackupLabel)
if (adhocBackupLabel != NULL)
{
String *manifestFileName = strNewFmt(
STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(strLstGet(backupList, backupIdx)));
String *manifestCopyFileName = strNewFmt("%s" INFO_COPY_EXT, strPtr(manifestFileName));
STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(strLstGet(backupList, backupIdx)));
String *manifestCopyFileName = strNewFmt("%s" INFO_COPY_EXT, strZ(manifestFileName));
// If the latest backup is resumable (has a backup.manifest.copy but no backup.manifest)
if (!storageExistsP(storageRepo(), manifestFileName) && storageExistsP(storageRepo(), manifestCopyFileName))
@ -810,13 +809,13 @@ removeExpiredBackup(InfoBackup *infoBackup, const String *adhocBackupLabel)
{
if (!strLstExists(currentBackupList, strLstGet(backupList, backupIdx)))
{
LOG_INFO_FMT("remove expired backup %s", strPtr(strLstGet(backupList, backupIdx)));
LOG_INFO_FMT("remove expired backup %s", strZ(strLstGet(backupList, backupIdx)));
// Execute the real expiration and deletion only if the dry-run mode is disabled
if (!cfgOptionValid(cfgOptDryRun) || !cfgOptionBool(cfgOptDryRun))
{
storagePathRemoveP(
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s", strPtr(strLstGet(backupList, backupIdx))),
storageRepoWrite(), strNewFmt(STORAGE_REPO_BACKUP "/%s", strZ(strLstGet(backupList, backupIdx))),
.recurse = true);
}
}

32
src/command/help/help.c
View File

@ -104,8 +104,8 @@ helpRenderValue(const Variant *value)
strCatZ(resultTemp, ", ");
strCatFmt(
resultTemp, "%s=%s", strPtr(varStr(varLstGet(keyList, keyIdx))),
strPtr(varStrForce(kvGet(optionKv, varLstGet(keyList, keyIdx)))));
resultTemp, "%s=%s", strZ(varStr(varLstGet(keyList, keyIdx))),
strZ(varStrForce(kvGet(optionKv, varLstGet(keyList, keyIdx)))));
}
result = resultTemp;
@ -121,7 +121,7 @@ helpRenderValue(const Variant *value)
if (listIdx != 0)
strCatZ(resultTemp, ", ");
strCatFmt(resultTemp, "%s", strPtr(varStr(varLstGet(list, listIdx))));
strCatFmt(resultTemp, "%s", strZ(varStr(varLstGet(list, listIdx))));
}
result = resultTemp;
@ -181,7 +181,7 @@ helpRender(void)
strCatFmt(
result, " %s%*s%s\n", cfgCommandName(commandId),
(int)(commandSizeMax - strlen(cfgCommandName(commandId)) + 2), "",
strPtr(
strZ(
helpRenderText(
STR(cfgDefCommandHelpSummary(cfgCommandDefIdFromId(commandId))), commandSizeMax + 6, false,
CONSOLE_WIDTH)));
@ -210,8 +210,8 @@ helpRender(void)
"%s\n"
"\n"
"%s\n",
strPtr(helpRenderText(STR(cfgDefCommandHelpSummary(commandDefId)), 0, true, CONSOLE_WIDTH)),
strPtr(helpRenderText(STR(cfgDefCommandHelpDescription(commandDefId)), 0, true, CONSOLE_WIDTH)));
strZ(helpRenderText(STR(cfgDefCommandHelpSummary(commandDefId)), 0, true, CONSOLE_WIDTH)),
strZ(helpRenderText(STR(cfgDefCommandHelpDescription(commandDefId)), 0, true, CONSOLE_WIDTH)));
// Construct key/value of sections and options
KeyValue *optionKv = kvNew();
@ -247,7 +247,7 @@ helpRender(void)
{
const String *section = strLstGet(sectionList, sectionIdx);
strCatFmt(result, "\n%s Options:\n\n", strPtr(strFirstUpper(strDup(section))));
strCatFmt(result, "\n%s Options:\n\n", strZ(strFirstUpper(strDup(section))));
// Output options
VariantList *optionList = kvGetList(optionKv, VARSTR(section));
@ -274,14 +274,14 @@ helpRender(void)
strCatZ(summary, " [");
if (value != NULL)
strCatFmt(summary, "current=%s", cfgDefOptionSecure(optionDefId) ? "<redacted>" : strPtr(value));
strCatFmt(summary, "current=%s", cfgDefOptionSecure(optionDefId) ? "<redacted>" : strZ(value));
if (defaultValue != NULL)
{
if (value != NULL)
strCatZ(summary, ", ");
strCatFmt(summary, "default=%s", strPtr(defaultValue));
strCatFmt(summary, "default=%s", strZ(defaultValue));
}
strCatZ(summary, "]");
@ -291,7 +291,7 @@ helpRender(void)
strCatFmt(
result, " --%s%*s%s\n",
cfgDefOptionName(optionDefId), (int)(optionSizeMax - strlen(cfgDefOptionName(optionDefId)) + 2), "",
strPtr(helpRenderText(summary, optionSizeMax + 6, false, CONSOLE_WIDTH)));
strZ(helpRenderText(summary, optionSizeMax + 6, false, CONSOLE_WIDTH)));
}
}
@ -307,7 +307,7 @@ helpRender(void)
THROW(ParamInvalidError, "only one option allowed for option help");
// Ensure the option is valid
const char *optionName = strPtr(strLstGet(cfgCommandParam(), 0));
const char *optionName = strZ(strLstGet(cfgCommandParam(), 0));
ConfigOption optionId = cfgOptionId(optionName);
if (cfgOptionId(optionName) == -1)
@ -329,8 +329,8 @@ helpRender(void)
"\n"
"%s\n",
optionName,
strPtr(helpRenderText(STR(cfgDefOptionHelpSummary(commandDefId, optionDefId)), 0, true, CONSOLE_WIDTH)),
strPtr(helpRenderText(STR(cfgDefOptionHelpDescription(commandDefId, optionDefId)), 0, true, CONSOLE_WIDTH)));
strZ(helpRenderText(STR(cfgDefOptionHelpSummary(commandDefId, optionDefId)), 0, true, CONSOLE_WIDTH)),
strZ(helpRenderText(STR(cfgDefOptionHelpDescription(commandDefId, optionDefId)), 0, true, CONSOLE_WIDTH)));
// Ouput current and default values if they exist
const String *defaultValue = helpRenderValue(cfgOptionDefault(optionId));
@ -344,10 +344,10 @@ helpRender(void)
strCat(result, LF_STR);
if (value != NULL)
strCatFmt(result, "current: %s\n", cfgDefOptionSecure(optionDefId) ? "<redacted>" : strPtr(value));
strCatFmt(result, "current: %s\n", cfgDefOptionSecure(optionDefId) ? "<redacted>" : strZ(value));
if (defaultValue != NULL)
strCatFmt(result, "default: %s\n", strPtr(defaultValue));
strCatFmt(result, "default: %s\n", strZ(defaultValue));
}
// Output alternate name (call it deprecated so the user will know not to use it)
@ -358,7 +358,7 @@ helpRender(void)
// If there is more help available output a message to let the user know
if (more != NULL)
strCatFmt(result, "\nUse '" PROJECT_BIN " help %s' for more information.\n", strPtr(more));
strCatFmt(result, "\nUse '" PROJECT_BIN " help %s' for more information.\n", strZ(more));
}
MEM_CONTEXT_TEMP_END();

75
src/command/info/info.c
View File

@ -135,7 +135,7 @@ archiveDbList(const String *stanza, const InfoPgData *pgData, VariantList *archi
// If there is no match, an error will be thrown.
const String *archiveId = infoArchiveIdHistoryMatch(info, pgData->id, pgData->version, pgData->systemId);
String *archivePath = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/%s", strPtr(stanza), strPtr(archiveId));
String *archivePath = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/%s", strZ(stanza), strZ(archiveId));
String *archiveStart = NULL;
String *archiveStop = NULL;
Variant *archiveInfo = varNewKv(kvNew());
@ -151,7 +151,7 @@ archiveDbList(const String *stanza, const InfoPgData *pgData, VariantList *archi
{
// Get a list of all WAL in this WAL dir
StringList *list = storageListP(
storageRepo(), strNewFmt("%s/%s", strPtr(archivePath), strPtr(strLstGet(walDir, idx))),
storageRepo(), strNewFmt("%s/%s", strZ(archivePath), strZ(strLstGet(walDir, idx))),
.expression = WAL_SEGMENT_FILE_REGEXP_STR);
// If wal segments are found, get the oldest one as the archive start
@ -169,7 +169,7 @@ archiveDbList(const String *stanza, const InfoPgData *pgData, VariantList *archi
{
// Get a list of all WAL in this WAL dir
StringList *list = storageListP(
storageRepo(), strNewFmt("%s/%s", strPtr(archivePath), strPtr(strLstGet(walDir, idx))),
storageRepo(), strNewFmt("%s/%s", strZ(archivePath), strZ(strLstGet(walDir, idx))),
.expression = WAL_SEGMENT_FILE_REGEXP_STR);
// If wal segments are found, get the newest one as the archive stop
@ -279,7 +279,7 @@ backupList(VariantList *backupSection, InfoBackup *info, const String *backupLab
{
// Load the manifest file
const Manifest *manifest = manifestLoadFile(
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel)),
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel)),
cipherType(cfgOptionStr(cfgOptRepoCipherType)), infoPgCipherPass(infoBackupPg(info)));
// Get the list of databases in this backup
@ -325,8 +325,8 @@ backupList(VariantList *backupSection, InfoBackup *info, const String *backupLab
{
kvPut(varKv(link), KEY_NAME_VAR, varNewStr(target->file));
kvPut(
varKv(link), KEY_DESTINATION_VAR, varNewStr(strNewFmt("%s/%s", strPtr(target->path),
strPtr(target->file))));
varKv(link), KEY_DESTINATION_VAR, varNewStr(strNewFmt("%s/%s", strZ(target->path),
strZ(target->file))));
varLstAdd(linkSection, link);
}
else
@ -395,7 +395,7 @@ stanzaInfoList(const String *stanza, StringList *stanzaList, const String *backu
{
// Attempt to load the backup info file
info = infoBackupLoadFile(
storageRepo(), strNewFmt(STORAGE_PATH_BACKUP "/%s/%s", strPtr(stanzaListName), INFO_BACKUP_FILE),
storageRepo(), strNewFmt(STORAGE_PATH_BACKUP "/%s/%s", strZ(stanzaListName), INFO_BACKUP_FILE),
cipherType(cfgOptionStr(cfgOptRepoCipherType)), cfgOptionStrNull(cfgOptRepoCipherPass));
}
CATCH(FileMissingError)
@ -442,7 +442,7 @@ stanzaInfoList(const String *stanza, StringList *stanzaList, const String *backu
// Get the archive info for the DB from the archive.info file
InfoArchive *info = infoArchiveLoadFile(
storageRepo(), strNewFmt(STORAGE_PATH_ARCHIVE "/%s/%s", strPtr(stanzaListName), INFO_ARCHIVE_FILE),
storageRepo(), strNewFmt(STORAGE_PATH_ARCHIVE "/%s/%s", strZ(stanzaListName), INFO_ARCHIVE_FILE),
cipherType(cfgOptionStr(cfgOptRepoCipherType)), cfgOptionStrNull(cfgOptRepoCipherPass));
archiveDbList(stanzaListName, &pgData, archiveSection, info, (pgIdx == 0 ? true : false));
}
@ -564,14 +564,14 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
{
strCatFmt(
archiveResult, "\n wal archive min/max (%s): ",
strPtr(varStr(kvGet(archiveInfo, DB_KEY_ID_VAR))));
strZ(varStr(kvGet(archiveInfo, DB_KEY_ID_VAR))));
// Get the archive min/max if there are any archives for the database
if (kvGet(archiveInfo, ARCHIVE_KEY_MIN_VAR) != NULL)
{
strCatFmt(
archiveResult, "%s/%s\n", strPtr(varStr(kvGet(archiveInfo, ARCHIVE_KEY_MIN_VAR))),
strPtr(varStr(kvGet(archiveInfo, ARCHIVE_KEY_MAX_VAR))));
archiveResult, "%s/%s\n", strZ(varStr(kvGet(archiveInfo, ARCHIVE_KEY_MIN_VAR))),
strZ(varStr(kvGet(archiveInfo, ARCHIVE_KEY_MAX_VAR))));
}
else
strCatZ(archiveResult, "none present\n");
@ -594,8 +594,8 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
if (backupDbId == dbId)
{
strCatFmt(
backupResult, "\n %s backup: %s\n", strPtr(varStr(kvGet(backupInfo, BACKUP_KEY_TYPE_VAR))),
strPtr(varStr(kvGet(backupInfo, BACKUP_KEY_LABEL_VAR))));
backupResult, "\n %s backup: %s\n", strZ(varStr(kvGet(backupInfo, BACKUP_KEY_TYPE_VAR))),
strZ(varStr(kvGet(backupInfo, BACKUP_KEY_LABEL_VAR))));
KeyValue *timestampInfo = varKv(kvGet(backupInfo, BACKUP_KEY_TIMESTAMP_VAR));
@ -617,8 +617,9 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
if (kvGet(archiveBackupInfo, KEY_START_VAR) != NULL &&
kvGet(archiveBackupInfo, KEY_STOP_VAR) != NULL)
{
strCatFmt(backupResult, "%s / %s\n", strPtr(varStr(kvGet(archiveBackupInfo, KEY_START_VAR))),
strPtr(varStr(kvGet(archiveBackupInfo, KEY_STOP_VAR))));
strCatFmt(
backupResult, "%s / %s\n", strZ(varStr(kvGet(archiveBackupInfo, KEY_START_VAR))),
strZ(varStr(kvGet(archiveBackupInfo, KEY_STOP_VAR))));
}
else
strCatZ(backupResult, "n/a\n");
@ -627,20 +628,20 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
strCatFmt(
backupResult, " database size: %s, backup size: %s\n",
strPtr(strSizeFormat(varUInt64Force(kvGet(info, KEY_SIZE_VAR)))),
strPtr(strSizeFormat(varUInt64Force(kvGet(info, KEY_DELTA_VAR)))));
strZ(strSizeFormat(varUInt64Force(kvGet(info, KEY_SIZE_VAR)))),
strZ(strSizeFormat(varUInt64Force(kvGet(info, KEY_DELTA_VAR)))));
KeyValue *repoInfo = varKv(kvGet(info, INFO_KEY_REPOSITORY_VAR));
strCatFmt(
backupResult, " repository size: %s, repository backup size: %s\n",
strPtr(strSizeFormat(varUInt64Force(kvGet(repoInfo, KEY_SIZE_VAR)))),
strPtr(strSizeFormat(varUInt64Force(kvGet(repoInfo, KEY_DELTA_VAR)))));
strZ(strSizeFormat(varUInt64Force(kvGet(repoInfo, KEY_SIZE_VAR)))),
strZ(strSizeFormat(varUInt64Force(kvGet(repoInfo, KEY_DELTA_VAR)))));
if (kvGet(backupInfo, BACKUP_KEY_REFERENCE_VAR) != NULL)
{
StringList *referenceList = strLstNewVarLst(varVarLst(kvGet(backupInfo, BACKUP_KEY_REFERENCE_VAR)));
strCatFmt(backupResult, " backup reference list: %s\n", strPtr(strLstJoin(referenceList, ", ")));
strCatFmt(backupResult, " backup reference list: %s\n", strZ(strLstJoin(referenceList, ", ")));
}
if (kvGet(backupInfo, BACKUP_KEY_DATABASE_REF_VAR) != NULL)
@ -656,8 +657,8 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
{
KeyValue *db = varKv(varLstGet(dbSection, dbIdx));
strCatFmt(
backupResult, " %s (%s)", strPtr(varStr(kvGet(db, KEY_NAME_VAR))),
strPtr(varStrForce(kvGet(db, KEY_OID_VAR))));
backupResult, " %s (%s)", strZ(varStr(kvGet(db, KEY_NAME_VAR))),
strZ(varStrForce(kvGet(db, KEY_OID_VAR))));
if (dbIdx != varLstSize(dbSection) - 1)
strCatZ(backupResult, ",");
@ -677,8 +678,8 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
KeyValue *link = varKv(varLstGet(linkSection, linkIdx));
strCatFmt(
backupResult, " %s => %s", strPtr(varStr(kvGet(link, KEY_NAME_VAR))),
strPtr(varStr(kvGet(link, KEY_DESTINATION_VAR))));
backupResult, " %s => %s", strZ(varStr(kvGet(link, KEY_NAME_VAR))),
strZ(varStr(kvGet(link, KEY_DESTINATION_VAR))));
if (linkIdx != varLstSize(linkSection) - 1)
strCat(backupResult, LF_STR);
@ -697,9 +698,9 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr, const String *backup
KeyValue *tablespace = varKv(varLstGet(tablespaceSection, tblIdx));
strCatFmt(
backupResult, " %s (%s) => %s", strPtr(varStr(kvGet(tablespace, KEY_NAME_VAR))),
strPtr(varStrForce(kvGet(tablespace, KEY_OID_VAR))),
strPtr(varStr(kvGet(tablespace, KEY_DESTINATION_VAR))));
backupResult, " %s (%s) => %s", strZ(varStr(kvGet(tablespace, KEY_NAME_VAR))),
strZ(varStrForce(kvGet(tablespace, KEY_OID_VAR))),
strZ(varStr(kvGet(tablespace, KEY_DESTINATION_VAR))));
if (tblIdx != varLstSize(tablespaceSection) - 1)
strCat(backupResult, LF_STR);
@ -753,11 +754,11 @@ infoRender(void)
if (!strEq(cfgOptionStr(cfgOptOutput), CFGOPTVAL_INFO_OUTPUT_TEXT_STR))
THROW(ConfigError, "option 'set' is currently only valid for text output");
if (!storageExistsP(storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel))))
if (!storageExistsP(storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel))))
{
THROW_FMT(
FileMissingError, "manifest does not exist for backup '%s'\n"
"HINT: is the backup listed when running the info command with --stanza option only?", strPtr(backupLabel));
"HINT: is the backup listed when running the info command with --stanza option only?", strZ(backupLabel));
}
}
@ -786,7 +787,7 @@ infoRender(void)
// Stanza name and status
strCatFmt(
resultStr, "stanza: %s\n status: ", strPtr(varStr(kvGet(stanzaInfo, KEY_NAME_VAR))));
resultStr, "stanza: %s\n status: ", strZ(varStr(kvGet(stanzaInfo, KEY_NAME_VAR))));
// If an error has occurred, provide the information that is available and move onto next stanza
KeyValue *stanzaStatus = varKv(kvGet(stanzaInfo, STANZA_KEY_STATUS_VAR));
@ -803,21 +804,21 @@ infoRender(void)
{
strCatFmt(
resultStr, "%s (%s, %s)\n", INFO_STANZA_STATUS_ERROR,
strPtr(varStr(kvGet(stanzaStatus, STATUS_KEY_MESSAGE_VAR))),
strPtr(INFO_STANZA_STATUS_MESSAGE_LOCK_BACKUP_STR));
strZ(varStr(kvGet(stanzaStatus, STATUS_KEY_MESSAGE_VAR))),
strZ(INFO_STANZA_STATUS_MESSAGE_LOCK_BACKUP_STR));
}
else
{
strCatFmt(
resultStr, "%s (%s)\n", INFO_STANZA_STATUS_ERROR,
strPtr(varStr(kvGet(stanzaStatus, STATUS_KEY_MESSAGE_VAR))));
strZ(varStr(kvGet(stanzaStatus, STATUS_KEY_MESSAGE_VAR))));
}
if (statusCode == INFO_STANZA_STATUS_CODE_MISSING_STANZA_DATA ||
statusCode == INFO_STANZA_STATUS_CODE_NO_BACKUP)
{
strCatFmt(
resultStr, " cipher: %s\n", strPtr(varStr(kvGet(stanzaInfo, STANZA_KEY_CIPHER_VAR))));
resultStr, " cipher: %s\n", strZ(varStr(kvGet(stanzaInfo, STANZA_KEY_CIPHER_VAR))));
// If there is a backup.info file but no backups, then process the archive info
if (statusCode == INFO_STANZA_STATUS_CODE_NO_BACKUP)
@ -832,15 +833,15 @@ infoRender(void)
if (varBool(kvGet(backupLockKv, STATUS_KEY_LOCK_BACKUP_HELD_VAR)))
{
strCatFmt(
resultStr, "%s (%s)\n", INFO_STANZA_STATUS_OK, strPtr(INFO_STANZA_STATUS_MESSAGE_LOCK_BACKUP_STR));
resultStr, "%s (%s)\n", INFO_STANZA_STATUS_OK, strZ(INFO_STANZA_STATUS_MESSAGE_LOCK_BACKUP_STR));
}
else
strCatFmt(resultStr, "%s\n", INFO_STANZA_STATUS_OK);
}
// Cipher
strCatFmt(resultStr, " cipher: %s\n",
strPtr(varStr(kvGet(stanzaInfo, STANZA_KEY_CIPHER_VAR))));
strCatFmt(
resultStr, " cipher: %s\n", strZ(varStr(kvGet(stanzaInfo, STANZA_KEY_CIPHER_VAR))));
formatTextDb(stanzaInfo, resultStr, backupLabel);
}

16
src/command/repo/get.c
View File

@ -47,8 +47,8 @@ storageGetProcess(IoWrite *destination)
if (!strBeginsWith(file, cfgOptionStr(cfgOptRepoPath)))
{
THROW_FMT(
OptionInvalidValueError, "absolute path '%s' is not in base path '%s'", strPtr(file),
strPtr(cfgOptionStr(cfgOptRepoPath)));
OptionInvalidValueError, "absolute path '%s' is not in base path '%s'", strZ(file),
strZ(cfgOptionStr(cfgOptRepoPath)));
}
// Get the relative part of the file
@ -95,7 +95,7 @@ storageGetProcess(IoWrite *destination)
{
THROW_FMT(
OptionInvalidValueError, "stanza name '%s' given in option doesn't match the given path",
strPtr(cfgOptionStr(cfgOptStanza)));
strZ(cfgOptionStr(cfgOptStanza)));
}
// Archive path
@ -107,7 +107,7 @@ storageGetProcess(IoWrite *destination)
if (!strEndsWithZ(file, INFO_ARCHIVE_FILE) && !strEndsWithZ(file, INFO_ARCHIVE_FILE INFO_COPY_EXT))
{
InfoArchive *info = infoArchiveLoadFile(
storageRepo(), strNewFmt(STORAGE_PATH_ARCHIVE "/%s/%s", strPtr(stanza), INFO_ARCHIVE_FILE),
storageRepo(), strNewFmt(STORAGE_PATH_ARCHIVE "/%s/%s", strZ(stanza), INFO_ARCHIVE_FILE),
repoCipherType, cipherPass);
cipherPass = infoArchiveCipherPass(info);
}
@ -122,7 +122,7 @@ storageGetProcess(IoWrite *destination)
{
// Find the backup passphrase
InfoBackup *info = infoBackupLoadFile(
storageRepo(), strNewFmt(STORAGE_PATH_BACKUP "/%s/%s", strPtr(stanza), INFO_BACKUP_FILE),
storageRepo(), strNewFmt(STORAGE_PATH_BACKUP "/%s/%s", strZ(stanza), INFO_BACKUP_FILE),
repoCipherType, cipherPass);
cipherPass = infoBackupCipherPass(info);
@ -132,8 +132,8 @@ storageGetProcess(IoWrite *destination)
!strEndsWithZ(file, BACKUP_MANIFEST_FILE INFO_COPY_EXT))
{
const Manifest *manifest = manifestLoadFile(
storageRepo(), strNewFmt(STORAGE_PATH_BACKUP "/%s/%s/%s", strPtr(stanza),
strPtr(strLstGet(filePathSplitLst, 2)), BACKUP_MANIFEST_FILE), repoCipherType, cipherPass);
storageRepo(), strNewFmt(STORAGE_PATH_BACKUP "/%s/%s/%s", strZ(stanza),
strZ(strLstGet(filePathSplitLst, 2)), BACKUP_MANIFEST_FILE), repoCipherType, cipherPass);
cipherPass = manifestCipherSubPass(manifest);
}
}
@ -143,7 +143,7 @@ storageGetProcess(IoWrite *destination)
// Error when unable to determine cipher passphrase
if (cipherPass == NULL)
THROW_FMT(OptionInvalidValueError, "unable to determine cipher passphrase for '%s'", strPtr(file));
THROW_FMT(OptionInvalidValueError, "unable to determine cipher passphrase for '%s'", strZ(file));
// Add encryption filter
cipherBlockFilterGroupAdd(ioReadFilterGroup(source), repoCipherType, cipherModeDecrypt, cipherPass);

2
src/command/repo/ls.c
View File

@ -91,7 +91,7 @@ storageListRenderCallback(void *data, const StorageInfo *info)
}
if (info->type == storageTypeLink)
ioWriteStr(listData->write, strNewFmt(",\"destination\":%s", strPtr(jsonFromStr(info->linkDestination))));
ioWriteStr(listData->write, strNewFmt(",\"destination\":%s", strZ(jsonFromStr(info->linkDestination))));
ioWrite(listData->write, BRACER_BUF);
}

14
src/command/restore/file.c
View File

@ -98,9 +98,9 @@ restoreFile(
{
THROW_ON_SYS_ERROR_FMT(
utime(
strPtr(storagePathP(storagePg(), pgFile)),
strZ(storagePathP(storagePg(), pgFile)),
&((struct utimbuf){.actime = pgFileModified, .modtime = pgFileModified})) == -1,
FileInfoError, "unable to set time for '%s'", strPtr(storagePathP(storagePg(), pgFile)));
FileInfoError, "unable to set time for '%s'", strZ(storagePathP(storagePg(), pgFile)));
}
result = false;
@ -128,7 +128,7 @@ restoreFile(
{
THROW_ON_SYS_ERROR_FMT(
ftruncate(ioWriteHandle(storageWriteIo(pgFileWrite)), (off_t)pgFileSize) == -1, FileWriteError,
"unable to truncate '%s'", strPtr(pgFile));
"unable to truncate '%s'", strZ(pgFile));
// Report the file as not copied
result = false;
@ -166,8 +166,8 @@ restoreFile(
storageNewReadP(
storageRepo(),
strNewFmt(
STORAGE_REPO_BACKUP "/%s/%s%s", strPtr(repoFileReference), strPtr(repoFile),
strPtr(compressExtStr(repoFileCompressType))),
STORAGE_REPO_BACKUP "/%s/%s%s", strZ(repoFileReference), strZ(repoFile),
strZ(compressExtStr(repoFileCompressType))),
.compressible = compressible),
pgFileWrite);
@ -176,8 +176,8 @@ restoreFile(
{
THROW_FMT(
ChecksumError,
"error restoring '%s': actual checksum '%s' does not match expected checksum '%s'", strPtr(pgFile),
strPtr(varStr(ioFilterGroupResult(filterGroup, CRYPTO_HASH_FILTER_TYPE_STR))), strPtr(pgFileChecksum));
"error restoring '%s': actual checksum '%s' does not match expected checksum '%s'", strZ(pgFile),
strZ(varStr(ioFilterGroupResult(filterGroup, CRYPTO_HASH_FILTER_TYPE_STR))), strZ(pgFileChecksum));
}
}
}

2
src/command/restore/protocol.c
View File

@ -46,7 +46,7 @@ restoreProtocol(const String *command, const VariantList *paramList, ProtocolSer
varStr(varLstGet(paramList, 0)), varStr(varLstGet(paramList, 1)),
(CompressType)varUIntForce(varLstGet(paramList, 2)), varStr(varLstGet(paramList, 3)),
varStr(varLstGet(paramList, 4)), varBoolForce(varLstGet(paramList, 5)), varUInt64(varLstGet(paramList, 6)),
(time_t)varInt64Force(varLstGet(paramList, 7)), cvtZToUIntBase(strPtr(varStr(varLstGet(paramList, 8))), 8),
(time_t)varInt64Force(varLstGet(paramList, 7)), cvtZToUIntBase(strZ(varStr(varLstGet(paramList, 8))), 8),
varStr(varLstGet(paramList, 9)), varStr(varLstGet(paramList, 10)),
(time_t)varInt64Force(varLstGet(paramList, 11)), varBoolForce(varLstGet(paramList, 12)),
varBoolForce(varLstGet(paramList, 13)), varStr(varLstGet(paramList, 14)))));

189
src/command/restore/restore.c
View File

@ -75,7 +75,7 @@ restorePathValidate(void)
// The PGDATA directory must exist
// ??? We should remove this requirement in a separate commit. What's the harm in creating the dir assuming we have perms?
if (!storagePathExistsP(storagePg(), NULL))
THROW_FMT(PathMissingError, "$PGDATA directory '%s' does not exist", strPtr(cfgOptionStr(cfgOptPgPath)));
THROW_FMT(PathMissingError, "$PGDATA directory '%s' does not exist", strZ(cfgOptionStr(cfgOptPgPath)));
// PostgreSQL must not be running
if (storageExistsP(storagePg(), PG_FILE_POSTMASTERPID_STR))
@ -85,7 +85,7 @@ restorePathValidate(void)
"unable to restore while PostgreSQL is running\n"
"HINT: presence of '" PG_FILE_POSTMASTERPID "' in '%s' indicates PostgreSQL is running.\n"
"HINT: remove '" PG_FILE_POSTMASTERPID "' only if PostgreSQL is not running.",
strPtr(cfgOptionStr(cfgOptPgPath)));
strZ(cfgOptionStr(cfgOptPgPath)));
}
// If the restore will be destructive attempt to verify that PGDATA looks like a valid PostgreSQL directory
@ -96,7 +96,7 @@ restorePathValidate(void)
"--delta or --force specified but unable to find '" PG_FILE_PGVERSION "' or '" BACKUP_MANIFEST_FILE "' in '%s' to"
" confirm that this is a valid $PGDATA directory. --delta and --force have been disabled and if any files"
" exist in the destination directories the restore will be aborted.",
strPtr(cfgOptionStr(cfgOptPgPath)));
strZ(cfgOptionStr(cfgOptPgPath)));
// Disable delta and force so restore will fail if the directories are not empty
cfgOptionSet(cfgOptDelta, cfgSourceDefault, VARBOOL(false));
@ -137,12 +137,12 @@ getEpoch(const String *targetTime)
// Strip off the date and time and put the remainder into another string
String *datetime = strSubN(targetTime, 0, 19);
int dtYear = cvtZToInt(strPtr(strSubN(datetime, 0, 4)));
int dtMonth = cvtZToInt(strPtr(strSubN(datetime, 5, 2)));
int dtDay = cvtZToInt(strPtr(strSubN(datetime, 8, 2)));
int dtHour = cvtZToInt(strPtr(strSubN(datetime, 11, 2)));
int dtMinute = cvtZToInt(strPtr(strSubN(datetime, 14, 2)));
int dtSecond = cvtZToInt(strPtr(strSubN(datetime, 17, 2)));
int dtYear = cvtZToInt(strZ(strSubN(datetime, 0, 4)));
int dtMonth = cvtZToInt(strZ(strSubN(datetime, 5, 2)));
int dtDay = cvtZToInt(strZ(strSubN(datetime, 8, 2)));
int dtHour = cvtZToInt(strZ(strSubN(datetime, 11, 2)));
int dtMinute = cvtZToInt(strZ(strSubN(datetime, 14, 2)));
int dtSecond = cvtZToInt(strZ(strSubN(datetime, 17, 2)));
// Confirm date and time parts are valid
datePartsValid(dtYear, dtMonth, dtDay);
@ -162,13 +162,13 @@ getEpoch(const String *targetTime)
String *timezoneOffset = strSub(timeTargetZone, (size_t)idxSign);
// Include the sign with the hour
int tzHour = cvtZToInt(strPtr(strSubN(timezoneOffset, 0, 3)));
int tzHour = cvtZToInt(strZ(strSubN(timezoneOffset, 0, 3)));
int tzMinute = 0;
// If minutes are included in timezone offset then extract the minutes based on whether a colon separates them from
// the hour
if (strSize(timezoneOffset) > 3)
tzMinute = cvtZToInt(strPtr(strSubN(timezoneOffset, 3 + (strChr(timezoneOffset, ':') == -1 ? 0 : 1), 2)));
tzMinute = cvtZToInt(strZ(strSubN(timezoneOffset, 3 + (strChr(timezoneOffset, ':') == -1 ? 0 : 1), 2)));
result = epochFromParts(dtYear, dtMonth, dtDay, dtHour, dtMinute, dtSecond, tzOffsetSeconds(tzHour, tzMinute));
}
@ -189,7 +189,7 @@ getEpoch(const String *targetTime)
"automatic backup set selection cannot be performed with provided time '%s', latest backup set will be used"
"\nHINT: time format must be YYYY-MM-DD HH:MM:SS with optional msec and optional timezone (+/- HH or HHMM or HH:MM)"
" - if timezone is omitted, local time is assumed (for UTC use +00)",
strPtr(targetTime));
strZ(targetTime));
}
}
MEM_CONTEXT_TEMP_END();
@ -249,7 +249,7 @@ restoreBackupSet(InfoBackup *infoBackup)
{
LOG_WARN_FMT(
"unable to find backup set with stop time less than '%s', latest backup set will be used",
strPtr(cfgOptionStr(cfgOptTarget)));
strZ(cfgOptionStr(cfgOptTarget)));
}
}
}
@ -274,7 +274,7 @@ restoreBackupSet(InfoBackup *infoBackup)
}
if (!found)
THROW_FMT(BackupSetInvalidError, "backup set %s is not valid", strPtr(backupSet));
THROW_FMT(BackupSetInvalidError, "backup set %s is not valid", strZ(backupSet));
}
MEM_CONTEXT_PRIOR_BEGIN()
@ -316,7 +316,7 @@ restoreManifestValidate(Manifest *manifest, const String *backupSet)
FormatError,
"requested backup '%s' and manifest label '%s' do not match\n"
"HINT: this indicates some sort of corruption (at the very least paths have been renamed).",
strPtr(backupSet), strPtr(data->backupLabel));
strZ(backupSet), strZ(data->backupLabel));
}
}
MEM_CONTEXT_TEMP_END();
@ -345,7 +345,7 @@ restoreManifestMap(Manifest *manifest)
if (!strEq(targetBase->path, pgPath))
{
LOG_INFO_FMT("remap data directory to '%s'", strPtr(pgPath));
LOG_INFO_FMT("remap data directory to '%s'", strZ(pgPath));
manifestTargetUpdate(manifest, targetBase->name, pgPath, NULL);
}
@ -389,7 +389,7 @@ restoreManifestMap(Manifest *manifest)
{
THROW_FMT(
TablespaceMapError, "tablespace remapped by name '%s' and id %u with different paths",
strPtr(target->tablespaceName), target->tablespaceId);
strZ(target->tablespaceName), target->tablespaceId);
}
// Else set the path by name
else if (tablespacePathByName != NULL)
@ -403,15 +403,15 @@ restoreManifestMap(Manifest *manifest)
// If not individual mapping check if all tablespaces are being remapped
if (tablespacePath == NULL && tablespaceMapAllPath != NULL)
tablespacePath = strNewFmt("%s/%s", strPtr(tablespaceMapAllPath), strPtr(target->tablespaceName));
tablespacePath = strNewFmt("%s/%s", strZ(tablespaceMapAllPath), strZ(target->tablespaceName));
// Remap tablespace if a mapping was found
if (tablespacePath != NULL)
{
LOG_INFO_FMT("map tablespace '%s' to '%s'", strPtr(target->name), strPtr(tablespacePath));
LOG_INFO_FMT("map tablespace '%s' to '%s'", strZ(target->name), strZ(tablespacePath));
manifestTargetUpdate(manifest, target->name, tablespacePath, NULL);
manifestLinkUpdate(manifest, strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strPtr(target->name)), tablespacePath);
manifestLinkUpdate(manifest, strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strZ(target->name)), tablespacePath);
}
}
}
@ -427,7 +427,7 @@ restoreManifestMap(Manifest *manifest)
const String *tablespace = varStr(varLstGet(tablespaceMapList, tablespaceMapIdx));
if (!strLstExists(tablespaceRemapped, tablespace))
THROW_FMT(TablespaceMapError, "unable to remap invalid tablespace '%s'", strPtr(tablespace));
THROW_FMT(TablespaceMapError, "unable to remap invalid tablespace '%s'", strZ(tablespace));
}
}
@ -456,7 +456,7 @@ restoreManifestMap(Manifest *manifest)
// Remap link if a mapping was found
if (linkPath != NULL)
{
LOG_INFO_FMT("map link '%s' to '%s'", strPtr(link), strPtr(linkPath));
LOG_INFO_FMT("map link '%s' to '%s'", strZ(link), strZ(linkPath));
manifestLinkUpdate(manifest, target->name, linkPath);
// If the link is a file separate the file name from the path to update the target
@ -469,8 +469,8 @@ restoreManifestMap(Manifest *manifest)
if (strSize(strPath(linkPath)) == 0)
{
THROW_FMT(
LinkMapError, "'%s' is not long enough to be the destination for file link '%s'", strPtr(linkPath),
strPtr(link));
LinkMapError, "'%s' is not long enough to be the destination for file link '%s'", strZ(linkPath),
strZ(link));
}
linkFile = strBase(linkPath);
@ -486,12 +486,11 @@ restoreManifestMap(Manifest *manifest)
else if (!linkAll)
{
if (target->file != NULL)
LOG_WARN_FMT("file link '%s' will be restored as a file at the same location", strPtr(link));
LOG_WARN_FMT("file link '%s' will be restored as a file at the same location", strZ(link));
else
{
LOG_WARN_FMT(
"contents of directory link '%s' will be restored in a directory at the same location",
strPtr(link));
"contents of directory link '%s' will be restored in a directory at the same location", strZ(link));
}
manifestLinkRemove(manifest, target->name);
@ -512,7 +511,7 @@ restoreManifestMap(Manifest *manifest)
const String *link = varStr(varLstGet(linkMapList, linkMapIdx));
if (!strLstExists(linkRemapped, link))
THROW_FMT(LinkMapError, "unable to remap invalid link '%s'", strPtr(link));
THROW_FMT(LinkMapError, "unable to remap invalid link '%s'", strZ(link));
}
}
}
@ -572,7 +571,7 @@ Check ownership of items in the manifest
const String *owner = strLstGet(type##List, ownerIdx); \
\
if (type##Name() == NULL || !strEq(type##Name(), owner)) \
LOG_WARN_FMT("unknown " #type " '%s' in backup manifest mapped to current " #type, strPtr(owner)); \
LOG_WARN_FMT("unknown " #type " '%s' in backup manifest mapped to current " #type, strZ(owner)); \
} \
} \
while (0)
@ -616,10 +615,10 @@ restoreManifestOwner(Manifest *manifest)
if (userNull || groupNull)
{
if (userNull)
LOG_WARN_FMT("unknown user in backup manifest mapped to '%s'", strPtr(pathInfo.user));
LOG_WARN_FMT("unknown user in backup manifest mapped to '%s'", strZ(pathInfo.user));
if (groupNull)
LOG_WARN_FMT("unknown group in backup manifest mapped to '%s'", strPtr(pathInfo.group));
LOG_WARN_FMT("unknown group in backup manifest mapped to '%s'", strZ(pathInfo.group));
MEM_CONTEXT_PRIOR_BEGIN()
{
@ -708,11 +707,11 @@ restoreCleanOwnership(
{
// If this is a newly created file/link/path then there's no need to log updated permissions
if (!new)
LOG_DETAIL_FMT("update ownership for '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("update ownership for '%s'", strZ(pgPath));
THROW_ON_SYS_ERROR_FMT(
lchown(strPtr(pgPath), expectedUserId, expectedGroupId) == -1, FileOwnerError, "unable to set ownership for '%s'",
strPtr(pgPath));
lchown(strZ(pgPath), expectedUserId, expectedGroupId) == -1, FileOwnerError, "unable to set ownership for '%s'",
strZ(pgPath));
}
FUNCTION_TEST_RETURN_VOID();
@ -734,10 +733,10 @@ restoreCleanMode(const String *pgPath, mode_t manifestMode, const StorageInfo *i
// Update mode if not as expected
if (manifestMode != info->mode)
{
LOG_DETAIL_FMT("update mode for '%s' to %04o", strPtr(pgPath), manifestMode);
LOG_DETAIL_FMT("update mode for '%s' to %04o", strZ(pgPath), manifestMode);
THROW_ON_SYS_ERROR_FMT(
chmod(strPtr(pgPath), manifestMode) == -1, FileOwnerError, "unable to set mode for '%s'", strPtr(pgPath));
chmod(strZ(pgPath), manifestMode) == -1, FileOwnerError, "unable to set mode for '%s'", strZ(pgPath));
}
FUNCTION_TEST_RETURN_VOID();
@ -778,14 +777,14 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
PathNotEmptyError,
"unable to restore to path '%s' because it contains files\n"
"HINT: try using --delta if this is what you intended.",
strPtr(cleanData->targetPath));
strZ(cleanData->targetPath));
}
// Construct the name used to find this file/link/path in the manifest
const String *manifestName = strNewFmt("%s/%s", strPtr(cleanData->targetName), strPtr(info->name));
const String *manifestName = strNewFmt("%s/%s", strZ(cleanData->targetName), strZ(info->name));
// Construct the path of this file/link/path in the PostgreSQL data directory
const String *pgPath = strNewFmt("%s/%s", strPtr(cleanData->targetPath), strPtr(info->name));
const String *pgPath = strNewFmt("%s/%s", strZ(cleanData->targetPath), strZ(info->name));
switch (info->type)
{
@ -800,7 +799,7 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
}
else
{
LOG_DETAIL_FMT("remove invalid file '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("remove invalid file '%s'", strZ(pgPath));
storageRemoveP(storageLocalWrite(), pgPath, .errorOnMissing = true);
}
@ -815,7 +814,7 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
{
if (!strEq(manifestLink->destination, info->linkDestination))
{
LOG_DETAIL_FMT("remove link '%s' because destination changed", strPtr(pgPath));
LOG_DETAIL_FMT("remove link '%s' because destination changed", strZ(pgPath));
storageRemoveP(storageLocalWrite(), pgPath, .errorOnMissing = true);
}
else
@ -823,7 +822,7 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
}
else
{
LOG_DETAIL_FMT("remove invalid link '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("remove invalid link '%s'", strZ(pgPath));
storageRemoveP(storageLocalWrite(), pgPath, .errorOnMissing = true);
}
@ -842,8 +841,8 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
// Recurse into the path
RestoreCleanCallbackData cleanDataSub = *cleanData;
cleanDataSub.targetName = strNewFmt("%s/%s", strPtr(cleanData->targetName), strPtr(info->name));
cleanDataSub.targetPath = strNewFmt("%s/%s", strPtr(cleanData->targetPath), strPtr(info->name));
cleanDataSub.targetName = strNewFmt("%s/%s", strZ(cleanData->targetName), strZ(info->name));
cleanDataSub.targetPath = strNewFmt("%s/%s", strZ(cleanData->targetPath), strZ(info->name));
cleanDataSub.basePath = false;
storageInfoListP(
@ -852,7 +851,7 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
}
else
{
LOG_DETAIL_FMT("remove invalid path '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("remove invalid path '%s'", strZ(pgPath));
storagePathRemoveP(storageLocalWrite(), pgPath, .errorOnMissing = true, .recurse = true);
}
@ -862,7 +861,7 @@ restoreCleanInfoListCallback(void *data, const StorageInfo *info)
// Special file types cannot exist in the manifest so just delete them
case storageTypeSpecial:
{
LOG_DETAIL_FMT("remove special file '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("remove special file '%s'", strZ(pgPath));
storageRemoveP(storageLocalWrite(), pgPath, .errorOnMissing = true);
break;
}
@ -934,8 +933,8 @@ restoreCleanBuild(Manifest *manifest)
// Only PostgreSQL >= 9.0 has tablespace indentifiers
if (tablespaceId != NULL)
{
cleanData->targetName = strNewFmt("%s/%s", strPtr(cleanData->targetName), strPtr(tablespaceId));
cleanData->targetPath = strNewFmt("%s/%s", strPtr(cleanData->targetPath), strPtr(tablespaceId));
cleanData->targetName = strNewFmt("%s/%s", strZ(cleanData->targetName), strZ(tablespaceId));
cleanData->targetPath = strNewFmt("%s/%s", strZ(cleanData->targetPath), strZ(tablespaceId));
}
}
@ -945,7 +944,7 @@ restoreCleanBuild(Manifest *manifest)
// Don't log check for the same path twice. There can be multiple links to files in the same path, but logging it more
// than once makes the logs noisy and looks like a bug.
if (!strLstExists(pathChecked, cleanData->targetPath))
LOG_DETAIL_FMT("check '%s' exists", strPtr(cleanData->targetPath));
LOG_DETAIL_FMT("check '%s' exists", strZ(cleanData->targetPath));
StorageInfo info = storageInfoP(storageLocal(), cleanData->targetPath, .ignoreMissing = true, .followLink = true);
strLstAdd(pathChecked, cleanData->targetPath);
@ -956,13 +955,13 @@ restoreCleanBuild(Manifest *manifest)
if (!userRoot() && userId() != info.userId)
{
THROW_FMT(
PathOpenError, "unable to restore to path '%s' not owned by current user", strPtr(cleanData->targetPath));
PathOpenError, "unable to restore to path '%s' not owned by current user", strZ(cleanData->targetPath));
}
if ((info.mode & 0700) != 0700)
{
THROW_FMT(
PathOpenError, "unable to restore to path '%s' without rwx permissions", strPtr(cleanData->targetPath));
PathOpenError, "unable to restore to path '%s' without rwx permissions", strZ(cleanData->targetPath));
}
// If not a delta restore then check that the directories are empty, or if a file link, that the file doesn't exist
@ -976,7 +975,7 @@ restoreCleanBuild(Manifest *manifest)
}
else
{
const String *file = strNewFmt("%s/%s", strPtr(cleanData->targetPath), strPtr(cleanData->target->file));
const String *file = strNewFmt("%s/%s", strZ(cleanData->targetPath), strZ(cleanData->target->file));
if (storageExistsP(storageLocal(), file))
{
@ -984,7 +983,7 @@ restoreCleanBuild(Manifest *manifest)
FileExistsError,
"unable to restore file '%s' because it already exists\n"
"HINT: try using --delta if this is what you intended.",
strPtr(file));
strZ(file));
}
}
@ -1040,7 +1039,7 @@ restoreCleanBuild(Manifest *manifest)
// Only log when doing a delta restore because otherwise the targets should be empty. We'll still run the clean
// to fix permissions/ownership on the target paths.
if (delta)
LOG_INFO_FMT("remove invalid files/links/paths from '%s'", strPtr(cleanData->targetPath));
LOG_INFO_FMT("remove invalid files/links/paths from '%s'", strZ(cleanData->targetPath));
// Check target ownership/permissions
const ManifestPath *manifestPath = manifestPathFind(cleanData->manifest, cleanData->targetName);
@ -1091,7 +1090,7 @@ restoreCleanBuild(Manifest *manifest)
const ManifestLink *link = manifestLinkFindDefault(
manifest,
strBeginsWith(path->name, MANIFEST_TARGET_PGTBLSPC_STR) ?
strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strPtr(path->name)) : path->name,
strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strZ(path->name)) : path->name,
NULL);
if (link != NULL)
@ -1102,11 +1101,11 @@ restoreCleanBuild(Manifest *manifest)
// Create the link if it is missing. If it exists it should already have the correct ownership and destination.
if (!linkInfo.exists)
{
LOG_DETAIL_FMT("create symlink '%s' to '%s'", strPtr(pgPath), strPtr(link->destination));
LOG_DETAIL_FMT("create symlink '%s' to '%s'", strZ(pgPath), strZ(link->destination));
THROW_ON_SYS_ERROR_FMT(
symlink(strPtr(link->destination), strPtr(pgPath)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strPtr(pgPath), strPtr(link->destination));
symlink(strZ(link->destination), strZ(pgPath)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strZ(pgPath), strZ(link->destination));
restoreCleanOwnership(pgPath, link->user, link->group, userId(), groupId(), true);
}
}
@ -1119,7 +1118,7 @@ restoreCleanBuild(Manifest *manifest)
// Create the path if it is missing If it exists it should already have the correct ownership and mode.
if (!pathInfo.exists)
{
LOG_DETAIL_FMT("create path '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("create path '%s'", strZ(pgPath));
storagePathCreateP(storagePgWrite(), pgPath, .mode = path->mode, .noParentCreate = true, .errorOnExists = true);
restoreCleanOwnership(storagePathP(storagePg(), pgPath), path->user, path->group, userId(), groupId(), true);
@ -1139,11 +1138,11 @@ restoreCleanBuild(Manifest *manifest)
// Create the link if it is missing. If it exists it should already have the correct ownership and destination.
if (!linkInfo.exists)
{
LOG_DETAIL_FMT("create symlink '%s' to '%s'", strPtr(pgPath), strPtr(link->destination));
LOG_DETAIL_FMT("create symlink '%s' to '%s'", strZ(pgPath), strZ(link->destination));
THROW_ON_SYS_ERROR_FMT(
symlink(strPtr(link->destination), strPtr(pgPath)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strPtr(pgPath), strPtr(link->destination));
symlink(strZ(link->destination), strZ(pgPath)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strZ(pgPath), strZ(link->destination));
restoreCleanOwnership(pgPath, link->user, link->group, userId(), groupId(), true);
}
}
@ -1184,7 +1183,7 @@ restoreSelectiveExpression(Manifest *manifest)
else
{
tablespaceRegExp = regExpNew(
strNewFmt("^" MANIFEST_TARGET_PGTBLSPC "/[0-9]+/%s/[0-9]+/" PG_FILE_PGVERSION, strPtr(tablespaceId)));
strNewFmt("^" MANIFEST_TARGET_PGTBLSPC "/[0-9]+/%s/[0-9]+/" PG_FILE_PGVERSION, strZ(tablespaceId)));
}
// Generate a list of databases in base or in a tablespace
@ -1205,7 +1204,7 @@ restoreSelectiveExpression(Manifest *manifest)
THROW(FormatError, "no databases found for selective restore\nHINT: is this a valid cluster?");
// Log databases found
LOG_DETAIL_FMT("databases found for selective restore (%s)", strPtr(strLstJoin(dbList, ", ")));
LOG_DETAIL_FMT("databases found for selective restore (%s)", strZ(strLstJoin(dbList, ", ")));
// Remove included databases from the list
const StringList *includeList = strLstNewVarLst(cfgOptionLst(cfgOptDbInclude));
@ -1220,14 +1219,14 @@ restoreSelectiveExpression(Manifest *manifest)
const ManifestDb *db = manifestDbFindDefault(manifest, includeDb, NULL);
if (db == NULL || !strLstExists(dbList, varStrForce(VARUINT(db->id))))
THROW_FMT(DbMissingError, "database to include '%s' does not exist", strPtr(includeDb));
THROW_FMT(DbMissingError, "database to include '%s' does not exist", strZ(includeDb));
// Set the include db to the id if the name mapping was successful
includeDb = varStrForce(VARUINT(db->id));
}
// Error if the db is a system db
if (cvtZToUInt64(strPtr(includeDb)) < PG_USER_OBJECT_MIN_ID)
if (cvtZToUInt64(strZ(includeDb)) < PG_USER_OBJECT_MIN_ID)
THROW(DbInvalidError, "system databases (template0, postgres, etc.) are included by default");
// Remove from list of DBs to zero
@ -1243,7 +1242,7 @@ restoreSelectiveExpression(Manifest *manifest)
const String *db = strLstGet(dbList, dbIdx);
// Only user created databases can be zeroed, never system databases
if (cvtZToUInt64(strPtr(db)) >= PG_USER_OBJECT_MIN_ID)
if (cvtZToUInt64(strZ(db)) >= PG_USER_OBJECT_MIN_ID)
{
// Create expression string or append |
if (expression == NULL)
@ -1252,7 +1251,7 @@ restoreSelectiveExpression(Manifest *manifest)
strCatZ(expression, "|");
// Filter files in base directory
strCatFmt(expression, "(^" MANIFEST_TARGET_PGDATA "/" PG_PATH_BASE "/%s/)", strPtr(db));
strCatFmt(expression, "(^" MANIFEST_TARGET_PGDATA "/" PG_PATH_BASE "/%s/)", strZ(db));
// Filter files in tablespace directories
for (unsigned int targetIdx = 0; targetIdx < manifestTargetTotal(manifest); targetIdx++)
@ -1262,9 +1261,9 @@ restoreSelectiveExpression(Manifest *manifest)
if (target->tablespaceId != 0)
{
if (tablespaceId == NULL)
strCatFmt(expression, "|(^%s/%s/)", strPtr(target->name), strPtr(db));
strCatFmt(expression, "|(^%s/%s/)", strZ(target->name), strZ(db));
else
strCatFmt(expression, "|(^%s/%s/%s/)", strPtr(target->name), strPtr(tablespaceId), strPtr(db));
strCatFmt(expression, "|(^%s/%s/%s/)", strZ(target->name), strZ(tablespaceId), strZ(db));
}
}
}
@ -1349,8 +1348,8 @@ restoreRecoveryOption(unsigned int pgVersion)
result, VARSTRZ(RESTORE_COMMAND),
VARSTR(
strNewFmt(
"%s %s %%f \"%%p\"", strPtr(cfgExe()),
strPtr(strLstJoin(cfgExecParam(cfgCmdArchiveGet, cfgCmdRoleDefault, optionReplace, true, true), " ")))));
"%s %s %%f \"%%p\"", strZ(cfgExe()),
strZ(strLstJoin(cfgExecParam(cfgCmdArchiveGet, cfgCmdRoleDefault, optionReplace, true, true), " ")))));
}
// If recovery type is immediate
@ -1370,7 +1369,7 @@ restoreRecoveryOption(unsigned int pgVersion)
{
// Write the recovery target
kvPut(
result, VARSTR(strNewFmt(RECOVERY_TARGET "_%s", strPtr(cfgOptionStr(cfgOptType)))),
result, VARSTR(strNewFmt(RECOVERY_TARGET "_%s", strZ(cfgOptionStr(cfgOptType)))),
VARSTR(cfgOptionStr(cfgOptTarget)));
// Write recovery_target_inclusive
@ -1399,7 +1398,7 @@ restoreRecoveryOption(unsigned int pgVersion)
THROW_FMT(
OptionInvalidError,
CFGOPT_TARGET_ACTION "=" RECOVERY_TARGET_ACTION_SHUTDOWN " is only available in PostgreSQL >= %s",
strPtr(pgVersionToStr(PG_VERSION_RECOVERY_TARGET_ACTION)));
strZ(pgVersionToStr(PG_VERSION_RECOVERY_TARGET_ACTION)));
}
kvPut(result, VARSTRZ(PAUSE_AT_RECOVERY_TARGET), VARSTR(FALSE_STR));
@ -1409,7 +1408,7 @@ restoreRecoveryOption(unsigned int pgVersion)
{
THROW_FMT(
OptionInvalidError, CFGOPT_TARGET_ACTION " option is only available in PostgreSQL >= %s",
strPtr(pgVersionToStr(PG_VERSION_RECOVERY_TARGET_PAUSE)));
strZ(pgVersionToStr(PG_VERSION_RECOVERY_TARGET_PAUSE)));
}
}
}
@ -1439,7 +1438,7 @@ restoreRecoveryConf(unsigned int pgVersion, const String *restoreLabel)
MEM_CONTEXT_TEMP_BEGIN()
{
result = strNewFmt("# Recovery settings generated by " PROJECT_NAME " restore on %s\n", strPtr(restoreLabel));
result = strNewFmt("# Recovery settings generated by " PROJECT_NAME " restore on %s\n", strZ(restoreLabel));
// Output all recovery options
KeyValue *optionKv = restoreRecoveryOption(pgVersion);
@ -1448,7 +1447,7 @@ restoreRecoveryConf(unsigned int pgVersion, const String *restoreLabel)
for (unsigned int optionKeyIdx = 0; optionKeyIdx < varLstSize(optionKeyList); optionKeyIdx++)
{
const Variant *optionKey = varLstGet(optionKeyList, optionKeyIdx);
strCatFmt(result, "%s = '%s'\n", strPtr(varStr(optionKey)), strPtr(varStr(kvGet(optionKv, optionKey))));
strCatFmt(result, "%s = '%s'\n", strZ(varStr(optionKey)), strZ(varStr(kvGet(optionKv, optionKey))));
}
// Move to prior context
@ -1476,7 +1475,7 @@ restoreRecoveryWriteConf(const Manifest *manifest, unsigned int pgVersion, const
// Only write recovery.conf if recovery type != none
if (!strEq(cfgOptionStr(cfgOptType), RECOVERY_TYPE_NONE_STR))
{
LOG_INFO_FMT("write %s", strPtr(storagePathP(storagePg(), PG_FILE_RECOVERYCONF_STR)));
LOG_INFO_FMT("write %s", strZ(storagePathP(storagePg(), PG_FILE_RECOVERYCONF_STR)));
// Use the data directory to set permissions and ownership for recovery file
const ManifestPath *dataPath = manifestPathFind(manifest, MANIFEST_TARGET_PGDATA_STR);
@ -1540,7 +1539,7 @@ restoreRecoveryWriteAutoConf(unsigned int pgVersion, const String *restoreLabel)
const String *line = strLstGet(contentList, contentIdx);
if (regExpMatch(recoveryExp, line))
strCatFmt(content, "# Removed by " PROJECT_NAME " restore on %s # ", strPtr(restoreLabel));
strCatFmt(content, "# Removed by " PROJECT_NAME " restore on %s # ", strZ(restoreLabel));
strCat(content, line);
}
@ -1578,16 +1577,16 @@ restoreRecoveryWriteAutoConf(unsigned int pgVersion, const String *restoreLabel)
"'" STANDBY_MODE "' setting is not valid for " PG_NAME " >= %s\n"
"HINT: use --" CFGOPT_TYPE "=" RECOVERY_TYPE_STANDBY " instead of --" CFGOPT_RECOVERY_OPTION "="
STANDBY_MODE "=on.",
strPtr(pgVersionToStr(PG_VERSION_RECOVERY_GUC)));
strZ(pgVersionToStr(PG_VERSION_RECOVERY_GUC)));
}
}
}
strCatFmt(content, "%s", strPtr(restoreRecoveryConf(pgVersion, restoreLabel)));
strCatFmt(content, "%s", strZ(restoreRecoveryConf(pgVersion, restoreLabel)));
}
LOG_INFO_FMT(
"write %s%s", autoConf == NULL ? "" : "updated ", strPtr(storagePathP(storagePg(), PG_FILE_POSTGRESQLAUTOCONF_STR)));
"write %s%s", autoConf == NULL ? "" : "updated ", strZ(storagePathP(storagePg(), PG_FILE_POSTGRESQLAUTOCONF_STR)));
// Use the data directory to set permissions and ownership for recovery file
const StorageInfo dataPath = storageInfoP(storagePg(), NULL);
@ -1645,7 +1644,7 @@ restoreRecoveryWrite(const Manifest *manifest)
{
LOG_WARN_FMT(
"recovery type is " RECOVERY_TYPE_PRESERVE " but recovery file does not exist at '%s'",
strPtr(storagePathP(storagePg(), recoveryFile)));
strZ(storagePathP(storagePg(), recoveryFile)));
}
}
// Else write recovery file
@ -1720,7 +1719,7 @@ restoreProcessQueue(Manifest *manifest, List **queueList)
const ManifestTarget *target = manifestTarget(manifest, targetIdx);
if (target->tablespaceId != 0)
strLstAdd(targetList, strNewFmt("%s/", strPtr(target->name)));
strLstAdd(targetList, strNewFmt("%s/", strZ(target->name)));
}
// Generate the processing queues
@ -1803,10 +1802,10 @@ restoreFilePgPath(const Manifest *manifest, const String *manifestName)
ASSERT(manifest != NULL);
ASSERT(manifestName != NULL);
String *result = strNewFmt("%s/%s", strPtr(manifestTargetBase(manifest)->path), strPtr(manifestPathPg(manifestName)));
String *result = strNewFmt("%s/%s", strZ(manifestTargetBase(manifest)->path), strZ(manifestPathPg(manifestName)));
if (strEq(manifestName, STRDEF(MANIFEST_TARGET_PGDATA "/" PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL)))
result = strNewFmt("%s." STORAGE_FILE_TEMP_EXT, strPtr(result));
result = strNewFmt("%s." STORAGE_FILE_TEMP_EXT, strZ(result));
FUNCTION_TEST_RETURN(result);
}
@ -1840,7 +1839,7 @@ restoreJobResult(const Manifest *manifest, ProtocolParallelJob *job, RegExp *zer
strCatZ(log, " zeroed");
// Add filename
strCatFmt(log, " file %s", strPtr(restoreFilePgPath(manifest, file->name)));
strCatFmt(log, " file %s", strZ(restoreFilePgPath(manifest, file->name)));
// If not copied and not zeroed add details to explain why it was not copied
if (!copy && !zeroed)
@ -1872,13 +1871,13 @@ restoreJobResult(const Manifest *manifest, ProtocolParallelJob *job, RegExp *zer
// Add size and percent complete
sizeRestored += file->size;
strCatFmt(log, " (%s, %" PRIu64 "%%)", strPtr(strSizeFormat(file->size)), sizeRestored * 100 / sizeTotal);
strCatFmt(log, " (%s, %" PRIu64 "%%)", strZ(strSizeFormat(file->size)), sizeRestored * 100 / sizeTotal);
// If not zero-length add the checksum
if (file->size != 0 && !zeroed)
strCatFmt(log, " checksum %s", file->checksumSha1);
LOG_PID(copy ? logLevelInfo : logLevelDetail, protocolParallelJobProcessId(job), 0, strPtr(log));
LOG_PID(copy ? logLevelInfo : logLevelDetail, protocolParallelJobProcessId(job), 0, strZ(log));
}
MEM_CONTEXT_TEMP_END();
@ -1887,7 +1886,7 @@ restoreJobResult(const Manifest *manifest, ProtocolParallelJob *job, RegExp *zer
}
// Else the job errored
else
THROW_CODE(protocolParallelJobErrorCode(job), strPtr(protocolParallelJobErrorMessage(job)));
THROW_CODE(protocolParallelJobErrorCode(job), strZ(protocolParallelJobErrorMessage(job)));
FUNCTION_LOG_RETURN(UINT64, sizeRestored);
}
@ -2026,7 +2025,7 @@ cmdRestore(void)
RestoreJobData jobData = {0};
jobData.manifest = manifestLoadFile(
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupSet)),
storageRepo(), strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupSet)),
cipherType(cfgOptionStr(cfgOptRepoCipherType)), infoPgCipherPass(infoBackupPg(infoBackup)));
// Validate manifest. Don't use strict mode because we'd rather ignore problems that won't affect a restore.
@ -2039,7 +2038,7 @@ cmdRestore(void)
restoreManifestValidate(jobData.manifest, backupSet);
// Log the backup set to restore
LOG_INFO_FMT("restore backup set %s", strPtr(backupSet));
LOG_INFO_FMT("restore backup set %s", strZ(backupSet));
// Map manifest
restoreManifestMap(jobData.manifest);
@ -2111,7 +2110,7 @@ cmdRestore(void)
strLstAdd(pathSynced, pgPath);
// Sync the path
LOG_DETAIL_FMT("sync path '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("sync path '%s'", strZ(pgPath));
storagePathSyncP(storageLocalWrite(), pgPath);
}
}
@ -2132,7 +2131,7 @@ cmdRestore(void)
const String *pgPath = storagePathP(storagePg(), manifestPathPg(manifestName));
LOG_DETAIL_FMT("sync path '%s'", strPtr(pgPath));
LOG_DETAIL_FMT("sync path '%s'", strZ(pgPath));
storagePathSyncP(storagePgWrite(), pgPath);
}
@ -2151,7 +2150,7 @@ cmdRestore(void)
LOG_WARN("backup does not contain '" PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL "' -- cluster will not start");
// Sync global path
LOG_DETAIL_FMT("sync path '%s'", strPtr(storagePathP(storagePg(), PG_PATH_GLOBAL_STR)));
LOG_DETAIL_FMT("sync path '%s'", strZ(storagePathP(storagePg(), PG_PATH_GLOBAL_STR)));
storagePathSyncP(storagePgWrite(), PG_PATH_GLOBAL_STR);
}
MEM_CONTEXT_TEMP_END();

2
src/command/stanza/create.c
View File

@ -123,7 +123,7 @@ cmdStanzaCreate(void)
// If no files copied, then the stanza was already valid
if (sourceFile == NULL)
LOG_INFO_FMT("stanza '%s' already exists and is valid", strPtr(cfgOptionStr(cfgOptStanza)));
LOG_INFO_FMT("stanza '%s' already exists and is valid", strZ(cfgOptionStr(cfgOptStanza)));
}
// Else if both .info and corresponding .copy file are missing for one but not the other, then error
else

8
src/command/stanza/delete.c
View File

@ -41,10 +41,10 @@ manifestDelete(const Storage *storageRepoWriteStanza)
for (unsigned int idx = 0; idx < strLstSize(backupList); idx++)
{
storageRemoveP(
storageRepoWriteStanza, strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(strLstGet(backupList, idx))));
storageRepoWriteStanza, strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(strLstGet(backupList, idx))));
storageRemoveP(
storageRepoWriteStanza,
strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strPtr(strLstGet(backupList, idx))));
strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE INFO_COPY_EXT, strZ(strLstGet(backupList, idx))));
}
FUNCTION_TEST_RETURN_VOID();
@ -79,7 +79,7 @@ stanzaDelete(const Storage *storageRepoWriteStanza, const StringList *archiveLis
THROW_FMT(
FileMissingError, "stop file does not exist for stanza '%s'\n"
"HINT: has the pgbackrest stop command been run on this server for this stanza?",
strPtr(cfgOptionStr(cfgOptStanza)));
strZ(cfgOptionStr(cfgOptStanza)));
}
// If a force has not been issued and Postgres is running, then error
@ -88,7 +88,7 @@ stanzaDelete(const Storage *storageRepoWriteStanza, const StringList *archiveLis
THROW_FMT(
PgRunningError, PG_FILE_POSTMASTERPID " exists - looks like " PG_NAME " is running. "
"To delete stanza '%s', shut down " PG_NAME " for stanza '%s' and try again, or use --force.",
strPtr(cfgOptionStr(cfgOptStanza)), strPtr(cfgOptionStr(cfgOptStanza)));
strZ(cfgOptionStr(cfgOptStanza)), strZ(cfgOptionStr(cfgOptStanza)));
}
// Delete the archive info files

2
src/command/stanza/upgrade.c
View File

@ -92,7 +92,7 @@ cmdStanzaUpgrade(void)
}
if (!(infoArchiveUpgrade || infoBackupUpgrade))
LOG_INFO_FMT("stanza '%s' is already up to date", strPtr(cfgOptionStr(cfgOptStanza)));
LOG_INFO_FMT("stanza '%s' is already up to date", strZ(cfgOptionStr(cfgOptStanza)));
}
MEM_CONTEXT_TEMP_END();

10
src/common/compress/helper.c
View File

@ -120,7 +120,7 @@ compressTypeEnum(const String *type)
}
if (result == COMPRESS_LIST_SIZE)
THROW_FMT(AssertError, "invalid compression type '%s'", strPtr(type));
THROW_FMT(AssertError, "invalid compression type '%s'", strZ(type));
FUNCTION_TEST_RETURN(result);
}
@ -136,11 +136,7 @@ compressTypePresent(CompressType type)
ASSERT(type < COMPRESS_LIST_SIZE);
if (type != compressTypeNone && compressHelperLocal[type].compressNew == NULL)
{
THROW_FMT(
OptionInvalidValueError, PROJECT_NAME " not compiled with %s support",
strPtr(compressHelperLocal[type].type));
}
THROW_FMT(OptionInvalidValueError, PROJECT_NAME " not compiled with %s support", strZ(compressHelperLocal[type].type));
FUNCTION_TEST_RETURN_VOID();
}
@ -298,7 +294,7 @@ compressExtStrip(const String *file, CompressType type)
ASSERT(file != NULL);
if (!strEndsWith(file, compressExtStr(type)))
THROW_FMT(FormatError, "'%s' must have '%s' extension", strPtr(file), strPtr(compressExtStr(type)));
THROW_FMT(FormatError, "'%s' must have '%s' extension", strZ(file), strZ(compressExtStr(type)));
FUNCTION_TEST_RETURN(strSubN(file, 0, strSize(file) - strSize(compressExtStr(type))));
}

8
src/common/crypto/cipherBlock.c
View File

@ -399,21 +399,21 @@ cipherBlockNew(CipherMode mode, CipherType cipherType, const Buffer *pass, const
// Lookup cipher by name. This means the ciphers passed in must exactly match a name expected by OpenSSL. This is a good
// thing since the name required by the openssl command-line tool will match what is used by pgBackRest.
const EVP_CIPHER *cipher = EVP_get_cipherbyname(strPtr(cipherTypeName(cipherType)));
const EVP_CIPHER *cipher = EVP_get_cipherbyname(strZ(cipherTypeName(cipherType)));
if (!cipher)
THROW_FMT(AssertError, "unable to load cipher '%s'", strPtr(cipherTypeName(cipherType)));
THROW_FMT(AssertError, "unable to load cipher '%s'", strZ(cipherTypeName(cipherType)));
// Lookup digest. If not defined it will be set to sha1.
const EVP_MD *digest = NULL;
if (digestName)
digest = EVP_get_digestbyname(strPtr(digestName));
digest = EVP_get_digestbyname(strZ(digestName));
else
digest = EVP_sha1();
if (!digest)
THROW_FMT(AssertError, "unable to load digest '%s'", strPtr(digestName));
THROW_FMT(AssertError, "unable to load digest '%s'", strZ(digestName));
// Allocate memory to hold process state
IoFilter *this = NULL;

2
src/common/crypto/common.c
View File

@ -69,7 +69,7 @@ cipherType(const String *name)
if (strEq(name, CIPHER_TYPE_AES_256_CBC_STR))
result = cipherTypeAes256Cbc;
else if (!strEq(name, CIPHER_TYPE_NONE_STR))
THROW_FMT(AssertError, "invalid cipher name '%s'", strPtr(name));
THROW_FMT(AssertError, "invalid cipher name '%s'", strZ(name));
FUNCTION_TEST_RETURN(result);
}

6
src/common/crypto/hash.c
View File

@ -193,8 +193,8 @@ cryptoHashNew(const String *type)
else
{
// Lookup digest
if ((driver->hashType = EVP_get_digestbyname(strPtr(type))) == NULL)
THROW_FMT(AssertError, "unable to load hash '%s'", strPtr(type));
if ((driver->hashType = EVP_get_digestbyname(strZ(type))) == NULL)
THROW_FMT(AssertError, "unable to load hash '%s'", strZ(type));
// Create context
cryptoError((driver->hashContext = EVP_MD_CTX_create()) == NULL, "unable to create hash context");
@ -275,7 +275,7 @@ cryptoHmacOne(const String *type, const Buffer *key, const Buffer *message)
// Init crypto subsystem
cryptoInit();
const EVP_MD *hashType = EVP_get_digestbyname(strPtr(type));
const EVP_MD *hashType = EVP_get_digestbyname(strZ(type));
ASSERT(hashType != NULL);
// Allocate a buffer to hold the hmac

18
src/common/exec.c
View File

@ -98,7 +98,7 @@ OBJECT_DEFINE_FREE_RESOURCE_BEGIN(EXEC, LOG, logLevelTrace)
// If the process did not exit then error -- else we may end up with a collection of zombie processes
if (processResult == 0)
THROW_FMT(ExecuteError, "%s did not exit when expected", strPtr(this->name));
THROW_FMT(ExecuteError, "%s did not exit when expected", strZ(this->name));
}
MEM_CONTEXT_TEMP_END();
}
@ -175,18 +175,18 @@ execCheck(Exec *this)
if (WIFEXITED(processStatus))
{
// Get data from stderr to help diagnose the problem
IoRead *ioReadError = ioHandleReadNew(strNewFmt("%s error", strPtr(this->name)), this->handleError, 0);
IoRead *ioReadError = ioHandleReadNew(strNewFmt("%s error", strZ(this->name)), this->handleError, 0);
ioReadOpen(ioReadError);
String *errorStr = strTrim(strNewBuf(ioReadBuf(ioReadError)));
// Throw the error with as much information as is available
THROWP_FMT(
errorTypeFromCode(WEXITSTATUS(processStatus)), "%s terminated unexpectedly [%d]%s%s", strPtr(this->name),
WEXITSTATUS(processStatus), strSize(errorStr) > 0 ? ": " : "", strSize(errorStr) > 0 ? strPtr(errorStr) : "");
errorTypeFromCode(WEXITSTATUS(processStatus)), "%s terminated unexpectedly [%d]%s%s", strZ(this->name),
WEXITSTATUS(processStatus), strSize(errorStr) > 0 ? ": " : "", strSize(errorStr) > 0 ? strZ(errorStr) : "");
}
// If the process did not exit normally then it must have been a signal
THROW_FMT(ExecuteError, "%s terminated unexpectedly on signal %d", strPtr(this->name), WTERMSIG(processStatus));
THROW_FMT(ExecuteError, "%s terminated unexpectedly on signal %d", strZ(this->name), WTERMSIG(processStatus));
}
FUNCTION_LOG_RETURN_VOID();
@ -333,11 +333,11 @@ execOpen(Exec *this)
PIPE_DUP2(pipeError, 1, STDERR_FILENO);
// Execute the binary. This statement will not return if it is successful
execvp(strPtr(this->command), (char ** const)strLstPtr(this->param));
execvp(strZ(this->command), (char ** const)strLstPtr(this->param));
// If we got here then there was an error. We can't use a throw as we normally would because we have already shutdown
// logging and we don't want to execute exit paths that might free parent resources which we still have references to.
fprintf(stderr, "unable to execute '%s': [%d] %s\n", strPtr(this->command), errno, strerror(errno));
fprintf(stderr, "unable to execute '%s': [%d] %s\n", strZ(this->command), errno, strerror(errno));
exit(errorTypeCode(&ExecuteError));
}
@ -352,8 +352,8 @@ execOpen(Exec *this)
this->handleError = pipeError[0];
// Assign handles to io interfaces
this->ioReadHandle = ioHandleReadNew(strNewFmt("%s read", strPtr(this->name)), this->handleRead, this->timeout);
this->ioWriteHandle = ioHandleWriteNew(strNewFmt("%s write", strPtr(this->name)), this->handleWrite);
this->ioReadHandle = ioHandleReadNew(strNewFmt("%s read", strZ(this->name)), this->handleRead, this->timeout);
this->ioWriteHandle = ioHandleWriteNew(strNewFmt("%s write", strZ(this->name)), this->handleWrite);
ioWriteOpen(this->ioWriteHandle);
// Create wrapper interfaces that check process state

6
src/common/ini.c
View File

@ -78,7 +78,7 @@ iniGetInternal(const Ini *this, const String *section, const String *key, bool r
// If value is null and required then error
if (result == NULL && required)
THROW_FMT(FormatError, "section '%s', key '%s' does not exist", strPtr(section), strPtr(key));
THROW_FMT(FormatError, "section '%s', key '%s' does not exist", strZ(section), strZ(key));
FUNCTION_TEST_RETURN(result);
}
@ -251,7 +251,7 @@ iniParse(Ini *this, const String *content)
{
// Get next line
const String *line = strTrim(strLstGet(lines, lineIdx));
const char *linePtr = strPtr(line);
const char *linePtr = strZ(line);
// Only interested in lines that are not blank or comments
if (strSize(line) > 0 && linePtr[0] != '#')
@ -358,7 +358,7 @@ iniLoad(
do
{
const String *line = strTrim(ioReadLineParam(read, true));
const char *linePtr = strPtr(line);
const char *linePtr = strZ(line);
// Only interested in lines that are not blank or comments
if (strSize(line) > 0 && linePtr[0] != '#')

2
src/common/io/filter/filter.c
View File

@ -226,5 +226,5 @@ ioFilterType(const IoFilter *this)
String *
ioFilterToLog(const IoFilter *this)
{
return strNewFmt("{type: %s}", strPtr(this->type));
return strNewFmt("{type: %s}", strZ(this->type));
}

6
src/common/io/handleRead.c
View File

@ -72,16 +72,16 @@ ioHandleRead(THIS_VOID, Buffer *buffer, bool block)
// Determine if there is data to be read
int result = select(this->handle + 1, &selectSet, NULL, NULL, &timeoutSelect);
THROW_ON_SYS_ERROR_FMT(result == -1, FileReadError, "unable to select from %s", strPtr(this->name));
THROW_ON_SYS_ERROR_FMT(result == -1, FileReadError, "unable to select from %s", strZ(this->name));
// If no data read after time allotted then error
if (!result)
THROW_FMT(FileReadError, "unable to read data from %s after %" PRIu64 "ms", strPtr(this->name), this->timeout);
THROW_FMT(FileReadError, "unable to read data from %s after %" PRIu64 "ms", strZ(this->name), this->timeout);
// Read and handle errors
THROW_ON_SYS_ERROR_FMT(
(actualBytes = read(this->handle, bufRemainsPtr(buffer), bufRemains(buffer))) == -1, FileReadError,
"unable to read from %s", strPtr(this->name));
"unable to read from %s", strZ(this->name));
// Update amount of buffer used
bufUsedInc(buffer, (size_t)actualBytes);

5
src/common/io/handleWrite.c
View File

@ -47,8 +47,7 @@ ioHandleWrite(THIS_VOID, const Buffer *buffer)
ASSERT(buffer != NULL);
THROW_ON_SYS_ERROR_FMT(
write(this->handle, bufPtrConst(buffer), bufUsed(buffer)) == -1, FileWriteError,
"unable to write to %s", strPtr(this->name));
write(this->handle, bufPtrConst(buffer), bufUsed(buffer)) == -1, FileWriteError, "unable to write to %s", strZ(this->name));
FUNCTION_LOG_RETURN_VOID();
}
@ -109,7 +108,7 @@ ioHandleWriteOneStr(int handle, const String *string)
ASSERT(string != NULL);
if (write(handle, strPtr(string), strSize(string)) != (int)strSize(string))
if (write(handle, strZ(string), strSize(string)) != (int)strSize(string))
THROW_SYS_ERROR(FileWriteError, "unable to write to handle");
FUNCTION_LOG_RETURN_VOID();

16
src/common/io/http/common.c
View File

@ -28,7 +28,7 @@ httpDateToTime(const String *lastModified)
MEM_CONTEXT_TEMP_BEGIN()
{
// Find the month
const char *month = strPtr(strSubN(lastModified, 8, 3));
const char *month = strZ(strSubN(lastModified, 8, 3));
unsigned int monthIdx = 0;
for (; monthIdx < sizeof(httpCommonMonthList) / sizeof(char *); monthIdx++)
@ -42,9 +42,9 @@ httpDateToTime(const String *lastModified)
// Convert to time_t
result = epochFromParts(
cvtZToInt(strPtr(strSubN(lastModified, 12, 4))), (int)monthIdx + 1, cvtZToInt(strPtr(strSubN(lastModified, 5, 2))),
cvtZToInt(strPtr(strSubN(lastModified, 17, 2))), cvtZToInt(strPtr(strSubN(lastModified, 20, 2))),
cvtZToInt(strPtr(strSubN(lastModified, 23, 2))), 0);
cvtZToInt(strZ(strSubN(lastModified, 12, 4))), (int)monthIdx + 1, cvtZToInt(strZ(strSubN(lastModified, 5, 2))),
cvtZToInt(strZ(strSubN(lastModified, 17, 2))), cvtZToInt(strZ(strSubN(lastModified, 20, 2))),
cvtZToInt(strZ(strSubN(lastModified, 23, 2))), 0);
}
MEM_CONTEXT_TEMP_END();
@ -87,17 +87,17 @@ httpUriDecode(const String *uri)
// Iterate all characters in the string
for (unsigned uriIdx = 0; uriIdx < strSize(uri); uriIdx++)
{
char uriChar = strPtr(uri)[uriIdx];
char uriChar = strZ(uri)[uriIdx];
// Convert escaped characters
if (uriChar == '%')
{
// Sequence must be exactly three characters (% and two hex digits)
if (strSize(uri) - uriIdx < 3)
THROW_FMT(FormatError, "invalid escape sequence length in '%s'", strPtr(uri));
THROW_FMT(FormatError, "invalid escape sequence length in '%s'", strZ(uri));
// Convert hex digits
uriChar = (char)cvtZToUIntBase(strPtr(strSubN(uri, uriIdx + 1, 2)), 16);
uriChar = (char)cvtZToUIntBase(strZ(strSubN(uri, uriIdx + 1, 2)), 16);
// Skip to next character or escape
uriIdx += 2;
@ -131,7 +131,7 @@ httpUriEncode(const String *uri, bool path)
// Iterate all characters in the string
for (unsigned uriIdx = 0; uriIdx < strSize(uri); uriIdx++)
{
char uriChar = strPtr(uri)[uriIdx];
char uriChar = strZ(uri)[uriIdx];
// These characters are reproduced verbatim
if ((uriChar >= 'A' && uriChar <= 'Z') || (uriChar >= 'a' && uriChar <= 'z') || (uriChar >= '0' && uriChar <= '9') ||

6
src/common/io/http/header.c
View File

@ -105,7 +105,7 @@ httpHeaderAdd(HttpHeader *this, const String *key, const String *value)
{
String *valueAppend = strDup(varStr(valueVar));
strCatZ(valueAppend, ", ");
strCatZ(valueAppend, strPtr(value));
strCatZ(valueAppend, strZ(value));
kvPut(this->kv, keyVar, VARSTR(valueAppend));
}
@ -196,9 +196,9 @@ httpHeaderToLog(const HttpHeader *this)
strCatZ(result, ", ");
if (httpHeaderRedact(this, key))
strCatFmt(result, "%s: <redacted>", strPtr(key));
strCatFmt(result, "%s: <redacted>", strZ(key));
else
strCatFmt(result, "%s: '%s'", strPtr(key), strPtr(httpHeaderGet(this, key)));
strCatFmt(result, "%s: '%s'", strZ(key), strZ(httpHeaderGet(this, key)));
}
strCatZ(result, "}");

14
src/common/io/http/query.c
View File

@ -89,8 +89,8 @@ httpQueryNewStr(const String *query)
if (strLstSize(keyValue) != 2)
{
THROW_FMT(
FormatError, "invalid key/value '%s' in query '%s'", strPtr(strLstGet(keyValueList, keyValueIdx)),
strPtr(query));
FormatError, "invalid key/value '%s' in query '%s'", strZ(strLstGet(keyValueList, keyValueIdx)),
strZ(query));
}
httpQueryAdd(this, httpUriDecode(strLstGet(keyValue, 0)), httpUriDecode(strLstGet(keyValue, 1)));
@ -152,7 +152,7 @@ httpQueryAdd(HttpQuery *this, const String *key, const String *value)
const Variant *keyVar = VARSTR(key);
if (kvGet(this->kv, keyVar) != NULL)
THROW_FMT(AssertError, "key '%s' already exists", strPtr(key));
THROW_FMT(AssertError, "key '%s' already exists", strZ(key));
// Store the key
kvPut(this->kv, keyVar, VARSTR(value));
@ -284,9 +284,9 @@ httpQueryRender(const HttpQuery *this, HttpQueryRenderParam param)
strCatZ(result, "&");
strCatFmt(
result, "%s=%s", strPtr(key),
result, "%s=%s", strZ(key),
param.redact && httpQueryRedact(this, key) ?
"<redacted>" : strPtr(httpUriEncode(httpQueryGet(this, key), false)));
"<redacted>" : strZ(httpUriEncode(httpQueryGet(this, key), false)));
}
}
}
@ -310,12 +310,12 @@ httpQueryToLog(const HttpQuery *this)
if (strSize(result) != 1)
strCatZ(result, ", ");
strCatFmt(result, "%s: ", strPtr(key));
strCatFmt(result, "%s: ", strZ(key));
if (httpQueryRedact(this, key))
strCatZ(result, "<redacted>");
else
strCatFmt(result, "'%s'", strPtr(httpQueryGet(this, key)));
strCatFmt(result, "'%s'", strZ(httpQueryGet(this, key)));
}
strCatZ(result, "}");

29
src/common/io/http/request.c
View File

@ -103,8 +103,8 @@ httpRequestProcess(HttpRequest *this, bool waitForResponse, bool contentCache)
// Format the request
String *requestStr =
strNewFmt(
"%s %s%s%s " HTTP_VERSION CRLF_Z, strPtr(this->verb), strPtr(httpUriEncode(this->uri, true)),
this->query == NULL ? "" : "?", this->query == NULL ? "" : strPtr(httpQueryRenderP(this->query)));
"%s %s%s%s " HTTP_VERSION CRLF_Z, strZ(this->verb), strZ(httpUriEncode(this->uri, true)),
this->query == NULL ? "" : "?", this->query == NULL ? "" : strZ(httpQueryRenderP(this->query)));
// Add headers
const StringList *headerList = httpHeaderList(this->header);
@ -113,8 +113,7 @@ httpRequestProcess(HttpRequest *this, bool waitForResponse, bool contentCache)
{
const String *headerKey = strLstGet(headerList, headerIdx);
strCatFmt(
requestStr, "%s:%s" CRLF_Z, strPtr(headerKey), strPtr(httpHeaderGet(this->header, headerKey)));
strCatFmt(requestStr, "%s:%s" CRLF_Z, strZ(headerKey), strZ(httpHeaderGet(this->header, headerKey)));
}
// Add blank line to end of headers and write the request as a buffer so secrets do not show up in logs
@ -142,7 +141,7 @@ httpRequestProcess(HttpRequest *this, bool waitForResponse, bool contentCache)
// looks valid. There are a few errors that might be permanently fatal but they are rare and it seems best
// not to try and pick and choose errors in this class to retry.
if (httpResponseCode(result) / 100 == HTTP_RESPONSE_CODE_RETRY_CLASS)
THROW_FMT(ServiceError, "[%u] %s", httpResponseCode(result), strPtr(httpResponseReason(result)));
THROW_FMT(ServiceError, "[%u] %s", httpResponseCode(result), strZ(httpResponseReason(result)));
// Move response to outer temp context
httpResponseMove(result, memContextPrior());
@ -248,15 +247,15 @@ httpRequestError(const HttpRequest *this, HttpResponse *response)
// Add reason when present
if (strSize(httpResponseReason(response)) > 0)
strCatFmt(error, " (%s)", strPtr(httpResponseReason(response)));
strCatFmt(error, " (%s)", strZ(httpResponseReason(response)));
// Output uri/query
strCatZ(error, ":\n*** URI/Query ***:");
strCatFmt(error, "\n%s", strPtr(httpUriEncode(this->uri, true)));
strCatFmt(error, "\n%s", strZ(httpUriEncode(this->uri, true)));
if (this->query != NULL)
strCatFmt(error, "?%s", strPtr(httpQueryRenderP(this->query, .redact = true)));
strCatFmt(error, "?%s", strZ(httpQueryRenderP(this->query, .redact = true)));
// Output request headers
const StringList *requestHeaderList = httpHeaderList(this->header);
@ -270,8 +269,8 @@ httpRequestError(const HttpRequest *this, HttpResponse *response)
const String *key = strLstGet(requestHeaderList, requestHeaderIdx);
strCatFmt(
error, "\n%s: %s", strPtr(key),
httpHeaderRedact(this->header, key) ? "<redacted>" : strPtr(httpHeaderGet(this->header, key)));
error, "\n%s: %s", strZ(key),
httpHeaderRedact(this->header, key) ? "<redacted>" : strZ(httpHeaderGet(this->header, key)));
}
}
@ -286,7 +285,7 @@ httpRequestError(const HttpRequest *this, HttpResponse *response)
for (unsigned int responseHeaderIdx = 0; responseHeaderIdx < strLstSize(responseHeaderList); responseHeaderIdx++)
{
const String *key = strLstGet(responseHeaderList, responseHeaderIdx);
strCatFmt(error, "\n%s: %s", strPtr(key), strPtr(httpHeaderGet(responseHeader, key)));
strCatFmt(error, "\n%s: %s", strZ(key), strZ(httpHeaderGet(responseHeader, key)));
}
}
@ -297,7 +296,7 @@ httpRequestError(const HttpRequest *this, HttpResponse *response)
strCat(error, strNewBuf(httpResponseContent(response)));
}
THROW(ProtocolError, strPtr(error));
THROW(ProtocolError, strZ(error));
}
/**********************************************************************************************************************************/
@ -305,7 +304,7 @@ String *
httpRequestToLog(const HttpRequest *this)
{
return strNewFmt(
"{verb: %s, uri: %s, query: %s, header: %s, contentSize: %zu}",
strPtr(this->verb), strPtr(this->uri), this->query == NULL ? "null" : strPtr(httpQueryToLog(this->query)),
strPtr(httpHeaderToLog(this->header)), this->content == NULL ? 0 : bufUsed(this->content));
"{verb: %s, uri: %s, query: %s, header: %s, contentSize: %zu}", strZ(this->verb), strZ(this->uri),
this->query == NULL ? "null" : strZ(httpQueryToLog(this->query)), strZ(httpHeaderToLog(this->header)),
this->content == NULL ? 0 : bufUsed(this->content));
}

22
src/common/io/http/response.c
View File

@ -132,7 +132,7 @@ httpResponseRead(THIS_VOID, Buffer *buffer, bool block)
if (this->contentChunked && this->contentRemaining == 0)
{
// Read length of next chunk
this->contentRemaining = cvtZToUInt64Base(strPtr(strTrim(ioReadLine(rawRead))), 16);
this->contentRemaining = cvtZToUInt64Base(strZ(strTrim(ioReadLine(rawRead))), 16);
// If content remaining is still zero then eof
if (this->contentRemaining == 0)
@ -236,17 +236,17 @@ httpResponseNew(HttpSession *session, const String *verb, bool contentCache)
// Check status ends with a CR and remove it to make error formatting easier and more accurate
if (!strEndsWith(status, CR_STR))
THROW_FMT(FormatError, "HTTP response status '%s' should be CR-terminated", strPtr(status));
THROW_FMT(FormatError, "HTTP response status '%s' should be CR-terminated", strZ(status));
status = strSubN(status, 0, strSize(status) - 1);
// Check status is at least the minimum required length to avoid harder to interpret errors later on
if (strSize(status) < sizeof(HTTP_VERSION) + 4)
THROW_FMT(FormatError, "HTTP response '%s' has invalid length", strPtr(strTrim(status)));
THROW_FMT(FormatError, "HTTP response '%s' has invalid length", strZ(strTrim(status)));
// Check status starts with the correct http version
if (!strBeginsWith(status, HTTP_VERSION_STR))
THROW_FMT(FormatError, "HTTP version of response '%s' must be " HTTP_VERSION, strPtr(status));
THROW_FMT(FormatError, "HTTP version of response '%s' must be " HTTP_VERSION, strZ(status));
// Read status code
status = strSub(status, sizeof(HTTP_VERSION));
@ -254,9 +254,9 @@ httpResponseNew(HttpSession *session, const String *verb, bool contentCache)
int spacePos = strChr(status, ' ');
if (spacePos != 3)
THROW_FMT(FormatError, "response status '%s' must have a space after the status code", strPtr(status));
THROW_FMT(FormatError, "response status '%s' must have a space after the status code", strZ(status));
this->code = cvtZToUInt(strPtr(strSubN(status, 0, (size_t)spacePos)));
this->code = cvtZToUInt(strZ(strSubN(status, 0, (size_t)spacePos)));
// Read reason phrase. A missing reason phrase will be represented as an empty string.
MEM_CONTEXT_BEGIN(this->memContext)
@ -279,7 +279,7 @@ httpResponseNew(HttpSession *session, const String *verb, bool contentCache)
int colonPos = strChr(header, ':');
if (colonPos < 0)
THROW_FMT(FormatError, "header '%s' missing colon", strPtr(strTrim(header)));
THROW_FMT(FormatError, "header '%s' missing colon", strZ(strTrim(header)));
String *headerKey = strLower(strTrim(strSubN(header, 0, (size_t)colonPos)));
String *headerValue = strTrim(strSub(header, (size_t)colonPos + 1));
@ -303,7 +303,7 @@ httpResponseNew(HttpSession *session, const String *verb, bool contentCache)
// Read content size
if (strEq(headerKey, HTTP_HEADER_CONTENT_LENGTH_STR))
{
this->contentSize = cvtZToUInt64(strPtr(headerValue));
this->contentSize = cvtZToUInt64(strZ(headerValue));
this->contentRemaining = this->contentSize;
}
@ -409,7 +409,7 @@ httpResponseToLog(const HttpResponse *this)
return strNewFmt(
"{code: %u, reason: %s, header: %s, contentChunked: %s, contentSize: %" PRIu64 ", contentRemaining: %" PRIu64
", closeOnContentEof: %s, contentExists: %s, contentEof: %s, contentCached: %s}",
this->code, strPtr(this->reason), strPtr(httpHeaderToLog(this->header)),
cvtBoolToConstZ(this->contentChunked), this->contentSize, this->contentRemaining, cvtBoolToConstZ(this->closeOnContentEof),
cvtBoolToConstZ(this->contentExists), cvtBoolToConstZ(this->contentEof), cvtBoolToConstZ(this->content != NULL));
this->code, strZ(this->reason), strZ(httpHeaderToLog(this->header)), cvtBoolToConstZ(this->contentChunked),
this->contentSize, this->contentRemaining, cvtBoolToConstZ(this->closeOnContentEof), cvtBoolToConstZ(this->contentExists),
cvtBoolToConstZ(this->contentEof), cvtBoolToConstZ(this->content != NULL));
}

6
src/common/io/socket/client.c
View File

@ -112,10 +112,10 @@ sckClientOpen(SocketClient *this)
struct addrinfo *hostAddress;
int resultAddr;
if ((resultAddr = getaddrinfo(strPtr(this->host), port, &hints, &hostAddress)) != 0)
if ((resultAddr = getaddrinfo(strZ(this->host), port, &hints, &hostAddress)) != 0)
{
THROW_FMT(
HostConnectError, "unable to get address for '%s': [%d] %s", strPtr(this->host), resultAddr,
HostConnectError, "unable to get address for '%s': [%d] %s", strZ(this->host), resultAddr,
gai_strerror(resultAddr));
}
@ -190,5 +190,5 @@ sckClientStatStr(void)
String *
sckClientToLog(const SocketClient *this)
{
return strNewFmt("{host: %s, port: %u, timeout: %" PRIu64 "}", strPtr(this->host), this->port, this->timeout);
return strNewFmt("{host: %s, port: %u, timeout: %" PRIu64 "}", strZ(this->host), this->port, this->timeout);
}

4
src/common/io/socket/common.c
View File

@ -169,7 +169,7 @@ sckConnect(int fd, const String *host, unsigned int port, const struct addrinfo
{
// Wait for write-ready
if (!sckReadyWrite(fd, timeout))
THROW_FMT(HostConnectError, "timeout connecting to '%s:%u'", strPtr(host), port);
THROW_FMT(HostConnectError, "timeout connecting to '%s:%u'", strZ(host), port);
// Check for success or error. If the connection was successful this will set errNo to 0.
socklen_t errNoLen = sizeof(errNo);
@ -180,7 +180,7 @@ sckConnect(int fd, const String *host, unsigned int port, const struct addrinfo
// Throw error if it is still set
if (errNo != 0)
THROW_SYS_ERROR_CODE_FMT(errNo, HostConnectError, "unable to connect to '%s:%u'", strPtr(host), port);
THROW_SYS_ERROR_CODE_FMT(errNo, HostConnectError, "unable to connect to '%s:%u'", strZ(host), port);
}
FUNCTION_LOG_RETURN_VOID();

7
src/common/io/socket/session.c
View File

@ -93,7 +93,7 @@ sckSessionReadyRead(SocketSession *this)
if (!sckReadyRead(this->fd, this->timeout))
{
THROW_FMT(
ProtocolError, "timeout after %" PRIu64 "ms waiting for read from '%s:%u'", this->timeout, strPtr(this->host),
ProtocolError, "timeout after %" PRIu64 "ms waiting for read from '%s:%u'", this->timeout, strZ(this->host),
this->port);
}
@ -112,8 +112,7 @@ sckSessionReadyWrite(SocketSession *this)
if (!sckReadyWrite(this->fd, this->timeout))
{
THROW_FMT(
ProtocolError, "timeout after %" PRIu64 "ms waiting for write to '%s:%u'", this->timeout, strPtr(this->host),
this->port);
ProtocolError, "timeout after %" PRIu64 "ms waiting for write to '%s:%u'", this->timeout, strZ(this->host), this->port);
}
FUNCTION_LOG_RETURN_VOID();
@ -125,5 +124,5 @@ sckSessionToLog(const SocketSession *this)
{
return strNewFmt(
"{type: %s, fd %d, host: %s, port: %u, timeout: %" PRIu64 "}", this->type == sckSessionTypeClient ? "client" : "server",
this->fd, strPtr(this->host), this->port, this->timeout);
this->fd, strZ(this->host), this->port, this->timeout);
}

16
src/common/io/tls/client.c
View File

@ -104,7 +104,7 @@ tlsClientNew(SocketClient *socket, TimeMSec timeout, bool verifyPeer, const Stri
if (caFile != NULL || caPath != NULL) // {vm_covered}
{
cryptoError( // {vm_covered}
SSL_CTX_load_verify_locations(this->context, strPtrNull(caFile), strPtrNull(caPath)) != 1, // {vm_covered}
SSL_CTX_load_verify_locations(this->context, strZNull(caFile), strZNull(caPath)) != 1, // {vm_covered}
"unable to set user-defined CA certificate location"); // {vm_covered}
}
// Else use the defaults
@ -160,13 +160,13 @@ tlsClientHostVerifyName(const String *host, const String *name)
ASSERT(name != NULL);
// Reject embedded nulls in certificate common or alternative name to prevent attacks like CVE-2009-4034
if (strlen(strPtr(name)) != strSize(name))
if (strlen(strZ(name)) != strSize(name))
THROW(CryptoError, "TLS certificate name contains embedded null");
bool result = false;
// Try an exact match
if (strcasecmp(strPtr(name), strPtr(host)) == 0) // {vm_covered}
if (strcasecmp(strZ(name), strZ(host)) == 0) // {vm_covered}
{
result = true; // {vm_covered}
}
@ -180,9 +180,9 @@ tlsClientHostVerifyName(const String *host, const String *name)
//
// This is roughly in line with RFC2818, but contrary to what most browsers appear to be implementing (point 3 being the
// difference)
else if (strPtr(name)[0] == '*' && strPtr(name)[1] == '.' && strSize(name) > 2 && // {vm_covered}
else if (strZ(name)[0] == '*' && strZ(name)[1] == '.' && strSize(name) > 2 && // {vm_covered}
strSize(name) < strSize(host) && // {vm_covered}
strcasecmp(strPtr(name) + 1, strPtr(host) + strSize(host) - strSize(name) + 1) == 0 && // {vm_covered}
strcasecmp(strZ(name) + 1, strZ(host) + strSize(host) - strSize(name) + 1) == 0 && // {vm_covered}
strChr(host, '.') >= (int)(strSize(host) - strSize(name))) // {vm_covered}
{
result = true; // {vm_covered}
@ -292,7 +292,7 @@ tlsClientOpen(TlsClient *this)
// Set server host name used for validation
cryptoError(
SSL_set_tlsext_host_name(session, strPtr(sckClientHost(this->socketClient))) != 1,
SSL_set_tlsext_host_name(session, strZ(sckClientHost(this->socketClient))) != 1,
"unable to set TLS host name");
// Create the TLS session
@ -333,7 +333,7 @@ tlsClientOpen(TlsClient *this)
{
THROW_FMT( // {vm_covered}
CryptoError, "unable to verify certificate presented by '%s:%u': [%ld] %s", // {vm_covered}
strPtr(sckClientHost(this->socketClient)), sckClientPort(this->socketClient), verifyResult, // {vm_covered}
strZ(sckClientHost(this->socketClient)), sckClientPort(this->socketClient), verifyResult, // {vm_covered}
X509_verify_cert_error_string(verifyResult)); // {vm_covered}
}
@ -347,7 +347,7 @@ tlsClientOpen(TlsClient *this)
THROW_FMT( // {vm_covered}
CryptoError, // {vm_covered}
"unable to find hostname '%s' in certificate common name or subject alternative names", // {vm_covered}
strPtr(sckClientHost(this->socketClient))); // {vm_covered}
strZ(sckClientHost(this->socketClient))); // {vm_covered}
}
}

11
src/common/lock.c
View File

@ -59,7 +59,7 @@ lockAcquireFile(const String *lockFile, TimeMSec lockTimeout, bool failOnNoLock)
do
{
// Attempt to open the file
if ((result = open(strPtr(lockFile), O_WRONLY | O_CREAT, STORAGE_MODE_FILE_DEFAULT)) == -1)
if ((result = open(strZ(lockFile), O_WRONLY | O_CREAT, STORAGE_MODE_FILE_DEFAULT)) == -1)
{
// Save the error for reporting outside the loop
errNo = errno;
@ -100,13 +100,12 @@ lockAcquireFile(const String *lockFile, TimeMSec lockTimeout, bool failOnNoLock)
else if (errNo == EACCES)
{
errorHint = strNewFmt(
"\nHINT: does the user running " PROJECT_NAME " have permissions on the '%s' file?",
strPtr(lockFile));
"\nHINT: does the user running " PROJECT_NAME " have permissions on the '%s' file?", strZ(lockFile));
}
THROW_FMT(
LockAcquireError, "unable to acquire lock on file '%s': %s%s",
strPtr(lockFile), strerror(errNo), errorHint == NULL ? "" : strPtr(errorHint));
LockAcquireError, "unable to acquire lock on file '%s': %s%s", strZ(lockFile), strerror(errNo),
errorHint == NULL ? "" : strZ(errorHint));
}
}
else
@ -186,7 +185,7 @@ lockAcquire(const String *lockPath, const String *stanza, LockType lockType, Tim
for (LockType lockIdx = lockMin; lockIdx <= lockMax; lockIdx++)
{
lockFile[lockIdx] = strNewFmt("%s/%s-%s" LOCK_FILE_EXT, strPtr(lockPath), strPtr(stanza), lockTypeName[lockIdx]);
lockFile[lockIdx] = strNewFmt("%s/%s-%s" LOCK_FILE_EXT, strZ(lockPath), strZ(stanza), lockTypeName[lockIdx]);
lockHandle[lockIdx] = lockAcquireFile(lockFile[lockIdx], lockTimeout, failOnNoLock);

10
src/common/regExp.c
View File

@ -81,7 +81,7 @@ regExpNew(const String *expression)
// Compile the regexp and process errors
int result = 0;
if ((result = regcomp(&this->regExp, strPtr(expression), REG_EXTENDED)) != 0)
if ((result = regcomp(&this->regExp, strZ(expression), REG_EXTENDED)) != 0)
{
memFree(this);
regExpError(result);
@ -109,7 +109,7 @@ regExpMatch(RegExp *this, const String *string)
// Test for a match
regmatch_t matchPtr;
int result = regexec(&this->regExp, strPtr(string), 1, &matchPtr, 0);
int result = regexec(&this->regExp, strZ(string), 1, &matchPtr, 0);
// Check for an error
regExpErrorCheck(result);
@ -117,7 +117,7 @@ regExpMatch(RegExp *this, const String *string)
// Store match results
if (result == 0)
{
this->matchPtr = strPtr(string) + matchPtr.rm_so;
this->matchPtr = strZ(string) + matchPtr.rm_so;
this->matchSize = (size_t)(matchPtr.rm_eo - matchPtr.rm_so);
}
// Else reset match results
@ -208,9 +208,9 @@ regExpPrefix(const String *expression)
String *result = NULL;
// Only generate prefix if expression is defined and has a beginning anchor
if (expression != NULL && strPtr(expression)[0] == '^')
if (expression != NULL && strZ(expression)[0] == '^')
{
const char *expressionZ = strPtr(expression);
const char *expressionZ = strZ(expression);
size_t expressionSize = strSize(expression);
unsigned int expressionIdx = 1;

2
src/common/type/buffer.c
View File

@ -355,7 +355,7 @@ bufToLog(const Buffer *this)
{
String *result = strNewFmt(
"{used: %zu, size: %zu%s", this->used, this->size,
this->sizeLimit ? strPtr(strNewFmt(", sizeAlloc: %zu}", this->sizeAlloc)) : "}");
this->sizeLimit ? strZ(strNewFmt(", sizeAlloc: %zu}", this->sizeAlloc)) : "}");
return result;
}

2
src/common/type/buffer.h
View File

@ -159,7 +159,7 @@ By convention all buffer constant identifiers are appended with _BUF.
// Create a buffer constant inline from a String
#define BUFSTR(string) \
BUF((unsigned char *)strPtr(string), strSize(string))
BUF((unsigned char *)strZ(string), strSize(string))
// Create a buffer constant inline from a constant zero-terminated string
#define BUFSTRDEF(stringdef) \

60
src/common/type/json.c
View File

@ -68,14 +68,14 @@ jsonToBool(const String *json)
FUNCTION_TEST_END();
unsigned int jsonPos = 0;
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
bool result = jsonToBoolInternal(strPtr(json), &jsonPos);
bool result = jsonToBoolInternal(strZ(json), &jsonPos);
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
if (jsonPos != strSize(json))
THROW_FMT(JsonFormatError, "unexpected characters after boolean at '%s'", strPtr(json) + jsonPos);
THROW_FMT(JsonFormatError, "unexpected characters after boolean at '%s'", strZ(json) + jsonPos);
FUNCTION_TEST_RETURN(result);
}
@ -117,9 +117,9 @@ jsonToNumberInternal(const char *json, unsigned int *jsonPos)
MEM_CONTEXT_PRIOR_BEGIN()
{
if (intSigned)
result = varNewInt64(cvtZToInt64(strPtr(resultStr)));
result = varNewInt64(cvtZToInt64(strZ(resultStr)));
else
result = varNewUInt64(cvtZToUInt64(strPtr(resultStr)));
result = varNewUInt64(cvtZToUInt64(strZ(resultStr)));
}
MEM_CONTEXT_PRIOR_END();
}
@ -136,14 +136,14 @@ jsonToNumber(const String *json)
FUNCTION_TEST_END();
unsigned int jsonPos = 0;
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
Variant *result = jsonToNumberInternal(strPtr(json), &jsonPos);
Variant *result = jsonToNumberInternal(strZ(json), &jsonPos);
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
if (jsonPos != strSize(json))
THROW_FMT(JsonFormatError, "unexpected characters after number at '%s'", strPtr(json) + jsonPos);
THROW_FMT(JsonFormatError, "unexpected characters after number at '%s'", strZ(json) + jsonPos);
FUNCTION_TEST_RETURN(result);
}
@ -329,19 +329,19 @@ jsonToStr(const String *json)
FUNCTION_TEST_END();
unsigned int jsonPos = 0;
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
String *result = NULL;
if (strncmp(strPtr(json), NULL_Z, 4) == 0)
if (strncmp(strZ(json), NULL_Z, 4) == 0)
jsonPos += 4;
else
result = jsonToStrInternal(strPtr(json), &jsonPos);
result = jsonToStrInternal(strZ(json), &jsonPos);
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
if (jsonPos != strSize(json))
THROW_FMT(JsonFormatError, "unexpected characters after string at '%s'", strPtr(json) + jsonPos);
THROW_FMT(JsonFormatError, "unexpected characters after string at '%s'", strZ(json) + jsonPos);
FUNCTION_TEST_RETURN(result);
}
@ -406,17 +406,17 @@ jsonToKv(const String *json)
FUNCTION_TEST_END();
unsigned int jsonPos = 0;
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
if (strPtr(json)[jsonPos] != '{')
THROW_FMT(JsonFormatError, "expected '{' at '%s'", strPtr(json) + jsonPos);
if (strZ(json)[jsonPos] != '{')
THROW_FMT(JsonFormatError, "expected '{' at '%s'", strZ(json) + jsonPos);
KeyValue *result = jsonToKvInternal(strPtr(json), &jsonPos);
KeyValue *result = jsonToKvInternal(strZ(json), &jsonPos);
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
if (jsonPos != strSize(json))
THROW_FMT(JsonFormatError, "unexpected characters after object at '%s'", strPtr(json) + jsonPos);
THROW_FMT(JsonFormatError, "unexpected characters after object at '%s'", strZ(json) + jsonPos);
FUNCTION_TEST_RETURN(result);
}
@ -481,14 +481,14 @@ jsonToVarLst(const String *json)
FUNCTION_TEST_END();
unsigned int jsonPos = 0;
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
VariantList *result = jsonToVarLstInternal(strPtr(json), &jsonPos);
VariantList *result = jsonToVarLstInternal(strZ(json), &jsonPos);
jsonConsumeWhiteSpace(strPtr(json), &jsonPos);
jsonConsumeWhiteSpace(strZ(json), &jsonPos);
if (jsonPos != strSize(json))
THROW_FMT(JsonFormatError, "unexpected characters after array at '%s'", strPtr(json) + jsonPos);
THROW_FMT(JsonFormatError, "unexpected characters after array at '%s'", strZ(json) + jsonPos);
FUNCTION_TEST_RETURN(result);
}
@ -581,13 +581,13 @@ jsonToVar(const String *json)
FUNCTION_LOG_PARAM(STRING, json);
FUNCTION_LOG_END();
const char *jsonPtr = strPtr(json);
const char *jsonPtr = strZ(json);
unsigned int jsonPos = 0;
Variant *result = jsonToVarInternal(jsonPtr, &jsonPos);
if (jsonPos != strSize(json))
THROW_FMT(JsonFormatError, "unexpected characters after JSON at '%s'", strPtr(json) + jsonPos);
THROW_FMT(JsonFormatError, "unexpected characters after JSON at '%s'", strZ(json) + jsonPos);
FUNCTION_LOG_RETURN(VARIANT, result);
}
@ -683,7 +683,7 @@ jsonFromStrInternal(String *json, const String *string)
for (unsigned int stringIdx = 0; stringIdx < strSize(string); stringIdx++)
{
char stringChr = strPtr(string)[stringIdx];
char stringChr = strZ(string)[stringIdx];
switch (stringChr)
{
@ -754,7 +754,7 @@ jsonFromStrInternal(String *json, const String *string)
{
// If escape string is zero size then start it
if (noEscapeSize == 0)
noEscape = strPtr(string) + stringIdx;
noEscape = strZ(string) + stringIdx;
noEscapeSize++;
break;
@ -813,7 +813,7 @@ jsonFromKvInternal(const KeyValue *kv)
strCatZ(result, ",");
// Keys are always strings in the output, so add starting quote and colon.
strCatFmt(result, "\"%s\":", strPtr(key));
strCatFmt(result, "\"%s\":", strZ(key));
// NULL value
if (value == NULL)

41
src/common/type/string.c
View File

@ -235,7 +235,7 @@ strBeginsWith(const String *this, const String *beginsWith)
ASSERT(this != NULL);
ASSERT(beginsWith != NULL);
FUNCTION_TEST_RETURN(strBeginsWithZ(this, strPtr(beginsWith)));
FUNCTION_TEST_RETURN(strBeginsWithZ(this, strZ(beginsWith)));
}
bool
@ -253,7 +253,7 @@ strBeginsWithZ(const String *this, const char *beginsWith)
unsigned int beginsWithSize = (unsigned int)strlen(beginsWith);
if (this->size >= beginsWithSize)
result = strncmp(strPtr(this), beginsWith, beginsWithSize) == 0;
result = strncmp(strZ(this), beginsWith, beginsWithSize) == 0;
FUNCTION_TEST_RETURN(result);
}
@ -303,7 +303,7 @@ strCat(String *this, const String *cat)
ASSERT(this != NULL);
ASSERT(cat != NULL);
FUNCTION_TEST_RETURN(strCatZN(this, strPtr(cat), strSize(cat)));
FUNCTION_TEST_RETURN(strCatZN(this, strZ(cat), strSize(cat)));
}
String *
@ -422,7 +422,7 @@ strCmp(const String *this, const String *compare)
FUNCTION_TEST_END();
if (this != NULL && compare != NULL)
FUNCTION_TEST_RETURN(strcmp(strPtr(this), strPtr(compare)));
FUNCTION_TEST_RETURN(strcmp(strZ(this), strZ(compare)));
else if (this == NULL)
{
if (compare == NULL)
@ -456,7 +456,7 @@ strDup(const String *this)
String *result = NULL;
if (this != NULL)
result = strNew(strPtr(this));
result = strNew(strZ(this));
FUNCTION_TEST_RETURN(result);
}
@ -484,7 +484,7 @@ strEndsWith(const String *this, const String *endsWith)
ASSERT(this != NULL);
ASSERT(endsWith != NULL);
FUNCTION_TEST_RETURN(strEndsWithZ(this, strPtr(endsWith)));
FUNCTION_TEST_RETURN(strEndsWithZ(this, strZ(endsWith)));
}
bool
@ -502,7 +502,7 @@ strEndsWithZ(const String *this, const char *endsWith)
unsigned int endsWithSize = (unsigned int)strlen(endsWith);
if (this->size >= endsWithSize)
result = strcmp(strPtr(this) + (this->size - endsWithSize), endsWith) == 0;
result = strcmp(strZ(this) + (this->size - endsWithSize), endsWith) == 0;
FUNCTION_TEST_RETURN(result);
}
@ -524,7 +524,7 @@ strEq(const String *this, const String *compare)
if (this != NULL && compare != NULL)
{
if (this->size == compare->size)
result = strcmp(strPtr(this), strPtr(compare)) == 0;
result = strcmp(strZ(this), strZ(compare)) == 0;
}
else
result = this == NULL && compare == NULL;
@ -543,7 +543,7 @@ strEqZ(const String *this, const char *compare)
ASSERT(this != NULL);
ASSERT(compare != NULL);
FUNCTION_TEST_RETURN(strcmp(strPtr(this), compare) == 0);
FUNCTION_TEST_RETURN(strcmp(strZ(this), compare) == 0);
}
/**********************************************************************************************************************************/
@ -659,7 +659,7 @@ strPathAbsolute(const String *this, const String *base)
// Base must be absolute to start
if (!strBeginsWith(base, FSLASH_STR))
THROW_FMT(AssertError, "base path '%s' is not absolute", strPtr(base));
THROW_FMT(AssertError, "base path '%s' is not absolute", strZ(base));
MEM_CONTEXT_TEMP_BEGIN()
{
@ -680,7 +680,7 @@ strPathAbsolute(const String *this, const String *base)
break;
}
THROW_FMT(AssertError, "'%s' is not a valid relative path", strPtr(this));
THROW_FMT(AssertError, "'%s' is not a valid relative path", strZ(this));
}
if (strEq(pathPart, DOTDOT_STR))
@ -688,10 +688,7 @@ strPathAbsolute(const String *this, const String *base)
const String *basePart = strLstGet(baseList, strLstSize(baseList) - 1);
if (strSize(basePart) == 0)
{
THROW_FMT(
AssertError, "relative path '%s' goes back too far in base path '%s'", strPtr(this), strPtr(base));
}
THROW_FMT(AssertError, "relative path '%s' goes back too far in base path '%s'", strZ(this), strZ(base));
strLstRemoveIdx(baseList, strLstSize(baseList) - 1);
}
@ -714,15 +711,15 @@ strPathAbsolute(const String *this, const String *base)
}
// There should not be any stray .. or // in the final result
if (strstr(strPtr(result), "/..") != NULL || strstr(strPtr(result), "//") != NULL)
THROW_FMT(AssertError, "result path '%s' is not absolute", strPtr(result));
if (strstr(strZ(result), "/..") != NULL || strstr(strZ(result), "//") != NULL)
THROW_FMT(AssertError, "result path '%s' is not absolute", strZ(result));
FUNCTION_TEST_RETURN(result);
}
/**********************************************************************************************************************************/
const char *
strPtrNull(const String *this)
strZNull(const String *this)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(STRING, this);
@ -743,7 +740,7 @@ strQuote(const String *this, const String *quote)
ASSERT(this != NULL);
ASSERT(quote != NULL);
FUNCTION_TEST_RETURN(strQuoteZ(this, strPtr(quote)));
FUNCTION_TEST_RETURN(strQuoteZ(this, strZ(quote)));
}
String *
@ -757,7 +754,7 @@ strQuoteZ(const String *this, const char *quote)
ASSERT(this != NULL);
ASSERT(quote != NULL);
FUNCTION_TEST_RETURN(strNewFmt("%s%s%s", quote, strPtr(this), quote));
FUNCTION_TEST_RETURN(strNewFmt("%s%s%s", quote, strZ(this), quote));
}
/**********************************************************************************************************************************/
@ -925,7 +922,7 @@ size_t strObjToLog(const void *object, StrObjToLogFormat formatFunc, char *buffe
MEM_CONTEXT_TEMP_BEGIN()
{
result = (size_t)snprintf(buffer, bufferSize, "%s", object == NULL ? NULL_Z : strPtr(formatFunc(object)));
result = (size_t)snprintf(buffer, bufferSize, "%s", object == NULL ? NULL_Z : strZ(formatFunc(object)));
}
MEM_CONTEXT_TEMP_END();
@ -936,7 +933,7 @@ size_t strObjToLog(const void *object, StrObjToLogFormat formatFunc, char *buffe
String *
strToLog(const String *this)
{
return this == NULL ? strDup(NULL_STR) : strNewFmt("{\"%s\"}", strPtr(this));
return this == NULL ? strDup(NULL_STR) : strNewFmt("{\"%s\"}", strZ(this));
}
/**********************************************************************************************************************************/

6
src/common/type/string.h
View File

@ -136,15 +136,15 @@ String *strPath(const String *this);
// Combine with a base path to get an absolute path
String *strPathAbsolute(const String *this, const String *base);
// Pointer to zero-terminated string. strPtrNull() returns NULL when the String is NULL.
// Pointer to zero-terminated string. strZNull() returns NULL when the String is NULL.
__attribute__((always_inline)) static inline const char *
strPtr(const String *this)
strZ(const String *this)
{
ASSERT_INLINE(this != NULL);
return ((const StringConst *)this)->buffer;
}
const char *strPtrNull(const String *this);
const char *strZNull(const String *this);
// Quote a string
String *strQuote(const String *this, const String *quote);

14
src/common/type/stringList.c
View File

@ -67,7 +67,7 @@ strLstNewSplit(const String *string, const String *delimiter)
ASSERT(string != NULL);
ASSERT(delimiter != NULL);
FUNCTION_TEST_RETURN(strLstNewSplitZ(string, strPtr(delimiter)));
FUNCTION_TEST_RETURN(strLstNewSplitZ(string, strZ(delimiter)));
}
StringList *
@ -85,7 +85,7 @@ strLstNewSplitZ(const String *string, const char *delimiter)
StringList *this = strLstNew();
// Base points to the beginning of the string that is being searched
const char *stringBase = strPtr(string);
const char *stringBase = strZ(string);
// Match points to the next delimiter match that has been found
const char *stringMatch = NULL;
@ -127,7 +127,7 @@ strLstNewSplitSize(const String *string, const String *delimiter, size_t size)
ASSERT(string != NULL);
ASSERT(delimiter != NULL);
FUNCTION_TEST_RETURN(strLstNewSplitSizeZ(string, strPtr(delimiter), size));
FUNCTION_TEST_RETURN(strLstNewSplitSizeZ(string, strZ(delimiter), size));
}
StringList *
@ -146,7 +146,7 @@ strLstNewSplitSizeZ(const String *string, const char *delimiter, size_t size)
StringList *this = strLstNew();
// Base points to the beginning of the string that is being searched
const char *stringBase = strPtr(string);
const char *stringBase = strZ(string);
// Match points to the next delimiter match that has been found
const char *stringMatchLast = NULL;
@ -435,7 +435,7 @@ strLstJoinQuote(const StringList *this, const char *separator, const char *quote
if (strLstGet(this, listIdx) == NULL)
strCatZ(join, "[NULL]");
else
strCatFmt(join, "%s%s%s", quote, strPtr(strLstGet(this, listIdx)), quote);
strCatFmt(join, "%s%s%s", quote, strZ(strLstGet(this, listIdx)), quote);
}
FUNCTION_TEST_RETURN(join);
@ -535,7 +535,7 @@ strLstPtr(const StringList *this)
if (strLstGet(this, listIdx) == NULL)
list[listIdx] = NULL;
else
list[listIdx] = strPtr(strLstGet(this, listIdx));
list[listIdx] = strZ(strLstGet(this, listIdx));
}
list[strLstSize(this)] = NULL;
@ -618,7 +618,7 @@ strLstComparatorSet(StringList *this, ListComparator *comparator)
String *
strLstToLog(const StringList *this)
{
return strNewFmt("{[%s]}", strPtr(strLstJoinQuote(this, ", ", "\"")));
return strNewFmt("{[%s]}", strZ(strLstJoinQuote(this, ", ", "\"")));
}
/**********************************************************************************************************************************/

14
src/common/type/variant.c
View File

@ -351,7 +351,7 @@ varBoolForce(const Variant *this)
};
// Search for the string
const char *string = strPtr(varStr(this));
const char *string = strZ(varStr(this));
unsigned int boolIdx;
for (boolIdx = 0; boolIdx < sizeof(boolString) / sizeof(char *); boolIdx++)
@ -457,7 +457,7 @@ varDblForce(const Variant *this)
case varTypeString:
{
result = cvtZToDouble(strPtr(varStr(this)));
result = cvtZToDouble(strZ(varStr(this)));
break;
}
@ -556,7 +556,7 @@ varIntForce(const Variant *this)
case varTypeString:
{
result = cvtZToInt(strPtr(varStr(this)));
result = cvtZToInt(strZ(varStr(this)));
break;
}
@ -663,7 +663,7 @@ varInt64Force(const Variant *this)
case varTypeString:
{
result = cvtZToInt64(strPtr(varStr(this)));
result = cvtZToInt64(strZ(varStr(this)));
break;
}
@ -811,7 +811,7 @@ varUIntForce(const Variant *this)
case varTypeString:
{
result = cvtZToUInt(strPtr(varStr(this)));
result = cvtZToUInt(strZ(varStr(this)));
break;
}
@ -912,7 +912,7 @@ varUInt64Force(const Variant *this)
case varTypeString:
{
result = cvtZToUInt64(strPtr(varStr(this)));
result = cvtZToUInt64(strZ(varStr(this)));
break;
}
@ -1183,7 +1183,7 @@ varToLog(const Variant *this)
case varTypeUInt:
case varTypeUInt64:
{
result = strNewFmt("{%s}", strPtr(varStrForce(this)));
result = strNewFmt("{%s}", strZ(varStrForce(this)));
break;
}
}

2
src/common/type/variant.h
View File

@ -12,7 +12,7 @@ old context and then back. Below is a simplified example:
MEM_CONTEXT_PRIOR_BEGIN() <--- switch to old context so creation of the variant from the string is in old context
{
result = varNewUInt64(cvtZToUInt64(strPtr(resultStr))); <--- recreates variant from the string in the old context.
result = varNewUInt64(cvtZToUInt64(strZ(resultStr))); <--- recreates variant from the string in the old context.
}
MEM_CONTEXT_PRIOR_END(); <--- switch back to the temporary context
}

10
src/common/type/xml.c
View File

@ -159,7 +159,7 @@ xmlNodeAdd(XmlNode *this, const String *name)
ASSERT(this != NULL);
ASSERT(name != NULL);
XmlNode *result = xmlNodeNew(xmlNewNode(NULL, BAD_CAST strPtr(name)));
XmlNode *result = xmlNodeNew(xmlNewNode(NULL, BAD_CAST strZ(name)));
xmlAddChild(this->node, result->node);
FUNCTION_TEST_RETURN(result);
@ -202,7 +202,7 @@ xmlNodeAttribute(const XmlNode *this, const String *name)
ASSERT(name != NULL);
String *result = NULL;
xmlChar *value = xmlGetProp(this->node, (unsigned char *)strPtr(name));
xmlChar *value = xmlGetProp(this->node, (unsigned char *)strZ(name));
if (value != NULL)
{
@ -244,7 +244,7 @@ xmlNodeContentSet(XmlNode *this, const String *content)
ASSERT(this != NULL);
ASSERT(content != NULL);
xmlAddChild(this->node, xmlNewText(BAD_CAST strPtr(content)));
xmlAddChild(this->node, xmlNewText(BAD_CAST strZ(content)));
FUNCTION_TEST_RETURN_VOID();
}
@ -303,7 +303,7 @@ xmlNodeChildN(const XmlNode *this, const String *name, unsigned int index, bool
}
if (child == NULL && errorOnMissing)
THROW_FMT(FormatError, "unable to find child '%s':%u in node '%s'", strPtr(name), index, this->node->name);
THROW_FMT(FormatError, "unable to find child '%s':%u in node '%s'", strZ(name), index, this->node->name);
FUNCTION_TEST_RETURN(child);
}
@ -394,7 +394,7 @@ xmlDocumentNew(const String *rootName)
// Set callback to ensure xml document is freed
memContextCallbackSet(this->memContext, xmlDocumentFreeResource, this);
this->root = xmlNodeNew(xmlNewNode(NULL, BAD_CAST strPtr(rootName)));
this->root = xmlNodeNew(xmlNewNode(NULL, BAD_CAST strZ(rootName)));
xmlDocSetRootElement(this->xml, this->root->node);
}
MEM_CONTEXT_NEW_END();

4
src/common/user.c
View File

@ -81,7 +81,7 @@ groupIdFromName(const String *groupName)
if (groupName != NULL)
{
struct group *groupData = getgrnam(strPtr(groupName));
struct group *groupData = getgrnam(strZ(groupName));
if (groupData != NULL)
FUNCTION_TEST_RETURN(groupData->gr_gid);
@ -132,7 +132,7 @@ userIdFromName(const String *userName)
if (userName != NULL)
{
struct passwd *userData = getpwnam(strPtr(userName));
struct passwd *userData = getpwnam(strZ(userName));
if (userData != NULL)
FUNCTION_TEST_RETURN(userData->pw_uid);

10
src/config/config.c
View File

@ -247,7 +247,7 @@ cfgCommandRoleNameParam(ConfigCommand commandId, ConfigCommandRole commandRoleId
String *result = strNew(cfgCommandName(commandId));
if (commandRoleId != cfgCmdRoleDefault)
strCatFmt(result, "%s%s", strPtr(separator), strPtr(cfgCommandRoleStr(commandRoleId)));
strCatFmt(result, "%s%s", strZ(separator), strZ(cfgCommandRoleStr(commandRoleId)));
FUNCTION_TEST_RETURN(result);
}
@ -317,7 +317,7 @@ cfgCommandRoleEnum(const String *commandRole)
else if (strEq(commandRole, CONFIG_COMMAND_ROLE_REMOTE_STR))
FUNCTION_TEST_RETURN(cfgCmdRoleRemote);
THROW_FMT(CommandInvalidError, "invalid command role '%s'", strPtr(commandRole));
THROW_FMT(CommandInvalidError, "invalid command role '%s'", strZ(commandRole));
}
const String *
@ -616,7 +616,7 @@ cfgOptionHostPort(ConfigOption optionId, unsigned int *port)
OptionInvalidError,
"'%s' is not valid for option '%s'"
"\nHINT: is more than one port specified?",
strPtr(host), cfgOptionName(optionId));
strZ(host), cfgOptionName(optionId));
}
// Set the host
@ -629,7 +629,7 @@ cfgOptionHostPort(ConfigOption optionId, unsigned int *port)
// Set the port and error if it is not a positive integer
TRY_BEGIN()
{
*port = cvtZToUInt(strPtr(strLstGet(hostPart, 1)));
*port = cvtZToUInt(strZ(strLstGet(hostPart, 1)));
}
CATCH(FormatError)
{
@ -637,7 +637,7 @@ cfgOptionHostPort(ConfigOption optionId, unsigned int *port)
OptionInvalidError,
"'%s' is not valid for option '%s'"
"\nHINT: port is not a positive integer.",
strPtr(host), cfgOptionName(optionId));
strZ(host), cfgOptionName(optionId));
}
TRY_END();
}

10
src/config/exec.c
View File

@ -96,8 +96,8 @@ cfgExecParam(ConfigCommand commandId, ConfigCommandRole commandRoleId, const Key
strLstAdd(
valueList,
strNewFmt(
"%s=%s", strPtr(varStr(varLstGet(keyList, keyIdx))),
strPtr(varStrForce(kvGet(optionKv, varLstGet(keyList, keyIdx))))));
"%s=%s", strZ(varStr(varLstGet(keyList, keyIdx))),
strZ(varStrForce(kvGet(optionKv, varLstGet(keyList, keyIdx))))));
}
}
else if (varType(value) == varTypeVariantList)
@ -116,10 +116,10 @@ cfgExecParam(ConfigCommand commandId, ConfigCommandRole commandRoleId, const Key
{
const String *value = strLstGet(valueList, valueListIdx);
if (quote && strchr(strPtr(value), ' ') != NULL)
value = strNewFmt("\"%s\"", strPtr(value));
if (quote && strchr(strZ(value), ' ') != NULL)
value = strNewFmt("\"%s\"", strZ(value));
strLstAdd(result, strNewFmt("--%s=%s", cfgOptionName(optionId), strPtr(value)));
strLstAdd(result, strNewFmt("--%s=%s", cfgOptionName(optionId), strZ(value)));
}
}
}

30
src/config/load.c
View File

@ -35,15 +35,15 @@ cfgLoadLogSetting(void)
unsigned int logProcessMax = 1;
if (cfgOptionValid(cfgOptLogLevelConsole))
logLevelConsole = logLevelEnum(strPtr(cfgOptionStr(cfgOptLogLevelConsole)));
logLevelConsole = logLevelEnum(strZ(cfgOptionStr(cfgOptLogLevelConsole)));
if (cfgOptionValid(cfgOptLogLevelStderr))
{
logLevelStdErr = logLevelEnum(strPtr(cfgOptionStr(cfgOptLogLevelStderr)));
logLevelStdErr = logLevelEnum(strZ(cfgOptionStr(cfgOptLogLevelStderr)));
}
if (cfgOptionValid(cfgOptLogLevelFile))
logLevelFile = logLevelEnum(strPtr(cfgOptionStr(cfgOptLogLevelFile)));
logLevelFile = logLevelEnum(strZ(cfgOptionStr(cfgOptLogLevelFile)));
if (cfgOptionValid(cfgOptLogTimestamp))
logTimestamp = cfgOptionBool(cfgOptLogTimestamp);
@ -104,8 +104,8 @@ cfgLoadUpdateOption(void)
OptionInvalidValueError,
"'%s' is not valid for '" CFGOPT_PROTOCOL_TIMEOUT "' option\nHINT '" CFGOPT_PROTOCOL_TIMEOUT "' option (%s)"
" should be greater than '" CFGOPT_DB_TIMEOUT "' option (%s).",
strPtr(varStrForce(cfgOption(cfgOptProtocolTimeout))), strPtr(varStrForce(cfgOption(cfgOptProtocolTimeout))),
strPtr(varStrForce(cfgOption(cfgOptDbTimeout))));
strZ(varStrForce(cfgOption(cfgOptProtocolTimeout))), strZ(varStrForce(cfgOption(cfgOptProtocolTimeout))),
strZ(varStrForce(cfgOption(cfgOptDbTimeout))));
}
}
@ -146,7 +146,7 @@ cfgLoadUpdateOption(void)
"option '%s' is not set for '%s=%s', the repository may run out of space"
"\nHINT: to retain full backups indefinitely (without warning), set option '%s' to the maximum.",
cfgOptionName(cfgOptRepoRetentionFull + optionIdx), cfgOptionName(cfgOptRepoRetentionFullType + optionIdx),
strPtr(cfgOptionStr(cfgOptRepoRetentionFullType + optionIdx)),
strZ(cfgOptionStr(cfgOptRepoRetentionFullType + optionIdx)),
cfgOptionName(cfgOptRepoRetentionFull + optionIdx));
}
}
@ -162,7 +162,7 @@ cfgLoadUpdateOption(void)
const String *msgArchiveOff = strNewFmt(
"WAL segments will not be expired: option '" CFGOPT_REPO1_RETENTION_ARCHIVE_TYPE "=%s' but",
strPtr(archiveRetentionType));
strZ(archiveRetentionType));
// If the archive retention is not explicitly set then determine what it should be defaulted to
if (!cfgOptionTest(cfgOptRepoRetentionArchive + optionIdx))
@ -189,7 +189,8 @@ cfgLoadUpdateOption(void)
}
else
{
LOG_WARN_FMT("%s neither option '%s' nor option '%s' is set", strPtr(msgArchiveOff),
LOG_WARN_FMT(
"%s neither option '%s' nor option '%s' is set", strZ(msgArchiveOff),
cfgOptionName(cfgOptRepoRetentionArchive + optionIdx),
cfgOptionName(cfgOptRepoRetentionDiff + optionIdx));
}
@ -198,7 +199,8 @@ cfgLoadUpdateOption(void)
{
CHECK(strEqZ(archiveRetentionType, CFGOPTVAL_TMP_REPO_RETENTION_ARCHIVE_TYPE_INCR));
LOG_WARN_FMT("%s option '%s' is not set", strPtr(msgArchiveOff),
LOG_WARN_FMT(
"%s option '%s' is not set", strZ(msgArchiveOff),
cfgOptionName(cfgOptRepoRetentionArchive + optionIdx));
}
}
@ -231,7 +233,7 @@ cfgLoadUpdateOption(void)
"\nHINT: RFC-2818 forbids dots in wildcard matches."
"\nHINT: TLS/SSL verification cannot proceed with this bucket name."
"\nHINT: remove dots from the bucket name.",
strPtr(cfgOptionStr(cfgOptRepoS3Bucket)));
strZ(cfgOptionStr(cfgOptRepoS3Bucket)));
}
// Check/update compress-type if compress is valid. There should be no references to the compress option outside this block.
@ -282,8 +284,8 @@ cfgLoadLogFile(void)
{
// Construct log filename prefix
String *logFile = strNewFmt(
"%s/%s-%s", strPtr(cfgOptionStr(cfgOptLogPath)),
cfgOptionTest(cfgOptStanza) ? strPtr(cfgOptionStr(cfgOptStanza)): "all", cfgCommandName(cfgCommand()));
"%s/%s-%s", strZ(cfgOptionStr(cfgOptLogPath)),
cfgOptionTest(cfgOptStanza) ? strZ(cfgOptionStr(cfgOptStanza)): "all", cfgCommandName(cfgCommand()));
// ??? Append async for local/remote archive async commands. It would be good to find a more generic way to do this in
// case the async role is added to more commands.
@ -295,7 +297,7 @@ cfgLoadLogFile(void)
// Add command role if it is not default
if (cfgCommandRole() != cfgCmdRoleDefault)
strCatFmt(logFile, "-%s", strPtr(cfgCommandRoleStr(cfgCommandRole())));
strCatFmt(logFile, "-%s", strZ(cfgCommandRoleStr(cfgCommandRole())));
// Add process id if local or remote role
if (cfgCommandRole() == cfgCmdRoleLocal || cfgCommandRole() == cfgCmdRoleRemote)
@ -305,7 +307,7 @@ cfgLoadLogFile(void)
strCatZ(logFile, ".log");
// Attempt to open log file
if (!logFileSet(strPtr(logFile)))
if (!logFileSet(strZ(logFile)))
cfgOptionSet(cfgOptLogLevelFile, cfgSourceParam, varNewStrZ("off"));
}
MEM_CONTEXT_TEMP_END();

80
src/config/parse.c
View File

@ -93,7 +93,7 @@ optionFind(const String *option)
while (optionList[optionIdx].name != NULL)
{
if (strcmp(strPtr(option), optionList[optionIdx].name) == 0)
if (strcmp(strZ(option), optionList[optionIdx].name) == 0)
break;
optionIdx++;
@ -176,7 +176,7 @@ convertToByte(String **value, double *valueDbl)
if (regExpMatchOne(STRDEF("^[0-9]+(kb|k|mb|m|gb|g|tb|t|pb|p|b)*$"), result))
{
// Get the character array and size
const char *strArray = strPtr(result);
const char *strArray = strZ(result);
size_t size = strSize(result);
int chrPos = -1;
@ -215,7 +215,7 @@ convertToByte(String **value, double *valueDbl)
*value = result;
}
else
THROW_FMT(FormatError, "value '%s' is not valid", strPtr(*value));
THROW_FMT(FormatError, "value '%s' is not valid", strZ(*value));
FUNCTION_LOG_RETURN_VOID();
}
@ -316,9 +316,9 @@ cfgFileLoad( // NOTE: Pas
if (optionList[cfgOptConfigPath].found)
{
optConfigDefault =
strNewFmt("%s/%s", strPtr(strLstGet(optionList[cfgOptConfigPath].valueList, 0)), strBaseZ(optConfigDefault));
strNewFmt("%s/%s", strZ(strLstGet(optionList[cfgOptConfigPath].valueList, 0)), strBaseZ(optConfigDefault));
optConfigIncludePathDefault =
strNewFmt("%s/%s", strPtr(strLstGet(optionList[cfgOptConfigPath].valueList, 0)), PGBACKREST_CONFIG_INCLUDE_PATH);
strNewFmt("%s/%s", strZ(strLstGet(optionList[cfgOptConfigPath].valueList, 0)), PGBACKREST_CONFIG_INCLUDE_PATH);
}
// If the --no-config option was passed then do not load the config file
@ -400,7 +400,7 @@ cfgFileLoad( // NOTE: Pas
&result,
storageGetP(
storageNewReadP(
storageLocal(), strNewFmt("%s/%s", strPtr(configIncludePath), strPtr(strLstGet(list, listIdx))),
storageLocal(), strNewFmt("%s/%s", strZ(configIncludePath), strZ(strLstGet(list, listIdx))),
.ignoreMissing = true)));
}
}
@ -472,7 +472,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (strLstSize(commandPart) == 2)
{
// Get command id
commandId = cfgCommandId(strPtr(strLstGet(commandPart, 0)), false);
commandId = cfgCommandId(strZ(strLstGet(commandPart, 0)), false);
// If command id is valid then get command role id
if (commandId != cfgCmdNone)
@ -651,19 +651,19 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
// Warn if the option not found
if (optionList[optionIdx].name == NULL)
{
LOG_WARN_FMT("environment contains invalid option '%s'", strPtr(key));
LOG_WARN_FMT("environment contains invalid option '%s'", strZ(key));
continue;
}
// Warn if negate option found in env
else if (optionList[optionIdx].val & PARSE_NEGATE_FLAG)
{
LOG_WARN_FMT("environment contains invalid negate option '%s'", strPtr(key));
LOG_WARN_FMT("environment contains invalid negate option '%s'", strZ(key));
continue;
}
// Warn if reset option found in env
else if (optionList[optionIdx].val & PARSE_RESET_FLAG)
{
LOG_WARN_FMT("environment contains invalid reset option '%s'", strPtr(key));
LOG_WARN_FMT("environment contains invalid reset option '%s'", strZ(key));
continue;
}
@ -675,7 +675,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
continue;
if (strSize(value) == 0)
THROW_FMT(OptionInvalidValueError, "environment variable '%s' must have a value", strPtr(key));
THROW_FMT(OptionInvalidValueError, "environment variable '%s' must have a value", strZ(key));
// Continue if the option has already been specified on the command line
if (parseOptionList[optionId].found)
@ -690,7 +690,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (strEqZ(value, "n"))
parseOptionList[optionId].negate = true;
else if (!strEqZ(value, "y"))
THROW_FMT(OptionInvalidValueError, "environment boolean option '%s' must be 'y' or 'n'", strPtr(key));
THROW_FMT(OptionInvalidValueError, "environment boolean option '%s' must be 'y' or 'n'", strZ(key));
}
// Else split list/hash into separate values
else if (cfgDefOptionMulti(optionDefId))
@ -729,7 +729,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (stanza != NULL)
{
strLstAdd(sectionList, strNewFmt("%s:%s", strPtr(stanza), cfgCommandName(cfgCommand())));
strLstAdd(sectionList, strNewFmt("%s:%s", strZ(stanza), cfgCommandName(cfgCommand())));
strLstAdd(sectionList, stanza);
}
@ -754,19 +754,19 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
// Warn if the option not found
if (optionList[optionIdx].name == NULL)
{
LOG_WARN_FMT("configuration file contains invalid option '%s'", strPtr(key));
LOG_WARN_FMT("configuration file contains invalid option '%s'", strZ(key));
continue;
}
// Warn if negate option found in config
else if (optionList[optionIdx].val & PARSE_NEGATE_FLAG)
{
LOG_WARN_FMT("configuration file contains negate option '%s'", strPtr(key));
LOG_WARN_FMT("configuration file contains negate option '%s'", strZ(key));
continue;
}
// Warn if reset option found in config
else if (optionList[optionIdx].val & PARSE_RESET_FLAG)
{
LOG_WARN_FMT("configuration file contains reset option '%s'", strPtr(key));
LOG_WARN_FMT("configuration file contains reset option '%s'", strZ(key));
continue;
}
@ -776,7 +776,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
/// Warn if this option should be command-line only
if (cfgDefOptionSection(optionDefId) == cfgDefSectionCommandLine)
{
LOG_WARN_FMT("configuration file contains command-line only option '%s'", strPtr(key));
LOG_WARN_FMT("configuration file contains command-line only option '%s'", strZ(key));
continue;
}
@ -788,7 +788,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
{
THROW_FMT(
OptionInvalidError, "configuration file contains duplicate options ('%s', '%s') in section '[%s]'",
strPtr(key), strPtr(varStr(optionFoundName)), strPtr(section));
strZ(key), strZ(varStr(optionFoundName)), strZ(section));
}
else
kvPut(optionFound, optionFoundKey, VARSTR(key));
@ -800,8 +800,8 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (sectionIdx % 2 == 0)
{
LOG_WARN_FMT(
"configuration file contains option '%s' invalid for section '%s'", strPtr(key),
strPtr(section));
"configuration file contains option '%s' invalid for section '%s'", strZ(key),
strZ(section));
continue;
}
@ -813,8 +813,8 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
strBeginsWithZ(section, CFGDEF_SECTION_GLOBAL))
{
LOG_WARN_FMT(
"configuration file contains stanza-only option '%s' in global section '%s'", strPtr(key),
strPtr(section));
"configuration file contains stanza-only option '%s' in global section '%s'", strZ(key),
strZ(section));
continue;
}
@ -842,8 +842,8 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (strSize(value) == 0)
{
THROW_FMT(
OptionInvalidValueError, "section '%s', key '%s' must have a value", strPtr(section),
strPtr(key));
OptionInvalidValueError, "section '%s', key '%s' must have a value", strZ(section),
strZ(key));
}
if (cfgDefOptionType(optionDefId) == cfgDefOptTypeBoolean)
@ -851,7 +851,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (strEqZ(value, "n"))
parseOptionList[optionId].negate = true;
else if (!strEqZ(value, "y"))
THROW_FMT(OptionInvalidValueError, "boolean option '%s' must be 'y' or 'n'", strPtr(key));
THROW_FMT(OptionInvalidValueError, "boolean option '%s' must be 'y' or 'n'", strZ(key));
}
// Else add the string value
else
@ -944,7 +944,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
// If a depend list exists, make sure the value is in the list
else if (cfgDefOptionDependValueTotal(commandDefId, optionDefId) > 0)
{
dependResolved = cfgDefOptionDependValueValid(commandDefId, optionDefId, strPtr(varStr(dependValue)));
dependResolved = cfgDefOptionDependValueValid(commandDefId, optionDefId, strZ(varStr(dependValue)));
// If depend not resolved and option value is set on the command-line then error. It's OK to have
// unresolved options in the config file because they may be there for another command. For instance,
@ -981,17 +981,17 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
const String *errorValue = EMPTY_STR;
if (strLstSize(dependValueList) == 1)
errorValue = strNewFmt(" = %s", strPtr(strLstGet(dependValueList, 0)));
errorValue = strNewFmt(" = %s", strZ(strLstGet(dependValueList, 0)));
else if (strLstSize(dependValueList) > 1)
errorValue = strNewFmt(" in (%s)", strPtr(strLstJoin(dependValueList, ", ")));
errorValue = strNewFmt(" in (%s)", strZ(strLstJoin(dependValueList, ", ")));
// Throw the error
THROW(
OptionInvalidError,
strPtr(
strZ(
strNewFmt(
"option '%s' not valid without option '%s'%s", cfgOptionName(optionId),
strPtr(dependOptionName), strPtr(errorValue))));
strZ(dependOptionName), strZ(errorValue))));
}
}
}
@ -1013,14 +1013,14 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
for (unsigned int listIdx = 0; listIdx < strLstSize(parseOption->valueList); listIdx++)
{
const char *pair = strPtr(strLstGet(parseOption->valueList, listIdx));
const char *pair = strZ(strLstGet(parseOption->valueList, listIdx));
const char *equal = strchr(pair, '=');
if (equal == NULL)
{
THROW_FMT(
OptionInvalidError, "key/value '%s' not valid for '%s' option",
strPtr(strLstGet(parseOption->valueList, listIdx)), cfgOptionName(optionId));
strZ(strLstGet(parseOption->valueList, listIdx)), cfgOptionName(optionId));
}
kvPut(keyValue, VARSTR(strNewN(pair, (size_t)(equal - pair))), VARSTRZ(equal + 1));
@ -1059,7 +1059,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
CATCH_ANY()
{
THROW_FMT(
OptionInvalidValueError, "'%s' is not valid for '%s' option", strPtr(value),
OptionInvalidValueError, "'%s' is not valid for '%s' option", strZ(value),
cfgOptionName(optionId));
}
TRY_END();
@ -1070,7 +1070,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
valueDbl > cfgDefOptionAllowRangeMax(commandDefId, optionDefId)))
{
THROW_FMT(
OptionInvalidValueError, "'%s' is out of range for '%s' option", strPtr(value),
OptionInvalidValueError, "'%s' is out of range for '%s' option", strZ(value),
cfgOptionName(optionId));
}
}
@ -1081,7 +1081,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (strSize(value) == 0)
{
THROW_FMT(
OptionInvalidValueError, "'%s' must be >= 1 character for '%s' option", strPtr(value),
OptionInvalidValueError, "'%s' must be >= 1 character for '%s' option", strZ(value),
cfgOptionName(optionId));
}
@ -1089,15 +1089,15 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (!strBeginsWithZ(value, "/"))
{
THROW_FMT(
OptionInvalidValueError, "'%s' must begin with / for '%s' option", strPtr(value),
OptionInvalidValueError, "'%s' must begin with / for '%s' option", strZ(value),
cfgOptionName(optionId));
}
// Make sure there are no occurrences of //
if (strstr(strPtr(value), "//") != NULL)
if (strstr(strZ(value), "//") != NULL)
{
THROW_FMT(
OptionInvalidValueError, "'%s' cannot contain // for '%s' option", strPtr(value),
OptionInvalidValueError, "'%s' cannot contain // for '%s' option", strZ(value),
cfgOptionName(optionId));
}
@ -1108,10 +1108,10 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
// If the option has an allow list then check it
if (cfgDefOptionAllowList(commandDefId, optionDefId) &&
!cfgDefOptionAllowListValueValid(commandDefId, optionDefId, strPtr(value)))
!cfgDefOptionAllowListValueValid(commandDefId, optionDefId, strZ(value)))
{
THROW_FMT(
OptionInvalidValueError, "'%s' is not allowed for '%s' option", strPtr(value),
OptionInvalidValueError, "'%s' is not allowed for '%s' option", strZ(value),
cfgOptionName(optionId));
}

2
src/config/protocol.c
View File

@ -37,7 +37,7 @@ configProtocol(const String *command, const VariantList *paramList, ProtocolServ
VariantList *optionList = varLstNew();
for (unsigned int optionIdx = 0; optionIdx < varLstSize(paramList); optionIdx++)
varLstAdd(optionList, varDup(cfgOption(cfgOptionId(strPtr(varStr(varLstGet(paramList, optionIdx)))))));
varLstAdd(optionList, varDup(cfgOption(cfgOptionId(strZ(varStr(varLstGet(paramList, optionIdx)))))));
protocolServerResponse(server, varNewVarLst(optionList));
}

33
src/db/db.c
View File

@ -235,7 +235,7 @@ dbOpen(Db *this)
// Set application name to help identify the backup session
if (this->pgVersion >= PG_VERSION_APPLICATION_NAME)
dbExec(this, strNewFmt("set application_name = '%s'", strPtr(this->applicationName)));
dbExec(this, strNewFmt("set application_name = '%s'", strZ(this->applicationName)));
// There is no need to have parallelism enabled in a backup session. In particular, 9.6 marks pg_stop_backup() as
// parallel-safe but an error will be thrown if pg_stop_backup() is run in a worker.
@ -262,7 +262,7 @@ dbBackupStartQuery(unsigned int pgVersion, bool startFast)
"select lsn::text as lsn,\n"
" pg_catalog.pg_%sfile_name(lsn)::text as wal_segment_name\n"
" from pg_catalog.pg_start_backup('" PROJECT_NAME " backup started at ' || current_timestamp",
strPtr(pgWalName(pgVersion)));
strZ(pgWalName(pgVersion)));
// Start backup after immediate checkpoint
if (startFast)
@ -361,7 +361,7 @@ dbBackupStopQuery(unsigned int pgVersion)
String *result = strNewFmt(
"select lsn::text as lsn,\n"
" pg_catalog.pg_%sfile_name(lsn)::text as wal_segment_name",
strPtr(pgWalName(pgVersion)));
strZ(pgWalName(pgVersion)));
// For PostgreSQL >= 9.6 the backup label and tablespace map are returned from pg_stop_backup
if (pgVersion >= PG_VERSION_96)
@ -493,9 +493,9 @@ dbReplayWait(Db *this, const String *targetLsn, TimeMSec timeout)
// Loop until lsn has been reached or timeout
Wait *wait = waitNew(timeout);
bool targetReached = false;
const char *lsnName = strPtr(pgLsnName(dbPgVersion(this)));
const char *lsnName = strZ(pgLsnName(dbPgVersion(this)));
const String *replayLsnFunction = strNewFmt(
"pg_catalog.pg_last_%s_replay_%s()", strPtr(pgWalName(dbPgVersion(this))), lsnName);
"pg_catalog.pg_last_%s_replay_%s()", strZ(pgWalName(dbPgVersion(this))), lsnName);
const String *replayLsn = NULL;
do
@ -504,21 +504,22 @@ dbReplayWait(Db *this, const String *targetLsn, TimeMSec timeout)
String *query = strNewFmt(
"select replayLsn::text,\n"
" (replayLsn > '%s')::bool as targetReached",
strPtr(targetLsn));
strZ(targetLsn));
if (replayLsn != NULL)
{
strCatFmt(
query,
",\n"
" (replayLsn > '%s')::bool as replayProgress", strPtr(replayLsn));
" (replayLsn > '%s')::bool as replayProgress",
strZ(replayLsn));
}
strCatFmt(
query,
"\n"
" from %s as replayLsn",
strPtr(replayLsnFunction));
strZ(replayLsnFunction));
// Execute the query and get replayLsn
VariantList *row = dbQueryRow(this, query);
@ -532,7 +533,7 @@ dbReplayWait(Db *this, const String *targetLsn, TimeMSec timeout)
ArchiveTimeoutError,
"unable to query replay lsn on the standby using '%s'\n"
"HINT: Is this a standby?",
strPtr(replayLsnFunction));
strZ(replayLsnFunction));
}
targetReached = varBool(varLstGet(row, 1));
@ -549,8 +550,8 @@ dbReplayWait(Db *this, const String *targetLsn, TimeMSec timeout)
if (!targetReached)
{
THROW_FMT(
ArchiveTimeoutError, "timeout before standby replayed to %s - only reached %s", strPtr(targetLsn),
strPtr(replayLsn));
ArchiveTimeoutError, "timeout before standby replayed to %s - only reached %s", strZ(targetLsn),
strZ(replayLsn));
}
// Perform a checkpoint
@ -568,7 +569,7 @@ dbReplayWait(Db *this, const String *targetLsn, TimeMSec timeout)
"select (checkpoint_%s > '%s')::bool as targetReached,\n"
" checkpoint_%s::text as checkpointLsn\n"
" from pg_catalog.pg_control_checkpoint()",
lsnName, strPtr(targetLsn), lsnName);
lsnName, strZ(targetLsn), lsnName);
// Execute query
VariantList *row = dbQueryRow(this, query);
@ -579,7 +580,7 @@ dbReplayWait(Db *this, const String *targetLsn, TimeMSec timeout)
THROW_FMT(
ArchiveTimeoutError,
"the checkpoint lsn %s is less than the target lsn %s even though the replay lsn is %s",
strPtr(varStr(varLstGet(row, 1))), strPtr(targetLsn), strPtr(replayLsn));
strZ(varStr(varLstGet(row, 1))), strZ(targetLsn), strZ(replayLsn));
}
}
}
@ -631,7 +632,7 @@ dbWalSwitch(Db *this)
dbQueryColumn(this, STRDEF("select pg_catalog.pg_create_restore_point('" PROJECT_NAME " Archive Check')::text"));
// Request a WAL segment switch
const char *walName = strPtr(pgWalName(this->pgVersion));
const char *walName = strZ(pgWalName(this->pgVersion));
const String *walFileName = varStr(
dbQueryColumn(this, strNewFmt("select pg_catalog.pg_%sfile_name(pg_catalog.pg_switch_%s())::text", walName, walName)));
@ -704,6 +705,6 @@ String *
dbToLog(const Db *this)
{
return strNewFmt(
"{client: %s, remoteClient: %s}", this->client == NULL ? NULL_Z : strPtr(pgClientToLog(this->client)),
this->remoteClient == NULL ? NULL_Z : strPtr(protocolClientToLog(this->remoteClient)));
"{client: %s, remoteClient: %s}", this->client == NULL ? NULL_Z : strZ(pgClientToLog(this->client)),
this->remoteClient == NULL ? NULL_Z : strZ(protocolClientToLog(this->remoteClient)));
}

12
src/info/info.c
View File

@ -210,7 +210,7 @@ infoLoadCallback(void *data, const String *section, const String *key, const Str
if (strEq(key, INFO_KEY_FORMAT_STR))
{
if (jsonToUInt(value) != REPOSITORY_FORMAT)
THROW_FMT(FormatError, "expected format %d but found %d", REPOSITORY_FORMAT, cvtZToInt(strPtr(value)));
THROW_FMT(FormatError, "expected format %d but found %d", REPOSITORY_FORMAT, cvtZToInt(strZ(value)));
}
// Store pgBackRest version
else if (strEq(key, INFO_KEY_VERSION_STR))
@ -301,12 +301,12 @@ infoNewLoad(IoRead *read, InfoLoadNewCallback *callbackFunction, void *callbackD
const String *checksumActual = varStr(ioFilterResult(data.checksumActual));
if (data.checksumExpected == NULL)
THROW_FMT(ChecksumError, "invalid checksum, actual '%s' but no checksum found", strPtr(checksumActual));
THROW_FMT(ChecksumError, "invalid checksum, actual '%s' but no checksum found", strZ(checksumActual));
else if (!strEq(data.checksumExpected, checksumActual))
{
THROW_FMT(
ChecksumError, "invalid checksum, actual '%s' but expected '%s'", strPtr(checksumActual),
strPtr(data.checksumExpected));
ChecksumError, "invalid checksum, actual '%s' but expected '%s'", strZ(checksumActual),
strZ(data.checksumExpected));
}
}
MEM_CONTEXT_TEMP_END();
@ -525,7 +525,7 @@ infoLoad(const String *error, InfoLoadCallback *callbackFunction, void *callback
if (loadErrorType == NULL)
{
loadErrorType = errorType();
loadErrorMessage = strNewFmt("%s:", strPtr(error));
loadErrorMessage = strNewFmt("%s:", strZ(error));
}
// Else if the error type is different
else if (loadErrorType != errorType())
@ -552,7 +552,7 @@ infoLoad(const String *error, InfoLoadCallback *callbackFunction, void *callback
// Error when no file was loaded
if (!loaded)
THROWP(loadErrorType, strPtr(loadErrorMessage));
THROWP(loadErrorType, strZ(loadErrorMessage));
}
MEM_CONTEXT_TEMP_END();

9
src/info/infoArchive.c
View File

@ -157,7 +157,7 @@ infoArchiveIdHistoryMatch(
THROW_FMT(
ArchiveMismatchError,
"unable to retrieve the archive id for database version '%s' and system-id '%" PRIu64 "'",
strPtr(pgVersionToStr(pgVersion)), pgSystemId);
strZ(pgVersionToStr(pgVersion)), pgSystemId);
}
FUNCTION_LOG_RETURN(STRING, archiveId);
@ -269,7 +269,7 @@ infoArchiveLoadFileCallback(void *data, unsigned int try)
if (try < 2)
{
// Construct filename based on try
const String *fileName = try == 0 ? loadData->fileName : strNewFmt("%s" INFO_COPY_EXT, strPtr(loadData->fileName));
const String *fileName = try == 0 ? loadData->fileName : strNewFmt("%s" INFO_COPY_EXT, strZ(loadData->fileName));
// Attempt to load the file
IoRead *read = storageReadIo(storageNewReadP(loadData->storage, fileName));
@ -311,7 +311,7 @@ infoArchiveLoadFile(const Storage *storage, const String *fileName, CipherType c
MEM_CONTEXT_TEMP_BEGIN()
{
const char *fileNamePath = strPtr(storagePathP(storage, fileName));
const char *fileNamePath = strZ(storagePathP(storage, fileName));
TRY_BEGIN()
{
@ -363,8 +363,7 @@ infoArchiveSaveFile(
infoArchiveSave(infoArchive, write);
// Make a copy of the file
storageCopy(
storageNewReadP(storage, fileName), storageNewWriteP(storage, strNewFmt("%s" INFO_COPY_EXT, strPtr(fileName))));
storageCopy(storageNewReadP(storage, fileName), storageNewWriteP(storage, strNewFmt("%s" INFO_COPY_EXT, strZ(fileName))));
}
MEM_CONTEXT_TEMP_END();

21
src/info/infoBackup.c
View File

@ -148,7 +148,7 @@ infoBackupLoadCallback(void *data, const String *section, const String *key, con
.backupInfoSize = varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_INFO_SIZE_VAR)),
.backupInfoSizeDelta = varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_INFO_SIZE_DELTA_VAR)),
.backupLabel = strDup(key),
.backupPgId = cvtZToUInt(strPtr(varStrForce(kvGet(backupKv, INFO_KEY_DB_ID_VAR)))),
.backupPgId = cvtZToUInt(strZ(varStrForce(kvGet(backupKv, INFO_KEY_DB_ID_VAR)))),
// When reading timestamps, read as uint64 to ensure always positive value (guarantee no backups before 1970)
.backupTimestampStart = (time_t)varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_TIMESTAMP_START_VAR)),
@ -579,7 +579,7 @@ infoBackupLoadFileCallback(void *data, unsigned int try)
if (try < 2)
{
// Construct filename based on try
const String *fileName = try == 0 ? loadData->fileName : strNewFmt("%s" INFO_COPY_EXT, strPtr(loadData->fileName));
const String *fileName = try == 0 ? loadData->fileName : strNewFmt("%s" INFO_COPY_EXT, strZ(loadData->fileName));
// Attempt to load the file
IoRead *read = storageReadIo(storageNewReadP(loadData->storage, fileName));
@ -621,7 +621,7 @@ infoBackupLoadFile(const Storage *storage, const String *fileName, CipherType ci
MEM_CONTEXT_TEMP_BEGIN()
{
const char *fileNamePath = strPtr(storagePathP(storage, fileName));
const char *fileNamePath = strZ(storagePathP(storage, fileName));
TRY_BEGIN()
{
@ -677,7 +677,7 @@ infoBackupLoadFileReconstruct(const Storage *storage, const String *fileName, Ci
for (unsigned int backupCurrIdx = 0; backupCurrIdx < strLstSize(backupCurrentList); backupCurrIdx++)
{
String *backupLabel = strLstGet(backupCurrentList, backupCurrIdx);
String *manifestFileName = strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel));
String *manifestFileName = strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel));
// If the manifest does not exist on disk and this backup has not already been deleted from the current list in the
// infoBackup object, then remove it and its dependencies
@ -689,7 +689,7 @@ infoBackupLoadFileReconstruct(const Storage *storage, const String *fileName, Ci
{
String *removeBackup = strLstGet(backupList, backupIdx);
LOG_WARN_FMT("backup '%s' missing manifest removed from " INFO_BACKUP_FILE, strPtr(removeBackup));
LOG_WARN_FMT("backup '%s' missing manifest removed from " INFO_BACKUP_FILE, strZ(removeBackup));
infoBackupDataDelete(infoBackup, removeBackup);
}
@ -707,7 +707,7 @@ infoBackupLoadFileReconstruct(const Storage *storage, const String *fileName, Ci
// If it does not exist in the list of current backups, then if it is valid, add it
if (!strLstExists(backupCurrentList, backupLabel))
{
String *manifestFileName = strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strPtr(backupLabel));
String *manifestFileName = strNewFmt(STORAGE_REPO_BACKUP "/%s/" BACKUP_MANIFEST_FILE, strZ(backupLabel));
// Check if a completed backup exists (backup.manifest only - ignore .copy)
if (storageExistsP(storage, manifestFileName))
@ -730,7 +730,7 @@ infoBackupLoadFileReconstruct(const Storage *storage, const String *fileName, Ci
(manData->backupLabelPrior == NULL ||
infoBackupDataByLabel(infoBackup, manData->backupLabelPrior) != NULL))
{
LOG_WARN_FMT("backup '%s' found in repository added to " INFO_BACKUP_FILE, strPtr(backupLabel));
LOG_WARN_FMT("backup '%s' found in repository added to " INFO_BACKUP_FILE, strZ(backupLabel));
infoBackupDataAdd(infoBackup, manifest);
found = true;
break;
@ -738,7 +738,7 @@ infoBackupLoadFileReconstruct(const Storage *storage, const String *fileName, Ci
}
if (!found)
LOG_WARN_FMT("invalid backup '%s' cannot be added to current backups", strPtr(manData->backupLabel));
LOG_WARN_FMT("invalid backup '%s' cannot be added to current backups", strZ(manData->backupLabel));
}
}
}
@ -774,8 +774,7 @@ infoBackupSaveFile(
infoBackupSave(infoBackup, write);
// Make a copy of the file
storageCopy(
storageNewReadP(storage, fileName), storageNewWriteP(storage, strNewFmt("%s" INFO_COPY_EXT, strPtr(fileName))));
storageCopy(storageNewReadP(storage, fileName), storageNewWriteP(storage, strNewFmt("%s" INFO_COPY_EXT, strZ(fileName))));
}
MEM_CONTEXT_TEMP_END();
@ -786,5 +785,5 @@ infoBackupSaveFile(
String *
infoBackupDataToLog(const InfoBackupData *this)
{
return strNewFmt("{label: %s, pgId: %u}", strPtr(this->backupLabel), this->backupPgId);
return strNewFmt("{label: %s, pgId: %u}", strZ(this->backupLabel), this->backupPgId);
}

4
src/info/infoPg.c
View File

@ -132,7 +132,7 @@ infoPgLoadCallback(void *data, const String *section, const String *key, const S
// Get db values that are common to all info files
InfoPgData infoPgData =
{
.id = cvtZToUInt(strPtr(key)),
.id = cvtZToUInt(strZ(key)),
.version = pgVersionFromStr(varStr(kvGet(pgDataKv, INFO_KEY_DB_VERSION_VAR))),
// This is different in archive.info due to a typo that can't be fixed without a format version bump
@ -386,7 +386,7 @@ infoPgArchiveId(const InfoPg *this, unsigned int pgDataIdx)
InfoPgData pgData = infoPgData(this, pgDataIdx);
FUNCTION_LOG_RETURN(STRING, strNewFmt("%s-%u", strPtr(pgVersionToStr(pgData.version)), pgData.id));
FUNCTION_LOG_RETURN(STRING, strNewFmt("%s-%u", strZ(pgVersionToStr(pgData.version)), pgData.id));
}
/**********************************************************************************************************************************/

121
src/info/manifest.c
View File

@ -443,14 +443,14 @@ manifestBuildCallback(void *data, const StorageInfo *info)
unsigned int pgVersion = buildData.manifest->data.pgVersion;
// Contruct the name used to identify this file/link/path in the manifest
const String *manifestName = strNewFmt("%s/%s", strPtr(buildData.manifestParentName), strPtr(info->name));
const String *manifestName = strNewFmt("%s/%s", strZ(buildData.manifestParentName), strZ(info->name));
// Skip excluded files/links/paths
if (buildData.excludeSingle != NULL && strLstExists(buildData.excludeSingle, manifestName))
{
LOG_INFO_FMT(
"exclude '%s/%s' from backup using '%s' exclusion", strPtr(buildData.pgPath), strPtr(info->name),
strPtr(strSub(manifestName, sizeof(MANIFEST_TARGET_PGDATA))));
"exclude '%s/%s' from backup using '%s' exclusion", strZ(buildData.pgPath), strZ(info->name),
strZ(strSub(manifestName, sizeof(MANIFEST_TARGET_PGDATA))));
FUNCTION_TEST_RETURN_VOID();
return;
@ -468,7 +468,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
{
THROW_FMT(
LinkExpectedError, "'%s' is not a symlink - " MANIFEST_TARGET_PGTBLSPC " should contain only symlinks",
strPtr(manifestName));
strZ(manifestName));
}
// Add path to manifest
@ -486,8 +486,8 @@ manifestBuildCallback(void *data, const StorageInfo *info)
if (buildData.excludeContent != NULL && strLstExists(buildData.excludeContent, manifestName))
{
LOG_INFO_FMT(
"exclude contents of '%s/%s' from backup using '%s/' exclusion", strPtr(buildData.pgPath), strPtr(info->name),
strPtr(strSub(manifestName, sizeof(MANIFEST_TARGET_PGDATA))));
"exclude contents of '%s/%s' from backup using '%s/' exclusion", strZ(buildData.pgPath), strZ(info->name),
strZ(strSub(manifestName, sizeof(MANIFEST_TARGET_PGDATA))));
FUNCTION_TEST_RETURN_VOID();
return;
@ -558,7 +558,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
// Recurse into the path
ManifestBuildData buildDataSub = buildData;
buildDataSub.manifestParentName = manifestName;
buildDataSub.pgPath = strNewFmt("%s/%s", strPtr(buildData.pgPath), strPtr(info->name));
buildDataSub.pgPath = strNewFmt("%s/%s", strZ(buildData.pgPath), strZ(info->name));
if (buildData.dbPathExp != NULL)
buildDataSub.dbPath = regExpMatch(buildData.dbPathExp, manifestName);
@ -578,7 +578,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
{
THROW_FMT(
LinkExpectedError, "'%s' is not a symlink - " MANIFEST_TARGET_PGTBLSPC " should contain only symlinks",
strPtr(manifestName));
strZ(manifestName));
}
// Skip pg_internal.init since it is recreated on startup. It's also possible, (though unlikely) that a temp file with
@ -676,8 +676,8 @@ manifestBuildCallback(void *data, const StorageInfo *info)
if (linkedCheck.exists && linkedCheck.type == storageTypeLink)
{
THROW_FMT(
LinkDestinationError, "link '%s/%s' cannot reference another link '%s'", strPtr(buildData.pgPath),
strPtr(info->name), strPtr(linkDestinationAbsolute));
LinkDestinationError, "link '%s/%s' cannot reference another link '%s'", strZ(buildData.pgPath),
strZ(info->name), strZ(linkDestinationAbsolute));
}
// Initialize link and target
@ -707,7 +707,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
// Identify this target as a tablespace
target.name = manifestName;
target.tablespaceId = cvtZToUInt(strPtr(info->name));
target.tablespaceId = cvtZToUInt(strZ(info->name));
// Look for this tablespace in the provided list (list may be null for off-line backup)
if (buildData.tablespaceList != NULL)
@ -734,7 +734,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
// If no tablespace name was found then create one
if (target.tablespaceName == NULL)
target.tablespaceName = strNewFmt("ts%s", strPtr(info->name));
target.tablespaceName = strNewFmt("ts%s", strZ(info->name));
// Add a dummy pg_tblspc path entry if it does not already exist. This entry will be ignored by restore but it is
// part of the original manifest format so we need to have it.
@ -773,8 +773,8 @@ manifestBuildCallback(void *data, const StorageInfo *info)
// Update build structure to reflect the path added above and the tablespace id
buildData.manifestParentName = manifestName;
manifestName = strNewFmt("%s/%s", strPtr(manifestName), strPtr(buildData.tablespaceId));
buildData.pgPath = strNewFmt("%s/%s", strPtr(buildData.pgPath), strPtr(info->name));
manifestName = strNewFmt("%s/%s", strZ(manifestName), strZ(buildData.tablespaceId));
buildData.pgPath = strNewFmt("%s/%s", strZ(buildData.pgPath), strZ(info->name));
linkName = buildData.tablespaceId;
}
// If no tablespace id then parent manifest name is the tablespace directory
@ -783,7 +783,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
}
// Add info about the linked file/path
const String *linkPgPath = strNewFmt("%s/%s", strPtr(buildData.pgPath), strPtr(linkName));
const String *linkPgPath = strNewFmt("%s/%s", strZ(buildData.pgPath), strZ(linkName));
StorageInfo linkedInfo = storageInfoP(
buildData.storagePg, linkPgPath, .followLink = true, .ignoreMissing = true);
linkedInfo.name = linkName;
@ -834,7 +834,7 @@ manifestBuildCallback(void *data, const StorageInfo *info)
// -------------------------------------------------------------------------------------------------------------------------
case storageTypeSpecial:
{
LOG_WARN_FMT("exclude special file '%s/%s' from backup", strPtr(buildData.pgPath), strPtr(info->name));
LOG_WARN_FMT("exclude special file '%s/%s' from backup", strZ(buildData.pgPath), strZ(info->name));
break;
}
}
@ -888,7 +888,7 @@ manifestNewBuild(
.checksumPage = checksumPage,
.tablespaceList = tablespaceList,
.manifestParentName = MANIFEST_TARGET_PGDATA_STR,
.manifestWalName = strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strPtr(pgWalPath(pgVersion))),
.manifestWalName = strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strZ(pgWalPath(pgVersion))),
.pgPath = storagePathP(storagePg, NULL),
};
@ -900,7 +900,7 @@ manifestNewBuild(
ASSERT(buildData.tablespaceId != NULL);
// Expression to identify database paths
buildData.dbPathExp = regExpNew(strNewFmt("^" DB_PATH_EXP "$", strPtr(buildData.tablespaceId)));
buildData.dbPathExp = regExpNew(strNewFmt("^" DB_PATH_EXP "$", strZ(buildData.tablespaceId)));
// Expression to find temp relations
buildData.tempRelationExp = regExpNew(STRDEF("^t[0-9]+_" RELATION_EXP "$"));
@ -912,7 +912,7 @@ manifestNewBuild(
strNewFmt(
"^((" MANIFEST_TARGET_PGDATA "/(" PG_PATH_BASE "|" PG_PATH_GLOBAL "|%s|" PG_PATH_PGMULTIXACT "))|"
MANIFEST_TARGET_PGTBLSPC ")/",
strPtr(pgXactPath(pgVersion))));
strZ(pgXactPath(pgVersion))));
// Build list of exclusions
// ---------------------------------------------------------------------------------------------------------------------
@ -920,7 +920,7 @@ manifestNewBuild(
{
for (unsigned int excludeIdx = 0; excludeIdx < strLstSize(excludeList); excludeIdx++)
{
const String *exclude = strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strPtr(strLstGet(excludeList, excludeIdx)));
const String *exclude = strNewFmt(MANIFEST_TARGET_PGDATA "/%s", strZ(strLstGet(excludeList, excludeIdx)));
// If the exclusions refers to the contents of a path
if (strEndsWithZ(exclude, "/"))
@ -980,7 +980,7 @@ manifestNewBuild(
// -------------------------------------------------------------------------------------------------------------------------
if (pgVersion >= PG_VERSION_91)
{
RegExp *relationExp = regExpNew(strNewFmt("^" DB_PATH_EXP "/" RELATION_EXP "$", strPtr(buildData.tablespaceId)));
RegExp *relationExp = regExpNew(strNewFmt("^" DB_PATH_EXP "/" RELATION_EXP "$", strZ(buildData.tablespaceId)));
unsigned int fileIdx = 0;
const String *lastRelationFileId = NULL;
bool lastRelationFileIdUnlogged = false;
@ -998,7 +998,7 @@ manifestNewBuild(
// Strip off the numeric part of the relation
for (unsigned int nameIdx = 0; nameIdx < strSize(fileName); nameIdx++)
{
char nameChr = strPtr(fileName)[nameIdx];
char nameChr = strZ(fileName)[nameIdx];
if (!isdigit(nameChr))
break;
@ -1010,8 +1010,7 @@ manifestNewBuild(
if (lastRelationFileId == NULL || !strEq(lastRelationFileId, relationFileId))
{
// Determine if the relation is unlogged
const String *relationInit = strNewFmt(
"%s/%s_init", strPtr(strPath(file->name)), strPtr(relationFileId));
const String *relationInit = strNewFmt("%s/%s_init", strZ(strPath(file->name)), strZ(relationFileId));
lastRelationFileId = relationFileId;
lastRelationFileIdUnlogged = manifestFileFindDefault(this, relationInit, NULL) != NULL;
}
@ -1078,7 +1077,7 @@ manifestBuildValidate(Manifest *this, bool delta, time_t copyStart, CompressType
if (file->timestamp > copyStart)
{
LOG_WARN_FMT(
"file '%s' has timestamp in the future, enabling delta checksum", strPtr(manifestPathPg(file->name)));
"file '%s' has timestamp in the future, enabling delta checksum", strZ(manifestPathPg(file->name)));
this->data.backupOptionDelta = BOOL_TRUE_VAR;
break;
@ -1127,7 +1126,7 @@ manifestBuildIncr(Manifest *this, const Manifest *manifestPrior, BackupType type
LOG_WARN_FMT(
"a timeline switch has occurred since the %s backup, enabling delta checksum\n"
"HINT: this is normal after restoring from backup or promoting a standby.",
strPtr(manifestData(manifestPrior)->backupLabel));
strZ(manifestData(manifestPrior)->backupLabel));
this->data.backupOptionDelta = BOOL_TRUE_VAR;
}
@ -1136,7 +1135,7 @@ manifestBuildIncr(Manifest *this, const Manifest *manifestPrior, BackupType type
{
LOG_WARN_FMT(
"the online option has changed since the %s backup, enabling delta checksum",
strPtr(manifestData(manifestPrior)->backupLabel));
strZ(manifestData(manifestPrior)->backupLabel));
this->data.backupOptionDelta = BOOL_TRUE_VAR;
}
@ -1158,7 +1157,7 @@ manifestBuildIncr(Manifest *this, const Manifest *manifestPrior, BackupType type
{
LOG_WARN_FMT(
"file '%s' has timestamp earlier than prior backup, enabling delta checksum",
strPtr(manifestPathPg(file->name)));
strZ(manifestPathPg(file->name)));
this->data.backupOptionDelta = BOOL_TRUE_VAR;
break;
@ -1169,7 +1168,7 @@ manifestBuildIncr(Manifest *this, const Manifest *manifestPrior, BackupType type
{
LOG_WARN_FMT(
"file '%s' has same timestamp as prior but different size, enabling delta checksum",
strPtr(manifestPathPg(file->name)));
strZ(manifestPathPg(file->name)));
this->data.backupOptionDelta = BOOL_TRUE_VAR;
break;
@ -1385,7 +1384,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
const Variant *timestamp = kvGet(fileKv, MANIFEST_KEY_TIMESTAMP_VAR);
if (timestamp == NULL)
THROW_FMT(FormatError, "missing timestamp for file '%s'", strPtr(key));
THROW_FMT(FormatError, "missing timestamp for file '%s'", strZ(key));
file.timestamp = (time_t)varUInt64(timestamp);
@ -1395,7 +1394,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
const Variant *size = kvGet(fileKv, MANIFEST_KEY_SIZE_VAR);
if (size == NULL)
THROW_FMT(FormatError, "missing size for file '%s'", strPtr(key));
THROW_FMT(FormatError, "missing size for file '%s'", strZ(key));
file.size = varUInt64(size);
@ -1411,10 +1410,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
// Else if the key exists then load it. The key might not exist if this is a partial save that was done during the
// backup to preserve checksums for already backed up files.
else if (kvKeyExists(fileKv, MANIFEST_KEY_CHECKSUM_VAR))
{
memcpy(
file.checksumSha1, strPtr(varStr(kvGet(fileKv, MANIFEST_KEY_CHECKSUM_VAR))), HASH_TYPE_SHA1_SIZE_HEX + 1);
}
memcpy(file.checksumSha1, strZ(varStr(kvGet(fileKv, MANIFEST_KEY_CHECKSUM_VAR))), HASH_TYPE_SHA1_SIZE_HEX + 1);
const Variant *checksumPage = kvGetDefault(fileKv, MANIFEST_KEY_CHECKSUM_PAGE_VAR, NULL);
@ -1438,7 +1434,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
if (kvKeyExists(fileKv, MANIFEST_KEY_MODE_VAR))
{
valueFound.mode = true;
file.mode = cvtZToMode(strPtr(varStr(kvGet(fileKv, MANIFEST_KEY_MODE_VAR))));
file.mode = cvtZToMode(strZ(varStr(kvGet(fileKv, MANIFEST_KEY_MODE_VAR))));
}
if (kvKeyExists(fileKv, MANIFEST_KEY_PRIMARY_VAR))
@ -1482,7 +1478,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
if (kvKeyExists(pathKv, MANIFEST_KEY_MODE_VAR))
{
valueFound.mode = true;
path.mode = cvtZToMode(strPtr(varStr(kvGet(pathKv, MANIFEST_KEY_MODE_VAR))));
path.mode = cvtZToMode(strZ(varStr(kvGet(pathKv, MANIFEST_KEY_MODE_VAR))));
}
if (kvKeyExists(pathKv, MANIFEST_KEY_USER_VAR))
@ -1538,7 +1534,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
if (strEq(key, MANIFEST_KEY_GROUP_STR))
loadData->fileGroupDefault = manifestOwnerDefaultGet(value);
else if (strEq(key, MANIFEST_KEY_MODE_STR))
loadData->fileModeDefault = cvtZToMode(strPtr(jsonToStr(value)));
loadData->fileModeDefault = cvtZToMode(strZ(jsonToStr(value)));
else if (strEq(key, MANIFEST_KEY_PRIMARY_STR))
loadData->filePrimaryDefault = jsonToBool(value);
else if (strEq(key, MANIFEST_KEY_USER_STR))
@ -1555,7 +1551,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
if (strEq(key, MANIFEST_KEY_GROUP_STR))
loadData->pathGroupDefault = manifestOwnerDefaultGet(value);
else if (strEq(key, MANIFEST_KEY_MODE_STR))
loadData->pathModeDefault = cvtZToMode(strPtr(jsonToStr(value)));
loadData->pathModeDefault = cvtZToMode(strZ(jsonToStr(value)));
else if (strEq(key, MANIFEST_KEY_USER_STR))
loadData->pathUserDefault = manifestOwnerDefaultGet(value);
}
@ -1588,8 +1584,7 @@ manifestLoadCallback(void *callbackData, const String *section, const String *ke
.name = key,
.file = varStr(kvGetDefault(targetKv, MANIFEST_KEY_FILE_VAR, NULL)),
.path = varStr(kvGet(targetKv, MANIFEST_KEY_PATH_VAR)),
.tablespaceId =
cvtZToUInt(strPtr(varStr(kvGetDefault(targetKv, MANIFEST_KEY_TABLESPACE_ID_VAR, VARSTRDEF("0"))))),
.tablespaceId = cvtZToUInt(strZ(varStr(kvGetDefault(targetKv, MANIFEST_KEY_TABLESPACE_ID_VAR, VARSTRDEF("0"))))),
.tablespaceName = varStr(kvGetDefault(targetKv, MANIFEST_KEY_TABLESPACE_NAME_VAR, NULL)),
.type = strEq(targetType, MANIFEST_TARGET_TYPE_PATH_STR) ? manifestTargetTypePath : manifestTargetTypeLink,
};
@ -2322,24 +2317,24 @@ manifestValidate(Manifest *this, bool strict)
// All files must have a checksum
if (file->checksumSha1[0] == '\0')
strCatFmt(error, "\nmissing checksum for file '%s'", strPtr(file->name));
strCatFmt(error, "\nmissing checksum for file '%s'", strZ(file->name));
// These are strict checks to be performed only after a backup and before the final manifest save
if (strict)
{
// Zero-length files must have a specific checksum
if (file->size == 0 && !strEqZ(HASH_TYPE_SHA1_ZERO_STR, file->checksumSha1))
strCatFmt(error, "\ninvalid checksum '%s' for zero size file '%s'", file->checksumSha1, strPtr(file->name));
strCatFmt(error, "\ninvalid checksum '%s' for zero size file '%s'", file->checksumSha1, strZ(file->name));
// Non-zero size files must have non-zero repo size
if (file->sizeRepo == 0 && file->size != 0)
strCatFmt(error, "\nrepo size must be > 0 for file '%s'", strPtr(file->name));
strCatFmt(error, "\nrepo size must be > 0 for file '%s'", strZ(file->name));
}
}
// Throw exception when there are errors
if (strSize(error) > 0)
THROW_FMT(FormatError, "manifest validation failed:%s", strPtr(error));
THROW_FMT(FormatError, "manifest validation failed:%s", strZ(error));
}
MEM_CONTEXT_TEMP_END();
@ -2368,13 +2363,13 @@ manifestLinkCheck(const Manifest *this)
{
// Check that the link is not inside the base data path
if (strBeginsWith(
strNewFmt("%s/", strPtr(manifestTargetPath(this, link1))),
strNewFmt("%s/", strPtr(manifestTargetPath(this, base)))))
strNewFmt("%s/", strZ(manifestTargetPath(this, link1))),
strNewFmt("%s/", strZ(manifestTargetPath(this, base)))))
{
THROW_FMT(
LinkDestinationError,
"link '%s' destination '%s' is in PGDATA",
strPtr(manifestPathPg(link1->name)), strPtr(manifestTargetPath(this, link1)));
strZ(manifestPathPg(link1->name)), strZ(manifestTargetPath(this, link1)));
}
// Check that no link is a subpath of another link
@ -2392,14 +2387,14 @@ manifestLinkCheck(const Manifest *this)
continue;
if (strBeginsWith(
strNewFmt("%s/", strPtr(manifestTargetPath(this, link1))),
strNewFmt("%s/", strPtr(manifestTargetPath(this, link2)))))
strNewFmt("%s/", strZ(manifestTargetPath(this, link1))),
strNewFmt("%s/", strZ(manifestTargetPath(this, link2)))))
{
THROW_FMT(
LinkDestinationError,
"link '%s' (%s) destination is a subdirectory of or the same directory as link '%s' (%s)",
strPtr(manifestPathPg(link1->name)), strPtr(manifestTargetPath(this, link1)),
strPtr(manifestPathPg(link2->name)), strPtr(manifestTargetPath(this, link2)));
strZ(manifestPathPg(link1->name)), strZ(manifestTargetPath(this, link1)),
strZ(manifestPathPg(link2->name)), strZ(manifestTargetPath(this, link2)));
}
}
}
@ -2439,7 +2434,7 @@ manifestDbFind(const Manifest *this, const String *name)
const ManifestDb *result = lstFind(this->dbList, &name);
if (result == NULL)
THROW_FMT(AssertError, "unable to find '%s' in manifest db list", strPtr(name));
THROW_FMT(AssertError, "unable to find '%s' in manifest db list", strZ(name));
FUNCTION_TEST_RETURN(result);
}
@ -2502,7 +2497,7 @@ manifestFileFind(const Manifest *this, const String *name)
const ManifestFile *result = lstFind(this->fileList, &name);
if (result == NULL)
THROW_FMT(AssertError, "unable to find '%s' in manifest file list", strPtr(name));
THROW_FMT(AssertError, "unable to find '%s' in manifest file list", strZ(name));
FUNCTION_TEST_RETURN(result);
}
@ -2535,7 +2530,7 @@ manifestFileRemove(const Manifest *this, const String *name)
ASSERT(name != NULL);
if (!lstRemove(this->fileList, &name))
THROW_FMT(AssertError, "unable to remove '%s' from manifest file list", strPtr(name));
THROW_FMT(AssertError, "unable to remove '%s' from manifest file list", strZ(name));
FUNCTION_TEST_RETURN_VOID();
}
@ -2636,7 +2631,7 @@ manifestLinkFind(const Manifest *this, const String *name)
const ManifestLink *result = lstFind(this->linkList, &name);
if (result == NULL)
THROW_FMT(AssertError, "unable to find '%s' in manifest link list", strPtr(name));
THROW_FMT(AssertError, "unable to find '%s' in manifest link list", strZ(name));
FUNCTION_TEST_RETURN(result);
}
@ -2669,7 +2664,7 @@ manifestLinkRemove(const Manifest *this, const String *name)
ASSERT(name != NULL);
if (!lstRemove(this->linkList, &name))
THROW_FMT(AssertError, "unable to remove '%s' from manifest link list", strPtr(name));
THROW_FMT(AssertError, "unable to remove '%s' from manifest link list", strZ(name));
FUNCTION_TEST_RETURN_VOID();
}
@ -2741,7 +2736,7 @@ manifestPathFind(const Manifest *this, const String *name)
const ManifestPath *result = lstFind(this->pathList, &name);
if (result == NULL)
THROW_FMT(AssertError, "unable to find '%s' in manifest path list", strPtr(name));
THROW_FMT(AssertError, "unable to find '%s' in manifest path list", strZ(name));
FUNCTION_TEST_RETURN(result);
}
@ -2774,7 +2769,7 @@ manifestPathPg(const String *manifestPath)
// If something in pg_data/
if (strBeginsWith(manifestPath, STRDEF(MANIFEST_TARGET_PGDATA "/")))
{
FUNCTION_TEST_RETURN(strNew(strPtr(manifestPath) + sizeof(MANIFEST_TARGET_PGDATA)));
FUNCTION_TEST_RETURN(strNew(strZ(manifestPath) + sizeof(MANIFEST_TARGET_PGDATA)));
}
// Else not pg_data (this is faster since the length of everything else will be different than pg_data)
else if (!strEq(manifestPath, MANIFEST_TARGET_PGDATA_STR))
@ -2843,7 +2838,7 @@ manifestTargetFind(const Manifest *this, const String *name)
const ManifestTarget *result = lstFind(this->targetList, &name);
if (result == NULL)
THROW_FMT(AssertError, "unable to find '%s' in manifest target list", strPtr(name));
THROW_FMT(AssertError, "unable to find '%s' in manifest target list", strZ(name));
FUNCTION_TEST_RETURN(result);
}
@ -2898,7 +2893,7 @@ manifestTargetRemove(const Manifest *this, const String *name)
ASSERT(name != NULL);
if (!lstRemove(this->targetList, &name))
THROW_FMT(AssertError, "unable to remove '%s' from manifest target list", strPtr(name));
THROW_FMT(AssertError, "unable to remove '%s' from manifest target list", strZ(name));
FUNCTION_TEST_RETURN_VOID();
}
@ -3034,7 +3029,7 @@ manifestLoadFileCallback(void *data, unsigned int try)
if (try < 2)
{
// Construct filename based on try
const String *fileName = try == 0 ? loadData->fileName : strNewFmt("%s" INFO_COPY_EXT, strPtr(loadData->fileName));
const String *fileName = try == 0 ? loadData->fileName : strNewFmt("%s" INFO_COPY_EXT, strZ(loadData->fileName));
// Attempt to load the file
IoRead *read = storageReadIo(storageNewReadP(loadData->storage, fileName));
@ -3076,7 +3071,7 @@ manifestLoadFile(const Storage *storage, const String *fileName, CipherType ciph
MEM_CONTEXT_TEMP_BEGIN()
{
const char *fileNamePath = strPtr(storagePathP(storage, fileName));
const char *fileNamePath = strZ(storagePathP(storage, fileName));
infoLoad(
strNewFmt("unable to load backup manifest file '%s' or '%s" INFO_COPY_EXT "'", fileNamePath, fileNamePath),

34
src/postgres/client.c
View File

@ -103,7 +103,7 @@ pgClientEscape(const String *string)
// Iterate all characters in the string
for (unsigned stringIdx = 0; stringIdx < strSize(string); stringIdx++)
{
char stringChar = strPtr(string)[stringIdx];
char stringChar = strZ(string)[stringIdx];
// These characters are escaped
if (stringChar == '\'' || stringChar == '\\')
@ -131,18 +131,18 @@ pgClientOpen(PgClient *this)
MEM_CONTEXT_TEMP_BEGIN()
{
// Base connection string
String *connInfo = strNewFmt("dbname=%s port=%u", strPtr(pgClientEscape(this->database)), this->port);
String *connInfo = strNewFmt("dbname=%s port=%u", strZ(pgClientEscape(this->database)), this->port);
// Add user if specified
if (this->user != NULL)
strCatFmt(connInfo, " user=%s", strPtr(pgClientEscape(this->user)));
strCatFmt(connInfo, " user=%s", strZ(pgClientEscape(this->user)));
// Add host if specified
if (this->host != NULL)
strCatFmt(connInfo, " host=%s", strPtr(pgClientEscape(this->host)));
strCatFmt(connInfo, " host=%s", strZ(pgClientEscape(this->host)));
// Make the connection
this->connection = PQconnectdb(strPtr(connInfo));
this->connection = PQconnectdb(strZ(connInfo));
// Set a callback to shutdown the connection
memContextCallbackSet(this->memContext, pgClientFreeResource, this);
@ -151,8 +151,8 @@ pgClientOpen(PgClient *this)
if (PQstatus(this->connection) != CONNECTION_OK)
{
THROW_FMT(
DbConnectError, "unable to connect to '%s': %s", strPtr(connInfo),
strPtr(strTrim(strNew(PQerrorMessage(this->connection)))));
DbConnectError, "unable to connect to '%s': %s", strZ(connInfo),
strZ(strTrim(strNew(PQerrorMessage(this->connection)))));
}
// Set notice and warning processor
@ -181,11 +181,11 @@ pgClientQuery(PgClient *this, const String *query)
MEM_CONTEXT_TEMP_BEGIN()
{
// Send the query without waiting for results so we can timeout if needed
if (!PQsendQuery(this->connection, strPtr(query)))
if (!PQsendQuery(this->connection, strZ(query)))
{
THROW_FMT(
DbQueryError, "unable to send query '%s': %s", strPtr(query),
strPtr(strTrim(strNew(PQerrorMessage(this->connection)))));
DbQueryError, "unable to send query '%s': %s", strZ(query),
strZ(strTrim(strNew(PQerrorMessage(this->connection)))));
}
// Wait for a result
@ -210,7 +210,7 @@ pgClientQuery(PgClient *this, const String *query)
char error[256];
if (!PQcancel(cancel, error, sizeof(error)))
THROW_FMT(DbQueryError, "unable to cancel query '%s': %s", strPtr(query), strPtr(strTrim(strNew(error))));
THROW_FMT(DbQueryError, "unable to cancel query '%s': %s", strZ(query), strZ(strTrim(strNew(error))));
}
FINALLY()
{
@ -226,7 +226,7 @@ pgClientQuery(PgClient *this, const String *query)
{
// Throw timeout error if cancelled
if (busy)
THROW_FMT(DbQueryError, "query '%s' timed out after %" PRIu64 "ms", strPtr(query), this->queryTimeout);
THROW_FMT(DbQueryError, "query '%s' timed out after %" PRIu64 "ms", strZ(query), this->queryTimeout);
// If this was a command that returned no results then we are done
int resultStatus = PQresultStatus(pgResult);
@ -237,8 +237,8 @@ pgClientQuery(PgClient *this, const String *query)
if (resultStatus != PGRES_TUPLES_OK)
{
THROW_FMT(
DbQueryError, "unable to execute query '%s': %s", strPtr(query),
strPtr(strTrim(strNew(PQresultErrorMessage(pgResult)))));
DbQueryError, "unable to execute query '%s': %s", strZ(query),
strZ(strTrim(strNew(PQresultErrorMessage(pgResult)))));
}
// Fetch row and column values
@ -305,7 +305,7 @@ pgClientQuery(PgClient *this, const String *query)
{
THROW_FMT(
FormatError, "unable to parse type %u in column %d for query '%s'",
columnType[columnIdx], columnIdx, strPtr(query));
columnType[columnIdx], columnIdx, strZ(query));
}
}
}
@ -359,6 +359,6 @@ String *
pgClientToLog(const PgClient *this)
{
return strNewFmt(
"{host: %s, port: %u, database: %s, user: %s, queryTimeout %" PRIu64 "}", strPtr(strToLog(this->host)), this->port,
strPtr(strToLog(this->database)), strPtr(strToLog(this->user)), this->queryTimeout);
"{host: %s, port: %u, database: %s, user: %s, queryTimeout %" PRIu64 "}", strZ(strToLog(this->host)), this->port,
strZ(strToLog(this->database)), strZ(strToLog(this->user)), this->queryTimeout);
}

16
src/postgres/interface.c
View File

@ -589,7 +589,7 @@ pgTablespaceId(unsigned int pgVersion)
MEM_CONTEXT_PRIOR_BEGIN()
{
result = strNewFmt("PG_%s_%u", strPtr(pgVersionStr), pgCatalogVersion(pgVersion));
result = strNewFmt("PG_%s_%u", strZ(pgVersionStr), pgCatalogVersion(pgVersion));
}
MEM_CONTEXT_PRIOR_END();
}
@ -615,7 +615,7 @@ pgLsnFromStr(const String *lsn)
CHECK(strLstSize(lsnPart) == 2);
result = (cvtZToUInt64Base(strPtr(strLstGet(lsnPart, 0)), 16) << 32) + cvtZToUInt64Base(strPtr(strLstGet(lsnPart, 1)), 16);
result = (cvtZToUInt64Base(strZ(strLstGet(lsnPart, 0)), 16) << 32) + cvtZToUInt64Base(strZ(strLstGet(lsnPart, 1)), 16);
}
MEM_CONTEXT_TEMP_END();
@ -659,8 +659,8 @@ pgLsnFromWalSegment(const String *walSegment, unsigned int walSegmentSize)
ASSERT(walSegmentSize > 0);
FUNCTION_TEST_RETURN(
(cvtZToUInt64Base(strPtr(strSubN(walSegment, 8, 8)), 16) << 32) +
(cvtZToUInt64Base(strPtr(strSubN(walSegment, 16, 8)), 16) * walSegmentSize));
(cvtZToUInt64Base(strZ(strSubN(walSegment, 8, 8)), 16) << 32) +
(cvtZToUInt64Base(strZ(strSubN(walSegment, 16, 8)), 16) * walSegmentSize));
}
/**********************************************************************************************************************************/
@ -837,7 +837,7 @@ pgVersionFromStr(const String *version)
{
// If format is not number.number (9.4) or number only (10) then error
if (!regExpMatchOne(STRDEF("^[0-9]+[.]*[0-9]+$"), version))
THROW_FMT(AssertError, "version %s format is invalid", strPtr(version));
THROW_FMT(AssertError, "version %s format is invalid", strZ(version));
// If there is a dot set the major and minor versions, else just the major
int idxStart = strChr(version, '.');
@ -846,11 +846,11 @@ pgVersionFromStr(const String *version)
if (idxStart != -1)
{
major = cvtZToUInt(strPtr(strSubN(version, 0, (size_t)idxStart)));
minor = cvtZToUInt(strPtr(strSub(version, (size_t)idxStart + 1)));
major = cvtZToUInt(strZ(strSubN(version, 0, (size_t)idxStart)));
minor = cvtZToUInt(strZ(strSub(version, (size_t)idxStart + 1)));
}
else
major = cvtZToUInt(strPtr(version));
major = cvtZToUInt(strZ(version));
// No check to see if valid/supported PG version is on purpose
result = major * 10000 + minor * 100;

22
src/protocol/client.c
View File

@ -83,7 +83,7 @@ protocolClientNew(const String *name, const String *service, IoRead *read, IoWri
{
.memContext = memContextCurrent(),
.name = strDup(name),
.errorPrefix = strNewFmt("raised from %s", strPtr(name)),
.errorPrefix = strNewFmt("raised from %s", strZ(name)),
.read = read,
.write = write,
.keepAliveTime = timeMSec(),
@ -110,16 +110,16 @@ protocolClientNew(const String *name, const String *service, IoRead *read, IoWri
const Variant *actualValue = kvGet(greetingKv, VARSTR(expectedKey));
if (actualValue == NULL)
THROW_FMT(ProtocolError, "unable to find greeting key '%s'", strPtr(expectedKey));
THROW_FMT(ProtocolError, "unable to find greeting key '%s'", strZ(expectedKey));
if (varType(actualValue) != varTypeString)
THROW_FMT(ProtocolError, "greeting key '%s' must be string type", strPtr(expectedKey));
THROW_FMT(ProtocolError, "greeting key '%s' must be string type", strZ(expectedKey));
if (!strEq(varStr(actualValue), expectedValue))
{
THROW_FMT(
ProtocolError, "expected value '%s' for greeting key '%s' but got '%s'", strPtr(expectedValue),
strPtr(expectedKey), strPtr(varStr(actualValue)));
ProtocolError, "expected value '%s' for greeting key '%s' but got '%s'", strZ(expectedValue),
strZ(expectedKey), strZ(varStr(actualValue)));
}
}
}
@ -161,7 +161,7 @@ protocolClientProcessError(ProtocolClient *this, KeyValue *errorKv)
// Required part of the message
String *throwMessage = strNewFmt(
"%s: %s", strPtr(this->errorPrefix), message == NULL ? "no details available" : strPtr(message));
"%s: %s", strZ(this->errorPrefix), message == NULL ? "no details available" : strZ(message));
// Add stack trace if the error is an assertion or debug-level logging is enabled
if (type == &AssertError || logAny(logLevelDebug))
@ -172,7 +172,7 @@ protocolClientProcessError(ProtocolClient *this, KeyValue *errorKv)
strCat(throwMessage, stack == NULL ? STRDEF("no stack trace available") : stack);
}
THROWP(type, strPtr(throwMessage));
THROWP(type, strZ(throwMessage));
}
}
MEM_CONTEXT_TEMP_END();
@ -300,7 +300,7 @@ protocolClientReadLine(ProtocolClient *this)
{
THROW(FormatError, "unexpected empty line");
}
else if (strPtr(result)[0] == '{')
else if (strZ(result)[0] == '{')
{
KeyValue *responseKv = varKv(jsonToVar(result));
@ -310,8 +310,8 @@ protocolClientReadLine(ProtocolClient *this)
// If not an error then there is probably a protocol bug
THROW(FormatError, "expected error but got output");
}
else if (strPtr(result)[0] != '.')
THROW_FMT(FormatError, "invalid prefix in '%s'", strPtr(result));
else if (strZ(result)[0] != '.')
THROW_FMT(FormatError, "invalid prefix in '%s'", strZ(result));
MEM_CONTEXT_PRIOR_BEGIN()
{
@ -354,5 +354,5 @@ protocolClientIoWrite(const ProtocolClient *this)
String *
protocolClientToLog(const ProtocolClient *this)
{
return strNewFmt("{name: %s}", strPtr(this->name));
return strNewFmt("{name: %s}", strZ(this->name));
}

2
src/protocol/command.c
View File

@ -116,5 +116,5 @@ protocolCommandJson(const ProtocolCommand *this)
String *
protocolCommandToLog(const ProtocolCommand *this)
{
return strNewFmt("{command: %s}", strPtr(this->command));
return strNewFmt("{command: %s}", strZ(this->command));
}

10
src/protocol/helper.c
View File

@ -315,8 +315,8 @@ protocolRemoteParam(ProtocolStorageType protocolStorageType, unsigned int protoc
strLstAdd(
result,
strNewFmt(
"%s@%s", strPtr(cfgOptionStr(isRepo ? cfgOptRepoHostUser : cfgOptPgHostUser + hostIdx)),
strPtr(cfgOptionStr(isRepo ? cfgOptRepoHost : cfgOptPgHost + hostIdx))));
"%s@%s", strZ(cfgOptionStr(isRepo ? cfgOptRepoHostUser : cfgOptPgHostUser + hostIdx)),
strZ(cfgOptionStr(isRepo ? cfgOptRepoHost : cfgOptPgHost + hostIdx))));
// Option replacements
KeyValue *optionReplace = kvNew();
@ -509,13 +509,13 @@ protocolRemoteGet(ProtocolStorageType protocolStorageType, unsigned int hostId)
// Execute the protocol command
protocolHelperClient->exec = execNew(
cfgOptionStr(cfgOptCmdSsh), protocolRemoteParam(protocolStorageType, protocolId, hostId - 1),
strNewFmt(PROTOCOL_SERVICE_REMOTE "-%u process on '%s'", protocolId, strPtr(cfgOptionStr(optHost))),
strNewFmt(PROTOCOL_SERVICE_REMOTE "-%u process on '%s'", protocolId, strZ(cfgOptionStr(optHost))),
(TimeMSec)(cfgOptionDbl(cfgOptProtocolTimeout) * 1000));
execOpen(protocolHelperClient->exec);
// Create protocol object
protocolHelperClient->client = protocolClientNew(
strNewFmt(PROTOCOL_SERVICE_REMOTE "-%u protocol on '%s'", protocolId, strPtr(cfgOptionStr(optHost))),
strNewFmt(PROTOCOL_SERVICE_REMOTE "-%u protocol on '%s'", protocolId, strZ(cfgOptionStr(optHost))),
PROTOCOL_SERVICE_REMOTE_STR, execIoRead(protocolHelperClient->exec), execIoWrite(protocolHelperClient->exec));
// Get cipher options from the remote if none are locally configured
@ -594,7 +594,7 @@ protocolStorageTypeEnum(const String *type)
else if (strEq(type, PROTOCOL_REMOTE_TYPE_REPO_STR))
FUNCTION_TEST_RETURN(protocolStorageTypeRepo);
THROW_FMT(AssertError, "invalid protocol storage type '%s'", strPtr(type));
THROW_FMT(AssertError, "invalid protocol storage type '%s'", strZ(type));
}
const String *

4
src/protocol/parallelJob.c
View File

@ -267,6 +267,6 @@ protocolParallelJobToLog(const ProtocolParallelJob *this)
{
return strNewFmt(
"{state: %s, key: %s, command: %s, code: %d, message: %s, result: %s}", protocolParallelJobToConstZ(this->state),
strPtr(varToLog(this->key)), strPtr(protocolCommandToLog(this->command)), this->code, strPtr(strToLog(this->message)),
strPtr(varToLog(this->result)));
strZ(varToLog(this->key)), strZ(protocolCommandToLog(this->command)), this->code, strZ(strToLog(this->message)),
strZ(varToLog(this->result)));
}

4
src/protocol/server.c
View File

@ -217,7 +217,7 @@ protocolServerProcess(ProtocolServer *this, const VariantList *retryInterval)
else if (strEq(command, PROTOCOL_COMMAND_EXIT_STR))
exit = true;
else
THROW_FMT(ProtocolError, "invalid command '%s'", strPtr(command));
THROW_FMT(ProtocolError, "invalid command '%s'", strZ(command));
}
// Send keep alives to remotes. When a local process is doing work that does not involve the remote it is important
@ -313,5 +313,5 @@ protocolServerIoWrite(const ProtocolServer *this)
String *
protocolServerToLog(const ProtocolServer *this)
{
return strNewFmt("{name: %s}", strPtr(this->name));
return strNewFmt("{name: %s}", strZ(this->name));
}

2
src/storage/azure/read.c
View File

@ -69,7 +69,7 @@ storageReadAzureOpen(THIS_VOID)
}
// Else error unless ignore missing
else if (!this->interface.ignoreMissing)
THROW_FMT(FileMissingError, "unable to open '%s': No such file or directory", strPtr(this->interface.name));
THROW_FMT(FileMissingError, "unable to open '%s': No such file or directory", strZ(this->interface.name));
FUNCTION_LOG_RETURN(BOOL, result);
}

31
src/storage/azure/storage.c
View File

@ -132,7 +132,7 @@ storageAzureAuth(
if (!strBeginsWithZ(headerKey, "x-ms-"))
continue;
strCatFmt(headerCanonical, "%s:%s\n", strPtr(headerKey), strPtr(httpHeaderGet(httpHeader, headerKey)));
strCatFmt(headerCanonical, "%s:%s\n", strZ(headerKey), strZ(httpHeaderGet(httpHeader, headerKey)));
}
// Generate canonical query
@ -147,7 +147,7 @@ storageAzureAuth(
{
const String *queryKey = strLstGet(queryKeyList, queryKeyIdx);
strCatFmt(queryCanonical, "\n%s:%s", strPtr(queryKey), strPtr(httpQueryGet(query, queryKey)));
strCatFmt(queryCanonical, "\n%s:%s", strZ(queryKey), strZ(httpQueryGet(query, queryKey)));
}
}
@ -171,12 +171,12 @@ storageAzureAuth(
"%s" // Canonicalized headers
"/%s%s" // Canonicalized account/uri
"%s", // Canonicalized query
strPtr(verb), strEq(contentLength, ZERO_STR) ? "" : strPtr(contentLength), contentMd5 == NULL ? "" : strPtr(contentMd5),
strPtr(dateTime), strPtr(headerCanonical), strPtr(this->account), strPtr(uri), strPtr(queryCanonical));
strZ(verb), strEq(contentLength, ZERO_STR) ? "" : strZ(contentLength), contentMd5 == NULL ? "" : strZ(contentMd5),
strZ(dateTime), strZ(headerCanonical), strZ(this->account), strZ(uri), strZ(queryCanonical));
// Generate authorization header
Buffer *keyBin = bufNew(decodeToBinSize(encodeBase64, strPtr(this->sharedKey)));
decodeToBin(encodeBase64, strPtr(this->sharedKey), bufPtr(keyBin));
Buffer *keyBin = bufNew(decodeToBinSize(encodeBase64, strZ(this->sharedKey)));
decodeToBin(encodeBase64, strZ(this->sharedKey), bufPtr(keyBin));
bufUsedSet(keyBin, bufSize(keyBin));
char authHmacBase64[45];
@ -185,7 +185,7 @@ storageAzureAuth(
HASH_TYPE_SHA256_SIZE, authHmacBase64);
httpHeaderPut(
httpHeader, HTTP_HEADER_AUTHORIZATION_STR, strNewFmt("SharedKey %s:%s", strPtr(this->account), authHmacBase64));
httpHeader, HTTP_HEADER_AUTHORIZATION_STR, strNewFmt("SharedKey %s:%s", strZ(this->account), authHmacBase64));
}
// SAS authentication
else
@ -219,7 +219,7 @@ storageAzureRequestAsync(StorageAzure *this, const String *verb, StorageAzureReq
MEM_CONTEXT_TEMP_BEGIN()
{
// Prepend uri prefix
param.uri = param.uri == NULL ? this->uriPrefix : strNewFmt("%s%s", strPtr(this->uriPrefix), strPtr(param.uri));
param.uri = param.uri == NULL ? this->uriPrefix : strNewFmt("%s%s", strZ(this->uriPrefix), strZ(param.uri));
// Create header list and add content length
HttpHeader *requestHeader = param.header == NULL ?
@ -343,7 +343,7 @@ storageAzureListInternal(
if (strSize(path) == 1)
basePrefix = EMPTY_STR;
else
basePrefix = strNewFmt("%s/", strPtr(strSub(path, 1)));
basePrefix = strNewFmt("%s/", strZ(strSub(path, 1)));
// Get the expression prefix when possible to limit initial results
const String *expressionPrefix = regExpPrefix(expression);
@ -358,7 +358,7 @@ storageAzureListInternal(
if (strEmpty(basePrefix))
queryPrefix = expressionPrefix;
else
queryPrefix = strNewFmt("%s%s", strPtr(basePrefix), strPtr(expressionPrefix));
queryPrefix = strNewFmt("%s%s", strZ(basePrefix), strZ(expressionPrefix));
}
// Loop as long as a continuation token returned
@ -469,7 +469,7 @@ storageAzureInfo(THIS_VOID, const String *file, StorageInfoLevel level, StorageI
if (result.level >= storageInfoLevelBasic && result.exists)
{
result.type = storageTypeFile;
result.size = cvtZToUInt64(strPtr(httpHeaderGet(httpResponseHeader(httpResponse), HTTP_HEADER_CONTENT_LENGTH_STR)));
result.size = cvtZToUInt64(strZ(httpHeaderGet(httpResponseHeader(httpResponse), HTTP_HEADER_CONTENT_LENGTH_STR)));
result.timeModified = httpDateToTime(httpHeaderGet(httpResponseHeader(httpResponse), HTTP_HEADER_LAST_MODIFIED_STR));
}
@ -517,7 +517,7 @@ storageAzureInfoListCallback(StorageAzure *this, void *callbackData, const Strin
{
ASSERT(xml != NULL);
info.size = cvtZToUInt64(strPtr(xmlNodeContent(xmlNodeChild(xml, AZURE_XML_TAG_CONTENT_LENGTH_STR, true))));
info.size = cvtZToUInt64(strZ(xmlNodeContent(xmlNodeChild(xml, AZURE_XML_TAG_CONTENT_LENGTH_STR, true))));
info.timeModified = httpDateToTime(xmlNodeContent(xmlNodeChild(xml, AZURE_XML_TAG_LAST_MODIFIED_STR, true)));
}
}
@ -623,7 +623,7 @@ storageAzurePathRemoveCallback(StorageAzure *this, void *callbackData, const Str
if (type == storageTypeFile)
{
StorageAzurePathRemoveData *data = (StorageAzurePathRemoveData *)callbackData;
storageInterfaceRemoveP(this, strNewFmt("%s/%s", strEq(data->path, FSLASH_STR) ? "" : strPtr(data->path), strPtr(name)));
storageInterfaceRemoveP(this, strNewFmt("%s/%s", strEq(data->path, FSLASH_STR) ? "" : strZ(data->path), strZ(name)));
}
FUNCTION_TEST_RETURN_VOID();
@ -728,9 +728,8 @@ storageAzureNew(
.container = strDup(container),
.account = strDup(account),
.blockSize = blockSize,
.host = host == NULL ? strNewFmt("%s." AZURE_BLOB_HOST, strPtr(account)) : host,
.uriPrefix = host == NULL ?
strNewFmt("/%s", strPtr(container)) : strNewFmt("/%s/%s", strPtr(account), strPtr(container)),
.host = host == NULL ? strNewFmt("%s." AZURE_BLOB_HOST, strZ(account)) : host,
.uriPrefix = host == NULL ? strNewFmt("/%s", strZ(container)) : strNewFmt("/%s/%s", strZ(account), strZ(container)),
};
// Store shared key or parse sas query

24
src/storage/helper.c
View File

@ -295,7 +295,7 @@ storageRepoPathExpression(const String *expression, const String *path)
{
// Construct the base path
if (storageHelper.stanza != NULL)
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s", strPtr(storageHelper.stanza));
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s", strZ(storageHelper.stanza));
else
result = strNew(STORAGE_PATH_ARCHIVE);
@ -306,25 +306,25 @@ storageRepoPathExpression(const String *expression, const String *path)
String *file = strLstSize(pathSplit) == 2 ? strLstGet(pathSplit, 1) : NULL;
if (file != NULL && regExpMatch(storageHelper.walRegExp, file))
strCatFmt(result, "/%s/%s/%s", strPtr(strLstGet(pathSplit, 0)), strPtr(strSubN(file, 0, 16)), strPtr(file));
strCatFmt(result, "/%s/%s/%s", strZ(strLstGet(pathSplit, 0)), strZ(strSubN(file, 0, 16)), strZ(file));
else
strCatFmt(result, "/%s", strPtr(path));
strCatFmt(result, "/%s", strZ(path));
}
}
else if (strEq(expression, STORAGE_REPO_BACKUP_STR))
{
// Construct the base path
if (storageHelper.stanza != NULL)
result = strNewFmt(STORAGE_PATH_BACKUP "/%s", strPtr(storageHelper.stanza));
result = strNewFmt(STORAGE_PATH_BACKUP "/%s", strZ(storageHelper.stanza));
else
result = strNew(STORAGE_PATH_BACKUP);
// Append subpath if provided
if (path != NULL)
strCatFmt(result, "/%s", strPtr(path));
strCatFmt(result, "/%s", strZ(path));
}
else
THROW_FMT(AssertError, "invalid expression '%s'", strPtr(expression));
THROW_FMT(AssertError, "invalid expression '%s'", strZ(expression));
FUNCTION_TEST_RETURN(result);
}
@ -397,7 +397,7 @@ storageRepoGet(const String *type, bool write)
cfgOptionBool(cfgOptRepoS3VerifyTls), cfgOptionStrNull(cfgOptRepoS3CaFile), cfgOptionStrNull(cfgOptRepoS3CaPath));
}
else
THROW_FMT(AssertError, "invalid storage type '%s'", strPtr(type));
THROW_FMT(AssertError, "invalid storage type '%s'", strZ(type));
FUNCTION_TEST_RETURN(result);
}
@ -468,19 +468,19 @@ storageSpoolPathExpression(const String *expression, const String *path)
if (strEqZ(expression, STORAGE_SPOOL_ARCHIVE_IN))
{
if (path == NULL)
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/in", strPtr(storageHelper.stanza));
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/in", strZ(storageHelper.stanza));
else
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/in/%s", strPtr(storageHelper.stanza), strPtr(path));
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/in/%s", strZ(storageHelper.stanza), strZ(path));
}
else if (strEqZ(expression, STORAGE_SPOOL_ARCHIVE_OUT))
{
if (path == NULL)
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/out", strPtr(storageHelper.stanza));
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/out", strZ(storageHelper.stanza));
else
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/out/%s", strPtr(storageHelper.stanza), strPtr(path));
result = strNewFmt(STORAGE_PATH_ARCHIVE "/%s/out/%s", strZ(storageHelper.stanza), strZ(path));
}
else
THROW_FMT(AssertError, "invalid expression '%s'", strPtr(expression));
THROW_FMT(AssertError, "invalid expression '%s'", strZ(expression));
FUNCTION_TEST_RETURN(result);
}

10
src/storage/posix/read.c
View File

@ -47,7 +47,7 @@ Close the file handle
OBJECT_DEFINE_FREE_RESOURCE_BEGIN(STORAGE_READ_POSIX, LOG, logLevelTrace)
{
if (this->handle != -1)
THROW_ON_SYS_ERROR_FMT(close(this->handle) == -1, FileCloseError, STORAGE_ERROR_READ_CLOSE, strPtr(this->interface.name));
THROW_ON_SYS_ERROR_FMT(close(this->handle) == -1, FileCloseError, STORAGE_ERROR_READ_CLOSE, strZ(this->interface.name));
}
OBJECT_DEFINE_FREE_RESOURCE_END(LOG);
@ -69,7 +69,7 @@ storageReadPosixOpen(THIS_VOID)
bool result = false;
// Open the file
this->handle = open(strPtr(this->interface.name), O_RDONLY, 0);
this->handle = open(strZ(this->interface.name), O_RDONLY, 0);
// Handle errors
if (this->handle == -1)
@ -77,10 +77,10 @@ storageReadPosixOpen(THIS_VOID)
if (errno == ENOENT) // {vm_covered}
{
if (!this->interface.ignoreMissing)
THROW_FMT(FileMissingError, STORAGE_ERROR_READ_MISSING, strPtr(this->interface.name));
THROW_FMT(FileMissingError, STORAGE_ERROR_READ_MISSING, strZ(this->interface.name));
}
else
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_READ_OPEN, strPtr(this->interface.name)); // {vm_covered}
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_READ_OPEN, strZ(this->interface.name)); // {vm_covered}
}
// On success set free callback to ensure file handle is freed
if (this->handle != -1)
@ -125,7 +125,7 @@ storageReadPosix(THIS_VOID, Buffer *buffer, bool block)
// Error occurred during read
if (actualBytes == -1)
THROW_SYS_ERROR_FMT(FileReadError, "unable to read '%s'", strPtr(this->interface.name));
THROW_SYS_ERROR_FMT(FileReadError, "unable to read '%s'", strZ(this->interface.name));
// Update amount of buffer used
bufUsedInc(buffer, (size_t)actualBytes);

50
src/storage/posix/storage.c
View File

@ -63,10 +63,10 @@ storagePosixInfo(THIS_VOID, const String *file, StorageInfoLevel level, StorageI
// Stat the file to check if it exists
struct stat statFile;
if ((param.followLink ? stat(strPtr(file), &statFile) : lstat(strPtr(file), &statFile)) == -1)
if ((param.followLink ? stat(strZ(file), &statFile) : lstat(strZ(file), &statFile)) == -1)
{
if (errno != ENOENT) // {vm_covered}
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_INFO, strPtr(file)); // {vm_covered}
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_INFO, strZ(file)); // {vm_covered}
}
// On success the file exists
else
@ -106,8 +106,8 @@ storagePosixInfo(THIS_VOID, const String *file, StorageInfoLevel level, StorageI
ssize_t linkDestinationSize = 0;
THROW_ON_SYS_ERROR_FMT(
(linkDestinationSize = readlink(strPtr(file), linkDestination, sizeof(linkDestination) - 1)) == -1,
FileReadError, "unable to get destination for link '%s'", strPtr(file));
(linkDestinationSize = readlink(strZ(file), linkDestination, sizeof(linkDestination) - 1)) == -1,
FileReadError, "unable to get destination for link '%s'", strZ(file));
result.linkDestination = strNewN(linkDestination, (size_t)linkDestinationSize);
}
@ -141,7 +141,7 @@ storagePosixInfoListEntry(
ASSERT(callback != NULL);
StorageInfo storageInfo = storageInterfaceInfoP(
this, strEq(name, DOT_STR) ? strDup(path) : strNewFmt("%s/%s", strPtr(path), strPtr(name)), level);
this, strEq(name, DOT_STR) ? strDup(path) : strNewFmt("%s/%s", strZ(path), strZ(name)), level);
if (storageInfo.exists)
{
@ -175,13 +175,13 @@ storagePosixInfoList(
bool result = false;
// Open the directory for read
DIR *dir = opendir(strPtr(path));
DIR *dir = opendir(strZ(path));
// If the directory could not be opened process errors and report missing directories
if (dir == NULL)
{
if (errno != ENOENT) // {vm_covered}
THROW_SYS_ERROR_FMT(PathOpenError, STORAGE_ERROR_LIST_INFO, strPtr(path)); // {vm_covered}
THROW_SYS_ERROR_FMT(PathOpenError, STORAGE_ERROR_LIST_INFO, strZ(path)); // {vm_covered}
}
else
{
@ -258,19 +258,19 @@ storagePosixMove(THIS_VOID, StorageRead *source, StorageWrite *destination, Stor
const String *destinationPath = strPath(destinationFile);
// Attempt to move the file
if (rename(strPtr(sourceFile), strPtr(destinationFile)) == -1)
if (rename(strZ(sourceFile), strZ(destinationFile)) == -1)
{
// Determine which file/path is missing
if (errno == ENOENT)
{
// Check if the source is missing. Rename does not follow links so there is no need to set followLink.
if (!storageInterfaceInfoP(this, sourceFile, storageInfoLevelExists).exists)
THROW_SYS_ERROR_FMT(FileMissingError, "unable to move missing source '%s'", strPtr(sourceFile));
THROW_SYS_ERROR_FMT(FileMissingError, "unable to move missing source '%s'", strZ(sourceFile));
if (!storageWriteCreatePath(destination))
{
THROW_SYS_ERROR_FMT(
PathMissingError, "unable to move '%s' to missing path '%s'", strPtr(sourceFile), strPtr(destinationPath));
PathMissingError, "unable to move '%s' to missing path '%s'", strZ(sourceFile), strZ(destinationPath));
}
storageInterfacePathCreateP(this, destinationPath, false, false, storageWriteModePath(destination));
@ -284,7 +284,7 @@ storagePosixMove(THIS_VOID, StorageRead *source, StorageWrite *destination, Stor
else
{
THROW_SYS_ERROR_FMT( // {vm_covered}
FileMoveError, "unable to move '%s' to '%s'", strPtr(sourceFile), strPtr(destinationFile)); // {vm_covered}
FileMoveError, "unable to move '%s' to '%s'", strZ(sourceFile), strZ(destinationFile)); // {vm_covered}
}
}
// Sync paths on success
@ -374,7 +374,7 @@ storagePosixPathCreate(
ASSERT(path != NULL);
// Attempt to create the directory
if (mkdir(strPtr(path), mode) == -1)
if (mkdir(strZ(path), mode) == -1)
{
// If the parent path does not exist then create it if allowed
if (errno == ENOENT && !noParentCreate)
@ -384,7 +384,7 @@ storagePosixPathCreate(
}
// Ignore path exists if allowed
else if (errno != EEXIST || errorOnExists)
THROW_SYS_ERROR_FMT(PathCreateError, "unable to create path '%s'", strPtr(path));
THROW_SYS_ERROR_FMT(PathCreateError, "unable to create path '%s'", strZ(path));
}
FUNCTION_LOG_RETURN_VOID();
@ -411,10 +411,10 @@ storagePosixPathRemoveCallback(void *callbackData, const StorageInfo *info)
if (!strEqZ(info->name, "."))
{
StoragePosixPathRemoveData *data = callbackData;
String *file = strNewFmt("%s/%s", strPtr(data->path), strPtr(info->name));
String *file = strNewFmt("%s/%s", strZ(data->path), strZ(info->name));
// Rather than stat the file to discover what type it is, just try to unlink it and see what happens
if (unlink(strPtr(file)) == -1) // {vm_covered}
if (unlink(strZ(file)) == -1) // {vm_covered}
{
// These errors indicate that the entry is actually a path so we'll try to delete it that way
if (errno == EPERM || errno == EISDIR) // {uncovered_branch - no EPERM on tested systems}
@ -423,7 +423,7 @@ storagePosixPathRemoveCallback(void *callbackData, const StorageInfo *info)
}
// Else error
else
THROW_SYS_ERROR_FMT(PathRemoveError, STORAGE_ERROR_PATH_REMOVE_FILE, strPtr(file)); // {vm_covered}
THROW_SYS_ERROR_FMT(PathRemoveError, STORAGE_ERROR_PATH_REMOVE_FILE, strZ(file)); // {vm_covered}
}
}
@ -463,10 +463,10 @@ storagePosixPathRemove(THIS_VOID, const String *path, bool recurse, StorageInter
}
// Delete the path
if (rmdir(strPtr(path)) == -1)
if (rmdir(strZ(path)) == -1)
{
if (errno != ENOENT) // {vm_covered}
THROW_SYS_ERROR_FMT(PathRemoveError, STORAGE_ERROR_PATH_REMOVE, strPtr(path)); // {vm_covered}
THROW_SYS_ERROR_FMT(PathRemoveError, STORAGE_ERROR_PATH_REMOVE, strZ(path)); // {vm_covered}
// Path does not exist
result = false;
@ -493,15 +493,15 @@ storagePosixPathSync(THIS_VOID, const String *path, StorageInterfacePathSyncPara
ASSERT(path != NULL);
// Open directory and handle errors
int handle = open(strPtr(path), O_RDONLY, 0);
int handle = open(strZ(path), O_RDONLY, 0);
// Handle errors
if (handle == -1)
{
if (errno == ENOENT) // {vm_covered}
THROW_FMT(PathMissingError, STORAGE_ERROR_PATH_SYNC_MISSING, strPtr(path));
THROW_FMT(PathMissingError, STORAGE_ERROR_PATH_SYNC_MISSING, strZ(path));
else
THROW_SYS_ERROR_FMT(PathOpenError, STORAGE_ERROR_PATH_SYNC_OPEN, strPtr(path)); // {vm_covered}
THROW_SYS_ERROR_FMT(PathOpenError, STORAGE_ERROR_PATH_SYNC_OPEN, strZ(path)); // {vm_covered}
}
else
{
@ -513,10 +513,10 @@ storagePosixPathSync(THIS_VOID, const String *path, StorageInterfacePathSyncPara
// Close the handle to free resources but don't check for failure
close(handle);
THROW_SYS_ERROR_CODE_FMT(errNo, PathSyncError, STORAGE_ERROR_PATH_SYNC, strPtr(path));
THROW_SYS_ERROR_CODE_FMT(errNo, PathSyncError, STORAGE_ERROR_PATH_SYNC, strZ(path));
}
THROW_ON_SYS_ERROR_FMT(close(handle) == -1, PathCloseError, STORAGE_ERROR_PATH_SYNC_CLOSE, strPtr(path));
THROW_ON_SYS_ERROR_FMT(close(handle) == -1, PathCloseError, STORAGE_ERROR_PATH_SYNC_CLOSE, strZ(path));
}
FUNCTION_LOG_RETURN_VOID();
@ -538,10 +538,10 @@ storagePosixRemove(THIS_VOID, const String *file, StorageInterfaceRemoveParam pa
ASSERT(file != NULL);
// Attempt to unlink the file
if (unlink(strPtr(file)) == -1)
if (unlink(strZ(file)) == -1)
{
if (param.errorOnMissing || errno != ENOENT) // {vm_covered}
THROW_SYS_ERROR_FMT(FileRemoveError, "unable to remove '%s'", strPtr(file)); // {vm_covered}
THROW_SYS_ERROR_FMT(FileRemoveError, "unable to remove '%s'", strZ(file)); // {vm_covered}
}
FUNCTION_LOG_RETURN_VOID();

33
src/storage/posix/write.c
View File

@ -56,7 +56,7 @@ Close file handle
***********************************************************************************************************************************/
OBJECT_DEFINE_FREE_RESOURCE_BEGIN(STORAGE_WRITE_POSIX, LOG, logLevelTrace)
{
THROW_ON_SYS_ERROR_FMT(close(this->handle) == -1, FileCloseError, STORAGE_ERROR_WRITE_CLOSE, strPtr(this->nameTmp));
THROW_ON_SYS_ERROR_FMT(close(this->handle) == -1, FileCloseError, STORAGE_ERROR_WRITE_CLOSE, strZ(this->nameTmp));
}
OBJECT_DEFINE_FREE_RESOURCE_END(LOG);
@ -76,7 +76,7 @@ storageWritePosixOpen(THIS_VOID)
ASSERT(this->handle == -1);
// Open the file
this->handle = open(strPtr(this->nameTmp), FILE_OPEN_FLAGS, this->interface.modeFile);
this->handle = open(strZ(this->nameTmp), FILE_OPEN_FLAGS, this->interface.modeFile);
// Attempt to create the path if it is missing
if (this->handle == -1 && errno == ENOENT && this->interface.createPath) // {vm_covered}
@ -85,16 +85,16 @@ storageWritePosixOpen(THIS_VOID)
storageInterfacePathCreateP(this->storage, this->path, false, false, this->interface.modePath);
// Open file again
this->handle = open(strPtr(this->nameTmp), FILE_OPEN_FLAGS, this->interface.modeFile);
this->handle = open(strZ(this->nameTmp), FILE_OPEN_FLAGS, this->interface.modeFile);
}
// Handle errors
if (this->handle == -1)
{
if (errno == ENOENT) // {vm_covered}
THROW_FMT(FileMissingError, STORAGE_ERROR_WRITE_MISSING, strPtr(this->interface.name));
THROW_FMT(FileMissingError, STORAGE_ERROR_WRITE_MISSING, strZ(this->interface.name));
else
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_WRITE_OPEN, strPtr(this->interface.name)); // {vm_covered}
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_WRITE_OPEN, strZ(this->interface.name)); // {vm_covered}
}
// Set free callback to ensure file handle is freed
@ -114,8 +114,8 @@ storageWritePosixOpen(THIS_VOID)
updateGroupId = (gid_t)-1;
THROW_ON_SYS_ERROR_FMT(
chown(strPtr(this->nameTmp), updateUserId, updateGroupId) == -1,
FileOwnerError, "unable to set ownership for '%s'", strPtr(this->nameTmp));
chown(strZ(this->nameTmp), updateUserId, updateGroupId) == -1, FileOwnerError, "unable to set ownership for '%s'",
strZ(this->nameTmp));
}
FUNCTION_LOG_RETURN_VOID();
@ -140,7 +140,7 @@ storageWritePosix(THIS_VOID, const Buffer *buffer)
// Write the data
if (write(this->handle, bufPtrConst(buffer), bufUsed(buffer)) != (ssize_t)bufUsed(buffer))
THROW_SYS_ERROR_FMT(FileWriteError, "unable to write '%s'", strPtr(this->nameTmp));
THROW_SYS_ERROR_FMT(FileWriteError, "unable to write '%s'", strZ(this->nameTmp));
FUNCTION_LOG_RETURN_VOID();
}
@ -164,11 +164,11 @@ storageWritePosixClose(THIS_VOID)
{
// Sync the file
if (this->interface.syncFile)
THROW_ON_SYS_ERROR_FMT(fsync(this->handle) == -1, FileSyncError, STORAGE_ERROR_WRITE_SYNC, strPtr(this->nameTmp));
THROW_ON_SYS_ERROR_FMT(fsync(this->handle) == -1, FileSyncError, STORAGE_ERROR_WRITE_SYNC, strZ(this->nameTmp));
// Close the file
memContextCallbackClear(this->memContext);
THROW_ON_SYS_ERROR_FMT(close(this->handle) == -1, FileCloseError, STORAGE_ERROR_WRITE_CLOSE, strPtr(this->nameTmp));
THROW_ON_SYS_ERROR_FMT(close(this->handle) == -1, FileCloseError, STORAGE_ERROR_WRITE_CLOSE, strZ(this->nameTmp));
this->handle = -1;
// Update modified time
@ -176,19 +176,16 @@ storageWritePosixClose(THIS_VOID)
{
THROW_ON_SYS_ERROR_FMT(
utime(
strPtr(this->nameTmp),
strZ(this->nameTmp),
&((struct utimbuf){.actime = this->interface.timeModified, .modtime = this->interface.timeModified})) == -1,
FileInfoError, "unable to set time for '%s'", strPtr(this->nameTmp));
FileInfoError, "unable to set time for '%s'", strZ(this->nameTmp));
}
// Rename from temp file
if (this->interface.atomic)
{
if (rename(strPtr(this->nameTmp), strPtr(this->interface.name)) == -1)
{
THROW_SYS_ERROR_FMT(
FileMoveError, "unable to move '%s' to '%s'", strPtr(this->nameTmp), strPtr(this->interface.name));
}
if (rename(strZ(this->nameTmp), strZ(this->interface.name)) == -1)
THROW_SYS_ERROR_FMT(FileMoveError, "unable to move '%s' to '%s'", strZ(this->nameTmp), strZ(this->interface.name));
}
// Sync the path
@ -279,7 +276,7 @@ storageWritePosixNew(
};
// Create temp file name
driver->nameTmp = atomic ? strNewFmt("%s." STORAGE_FILE_TEMP_EXT, strPtr(name)) : driver->interface.name;
driver->nameTmp = atomic ? strNewFmt("%s." STORAGE_FILE_TEMP_EXT, strZ(name)) : driver->interface.name;
this = storageWriteNew(driver, &driver->interface);
}

2
src/storage/read.c
View File

@ -128,6 +128,6 @@ String *
storageReadToLog(const StorageRead *this)
{
return strNewFmt(
"{type: %s, name: %s, ignoreMissing: %s}", strPtr(this->interface->type), strPtr(strToLog(this->interface->name)),
"{type: %s, name: %s, ignoreMissing: %s}", strZ(this->interface->type), strZ(strToLog(this->interface->name)),
cvtBoolToConstZ(this->interface->ignoreMissing));
}

6
src/storage/remote/protocol.c
View File

@ -83,7 +83,7 @@ storageRemoteFilterGroup(IoFilterGroup *filterGroup, const Variant *filterList)
else if (strEq(filterKey, SIZE_FILTER_TYPE_STR))
ioFilterGroupAdd(filterGroup, ioSizeNew());
else
THROW_FMT(AssertError, "unable to add filter '%s'", strPtr(filterKey));
THROW_FMT(AssertError, "unable to add filter '%s'", strZ(filterKey));
}
FUNCTION_TEST_RETURN_VOID();
@ -400,7 +400,7 @@ storageRemoteProtocolBlockSize(const String *message)
// Validate the header block size message
if (!regExpMatch(storageRemoteProtocolLocal.blockRegExp, message))
THROW_FMT(ProtocolError, "'%s' is not a valid block size message", strPtr(message));
THROW_FMT(ProtocolError, "'%s' is not a valid block size message", strZ(message));
FUNCTION_LOG_RETURN(SSIZE, (ssize_t)cvtZToInt(strPtr(message) + sizeof(PROTOCOL_BLOCK_HEADER) - 1));
FUNCTION_LOG_RETURN(SSIZE, (ssize_t)cvtZToInt(strZ(message) + sizeof(PROTOCOL_BLOCK_HEADER) - 1));
}

2
src/storage/remote/storage.c
View File

@ -65,7 +65,7 @@ storageRemoteInfoParse(ProtocolClient *client, StorageInfo *info)
FUNCTION_TEST_PARAM(STORAGE_INFO, info);
FUNCTION_TEST_END();
info->type = storageRemoteInfoParseType(strPtr(protocolClientReadLine(client))[0]);
info->type = storageRemoteInfoParseType(strZ(protocolClientReadLine(client))[0]);
info->timeModified = (time_t)jsonToUInt64(protocolClientReadLine(client));
if (info->type == storageTypeFile)

2
src/storage/s3/read.c
View File

@ -69,7 +69,7 @@ storageReadS3Open(THIS_VOID)
}
// Else error unless ignore missing
else if (!this->interface.ignoreMissing)
THROW_FMT(FileMissingError, "unable to open '%s': No such file or directory", strPtr(this->interface.name));
THROW_FMT(FileMissingError, "unable to open '%s': No such file or directory", strZ(this->interface.name));
FUNCTION_LOG_RETURN(BOOL, result);
}

42
src/storage/s3/storage.c
View File

@ -168,7 +168,7 @@ storageS3Auth(
String *signedHeaders = NULL;
String *canonicalRequest = strNewFmt(
"%s\n%s\n%s\n", strPtr(verb), strPtr(uri), query == NULL ? "" : strPtr(httpQueryRenderP(query)));
"%s\n%s\n%s\n", strZ(verb), strZ(uri), query == NULL ? "" : strZ(httpQueryRenderP(query)));
for (unsigned int headerIdx = 0; headerIdx < strLstSize(headerList); headerIdx++)
{
@ -179,20 +179,20 @@ storageS3Auth(
if (strEq(headerKeyLower, HTTP_HEADER_AUTHORIZATION_STR))
continue;
strCatFmt(canonicalRequest, "%s:%s\n", strPtr(headerKeyLower), strPtr(httpHeaderGet(httpHeader, headerKey)));
strCatFmt(canonicalRequest, "%s:%s\n", strZ(headerKeyLower), strZ(httpHeaderGet(httpHeader, headerKey)));
if (signedHeaders == NULL)
signedHeaders = strDup(headerKeyLower);
else
strCatFmt(signedHeaders, ";%s", strPtr(headerKeyLower));
strCatFmt(signedHeaders, ";%s", strZ(headerKeyLower));
}
strCatFmt(canonicalRequest, "\n%s\n%s", strPtr(signedHeaders), strPtr(payloadHash));
strCatFmt(canonicalRequest, "\n%s\n%s", strZ(signedHeaders), strZ(payloadHash));
// Generate string to sign
const String *stringToSign = strNewFmt(
AWS4_HMAC_SHA256 "\n%s\n%s/%s/" S3 "/" AWS4_REQUEST "\n%s", strPtr(dateTime), strPtr(date), strPtr(this->region),
strPtr(bufHex(cryptoHashOne(HASH_TYPE_SHA256_STR, BUFSTR(canonicalRequest)))));
AWS4_HMAC_SHA256 "\n%s\n%s/%s/" S3 "/" AWS4_REQUEST "\n%s", strZ(dateTime), strZ(date), strZ(this->region),
strZ(bufHex(cryptoHashOne(HASH_TYPE_SHA256_STR, BUFSTR(canonicalRequest)))));
// Generate signing key. This key only needs to be regenerated every seven days but we'll do it once a day to keep the
// logic simple. It's a relatively expensive operation so we'd rather not do it for every request.
@ -200,7 +200,7 @@ storageS3Auth(
if (!strEq(date, this->signingKeyDate))
{
const Buffer *dateKey = cryptoHmacOne(
HASH_TYPE_SHA256_STR, BUFSTR(strNewFmt(AWS4 "%s", strPtr(this->secretAccessKey))), BUFSTR(date));
HASH_TYPE_SHA256_STR, BUFSTR(strNewFmt(AWS4 "%s", strZ(this->secretAccessKey))), BUFSTR(date));
const Buffer *regionKey = cryptoHmacOne(HASH_TYPE_SHA256_STR, dateKey, BUFSTR(this->region));
const Buffer *serviceKey = cryptoHmacOne(HASH_TYPE_SHA256_STR, regionKey, S3_BUF);
@ -216,8 +216,8 @@ storageS3Auth(
// Generate authorization header
const String *authorization = strNewFmt(
AWS4_HMAC_SHA256 " Credential=%s/%s/%s/" S3 "/" AWS4_REQUEST ",SignedHeaders=%s,Signature=%s",
strPtr(this->accessKey), strPtr(date), strPtr(this->region), strPtr(signedHeaders),
strPtr(bufHex(cryptoHmacOne(HASH_TYPE_SHA256_STR, this->signingKey, BUFSTR(stringToSign)))));
strZ(this->accessKey), strZ(date), strZ(this->region), strZ(signedHeaders),
strZ(bufHex(cryptoHmacOne(HASH_TYPE_SHA256_STR, this->signingKey, BUFSTR(stringToSign)))));
httpHeaderPut(httpHeader, HTTP_HEADER_AUTHORIZATION_STR, authorization);
}
@ -265,7 +265,7 @@ storageS3RequestAsync(StorageS3 *this, const String *verb, const String *uri, St
// When using path-style URIs the bucket name needs to be prepended
if (this->uriStyle == storageS3UriStylePath)
uri = strNewFmt("/%s%s", strPtr(this->bucket), strPtr(uri));
uri = strNewFmt("/%s%s", strZ(this->bucket), strZ(uri));
// Generate authorization header
storageS3Auth(
@ -367,7 +367,7 @@ storageS3ListInternal(
if (strSize(path) == 1)
basePrefix = EMPTY_STR;
else
basePrefix = strNewFmt("%s/", strPtr(strSub(path, 1)));
basePrefix = strNewFmt("%s/", strZ(strSub(path, 1)));
// Get the expression prefix when possible to limit initial results
const String *expressionPrefix = regExpPrefix(expression);
@ -382,7 +382,7 @@ storageS3ListInternal(
if (strEmpty(basePrefix))
queryPrefix = expressionPrefix;
else
queryPrefix = strNewFmt("%s%s", strPtr(basePrefix), strPtr(expressionPrefix));
queryPrefix = strNewFmt("%s%s", strZ(basePrefix), strZ(expressionPrefix));
}
// Loop as long as a continuation token returned
@ -490,7 +490,7 @@ storageS3Info(THIS_VOID, const String *file, StorageInfoLevel level, StorageInte
const HttpHeader *httpHeader = httpResponseHeader(httpResponse);
result.type = storageTypeFile;
result.size = cvtZToUInt64(strPtr(httpHeaderGet(httpHeader, HTTP_HEADER_CONTENT_LENGTH_STR)));
result.size = cvtZToUInt64(strZ(httpHeaderGet(httpHeader, HTTP_HEADER_CONTENT_LENGTH_STR)));
result.timeModified = httpDateToTime(httpHeaderGet(httpHeader, HTTP_HEADER_LAST_MODIFIED_STR));
}
@ -516,9 +516,9 @@ storageS3CvtTime(const String *time)
FUNCTION_TEST_RETURN(
epochFromParts(
cvtZToInt(strPtr(strSubN(time, 0, 4))), cvtZToInt(strPtr(strSubN(time, 5, 2))),
cvtZToInt(strPtr(strSubN(time, 8, 2))), cvtZToInt(strPtr(strSubN(time, 11, 2))),
cvtZToInt(strPtr(strSubN(time, 14, 2))), cvtZToInt(strPtr(strSubN(time, 17, 2))), 0));
cvtZToInt(strZ(strSubN(time, 0, 4))), cvtZToInt(strZ(strSubN(time, 5, 2))),
cvtZToInt(strZ(strSubN(time, 8, 2))), cvtZToInt(strZ(strSubN(time, 11, 2))),
cvtZToInt(strZ(strSubN(time, 14, 2))), cvtZToInt(strZ(strSubN(time, 17, 2))), 0));
}
static void
@ -554,7 +554,7 @@ storageS3InfoListCallback(StorageS3 *this, void *callbackData, const String *nam
{
ASSERT(xml != NULL);
info.size = cvtZToUInt64(strPtr(xmlNodeContent(xmlNodeChild(xml, S3_XML_TAG_SIZE_STR, true))));
info.size = cvtZToUInt64(strZ(xmlNodeContent(xmlNodeChild(xml, S3_XML_TAG_SIZE_STR, true))));
info.timeModified = storageS3CvtTime(xmlNodeContent(xmlNodeChild(xml, S3_XML_TAG_LAST_MODIFIED_STR, true)));
}
}
@ -670,9 +670,9 @@ storageS3PathRemoveInternal(StorageS3 *this, XmlDocument *request)
THROW_FMT(
FileRemoveError, STORAGE_ERROR_PATH_REMOVE_FILE ": [%s] %s",
strPtr(xmlNodeContent(xmlNodeChild(error, S3_XML_TAG_KEY_STR, true))),
strPtr(xmlNodeContent(xmlNodeChild(error, S3_XML_TAG_CODE_STR, true))),
strPtr(xmlNodeContent(xmlNodeChild(error, S3_XML_TAG_MESSAGE_STR, true))));
strZ(xmlNodeContent(xmlNodeChild(error, S3_XML_TAG_KEY_STR, true))),
strZ(xmlNodeContent(xmlNodeChild(error, S3_XML_TAG_CODE_STR, true))),
strZ(xmlNodeContent(xmlNodeChild(error, S3_XML_TAG_MESSAGE_STR, true))));
}
}
@ -845,7 +845,7 @@ storageS3New(
.deleteMax = deleteMax,
.uriStyle = uriStyle,
.bucketEndpoint = uriStyle == storageS3UriStyleHost ?
strNewFmt("%s.%s", strPtr(bucket), strPtr(endPoint)) : strDup(endPoint),
strNewFmt("%s.%s", strZ(bucket), strZ(endPoint)) : strDup(endPoint),
.port = port,
// Force the signing key to be generated on the first run

45
src/storage/storage.c
View File

@ -53,7 +53,7 @@ storageNew(
FUNCTION_LOG_END();
ASSERT(type != NULL);
ASSERT(strSize(path) >= 1 && strPtr(path)[0] == '/');
ASSERT(strSize(path) >= 1 && strZ(path)[0] == '/');
ASSERT(driver != NULL);
ASSERT(interface.info != NULL);
ASSERT(interface.infoList != NULL);
@ -197,10 +197,7 @@ storageGet(StorageRead *file, StorageGetParam param)
// If an exact read make sure the size is as expected
if (bufUsed(result) != param.exactSize)
{
THROW_FMT(
FileReadError, "unable to read %zu byte(s) from '%s'", param.exactSize, strPtr(storageReadName(file)));
}
THROW_FMT(FileReadError, "unable to read %zu byte(s) from '%s'", param.exactSize, strZ(storageReadName(file)));
}
// Else read entire file
else
@ -263,7 +260,7 @@ storageInfo(const Storage *this, const String *fileExp, StorageInfoParam param)
// Error if the file missing and not ignoring
if (!result.exists && !param.ignoreMissing)
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_INFO_MISSING, strPtr(file));
THROW_SYS_ERROR_FMT(FileOpenError, STORAGE_ERROR_INFO_MISSING, strZ(file));
// Dup the strings into the prior context
MEM_CONTEXT_PRIOR_BEGIN()
@ -410,7 +407,7 @@ storageInfoListCallback(void *data, const StorageInfo *info)
StorageInfo infoUpdate = *info;
if (listData->subPath != NULL)
infoUpdate.name = strNewFmt("%s/%s", strPtr(listData->subPath), strPtr(infoUpdate.name));
infoUpdate.name = strNewFmt("%s/%s", strZ(listData->subPath), strZ(infoUpdate.name));
// Is this file a match?
bool match = listData->expression == NULL || regExpMatch(listData->regExp, infoUpdate.name);
@ -426,7 +423,7 @@ storageInfoListCallback(void *data, const StorageInfo *info)
data.subPath = infoUpdate.name;
storageInfoListSort(
data.storage, strNewFmt("%s/%s", strPtr(data.path), strPtr(data.subPath)), infoUpdate.level, data.expression,
data.storage, strNewFmt("%s/%s", strZ(data.path), strZ(data.subPath)), infoUpdate.level, data.expression,
data.sortOrder, storageInfoListCallback, &data);
}
@ -493,7 +490,7 @@ storageInfoList(
result = storageInfoListSort(this, path, param.level, NULL, param.sortOrder, callback, callbackData);
if (!result && param.errorOnMissing)
THROW_FMT(PathMissingError, STORAGE_ERROR_LIST_INFO_MISSING, strPtr(path));
THROW_FMT(PathMissingError, STORAGE_ERROR_LIST_INFO_MISSING, strZ(path));
}
MEM_CONTEXT_TEMP_END();
@ -692,15 +689,15 @@ storagePath(const Storage *this, const String *pathExp, StoragePathParam param)
else
{
// If the path expression is absolute then use it as is
if ((strPtr(pathExp))[0] == '/')
if ((strZ(pathExp))[0] == '/')
{
// Make sure the base storage path is contained within the path expression
if (!strEqZ(this->path, "/"))
{
if (!param.noEnforce && (!strBeginsWith(pathExp, this->path) ||
!(strSize(pathExp) == strSize(this->path) || *(strPtr(pathExp) + strSize(this->path)) == '/')))
!(strSize(pathExp) == strSize(this->path) || *(strZ(pathExp) + strSize(this->path)) == '/')))
{
THROW_FMT(AssertError, "absolute path '%s' is not in base path '%s'", strPtr(pathExp), strPtr(this->path));
THROW_FMT(AssertError, "absolute path '%s' is not in base path '%s'", strZ(pathExp), strZ(this->path));
}
}
@ -713,20 +710,20 @@ storagePath(const Storage *this, const String *pathExp, StoragePathParam param)
String *pathEvaluated = NULL;
// Check if there is a path expression that needs to be evaluated
if ((strPtr(pathExp))[0] == '<')
if ((strZ(pathExp))[0] == '<')
{
if (this->pathExpressionFunction == NULL)
THROW_FMT(AssertError, "expression '%s' not valid without callback function", strPtr(pathExp));
THROW_FMT(AssertError, "expression '%s' not valid without callback function", strZ(pathExp));
// Get position of the expression end
char *end = strchr(strPtr(pathExp), '>');
char *end = strchr(strZ(pathExp), '>');
// Error if end is not found
if (end == NULL)
THROW_FMT(AssertError, "end > not found in path expression '%s'", strPtr(pathExp));
THROW_FMT(AssertError, "end > not found in path expression '%s'", strZ(pathExp));
// Create a string from the expression
String *expression = strNewN(strPtr(pathExp), (size_t)(end - strPtr(pathExp) + 1));
String *expression = strNewN(strZ(pathExp), (size_t)(end - strZ(pathExp) + 1));
// Create a string from the path if there is anything left after the expression
String *path = NULL;
@ -735,11 +732,11 @@ storagePath(const Storage *this, const String *pathExp, StoragePathParam param)
{
// Error if path separator is not found
if (end[1] != '/')
THROW_FMT(AssertError, "'/' should separate expression and path '%s'", strPtr(pathExp));
THROW_FMT(AssertError, "'/' should separate expression and path '%s'", strZ(pathExp));
// Only create path if there is something after the path separator
if (end[2] == 0)
THROW_FMT(AssertError, "path '%s' should not end in '/'", strPtr(pathExp));
THROW_FMT(AssertError, "path '%s' should not end in '/'", strZ(pathExp));
path = strNew(end + 2);
}
@ -749,7 +746,7 @@ storagePath(const Storage *this, const String *pathExp, StoragePathParam param)
// Evaluated path cannot be NULL
if (pathEvaluated == NULL)
THROW_FMT(AssertError, "evaluated path '%s' cannot be null", strPtr(pathExp));
THROW_FMT(AssertError, "evaluated path '%s' cannot be null", strZ(pathExp));
// Assign evaluated path to path
pathExp = pathEvaluated;
@ -760,9 +757,9 @@ storagePath(const Storage *this, const String *pathExp, StoragePathParam param)
}
if (strEqZ(this->path, "/"))
result = strNewFmt("/%s", strPtr(pathExp));
result = strNewFmt("/%s", strZ(pathExp));
else
result = strNewFmt("%s/%s", strPtr(this->path), strPtr(pathExp));
result = strNewFmt("%s/%s", strZ(this->path), strZ(pathExp));
strFree(pathEvaluated);
}
@ -844,7 +841,7 @@ storagePathRemove(const Storage *this, const String *pathExp, StoragePathRemoveP
// Call driver function
if (!storageInterfacePathRemoveP(this->driver, path, param.recurse) && param.errorOnMissing)
{
THROW_FMT(PathRemoveError, STORAGE_ERROR_PATH_REMOVE_MISSING, strPtr(path));
THROW_FMT(PathRemoveError, STORAGE_ERROR_PATH_REMOVE_MISSING, strZ(path));
}
}
MEM_CONTEXT_TEMP_END();
@ -978,5 +975,5 @@ String *
storageToLog(const Storage *this)
{
return strNewFmt(
"{type: %s, path: %s, write: %s}", strPtr(this->type), strPtr(strToLog(this->path)), cvtBoolToConstZ(this->write));
"{type: %s, path: %s, write: %s}", strZ(this->type), strZ(strToLog(this->path)), cvtBoolToConstZ(this->write));
}

2
src/storage/write.c
View File

@ -182,7 +182,7 @@ storageWriteToLog(const StorageWrite *this)
{
return strNewFmt(
"{type: %s, name: %s, modeFile: %04o, modePath: %04o, createPath: %s, syncFile: %s, syncPath: %s, atomic: %s}",
strPtr(storageWriteType(this)), strPtr(strToLog(storageWriteName(this))), storageWriteModeFile(this),
strZ(storageWriteType(this)), strZ(strToLog(storageWriteName(this))), storageWriteModeFile(this),
storageWriteModePath(this), cvtBoolToConstZ(storageWriteCreatePath(this)), cvtBoolToConstZ(storageWriteSyncFile(this)),
cvtBoolToConstZ(storageWriteSyncPath(this)), cvtBoolToConstZ(storageWriteAtomic(this)));
}

2
test/src/common/harnessInfo.c
View File

@ -118,5 +118,5 @@ void
harnessInfoLoadNewCallback(void *callbackData, const String *section, const String *key, const String *value)
{
if (callbackData != NULL)
strCatFmt((String *)callbackData, "[%s] %s=%s\n", strPtr(section), strPtr(key), strPtr(value));
strCatFmt((String *)callbackData, "[%s] %s=%s\n", strZ(section), strZ(key), strZ(value));
}

8
test/src/common/harnessLog.c
View File

@ -295,18 +295,18 @@ hrnLogReplace(void)
{
THROW_FMT(
AssertError, "unable to find sub expression '%s' in '%s' extracted with expresion '%s'",
strPtr(logReplace->expressionSub), strPtr(match), strPtr(logReplace->expression));
strZ(logReplace->expressionSub), strZ(match), strZ(logReplace->expression));
}
// Find beginning of match
begin += regExpMatchPtr(logReplace->regExpSub) - strPtr(match);
begin += regExpMatchPtr(logReplace->regExpSub) - strZ(match);
// Get the match
match = regExpMatchStr(logReplace->regExpSub);
}
// Build replacement string. If versioned then append the version number.
String *replace = strNewFmt("[%s", strPtr(logReplace->replacement));
String *replace = strNewFmt("[%s", strZ(logReplace->replacement));
if (logReplace->version)
{
@ -332,7 +332,7 @@ hrnLogReplace(void)
// Move data from end of string enough to make room for the replacement and copy replacement
memmove(end + diff, end, strlen(end) + 1);
memcpy(begin, strPtr(replace), strSize(replace));
memcpy(begin, strZ(replace), strSize(replace));
}
}
}

6
test/src/common/harnessPq.c
View File

@ -83,7 +83,7 @@ harnessPqScriptRun(const char *function, const VariantList *param, HarnessPq *pa
// Ensure script has not ended
if (harnessPqScriptDone)
{
snprintf(harnessPqScriptError, sizeof(harnessPqScriptError), "pq script ended before %s (%s)", function, strPtr(paramStr));
snprintf(harnessPqScriptError, sizeof(harnessPqScriptError), "pq script ended before %s (%s)", function, strZ(paramStr));
TEST_LOG_FMT(PQ_ERROR_PREFIX ": %s", harnessPqScriptError);
harnessPqScriptFail = true;
@ -99,7 +99,7 @@ harnessPqScriptRun(const char *function, const VariantList *param, HarnessPq *pa
{
snprintf(
harnessPqScriptError, sizeof(harnessPqScriptError), "pq script [%u] expected function %s (%s) but got %s (%s)",
harnessPqScriptIdx, result->function, result->param == NULL ? "" : result->param, function, strPtr(paramStr));
harnessPqScriptIdx, result->function, result->param == NULL ? "" : result->param, function, strZ(paramStr));
TEST_LOG_FMT(PQ_ERROR_PREFIX ": %s", harnessPqScriptError);
harnessPqScriptFail = true;
@ -113,7 +113,7 @@ harnessPqScriptRun(const char *function, const VariantList *param, HarnessPq *pa
{
snprintf(
harnessPqScriptError, sizeof(harnessPqScriptError), "pq script [%u] function '%s', expects param '%s' but got '%s'",
harnessPqScriptIdx, result->function, result->param ? result->param : "NULL", param ? strPtr(paramStr) : "NULL");
harnessPqScriptIdx, result->function, result->param ? result->param : "NULL", param ? strZ(paramStr) : "NULL");
TEST_LOG_FMT(PQ_ERROR_PREFIX ": %s", harnessPqScriptError);
harnessPqScriptFail = true;

16
test/src/common/harnessPq.h
View File

@ -91,7 +91,7 @@ Macros for defining groups of functions that implement various queries and comma
#define HRNPQ_MACRO_SET_APPLICATION_NAME(sessionParam) \
{.session = sessionParam, .function = HRNPQ_SENDQUERY, \
.param = strPtr(strNewFmt("[\"set application_name = '" PROJECT_NAME " [%s]'\"]", cfgCommandName(cfgCommand()))), \
.param = strZ(strNewFmt("[\"set application_name = '" PROJECT_NAME " [%s]'\"]", cfgCommandName(cfgCommand()))), \
.resultInt = 1}, \
{.session = sessionParam, .function = HRNPQ_CONSUMEINPUT}, \
{.session = sessionParam, .function = HRNPQ_ISBUSY}, \
@ -165,7 +165,7 @@ Macros for defining groups of functions that implement various queries and comma
{.session = sessionParam, .function = HRNPQ_NFIELDS, .resultInt = 1}, \
{.session = sessionParam, .function = HRNPQ_FTYPE, .param = "[0]", .resultInt = HRNPQ_TYPE_INT}, \
{.session = sessionParam, .function = HRNPQ_GETVALUE, .param = "[0,0]", \
.resultZ = strPtr(strNewFmt("%" PRId64, (int64_t)(timeParam)))}, \
.resultZ = strZ(strNewFmt("%" PRId64, (int64_t)(timeParam)))}, \
{.session = sessionParam, .function = HRNPQ_CLEAR}, \
{.session = sessionParam, .function = HRNPQ_GETRESULT, .resultNull = true}
@ -223,7 +223,7 @@ Macros for defining groups of functions that implement various queries and comma
#define HRNPQ_MACRO_START_BACKUP_84_95(sessionParam, startFastParam, lsnParam, walSegmentNameParam) \
{.session = sessionParam, \
.function = HRNPQ_SENDQUERY, \
.param = strPtr(strNewFmt( \
.param = strZ(strNewFmt( \
"[\"select lsn::text as lsn,\\n" \
" pg_catalog.pg_xlogfile_name(lsn)::text as wal_segment_name\\n" \
" from pg_catalog.pg_start_backup('pgBackRest backup started at ' || current_timestamp, %s) as lsn\"]", \
@ -245,7 +245,7 @@ Macros for defining groups of functions that implement various queries and comma
#define HRNPQ_MACRO_START_BACKUP_96(sessionParam, startFastParam, lsnParam, walSegmentNameParam) \
{.session = sessionParam, \
.function = HRNPQ_SENDQUERY, \
.param = strPtr(strNewFmt( \
.param = strZ(strNewFmt( \
"[\"select lsn::text as lsn,\\n" \
" pg_catalog.pg_xlogfile_name(lsn)::text as wal_segment_name\\n" \
" from pg_catalog.pg_start_backup('pgBackRest backup started at ' || current_timestamp, %s, false) as lsn\"]", \
@ -267,7 +267,7 @@ Macros for defining groups of functions that implement various queries and comma
#define HRNPQ_MACRO_START_BACKUP_GE_10(sessionParam, startFastParam, lsnParam, walSegmentNameParam) \
{.session = sessionParam, \
.function = HRNPQ_SENDQUERY, \
.param = strPtr(strNewFmt( \
.param = strZ(strNewFmt( \
"[\"select lsn::text as lsn,\\n" \
" pg_catalog.pg_walfile_name(lsn)::text as wal_segment_name\\n" \
" from pg_catalog.pg_start_backup('pgBackRest backup started at ' || current_timestamp, %s, false) as lsn\"]", \
@ -410,7 +410,7 @@ Macros for defining groups of functions that implement various queries and comma
{.session = sessionParam, .function = HRNPQ_NFIELDS, .resultInt = 2}, \
{.session = sessionParam, .function = HRNPQ_FTYPE, .param = "[0]", .resultInt = HRNPQ_TYPE_INT}, \
{.session = sessionParam, .function = HRNPQ_FTYPE, .param = "[1]", .resultInt = HRNPQ_TYPE_TEXT}, \
{.session = sessionParam, .function = HRNPQ_GETVALUE, .param = "[0,0]", .resultZ = strPtr(strNewFmt("%d", id1Param))}, \
{.session = sessionParam, .function = HRNPQ_GETVALUE, .param = "[0,0]", .resultZ = strZ(strNewFmt("%d", id1Param))}, \
{.session = sessionParam, .function = HRNPQ_GETVALUE, .param = "[0,1]", .resultZ = name1Param}, \
{.session = sessionParam, .function = HRNPQ_CLEAR}, \
{.session = sessionParam, .function = HRNPQ_GETRESULT, .resultNull = true}
@ -428,7 +428,7 @@ Macros for defining groups of functions that implement various queries and comma
sessionParam, walNameParam, lsnNameParam, targetLsnParam, targetReachedParam, replayLsnParam) \
{.session = sessionParam, \
.function = HRNPQ_SENDQUERY, \
.param = strPtr(strNewFmt( \
.param = strZ(strNewFmt( \
"[\"select replayLsn::text,\\n" \
" (replayLsn > '%s')::bool as targetReached\\n" \
" from pg_catalog.pg_last_" walNameParam "_replay_" lsnNameParam "() as replayLsn\"]", targetLsnParam)), \
@ -455,7 +455,7 @@ Macros for defining groups of functions that implement various queries and comma
#define HRNPQ_MACRO_CHECKPOINT_TARGET_REACHED(sessionParam, lsnNameParam, targetLsnParam, targetReachedParam, checkpointLsnParam) \
{.session = sessionParam, \
.function = HRNPQ_SENDQUERY, \
.param = strPtr(strNewFmt( \
.param = strZ(strNewFmt( \
"[\"select (checkpoint_" lsnNameParam " > '%s')::bool as targetReached,\\n" \
" checkpoint_" lsnNameParam "::text as checkpointLsn\\n" \
" from pg_catalog.pg_control_checkpoint()\"]", targetLsnParam)), \

10
test/src/common/harnessStorage.c
View File

@ -71,7 +71,7 @@ hrnStorageInfoListCallback(void *callbackData, const StorageInfo *info)
if (data->rootPathOmit && info->type == storageTypePath && strEq(info->name, DOT_STR))
return;
strCatFmt(data->content, "%s {", strPtr(info->name));
strCatFmt(data->content, "%s {", strZ(info->name));
if (info->level > storageInfoLevelExists)
{
@ -93,7 +93,7 @@ hrnStorageInfoListCallback(void *callbackData, const StorageInfo *info)
StorageRead *read = storageNewReadP(
data->storage,
data->path != NULL ? strNewFmt("%s/%s", strPtr(data->path), strPtr(info->name)) : info->name);
data->path != NULL ? strNewFmt("%s/%s", strZ(data->path), strZ(info->name)) : info->name);
ioFilterGroupAdd(ioReadFilterGroup(storageReadIo(read)), decompressFilter(compressTypeGz));
size = bufUsed(storageGetP(read));
}
@ -106,7 +106,7 @@ hrnStorageInfoListCallback(void *callbackData, const StorageInfo *info)
case storageTypeLink:
{
strCatFmt(data->content, "link, d=%s", strPtr(info->linkDestination));
strCatFmt(data->content, "link, d=%s", strZ(info->linkDestination));
break;
}
@ -145,7 +145,7 @@ hrnStorageInfoListCallback(void *callbackData, const StorageInfo *info)
{
if (info->user != NULL)
{
strCatFmt(data->content, ", u=%s", strPtr(info->user));
strCatFmt(data->content, ", u=%s", strZ(info->user));
}
else
{
@ -157,7 +157,7 @@ hrnStorageInfoListCallback(void *callbackData, const StorageInfo *info)
{
if (info->group != NULL)
{
strCatFmt(data->content, ", g=%s", strPtr(info->group));
strCatFmt(data->content, ", g=%s", strZ(info->group));
}
else
{

10
test/src/common/harnessTest.h
View File

@ -239,15 +239,15 @@ Macros to compare results of common data types
TEST_RESULT_Z_PARAM(statement, expected, harnessTestResultOperationNe, __VA_ARGS__);
#define TEST_RESULT_STR(statement, resultExpected, ...) \
TEST_RESULT_Z(strPtrNull(statement), strPtrNull(resultExpected), __VA_ARGS__);
TEST_RESULT_Z(strZNull(statement), strZNull(resultExpected), __VA_ARGS__);
#define TEST_RESULT_STR_Z(statement, resultExpected, ...) \
TEST_RESULT_Z(strPtrNull(statement), resultExpected, __VA_ARGS__);
TEST_RESULT_Z(strZNull(statement), resultExpected, __VA_ARGS__);
#define TEST_RESULT_STR_KEYRPL(statement, resultExpected, ...) \
TEST_RESULT_Z(strPtrNull(statement), hrnReplaceKey(strPtr(resultExpected)), __VA_ARGS__);
TEST_RESULT_Z(strZNull(statement), hrnReplaceKey(strZ(resultExpected)), __VA_ARGS__);
#define TEST_RESULT_STR_Z_KEYRPL(statement, resultExpected, ...) \
TEST_RESULT_Z(strPtrNull(statement), hrnReplaceKey(resultExpected), __VA_ARGS__);
TEST_RESULT_Z(strZNull(statement), hrnReplaceKey(resultExpected), __VA_ARGS__);
#define TEST_RESULT_Z_STR(statement, resultExpected, ...) \
TEST_RESULT_Z(statement, strPtrNull(resultExpected), __VA_ARGS__);
TEST_RESULT_Z(statement, strZNull(resultExpected), __VA_ARGS__);
#define TEST_RESULT_UINT_PARAM(statement, expected, operation, ...) \
do \

11
test/src/common/harnessTls.c
View File

@ -233,10 +233,9 @@ void hrnTlsServerRunParam(IoRead *read, const String *certificate, const String
// Configure the context by setting key and cert
cryptoError(
SSL_CTX_use_certificate_file(serverContext, strPtr(certificate), SSL_FILETYPE_PEM) <= 0,
"unable to load server certificate");
SSL_CTX_use_certificate_file(serverContext, strZ(certificate), SSL_FILETYPE_PEM) <= 0, "unable to load server certificate");
cryptoError(
SSL_CTX_use_PrivateKey_file(serverContext, strPtr(key), SSL_FILETYPE_PEM) <= 0, "unable to load server private key");
SSL_CTX_use_PrivateKey_file(serverContext, strZ(key), SSL_FILETYPE_PEM) <= 0, "unable to load server private key");
// Create the socket
int serverSocket;
@ -340,13 +339,13 @@ void hrnTlsServerRunParam(IoRead *read, const String *certificate, const String
for (unsigned int actualIdx = 0; actualIdx < strSize(actual); actualIdx++)
{
if (strPtr(expected)[actualIdx] == '?')
((char *)strPtr(actual))[actualIdx] = '?';
if (strZ(expected)[actualIdx] == '?')
((char *)strZ(actual))[actualIdx] = '?';
}
// Error if actual does not match expected
if (!strEq(actual, expected))
THROW_FMT(AssertError, "server expected '%s' but got '%s'", strPtr(expected), strPtr(actual));
THROW_FMT(AssertError, "server expected '%s' but got '%s'", strZ(expected), strZ(actual));
break;
}

40
test/src/module/command/archiveCommonTest.c
View File

@ -37,16 +37,16 @@ testRun(void)
TEST_RESULT_BOOL(archiveAsyncStatus(archiveModeGet, segment, false), false, "directory and status file not present");
// -------------------------------------------------------------------------------------------------------------------------
mkdir(strPtr(strNewFmt("%s/archive", testPath())), 0750);
mkdir(strPtr(strNewFmt("%s/archive/db", testPath())), 0750);
mkdir(strPtr(strNewFmt("%s/archive/db/out", testPath())), 0750);
mkdir(strZ(strNewFmt("%s/archive", testPath())), 0750);
mkdir(strZ(strNewFmt("%s/archive/db", testPath())), 0750);
mkdir(strZ(strNewFmt("%s/archive/db/out", testPath())), 0750);
TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false), false, "status file not present");
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("clear archive file errors");
const String *errorSegment = strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strPtr(segment));
const String *errorSegment = strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strZ(segment));
const String *errorGlobal = strNew(STORAGE_SPOOL_ARCHIVE_OUT "/global.error");
storagePutP(storageNewWriteP(storageSpoolWrite(), errorSegment), NULL);
@ -59,53 +59,53 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
BUFSTRDEF(BOGUS_STR));
TEST_ERROR(
archiveAsyncStatus(archiveModePush, segment, false), FormatError,
"000000010000000100000001.ok content must have at least two lines");
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
BUFSTRDEF(BOGUS_STR "\n"));
TEST_ERROR(
archiveAsyncStatus(archiveModePush, segment, false), FormatError, "000000010000000100000001.ok message must be > 0");
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
BUFSTRDEF(BOGUS_STR "\nmessage"));
TEST_ERROR(
archiveAsyncStatus(archiveModePush, segment, false), FormatError, "unable to convert base 10 string 'BOGUS' to int");
storagePutP(storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment))), NULL);
storagePutP(storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))), NULL);
TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false), true, "ok file");
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
BUFSTRDEF("0\nwarning"));
TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false), true, "ok file with warning");
harnessLogResult("P00 WARN: warning");
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
BUFSTRDEF("25\nerror"));
TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false), true, "error status renamed to ok");
harnessLogResult(
"P00 WARN: WAL segment '000000010000000100000001' was not pushed due to error [25] and was manually skipped: error");
TEST_RESULT_VOID(
storageRemoveP(
storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strPtr(segment)), .errorOnMissing = true),
storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment)), .errorOnMissing = true),
"remove ok");
// -------------------------------------------------------------------------------------------------------------------------
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strPtr(segment))), bufNew(0));
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strZ(segment))), bufNew(0));
TEST_ERROR(
archiveAsyncStatus(archiveModePush, segment, true), AssertError,
"status file '000000010000000100000001.error' has no content");
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strPtr(segment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strZ(segment))),
BUFSTRDEF("25\nmessage"));
TEST_ERROR(archiveAsyncStatus(archiveModePush, segment, true), AssertError, "message");
@ -191,23 +191,21 @@ testRun(void)
TEST_RESULT_STR_Z(walPath(strNew("/absolute/path"), pgPath, strNew("test")), "/absolute/path", "absolute path");
THROW_ON_SYS_ERROR(chdir(strPtr(pgPath)) != 0, PathMissingError, "unable to chdir()");
THROW_ON_SYS_ERROR(chdir(strZ(pgPath)) != 0, PathMissingError, "unable to chdir()");
TEST_RESULT_STR(
walPath(strNew("relative/path"), pgPath, strNew("test")), strNewFmt("%s/relative/path", strPtr(pgPath)),
walPath(strNew("relative/path"), pgPath, strNew("test")), strNewFmt("%s/relative/path", strZ(pgPath)),
"relative path");
const String *pgPathLink = storagePathP(storageTest, STRDEF("pg-link"));
THROW_ON_SYS_ERROR_FMT(
symlink(strPtr(pgPath), strPtr(pgPathLink)) == -1, FileOpenError,
"unable to create symlink '%s' to '%s'", strPtr(pgPath), strPtr(pgPathLink));
symlink(strZ(pgPath), strZ(pgPathLink)) == -1, FileOpenError, "unable to create symlink '%s' to '%s'", strZ(pgPath),
strZ(pgPathLink));
THROW_ON_SYS_ERROR(chdir(strPtr(pgPath)) != 0, PathMissingError, "unable to chdir()");
THROW_ON_SYS_ERROR(chdir(strZ(pgPath)) != 0, PathMissingError, "unable to chdir()");
TEST_RESULT_STR(
walPath(strNew("relative/path"), pgPathLink, strNew("test")), strNewFmt("%s/relative/path", strPtr(pgPathLink)),
walPath(strNew("relative/path"), pgPathLink, strNew("test")), strNewFmt("%s/relative/path", strZ(pgPathLink)),
"relative path");
THROW_ON_SYS_ERROR(chdir("/") != 0, PathMissingError, "unable to chdir()");
TEST_ERROR(
walPath(strNew("relative/path"), pgPathLink, strNew("test")), AssertError,

29
test/src/module/command/archiveGetTest.c
View File

@ -234,7 +234,7 @@ testRun(void)
archiveGetProtocol(PROTOCOL_COMMAND_ARCHIVE_GET_STR, paramList, server), true, "protocol archive get");
TEST_RESULT_STR_Z(strNewBuf(serverWrite), "{\"out\":0}\n", "check result");
TEST_RESULT_BOOL(
storageExistsP(storageTest, strNewFmt("spool/archive/test1/in/%s", strPtr(archiveFile))), true, " check exists");
storageExistsP(storageTest, strNewFmt("spool/archive/test1/in/%s", strZ(archiveFile))), true, " check exists");
bufUsedSet(serverWrite, 0);
@ -577,9 +577,9 @@ testRun(void)
"HINT: has a stanza-create been performed?\n"
"HINT: use --no-archive-check to disable archive checks during backup if you have an alternate archiving"
" scheme.",
strPtr(cfgOptionStr(cfgOptRepoPath)), strPtr(cfgOptionStr(cfgOptRepoPath)),
strPtr(strNewFmt("%s/archive/test1/archive.info", strPtr(cfgOptionStr(cfgOptRepoPath)))),
strPtr(strNewFmt("%s/archive/test1/archive.info.copy", strPtr(cfgOptionStr(cfgOptRepoPath)))));
strZ(cfgOptionStr(cfgOptRepoPath)), strZ(cfgOptionStr(cfgOptRepoPath)),
strZ(strNewFmt("%s/archive/test1/archive.info", strZ(cfgOptionStr(cfgOptRepoPath)))),
strZ(strNewFmt("%s/archive/test1/archive.info.copy", strZ(cfgOptionStr(cfgOptRepoPath)))));
}
HARNESS_FORK_CHILD_END();
}
@ -607,9 +607,9 @@ testRun(void)
"HINT: has a stanza-create been performed?\n"
"HINT: use --no-archive-check to disable archive checks during backup if you have an alternate archiving"
" scheme.",
strPtr(cfgOptionStr(cfgOptRepoPath)), strPtr(cfgOptionStr(cfgOptRepoPath)),
strPtr(strNewFmt("%s/archive/test1/archive.info", strPtr(cfgOptionStr(cfgOptRepoPath)))),
strPtr(strNewFmt("%s/archive/test1/archive.info.copy", strPtr(cfgOptionStr(cfgOptRepoPath)))));
strZ(cfgOptionStr(cfgOptRepoPath)), strZ(cfgOptionStr(cfgOptRepoPath)),
strZ(strNewFmt("%s/archive/test1/archive.info", strZ(cfgOptionStr(cfgOptRepoPath)))),
strZ(strNewFmt("%s/archive/test1/archive.info.copy", strZ(cfgOptionStr(cfgOptRepoPath)))));
}
HARNESS_FORK_CHILD_END();
}
@ -623,7 +623,7 @@ testRun(void)
strLstAddZ(argList, "pg_wal/RECOVERYXLOG");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
THROW_ON_SYS_ERROR(chdir(strPtr(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
HARNESS_FORK_BEGIN()
{
@ -639,8 +639,7 @@ testRun(void)
// Check for missing WAL
// -------------------------------------------------------------------------------------------------------------------------
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s.ok", strPtr(walSegment))), NULL);
storagePutP(storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s.ok", strZ(walSegment))), NULL);
HARNESS_FORK_BEGIN()
{
@ -655,13 +654,13 @@ testRun(void)
harnessLogResult("P01 INFO: unable to find 000000010000000100000001 in the archive");
TEST_RESULT_BOOL(
storageExistsP(storageSpool(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s.ok", strPtr(walSegment))), false,
storageExistsP(storageSpool(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s.ok", strZ(walSegment))), false,
"check OK file was removed");
// Write out a WAL segment for success
// -------------------------------------------------------------------------------------------------------------------------
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment))),
BUFSTRDEF("SHOULD-BE-A-REAL-WAL-FILE"));
HARNESS_FORK_BEGIN()
@ -677,7 +676,7 @@ testRun(void)
TEST_RESULT_VOID(harnessLogResult("P01 INFO: found 000000010000000100000001 in the archive"), "check log");
TEST_RESULT_BOOL(
storageExistsP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment))), false,
storageExistsP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment))), false,
"check WAL segment was removed from source");
TEST_RESULT_BOOL(storageExistsP(storageTest, walFile), true, "check WAL segment was moved to destination");
storageRemoveP(storageTest, walFile, .errorOnMissing = true);
@ -690,10 +689,10 @@ testRun(void)
String *walSegment2 = strNew("000000010000000100000002");
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment))),
BUFSTRDEF("SHOULD-BE-A-REAL-WAL-FILE"));
storagePutP(
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment2))),
storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strZ(walSegment2))),
BUFSTRDEF("SHOULD-BE-A-REAL-WAL-FILE"));
HARNESS_FORK_BEGIN()

Some files were not shown because too many files have changed in this diff Show More