DWORD
RegSrvStartListenThread(
void
)
{
PSTR pszCachePath = NULL;
PSTR pszCommPath = NULL;
BOOLEAN bDirExists = FALSE;
DWORD dwError = 0;
static LWMsgTime idleTimeout = {30, 0};
dwError = RegSrvGetCachePath(&pszCachePath);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCheckDirectoryExists(pszCachePath, &bDirExists);
BAIL_ON_REG_ERROR(dwError);
if (!bDirExists)
{
// Directory should be RWX for root and accessible to all
// (so they can see the socket.
mode_t mode = S_IRWXU | S_IRGRP| S_IXGRP | S_IROTH | S_IXOTH;
dwError = RegCreateDirectory(pszCachePath, mode);
BAIL_ON_REG_ERROR(dwError);
}
dwError = LwRtlCStringAllocatePrintf(&pszCommPath, "%s/%s",
pszCachePath, REG_SERVER_FILENAME);
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &gpContext));
BAIL_ON_REG_ERROR(dwError);
lwmsg_context_set_log_function(gpContext, RegSrvLogIpc, NULL);
/* Set up IPC protocol object */
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_new(gpContext, &gpProtocol));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_add_protocol_spec(
gpProtocol,
RegIPCGetProtocolSpec()));
BAIL_ON_REG_ERROR(dwError);
/* Set up IPC server object */
dwError = MAP_LWMSG_ERROR(lwmsg_peer_new(gpContext, gpProtocol, &gpServer));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_dispatch_spec(
gpServer,
RegSrvGetDispatchSpec()));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_DIRECT,
"lwreg",
0));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_LOCAL,
pszCommPath,
0666));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_max_listen_clients(
gpServer,
MAX_CLIENTS));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_max_listen_backlog(
gpServer,
REG_MAX(5, MAX_CLIENTS / 4)));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_timeout(
gpServer,
LWMSG_TIMEOUT_IDLE,
&idleTimeout));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_listen_session_functions(
gpServer,
RegSrvIpcConstructSession,
RegSrvIpcDestructSession,
NULL));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_start_listen(gpServer));
error:
LWREG_SAFE_FREE_STRING(pszCachePath);
LWREG_SAFE_FREE_STRING(pszCommPath);
if (dwError)
{
if (gpServer)
{
lwmsg_peer_stop_listen(gpServer);
lwmsg_peer_delete(gpServer);
gpServer = NULL;
}
}
return dwError;
}
static
DWORD
RegCreateDirectoryRecursive(
PSTR pszCurDirPath,
PSTR pszTmpPath,
PSTR *ppszTmp,
DWORD dwFileMode,
DWORD dwWorkingFileMode,
int iPart
)
{
DWORD dwError = 0;
PSTR pszDirPath = NULL;
BOOLEAN bDirCreated = FALSE;
BOOLEAN bDirExists = FALSE;
CHAR szDelimiters[] = "/";
PSTR pszToken = strtok_r((iPart ? NULL : pszTmpPath), szDelimiters, ppszTmp);
if (pszToken != NULL) {
dwError = RegAllocateMemory(strlen(pszCurDirPath)+strlen(pszToken)+2, (PVOID*)&pszDirPath);
BAIL_ON_REG_ERROR(dwError);
sprintf(pszDirPath,
"%s/%s",
(!strcmp(pszCurDirPath, "/") ? "" : pszCurDirPath),
pszToken);
dwError = RegCheckDirectoryExists(pszDirPath, &bDirExists);
BAIL_ON_REG_ERROR(dwError);
if (!bDirExists) {
if (mkdir(pszDirPath, dwWorkingFileMode) < 0) {
dwError = errno;
BAIL_ON_REG_ERROR(dwError);
}
bDirCreated = TRUE;
}
dwError = RegChangeDirectory(pszDirPath);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCreateDirectoryRecursive(
pszDirPath,
pszTmpPath,
ppszTmp,
dwFileMode,
dwWorkingFileMode,
iPart+1
);
BAIL_ON_REG_ERROR(dwError);
}
if (bDirCreated && (dwFileMode != dwWorkingFileMode)) {
dwError = RegChangePermissions(pszDirPath, dwFileMode);
BAIL_ON_REG_ERROR(dwError);
}
if (pszDirPath) {
RegMemoryFree(pszDirPath);
}
return dwError;
error:
if (bDirCreated) {
RegRemoveDirectory(pszDirPath);
}
if (pszDirPath) {
RegMemoryFree(pszDirPath);
}
return dwError;
}
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;
}
int main(int argc, char *argv[])
{
PIV_CONVERT_CTX ivHandle = NULL;
PCHAR strDefaultList[] = {
"1: Now is the time",
"2: For all good people",
"3: All work and no play",
"4: Makes Jack a dull boy",
NULL,
};
PCHAR *argcList = NULL;
PCHAR *multiStringList = strDefaultList;
PBYTE multiString = NULL;
ssize_t multiStringLen = 0;
PSTR exportString = NULL;
DWORD exportStringLen = 0;
DWORD dwError = 0;
DWORD count = 0;
if (argc > 1)
{
dwError = RegAllocateMemory(sizeof(PCHAR) * argc, (PVOID*)&argcList);
BAIL_ON_REG_ERROR(dwError);
for (count=1; count < argc; count++)
{
argcList[count-1] = argv[count];
}
multiStringList = argcList;
}
RegIconvConvertOpen(&ivHandle, "ucs-2le", "utf-8");
RegMultiStrsToByteArray(multiStringList,
&multiString,
&multiStringLen);
RegExportEntry("HKLM_LINUX/likewise/registry/devel",
NULL,
0,
NULL,
REG_KEY,
NULL,
0,
&exportString,
&exportStringLen);
printf("%s\n", exportString);
RegExportEntry(NULL,
NULL,
0,
"testkey1",
REG_MULTI_SZ,
multiString,
multiStringLen,
&exportString,
&exportStringLen);
printf("%s\n", exportString);
RegIconvConvertClose(ivHandle);
cleanup:
return dwError;
error:
goto cleanup;
}
int main(int argc, char *argv[])
{
DWORD dwError;
HANDLE hReg = NULL;
PLWREG_VALUE_ATTRIBUTES pAttr = NULL;
PLWREG_VALUE_ATTRIBUTES pAttr_int = NULL;
PWSTR* ppwszRootKeyNames = NULL;
DWORD dwNumRootKeys = 0;
wchar16_t szSubKey[] = {'a', 0};
wchar16_t szSubKey1[] = {'b', 0};
wchar16_t szValueName[] = {'a','t','t','r',0};
wchar16_t szValueName1[] = {'a','t','t','r','1',0};
HKEY hKey = NULL;
HKEY hSubKey = NULL;
HKEY hSubSubKey = NULL;
PLWREG_CURRENT_VALUEINFO pCurrentValue = NULL;
PLWREG_VALUE_ATTRIBUTES pValueAttributes = NULL;
PLWREG_VALUE_ATTRIBUTES pValueAttributes_int = NULL;
ValueAttribute.Range.ppszRangeEnumStrings = ppszRangeEnumStrings;
ValueAttribute_int.Range.RangeInteger.Max = 100;
ValueAttribute_int.Range.RangeInteger.Min = 1;
DWORD dwType = REG_NONE;
PBYTE pData[MAX_VALUE_LENGTH] = {0};
DWORD cbData = MAX_VALUE_LENGTH;
wchar16_t pCurrData[] = {'C', 'u', 'r', 'r', 'e', 'n', 't', 0};
dwError = RegConvertValueAttributesAToW(ValueAttribute,
&pAttr);
BAIL_ON_REG_ERROR(dwError);
dwError = RegConvertValueAttributesAToW(ValueAttribute_int,
&pAttr_int);
BAIL_ON_REG_ERROR(dwError);
dwError = RegOpenServer(&hReg);
BAIL_ON_REG_ERROR(dwError);
dwError = RegEnumRootKeysW(hReg,
&ppwszRootKeyNames,
&dwNumRootKeys);
BAIL_ON_REG_ERROR(dwError);
dwError = RegOpenKeyExW(
hReg,
NULL,
ppwszRootKeyNames[0],
0,
KEY_ALL_ACCESS | KEY_SET_VALUE | KEY_CREATE_SUB_KEY | DELETE,
&hKey);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCreateKeyExW(
hReg,
hKey,
szSubKey,
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hSubKey,
NULL);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCreateKeyExW(
hReg,
hSubKey,
szSubKey1,
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hSubSubKey,
NULL);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueAttributesW(
hReg,
hKey,
NULL,
szValueName,
pAttr);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueAttributesW(
hReg,
hKey,
NULL,
szValueName1,
pAttr_int);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueAttributesW(
hReg,
hKey,
szSubKey,
szValueName,
pAttr);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueAttributesW(
hReg,
hKey,
szSubKey,
szValueName1,
pAttr);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueAttributesW(
hReg,
hSubSubKey,
NULL,
szValueName1,
pAttr_int);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueAttributesW(
hReg,
hSubSubKey,
NULL,
szValueName,
pAttr);
BAIL_ON_REG_ERROR(dwError);
dwError = RegGetValueAttributesW(
hReg,
hKey,
NULL,
szValueName,
&pCurrentValue,
&pValueAttributes);
BAIL_ON_REG_ERROR(dwError);
dwError = RegGetValueAttributesW(
hReg,
hKey,
NULL,
szValueName1,
NULL,
&pValueAttributes_int);
BAIL_ON_REG_ERROR(dwError);
dwError = RegSetValueExW(
hReg,
hSubKey,
szValueName,
0,
REG_SZ,
(const BYTE*)pCurrData,
(wc16slen(pCurrData)+1)*sizeof(*pCurrData));
BAIL_ON_REG_ERROR(dwError);
dwError = RegGetValueW(
hReg,
hKey,
szSubKey,
szValueName,
RRF_RT_REG_NONE,
&dwType,
pData,
&cbData);
BAIL_ON_REG_ERROR(dwError);
dwError = RegDeleteValueAttributesW(
hReg,
hKey,
NULL,
szValueName);
BAIL_ON_REG_ERROR(dwError);
dwError = RegDeleteTreeW(
hReg,
hKey,
szSubKey);
if (LWREG_ERROR_KEY_IS_ACTIVE == dwError)
{
if (hSubKey)
{
RegCloseKey(hReg, hSubKey);
}
if (hSubSubKey)
{
RegCloseKey(hReg, hSubSubKey);
}
dwError = RegDeleteTreeW(
hReg,
hKey,
szSubKey);
BAIL_ON_REG_ERROR(dwError);
}
BAIL_ON_REG_ERROR(dwError);
cleanup:
if (hKey)
{
RegCloseKey(hReg, hKey);
}
if (hSubKey)
{
RegCloseKey(hReg, hSubKey);
}
if (hSubSubKey)
{
RegCloseKey(hReg, hSubSubKey);
}
if (hReg)
{
RegCloseServer(hReg);
}
RegFreeWC16StringArray(ppwszRootKeyNames,
dwNumRootKeys);
RegSafeFreeValueAttributes(&pAttr);
RegSafeFreeCurrentValueInfo(&pCurrentValue);
RegSafeFreeValueAttributes(&pValueAttributes);
return dwError;
error:
goto cleanup;
}
