static
DWORD
ProcessRootKeys(
HANDLE hReg,
PREG_EXPORT_STATE pExportState
)
{
DWORD dwError = 0;
PSTR* ppszRootKeyNames = NULL;
DWORD dwNumRootKeys = 0;
DWORD iCount = 0;
HKEY hRootKey = NULL;
DWORD dwNumSubKeys = 0;
DWORD dwMaxSubKeyLen = 0;
dwError = RegEnumRootKeysA(hReg,
&ppszRootKeyNames,
&dwNumRootKeys);
BAIL_ON_REG_ERROR(dwError);
if (!dwNumRootKeys)
{
goto cleanup;
}
for (iCount = 0; iCount < dwNumRootKeys; iCount++)
{
dwError = RegOpenKeyExA((HANDLE) hReg,
NULL,
ppszRootKeyNames[iCount],
0,
KEY_READ,
&hRootKey);
BAIL_ON_REG_ERROR(dwError);
dwError = RegQueryInfoKeyA(
(HANDLE) hReg,
hRootKey,
NULL,
NULL,
NULL,
&dwNumSubKeys,
&dwMaxSubKeyLen,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);
BAIL_ON_REG_ERROR(dwError);
dwError = RegShellUtilExport(hReg,
pExportState,
hRootKey,
ppszRootKeyNames[iCount],
dwNumSubKeys,
dwMaxSubKeyLen);
BAIL_ON_REG_ERROR(dwError);
if (hRootKey)
{
dwError = RegCloseKey((HANDLE) hReg,
hRootKey);
BAIL_ON_REG_ERROR(dwError);
hRootKey = NULL;
}
dwNumSubKeys = 0;
dwMaxSubKeyLen = 0;
}
cleanup:
RegFreeStringArray(ppszRootKeyNames, dwNumRootKeys);
if (hRootKey)
{
RegCloseKey((HANDLE) hReg, hRootKey);
}
return dwError;
error:
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;
}
