static PyObject *
package_repr(_PackageObject *self)
{
HyPackage pkg = self->package;
char *nevra = hy_package_get_nevra(pkg);
PyObject *repr;
repr = PyString_FromFormat("<hawkey.Package object id %ld, %s, %s>",
package_hash(self), nevra,
hy_package_get_reponame(pkg));
solv_free(nevra);
return repr;
}
static void execute_print(HySack sack, HyQuery q, int show_obsoletes)
{
HyPackageList plist;
plist = hy_query_run(q);
const int count = hy_packagelist_count(plist);
for (int i = 0; i < count; ++i) {
HyPackage pkg = hy_packagelist_get(plist, i);
char *nvra = hy_package_get_nevra(pkg);
const char *reponame = hy_package_get_reponame(pkg);
printf("found package: %s [%s]\n", nvra, reponame);
if (strcmp(reponame, HY_SYSTEM_REPO_NAME) == 0) {
int type;
const unsigned char * hdrid = hy_package_get_hdr_chksum(pkg, &type);
char *str = hy_chksum_str(hdrid, type);
printf("\tsha1 header id: %s\n", str);
hy_free(str);
}
if (show_obsoletes) {
HyReldepList obsoletes = hy_package_get_obsoletes(pkg);
HyQuery qobs = hy_query_create(sack);
hy_query_filter(qobs, HY_PKG_REPONAME, HY_NEQ, HY_SYSTEM_REPO_NAME);
hy_query_filter_reldep_in(qobs, HY_PKG_PROVIDES, obsoletes);
HyPackageList olist = hy_query_run(qobs);
const int ocount = hy_packagelist_count(olist);
for (int j = 0; j < ocount; ++j) {
HyPackage opkg = hy_packagelist_get(olist, j);
char *onvra = hy_package_get_nevra(opkg);
printf("obsoleting: %s\n", onvra);
hy_free(onvra);
}
hy_packagelist_free(olist);
hy_query_free(qobs);
hy_reldeplist_free(obsoletes);
}
hy_free(nvra);
}
hy_packagelist_free(plist);
}
uint32_t
TDNFDownloadPackage(
PTDNF pTdnf,
HyPackage hPkg,
const char* pszRpmCacheDir
)
{
uint32_t dwError = 0;
LrHandle *pRepoHandle = NULL;
GError* pError = NULL;
gboolean bRet = FALSE;
char* ppszUrls[] = {NULL, NULL};
const char* pszPackage = NULL;
const char* pszRepo = NULL;
char* pszUserPass = NULL;
if(!pTdnf || !hPkg || IsNullOrEmptyString(pszRpmCacheDir))
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
pRepoHandle = lr_handle_init();
if(!pRepoHandle)
{
//TODO: Add repo specific
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
//Get package details
pszPackage = hy_package_get_location(hPkg);
pszRepo = hy_package_get_reponame(hPkg);
dwError = TDNFRepoGetBaseUrl(pTdnf, pszRepo, &ppszUrls[0]);
BAIL_ON_TDNF_ERROR(dwError);
lr_handle_setopt(pRepoHandle, NULL, LRO_URLS, ppszUrls);
lr_handle_setopt(pRepoHandle, NULL, LRO_REPOTYPE, LR_YUMREPO);
lr_handle_setopt(pRepoHandle, NULL, LRO_SSLVERIFYPEER, 1);
lr_handle_setopt(pRepoHandle, NULL, LRO_SSLVERIFYHOST, 2);
dwError = TDNFRepoGetUserPass(pTdnf, pszRepo, &pszUserPass);
BAIL_ON_TDNF_ERROR(dwError);
if(!IsNullOrEmptyString(pszUserPass))
{
lr_handle_setopt(pRepoHandle, NULL, LRO_USERPWD, pszUserPass);
}
bRet = lr_handle_setopt(pRepoHandle, NULL, LRO_PROGRESSCB, lrProgressCB);
if(bRet == FALSE)
{
//TODO: Add repo specific
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
bRet = lr_download_package (
pRepoHandle,
pszPackage,
pszRpmCacheDir,
LR_CHECKSUM_UNKNOWN,
NULL,
0,
NULL,
TRUE,
&pError);
if(bRet == FALSE)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
fprintf(stdout, "\n");
cleanup:
if(pRepoHandle)
{
lr_handle_free(pRepoHandle);
}
return dwError;
error:
if(pError)
{
fprintf(
stderr,
"Error during download: %d: %s\n",
pError->code,
pError->message
);
g_error_free(pError);
}
goto cleanup;
}
uint32_t
TDNFTransAddInstallPkg(
PTDNFRPMTS pTS,
PTDNF pTdnf,
HyPackage hPkg,
int nUpgrade
)
{
uint32_t dwError = 0;
int nGPGCheck = 0;
char* pszRpmCacheDir = NULL;
char* pszFilePath = NULL;
const char* pszRepoName = NULL;
char* pszHyName = NULL;
Header rpmHeader = NULL;
FD_t fp = NULL;
char* pszDownloadCacheDir = NULL;
char* pszUrlGPGKey = 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);
}
}
pszDownloadCacheDir = g_path_get_dirname(pszFilePath);
if(!pszDownloadCacheDir)
{
dwError = ENOENT;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
if(access(pszDownloadCacheDir, F_OK))
{
if(errno != ENOENT)
{
dwError = errno;
}
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
dwError = TDNFUtilsMakeDirs(pszDownloadCacheDir);
BAIL_ON_TDNF_ERROR(dwError);
}
if(access(pszFilePath, F_OK))
{
if(errno != ENOENT)
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
dwError = TDNFDownloadPackage(pTdnf, hPkg, pszDownloadCacheDir);
BAIL_ON_TDNF_ERROR(dwError);
}
//A download could have been triggered.
//So check access and bail if not available
if(access(pszFilePath, F_OK))
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
//Check override, then repo config and launch
//gpg check if needed
dwError = TDNFGetGPGCheck(pTdnf, pszRepoName, &nGPGCheck, &pszUrlGPGKey);
BAIL_ON_TDNF_ERROR(dwError);
if(nGPGCheck)
{
dwError = TDNFGPGCheck(pTS->pKeyring, pszUrlGPGKey, pszFilePath);
BAIL_ON_TDNF_ERROR(dwError);
}
fp = Fopen (pszFilePath, "r.ufdio");
if(!fp)
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
dwError = rpmReadPackageFile(
pTS->pTS,
fp,
pszFilePath,
&rpmHeader);
//If not checking gpg sigs, ignore signature errors
if(!nGPGCheck && (dwError == RPMRC_NOTTRUSTED || dwError == RPMRC_NOKEY))
{
dwError = 0;
}
BAIL_ON_TDNF_RPM_ERROR(dwError);
dwError = rpmtsAddInstallElement(
pTS->pTS,
rpmHeader,
(fnpyKey)pszFilePath,
nUpgrade,
NULL);
BAIL_ON_TDNF_RPM_ERROR(dwError);
cleanup:
TDNF_SAFE_FREE_MEMORY(pszUrlGPGKey);
if(pszHyName)
{
hy_free(pszHyName);
}
if(pszDownloadCacheDir)
{
g_free(pszDownloadCacheDir);
}
if(pszRpmCacheDir)
{
g_free(pszRpmCacheDir);
}
if(fp)
{
Fclose(fp);
}
if(rpmHeader)
{
headerFree(rpmHeader);
}
return dwError;
error:
goto cleanup;
}
