mirror of https://github.com/vmware/tdnf.git
Remove glib dependency from tdnf.
Change-Id: I51ed0e224c54c2a3eff57b8c54af7204db2ef26e
This commit is contained in:
parent
ff092063d6
commit
f25379c61e
|
@ -1,7 +1,6 @@
|
|||
lib_LTLIBRARIES = libtdnfclient.la
|
||||
libtdnfclient_la_CPPFLAGS = -I$(top_srcdir)/include
|
||||
|
||||
AM_CFLAGS += $(GLIB_CFLAGS)
|
||||
AM_CFLAGS += $(LIBCURL_CFLAGS)
|
||||
|
||||
libtdnfclient_la_SOURCES = \
|
||||
|
@ -26,7 +25,6 @@ libtdnfclient_la_SOURCES = \
|
|||
|
||||
libtdnfclient_la_LIBADD = \
|
||||
$(top_builddir)/common/libcommon.la \
|
||||
@GLIB_LIBS@ \
|
||||
@LIBCURL_LIBS@ \
|
||||
-lhawkey \
|
||||
-lrpm
|
||||
|
|
51
client/api.c
51
client/api.c
|
@ -134,12 +134,14 @@ TDNFCheckLocalPackages(
|
|||
uint32_t dwError = 0;
|
||||
int i = 0;
|
||||
char* pszRPMPath = NULL;
|
||||
const char* pszFile = NULL;
|
||||
GDir* pDir = NULL;
|
||||
DIR *pDir = NULL;
|
||||
struct dirent *pEnt = NULL;
|
||||
HySack hSack = NULL;
|
||||
HyPackage hPkg = NULL;
|
||||
HyGoal hGoal = NULL;
|
||||
HyPackageList hPkgList = NULL;
|
||||
int nLen = 0;
|
||||
int nLenRpmExt = 0;
|
||||
|
||||
if(!pTdnf || !pszLocalPath)
|
||||
{
|
||||
|
@ -147,8 +149,8 @@ TDNFCheckLocalPackages(
|
|||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pDir = g_dir_open(pszLocalPath, 0, NULL);
|
||||
if(!pDir)
|
||||
pDir = opendir(pszLocalPath);
|
||||
if(pDir == NULL)
|
||||
{
|
||||
dwError = errno;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
|
@ -170,25 +172,34 @@ TDNFCheckLocalPackages(
|
|||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
while ((pszFile = g_dir_read_name (pDir)) != NULL)
|
||||
while ((pEnt = readdir (pDir)) != NULL )
|
||||
{
|
||||
if (!g_str_has_suffix (pszFile, TDNF_RPM_EXT))
|
||||
nLenRpmExt = strlen(TDNF_RPM_EXT);
|
||||
nLen = strlen(pEnt->d_name);
|
||||
if (nLen <= nLenRpmExt ||
|
||||
strcmp(pEnt->d_name + nLen - nLenRpmExt, TDNF_RPM_EXT))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
pszRPMPath = g_build_filename(pszLocalPath, pszFile, NULL);
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRPMPath,
|
||||
"%s/%s",
|
||||
pszLocalPath,
|
||||
pEnt->d_name);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
hPkg = hy_sack_add_cmdline_package(hSack, pszRPMPath);
|
||||
|
||||
if(!hPkg)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
hy_packagelist_push(hPkgList, hPkg);
|
||||
hPkg = NULL;
|
||||
|
||||
g_free(pszRPMPath);
|
||||
TDNF_SAFE_FREE_MEMORY(pszRPMPath);
|
||||
pszRPMPath = NULL;
|
||||
printf ("%s\n", pEnt->d_name);
|
||||
}
|
||||
|
||||
fprintf(stdout, "Found %d packages\n", hy_packagelist_count(hPkgList));
|
||||
|
@ -216,24 +227,21 @@ TDNFCheckLocalPackages(
|
|||
cleanup:
|
||||
if(pDir)
|
||||
{
|
||||
g_dir_close(pDir);
|
||||
}
|
||||
if(pszRPMPath)
|
||||
{
|
||||
g_free(pszRPMPath);
|
||||
closedir(pDir);
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszRPMPath);
|
||||
if(hGoal)
|
||||
{
|
||||
hy_goal_free(hGoal);
|
||||
}
|
||||
}
|
||||
if(hPkgList)
|
||||
{
|
||||
hy_packagelist_free(hPkgList);
|
||||
}
|
||||
}
|
||||
if(hSack)
|
||||
{
|
||||
hy_sack_free(hSack);
|
||||
}
|
||||
}
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
|
@ -310,9 +318,9 @@ TDNFClean(
|
|||
}
|
||||
|
||||
dwError = TDNFAllocateMemory(
|
||||
1,
|
||||
sizeof(TDNF_CLEAN_INFO),
|
||||
(void**)&pCleanInfo);
|
||||
1,
|
||||
sizeof(TDNF_CLEAN_INFO),
|
||||
(void**)&pCleanInfo);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFCopyEnabledRepos(pTdnf->pRepos, &pCleanInfo->ppszReposUsed);
|
||||
|
@ -586,7 +594,8 @@ TDNFOpenHandle(
|
|||
dwError = TDNFCloneCmdArgs(pArgs, &pTdnf->pArgs);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadConfig(pTdnf,
|
||||
dwError = TDNFReadConfig(
|
||||
pTdnf,
|
||||
pTdnf->pArgs->pszConfFile,
|
||||
TDNF_CONF_GROUP);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
|
341
client/config.c
341
client/config.c
|
@ -36,142 +36,96 @@ TDNFConfGetRpmVerbosity(
|
|||
uint32_t
|
||||
TDNFReadConfig(
|
||||
PTDNF pTdnf,
|
||||
char* pszFile,
|
||||
char* pszGroup
|
||||
const char* pszConfFile,
|
||||
const char* pszGroup
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
|
||||
GKeyFile* pKeyFile = NULL;
|
||||
|
||||
PTDNF_CONF pConf = NULL;
|
||||
PCONF_DATA pData = NULL;
|
||||
PCONF_SECTION pSection = NULL;
|
||||
|
||||
if(!pTdnf ||
|
||||
IsNullOrEmptyString(pszFile) ||
|
||||
IsNullOrEmptyString(pszConfFile) ||
|
||||
IsNullOrEmptyString(pszGroup))
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pKeyFile = g_key_file_new();
|
||||
if(!pKeyFile)
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = TDNFReadConfigFile(pszConfFile, 0, &pData);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(!g_key_file_load_from_file(
|
||||
pKeyFile,
|
||||
pszFile,
|
||||
G_KEY_FILE_KEEP_COMMENTS,
|
||||
NULL))
|
||||
{
|
||||
dwError = ERROR_TDNF_CONF_FILE_LOAD;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
if(g_key_file_has_group(pKeyFile, pszGroup))
|
||||
{
|
||||
dwError = TDNFAllocateMemory(
|
||||
1,
|
||||
sizeof(TDNF_CONF),
|
||||
(void**)&pConf);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
dwError = TDNFAllocateMemory(
|
||||
1,
|
||||
sizeof(TDNF_CONF),
|
||||
(void**)&pConf);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(g_key_file_has_key(pKeyFile, pszGroup, TDNF_CONF_KEY_GPGCHECK, NULL))
|
||||
{
|
||||
if(g_key_file_get_boolean(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_GPGCHECK,
|
||||
NULL))
|
||||
{
|
||||
pConf->nGPGCheck=1;
|
||||
}
|
||||
}
|
||||
if(g_key_file_has_key(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_INSTALLONLY_LIMIT,
|
||||
NULL))
|
||||
{
|
||||
pConf->nInstallOnlyLimit = g_key_file_get_integer(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_INSTALLONLY_LIMIT,
|
||||
NULL);
|
||||
}
|
||||
if(g_key_file_has_key(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_CLEAN_REQ_ON_REMOVE,
|
||||
NULL))
|
||||
{
|
||||
pConf->nCleanRequirementsOnRemove =
|
||||
g_key_file_get_boolean(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_CLEAN_REQ_ON_REMOVE,
|
||||
NULL);
|
||||
}
|
||||
if(g_key_file_has_key(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_KEEP_CACHE,
|
||||
NULL))
|
||||
{
|
||||
pConf->nKeepCache =
|
||||
g_key_file_get_boolean(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_KEEP_CACHE,
|
||||
NULL);
|
||||
}
|
||||
dwError = TDNFReadKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_REPODIR,
|
||||
TDNF_DEFAULT_REPO_LOCATION,
|
||||
&pConf->pszRepoDir);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
dwError = TDNFConfigGetSection(pData, pszGroup, &pSection);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_CACHEDIR,
|
||||
TDNF_DEFAULT_CACHE_LOCATION,
|
||||
&pConf->pszCacheDir);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
dwError = TDNFReadKeyValueInt(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_INSTALLONLY_LIMIT,
|
||||
1,
|
||||
&pConf->nInstallOnlyLimit);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
TDNF_CONF_KEY_DISTROVERPKG,
|
||||
TDNF_DEFAULT_DISTROVERPKG,
|
||||
&pConf->pszDistroVerPkg);
|
||||
if(dwError == ERROR_TDNF_NO_DATA)
|
||||
{
|
||||
dwError = TDNFAllocateString(
|
||||
TDNF_DEFAULT_DISTROVERPKG,
|
||||
&pConf->pszDistroVerPkg);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
dwError = TDNFReadKeyValueBoolean(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_CLEAN_REQ_ON_REMOVE,
|
||||
0,
|
||||
&pConf->nCleanRequirementsOnRemove);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFConfigReadProxySettings(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
pConf);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
dwError = TDNFReadKeyValueBoolean(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_GPGCHECK,
|
||||
0,
|
||||
&pConf->nGPGCheck);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadKeyValueBoolean(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_KEEP_CACHE,
|
||||
0,
|
||||
&pConf->nKeepCache);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_REPODIR,
|
||||
TDNF_DEFAULT_REPO_LOCATION,
|
||||
&pConf->pszRepoDir);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_CACHEDIR,
|
||||
TDNF_DEFAULT_CACHE_LOCATION,
|
||||
&pConf->pszCacheDir);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSection,
|
||||
TDNF_CONF_KEY_DISTROVERPKG,
|
||||
TDNF_DEFAULT_DISTROVERPKG,
|
||||
&pConf->pszDistroVerPkg);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFConfigReadProxySettings(
|
||||
pSection,
|
||||
pConf);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
}
|
||||
|
||||
pTdnf->pConf = pConf;
|
||||
|
||||
cleanup:
|
||||
if(pKeyFile)
|
||||
if(pData)
|
||||
{
|
||||
g_key_file_free(pKeyFile);
|
||||
TDNFFreeConfigData(pData);
|
||||
}
|
||||
return dwError;
|
||||
|
||||
|
@ -236,15 +190,14 @@ error:
|
|||
|
||||
uint32_t
|
||||
TDNFConfigReadProxySettings(
|
||||
GKeyFile* pKeyFile,
|
||||
char* pszGroup,
|
||||
PCONF_SECTION pSection,
|
||||
PTDNF_CONF pConf)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszProxyUser = NULL;
|
||||
char* pszProxyPass = NULL;
|
||||
|
||||
if(!pKeyFile || !pszGroup || !pConf)
|
||||
if(!pSection || !pConf)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
@ -252,8 +205,7 @@ TDNFConfigReadProxySettings(
|
|||
|
||||
//optional proxy server
|
||||
dwError = TDNFReadKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
pSection,
|
||||
TDNF_CONF_KEY_PROXY,
|
||||
NULL,
|
||||
&pConf->pszProxy);
|
||||
|
@ -267,8 +219,7 @@ TDNFConfigReadProxySettings(
|
|||
{
|
||||
//optional proxy user
|
||||
dwError = TDNFReadKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
pSection,
|
||||
TDNF_CONF_KEY_PROXY_USER,
|
||||
NULL,
|
||||
&pszProxyUser);
|
||||
|
@ -280,8 +231,7 @@ TDNFConfigReadProxySettings(
|
|||
|
||||
//optional proxy pass
|
||||
dwError = TDNFReadKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
pSection,
|
||||
TDNF_CONF_KEY_PROXY_PASS,
|
||||
NULL,
|
||||
&pszProxyPass);
|
||||
|
@ -311,59 +261,154 @@ error:
|
|||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFReadKeyValueBoolean(
|
||||
PCONF_SECTION pSection,
|
||||
const char* pszKeyName,
|
||||
int nDefault,
|
||||
int* pnValue
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszValue = NULL;
|
||||
int nValue = 0;
|
||||
|
||||
if(!pSection || !pszKeyName || !pnValue)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSection,
|
||||
pszKeyName,
|
||||
NULL,
|
||||
&pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(pszValue)
|
||||
{
|
||||
if(!strcmp(pszValue, "1") || !strcasecmp(pszValue, "true"))
|
||||
{
|
||||
nValue = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nValue = nDefault;
|
||||
}
|
||||
|
||||
*pnValue = nValue;
|
||||
|
||||
cleanup:
|
||||
TDNF_SAFE_FREE_MEMORY(pszValue);
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(pnValue)
|
||||
{
|
||||
*pnValue = 0;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFReadKeyValueInt(
|
||||
PCONF_SECTION pSection,
|
||||
const char* pszKeyName,
|
||||
int nDefault,
|
||||
int* pnValue
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszValue = NULL;
|
||||
int nValue = 0;
|
||||
|
||||
if(!pSection || !pszKeyName || !pnValue)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSection,
|
||||
pszKeyName,
|
||||
NULL,
|
||||
&pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(pszValue)
|
||||
{
|
||||
|
||||
nValue = atoi(pszValue);
|
||||
}
|
||||
else
|
||||
{
|
||||
nValue = nDefault;
|
||||
}
|
||||
|
||||
*pnValue = nValue;
|
||||
|
||||
cleanup:
|
||||
TDNF_SAFE_FREE_MEMORY(pszValue);
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(pnValue)
|
||||
{
|
||||
*pnValue = 0;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFReadKeyValue(
|
||||
GKeyFile* pKeyFile,
|
||||
char* pszGroupName,
|
||||
char* pszKeyName,
|
||||
char* pszDefault,
|
||||
PCONF_SECTION pSection,
|
||||
const char* pszKeyName,
|
||||
const char* pszDefault,
|
||||
char** ppszValue
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszVal = NULL;
|
||||
char* pszValue = NULL;
|
||||
PKEYVALUE pKeyValues = NULL;
|
||||
|
||||
if(!pKeyFile || !pszGroupName || !pszKeyName || !ppszValue)
|
||||
if(!pSection || !pszKeyName || !ppszValue)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
if(!g_key_file_has_key(pKeyFile, pszGroupName, pszKeyName, NULL))
|
||||
pKeyValues = pSection->pKeyValues;
|
||||
for(; pKeyValues; pKeyValues = pKeyValues->pNext)
|
||||
{
|
||||
dwError = ERROR_TDNF_NO_DATA;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
pszVal = g_key_file_get_string(
|
||||
pKeyFile,
|
||||
pszGroupName,
|
||||
pszKeyName,
|
||||
NULL);
|
||||
if(!pszVal && pszDefault)
|
||||
{
|
||||
pszVal = g_strdup(pszDefault);
|
||||
if(!pszVal)
|
||||
if(strcmp(pszKeyName, pKeyValues->pszKey) == 0)
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
dwError = TDNFAllocateString(pKeyValues->pszValue, &pszVal);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!pszVal)
|
||||
|
||||
if(pszVal)
|
||||
{
|
||||
dwError = ERROR_TDNF_NO_DATA;
|
||||
dwError = TDNFAllocateString(
|
||||
pszVal,
|
||||
&pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
else if(pszDefault)
|
||||
{
|
||||
dwError = TDNFAllocateString(
|
||||
pszDefault,
|
||||
&pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFAllocateString(
|
||||
pszVal,
|
||||
&pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
*ppszValue = pszValue;
|
||||
|
||||
cleanup:
|
||||
g_free(pszVal);
|
||||
TDNF_SAFE_FREE_MEMORY(pszVal);
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
|
|
|
@ -50,6 +50,103 @@ error:
|
|||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t TDNFParseScheme(
|
||||
const char* pszKeyUrl,
|
||||
char** ppszScheme)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszScheme = NULL;
|
||||
const char* pszTmpStr = NULL;
|
||||
int nLen = 0;
|
||||
int i = 0;
|
||||
if(IsNullOrEmptyString(pszKeyUrl) || !ppszScheme)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
pszTmpStr = strchr(pszKeyUrl, ':');
|
||||
if(pszTmpStr == NULL)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
nLen = pszTmpStr - pszKeyUrl;
|
||||
dwError = TDNFAllocateMemory(
|
||||
nLen + 1,
|
||||
sizeof(char),
|
||||
(void**)&pszScheme);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
for(i = 0; i < nLen; i ++)
|
||||
{
|
||||
pszScheme[i] = pszKeyUrl[i];
|
||||
}
|
||||
*ppszScheme = pszScheme;
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(ppszScheme)
|
||||
{
|
||||
*ppszScheme = NULL;
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszScheme);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t FileNameFromUri(
|
||||
const char* pszKeyUrl,
|
||||
char** ppszFile)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
const char* pszPath = NULL;
|
||||
const char* pszFilePrefix = "file://";
|
||||
char *pszFile = NULL;
|
||||
|
||||
if(strncmp(pszKeyUrl, pszFilePrefix, strlen(pszFilePrefix)) != 0)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
pszPath = pszKeyUrl + strlen(pszFilePrefix);
|
||||
|
||||
if(!pszPath || *pszPath == '\0')
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
if (strchr (pszPath, '#') != NULL)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
if(*pszPath != '/')
|
||||
{
|
||||
//skip hostname in the uri.
|
||||
pszPath = strchr (pszPath, '/');
|
||||
if(pszPath == NULL)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
}
|
||||
dwError = TDNFAllocateString(pszPath, &pszFile);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
*ppszFile = pszFile;
|
||||
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
TDNF_SAFE_FREE_MEMORY(pszFile);
|
||||
if(ppszFile)
|
||||
{
|
||||
*ppszFile = NULL;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
ReadGPGKey(
|
||||
const char* pszKeyUrl,
|
||||
|
@ -57,35 +154,27 @@ ReadGPGKey(
|
|||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
gchar* pszScheme = NULL;
|
||||
gchar* pszFile = NULL;
|
||||
char* pszKeyData = NULL;
|
||||
int nPathIsDir = 0;
|
||||
char* pszScheme = NULL;
|
||||
char* pszFile = NULL;
|
||||
|
||||
if(IsNullOrEmptyString(pszKeyUrl) || !ppszKeyData)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pszScheme = g_uri_parse_scheme(pszKeyUrl);
|
||||
if(!pszScheme)
|
||||
{
|
||||
dwError = ERROR_TDNF_KEYURL_INVALID;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
dwError = TDNFParseScheme(pszKeyUrl, &pszScheme);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
if(strcasecmp("file", pszScheme))
|
||||
{
|
||||
dwError = ERROR_TDNF_KEYURL_UNSUPPORTED;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pszFile = g_filename_from_uri(pszKeyUrl, NULL, NULL);
|
||||
if(!pszFile)
|
||||
{
|
||||
dwError = ERROR_TDNF_KEYURL_INVALID;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = FileNameFromUri(pszKeyUrl, &pszFile);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFIsDir(pszFile, &nPathIsDir);
|
||||
if(dwError)
|
||||
|
@ -103,26 +192,17 @@ ReadGPGKey(
|
|||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
if(g_file_get_contents(pszFile, &pszKeyData, NULL, NULL) != TRUE)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PUBKEY_FILE;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
dwError = TDNFFileReadAllText(pszFile, &pszKeyData);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
*ppszKeyData = pszKeyData;
|
||||
|
||||
cleanup:
|
||||
if(pszScheme)
|
||||
{
|
||||
g_free(pszScheme);
|
||||
}
|
||||
if(pszFile)
|
||||
{
|
||||
g_free(pszFile);
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszScheme);
|
||||
TDNF_SAFE_FREE_MEMORY(pszFile);
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
TDNF_SAFE_FREE_MEMORY(pszKeyData);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
|
|
|
@ -33,9 +33,10 @@
|
|||
#include <libgen.h>
|
||||
//
|
||||
#include <sys/utsname.h>
|
||||
//glib
|
||||
#include <glib.h>
|
||||
#include <glib/gstdio.h>
|
||||
|
||||
#include <dirent.h>
|
||||
#include <pthread.h>
|
||||
|
||||
//hawkey
|
||||
#include <hawkey/advisory.h>
|
||||
#include <hawkey/advisorypkg.h>
|
||||
|
@ -75,5 +76,7 @@
|
|||
|
||||
#include "defines.h"
|
||||
#include "structs.h"
|
||||
#include "prototypes.h"
|
||||
#include "../common/structs.h"
|
||||
#include "../common/prototypes.h"
|
||||
#include "prototypes.h"
|
||||
|
||||
|
|
|
@ -145,24 +145,6 @@ TDNFRepoRemoveCache(
|
|||
const char* pszRepoId
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFRepoGetKeyValue(
|
||||
GKeyFile* pKeyFile,
|
||||
const char* pszGroup,
|
||||
const char* pszKeyName,
|
||||
const char* pszDefault,
|
||||
char** ppszValue
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFRepoGetKeyValueBoolean(
|
||||
GKeyFile* pKeyFile,
|
||||
const char* pszGroup,
|
||||
const char* pszKeyName,
|
||||
int nDefault,
|
||||
int* pnValue
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFRepoApplyProxySettings(
|
||||
PTDNF_CONF pConf,
|
||||
|
@ -362,20 +344,36 @@ TDNFConfGetValue(
|
|||
TDNF_CONF_TYPE nType,
|
||||
char** ppszValue
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFReadKeyValue(
|
||||
GKeyFile* pKeyFile,
|
||||
char* pszGroupName,
|
||||
char* pszKeyName,
|
||||
char* pszDefault,
|
||||
PCONF_SECTION pSection,
|
||||
const char* pszKeyName,
|
||||
const char* pszDefault,
|
||||
char** ppszValue
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFReadKeyValueBoolean(
|
||||
PCONF_SECTION pSection,
|
||||
const char* pszKeyName,
|
||||
int nDefault,
|
||||
int* pnValue
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFReadKeyValueInt(
|
||||
PCONF_SECTION pSection,
|
||||
const char* pszKeyName,
|
||||
int nDefault,
|
||||
int* pnValue
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFReadConfig(
|
||||
PTDNF pTdnf,
|
||||
char* pszConfFile,
|
||||
char* pszConfGroup
|
||||
const char* pszConfFile,
|
||||
const char* pszConfGroup
|
||||
);
|
||||
|
||||
uint32_t
|
||||
|
@ -385,8 +383,7 @@ TDNFConfigExpandVars(
|
|||
|
||||
uint32_t
|
||||
TDNFConfigReadProxySettings(
|
||||
GKeyFile* pKeyFile,
|
||||
char* pszGroup,
|
||||
PCONF_SECTION pSection,
|
||||
PTDNF_CONF pConf);
|
||||
|
||||
void
|
||||
|
@ -675,12 +672,12 @@ TDNFRunTransaction(
|
|||
|
||||
uint32_t
|
||||
TDNFRemoveCachedRpms(
|
||||
GArray* pCachedRpmsArray
|
||||
PTDNF_CACHED_RPM_LIST pCachedRpmsList
|
||||
);
|
||||
|
||||
void
|
||||
TDNFFreeCachedRpmsArray(
|
||||
GArray* pArray
|
||||
PTDNF_CACHED_RPM_LIST pArray
|
||||
);
|
||||
|
||||
//memory.c
|
||||
|
|
|
@ -44,27 +44,19 @@ TDNFInitRepo(
|
|||
|
||||
pConf = pTdnf->pConf;
|
||||
|
||||
pszRepoCacheDir = g_build_path(
|
||||
G_DIR_SEPARATOR_S,
|
||||
pConf->pszCacheDir,
|
||||
pRepoData->pszId,
|
||||
NULL);
|
||||
if(!pszRepoCacheDir)
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRepoCacheDir,
|
||||
"%s/%s",
|
||||
pConf->pszCacheDir,
|
||||
pRepoData->pszId);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
pszRepoDataDir = g_build_path(
|
||||
G_DIR_SEPARATOR_S,
|
||||
pszRepoCacheDir,
|
||||
TDNF_REPODATA_DIR_NAME,
|
||||
NULL);
|
||||
if(!pszRepoDataDir)
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRepoDataDir,
|
||||
"%s/%s",
|
||||
pszRepoCacheDir,
|
||||
TDNF_REPODATA_DIR_NAME);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFGetRepoMD(pTdnf,
|
||||
pRepoData,
|
||||
|
@ -98,14 +90,8 @@ TDNFInitRepo(
|
|||
cleanup:
|
||||
TDNFFreeRepoMetadata(pRepoMD);
|
||||
TDNF_SAFE_FREE_MEMORY(pszLastRefreshMarker);
|
||||
if(pszRepoDataDir)
|
||||
{
|
||||
g_free(pszRepoDataDir);
|
||||
}
|
||||
if(pszRepoCacheDir)
|
||||
{
|
||||
g_free(pszRepoCacheDir);
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszRepoDataDir);
|
||||
TDNF_SAFE_FREE_MEMORY(pszRepoCacheDir);
|
||||
|
||||
return dwError;
|
||||
|
||||
|
|
|
@ -30,14 +30,14 @@ TDNFLoadRepoData(
|
|||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszRepoFilePath = NULL;
|
||||
const char* pszFile = NULL;
|
||||
|
||||
PTDNF_REPO_DATA pReposAll = NULL;
|
||||
PTDNF_REPO_DATA pReposTemp = NULL;
|
||||
PTDNF_REPO_DATA pReposTemp = NULL;
|
||||
PTDNF_REPO_DATA pRepos = NULL;
|
||||
PTDNF_CONF pConf = NULL;
|
||||
|
||||
GDir* pDir = NULL;
|
||||
DIR *pDir = NULL;
|
||||
struct dirent *pEnt = NULL;
|
||||
int nLen = 0;
|
||||
int nLenRepoExt = 0;
|
||||
|
||||
if(!pTdnf || !pTdnf->pConf || !ppReposAll)
|
||||
{
|
||||
|
@ -46,25 +46,34 @@ TDNFLoadRepoData(
|
|||
}
|
||||
pConf = pTdnf->pConf;
|
||||
|
||||
pDir = g_dir_open(pConf->pszRepoDir, 0, NULL);
|
||||
if(!pDir)
|
||||
pDir = opendir(pConf->pszRepoDir);
|
||||
if(pDir == NULL)
|
||||
{
|
||||
dwError = ERROR_TDNF_REPO_DIR_OPEN;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
while ((pszFile = g_dir_read_name (pDir)) != NULL)
|
||||
while ((pEnt = readdir (pDir)) != NULL )
|
||||
{
|
||||
if (!g_str_has_suffix (pszFile, TDNF_REPO_EXT))
|
||||
nLen = strlen(pEnt->d_name);
|
||||
nLenRepoExt = strlen(TDNF_REPO_EXT);
|
||||
if (nLen <= nLenRepoExt ||
|
||||
strcmp(pEnt->d_name + nLen - nLenRepoExt, TDNF_REPO_EXT))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
pszRepoFilePath = g_build_filename(pConf->pszRepoDir, pszFile, NULL);
|
||||
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRepoFilePath,
|
||||
"%s/%s",
|
||||
pConf->pszRepoDir,
|
||||
pEnt->d_name);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFLoadReposFromFile(pTdnf, pszRepoFilePath, &pRepos);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
g_free(pszRepoFilePath);
|
||||
TDNF_SAFE_FREE_MEMORY(pszRepoFilePath);
|
||||
pszRepoFilePath = NULL;
|
||||
|
||||
//Apply filter
|
||||
|
@ -96,14 +105,11 @@ TDNFLoadRepoData(
|
|||
cleanup:
|
||||
if(pDir)
|
||||
{
|
||||
g_dir_close(pDir);
|
||||
closedir(pDir);
|
||||
}
|
||||
if(pszRepoFilePath)
|
||||
{
|
||||
g_free(pszRepoFilePath);
|
||||
}
|
||||
return dwError;
|
||||
TDNF_SAFE_FREE_MEMORY(pszRepoFilePath);
|
||||
|
||||
return dwError;
|
||||
error:
|
||||
if(ppReposAll)
|
||||
{
|
||||
|
@ -124,139 +130,102 @@ TDNFLoadReposFromFile(
|
|||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
int i = 0;
|
||||
|
||||
GKeyFile* pKeyFile = NULL;
|
||||
char** ppszRepos = NULL;
|
||||
char* pszRepo = NULL;
|
||||
char* pszValue = NULL;
|
||||
char* pszMetadataExpire = NULL;
|
||||
|
||||
PTDNF_REPO_DATA pRepos = NULL;
|
||||
PTDNF_REPO_DATA pRepo = NULL;
|
||||
|
||||
pKeyFile = g_key_file_new();
|
||||
if(!pKeyFile)
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
PCONF_DATA pData = NULL;
|
||||
PCONF_SECTION pSections = NULL;
|
||||
|
||||
if(!g_key_file_load_from_file(
|
||||
pKeyFile,
|
||||
pszRepoFile,
|
||||
G_KEY_FILE_KEEP_COMMENTS,
|
||||
NULL))
|
||||
dwError = TDNFReadConfigFile(pszRepoFile, 0, &pData);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
pSections = pData->pSections;
|
||||
for(; pSections; pSections = pSections->pNext)
|
||||
{
|
||||
dwError = ERROR_TDNF_REPO_FILE_LOAD;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
ppszRepos = g_key_file_get_groups (pKeyFile, NULL);
|
||||
if(!ppszRepos)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_REPO_FILE;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
while(ppszRepos[i])
|
||||
{
|
||||
pszRepo = ppszRepos[i];
|
||||
pszRepo = pSections->pszName;
|
||||
|
||||
dwError = TDNFAllocateMemory(1, sizeof(TDNF_REPO_DATA), (void**)&pRepo);
|
||||
dwError = TDNFAllocateMemory(
|
||||
1,
|
||||
sizeof(TDNF_REPO_DATA),
|
||||
(void**)&pRepo);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFAllocateString(pszRepo, &pRepo->pszId);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValueBoolean(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValueBoolean(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_ENABLED,
|
||||
0,
|
||||
&pRepo->nEnabled);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_NAME,
|
||||
NULL,
|
||||
&pRepo->pszName);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_BASEURL,
|
||||
NULL,
|
||||
&pRepo->pszBaseUrl);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_METALINK,
|
||||
NULL,
|
||||
&pRepo->pszMetaLink);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValueBoolean(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValueBoolean(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_SKIP,
|
||||
1,
|
||||
&pRepo->nSkipIfUnavailable);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValueBoolean(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValueBoolean(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_GPGCHECK,
|
||||
1,
|
||||
&pRepo->nGPGCheck);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_GPGKEY,
|
||||
NULL,
|
||||
&pRepo->pszUrlGPGKey);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_USERNAME,
|
||||
NULL,
|
||||
&pRepo->pszUser);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_PASSWORD,
|
||||
NULL,
|
||||
&pRepo->pszPass);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszRepo,
|
||||
dwError = TDNFReadKeyValue(
|
||||
pSections,
|
||||
TDNF_REPO_KEY_METADATA_EXPIRE,
|
||||
NULL,
|
||||
TDNF_REPO_DEFAULT_METADATA_EXPIRE,
|
||||
&pszMetadataExpire);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
//Set
|
||||
if(IsNullOrEmptyString(pszMetadataExpire))
|
||||
{
|
||||
TDNF_SAFE_FREE_MEMORY(pszMetadataExpire);
|
||||
dwError = TDNFAllocateString(
|
||||
TDNF_REPO_DEFAULT_METADATA_EXPIRE,
|
||||
&pszMetadataExpire);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
dwError = TDNFParseMetadataExpire(
|
||||
pszMetadataExpire,
|
||||
&pRepo->lMetadataExpire);
|
||||
|
@ -268,17 +237,14 @@ TDNFLoadReposFromFile(
|
|||
pRepo->pNext = pRepos;
|
||||
pRepos = pRepo;
|
||||
pRepo = NULL;
|
||||
i++;
|
||||
}
|
||||
|
||||
*ppRepos = pRepos;
|
||||
cleanup:
|
||||
if(pKeyFile)
|
||||
if(pData)
|
||||
{
|
||||
g_key_file_free(pKeyFile);
|
||||
TDNFFreeConfigData(pData);
|
||||
}
|
||||
g_free(pszValue);
|
||||
g_strfreev(ppszRepos);
|
||||
TDNF_SAFE_FREE_MEMORY(pszMetadataExpire);
|
||||
return dwError;
|
||||
|
||||
|
|
|
@ -171,12 +171,14 @@ TDNFRepoGetRpmCacheDir(
|
|||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pszRpmCacheDir = g_build_path(
|
||||
G_DIR_SEPARATOR_S,
|
||||
pTdnf->pConf->pszCacheDir,
|
||||
pszRepoId,
|
||||
TDNF_RPM_CACHE_DIR_NAME,
|
||||
NULL);
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRpmCacheDir,
|
||||
"%s/%s/%s",
|
||||
pTdnf->pConf->pszCacheDir,
|
||||
pszRepoId,
|
||||
TDNF_RPM_CACHE_DIR_NAME);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(access(pszRpmCacheDir, F_OK))
|
||||
{
|
||||
dwError = errno;
|
||||
|
@ -201,9 +203,9 @@ TDNFRepoRemoveCache(
|
|||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszRepoCacheDir = NULL;
|
||||
const char* pszFile = NULL;
|
||||
char* pszFilePath = NULL;
|
||||
GDir* pDir = NULL;
|
||||
DIR *pDir = NULL;
|
||||
struct dirent *pEnt = NULL;
|
||||
|
||||
if(!pTdnf || !pTdnf->pConf || IsNullOrEmptyString(pszRepoId))
|
||||
{
|
||||
|
@ -211,28 +213,29 @@ TDNFRepoRemoveCache(
|
|||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pszRepoCacheDir = g_build_path(
|
||||
G_DIR_SEPARATOR_S,
|
||||
pTdnf->pConf->pszCacheDir,
|
||||
pszRepoId,
|
||||
TDNF_REPODATA_DIR_NAME,
|
||||
NULL);
|
||||
if(access(pszRepoCacheDir, F_OK))
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRepoCacheDir,
|
||||
"%s/%s/%s",
|
||||
pTdnf->pConf->pszCacheDir,
|
||||
pszRepoId,
|
||||
TDNF_REPODATA_DIR_NAME);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
pDir = opendir(pszRepoCacheDir);
|
||||
if(pDir == NULL)
|
||||
{
|
||||
dwError = errno;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
pDir = g_dir_open(pszRepoCacheDir, 0, NULL);
|
||||
if(!pDir)
|
||||
while ((pEnt = readdir (pDir)) != NULL )
|
||||
{
|
||||
dwError = ERROR_TDNF_REPO_DIR_OPEN;
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszFilePath,
|
||||
"%s/%s",
|
||||
pszRepoCacheDir,
|
||||
pEnt->d_name);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
while ((pszFile = g_dir_read_name (pDir)) != NULL)
|
||||
{
|
||||
pszFilePath = g_build_filename(pszRepoCacheDir, pszFile, NULL);
|
||||
if(pszFilePath)
|
||||
{
|
||||
if(unlink(pszFilePath))
|
||||
|
@ -240,8 +243,7 @@ TDNFRepoRemoveCache(
|
|||
dwError = errno;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
g_free(pszFilePath);
|
||||
TDNF_SAFE_FREE_MEMORY(pszFilePath);
|
||||
pszFilePath = NULL;
|
||||
}
|
||||
else
|
||||
|
@ -257,17 +259,11 @@ TDNFRepoRemoveCache(
|
|||
}
|
||||
|
||||
cleanup:
|
||||
if(pszFilePath)
|
||||
{
|
||||
g_free(pszFilePath);
|
||||
}
|
||||
if(pszRepoCacheDir)
|
||||
{
|
||||
g_free(pszRepoCacheDir);
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszFilePath);
|
||||
TDNF_SAFE_FREE_MEMORY(pszRepoCacheDir);
|
||||
if(pDir)
|
||||
{
|
||||
g_dir_close(pDir);
|
||||
closedir(pDir);
|
||||
}
|
||||
return dwError;
|
||||
|
||||
|
@ -275,116 +271,6 @@ error:
|
|||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFRepoGetKeyValue(
|
||||
GKeyFile* pKeyFile,
|
||||
const char* pszGroup,
|
||||
const char* pszKeyName,
|
||||
const char* pszDefault,
|
||||
char** ppszValue
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszValue = NULL;
|
||||
char* pszKeyValue = NULL;
|
||||
|
||||
if(!pKeyFile || !pszGroup || !pszKeyName || !ppszValue)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
if(g_key_file_has_key(pKeyFile, pszGroup, pszKeyName, NULL))
|
||||
{
|
||||
pszKeyValue = g_key_file_get_string(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
pszKeyName,
|
||||
NULL);
|
||||
if(pszKeyValue)
|
||||
{
|
||||
dwError = TDNFAllocateString(g_strstrip(pszKeyValue), &pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
g_free(pszKeyValue);
|
||||
pszKeyValue = NULL;
|
||||
}
|
||||
else if(pszDefault)
|
||||
{
|
||||
dwError = TDNFAllocateString(pszDefault, &pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
*ppszValue = pszValue;
|
||||
|
||||
cleanup:
|
||||
if(pszKeyValue)
|
||||
{
|
||||
g_free(pszKeyValue);
|
||||
}
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(ppszValue)
|
||||
{
|
||||
*ppszValue = NULL;
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszValue);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFRepoGetKeyValueBoolean(
|
||||
GKeyFile* pKeyFile,
|
||||
const char* pszGroup,
|
||||
const char* pszKeyName,
|
||||
int nDefault,
|
||||
int* pnValue
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char* pszValue = NULL;
|
||||
int nValue = 0;
|
||||
|
||||
if(!pKeyFile || !pszGroup || !pszKeyName || !pnValue)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
dwError = TDNFRepoGetKeyValue(
|
||||
pKeyFile,
|
||||
pszGroup,
|
||||
pszKeyName,
|
||||
NULL,
|
||||
&pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(pszValue)
|
||||
{
|
||||
if(!strcmp(pszValue, "1") || !strcasecmp(pszValue, "true"))
|
||||
{
|
||||
nValue = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nValue = nDefault;
|
||||
}
|
||||
|
||||
*pnValue = nValue;
|
||||
|
||||
cleanup:
|
||||
TDNF_SAFE_FREE_MEMORY(pszValue);
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(pnValue)
|
||||
{
|
||||
*pnValue = 0;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFRepoApplyProxySettings(
|
||||
PTDNF_CONF pConf,
|
||||
|
|
|
@ -39,7 +39,11 @@ TDNFRpmExecTransaction(
|
|||
|
||||
nKeepCachedRpms = pTdnf->pConf->nKeepCache;
|
||||
|
||||
ts.pCachedRpmsArray = g_array_new(TRUE, TRUE, sizeof(char*));
|
||||
dwError = TDNFAllocateMemory(
|
||||
1,
|
||||
sizeof(TDNF_CACHED_RPM_LIST),
|
||||
(void**)&ts.pCachedRpmsArray);
|
||||
|
||||
if(!ts.pCachedRpmsArray)
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
|
@ -82,7 +86,6 @@ TDNFRpmExecTransaction(
|
|||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
|
||||
dwError = TDNFPopulateTransaction(&ts, pTdnf, pSolvedInfo);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
|
@ -345,34 +348,38 @@ TDNFTransAddInstallPkg(
|
|||
int nGPGCheck = 0;
|
||||
char* pszRpmCacheDir = NULL;
|
||||
char* pszFilePath = NULL;
|
||||
char* pszFilePathCopy = NULL;
|
||||
const char* pszRepoName = NULL;
|
||||
char* pszHyName = NULL;
|
||||
Header rpmHeader = NULL;
|
||||
FD_t fp = NULL;
|
||||
char* pszDownloadCacheDir = NULL;
|
||||
char* pszUrlGPGKey = NULL;
|
||||
PTDNF_CACHED_RPM_ENTRY pRpmCache = NULL;
|
||||
|
||||
pszRepoName = hy_package_get_reponame(hPkg);
|
||||
pszHyName = hy_package_get_location(hPkg);
|
||||
|
||||
pszRpmCacheDir = g_build_filename(
|
||||
G_DIR_SEPARATOR_S,
|
||||
pTdnf->pConf->pszCacheDir,
|
||||
pszRepoName,
|
||||
"rpms",
|
||||
G_DIR_SEPARATOR_S,
|
||||
NULL);
|
||||
pszFilePath = g_build_filename(pszRpmCacheDir, pszHyName, NULL);
|
||||
if(pTS->pCachedRpmsArray)
|
||||
{
|
||||
if(!g_array_append_val(pTS->pCachedRpmsArray, pszFilePath))
|
||||
{
|
||||
dwError = ERROR_TDNF_OUT_OF_MEMORY;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
}
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszRpmCacheDir,
|
||||
"%s/%s/%s",
|
||||
pTdnf->pConf->pszCacheDir,
|
||||
pszRepoName,
|
||||
"rpms");
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
pszDownloadCacheDir = g_path_get_dirname(pszFilePath);
|
||||
dwError = TDNFAllocateStringPrintf(
|
||||
&pszFilePath,
|
||||
"%s/%s",
|
||||
pszRpmCacheDir,
|
||||
pszHyName);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
// dirname() may modify the contents of path, so it may be desirable to
|
||||
// pass a copy when calling this function.
|
||||
dwError = TDNFAllocateString(pszFilePath, &pszFilePathCopy);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
pszDownloadCacheDir = dirname(pszFilePathCopy);
|
||||
if(!pszDownloadCacheDir)
|
||||
{
|
||||
dwError = ENOENT;
|
||||
|
@ -445,20 +452,26 @@ TDNFTransAddInstallPkg(
|
|||
nUpgrade,
|
||||
NULL);
|
||||
BAIL_ON_TDNF_RPM_ERROR(dwError);
|
||||
|
||||
if(pTS->pCachedRpmsArray)
|
||||
{
|
||||
dwError = TDNFAllocateMemory(
|
||||
1,
|
||||
sizeof(TDNF_CACHED_RPM_ENTRY),
|
||||
(void**)&pRpmCache);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
pRpmCache->pszFilePath = pszFilePath;
|
||||
pRpmCache->pNext = pTS->pCachedRpmsArray->pHead;
|
||||
pTS->pCachedRpmsArray->pHead = pRpmCache;
|
||||
}
|
||||
cleanup:
|
||||
TDNF_SAFE_FREE_MEMORY(pszFilePathCopy);
|
||||
TDNF_SAFE_FREE_MEMORY(pszUrlGPGKey);
|
||||
if(pszHyName)
|
||||
{
|
||||
hy_free(pszHyName);
|
||||
}
|
||||
if(pszDownloadCacheDir)
|
||||
{
|
||||
g_free(pszDownloadCacheDir);
|
||||
}
|
||||
if(pszRpmCacheDir)
|
||||
{
|
||||
g_free(pszRpmCacheDir);
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszRpmCacheDir);
|
||||
if(fp)
|
||||
{
|
||||
Fclose(fp);
|
||||
|
@ -467,9 +480,15 @@ cleanup:
|
|||
{
|
||||
headerFree(rpmHeader);
|
||||
}
|
||||
if(!pTS->pCachedRpmsArray && dwError == 0)
|
||||
{
|
||||
TDNF_SAFE_FREE_MEMORY(pszFilePath);
|
||||
}
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
TDNF_SAFE_FREE_MEMORY(pszFilePath);
|
||||
TDNF_SAFE_FREE_MEMORY(pRpmCache);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
|
@ -737,30 +756,29 @@ TDNFRpmCB(
|
|||
|
||||
uint32_t
|
||||
TDNFRemoveCachedRpms(
|
||||
GArray* pCachedRpmsArray
|
||||
PTDNF_CACHED_RPM_LIST pCachedRpmsList
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
uint32_t dwIndex = 0;
|
||||
char* pszCachedRpm = NULL;
|
||||
PTDNF_CACHED_RPM_ENTRY pCur = NULL;
|
||||
|
||||
if(!pCachedRpmsArray)
|
||||
if(!pCachedRpmsList)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
for(dwIndex = 0; dwIndex < pCachedRpmsArray->len; ++dwIndex)
|
||||
pCur = pCachedRpmsList->pHead;
|
||||
while(pCur != NULL)
|
||||
{
|
||||
pszCachedRpm = g_array_index(pCachedRpmsArray, char*, dwIndex);
|
||||
if(!IsNullOrEmptyString(pszCachedRpm))
|
||||
if(!IsNullOrEmptyString(pCur->pszFilePath))
|
||||
{
|
||||
if(unlink(pszCachedRpm))
|
||||
if(unlink(pCur->pszFilePath))
|
||||
{
|
||||
dwError = errno;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
}
|
||||
pCur = pCur->pNext;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
|
@ -768,23 +786,27 @@ cleanup:
|
|||
|
||||
error:
|
||||
goto cleanup;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
TDNFFreeCachedRpmsArray(
|
||||
GArray* pArray
|
||||
PTDNF_CACHED_RPM_LIST pArray
|
||||
)
|
||||
{
|
||||
uint32_t dwIndex = 0;
|
||||
char* pszPath = NULL;
|
||||
PTDNF_CACHED_RPM_ENTRY pCur = NULL;
|
||||
PTDNF_CACHED_RPM_ENTRY pNext = NULL;
|
||||
|
||||
if(pArray)
|
||||
{
|
||||
for(dwIndex = 0; dwIndex < pArray->len; ++dwIndex)
|
||||
pCur = pArray->pHead;
|
||||
while(pCur != NULL)
|
||||
{
|
||||
pszPath = g_array_index(pArray, char*, dwIndex);
|
||||
TDNF_SAFE_FREE_MEMORY(pszPath);
|
||||
pNext = pCur->pNext;
|
||||
TDNF_SAFE_FREE_MEMORY(pCur->pszFilePath);
|
||||
TDNF_SAFE_FREE_MEMORY(pCur);
|
||||
pCur = pNext;
|
||||
}
|
||||
g_array_free(pArray, TRUE);
|
||||
TDNF_SAFE_FREE_MEMORY(pArray);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -29,14 +29,26 @@ typedef struct _TDNF_
|
|||
PTDNF_REPO_DATA pRepos;
|
||||
}TDNF;
|
||||
|
||||
typedef struct _TDNF_CACHED_RPM_ENTRY
|
||||
{
|
||||
char* pszFilePath;
|
||||
struct _TDNF_CACHED_RPM_ENTRY *pNext;
|
||||
}TDNF_CACHED_RPM_ENTRY, *PTDNF_CACHED_RPM_ENTRY;
|
||||
|
||||
typedef struct _TDNF_CACHED_RPM_LIST
|
||||
{
|
||||
int nSize;
|
||||
PTDNF_CACHED_RPM_ENTRY pHead;
|
||||
}TDNF_CACHED_RPM_LIST, *PTDNF_CACHED_RPM_LIST;
|
||||
|
||||
typedef struct _TDNF_RPM_TS_
|
||||
{
|
||||
rpmts pTS;
|
||||
rpmKeyring pKeyring;
|
||||
rpmtransFlags nTransFlags;
|
||||
rpmprobFilterFlags nProbFilterFlags;
|
||||
FD_t pFD;
|
||||
GArray* pCachedRpmsArray;
|
||||
rpmts pTS;
|
||||
rpmKeyring pKeyring;
|
||||
rpmtransFlags nTransFlags;
|
||||
rpmprobFilterFlags nProbFilterFlags;
|
||||
FD_t pFD;
|
||||
PTDNF_CACHED_RPM_LIST pCachedRpmsArray;
|
||||
}TDNFRPMTS, *PTDNFRPMTS;
|
||||
|
||||
typedef struct _TDNF_ENV_
|
||||
|
|
|
@ -2,7 +2,9 @@ noinst_LTLIBRARIES = libcommon.la
|
|||
|
||||
libcommon_la_SOURCES = \
|
||||
memory.c \
|
||||
strings.c
|
||||
strings.c \
|
||||
configreader.c \
|
||||
utils.c
|
||||
|
||||
libcommon_la_CPPFLAGS = \
|
||||
-I$(top_srcdir)/include
|
||||
|
|
|
@ -0,0 +1,483 @@
|
|||
#include "includes.h"
|
||||
|
||||
uint32_t TDNFConfSectionDefault(
|
||||
PCONF_DATA pData,
|
||||
const char *pszSection
|
||||
);
|
||||
|
||||
uint32_t TDNFConfKeyvalueDefault(
|
||||
PCONF_DATA pData,
|
||||
const char *psKey,
|
||||
const char *pszValue
|
||||
);
|
||||
|
||||
static PFN_CONF_SECTION_CB pfnConfSectionCB = TDNFConfSectionDefault;
|
||||
static PFN_CONF_KEYVALUE_CB pfnConfKeyValueCB = TDNFConfKeyvalueDefault;
|
||||
|
||||
void
|
||||
TDNFPrintConfigData(
|
||||
PCONF_DATA pData
|
||||
)
|
||||
{
|
||||
PCONF_SECTION pSection = NULL;
|
||||
PKEYVALUE pKeyValue = NULL;
|
||||
if(!pData) return;
|
||||
|
||||
fprintf(stdout, "File: %s\n", pData->pszConfFile);
|
||||
|
||||
pSection = pData->pSections;
|
||||
while(pSection)
|
||||
{
|
||||
fprintf(stdout, "[%s]\n", pSection->pszName);
|
||||
pKeyValue = pSection->pKeyValues;
|
||||
while(pKeyValue)
|
||||
{
|
||||
fprintf(stdout, "%s=%s\n", pKeyValue->pszKey, pKeyValue->pszValue);
|
||||
pKeyValue = pKeyValue->pNext;
|
||||
}
|
||||
pSection = pSection->pNext;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFGetSectionBoundaries(
|
||||
const char *pszLine,
|
||||
const char **ppszStart,
|
||||
const char **ppszEnd
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
const char *pszStart = NULL;
|
||||
const char *pszEnd = NULL;
|
||||
|
||||
pszStart = strchr(pszLine, '[');
|
||||
if(!pszStart)
|
||||
{
|
||||
dwError = ENOENT;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pszEnd = strrchr(pszLine, ']');
|
||||
if(!pszEnd)
|
||||
{
|
||||
dwError = ENOENT;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
if(pszEnd < pszStart)
|
||||
{
|
||||
dwError = ENOENT;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
*ppszStart = pszStart;
|
||||
*ppszEnd = pszEnd;
|
||||
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFGetSection(
|
||||
const char *pszLine,
|
||||
char **ppszSection
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char *pszSection = NULL;
|
||||
const char *pszStart = NULL;
|
||||
const char *pszEnd = NULL;
|
||||
|
||||
dwError = TDNFGetSectionBoundaries(pszLine, &pszStart, &pszEnd);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
pszStart = TDNFLeftTrim(pszStart + 1);
|
||||
pszEnd = TDNFRightTrim(pszStart, pszEnd - 1);
|
||||
|
||||
dwError = TDNFAllocateMemory(pszEnd - pszStart + 2, 1, (void**)&pszSection);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
memcpy(pszSection, pszStart, pszEnd - pszStart + 1);
|
||||
|
||||
*ppszSection = pszSection;
|
||||
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(ppszSection)
|
||||
{
|
||||
*ppszSection = NULL;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFIsSection(
|
||||
const char *pszLine,
|
||||
int *pnSection
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
const char *pszStart = NULL;
|
||||
const char *pszEnd = NULL;
|
||||
|
||||
dwError = TDNFGetSectionBoundaries(pszLine, &pszStart, &pszEnd);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
*pnSection = 1;
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(pnSection)
|
||||
{
|
||||
*pnSection = 0;
|
||||
}
|
||||
if(dwError == ENOENT)
|
||||
{
|
||||
dwError = 0;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
void
|
||||
TDNFFreeKeyValues(
|
||||
PKEYVALUE pKeyValue
|
||||
)
|
||||
{
|
||||
if(!pKeyValue)
|
||||
{
|
||||
return;
|
||||
}
|
||||
while(pKeyValue)
|
||||
{
|
||||
PKEYVALUE pKeyValueTemp = pKeyValue->pNext;
|
||||
TDNF_SAFE_FREE_MEMORY(pKeyValue->pszKey);
|
||||
TDNF_SAFE_FREE_MEMORY(pKeyValue->pszValue);
|
||||
TDNF_SAFE_FREE_MEMORY(pKeyValue);
|
||||
pKeyValue = pKeyValueTemp;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
TdnfFreeConfigSections(
|
||||
PCONF_SECTION pSection
|
||||
)
|
||||
{
|
||||
if(!pSection)
|
||||
{
|
||||
return;
|
||||
}
|
||||
while(pSection)
|
||||
{
|
||||
PCONF_SECTION pSectionTemp = pSection->pNext;
|
||||
TDNFFreeKeyValues(pSection->pKeyValues);
|
||||
TDNF_SAFE_FREE_MEMORY(pSection->pszName);
|
||||
TDNF_SAFE_FREE_MEMORY(pSection);
|
||||
pSection = pSectionTemp;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
TDNFFreeConfigData(
|
||||
PCONF_DATA pData
|
||||
)
|
||||
{
|
||||
if(!pData)
|
||||
{
|
||||
return;
|
||||
}
|
||||
TdnfFreeConfigSections(pData->pSections);
|
||||
TDNF_SAFE_FREE_MEMORY(pData);
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFConfSectionDefault(
|
||||
PCONF_DATA pData,
|
||||
const char *pszSection
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
PCONF_SECTION pNewSection = NULL;
|
||||
PCONF_SECTION pSection = NULL;
|
||||
|
||||
if(!pData || IsNullOrEmptyString(pszSection))
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pSection = pData->pSections;
|
||||
while(pSection && pSection->pNext) pSection = pSection->pNext;
|
||||
|
||||
dwError = TDNFAllocateMemory(1, sizeof(CONF_SECTION), (void **)&pNewSection);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFAllocateString(pszSection, &pNewSection->pszName);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(pSection)
|
||||
{
|
||||
pSection->pNext = pNewSection;
|
||||
}
|
||||
else
|
||||
{
|
||||
pData->pSections = pNewSection;
|
||||
}
|
||||
pNewSection = NULL;
|
||||
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(pNewSection)
|
||||
{
|
||||
TdnfFreeConfigSections(pNewSection);
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFConfKeyvalueDefault(
|
||||
PCONF_DATA pData,
|
||||
const char *pszKey,
|
||||
const char *pszValue
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
char *pszEq = NULL;
|
||||
PCONF_SECTION pSection = NULL;
|
||||
PKEYVALUE pNewKeyValue = NULL;
|
||||
PKEYVALUE pKeyValue = NULL;
|
||||
const char *pszTemp = NULL;
|
||||
const char *pszTempEnd = NULL;
|
||||
|
||||
//Allow for empty values
|
||||
if(!pData || IsNullOrEmptyString(pszKey))
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pszEq = strchr(pszKey, '=');
|
||||
if(!pszEq)
|
||||
{
|
||||
fprintf(stderr, "keyvalue lines must be of format key=value\n");
|
||||
dwError = EDOM;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pSection = pData->pSections;
|
||||
for(;pSection && pSection->pNext; pSection = pSection->pNext);
|
||||
|
||||
if(!pSection)
|
||||
{
|
||||
fprintf(stderr, "conf file must start with a section");
|
||||
dwError = EINVAL;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pKeyValue = pSection->pKeyValues;
|
||||
for(;pKeyValue && pKeyValue->pNext; pKeyValue = pKeyValue->pNext);
|
||||
|
||||
pszTemp = TDNFRightTrim(pszValue, pszEq);
|
||||
dwError = TDNFAllocateMemory(sizeof(KEYVALUE), 1, (void**)&pNewKeyValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFAllocateMemory(
|
||||
pszTemp - pszValue + 1,
|
||||
1,
|
||||
(void**)&pNewKeyValue->pszKey);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
strncpy(pNewKeyValue->pszKey, pszValue, pszTemp - pszValue);
|
||||
|
||||
pszTemp = TDNFLeftTrim(pszEq + 1);
|
||||
pszTempEnd = TDNFRightTrim(pszTemp, pszTemp + strlen(pszTemp) - 1);
|
||||
dwError = TDNFAllocateMemory(
|
||||
pszTempEnd - pszTemp + 2,
|
||||
1,
|
||||
(void**)&pNewKeyValue->pszValue);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
strncpy(pNewKeyValue->pszValue, pszTemp, pszTempEnd - pszTemp + 1);
|
||||
|
||||
if(pKeyValue)
|
||||
{
|
||||
pKeyValue->pNext = pNewKeyValue;
|
||||
}
|
||||
else
|
||||
{
|
||||
pSection->pKeyValues = pNewKeyValue;
|
||||
}
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
TDNFFreeKeyValues(pNewKeyValue);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFProcessConfigLine(
|
||||
const char *pszLine,
|
||||
PCONF_DATA pData
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
int nSection = 0;
|
||||
|
||||
if(IsNullOrEmptyString(pszLine) || !pData)
|
||||
{
|
||||
dwError = EINVAL;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
dwError = TDNFIsSection(pszLine, &nSection);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(nSection && pfnConfSectionCB)
|
||||
{
|
||||
char *pszSection = NULL;
|
||||
|
||||
dwError = TDNFGetSection(pszLine, &pszSection);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = pfnConfSectionCB(pData, pszSection);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
else if(pfnConfKeyValueCB)
|
||||
{
|
||||
if(strchr(pszLine, '='))
|
||||
{
|
||||
dwError = pfnConfKeyValueCB(pData, pszLine, pszLine);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
}
|
||||
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFReadConfigFile(
|
||||
const char *pszFile,
|
||||
const int nLineLength,
|
||||
PCONF_DATA *ppData
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
FILE *fp = NULL;
|
||||
char *pszLine = NULL;
|
||||
PCONF_DATA pData = NULL;
|
||||
int nMaxLineLength = 0;
|
||||
|
||||
if(IsNullOrEmptyString(pszFile) || !ppData)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
fp = fopen(pszFile, "r");
|
||||
if(!fp)
|
||||
{
|
||||
dwError = errno;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
dwError = TDNFAllocateMemory(1, sizeof(CONF_DATA), (void **)&pData);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
dwError = TDNFAllocateString(pszFile, &pData->pszConfFile);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
nMaxLineLength = nLineLength > MAX_CONFIG_LINE_LENGTH ?
|
||||
nLineLength : MAX_CONFIG_LINE_LENGTH;
|
||||
dwError = TDNFAllocateMemory(1, nMaxLineLength, (void **)&pszLine);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(fp)
|
||||
{
|
||||
while(fgets(pszLine, nMaxLineLength, fp) != NULL)
|
||||
{
|
||||
const char *pszTrimmedLine = TDNFLeftTrim(pszLine);
|
||||
|
||||
//ignore empty lines, comments
|
||||
if(IsNullOrEmptyString(pszTrimmedLine) || *pszTrimmedLine == '#')
|
||||
{
|
||||
continue;
|
||||
}
|
||||
dwError = TDNFProcessConfigLine(pszTrimmedLine, pData);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
}
|
||||
|
||||
*ppData = pData;
|
||||
|
||||
cleanup:
|
||||
TDNF_SAFE_FREE_MEMORY(pszLine);
|
||||
if(fp)
|
||||
{
|
||||
fclose(fp);
|
||||
}
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(ppData)
|
||||
{
|
||||
*ppData = NULL;
|
||||
}
|
||||
TDNFFreeConfigData(pData);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFConfigGetSection(
|
||||
PCONF_DATA pData,
|
||||
const char *pszGroup,
|
||||
PCONF_SECTION *ppSection
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
PCONF_SECTION pSections = NULL;
|
||||
PCONF_SECTION pSection = NULL;
|
||||
|
||||
if(!pData || IsNullOrEmptyString(pszGroup) || !ppSection)
|
||||
{
|
||||
dwError = ERROR_TDNF_INVALID_PARAMETER;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
pSections = pData->pSections;
|
||||
for(; pSections; pSections = pSections->pNext)
|
||||
{
|
||||
if(!strcmp(pszGroup, pSections->pszName))
|
||||
{
|
||||
pSection = pSections;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(!pSection)
|
||||
{
|
||||
dwError = ENOENT;
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
}
|
||||
|
||||
*ppSection = pSection;
|
||||
|
||||
cleanup:
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(ppSection)
|
||||
{
|
||||
*ppSection = NULL;
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
|
@ -20,6 +20,8 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#define MAX_CONFIG_LINE_LENGTH 1024
|
||||
|
||||
#define IsNullOrEmptyString(str) (!(str) || !(*str))
|
||||
|
||||
#define BAIL_ON_TDNF_ERROR(dwError) \
|
||||
|
|
|
@ -6,6 +6,7 @@
|
|||
* of the License are located in the COPYING file of this distribution.
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
@ -16,4 +17,5 @@
|
|||
#include <tdnferror.h>
|
||||
|
||||
#include "defines.h"
|
||||
#include "structs.h"
|
||||
#include "prototypes.h"
|
||||
|
|
|
@ -71,3 +71,57 @@ TDNFReplaceString(
|
|||
const char* pszReplace,
|
||||
char** ppszDst
|
||||
);
|
||||
|
||||
void
|
||||
TDNFFreeStringArray(
|
||||
char** ppszArray
|
||||
);
|
||||
|
||||
void
|
||||
TDNFFreeStringArrayWithCount(
|
||||
char **ppszArray,
|
||||
int nCount
|
||||
);
|
||||
|
||||
//configreader.c
|
||||
void
|
||||
TDNFPrintConfigData(
|
||||
PCONF_DATA pData
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFReadConfigFile(
|
||||
const char *pszFile,
|
||||
const int nMaxLineLength,
|
||||
PCONF_DATA *ppData
|
||||
);
|
||||
|
||||
uint32_t
|
||||
TDNFConfigGetSection(
|
||||
PCONF_DATA pData,
|
||||
const char *pszGroup,
|
||||
PCONF_SECTION *ppSection
|
||||
);
|
||||
|
||||
void
|
||||
TDNFFreeConfigData(
|
||||
PCONF_DATA pData
|
||||
);
|
||||
|
||||
//utils.c
|
||||
uint32_t
|
||||
TDNFFileReadAllText(
|
||||
const char *pszFileName,
|
||||
char **ppszText
|
||||
);
|
||||
|
||||
const char *
|
||||
TDNFLeftTrim(
|
||||
const char *pszStr
|
||||
);
|
||||
|
||||
const char *
|
||||
TDNFRightTrim(
|
||||
const char *pszStart,
|
||||
const char *pszEnd
|
||||
);
|
||||
|
|
|
@ -168,6 +168,22 @@ TDNFFreeStringArray(
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
TDNFFreeStringArrayWithCount(
|
||||
char **ppszArray,
|
||||
int nCount
|
||||
)
|
||||
{
|
||||
if(ppszArray)
|
||||
{
|
||||
while(nCount)
|
||||
{
|
||||
TDNFFreeMemory(ppszArray[--nCount]);
|
||||
}
|
||||
TDNFFreeMemory(ppszArray);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t
|
||||
TDNFAllocateStringN(
|
||||
const char* pszSrc,
|
||||
|
|
|
@ -0,0 +1,34 @@
|
|||
#pragma once
|
||||
|
||||
typedef struct _KEYVALUE_
|
||||
{
|
||||
char *pszKey;
|
||||
char *pszValue;
|
||||
struct _KEYVALUE_ *pNext;
|
||||
}KEYVALUE, *PKEYVALUE;
|
||||
|
||||
typedef struct _CONF_SECTION_
|
||||
{
|
||||
char *pszName;
|
||||
PKEYVALUE pKeyValues;
|
||||
struct _CONF_SECTION_ *pNext;
|
||||
}CONF_SECTION, *PCONF_SECTION;
|
||||
|
||||
typedef struct _CONF_DATA_
|
||||
{
|
||||
char *pszConfFile;
|
||||
PCONF_SECTION pSections;
|
||||
}CONF_DATA, *PCONF_DATA;
|
||||
|
||||
typedef uint32_t
|
||||
(*PFN_CONF_SECTION_CB)(
|
||||
PCONF_DATA pData,
|
||||
const char *pszSection
|
||||
);
|
||||
|
||||
typedef uint32_t
|
||||
(*PFN_CONF_KEYVALUE_CB)(
|
||||
PCONF_DATA pData,
|
||||
const char *pszKey,
|
||||
const char *pszValue
|
||||
);
|
|
@ -0,0 +1,82 @@
|
|||
#include "includes.h"
|
||||
|
||||
uint32_t
|
||||
TDNFFileReadAllText(
|
||||
const char *pszFileName,
|
||||
char **ppszText
|
||||
)
|
||||
{
|
||||
uint32_t dwError = 0;
|
||||
FILE *fp = NULL;
|
||||
char *pszText = NULL;
|
||||
int nLength = 0;
|
||||
int nBytesRead = 0;
|
||||
|
||||
if(!pszFileName || !ppszText)
|
||||
{
|
||||
dwError = EINVAL;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
fp = fopen(pszFileName, "r");
|
||||
if(!fp)
|
||||
{
|
||||
dwError = ENOENT;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
fseek(fp, 0, SEEK_END);
|
||||
nLength = ftell(fp);
|
||||
|
||||
dwError = TDNFAllocateMemory(1, nLength + 1, (void **)&pszText);
|
||||
BAIL_ON_TDNF_ERROR(dwError);
|
||||
|
||||
if(fseek(fp, 0, SEEK_SET))
|
||||
{
|
||||
dwError = errno;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
nBytesRead = fread(pszText, 1, nLength, fp);
|
||||
if(nBytesRead != nLength)
|
||||
{
|
||||
dwError = EBADFD;
|
||||
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
|
||||
}
|
||||
|
||||
*ppszText = pszText;
|
||||
cleanup:
|
||||
if(fp)
|
||||
{
|
||||
fclose(fp);
|
||||
}
|
||||
return dwError;
|
||||
|
||||
error:
|
||||
if(ppszText)
|
||||
{
|
||||
*ppszText = NULL;
|
||||
}
|
||||
TDNF_SAFE_FREE_MEMORY(pszText);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
const char *
|
||||
TDNFLeftTrim(
|
||||
const char *pszStr
|
||||
)
|
||||
{
|
||||
if(!pszStr) return NULL;
|
||||
while(isspace(*pszStr)) ++pszStr;
|
||||
return pszStr;
|
||||
}
|
||||
|
||||
const char *
|
||||
TDNFRightTrim(
|
||||
const char *pszStart,
|
||||
const char *pszEnd
|
||||
)
|
||||
{
|
||||
if(!pszStart || !pszEnd) return NULL;
|
||||
while(pszEnd > pszStart && isspace(*pszEnd)) pszEnd--;
|
||||
return pszEnd;
|
||||
}
|
|
@ -27,10 +27,6 @@ AC_CHECK_HEADERS(hawkey/sack.h)
|
|||
echo "Looking for hawkey libs"
|
||||
AC_CHECK_LIB(hawkey, hy_sack_count)
|
||||
|
||||
#glib
|
||||
PKG_CHECK_MODULES([GLIB], [glib-2.0], [have_libglib=yes], [have_libglib=no])
|
||||
AM_CONDITIONAL([GLIB], [test "$have_libglib" = "yes"])
|
||||
|
||||
#licurl
|
||||
PKG_CHECK_MODULES([LIBCURL], [libcurl], [have_libcurl=yes], [have_libcurl=no])
|
||||
AM_CONDITIONAL([LIBCURL], [test "$have_libcurl" = "yes"])
|
||||
|
|
|
@ -227,11 +227,6 @@ TDNFFreeSolvedPackageInfo(
|
|||
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
|
||||
);
|
||||
|
||||
void
|
||||
TDNFFreeStringArray(
|
||||
char** ppszArray
|
||||
);
|
||||
|
||||
void
|
||||
TDNFFreeUpdateInfo(
|
||||
PTDNF_UPDATEINFO pUpdateInfo
|
||||
|
|
|
@ -33,4 +33,5 @@
|
|||
#include "defines.h"
|
||||
#include "structs.h"
|
||||
#include "prototypes.h"
|
||||
#include "../common/structs.h"
|
||||
#include "../common/prototypes.h"
|
||||
|
|
Loading…
Reference in New Issue