/* ----------------------------------------------------------------------- *
 *   
 *  macros.c - module to handle macro substitution variables for map
 *		entries.
 * 
 *   Copyright 2006 Ian Kent <raven@themaw.net>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
 *   USA; either version 2 of the License, or (at your option) any later
 *   version; incorporated herein by reference.
 *
 * ----------------------------------------------------------------------- */

#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/utsname.h>
#include <unistd.h>

#include "automount.h"

static struct utsname un;
static char processor[65];		/* Not defined on Linux, so we make our own */
static char hostname[HOST_NAME_MAX + 1];
static char host[HOST_NAME_MAX];
static char domain[HOST_NAME_MAX];
static char hostd[HOST_NAME_MAX + 1];
static char endian[] = "unknown";

/* Predefined variables: tail of link chain */
static struct substvar
	sv_arch   = {"ARCH",   un.machine,  1, NULL },
	sv_cpu    = {"CPU",    processor,   1, &sv_arch},
	sv_host   = {"HOST",   un.nodename, 1, &sv_cpu},
	sv_osname = {"OSNAME", un.sysname,  1, &sv_host},
	sv_osrel  = {"OSREL",  un.release,  1, &sv_osname},
	sv_osvers = {"OSVERS", un.version,  1, &sv_osrel},
	sv_dollar = {"dollar", "$",         1, &sv_osvers},
	sv_true   = {"true",   "1",         1, &sv_dollar},
	sv_false  = {"false",  "0",         1, &sv_true},
	sv_byte	  = {"byte",   endian,	    1, &sv_false},
	sv_host2  = {"host",   host,        1, &sv_byte},
	sv_xhost  = {"xhost",  host,	    1, &sv_host2},
	sv_domain = {"domain", domain,      1, &sv_xhost},
	sv_hostd  = {"hostd",  hostd,       1, &sv_domain
};

static struct substvar *system_table = &sv_hostd;
static unsigned int macro_init_done = 0;

static pthread_mutex_t table_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t macro_mutex = PTHREAD_MUTEX_INITIALIZER;

void dump_table(struct substvar *table)
{
	struct substvar *lv = table;
	int status;

	status = pthread_mutex_lock(&table_mutex);
	if (status)
		fatal(status);

	while (lv) {
		logmsg("lv->def %s lv->val %s lv->next %p",
		      lv->def, lv->val, lv->next);
		lv = lv->next;
	}

	status = pthread_mutex_unlock(&table_mutex);
	if (status)
		fatal(status);
}

/* Get processor information for predefined macro definitions */
void macro_init(void)
{
	char *local_domain;

	memset(hostname, 0, HOST_NAME_MAX + 1);
	memset(host, 0, HOST_NAME_MAX);
	memset(domain, 0, HOST_NAME_MAX);
	memset(hostd, 0, HOST_NAME_MAX + 1);

	macro_lock();
	if (macro_init_done) {
		macro_unlock();
		return;
	}

	uname(&un);
	/*
	 * uname -p is not defined on Linux.  Make it the same as
	 * uname -m, except make it return i386 on all x86 (x >= 3)
	 */
	strcpy(processor, un.machine);
	if (processor[0] == 'i' && processor[1] >= '3' &&
		!strcmp(processor + 2, "86"))
		processor[1] = '3';

	local_domain = conf_amd_get_sub_domain();

	if (!gethostname(hostname, HOST_NAME_MAX)) {
		char *dot;
		dot = strchr(hostname, '.');
		if (dot) {
			*dot++ = '\0';
			strcpy(domain, dot);
		}
		strcpy(host, hostname);
		strcpy(hostd, host);
		if (*domain || local_domain) {
			strcat(hostd, ".");
			if (!local_domain)
				strcat(hostd, domain);
			else {
				strcat(hostd, local_domain);
				strcpy(domain, local_domain);
			}
		}
	}

	if (sizeof(short) == 2) {
		union { short s; char c[sizeof(short)]; } order;
		order.s = 0x0102;
		if (order.c[0] == 1 && order.c[1] == 2)
			strcpy(endian, "big");
		else if (order.c[0] == 2 && order.c[1] == 1)
			strcpy(endian, "little");
		else
			strcpy(endian, "unknown");
	}

	add_std_amd_vars(system_table);

	macro_init_done = 1;
	macro_unlock();
	free(local_domain);
	return;
}

int macro_is_systemvar(const char *str, int len)
{
	struct substvar *sv;
	int found = 0;
	int status;

	status = pthread_mutex_lock(&table_mutex);
	if (status)
		fatal(status);

	sv = system_table;

	while (sv) {
		if (!strncmp(str, sv->def, len) && sv->def[len] == '\0') {
			found = 1;
			break;
		}
		sv = sv->next;
	}

	status = pthread_mutex_unlock(&table_mutex);
	if (status)
		fatal(status);

	return found;
}

int macro_global_addvar(const char *str, int len, const char *value)
{
	struct substvar *sv;
	int status, ret = 0;

	status = pthread_mutex_lock(&table_mutex);
	if (status)
		fatal(status);

	sv = system_table;

	while (sv) {
		if (!strncmp(str, sv->def, len) && sv->def[len] == '\0')
			break;
		sv = sv->next;
	}

	if (sv && !sv->readonly) {
		char *this = malloc(strlen(value) + 1);
		if (!this)
			goto done;
		strcpy(this, value);
		free(sv->val);
		sv->val = this;
		ret = 1;
	} else {
		struct substvar *new;
		char *def, *val;

		def = strdup(str);
		if (!def)
			goto done;
		def[len] = '\0';

		val = strdup(value);
		if (!val) {
			free(def);
			goto done;
		}

		new = malloc(sizeof(struct substvar));
		if (!new) {
			free(def);
			free(val);
			goto done;
		}
		new->def = def;
		new->val = val;
		new->readonly = 0;
		new->next = system_table;
		system_table = new;
		ret =1;
	}
done:
	status = pthread_mutex_unlock(&table_mutex);
	if (status)
		fatal(status);

	return ret;
}

int macro_parse_globalvar(const char *define)
{
	char buf[MAX_MACRO_STRING];
	char *pbuf, *value;

	if (strlen(define) >= MAX_MACRO_STRING)
		return 0;

	strcpy(buf, define);

	pbuf = buf;
	while (pbuf) {
		if (*pbuf == '=') {
			*pbuf = '\0';
			value = pbuf + 1;
			break;
		}
		pbuf++;
	}

	/* Macro must have value */
	if (!pbuf)
		return 0;

	return macro_global_addvar(buf, strlen(buf), value);
}

void macro_lock(void)
{
	int status = pthread_mutex_lock(&macro_mutex);
	if (status)
		fatal(status);
}

void macro_unlock(void)
{
	int status = pthread_mutex_unlock(&macro_mutex);
	if (status)
		fatal(status);
}

struct substvar *
macro_addvar(struct substvar *table, const char *str, int len, const char *value)
{
	struct substvar *lv = table;

	while (lv) {
		if (!strncmp(str, lv->def, len) && lv->def[len] == '\0')
			break;
		lv = lv->next;
	}

	if (lv) {
		const char *val = value ? value : "";
		char *this = malloc(strlen(val) + 1);
		if (!this) {
			lv = table;
			goto done;
		}
		strcpy(this, val);
		free(lv->val);
		lv->val = this;
		if (lv != table)
			lv = table;
	} else {
		struct substvar *new;
		const char *this = value ? value : "";
		char *def, *val;

		def = strdup(str);
		if (!def) {
			lv = table;
			goto done;
		}
		def[len] = '\0';

		val = strdup(this);
		if (!val) {
			lv = table;
			free(def);
			goto done;
		}

		new = malloc(sizeof(struct substvar));
		if (!new) {
			lv = table;
			free(def);
			free(val);
			goto done;
		}
		new->def = def;
		new->val = val;
		new->readonly = 0;
		new->next = table;
		lv = new;
	}
done:

	return lv;
}

void macro_global_removevar(const char *str, int len)
{
	struct substvar *sv;
	struct substvar *last = NULL;
	int status;

	status = pthread_mutex_lock(&table_mutex);
	if (status)
		fatal(status);

	sv = system_table;

	while (sv) {
		if (!strncmp(str, sv->def, len) && sv->def[len] == '\0')
			break;
		last = sv;
		sv = sv->next;
	}

	if (sv && !sv->readonly) {
		if (last)
			last->next = sv->next;
		else
			system_table = sv->next;
		if (sv->def)
			free(sv->def);
		if (sv->val)
			free(sv->val);
		free(sv);
	}

	status = pthread_mutex_unlock(&table_mutex);
	if (status)
		fatal(status);

	return;
}

struct substvar *
macro_removevar(struct substvar *table, const char *str, int len)
{
	struct substvar *list, *lv;
	struct substvar *last = NULL;

	lv = list = table;

	while (lv) {
		if (!strncmp(str, lv->def, len) && lv->def[len] == '\0')
			break;
		last = lv;
		lv = lv->next;
	}

	if (lv) {
		if (last)
			last->next = lv->next;
		else
			list = lv->next;
		if (lv->def)
			free(lv->def);
		if (lv->val)
			free(lv->val);
		free(lv);
	}

	return list;
}

void macro_free_global_table(void)
{
	struct substvar *sv;
	struct substvar *next;
	int status;

	status = pthread_mutex_lock(&table_mutex);
	if (status)
		fatal(status);

	sv = system_table;

	while (sv) {
		if (sv->readonly) {
			sv = sv->next;
			continue;
		}
		next = sv->next;
		if (sv->def)
			free(sv->def);
		if (sv->val)
			free(sv->val);
		free(sv);
		sv = next;
	}

	system_table = &sv_osvers;

	status = pthread_mutex_unlock(&table_mutex);
	if (status)
		fatal(status);

	return;
}

void macro_free_table(struct substvar *table)
{
	struct substvar *lv = table;
	struct substvar *next;

	if (!lv)
		return;

	while (lv) {
		next = lv->next;
		if (lv->def)
			free(lv->def);
		if (lv->val)
			free(lv->val);
		free(lv);
		lv = next;
	}

	return;
}

/* Find the $-variable matching a certain string fragment */
const struct substvar *
macro_findvar(const struct substvar *table, const char *str, int len)
{
	const struct substvar *sv = system_table;
	const struct substvar *lv = table;
#ifdef ENABLE_EXT_ENV
	/* holds one env var */
	static struct substvar *lv_var;
	static char *value;
	char etmp[512];
#endif

	/* First try the passed in local table */
	while (lv) {
		if (!strncmp(str, lv->def, len) && lv->def[len] == '\0')
			return lv;
		lv = lv->next;
	}

	/* Then look in the system wide table */
	while (sv) {
		if (!strncmp(str, sv->def, len) && sv->def[len] == '\0')
			return sv;
		sv = sv->next;
	}

#ifdef ENABLE_EXT_ENV
	/* builtin and local map failed, try the $ENV */
	memcpy(etmp, str, len);
	etmp[len]='\0';

	if ((value=getenv(etmp)) != NULL) {
		lv_var = macro_addvar((struct substvar *) table, str, len, value);
		return(lv_var);
	}
#endif

	return NULL;
}

/* Set environment from macro variable table */
void macro_setenv(struct substvar *table)
{
	const struct substvar *sv = system_table;
	const struct substvar *lv = table;

	/*
	 * First set environment from global table, matching local
	 * variables will overwrite these.
	 */
	while (sv) {
		if (sv->def)
			setenv(sv->def, sv->val, 1);
		sv = sv->next;
	}

	/* Next set environment from the local table */
	while (lv) {
		if (lv->def)
			setenv(lv->def, lv->val, 1);
		lv = lv->next;
	}

	return;
}