static
Header do_loadrpmhdr(const char *path, int vfmode, const char *pdir_name)
{
struct vfile *vf = NULL;
tn_buf *nbuf;
tn_buf buf[4096];
int n;
Header h, ch = NULL;
if ((vf = vfile_open_ul(path, VFT_GZIO, vfmode, pdir_name)) == NULL)
return NULL;
nbuf = n_buf_new(1024 * 64);
while ((n = gzread(vf->vf_gzstream, buf, sizeof(buf))) > 0)
n_buf_write(nbuf, buf, n);
vfile_close(vf);
h = headerLoad(n_buf_ptr(nbuf)); /* rpm's memleak */
if (h == NULL) {
logn(LOGERR, "%s: load header failed", n_basenam(path));
} else if (headerIsEntry(h, RPMTAG_SOURCEPACKAGE)) { /* omit src.rpms */
h = NULL;
}
if (h)
ch = headerCopy(h);
n_buf_free(nbuf);
return ch;
}
/** \ingroup header
* Read (and load) header from file handle.
* @param fd file handle
* @param magicp read (and verify) 8 bytes of (magic, 0)?
* @return header (or NULL on error)
*/
Header headerRead(FD_t fd, enum hMagic magicp)
{
int32_t block[4];
int32_t reserved;
int32_t * ei = NULL;
int32_t il;
int32_t dl;
int32_t magic;
Header h = NULL;
size_t len;
int i;
memset(block, 0, sizeof(block));
i = 2;
if (magicp == HEADER_MAGIC_YES)
i += 2;
/* FIX: cast? */
if (timedRead(fd, (char *)block, i*sizeof(*block)) != (i * sizeof(*block)))
goto exit;
i = 0;
if (magicp == HEADER_MAGIC_YES) {
magic = block[i++];
if (memcmp(&magic, rpm_header_magic, sizeof(magic)))
goto exit;
reserved = block[i++];
}
il = ntohl(block[i]); i++;
dl = ntohl(block[i]); i++;
len = sizeof(il) + sizeof(dl) + (il * sizeof(struct entryInfo_s)) + dl;
/* Sanity checks on header intro. */
if (hdrchkTags(il) || hdrchkData(dl) || len > headerMaxbytes)
goto exit;
ei = xmalloc(len);
ei[0] = htonl(il);
ei[1] = htonl(dl);
len -= sizeof(il) + sizeof(dl);
/* FIX: cast? */
if (timedRead(fd, (char *)&ei[2], len) != len)
goto exit;
h = headerLoad(ei);
exit:
if (h == NULL && ei != NULL) {
free(ei);
}
return h;
}
Header headerCopyLoad(const void * uh)
{
int32_t * ei = (int32_t *) uh;
int32_t il = ntohl(ei[0]); /* index length */
int32_t dl = ntohl(ei[1]); /* data length */
size_t pvlen = sizeof(il) + sizeof(dl) +
(il * sizeof(struct entryInfo_s)) + dl;
void * nuh = NULL;
Header h = NULL;
/* Sanity checks on header intro. */
if (!(hdrchkTags(il) || hdrchkData(dl)) && pvlen < headerMaxbytes) {
nuh = memcpy(xmalloc(pvlen), uh, pvlen);
if ((h = headerLoad(nuh)) == NULL)
nuh = _free(nuh);
}
return h;
}
struct pkguinf *pkguinf_restore_rpmhdr_st(tn_alloc *na,
tn_stream *st, off_t offset)
{
uint16_t nsize, nlangs;
struct pkguinf *pkgu = NULL;
void *rawhdr;
Header hdr;
if (offset > 0)
if (n_stream_seek(st, offset, SEEK_SET) != 0) {
logn(LOGERR, "pkguinf_restore: fseek %ld: %m", (long int)offset);
return NULL;
}
if (!n_stream_read_uint16(st, &nlangs)) {
logn(LOGERR, "pkguinf_restore: read error nlangs (%m) at %ld %p",
n_stream_tell(st), st);
return NULL;
}
if (!n_stream_read_uint16(st, &nsize)) {
logn(LOGERR, "pkguinf_restore: read error nsize (%m) at %ld",
n_stream_tell(st));
return NULL;
}
rawhdr = alloca(nsize);
if (n_stream_read(st, rawhdr, nsize) != nsize) {
logn(LOGERR, "pkguinf_restore: read %d error at %ld", nsize,
n_stream_tell(st));
return NULL;
}
if ((hdr = headerLoad(rawhdr)) != NULL) {
pkgu = pkguinf_ldrpmhdr(na, hdr, NULL);
headerFree(hdr); //rpm's memleak
}
return pkgu;
}
Header headerReload(Header h, rpmTag tag)
{
Header nh;
size_t length;
void * uh = doHeaderUnload(h, &length);
h = headerFree(h);
if (uh == NULL)
return NULL;
nh = headerLoad(uh);
if (nh == NULL) {
uh = _free(uh);
return NULL;
}
if (ENTRY_IS_REGION(nh->index)) {
if (tag == HEADER_SIGNATURES || tag == HEADER_IMMUTABLE)
nh->index[0].info.tag = tag;
}
return nh;
}
static rpmRC rpmpkgReadHeader(rpmKeyring keyring, rpmVSFlags vsflags,
FD_t fd, Header *hdrp, char ** msg)
{
char *buf = NULL;
int32_t block[4];
int32_t il;
int32_t dl;
int32_t * ei = NULL;
size_t uc;
size_t nb;
Header h = NULL;
rpmRC rc = RPMRC_FAIL; /* assume failure */
int xx;
if (hdrp)
*hdrp = NULL;
if (msg)
*msg = NULL;
memset(block, 0, sizeof(block));
if ((xx = timedRead(fd, (char *)block, sizeof(block))) != sizeof(block)) {
rasprintf(&buf,
_("hdr size(%d): BAD, read returned %d\n"), (int)sizeof(block), xx);
goto exit;
}
if (memcmp(block, rpm_header_magic, sizeof(rpm_header_magic))) {
rasprintf(&buf, _("hdr magic: BAD\n"));
goto exit;
}
il = ntohl(block[2]);
if (hdrchkTags(il)) {
rasprintf(&buf, _("hdr tags: BAD, no. of tags(%d) out of range\n"), il);
goto exit;
}
dl = ntohl(block[3]);
if (hdrchkData(dl)) {
rasprintf(&buf,
_("hdr data: BAD, no. of bytes(%d) out of range\n"), dl);
goto exit;
}
nb = (il * sizeof(struct entryInfo_s)) + dl;
uc = sizeof(il) + sizeof(dl) + nb;
ei = xmalloc(uc);
ei[0] = block[2];
ei[1] = block[3];
if ((xx = timedRead(fd, (char *)&ei[2], nb)) != nb) {
rasprintf(&buf, _("hdr blob(%zd): BAD, read returned %d\n"), nb, xx);
goto exit;
}
/* Sanity check header tags */
rc = headerVerify(keyring, vsflags, ei, uc, msg);
if (rc != RPMRC_OK)
goto exit;
/* OK, blob looks sane, load the header. */
h = headerLoad(ei);
if (h == NULL) {
rasprintf(&buf, _("hdr load: BAD\n"));
rc = RPMRC_FAIL;
goto exit;
}
ei = NULL; /* XXX will be freed with header */
exit:
if (hdrp && h && rc == RPMRC_OK)
*hdrp = headerLink(h);
ei = _free(ei);
h = headerFree(h);
if (msg != NULL && *msg == NULL && buf != NULL) {
*msg = buf;
} else {
free(buf);
}
return rc;
}
