#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <limits.h>

#include "config.h"

int lt_error_app(struct lt_config_app *cfg, struct lt_error_app *error_app)
{
	struct lt_error_app *app;
	struct lt_error_app_go *go, *g;
	struct lt_error_app_run *run, *r;

	if (!error_app->prog)
		return -EINVAL;

	app = malloc(sizeof(*app));
	if (!app)
		return -ENOMEM;

	/* XXX Just copy whatever we got from the bison app object,
	 * but afterwards we need to reinit all the lists, since
	 * it's based on the bison object.
	 * There's probably more sane way to have the app object
	 * dynamically allocated from the start.. let's wait for
	 * someone smart to do that ;) */

	*app = *error_app;

	lt_init_list_head(&app->head_run);
	lt_init_list_head(&app->head_go);
	lt_init_list_head(&app->list);

	lt_list_for_each_entry_safe(run, r, &error_app->head_run, list_app) {
		lt_list_del(&run->list_app);
		lt_list_add_tail(&run->list_app, &app->head_run);
	}

	lt_list_for_each_entry_safe(go, g, &error_app->head_go, list) {
		lt_list_del(&go->list);
		lt_list_add_tail(&go->list, &app->head_go);
	}

	lt_list_add_tail(&app->list, &cfg->error_apps);

	return 0;
}

int lt_error_set(struct lt_config_app *cfg, char *error)
{
	struct lt_error_app *app;
	int found = 0;

	lt_list_for_each_entry(app, &cfg->error_apps, list) {
		if (!strcmp(error, app->name)) {
			found = 1;
			break;
		}
	}

	if (!found)
		return -EINVAL;

	lt_sh(cfg, error_sim) = 1;
	cfg->error_app = app;
	return 0;
}

#define LT_DIR_PERM (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)

static int dir_get(struct lt_config_app *cfg, char *dir, int exist_check)
{
	struct stat st;

	PRINT_VERBOSE(cfg, 1, "exist_check %d, dir '%s'\n", exist_check, dir);

	if (!stat(dir, &st)) {
		if (exist_check) {
			printf("failed: directory already exists '%s'\n", dir);
			return -EEXIST;
		}

		/* TODO permission check */
		return 0;
	}

	if (mkdir(dir, LT_DIR_PERM)) {
		PRINT_VERBOSE(cfg, 1, "failed to create directory '%s'\n",
			      dir);
		/* XXX some sensiblle return value ;) */
		return -1;
	}

	return 0;
}

static int dir_base_name(struct lt_config_app *cfg,
			 char *buf, int len,
			 char *dir, char *prog)
{
	char file[LT_MAXFILE];
	char *last_bs;
	int size;

	PRINT_VERBOSE(cfg, 1, "dir '%s', prog '%s'\n", dir, prog);

	last_bs = strrchr(prog, '/');
	if (last_bs) {
		/* move behind '/' */
		last_bs++;

		/* endup with '/' isnt nice */
		if (!strlen(last_bs))
			return 0;

		size = snprintf(file, LT_MAXFILE, "%s", last_bs);
	} else
		size = snprintf(file, LT_MAXFILE, "%s", prog);

	PRINT_VERBOSE(cfg, 1, "file '%s'\n", file);

	if (size == LT_MAXFILE)
		return 0;

	size = snprintf(buf, len, "%s/latrace-%s/", dir, file);
	if (size == len)
		return 0;

	PRINT_VERBOSE(cfg, 1, "main dir '%s'\n", buf);
	return size;
}

static int dir_base(struct lt_config_app *cfg, struct lt_error_app *app, char *dir)
{
	int size;
	int ret;

	/* We dont create parents, just one level..
	 * whatever pass mkdir ;) */
	if (dir_get(cfg, app->dir, 0))
		return -1;

	size = dir_base_name(cfg, dir, LT_MAXFILE, app->dir, app->prog);
	if (!size)
		return -1;

	if (dir_get(cfg, dir, 0))
		return -1;

	size = snprintf(dir + size , LT_MAXFILE, "latest");
	if (size == LT_MAXFILE)
		return -1;

	ret = dir_get(cfg, dir, 1);
	if (ret == -EEXIST) {
		/* TODO move latest */
		return -1;
	} else if (ret != 0) {
		return ret;
	}

	return 0;
}

static int dir_go(struct lt_config_app *cfg,
		    char *dir, char *dir_base,
		    struct lt_error_app_go *go)
{
	int size;

	size = snprintf(dir, LT_MAXFILE, "%s/GO-%s/", dir_base, go->name);
	if (size == LT_MAXFILE)
		return -1;

	if (dir_get(cfg, dir, 0))
		return -1;

	return 0;
}

static int dir_run(struct lt_config_app *cfg,
		     char *dir, char *dir_base,
		     struct lt_error_app_run *run, int n)
{
	int size;

	size = snprintf(dir, LT_MAXFILE, "%s/RUN-%s-%05d/", dir_base, run->name, n);
	if (size == LT_MAXFILE)
		return -1;

	if (dir_get(cfg, dir, 0))
		return -1;

	return 0;
}

static int prepare_config_trace(struct lt_config_app *cfg, char *dir)
{
	FILE *f;

	snprintf(lt_sh(cfg, output), LT_MAXFILE, "%s/trace", dir);

	PRINT_VERBOSE(cfg, 1, "trace file %s\n", lt_sh(cfg, output));

	/* If the pipe mode is on, the latrace itself is doing the
	 * the trace output to the file, we need to open the output
	 * file each run */
	if (lt_sh(cfg, pipe)) {

		f = fopen(lt_sh(cfg, output), "w");
		if (!f) {
			perror("pipe mode: failed to open output file");
			return -1;
		}

		lt_sh(cfg, fout) = f;
		PRINT_VERBOSE(cfg, 1, "trace file pipe enabled\n");
	}

	return 0;
}

static int prepare_config_stat(struct lt_config_app *cfg, char *dir)
{
	char stat_file[LT_MAXFILE];
	FILE *f;

	snprintf(stat_file, LT_MAXFILE, "%s/stat", dir);
	f = fopen(stat_file, "w");
	if (!f) {
		perror("failed to open stat file");
		return -1;
	}

	cfg->fstat = f;

	PRINT_VERBOSE(cfg, 1, "stat file %s\n", stat_file);
	return 0;
}

static int prepare_config_tty(struct lt_config_app *cfg, char *dir)
{
	cfg->output_tty = 1;
	cfg->output_tty_fd = -1;
	snprintf(cfg->output_tty_file, LT_MAXFILE, "%s/tty-output", dir);

	PRINT_VERBOSE(cfg, 1, "tty output file %s\n", cfg->output_tty_file);
	return 0;
}

static int prepare_config_args(struct lt_config_app *cfg,
			       struct lt_error_app *app,
			       struct lt_error_app_run *run)
{
	int i = 1, size;
	char **arg = run->args;
#define BUFSIZE 4096
	char buf[BUFSIZE];

	cfg->prog   = app->prog;
	cfg->arg[0] = app->prog;

	size = snprintf(buf, BUFSIZE, "%s", app->prog);

	while(arg && *arg && (i < LT_NUM_ARG)) {
		PRINT_VERBOSE(cfg, 1, "arg: %s\n", *arg);
		size += snprintf(buf + size, BUFSIZE, " %s", *arg);
		cfg->arg[i++] = *arg++;
	}

	PRINT_VERBOSE(cfg, 1, "args: %s\n", buf);
	return 0;
}

static int prepare_config_error(struct lt_config_app *cfg,
			        struct lt_error_app_run *run,
			        int n)
{
	struct lt_error_app_return *ret;
	struct lt_error_config *cfg_err;
	int sym_cnt = 0;

	/* get the nymber of configured symbols */
	lt_list_for_each_entry(ret, &run->head_return, list_run) {
		struct lt_error_app_return_sym *sym;
		lt_list_for_each_entry(sym, &ret->head_sym, list)
			sym_cnt++;
	}

	PRINT_VERBOSE(cfg, 1, "number of symbols %d\n", sym_cnt);

	cfg_err = malloc(sizeof(*cfg_err) +
			 sym_cnt * sizeof(struct lt_error_config_sym));
	if (!cfg_err)
		return -ENOMEM;

	cfg_err->sym_cnt = sym_cnt;
	cfg_err->n = n;

	sym_cnt = 0;

	lt_list_for_each_entry(ret, &run->head_return, list_run) {
		struct lt_error_app_return_sym *sym;

		lt_list_for_each_entry(sym, &ret->head_sym, list) {
			struct lt_error_config_sym *cfg_sym;

			cfg_sym = &cfg_err->sym[sym_cnt++];
			strncpy(cfg_sym->symbol, sym->name, LT_MAXNAME);
			cfg_sym->ret = sym->val;
			cfg_sym->filter.type = ret->filter.type;
			cfg_sym->handle_sigsegv = sym->handle_sigsegv;

			PRINT_VERBOSE(cfg, 1, "symbol %s, ret %s\n",
					sym->name, sym->val);
		}
	}

	cfg->error_config = cfg_err;
	return 0;
}

static int prepare_config(struct lt_config_app *cfg, char *dir,
			  struct lt_error_app *app,
			  struct lt_error_app_run *run, int n)
{
	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	if (!app->no_storage) {
		if (prepare_config_trace(cfg, dir))
			return -1;

		if (prepare_config_stat(cfg, dir))
			return -1;

		if (prepare_config_tty(cfg, dir))
			return -1;
	}

	if (prepare_config_args(cfg, app, run))
		return -1;

	if (prepare_config_error(cfg, run, n))
		return -1;

	return 0;
}

static void post_config(struct lt_config_app *cfg,
			struct lt_error_app *app)
{
	if (!app->no_storage) {
		if ((lt_sh(cfg, pipe)) && (*lt_sh(cfg, output)))
			fclose(lt_sh(cfg, fout));

		fclose(cfg->fstat);
	}
}

static int process_run(struct lt_config_app *cfg,
		       char *dir_base,
		       struct lt_error_app *app,
		       struct lt_error_app_go *go,
		       struct lt_error_app_run *run,
		       int n)
{
	static char dir[LT_MAXFILE];

	if (!app->no_storage &&
	    dir_run(cfg, dir, dir_base, run, n))
		return -1;

	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	if (prepare_config(cfg, dir, app, run, n))
		return -1;

	if (app->no_storage)
		printf("latrace error simulation [%s] n = %d\n", app->name, n);

	lt_run(cfg);

	post_config(cfg, app);

	return 0;
}

static int automated_get_all_syms(struct lt_config_app *cfg,
				  struct lt_error_app_go *go)
{
	struct lt_list_head *sym_all = &cfg->error_symbols_all;
	struct lt_error_app_run *run;
	int count = 0, runs = 1;

	lt_list_for_each_entry(run, &go->head_run, list_go) {
		struct lt_error_app_return *ret;

		if (!runs--) {
			PRINT_VERBOSE(cfg, 1,
				"failed: supporting only single RUN within AUTOMATED go\n");
			return -1;
		}

		lt_list_for_each_entry(ret, &run->head_return, list_run) {
			struct lt_error_app_return_sym *sym;

			lt_list_for_each_entry(sym, &ret->head_sym, list) {
				lt_list_move_tail(&sym->list, sym_all);
				count++;
			}
		}
	}

	PRINT_VERBOSE(cfg, 1, "got %d symbols\n", count);
	return count;
}

long automated_get_index(struct lt_config_app *cfg,
			 struct lt_fifo_mbase *mbase)
{
	struct lt_fifo_msym *msym = (struct lt_fifo_msym*) mbase;
	return msym->info;
}

static char *automated_get_symname(struct lt_config_app *cfg,
				   struct lt_fifo_mbase *mbase)
{
	struct lt_fifo_msym *msym = (struct lt_fifo_msym*) mbase;
	return msym->data + msym->sym;
}

static struct lt_error_app_return_sym*
automated_find_symbol_all(struct lt_config_app *cfg, char *symname)
{
	struct lt_error_app_return_sym *sym;
	struct lt_list_head *sym_all = &cfg->error_symbols_all;

	/* TODO hash, hash, hash... and hash again .. pleaeease ;) hash! */
	lt_list_for_each_entry(sym, sym_all, list)
		if (!strcmp(sym->name, symname))
			return sym;

	return NULL;
}

static int automated_add_symbol_current(struct lt_config_app *cfg,
					struct lt_error_app_return_sym *sym_orig)
{
	struct lt_error_app_return_sym *sym;

	sym = malloc(sizeof(*sym));
	if (!sym)
		return -1;

	*sym = *sym_orig;

	sym->keep = 1;
	sym->val_idx = 0;

	lt_list_add_tail(&sym->list, &cfg->error_symbols_current);
	return 0;
}

static int process_run_automated_cb(struct lt_config_app *cfg,
				    struct lt_thread *t,
				    struct lt_fifo_mbase *mbase)
{
	struct lt_error_app_return_sym *sym;
	struct lt_error_config *error_config;
	char *symname;
	long index;

	if (mbase->type != LT_FIFO_MTYPE_EXIT)
		return 0;

	index = automated_get_index(cfg, mbase);
	error_config = cfg->error_config;

	if (cfg->error_automated_symbol_index < error_config->sym_cnt) {
		if (index != -1)
			BUG_ON((cfg->error_automated_symbol_index + 1) != index);
			cfg->error_automated_symbol_index = index;
		return 0;
	}

	symname = automated_get_symname(cfg, mbase);
	sym = automated_find_symbol_all(cfg, symname);
	if (!sym)
		return 0;

	if (automated_add_symbol_current(cfg, sym))
		return -1;

	return 0;
}

static int prepare_config_symbols_automated(struct lt_config_app *cfg)
{
	struct lt_list_head *sym_current = &cfg->error_symbols_current;

	while (!lt_list_empty(sym_current)) {
		struct lt_error_app_return_sym *last;

		last = lt_list_last_entry(sym_current,
					  struct lt_error_app_return_sym,
					  list);

		PRINT_VERBOSE(cfg, 1, "last %s\n", last->name);

		if (last->keep) {
			int idx = last->val_idx;
			last->keep = 0;

			PRINT_VERBOSE(cfg, 1, "from keep to vals[%d] = %llu\n",
				      idx, last->vals[idx]);
			break;
		} else {
			int idx = last->val_idx + 1;

			if (idx < last->val_cnt) {
				last->val_idx = idx;

				PRINT_VERBOSE(cfg, 1, "from vals[%d] = %llu to vals[%d] = %llu\n",
					      idx - 1, last->vals[idx - 1],
					      idx, last->vals[idx]);
				break;
			}

			PRINT_VERBOSE(cfg, 1, "removing\n");
			lt_list_del(&last->list);
		}
	}

	/* nothing more to try, we are done */
	if (lt_list_empty(sym_current)) {
		PRINT_VERBOSE(cfg, 1, "FINISHED\n");
		cfg->error_automated_finished = 1;
		return 0;
	}

	return 0;
}

static int prepare_config_error_automated(struct lt_config_app *cfg,
					  struct lt_error_app_run *run)
{
	struct lt_list_head *sym_current = &cfg->error_symbols_current;
	struct lt_error_app_return_sym *sym;
	struct lt_error_config *cfg_err;
	int sym_cnt = 0;

	lt_list_for_each_entry(sym, sym_current, list)
		sym_cnt++;

	BUG_ON(sym_cnt);

	PRINT_VERBOSE(cfg, 1, "number of symbols %d\n", sym_cnt);

	cfg_err = malloc(sizeof(*cfg_err) +
			 sym_cnt * sizeof(struct lt_error_config_sym));
	if (!cfg_err)
		return -ENOMEM;

	cfg_err->sym_cnt = sym_cnt;
	cfg_err->automated = 1;

	sym_cnt = 0;

	lt_list_for_each_entry(sym, sym_current, list) {
		struct lt_error_config_sym *cfg_sym;

		cfg_sym = &cfg_err->sym[sym_cnt++];
		strncpy(cfg_sym->symbol, sym->name, LT_MAXNAME);
		cfg_sym->ret = sym->vals[sym->val_idx];
		cfg_sym->keep = sym->keep;
		cfg_sym->handle_sigsegv = sym->handle_sigsegv;

		PRINT_VERBOSE(cfg, 1, "symbol %s, ret %s\n",
				sym->name, cfg_sym->ret);
	}

	cfg->error_config = cfg_err;
	return 0;
}

static int prepare_config_automated(struct lt_config_app *cfg,
				    char *dir,
				    struct lt_error_app *app,
				    struct lt_error_app_run *run,
				    int n)
{
	if (prepare_config_trace(cfg, dir))
		return -1;

	if (prepare_config_stat(cfg, dir))
		return -1;

	if (prepare_config_tty(cfg, dir))
		return -1;

	if (prepare_config_args(cfg, app, run))
		return -1;

	/* omit the first run */
	if (n && prepare_config_symbols_automated(cfg))
		return -1;

	if (prepare_config_error_automated(cfg, run))
		return -1;

	return 0;
}

static void automated_dump_config(struct lt_config_app *cfg,
				  struct lt_error_app *app,
				  char *dir)
{
	/* dump config to be replayed with REPLAY */
}

static void post_config_automated(struct lt_config_app *cfg,
				  struct lt_error_app *app,
				  char *dir)
{
	post_config(cfg, app);
	automated_dump_config(cfg, app, dir);
	free(cfg->error_config);
}

static int process_run_automated(struct lt_config_app *cfg,
				 char *dir_base,
				 struct lt_error_app *app,
				 struct lt_error_app_run *run)
{
	static char dir[LT_MAXFILE];
	int n = 0;

	if (lt_process_register(cfg, process_run_automated_cb))
		return -1;

	while(1) {
		if (dir_run(cfg, dir, dir_base, run, n))
			break;

		if (prepare_config_automated(cfg, dir, app, run, n))
			break;

		if (cfg->error_automated_finished)
			break;

		lt_run(cfg);

		post_config_automated(cfg, app, dir);

		n++;
	}

	BUG_ON(lt_process_unregister(cfg, process_run_automated_cb));

	return cfg->error_automated_finished ? 0 : -1;
}

static int process_go_automated(struct lt_config_app *cfg, char *dir,
				struct lt_error_app *app,
				struct lt_error_app_go *go)
{
	struct lt_error_app_run *run;

	if (!automated_get_all_syms(cfg, go) <= 0)
		return -1;

	run = lt_list_first_entry(&go->head_run, struct lt_error_app_run, list_go);

	if (process_run_automated(cfg, dir, app, run))
		PRINT_VERBOSE(cfg, 1, "failed: AUTOMATED run %s\n", run->name);

	return 0;
}

static int process_go_replay(struct lt_config_app *cfg, char *dir,
			     struct lt_error_app *app,
			     struct lt_error_app_go *go)
{
	return 0;
}

static int process_go_configured(struct lt_config_app *cfg, char *dir,
				 struct lt_error_app *app,
				 struct lt_error_app_go *go)
{
	int i;

	PRINT_VERBOSE(cfg, 1, "dir '%s', name %s, start %d, n %d\n",
			dir, go->name, go->start, go->n);

	for(i = go->start; i < (go->start + go->n); i++) {
		struct lt_error_app_run *run;

		lt_list_for_each_entry(run, &go->head_run, list_go)
			if (process_run(cfg, dir, app, go, run, i))
				return -1;
	}

	return 0;
}

static int process_go(struct lt_config_app *cfg, char *dir_base,
		      struct lt_error_app *app,
		      struct lt_error_app_go *go)
{
	static char dir[LT_MAXFILE];

	if (!app->no_storage &&
	    dir_go(cfg, dir, dir_base, go))
		return -1;

	/* automated processing.. God save us */
	if (go->automated)
		return process_go_automated(cfg, dir, app, go);

	/* exact symbols return replay */
	if (go->replay)
		return process_go_replay(cfg, dir, app, go);

	/* Whatever user configuration wants.. */
	return process_go_configured(cfg, dir, app, go);
}

int lt_error_run(struct lt_config_app *cfg)
{
	struct lt_error_app *app = cfg->error_app;
	struct lt_error_app_go *go;
	static char dir[LT_MAXFILE];

	printf("latrace error simulation [%s]\n", app->name);

	if (!app->no_storage &&
	    dir_base(cfg, app, dir))
		return -1;

	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	lt_list_for_each_entry(go, &app->head_go, list) {
		if (process_go(cfg, dir, app, go))
			return -1;
	}

	return 0;
}

static struct lt_error_app_run *app_run_get(struct lt_config_app *cfg,
					    struct lt_error_app_run **run)
{

	PRINT_VERBOSE(cfg, 1, "run %p\n", *run);

	if (!*run) {
		struct lt_error_app_run *app_run;

		app_run = malloc(sizeof(*app_run));
		if (!app_run)
			return NULL;

		bzero(app_run, sizeof(*app_run));
		lt_init_list_head(&app_run->head_return);
		lt_init_list_head(&app_run->list_go);
		lt_init_list_head(&app_run->list_app);

		*run = app_run;
		PRINT_VERBOSE(cfg, 1, "new %p\n", *run);
	}

	return *run;
}

static struct lt_error_app_return*
find_return(struct lt_config_app *cfg,
	    struct lt_error_app *error_app,
	    char *name)
{
	struct lt_error_app_return *ret;

	PRINT_VERBOSE(cfg, 1, "looking for %s\n", name);

	lt_list_for_each_entry(ret, &error_app->head_return, list_app) {

		PRINT_VERBOSE(cfg, 2, "got %s\n", ret->name);

		if (!strcmp(name, ret->name)) {
			PRINT_VERBOSE(cfg, 2, "FOUND\n");
			return ret;
		}
	}

	PRINT_VERBOSE(cfg, 1, "NOT FOUND\n");
	return NULL;
}

int lt_error_run_return(struct lt_config_app *cfg,
			struct lt_error_app_run **run,
			struct lt_error_app *error_app,
			struct lt_list_head *rets)
{
	struct lt_error_app_run *app_run = app_run_get(cfg, run);
	struct lt_config_ln *ln, *h;

	if (!app_run)
		return -ENOMEM;

	PRINT_VERBOSE(cfg, 1, "run %s\n", app_run->name);

	lt_list_for_each_entry_safe(ln, h, rets, list) {
		struct lt_error_app_return *ret;

		ret = find_return(cfg, error_app, ln->name);
		if (!ret)
			return -EINVAL;

		PRINT_VERBOSE(cfg, 1, "return %s, empty %d\n",
			      ret->name, lt_list_empty(&ret->list_run));

		/* TODO Allow more than 1 RETURN assignment to RUN,
		 * so far only one assignment is allowed.  */
		if (!lt_list_empty(&ret->list_run))
			return -EINVAL;

		lt_list_add_tail(&ret->list_run, &app_run->head_return);

		lt_list_del(&ln->list);
                free(ln->name);
                free(ln);
	}

	return 0;
}

int lt_error_run_args(struct lt_config_app *cfg,
		      struct lt_error_app_run **run,
		      struct lt_list_head *head)
{
	struct lt_error_app_run *app_run = app_run_get(cfg, run);
	char **args = NULL;

	if (!app_run)
		return -ENOMEM;

	/* only one ARGS definition perf RUN */
	if (app_run->args)
		return -EINVAL;

	args = lt_config_ln_fill_array(head);
	if (!args)
		return -ENOMEM;

	PRINT_VERBOSE(cfg, 1, "args %p\n", args);

	app_run->args = args;
	return 0;
}

static struct lt_error_app_run *find_run(struct lt_config_app *cfg,
					 struct lt_error_app *error_app,
					 char *name)
{
	struct lt_error_app_run *run;

	PRINT_VERBOSE(cfg, 1, "looking for %s\n", name);

	lt_list_for_each_entry(run, &error_app->head_run, list_app) {

		PRINT_VERBOSE(cfg, 2, "got %s\n", run->name);

		if (!strcmp(name, run->name)) {
			PRINT_VERBOSE(cfg, 2, "FOUND\n");
			return run;
		}
	}

	PRINT_VERBOSE(cfg, 1, "NOT FOUND\n");
	return NULL;
}

int lt_error_go(struct lt_config_app *cfg,
		struct lt_error_app_go **go,
		struct lt_error_app *error_app,
		char *name, int start, int n,
		int automated, int replay,
		struct lt_list_head *runs)
{
	struct lt_error_app_go *app_go = *go;
	struct lt_config_ln *ln, *h;

	if (app_go)
		return -EINVAL;

	app_go = malloc(sizeof(*app_go));
	bzero(app_go, sizeof(*app_go));
	lt_init_list_head(&app_go->head_run);
	lt_init_list_head(&app_go->list);

	app_go->n = n;
	app_go->start = start;
	app_go->name = name;
	app_go->automated = automated;
	app_go->replay = replay;

	lt_list_for_each_entry_safe(ln, h, runs, list) {
		struct lt_error_app_run *run;

		run = find_run(cfg, error_app, ln->name);
		if (!run)
			return -EINVAL;

		PRINT_VERBOSE(cfg, 1, "run %s, empty %d\n",
			      run->name, lt_list_empty(&run->list_go));

		/* TODO Allow more than 1 RUN assignment to GO,
		 * so far only one assignment is allowed.  */
		if (!lt_list_empty(&run->list_go))
			return -EINVAL;

		lt_list_add_tail(&run->list_go, &app_go->head_run);

		lt_list_del(&ln->list);
                free(ln->name);
                free(ln);
	}

	*go = app_go;
	return 0;
}

static struct lt_error_app_return*
app_return_get(struct lt_config_app *cfg, struct lt_error_app_return **ret)
{
	if (!*ret) {
		struct lt_error_app_return *app_return;

		app_return = malloc(sizeof(*app_return));
		if (!app_return)
			return NULL;

		bzero(app_return, sizeof(*app_return));
		lt_init_list_head(&app_return->head_sym);
		lt_init_list_head(&app_return->list_app);
		lt_init_list_head(&app_return->list_run);

		*ret = app_return;
		PRINT_VERBOSE(cfg, 1, "new %p\n", *ret);
	}

	return *ret;
}

int lt_error_return_ass(struct lt_config_app *cfg,
			struct lt_error_app_return **ret,
			char *name, struct lt_list_head *list_vals,
			int handle_sigsegv, int keep)
{
	struct lt_error_app_return *app_ret = app_return_get(cfg, ret);
	struct lt_error_app_return_sym *sym;
	struct lt_config_ln *ln, *h;
	int vals_cnt = 0;

	if (!app_ret)
		return -ENOMEM;

	sym = malloc(sizeof(*sym));
	if (!sym)
		return -ENOMEM;

	sym->name = strdup(name);
	sym->handle_sigsegv = handle_sigsegv;
	sym->keep = keep;

	/* process return values name list */
	lt_list_for_each_entry_safe(ln, h, list_vals, list) {

		if (vals_cnt == LT_MAX_SYM_RETURNS) {
			PRINT_VERBOSE(cfg, 1,
				"failed: too many return values for (%d allowed) for symbol %s\n",
				LT_MAX_SYM_RETURNS, name);
			return -1;
		}

		BUG_ON(ln->type != LT_CONFIG_LN_VALUE);

		sym->vals[vals_cnt++] = ln->val;

		lt_list_del(&ln->list);
		free(ln);
	}

	sym->val_cnt = vals_cnt;

	PRINT_VERBOSE(cfg, 1, "%s = %ld, handle_sigsegv = %d, keep %d\n",
		      sym->name, sym->val, handle_sigsegv, keep);

	if (vals_cnt > 1) {
		int i;

		for(i = 0; i < vals_cnt; i++)
			PRINT_VERBOSE(cfg, 1,
				"\tret[%d] = %lu\n",
				i, sym->vals[i]);
	}

	/* It's essential we keep the user
	 * defined sequenece of symbols. */
	lt_list_add_tail(&sym->list, &app_ret->head_sym);
        return 0;
}

int lt_error_return_filter(struct lt_config_app *cfg,
                           struct lt_error_app_return **ret,
                           int type, void *data)
{
	struct lt_error_app_return *app_ret = app_return_get(cfg, ret);

	if (!app_ret)
		return -ENOMEM;

	app_ret->filter.type = type;
	PRINT_VERBOSE(cfg, 1, "type %d\n", type);
        return 0;
}


int lt_error_app_init(struct lt_error_app *app)
{
	bzero(app, sizeof(*app));
	lt_init_list_head(&app->head_run);
	lt_init_list_head(&app->head_go);
	lt_init_list_head(&app->head_return);
	lt_init_list_head(&app->list);
	app->no_storage = 1;
	return 0;
}

int lt_error_config_write(struct lt_config_app *cfg, int fd)
{
	struct lt_error_config *cfg_err = cfg->error_config;
	int size = sizeof(struct lt_error_config);

	BUG_ON(!cfg_err);

	size += cfg_err->sym_cnt * sizeof(struct lt_error_config_sym);

	if (size != write(fd, cfg_err, size)) {
		perror("write failed");
		return -1;
	}

	return 0;
}