自学教程：C++ rpmtdFreeData函数代码示例

rpmScript rpmScriptFromTriggerTag(Header h, rpmTagVal triggerTag, uint32_t ix){    rpmScript script = NULL;    struct rpmtd_s tscripts, tprogs, tflags;    headerGetFlags hgflags = HEADERGET_MINMEM;    headerGet(h, RPMTAG_TRIGGERSCRIPTS, &tscripts, hgflags);    headerGet(h, RPMTAG_TRIGGERSCRIPTPROG, &tprogs, hgflags);    headerGet(h, RPMTAG_TRIGGERSCRIPTFLAGS, &tflags, hgflags);    if (rpmtdSetIndex(&tscripts, ix) >= 0 && rpmtdSetIndex(&tprogs, ix) >= 0) {        rpmscriptFlags sflags = 0;        const char *prog = rpmtdGetString(&tprogs);        if (rpmtdSetIndex(&tflags, ix) >= 0)            sflags = rpmtdGetNumber(&tflags);        script = rpmScriptNew(h, triggerTag, rpmtdGetString(&tscripts), sflags);        /* hack up a hge-style NULL-terminated array */        script->args = xmalloc(2 * sizeof(*script->args) + strlen(prog) + 1);        script->args[0] = (char *)(script->args + 2);        script->args[1] = NULL;        strcpy(script->args[0], prog);    }    rpmtdFreeData(&tscripts);    rpmtdFreeData(&tprogs);    rpmtdFreeData(&tflags);    return script;}

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, &copytd)) {	    if (copytd.data)		headerPut(nh, &copytd, HEADERPUT_DEFAULT);	    rpmtdFreeData(&copytd);	}	headerFreeIterator(hi);	headerFree(oh);	rpmtdFreeData(utd);	headerFree(*hdrp);	*hdrp = headerLink(nh);	headerFree(nh);    }}

int headerFindSpec(Header h){    struct rpmtd_s filenames;    int specix = -1;    if (headerGet(h, RPMTAG_BASENAMES, &filenames, HEADERGET_MINMEM)) {	struct rpmtd_s td;	const char *str;		/* Try to find spec by file flags */	if (headerGet(h, RPMTAG_FILEFLAGS, &td, HEADERGET_MINMEM)) {	    rpmfileAttrs *flags;	    while (specix < 0 && (flags = rpmtdNextUint32(&td))) {		if (*flags & RPMFILE_SPECFILE)		    specix = rpmtdGetIndex(&td);	    }	    rpmtdFreeData(&td);	}	/* Still no spec? Look by filename. */	while (specix < 0 && (str = rpmtdNextString(&filenames))) {	    if (rpmFileHasSuffix(str, ".spec")) 		specix = rpmtdGetIndex(&filenames);	}	rpmtdFreeData(&filenames);    }    return specix;}

/** * 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 int addPrefixes(Header h, rpmRelocation *relocations, int numRelocations){    struct rpmtd_s validRelocs;    const char *validprefix;    const char ** actualRelocations;    int numActual = 0;    headerGet(h, RPMTAG_PREFIXES, &validRelocs, HEADERGET_MINMEM);    /*     * If no relocations are specified (usually the case), then return the     * original header. If there are prefixes, however, then INSTPREFIXES     * should be added for RPM_INSTALL_PREFIX environ variables in scriptlets,      * but, since relocateFileList() can be called more than once for      * the same header, don't bother if already present.     */    if (relocations == NULL || numRelocations == 0) {	if (rpmtdCount(&validRelocs) > 0) {	    if (!headerIsEntry(h, RPMTAG_INSTPREFIXES)) {		rpmtdSetTag(&validRelocs, RPMTAG_INSTPREFIXES);		headerPut(h, &validRelocs, HEADERPUT_DEFAULT);	    }	    rpmtdFreeData(&validRelocs);	}	return 0;    }    actualRelocations = xmalloc(rpmtdCount(&validRelocs) * sizeof(*actualRelocations));    rpmtdInit(&validRelocs);    while ((validprefix = rpmtdNextString(&validRelocs))) {	int j;	for (j = 0; j < numRelocations; j++) {	    if (relocations[j].oldPath == NULL || /* XXX can't happen */		!rstreq(validprefix, relocations[j].oldPath))		continue;	    /* On install, a relocate to NULL means skip the path. */	    if (relocations[j].newPath) {		actualRelocations[numActual] = relocations[j].newPath;		numActual++;	    }	    break;	}	if (j == numRelocations) {	    actualRelocations[numActual] = validprefix;	    numActual++;	}    }    rpmtdFreeData(&validRelocs);    if (numActual) {	headerPutStringArray(h, RPMTAG_INSTPREFIXES, actualRelocations, numActual);    }    free(actualRelocations);    /* When any relocations are present there'll be more work to do */    return 1;}

rpmfi rpmfiNewPool(rpmstrPool pool, Header h, rpmTagVal tagN, rpmfiFlags flags){    rpmfi fi = xcalloc(1, sizeof(*fi));     struct rpmtd_s bn, dn, dx;    fi->magic = RPMFIMAGIC;    fi->i = -1;    fi->fiflags = flags;    /*     * Grab and validate file triplet data. Headers with no files simply     * fall through here and an empty file set is returned.     */    if (headerGet(h, RPMTAG_BASENAMES, &bn, HEADERGET_MINMEM)) {	headerGet(h, RPMTAG_DIRNAMES, &dn, HEADERGET_MINMEM);	headerGet(h, RPMTAG_DIRINDEXES, &dx, HEADERGET_ALLOC);	if (indexSane(&bn, &dn, &dx)) {	    /* private or shared pool? */	    fi->pool = (pool != NULL) ? rpmstrPoolLink(pool) :					rpmstrPoolCreate();	    /* init the file triplet data */	    fi->fc = rpmtdCount(&bn);	    fi->dc = rpmtdCount(&dn);	    fi->bnid = rpmtdToPool(&bn, fi->pool);	    fi->dnid = rpmtdToPool(&dn, fi->pool);	    /* steal index data from the td (pooh...) */	    fi->dil = dx.data;	    dx.data = NULL;	    /* populate the rest of the stuff */	    rpmfiPopulate(fi, h, flags);	    /* freeze the pool to save memory, but only if private pool */	    if (fi->pool != pool)		rpmstrPoolFreeze(fi->pool, 0);	    fi->h = (fi->fiflags & RPMFI_KEEPHEADER) ? headerLink(h) : NULL;	} else {	    /* broken data, free and return NULL */	    fi = _free(fi);	}	rpmtdFreeData(&bn);	rpmtdFreeData(&dn);	rpmtdFreeData(&dx);    }    return rpmfiLink(fi);}

/** * Print package size (debug purposes only) * @param fd			package file handle * @param sigh			signature header */static void printSize(FD_t fd, Header sigh){    struct stat st;    int fdno = Fileno(fd);    size_t siglen = headerSizeof(sigh, HEADER_MAGIC_YES);    size_t pad = (8 - (siglen % 8)) % 8; /* 8-byte pad */    struct rpmtd_s sizetag;    rpm_loff_t datalen = 0;    /* Print package component sizes. */    if (headerGet(sigh, RPMSIGTAG_LONGSIZE, &sizetag, HEADERGET_DEFAULT)) {	rpm_loff_t *tsize = rpmtdGetUint64(&sizetag);	datalen = (tsize) ? *tsize : 0;    } else if (headerGet(sigh, RPMSIGTAG_SIZE, &sizetag, HEADERGET_DEFAULT)) {	rpm_off_t *tsize = rpmtdGetUint32(&sizetag);	datalen = (tsize) ? *tsize : 0;    }    rpmtdFreeData(&sizetag);    rpmlog(RPMLOG_DEBUG,		"Expected size: %12" PRIu64 /		" = lead(%d)+sigs(%zd)+pad(%zd)+data(%" PRIu64 ")/n",		RPMLEAD_SIZE+siglen+pad+datalen,		RPMLEAD_SIZE, siglen, pad, datalen);    if (fstat(fdno, &st) == 0) {	rpmlog(RPMLOG_DEBUG,		"  Actual size: %12" PRIu64 "/n", (rpm_loff_t) st.st_size);    }}

static int isNewDep(rpmds *dsp, rpmds bds,		  Header h, rpmTagVal indextag, uint32_t index){    int isnew = 1;    if (!indextag) {	/* With normal deps, we can just merge and see if anything got added */	isnew = (rpmdsMerge(dsp, bds) > 0);    } else {	struct rpmtd_s idx;	rpmds ads = *dsp;	headerGet(h, indextag, &idx, HEADERGET_MINMEM);	/* rpmdsFind/Merge() probably isn't realiable with triggers... */	rpmdsInit(ads);	while (isnew && rpmdsNext(ads) >= 0) {	    if (!rstreq(rpmdsN(ads), rpmdsN(bds))) continue;	    if (!rstreq(rpmdsEVR(ads), rpmdsEVR(bds))) continue;	    if (rpmdsFlags(ads) != rpmdsFlags(bds)) continue;	    if (indextag && rpmtdSetIndex(&idx, rpmdsIx(ads)) >= 0 &&			    rpmtdGetNumber(&idx) != index) continue;	    isnew = 0;	}	rpmtdFreeData(&idx);	rpmdsMerge(dsp, bds);    }    return isnew;}

/* * Helper to convert 32bit tag to 64bit version. * If header has new 64bit tag then just return the data, * otherwise convert 32bit old tag data to 64bit values. * For consistency, always return malloced data. */static int get64(Header h, rpmtd td, rpmTag newtag, rpmTag oldtag){    int rc;    if (headerIsEntry(h, newtag)) {	rc = headerGet(h, newtag, td, HEADERGET_ALLOC);    } else {	struct rpmtd_s olddata;	uint32_t *d32 = NULL;	uint64_t *d64 = NULL;	headerGet(h, oldtag, &olddata, HEADERGET_MINMEM);	if (rpmtdType(&olddata) == RPM_INT32_TYPE) {	    td->type = RPM_INT64_TYPE;	    td->count = olddata.count;	    td->flags = RPMTD_ALLOCED;	    td->data = xmalloc(sizeof(*d64) * td->count);	    d64 = td->data;	    while ((d32 = rpmtdNextUint32(&olddata))) {		*d64++ = *d32;	    }	} 	rpmtdFreeData(&olddata);	rc = d64 ? 1 : 0;    }    return rc;}

/** * Define or undefine per-header macros. * @param h		header * @param define	define/undefine? * @return		0 always */static void rpmInstallLoadMacros(Header h, int define){    const struct tagMacro * tagm;    for (tagm = tagMacros; tagm->macroname != NULL; tagm++) {	struct rpmtd_s td;	char *body;	if (!headerGet(h, tagm->tag, &td, HEADERGET_DEFAULT))	    continue;	/*	 * Undefine doesn't need the actual data for anything, but	 * this way ensures we only undefine what was defined earlier.	 */	switch (rpmtdType(&td)) {	default:	    if (define) {		body = rpmtdFormat(&td, RPMTD_FORMAT_STRING, NULL);		addMacro(NULL, tagm->macroname, NULL, body, -1);		free(body);	    } else {		delMacro(NULL, tagm->macroname);	    }	    break;	case RPM_NULL_TYPE:	    break;	}	rpmtdFreeData(&td);    }}

/* * Source rpms only contain basenames, on install the full paths are * constructed with %{_specdir} and %{_sourcedir} macros. Because * of that regular relocation wont work, we need to do it the hard * way. Return spec file index on success, -1 on errors. */int rpmRelocateSrpmFileList(Header h, const char *rootDir){    int specix = headerFindSpec(h);    if (specix >= 0) {	const char *bn;	struct rpmtd_s filenames;	/* save original file names */	saveOrig(h);	headerDel(h, RPMTAG_BASENAMES);	headerDel(h, RPMTAG_DIRNAMES);	headerDel(h, RPMTAG_DIRINDEXES);	/* Macros need to be added before trying to create directories */	rpmInstallLoadMacros(h, 1);	/* ALLOC is needed as we modify the header */	headerGet(h, RPMTAG_ORIGBASENAMES, &filenames, HEADERGET_ALLOC);	for (int i = 0; (bn = rpmtdNextString(&filenames)); i++) {	    int spec = (i == specix);	    char *fn = rpmGenPath(rootDir,				  spec ? "%{_specdir}" : "%{_sourcedir}", bn);	    headerPutString(h, RPMTAG_OLDFILENAMES, fn);	    free(fn);	}	rpmtdFreeData(&filenames);	headerConvert(h, HEADERCONV_COMPRESSFILELIST);	rpmInstallLoadMacros(h, 0);    }    return specix;}

/** * Retrieve trigger type info. * @param h		header * @retval td		tag data container * @return		1 on success */static int triggertypeTag(Header h, rpmtd td, headerGetFlags hgflags){    int i;    char ** conds;    struct rpmtd_s indices, flags, scripts;    if (!headerGet(h, RPMTAG_TRIGGERINDEX, &indices, HEADERGET_MINMEM)) {	return 0;    }    headerGet(h, RPMTAG_TRIGGERFLAGS, &flags, HEADERGET_MINMEM);    headerGet(h, RPMTAG_TRIGGERSCRIPTS, &scripts, HEADERGET_MINMEM);    td->flags = RPMTD_ALLOCED | RPMTD_PTR_ALLOCED;    td->count = rpmtdCount(&scripts);    td->data = conds = xmalloc(sizeof(*conds) * td->count);    td->type = RPM_STRING_ARRAY_TYPE;    while ((i = rpmtdNext(&scripts)) >= 0) {	rpm_flag_t *flag;	rpmtdInit(&indices); rpmtdInit(&flags);	while (rpmtdNext(&indices) >= 0 && rpmtdNext(&flags) >= 0) {	    if (*rpmtdGetUint32(&indices) != i) 		continue;	    flag = rpmtdGetUint32(&flags);	    if (*flag & RPMSENSE_TRIGGERPREIN)		conds[i] = xstrdup("prein");	    else if (*flag & RPMSENSE_TRIGGERIN)		conds[i] = xstrdup("in");	    else if (*flag & RPMSENSE_TRIGGERUN)		conds[i] = xstrdup("un");	    else if (*flag & RPMSENSE_TRIGGERPOSTUN)		conds[i] = xstrdup("postun");	    else		conds[i] = xstrdup("");	    break;	}    }    rpmtdFreeData(&indices);    rpmtdFreeData(&flags);    rpmtdFreeData(&scripts);    return 1;}

/** /ingroup py_c */static void rpmtd_dealloc(rpmtdObject * s){    if (s) {	rpmtdFreeData(s->td);	rpmtdFree(s->td);	PyObject_Del(s);    }}

rpmds rpmdsNewPool(rpmstrPool pool, Header h, rpmTagVal tagN, int flags){    rpmTagVal tagEVR, tagF, tagTi;    rpmds ds = NULL;    const char * Type;    struct rpmtd_s names;    if (dsType(tagN, &Type, &tagEVR, &tagF, &tagTi))	goto exit;    if (headerGet(h, tagN, &names, HEADERGET_MINMEM)) {	struct rpmtd_s evr, flags, tindices;	ds = rpmdsCreate(pool, tagN, Type,			 rpmtdCount(&names), headerGetInstance(h));	ds->N = rpmtdToPool(&names, ds->pool);	headerGet(h, tagEVR, &evr, HEADERGET_MINMEM);	ds->EVR = rpmtdToPool(&evr, ds->pool);	headerGet(h, tagF, &flags, HEADERGET_ALLOC);	ds->Flags = flags.data;	if (tagTi != RPMTAG_NOT_FOUND) {	    headerGet(h, tagTi, &tindices, HEADERGET_ALLOC);	    ds->ti = tindices.data;	}	/* ensure rpmlib() requires always have RPMSENSE_RPMLIB flag set */	if (tagN == RPMTAG_REQUIRENAME && ds->Flags) {	    for (int i = 0; i < ds->Count; i++) {		if (!(rpmdsFlagsIndex(ds, i) & RPMSENSE_RPMLIB)) {		    const char *N = rpmdsNIndex(ds, i);		    if (rstreqn(N, "rpmlib(", sizeof("rpmlib(")-1))			ds->Flags[i] |= RPMSENSE_RPMLIB;		}	    }	}	rpmtdFreeData(&names);	rpmtdFreeData(&evr);	/* freeze the pool to save memory, but only if private pool */	if (ds->pool != pool)	    rpmstrPoolFreeze(ds->pool, 0);    }exit:    return ds;}

/** * Run triggers from this header that are fired by headers in the database. * @param psm		package state machine data * @param sense		trigger type * @return		0 on success */static rpmRC runImmedTriggers(rpmpsm psm, rpmsenseFlags sense){    const rpmts ts = psm->ts;    unsigned char * triggersRun;    struct rpmtd_s tnames, tindexes;    Header h = rpmteHeader(psm->te);    int nerrors = 0;    if (!(headerGet(h, RPMTAG_TRIGGERNAME, &tnames, HEADERGET_MINMEM) &&	  headerGet(h, RPMTAG_TRIGGERINDEX, &tindexes, HEADERGET_MINMEM))) {	goto exit;    }    triggersRun = xcalloc(rpmtdCount(&tindexes), sizeof(*triggersRun));    {	Header sourceH = NULL;	const char *trigName;    	rpm_count_t *triggerIndices = tindexes.data;	while ((trigName = rpmtdNextString(&tnames))) {	    rpmdbMatchIterator mi;	    int i = rpmtdGetIndex(&tnames);	    if (triggersRun[triggerIndices[i]] != 0) continue;		    mi = rpmtsInitIterator(ts, RPMDBI_NAME, trigName, 0);	    while((sourceH = rpmdbNextIterator(mi)) != NULL) {		nerrors += handleOneTrigger(psm->ts, psm->te,				sense, sourceH, h,				psm->countCorrection,				rpmdbGetIteratorCount(mi),				triggersRun);	    }	    rpmdbFreeIterator(mi);	}    }    rpmtdFreeData(&tnames);    rpmtdFreeData(&tindexes);    free(triggersRun);exit:    headerFree(h);    return (nerrors == 0) ? RPMRC_OK : RPMRC_FAIL;}

static void saveOrig(Header h){	struct rpmtd_s td;	headerGet(h, RPMTAG_BASENAMES, &td, HEADERGET_MINMEM);	rpmtdSetTag(&td, RPMTAG_ORIGBASENAMES);	headerPut(h, &td, HEADERPUT_DEFAULT);	rpmtdFreeData(&td);	headerGet(h, RPMTAG_DIRNAMES, &td, HEADERGET_MINMEM);	rpmtdSetTag(&td, RPMTAG_ORIGDIRNAMES);	headerPut(h, &td, HEADERPUT_DEFAULT);	rpmtdFreeData(&td);	headerGet(h, RPMTAG_DIRINDEXES, &td, HEADERGET_MINMEM);	rpmtdSetTag(&td, RPMTAG_ORIGDIRINDEXES);	headerPut(h, &td, HEADERPUT_DEFAULT);	rpmtdFreeData(&td);}

static rpmsid * tag2pool(rpmstrPool pool, Header h, rpmTag tag){    rpmsid *sids = NULL;    struct rpmtd_s td;    if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {	sids = rpmtdToPool(&td, pool);	rpmtdFreeData(&td);    }    return sids;}

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;}

/** * Retrieve signature from header tag * @param sigh		signature header * @param sigtag	signature tag * @return		parsed pgp dig or NULL */static pgpDigParams getSig(Header sigh, rpmTagVal sigtag){    struct rpmtd_s pkt;    pgpDigParams sig = NULL;    if (headerGet(sigh, sigtag, &pkt, HEADERGET_DEFAULT) && pkt.data != NULL) {	pgpPrtParams(pkt.data, pkt.count, PGPTAG_SIGNATURE, &sig);	rpmtdFreeData(&pkt);    }    return sig;}

static PyObject * hdrGetTag(Header h, rpmTagVal tag){    PyObject *res = NULL;    struct rpmtd_s td;    /* rpmtd_AsPyObj() knows how to handle empty containers and all */    (void) headerGet(h, tag, &td, HEADERGET_EXT);    res = rpmtd_AsPyobj(&td);    rpmtdFreeData(&td);    return res;}

/* * Up to rpm 3.0.4, packages implicitly provided their own name-version-release. * Retrofit an explicit "Provides: name = epoch:version-release. */static void providePackageNVR(Header h){    const char *name = headerGetString(h, RPMTAG_NAME);    char *pEVR = headerGetAsString(h, RPMTAG_EVR);    rpmsenseFlags pFlags = RPMSENSE_EQUAL;    int bingo = 1;    struct rpmtd_s pnames;    rpmds hds, nvrds;    /* Generate provides for this package name-version-release. */    if (!(name && pEVR))	return;    /*     * Rpm prior to 3.0.3 does not have versioned provides.     * If no provides at all are available, we can just add.     */    if (!headerGet(h, RPMTAG_PROVIDENAME, &pnames, HEADERGET_MINMEM)) {	goto exit;    }    /*     * Otherwise, fill in entries on legacy packages.     */    if (!headerIsEntry(h, RPMTAG_PROVIDEVERSION)) {	while (rpmtdNext(&pnames) >= 0) {	    rpmsenseFlags fdummy = RPMSENSE_ANY;	    headerPutString(h, RPMTAG_PROVIDEVERSION, "");	    headerPutUint32(h, RPMTAG_PROVIDEFLAGS, &fdummy, 1);	}	goto exit;    }    /* see if we already have this provide */    hds = rpmdsNew(h, RPMTAG_PROVIDENAME, 0);    nvrds = rpmdsSingle(RPMTAG_PROVIDENAME, name, pEVR, pFlags);    if (rpmdsFind(hds, nvrds) >= 0) {	bingo = 0;    }    rpmdsFree(hds);    rpmdsFree(nvrds);    exit:    if (bingo) {	headerPutString(h, RPMTAG_PROVIDENAME, name);	headerPutString(h, RPMTAG_PROVIDEVERSION, pEVR);	headerPutUint32(h, RPMTAG_PROVIDEFLAGS, &pFlags, 1);    }    rpmtdFreeData(&pnames);    free(pEVR);}

static int depContainsTilde(Header h, rpmTagVal tagEVR){    struct rpmtd_s evrs;    const char *evr = NULL;    if (headerGet(h, tagEVR, &evrs, HEADERGET_MINMEM)) {	while ((evr = rpmtdNextString(&evrs)) != NULL)	    if (strchr(evr, '~'))		break;	rpmtdFreeData(&evrs);    }    return evr != NULL;}

uint64_t headerGetNumber(Header h, rpmTag tag){    uint64_t res = 0;    struct rpmtd_s td;    if (headerGet(h, tag, &td, HEADERGET_EXT)) {	if (rpmtdCount(&td) == 1) {	    res = rpmtdGetNumber(&td);	}	rpmtdFreeData(&td);    }    return res;}

const char * headerGetString(Header h, rpmTag tag){    const char *res = NULL;    struct rpmtd_s td;    if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {	if (rpmtdCount(&td) == 1) {	    res = rpmtdGetString(&td);	}	rpmtdFreeData(&td);    }    return res;}

char * headerGetAsString(Header h, rpmTag tag){    char *res = NULL;    struct rpmtd_s td;    if (headerGet(h, tag, &td, HEADERGET_EXT)) {	if (rpmtdCount(&td) == 1) {	    res = rpmtdFormat(&td, RPMTD_FORMAT_STRING, NULL);	}	rpmtdFreeData(&td);    }    return res;}

static void saveRelocs(Header h, rpmtd bnames, rpmtd dnames, rpmtd dindexes){	struct rpmtd_s td;	headerGet(h, RPMTAG_BASENAMES, &td, HEADERGET_MINMEM);	rpmtdSetTag(&td, RPMTAG_ORIGBASENAMES);	headerPut(h, &td, HEADERPUT_DEFAULT);	rpmtdFreeData(&td);	headerGet(h, RPMTAG_DIRNAMES, &td, HEADERGET_MINMEM);	rpmtdSetTag(&td, RPMTAG_ORIGDIRNAMES);	headerPut(h, &td, HEADERPUT_DEFAULT);	rpmtdFreeData(&td);	headerGet(h, RPMTAG_DIRINDEXES, &td, HEADERGET_MINMEM);	rpmtdSetTag(&td, RPMTAG_ORIGDIRINDEXES);	headerPut(h, &td, HEADERPUT_DEFAULT);	rpmtdFreeData(&td);	headerMod(h, bnames);	headerMod(h, dnames);	headerMod(h, dindexes);}

static void initSourceHeader(rpmSpec spec){    Package sourcePkg = spec->sourcePackage;    struct Source *srcPtr;    if (headerIsEntry(sourcePkg->header, RPMTAG_NAME))        return;    /* Only specific tags are added to the source package header */    headerCopyTags(spec->packages->header, sourcePkg->header, sourceTags);    /* Add the build restrictions */    for (int i=0; i<PACKAGE_NUM_DEPS; i++) {        rpmdsPutToHeader(sourcePkg->dependencies[i], sourcePkg->header);    }    {        HeaderIterator hi = headerInitIterator(spec->buildRestrictions);        struct rpmtd_s td;        while (headerNext(hi, &td)) {            if (rpmtdCount(&td) > 0) {                (void) headerPut(sourcePkg->header, &td, HEADERPUT_DEFAULT);            }            rpmtdFreeData(&td);        }        headerFreeIterator(hi);    }    if (spec->BANames && spec->BACount > 0) {        headerPutStringArray(sourcePkg->header, RPMTAG_BUILDARCHS,                             spec->BANames, spec->BACount);    }    /* Add tags for sources and patches */    for (srcPtr = spec->sources; srcPtr != NULL; srcPtr = srcPtr->next) {        if (srcPtr->flags & RPMBUILD_ISSOURCE) {            headerPutString(sourcePkg->header, RPMTAG_SOURCE, srcPtr->source);            if (srcPtr->flags & RPMBUILD_ISNO) {                headerPutUint32(sourcePkg->header, RPMTAG_NOSOURCE,                                &srcPtr->num, 1);            }        }        if (srcPtr->flags & RPMBUILD_ISPATCH) {            headerPutString(sourcePkg->header, RPMTAG_PATCH, srcPtr->source);            if (srcPtr->flags & RPMBUILD_ISNO) {                headerPutUint32(sourcePkg->header, RPMTAG_NOPATCH,                                &srcPtr->num, 1);            }        }    }}

static int headercolorTag(Header h, rpmtd td, headerGetFlags hgflags){    rpm_color_t *fcolor, hcolor = 0;    struct rpmtd_s fcolors;    headerGet(h, RPMTAG_FILECOLORS, &fcolors, HEADERGET_MINMEM);    while ((fcolor = rpmtdNextUint32(&fcolors)) != NULL) {	hcolor |= *fcolor;    }    rpmtdFreeData(&fcolors);    hcolor &= 0x0f;    return numberTag(td, hcolor);}

static int haveLangTag(Header h, rpmTagVal tag, const char *lang){    int rc = 0;	/* assume tag not present */    int langNum = -1;    if (lang && *lang) {	/* See if the language is in header i18n table */	struct rpmtd_s langtd;	const char *s = NULL;	headerGet(h, RPMTAG_HEADERI18NTABLE, &langtd, HEADERGET_MINMEM);	while ((s = rpmtdNextString(&langtd)) != NULL) {	    if (rstreq(s, lang)) {		langNum = rpmtdGetIndex(&langtd);		break;	    }	}	rpmtdFreeData(&langtd);    } else {	/* C locale */	langNum = 0;    }    /* If locale is present, check the actual tag content */    if (langNum >= 0) {	struct rpmtd_s td;	headerGet(h, tag, &td, HEADERGET_MINMEM|HEADERGET_RAW);	if (rpmtdSetIndex(&td, langNum) == langNum) {	    const char *s = rpmtdGetString(&td);	    /* non-empty string means a dupe */	    if (s && *s)		rc = 1;	}	rpmtdFreeData(&td);    };    return rc;}

/* Helper to push header tag data into a string cache */static scidx_t *cacheTag(strcache cache, Header h, rpmTag tag){    scidx_t *idx = NULL;    struct rpmtd_s td;    if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {       idx = xmalloc(sizeof(*idx) * rpmtdCount(&td));       int i = 0;       const char *str;       while ((str = rpmtdNextString(&td))) {	   idx[i++] = strcachePut(cache, str);       }       rpmtdFreeData(&td);    }    return idx;}