/**
* @retval 0 if variant did not have a result
* @retval 1 on success
*/
static int elektraResolveSystem (char variant, ElektraResolved * handle, ElektraResolveTempfile tmpDir, Key * warningsKey)
{
// hardcoded path wins against variants for now
if (handle->relPath[0] == '/')
{
/* Use absolute path */
handle->fullPath = elektraStrDup (handle->relPath);
elektraResolveFinishByFilename (handle, tmpDir);
return 1;
}
if (handle->relPath[0] == '~')
{
if (elektraResolveSystemPasswd (handle, warningsKey) == -1)
{
return -1;
}
elektraResolveFinishByFilename (handle, tmpDir);
return 1;
}
switch (variant)
{
case 'x':
return elektraResolveSystemXDG (handle, tmpDir, warningsKey);
case 'b':
return elektraResolveSystemBuildin (handle, tmpDir, warningsKey);
// TODO: also document in doc/COMPILE.md
}
return -1;
}
/**
* @retval 0 if variant did not have a result
* @retval 1 on success
*/
static int elektraResolveSystem (char variant, resolverHandle * p, Key * warningsKey)
{
// hardcoded path wins against variants for now
if (p->path[0] == '/')
{
/* Use absolute path */
size_t filenameSize = strlen (p->path) + 1;
p->filename = elektraMalloc (filenameSize);
strcpy (p->filename, p->path);
elektraResolveFinishByFilename (p);
return 1;
}
if (p->path[0] == '~')
{
if (elektraResolvePasswdHome (p, warningsKey) == -1) return -1;
elektraResolveFinishByFilename (p);
return 1;
}
switch (variant)
{
case 'x':
return elektraResolveSystemXDG (p, warningsKey);
case 'b':
return elektraResolveSystemBuildin (p, warningsKey);
// TODO: also document in doc/COMPILE.md
}
return -1;
}
static int elektraResolveSystemXDG(resolverHandle *p,
Key *warningsKey)
{
const char * configDir = getenv("XDG_CONFIG_DIRS");
const char *defaultDir = "/etc/xdg";
if (!configDir || !strcmp(configDir, ""))
{
elektraResolveSystemXDGHelper(p, defaultDir);
elektraResolveFinishByFilename(p);
return 1;
}
char *saveptr = 0;
char *str = elektraStrDup(configDir);
char *result = strtok_r (str, ":", &saveptr);
struct stat buf;
int errnoSave = errno;
int success = 0;
while (result)
{
if (result[0] != '/')
{
ELEKTRA_ADD_WARNINGF(100,
warningsKey,
"XDG_CONFIG_DIRS contains a path that is "
"not absolute (violates XDG specification) and thus "
"it was skipped: %s",
result);
result = strtok_r (0, ":", &saveptr);
continue;
}
success = 1; // at least once we got a valid path
elektraResolveSystemXDGHelper(p, result);
if (stat(p->filename, &buf) == 0)
{
// we found a file!
break;
}
result = strtok_r (0, ":", &saveptr);
}
elektraFree(str);
errno = errnoSave;
if (!success)
{
elektraResolveSystemXDGHelper(p, defaultDir);
}
elektraResolveFinishByFilename(p);
return 1;
}
static int elektraResolveSystemBuildin (ElektraResolved * handle, ElektraResolveTempfile tmpDir, Key * warningsKey)
{
size_t filenameSize = sizeof (KDB_DB_SYSTEM) + elektraStrLen (handle->relPath) + sizeof ("/");
char * resolved = NULL;
if (KDB_DB_SYSTEM[0] == '~')
{
char * resolvedPath = elektraMalloc (filenameSize);
strcpy (resolvedPath, KDB_DB_SYSTEM);
strcat (resolvedPath, "/");
strcat (resolvedPath, handle->relPath);
char * oldPath = handle->relPath;
handle->relPath = resolvedPath;
elektraResolveSystemPasswd (handle, warningsKey);
elektraFree (resolvedPath);
handle->relPath = oldPath;
}
else
{
resolved = elektraMalloc (filenameSize);
strcpy (resolved, KDB_DB_SYSTEM);
strcat (resolved, "/");
strcat (resolved, handle->relPath);
handle->fullPath = resolved;
}
elektraResolveFinishByFilename (handle, tmpDir);
return 1;
}
static int elektraResolveSystemBuildin (resolverHandle * p, Key * warningsKey)
{
size_t filenameSize = sizeof (KDB_DB_SYSTEM) + strlen (p->path) + sizeof ("/") + 1;
if (KDB_DB_SYSTEM[0] == '~')
{
const char * oldPath = p->path;
char * path = elektraMalloc (filenameSize);
strcpy (path, KDB_DB_SYSTEM);
strcat (path, "/");
strcat (path, p->path);
p->path = path;
elektraResolvePasswdHome (p, warningsKey);
elektraFree (path);
p->path = oldPath;
}
else
{
p->filename = elektraMalloc (filenameSize);
strcpy (p->filename, KDB_DB_SYSTEM);
strcat (p->filename, "/");
strcat (p->filename, p->path);
}
elektraResolveFinishByFilename (p);
return 1;
}
static int elektraResolveSystemBuildin(resolverHandle *p)
{
size_t filenameSize = sizeof(KDB_DB_SYSTEM)
+ strlen(p->path) + sizeof("/") + 1;
p->filename = elektraMalloc (filenameSize);
strcpy (p->filename, KDB_DB_SYSTEM);
strcat (p->filename, "/");
strcat (p->filename, p->path);
elektraResolveFinishByFilename(p);
return 1;
}
static void elektraResolveFinishByDirname (ElektraResolved * handle, ElektraResolveTempfile tmpDir)
{
size_t filenameSize = elektraStrLen (handle->relPath) + elektraStrLen (handle->dirname);
char * filename = elektraMalloc (filenameSize);
strcpy (filename, handle->dirname);
if (handle->relPath[0] != '/')
{
strcat (filename, "/");
}
strcat (filename, handle->relPath);
elektraFree (handle->dirname);
handle->fullPath = filename;
elektraResolveFinishByFilename (handle, tmpDir);
}
