DWORD
RegGetCurrentDirectoryPath(
PSTR* ppszPath
)
{
DWORD dwError = 0;
CHAR szBuf[PATH_MAX+1];
PSTR pszPath = NULL;
if (getcwd(szBuf, PATH_MAX) == NULL) {
dwError = errno;
BAIL_ON_REG_ERROR(dwError);
}
dwError = RegCStringDuplicate(&pszPath, szBuf);
BAIL_ON_REG_ERROR(dwError);
*ppszPath = pszPath;
return dwError;
error:
LWREG_SAFE_FREE_STRING(pszPath);
return dwError;
}
DWORD
RegGetDirectoryFromPath(
IN PCSTR pszPath,
OUT PSTR* ppszDir
)
{
PCSTR pszLastSlash = NULL;
PSTR pszDir = NULL;
DWORD dwError = 0;
BAIL_ON_INVALID_POINTER(pszPath);
pszLastSlash = strrchr(pszPath, '/');
if (pszLastSlash == pszPath)
{
//Include the trailing / since this is the root directory ( / )
pszLastSlash++;
}
if (pszLastSlash == NULL)
{
dwError = RegCStringDuplicate(
&pszDir, ".");
BAIL_ON_REG_ERROR(dwError);
}
else
{
dwError = RegStrndup(
pszPath,
pszLastSlash - pszPath,
&pszDir);
BAIL_ON_REG_ERROR(dwError);
}
*ppszDir = pszDir;
cleanup:
return dwError;
error:
LWREG_SAFE_FREE_STRING(pszDir);
*ppszDir = NULL;
goto cleanup;
}
DWORD
RegGetSymlinkTarget(
PCSTR pszPath,
PSTR* ppszTargetPath
)
{
DWORD dwError = 0;
CHAR szBuf[PATH_MAX+1];
PSTR pszTargetPath = NULL;
memset(szBuf, 0, sizeof(szBuf));
while (1) {
if (readlink(pszPath, szBuf, PATH_MAX) < 0) {
if (errno == EINTR)
continue;
dwError = errno;
BAIL_ON_REG_ERROR(dwError);
}
break;
}
dwError = RegCStringDuplicate(
&pszTargetPath,
szBuf);
BAIL_ON_REG_ERROR(dwError);
*ppszTargetPath = pszTargetPath;
cleanup:
return dwError;
error:
*ppszTargetPath = NULL;
LWREG_SAFE_FREE_STRING(pszTargetPath);
goto cleanup;
}
DWORD
RegOpenSyslog(
PCSTR pszIdentifier,
RegLogLevel maxAllowedLogLevel,
DWORD dwOptions,
DWORD dwFacility,
PHANDLE phLog
)
{
DWORD dwError = 0;
PREG_SYS_LOG pSyslog = NULL;
dwError = RegAllocateMemory(sizeof(*pSyslog), (PVOID*)&pSyslog);
if (dwError)
{
goto error;
}
dwError = RegCStringDuplicate(
&pSyslog->pszIdentifier,
(IsNullOrEmptyString(pszIdentifier) ? "registry" : pszIdentifier));
if (dwError)
{
goto error;
}
pSyslog->dwOptions = dwOptions;
pSyslog->dwFacility = dwFacility;
openlog(
pSyslog->pszIdentifier,
pSyslog->dwOptions,
pSyslog->dwFacility);
pSyslog->bOpened = TRUE;
RegSetSyslogMask(maxAllowedLogLevel);
dwError = RegSetupLogging(
(HANDLE)pSyslog,
maxAllowedLogLevel,
&RegLogToSyslog);
if (dwError)
{
goto error;
}
*phLog = (HANDLE)pSyslog;
cleanup:
return dwError;
error:
*phLog = (HANDLE)NULL;
if (pSyslog)
{
RegFreeSysLogInfo(pSyslog);
}
goto cleanup;
}
DWORD
RegGetMatchingFilePathsInFolder(
PCSTR pszDirPath,
PCSTR pszFileNameRegExp,
PSTR** pppszHostFilePaths,
PDWORD pdwNPaths
)
{
typedef struct __PATHNODE
{
PSTR pszPath;
struct __PATHNODE *pNext;
} *PPATHNODE;
DWORD dwError = 0;
DIR* pDir = NULL;
struct dirent* pDirEntry = NULL;
regex_t rx;
BOOLEAN rxAllocated = FALSE;
regmatch_t* pResult = NULL;
size_t nMatch = 1;
DWORD dwNPaths = 0;
DWORD iPath = 0;
PSTR* ppszHostFilePaths = NULL;
CHAR szBuf[PATH_MAX+1];
struct stat statbuf;
PPATHNODE pPathList = NULL;
PPATHNODE pPathNode = NULL;
BOOLEAN bDirExists = FALSE;
dwError = RegCheckDirectoryExists(pszDirPath, &bDirExists);
BAIL_ON_REG_ERROR(dwError);
if(!bDirExists) {
dwError = ENOENT;
BAIL_ON_REG_ERROR(dwError);
}
if (regcomp(&rx, pszFileNameRegExp, REG_EXTENDED) != 0) {
dwError = LWREG_ERROR_REGEX_COMPILE_FAILED;
BAIL_ON_REG_ERROR(dwError);
}
rxAllocated = TRUE;
dwError = RegAllocateMemory(sizeof(*pResult), (PVOID*)&pResult);
BAIL_ON_REG_ERROR(dwError);
pDir = opendir(pszDirPath);
if (!pDir) {
dwError = errno;
BAIL_ON_REG_ERROR(dwError);
}
while ((pDirEntry = readdir(pDir)) != NULL) {
int copied = snprintf(
szBuf,
sizeof(szBuf),
"%s/%s",
pszDirPath,
pDirEntry->d_name);
if (copied >= sizeof(szBuf))
{
//Skip pathnames that are too long
continue;
}
memset(&statbuf, 0, sizeof(struct stat));
if (lstat(szBuf, &statbuf) < 0) {
if(errno == ENOENT)
{
//This occurs when there is a symbolic link pointing to a
//location that doesn't exist, because stat looks at the final
//file, not the link. Since this file doesn't exist anyway,
//just skip it.
continue;
}
dwError = errno;
BAIL_ON_REG_ERROR(dwError);
}
/*
* For now, we are searching only for regular files
* This may be enhanced in the future to support additional
* file system entry types
*/
if (((statbuf.st_mode & S_IFMT) == S_IFREG) &&
(regexec(&rx, pDirEntry->d_name, nMatch, pResult, 0) == 0)) {
dwNPaths++;
dwError = RegAllocateMemory(sizeof(*pPathNode), (PVOID*)&pPathNode);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCStringDuplicate(&pPathNode->pszPath, szBuf);
BAIL_ON_REG_ERROR(dwError);
pPathNode->pNext = pPathList;
pPathList = pPathNode;
pPathNode = NULL;
}
}
if (pPathList) {
dwError = RegAllocateMemory(sizeof(*ppszHostFilePaths)*dwNPaths, (PVOID*)&ppszHostFilePaths);
BAIL_ON_REG_ERROR(dwError);
/*
* The linked list is in reverse.
* Assign values in reverse to get it right
*/
iPath = dwNPaths-1;
pPathNode = pPathList;
while (pPathNode) {
*(ppszHostFilePaths+iPath) = pPathNode->pszPath;
pPathNode->pszPath = NULL;
pPathNode = pPathNode->pNext;
iPath--;
}
}
*pppszHostFilePaths = ppszHostFilePaths;
*pdwNPaths = dwNPaths;
cleanup:
if (pPathNode) {
LWREG_SAFE_FREE_STRING(pPathNode->pszPath);
RegMemoryFree(pPathNode);
}
while(pPathList) {
pPathNode = pPathList;
pPathList = pPathList->pNext;
LWREG_SAFE_FREE_STRING(pPathNode->pszPath);
RegMemoryFree(pPathNode);
}
if (rxAllocated) {
regfree(&rx);
}
LWREG_SAFE_FREE_MEMORY(pResult);
if (pDir) {
closedir(pDir);
}
return dwError;
error:
if (ppszHostFilePaths) {
RegFreeStringArray(ppszHostFilePaths, dwNPaths);
}
goto cleanup;
}
DWORD
RegCreateDirectory(
PCSTR pszPath,
mode_t dwFileMode
)
{
DWORD dwError = 0;
PSTR pszCurDirPath = NULL;
PSTR pszTmpPath = NULL;
PSTR pszTmp = NULL;
mode_t dwWorkingFileMode;
if (pszPath == NULL || *pszPath == '\0') {
dwError = EINVAL;
BAIL_ON_REG_ERROR(dwError);
}
dwWorkingFileMode = dwFileMode;
if (!(dwFileMode & S_IXUSR)) {
/*
* This is so that we can navigate the folders
* when we are creating the subfolders
*/
dwWorkingFileMode |= S_IXUSR;
}
dwError = RegGetCurrentDirectoryPath(&pszCurDirPath);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCStringDuplicate(&pszTmpPath, pszPath);
BAIL_ON_REG_ERROR(dwError);
if (*pszPath == '/') {
dwError = RegChangeDirectory("/");
BAIL_ON_REG_ERROR(dwError);
dwError = RegCreateDirectoryRecursive("/", pszTmpPath, &pszTmp, dwFileMode, dwWorkingFileMode, 0);
BAIL_ON_REG_ERROR(dwError);
} else {
dwError = RegCreateDirectoryRecursive(pszCurDirPath, pszTmpPath, &pszTmp, dwFileMode, dwWorkingFileMode, 0);
BAIL_ON_REG_ERROR(dwError);
}
error:
if (pszCurDirPath) {
RegChangeDirectory(pszCurDirPath);
RegMemoryFree(pszCurDirPath);
}
if (pszTmpPath) {
RegMemoryFree(pszTmpPath);
}
return dwError;
}