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 VALUE
rpmhdr_new(int argc, VALUE *argv, VALUE s)
{
Header h;
rb_scan_args(argc, argv, "00");
h = headerNew();
if (_debug)
fprintf(stderr, "==> %s(%p[%d], 0x%lx) mi %p\n", __FUNCTION__, argv, argc, s, h);
return Data_Wrap_Struct(s, 0, rpmhdr_free, h);
}
/* --- 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;
}
static Header make_pkguinf_hdr(struct pkguinf *pkgu, int *langs_cnt)
{
int i, nlangs = 0;
Header hdr = NULL;
unsigned hdr_size;
tn_array *langs;
hdr = headerNew();
if ((langs = pkgu->_langs_rpmhdr) == NULL)
langs = pkguinf_langs(pkgu);
for (i=0; i < n_array_size(langs); i++) {
const char *lang = n_array_nth(langs, i);
struct pkguinf_i18n *inf = n_hash_get(pkgu->_ht, lang);
headerAddI18NString(hdr, RPMTAG_SUMMARY, inf->summary, lang);
headerAddI18NString(hdr, RPMTAG_DESCRIPTION, inf->description, lang);
}
#if 0
if (pkgu->vendor)
headerAddEntry(hdr, RPMTAG_VENDOR, RPM_STRING_TYPE, pkgu->vendor, 1);
if (pkgu->license)
headerAddEntry(hdr, PM_RPMTAG_LICENSE, RPM_STRING_TYPE, pkgu->license, 1);
if (pkgu->url)
headerAddEntry(hdr, RPMTAG_URL, RPM_STRING_TYPE, pkgu->url, 1);
if (pkgu->distro)
headerAddEntry(hdr, RPMTAG_DISTRIBUTION, RPM_STRING_TYPE, pkgu->distro, 1);
if (pkgu->buildhost)
headerAddEntry(hdr, RPMTAG_BUILDHOST, RPM_STRING_TYPE, pkgu->buildhost, 1);
#endif
hdr_size = hacked_headerSizeof(hdr);
if (hdr_size > UINT16_MAX) {
logn(LOGERR, "internal: header size too large: %d", hdr_size);
headerFree(hdr);
hdr = NULL;
}
if (langs_cnt)
*langs_cnt = nlangs;
return hdr;
}
/** \ingroup header
* Duplicate a header.
* @param h header
* @return new header instance
*/
Header headerCopy(Header h)
{
Header nh = headerNew();
HeaderIterator hi;
struct rpmtd_s td;
hi = headerInitIterator(h);
while (headerNext(hi, &td)) {
if (rpmtdCount(&td) > 0) {
(void) headerPut(nh, &td, HEADERPUT_DEFAULT);
}
rpmtdFreeData(&td);
}
hi = headerFreeIterator(hi);
return headerReload(nh, HEADER_IMAGE);
}
/* TODO: permit keyring check + retrofits on copy/load */
static PyObject *hdr_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
{
PyObject *obj = NULL;
rpmfdObject *fdo = NULL;
Header h = NULL;
char *kwlist[] = { "obj", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &obj)) {
return NULL;
}
if (obj == NULL) {
h = headerNew();
} else if (CAPSULE_CHECK(obj)) {
h = CAPSULE_EXTRACT(obj, "rpm._C_Header");
headerLink(h);
} else if (hdrObject_Check(obj)) {
h = headerCopy(((hdrObject*) obj)->h);
} else if (PyBytes_Check(obj)) {
h = headerCopyLoad(PyBytes_AsString(obj));
} else if (rpmfdFromPyObject(obj, &fdo)) {
Py_BEGIN_ALLOW_THREADS;
h = headerRead(rpmfdGetFd(fdo), HEADER_MAGIC_YES);
Py_END_ALLOW_THREADS;
Py_XDECREF(fdo);
} else {
PyErr_SetString(PyExc_TypeError, "header, blob or file expected");
return NULL;
}
if (h == NULL) {
PyErr_SetString(pyrpmError, "bad header");
return NULL;
}
return hdr_Wrap(subtype, h);
}
Package newPackage(/*@unused@*/ Spec spec)
{
Package pkg = pkgGetPool(_pkgPool);
pkg->header = headerNew();
pkg->ds = NULL;
pkg->autoProv = ((_rpmbuildFlags & 0x1) != 0);
pkg->autoReq = ((_rpmbuildFlags & 0x2) != 0);
#if 0
pkg->reqProv = NULL;
pkg->triggers = NULL;
pkg->triggerScripts = NULL;
#endif
pkg->triggerFiles = NULL;
pkg->fileFile = NULL;
pkg->fileList = NULL;
pkg->fi = NULL;
pkg->preInFile = NULL;
pkg->postInFile = NULL;
pkg->preUnFile = NULL;
pkg->postUnFile = NULL;
pkg->verifyFile = NULL;
pkg->sanityCheckFile = NULL;
pkg->specialDoc = NULL;
pkg->next = NULL;
return (Package)rpmioLinkPoolItem((rpmioItem)pkg, __FUNCTION__, __FILE__, __LINE__);
}
Header rpmNewSignature(void)
{
Header sigh = headerNew();
return sigh;
}
rpmRC rpmGenerateSignature(char *SHA1, uint8_t *MD5, rpm_loff_t size,
rpm_loff_t payloadSize, FD_t fd)
{
Header sig = headerNew();
struct rpmtd_s td;
rpmRC rc = RPMRC_OK;
char *reservedSpace;
int spaceSize = 32; /* always reserve a bit of space */
int gpgSize = rpmExpandNumeric("%{__gpg_reserved_space}");
/* Prepare signature */
rpmtdReset(&td);
td.tag = RPMSIGTAG_SHA1;
td.count = 1;
td.type = RPM_STRING_TYPE;
td.data = SHA1;
headerPut(sig, &td, HEADERPUT_DEFAULT);
rpmtdReset(&td);
td.tag = RPMSIGTAG_MD5;
td.count = 16;
td.type = RPM_BIN_TYPE;
td.data = MD5;
headerPut(sig, &td, HEADERPUT_DEFAULT);
rpmtdReset(&td);
td.count = 1;
if (payloadSize < UINT32_MAX) {
rpm_off_t p = payloadSize;
rpm_off_t s = size;
td.type = RPM_INT32_TYPE;
td.tag = RPMSIGTAG_PAYLOADSIZE;
td.data = &p;
headerPut(sig, &td, HEADERPUT_DEFAULT);
td.tag = RPMSIGTAG_SIZE;
td.data = &s;
headerPut(sig, &td, HEADERPUT_DEFAULT);
} else {
rpm_loff_t p = payloadSize;
rpm_loff_t s = size;
td.type = RPM_INT64_TYPE;
td.tag = RPMSIGTAG_LONGARCHIVESIZE;
td.data = &p;
headerPut(sig, &td, HEADERPUT_DEFAULT);
td.tag = RPMSIGTAG_LONGSIZE;
td.data = &s;
headerPut(sig, &td, HEADERPUT_DEFAULT);
/* adjust for the size difference between 64- and 32bit tags */
spaceSize -= 8;
}
if (gpgSize > 0)
spaceSize += gpgSize;
if(spaceSize > 0) {
reservedSpace = xcalloc(spaceSize, sizeof(char));
rpmtdReset(&td);
td.tag = RPMSIGTAG_RESERVEDSPACE;
td.count = spaceSize;
td.type = RPM_BIN_TYPE;
td.data = reservedSpace;
headerPut(sig, &td, HEADERPUT_DEFAULT);
free(reservedSpace);
}
/* Reallocate the signature into one contiguous region. */
sig = headerReload(sig, RPMTAG_HEADERSIGNATURES);
if (sig == NULL) { /* XXX can't happen */
rpmlog(RPMLOG_ERR, _("Unable to reload signature header.\n"));
rc = RPMRC_FAIL;
goto exit;
}
/* Write the signature section into the package. */
if (rpmWriteSignature(fd, sig)) {
rc = RPMRC_FAIL;
goto exit;
}
exit:
headerFree(sig);
return rc;
}
/* Build pubkey header. */
static int makePubkeyHeader(rpmts ts, rpmPubkey key, Header * hdrp)
{
Header h = headerNew();
const char * afmt = "%{pubkeys:armor}";
const char * group = "Public Keys";
const char * license = "pubkey";
const char * buildhost = "localhost";
const char * userid;
rpmsenseFlags pflags = (RPMSENSE_KEYRING|RPMSENSE_EQUAL);
uint32_t zero = 0;
uint32_t keytime = 0;
pgpDig dig = NULL;
pgpDigParams pubp = NULL;
char * d = NULL;
char * enc = NULL;
char * n = NULL;
char * u = NULL;
char * v = NULL;
char * r = NULL;
char * evr = NULL;
int rc = -1;
if ((enc = rpmPubkeyBase64(key)) == NULL)
goto exit;
if ((dig = rpmPubkeyDig(key)) == NULL)
goto exit;
if ((pubp = pgpDigGetParams(dig, PGPTAG_PUBLIC_KEY)) == NULL)
goto exit;
/* Build header elements. */
v = pgpHexStr(pubp->signid, sizeof(pubp->signid));
r = pgpHexStr(pubp->time, sizeof(pubp->time));
userid = pubp->userid ? pubp->userid : "none";
keytime = pgpGrab(pubp->time, sizeof(pubp->time));
rasprintf(&n, "gpg(%s)", v+8);
rasprintf(&u, "gpg(%s)", userid);
rasprintf(&evr, "%d:%s-%s", pubp->version, v, r);
headerPutString(h, RPMTAG_PUBKEYS, enc);
if ((d = headerFormat(h, afmt, NULL)) == NULL)
goto exit;
headerPutString(h, RPMTAG_NAME, "gpg-pubkey");
headerPutString(h, RPMTAG_VERSION, v+8);
headerPutString(h, RPMTAG_RELEASE, r);
headerPutString(h, RPMTAG_DESCRIPTION, d);
headerPutString(h, RPMTAG_GROUP, group);
headerPutString(h, RPMTAG_LICENSE, license);
headerPutString(h, RPMTAG_SUMMARY, u);
headerPutString(h, RPMTAG_PACKAGER, userid);
headerPutUint32(h, RPMTAG_SIZE, &zero, 1);
headerPutString(h, RPMTAG_PROVIDENAME, u);
headerPutString(h, RPMTAG_PROVIDEVERSION, evr);
headerPutUint32(h, RPMTAG_PROVIDEFLAGS, &pflags, 1);
headerPutString(h, RPMTAG_PROVIDENAME, n);
headerPutString(h, RPMTAG_PROVIDEVERSION, evr);
headerPutUint32(h, RPMTAG_PROVIDEFLAGS, &pflags, 1);
headerPutString(h, RPMTAG_RPMVERSION, RPMVERSION);
headerPutString(h, RPMTAG_BUILDHOST, buildhost);
headerPutUint32(h, RPMTAG_BUILDTIME, &keytime, 1);
headerPutString(h, RPMTAG_SOURCERPM, "(none)");
/* Reload the lot to immutable region and stomp sha1 digest on it */
h = headerReload(h, RPMTAG_HEADERIMMUTABLE);
if (h != NULL) {
char *sha1 = NULL;
unsigned int blen = 0;
const void *blob = headerExport(h, &blen);
/* XXX FIXME: bah, this code is repeated in way too many places */
DIGEST_CTX ctx = rpmDigestInit(PGPHASHALGO_SHA1, RPMDIGEST_NONE);
rpmDigestUpdate(ctx, rpm_header_magic, sizeof(rpm_header_magic));
rpmDigestUpdate(ctx, blob, blen);
rpmDigestFinal(ctx, (void **)&sha1, NULL, 1);
if (sha1) {
headerPutString(h, RPMTAG_SHA1HEADER, sha1);
*hdrp = headerLink(h);
rc = 0;
}
free(sha1);
}
exit:
headerFree(h);
pgpFreeDig(dig);
free(n);
free(u);
free(v);
free(r);
free(evr);
free(enc);
free(d);
return rc;
}
Spec newSpec(void)
{
static const char _spec_line_buffer_size[] =
"%{?_spec_line_buffer_size}%{!?_spec_line_buffer_size:100000}";
Spec spec = specGetPool(_specPool);
spec->specFile = NULL;
spec->sl = newSl();
spec->st = newSt();
spec->fileStack = NULL;
spec->lbuf_len = (size_t)rpmExpandNumeric(_spec_line_buffer_size);
spec->lbuf = (char *)xmalloc(spec->lbuf_len);
spec->lbuf[0] = '\0';
spec->line = spec->lbuf;
spec->nextline = NULL;
spec->nextpeekc = '\0';
spec->lineNum = 0;
spec->readStack = xmalloc(sizeof(*spec->readStack));
spec->readStack->next = NULL;
spec->readStack->reading = 1;
spec->rootURL = NULL;
memset(&spec->sstates, 0, sizeof(spec->sstates));
memset(&spec->smetrics, 0, sizeof(spec->smetrics));
spec->prep = NULL;
spec->build = NULL;
spec->install = NULL;
spec->check = NULL;
spec->clean = NULL;
spec->foo = NULL;
spec->nfoo = 0;
spec->dig = NULL;
spec->sources = NULL;
spec->packages = NULL;
spec->noSource = 0;
spec->numSources = 0;
spec->sourceRpmName = NULL;
spec->sourcePkgId = NULL;
spec->sourceHeader = headerNew();
spec->fi = NULL;
spec->buildSubdir = NULL;
spec->passPhrase = NULL;
spec->timeCheck = 0;
spec->cookie = NULL;
spec->BANames = NULL;
spec->BACount = 0;
spec->recursing = 0;
spec->toplevel = 1;
spec->BASpecs = NULL;
spec->force = 0;
spec->anyarch = 0;
/*@i@*/ spec->macros = rpmGlobalMacroContext;
spec->_parseRCPOT = parseRCPOT; /* XXX hack around backward linkage. */
return (Spec)rpmioLinkPoolItem((rpmioItem)spec, __FUNCTION__, __FILE__, __LINE__);
}