uint32_t
TDNFGPGCheck(
rpmKeyring pKeyring,
const char* pszUrlKeyFile,
const char* pszPkgFile
)
{
uint32_t dwError = 0;
char* pszKeyData = NULL;
if(!pKeyring || IsNullOrEmptyString(pszUrlKeyFile) || !pszPkgFile)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = AddKeyToKeyRing(pszUrlKeyFile, pKeyring);
BAIL_ON_TDNF_ERROR(dwError);
dwError = VerifyRpmSig(pKeyring, pszPkgFile);
BAIL_ON_TDNF_ERROR(dwError);
cleanup:
TDNF_SAFE_FREE_MEMORY(pszKeyData);
return dwError;
error:
goto cleanup;
}
uint32_t
TDNFGetGPGCheck(
PTDNF pTdnf,
const char* pszRepo,
int* pnGPGCheck,
char** ppszUrlGPGKey
)
{
uint32_t dwError = 0;
PTDNF_REPO_DATA pRepo = NULL;
int nGPGCheck = 0;
char* pszUrlGPGKey = NULL;
if(!pTdnf || !ppszUrlGPGKey || IsNullOrEmptyString(pszRepo))
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(!pTdnf->pArgs->nNoGPGCheck)
{
dwError = TDNFGetRepoById(pTdnf, pszRepo, &pRepo);
if(dwError == ERROR_TDNF_NO_DATA)
{
dwError = 0;
}
BAIL_ON_TDNF_ERROR(dwError);
if(pRepo)
{
nGPGCheck = pRepo->nGPGCheck;
if(nGPGCheck)
{
dwError = TDNFAllocateString(
pRepo->pszUrlGPGKey,
&pszUrlGPGKey);
BAIL_ON_TDNF_ERROR(dwError);
}
}
}
*pnGPGCheck = nGPGCheck;
*ppszUrlGPGKey = pszUrlGPGKey;
cleanup:
return dwError;
error:
if(ppszUrlGPGKey)
{
*ppszUrlGPGKey = NULL;
}
TDNF_SAFE_FREE_MEMORY(pszUrlGPGKey);
goto cleanup;
}
void
TDNFFreeCachedRpmsArray(
GArray* pArray
)
{
uint32_t dwIndex = 0;
char* pszPath = NULL;
if(pArray)
{
for(dwIndex = 0; dwIndex < pArray->len; ++dwIndex)
{
pszPath = g_array_index(pArray, char*, dwIndex);
TDNF_SAFE_FREE_MEMORY(pszPath);
}
g_array_free(pArray, TRUE);
}
}
uint32_t
ReadAllBytes(
const char* pszFile,
char** ppszData
)
{
uint32_t dwError = 0;
size_t fsize = 0;
char* pszData = NULL;
FILE* fp = NULL;
if(IsNullOrEmptyString(pszFile) || !ppszData)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
fp = fopen(pszFile, "r");
if(!fp)
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
if(fseek(fp, 0, SEEK_END))
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
fsize = ftell(fp);
if(fseek(fp, 0, SEEK_SET))
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
dwError = TDNFAllocateMemory(fsize+1, (void**)&pszData);
BAIL_ON_TDNF_ERROR(dwError);
if(!fread(pszData, fsize, 1, fp))
{
dwError = errno;
BAIL_ON_TDNF_SYSTEM_ERROR(dwError);
}
*ppszData = pszData;
cleanup:
if(fp)
{
fclose(fp);
}
return dwError;
error:
if(!ppszData)
{
*ppszData = NULL;
}
TDNF_SAFE_FREE_MEMORY(pszData);
goto cleanup;
}
uint32_t
AddKeyToKeyRing(
const char* pszFile,
rpmKeyring pKeyring
)
{
uint32_t dwError = 0;
pgpArmor nArmor = PGPARMOR_NONE;
pgpDig pDig = NULL;
rpmPubkey pPubkey = NULL;
uint8_t* pPkt = NULL;
size_t nPktLen = 0;
char* pszKeyData = NULL;
if(IsNullOrEmptyString(pszFile) || !pKeyring)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = ReadGPGKey(pszFile, &pszKeyData);
BAIL_ON_TDNF_ERROR(dwError);
nArmor = pgpParsePkts(pszKeyData, &pPkt, &nPktLen);
if(nArmor != PGPARMOR_PUBKEY)
{
dwError = ERROR_TDNF_INVALID_PUBKEY_FILE;
BAIL_ON_TDNF_ERROR(dwError);
}
pPubkey = rpmPubkeyNew (pPkt, nPktLen);
if(!pPubkey)
{
dwError = ERROR_TDNF_CREATE_PUBKEY_FAILED;
BAIL_ON_TDNF_ERROR(dwError);
}
pDig = rpmPubkeyDig(pPubkey);
if(!pDig)
{
dwError = ERROR_TDNF_CREATE_PUBKEY_FAILED;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = rpmKeyringLookup(pKeyring, pDig);
if(dwError == RPMRC_OK)
{
dwError = 0;//key exists
}
else
{
dwError = rpmKeyringAddKey(pKeyring, pPubkey);
if(dwError == 1)
{
dwError = 0;//Already added. ignore
}
BAIL_ON_TDNF_ERROR(dwError);
}
cleanup:
return dwError;
error:
TDNF_SAFE_FREE_MEMORY(pszKeyData);
if(pPubkey)
{
rpmPubkeyFree(pPubkey);
}
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;
}
