static PyObject * rpmts_Check(rpmtsObject * s, PyObject * args, PyObject * kwds) { struct rpmtsCallbackType_s cbInfo; int rc; char * kwlist[] = {"callback", NULL}; memset(&cbInfo, 0, sizeof(cbInfo)); if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:Check", kwlist, &cbInfo.cb)) return NULL; if (cbInfo.cb != NULL) { if (!PyCallable_Check(cbInfo.cb)) { PyErr_SetString(PyExc_TypeError, "expected a callable"); return NULL; } rc = rpmtsSetSolveCallback(s->ts, rpmts_SolveCallback, (void *)&cbInfo); } cbInfo.tso = s; cbInfo._save = PyEval_SaveThread(); rc = rpmtsCheck(s->ts); PyEval_RestoreThread(cbInfo._save); return PyBool_FromLong((rc == 0)); }
int doCheck(PTDNFRPMTS pTS) { int nResult = 0; rpmpsi psi = NULL; rpmProblem prob = NULL; nResult = rpmtsCheck(pTS->pTS); rpmps ps = rpmtsProblems(pTS->pTS); if(ps) { int nProbs = rpmpsNumProblems(ps); if(nProbs > 0) { printf("Found %d problems\n", nProbs); psi = rpmpsInitIterator(ps); while(rpmpsNextIterator(psi) >= 0) { prob = rpmpsGetProblem(psi); printf("Prob = %s, type = %d, nevr1=%s, nevr2=%s\n", rpmProblemGetStr(prob), rpmProblemGetType(prob), rpmProblemGetPkgNEVR(prob), rpmProblemGetAltNEVR(prob)); rpmProblemFree(prob); } rpmpsFreeIterator(psi); } } return nResult; }
/** * 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; }
/** * 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; }
/************************************************************************* * FUNCTION : RPMTransaction_Set::Check * * ARGUMENTS : none * * RETURNS : TCL_OK or TCL_ERROR * * EXCEPTIONS : none * * PURPOSE : Check the transaction set for problems * *************************************************************************/ int RPMTransaction_Set::Check(Tcl_Interp *interp,int objc, Tcl_Obj *const objv[]) { if (objc != 2) { Tcl_WrongNumArgs(interp,2,objv,0); return TCL_ERROR; } rpmtsCheck(transaction); return Problems(interp); }
static int rpmcliTransaction(rpmts ts, struct rpmInstallArguments_s * ia, int numPackages) { rpmps ps; int rc = 0; int stop = 0; int eflags = ia->installInterfaceFlags & INSTALL_ERASE; if (!(ia->installInterfaceFlags & INSTALL_NODEPS)) { if (rpmtsCheck(ts)) { rc = numPackages; stop = 1; } ps = rpmtsProblems(ts); if (!stop && rpmpsNumProblems(ps) > 0) { rpmlog(RPMLOG_ERR, _("Failed dependencies:\n")); rpmpsPrint(NULL, ps); rc = numPackages; stop = 1; } ps = rpmpsFree(ps); } if (!stop && !(ia->installInterfaceFlags & INSTALL_NOORDER)) { if (rpmtsOrder(ts)) { rc = numPackages; stop = 1; } } if (numPackages && !stop) { rpmlog(RPMLOG_DEBUG, eflags ? "erasing packages\n" : "installing binary packages\n"); rpmtsClean(ts); rc = rpmtsRun(ts, NULL, ia->probFilter); ps = rpmtsProblems(ts); if (rpmpsNumProblems(ps) > 0 && (eflags || rc > 0)) rpmpsPrint(NULL, ps); ps = rpmpsFree(ps); } return rc; }
static int checkSpec(rpmts ts, Header h) /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/ /*@modifies ts, h, rpmGlobalMacroContext, fileSystem, internalState @*/ { int rc; if (!headerIsEntry(h, RPMTAG_REQUIRENAME) && !headerIsEntry(h, RPMTAG_CONFLICTNAME)) return 0; rc = rpmtsAddInstallElement(ts, h, NULL, 0, NULL); rc = rpmcliInstallProblems(ts, _("Failed build dependencies"), rpmtsCheck(ts)); /* XXX nuke the added package. */ rpmtsClean(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 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; }
int main(int argc, char **argv) { rpmts ts; rpmps probs; int probFilter = 0; int notifyFlags = 0; int tsFlags = 0; int rc = 0; /* Read configuration, initialize transaction */ rpmReadConfigFiles(NULL, NULL); ts = rpmtsCreate(); /* Set verification flags if needed, for example --nomd5 */ /* rpmtsSetVSFlags(ts, rpmtsVSFlags(ts) | RPMVSF_NOMD5); */ /* Open rpmdb */ //rpmtsSetRootDir(ts, NULL); rc = rpmtsOpenDB(ts, O_RDWR); if (rc) { printf("Error opening rpmdb\n"); goto exit; } /* Add packages for install/upgrade/erase */ while (optind < argc) { int upgrade = 0; switch (getopt(argc, argv, "i:U:e:")) { case 'U': upgrade = 1; case 'i': add_for_install(ts, optarg, upgrade); break; case 'e': add_for_erase(ts, optarg); break; default: printf("usage ...\n"); goto exit; } } /* Set problem filters if needed, for example --oldpackage */ /* rpmbFilter |= RPMPROB_FILTER_OLDPACKAGE /* /* Set transaction flags if needed, for example --excludedocs */ /* tsFlags |= RPMTRANS_FLAG_NODOCS */ /* Check transaction sanity */ rc = rpmtsCheck(ts); probs = rpmtsProblems(ts); if (rc || rpmpsNumProblems(probs)) { rpmpsPrint(NULL, probs); rpmpsFree(probs); goto exit; } /* Create ordering for the transaction */ rc = rpmtsOrder(ts); if (rc > 0) { printf("Ordering failed\n"); goto exit; } rpmtsClean(ts); /* Set callback routine & flags, for example -vh */ notifyFlags |= INSTALL_LABEL | INSTALL_HASH; rpmtsSetNotifyCallback(ts, rpmShowProgress, (void *)notifyFlags); /* Set transaction flags and run the actual transaction */ rpmtsSetFlags(ts, (rpmtransFlags)(rpmtsFlags(ts) | tsFlags)); rc = rpmtsRun(ts, NULL, (rpmprobFilterFlags)probFilter); /* Check for results .. */ if (rc || rpmpsNumProblems(probs) > 0) rpmpsPrint(stderr, probs); rpmpsFree(probs); exit: /* ..and clean up */ rpmtsFree(ts); exit(rc); }
/* * Check the dependencies. * @return [Array<Dependency>, +nil+] If dependencies are not met returns an * array with dependencies. Otherwise +nil+. */ VALUE rpm_transaction_check(VALUE trans) { #if RPM_VERSION_CODE < RPM_VERSION(4,1,0) rpmDependencyConflict conflicts; int num; rpmdepCheck(RPM_TRANSACTION(trans), &conflicts, &num); if (num) { VALUE list = rb_ary_new(); register int i; for (i = 0; i < num; i++) { VALUE dep; switch (conflicts[i].sense) { case RPMDEP_SENSE_REQUIRES: dep = rpm_require_new(conflicts[i].needsName, rpm_version_new(conflicts[i].needsVersion), conflicts[i].needsFlags, rpm_package_new_from_header(conflicts[i].byHeader)); break; case RPMDEP_SENSE_CONFLICTS: dep = rpm_conflict_new(conflicts[i].needsName, rpm_version_new(conflicts[i].needsVersion), conflicts[i].needsFlags, rpm_package_new_from_header(conflicts[i].byHeader)); break; } rb_ary_push(list, dep); } rpmdepFreeConflicts(conflicts, num); return list; } return Qnil; #else int rc; rpmps ps; int num; VALUE list = Qnil; rc = rpmtsCheck(RPM_TRANSACTION(trans)); ps = rpmtsProblems(RPM_TRANSACTION(trans)); #if RPM_VERSION_CODE < RPM_VERSION(4,9,0) || RPM_VERSION_CODE >= RPM_VERSION(5,0,0) /* get rid of duplicate problems */ rpmpsTrim(ps, RPMPROB_FILTER_NONE); #endif num = rpmpsNumProblems(ps); #ifdef RPMPS_OPAQUE rpmpsi psi = rpmpsInitIterator(ps); if (num > 0) { list = rb_ary_new(); } while (rpmpsNextIterator(psi) >= 0) { rpmProblem p = rpmpsGetProblem(psi); VALUE dep; switch (rpmProblemGetType(p)) { case RPMPROB_REQUIRES: { char *buf = strdup (rpmProblemGetAltNEVR(p)); /* TODO: zaki: NULL check*/ char *end; char *name = buf+2; char *relation = NULL; char *evr = NULL; rpmsenseFlags sense_flags = 0; end = strchr ( name, ' '); if ( end ) { *end = '\0'; relation = end + 1; end = strchr ( relation, ' '); if ( end ) { *end = '\0'; evr = end + 1; } for ( ; (*relation) != '\0'; relation++ ) { if ( (*relation) == '=' ) { sense_flags |= RPMSENSE_EQUAL; } else if ( (*relation) == '>' ) { sense_flags |= RPMSENSE_GREATER; } else if ( (*relation) == '<' ) { sense_flags |= RPMSENSE_LESS; } } } dep = rpm_require_new(name, rpm_version_new(evr ? evr : ""), sense_flags, package_new_from_NEVR( rpmProblemGetPkgNEVR(p) )); free ( buf ); rb_ary_push(list, dep); break; } default: break; } } #else if (ps != NULL && 0 < num) { rpmProblem p; int i; list = rb_ary_new(); for (i = 0; i < num; i++) { const char *altNEVR; VALUE dep; p = ps->probs + i; altNEVR = (p->altNEVR ? p->altNEVR : "? ?altNEVR?"); if (p->ignoreProblem) continue; #if 0 /* XXX shouldn't be needed at all due to rpmpsTrim() */ /* Filter already appended problems. */ for (j = 0; j < i; j++) { if (!sameProblem(p, ps->probs + j)) break; } if (j < i) continue; #endif if ( p->type == RPMPROB_REQUIRES ) { char *buf = strdup ( altNEVR ); /* TODO: zaki: NULL check*/ char *end; char *name = buf+2; char *relation = NULL; char *evr = ""; rpmsenseFlags sense_flags = 0; end = strchr ( name, ' '); if ( end ) { *end = '\0'; relation = end + 1; end = strchr ( relation, ' '); if ( end ) { *end = '\0'; evr = end + 1; } for ( ; (*relation) != '\0'; relation++ ) { if ( (*relation) == '=' ) { sense_flags |= RPMSENSE_EQUAL; } else if ( (*relation) == '>' ) { sense_flags |= RPMSENSE_GREATER; } else if ( (*relation) == '<' ) { sense_flags |= RPMSENSE_LESS; } } } dep = rpm_require_new(name, rpm_version_new(evr), sense_flags, package_new_from_NEVR(p->pkgNEVR) ); free ( buf ); rb_ary_push(list, dep); } else { #if 0 RPMPROB_CONFLICT: RPMPROB_BADARCH: RPMPROB_BADOS: RPMPROB_PKG_INSTALLED: RPMPROB_BADRELOCATE: RPMPROB_NEW_FILE_CONFLICT: RPMPROB_FILE_CONFLICT: RPMPROB_OLDPACKAGE: RPMPROB_DISKSPACE: RPMPROB_DISKNODES: RPMPROB_BADPRETRANS: #endif break; } #if 0 printf ("%d, type=%d, ignoreProblem=%d, str1=%s pkgNEVR=%s, %s\n", i, p->type, p->ignoreProblem, p->str1, p->pkgNEVR, altNEVR); #endif } } #endif /* RPMPS_OPAQUE */ ps = rpmpsFree(ps); return list; #endif }