/*
* For packages being installed:
* - verify package arch/os.
* - verify package epoch:version-release is newer.
*/
static rpmps checkProblems(rpmts ts)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpmprobFilterFlags probFilter = rpmtsFilterFlags(ts);
rpmstrPool tspool = rpmtsPool(ts);
rpmtsi pi = rpmtsiInit(ts);
rpmte p;
/* The ordering doesn't matter here */
/* XXX Only added packages need be checked. */
rpmlog(RPMLOG_DEBUG, "sanity checking %d elements\n", rpmtsNElements(ts));
while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
if (!(probFilter & RPMPROB_FILTER_IGNOREARCH) && badArch(rpmteA(p)))
rpmteAddProblem(p, RPMPROB_BADARCH, rpmteA(p), NULL, 0);
if (!(probFilter & RPMPROB_FILTER_IGNOREOS) && badOs(rpmteO(p)))
rpmteAddProblem(p, RPMPROB_BADOS, rpmteO(p), NULL, 0);
if (!(probFilter & RPMPROB_FILTER_OLDPACKAGE)) {
Header h;
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(ts, RPMDBI_NAME, rpmteN(p), 0);
while ((h = rpmdbNextIterator(mi)) != NULL)
ensureOlder(tspool, p, h);
rpmdbFreeIterator(mi);
}
if (!(probFilter & RPMPROB_FILTER_REPLACEPKG)) {
Header h;
rpmdbMatchIterator mi;
mi = rpmtsPrunedIterator(ts, RPMDBI_NAME, rpmteN(p), 1);
rpmdbSetIteratorRE(mi, RPMTAG_EPOCH, RPMMIRE_STRCMP, rpmteE(p));
rpmdbSetIteratorRE(mi, RPMTAG_VERSION, RPMMIRE_STRCMP, rpmteV(p));
rpmdbSetIteratorRE(mi, RPMTAG_RELEASE, RPMMIRE_STRCMP, rpmteR(p));
if (tscolor) {
rpmdbSetIteratorRE(mi, RPMTAG_ARCH, RPMMIRE_STRCMP, rpmteA(p));
rpmdbSetIteratorRE(mi, RPMTAG_OS, RPMMIRE_STRCMP, rpmteO(p));
}
if ((h = rpmdbNextIterator(mi)) != NULL) {
rpmteAddProblem(p, RPMPROB_PKG_INSTALLED, NULL, NULL,
headerGetInstance(h));
}
rpmdbFreeIterator(mi);
}
if (!(probFilter & RPMPROB_FILTER_FORCERELOCATE))
rpmteAddRelocProblems(p);
}
rpmtsiFree(pi);
return rpmtsProblems(ts);
}
/* Check a given dependency against installed packages */
static void checkInstDeps(rpmts ts, depCache dcache, rpmte te,
rpmTag depTag, const char *dep)
{
Header h;
rpmdbMatchIterator mi = rpmtsPrunedIterator(ts, depTag, dep, 1);
rpmstrPool pool = rpmtsPool(ts);
/* require-problems are unsatisfied, others appear "satisfied" */
int is_problem = (depTag == RPMTAG_REQUIRENAME);
while ((h = rpmdbNextIterator(mi)) != NULL) {
char * pkgNEVRA;
rpmds ds;
/* Ignore self-obsoletes and self-conflicts */
if (depTag == RPMTAG_OBSOLETENAME || depTag == RPMTAG_CONFLICTNAME) {
unsigned int instance = headerGetInstance(h);
if (instance && instance == rpmteDBInstance(te))
continue;
}
pkgNEVRA = headerGetAsString(h, RPMTAG_NEVRA);
ds = rpmdsNewPool(pool, h, depTag, 0);
rpmdsSetIx(ds, rpmdbGetIteratorFileNum(mi));
if (unsatisfiedDepend(ts, dcache, ds) == is_problem)
rpmteAddDepProblem(te, pkgNEVRA, ds, NULL);
rpmdsFree(ds);
free(pkgNEVRA);
}
rpmdbFreeIterator(mi);
}
char* rpm_get_component(const char *filename, const char *rootdir_or_NULL)
{
#ifdef HAVE_LIBRPM
char *ret = NULL;
char *srpm = NULL;
rpmts ts;
rpmdbMatchIterator iter;
Header header;
if (rpm_query_file(&ts, &iter, &header, filename, rootdir_or_NULL) < 0)
return NULL;
if (!header)
goto error;
const char *errmsg = NULL;
srpm = headerFormat(header, "%{SOURCERPM}", &errmsg);
if (!srpm && errmsg)
{
error_msg("cannot get srpm. reason: %s", errmsg);
goto error;
}
ret = get_package_name_from_NVR_or_NULL(srpm);
free(srpm);
error:
rpmdbFreeIterator(iter);
rpmtsFree(ts);
return ret;
#else
return NULL;
#endif
}
/**
* Run trigger scripts in the database that are fired by this header.
* @param psm package state machine data
* @param sense trigger type
* @return 0 on success
*/
static rpmRC runTriggers(rpmpsm psm, rpmsenseFlags sense)
{
const rpmts ts = psm->ts;
int numPackage = -1;
const char * N = NULL;
int nerrors = 0;
if (psm->te) /* XXX can't happen */
N = rpmteN(psm->te);
if (N) /* XXX can't happen */
numPackage = rpmdbCountPackages(rpmtsGetRdb(ts), N)
+ psm->countCorrection;
if (numPackage < 0)
return RPMRC_NOTFOUND;
{ Header triggeredH;
Header h = rpmteHeader(psm->te);
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(ts, RPMDBI_TRIGGERNAME, N, 0);
while((triggeredH = rpmdbNextIterator(mi)) != NULL) {
nerrors += handleOneTrigger(ts, psm->te, sense, h, triggeredH,
0, numPackage, NULL);
}
rpmdbFreeIterator(mi);
headerFree(h);
}
return (nerrors == 0) ? RPMRC_OK : RPMRC_FAIL;
}
char *rpm_get_fingerprint(const char *pkg)
{
#ifdef HAVE_LIBRPM
char *fingerprint = NULL;
char *pgpsig = NULL;
const char *errmsg = NULL;
rpmts ts = rpmtsCreate();
rpmdbMatchIterator iter = rpmtsInitIterator(ts, RPMTAG_NAME, pkg, 0);
Header header = rpmdbNextIterator(iter);
if (!header)
goto error;
pgpsig = headerFormat(header, "%|SIGGPG?{%{SIGGPG:pgpsig}}:{%{SIGPGP:pgpsig}}|", &errmsg);
if (!pgpsig && errmsg)
{
log_notice("cannot get siggpg:pgpsig. reason: %s", errmsg);
goto error;
}
char *pgpsig_tmp = strstr(pgpsig, " Key ID ");
if (pgpsig_tmp)
fingerprint = xstrdup(pgpsig_tmp + sizeof(" Key ID ") - 1);
error:
free(pgpsig);
rpmdbFreeIterator(iter);
rpmtsFree(ts);
return fingerprint;
#else
return NULL;
#endif
}
static int rpm_query_file(rpmts *ts, rpmdbMatchIterator *iter, Header *header,
const char *filename, const char *rootdir_or_NULL)
{
const char *queryname = filename;
*ts = rpmtsCreate();
if (rootdir_or_NULL)
{
if (rpmtsSetRootDir(*ts, rootdir_or_NULL) != 0)
{
rpmtsFree(*ts);
return -1;
}
unsigned len = strlen(rootdir_or_NULL);
/* remove 'chroot' prefix */
if (strncmp(filename, rootdir_or_NULL, len) == 0 && filename[len] == '/')
queryname += len;
}
*iter = rpmtsInitIterator(*ts, RPMTAG_BASENAMES, queryname, 0);
*header = rpmdbNextIterator(*iter);
if (!(*header) && rootdir_or_NULL)
{
rpmdbFreeIterator(*iter);
rpmtsFree(*ts);
return rpm_query_file(ts, iter, header, filename, NULL);
}
return 0;
}
int rpmErase(rpmts ts, struct rpmInstallArguments_s * ia, ARGV_const_t argv)
{
char * const * arg;
char *qfmt = NULL;
int numFailed = 0;
int numPackages = 0;
rpmVSFlags vsflags, ovsflags;
if (argv == NULL) return 0;
vsflags = setvsFlags(ia);
ovsflags = rpmtsSetVSFlags(ts, vsflags);
(void) rpmtsSetFlags(ts, ia->transFlags);
setNotifyFlag(ia, ts);
qfmt = rpmExpand("%{?_query_all_fmt}\n", NULL);
for (arg = argv; *arg; arg++) {
rpmdbMatchIterator mi = rpmtsInitIterator(ts, RPMDBI_LABEL, *arg, 0);
int matches = rpmdbGetIteratorCount(mi);
int erasing = 1;
if (! matches) {
rpmlog(RPMLOG_ERR, _("package %s is not installed\n"), *arg);
numFailed++;
} else {
Header h; /* XXX iterator owns the reference */
if (matches > 1 &&
!(ia->installInterfaceFlags & UNINSTALL_ALLMATCHES)) {
rpmlog(RPMLOG_ERR, _("\"%s\" specifies multiple packages:\n"),
*arg);
numFailed++;
erasing = 0;
}
while ((h = rpmdbNextIterator(mi)) != NULL) {
if (erasing) {
(void) rpmtsAddEraseElement(ts, h, -1);
numPackages++;
} else {
char *nevra = headerFormat(h, qfmt, NULL);
rpmlog(RPMLOG_NOTICE, " %s", nevra);
free(nevra);
}
}
}
rpmdbFreeIterator(mi);
}
free(qfmt);
if (numFailed) goto exit;
numFailed = rpmcliTransaction(ts, ia, numPackages);
exit:
rpmtsEmpty(ts);
rpmtsSetVSFlags(ts, ovsflags);
return numFailed;
}
/**
* Check file info from header against what's actually installed.
* @param ts transaction set
* @param h header to verify
* @param omitMask bits to disable verify checks
* @param ghosts should ghosts be verified?
* @return 0 no problems, 1 problems found
*/
static int verifyHeader(rpmts ts, Header h, rpmVerifyAttrs omitMask, int ghosts)
{
rpmVerifyAttrs verifyResult = 0;
int ec = 0; /* assume no problems */
rpmfi fi = rpmfiNew(ts, h, RPMTAG_BASENAMES, RPMFI_FLAGS_VERIFY);
rpmfiInit(fi, 0);
while (rpmfiNext(fi) >= 0) {
rpmfileAttrs fileAttrs = rpmfiFFlags(fi);
char *buf = NULL, *attrFormat;
char ac;
int rc;
/* If not verifying %ghost, skip ghost files. */
if ((fileAttrs & RPMFILE_GHOST) && !ghosts)
continue;
rc = rpmVerifyFile(ts, fi, &verifyResult, omitMask);
/* Filter out timestamp differences of shared files */
if (rc == 0 && (verifyResult & RPMVERIFY_MTIME)) {
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(ts, RPMDBI_BASENAMES, rpmfiFN(fi), 0);
if (rpmdbGetIteratorCount(mi) > 1)
verifyResult &= ~RPMVERIFY_MTIME;
rpmdbFreeIterator(mi);
}
attrFormat = rpmFFlagsString(fileAttrs, "");
ac = rstreq(attrFormat, "") ? ' ' : attrFormat[0];
if (rc) {
if (!(fileAttrs & (RPMFILE_MISSINGOK|RPMFILE_GHOST)) || rpmIsVerbose()) {
rasprintf(&buf, _("missing %c %s"), ac, rpmfiFN(fi));
if ((verifyResult & RPMVERIFY_LSTATFAIL) != 0 &&
errno != ENOENT) {
char *app;
rasprintf(&app, " (%s)", strerror(errno));
rstrcat(&buf, app);
free(app);
}
ec = rc;
}
} else if (verifyResult || rpmIsVerbose()) {
char *verifyFormat = rpmVerifyString(verifyResult, ".");
rasprintf(&buf, "%s %c %s", verifyFormat, ac, rpmfiFN(fi));
free(verifyFormat);
if (verifyResult) ec = 1;
}
free(attrFormat);
if (buf) {
rpmlog(RPMLOG_NOTICE, "%s\n", buf);
buf = _free(buf);
}
}
rpmfiFree(fi);
return ec;
}
/* Add erase elements for older packages of same color (if any). */
static int addSelfErasures(rpmts ts, rpm_color_t tscolor, int op,
rpmte p, rpm_color_t hcolor, Header h)
{
Header oh;
rpmdbMatchIterator mi = rpmtsInitIterator(ts, RPMDBI_NAME, rpmteN(p), 0);
int rc = 0;
int cmp;
while((oh = rpmdbNextIterator(mi)) != NULL) {
/* Ignore colored packages not in our rainbow. */
if (skipColor(tscolor, hcolor, headerGetNumber(oh, RPMTAG_HEADERCOLOR)))
continue;
cmp = rpmVersionCompare(h, oh);
/* On upgrade, skip packages that contain identical NEVR. */
if ((op == RPMTE_UPGRADE) && (cmp == 0))
continue;
/* On reinstall, skip packages with differing NEVR. */
if ((op == RPMTE_REINSTALL) && (cmp != 0))
continue;
if (removePackage(ts, oh, p)) {
rc = 1;
break;
}
}
rpmdbFreeIterator(mi);
return rc;
}
static char *rpm_get_nvr_by_pkg_name(const char *pkg_name)
{
int status = rpmReadConfigFiles((const char *) NULL, (const char *) NULL);
if (status)
error_msg_and_die("error reading RPM rc files");
char *nvr = NULL;
rpmts ts = rpmtsCreate();
rpmdbMatchIterator iter = rpmtsInitIterator(ts, RPMTAG_NAME, pkg_name, 0);
Header header = rpmdbNextIterator(iter);
if (!header)
goto error;
const char *errmsg = NULL;
nvr = headerFormat(header, "%{name}-%{version}-%{release}", &errmsg);
if (!nvr && errmsg)
error_msg("cannot get nvr. reason: %s", errmsg);
error:
rpmdbFreeIterator(iter);
rpmtsFree(ts);
rpmFreeRpmrc();
rpmFreeCrypto();
rpmFreeMacros(NULL);
return nvr;
}
static matchFilesIter matchFilesIteratorFree(matchFilesIter mfi)
{
rpmfiFree(mfi->fi);
rpmfilesFree(mfi->files);
rpmdbFreeIterator(mfi->pi);
free(mfi);
return NULL;
}
/** \ingroup py_c
*/
static void rpmmi_dealloc(rpmmiObject * s)
{
if (s) {
s->mi = rpmdbFreeIterator(s->mi);
Py_DECREF(s->ref);
PyObject_Del(s);
}
}
static void
mi_free(rpm_mi_t* mi)
{
rpmdbFreeIterator(mi->mi);
#if RPM_VERSION_CODE < RPM_VERSION(4,9,0) || RPM_VERSION_CODE >= RPM_VERSION(5,0,0)
db_unref(mi->db);
#endif
free(mi);
}
static void
Check_HRSW_cache(void *xxx)
{
SWI_t *swi = (SWI_t *) xxx;
/*
* Make sure cache is up-to-date
*/
if (swi->swi_recs != NULL) {
struct stat sb;
lstat(swi->swi_directory, &sb);
if (swi->swi_timestamp == sb.st_mtime)
return;
swi->swi_timestamp = sb.st_mtime;
swi->swi_maxrec = 0;
}
/*
* Get header offsets
*/
{
int ix = 0;
int offset;
#if defined(RPMDBI_PACKAGES)
rpmdbMatchIterator mi = NULL;
Header h;
mi = rpmdbInitIterator(swi->swi_rpmdb, RPMDBI_PACKAGES, NULL, 0);
while ((h = rpmdbNextIterator(mi)) != NULL) {
offset = rpmdbGetIteratorOffset(mi);
#else
for (offset = rpmdbFirstRecNum(swi->swi_rpmdb);
offset != 0;
offset = rpmdbNextRecNum(swi->swi_rpmdb, offset)) {
#endif
if (ix >= swi->swi_maxrec) {
swi->swi_maxrec += 256;
swi->swi_recs = (swi->swi_recs == NULL)
? (int *) malloc(swi->swi_maxrec * sizeof(int))
: (int *) realloc(swi->swi_recs,
swi->swi_maxrec * sizeof(int));
}
swi->swi_recs[ix++] = offset;
#if !defined(RPMDBI_PACKAGES)
}
#else
}
rpmdbFreeIterator(mi);
#endif
swi->swi_nrec = ix;
}
}
void rpmtriggersPrepPostUnTransFileTrigs(rpmts ts, rpmte te)
{
rpmdbMatchIterator mi;
rpmdbIndexIterator ii;
Header trigH;
const void *key;
size_t keylen;
rpmfiles files;
rpmds rpmdsTriggers;
rpmds rpmdsTrigger;
int tix = 0;
ii = rpmdbIndexIteratorInit(rpmtsGetRdb(ts), RPMDBI_TRANSFILETRIGGERNAME);
mi = rpmdbNewIterator(rpmtsGetRdb(ts), RPMDBI_PACKAGES);
files = rpmteFiles(te);
/* Iterate over file triggers in rpmdb */
while ((rpmdbIndexIteratorNext(ii, &key, &keylen)) == 0) {
char pfx[keylen + 1];
memcpy(pfx, key, keylen);
pfx[keylen] = '\0';
/* Check if file trigger matches any file in this te */
rpmfi fi = rpmfilesFindPrefix(files, pfx);
if (rpmfiFC(fi) > 0) {
/* If yes then store it */
rpmdbAppendIterator(mi, rpmdbIndexIteratorPkgOffsets(ii),
rpmdbIndexIteratorNumPkgs(ii));
}
rpmfiFree(fi);
}
rpmdbIndexIteratorFree(ii);
if (rpmdbGetIteratorCount(mi)) {
/* Filter triggers and save only trans postun triggers into ts */
while((trigH = rpmdbNextIterator(mi)) != NULL) {
rpmdsTriggers = rpmdsNew(trigH, RPMTAG_TRANSFILETRIGGERNAME, 0);
while ((rpmdsTrigger = rpmdsFilterTi(rpmdsTriggers, tix))) {
if ((rpmdsNext(rpmdsTrigger) >= 0) &&
(rpmdsFlags(rpmdsTrigger) & RPMSENSE_TRIGGERPOSTUN)) {
struct rpmtd_s priorities;
headerGet(trigH, RPMTAG_TRANSFILETRIGGERPRIORITIES,
&priorities, HEADERGET_MINMEM);
rpmtdSetIndex(&priorities, tix);
rpmtriggersAdd(ts->trigs2run, rpmdbGetIteratorOffset(mi),
tix, *rpmtdGetUint32(&priorities));
}
rpmdsFree(rpmdsTrigger);
tix++;
}
rpmdsFree(rpmdsTriggers);
}
}
rpmdbFreeIterator(mi);
}
static PyObject *
rpmmi_iternext(rpmmiObject * s)
{
Header h;
if (s->mi == NULL || (h = rpmdbNextIterator(s->mi)) == NULL) {
s->mi = rpmdbFreeIterator(s->mi);
return NULL;
}
return (PyObject *) hdr_Wrap(h);
}
static const char *matchFilesNext(matchFilesIter mfi)
{
const char *matchFile = NULL;
int fx = 0;
/* Decide if we iterate over given files (mfi->files) */
if (!mfi->ts)
do {
/* Get next file from mfi->fi */
rpmfiNext(mfi->fi);
matchFile = rpmfiFN(mfi->fi);
if (strlen(matchFile))
break;
matchFile = NULL;
/* If we are done with current mfi->fi, create mfi->fi for next prefix */
fx = rpmdsNext(mfi->rpmdsTrigger);
mfi->pfx = rpmdsN(mfi->rpmdsTrigger);
rpmfiFree(mfi->fi);
mfi->fi = rpmfilesFindPrefix(mfi->files, mfi->pfx);
} while (fx >= 0);
/* or we iterate over files in rpmdb */
else
do {
rpmfiNext(mfi->fi);
matchFile = rpmfiFN(mfi->fi);
if (strlen(matchFile))
break;
matchFile = NULL;
/* If we are done with current mfi->fi, create mfi->fi for next package */
rpmfilesFree(mfi->files);
rpmfiFree(mfi->fi);
mfi->files = rpmtsNextFiles(mfi->ts, mfi->pi);
mfi->fi = rpmfilesFindPrefix(mfi->files, mfi->pfx);
if (mfi->files)
continue;
/* If we are done with all packages, go through packages with new prefix */
fx = rpmdsNext(mfi->rpmdsTrigger);
mfi->pfx = rpmdsN(mfi->rpmdsTrigger);
rpmdbFreeIterator(mfi->pi);
mfi->pi = rpmdbInitPrefixIterator(rpmtsGetRdb(mfi->ts),
RPMDBI_DIRNAMES, mfi->pfx, 0);
rpmdbFilterIterator(mfi->pi, mfi->tranPkgs, 0);
} while (fx >= 0);
return matchFile;
}
/* Add erase elements for obsoleted packages of same color (if any). */
static int addObsoleteErasures(rpmts ts, rpm_color_t tscolor, rpmte p)
{
rpmstrPool tspool = rpmtsPool(ts);
rpmds obsoletes = rpmdsInit(rpmteDS(p, RPMTAG_OBSOLETENAME));
Header oh;
int rc = 0;
while (rpmdsNext(obsoletes) >= 0 && rc == 0) {
const char * Name;
rpmdbMatchIterator mi = NULL;
if ((Name = rpmdsN(obsoletes)) == NULL)
continue; /* XXX can't happen */
mi = rpmtsPrunedIterator(ts, RPMDBI_NAME, Name, 1);
while((oh = rpmdbNextIterator(mi)) != NULL) {
const char *oarch = headerGetString(oh, RPMTAG_ARCH);
int match;
/* avoid self-obsoleting packages */
if (rstreq(rpmteN(p), Name) && rstreq(rpmteA(p), oarch)) {
char * ohNEVRA = headerGetAsString(oh, RPMTAG_NEVRA);
rpmlog(RPMLOG_DEBUG, " Not obsoleting: %s\n", ohNEVRA);
free(ohNEVRA);
continue;
}
/*
* Rpm prior to 3.0.3 does not have versioned obsoletes.
* If no obsoletes version info is available, match all names.
*/
match = (rpmdsEVR(obsoletes) == NULL);
if (!match)
match = rpmdsMatches(tspool, oh, -1, obsoletes, 1,
_rpmds_nopromote);
if (match) {
char * ohNEVRA = headerGetAsString(oh, RPMTAG_NEVRA);
rpmlog(RPMLOG_DEBUG, " Obsoletes: %s\t\terases %s\n",
rpmdsDNEVR(obsoletes)+2, ohNEVRA);
free(ohNEVRA);
if (removePackage(ts, oh, p)) {
rc = 1;
break;
}
}
}
rpmdbFreeIterator(mi);
}
return rc;
}
int
Save_HR_SW_info(int ix)
{
SWI_t *swi = &_myswi; /* XXX static for now */
#ifdef HAVE_LIBRPM
/*
* XXX Watchout: ix starts with 1
*/
if (1 <= ix && ix <= swi->swi_nrec && ix != swi->swi_prevx) {
int offset;
Header h;
char *n, *v, *r;
offset = swi->swi_recs[ix - 1];
{
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(swi->swi_rpmts, RPMDBI_PACKAGES,
&offset, sizeof(offset));
if ((h = rpmdbNextIterator(mi)) != NULL)
h = headerLink(h);
rpmdbFreeIterator(mi);
}
if (h == NULL) {
DEBUGMSGTL(("host/hr_swinst",
"RPM cache has probably expired when reading entry %d, "
"reloading...\n", ix));
swi->swi_timestamp = 0;
return -1;
}
if (swi->swi_h != NULL)
headerFree(swi->swi_h);
swi->swi_h = h;
swi->swi_prevx = ix;
headerGetEntry(swi->swi_h, RPMTAG_NAME, NULL, (void **) &n, NULL);
headerGetEntry(swi->swi_h, RPMTAG_VERSION, NULL, (void **) &v,
NULL);
headerGetEntry(swi->swi_h, RPMTAG_RELEASE, NULL, (void **) &r,
NULL);
snprintf(swi->swi_name, sizeof(swi->swi_name), "%s-%s-%s", n, v, r);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
}
#else
snprintf(swi->swi_name, sizeof(swi->swi_name), "%s", swi->swi_dep->d_name);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
#endif
return 0;
}
QueryData genRpmPackages(QueryContext& context) {
QueryData results;
auto dropper = DropPrivileges::get();
if (!dropper->dropTo("nobody") && isUserAdmin()) {
LOG(WARNING) << "Cannot drop privileges for rpm_packages";
return results;
}
// Isolate RPM/package inspection to the canonical: /usr/lib/rpm.
RpmEnvironmentManager env_manager;
// The following implementation uses http://rpm.org/api/4.11.1/
rpmInitCrypto();
if (rpmReadConfigFiles(nullptr, nullptr) != 0) {
TLOG << "Cannot read RPM configuration files";
return results;
}
rpmts ts = rpmtsCreate();
rpmdbMatchIterator matches;
if (context.constraints["name"].exists(EQUALS)) {
auto name = (*context.constraints["name"].getAll(EQUALS).begin());
matches = rpmtsInitIterator(ts, RPMTAG_NAME, name.c_str(), name.size());
} else {
matches = rpmtsInitIterator(ts, RPMTAG_NAME, nullptr, 0);
}
Header header;
while ((header = rpmdbNextIterator(matches)) != nullptr) {
Row r;
rpmtd td = rpmtdNew();
r["name"] = getRpmAttribute(header, RPMTAG_NAME, td);
r["version"] = getRpmAttribute(header, RPMTAG_VERSION, td);
r["release"] = getRpmAttribute(header, RPMTAG_RELEASE, td);
r["source"] = getRpmAttribute(header, RPMTAG_SOURCERPM, td);
r["size"] = getRpmAttribute(header, RPMTAG_SIZE, td);
r["sha1"] = getRpmAttribute(header, RPMTAG_SHA1HEADER, td);
r["arch"] = getRpmAttribute(header, RPMTAG_ARCH, td);
rpmtdFree(td);
results.push_back(r);
}
rpmdbFreeIterator(matches);
rpmtsFree(ts);
rpmFreeCrypto();
rpmFreeRpmrc();
return results;
}
void
Save_HR_SW_info(int ix)
{
SWI_t *swi = &_myswi; /* XXX static for now */
#ifdef HAVE_LIBRPM
/*
* XXX Watchout: ix starts with 1
*/
if (1 <= ix && ix <= swi->swi_nrec && ix != swi->swi_prevx) {
int offset;
Header h;
char *n, *v, *r;
offset = swi->swi_recs[ix - 1];
#if defined(RPMDBI_PACKAGES)
{
rpmdbMatchIterator mi;
mi = rpmdbInitIterator(swi->swi_rpmdb, RPMDBI_PACKAGES,
&offset, sizeof(offset));
if ((h = rpmdbNextIterator(mi)) != NULL)
h = headerLink(h);
rpmdbFreeIterator(mi);
}
#else
h = rpmdbGetRecord(swi->swi_rpmdb, offset);
#endif
if (h == NULL)
return;
if (swi->swi_h != NULL)
headerFree(swi->swi_h);
swi->swi_h = h;
swi->swi_prevx = ix;
headerGetEntry(swi->swi_h, RPMTAG_NAME, NULL, (void **) &n, NULL);
headerGetEntry(swi->swi_h, RPMTAG_VERSION, NULL, (void **) &v,
NULL);
headerGetEntry(swi->swi_h, RPMTAG_RELEASE, NULL, (void **) &r,
NULL);
snprintf(swi->swi_name, sizeof(swi->swi_name), "%s-%s-%s", n, v, r);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
}
#else
snprintf(swi->swi_name, sizeof(swi->swi_name), swi->swi_dep->d_name);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
#endif
}
/**
* Run triggers from this header that are fired by headers in the database.
* @param psm package state machine data
* @param sense trigger type
* @return 0 on success
*/
static rpmRC runImmedTriggers(rpmpsm psm, rpmsenseFlags sense)
{
const rpmts ts = psm->ts;
unsigned char * triggersRun;
struct rpmtd_s tnames, tindexes;
Header h = rpmteHeader(psm->te);
int nerrors = 0;
if (!(headerGet(h, RPMTAG_TRIGGERNAME, &tnames, HEADERGET_MINMEM) &&
headerGet(h, RPMTAG_TRIGGERINDEX, &tindexes, HEADERGET_MINMEM))) {
goto exit;
}
triggersRun = xcalloc(rpmtdCount(&tindexes), sizeof(*triggersRun));
{ Header sourceH = NULL;
const char *trigName;
rpm_count_t *triggerIndices = tindexes.data;
while ((trigName = rpmtdNextString(&tnames))) {
rpmdbMatchIterator mi;
int i = rpmtdGetIndex(&tnames);
if (triggersRun[triggerIndices[i]] != 0) continue;
mi = rpmtsInitIterator(ts, RPMDBI_NAME, trigName, 0);
while((sourceH = rpmdbNextIterator(mi)) != NULL) {
nerrors += handleOneTrigger(psm->ts, psm->te,
sense, sourceH, h,
psm->countCorrection,
rpmdbGetIteratorCount(mi),
triggersRun);
}
rpmdbFreeIterator(mi);
}
}
rpmtdFreeData(&tnames);
rpmtdFreeData(&tindexes);
free(triggersRun);
exit:
headerFree(h);
return (nerrors == 0) ? RPMRC_OK : RPMRC_FAIL;
}
/*
* --replacepkgs hack: find the header instance we're replacing and
* mark it as the db instance of the install element. In PSM_POST,
* if an install element already has a db instance, it's removed
* before proceeding with the adding the new header to the db.
*/
static void markReplacedInstance(rpmts ts, rpmte te)
{
rpmdbMatchIterator mi = rpmtsInitIterator(ts, RPMDBI_NAME, rpmteN(te), 0);
rpmdbSetIteratorRE(mi, RPMTAG_EPOCH, RPMMIRE_STRCMP, rpmteE(te));
rpmdbSetIteratorRE(mi, RPMTAG_VERSION, RPMMIRE_STRCMP, rpmteV(te));
rpmdbSetIteratorRE(mi, RPMTAG_RELEASE, RPMMIRE_STRCMP, rpmteR(te));
/* XXX shouldn't we also do this on colorless transactions? */
if (rpmtsColor(ts)) {
rpmdbSetIteratorRE(mi, RPMTAG_ARCH, RPMMIRE_STRCMP, rpmteA(te));
rpmdbSetIteratorRE(mi, RPMTAG_OS, RPMMIRE_STRCMP, rpmteO(te));
}
while (rpmdbNextIterator(mi) != NULL) {
rpmteSetDBInstance(te, rpmdbGetIteratorOffset(mi));
break;
}
rpmdbFreeIterator(mi);
}
/* Check a given dependency type against installed packages */
static void checkInstDeps(rpmts ts, depCache dcache, rpmte te,
rpmTag depTag, const char *dep)
{
Header h;
rpmdbMatchIterator mi = rpmtsPrunedIterator(ts, depTag, dep, 1);
rpmstrPool pool = rpmtsPool(ts);
while ((h = rpmdbNextIterator(mi)) != NULL) {
char * pkgNEVRA = headerGetAsString(h, RPMTAG_NEVRA);
rpmds ds = rpmdsNewPool(pool, h, depTag, 0);
checkDS(ts, dcache, te, pkgNEVRA, ds, dep, 0);
rpmdsFree(ds);
free(pkgNEVRA);
}
rpmdbFreeIterator(mi);
}
int ssds_add_to_erase(rpmts ts, char *pkg){
Header hdr;
rpmdbMatchIterator mi;
int rc = OK;
/* Locate the package and add for erasure */
mi = rpmtsInitIterator(ts, (rpmTag)RPMDBI_LABEL, pkg, 0);
while ((hdr = rpmdbNextIterator(mi)) != NULL) {
int recOffset = rpmdbGetIteratorOffset(mi);
if (recOffset) {
rc = rpmtsAddEraseElement(ts, hdr, recOffset);
if (rc)
ssds_log(logERROR, "Error adding %s to transaction.\n", pkg);
}
}
mi = rpmdbFreeIterator(mi);
return rc;
}
int add_for_erase(rpmts ts, char *name)
{
Header hdr;
rpmdbMatchIterator mi;
int rc = 0;
/* Locate the package and add for erasure */
mi = rpmtsInitIterator(ts, (rpmTag)RPMDBI_LABEL, name, 0);
while ((hdr = rpmdbNextIterator(mi)) != NULL) {
int recOffset = rpmdbGetIteratorOffset(mi);
if (recOffset) {
rc = rpmtsAddEraseElement(ts, hdr, recOffset);
if (rc)
printf("Error adding %s to transaction", name);
}
}
mi = rpmdbFreeIterator(mi);
return rc;
}
void RpmTransaction::addToTransactionRemove(const StringVector& files)
{
for (StringVector::size_type i = 0;i < files.size();i++)
{
rpmdbMatchIterator MI;
MI = rpmdbInitIterator(m_db, RPMDBI_LABEL, files[i].c_str(), 0);
Header hdr;
while ((hdr = rpmdbNextIterator(MI)) != NULL)
{
const unsigned int recOffset = rpmdbGetIteratorOffset(MI);
if (recOffset)
{
const int rc = rpmtransRemovePackage(m_ts, recOffset);
if (rc != 0)
throw PkgBackEndException("rpmtransRemovePackage()");
}
}
MI = rpmdbFreeIterator(MI);
}
}
QueryData genRpmPackages(QueryContext& context) {
QueryData results;
// The following implementation uses http://rpm.org/api/4.11.1/
rpmInitCrypto();
if (rpmReadConfigFiles(nullptr, nullptr) != 0) {
TLOG << "Cannot read RPM configuration files.";
return results;
}
rpmts ts = rpmtsCreate();
rpmdbMatchIterator matches;
if (context.constraints["name"].exists()) {
auto name = (*context.constraints["name"].getAll(EQUALS).begin());
matches = rpmtsInitIterator(ts, RPMTAG_NAME, name.c_str(), name.size());
} else {
matches = rpmtsInitIterator(ts, RPMTAG_NAME, nullptr, 0);
}
Header header;
while ((header = rpmdbNextIterator(matches)) != nullptr) {
Row r;
rpmtd td = rpmtdNew();
r["name"] = getRpmAttribute(header, RPMTAG_NAME, td);
r["version"] = getRpmAttribute(header, RPMTAG_VERSION, td);
r["release"] = getRpmAttribute(header, RPMTAG_RELEASE, td);
r["source"] = getRpmAttribute(header, RPMTAG_SOURCERPM, td);
r["size"] = getRpmAttribute(header, RPMTAG_SIZE, td);
r["sha1"] = getRpmAttribute(header, RPMTAG_SHA1HEADER, td);
r["arch"] = getRpmAttribute(header, RPMTAG_ARCH, td);
rpmtdFree(td);
results.push_back(r);
}
rpmdbFreeIterator(matches);
rpmtsFree(ts);
rpmFreeCrypto();
rpmFreeRpmrc();
return results;
}
uint32_t
TDNFTransAddErasePkg(
PTDNFRPMTS pTS,
HyPackage hPkg
)
{
uint32_t dwError = 0;
Header pRpmHeader = NULL;
rpmdbMatchIterator pIterator = NULL;
const char* pszName = NULL;
unsigned int nOffset = 0;
if(!pTS || !hPkg)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
pszName = hy_package_get_name(hPkg);
pIterator = rpmtsInitIterator(pTS->pTS, (rpmTag)RPMDBI_LABEL, pszName, 0);
while ((pRpmHeader = rpmdbNextIterator(pIterator)) != NULL)
{
nOffset = rpmdbGetIteratorOffset(pIterator);
if(nOffset)
{
dwError = rpmtsAddEraseElement(pTS->pTS, pRpmHeader, nOffset);
BAIL_ON_TDNF_ERROR(dwError);
}
}
cleanup:
if(pIterator)
{
rpmdbFreeIterator(pIterator);
}
return dwError;
error:
goto cleanup;
}
/* On --freshen, verify package is installed and newer */
static int checkFreshenStatus(rpmts ts, Header h)
{
rpmdbMatchIterator mi = NULL;
const char * name = headerGetString(h, RPMTAG_NAME);
const char *arch = headerGetString(h, RPMTAG_ARCH);
Header oldH = NULL;
if (name != NULL)
mi = rpmtsInitIterator(ts, RPMDBI_NAME, name, 0);
if (rpmtsColor(ts) && arch)
rpmdbSetIteratorRE(mi, RPMTAG_ARCH, RPMMIRE_DEFAULT, arch);
while ((oldH = rpmdbNextIterator(mi)) != NULL) {
/* Package is newer than those currently installed. */
if (rpmVersionCompare(oldH, h) < 0)
break;
}
rpmdbFreeIterator(mi);
return (oldH != NULL);
}
