/** \ingroup header

 * \file lib/formats.c

 */

#include "system.h"

#include <rpm/rpmtypes.h>

#include <rpm/rpmlib.h>

#include <rpm/rpmmacro.h>	/* XXX for %_i18ndomains */

#include <rpm/rpmfi.h>

#include <rpm/rpmstring.h>

#include <rpm/rpmlog.h>

#include "lib/misc.h"		/* tag function proto */

#include "debug.h"

struct headerTagFunc_s {

    rpmTag tag;		/*!< Tag of extension. */

    headerTagTagFunction func;	/*!< Pointer to formatter function. */	

};

/** \ingroup rpmfi

 * Retrieve file names from header.

 *

 * The representation of file names in package headers changed in rpm-4.0.

 * Originally, file names were stored as an array of absolute paths.

 * In rpm-4.0, file names are stored as separate arrays of dirname's and

 * basename's, * with a dirname index to associate the correct dirname

 * with each basname.

 *

 * This function is used to retrieve file names independent of how the

 * file names are represented in the package header.

 * 

 * @param h		header

 * @param tagN		RPMTAG_BASENAMES | PMTAG_ORIGBASENAMES

 * @param withstate	take file state into account?

 * @retval td		tag data container

 * @return		1 on success

 */

static int fnTag(Header h, rpmTag tagN, int withstate, rpmtd td)

{

    const char **baseNames, **dirNames;

    const char *fileStates = NULL;

    uint32_t *dirIndexes;

    rpm_count_t count, retcount, dncount;

    size_t size = 0;

    rpmTag dirNameTag = RPMTAG_DIRNAMES;

    rpmTag dirIndexesTag = RPMTAG_DIRINDEXES;

    int i, j;

    int rc = 0; /* assume failure */

    struct rpmtd_s bnames, dnames, dixs, fstates;

    if (tagN == RPMTAG_ORIGBASENAMES) {

	dirNameTag = RPMTAG_ORIGDIRNAMES;

	dirIndexesTag = RPMTAG_ORIGDIRINDEXES;

    }

    if (!headerGet(h, tagN, &bnames, HEADERGET_MINMEM)) {

	return 0;		/* no file list */

    }

    (void) headerGet(h, dirNameTag, &dnames, HEADERGET_MINMEM);

    (void) headerGet(h, dirIndexesTag, &dixs, HEADERGET_MINMEM);

    retcount = count = rpmtdCount(&bnames);

    dncount = rpmtdCount(&dnames);

    /* Basic sanity checking for our interrelated tags  */

    if (rpmtdCount(&dixs) != count || dncount < 1 || dncount > count)

	td->flags |= RPMTD_INVALID;

    if (withstate) {

	/* no recorded states means no installed files */

	if (!headerGet(h, RPMTAG_FILESTATES, &fstates, HEADERGET_MINMEM))

	    goto exit;

	if (rpmtdCount(&fstates) != count)

	    td->flags |= RPMTD_INVALID;

	fileStates = fstates.data;

    }

    if (td->flags & RPMTD_INVALID)

	goto exit;

    baseNames = bnames.data;

    dirNames = dnames.data;

    dirIndexes = dixs.data;

    /*

     * fsm, psm and rpmfi assume the data is stored in a single allocation

     * block, until those assumptions are removed we need to jump through

     * a few hoops here and precalculate sizes etc

     */

    for (i = 0; i < count; i++) {

	if (fileStates && !RPMFILE_IS_INSTALLED(fileStates[i])) {

	    retcount--;

	    continue;

	}

	/* Sanity check  directory indexes are within bounds */

	if (dirIndexes[i] >= dncount) {

	    td->flags |= RPMTD_INVALID;

	    break;

	}

	size += strlen(baseNames[i]) + strlen(dirNames[dirIndexes[i]]) + 1;

    }

    if (!(td->flags & RPMTD_INVALID)) {

	char **fileNames = xmalloc(size + (sizeof(*fileNames) * retcount));

	char *t = ((char *) fileNames) + (sizeof(*fileNames) * retcount);

	for (i = 0, j = 0; i < count; i++) {

	    if (fileStates && !RPMFILE_IS_INSTALLED(fileStates[i]))

		continue;

	    fileNames[j++] = t;

	    t = stpcpy( stpcpy(t, dirNames[dirIndexes[i]]), baseNames[i]);

	    *t++ = '\0';

	}

	td->data = fileNames;

	td->count = retcount;

	td->type = RPM_STRING_ARRAY_TYPE;

	td->flags |= RPMTD_ALLOCED;

	rc = 1;

    }

exit:

    rpmtdFreeData(&bnames);

    rpmtdFreeData(&dnames);

    rpmtdFreeData(&dixs);

    /* only safe if the headerGet() on file states was actually called */

    if (fileStates)

	rpmtdFreeData(&fstates);

    return rc;

}

static int filedepTag(Header h, rpmTag tagN, rpmtd td, headerGetFlags hgflags)

{

    rpmfi fi = rpmfiNew(NULL, h, RPMTAG_BASENAMES, RPMFI_NOHEADER);

    rpmds ds = NULL;

    char **fdeps = NULL;

    int numfiles;

    char deptype = 'R';

    int fileix;

    int rc = 0;

    numfiles = rpmfiFC(fi);

    if (numfiles <= 0) {

	goto exit;

    }

    if (tagN == RPMTAG_PROVIDENAME)

	deptype = 'P';

    else if (tagN == RPMTAG_REQUIRENAME)

	deptype = 'R';

    ds = rpmdsNew(h, tagN, 0);

    fdeps = xmalloc(numfiles * sizeof(*fdeps));

    while ((fileix = rpmfiNext(fi)) >= 0) {

	ARGV_t deps = NULL;

	const uint32_t * ddict = NULL;

	int ndx = rpmfiFDepends(fi, &ddict);

	if (ddict != NULL) {

	    while (ndx-- > 0) {

		const char * DNEVR;

		unsigned dix = *ddict++;

		char mydt = ((dix >> 24) & 0xff);

		if (mydt != deptype)

		    continue;

		dix &= 0x00ffffff;

		(void) rpmdsSetIx(ds, dix-1);

		if (rpmdsNext(ds) < 0)

		    continue;

		DNEVR = rpmdsDNEVR(ds);

		if (DNEVR != NULL) {

		    argvAdd(&deps, DNEVR + 2);

		}

	    }

	}

	fdeps[fileix] = deps ? argvJoin(deps, " ") : xstrdup("");

	argvFree(deps);

    }

    td->data = fdeps;

    td->count = numfiles;

    td->flags = RPMTD_ALLOCED | RPMTD_PTR_ALLOCED;

    td->type = RPM_STRING_ARRAY_TYPE;

    rc = 1;

exit:

    rpmfiFree(fi);

    rpmdsFree(ds);

    return rc;

}

typedef enum tMode_e {

    NORMALTRIGGER     = 0,

    FILETRIGGER       = 1,

    TRANSFILETRIGGER  = 2,

} tMode;

/**

 * Retrieve trigger info.

 * @param mode		type of trigger (see tMode_e)

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int triggercondsTagFor(tMode mode, Header h, rpmtd td,

				headerGetFlags hgflags)

{

    uint32_t * indices;

    int i, j;

    char ** conds;

    struct rpmtd_s nametd, indextd, flagtd, versiontd, scripttd;

    int hgeflags = HEADERGET_MINMEM;

    rpmTagVal triggername, triggerindex, triggerflags;

    rpmTagVal triggerversion, triggerscripts;

    switch (mode) {

	case NORMALTRIGGER:

	    triggername = RPMTAG_TRIGGERNAME;

	    triggerindex = RPMTAG_TRIGGERINDEX;

	    triggerflags = RPMTAG_TRIGGERFLAGS;

	    triggerversion = RPMTAG_TRIGGERVERSION;

	    triggerscripts = RPMTAG_TRIGGERSCRIPTS;

	    break;

	case FILETRIGGER:

	    triggername = RPMTAG_FILETRIGGERNAME;

	    triggerindex = RPMTAG_FILETRIGGERINDEX;

	    triggerflags = RPMTAG_FILETRIGGERFLAGS;

	    triggerversion = RPMTAG_FILETRIGGERVERSION;

	    triggerscripts = RPMTAG_FILETRIGGERSCRIPTS;

	    break;

	case TRANSFILETRIGGER:

	    triggername = RPMTAG_TRANSFILETRIGGERNAME;

	    triggerindex = RPMTAG_TRANSFILETRIGGERINDEX;

	    triggerflags = RPMTAG_TRANSFILETRIGGERFLAGS;

	    triggerversion = RPMTAG_TRANSFILETRIGGERVERSION;

	    triggerscripts = RPMTAG_TRANSFILETRIGGERSCRIPTS;

	    break;

	default:

	    return 0;

    }

    if (!headerGet(h, triggername, &nametd, hgeflags)) {

	return 0;

    }

    headerGet(h, triggerindex, &indextd, hgeflags);

    headerGet(h, triggerflags, &flagtd, hgeflags);

    headerGet(h, triggerversion, &versiontd, hgeflags);

    headerGet(h, triggerscripts, &scripttd, hgeflags);

    td->type = RPM_STRING_ARRAY_TYPE;

    td->flags = RPMTD_ALLOCED | RPMTD_PTR_ALLOCED;

    td->data = conds = xmalloc(sizeof(*conds) * rpmtdCount(&scripttd));

    td->count = rpmtdCount(&scripttd);

    indices = indextd.data;

    while ((i = rpmtdNext(&scripttd)) >= 0) {

	rpm_flag_t *flag;

	char *flagStr, *item;

	ARGV_t items = NULL;

	rpmtdInit(&nametd); rpmtdInit(&flagtd); rpmtdInit(&versiontd);

	while ((j = rpmtdNext(&nametd)) >= 0) {

	    /* flag and version arrays match name array size always */

	    rpmtdNext(&flagtd); rpmtdNext(&versiontd);

	    if (indices[j] != i)

		continue;

	    flag = rpmtdGetUint32(&flagtd);

	    if (flag && *flag & RPMSENSE_SENSEMASK) {

		flagStr = rpmtdFormat(&flagtd, RPMTD_FORMAT_DEPFLAGS, NULL);

		rasprintf(&item, "%s %s %s", rpmtdGetString(&nametd),

					     flagStr,

					     rpmtdGetString(&versiontd));

		free(flagStr);

	    } else {

		item = xstrdup(rpmtdGetString(&nametd));

	    }

	    argvAdd(&items, item);

	    free(item);

	}

	conds[i] = argvJoin(items, ", ");

	argvFree(items);

    }

    rpmtdFreeData(&nametd);

    rpmtdFreeData(&versiontd);

    rpmtdFreeData(&flagtd);

    rpmtdFreeData(&indextd);

    rpmtdFreeData(&scripttd);

    return 1;

}

static int triggercondsTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return triggercondsTagFor(NORMALTRIGGER, h, td, hgflags);

}

static int filetriggercondsTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return triggercondsTagFor(FILETRIGGER, h, td, hgflags);

}

static int transfiletriggercondsTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return triggercondsTagFor(TRANSFILETRIGGER, h, td, hgflags);

}

/**

 * Retrieve trigger type info.

 * @param mode		type of trigger (see tMode_e)

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int triggertypeTagFor(tMode mode, Header h, rpmtd td,

				headerGetFlags hgflags)

{

    int i;

    char ** conds;

    struct rpmtd_s indices, flags, scripts;

    rpmTagVal triggerindex, triggerflags, triggerscripts;

    switch (mode) {

	case NORMALTRIGGER:

	    triggerindex = RPMTAG_TRIGGERINDEX;

	    triggerflags = RPMTAG_TRIGGERFLAGS;

	    triggerscripts = RPMTAG_TRIGGERSCRIPTS;

	    break;

	case FILETRIGGER:

	    triggerindex = RPMTAG_FILETRIGGERINDEX;

	    triggerflags = RPMTAG_FILETRIGGERFLAGS;

	    triggerscripts = RPMTAG_FILETRIGGERSCRIPTS;

	    break;

	case TRANSFILETRIGGER:

	    triggerindex = RPMTAG_TRANSFILETRIGGERINDEX;

	    triggerflags = RPMTAG_TRANSFILETRIGGERFLAGS;

	    triggerscripts = RPMTAG_TRANSFILETRIGGERSCRIPTS;

	    break;

	default:

	   return 0;

    }

    if (!headerGet(h, triggerindex, &indices, HEADERGET_MINMEM)) {

	return 0;

    }

    headerGet(h, triggerflags, &flags, HEADERGET_MINMEM);

    headerGet(h, 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;

}

static int triggertypeTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return triggertypeTagFor(NORMALTRIGGER, h, td, hgflags);

}

static int filetriggertypeTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return triggertypeTagFor(FILETRIGGER, h, td, hgflags);

}

static int transfiletriggertypeTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return triggertypeTagFor(TRANSFILETRIGGER, h, td, hgflags);

}

/**

 * Retrieve installed file paths.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int instfilenamesTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return fnTag(h, RPMTAG_BASENAMES, 1, td);

}

/**

 * Retrieve file paths.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int filenamesTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return fnTag(h, RPMTAG_BASENAMES, 0, td);

}

/**

 * Retrieve original file paths (wrt relocation).

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int origfilenamesTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return fnTag(h, RPMTAG_ORIGBASENAMES, 0, td);

}

/*

 * Attempt to generate libmagic-style file class if missing from header:

 * we can easily generate this for symlinks and other special types.

 * Always return malloced strings to simplify life in fileclassTag().

 */

static char *makeFClass(rpmfi fi)

{

    char *fclass = NULL;

    const char *hc = rpmfiFClass(fi);

    if (hc != NULL && hc[0] != '\0') {

	fclass = xstrdup(hc);

    } else {

	switch (rpmfiFMode(fi) & S_IFMT) {

	case S_IFBLK:

	    fclass = xstrdup("block special");

	    break;

	case S_IFCHR:

	    fclass = xstrdup("character special");

	    break;

	case S_IFDIR:

	    fclass = xstrdup("directory");

	    break;

	case S_IFIFO:

	    fclass = xstrdup("fifo (named pipe)");

	    break;

	case S_IFSOCK:

	    fclass = xstrdup("socket");

	    break;

	case S_IFLNK:

	    fclass = rstrscat(NULL, "symbolic link to `",

			      rpmfiFLink(fi), "'", NULL);

	    break;

	}

    }

    return (fclass != NULL) ? fclass : xstrdup("");

}

/**

 * Retrieve/generate file classes.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int fileclassTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    rpmfi fi = rpmfiNew(NULL, h, RPMTAG_BASENAMES, RPMFI_NOHEADER);

    int numfiles = rpmfiFC(fi);

    if (numfiles > 0) {

	char **fclasses = xmalloc(numfiles * sizeof(*fclasses));

	int ix;

	rpmfiInit(fi, 0);

	while ((ix = rpmfiNext(fi)) >= 0) {

	    fclasses[ix] = makeFClass(fi);

	}

	td->data = fclasses;

	td->count = numfiles;

	td->flags = RPMTD_ALLOCED | RPMTD_PTR_ALLOCED;

	td->type = RPM_STRING_ARRAY_TYPE;

    }

    rpmfiFree(fi);

    return (numfiles > 0); 

}

/**

 * Retrieve file provides.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int fileprovideTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return filedepTag(h, RPMTAG_PROVIDENAME, td, hgflags);

}

/**

 * Retrieve file requires.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int filerequireTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return filedepTag(h, RPMTAG_REQUIRENAME, td, hgflags);

}

/**

 * Retrieve i18n text.

 * @param h		header

 * @param tag		tag

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int i18nTag(Header h, rpmTag tag, rpmtd td, headerGetFlags hgflags)

{

    int rc = headerGet(h, tag, td, HEADERGET_ALLOC);

#if defined(ENABLE_NLS)

    if (rc) {

	static const char * const _macro_i18ndomains = "%{?_i18ndomains}";

	char *de, *dstring = rpmExpand(_macro_i18ndomains, NULL);

	const char *domain;

	for (domain = dstring; domain != NULL; domain = de) {

	    const char *msgid = td->data;

	    const char *msg = NULL;

	    de = strchr(domain, ':');

	    if (de) *de++ = '\0';

	    msg = dgettext(domain, td->data);

	    if (msg != msgid) {

		free(td->data);

		td->data = xstrdup(msg);

		break;

	    }

	}

	free(dstring);

    }

#endif

    return rc;

}

/**

 * Retrieve summary text.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int summaryTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return i18nTag(h, RPMTAG_SUMMARY, td, hgflags);

}

/**

 * Retrieve description text.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int descriptionTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return i18nTag(h, RPMTAG_DESCRIPTION, td, hgflags);

}

/**

 * Retrieve group text.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int groupTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return i18nTag(h, RPMTAG_GROUP, td, hgflags);

}

/*

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

}

/**

 * Retrieve file sizes as 64bit regardless of how they're stored.

 * @param h		header

 * @retval td		tag data container

 * @param hgflags	header get flags

 * @return		1 on success

 */

static int longfilesizesTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return get64(h, td, RPMTAG_LONGFILESIZES, RPMTAG_FILESIZES);

}

static int longarchivesizeTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return get64(h, td, RPMTAG_LONGARCHIVESIZE, RPMTAG_ARCHIVESIZE);

}

static int longsizeTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return get64(h, td, RPMTAG_LONGSIZE, RPMTAG_SIZE);

}

static int longsigsizeTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return get64(h, td, RPMTAG_LONGSIGSIZE, RPMTAG_SIGSIZE);

}

static int numberTag(rpmtd td, uint32_t val)

{

    uint32_t *tval = xmalloc(sizeof(*tval));

    tval[0] = val;

    td->type = RPM_INT32_TYPE;

    td->count = 1;

    td->data = tval;

    td->flags = RPMTD_ALLOCED;

    return 1; /* this cannot fail */

}

static int dbinstanceTag(Header h, rpmtd td, headerGetFlags hgflags)

{

    return numberTag(td, headerGetInstance(h));

}

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

}

enum nevraFlags_e {

    NEVRA_NAME		= (1 << 0),

    NEVRA_EPOCH		= (1 << 1),

    NEVRA_VERSION	= (1 << 2),

    NEVRA_RELEASE	= (1 << 3),

    NEVRA_ARCH		= (1 << 4)

};

typedef rpmFlags nevraFlags;

static int getNEVRA(Header h, rpmtd td, nevraFlags flags)

{

    const char *val = NULL;

    char *res = xstrdup("");

    if ((flags & NEVRA_NAME)) {

	val = headerGetString(h, RPMTAG_NAME);

	if (val) rstrscat(&res, val, "-", NULL);

    }

    if ((flags & NEVRA_EPOCH)) {