/*************************************************************************
* FUNCTION : RPMTransaction_Set::Exec *
* ARGUMENTS : which cmd to do,interp, arg count, arg list *
* RETURNS : per subcommands *
* EXCEPTIONS : Per subcommands *
* PURPOSE : Carry out the RPM command *
*************************************************************************/
int RPMTransaction_Set::Exec(int which,Tcl_Interp *interp,int objc, Tcl_Obj *const objv[])
{
// Before doing any command, see if the databases are dirty - if so, close them
if (RPM_for_TCL::Are_DBs_dirty(my_dirty_count))
rpmtsCloseDB(transaction);
return (this->*cmds[which].func)(interp,objc,objv);
}
static PyObject *
rpmts_CloseDB(rpmtsObject * s)
{
int rc;
rc = rpmtsCloseDB(s->ts);
rpmtsSetDBMode(s->ts, -1); /* XXX disable lazy opens */
return Py_BuildValue("i", rc);
}
static PyObject *
rpmts_InitDB(rpmtsObject * s)
{
int rc;
rc = rpmtsInitDB(s->ts, O_RDONLY);
if (rc == 0)
rc = rpmtsCloseDB(s->ts);
return Py_BuildValue("i", rc);
}
rpmts rpmtsFree(rpmts ts)
{
tsMembers tsmem = rpmtsMembers(ts);
if (ts == NULL)
return NULL;
if (ts->nrefs > 1)
return rpmtsUnlink(ts);
rpmtsEmpty(ts);
(void) rpmtsCloseDB(ts);
tsmem->removedPackages = removedHashFree(tsmem->removedPackages);
tsmem->order = _free(tsmem->order);
ts->members = _free(ts->members);
ts->dsi = _free(ts->dsi);
if (ts->scriptFd != NULL) {
ts->scriptFd = fdFree(ts->scriptFd);
ts->scriptFd = NULL;
}
ts->rootDir = _free(ts->rootDir);
ts->lockPath = _free(ts->lockPath);
ts->lock = rpmlockFree(ts->lock);
ts->keyring = rpmKeyringFree(ts->keyring);
ts->netsharedPaths = argvFree(ts->netsharedPaths);
ts->installLangs = argvFree(ts->installLangs);
ts->plugins = rpmpluginsFree(ts->plugins);
if (_rpmts_stats)
rpmtsPrintStats(ts);
(void) rpmtsUnlink(ts);
ts = _free(ts);
return NULL;
}
int rpmtsOpenDB(rpmts ts, int dbmode)
{
int rc = 0;
if (ts->rdb != NULL && ts->dbmode == dbmode)
return 0;
(void) rpmtsCloseDB(ts);
/* XXX there's a potential db lock race here. */
ts->dbmode = dbmode;
rc = rpmdbOpen(ts->rootDir, &ts->rdb, ts->dbmode, 0644);
if (rc) {
char * dn = rpmGetPath(ts->rootDir, "%{_dbpath}", NULL);
rpmlog(RPMLOG_ERR, _("cannot open Packages database in %s\n"), dn);
free(dn);
}
return rc;
}
int rpmtsCheck(rpmts ts)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpmtsi pi = NULL; rpmte p;
int closeatexit = 0;
int rc = 0;
depCache dcache = NULL;
filedepHash confilehash = NULL; /* file conflicts of installed packages */
filedepHash connotfilehash = NULL; /* file conflicts of installed packages */
depexistsHash connothash = NULL;
filedepHash reqfilehash = NULL; /* file requires of installed packages */
filedepHash reqnotfilehash = NULL; /* file requires of installed packages */
depexistsHash reqnothash = NULL;
fingerPrintCache fpc = NULL;
rpmdb rdb = NULL;
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_CHECK), 0);
/* Do lazy, readonly, open of rpm database. */
rdb = rpmtsGetRdb(ts);
if (rdb == NULL && rpmtsGetDBMode(ts) != -1) {
if ((rc = rpmtsOpenDB(ts, rpmtsGetDBMode(ts))) != 0)
goto exit;
rdb = rpmtsGetRdb(ts);
closeatexit = 1;
}
if (rdb)
rpmdbCtrl(rdb, RPMDB_CTRL_LOCK_RO);
/* XXX FIXME: figure some kind of heuristic for the cache size */
dcache = depCacheCreate(5001, rstrhash, strcmp,
(depCacheFreeKey)rfree, NULL);
/* build hashes of all confilict sdependencies */
confilehash = filedepHashCreate(257, rstrhash, strcmp,
(filedepHashFreeKey)rfree,
(filedepHashFreeData)rfree);
connothash = depexistsHashCreate(257, rstrhash, strcmp,
(filedepHashFreeKey)rfree);
connotfilehash = filedepHashCreate(257, rstrhash, strcmp,
(filedepHashFreeKey)rfree,
(filedepHashFreeData)rfree);
addIndexToDepHashes(ts, RPMTAG_CONFLICTNAME, NULL, confilehash, connothash, connotfilehash);
if (!filedepHashNumKeys(confilehash))
confilehash = filedepHashFree(confilehash);
if (!depexistsHashNumKeys(connothash))
connothash= depexistsHashFree(connothash);
if (!filedepHashNumKeys(connotfilehash))
connotfilehash = filedepHashFree(connotfilehash);
/* build hashes of all requires dependencies */
reqfilehash = filedepHashCreate(8191, rstrhash, strcmp,
(filedepHashFreeKey)rfree,
(filedepHashFreeData)rfree);
reqnothash = depexistsHashCreate(257, rstrhash, strcmp,
(filedepHashFreeKey)rfree);
reqnotfilehash = filedepHashCreate(257, rstrhash, strcmp,
(filedepHashFreeKey)rfree,
(filedepHashFreeData)rfree);
addIndexToDepHashes(ts, RPMTAG_REQUIRENAME, NULL, reqfilehash, reqnothash, reqnotfilehash);
if (!filedepHashNumKeys(reqfilehash))
reqfilehash = filedepHashFree(reqfilehash);
if (!depexistsHashNumKeys(reqnothash))
reqnothash= depexistsHashFree(reqnothash);
if (!filedepHashNumKeys(reqnotfilehash))
reqnotfilehash = filedepHashFree(reqnotfilehash);
/*
* Look at all of the added packages and make sure their dependencies
* are satisfied.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
rpmds provides = rpmdsInit(rpmteDS(p, RPMTAG_PROVIDENAME));
rpmlog(RPMLOG_DEBUG, "========== +++ %s %s/%s 0x%x\n",
rpmteNEVR(p), rpmteA(p), rpmteO(p), rpmteColor(p));
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_REQUIRENAME),
tscolor);
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_CONFLICTNAME),
tscolor);
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_OBSOLETENAME),
tscolor);
/* Check provides against conflicts in installed packages. */
while (rpmdsNext(provides) >= 0) {
const char *dep = rpmdsN(provides);
checkInstDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, dep);
if (reqnothash && depexistsHashHasEntry(reqnothash, dep))
checkNotInstDeps(ts, dcache, p, RPMTAG_REQUIRENAME, dep);
}
/* Skip obsoletion checks for source packages (ie build) */
if (rpmteIsSource(p))
continue;
/* Check package name (not provides!) against installed obsoletes */
checkInstDeps(ts, dcache, p, RPMTAG_OBSOLETENAME, rpmteN(p));
/* Check filenames against installed conflicts */
if (confilehash || reqnotfilehash) {
rpmfiles files = rpmteFiles(p);
rpmfi fi = rpmfilesIter(files, RPMFI_ITER_FWD);
while (rpmfiNext(fi) >= 0) {
if (confilehash)
checkInstFileDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, fi, 0, confilehash, &fpc);
if (reqnotfilehash)
checkInstFileDeps(ts, dcache, p, RPMTAG_REQUIRENAME, fi, 1, reqnotfilehash, &fpc);
}
rpmfiFree(fi);
rpmfilesFree(files);
}
}
rpmtsiFree(pi);
/*
* Look at the removed packages and make sure they aren't critical.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_REMOVED)) != NULL) {
rpmds provides = rpmdsInit(rpmteDS(p, RPMTAG_PROVIDENAME));
rpmlog(RPMLOG_DEBUG, "========== --- %s %s/%s 0x%x\n",
rpmteNEVR(p), rpmteA(p), rpmteO(p), rpmteColor(p));
/* Check provides and filenames against installed dependencies. */
while (rpmdsNext(provides) >= 0) {
const char *dep = rpmdsN(provides);
checkInstDeps(ts, dcache, p, RPMTAG_REQUIRENAME, dep);
if (connothash && depexistsHashHasEntry(connothash, dep))
checkNotInstDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, dep);
}
if (reqfilehash || connotfilehash) {
rpmfiles files = rpmteFiles(p);
rpmfi fi = rpmfilesIter(files, RPMFI_ITER_FWD);;
while (rpmfiNext(fi) >= 0) {
if (RPMFILE_IS_INSTALLED(rpmfiFState(fi))) {
if (reqfilehash)
checkInstFileDeps(ts, dcache, p, RPMTAG_REQUIRENAME, fi, 0, reqfilehash, &fpc);
if (connotfilehash)
checkInstFileDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, fi, 1, connotfilehash, &fpc);
}
}
rpmfiFree(fi);
rpmfilesFree(files);
}
}
rpmtsiFree(pi);
if (rdb)
rpmdbCtrl(rdb, RPMDB_CTRL_UNLOCK_RO);
exit:
depCacheFree(dcache);
filedepHashFree(confilehash);
filedepHashFree(connotfilehash);
depexistsHashFree(connothash);
filedepHashFree(reqfilehash);
filedepHashFree(reqnotfilehash);
depexistsHashFree(reqnothash);
fpCacheFree(fpc);
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_CHECK), 0);
if (closeatexit)
(void) rpmtsCloseDB(ts);
return rc;
}
uint32_t
TDNFRpmExecTransaction(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedInfo
)
{
uint32_t dwError = 0;
int nKeepCachedRpms = 0;
TDNFRPMTS ts = {0};
if(!pTdnf || !pTdnf->pConf || !pSolvedInfo)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
nKeepCachedRpms = pTdnf->pConf->nKeepCache;
ts.pCachedRpmsArray = g_array_new(TRUE, TRUE, sizeof(char*));
if(!ts.pCachedRpmsArray)
{
dwError = ERROR_TDNF_OUT_OF_MEMORY;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = rpmReadConfigFiles(NULL, NULL);
BAIL_ON_TDNF_ERROR(dwError);
rpmSetVerbosity(TDNFConfGetRpmVerbosity(pTdnf));
//Allow downgrades
ts.nProbFilterFlags = RPMPROB_FILTER_OLDPACKAGE;
if(pSolvedInfo->nAlterType == ALTER_REINSTALL)
{
ts.nProbFilterFlags = ts.nProbFilterFlags | RPMPROB_FILTER_REPLACEPKG;
}
ts.pTS = rpmtsCreate();
if(!ts.pTS)
{
dwError = ERROR_TDNF_RPMTS_CREATE_FAILED;
BAIL_ON_TDNF_ERROR(dwError);
}
ts.pKeyring = rpmKeyringNew();
if(!ts.pKeyring)
{
dwError = ERROR_TDNF_RPMTS_KEYRING_FAILED;
BAIL_ON_TDNF_ERROR(dwError);
}
ts.nTransFlags = rpmtsSetFlags (ts.pTS, RPMTRANS_FLAG_NONE);
if(rpmtsSetRootDir (ts.pTS, pTdnf->pArgs->pszInstallRoot))
{
dwError = ERROR_TDNF_RPMTS_BAD_ROOT_DIR;
BAIL_ON_TDNF_ERROR(dwError);
}
if(rpmtsSetNotifyCallback(ts.pTS, TDNFRpmCB, (void*)&ts))
{
dwError = ERROR_TDNF_RPMTS_SET_CB_FAILED;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFPopulateTransaction(&ts, pTdnf, pSolvedInfo);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFRunTransaction(&ts, pTdnf);
BAIL_ON_TDNF_ERROR(dwError);
cleanup:
if(ts.pTS)
{
rpmtsCloseDB(ts.pTS);
rpmtsFree(ts.pTS);
}
if(ts.pKeyring)
{
rpmKeyringFree(ts.pKeyring);
}
if(ts.pCachedRpmsArray)
{
if(!nKeepCachedRpms)
{
TDNFRemoveCachedRpms(ts.pCachedRpmsArray);
}
TDNFFreeCachedRpmsArray(ts.pCachedRpmsArray);
}
return dwError;
error:
goto cleanup;
}
int rpmtsCheck(rpmts ts)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpmtsi pi = NULL; rpmte p;
int closeatexit = 0;
int rc = 0;
depCache dcache = NULL;
conflictsCache confcache = NULL;
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_CHECK), 0);
/* Do lazy, readonly, open of rpm database. */
if (rpmtsGetRdb(ts) == NULL && rpmtsGetDBMode(ts) != -1) {
if ((rc = rpmtsOpenDB(ts, rpmtsGetDBMode(ts))) != 0)
goto exit;
closeatexit = 1;
}
/* XXX FIXME: figure some kind of heuristic for the cache size */
dcache = depCacheCreate(5001, rstrhash, strcmp,
(depCacheFreeKey)rfree, NULL);
confcache = conflictsCacheCreate(257, rstrhash, strcmp,
(depCacheFreeKey)rfree);
if (confcache) {
rpmdbIndexIterator ii = rpmdbIndexIteratorInit(rpmtsGetRdb(ts), RPMTAG_CONFLICTNAME);
if (ii) {
char *key;
size_t keylen;
while ((rpmdbIndexIteratorNext(ii, (const void**)&key, &keylen)) == 0) {
char *k;
if (!key || keylen == 0 || key[0] != '/')
continue;
k = rmalloc(keylen + 1);
memcpy(k, key, keylen);
k[keylen] = 0;
conflictsCacheAddEntry(confcache, k);
}
rpmdbIndexIteratorFree(ii);
}
}
/*
* Look at all of the added packages and make sure their dependencies
* are satisfied.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
rpmds provides = rpmdsInit(rpmteDS(p, RPMTAG_PROVIDENAME));
rpmlog(RPMLOG_DEBUG, "========== +++ %s %s/%s 0x%x\n",
rpmteNEVR(p), rpmteA(p), rpmteO(p), rpmteColor(p));
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_REQUIRENAME),
NULL, tscolor);
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_CONFLICTNAME),
NULL, tscolor);
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_OBSOLETENAME),
NULL, tscolor);
/* Check provides against conflicts in installed packages. */
while (rpmdsNext(provides) >= 0) {
checkInstDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, rpmdsN(provides));
}
/* Skip obsoletion checks for source packages (ie build) */
if (rpmteIsSource(p))
continue;
/* Check package name (not provides!) against installed obsoletes */
checkInstDeps(ts, dcache, p, RPMTAG_OBSOLETENAME, rpmteN(p));
/* Check filenames against installed conflicts */
if (conflictsCacheNumKeys(confcache)) {
rpmfi fi = rpmfiInit(rpmteFI(p), 0);
while (rpmfiNext(fi) >= 0) {
const char *fn = rpmfiFN(fi);
if (!conflictsCacheHasEntry(confcache, fn))
continue;
checkInstDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, fn);
}
}
}
rpmtsiFree(pi);
/*
* Look at the removed packages and make sure they aren't critical.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_REMOVED)) != NULL) {
rpmds provides = rpmdsInit(rpmteDS(p, RPMTAG_PROVIDENAME));
rpmfi fi = rpmfiInit(rpmteFI(p), 0);
rpmlog(RPMLOG_DEBUG, "========== --- %s %s/%s 0x%x\n",
rpmteNEVR(p), rpmteA(p), rpmteO(p), rpmteColor(p));
/* Check provides and filenames against installed dependencies. */
while (rpmdsNext(provides) >= 0) {
checkInstDeps(ts, dcache, p, RPMTAG_REQUIRENAME, rpmdsN(provides));
}
while (rpmfiNext(fi) >= 0) {
if (RPMFILE_IS_INSTALLED(rpmfiFState(fi)))
checkInstDeps(ts, dcache, p, RPMTAG_REQUIRENAME, rpmfiFN(fi));
}
}
rpmtsiFree(pi);
exit:
depCacheFree(dcache);
conflictsCacheFree(confcache);
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_CHECK), 0);
if (closeatexit)
(void) rpmtsCloseDB(ts);
return rc;
}