static void unloadImmutableRegion(Header *hdrp, rpmTagVal tag)
{
struct rpmtd_s copytd, td;
rpmtd utd = &td;
Header nh;
Header oh;
HeaderIterator hi;
if (headerGet(*hdrp, tag, utd, HEADERGET_DEFAULT)) {
nh = headerNew();
oh = headerCopyLoad(utd->data);
hi = headerInitIterator(oh);
while (headerNext(hi, ©td)) {
if (copytd.data)
headerPut(nh, ©td, HEADERPUT_DEFAULT);
rpmtdFreeData(©td);
}
headerFreeIterator(hi);
headerFree(oh);
rpmtdFreeData(utd);
headerFree(*hdrp);
*hdrp = headerLink(nh);
headerFree(nh);
}
}
static PyObject * hdrUnload(hdrObject * s, PyObject * args, PyObject *keywords)
{
char * buf;
PyObject * rc;
int len, legacy = 0;
Header h;
static char *kwlist[] = { "legacyHeader", NULL};
if (!PyArg_ParseTupleAndKeywords(args, keywords, "|i", kwlist, &legacy))
return NULL;
h = headerLink(s->h);
/* XXX this legacy switch is a hack, needs to be removed. */
if (legacy) {
h = headerCopy(s->h); /* XXX strip region tags, etc */
headerFree(s->h);
}
len = headerSizeof(h, HEADER_MAGIC_NO);
buf = headerUnload(h);
h = headerFree(h);
if (buf == NULL || len == 0) {
PyErr_SetString(pyrpmError, "can't unload bad header\n");
return NULL;
}
rc = PyBytes_FromStringAndSize(buf, len);
buf = _free(buf);
return rc;
}
rpmRC rpmReadSignature(FD_t fd, Header * sighp, char ** msg)
{
char *buf = NULL;
struct hdrblob_s blob;
Header sigh = NULL;
rpmRC rc = RPMRC_FAIL; /* assume failure */
if (sighp)
*sighp = NULL;
if (hdrblobRead(fd, 1, 1, RPMTAG_HEADERSIGNATURES, &blob, &buf) != RPMRC_OK)
goto exit;
/* OK, blob looks sane, load the header. */
if (hdrblobImport(&blob, 0, &sigh, &buf) != RPMRC_OK)
goto exit;
printSize(fd, sigh);
rc = RPMRC_OK;
exit:
if (sighp && sigh && rc == RPMRC_OK)
*sighp = headerLink(sigh);
headerFree(sigh);
if (msg != NULL) {
*msg = buf;
} else {
free(buf);
}
return rc;
}
static rpmRC dbAdd(rpmts ts, rpmte te)
{
Header h = rpmteHeader(te);
rpm_time_t installTime = (rpm_time_t) time(NULL);
rpmfs fs = rpmteGetFileStates(te);
rpm_count_t fc = rpmfsFC(fs);
rpm_fstate_t * fileStates = rpmfsGetStates(fs);
rpm_color_t tscolor = rpmtsColor(ts);
rpm_tid_t tid = rpmtsGetTid(ts);
rpmRC rc;
if (fileStates != NULL && fc > 0) {
headerPutChar(h, RPMTAG_FILESTATES, fileStates, fc);
}
headerPutUint32(h, RPMTAG_INSTALLTID, &tid, 1);
headerPutUint32(h, RPMTAG_INSTALLTIME, &installTime, 1);
headerPutUint32(h, RPMTAG_INSTALLCOLOR, &tscolor, 1);
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_DBADD), 0);
rc = (rpmdbAdd(rpmtsGetRdb(ts), h) == 0) ? RPMRC_OK : RPMRC_FAIL;
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_DBADD), 0);
if (rc == RPMRC_OK)
rpmteSetDBInstance(te, headerGetInstance(h));
headerFree(h);
return rc;
}
static PyObject *
rpmts_HdrFromFdno(rpmtsObject * s, PyObject *arg)
{
PyObject *ho = NULL;
rpmfdObject *fdo = NULL;
Header h;
rpmRC rpmrc;
if (!PyArg_Parse(arg, "O&:HdrFromFdno", rpmfdFromPyObject, &fdo))
return NULL;
Py_BEGIN_ALLOW_THREADS;
rpmrc = rpmReadPackageFile(s->ts, rpmfdGetFd(fdo), "rpmts_HdrFromFdno", &h);
Py_END_ALLOW_THREADS;
Py_XDECREF(fdo);
if (rpmrc == RPMRC_OK) {
ho = hdr_Wrap(&hdr_Type, h);
h = headerFree(h); /* ref held by python object */
} else {
Py_INCREF(Py_None);
ho = Py_None;
}
return Py_BuildValue("(iN)", rpmrc, ho);
}
static
struct pkguinf *load_pkguinf(tn_alloc *na, const struct pkg *pkg,
void *ptr, tn_array *langs)
{
unsigned vfmode = VFM_RO | VFM_CACHE | VFM_NOEMPTY;
struct pkguinf *pkgu = NULL;
char *nvr = ptr;
char path[PATH_MAX], *hdrpath;
Header h;
if (!pkg->pkgdir)
return NULL;
n_strdupap(pkg->pkgdir->idxpath, &hdrpath);
hdrpath = n_dirname(hdrpath);
n_snprintf(path, sizeof(path), "%s/%s.hdr", hdrpath, nvr);
pkg = pkg;
if ((h = do_loadrpmhdr(path, vfmode, n_basenam(path)))) {
pkgu = pkguinf_ldrpmhdr(na, h, langs);
headerFree(h);
}
return pkgu;
}
int add_for_install(rpmts ts, char *file, int upgrade)
{
FD_t fd;
Header hdr;
int rc = 0;
/* Read package header */
fd = Fopen(file, "r.ufdio");
if (fd == NULL) {
printf("Unable to open file %s\n", file);
return 1;
}
rc = rpmReadPackageFile(ts, fd, file, &hdr);
if (rc != RPMRC_OK) {
printf("Unable to read package %s\n", file);
return rc;
}
/* Add it to the transaction set */
rc = rpmtsAddInstallElement(ts, hdr, file, upgrade, 0);
if (rc) {
printf("Error adding %s to transaction\n", file);
goto out;
}
out:
headerFree(hdr);
Fclose(fd);
return rc;
}
int pkguinf_store_rpmhdr(struct pkguinf *pkgu, tn_buf *nbuf)
{
Header hdr = NULL;
void *rawhdr;
int rawhdr_size;
int rc;
hdr = make_pkguinf_hdr(pkgu, NULL);
#ifdef HAVE_RPM_VERSION_GE_5
rawhdr = headerUnload(hdr, &rawhdr_size);
#else
rawhdr_size = hacked_headerSizeof(hdr);
rawhdr = headerUnload(hdr);
#endif
#if 0
printf("> %ld\t%d\n", ftell(stream), hacked_headerSizeof(pkgu->_hdr));
headerDump(pkgu->_hdr, stdout, HEADER_DUMP_INLINE, rpmTagTable);
#endif
n_buf_write_int16(nbuf, n_hash_size(pkgu->_ht));
n_buf_write_int16(nbuf, rawhdr_size);
rc = (n_buf_write(nbuf, rawhdr, rawhdr_size) == rawhdr_size);
free(rawhdr);
headerFree(hdr);
return rc;
}
void _rpm2header(rpmts ts, char * filename, int checkmode) {
FD_t fd;
Header ret = NULL;
rpmRC rc;
dSP;
if ((fd = Fopen(filename, "r"))) {
rc = rpmReadPackageFile(ts, fd, filename, &ret);
if (checkmode) {
XPUSHs(sv_2mortal(newSViv(rc)));
(void)headerFree(ret); /* For checking the package, we don't keep the header */
ret = NULL;
} else {
if (rc == 0) {
XPUSHs(sv_2mortal(sv_setref_pv(newSVpv("", 0), "RPM::Header", (void *)ret)));
} else {
XPUSHs(sv_2mortal(&PL_sv_undef));
}
}
Fclose(fd);
} else {
XPUSHs(sv_2mortal(&PL_sv_undef));
}
PUTBACK;
return;
}
static void pkgFini(void * _pkg)
/*@modifies _pkg @*/
{
Package pkg = _pkg;
if (pkg == NULL) return; /* XXX assert? */
pkg->preInFile = _free(pkg->preInFile);
pkg->postInFile = _free(pkg->postInFile);
pkg->preUnFile = _free(pkg->preUnFile);
pkg->postUnFile = _free(pkg->postUnFile);
pkg->verifyFile = _free(pkg->verifyFile);
pkg->sanityCheckFile = _free(pkg->sanityCheckFile);
(void)headerFree(pkg->header);
pkg->header = NULL;
(void)rpmdsFree(pkg->ds);
pkg->ds = NULL;
pkg->fileList = rpmiobFree(pkg->fileList);
pkg->fileFile = _free(pkg->fileFile);
if (pkg->fi != NULL) {
rpmfi fi = pkg->fi;
pkg->fi = NULL;
fi = rpmfiFree(fi);
}
pkg->specialDoc = rpmiobFree(pkg->specialDoc);
pkg->triggerFiles = freeTriggerFiles(pkg->triggerFiles);
}
static int replaceSignature(Header sigh, sigTarget sigt1, sigTarget sigt2)
{
/* Grab a copy of the header so we can compare the result */
Header oldsigh = headerCopy(sigh);
int rc = -1;
/* Nuke all signature tags */
deleteSigs(sigh);
/*
* rpmGenSignature() internals parse the actual signing result and
* adds appropriate tags for DSA/RSA.
*/
if (rpmGenSignature(sigh, sigt1, sigt2) == 0) {
/* Lets see what we got and whether its the same signature as before */
rpmTagVal sigtag = headerIsEntry(sigh, RPMSIGTAG_DSA) ?
RPMSIGTAG_DSA : RPMSIGTAG_RSA;
rc = sameSignature(sigtag, sigh, oldsigh);
}
headerFree(oldsigh);
return rc;
}
/**
* Run trigger scripts in the database that are fired by this header.
* @param psm package state machine data
* @param sense trigger type
* @return 0 on success
*/
static rpmRC runTriggers(rpmpsm psm, rpmsenseFlags sense)
{
const rpmts ts = psm->ts;
int numPackage = -1;
const char * N = NULL;
int nerrors = 0;
if (psm->te) /* XXX can't happen */
N = rpmteN(psm->te);
if (N) /* XXX can't happen */
numPackage = rpmdbCountPackages(rpmtsGetRdb(ts), N)
+ psm->countCorrection;
if (numPackage < 0)
return RPMRC_NOTFOUND;
{ Header triggeredH;
Header h = rpmteHeader(psm->te);
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(ts, RPMDBI_TRIGGERNAME, N, 0);
while((triggeredH = rpmdbNextIterator(mi)) != NULL) {
nerrors += handleOneTrigger(ts, psm->te, sense, h, triggeredH,
0, numPackage, NULL);
}
rpmdbFreeIterator(mi);
headerFree(h);
}
return (nerrors == 0) ? RPMRC_OK : RPMRC_FAIL;
}
Header rpmgiReadHeader(rpmgi gi, const char * path)
{
FD_t fd = rpmgiOpen(path, "r%{?_rpmgio}");
Header h = NULL;
if (fd != NULL) {
/* XXX what if path needs expansion? */
rpmRC rpmrc = rpmReadPackageFile(gi->ts, fd, path, &h);
(void) Fclose(fd);
switch (rpmrc) {
case RPMRC_NOTFOUND:
/* XXX Read a package manifest. Restart ftswalk on success. */
case RPMRC_FAIL:
default:
(void)headerFree(h);
h = NULL;
gi->rc = rpmrc;
break;
case RPMRC_NOTTRUSTED:
case RPMRC_NOKEY:
case RPMRC_OK:
break;
}
} else {
gi->rc = RPMRC_NOTFOUND; /* XXX other failures? */
}
return h;
}
static rpmRC rpmpkgReadHeader(FD_t fd, Header *hdrp, char ** msg)
{
char *buf = NULL;
struct hdrblob_s blob;
Header h = NULL;
rpmRC rc = RPMRC_FAIL; /* assume failure */
if (hdrp)
*hdrp = NULL;
if (msg)
*msg = NULL;
if (hdrblobRead(fd, 1, 1, RPMTAG_HEADERIMMUTABLE, &blob, &buf) != RPMRC_OK)
goto exit;
/* OK, blob looks sane, load the header. */
rc = hdrblobImport(&blob, 0, &h, &buf);
exit:
if (hdrp && h && rc == RPMRC_OK)
*hdrp = headerLink(h);
headerFree(h);
if (msg != NULL && *msg == NULL && buf != NULL) {
*msg = buf;
} else {
free(buf);
}
return rc;
}
static rpmRC inst(const char *fn)
{
rpmRC rc = RPMRC_FAIL;
rpmts ts = rpmtsCreate();
FD_t fd = Fopen(fn, "r");
Header h = NULL;
int upgrade = 1;
rpmRelocation relocs = NULL;
rpmps ps = NULL;
rpmprobFilterFlags probFilter = 0;
assert(ts);
(void) rpmtsSetNotifyCallback(ts, rpmShowProgress, (void *) ((long)0));
if (fd == NULL || Ferror(fd))
goto exit;
(void) rpmReadPackageFile(ts, fd, fn, &h);
if ((rc = rpmtsAddInstallElement(ts, h, fn, upgrade, relocs)) != 0
|| (rc = rpmcliInstallCheck(ts)) != 0
|| (rc = rpmcliInstallOrder(ts)) != 0
|| (rc = rpmcliInstallRun(ts, ps, probFilter)) != 0)
goto exit;
exit:
h = headerFree(h);
if (fd) (void) Fclose(fd);
fd = NULL;
ts = rpmtsFree(ts);
if (rc)
fprintf(stderr, "<== %s(%s) rc %d\n", __FUNCTION__, fn, rc);
return rc;
}
int main(int argc, char *argv[])
{
Header h;
FD_t fdi;
setprogname(argv[0]); /* Retrofit glibc __progname */
if (argc == 1) {
fdi = Fopen("-", "r.ufdio");
} else {
fdi = Fopen(argv[1], "r.ufdio");
}
if (Ferror(fdi)) {
fprintf(stderr, "cannot open %s: %s\n",
(argc == 1 ? "<stdin>" : argv[1]), Fstrerror(fdi));
exit(EXIT_FAILURE);
}
h = headerRead(fdi, HEADER_MAGIC_YES);
if (!h) {
fprintf(stderr, "headerRead error: %s\n", Fstrerror(fdi));
exit(EXIT_FAILURE);
}
Fclose(fdi);
headerDump(h, stdout, HEADER_DUMP_INLINE, rpmTagTable);
h = headerFree(h);
return 0;
}
/*@-mustmod@*/
static void rpmgiFini(void * _gi)
/*@modifies _gi @*/
{
rpmgi gi = _gi;
int xx;
gi->hdrPath = _free(gi->hdrPath);
(void)headerFree(gi->h);
gi->h = NULL;
gi->argv = argvFree(gi->argv);
if (gi->ftsp != NULL) {
xx = Fts_close(gi->ftsp);
gi->ftsp = NULL;
gi->fts = NULL;
}
if (gi->fd != NULL) {
xx = Fclose(gi->fd);
gi->fd = NULL;
}
gi->tsi = rpmtsiFree(gi->tsi);
gi->mi = rpmmiFree(gi->mi);
(void)rpmtsFree(gi->ts);
gi->ts = NULL;
}
rpmfi rpmfiFree(rpmfi fi)
{
if (fi == NULL) return NULL;
if (fi->nrefs > 1)
return rpmfiUnlink(fi);
if (fi->fc > 0) {
fi->bnl = _free(fi->bnl);
fi->dnl = _free(fi->dnl);
fi->flinkcache = strcacheFree(fi->flinkcache);
fi->flinks = _free(fi->flinks);
fi->flangs = _free(fi->flangs);
fi->digests = _free(fi->digests);
fi->fcapcache = strcacheFree(fi->fcapcache);
fi->fcaps = _free(fi->fcaps);
fi->cdict = _free(fi->cdict);
fi->fuser = _free(fi->fuser);
fi->fgroup = _free(fi->fgroup);
fi->fstates = _free(fi->fstates);
fi->fps = _free(fi->fps);
/* these point to header memory if KEEPHEADER is used, dont free */
if (!(fi->fiflags & RPMFI_KEEPHEADER) && fi->h == NULL) {
fi->fmtimes = _free(fi->fmtimes);
fi->fmodes = _free(fi->fmodes);
fi->fflags = _free(fi->fflags);
fi->vflags = _free(fi->vflags);
fi->fsizes = _free(fi->fsizes);
fi->frdevs = _free(fi->frdevs);
fi->finodes = _free(fi->finodes);
fi->dil = _free(fi->dil);
fi->fcolors = _free(fi->fcolors);
fi->fcdictx = _free(fi->fcdictx);
fi->ddict = _free(fi->ddict);
fi->fddictx = _free(fi->fddictx);
fi->fddictn = _free(fi->fddictn);
}
}
fi->fn = _free(fi->fn);
fi->apath = _free(fi->apath);
fi->replacedSizes = _free(fi->replacedSizes);
fi->h = headerFree(fi->h);
(void) rpmfiUnlink(fi);
memset(fi, 0, sizeof(*fi)); /* XXX trash and burn */
fi = _free(fi);
return NULL;
}
/* --- Object ctors/dtors */
static void
rpmhdr_free(Header h)
{
if (_debug)
fprintf(stderr, "==> %s(%p)\n", __FUNCTION__, h);
h = headerFree(h);
}
void nbuf_header_free(struct nbuf_header *hdr)
{
if (hdr->h)
headerFree(hdr->h);
if (hdr->nbuf)
n_buf_free(hdr->nbuf);
}
static void unloadImmutableRegion(Header *hdrp, rpmTagVal tag)
{
struct rpmtd_s td;
rpmtd utd = &td;
Header nh;
Header oh;
if (headerGet(*hdrp, tag, utd, HEADERGET_DEFAULT)) {
oh = headerCopyLoad(utd->data);
nh = headerCopy(oh);
headerFree(oh);
rpmtdFreeData(utd);
headerFree(*hdrp);
*hdrp = headerLink(nh);
headerFree(nh);
}
}
HeaderIterator headerFreeIterator(HeaderIterator hi)
{
if (hi != NULL) {
hi->h = headerFree(hi->h);
hi = _free(hi);
}
return NULL;
}
/**
* This assumes the order of list matches the order of the new headers, and
* throws an exception if that isn't true.
*/
static int rpmMergeHeaders(PyObject * list, FD_t fd, int matchTag)
{
Header h;
HeaderIterator hi;
rpmTagVal newMatch, oldMatch;
hdrObject * hdr;
rpm_count_t count = 0;
int rc = 1; /* assume failure */
rpmtd td = rpmtdNew();
Py_BEGIN_ALLOW_THREADS
h = headerRead(fd, HEADER_MAGIC_YES);
Py_END_ALLOW_THREADS
while (h) {
if (!headerGet(h, matchTag, td, HEADERGET_MINMEM)) {
PyErr_SetString(pyrpmError, "match tag missing in new header");
goto exit;
}
newMatch = rpmtdTag(td);
rpmtdFreeData(td);
hdr = (hdrObject *) PyList_GetItem(list, count++);
if (!hdr) goto exit;
if (!headerGet(hdr->h, matchTag, td, HEADERGET_MINMEM)) {
PyErr_SetString(pyrpmError, "match tag missing in new header");
goto exit;
}
oldMatch = rpmtdTag(td);
rpmtdFreeData(td);
if (newMatch != oldMatch) {
PyErr_SetString(pyrpmError, "match tag mismatch");
goto exit;
}
for (hi = headerInitIterator(h); headerNext(hi, td); rpmtdFreeData(td))
{
/* could be dupes */
headerDel(hdr->h, rpmtdTag(td));
headerPut(hdr->h, td, HEADERPUT_DEFAULT);
}
headerFreeIterator(hi);
h = headerFree(h);
Py_BEGIN_ALLOW_THREADS
h = headerRead(fd, HEADER_MAGIC_YES);
Py_END_ALLOW_THREADS
}
rc = 0;
exit:
rpmtdFree(td);
return rc;
}
static void
rpmhdr_dtor(JSContext *cx, JSObject *obj)
{
void * ptr = JS_GetInstancePrivate(cx, obj, &rpmhdrClass, NULL);
Header h = ptr;
_DTOR_DEBUG_ENTRY(_debug);
(void) headerFree(h);
}
void
Release_HRSW_token(void)
{
SWI_t *swi = &_myswi; /* XXX static for now */
if (swi != NULL && swi->swi_h) {
headerFree(swi->swi_h);
swi->swi_h = NULL;
swi->swi_prevx = -1;
}
}
static int makeHDRDigest(Header sigh, const char * file, rpmTagVal sigTag)
{
Header h = NULL;
FD_t fd = NULL;
char * SHA1 = NULL;
int ret = -1; /* assume failure. */
switch (sigTag) {
case RPMSIGTAG_SHA1:
fd = Fopen(file, "r.fdio");
if (fd == NULL || Ferror(fd))
goto exit;
h = headerRead(fd, HEADER_MAGIC_YES);
if (h == NULL)
goto exit;
if (headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
DIGEST_CTX ctx;
struct rpmtd_s utd;
if (!headerGet(h, RPMTAG_HEADERIMMUTABLE, &utd, HEADERGET_DEFAULT)
|| utd.data == NULL)
{
rpmlog(RPMLOG_ERR,
_("Immutable header region could not be read. "
"Corrupted package?\n"));
goto exit;
}
ctx = rpmDigestInit(PGPHASHALGO_SHA1, RPMDIGEST_NONE);
(void) rpmDigestUpdate(ctx, rpm_header_magic, sizeof(rpm_header_magic));
(void) rpmDigestUpdate(ctx, utd.data, utd.count);
(void) rpmDigestFinal(ctx, (void **)&SHA1, NULL, 1);
rpmtdFreeData(&utd);
} else {
rpmlog(RPMLOG_ERR, _("Cannot sign RPM v3 packages\n"));
goto exit;
}
if (SHA1 == NULL)
goto exit;
if (!sighdrPut(sigh, RPMSIGTAG_SHA1, RPM_STRING_TYPE, SHA1, 1))
goto exit;
ret = 0;
break;
default:
break;
}
exit:
free(SHA1);
headerFree(h);
if (fd != NULL) (void) Fclose(fd);
return ret;
}
int
Save_HR_SW_info(int ix)
{
SWI_t *swi = &_myswi; /* XXX static for now */
#ifdef HAVE_LIBRPM
/*
* XXX Watchout: ix starts with 1
*/
if (1 <= ix && ix <= swi->swi_nrec && ix != swi->swi_prevx) {
int offset;
Header h;
char *n, *v, *r;
offset = swi->swi_recs[ix - 1];
{
rpmdbMatchIterator mi;
mi = rpmtsInitIterator(swi->swi_rpmts, RPMDBI_PACKAGES,
&offset, sizeof(offset));
if ((h = rpmdbNextIterator(mi)) != NULL)
h = headerLink(h);
rpmdbFreeIterator(mi);
}
if (h == NULL) {
DEBUGMSGTL(("host/hr_swinst",
"RPM cache has probably expired when reading entry %d, "
"reloading...\n", ix));
swi->swi_timestamp = 0;
return -1;
}
if (swi->swi_h != NULL)
headerFree(swi->swi_h);
swi->swi_h = h;
swi->swi_prevx = ix;
headerGetEntry(swi->swi_h, RPMTAG_NAME, NULL, (void **) &n, NULL);
headerGetEntry(swi->swi_h, RPMTAG_VERSION, NULL, (void **) &v,
NULL);
headerGetEntry(swi->swi_h, RPMTAG_RELEASE, NULL, (void **) &r,
NULL);
snprintf(swi->swi_name, sizeof(swi->swi_name), "%s-%s-%s", n, v, r);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
}
#else
snprintf(swi->swi_name, sizeof(swi->swi_name), "%s", swi->swi_dep->d_name);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
#endif
return 0;
}
static PyObject * hdrAsBytes(hdrObject * s, int legacy)
{
PyObject *res = NULL;
char *buf = NULL;
unsigned int len;
Header h = headerLink(s->h);
/* XXX this legacy switch is a hack, needs to be removed. */
if (legacy) {
h = headerCopy(s->h); /* XXX strip region tags, etc */
headerFree(s->h);
}
buf = headerExport(h, &len);
h = headerFree(h);
if (buf == NULL || len == 0) {
PyErr_SetString(pyrpmError, "can't unload bad header\n");
} else {
res = PyBytes_FromStringAndSize(buf, len);
}
free(buf);
return res;
}
/* --- Object ctors/dtors */
static Header
rpmhdr_init(JSContext *cx, JSObject *obj, void * _h)
{
Header h = (_h ? _h : headerNew());
if (h == NULL)
return NULL;
if (!JS_SetPrivate(cx, obj, (void *)h)) {
/* XXX error msg */
h = headerFree(h);
return NULL;
}
return h;
}
void
Save_HR_SW_info(int ix)
{
SWI_t *swi = &_myswi; /* XXX static for now */
#ifdef HAVE_LIBRPM
/*
* XXX Watchout: ix starts with 1
*/
if (1 <= ix && ix <= swi->swi_nrec && ix != swi->swi_prevx) {
int offset;
Header h;
char *n, *v, *r;
offset = swi->swi_recs[ix - 1];
#if defined(RPMDBI_PACKAGES)
{
rpmdbMatchIterator mi;
mi = rpmdbInitIterator(swi->swi_rpmdb, RPMDBI_PACKAGES,
&offset, sizeof(offset));
if ((h = rpmdbNextIterator(mi)) != NULL)
h = headerLink(h);
rpmdbFreeIterator(mi);
}
#else
h = rpmdbGetRecord(swi->swi_rpmdb, offset);
#endif
if (h == NULL)
return;
if (swi->swi_h != NULL)
headerFree(swi->swi_h);
swi->swi_h = h;
swi->swi_prevx = ix;
headerGetEntry(swi->swi_h, RPMTAG_NAME, NULL, (void **) &n, NULL);
headerGetEntry(swi->swi_h, RPMTAG_VERSION, NULL, (void **) &v,
NULL);
headerGetEntry(swi->swi_h, RPMTAG_RELEASE, NULL, (void **) &r,
NULL);
snprintf(swi->swi_name, sizeof(swi->swi_name), "%s-%s-%s", n, v, r);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
}
#else
snprintf(swi->swi_name, sizeof(swi->swi_name), swi->swi_dep->d_name);
swi->swi_name[ sizeof(swi->swi_name)-1 ] = 0;
#endif
}
