HFD_t hfd = headerFreeData;
rpm_time_t * mtime;
const char ** files;
- rpm_tagtype_t fnt;
+ rpmTagType fnt;
rpm_count_t count, x;
time_t currentTime = time(NULL);
void initSourceHeader(rpmSpec spec)
{
HeaderIterator hi;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_tag_t tag;
rpm_count_t count;
rpm_data_t ptr;
/* XXX Fish the pkgid out of the signature header. */
if (sig != NULL && pkgidp != NULL) {
- rpm_tagtype_t tagType;
+ rpmTagType tagType;
unsigned char * MD5 = NULL;
rpm_count_t c;
int xx;
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
const char ** names;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
if (!hge(h, tag, &type, (rpm_data_t *)&names, &count))
char ** array;
int multiToken = 0;
rpmsenseFlags tagflags;
- rpm_tagtype_t type;
+ rpmTagType type;
size_t len;
rpm_count_t num;
int rc;
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
const char ** names;
- rpm_tagtype_t dnt;
+ rpmTagType 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, (rpm_data_t *) &names, &len)) {
const char ** versions = NULL;
- rpm_tagtype_t dvt = RPM_STRING_ARRAY_TYPE;
+ rpmTagType dvt = RPM_STRING_ARRAY_TYPE;
int *flags = NULL;
int *indexes = NULL;
int duplicate = 0;
* @param element (unused)
* @return formatted string
*/
-static char * triggertypeFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * triggertypeFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,
int element)
{
* @param element (unused)
* @return formatted string
*/
-static char * permsFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * permsFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding, int element)
{
char * val;
* @param element (unused)
* @return formatted string
*/
-static char * fflagsFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * fflagsFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding, int element)
{
char * val;
* @param element no. bytes of binary data
* @return formatted string
*/
-static char * armorFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * armorFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,
int element)
{
* @param element
* @return formatted string
*/
-static char * base64Format(rpm_tagtype_t type, rpm_constdata_t data,
+static char * base64Format(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding, int element)
{
char * val;
* @param element (unused)
* @return formatted string
*/
-static char * xmlFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * xmlFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,
int element)
{
* @param element (unused)
* @return formatted string
*/
-static char * pgpsigFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * pgpsigFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,
int element)
{
* @param element (unused)
* @return formatted string
*/
-static char * depflagsFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * depflagsFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding, int element)
{
char * val;
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int instprefixTag(Header h, rpm_tagtype_t* type,
+static int instprefixTag(Header h, rpmTagType* type,
rpm_data_t * data,
rpm_count_t * count,
int * freeData)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
- rpm_tagtype_t ipt;
+ rpmTagType ipt;
char ** array;
if (hge(h, RPMTAG_INSTALLPREFIX, type, (rpm_data_t *)data, count)) {
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int fssizesTag(Header h, rpm_tagtype_t* type,
+static int fssizesTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int triggercondsTag(Header h, rpm_tagtype_t* type,
+static int triggercondsTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
- rpm_tagtype_t tnt, tvt, tst;
+ rpmTagType tnt, tvt, tst;
int32_t * indices;
char ** names, ** versions;
rpm_count_t numNames, numScripts;
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int triggertypeTag(Header h, rpm_tagtype_t* type,
+static int triggertypeTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
- rpm_tagtype_t tst;
+ rpmTagType tst;
int32_t * indices;
const char ** conds;
const char ** s;
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int filenamesTag(Header h, rpm_tagtype_t* type,
+static int filenamesTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int fileclassTag(Header h, rpm_tagtype_t* type,
+static int fileclassTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int fileprovideTag(Header h, rpm_tagtype_t* type,
+static int fileprovideTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int filerequireTag(Header h, rpm_tagtype_t* type,
+static int filerequireTag(Header h, rpmTagType* type,
rpm_data_t * 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, rpm_tagtype_t* type,
+static int i18nTag(Header h, rpm_tag_t tag, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int summaryTag(Header h, rpm_tagtype_t* type,
+static int summaryTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int descriptionTag(Header h, rpm_tagtype_t* type,
+static int descriptionTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
* @retval *freeData data-was-malloc'ed indicator
* @return 0 on success
*/
-static int groupTag(Header h, rpm_tagtype_t* type,
+static int groupTag(Header h, rpmTagType* type,
rpm_data_t * data, rpm_count_t * count,
int * freeData)
{
(void) rpmdbSetIteratorRE(mi, RPMTAG_NAME, RPMMIRE_DEFAULT, '!gpg-pubkey');
#endif
while ((h = rpmdbNextIterator(mi)) != NULL) {
- rpm_tagtype_t type = RPM_NULL_TYPE;
+ rpmTagType type = RPM_NULL_TYPE;
rpm_count_t count = 0;
rpm_tid_t * tidp;
if (xx == 0)
for (i = 0; i < ac; i++) {
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
int isSource;
const char ** dirNames;
const char ** baseNames;
uint32_t * dirIndexes;
- rpm_tagtype_t fnt;
+ rpmTagType fnt;
rpm_count_t count, i;
int xx;
int dirIndex = -1;
rpmsenseFlags pFlags = RPMSENSE_EQUAL;
const char ** provides = NULL;
const char ** providesEVR = NULL;
- rpm_tagtype_t pnt, pvt;
+ rpmTagType pnt, pvt;
rpmsenseFlags * provideFlags = NULL;
rpm_count_t providesCount, i;
int xx;
HFD_t hfd = (HFD_t) headerFreeData;
HAE_t hae = (HAE_t) headerAddEntry;
HeaderIterator hi;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_tag_t tag;
rpm_count_t count;
rpm_data_t ptr;
HeaderIterator hi;
rpm_count_t count;
rpm_tag_t tag, stag;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_data_t ptr;
int xx;
rpmlead l = NULL;
Header sigh = NULL;
rpm_tag_t sigtag;
- rpm_tagtype_t sigtype;
+ rpmTagType sigtype;
rpm_data_t sig;
rpm_count_t siglen;
rpmtsOpX opx;
goto exit;
}
{ void * uh = NULL;
- rpm_tagtype_t uht;
+ rpmTagType uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc))
}
case RPMSIGTAG_SHA1:
{ void * uh = NULL;
- rpm_tagtype_t uht;
+ rpmTagType uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc))
int32_t * i32p;
} body;
char numbuf[32];
- rpm_tagtype_t type;
+ rpmTagType type;
for (tagm = tagMacros; tagm->macroname != NULL; tagm++) {
if (!hge(h, tagm->tag, &type, (rpm_data_t *) &body, NULL))
int argc = 0;
const char ** prefixes = NULL;
rpm_count_t numPrefixes;
- rpm_tagtype_t ipt;
+ rpmTagType ipt;
const char * oldPrefix;
size_t maxPrefixLength;
size_t len;
rpm_data_t * progArgv;
rpm_count_t progArgc;
const char ** argv;
- rpm_tagtype_t ptt, stt;
+ rpmTagType ptt, stt;
char * script;
rpmRC rc = RPMRC_OK;
int xx;
(void) rpmdsSetNoPromote(trigger, 1);
while ((i = rpmdsNext(trigger)) >= 0) {
- rpm_tagtype_t tit, tst, tpt;
+ rpmTagType tit, tst, tpt;
const char * Name;
rpmsenseFlags Flags = rpmdsFlags(trigger);
const char ** triggerNames;
rpm_count_t numTriggers, numTriggerIndices;
rpm_count_t * triggerIndices;
- rpm_tagtype_t tnt, tit;
+ rpmTagType tnt, tit;
unsigned char * triggersRun;
rpmRC rc = RPMRC_OK;
/* Regenerate original header. */
{ void * uh = NULL;
- rpm_tagtype_t uht;
+ rpmTagType 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;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_tag_t tag;
rpm_count_t count;
rpm_data_t ptr;
static int getSignid(Header sig, rpm_tag_t sigtag, pgpKeyID_t signid)
{
rpm_data_t pkt = NULL;
- rpm_tagtype_t pkttyp = 0;
+ rpmTagType pkttyp = 0;
rpm_count_t pktlen = 0;
int rc = 1;
Header sigh = NULL;
char * msg;
void * uh = NULL;
- rpm_tagtype_t uht;
+ rpmTagType 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;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_tag_t tag;
rpm_count_t count;
rpm_data_t ptr;
if (headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
void * uh;
- rpm_tagtype_t uht;
+ rpmTagType 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;
- rpm_tagtype_t sigtype;
+ rpmTagType sigtype;
rpm_data_t sig;
pgpDig dig;
pgpDigParams sigp;
int32_t * Refs; /*!< No. of file refs. */
time_t BT; /*!< Package build time tie breaker. */
rpm_tag_t tagN; /*!< Header tag. */
- rpm_tagtype_t Nt, EVRt, Ft; /*!< Tag data types. */
+ rpmTagType 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;
- rpm_tagtype_t BTt;
+ rpmTagType BTt;
rpm_time_t * BTp;
rpm_tag_t tagEVR, tagF;
rpmds ds = NULL;
const char * Type;
const char ** N;
- rpm_tagtype_t Nt;
+ rpmTagType Nt;
rpm_count_t Count;
if (dsType(tagN, &Type, &tagEVR, &tagF))
rpmRelocation * relocations = NULL;
int numRelocations;
const char ** validRelocations;
- rpm_tagtype_t validType;
+ rpmTagType validType;
const char ** baseNames;
const char ** dirNames;
uint32_t * dirIndexes;
if (nrelocated) {
rpm_count_t c;
void * d;
- rpm_tagtype_t t;
+ rpmTagType t;
d = NULL;
xx = hge(h, RPMTAG_BASENAMES, &t, &d, &c);
int size;
rpm_tag_t dirNameTag = 0;
rpm_tag_t dirIndexesTag = 0;
- rpm_tagtype_t bnt, dnt;
+ rpmTagType bnt, dnt;
char * t;
int i, xx;
if (eiu->relocations) {
const char ** paths;
- rpm_tagtype_t pft;
+ rpmTagType pft;
rpm_count_t c;
if (headerGetEntry(eiu->h, RPMTAG_PREFIXES, &pft,
RPM_BIN_TYPE = 7,
RPM_STRING_ARRAY_TYPE = 8,
RPM_I18NSTRING_TYPE = 9,
- RPM_MASK_TYPE = 0x0000ffff
#define RPM_MAX_TYPE 9
#define RPM_FORCEFREE_TYPE 0xff
+#define RPM_MASK_TYPE 0x0000ffff
} rpmTagType;
/** \ingroup header
mi = rpmtsInitIterator(ts, RPMTAG_PUBKEYS, sigp->signid, sizeof(sigp->signid));
while ((h = rpmdbNextIterator(mi)) != NULL) {
const char ** pubkeys;
- rpm_tagtype_t pt;
+ rpmTagType pt;
rpm_count_t pc;
if (!headerGetEntry(h, RPMTAG_PUBKEYS, &pt, (rpm_data_t *)&pubkeys, &pc))
return sigtag;
}
-rpm_tagtype_t rpmtsSigtype(const rpmts ts)
+rpmTagType rpmtsSigtype(const rpmts ts)
{
- rpm_tagtype_t sigtype = 0;
+ rpmTagType sigtype = 0;
if (ts != NULL)
sigtype = ts->sigtype;
return sigtype;
return siglen;
}
-int rpmtsSetSig(rpmts ts, rpm_tag_t sigtag, rpm_tagtype_t sigtype,
+int rpmtsSetSig(rpmts ts, rpm_tag_t sigtag, rpmTagType sigtype,
rpm_data_t sig, size_t siglen)
{
if (ts != NULL) {
* @param ts transaction set
* @return signature tag type
*/
-rpm_tagtype_t rpmtsSigtype(const rpmts ts);
+rpmTagType 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, rpm_tagtype_t sigtype,
+ rpm_tag_t sigtag, rpmTagType sigtype,
rpm_data_t sig, size_t siglen);
/** \ingroup rpmts
const char * fn; /*!< Current package fn. */
rpm_tag_t sigtag; /*!< Current package signature tag. */
- rpm_tagtype_t sigtype; /*!< Current package signature data type. */
+ rpmTagType sigtype; /*!< Current package signature data type. */
rpm_data_t sig; /*!< Current package signature. */
size_t siglen; /*!< Current package signature length. */
typedef struct headerIterator_s * HeaderIterator;
typedef int32_t rpm_tag_t;
-typedef uint32_t rpm_tagtype_t;
+typedef uint32_t rpm_tagtype_t; /* unused */
typedef uint32_t rpm_count_t;
typedef void * rpm_data_t;
if (headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
DIGEST_CTX ctx;
void * uh;
- rpm_tagtype_t uht;
+ rpmTagType uht;
rpm_count_t uhc;
if (!headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc)
PyObject * list, *o;
HeaderIterator hi;
rpm_tag_t tag;
- rpm_tagtype_t type;
+ rpmTagType type;
list = PyList_New(0);
case RPM_STRING_TYPE:
PyList_Append(list, o=PyInt_FromLong(tag));
Py_DECREF(o);
+ break;
+ case RPM_I18NSTRING_TYPE: /* hum.. ?`*/
+ case RPM_NULL_TYPE:
+ default:
+ break;
}
}
headerFreeIterator(hi);
* @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, rpm_tagtype_t *type,
+static int dressedHeaderGetEntry(Header h, rpm_tag_t tag, rpmTagType *type,
void **p, rpm_count_t *c)
{
switch (tag) {
*/
static PyObject * hdr_subscript(hdrObject * s, PyObject * item)
{
- rpm_tagtype_t tagtype, type;
+ rpmTagType tagtype, type;
rpm_tag_t tag = RPMTAG_NOT_FOUND;
rpm_count_t count, i;
rpm_data_t data;
hdrObject * hdr;
rpm_count_t c, count = 0;
rpm_tag_t tag;
- rpm_tagtype_t type;
+ rpmTagType type;
void * p;
Py_BEGIN_ALLOW_THREADS
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
const char ** baseNames, ** dirNames;
- rpm_tagtype_tbnt, dnt;
+ rpmTagTypebnt, dnt;
uint32_t * dirIndexes;
int fileCount;
int xx;
int headerNVR(Header h, const char **np, const char **vp, const char **rp)
{
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
if (np) {
const char **ep, const char **vp, const char **rp,
const char **ap)
{
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
headerNVR(h, np, vp, rp);
for (i = 0, entry = h->index; i < h->indexUsed; i++, entry++) {
unsigned diff;
- rpm_tagtype_t type;
+ rpmTagType 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(rpm_tagtype_t type, rpm_constdata_t p, rpm_count_t count,
+static int dataLength(rpmTagType type, rpm_constdata_t p, rpm_count_t count,
int onDisk, rpm_constdata_t pend)
{
const unsigned char * s = p;
memset(&ieprev, 0, sizeof(ieprev));
for (; il > 0; il--, pe++) {
struct indexEntry_s ie;
- rpm_tagtype_t type;
+ rpmTagType type;
ie.info.tag = ntohl(pe->tag);
ie.info.type = ntohl(pe->type);
int32_t il = 0;
int32_t dl = 0;
indexEntry entry;
- rpm_tagtype_t type;
+ rpmTagType type;
int i;
int drlen, ndribbles;
int driplen, ndrips;
* @return header entry
*/
static
-indexEntry findEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type)
+indexEntry findEntry(Header h, rpm_tag_t tag, rpmTagType type)
{
indexEntry entry, entry2, last;
struct indexEntry_s key;
* @return 1 on success, otherwise error.
*/
static int copyEntry(const indexEntry entry,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_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,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c,
int minMem)
return ((rc == 1) ? 1 : 0);
}
-void * headerFreeTag(Header h, rpm_data_t data, rpm_tagtype_t type)
+void * headerFreeTag(Header h, rpm_data_t data, rpmTagType type)
{
if (data) {
if (type == RPM_FORCEFREE_TYPE ||
}
int headerGetEntry(Header h, rpm_tag_t tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c)
{
}
int headerGetEntryMinMemory(Header h, rpm_tag_t tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c)
{
return intGetEntry(h, tag, type, (rpm_data_t) p, c, 1);
}
-int headerGetRawEntry(Header h, rpm_tag_t tag, rpm_tagtype_t * type, rpm_data_t * p,
+int headerGetRawEntry(Header h, rpm_tag_t tag, rpmTagType * type, rpm_data_t * p,
rpm_count_t * c)
{
indexEntry entry;
/**
*/
-static void copyData(rpm_tagtype_t type, rpm_data_t dstPtr,
+static void copyData(rpmTagType type, rpm_data_t dstPtr,
rpm_constdata_t srcPtr, rpm_count_t cnt, int dataLength)
{
switch (type) {
* @return (malloc'ed) copy of entry data, NULL on error
*/
static void *
-grabData(rpm_tagtype_t type, rpm_constdata_t p, rpm_count_t c, int * lengthPtr)
+grabData(rpmTagType type, rpm_constdata_t p, rpm_count_t c, int * lengthPtr)
{
rpm_data_t data = NULL;
int length;
return data;
}
-int headerAddEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
+int headerAddEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t p, rpm_count_t c)
{
indexEntry entry;
return 1;
}
-int headerAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
+int headerAppendEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t p, rpm_count_t c)
{
indexEntry entry;
return 1;
}
-int headerAddOrAppendEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
+int headerAddOrAppendEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t p, rpm_count_t c)
{
return (findEntry(h, tag, type)
return 0;
}
-int headerModifyEntry(Header h, rpm_tag_t tag, rpm_tagtype_t type,
+int headerModifyEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t p, rpm_count_t c)
{
indexEntry entry;
int headerNextIterator(HeaderIterator hi,
rpm_tag_t * tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c)
{
{
Header nh = headerNew();
HeaderIterator hi;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_tag_t tag;
rpm_count_t count;
rpm_data_t ptr;
hsa->i++;
} else {
rpm_tag_t tagno;
- rpm_tagtype_t type;
+ rpmTagType 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,
- rpm_tagtype_t * typeptr,
+ rpmTagType * typeptr,
rpm_data_t * data,
rpm_count_t * countptr,
rpmec ec)
size_t need = 0;
char * t, * te;
char buf[20];
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
rpm_data_t data;
unsigned int intVal;
{
char * t, * te;
int i, j, found;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count, numElements;
sprintfToken spft;
int condNumFormats;
* @param element (unused)
* @return formatted string
*/
-static char * octalFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * octalFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,int element)
{
char * val;
* @param element (unused)
* @return formatted string
*/
-static char * hexFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * hexFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,int element)
{
char * val;
/**
*/
-static char * realDateFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * realDateFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,int element,
const char * strftimeFormat)
{
* @param element (unused)
* @return formatted string
*/
-static char * dateFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * dateFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding, int element)
{
return realDateFormat(type, data, formatPrefix, padding, element,
* @param element (unused)
* @return formatted string
*/
-static char * dayFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * dayFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding, int element)
{
return realDateFormat(type, data, formatPrefix, padding, element,
* @param element (unused)
* @return formatted string
*/
-static char * shescapeFormat(rpm_tagtype_t type, rpm_constdata_t data,
+static char * shescapeFormat(rpmTagType type, rpm_constdata_t data,
char * formatPrefix, size_t padding,int element)
{
char * result, * dst, * src, * buf;
for (p = tagstocopy; *p != 0; p++) {
rpm_data_t s;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
if (headerIsEntry(headerTo, *p))
continue;
}
}
-void * headerFreeData(rpm_data_t data, rpm_tagtype_t type)
+void * headerFreeData(rpm_data_t data, rpmTagType type)
{
if (data) {
if (type == RPM_FORCEFREE_TYPE ||
struct headerTagTableEntry_s {
const char * name; /*!< Tag name. */
rpm_tag_t val; /*!< Tag numeric value. */
- rpm_tagtype_t type; /*!< Tag type. */
+ rpmTagType type; /*!< Tag type. */
};
/**
* @param element RPM_BIN_TYPE: no. bytes of data
* @return formatted string
*/
-typedef char * (*headerTagFormatFunction)(rpm_tagtype_t type,
+typedef char * (*headerTagFormatFunction)(rpmTagType type,
rpm_constdata_t data, char * formatPrefix,
size_t padding, rpm_count_t element);
* @return 0 on success
*/
typedef int (*headerTagTagFunction) (Header h,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * data,
rpm_count_t * count,
int * freeData);
*/
typedef struct HE_s {
rpm_tag_t tag;
- rpm_tagtype_t * typ;
+ rpmTagType * 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, rpm_data_t data, rpm_tagtype_t type);
+void * headerFreeTag(Header h, rpm_data_t data, rpmTagType type);
/** \ingroup header
* Retrieve tag value.
* @return 1 on success, 0 on failure
*/
int headerGetEntry(Header h, rpm_tag_t tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c);
* @return 1 on success, 0 on failure
*/
int headerGetEntryMinMemory(Header h, rpm_tag_t tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_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, rpm_tagtype_t type, rpm_constdata_t p, rpm_count_t c);
+int headerAddEntry(Header h, rpm_tag_t tag, rpmTagType type, rpm_constdata_t 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, rpm_tagtype_t type,
+int headerAppendEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t 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, rpm_tagtype_t type,
+int headerAddOrAppendEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t 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, rpm_tagtype_t type,
+int headerModifyEntry(Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t p, rpm_count_t c);
/** \ingroup header
*/
int headerNextIterator(HeaderIterator hi,
rpm_tag_t * tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c);
* @param type type of data (or RPM_FORCEFREE_TYPE to force free)
* @return NULL always
*/
-void * headerFreeData(rpm_data_t data, rpm_tagtype_t type);
+void * headerFreeData(rpm_data_t data, rpmTagType type);
/** \ingroup header
* Return name, version, release strings from header.
* @return NULL always
*/
typedef
- void * (*HFD_t) (rpm_data_t data, rpm_tagtype_t type);
+ void * (*HFD_t) (rpm_data_t data, rpmTagType type);
/**
* Prototype for headerGetEntry() vector.
* @return 1 on success, 0 on failure
*/
typedef int (*HGE_t) (Header h, rpm_tag_t tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * 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, rpm_tagtype_t type,
+typedef int (*HAE_t) (Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t 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, rpm_tagtype_t type,
+typedef int (*HME_t) (Header h, rpm_tag_t tag, rpmTagType type,
rpm_constdata_t p, rpm_count_t c);
/**
char ** headerGetLangs(Header h)
{
char **s, *e, **table;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t i, count;
if (!headerGetRawEntry(h, HEADER_I18NTABLE, &type, (rpm_data_t)&s, &count))
typedef struct entryInfo_s * entryInfo;
struct entryInfo_s {
rpm_tag_t tag; /*!< Tag identifier. */
- rpm_tagtype_t type; /*!< Tag data type. */
+ rpmTagType 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 {
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
int avail;
int freeit;
* @return 1 on success, 0 on failure
*/
int headerGetRawEntry(Header h, rpm_tag_t tag,
- rpm_tagtype_t * type,
+ rpmTagType * type,
rpm_data_t * p,
rpm_count_t * c);
HFD_t hfd = headerFreeData;
const char * dirName;
const char * baseName;
- rpm_tagtype_t bnt, dnt;
+ rpmTagType bnt, dnt;
fingerPrintCache fpc;
fingerPrint fp1;
dbiIndex dbi = NULL;
int8_t * i8p;
} u;
char numbuf[32];
- rpm_tagtype_t t;
+ rpmTagType t;
rpm_count_t c;
miRE mire;
static int32_t zero = 0;
dbiIndex dbi;
const char *av[1];
const char ** rpmvals = NULL;
- rpm_tagtype_t rpmtype = 0;
+ rpmTagType rpmtype = 0;
rpm_count_t rpmcnt = 0;
rpm_tag_t rpmtag;
int xx;
HFD_t hfd = headerFreeData;
sigset_t signalMask;
const char ** baseNames;
- rpm_tagtype_t bnt;
+ rpmTagType bnt;
rpm_count_t count = 0;
dbiIndex dbi;
int dbix;
for (dbix = 0; dbix < dbiTagsMax; dbix++) {
const char *av[1];
const char **rpmvals = NULL;
- rpm_tagtype_t rpmtype = 0;
+ rpmTagType rpmtype = 0;
rpm_count_t rpmcnt = 0;
rpm_tag_t rpmtag;
rpm_flag_t * requireFlags;
const char ** dirNames;
const char ** baseNames;
const char ** fullBaseNames;
- rpm_tagtype_t bnt, dnt;
+ rpmTagType bnt, dnt;
uint32_t * dirIndexes;
uint32_t * fullDirIndexes;
fingerPrint * fps;
enum cvtaction {CA_OLD, CA_NEW, CA_OMIT, CA_ERR};
-static enum cvtaction convertAMD(enum cvtaction ca, rpm_tagtype_t type,
+static enum cvtaction convertAMD(enum cvtaction ca, rpmTagType type,
void ** nvalsp, rpm_count_t *ncountp, cmd_t *newc)
{
int i;
return ca;
}
-static enum cvtaction convertExistingAMD(rpm_tag_t tag, rpm_tagtype_t type,
+static enum cvtaction convertExistingAMD(rpm_tag_t tag, rpmTagType type,
rpm_data_t valsp, rpm_count_t *countp, void ** nvalsp, rpm_count_t *ncountp,
cmd_t *cmds[], int ncmds)
{
Header headerCopyWithConvert(Header h, cmd_t *cmds[], int ncmds)
{
rpm_tag_t tag;
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t count;
rpm_data_t vals;
HeaderIterator headerIter;
rc = headerIsEntry(h, c->tagval);
if (!rc && !c->done && c->injmode != INJ_DELETE) {
- rpm_tagtype_t type;
+ rpmTagType type;
rpm_count_t ncount;
void *nvals;
enum cvtaction ca;