14 #include <rpmkeyring.h>
19 #define _RPMTAG_INTERNAL
23 #define _RPMDB_INTERNAL
32 #define _RPMTE_INTERNAL
35 #define _RPMTS_INTERNAL
36 #define _RPMBAG_INTERNAL
45 #if STATFS_IN_SYS_STATVFS
47 #if defined(__LCLINT__)
49 extern int statvfs (
const char *
file,
struct statvfs *
buf)
55 # include <sys/statvfs.h>
58 # if STATFS_IN_SYS_VFS
61 # if STATFS_IN_SYS_MOUNT
62 # include <sys/mount.h>
64 # if STATFS_IN_SYS_STATFS
65 # include <sys/statfs.h>
86 GENfree(rpmDiskSpaceInfo)
105 if (ts->rdb !=
NULL) {
119 if (ts->rdb !=
NULL && ts->dbmode == dbmode)
127 rc =
rpmdbOpen(ts->rootDir, &ts->rdb, ts->dbmode, (mode_t)0644);
138 void * lock = rpmtsAcquireLock(ts);
150 if (!(db->db_api == 3 || db->db_api == 4))
153 rc = rpmtxnCheckpoint(db);
157 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
161 switch (dbiTags->tag) {
175 fn =
rpmGetPath(db->db_root, db->db_home,
"/",
176 (dbiTags->str !=
NULL ? dbiTags->str :
tagName(dbiTags->tag)),
195 (
unsigned)db->db_maxkey);
202 rc = rpmtxnCheckpoint(db);
207 lock = rpmtsFreeLock(lock);
213 const void * keyp,
size_t keylen)
217 :
rpmmiInit(ts->rdb, rpmtag, keyp, keylen);
224 rpmbag bag = ts->bag;
228 rpmsdb * sdbp = bag->sdbp;
235 sdb = (
rpmdb) sdbp[i]->_db;
245 (
void) rpmbagDel(bag, i);
247 ts->bag = rpmbagFree(ts->bag);
254 static int has_sdbpath = -1;
255 rpmbag bag = ts->bag;
256 rpmsdb * sdbp =
NULL;
258 int sdbmode = O_RDONLY;
259 const char *
s =
NULL;
261 const char * rootDir = ts->rootDir;
263 const char * rootDir =
"/";
272 bag = ts->bag = rpmbagNew(
NULL, 0);
277 sdb = (
rpmdb) (sdbp[0] ? sdbp[0]->_db :
NULL);
278 sdbmode = (sdbp[0] ? sdbp[0]->dbmode : O_RDONLY);
280 if (sdb != NULL && sdbmode == dbmode) {
289 if (has_sdbpath <= 0) {
294 s =
rpmExpand(
"%{?_solve_dbpath}", NULL);
298 for (i = 0; i <
ac; i++) {
302 if (av[i] == NULL || *av[i] ==
'\0')
310 xx =
rpmdbOpen(rootDir, &sdb, dbmode, (mode_t)0644);
314 const char * dn =
rpmGetPath(rootDir,
"/", fn, NULL);
325 xx = rpmbagAdd(bag, sdb, dbmode);
333 fprintf(stderr,
"<-- %s(%p, 0%o) rc %d\n", __FUNCTION__, ts, dbmode, rc);
343 static int sugcmp(
const void * a,
const void *
b)
346 const char * astr = *(
const char **)a;
347 const char * bstr = *(
const char **)b;
348 return strcmp(astr, bstr);
354 rpmbag bag = ts->bag;
355 rpmsdb * sdbp =
NULL;
356 const char * errstr =
NULL;
357 const char * str =
NULL;
361 size_t bhnamelen = 0;
371 fprintf(stderr,
"--> %s(%p,%p,%p)\n", __FUNCTION__, ts, ds, data);
404 for (i = 0; i < (
int)bag->nsdbp; i++) {
409 sdb = (
rpmdb) sdbp[i]->_db;
415 mi =
rpmmiInit(sdb, rpmtag, keyp, keylen);
425 hnamelen = ((xx && he->
p.
str) ? strlen(he->
p.
str) : 0);
429 if (bhnamelen > 0 && hnamelen > bhnamelen)
446 bhnamelen = hnamelen;
465 if (qfmt ==
NULL || *qfmt ==
'\0')
482 fd =
Fopen(str,
"r.fdio");
518 if (ts->suggests !=
NULL && ts->nsuggests > 0) {
519 if (bsearch(&str, ts->suggests, ts->nsuggests,
520 sizeof(*ts->suggests),
sugcmp))
528 ts->suggests = (
const void **)
xrealloc(ts->suggests,
529 sizeof(*ts->suggests) * (ts->nsuggests + 2));
530 ts->suggests[ts->nsuggests] = str;
532 ts->suggests[ts->nsuggests] =
NULL;
534 if (ts->nsuggests > 1)
535 qsort(ts->suggests, ts->nsuggests,
sizeof(*ts->suggests),
sugcmp);
539 fprintf(stderr,
"<-- %s(%p,%p,%p) rc %d N %s EVR %s F 0x%x\n", __FUNCTION__, ts, ds, data, rc,
rpmdsN(ds),
rpmdsEVR(ds),
rpmdsFlags(ds));
548 if (ts->availablePackages ==
NULL)
555 if (sugkey[0] !=
NULL) {
556 ts->suggests = (
const void **)
xrealloc(ts->suggests,
557 sizeof(*ts->suggests) * (ts->nsuggests + 2));
558 ts->suggests[ts->nsuggests] = sugkey[0];
561 ts->suggests[ts->nsuggests] =
NULL;
563 sugkey =
_free(sugkey);
569 const void * solveData)
576 ts->solveData = solveData;
584 static const char msg[] =
"rpmtsProblems";
587 if (ts->probs ==
NULL)
609 ts->addedPackages =
rpmalFree(ts->addedPackages);
610 ts->numAddedPackages = 0;
612 ts->erasedPackages =
rpmalFree(ts->erasedPackages);
613 ts->numErasedPackages = 0;
615 ts->suggests =
_free(ts->suggests);
641 ts->numAddedFiles = 0;
642 ts->numErasedFiles = 0;
648 ts->numRemovedPackages = 0;
658 static unsigned int scale = (1000 * 1000);
660 fprintf(stderr,
" %s %8d %6lu.%06lu MB %6lu.%06lu secs\n",
662 (
unsigned long)op->
bytes/scale, (
unsigned long)op->
bytes%scale,
715 yarnRelease(ts->_item.use);
719 yarnPossess(ts->_item.use);
731 (
void) rpmbfFree(ts->rbf);
733 ts->removedPackages =
_free(ts->removedPackages);
735 ts->availablePackages =
rpmalFree(ts->availablePackages);
736 ts->numAvailablePackages = 0;
738 ts->dsi =
_free(ts->dsi);
740 if (ts->scriptFd !=
NULL) {
742 ts->scriptFd =
fdFree(ts->scriptFd, __FUNCTION__);
746 ts->rootDir =
_free(ts->rootDir);
747 ts->currDir =
_free(ts->currDir);
750 ts->order =
_free(ts->order);
752 ts->orderAlloced = 0;
754 ts->keyring = rpmKeyringFree(ts->keyring);
755 (
void) rpmhkpFree(ts->hkp);
780 if (_rpmtsPool ==
NULL) {
781 _rpmtsPool =
rpmioNewPool(
"ts",
sizeof(*ts), -1, _rpmts_debug,
786 memset(((
char *)ts)+
sizeof(ts->_item), 0,
sizeof(*ts)-
sizeof(ts->_item));
792 rpmKeyring keyring =
NULL;
795 if (ts->keyring ==
NULL && autoload)
797 keyring = rpmKeyringLink(ts->keyring);
799 keyring = ts->keyring;
803 return (
void *)keyring;
809 rpmKeyring keyring = (rpmKeyring) _keyring;
824 ts->keyring = rpmKeyringFree(ts->keyring);
828 ts->keyring = rpmKeyringLink(keyring);
831 ts->keyring = keyring;
881 return ((ts !=
NULL) ? ts->arbgoal : 0);
892 int unorderedSuccessors = 0;
894 unorderedSuccessors = ts->unorderedSuccessors;
896 ts->unorderedSuccessors = first;
898 return unorderedSuccessors;
903 const char * rootDir =
NULL;
905 if (ts !=
NULL && ts->rootDir !=
NULL) {
930 ts->rootDir =
_free(ts->rootDir);
932 if (rootDir ==
NULL) {
938 rootLen = strlen(rootDir);
941 if (!(rootLen && rootDir[rootLen - 1] ==
'/')) {
942 char *
t = (
char *)
alloca(rootLen + 2);
947 ts->rootDir =
xstrdup(rootDir);
953 const char * currDir =
NULL;
955 currDir = ts->currDir;
963 ts->currDir =
_free(ts->currDir);
965 ts->currDir =
xstrdup(currDir);
973 scriptFd = ts->scriptFd;
984 if (ts->scriptFd !=
NULL) {
986 ts->scriptFd =
fdFree(ts->scriptFd,
"rpmtsSetScriptFd");
991 if (scriptFd !=
NULL)
992 ts->scriptFd =
fdLink((
void *)scriptFd,
"rpmtsSetScriptFd");
999 int selinuxEnabled = 0;
1001 selinuxEnabled = (ts->selinuxEnabled > 0);
1002 return selinuxEnabled;
1007 return (ts !=
NULL ? ts->chrootDone : 0);
1012 int ochrootDone = 0;
1014 ochrootDone = ts->chrootDone;
1015 if (ts->rdb !=
NULL)
1016 ts->rdb->db_chrootDone = chrootDone;
1017 ts->chrootDone = chrootDone;
1047 static int oneshot = 0;
1067 rpmDiskSpaceInfo dsi;
1074 if (ts->filesystems !=
NULL)
1079 D_(
" i dev bsize bavail iavail mount point\n"));
1082 if (rc || ts->filesystems ==
NULL || ts->filesystemCount == 0)
1087 ts->dsi =
_free(ts->dsi);
1088 ts->dsi = (rpmDiskSpaceInfo)
xcalloc((ts->filesystemCount + 1),
sizeof(*ts->dsi));
1093 for (i = 0; (i < ts->filesystemCount) && dsi; i++, dsi++) {
1094 #if STATFS_IN_SYS_STATVFS
1096 memset(&sfb, 0,
sizeof(sfb));
1097 rc = statvfs(ts->filesystems[i], &sfb);
1100 memset(&sfb, 0,
sizeof(sfb));
1107 rc = statfs(ts->filesystems[i], &sfb,
sizeof(sfb), 0);
1109 rc = statfs(ts->filesystems[i], &sfb);
1115 rc = stat(ts->filesystems[i], &sb);
1118 dsi->dev = sb.st_dev;
1120 #if STATFS_IN_SYS_STATVFS
1121 dsi->f_frsize = sfb.f_frsize;
1122 #if defined(RPM_OS_AIX)
1125 dsi->f_fsid = sfb.f_fsid;
1127 dsi->f_flag = sfb.f_flag;
1128 dsi->f_favail = (
long long) sfb.f_favail;
1129 dsi->f_namemax = sfb.f_namemax;
1130 #elif defined(__APPLE__) && defined(__MACH__) && !defined(_SYS_STATVFS_H_)
1132 dsi->f_namemax = pathconf(ts->filesystems[i], _PC_NAME_MAX);
1133 #elif defined(__OpenBSD__)
1135 dsi->f_namemax = pathconf(ts->filesystems[i], _PC_NAME_MAX);
1137 dsi->f_fsid = sfb.f_fsid;
1138 dsi->f_namemax = sfb.f_namelen;
1141 dsi->f_bsize = sfb.f_bsize;
1142 dsi->f_blocks = (
unsigned long long)sfb.f_blocks;
1143 dsi->f_bfree = (
unsigned long long)sfb.f_bfree;
1144 dsi->f_files = (
unsigned long long)sfb.f_files;
1145 dsi->f_ffree = (
unsigned long long)sfb.f_ffree;
1149 #ifdef STATFS_HAS_F_BAVAIL
1150 dsi->f_bavail = (
long long)(sfb.f_bavail ? sfb.f_bavail : 1);
1151 if (sfb.f_ffree > 0 && sfb.f_files > 0 && sfb.f_favail > 0)
1152 dsi->f_favail = (
long long)sfb.f_favail;
1154 dsi->f_favail = !(sfb.f_ffree == 0 && sfb.f_files == 0)
1155 ? (
signed long long) sfb.f_ffree : -1;
1161 dsi->f_bavail = sfb.f_blocks - sfb.f_bfree;
1163 dsi->f_favail = !(sfb.f_ffree == 0 && sfb.f_files == 0)
1167 #if !defined(ST_RDONLY)
1171 (
unsigned)i, (
unsigned) dsi->dev, (
unsigned) dsi->f_bsize,
1172 (
signed long) dsi->f_bavail, (
signed long) dsi->f_favail,
1173 ((dsi->f_flag &
ST_RDONLY) ?
"ro" :
"rw"),
1174 ts->filesystems[i]);
1184 rpmDiskSpaceInfo dsi;
1189 while (dsi->f_bsize && dsi->dev != dev)
1191 if (dsi->f_bsize == 0)
1197 bneeded = BLOCK_ROUND(fileSize, dsi->f_bsize);
1204 dsi->bneeded += bneeded;
1213 dsi->bneeded += bneeded;
1214 dsi->bneeded -= BLOCK_ROUND(prevSize, dsi->f_bsize);
1219 dsi->bneeded -= bneeded;
1227 dsi->bneeded -= BLOCK_ROUND(fixupSize, dsi->f_bsize);
1232 rpmDiskSpaceInfo dsi;
1237 if (ts->filesystems ==
NULL || ts->filesystemCount == 0)
1248 for (i = 0; i < ts->filesystemCount; i++, dsi++) {
1250 if (dsi->f_bavail > 0 && adj_fs_blocks(dsi->bneeded) > dsi->f_bavail) {
1251 if (dsi->bneeded != dsi->obneeded) {
1255 (adj_fs_blocks(dsi->bneeded) - dsi->f_bavail) * dsi->f_bsize);
1256 dsi->obneeded = dsi->bneeded;
1260 if (dsi->f_favail > 0 && adj_fs_blocks(dsi->ineeded) > dsi->f_favail) {
1261 if (dsi->ineeded != dsi->oineeded) {
1265 (adj_fs_blocks(dsi->ineeded) - dsi->f_favail));
1266 dsi->oineeded = dsi->ineeded;
1270 if ((dsi->bneeded || dsi->ineeded) && (dsi->f_flag &
ST_RDONLY)) {
1273 ts->filesystems[i],
NULL,
NULL, 0);
1283 if (ts && ts->notify) {
1297 ptr = ts->notify(h, what, amount, total, cbkey, ts->notifyData);
1309 if (ts !=
NULL && ts->order !=
NULL) {
1310 nelements = ts->orderCount;
1318 if (ts !=
NULL && ts->order !=
NULL) {
1319 if (ix >= 0 && ix < ts->orderCount)
1336 transFlags = ts->transFlags;
1349 otransFlags = ts->transFlags;
1370 odepFlags = ts->depFlags;
1371 ts->depFlags = depFlags;
1385 Spec ospec = ts->spec;
1395 return ts->relocateElement;
1401 rpmte orelocateElement = ts->relocateElement;
1403 ts->relocateElement = relocateElement;
1405 return orelocateElement;
1425 return (ts !=
NULL ? ts->dbmode : 0);
1432 odbmode = ts->dbmode;
1433 ts->dbmode = dbmode;
1440 return (ts !=
NULL ? ts->color : 0);
1455 return (ts !=
NULL ? ts->prefcolor : 0);
1462 ts->notify = notify;
1463 ts->notifyData = notifyData;
1473 memset(&ts->ops, 0,
sizeof(ts->ops));
1477 ts->filesystemCount = 0;
1478 ts->filesystems =
NULL;
1482 ts->solveData =
NULL;
1484 ts->suggests =
NULL;
1491 ts->dbmode = O_RDONLY;
1494 ts->scriptFd =
NULL;
1495 {
struct timeval tv;
1496 xx = gettimeofday(&tv,
NULL);
1504 if (!ts->prefcolor) ts->prefcolor = 0x2;
1507 ts->numRemovedPackages = 0;
1508 ts->allocedRemovedPackages = ts->delta;
1509 ts->removedPackages = (uint32_t *)
xcalloc(ts->allocedRemovedPackages,
1510 sizeof(*ts->removedPackages));
1518 ts->numAddedPackages = 0;
1519 ts->addedPackages =
NULL;
1521 ts->numErasedPackages = 0;
1522 ts->erasedPackages =
NULL;
1524 ts->numAvailablePackages = 0;
1525 ts->availablePackages =
NULL;
1527 ts->orderAlloced = 0;
1540 ts->arbgoal = 0xffffffff;
int rpmtsSetNotifyCallback(rpmts ts, rpmCallbackFunction notify, rpmCallbackData notifyData)
Set transaction notify callback function and argument.
int rpmtsSolve(rpmts ts, rpmds ds, const void *data)
Attempt to solve a needed dependency using the solve database.
qsort(mc->macroTable, mc->firstFree, sizeof(mc->macroTable[0]), compareMacroName)
int rpmtsChrootDone(rpmts ts)
Get chrootDone flag, i.e.
int rpmtsSetKeyring(rpmts ts, void *_keyring)
Set transaction keyring.
rpmop rpmtsOp(rpmts ts, rpmtsOpX opx)
Retrieve operation timestamp from a transaction set.
rpmte rpmtsSetRelocateElement(rpmts ts, rpmte relocateElement)
Set current relocate transaction element.
rpmprobFilterFlags rpmtsFilterFlags(rpmts ts)
Get problem ignore bit mask, i.e.
struct rpmdb_s * rpmdb
Database of headers and tag value indices.
rpmlog(RPMLOG_ERR,"%s\n", buf)
int rpmtsInitDSI(const rpmts ts)
Initialize disk space info for each and every mounted file systems.
struct rpmte_s * rpmte
An element of a transaction set, i.e.
Spec rpmtsSetSpec(rpmts ts, Spec spec)
Set a spec control structure in transaction set.
rpmtime_t rpmswAdd(rpmop to, rpmop from)
Sum statistic counters.
enum urltype_e urltype
Supported URL types.
OpenPGP constants and structures from RFC-2440.
static PyObject *int type
void *(* rpmCallbackFunction)(const void *h, const rpmCallbackType what, const rpmuint64_t amount, const rpmuint64_t total, fnpyKey key, rpmCallbackData data)
void rpmpsAppend(rpmps ps, rpmProblemType type, const char *pkgNEVR, fnpyKey key, const char *dn, const char *bn, const char *altNEVR, rpmuint64_t ulong1)
Append a problem to current set of problems.
enum iosmFileAction_e iosmFileAction
File disposition(s) during package install/erase processing.
static void rpmtsPrintStats(rpmts ts)
Structures used for an "rpmte" transaction element.
struct rpmPRCO_s * rpmPRCO
Container for commonly extracted dependency set(s).
char * xstrdup(const char *str)
int rpmtsDBMode(rpmts ts)
Retrieve dbmode of transaction set.
FD_t Fopen(const char *path, const char *_fmode)
fopen(3) clone.
char * rpmGetPath(const char *path,...)
Return (malloc'ed) expanded, canonicalized, file path.
Structure(s) used for file info tag sets.
rpmfi rpmteFI(rpmte te, rpmTag tag)
Retrieve file info tag set from transaction element.
enum rpmprobFilterFlags_e rpmprobFilterFlags
rpmtransFlags rpmtsSetFlags(rpmts ts, rpmtransFlags transFlags)
Set transaction flags, i.e.
struct rpmts_s * rpmts
The RPM Transaction Set.
evrFlags rpmdsFlags(const rpmds ds)
Return current dependency flags.
rpmdb rpmtsGetRdb(rpmts ts)
Get transaction set database handle.
void rpmtsUpdateDSI(const rpmts ts, dev_t dev, rpmuint32_t fileSize, rpmuint32_t prevSize, rpmuint32_t fixupSize, int _action)
Update disk space info for a file.
int rpmdbClose(rpmdb db)
Close all database indices and free rpmdb.
int rpmtsSetSolveCallback(rpmts ts, int(*solve)(rpmts ts, rpmds key, const void *data), const void *solveData)
rpmuint32_t rpmtsSetTid(rpmts ts, rpmuint32_t tid)
Set transaction id, i.e.
int Stat(const char *path, struct stat *st)
stat(2) clone.
FD_t fdLink(void *cookie, const char *msg)
int rpmtsUnorderedSuccessors(rpmts ts, int first)
Set index of 1st element of successors.
int rpmdsSysinfo(rpmPRCO PRCO, const char *fn)
Load sysinfo dependencies into a dependency set.
enum rpmCallbackType_e rpmCallbackType
Bit(s) to identify progress callbacks.
Access mounted file system information.
rpmte rpmtsiNext(rpmtsi tsi, rpmElementType type)
Return next transaction element of type.
int rpmtsRebuildDB(rpmts ts)
Rebuild the database used by the transaction.
rpmTSType rpmtsType(rpmts ts)
Return the type of a transaction.
void addMacro(MacroContext mc, const char *n, const char *o, const char *b, int level)
Add macro to context.
void rpmtsEmpty(rpmts ts)
Re-create an empty transaction set.
void rpmtsSetARBGoal(rpmts ts, rpmuint32_t goal)
Set autorollback goal.
rpmPRCO rpmdsNewPRCO(Header h)
Create dependency set(s) container.
struct rpmps_s * rpmps
Transaction problems found while processing a transaction set/.
int rpmsxEnabled(rpmsx sx)
Return SELinux enabled state.
tsmStage rpmtsSetGoal(rpmts ts, tsmStage goal)
Set goal of transaction set.
rpmuint32_t rpmtsGetTid(rpmts ts)
Get transaction id, i.e.
int rpmfiFC(rpmfi fi)
Return file count from file info set.
void rpmtsSetCurrDir(rpmts ts, const char *currDir)
Set transaction currDir, i.e.
rpmPRCO rpmdsFreePRCO(rpmPRCO PRCO)
Free dependency set(s) container.
rpmdepFlags rpmtsSetDFlags(rpmts ts, rpmdepFlags depFlags)
Set dependency flags, i.e.
enum rpmRC_e rpmRC
RPM return codes.
Yet Another syslog(3) API clone.
void rpmtsCheckDSIProblems(const rpmts ts, const rpmte te)
Check a transaction element for disk space problems.
memset(_r, 0, sizeof(*_r))
enum rpmElementType_e rpmElementType
Transaction element type.
rpmts rpmtsLink(rpmts ts, const char *msg)
Reference a transaction set instance.
pgpVSFlags pgpDigVSFlags
Disabler bits(s) for signature/digest checking.
rpmts rpmtsCreate(void)
Create an empty transaction set.
void rpmtsSetRootDir(rpmts ts, const char *rootDir)
Set transaction rootDir, i.e.
const char * Fstrerror(FD_t fd)
strerror(3) clone.
void * xcalloc(size_t nmemb, size_t size)
assert(key->size==sizeof(hdrNum))
int rpmdbOpen(const char *prefix, rpmdb *dbp, int mode, mode_t perms)
Open rpm database.
rpmps rpmpsCreate(void)
Create a problem set.
void * rpmtsGetKeyring(rpmts ts, int autoload)
Get transaction keyring.
rpmmi rpmmiFree(rpmmi mi)
Destroy rpm database iterator.
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
fprintf(stderr,"--> %s(%p,%p,%p) sig %p sigp %p\n", __FUNCTION__, dig, t, rsactx, sig, sigp)
int rpmGetMacroEntries(MacroContext mc, void *_mire, int used, const char ***avp)
Return macro entries as string array.
FD_t fdFree(FD_t fd, const char *msg)
rpmte rpmtsRelocateElement(rpmts ts)
Get current relocate transaction element.
int argvCount(const ARGV_t argv)
Return no.
int rpmdsAnyMatchesDep(const Header h, const rpmds req, int nopromote)
Compare package provides dependencies from header with a single dependency.
rpmTag rpmdsTagN(const rpmds ds)
Return current dependency type.
unsigned long long rpmuint64_t
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
const char * tagName(rpmTag tag)
Return tag name from value.
int rpmtsCloseDB(rpmts ts)
Close the database used by the transaction.
int rpmioAccess(const char *FN, const char *path, int mode)
Check FN access, expanding relative paths and twiddles.
rpmRC rpmReadPackageFile(rpmts ts, FD_t fd, const char *fn, Header *hdrp)
Return package header from file handle, verifying digests/signatures.
Header rpmmiNext(rpmmi mi)
Return next package header from iteration.
rpmuint32_t rpmtsColor(rpmts ts)
Retrieve color bits of transaction set.
Structure(s) used for dependency tag sets.
void * rpmtsNotify(rpmts ts, rpmte te, rpmCallbackType what, rpmuint64_t amount, rpmuint64_t total)
Perform transaction progress notify callback.
int rpmtsAddInstallElement(rpmts ts, Header h, fnpyKey key, int upgrade, rpmRelocation relocs)
Add package to be installed to transaction set.
The FD_t File Handle data structure.
const char * rpmtsRootDir(rpmts ts)
Get transaction rootDir, i.e.
struct tagStore_s * tagStore_t
The structure used to store values parsed from a spec file.
static void rpmtsPrintStat(const char *name, struct rpmop_s *op)
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
static rpmts rpmtsGetPool(rpmioPool pool)
int rpmtsOpenDB(rpmts ts, int dbmode)
Open the database used by the transaction.
int rpmtsCloseSDB(rpmts ts)
Close the database used by the transaction to solve dependencies.
rpmtsi rpmtsiFree(rpmtsi tsi)
Destroy transaction element iterator.
rpmte rpmtsElement(rpmts ts, int ix)
Return (ordered) transaction set element.
int rpmtsSetDBMode(rpmts ts, int dbmode)
Set dbmode of transaction set.
pgpVSFlags rpmVSFlags
Bit(s) to control digest and signature verification.
static int sugcmp(const void *a, const void *b)
Compare suggested package resolutions (qsort/bsearch).
tsmStage rpmtsGoal(rpmts ts)
Retrieve goal of transaction set.
int Fclose(FD_t fd)
fclose(3) clone.
Cumulative statistics for an operation.
struct rpmds_s * rpmds
Dependency tag sets from a header, so that a header can be discarded early.
void argvPrint(const char *msg, ARGV_t argv, FILE *fp)
Print argv array elements.
rpmps rpmpsFree(rpmps ps)
Destroy a problem set.
Spec rpmtsSpec(rpmts ts)
Get spec control structure from transaction set.
rpmVSFlags rpmtsSetVSFlags(rpmts ts, rpmVSFlags vsflags)
Set verify signatures flag(s).
int Ferror(FD_t fd)
ferror(3) clone.
void rpmteCleanDS(rpmte te)
Destroy dependency set info of transaction element.
void rpmtsClean(rpmts ts)
Free memory needed only for dependency checks and ordering.
struct rpmtsi_s * rpmtsi
Transaction element iterator.
return strcmp(ame->name, bme->name)
rpmuint32_t rpmtsSetColor(rpmts ts, rpmuint32_t color)
Set color bits of transaction set.
int rpmtsSELinuxEnabled(rpmts ts)
Get selinuxEnabled flag, i.e.
urltype urlPath(const char *url, const char **pathp)
Return path component of URL.
static PyObject *rpmtransFlags transFlags
dbiIndex dbiOpen(rpmdb db, rpmTag tag, unsigned int flags)
enum rpmtransFlags_e rpmtransFlags
Bit(s) to control rpmtsRun() operation.
Methods to handle package elements.
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
int rpmtsAvailable(rpmts ts, const rpmds ds)
Attempt to solve a needed dependency using memory resident tables.
int rpmtsNElements(rpmts ts)
Return number of (ordered) transaction set elements.
char * stpcpy(char *dest, const char *src)
int rpmGetFilesystemList(const char ***listptr, rpmuint32_t *num)
Return (cached) file system mount points.
rpmtransFlags rpmtsFlags(rpmts ts)
Get transaction flags, i.e.
enum rpmTSType_e rpmTSType
Transaction Types.
rpmuint32_t rpmtsARBGoal(rpmts ts)
Return the autorollback goal.
Structures and prototypes used for an "rpmts" transaction set.
const char * rpmdsEVR(const rpmds ds)
Return current dependency epoch-version-release.
rpmVSFlags rpmtsVSFlags(rpmts ts)
Get verify signatures flag(s).
int argvSplit(ARGV_t *argvp, const char *str, const char *seps)
Split a string into an argv array.
rpmPRCO rpmtsPRCO(rpmts ts)
Get transaction set dependencies.
const char * rpmtsCurrDir(rpmts ts)
Get transaction currDir, i.e.
fnpyKey * rpmalAllSatisfiesDepend(const rpmal al, const rpmds ds, alKey *keyp)
Check added package file lists for package(s) that have a provide.
rpmal rpmalFree(rpmal al)
Destroy available list.
#define RMIL_DEFAULT
Markers for sources of macros added throughout rpm.
static void
Print copy of spec file, filling in Group/Description/Summary from specspo.
int rpmtsSetChrootDone(rpmts ts, int chrootDone)
Set chrootDone flag, i.e.
Structures used for managing added/available package lists.
char * buf
Parse (and execute) macro undefinition.
File state machine to handle archive I/O and system call's.
const char * rpmteNEVR(rpmte te)
Retrieve name-version-release string from transaction element.
int
Save source and expand field into target.
void rpmtsSetType(rpmts ts, rpmTSType type)
Set transaction type.
const char * rpmdsN(const rpmds ds)
Return current dependency name.
rpmuint32_t rpmtsPrefColor(rpmts ts)
Retrieve preferred file color.
rpmps rpmpsLink(rpmps ps, const char *msg)
Reference a problem set instance.
fnpyKey rpmteKey(rpmte te)
Retrieve key from transaction element.
Access RPM indices using Berkeley DB interface(s).
rpmte rpmteFree(rpmte te)
Destroy a transaction element.
rpmdepFlags rpmtsDFlags(rpmts ts)
Get dependency flags, i.e.
rpmmi rpmtsInitIterator(const rpmts ts, rpmTag rpmtag, const void *keyp, size_t keylen)
Return transaction database iterator.
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
enum rpmdepFlags_e rpmdepFlags
Bit(s) to control rpmtsCheck() and rpmtsOrder() operation.
int rpmExpandNumeric(const char *arg)
Return macro expansion as a numeric value.
static void rpmtsFini(void *_ts)
void rpmtsSetScriptFd(rpmts ts, FD_t scriptFd)
#define RPMDBI_PACKAGES
Pseudo-tags used by the rpmdb and rpmgi iterator API's.
FD_t rpmtsScriptFd(rpmts ts)
rpmtsi rpmtsiInit(rpmts ts)
Create transaction element iterator.
rpmmi rpmmiInit(rpmdb db, rpmTag tag, const void *keyp, size_t keylen)
Return database iterator.
static PyObject *rpmds ds
rpmps rpmtsProblems(rpmts ts)
Return current transaction set problems.
int rpmtsOpenSDB(rpmts ts, int dbmode)
Open the database used by the transaction to solve dependencies.
int Unlink(const char *path)
unlink(2) clone.
void rpmtsCleanDig(rpmts ts)
Free signature verification data.