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; }