static rpmRC systemd_inhibit_tsm_post(rpmPlugin plugin, rpmts ts, int res)
{
if (lock_fd >= 0) {
close(lock_fd);
lock_fd = -1;
rpmlog(RPMLOG_DEBUG, "System shutdown unblocked\n");
}
return RPMRC_OK;
}
static void fsmDebug(const char *fpath, rpmFileAction action,
const struct stat *st)
{
rpmlog(RPMLOG_DEBUG, "%-10s %06o%3d (%4d,%4d)%6d %s\n",
fileActionString(action), (int)st->st_mode,
(int)st->st_nlink, (int)st->st_uid,
(int)st->st_gid, (int)st->st_size,
(fpath ? fpath : ""));
}
/**
* Print package size.
* @todo rpmio: use fdSize rather than fstat(2) to get file size.
* @param fd package file handle
* @param siglen signature header size
* @param pad signature padding
* @param datalen length of header+payload
* @return rpmRC return code
*/
static inline rpmRC printSize(FD_t fd, size_t siglen, size_t pad, rpm_loff_t datalen)
{
struct stat st;
int fdno = Fileno(fd);
if (fstat(fdno, &st) < 0)
return RPMRC_FAIL;
rpmlog(RPMLOG_DEBUG,
"Expected size: %12" PRIu64 \
" = lead(%d)+sigs(%zd)+pad(%zd)+data(%" PRIu64 ")\n",
RPMLEAD_SIZE+siglen+pad+datalen,
RPMLEAD_SIZE, siglen, pad, datalen);
rpmlog(RPMLOG_DEBUG,
" Actual size: %12" PRIu64 "\n", (rpm_loff_t) st.st_size);
return RPMRC_OK;
}
int rpmluaRunScriptFile(rpmlua _lua, const char *filename)
{
INITSTATE(_lua, lua);
lua_State *L = lua->L;
int ret = 0;
if (luaL_loadfile(L, filename) != 0) {
rpmlog(RPMLOG_ERR, _("invalid syntax in Lua file: %s\n"),
lua_tostring(L, -1));
lua_pop(L, 1);
ret = -1;
} else if (lua_pcall(L, 0, 0, 0) != 0) {
rpmlog(RPMLOG_ERR, _("Lua script failed: %s\n"),
lua_tostring(L, -1));
lua_pop(L, 1);
ret = -1;
}
return ret;
}
static rpmRC fdJump(FD_t fd, off_t offset)
{
if (Fseek(fd, offset, SEEK_SET) < 0) {
rpmlog(RPMLOG_ERR, _("Could not seek in file %s: %s\n"),
Fdescr(fd), Fstrerror(fd));
return RPMRC_FAIL;
}
return RPMRC_OK;
}
static rpmRC checkPackages(char *pkgcheck)
{
int fail = rpmExpandNumeric("%{?_nonzero_exit_pkgcheck_terminate_build}");
int xx;
rpmlog(RPMLOG_NOTICE, _("Executing \"%s\":\n"), pkgcheck);
xx = system(pkgcheck);
if (WEXITSTATUS(xx) == -1 || WEXITSTATUS(xx) == 127) {
rpmlog(RPMLOG_ERR, _("Execution of \"%s\" failed.\n"), pkgcheck);
if (fail) return RPMRC_NOTFOUND;
}
if (WEXITSTATUS(xx) != 0) {
rpmlog(RPMLOG_ERR, _("Package check \"%s\" failed.\n"), pkgcheck);
if (fail) return RPMRC_FAIL;
}
return RPMRC_OK;
}
/* External interface */
rpmlock rpmlockNew(const char *lock_path, const char *descr)
{
rpmlock lock = rpmlock_new(lock_path, descr);
if (!lock) {
rpmlog(RPMLOG_ERR, _("can't create %s lock on %s (%s)\n"),
descr, lock_path, strerror(errno));
}
return lock;
}
const char * rpmmgFile(rpmmg mg, const char *fn)
{
const char * t = NULL;
if (_rpmmg_debug)
fprintf(stderr, "--> rpmmgFile(%p, %s)\n", mg, (fn ? fn : "(nil)"));
#if defined(HAVE_MAGIC_H)
if (mg->ms) {
const char * lpath = NULL;
int ut = urlPath(fn, &lpath);
switch (ut) {
case URL_IS_FTP:
case URL_IS_HKP:
case URL_IS_HTTP:
case URL_IS_HTTPS:
{ char b[512];
size_t nb = 0;
FD_t fd;
fd = Fopen(fn, "r.ufdio");
if (fd != NULL && !Ferror(fd)) {
nb = Fread(b, 1, sizeof(b), fd);
(void) Fclose(fd);
}
if (nb > 0)
return rpmmgBuffer(mg, b, nb);
} break;
case URL_IS_DASH:
case URL_IS_MONGO: /* XXX FIXME */
break;
case URL_IS_PATH:
fn = lpath;
/*@fallthrough@*/
case URL_IS_UNKNOWN:
default:
t = magic_file(mg->ms, fn);
/* XXX HACK: libmagic compiled without <pcreposix.h> spews here. */
if (t == NULL) {
const char * msg = magic_error(mg->ms);
if (strstr(msg, "regexec error 17, (match failed)") == NULL)
rpmlog(RPMLOG_ERR, _("magic_file(ms, %s) failed: %s\n"),
(fn ? fn : "(nil)"), msg);
}
break;
}
}
#endif
if (t == NULL) t = "";
t = xstrdup(t);
if (_rpmmg_debug)
fprintf(stderr, "<-- rpmmgFile(%p, %s) %s\n", mg, (fn ? fn : "(nil)"), t);
return t;
}
/**
* Check that file owner and group are known.
* @param urlfn file url
* @return RPMRC_OK on success
*/
static rpmRC checkOwners(const char * urlfn)
/*@globals h_errno, fileSystem, internalState @*/
/*@modifies fileSystem, internalState @*/
{
struct stat sb;
if (Lstat(urlfn, &sb)) {
rpmlog(RPMLOG_ERR, _("Bad source: %s: %s\n"),
urlfn, strerror(errno));
return RPMRC_FAIL;
}
if (!getUname(sb.st_uid) || !getGname(sb.st_gid)) {
rpmlog(RPMLOG_ERR, _("Bad owner/group: %s\n"), urlfn);
return RPMRC_FAIL;
}
return RPMRC_OK;
}
static rpmRC replaceSigDigests(FD_t fd, const char *rpm, Header *sigp,
off_t sigStart, off_t sigTargetSize,
char *SHA1, uint8_t *MD5)
{
off_t archiveSize;
rpmRC rc = RPMRC_OK;
if (Fseek(fd, sigStart, SEEK_SET) < 0) {
rc = RPMRC_FAIL;
rpmlog(RPMLOG_ERR, _("Could not seek in file %s: %s\n"),
rpm, Fstrerror(fd));
goto exit;
}
/* Get payload size from signature tag */
archiveSize = headerGetNumber(*sigp, RPMSIGTAG_PAYLOADSIZE);
if (!archiveSize) {
archiveSize = headerGetNumber(*sigp, RPMSIGTAG_LONGARCHIVESIZE);
}
/* Replace old digests in sigh */
rc = rpmGenerateSignature(SHA1, MD5, sigTargetSize, archiveSize, fd);
if (rc != RPMRC_OK) {
rpmlog(RPMLOG_ERR, _("generateSignature failed\n"));
goto exit;
}
if (Fseek(fd, sigStart, SEEK_SET) < 0) {
rc = RPMRC_FAIL;
rpmlog(RPMLOG_ERR, _("Could not seek in file %s: %s\n"),
rpm, Fstrerror(fd));
goto exit;
}
headerFree(*sigp);
rc = rpmReadSignature(fd, sigp, RPMSIGTYPE_HEADERSIG, NULL);
if (rc != RPMRC_OK) {
rpmlog(RPMLOG_ERR, _("rpmReadSignature failed\n"));
goto exit;
}
exit:
return rc;
}
static int parseNoSource(rpmSpec spec, const char * field, rpmTagVal tag)
{
const char *f, *fe;
const char *name;
int flag;
uint32_t num;
if (tag == RPMTAG_NOSOURCE) {
flag = RPMBUILD_ISSOURCE;
name = "source";
} else {
flag = RPMBUILD_ISPATCH;
name = "patch";
}
fe = field;
for (f = fe; *f != '\0'; f = fe) {
struct Source *p;
SKIPWHITE(f);
if (*f == '\0')
break;
fe = f;
SKIPNONWHITE(fe);
if (*fe != '\0') fe++;
if (parseUnsignedNum(f, &num)) {
rpmlog(RPMLOG_ERR, _("line %d: Bad number: %s\n"),
spec->lineNum, f);
return RPMRC_FAIL;
}
if (! (p = findSource(spec, num, flag))) {
rpmlog(RPMLOG_ERR, _("line %d: Bad no%s number: %u\n"),
spec->lineNum, name, num);
return RPMRC_FAIL;
}
p->flags |= RPMBUILD_ISNO;
}
return 0;
}
static int findPreambleTag(rpmSpec spec,rpmTagVal * tag,
const char ** macro, char * lang)
{
PreambleRec p;
char *s;
for (p = preambleList; p->token != NULL; p++) {
if (!(p->token && !rstrncasecmp(spec->line, p->token, p->len)))
continue;
if (p->deprecated) {
rpmlog(RPMLOG_WARNING, _("line %d: %s is deprecated: %s\n"),
spec->lineNum, p->token, spec->line);
}
break;
}
if (p == NULL || p->token == NULL)
return 1;
s = spec->line + p->len;
SKIPSPACE(s);
switch (p->type) {
default:
case 0:
/* Unless this is a source or a patch, a ':' better be next */
if (p->tag != RPMTAG_SOURCE && p->tag != RPMTAG_PATCH) {
if (*s != ':') return 1;
}
*lang = '\0';
break;
case 1: /* Parse optional ( <token> ). */
case 2:
if (*s == ':') {
/* Type 1 is multilang, 2 is qualifiers with no defaults */
strcpy(lang, (p->type == 1) ? RPMBUILD_DEFAULT_LANG : "");
break;
}
if (*s != '(') return 1;
s++;
SKIPSPACE(s);
while (!risspace(*s) && *s != ')')
*lang++ = *s++;
*lang = '\0';
SKIPSPACE(s);
if (*s != ')') return 1;
s++;
SKIPSPACE(s);
if (*s != ':') return 1;
break;
}
*tag = p->tag;
if (macro)
*macro = p->token;
return 0;
}
/**
* Parse a spec file, and query the resultant header.
* @param ts rpm transaction
* @param qva query args
* @param specName specfile to parse
* @param target cpu-vender-os platform for query (NULL is current)
* @return 0 on success
*/
static int _specQuery(rpmts ts, QVA_t qva, const char *specName,
/*@null@*/ const char *target)
/*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
/*@modifies rpmGlobalMacroContext, fileSystem, internalState @*/
{
Spec spec = NULL;
Package pkg;
int res = 1; /* assume error */
int anyarch = (target == NULL) ? 1 : 0;
char * passPhrase = "";
int recursing = 0;
char *cookie = NULL;
int verify = 0;
int xx;
/*@-mods@*/ /* FIX: make spec abstract */
if (parseSpec(ts, specName, "/", recursing, passPhrase,
cookie, anyarch, 1, verify)
|| (spec = rpmtsSetSpec(ts, NULL)) == NULL)
{
rpmlog(RPMLOG_ERR,
_("query of specfile %s failed, can't parse\n"),
specName);
goto exit;
}
/*@=mods@*/
res = 0;
if (specedit) {
printNewSpecfile(spec);
goto exit;
}
switch (qva->qva_source) {
case RPMQV_SPECSRPM:
xx = initSourceHeader(spec, NULL);
xx = initSourceHeaderScriptlets(spec);
xx = qva->qva_showPackage(qva, ts, spec->sourceHeader);
break;
default:
case RPMQV_SPECFILE:
for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
/* If no target was specified, display all packages.
* Packages with empty file lists are not produced.
*/
/* XXX DIEDIEDIE: this logic looks flawed. */
if (target == NULL || pkg->fileList != NULL)
xx = qva->qva_showPackage(qva, ts, pkg->header);
}
break;
}
exit:
spec = freeSpec(spec);
return res;
}
/**
* Return rpmdb match iterator with filters (if any) set.
* @param gi generalized iterator
* @returns RPMRC_OK on success
*/
static rpmRC rpmgiInitFilter(rpmgi gi)
/*@globals rpmGlobalMacroContext, h_errno, internalState @*/
/*@modifies gi, rpmGlobalMacroContext, h_errno, internalState @*/
{
rpmRC rpmrc = RPMRC_OK;
ARGV_t av;
int got = 0;
gi->mi = rpmtsInitIterator(gi->ts, gi->tag, gi->keyp, gi->keylen);
if (_rpmgi_debug < 0)
fprintf(stderr, "*** gi %p key %p[%d]\tmi %p\n", gi, gi->keyp, (int)gi->keylen, gi->mi);
if (gi->argv != NULL)
for (av = (const char **) gi->argv; *av != NULL; av++) {
if (gi->tag == RPMDBI_PACKAGES) {
int tag = RPMTAG_NAME;
const char * pat;
char * a, * ae;
pat = a = xstrdup(*av);
tag = RPMTAG_NAME;
/* Parse for "tag=pattern" args. */
if ((ae = strchr(a, '=')) != NULL) {
*ae++ = '\0';
if (*a != '\0') { /* XXX HACK: permit '=foo' */
tag = tagValue(a);
#ifdef DYING /* XXX arbitrary tags always have a return value */
if (tag < 0) {
rpmlog(RPMLOG_NOTICE, _("unknown tag: \"%s\"\n"), a);
got = -1;
}
#endif
}
pat = ae;
got++;
}
if (got) {
if (_rpmgi_debug < 0)
fprintf(stderr, "\tav %p[%d]: \"%s\" -> %s ~= \"%s\"\n", gi->argv, (int)(av - gi->argv), *av, tagName(tag), pat);
got = rpmmiAddPattern(gi->mi, tag, RPMMIRE_DEFAULT, pat);
}
a = _free(a);
}
if (got >= 0)
continue;
gi->mi = rpmmiFree(gi->mi); /* XXX odd side effect? */
rpmrc = RPMRC_FAIL;
break;
}
return rpmrc;
}
int parseNoSource(Spec spec, const char * field, rpmTag tag)
{
const char *f, *fe;
const char *name;
rpmuint32_t num, flag;
if (tag == RPMTAG_NOSOURCE) {
flag = RPMFILE_SOURCE;
name = "source";
} else {
flag = RPMFILE_PATCH;
name = "patch";
}
fe = field;
for (f = fe; *f != '\0'; f = fe) {
struct Source *p;
SKIPWHITE(f);
if (*f == '\0')
break;
fe = f;
SKIPNONWHITE(fe);
if (*fe != '\0') fe++;
if (parseNum(f, &num)) {
rpmlog(RPMLOG_ERR, _("line %d: Bad number: %s\n"),
spec->lineNum, f);
return RPMRC_FAIL;
}
if (! (p = findSource(spec, num, flag))) {
rpmlog(RPMLOG_ERR, _("line %d: Bad no%s number: %d\n"),
spec->lineNum, name, num);
return RPMRC_FAIL;
}
p->flags |= RPMFILE_GHOST;
}
return RPMRC_OK;
}
static int fsmMkdir(const char *path, mode_t mode)
{
int rc = mkdir(path, (mode & 07777));
if (_fsm_debug)
rpmlog(RPMLOG_DEBUG, " %8s (%s, 0%04o) %s\n", __func__,
path, (unsigned)(mode & 07777),
(rc < 0 ? strerror(errno) : ""));
if (rc < 0) rc = RPMERR_MKDIR_FAILED;
return rc;
}
/**
* @todo If the GPG key was known available, the md5 digest could be skipped.
*/
static int readFile(FD_t fd, const char * fn,
rpmDigestBundle plbundle, rpmDigestBundle hdrbundle)
{
unsigned char buf[4*BUFSIZ];
ssize_t count;
int rc = 1;
Header h = NULL;
char *msg = NULL;
/* Read the header from the package. */
if (rpmReadHeader(NULL, fd, &h, &msg) != RPMRC_OK) {
rpmlog(RPMLOG_ERR, _("%s: headerRead failed: %s\n"), fn, msg);
goto exit;
}
if (headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
struct rpmtd_s utd;
if (!headerGet(h, RPMTAG_HEADERIMMUTABLE, &utd, HEADERGET_DEFAULT)){
rpmlog(RPMLOG_ERR,
_("%s: Immutable header region could not be read. "
"Corrupted package?\n"), fn);
goto exit;
}
rpmDigestBundleUpdate(hdrbundle, rpm_header_magic, sizeof(rpm_header_magic));
rpmDigestBundleUpdate(hdrbundle, utd.data, utd.count);
rpmtdFreeData(&utd);
}
/* Read the payload from the package. */
while ((count = Fread(buf, sizeof(buf[0]), sizeof(buf), fd)) > 0) {}
if (count < 0) {
rpmlog(RPMLOG_ERR, _("%s: Fread failed: %s\n"), fn, Fstrerror(fd));
goto exit;
}
rc = 0;
exit:
free(msg);
headerFree(h);
return rc;
}
/* Delete fifo and then temporary directory in which it was located */
static int rpmRmTempFifo(const char *fn)
{
int rc = 0;
char *dfn = NULL, *dir = NULL;
if ((rc = unlink(fn)) != 0) {
rpmlog(RPMLOG_ERR, _("error delete fifo %s: %m\n"), fn);
return rc;
}
dfn = xstrdup(fn);
dir = dirname(dfn);
if ((rc = rmdir(dir)) != 0)
rpmlog(RPMLOG_ERR, _("error delete directory %s: %m\n"), dir);
free(dfn);
return rc;
}
int rpmlockAcquire(rpmlock lock)
{
int locked = 0; /* assume failure */
int maywait = isatty(STDIN_FILENO); /* dont wait within scriptlets */
if (lock) {
locked = rpmlock_acquire(lock, RPMLOCK_WRITE);
if (!locked && (lock->openmode & RPMLOCK_WRITE) && maywait) {
rpmlog(RPMLOG_WARNING, _("waiting for %s lock on %s\n"),
lock->descr, lock->path);
locked = rpmlock_acquire(lock, (RPMLOCK_WRITE|RPMLOCK_WAIT));
}
if (!locked) {
rpmlog(RPMLOG_ERR, _("can't create %s lock on %s (%s)\n"),
lock->descr, lock->path, strerror(errno));
}
}
return locked;
}
static FILE * rpmjsOpenFile(rpmjs js, const char * fn, const char ** msgp)
/*@modifies js @*/
{
FILE * fp = NULL;
fp = fopen(fn, "r");
if (fp == NULL || ferror(fp)) {
if (fp) {
if (msgp)
*msgp = xstrdup(strerror(errno));
(void) fclose(fp);
fp = NULL;
} else {
if (msgp) /* XXX FIXME: add __FUNCTION__ identifier? */
*msgp = xstrdup("unknown error");
}
goto exit;
}
gpsee_flock(fileno(fp), GPSEE_LOCK_SH);
if (F_ISSET(js->flags, SKIPSHEBANG)) {
char buf[BUFSIZ];
if (fgets(buf, sizeof(buf), fp)) {
if (!(buf[0] == '#' && buf[1] == '!')) {
/* XXX FIXME: return through *msgp */
rpmlog(RPMLOG_WARNING, "%s: %s: no \'#!\' on 1st line\n",
__FUNCTION__, fn);
rewind(fp);
} else {
#ifdef NOTYET /* XXX FIXME */
gpsee_interpreter_t * I = js->I;
I->linenoOffset += 1;
#endif /* NOTYET */
do { /* consume entire first line, regardless of length */
if (strchr(buf, '\n'))
break;
} while (fgets(buf, sizeof(buf), fp));
/*
* Make spidermonkey think the script starts with a blank line,
* to keep line numbers in sync.
*/
ungetc('\n', fp);
}
}
}
exit:
if (_rpmjs_debug)
fprintf(stderr, "<== %s(%p,%s,%p) fp %p\n", __FUNCTION__, js, fn, msgp, fp);
return fp;
}
static int db_fini(rpmdb rdb, const char * dbhome)
{
DB_ENV * dbenv = rdb->db_dbenv;
int rc;
int lockfd = -1;
uint32_t eflags = 0;
if (dbenv == NULL)
return 0;
if (rdb->db_opens > 1) {
rdb->db_opens--;
return 0;
}
(void) dbenv->get_open_flags(dbenv, &eflags);
if (!(eflags & DB_PRIVATE))
lockfd = serialize_env(dbhome);
rc = dbenv->close(dbenv, 0);
rc = dbapi_err(rdb, "dbenv->close", rc, _debug);
rpmlog(RPMLOG_DEBUG, "closed db environment %s\n", dbhome);
if (!(eflags & DB_PRIVATE) && rdb->db_remove_env) {
int xx;
xx = db_env_create(&dbenv, 0);
xx = dbapi_err(rdb, "db_env_create", xx, _debug);
xx = dbenv->remove(dbenv, dbhome, 0);
/* filter out EBUSY as it just means somebody else gets to clean it */
xx = dbapi_err(rdb, "dbenv->remove", xx, (xx == EBUSY ? 0 : _debug));
rpmlog(RPMLOG_DEBUG, "removed db environment %s\n", dbhome);
}
if (lockfd >= 0)
close(lockfd);
return rc;
}
static sepoltrans *sepoltransNew(void)
{
sepoltrans *pt = xcalloc(1, sizeof(*pt));
pt->semodulepath = rpmExpand("%{__semodule}", NULL);
pt->execsemodule = (!rpmChrootDone() && access(pt->semodulepath, X_OK) == 0);
pt->changes = 0;
if (pt->execsemodule) {
argvAdd(&pt->semodargs, "semodule");
} else {
pt->sh = semanage_handle_create();
if (!pt->sh) {
rpmlog(RPMLOG_ERR, _("Failed to create semanage handle\n"));
goto err;
}
semanage_set_create_store(pt->sh, 1);
semanage_set_check_contexts(pt->sh, 0);
if (semanage_connect(pt->sh) < 0) {
rpmlog(RPMLOG_ERR, _("Failed to connect to policy handler\n"));
goto err;
}
if (semanage_begin_transaction(pt->sh) < 0) {
rpmlog(RPMLOG_ERR, _("Failed to begin policy transaction: %s\n"),
errno ? strerror(errno) : "");
goto err;
}
semanage_set_reload(pt->sh, !rpmChrootDone());
}
return pt;
err:
if (pt->sh) {
if (semanage_is_connected(pt->sh)) {
semanage_disconnect(pt->sh);
}
semanage_handle_destroy(pt->sh);
}
free(pt);
return NULL;
}
int rpmluaRunScript(rpmlua _lua, const char *script, const char *name)
{
INITSTATE(_lua, lua);
lua_State *L = lua->L;
int ret = 0;
if (name == NULL)
name = "<lua>";
if (luaL_loadbuffer(L, script, strlen(script), name) != 0) {
rpmlog(RPMLOG_ERR, _("invalid syntax in Lua script: %s\n"),
lua_tostring(L, -1));
lua_pop(L, 1);
ret = -1;
} else if (lua_pcall(L, 0, 0, 0) != 0) {
rpmlog(RPMLOG_ERR, _("Lua script failed: %s\n"),
lua_tostring(L, -1));
lua_pop(L, 1);
ret = -1;
}
return ret;
}
static rpmRC cpio_copy(FD_t fdo, CSA_t csa)
{
char buf[BUFSIZ];
size_t nb;
while((nb = Fread(buf, sizeof(buf[0]), sizeof(buf), csa->cpioFdIn)) > 0) {
if (Fwrite(buf, sizeof(buf[0]), nb, fdo) != nb) {
rpmlog(RPMLOG_ERR, _("cpio_copy write failed: %s\n"),
Fstrerror(fdo));
return RPMRC_FAIL;
}
csa->cpioArchiveSize += nb;
}
if (Ferror(csa->cpioFdIn)) {
rpmlog(RPMLOG_ERR, _("cpio_copy read failed: %s\n"),
Fstrerror(csa->cpioFdIn));
return RPMRC_FAIL;
}
return RPMRC_OK;
}
static PyObject * doLog(PyObject * self, PyObject * args, PyObject *kwds)
{
int code;
const char *msg;
char * kwlist[] = {"code", "msg", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &code, &msg))
return NULL;
rpmlog(code, "%s", msg);
Py_RETURN_NONE;
}
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;
}
/* Get current header instance number or try to allocate a new one */
static unsigned int pkgInstance(dbiIndex dbi, int alloc)
{
unsigned int hdrNum = 0;
if (dbi != NULL && dbi->dbi_type == DBI_PRIMARY) {
dbiCursor dbc;
DBT key, data;
unsigned int firstkey = 0;
union _dbswap mi_offset;
int ret;
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
dbc = dbiCursorInit(dbi, alloc ? DBC_WRITE : 0);
/* Key 0 holds the current largest instance, fetch it */
key.data = &firstkey;
key.size = sizeof(firstkey);
ret = dbiCursorGet(dbc, &key, &data, DB_SET);
if (ret == 0 && data.data) {
memcpy(&mi_offset, data.data, sizeof(mi_offset.ui));
if (dbiByteSwapped(dbi) == 1)
_DBSWAP(mi_offset);
hdrNum = mi_offset.ui;
}
if (alloc) {
/* Rather complicated "increment by one", bswapping as needed */
++hdrNum;
mi_offset.ui = hdrNum;
if (dbiByteSwapped(dbi) == 1)
_DBSWAP(mi_offset);
if (ret == 0 && data.data) {
memcpy(data.data, &mi_offset, sizeof(mi_offset.ui));
} else {
data.data = &mi_offset;
data.size = sizeof(mi_offset.ui);
}
/* Unless we manage to insert the new instance number, we failed */
ret = dbiCursorPut(dbc, &key, &data, DB_KEYLAST);
if (ret) {
hdrNum = 0;
rpmlog(RPMLOG_ERR,
_("error(%d) allocating new package instance\n"), ret);
}
}
dbiCursorFree(dbi, dbc);
}
return hdrNum;
}
/* Update secondary index. NULL set deletes the key */
static rpmRC updateIndex(dbiCursor dbc, const char *keyp, unsigned int keylen,
dbiIndexSet set)
{
rpmRC rc = RPMRC_FAIL;
if (dbc && keyp) {
dbiIndex dbi = dbc->dbi;
int dbrc;
DBT data, key;
memset(&key, 0, sizeof(data));
memset(&data, 0, sizeof(data));
key.data = (void *) keyp; /* discards const */
key.size = keylen;
if (set)
set2dbt(dbi, &data, set);
if (dbiIndexSetCount(set) > 0) {
dbrc = dbiCursorPut(dbc, &key, &data, DB_KEYLAST);
if (dbrc) {
rpmlog(RPMLOG_ERR,
_("error(%d) storing record \"%s\" into %s\n"),
dbrc, (char*)key.data, dbiName(dbi));
}
free(data.data);
} else {
dbrc = dbiCursorDel(dbc, &key, &data, 0);
if (dbrc) {
rpmlog(RPMLOG_ERR,
_("error(%d) removing record \"%s\" from %s\n"),
dbrc, (char*)key.data, dbiName(dbi));
}
}
if (dbrc == 0)
rc = RPMRC_OK;
}
return rc;
}
/*
* For packages being installed:
* - verify package arch/os.
* - verify package epoch:version-release is newer.
*/
static rpmps checkProblems(rpmts ts)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpmprobFilterFlags probFilter = rpmtsFilterFlags(ts);
rpmstrPool tspool = rpmtsPool(ts);
rpmtsi pi = rpmtsiInit(ts);
rpmte p;
/* The ordering doesn't matter here */
/* XXX Only added packages need be checked. */
rpmlog(RPMLOG_DEBUG, "sanity checking %d elements\n", rpmtsNElements(ts));
while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
if (!(probFilter & RPMPROB_FILTER_IGNOREARCH) && badArch(rpmteA(p)))
rpmteAddProblem(p, RPMPROB_BADARCH, rpmteA(p), NULL, 0);
if (!(probFilter & RPMPROB_FILTER_IGNOREOS) && badOs(rpmteO(p)))
rpmteAddProblem(p, RPMPROB_BADOS, rpmteO(p), NULL, 0);
if (!(probFilter & RPMPROB_FILTER_OLDPACKAGE)) {
Header h;
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(ts, RPMDBI_NAME, rpmteN(p), 0);
while ((h = rpmdbNextIterator(mi)) != NULL)
ensureOlder(tspool, p, h);
rpmdbFreeIterator(mi);
}
if (!(probFilter & RPMPROB_FILTER_REPLACEPKG)) {
Header h;
rpmdbMatchIterator mi;
mi = rpmtsPrunedIterator(ts, RPMDBI_NAME, rpmteN(p), 1);
rpmdbSetIteratorRE(mi, RPMTAG_EPOCH, RPMMIRE_STRCMP, rpmteE(p));
rpmdbSetIteratorRE(mi, RPMTAG_VERSION, RPMMIRE_STRCMP, rpmteV(p));
rpmdbSetIteratorRE(mi, RPMTAG_RELEASE, RPMMIRE_STRCMP, rpmteR(p));
if (tscolor) {
rpmdbSetIteratorRE(mi, RPMTAG_ARCH, RPMMIRE_STRCMP, rpmteA(p));
rpmdbSetIteratorRE(mi, RPMTAG_OS, RPMMIRE_STRCMP, rpmteO(p));
}
if ((h = rpmdbNextIterator(mi)) != NULL) {
rpmteAddProblem(p, RPMPROB_PKG_INSTALLED, NULL, NULL,
headerGetInstance(h));
}
rpmdbFreeIterator(mi);
}
if (!(probFilter & RPMPROB_FILTER_FORCERELOCATE))
rpmteAddRelocProblems(p);
}
rpmtsiFree(pi);
return rpmtsProblems(ts);
}
static int fsmUnlink(const char *path)
{
int rc = 0;
removeSBITS(path);
rc = unlink(path);
if (_fsm_debug)
rpmlog(RPMLOG_DEBUG, " %8s (%s) %s\n", __func__,
path, (rc < 0 ? strerror(errno) : ""));
if (rc < 0)
rc = (errno == ENOENT ? RPMERR_ENOENT : RPMERR_UNLINK_FAILED);
return rc;
}
