folkslinux
/
tdnf
mirror of https://github.com/vmware/tdnf.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove glib dependency from tdnf. 

Change-Id: I51ed0e224c54c2a3eff57b8c54af7204db2ef26e
This commit is contained in:
xiaolin-vmware 2016-11-29 10:41:51 -08:00 committed by gerrit-photon
parent ff092063d6
commit f25379c61e
22 changed files with 1226 additions and 555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/Makefile.am
View File

@ -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

43
client/api.c
View File

@ -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,13 +172,21 @@ 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)
@ -187,8 +197,9 @@ TDNFCheckLocalPackages(
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,12 +227,9 @@ 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);
@ -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
View File

@ -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:

136
client/gpgcheck.c
View File

@ -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,10 +154,10 @@ 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)
{
@ -68,24 +165,16 @@ ReadGPGKey(
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;
}

11
client/includes.h
View File

@ -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"

53
client/prototypes.h
View File

@ -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

42
client/repo.c
View File

@ -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;

148
client/repolist.c
View File

@ -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 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;

174
client/repoutils.c
View File

@ -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,

108
client/rpmtrans.c
View File

@ -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);
}
}

24
client/structs.h
View File

@ -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_

4
common/Makefile.am
View File

@ -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

483
common/configreader.c Normal file
View File

@ -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;
}

2
common/defines.h
View File

@ -20,6 +20,8 @@
#pragma once
#define MAX_CONFIG_LINE_LENGTH 1024
#define IsNullOrEmptyString(str) (!(str) || !(*str))
#define BAIL_ON_TDNF_ERROR(dwError) \

2
common/includes.h
View File

@ -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"

54
common/prototypes.h
View File

@ -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
);

16
common/strings.c
View File

@ -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,

34
common/structs.h Normal file
View File

@ -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
);

82
common/utils.c Normal file
View File

@ -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;
}

4
configure.ac
View File

@ -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"])

5
include/tdnfclient.h
View File

@ -227,11 +227,6 @@ TDNFFreeSolvedPackageInfo(
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
);
void
TDNFFreeStringArray(
char** ppszArray
);
void
TDNFFreeUpdateInfo(
PTDNF_UPDATEINFO pUpdateInfo

1
tools/cli/includes.h
View File

@ -33,4 +33,5 @@
#include "defines.h"
#include "structs.h"
#include "prototypes.h"
#include "../common/structs.h"
#include "../common/prototypes.h"