/**
* Check installed package dependencies for problems.
* @param qva parsed query/verify options
* @param ts transaction set
* @param h header
* @return number of problems found (0 for no problems)
*/
static int verifyDependencies(QVA_t qva, rpmts ts,
Header h)
{
rpmps ps;
rpmpsi psi;
int rc = 0; /* assume no problems */
int xx;
rpmtsEmpty(ts);
(void) rpmtsAddInstallElement(ts, h, NULL, 0, NULL);
xx = rpmtsCheck(ts);
ps = rpmtsProblems(ts);
psi = rpmpsInitIterator(ps);
if (rpmpsNumProblems(ps) > 0) {
char *nevra = headerGetNEVRA(h, NULL);
rpmlog(RPMLOG_NOTICE, _("Unsatisfied dependencies for %s:\n"), nevra);
free(nevra);
while (rpmpsNextIterator(psi) >= 0) {
rpmProblem p = rpmpsGetProblem(psi);
char * ps = rpmProblemString(p);
rpmlog(RPMLOG_NOTICE, "\t%s\n", ps);
free(ps);
rc++;
}
}
psi = rpmpsFreeIterator(psi);
ps = rpmpsFree(ps);
rpmtsEmpty(ts);
return rc;
}
/**
* Check installed package dependencies for problems.
* @param ts transaction set
* @param h header
* @return number of problems found (0 for no problems)
*/
static int verifyDependencies(rpmts ts, Header h)
{
rpmps ps;
rpmte te;
int rc;
rpmtsEmpty(ts);
(void) rpmtsAddInstallElement(ts, h, NULL, 0, NULL);
(void) rpmtsCheck(ts);
te = rpmtsElement(ts, 0);
ps = rpmteProblems(te);
rc = rpmpsNumProblems(ps);
if (rc > 0) {
rpmlog(RPMLOG_NOTICE, _("Unsatisfied dependencies for %s:\n"),
rpmteNEVRA(te));
rpmpsi psi = rpmpsInitIterator(ps);
rpmProblem p;
while ((p = rpmpsiNext(psi)) != NULL) {
char * ps = rpmProblemString(p);
rpmlog(RPMLOG_NOTICE, "\t%s\n", ps);
free(ps);
}
rpmpsFreeIterator(psi);
}
rpmpsFree(ps);
rpmtsEmpty(ts);
return rc;
}
/**
* Return exit code from running verify script from header.
* @todo malloc/free/refcount handling is fishy here.
* @param qva parsed query/verify options
* @param ts transaction set
* @param h header
* @param scriptFd file handle to use for stderr (or NULL)
* @return 0 on success
*/
static int rpmVerifyScript(QVA_t qva, rpmts ts, Header h, FD_t scriptFd)
{
rpmpsm psm = NULL;
rpmte te = NULL;
int rc = 0;
/* fake up a erasure transaction element */
rc = rpmtsAddEraseElement(ts, h, -1);
te = rpmtsElement(ts, 0);
rpmteOpen(te, ts, 0);
if (scriptFd != NULL)
rpmtsSetScriptFd(ts, scriptFd);
/* create psm to run the script */
psm = rpmpsmNew(ts, te);
rpmpsmScriptStage(psm, RPMTAG_VERIFYSCRIPT, RPMTAG_VERIFYSCRIPTPROG);
rc = rpmpsmStage(psm, PSM_SCRIPT);
psm = rpmpsmFree(psm);
if (scriptFd != NULL)
rpmtsSetScriptFd(ts, NULL);
/* clean up our fake transaction bits */
rpmteClose(te, ts, 0);
rpmtsEmpty(ts);
return rc;
}
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;
}
static PyObject *
rpmts_Clear(rpmtsObject * s)
{
rpmtsEmpty(s->ts);
Py_RETURN_NONE;
}
/**
* @todo Create transaction set *much* earlier.
*/
static rpmRC cpio_doio(FD_t fdo, Header h, CSA_t csa,
const char * fmodeMacro)
{
rpmts ts = rpmtsCreate();
rpmfi fi = csa->cpioList;
rpmte te = NULL;
rpmfs fs = NULL;
char *failedFile = NULL;
FD_t cfd;
rpmRC rc = RPMRC_OK;
int xx, i;
{ char *fmode = rpmExpand(fmodeMacro, NULL);
if (!(fmode && fmode[0] == 'w'))
fmode = xstrdup("w9.gzdio");
(void) Fflush(fdo);
cfd = Fdopen(fdDup(Fileno(fdo)), fmode);
fmode = _free(fmode);
}
if (cfd == NULL)
return RPMRC_FAIL;
/* make up a transaction element for passing to fsm */
rpmtsAddInstallElement(ts, h, NULL, 0, NULL);
te = rpmtsElement(ts, 0);
fs = rpmteGetFileStates(te);
fi = rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0) {
if (rpmfiFFlags(fi) & RPMFILE_GHOST)
rpmfsSetAction(fs, i, FA_SKIP);
else
rpmfsSetAction(fs, i, FA_COPYOUT);
}
xx = fsmSetup(rpmfiFSM(fi), FSM_PKGBUILD, ts, te, fi, cfd,
&csa->cpioArchiveSize, &failedFile);
if (xx)
rc = RPMRC_FAIL;
(void) Fclose(cfd);
xx = fsmTeardown(rpmfiFSM(fi));
if (rc == RPMRC_OK && xx) rc = RPMRC_FAIL;
if (rc) {
if (failedFile)
rpmlog(RPMLOG_ERR, _("create archive failed on file %s: %s\n"),
failedFile, cpioStrerror(rc));
else
rpmlog(RPMLOG_ERR, _("create archive failed: %s\n"),
cpioStrerror(rc));
rc = RPMRC_FAIL;
}
rpmtsEmpty(ts);
failedFile = _free(failedFile);
ts = rpmtsFree(ts);
return rc;
}
int rpmcliVerify(rpmts ts, QVA_t qva, char * const * argv)
{
rpmVSFlags vsflags, ovsflags;
int ec = 0, xx;
const char * rootDir = rpmtsRootDir(ts);
/*
* Open the DB + indices explicitly before possible chroot,
* otherwises BDB is going to be unhappy...
*/
rpmtsOpenDB(ts, O_RDONLY);
rpmdbOpenAll(rpmtsGetRdb(ts));
if (rootDir && strcmp(rootDir, "/") != 0) {
if (chroot(rootDir) == -1) {
rpmlog(RPMLOG_ERR, _("Unable to change root directory: %m\n"));
ec = 1;
goto exit;
} else {
rpmtsSetChrootDone(ts, 1);
}
}
if (qva->qva_showPackage == NULL)
qva->qva_showPackage = showVerifyPackage;
/* XXX verify flags are inverted from query. */
vsflags = rpmExpandNumeric("%{?_vsflags_verify}");
if (!(qva->qva_flags & VERIFY_DIGEST))
vsflags |= _RPMVSF_NODIGESTS;
if (!(qva->qva_flags & VERIFY_SIGNATURE))
vsflags |= _RPMVSF_NOSIGNATURES;
if (!(qva->qva_flags & VERIFY_HDRCHK))
vsflags |= RPMVSF_NOHDRCHK;
vsflags &= ~RPMVSF_NEEDPAYLOAD;
ovsflags = rpmtsSetVSFlags(ts, vsflags);
ec = rpmcliArgIter(ts, qva, argv);
vsflags = rpmtsSetVSFlags(ts, ovsflags);
if (qva->qva_showPackage == showVerifyPackage)
qva->qva_showPackage = NULL;
rpmtsEmpty(ts);
if (rpmtsChrootDone(ts)) {
/* only done if previous chroot succeeded, assume success */
xx = chroot(".");
rpmtsSetChrootDone(ts, 0);
}
exit:
return ec;
}
int rpmcliVerify(rpmts ts, QVA_t qva, char * const * argv)
{
rpmVSFlags vsflags, ovsflags;
int ec = 0;
FD_t scriptFd = fdDup(STDOUT_FILENO);
/*
* Open the DB + indices explicitly before possible chroot,
* otherwises BDB is going to be unhappy...
*/
rpmtsOpenDB(ts, O_RDONLY);
rpmdbOpenAll(rpmtsGetRdb(ts));
if (rpmChrootSet(rpmtsRootDir(ts)) || rpmChrootIn()) {
ec = 1;
goto exit;
}
if (qva->qva_showPackage == NULL)
qva->qva_showPackage = showVerifyPackage;
vsflags = rpmExpandNumeric("%{?_vsflags_verify}");
if (rpmcliQueryFlags & VERIFY_DIGEST)
vsflags |= _RPMVSF_NODIGESTS;
if (rpmcliQueryFlags & VERIFY_SIGNATURE)
vsflags |= _RPMVSF_NOSIGNATURES;
if (rpmcliQueryFlags & VERIFY_HDRCHK)
vsflags |= RPMVSF_NOHDRCHK;
vsflags &= ~RPMVSF_NEEDPAYLOAD;
rpmtsSetScriptFd(ts, scriptFd);
ovsflags = rpmtsSetVSFlags(ts, vsflags);
ec = rpmcliArgIter(ts, qva, argv);
vsflags = rpmtsSetVSFlags(ts, ovsflags);
rpmtsSetScriptFd(ts, NULL);
if (qva->qva_showPackage == showVerifyPackage)
qva->qva_showPackage = NULL;
rpmtsEmpty(ts);
if (rpmChrootOut() || rpmChrootSet(NULL))
ec = 1;
exit:
Fclose(scriptFd);
return ec;
}
/*************************************************************************
* FUNCTION : RPMTransaction_Set::Clear *
* ARGUMENTS : none *
* RETURNS : TCL_OK or TCL_ERROR *
* EXCEPTIONS : none *
* PURPOSE : Clear the list of transactions *
*************************************************************************/
int RPMTransaction_Set::Clear(Tcl_Interp *interp,int objc, Tcl_Obj *const objv[])
{
if (objc != 2)
{
Tcl_WrongNumArgs(interp,2,objv,0);
return TCL_ERROR;
}
rpmtsEmpty(transaction);
// Free any header objects we've created
if (header_list)
{
Tcl_DecrRefCount(header_list);
header_list = 0;
}
return TCL_OK;
}
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;
}
static JSBool
rpmts_run(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
void * ptr = JS_GetInstancePrivate(cx, obj, &rpmtsClass, NULL);
rpmts ts = ptr;
JSBool ok = JS_FALSE;
_METHOD_DEBUG_ENTRY(_debug);
#ifdef NOTYET
/* XXX force --test instead. */
if (rpmtsNElements(ts) > 0)
(void) rpmcliInstallRun(ts, NULL, 0);
#else
rpmtsEmpty(ts);
#endif
ok = JS_TRUE;
*rval = BOOLEAN_TO_JSVAL(ok); /* XXX return error */
return ok;
}
int rpmcliVerify(rpmts ts, QVA_t qva, const char ** argv)
{
rpmdepFlags depFlags = qva->depFlags, odepFlags;
rpmtransFlags transFlags = qva->transFlags, otransFlags;
rpmVSFlags vsflags, ovsflags;
int ec = 0;
#if defined(_OPENMP)
(void) tagName(0); /* XXX instantiate the tagname store. */
omp_set_nested(1); /* XXX permit nested thread teams. */
#endif
if (qva->qva_showPackage == NULL)
qva->qva_showPackage = showVerifyPackage;
/* XXX verify flags are inverted from query. */
vsflags = rpmExpandNumeric("%{?_vsflags_verify}");
if (!(qva->qva_flags & VERIFY_DIGEST))
vsflags |= _RPMVSF_NODIGESTS;
if (!(qva->qva_flags & VERIFY_SIGNATURE))
vsflags |= _RPMVSF_NOSIGNATURES;
if (!(qva->qva_flags & VERIFY_HDRCHK))
vsflags |= RPMVSF_NOHDRCHK;
vsflags &= ~RPMVSF_NEEDPAYLOAD;
odepFlags = rpmtsSetDFlags(ts, depFlags);
otransFlags = rpmtsSetFlags(ts, transFlags);
ovsflags = rpmtsSetVSFlags(ts, vsflags);
ec = rpmcliArgIter(ts, qva, argv);
vsflags = rpmtsSetVSFlags(ts, ovsflags);
transFlags = rpmtsSetFlags(ts, otransFlags);
depFlags = rpmtsSetDFlags(ts, odepFlags);
if (qva->qva_showPackage == showVerifyPackage)
qva->qva_showPackage = NULL;
rpmtsEmpty(ts);
return ec;
}
/** @todo Generalize --freshen policies. */
int rpmInstall(rpmts ts, struct rpmInstallArguments_s * ia, ARGV_t fileArgv)
{
struct rpmEIU * eiu = xcalloc(1, sizeof(*eiu));
rpmRelocation * relocations;
char * fileURL = NULL;
rpmVSFlags vsflags, ovsflags;
int rc;
int i;
vsflags = setvsFlags(ia);
ovsflags = rpmtsSetVSFlags(ts, (vsflags | RPMVSF_NEEDPAYLOAD));
if (fileArgv == NULL) goto exit;
(void) rpmtsSetFlags(ts, ia->transFlags);
relocations = ia->relocations;
setNotifyFlag(ia, ts);
if ((eiu->relocations = relocations) != NULL) {
while (eiu->relocations->oldPath)
eiu->relocations++;
if (eiu->relocations->newPath == NULL)
eiu->relocations = NULL;
}
/* Build fully globbed list of arguments in argv[argc]. */
for (eiu->fnp = fileArgv; *eiu->fnp != NULL; eiu->fnp++) {
ARGV_t av = NULL;
int ac = 0;
if (giFlags & RPMGI_NOGLOB) {
rc = rpmNoGlob(*eiu->fnp, &ac, &av);
} else {
char * fn = rpmEscapeSpaces(*eiu->fnp);
rc = rpmGlob(fn, &ac, &av);
fn = _free(fn);
}
if (rc || ac == 0) {
if (giFlags & RPMGI_NOGLOB) {
rpmlog(RPMLOG_ERR, _("File not found: %s\n"), *eiu->fnp);
} else {
rpmlog(RPMLOG_ERR, _("File not found by glob: %s\n"), *eiu->fnp);
}
eiu->numFailed++;
continue;
}
argvAppend(&(eiu->argv), av);
argvFree(av);
eiu->argc += ac;
}
restart:
/* Allocate sufficient storage for next set of args. */
if (eiu->pkgx >= eiu->numPkgs) {
eiu->numPkgs = eiu->pkgx + eiu->argc;
eiu->pkgURL = xrealloc(eiu->pkgURL,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgURL));
memset(eiu->pkgURL + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgURL)));
eiu->pkgState = xrealloc(eiu->pkgState,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgState));
memset(eiu->pkgState + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgState)));
}
/* Retrieve next set of args, cache on local storage. */
for (i = 0; i < eiu->argc; i++) {
fileURL = _free(fileURL);
fileURL = eiu->argv[i];
eiu->argv[i] = NULL;
switch (urlIsURL(fileURL)) {
case URL_IS_HTTPS:
case URL_IS_HTTP:
case URL_IS_FTP:
{ char *tfn = NULL;
FD_t tfd;
if (rpmIsVerbose())
fprintf(stdout, _("Retrieving %s\n"), fileURL);
tfd = rpmMkTempFile(rpmtsRootDir(ts), &tfn);
if (tfd && tfn) {
Fclose(tfd);
rc = urlGetFile(fileURL, tfn);
} else {
rc = -1;
}
if (rc != 0) {
rpmlog(RPMLOG_ERR,
_("skipping %s - transfer failed\n"), fileURL);
eiu->numFailed++;
eiu->pkgURL[eiu->pkgx] = NULL;
tfn = _free(tfn);
break;
}
eiu->pkgState[eiu->pkgx] = 1;
eiu->pkgURL[eiu->pkgx] = tfn;
eiu->pkgx++;
} break;
case URL_IS_PATH:
case URL_IS_DASH: /* WRONG WRONG WRONG */
case URL_IS_HKP: /* WRONG WRONG WRONG */
default:
eiu->pkgURL[eiu->pkgx] = fileURL;
fileURL = NULL;
eiu->pkgx++;
break;
}
}
fileURL = _free(fileURL);
if (eiu->numFailed) goto exit;
/* Continue processing file arguments, building transaction set. */
for (eiu->fnp = eiu->pkgURL+eiu->prevx;
*eiu->fnp != NULL;
eiu->fnp++, eiu->prevx++)
{
Header h = NULL;
const char * fileName;
rpmlog(RPMLOG_DEBUG, "============== %s\n", *eiu->fnp);
(void) urlPath(*eiu->fnp, &fileName);
if (tryReadHeader(ts, eiu, &h) == RPMRC_FAIL)
continue;
if (eiu->rpmrc == RPMRC_NOTFOUND) {
rc = tryReadManifest(eiu);
if (rc == RPMRC_OK) {
eiu->prevx++;
goto restart;
}
}
if (headerIsSource(h)) {
if (ia->installInterfaceFlags & INSTALL_FRESHEN) {
headerFree(h);
continue;
}
rpmlog(RPMLOG_DEBUG, "\tadded source package [%d]\n",
eiu->numSRPMS);
eiu->sourceURL = xrealloc(eiu->sourceURL,
(eiu->numSRPMS + 2) * sizeof(*eiu->sourceURL));
eiu->sourceURL[eiu->numSRPMS] = *eiu->fnp;
*eiu->fnp = NULL;
eiu->numSRPMS++;
eiu->sourceURL[eiu->numSRPMS] = NULL;
continue;
}
if (eiu->relocations) {
struct rpmtd_s prefixes;
headerGet(h, RPMTAG_PREFIXES, &prefixes, HEADERGET_DEFAULT);
if (rpmtdCount(&prefixes) == 1) {
eiu->relocations->oldPath = xstrdup(rpmtdGetString(&prefixes));
rpmtdFreeData(&prefixes);
} else {
rpmlog(RPMLOG_ERR, _("package %s is not relocatable\n"),
headerGetString(h, RPMTAG_NAME));
eiu->numFailed++;
goto exit;
}
}
if (ia->installInterfaceFlags & INSTALL_FRESHEN)
if (checkFreshenStatus(ts, h) != 1) {
headerFree(h);
continue;
}
if (ia->installInterfaceFlags & INSTALL_REINSTALL)
rc = rpmtsAddReinstallElement(ts, h, (fnpyKey)fileName);
else
rc = rpmtsAddInstallElement(ts, h, (fnpyKey)fileName,
(ia->installInterfaceFlags & INSTALL_UPGRADE) != 0,
relocations);
headerFree(h);
if (eiu->relocations)
eiu->relocations->oldPath = _free(eiu->relocations->oldPath);
switch (rc) {
case 0:
rpmlog(RPMLOG_DEBUG, "\tadded binary package [%d]\n",
eiu->numRPMS);
break;
case 1:
rpmlog(RPMLOG_ERR,
_("error reading from file %s\n"), *eiu->fnp);
eiu->numFailed++;
goto exit;
break;
default:
eiu->numFailed++;
goto exit;
break;
}
eiu->numRPMS++;
}
rpmlog(RPMLOG_DEBUG, "found %d source and %d binary packages\n",
eiu->numSRPMS, eiu->numRPMS);
if (eiu->numFailed) goto exit;
if (eiu->numRPMS) {
int rc = rpmcliTransaction(ts, ia, eiu->numPkgs);
if (rc < 0)
eiu->numFailed += eiu->numRPMS;
else if (rc > 0)
eiu->numFailed += rc;
}
if (eiu->numSRPMS && (eiu->sourceURL != NULL)) {
rpmcliProgressState = 0;
rpmcliProgressTotal = 0;
rpmcliProgressCurrent = 0;
for (i = 0; i < eiu->numSRPMS; i++) {
rpmsqPoll();
if (eiu->sourceURL[i] != NULL) {
rc = RPMRC_OK;
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_TEST))
rc = rpmInstallSource(ts, eiu->sourceURL[i], NULL, NULL);
if (rc != 0)
eiu->numFailed++;
}
}
}
exit:
if (eiu->pkgURL != NULL) {
for (i = 0; i < eiu->numPkgs; i++) {
if (eiu->pkgURL[i] == NULL) continue;
if (eiu->pkgState[i] == 1)
(void) unlink(eiu->pkgURL[i]);
eiu->pkgURL[i] = _free(eiu->pkgURL[i]);
}
}
eiu->pkgState = _free(eiu->pkgState);
eiu->pkgURL = _free(eiu->pkgURL);
eiu->argv = _free(eiu->argv);
rc = eiu->numFailed;
free(eiu);
rpmtsEmpty(ts);
rpmtsSetVSFlags(ts, ovsflags);
return rc;
}
int rpmErase(rpmts ts, struct rpmInstallArguments_s * ia, ARGV_const_t argv)
{
char * const * arg;
char *qfmt = NULL;
int numFailed = 0;
int stopUninstall = 0;
int numPackages = 0;
rpmVSFlags vsflags, ovsflags;
rpmps ps;
if (argv == NULL) return 0;
vsflags = rpmExpandNumeric("%{?_vsflags_erase}");
if (ia->qva_flags & VERIFY_DIGEST)
vsflags |= _RPMVSF_NODIGESTS;
if (ia->qva_flags & VERIFY_SIGNATURE)
vsflags |= _RPMVSF_NOSIGNATURES;
if (ia->qva_flags & VERIFY_HDRCHK)
vsflags |= RPMVSF_NOHDRCHK;
ovsflags = rpmtsSetVSFlags(ts, vsflags);
/* XXX suggest mechanism only meaningful when installing */
ia->transFlags |= RPMTRANS_FLAG_NOSUGGEST;
(void) rpmtsSetFlags(ts, ia->transFlags);
#ifdef NOTYET /* XXX no callbacks on erase yet */
{ int notifyFlags, xx;
notifyFlags = ia->eraseInterfaceFlags | (rpmIsVerbose() ? INSTALL_LABEL : 0 );
xx = rpmtsSetNotifyCallback(ts,
rpmShowProgress, (void *) ((long)notifyFlags));
}
#endif
qfmt = rpmExpand("%{?_query_all_fmt}\n", NULL);
for (arg = argv; *arg; arg++) {
rpmdbMatchIterator mi;
int matches = 0;
int erasing = 1;
/* Iterator count isn't reliable with labels, count manually... */
mi = rpmtsInitIterator(ts, RPMDBI_LABEL, *arg, 0);
while (rpmdbNextIterator(mi) != NULL) {
matches++;
}
rpmdbFreeIterator(mi);
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->eraseInterfaceFlags & UNINSTALL_ALLMATCHES)) {
rpmlog(RPMLOG_ERR, _("\"%s\" specifies multiple packages:\n"),
*arg);
numFailed++;
erasing = 0;
}
mi = rpmtsInitIterator(ts, RPMDBI_LABEL, *arg, 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);
}
}
mi = rpmdbFreeIterator(mi);
}
}
free(qfmt);
if (numFailed) goto exit;
if (!(ia->eraseInterfaceFlags & UNINSTALL_NODEPS)) {
if (rpmtsCheck(ts)) {
numFailed = numPackages;
stopUninstall = 1;
}
ps = rpmtsProblems(ts);
if (!stopUninstall && rpmpsNumProblems(ps) > 0) {
rpmlog(RPMLOG_ERR, _("Failed dependencies:\n"));
rpmpsPrint(NULL, ps);
numFailed += numPackages;
stopUninstall = 1;
}
ps = rpmpsFree(ps);
}
if (!stopUninstall && !(ia->installInterfaceFlags & INSTALL_NOORDER)) {
if (rpmtsOrder(ts)) {
numFailed += numPackages;
stopUninstall = 1;
}
}
if (numPackages && !stopUninstall) {
(void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | RPMTRANS_FLAG_REVERSE));
/* Drop added/available package indices and dependency sets. */
rpmtsClean(ts);
numPackages = rpmtsRun(ts, NULL, ia->probFilter & (RPMPROB_FILTER_DISKSPACE|RPMPROB_FILTER_DISKNODES));
ps = rpmtsProblems(ts);
if (rpmpsNumProblems(ps) > 0)
rpmpsPrint(NULL, ps);
numFailed += numPackages;
stopUninstall = 1;
ps = rpmpsFree(ps);
}
exit:
rpmtsEmpty(ts);
return numFailed;
}
/** @todo Generalize --freshen policies. */
int rpmInstall(rpmts ts, struct rpmInstallArguments_s * ia, ARGV_t fileArgv)
{
struct rpmEIU * eiu = xcalloc(1, sizeof(*eiu));
rpmps ps;
rpmprobFilterFlags probFilter;
rpmRelocation * relocations;
char * fileURL = NULL;
int stopInstall = 0;
rpmVSFlags vsflags, ovsflags, tvsflags;
int rc;
int xx;
int i;
if (fileArgv == NULL) goto exit;
rpmcliPackagesTotal = 0;
(void) rpmtsSetFlags(ts, ia->transFlags);
probFilter = ia->probFilter;
relocations = ia->relocations;
if (ia->installInterfaceFlags & INSTALL_UPGRADE)
vsflags = rpmExpandNumeric("%{?_vsflags_erase}");
else
vsflags = rpmExpandNumeric("%{?_vsflags_install}");
if (ia->qva_flags & VERIFY_DIGEST)
vsflags |= _RPMVSF_NODIGESTS;
if (ia->qva_flags & VERIFY_SIGNATURE)
vsflags |= _RPMVSF_NOSIGNATURES;
if (ia->qva_flags & VERIFY_HDRCHK)
vsflags |= RPMVSF_NOHDRCHK;
ovsflags = rpmtsSetVSFlags(ts, (vsflags | RPMVSF_NEEDPAYLOAD));
{ int notifyFlags;
notifyFlags = ia->installInterfaceFlags | (rpmIsVerbose() ? INSTALL_LABEL : 0 );
xx = rpmtsSetNotifyCallback(ts,
rpmShowProgress, (void *) ((long)notifyFlags));
}
if ((eiu->relocations = relocations) != NULL) {
while (eiu->relocations->oldPath)
eiu->relocations++;
if (eiu->relocations->newPath == NULL)
eiu->relocations = NULL;
}
/* Build fully globbed list of arguments in argv[argc]. */
for (eiu->fnp = fileArgv; *eiu->fnp != NULL; eiu->fnp++) {
ARGV_t av = NULL;
int ac = 0;
char * fn;
fn = rpmEscapeSpaces(*eiu->fnp);
rc = rpmGlob(fn, &ac, &av);
fn = _free(fn);
if (rc || ac == 0) {
rpmlog(RPMLOG_ERR, _("File not found by glob: %s\n"), *eiu->fnp);
eiu->numFailed++;
continue;
}
argvAppend(&(eiu->argv), av);
argvFree(av);
eiu->argc += ac;
}
restart:
/* Allocate sufficient storage for next set of args. */
if (eiu->pkgx >= eiu->numPkgs) {
eiu->numPkgs = eiu->pkgx + eiu->argc;
eiu->pkgURL = xrealloc(eiu->pkgURL,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgURL));
memset(eiu->pkgURL + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgURL)));
eiu->pkgState = xrealloc(eiu->pkgState,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgState));
memset(eiu->pkgState + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgState)));
}
/* Retrieve next set of args, cache on local storage. */
for (i = 0; i < eiu->argc; i++) {
fileURL = _free(fileURL);
fileURL = eiu->argv[i];
eiu->argv[i] = NULL;
switch (urlIsURL(fileURL)) {
case URL_IS_HTTPS:
case URL_IS_HTTP:
case URL_IS_FTP:
{ char *tfn;
FD_t tfd;
if (rpmIsVerbose())
fprintf(stdout, _("Retrieving %s\n"), fileURL);
tfd = rpmMkTempFile(rpmtsRootDir(ts), &tfn);
if (tfd && tfn) {
Fclose(tfd);
rc = urlGetFile(fileURL, tfn);
} else {
rc = -1;
}
if (rc != 0) {
rpmlog(RPMLOG_ERR,
_("skipping %s - transfer failed\n"), fileURL);
eiu->numFailed++;
eiu->pkgURL[eiu->pkgx] = NULL;
tfn = _free(tfn);
break;
}
eiu->pkgState[eiu->pkgx] = 1;
eiu->pkgURL[eiu->pkgx] = tfn;
eiu->pkgx++;
} break;
case URL_IS_PATH:
case URL_IS_DASH: /* WRONG WRONG WRONG */
case URL_IS_HKP: /* WRONG WRONG WRONG */
default:
eiu->pkgURL[eiu->pkgx] = fileURL;
fileURL = NULL;
eiu->pkgx++;
break;
}
}
fileURL = _free(fileURL);
if (eiu->numFailed) goto exit;
/* Continue processing file arguments, building transaction set. */
for (eiu->fnp = eiu->pkgURL+eiu->prevx;
*eiu->fnp != NULL;
eiu->fnp++, eiu->prevx++)
{
const char * fileName;
rpmlog(RPMLOG_DEBUG, "============== %s\n", *eiu->fnp);
(void) urlPath(*eiu->fnp, &fileName);
/* Try to read the header from a package file. */
eiu->fd = Fopen(*eiu->fnp, "r.ufdio");
if (eiu->fd == NULL || Ferror(eiu->fd)) {
rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), *eiu->fnp,
Fstrerror(eiu->fd));
if (eiu->fd != NULL) {
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
eiu->numFailed++; *eiu->fnp = NULL;
continue;
}
/* Read the header, verifying signatures (if present). */
tvsflags = rpmtsSetVSFlags(ts, vsflags);
eiu->rpmrc = rpmReadPackageFile(ts, eiu->fd, *eiu->fnp, &eiu->h);
tvsflags = rpmtsSetVSFlags(ts, tvsflags);
xx = Fclose(eiu->fd);
eiu->fd = NULL;
switch (eiu->rpmrc) {
case RPMRC_FAIL:
rpmlog(RPMLOG_ERR, _("%s cannot be installed\n"), *eiu->fnp);
eiu->numFailed++; *eiu->fnp = NULL;
continue;
break;
case RPMRC_NOTFOUND:
goto maybe_manifest;
break;
case RPMRC_NOTTRUSTED:
case RPMRC_NOKEY:
case RPMRC_OK:
default:
break;
}
eiu->isSource = headerIsSource(eiu->h);
if (eiu->isSource) {
rpmlog(RPMLOG_DEBUG, "\tadded source package [%d]\n",
eiu->numSRPMS);
eiu->sourceURL = xrealloc(eiu->sourceURL,
(eiu->numSRPMS + 2) * sizeof(*eiu->sourceURL));
eiu->sourceURL[eiu->numSRPMS] = *eiu->fnp;
*eiu->fnp = NULL;
eiu->numSRPMS++;
eiu->sourceURL[eiu->numSRPMS] = NULL;
continue;
}
if (eiu->relocations) {
struct rpmtd_s prefixes;
headerGet(eiu->h, RPMTAG_PREFIXES, &prefixes, HEADERGET_DEFAULT);
if (rpmtdCount(&prefixes) == 1) {
eiu->relocations->oldPath = xstrdup(rpmtdGetString(&prefixes));
rpmtdFreeData(&prefixes);
} else {
const char * name;
xx = headerNVR(eiu->h, &name, NULL, NULL);
rpmlog(RPMLOG_ERR,
_("package %s is not relocatable\n"), name);
eiu->numFailed++;
goto exit;
}
}
/* On --freshen, verify package is installed and newer */
if (ia->installInterfaceFlags & INSTALL_FRESHEN) {
rpmdbMatchIterator mi;
const char * name;
Header oldH;
int count;
xx = headerNVR(eiu->h, &name, NULL, NULL);
mi = rpmtsInitIterator(ts, RPMTAG_NAME, name, 0);
count = rpmdbGetIteratorCount(mi);
while ((oldH = rpmdbNextIterator(mi)) != NULL) {
if (rpmVersionCompare(oldH, eiu->h) < 0)
continue;
/* same or newer package already installed */
count = 0;
break;
}
mi = rpmdbFreeIterator(mi);
if (count == 0) {
eiu->h = headerFree(eiu->h);
continue;
}
/* Package is newer than those currently installed. */
}
rc = rpmtsAddInstallElement(ts, eiu->h, (fnpyKey)fileName,
(ia->installInterfaceFlags & INSTALL_UPGRADE) != 0,
relocations);
/* XXX reference held by transaction set */
eiu->h = headerFree(eiu->h);
if (eiu->relocations)
eiu->relocations->oldPath = _free(eiu->relocations->oldPath);
switch(rc) {
case 0:
rpmlog(RPMLOG_DEBUG, "\tadded binary package [%d]\n",
eiu->numRPMS);
break;
case 1:
rpmlog(RPMLOG_ERR,
_("error reading from file %s\n"), *eiu->fnp);
eiu->numFailed++;
goto exit;
break;
case 2:
rpmlog(RPMLOG_ERR,
_("file %s requires a newer version of RPM\n"),
*eiu->fnp);
eiu->numFailed++;
goto exit;
break;
default:
eiu->numFailed++;
goto exit;
break;
}
eiu->numRPMS++;
continue;
maybe_manifest:
/* Try to read a package manifest. */
eiu->fd = Fopen(*eiu->fnp, "r.fpio");
if (eiu->fd == NULL || Ferror(eiu->fd)) {
rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), *eiu->fnp,
Fstrerror(eiu->fd));
if (eiu->fd != NULL) {
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
eiu->numFailed++; *eiu->fnp = NULL;
break;
}
/* Read list of packages from manifest. */
/* FIX: *eiu->argv can be NULL */
rc = rpmReadPackageManifest(eiu->fd, &eiu->argc, &eiu->argv);
if (rc != RPMRC_OK)
rpmlog(RPMLOG_ERR, _("%s: not an rpm package (or package manifest): %s\n"),
*eiu->fnp, Fstrerror(eiu->fd));
xx = Fclose(eiu->fd);
eiu->fd = NULL;
/* If successful, restart the query loop. */
if (rc == RPMRC_OK) {
eiu->prevx++;
goto restart;
}
eiu->numFailed++; *eiu->fnp = NULL;
break;
}
rpmlog(RPMLOG_DEBUG, "found %d source and %d binary packages\n",
eiu->numSRPMS, eiu->numRPMS);
if (eiu->numFailed) goto exit;
if (eiu->numRPMS && !(ia->installInterfaceFlags & INSTALL_NODEPS)) {
if (rpmtsCheck(ts)) {
eiu->numFailed = eiu->numPkgs;
stopInstall = 1;
}
ps = rpmtsProblems(ts);
if (!stopInstall && rpmpsNumProblems(ps) > 0) {
rpmlog(RPMLOG_ERR, _("Failed dependencies:\n"));
rpmpsPrint(NULL, ps);
eiu->numFailed = eiu->numPkgs;
stopInstall = 1;
}
ps = rpmpsFree(ps);
}
if (eiu->numRPMS && !(ia->installInterfaceFlags & INSTALL_NOORDER)) {
if (rpmtsOrder(ts)) {
eiu->numFailed = eiu->numPkgs;
stopInstall = 1;
}
}
if (eiu->numRPMS && !stopInstall) {
rpmcliPackagesTotal += eiu->numSRPMS;
rpmlog(RPMLOG_DEBUG, "installing binary packages\n");
/* Drop added/available package indices and dependency sets. */
rpmtsClean(ts);
rc = rpmtsRun(ts, NULL, probFilter);
ps = rpmtsProblems(ts);
if (rc < 0) {
eiu->numFailed += eiu->numRPMS;
} else if (rc > 0) {
eiu->numFailed += rc;
if (rpmpsNumProblems(ps) > 0)
rpmpsPrint(stderr, ps);
}
ps = rpmpsFree(ps);
}
if (eiu->numSRPMS && !stopInstall) {
if (eiu->sourceURL != NULL)
for (i = 0; i < eiu->numSRPMS; i++) {
rpmdbCheckSignals();
if (eiu->sourceURL[i] == NULL) continue;
eiu->fd = Fopen(eiu->sourceURL[i], "r.ufdio");
if (eiu->fd == NULL || Ferror(eiu->fd)) {
rpmlog(RPMLOG_ERR, _("cannot open file %s: %s\n"),
eiu->sourceURL[i], Fstrerror(eiu->fd));
if (eiu->fd != NULL) {
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
continue;
}
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_TEST)) {
eiu->rpmrc = rpmInstallSourcePackage(ts, eiu->fd, NULL, NULL);
if (eiu->rpmrc != RPMRC_OK) eiu->numFailed++;
}
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
}
exit:
if (eiu->pkgURL != NULL)
for (i = 0; i < eiu->numPkgs; i++) {
if (eiu->pkgURL[i] == NULL) continue;
if (eiu->pkgState[i] == 1)
(void) unlink(eiu->pkgURL[i]);
eiu->pkgURL[i] = _free(eiu->pkgURL[i]);
}
eiu->pkgState = _free(eiu->pkgState);
eiu->pkgURL = _free(eiu->pkgURL);
eiu->argv = _free(eiu->argv);
rc = eiu->numFailed;
free(eiu);
rpmtsEmpty(ts);
return rc;
}
/**
* Check installed package dependencies for problems.
* @param qva parsed query/verify options
* @param ts transaction set
* @param h header
* @return number of problems found (0 for no problems)
*/
static int verifyDependencies(/*@unused@*/ QVA_t qva, rpmts ts,
Header h)
/*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
/*@modifies ts, h, rpmGlobalMacroContext, fileSystem, internalState @*/
{
#ifdef NOTYET
uint32_t hdrNum = headerGetInstance(h);
#endif
rpmps ps;
int rc = 0; /* assume no problems */
int xx;
rpmtsEmpty(ts);
#ifdef NOTYET
if (hdrNum > 0)
(void) rpmtsAddEraseElement(ts, h, hdrNum);
else
#endif
(void) rpmtsAddInstallElement(ts, h, headerGetOrigin(h), 0, NULL);
xx = rpmtsCheck(ts);
ps = rpmtsProblems(ts);
if (rpmpsNumProblems(ps) > 0) {
const char * altNEVR;
const char * pkgNEVR = NULL;
rpmpsi psi;
rpmProblem prob;
char * t, * te;
int nb = 512;
psi = rpmpsInitIterator(ps);
while (rpmpsNextIterator(psi) >= 0) {
prob = rpmpsProblem(psi);
if (pkgNEVR == NULL)
pkgNEVR = rpmProblemGetPkgNEVR(prob);
altNEVR = rpmProblemGetAltNEVR(prob);
assert(altNEVR != NULL);
if (altNEVR[0] == 'R' && altNEVR[1] == ' ')
nb += sizeof("\tRequires: ")-1;
if (altNEVR[0] == 'C' && altNEVR[1] == ' ')
nb += sizeof("\tConflicts: ")-1;
nb += strlen(altNEVR+2) + sizeof("\n") - 1;
}
psi = rpmpsFreeIterator(psi);
te = t = alloca(nb);
*te = '\0';
sprintf(te, _("Unsatisfied dependencies for %s:\n"), pkgNEVR);
te += strlen(te);
psi = rpmpsInitIterator(ps);
while (rpmpsNextIterator(psi) >= 0) {
prob = rpmpsProblem(psi);
if ((altNEVR = rpmProblemGetAltNEVR(prob)) == NULL)
altNEVR = "? ?altNEVR?";
if (altNEVR[0] == 'R' && altNEVR[1] == ' ')
te = stpcpy(te, "\tRequires: ");
if (altNEVR[0] == 'C' && altNEVR[1] == ' ')
te = stpcpy(te, "\tConflicts: ");
te = stpcpy( stpcpy(te, altNEVR+2), "\n");
rc++;
}
psi = rpmpsFreeIterator(psi);
if (te > t) {
*te++ = '\n';
*te = '\0';
rpmlog(RPMLOG_NOTICE, "%s", t);
te = t;
*t = '\0';
}
}
ps = rpmpsFree(ps);
rpmtsEmpty(ts);
return rc;
}
rpmRC rpmInstallSourcePackage(rpmts ts, FD_t fd,
char ** specFilePtr, char ** cookie)
{
Header h = NULL;
rpmpsm psm = NULL;
rpmte te = NULL;
rpmRC rpmrc;
int specix = -1;
rpmrc = rpmReadPackageFile(ts, fd, NULL, &h);
switch (rpmrc) {
case RPMRC_NOTTRUSTED:
case RPMRC_NOKEY:
case RPMRC_OK:
break;
default:
goto exit;
break;
}
if (h == NULL)
goto exit;
rpmrc = RPMRC_FAIL; /* assume failure */
if (!headerIsSource(h)) {
rpmlog(RPMLOG_ERR, _("source package expected, binary found\n"));
goto exit;
}
/* src.rpm install can require specific rpmlib features, check them */
if (!rpmlibDeps(h))
goto exit;
specix = headerFindSpec(h);
if (specix < 0) {
rpmlog(RPMLOG_ERR, _("source package contains no .spec file\n"));
goto exit;
};
if (rpmtsAddInstallElement(ts, h, NULL, 0, NULL)) {
goto exit;
}
te = rpmtsElement(ts, 0);
if (te == NULL) { /* XXX can't happen */
goto exit;
}
rpmteSetFd(te, fd);
rpmteSetHeader(te, h);
{
/* set all files to be installed */
rpmfs fs = rpmteGetFileStates(te);
int fc = rpmfsFC(fs);
for (int i = 0; i < fc; i++)
rpmfsSetAction(fs, i, FA_CREATE);
}
psm = rpmpsmNew(ts, te, PKG_INSTALL);
if (rpmpsmUnpack(psm) == RPMRC_OK)
rpmrc = RPMRC_OK;
rpmpsmFree(psm);
exit:
if (rpmrc == RPMRC_OK && specix >= 0) {
if (cookie)
*cookie = headerGetAsString(h, RPMTAG_COOKIE);
if (specFilePtr) {
rpmfiles files = rpmteFiles(te);
*specFilePtr = rpmfilesFN(files, specix);
rpmfilesFree(files);
}
}
/* XXX nuke the added package(s). */
headerFree(h);
rpmtsEmpty(ts);
return rpmrc;
}
