HFD_t hfd = headerFreeData;
int * mtime;
const char ** files;
- rpmTagType fnt;
+ rpm_tagtype_t fnt;
rpm_count_t count, x;
time_t currentTime = time(NULL);
void initSourceHeader(rpmSpec spec)
{
HeaderIterator hi;
- int32_t type;
+ rpm_tagtype_t type;
rpm_tag_t tag;
rpm_count_t count;
const void * ptr;
/* XXX Fish the pkgid out of the signature header. */
if (sig != NULL && pkgidp != NULL) {
- int32_t tagType;
+ rpm_tagtype_t tagType;
unsigned char * MD5 = NULL;
rpm_count_t c;
int xx;
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
const char ** names;
- rpmTagType type;
+ rpm_tagtype_t type;
rpm_count_t count;
if (!hge(h, tag, &type, (void **)&names, &count))
char ** array;
int multiToken = 0;
rpmsenseFlags tagflags;
- rpmTagType type;
+ rpm_tagtype_t type;
int len;
rpm_count_t num;
int rc;
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
const char ** names;
- rpmTagType dnt;
+ rpm_tagtype_t dnt;
rpm_tag_t nametag = 0;
rpm_tag_t versiontag = 0;
rpm_tag_t flagtag = 0;
/* Check for duplicate dependencies. */
if (hge(h, nametag, &dnt, (void **) &names, &len)) {
const char ** versions = NULL;
- rpmTagType dvt = RPM_STRING_ARRAY_TYPE;
+ rpm_tagtype_t dvt = RPM_STRING_ARRAY_TYPE;
int *flags = NULL;
int *indexes = NULL;
int duplicate = 0;
* @param element (unused)
* @return formatted string
*/
-static char * triggertypeFormat(int32_t type, const void * data,
+static char * triggertypeFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding,
int element)
{
* @param element (unused)
* @return formatted string
*/
-static char * permsFormat(int32_t type, const void * data,
+static char * permsFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding, int element)
{
char * val;
* @param element (unused)
* @return formatted string
*/
-static char * fflagsFormat(int32_t type, const void * data,
+static char * fflagsFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding, int element)
{
char * val;
* @param element no. bytes of binary data
* @return formatted string
*/
-static char * armorFormat(int32_t type, const void * data,
+static char * armorFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding,
int element)
{
* @param element
* @return formatted string
*/
-static char * base64Format(int32_t type, const void * data,
+static char * base64Format(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding, int element)
{
char * val;
* @param element (unused)
* @return formatted string
*/
-static char * xmlFormat(int32_t type, const void * data,
+static char * xmlFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding,
int element)
{
* @param element (unused)
* @return formatted string
*/
-static char * pgpsigFormat(int32_t type, const void * data,
+static char * pgpsigFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding,
int element)
{
* @param element (unused)
* @return formatted string
*/
-static char * depflagsFormat(int32_t type, const void * data,
+static char * depflagsFormat(rpm_tagtype_t type, const void * data,
char * formatPrefix, int padding, int element)
{
char * val;
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int instprefixTag(Header h, rpmTagType * type,
+static int instprefixTag(Header h, rpm_tagtype_t* type,
const void ** data,
rpm_count_t * count,
int * freeData)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
- rpmTagType ipt;
+ rpm_tagtype_t ipt;
char ** array;
if (hge(h, RPMTAG_INSTALLPREFIX, type, (void **)data, count)) {
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int fssizesTag(Header h, rpmTagType * type,
+static int fssizesTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int triggercondsTag(Header h, rpmTagType * type,
+static int triggercondsTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
- rpmTagType tnt, tvt, tst;
+ rpm_tagtype_t tnt, tvt, tst;
int32_t * indices, * flags;
char ** names, ** versions;
rpm_count_t numNames, numScripts;
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int triggertypeTag(Header h, rpmTagType * type,
+static int triggertypeTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
- rpmTagType tst;
+ rpm_tagtype_t tst;
int32_t * indices, * flags;
const char ** conds;
const char ** s;
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int filenamesTag(Header h, rpmTagType * type,
+static int filenamesTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int fileclassTag(Header h, rpmTagType * type,
+static int fileclassTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int fileprovideTag(Header h, rpmTagType * type,
+static int fileprovideTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int filerequireTag(Header h, rpmTagType * type,
+static int filerequireTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int i18nTag(Header h, rpm_tag_t tag, rpmTagType * type,
+static int i18nTag(Header h, rpm_tag_t tag, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int summaryTag(Header h, rpmTagType * type,
+static int summaryTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int descriptionTag(Header h, rpmTagType * type,
+static int descriptionTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int groupTag(Header h, rpmTagType * type,
+static int groupTag(Header h, rpm_tagtype_t* type,
const void ** data, rpm_count_t * count,
int * freeData)
{
(void) rpmdbSetIteratorRE(mi, RPMTAG_NAME, RPMMIRE_DEFAULT, '!gpg-pubkey');
#endif
while ((h = rpmdbNextIterator(mi)) != NULL) {
- rpmTagType type = RPM_NULL_TYPE;
+ rpm_tagtype_t type = RPM_NULL_TYPE;
rpm_count_t count = 0;
int32_t * tidp;
if (xx == 0)
for (i = 0; i < ac; i++) {
- rpmTagType type;
+ rpm_tagtype_t type;
rpm_count_t count;
int isSource;
const char ** dirNames;
const char ** baseNames;
uint32_t * dirIndexes;
- rpmTagType fnt;
+ rpm_tagtype_t fnt;
rpm_count_t count, i;
int xx;
int dirIndex = -1;
int32_t pFlags = RPMSENSE_EQUAL;
const char ** provides = NULL;
const char ** providesEVR = NULL;
- rpmTagType pnt, pvt;
+ rpm_tagtype_t pnt, pvt;
int32_t * provideFlags = NULL;
rpm_count_t providesCount, i;
int xx;
HFD_t hfd = (HFD_t) headerFreeData;
HAE_t hae = (HAE_t) headerAddEntry;
HeaderIterator hi;
- int32_t type;
+ rpm_tagtype_t type;
rpm_tag_t tag;
rpm_count_t count;
const void * ptr;
HeaderIterator hi;
rpm_count_t count;
rpm_tag_t tag, stag;
- int32_t type;
+ rpm_tagtype_t type;
const void * ptr;
int xx;
rpmlead l = NULL;
Header sigh = NULL;
rpm_tag_t sigtag;
- int32_t sigtype;
+ rpm_tagtype_t sigtype;
const void * sig;
rpm_count_t siglen;
rpmtsOpX opx;
goto exit;
}
{ void * uh = NULL;
- int32_t uht;
+ rpm_tagtype_t uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc))
}
case RPMSIGTAG_SHA1:
{ void * uh = NULL;
- int32_t uht;
+ rpm_tagtype_t uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc))
int32_t * i32p;
} body;
char numbuf[32];
- rpmTagType type;
+ rpm_tagtype_t type;
for (tagm = tagMacros; tagm->macroname != NULL; tagm++) {
if (!hge(h, tagm->tag, &type, (void **) &body, NULL))
}
/* XXX FIXME: can't do endian neutral MD5 verification yet. */
-fi->fmd5s = hfd(fi->fmd5s, -1);
+fi->fmd5s = hfd(fi->fmd5s, RPM_FORCEFREE_TYPE);
/* XXX FIXME: don't do per-file mapping, force global flags. */
fi->fmapflags = _free(fi->fmapflags);
int sourcelen = strlen(_sourcedir) + 2;
char * t;
- fi->dnl = hfd(fi->dnl, -1);
+ fi->dnl = hfd(fi->dnl, RPM_FORCEFREE_TYPE);
fi->dc = 2;
fi->dnl = xmalloc(fi->dc * sizeof(*fi->dnl)
int argc = 0;
const char ** prefixes = NULL;
rpm_count_t numPrefixes;
- rpmTagType ipt;
+ rpm_tagtype_t ipt;
const char * oldPrefix;
int maxPrefixLength;
int len;
void ** progArgv;
rpm_count_t progArgc;
const char ** argv;
- rpmTagType ptt, stt;
+ rpm_tagtype_t ptt, stt;
const char * script;
rpmRC rc = RPMRC_OK;
int xx;
(void) rpmdsSetNoPromote(trigger, 1);
while ((i = rpmdsNext(trigger)) >= 0) {
- rpmTagType tit, tst, tpt;
+ rpm_tagtype_t tit, tst, tpt;
const char * Name;
int32_t Flags = rpmdsFlags(trigger);
const char ** triggerNames;
rpm_count_t numTriggers, numTriggerIndices;
rpm_count_t * triggerIndices;
- rpmTagType tnt, tit;
+ rpm_tagtype_t tnt, tit;
unsigned char * triggersRun;
rpmRC rc = RPMRC_OK;
/* Regenerate original header. */
{ void * uh = NULL;
- int32_t uht;
+ rpm_tagtype_t uht;
rpm_count_t uhc;
if (headerGetEntry(fi->h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc)) {
if (headerGetEntry(fi->h, RPMTAG_HEADERIMAGE, &uht, &uh, &uhc))
{
HeaderIterator hi;
- int32_t type;
+ rpm_tagtype_t type;
rpm_tag_t tag;
rpm_count_t count;
hPTR_t ptr;
psm->rpmio_flags = _free(psm->rpmio_flags);
psm->failedFile = _free(psm->failedFile);
- fi->fgroup = hfd(fi->fgroup, -1);
- fi->fuser = hfd(fi->fuser, -1);
+ fi->fgroup = hfd(fi->fgroup, RPM_FORCEFREE_TYPE);
+ fi->fuser = hfd(fi->fuser, RPM_FORCEFREE_TYPE);
fi->apath = _free(fi->apath);
fi->fstates = _free(fi->fstates);
break;
static int getSignid(Header sig, rpm_tag_t sigtag, pgpKeyID_t signid)
{
void * pkt = NULL;
- int32_t pkttyp = 0;
+ rpm_tagtype_t pkttyp = 0;
rpm_count_t pktlen = 0;
int rc = 1;
Header sigh = NULL;
const char * msg;
void * uh = NULL;
- int32_t uht;
+ rpm_tagtype_t uht;
rpm_count_t uhc;
int res = EXIT_FAILURE;
int deleting = (qva->qva_mode == RPMSIGN_DEL_SIGNATURE);
/* Dump the immutable region (if present). */
if (headerGetEntry(sigh, RPMTAG_HEADERSIGNATURES, &uht, &uh, &uhc)) {
HeaderIterator hi;
- int32_t type;
+ rpm_tagtype_t type;
rpm_tag_t tag;
rpm_count_t count;
hPTR_t ptr;
if (headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
void * uh;
- int32_t uht;
+ rpm_tagtype_t uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc)
char missingKeys[7164], * m;
char untrustedKeys[7164], * u;
rpm_tag_t sigtag;
- int32_t sigtype;
+ rpm_tagtype_t sigtype;
const void * sig;
pgpDig dig;
pgpDigParams sigp;
int32_t * Refs; /*!< No. of file refs. */
int32_t BT; /*!< Package build time tie breaker. */
rpm_tag_t tagN; /*!< Header tag. */
- rpmTagType Nt, EVRt, Ft; /*!< Tag data types. */
+ rpm_tagtype_t Nt, EVRt, Ft; /*!< Tag data types. */
int32_t Count; /*!< No. of elements */
int i; /*!< Element index. */
unsigned l; /*!< Low element (bsearch). */
HGE_t hge =
(scareMem ? (HGE_t) headerGetEntryMinMemory : (HGE_t) headerGetEntry);
rpm_tag_t tagBT = RPMTAG_BUILDTIME;
- rpmTagType BTt;
+ rpm_tagtype_t BTt;
int32_t * BTp;
rpm_tag_t tagEVR, tagF;
rpmds ds = NULL;
const char * Type;
const char ** N;
- rpmTagType Nt;
+ rpm_tagtype_t Nt;
rpm_count_t Count;
if (tagN == RPMTAG_PROVIDENAME) {
ds->tagN = tagN;
ds->Count = 1;
ds->N = N;
- ds->Nt = -1; /* XXX to insure that hfd will free */
+ ds->Nt = RPM_FORCEFREE_TYPE; /* XXX to insure that hfd will free */
ds->EVR = EVR;
- ds->EVRt = -1; /* XXX to insure that hfd will free */
+ ds->EVRt = RPM_FORCEFREE_TYPE; /* XXX to insure that hfd will free */
ds->Flags = xmalloc(sizeof(*ds->Flags)); ds->Flags[0] = Flags;
ds->i = 0;
{ char pre[2];
}
ds->Count = 1;
ds->N = xmalloc(sizeof(*ds->N)); ds->N[0] = N;
- ds->Nt = -1; /* XXX to insure that hfd will free */
+ ds->Nt = RPM_FORCEFREE_TYPE; /* XXX to insure that hfd will free */
ds->EVR = xmalloc(sizeof(*ds->EVR)); ds->EVR[0] = EVR;
- ds->EVRt = -1; /* XXX to insure that hfd will free */
+ ds->EVRt = RPM_FORCEFREE_TYPE; /* XXX to insure that hfd will free */
ds->Flags = xmalloc(sizeof(*ds->Flags)); ds->Flags[0] = Flags;
ds->i = 0;
{ char t[2];
rpmRelocation * relocations = NULL;
int numRelocations;
const char ** validRelocations;
- rpmTagType validType;
+ rpm_tagtype_t validType;
const char ** baseNames;
const char ** dirNames;
uint32_t * dirIndexes;
if (nrelocated) {
rpm_count_t c;
void * d;
- rpmTagType t;
+ rpm_tagtype_t t;
d = NULL;
xx = hge(h, RPMTAG_BASENAMES, &t, &d, &c);
fi->posttransprog = _free(fi->posttransprog);
if (fi->fc > 0) {
- fi->bnl = hfd(fi->bnl, -1);
- fi->dnl = hfd(fi->dnl, -1);
+ fi->bnl = hfd(fi->bnl, RPM_FORCEFREE_TYPE);
+ fi->dnl = hfd(fi->dnl, RPM_FORCEFREE_TYPE);
- fi->flinks = hfd(fi->flinks, -1);
- fi->flangs = hfd(fi->flangs, -1);
- fi->fmd5s = hfd(fi->fmd5s, -1);
+ fi->flinks = hfd(fi->flinks, RPM_FORCEFREE_TYPE);
+ fi->flangs = hfd(fi->flangs, RPM_FORCEFREE_TYPE);
+ fi->fmd5s = hfd(fi->fmd5s, RPM_FORCEFREE_TYPE);
fi->md5s = _free(fi->md5s);
- fi->cdict = hfd(fi->cdict, -1);
+ fi->cdict = hfd(fi->cdict, RPM_FORCEFREE_TYPE);
- fi->fuser = hfd(fi->fuser, -1);
- fi->fgroup = hfd(fi->fgroup, -1);
+ fi->fuser = hfd(fi->fuser, RPM_FORCEFREE_TYPE);
+ fi->fgroup = hfd(fi->fgroup, RPM_FORCEFREE_TYPE);
fi->fstates = _free(fi->fstates);
fi->apath = _free(fi->apath);
fi->fmapflags = _free(fi->fmapflags);
- fi->obnl = hfd(fi->obnl, -1);
- fi->odnl = hfd(fi->odnl, -1);
+ fi->obnl = hfd(fi->obnl, RPM_FORCEFREE_TYPE);
+ fi->odnl = hfd(fi->odnl, RPM_FORCEFREE_TYPE);
- fi->fcontexts = hfd(fi->fcontexts, -1);
+ fi->fcontexts = hfd(fi->fcontexts, RPM_FORCEFREE_TYPE);
fi->actions = _free(fi->actions);
fi->replacedSizes = _free(fi->replacedSizes);
for (j = 0; j < 16; j++, t++, fmd5 += 2)
*t = (nibble(fmd5[0]) << 4) | nibble(fmd5[1]);
}
- fi->fmd5s = hfd(fi->fmd5s, -1);
+ fi->fmd5s = hfd(fi->fmd5s, RPM_FORCEFREE_TYPE);
}
/* XXX TR_REMOVED doesn;t need fmtimes, frdevs, finodes, or fcontexts */
int size;
rpm_tag_t dirNameTag = 0;
rpm_tag_t dirIndexesTag = 0;
- rpmTagType bnt, dnt;
+ rpm_tagtype_t bnt, dnt;
char * t;
int i, xx;
if (eiu->relocations) {
const char ** paths;
- int pft;
+ rpm_tagtype_t pft;
rpm_count_t c;
if (headerGetEntry(eiu->h, RPMTAG_PREFIXES, &pft,
* Prototype for headerFreeData() vector.
*
* @param data address of data (or NULL)
- * @param type type of data (or -1 to force free)
+ * @param type type of data (or to force free)
* @return NULL always
*/
typedef
- void * (*HFD_t) (const void * data, rpmTagType type);
+ void * (*HFD_t) (const void * data, rpm_tagtype_t type);
/**
* Prototype for headerGetEntry() vector.
* @return 1 on success, 0 on failure
*/
typedef int (*HGE_t) (Header h, rpm_tag_t tag,
- rpmTagType * type,
+ rpm_tagtype_t * type,
void ** p,
rpm_count_t * c);
* @param c number of values
* @return 1 on success, 0 on failure
*/
-typedef int (*HAE_t) (Header h, rpm_tag_t tag, rpmTagType type,
+typedef int (*HAE_t) (Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c);
/**
* @param c number of values
* @return 1 on success, 0 on failure
*/
-typedef int (*HME_t) (Header h, rpm_tag_t tag, rpmTagType type,
+typedef int (*HME_t) (Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c);
/**
* @param tag tag value
* @return tag data type, RPM_NULL_TYPE on not found.
*/
-int rpmTagGetType(rpm_tag_t tag);
+rpm_tagtype_t rpmTagGetType(rpm_tag_t tag);
/** \ingroup rpmtag
* Return tag value from name.
mi = rpmtsInitIterator(ts, RPMTAG_PUBKEYS, sigp->signid, sizeof(sigp->signid));
while ((h = rpmdbNextIterator(mi)) != NULL) {
const char ** pubkeys;
- int32_t pt;
+ rpm_tagtype_t pt;
rpm_count_t pc;
if (!headerGetEntry(h, RPMTAG_PUBKEYS, &pt, (void **)&pubkeys, &pc))
return sigtag;
}
-int32_t rpmtsSigtype(const rpmts ts)
+rpm_tagtype_t rpmtsSigtype(const rpmts ts)
{
- int32_t sigtype = 0;
+ rpm_tagtype_t sigtype = 0;
if (ts != NULL)
sigtype = ts->sigtype;
return sigtype;
return siglen;
}
-int rpmtsSetSig(rpmts ts, rpm_tag_t sigtag, int32_t sigtype,
+int rpmtsSetSig(rpmts ts, rpm_tag_t sigtag, rpm_tagtype_t sigtype,
const void * sig, size_t siglen)
{
if (ts != NULL) {
* @param ts transaction set
* @return signature tag type
*/
-int32_t rpmtsSigtype(const rpmts ts);
+rpm_tagtype_t rpmtsSigtype(const rpmts ts);
/** \ingroup rpmts
* Get signature tag data, i.e. from header.
* @return 0 always
*/
int rpmtsSetSig(rpmts ts,
- rpm_tag_t sigtag, int32_t sigtype,
+ rpm_tag_t sigtag, rpm_tagtype_t sigtype,
const void * sig, size_t siglen);
/** \ingroup rpmts
const char * fn; /*!< Current package fn. */
rpm_tag_t sigtag; /*!< Current package signature tag. */
- int32_t sigtype; /*!< Current package signature data type. */
+ rpm_tagtype_t sigtype; /*!< Current package signature data type. */
const void * sig; /*!< Current package signature. */
int32_t siglen; /*!< Current package signature length. */
if (headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
DIGEST_CTX ctx;
void * uh;
- int32_t uht;
+ rpm_tagtype_t uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc)
PyObject * list, *o;
HeaderIterator hi;
rpm_tag_t tag;
- int type;
+ rpm_tagtype_t type;
list = PyList_New(0);
* @retval c address of number of values
* @return 0 on success, 1 on bad magic, 2 on error
*/
-static int dressedHeaderGetEntry(Header h, rpm_tag_t tag, int32_t *type,
+static int dressedHeaderGetEntry(Header h, rpm_tag_t tag, rpm_tagtype_t *type,
void **p, rpm_count_t *c)
{
switch (tag) {
*/
static PyObject * hdr_subscript(hdrObject * s, PyObject * item)
{
- int tagtype, type;
+ rpm_tagtype_t tagtype, type;
rpm_tag_t tag = RPMTAG_NOT_FOUND;
rpm_count_t count, i;
void * data;
hdrObject * hdr;
rpm_count_t c, count = 0;
rpm_tag_t tag;
- int type;
+ rpm_tagtype_t type;
void * p;
Py_BEGIN_ALLOW_THREADS
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
const char ** baseNames, ** dirNames;
- rpmTagType bnt, dnt;
+ rpm_tagtype_tbnt, dnt;
uint32_t * dirIndexes;
int fileCount;
int xx;
int headerNVR(Header h, const char **np, const char **vp, const char **rp)
{
- int type;
+ rpm_tagtype_t type;
rpm_count_t count;
if (np) {
const char **ep, const char **vp, const char **rp,
const char **ap)
{
- int type;
+ rpm_tagtype_t type;
rpm_count_t count;
headerNVR(h, np, vp, rp);
for (i = 0, entry = h->index; i < h->indexUsed; i++, entry++) {
unsigned diff;
- int32_t type;
+ rpm_tagtype_t type;
/* Regions go in as is ... */
if (ENTRY_IS_REGION(entry)) {
* @param pend pointer to end of data (or NULL)
* @return no. bytes in data, -1 on failure
*/
-static int dataLength(int32_t type, hPTR_t p, rpm_count_t count, int onDisk,
+static int dataLength(rpm_tagtype_t type, hPTR_t p, rpm_count_t count, int onDisk,
hPTR_t pend)
{
const unsigned char * s = p;
memset(&ieprev, 0, sizeof(ieprev));
for (; il > 0; il--, pe++) {
struct indexEntry_s ie;
- int32_t type;
+ rpm_tagtype_t type;
ie.info.tag = ntohl(pe->tag);
ie.info.type = ntohl(pe->type);
int32_t il = 0;
int32_t dl = 0;
indexEntry entry;
- int32_t type;
+ rpm_tagtype_t type;
int i;
int drlen, ndribbles;
int driplen, ndrips;
* @return header entry
*/
static
-indexEntry findEntry(Header h, rpm_tag_t tag, int32_t type)
+indexEntry findEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type)
{
indexEntry entry, entry2, last;
struct indexEntry_s key;
* @return 1 on success, otherwise error.
*/
static int copyEntry(const indexEntry entry,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c,
int minMem)
* @return 1 on success, 0 on not found
*/
static int intGetEntry(Header h, rpm_tag_t tag,
- int32_t * type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c,
int minMem)
* @return NULL always
*/
static void * _headerFreeTag(Header h,
- const void * data, rpmTagType type)
+ const void * data, rpm_tagtype_t type)
{
if (data) {
if (type == -1 ||
*/
static
int _headerGetEntry(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
void ** p,
rpm_count_t * c)
{
*/
static
int _headerGetEntryMinMemory(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c)
{
return intGetEntry(h, tag, type, p, c, 1);
}
-int headerGetRawEntry(Header h, rpm_tag_t tag, int32_t * type, hPTR_t * p,
+int headerGetRawEntry(Header h, rpm_tag_t tag, rpm_tagtype_t * type, hPTR_t * p,
rpm_count_t * c)
{
indexEntry entry;
/**
*/
-static void copyData(int32_t type, void * dstPtr, const void * srcPtr,
+static void copyData(rpm_tagtype_t type, void * dstPtr, const void * srcPtr,
rpm_count_t cnt, int dataLength)
{
switch (type) {
* @return (malloc'ed) copy of entry data, NULL on error
*/
static void *
-grabData(int32_t type, hPTR_t p, rpm_count_t c, int * lengthPtr)
+grabData(rpm_tagtype_t type, hPTR_t p, rpm_count_t c, int * lengthPtr)
{
void * data = NULL;
int length;
* @return 1 on success, 0 on failure
*/
static
-int _headerAddEntry(Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c)
+int _headerAddEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c)
{
indexEntry entry;
void * data;
* @return 1 on success, 0 on failure
*/
static
-int _headerAppendEntry(Header h, rpm_tag_t tag, int32_t type,
+int _headerAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c)
{
indexEntry entry;
* @return 1 on success, 0 on failure
*/
static
-int _headerAddOrAppendEntry(Header h, rpm_tag_t tag, int32_t type,
+int _headerAddOrAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c)
{
return (findEntry(h, tag, type)
* @return 1 on success, 0 on failure
*/
static
-int _headerModifyEntry(Header h, rpm_tag_t tag, int32_t type,
+int _headerModifyEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c)
{
indexEntry entry;
static
int _headerNextIterator(HeaderIterator hi,
rpm_tag_t * tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c)
{
{
Header nh = _headerNew();
HeaderIterator hi;
- int32_t type;
+ rpm_tagtype_t type;
rpm_tag_t tag;
rpm_count_t count;
hPTR_t ptr;
hsa->i++;
} else {
rpm_tag_t tagno;
- int32_t type;
+ rpm_tagtype_t type;
rpm_count_t count;
if (!_headerNextIterator(hsa->hi, &tagno, &type, NULL, &count))
* @return 0 on success, 1 on failure
*/
static int getExtension(headerSprintfArgs hsa, headerTagTagFunction fn,
- hTYP_t typeptr,
+ rpm_tagtype_t * typeptr,
hPTR_t * data,
rpm_count_t * countptr,
rpmec ec)
size_t need = 0;
char * t, * te;
char buf[20];
- int32_t type;
+ rpm_tagtype_t type;
rpm_count_t count;
hPTR_t data;
unsigned int intVal;
char * t, * te;
int i, j;
int numElements;
- int32_t type;
+ rpm_tagtype_t type;
rpm_count_t count;
sprintfToken spft;
int condNumFormats;
* @param element (unused)
* @return formatted string
*/
-static char * octalFormat(int32_t type, hPTR_t data,
+static char * octalFormat(rpm_tagtype_t type, hPTR_t data,
char * formatPrefix, int padding,int element)
{
char * val;
* @param element (unused)
* @return formatted string
*/
-static char * hexFormat(int32_t type, hPTR_t data,
+static char * hexFormat(rpm_tagtype_t type, hPTR_t data,
char * formatPrefix, int padding,int element)
{
char * val;
/**
*/
-static char * realDateFormat(int32_t type, hPTR_t data,
+static char * realDateFormat(rpm_tagtype_t type, hPTR_t data,
char * formatPrefix, int padding,int element,
const char * strftimeFormat)
{
* @param element (unused)
* @return formatted string
*/
-static char * dateFormat(int32_t type, hPTR_t data,
+static char * dateFormat(rpm_tagtype_t type, hPTR_t data,
char * formatPrefix, int padding, int element)
{
return realDateFormat(type, data, formatPrefix, padding, element,
* @param element (unused)
* @return formatted string
*/
-static char * dayFormat(int32_t type, hPTR_t data,
+static char * dayFormat(rpm_tagtype_t type, hPTR_t data,
char * formatPrefix, int padding, int element)
{
return realDateFormat(type, data, formatPrefix, padding, element,
* @param element (unused)
* @return formatted string
*/
-static char * shescapeFormat(int32_t type, hPTR_t data,
+static char * shescapeFormat(rpm_tagtype_t type, hPTR_t data,
char * formatPrefix, int padding,int element)
{
char * result, * dst, * src, * buf;
for (p = tagstocopy; *p != 0; p++) {
char *s;
- int32_t type;
+ rpm_tagtype_t type;
rpm_count_t count;
if (_headerIsEntry(headerTo, *p))
continue;
/** \ingroup header
*/
-typedef int32_t * hTYP_t;
typedef const void * hPTR_t;
typedef int32_t rpm_tag_t;
+typedef uint32_t rpm_tagtype_t;
typedef uint32_t rpm_count_t;
/** \ingroup header
typedef struct headerTagTableEntry_s * headerTagTableEntry;
struct headerTagTableEntry_s {
const char * name; /*!< Tag name. */
- int val; /*!< Tag numeric value. */
- int type; /*!< Tag type. */
+ rpm_tag_t val; /*!< Tag numeric value. */
+ rpm_tagtype_t type; /*!< Tag type. */
};
/**
* @param element RPM_BIN_TYPE: no. bytes of data
* @return formatted string
*/
-typedef char * (*headerTagFormatFunction)(int32_t type,
+typedef char * (*headerTagFormatFunction)(rpm_tagtype_t type,
const void * data, char * formatPrefix,
int padding, rpm_count_t element);
* @return 0 on success
*/
typedef int (*headerTagTagFunction) (Header h,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * data,
rpm_count_t * count,
int * freeData);
RPM_I18NSTRING_TYPE = 9,
RPM_MASK_TYPE = 0x0000ffff
#define RPM_MAX_TYPE 9
+#define RPM_FORCEFREE_TYPE UINT32_MAX
} rpmTagType;
/** \ingroup header
*/
typedef struct HE_s {
rpm_tag_t tag;
- hTYP_t typ;
+ rpm_tagtype_t * typ;
union {
hPTR_t * ptr;
hRET_t * ret;
* @param type type of data (or -1 to force free)
* @return NULL always
*/
-void * headerFreeTag(Header h, const void * data, rpmTagType type);
+void * headerFreeTag(Header h, const void * data, rpm_tagtype_t type);
/** \ingroup header
* Retrieve tag value.
* @return 1 on success, 0 on failure
*/
int headerGetEntry(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
void ** p,
rpm_count_t * c);
* @return 1 on success, 0 on failure
*/
int headerGetEntryMinMemory(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c);
* @param c number of values
* @return 1 on success, 0 on failure
*/
-int headerAddEntry(Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c);
+int headerAddEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c);
/** \ingroup header
* Append element to tag array in header.
* @param c number of values
* @return 1 on success, 0 on failure
*/
-int headerAppendEntry(Header h, rpm_tag_t tag, int32_t type,
+int headerAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c);
/** \ingroup header
* @param c number of values
* @return 1 on success, 0 on failure
*/
-int headerAddOrAppendEntry(Header h, rpm_tag_t tag, int32_t type,
+int headerAddOrAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c);
/** \ingroup header
* @param c number of values
* @return 1 on success, 0 on failure
*/
-int headerModifyEntry(Header h, rpm_tag_t tag, int32_t type,
+int headerModifyEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c);
/** \ingroup header
*/
int headerNextIterator(HeaderIterator hi,
rpm_tag_t * tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c);
* @todo Remove from API.
*
* @param data address of data (or NULL)
- * @param type type of data (or -1 to force free)
+ * @param type type of data (or RPM_FORCEFREE_TYPE to force free)
* @return NULL always
*/
static inline
-void * headerFreeData( const void * data, rpmTagType type)
+void * headerFreeData( const void * data, rpm_tagtype_t type)
{
if (data) {
- if (type == -1 ||
+ if (type == RPM_FORCEFREE_TYPE ||
type == RPM_STRING_ARRAY_TYPE ||
type == RPM_I18NSTRING_TYPE ||
type == RPM_BIN_TYPE)
}
void * headerFreeTag(Header h,
- const void * data, rpmTagType type)
+ const void * data, rpm_tagtype_t type)
{
return (h2hv(h)->hdrfreetag) (h, data, type);
}
int headerGetEntry(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
void ** p,
rpm_count_t * c)
{
}
int headerGetEntryMinMemory(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c)
{
return (h2hv(h)->hdrgetmin) (h, tag, type, p, c);
}
-int headerAddEntry(Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c)
+int headerAddEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c)
{
return (h2hv(h)->hdradd) (h, tag, type, p, c);
}
-int headerAppendEntry(Header h, rpm_tag_t tag, int32_t type,
+int headerAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c)
{
return (h2hv(h)->hdrappend) (h, tag, type, p, c);
}
-int headerAddOrAppendEntry(Header h, rpm_tag_t tag, int32_t type,
+int headerAddOrAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c)
{
return (h2hv(h)->hdraddorappend) (h, tag, type, p, c);
return (h2hv(h)->hdraddi18n) (h, tag, string, lang);
}
-int headerModifyEntry(Header h, rpm_tag_t tag, int32_t type,
+int headerModifyEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
const void * p, rpm_count_t c)
{
return (h2hv(h)->hdrmodify) (h, tag, type, p, c);
int headerNextIterator(HeaderIterator hi,
rpm_tag_t * tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c)
{
char ** headerGetLangs(Header h)
{
char **s, *e, **table;
- int type;
+ rpm_tagtype_t type;
rpm_count_t i, count;
if (!headerGetRawEntry(h, HEADER_I18NTABLE, &type, (const void **)&s, &count))
typedef struct entryInfo_s * entryInfo;
struct entryInfo_s {
rpm_tag_t tag; /*!< Tag identifier. */
- int32_t type; /*!< Tag data type. */
+ rpm_tagtype_t type; /*!< Tag data type. */
int32_t offset; /*!< Offset into data segment (ondisk only). */
rpm_count_t count; /*!< Number of tag elements. */
};
*/
typedef struct rpmec_s * rpmec;
struct rpmec_s {
- int32_t type;
+ rpm_tagtype_t type;
rpm_count_t count;
int avail;
int freeit;
* @return 1 on success, 0 on failure
*/
int headerGetRawEntry(Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c);
*/
typedef
void * (*HDRfreetag) (Header h,
- const void * data, rpmTagType type);
+ const void * data, rpm_tagtype_t type);
/** \ingroup header
* Retrieve tag value.
*/
typedef
int (*HDRget) (Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
void ** p,
rpm_count_t * c);
*/
typedef
int (*HDRgetmin) (Header h, rpm_tag_t tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c);
* @return 1 on success, 0 on failure
*/
typedef
-int (*HDRadd) (Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c);
+int (*HDRadd) (Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c);
/** \ingroup header
* Append element to tag array in header.
* @return 1 on success, 0 on failure
*/
typedef
-int (*HDRappend) (Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c);
+int (*HDRappend) (Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c);
/** \ingroup header
* Add or append element to tag array in header.
* @return 1 on success, 0 on failure
*/
typedef
-int (*HDRaddorappend) (Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c);
+int (*HDRaddorappend) (Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c);
/** \ingroup header
* Add locale specific tag to header.
* @return 1 on success, 0 on failure
*/
typedef
-int (*HDRmodify) (Header h, rpm_tag_t tag, int32_t type, const void * p, rpm_count_t c);
+int (*HDRmodify) (Header h, rpm_tag_t tag, rpm_tagtype_t type, const void * p, rpm_count_t c);
/** \ingroup header
* Delete tag in header.
typedef
int (*HDRnextiter) (HeaderIterator hi,
rpm_tag_t * tag,
- hTYP_t type,
+ rpm_tagtype_t * type,
hPTR_t * p,
rpm_count_t * c);
HFD_t hfd = headerFreeData;
const char * dirName;
const char * baseName;
- rpmTagType bnt, dnt;
+ rpm_tagtype_t bnt, dnt;
fingerPrintCache fpc;
fingerPrint fp1;
dbiIndex dbi = NULL;
int8_t * i8p;
} u;
char numbuf[32];
- rpmTagType t;
+ rpm_tagtype_t t;
rpm_count_t c;
miRE mire;
static int32_t zero = 0;
dbiIndex dbi;
const char *av[1];
const char ** rpmvals = NULL;
- rpmTagType rpmtype = 0;
+ rpm_tagtype_t rpmtype = 0;
rpm_count_t rpmcnt = 0;
rpm_tag_t rpmtag;
int xx;
HFD_t hfd = headerFreeData;
sigset_t signalMask;
const char ** baseNames;
- rpmTagType bnt;
+ rpm_tagtype_t bnt;
rpm_count_t count = 0;
dbiIndex dbi;
int dbix;
for (dbix = 0; dbix < dbiTagsMax; dbix++) {
const char *av[1];
const char **rpmvals = NULL;
- rpmTagType rpmtype = 0;
+ rpm_tagtype_t rpmtype = 0;
rpm_count_t rpmcnt = 0;
rpm_tag_t rpmtag;
int32_t * requireFlags;
const char ** dirNames;
const char ** baseNames;
const char ** fullBaseNames;
- rpmTagType bnt, dnt;
+ rpm_tagtype_t bnt, dnt;
uint32_t * dirIndexes;
uint32_t * fullDirIndexes;
fingerPrint * fps;
int byValueSize; /*!< no. of entries. */
int (*byValueCmp) (const void * avp, const void * bvp); /*!< compare entries by value. */
const char * (*tagName) (rpm_tag_t value); /* Return name from value. */
- int (*tagType) (rpm_tag_t value); /* Return type from value. */
+ rpm_tagtype_t (*tagType) (rpm_tag_t value); /* Return type from value. */
};
/**
/* forward refs */
static const char * _tagName(rpm_tag_t tag);
-static int _tagType(rpm_tag_t tag);
+static rpm_tagtype_t _tagType(rpm_tag_t tag);
static rpm_tag_t _tagValue(const char * tagstr);
static struct headerTagIndices_s _rpmTags = {
return nameBuf;
}
-static int _tagType(rpm_tag_t tag)
+static rpm_tagtype_t _tagType(rpm_tag_t tag)
{
const struct headerTagTableEntry_s *t;
int comparison, i, l, u;
* @param tag tag value
* @return tag data type, RPM_NULL_TYPE on not found.
*/
-int rpmTagGetType(rpm_tag_t tag)
+rpm_tagtype_t rpmTagGetType(rpm_tag_t tag)
{
return ((*rpmTags->tagType)(tag));
}
enum cvtaction {CA_OLD, CA_NEW, CA_OMIT, CA_ERR};
-static enum cvtaction convertAMD(enum cvtaction ca, int32_t type,
- void ** nvalsp, int32_t *ncountp, cmd_t *newc)
+static enum cvtaction convertAMD(enum cvtaction ca, rpm_tagtype_t type,
+ void ** nvalsp, rpm_count_t *ncountp, cmd_t *newc)
{
int i;
return ca;
}
-static enum cvtaction convertExistingAMD(int32_t tag, int32_t type,
- hPTR_t valsp, int32_t *countp, void ** nvalsp, int32_t *ncountp,
+static enum cvtaction convertExistingAMD(rpm_tag_t tag, rpm_tagtype_t type,
+ hPTR_t valsp, rpm_count_t *countp, void ** nvalsp, rpm_count_t *ncountp,
cmd_t *cmds[], int ncmds)
{
cmd_t *newc = NULL;
static
Header headerCopyWithConvert(Header h, cmd_t *cmds[], int ncmds)
{
- int32_t tag, type, count;
+ rpm_tag_t tag;
+ rpm_tagtype_t type;
+ rpm_count_t count;
hPTR_t vals;
HeaderIterator headerIter;
Header res = headerNew();
while (headerNextIterator(headerIter, &tag, &type, &vals, &count)) {
enum cvtaction ca;
void *nvals;
- int32_t ncount;
+ rpm_count_t ncount;
nvals = NULL;
ncount = 0;
rc = headerIsEntry(h, c->tagval);
if (!rc && !c->done && c->injmode != INJ_DELETE) {
- int32_t type, ncount;
+ rpm_tagtype_t type;
+ rpm_count_t ncount;
void *nvals;
enum cvtaction ca;