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);
129 const char * dn =
rpmGetPath(ts->rootDir,
"%{_dbpath}", NULL);
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)),
185 (void)
dbiOpen(db, dbiTags->tag, db->db_flags);
195 (
unsigned)db->db_maxkey);
196 fn =
rpmGetPath(db->db_root, db->db_home,
"/Seqno", NULL);
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;
464 const char * qfmt =
rpmExpand(
"%{?_solve_name_fmt}", NULL);
465 if (qfmt == NULL || *qfmt ==
'\0')
482 fd =
Fopen(str,
"r.fdio");
483 if (fd == NULL ||
Ferror(fd)) {
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);
568 int (*solve) (
rpmts ts,
rpmds key,
const void * data),
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);
637 ts->order[oc] =
rpmteFree(ts->order[oc]);
641 ts->numAddedFiles = 0;
642 ts->numErasedFiles = 0;
648 ts->numRemovedPackages = 0;
658 static unsigned int scale = (1000 * 1000);
659 if (op != NULL && op->
count > 0)
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);
726 assert(ts->txn == NULL);
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);
762 const char ** av = NULL;
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;
870 return (
rpmTSType) ((ts != NULL) ? ts->type : 0);
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);
971 FD_t scriptFd = NULL;
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;
1049 const char * fn =
rpmGetPath(
"%{?_rpmds_sysinfo_path}", NULL);
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 bneeded = BLOCK_ROUND(prevSize, dsi->f_bsize);
1215 if (dsi->bneeded > bneeded)
1216 dsi->bneeded -= bneeded;
1223 if (dsi->bneeded > bneeded)
1224 dsi->bneeded -= bneeded;
1234 bneeded = BLOCK_ROUND(fixupSize, dsi->f_bsize);
1235 if (dsi->bneeded > bneeded)
1236 dsi->bneeded -= bneeded;
1244 rpmDiskSpaceInfo dsi;
1249 if (ts->filesystems == NULL || ts->filesystemCount == 0)
1260 for (i = 0; i < ts->filesystemCount; i++, dsi++) {
1262 if (dsi->f_bavail > 0 && adj_fs_blocks(dsi->bneeded) > dsi->f_bavail) {
1263 if (dsi->bneeded != dsi->obneeded) {
1266 ts->filesystems[i], NULL, NULL,
1267 (adj_fs_blocks(dsi->bneeded) - dsi->f_bavail) * dsi->f_bsize);
1268 dsi->obneeded = dsi->bneeded;
1272 if (dsi->f_favail > 0 && adj_fs_blocks(dsi->ineeded) > dsi->f_favail) {
1273 if (dsi->ineeded != dsi->oineeded) {
1276 ts->filesystems[i], NULL, NULL,
1277 (adj_fs_blocks(dsi->ineeded) - dsi->f_favail));
1278 dsi->oineeded = dsi->ineeded;
1282 if ((dsi->bneeded || dsi->ineeded) && (dsi->f_flag &
ST_RDONLY)) {
1285 ts->filesystems[i], NULL, NULL, 0);
1295 if (ts && ts->notify) {
1309 ptr = ts->notify(h, what, amount, total, cbkey, ts->notifyData);
1321 if (ts != NULL && ts->order != NULL) {
1322 nelements = ts->orderCount;
1330 if (ts != NULL && ts->order != NULL) {
1331 if (ix >= 0 && ix < ts->orderCount)
1348 transFlags = ts->transFlags;
1361 otransFlags = ts->transFlags;
1368 ts->transFlags = transFlags;
1375 return (
rpmdepFlags) (ts != NULL ? ts->depFlags : 0);
1382 odepFlags = ts->depFlags;
1383 ts->depFlags = depFlags;
1397 Spec ospec = ts->spec;
1407 return ts->relocateElement;
1413 rpmte orelocateElement = ts->relocateElement;
1415 ts->relocateElement = relocateElement;
1417 return orelocateElement;
1437 return (ts != NULL ? ts->dbmode : 0);
1444 odbmode = ts->dbmode;
1445 ts->dbmode = dbmode;
1452 return (ts != NULL ? ts->color : 0);
1467 return (ts != NULL ? ts->prefcolor : 0);
1474 ts->notify = notify;
1475 ts->notifyData = notifyData;
1485 memset(&ts->ops, 0,
sizeof(ts->ops));
1489 ts->filesystemCount = 0;
1490 ts->filesystems = NULL;
1494 ts->solveData = NULL;
1496 ts->suggests = NULL;
1503 ts->dbmode = O_RDONLY;
1506 ts->scriptFd = NULL;
1507 {
struct timeval tv;
1508 xx = gettimeofday(&tv, NULL);
1516 if (!ts->prefcolor) ts->prefcolor = 0x2;
1519 ts->numRemovedPackages = 0;
1520 ts->allocedRemovedPackages = ts->delta;
1521 ts->removedPackages = (uint32_t *)
xcalloc(ts->allocedRemovedPackages,
1522 sizeof(*ts->removedPackages));
1530 ts->numAddedPackages = 0;
1531 ts->addedPackages = NULL;
1533 ts->numErasedPackages = 0;
1534 ts->erasedPackages = NULL;
1536 ts->numAvailablePackages = 0;
1537 ts->availablePackages = NULL;
1539 ts->orderAlloced = 0;
1552 ts->arbgoal = 0xffffffff;
Spec rpmtsSpec(rpmts ts)
Get spec control structure from transaction set.
evrFlags rpmdsFlags(const rpmds ds)
Return current dependency flags.
rpmPRCO rpmdsFreePRCO(rpmPRCO PRCO)
Free dependency set(s) container.
rpmtime_t rpmswExit(rpmop op, ssize_t rc)
Exit timed operation.
void * rpmtsNotify(rpmts ts, rpmte te, rpmCallbackType what, rpmuint64_t amount, rpmuint64_t total)
Perform transaction progress notify callback.
void *(* rpmCallbackFunction)(const void *h, const rpmCallbackType what, const rpmuint64_t amount, const rpmuint64_t total, fnpyKey key, rpmCallbackData data)
rpmte rpmteFree(rpmte te)
Destroy a transaction element.
enum urltype_e urltype
Supported URL types.
OpenPGP constants and structures from RFC-2440.
const char * rpmtsRootDir(rpmts ts)
Get transaction rootDir, i.e.
rpmte rpmtsElement(rpmts ts, int ix)
Return (ordered) transaction set element.
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.
char * xstrdup(const char *str)
FD_t Fopen(const char *path, const char *_fmode)
fopen(3) clone.
int rpmtsAddInstallElement(rpmts ts, Header h, fnpyKey key, int upgrade, rpmRelocation relocs)
Add package to be installed to transaction set.
char * rpmGetPath(const char *path,...)
Return (malloc'ed) expanded, canonicalized, file path.
Structure(s) used for file info tag sets.
enum rpmprobFilterFlags_e rpmprobFilterFlags
int rpmtsSetSolveCallback(rpmts ts, int(*solve)(rpmts ts, rpmds key, const void *data), const void *solveData)
rpmtime_t rpmswAdd(rpmop to, rpmop from)
Sum statistic counters.
int Stat(const char *path, struct stat *st)
stat(2) clone.
FD_t fdLink(void *cookie, const char *msg)
static rpmVSFlags vsflags
int rpmtsSetNotifyCallback(rpmts ts, rpmCallbackFunction notify, rpmCallbackData notifyData)
Set transaction notify callback function and argument.
enum rpmCallbackType_e rpmCallbackType
Bit(s) to identify progress callbacks.
Access mounted file system information.
enum rpmTSType_e rpmTSType
Transaction Types.
void addMacro(MacroContext mc, const char *n, const char *o, const char *b, int level)
Add macro to context.
rpmTag rpmdsTagN(const rpmds ds)
Return current dependency type.
rpmop rpmtsOp(rpmts ts, rpmtsOpX opx)
Retrieve operation timestamp from a transaction set.
int rpmtsSetChrootDone(rpmts ts, int chrootDone)
Set chrootDone flag, i.e.
rpmtsi rpmtsiFree(rpmtsi tsi)
Destroy transaction element iterator.
struct rpmtsi_s * rpmtsi
Transaction element iterator.
rpmTSType rpmtsType(rpmts ts)
Return the type of a transaction.
static void rpmlog(int code, const char *fmt,...)
struct rpmps_s * rpmps
Transaction problems found while processing a transaction set/.
rpmts rpmtsLink(rpmts ts, const char *msg)
Reference a transaction set instance.
int rpmsxEnabled(rpmsx sx)
Return SELinux enabled state.
struct rpmds_s * rpmds
Dependency tag sets from a header, so that a header can be discarded early.
rpmPRCO rpmtsPRCO(rpmts ts)
Get transaction set dependencies.
struct rpmPRCO_s * rpmPRCO
Container for commonly extracted dependency set(s).
char * headerSprintf(Header h, const char *fmt, headerTagTableEntry tags, headerSprintfExtension exts, errmsg_t *errmsg)
Return formatted output string from header tags.
int rpmfiFC(rpmfi fi)
Return file count from file info set.
struct rpmte_s * rpmte
An element of a transaction set, i.e.
rpmmi rpmmiInit(rpmdb db, rpmTag tag, const void *keyp, size_t keylen)
Return database iterator.
int rpmtsInitDSI(const rpmts ts)
Initialize disk space info for each and every mounted file systems.
const char * rpmtsCurrDir(rpmts ts)
Get transaction currDir, i.e.
rpmPRCO rpmdsNewPRCO(Header h)
Create dependency set(s) container.
Yet Another syslog(3) API clone.
enum rpmElementType_e rpmElementType
Transaction element type.
rpmuint32_t rpmtsSetTid(rpmts ts, rpmuint32_t tid)
Set transaction id, i.e.
rpmtransFlags rpmtsSetFlags(rpmts ts, rpmtransFlags transFlags)
Set transaction flags, i.e.
void delMacro(MacroContext mc, const char *n)
Delete macro from context.
pgpVSFlags pgpDigVSFlags
Disabler bits(s) for signature/digest checking.
void rpmtsCleanDig(rpmts ts)
Free signature verification data.
const char * rpmteNEVR(rpmte te)
Retrieve name-version-release string from transaction element.
const char * Fstrerror(FD_t fd)
strerror(3) clone.
void * xcalloc(size_t nmemb, size_t size)
int rpmdsSysinfo(rpmPRCO PRCO, const char *fn)
Load sysinfo dependencies into a dependency set.
rpmps rpmpsCreate(void)
Create a problem set.
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
int rpmGetMacroEntries(MacroContext mc, void *_mire, int used, const char ***avp)
Return macro entries as string array.
rpmfi rpmteFI(rpmte te, rpmTag tag)
Retrieve file info tag set from transaction element.
FD_t fdFree(FD_t fd, const char *msg)
int argvCount(const ARGV_t argv)
Return no.
int rpmtsCloseSDB(rpmts ts)
Close the database used by the transaction to solve dependencies.
enum rpmdepFlags_e rpmdepFlags
Bit(s) to control rpmtsCheck() and rpmtsOrder() operation.
unsigned long long rpmuint64_t
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
int rpmtsNElements(rpmts ts)
Return number of (ordered) transaction set elements.
const char * rpmdsEVR(const rpmds ds)
Return current dependency epoch-version-release.
const char * tagName(rpmTag tag)
Return tag name from value.
int rpmdbOpen(const char *prefix, rpmdb *dbp, int mode, mode_t perms)
Open rpm database.
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.
rpmuint32_t rpmtsPrefColor(rpmts ts)
Retrieve preferred file color.
Structure(s) used for dependency tag sets.
void rpmteCleanDS(rpmte te)
Destroy dependency set info of transaction element.
struct tagStore_s * tagStore_t
int rpmtsRebuildDB(rpmts ts)
Rebuild the database used by the transaction.
The FD_t File Handle data structure.
rpmmi rpmtsInitIterator(const rpmts ts, rpmTag rpmtag, const void *keyp, size_t keylen)
Return transaction database iterator.
struct rpmdb_s * rpmdb
Database of headers and tag value indices.
int rpmtsChrootDone(rpmts ts)
Get chrootDone flag, i.e.
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 rpmtsSolve(rpmts ts, rpmds ds, const void *data)
Attempt to solve a needed dependency using the solve database.
int rpmtsSetKeyring(rpmts ts, void *_keyring)
Set transaction keyring.
The structure used to store values parsed from a spec file.
pgpVSFlags rpmVSFlags
Bit(s) to control digest and signature verification.
Header headerFree(Header h)
Dereference a header instance.
static void rpmtsPrintStat(const char *name, struct rpmop_s *op)
int rpmswEnter(rpmop op, ssize_t rc)
Enter timed operation.
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
rpmuint32_t rpmtsARBGoal(rpmts ts)
Return the autorollback goal.
static rpmts rpmtsGetPool(rpmioPool pool)
void rpmtsSetARBGoal(rpmts ts, rpmuint32_t goal)
Set autorollback goal.
int rpmdsAnyMatchesDep(const Header h, const rpmds req, int nopromote)
Compare package provides dependencies from header with a single dependency.
void rpmtsSetType(rpmts ts, rpmTSType type)
Set transaction type.
void rpmtsSetRootDir(rpmts ts, const char *rootDir)
Set transaction rootDir, i.e.
int rpmtsSetDBMode(rpmts ts, int dbmode)
Set dbmode of transaction set.
void rpmtsSetCurrDir(rpmts ts, const char *currDir)
Set transaction currDir, i.e.
static int sugcmp(const void *a, const void *b)
Compare suggested package resolutions (qsort/bsearch).
const char * rpmdsN(const rpmds ds)
Return current dependency name.
rpmmi rpmmiFree(rpmmi mi)
Destroy rpm database iterator.
int Fclose(FD_t fd)
fclose(3) clone.
Cumulative statistics for an operation.
rpmte rpmtsiNext(rpmtsi tsi, rpmElementType type)
Return next transaction element of type.
void argvPrint(const char *msg, ARGV_t argv, FILE *fp)
Print argv array elements.
Spec rpmtsSetSpec(rpmts ts, Spec spec)
Set a spec control structure in transaction set.
rpmps rpmpsFree(rpmps ps)
Destroy a problem set.
Header headerLink(Header h)
Reference a header instance.
rpmte rpmtsRelocateElement(rpmts ts)
Get current relocate transaction element.
rpmdb rpmtsGetRdb(rpmts ts)
Get transaction set database handle.
fnpyKey rpmteKey(rpmte te)
Retrieve key from transaction element.
enum rpmRC_e rpmRC
RPM return codes.
void rpmtsCheckDSIProblems(const rpmts ts, const rpmte te)
Check a transaction element for disk space problems.
int Ferror(FD_t fd)
ferror(3) clone.
rpmuint32_t rpmtsColor(rpmts ts)
Retrieve color bits of transaction set.
rpmdepFlags rpmtsDFlags(rpmts ts)
Get dependency flags, i.e.
urltype urlPath(const char *url, const char **pathp)
Return path component of URL.
rpmdepFlags rpmtsSetDFlags(rpmts ts, rpmdepFlags depFlags)
Set dependency flags, i.e.
dbiIndex dbiOpen(rpmdb db, rpmTag tag, unsigned int flags)
rpmts rpmtsCreate(void)
Create an empty transaction set.
Methods to handle package elements.
rpmte rpmtsSetRelocateElement(rpmts ts, rpmte relocateElement)
Set current relocate transaction element.
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.
rpmps rpmtsProblems(rpmts ts)
Return current transaction set problems.
enum rpmtransFlags_e rpmtransFlags
Bit(s) to control rpmtsRun() operation.
int rpmtsOpenSDB(rpmts ts, int dbmode)
Open the database used by the transaction to solve dependencies.
rpmVSFlags rpmtsSetVSFlags(rpmts ts, rpmVSFlags vsflags)
Set verify signatures flag(s).
char * stpcpy(char *dest, const char *src)
int rpmGetFilesystemList(const char ***listptr, rpmuint32_t *num)
Return (cached) file system mount points.
struct rpmts_s * rpmts
The RPM Transaction Set.
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
tsmStage rpmtsGoal(rpmts ts)
Retrieve goal of transaction set.
Structures and prototypes used for an "rpmts" transaction set.
Header rpmmiNext(rpmmi mi)
Return next package header from iteration.
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.
int rpmtsUnorderedSuccessors(rpmts ts, int first)
Set index of 1st element of successors.
int rpmtsOpenDB(rpmts ts, int dbmode)
Open the database used by the transaction.
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.
void * rpmtsGetKeyring(rpmts ts, int autoload)
Get transaction keyring.
Structures used for managing added/available package lists.
File state machine to handle archive I/O and system call's.
rpmprobFilterFlags rpmtsFilterFlags(rpmts ts)
Get problem ignore bit mask, i.e.
int rpmtsSELinuxEnabled(rpmts ts)
Get selinuxEnabled flag, i.e.
rpmps rpmpsLink(rpmps ps, const char *msg)
Reference a problem set instance.
rpmuint32_t rpmtsGetTid(rpmts ts)
Get transaction id, i.e.
rpmtsi rpmtsiInit(rpmts ts)
Create transaction element iterator.
Access RPM indices using Berkeley DB interface(s).
int rpmdbClose(rpmdb db)
Close all database indices and free rpmdb.
rpmtransFlags rpmtsFlags(rpmts ts)
Get transaction flags, i.e.
int rpmtsDBMode(rpmts ts)
Retrieve dbmode of transaction set.
rpmuint32_t rpmtsSetColor(rpmts ts, rpmuint32_t color)
Set color bits of transaction set.
int rpmtsCloseDB(rpmts ts)
Close the database used by the transaction.
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)
void rpmtsEmpty(rpmts ts)
Re-create an empty transaction set.
tsmStage rpmtsSetGoal(rpmts ts, tsmStage goal)
Set goal of transaction set.
void rpmtsClean(rpmts ts)
Free memory needed only for dependency checks and ordering.
int rpmtsAvailable(rpmts ts, const rpmds ds)
Attempt to solve a needed dependency using memory resident tables.
int Unlink(const char *path)
unlink(2) clone.