VALUE rpm_mi_get_iterator_offset(VALUE mi) { int off = rpmdbGetIteratorOffset(RPM_MI(mi)); if (off) return INT2NUM(off); return Qnil; }
static PyObject * rpmmi_Instance(rpmmiObject * s) { int rc = 0; if (s->mi != NULL) rc = rpmdbGetIteratorOffset(s->mi); return Py_BuildValue("i", rc); }
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); }
/* * --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); }
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); } }
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; }
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; }
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; }
/** * Adjust file states in database for files shared with this package: * currently either "replaced" or "wrong color". * @param psm package state machine data * @return 0 always */ static rpmRC markReplacedFiles(const rpmpsm psm) { const rpmts ts = psm->ts; rpmfs fs = rpmteGetFileStates(psm->te); sharedFileInfo replaced = rpmfsGetReplaced(fs); sharedFileInfo sfi; rpmdbMatchIterator mi; Header h; unsigned int * offsets; unsigned int prev; unsigned int num; if (!replaced) return RPMRC_OK; num = prev = 0; for (sfi = replaced; sfi; sfi=rpmfsNextReplaced(fs, sfi)) { if (prev && prev == sfi->otherPkg) continue; prev = sfi->otherPkg; num++; } if (num == 0) return RPMRC_OK; offsets = xmalloc(num * sizeof(*offsets)); offsets[0] = 0; num = prev = 0; for (sfi = replaced; sfi; sfi=rpmfsNextReplaced(fs, sfi)) { if (prev && prev == sfi->otherPkg) continue; prev = sfi->otherPkg; offsets[num++] = sfi->otherPkg; } mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES, NULL, 0); rpmdbAppendIterator(mi, offsets, num); rpmdbSetIteratorRewrite(mi, 1); sfi = replaced; while ((h = rpmdbNextIterator(mi)) != NULL) { int modified; struct rpmtd_s secStates; modified = 0; if (!headerGet(h, RPMTAG_FILESTATES, &secStates, HEADERGET_MINMEM)) continue; prev = rpmdbGetIteratorOffset(mi); num = 0; while (sfi && sfi->otherPkg == prev) { int ix = rpmtdSetIndex(&secStates, sfi->otherFileNum); assert(ix != -1); char *state = rpmtdGetChar(&secStates); if (state && *state != sfi->rstate) { *state = sfi->rstate; if (modified == 0) { /* Modified header will be rewritten. */ modified = 1; rpmdbSetIteratorModified(mi, modified); } num++; } sfi=rpmfsNextReplaced(fs, sfi); } rpmtdFreeData(&secStates); } rpmdbFreeIterator(mi); free(offsets); return RPMRC_OK; }
/* Check files in the transactions against the rpmdb * Lookup all files with the same basename in the rpmdb * and then check for matching finger prints * @param ts transaction set * @param fpc global finger print cache */ static void checkInstalledFiles(rpmts ts, uint64_t fileCount, fingerPrintCache fpc) { tsMembers tsmem = rpmtsMembers(ts); rpmte p; rpmfiles fi; rpmfs fs; int j; unsigned int fileNum; rpmdbMatchIterator mi; Header h, newheader; rpmlog(RPMLOG_DEBUG, "computing file dispositions\n"); mi = rpmFindBaseNamesInDB(ts, fileCount); /* For all installed headers with matching basename's ... */ if (mi == NULL) return; if (rpmdbGetIteratorCount(mi) == 0) { mi = rpmdbFreeIterator(mi); return; } /* Loop over all packages from the rpmdb */ h = newheader = rpmdbNextIterator(mi); while (h != NULL) { headerGetFlags hgflags = HEADERGET_MINMEM; struct rpmtd_s bnames, dnames, dindexes, ostates; fingerPrint *fpp = NULL; unsigned int installedPkg; int beingRemoved = 0; rpmfiles otherFi = NULL; rpmte *removedPkg = NULL; /* Is this package being removed? */ installedPkg = rpmdbGetIteratorOffset(mi); if (packageHashGetEntry(tsmem->removedPackages, installedPkg, &removedPkg, NULL, NULL)) { beingRemoved = 1; otherFi = rpmteFiles(removedPkg[0]); } h = headerLink(h); /* For packages being removed we can use its rpmfi to avoid all this */ if (!beingRemoved) { headerGet(h, RPMTAG_BASENAMES, &bnames, hgflags); headerGet(h, RPMTAG_DIRNAMES, &dnames, hgflags); headerGet(h, RPMTAG_DIRINDEXES, &dindexes, hgflags); headerGet(h, RPMTAG_FILESTATES, &ostates, hgflags); } /* loop over all interesting files in that package */ do { int fpIx; struct rpmffi_s * recs; int numRecs; const char * dirName; const char * baseName; /* lookup finger print for this file */ fileNum = rpmdbGetIteratorFileNum(mi); if (!beingRemoved) { rpmtdSetIndex(&bnames, fileNum); rpmtdSetIndex(&dindexes, fileNum); rpmtdSetIndex(&dnames, *rpmtdGetUint32(&dindexes)); rpmtdSetIndex(&ostates, fileNum); dirName = rpmtdGetString(&dnames); baseName = rpmtdGetString(&bnames); fpLookup(fpc, dirName, baseName, &fpp); fpIx = 0; } else { fpp = rpmfilesFps(otherFi); fpIx = fileNum; } /* search for files in the transaction with same finger print */ fpCacheGetByFp(fpc, fpp, fpIx, &recs, &numRecs); for (j = 0; j < numRecs; j++) { p = recs[j].p; fi = rpmteFiles(p); fs = rpmteGetFileStates(p); /* Determine the fate of each file. */ switch (rpmteType(p)) { case TR_ADDED: if (!otherFi) { /* XXX What to do if this fails? */ otherFi = rpmfilesNew(NULL, h, RPMTAG_BASENAMES, RPMFI_KEEPHEADER); } handleInstInstalledFile(ts, p, fi, recs[j].fileno, h, otherFi, fileNum, beingRemoved); break; case TR_REMOVED: if (!beingRemoved) { if (*rpmtdGetChar(&ostates) == RPMFILE_STATE_NORMAL) rpmfsSetAction(fs, recs[j].fileno, FA_SKIP); } break; } rpmfilesFree(fi); } newheader = rpmdbNextIterator(mi); } while (newheader==h); otherFi = rpmfilesFree(otherFi); if (!beingRemoved) { rpmtdFreeData(&ostates); rpmtdFreeData(&bnames); rpmtdFreeData(&dnames); rpmtdFreeData(&dindexes); free(fpp); } headerFree(h); h = newheader; } rpmdbFreeIterator(mi); }
/* Check files in the transactions against the rpmdb * Lookup all files with the same basename in the rpmdb * and then check for matching finger prints * @param ts transaction set * @param fpc global finger print cache */ static void checkInstalledFiles(rpmts ts, fingerPrintCache fpc) { rpmps ps; rpmte p; rpmfi fi; rpmfs fs; rpmfi otherFi=NULL; int j; int xx; unsigned int fileNum; const char * oldDir; rpmdbMatchIterator mi; Header h, newheader; int beingRemoved; rpmlog(RPMLOG_DEBUG, "computing file dispositions\n"); mi = rpmFindBaseNamesInDB(ts); /* For all installed headers with matching basename's ... */ if (mi == NULL) return; if (rpmdbGetIteratorCount(mi) == 0) { mi = rpmdbFreeIterator(mi); return; } ps = rpmtsProblems(ts); /* Loop over all packages from the rpmdb */ h = newheader = rpmdbNextIterator(mi); while (h != NULL) { headerGetFlags hgflags = HEADERGET_MINMEM; struct rpmtd_s bnames, dnames, dindexes, ostates; fingerPrint fp; unsigned int installedPkg; /* Is this package being removed? */ installedPkg = rpmdbGetIteratorOffset(mi); beingRemoved = 0; if (ts->removedPackages != NULL) for (j = 0; j < ts->numRemovedPackages; j++) { if (ts->removedPackages[j] != installedPkg) continue; beingRemoved = 1; break; } h = headerLink(h); headerGet(h, RPMTAG_BASENAMES, &bnames, hgflags); headerGet(h, RPMTAG_DIRNAMES, &dnames, hgflags); headerGet(h, RPMTAG_DIRINDEXES, &dindexes, hgflags); headerGet(h, RPMTAG_FILESTATES, &ostates, hgflags); oldDir = NULL; /* loop over all interesting files in that package */ do { int gotRecs; struct rpmffi_s * recs; int numRecs; const char * dirName; const char * baseName; fileNum = rpmdbGetIteratorFileNum(mi); rpmtdSetIndex(&bnames, fileNum); rpmtdSetIndex(&dindexes, fileNum); rpmtdSetIndex(&dnames, *rpmtdGetUint32(&dindexes)); rpmtdSetIndex(&ostates, fileNum); dirName = rpmtdGetString(&dnames); baseName = rpmtdGetString(&bnames); /* lookup finger print for this file */ if ( dirName == oldDir) { /* directory is the same as last round */ fp.baseName = baseName; } else { fp = fpLookup(fpc, dirName, baseName, 1); oldDir = dirName; } /* search for files in the transaction with same finger print */ gotRecs = rpmFpHashGetEntry(ts->ht, &fp, &recs, &numRecs, NULL); for (j=0; (j<numRecs)&&gotRecs; j++) { p = recs[j].p; fi = rpmteFI(p); fs = rpmteGetFileStates(p); /* Determine the fate of each file. */ switch (rpmteType(p)) { case TR_ADDED: if (!otherFi) { otherFi = rpmfiNew(ts, h, RPMTAG_BASENAMES, RPMFI_KEEPHEADER); } rpmfiSetFX(fi, recs[j].fileno); rpmfiSetFX(otherFi, fileNum); xx = handleInstInstalledFile(ts, p, fi, h, otherFi, beingRemoved); break; case TR_REMOVED: if (!beingRemoved) { rpmfiSetFX(fi, recs[j].fileno); if (*rpmtdGetChar(&ostates) == RPMFILE_STATE_NORMAL) rpmfsSetAction(fs, recs[j].fileno, FA_SKIP); } break; } } newheader = rpmdbNextIterator(mi); } while (newheader==h); otherFi = rpmfiFree(otherFi); rpmtdFreeData(&ostates); rpmtdFreeData(&bnames); rpmtdFreeData(&dnames); rpmtdFreeData(&dindexes); headerFree(h); h = newheader; } mi = rpmdbFreeIterator(mi); }