#include "system.h"

#include <stdarg.h>

#include <pthread.h>

#if defined(__linux__)

#include <elf.h>

#include <link.h>

#endif

#if HAVE_SYS_UTSNAME_H

#include <sys/utsname.h>

#endif

#include <ctype.h>	/* XXX for /etc/rpm/platform contents */

#if HAVE_SYS_SYSTEMCFG_H

#include <sys/systemcfg.h>

#else

#define __power_pc() 0

#endif

#ifdef HAVE_SYS_AUXV_H

#include <sys/auxv.h>

#endif

#include <rpm/rpmlib.h>			/* RPM_MACTABLE*, Rc-prototypes */

#include <rpm/rpmmacro.h>

#include <rpm/rpmfileutil.h>

#include <rpm/rpmstring.h>

#include <rpm/rpmlog.h>

#include <rpm/argv.h>

#include "rpmio/rpmlua.h"

#include "rpmio/rpmio_internal.h"	/* XXX for rpmioSlurp */

#include "lib/misc.h"

#include "lib/rpmliblua.h"

#include "lib/rpmug.h"

#include "debug.h"

static const char * defrcfiles = NULL;

const char * macrofiles = NULL;

typedef struct machCacheEntry_s {

    char * name;

    int count;

    char ** equivs;

    int visited;

} * machCacheEntry;

typedef struct machCache_s {

    machCacheEntry cache;

    int size;

} * machCache;

typedef struct machEquivInfo_s {

    char * name;

    int score;

} * machEquivInfo;

typedef struct machEquivTable_s {

    int count;

    machEquivInfo list;

} * machEquivTable;

struct rpmvarValue {

    char * value;

    /* eventually, this arch will be replaced with a generic condition */

    char * arch;

struct rpmvarValue * next;

};

struct rpmOption {

    char * name;

    int var;

    int archSpecific;

    int macroize;

    int localize;

};

static struct rpmat_s {

    const char *platform;

    uint64_t hwcap;

} rpmat;

typedef struct defaultEntry_s {

    char * name;

    char * defName;

} * defaultEntry;

typedef struct canonEntry_s {

    char * name;

    char * short_name;

    short num;

} * canonEntry;

/* tags are 'key'canon, 'key'translate, 'key'compat

 *

 * for giggles, 'key'_canon, 'key'_compat, and 'key'_canon will also work

 */

typedef struct tableType_s {

    char * const key;

    const int hasCanon;

    const int hasTranslate;

    struct machEquivTable_s equiv;

    struct machCache_s cache;

    defaultEntry defaults;

    canonEntry canons;

    int defaultsLength;

    int canonsLength;

} * tableType;

/* XXX get rid of this stuff... */

/* Stuff for maintaining "variables" like SOURCEDIR, BUILDDIR, etc */

#define RPMVAR_OPTFLAGS                 3

#define RPMVAR_ARCHCOLOR                42

#define RPMVAR_INCLUDE                  43

#define RPMVAR_MACROFILES               49

#define RPMVAR_NUM                      55      /* number of RPMVAR entries */

/* this *must* be kept in alphabetical order */

/* The order of the flags is archSpecific, macroize, localize */

static const struct rpmOption optionTable[] = {

    { "archcolor",		RPMVAR_ARCHCOLOR,               1, 0, 0 },

    { "include",		RPMVAR_INCLUDE,			0, 0, 2 },

    { "macrofiles",		RPMVAR_MACROFILES,		0, 0, 1 },

    { "optflags",		RPMVAR_OPTFLAGS,		1, 1, 0 },

};

static const size_t optionTableSize = sizeof(optionTable) / sizeof(*optionTable);

#define OS	0

#define ARCH	1

typedef struct rpmrcCtx_s * rpmrcCtx;

struct rpmrcCtx_s {

    ARGV_t platpat;

    char *current[2];

    int currTables[2];

    struct rpmvarValue values[RPMVAR_NUM];

    struct tableType_s tables[RPM_MACHTABLE_COUNT];

    int machDefaults;

    int pathDefaults;

    pthread_rwlock_t lock;

};

/* prototypes */

static rpmRC doReadRC(rpmrcCtx ctx, const char * urlfn);

static void rpmSetVarArch(rpmrcCtx ctx,

			  int var, const char * val, const char * arch);

static void rebuildCompatTables(rpmrcCtx ctx, int type, const char * name);

static void rpmRebuildTargetVars(rpmrcCtx ctx, const char **target, const char ** canontarget);

/* Force context (lock) acquisition through a function */

static rpmrcCtx rpmrcCtxAcquire(int write)

{

    static struct rpmrcCtx_s _globalCtx = {

	.lock = PTHREAD_RWLOCK_INITIALIZER,

	.currTables = { RPM_MACHTABLE_INSTOS, RPM_MACHTABLE_INSTARCH },

	.tables = {

	    { "arch", 1, 0 },

	    { "os", 1, 0 },

	    { "buildarch", 0, 1 },

	    { "buildos", 0, 1 }

	},

    };

    rpmrcCtx ctx = &_globalCtx;

    /* XXX: errors should be handled */

    if (write)

	pthread_rwlock_wrlock(&ctx->lock);

    else

	pthread_rwlock_rdlock(&ctx->lock);

    return ctx;

}

/* Release context (lock) */

static rpmrcCtx rpmrcCtxRelease(rpmrcCtx ctx)

{

    pthread_rwlock_unlock(&ctx->lock);

    return NULL;

}

static int optionCompare(const void * a, const void * b)

{

    return rstrcasecmp(((const struct rpmOption *) a)->name,

		      ((const struct rpmOption *) b)->name);

}

static machCacheEntry

machCacheFindEntry(const machCache cache, const char * key)

{

    int i;

    for (i = 0; i < cache->size; i++)

	if (rstreq(cache->cache[i].name, key)) return cache->cache + i;

    return NULL;

}

static int machCompatCacheAdd(char * name, const char * fn, int linenum,

				machCache cache)

{

    machCacheEntry entry = NULL;

    char * chptr;

    char * equivs;

    int delEntry = 0;

    int i;

    while (*name && risspace(*name)) name++;

    chptr = name;

    while (*chptr && *chptr != ':') chptr++;

    if (!*chptr) {

	rpmlog(RPMLOG_ERR, _("missing second ':' at %s:%d\n"), fn, linenum);

	return 1;

    } else if (chptr == name) {

	rpmlog(RPMLOG_ERR, _("missing architecture name at %s:%d\n"), fn,

			     linenum);

	return 1;

    }

    while (*chptr == ':' || risspace(*chptr)) chptr--;

    *(++chptr) = '\0';

    equivs = chptr + 1;

    while (*equivs && risspace(*equivs)) equivs++;

    if (!*equivs) {

	delEntry = 1;

    }

    if (cache->size) {

	entry = machCacheFindEntry(cache, name);

	if (entry) {

	    for (i = 0; i < entry->count; i++)

		entry->equivs[i] = _free(entry->equivs[i]);

	    entry->equivs = _free(entry->equivs);

	    entry->count = 0;

	}

    }

    if (!entry) {

	cache->cache = xrealloc(cache->cache,

			       (cache->size + 1) * sizeof(*cache->cache));

	entry = cache->cache + cache->size++;

	entry->name = xstrdup(name);

	entry->count = 0;

	entry->visited = 0;

    }

    if (delEntry) return 0;

    while ((chptr = strtok(equivs, " ")) != NULL) {

	equivs = NULL;

	if (chptr[0] == '\0')	/* does strtok() return "" ever?? */

	    continue;

	if (entry->count)

	    entry->equivs = xrealloc(entry->equivs, sizeof(*entry->equivs)

					* (entry->count + 1));

	else

	    entry->equivs = xmalloc(sizeof(*entry->equivs));

	entry->equivs[entry->count] = xstrdup(chptr);

	entry->count++;

    }

    return 0;

}

static machEquivInfo

machEquivSearch(const machEquivTable table, const char * name)

{

    int i;

    for (i = 0; i < table->count; i++)

	if (!rstrcasecmp(table->list[i].name, name))

	    return table->list + i;

    return NULL;

}

static void machAddEquiv(machEquivTable table, const char * name,

			   int distance)

{

    machEquivInfo equiv;

    equiv = machEquivSearch(table, name);

    if (!equiv) {

	if (table->count)

	    table->list = xrealloc(table->list, (table->count + 1)

				    * sizeof(*table->list));

	else

	    table->list = xmalloc(sizeof(*table->list));

	table->list[table->count].name = xstrdup(name);

	table->list[table->count++].score = distance;

    }

}

static void machCacheEntryVisit(machCache cache,

		machEquivTable table, const char * name, int distance)

{

    machCacheEntry entry;

    int i;

    entry = machCacheFindEntry(cache, name);

    if (!entry || entry->visited) return;

    entry->visited = 1;

    for (i = 0; i < entry->count; i++) {

	machAddEquiv(table, entry->equivs[i], distance);

    }

    for (i = 0; i < entry->count; i++) {

	machCacheEntryVisit(cache, table, entry->equivs[i], distance + 1);

    }

}

static void machFindEquivs(machCache cache, machEquivTable table,

		const char * key)

{

    int i;

    for (i = 0; i < cache->size; i++)

	cache->cache[i].visited = 0;

    while (table->count > 0) {

	--table->count;

	table->list[table->count].name = _free(table->list[table->count].name);

    }

    table->count = 0;

    table->list = _free(table->list);

    /*

     *	We have a general graph built using strings instead of pointers.

     *	Yuck. We have to start at a point at traverse it, remembering how

     *	far away everything is.

     */

   	/* FIX: table->list may be NULL. */

    machAddEquiv(table, key, 1);

    machCacheEntryVisit(cache, table, key, 2);

    return;

}

static rpmRC addCanon(canonEntry * table, int * tableLen, char * line,

		    const char * fn, int lineNum)

{

    canonEntry t;

    char *s, *s1;

    const char * tname;

    const char * tshort_name;

    int tnum;

    (*tableLen) += 2;

    *table = xrealloc(*table, sizeof(**table) * (*tableLen));

    t = & ((*table)[*tableLen - 2]);

    tname = strtok(line, ": \t");

    tshort_name = strtok(NULL, " \t");

    s = strtok(NULL, " \t");

    if (! (tname && tshort_name && s)) {

	rpmlog(RPMLOG_ERR, _("Incomplete data line at %s:%d\n"),

		fn, lineNum);

	return RPMRC_FAIL;

    }

    if (strtok(NULL, " \t")) {

	rpmlog(RPMLOG_ERR, _("Too many args in data line at %s:%d\n"),

	      fn, lineNum);

	return RPMRC_FAIL;

    }

    tnum = strtoul(s, &s1, 10);

    if ((*s1) || (s1 == s) || (tnum == ULONG_MAX)) {

	rpmlog(RPMLOG_ERR, _("Bad arch/os number: %s (%s:%d)\n"), s,

	      fn, lineNum);

	return RPMRC_FAIL;

    }

    t[0].name = xstrdup(tname);

    t[0].short_name = (tshort_name ? xstrdup(tshort_name) : xstrdup(""));

    t[0].num = tnum;

    /* From A B C entry */

    /* Add  B B C entry */

    t[1].name = (tshort_name ? xstrdup(tshort_name) : xstrdup(""));

    t[1].short_name = (tshort_name ? xstrdup(tshort_name) : xstrdup(""));

    t[1].num = tnum;

    return RPMRC_OK;

}

static rpmRC addDefault(defaultEntry * table, int * tableLen, char * line,

			const char * fn, int lineNum)

{

    defaultEntry t;

    (*tableLen)++;

    *table = xrealloc(*table, sizeof(**table) * (*tableLen));

    t = & ((*table)[*tableLen - 1]);

    t->name = strtok(line, ": \t");

    t->defName = strtok(NULL, " \t");

    if (! (t->name && t->defName)) {

	rpmlog(RPMLOG_ERR, _("Incomplete default line at %s:%d\n"),

		 fn, lineNum);

	return RPMRC_FAIL;

    }

    if (strtok(NULL, " \t")) {

	rpmlog(RPMLOG_ERR, _("Too many args in default line at %s:%d\n"),

	      fn, lineNum);

	return RPMRC_FAIL;

    }

    t->name = xstrdup(t->name);

    t->defName = (t->defName ? xstrdup(t->defName) : NULL);

    return RPMRC_OK;

}

static canonEntry lookupInCanonTable(const char * name,

		const canonEntry table, int tableLen)

{

    while (tableLen) {

	tableLen--;

	if (!rstreq(name, table[tableLen].name))

	    continue;

	return &(table[tableLen]);

    }

    return NULL;

}

static

const char * lookupInDefaultTable(const char * name,

		const defaultEntry table, int tableLen)

{

    while (tableLen) {

	tableLen--;

	if (table[tableLen].name && rstreq(name, table[tableLen].name))

	    return table[tableLen].defName;

    }

    return name;

}

static void setDefaults(void)

{

    const char *confdir = rpmConfigDir();

    if (!defrcfiles) {

	defrcfiles = rstrscat(NULL, confdir, "/rpmrc", ":",

				confdir, "/" RPMCANONVENDOR "/rpmrc", ":",

				SYSCONFDIR "/rpmrc", ":",

			  	"~/.rpmrc", NULL);

    }

#ifndef MACROFILES

    if (!macrofiles) {

	macrofiles = rstrscat(NULL, confdir, "/macros", ":",

				confdir, "/macros.d/macros.*", ":",

				confdir, "/platform/%{_target}/macros", ":",

				confdir, "/fileattrs/*.attr", ":",

  				confdir, "/" RPMCANONVENDOR "/macros", ":",

				SYSCONFDIR "/rpm/macros.*", ":",

				SYSCONFDIR "/rpm/macros", ":",

				SYSCONFDIR "/rpm/%{_target}/macros", ":",

				"~/.rpmmacros", NULL);

    }

#else

    macrofiles = MACROFILES;

#endif

}

/* FIX: se usage inconsistent, W2DO? */

static rpmRC doReadRC(rpmrcCtx ctx, const char * urlfn)

{

    char *s;

    char *se, *next, *buf = NULL, *fn;

    int linenum = 0;

    struct rpmOption searchOption, * option;

    rpmRC rc = RPMRC_FAIL;

    fn = rpmGetPath(urlfn, NULL);

    if (rpmioSlurp(fn, (uint8_t **) &buf, NULL) || buf == NULL) {

	goto exit;

    }

    next = buf;

    while (*next != '\0') {

	linenum++;

	s = se = next;

	/* Find end-of-line. */

	while (*se && *se != '\n') se++;

	if (*se != '\0') *se++ = '\0';

	next = se;

	/* Trim leading spaces */

	while (*s && risspace(*s)) s++;

	/* We used to allow comments to begin anywhere, but not anymore. */

	if (*s == '#' || *s == '\0') continue;

	/* Find end-of-keyword. */

	se = (char *)s;

	while (*se && !risspace(*se) && *se != ':') se++;

	if (risspace(*se)) {

	    *se++ = '\0';

	    while (*se && risspace(*se) && *se != ':') se++;

	}

	if (*se != ':') {

	    rpmlog(RPMLOG_ERR, _("missing ':' (found 0x%02x) at %s:%d\n"),

		     (unsigned)(0xff & *se), fn, linenum);

	    goto exit;

	}

	*se++ = '\0';	/* terminate keyword or option, point to value */

	while (*se && risspace(*se)) se++;

	/* Find keyword in table */

	searchOption.name = s;

	option = bsearch(&searchOption, optionTable, optionTableSize,

			 sizeof(optionTable[0]), optionCompare);

	if (option) {	/* For configuration variables  ... */

	    const char *arch, *val;

	    arch = val = NULL;

	    if (*se == '\0') {

		rpmlog(RPMLOG_ERR, _("missing argument for %s at %s:%d\n"),

		      option->name, fn, linenum);

		goto exit;

	    }

	    if (option->var == RPMVAR_INCLUDE) {

		s = se;

		while (*se && !risspace(*se)) se++;

		if (*se != '\0') *se = '\0';

		if (doReadRC(ctx, s)) {

		    rpmlog(RPMLOG_ERR, _("cannot open %s at %s:%d: %m\n"),

			s, fn, linenum);

		    goto exit;

		}

		/* XXX don't save include value as var/macro */

		continue;

	    }

	    if (option->archSpecific) {

		arch = se;

		while (*se && !risspace(*se)) se++;

		if (*se == '\0') {

		    rpmlog(RPMLOG_ERR,

				_("missing architecture for %s at %s:%d\n"),

			  	option->name, fn, linenum);

		    goto exit;

		}

		*se++ = '\0';

		while (*se && risspace(*se)) se++;

		if (*se == '\0') {

		    rpmlog(RPMLOG_ERR,

				_("missing argument for %s at %s:%d\n"),

			  	option->name, fn, linenum);

		    goto exit;

		}

	    }

	    val = se;

	    /* Only add macros if appropriate for this arch */

	    if (option->macroize &&

	      (arch == NULL || rstreq(arch, ctx->current[ARCH]))) {

		char *n, *name;

		n = name = xmalloc(strlen(option->name)+2);

		if (option->localize)

		    *n++ = '_';

		strcpy(n, option->name);

		rpmPushMacro(NULL, name, NULL, val, RMIL_RPMRC);

		free(name);

	    }

	    rpmSetVarArch(ctx, option->var, val, arch);

	    fn = _free(fn);

	} else {	/* For arch/os compatibility tables ... */

	    int gotit;

	    int i;

	    gotit = 0;

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

		if (rstreqn(ctx->tables[i].key, s, strlen(ctx->tables[i].key)))

		    break;

	    }

	    if (i < RPM_MACHTABLE_COUNT) {

		const char *rest = s + strlen(ctx->tables[i].key);

		if (*rest == '_') rest++;

		if (rstreq(rest, "compat")) {

		    if (machCompatCacheAdd(se, fn, linenum,

						&ctx->tables[i].cache))

			goto exit;

		    gotit = 1;

		} else if (ctx->tables[i].hasTranslate &&

			   rstreq(rest, "translate")) {

		    if (addDefault(&ctx->tables[i].defaults,

				   &ctx->tables[i].defaultsLength,

				   se, fn, linenum))

			goto exit;

		    gotit = 1;

		} else if (ctx->tables[i].hasCanon &&

			   rstreq(rest, "canon")) {

		    if (addCanon(&ctx->tables[i].canons,

				 &ctx->tables[i].canonsLength,

				 se, fn, linenum))

			goto exit;

		    gotit = 1;

		}

	    }

	    if (!gotit) {

		rpmlog(RPMLOG_ERR, _("bad option '%s' at %s:%d\n"),

			    s, fn, linenum);

		goto exit;

	    }

	}

    }

    rc = RPMRC_OK;

exit:

    free(fn);

    free(buf);

    return rc;

}

/**

 */

static rpmRC rpmPlatform(rpmrcCtx ctx, const char * platform)

{

    const char *cpu = NULL, *vendor = NULL, *os = NULL, *gnu = NULL;

    uint8_t * b = NULL;

    ssize_t blen = 0;

    int init_platform = 0;

    char * p, * pe;

    rpmRC rc;

    rc = (rpmioSlurp(platform, &b, &blen) == 0) ? RPMRC_OK : RPMRC_FAIL;

    if (rc || b == NULL || blen <= 0) {

	rc = RPMRC_FAIL;

	goto exit;

    }

    p = (char *)b;

    for (pe = p; p && *p; p = pe) {

	pe = strchr(p, '\n');

	if (pe)

	    *pe++ = '\0';

	while (*p && isspace(*p))

	    p++;

	if (*p == '\0' || *p == '#')

	    continue;

	if (init_platform) {

	    char * t = p + strlen(p);

	    while (--t > p && isspace(*t))

		*t = '\0';

	    if (t > p) {

		argvAdd(&ctx->platpat, p);

	    }

	    continue;

	}

	cpu = p;

	vendor = "unknown";

	os = "unknown";

	gnu = NULL;

	while (*p && !(*p == '-' || isspace(*p)))

	    p++;

	if (*p != '\0') *p++ = '\0';

	vendor = p;

	while (*p && !(*p == '-' || isspace(*p)))

	    p++;

	if (*p != '-') {

	    if (*p != '\0') *p = '\0';

	    os = vendor;

	    vendor = "unknown";

	} else {

	    if (*p != '\0') *p++ = '\0';

	    os = p;

	    while (*p && !(*p == '-' || isspace(*p)))

		p++;

	    if (*p == '-') {

		*p++ = '\0';

		gnu = p;

		while (*p && !(*p == '-' || isspace(*p)))

		    p++;

	    }

	    if (*p != '\0') *p = '\0';

	}

	rpmPushMacro(NULL, "_host_cpu", NULL, cpu, -1);