/*
 * Copyright (C) 2014 Philippe Gerum <rpm@xenomai.org>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <boilerplate/ancillaries.h>
#include <smokey/smokey.h>

int smokey_int(const char *s, struct smokey_arg *arg)
{
	char *name, *p;
	int ret;

	ret = sscanf(s, "%m[_a-z]=%m[^\n]", &name, &p);
	if (ret != 2 || !(isdigit(*p) || *p == '-'))
		return 0;

	ret = !strcmp(name, arg->name);
	if (ret)
		arg->u.n_val = atoi(p);

	free(p);
	free(name);

	return ret;
}

int smokey_bool(const char *s, struct smokey_arg *arg)
{
	int ret;

	ret = smokey_int(s, arg);
	if (ret) {
		arg->u.n_val = !!arg->u.n_val;
		return 1;
	}

	if (strcmp(s, arg->name) == 0) {
		arg->u.n_val = 1;
		return 1;
	}

	return 0;
}

int smokey_string(const char *s, struct smokey_arg *arg)
{
	char *name, *p;
	int ret;

	ret = sscanf(s, "%m[_a-z]=%m[^\n]", &name, &p);
	if (ret != 2)
		return 0;

	ret = !strcmp(name, arg->name);
	if (ret)
		arg->u.s_val = p;
	else
		free(p);

	free(name);

	return ret;
}

int smokey_size(const char *s, struct smokey_arg *arg)
{
	char *name, *p;
	int ret;

	ret = sscanf(s, "%m[_a-z]=%m[^\n]", &name, &p);
	if (ret != 2)
		return 0;

	ret = !strcmp(name, arg->name);
	if (ret) {
		arg->u.l_val = get_mem_size(p);
		if (arg->u.l_val == 0)
			ret = 0;
	}

	free(p);
	free(name);

	return ret;
}

int smokey_parse_args(struct smokey_test *t,
		      int argc, char *const argv[])
{
	int matched = 0, n, ac;
	struct smokey_arg *arg;

	for (arg = t->args, ac = 0;
	     arg->name && ac < t->nargs; arg++, ac++) {
		for (n = 1; n < argc; n++) {
			arg->matched = !!arg->parser(argv[n], arg);
			if (arg->matched) {
				matched++;
				break;
			}
		}
	}

	return matched;
}

struct smokey_arg *smokey_lookup_arg(struct smokey_test *t,
				     const char *name)
{
	struct smokey_arg *arg = NULL;
	int ac;

	for (arg = t->args, ac = 0;
	     arg->name && ac < t->nargs; arg++, ac++) {
		if (strcmp(arg->name, name) == 0)
			return arg;
	}

	/* Assume this is fatal. */
	panic("test %s has no argument \"%s\"",
	      t->name, name);
}

void smokey_note(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);

	if (smokey_verbose_mode) {
		__RT(vfprintf(stdout, fmt, ap));
		__RT(fprintf(stdout, "\n"));
	}

	va_end(ap);
}

void smokey_vatrace(const char *fmt, va_list ap)
{
	if (smokey_verbose_mode > 1) {
		__RT(vfprintf(stdout, fmt, ap));
		__RT(fprintf(stdout, "\n"));
	}
}

void smokey_trace(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	smokey_vatrace(fmt, ap);
	va_end(ap);
}

void __smokey_warning(const char *file, int lineno,
		      const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);

	if (smokey_verbose_mode) {
		__RT(fprintf(stderr, "%s:%d, ", basename(file), lineno));
		__RT(vfprintf(stderr, fmt, ap));
		__RT(fprintf(stderr, "\n"));
	}

	va_end(ap);
}

int smokey_barrier_init(struct smokey_barrier *b)
{
	pthread_mutexattr_t mattr;
	pthread_condattr_t cattr;
	int ret;

	b->signaled = 0;
	pthread_mutexattr_init(&mattr);
	pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL);
	pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
	pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_NONE);
	ret = __RT(pthread_mutex_init(&b->lock, &mattr));
	pthread_mutexattr_destroy(&mattr);
	if (ret)
		return ret;

	pthread_condattr_init(&cattr);
	pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_PRIVATE);
	ret = __RT(pthread_cond_init(&b->barrier, &cattr));
	pthread_condattr_destroy(&cattr);
	if (ret)
		__RT(pthread_mutex_destroy(&b->lock));

	return ret;
}

void smokey_barrier_destroy(struct smokey_barrier *b)
{
	__RT(pthread_cond_destroy(&b->barrier));
	__RT(pthread_mutex_destroy(&b->lock));
}

int smokey_barrier_wait(struct smokey_barrier *b)
{
	int ret = 0;
	
	__RT(pthread_mutex_lock(&b->lock));

	while (!b->signaled) {
		ret = __RT(pthread_cond_wait(&b->barrier, &b->lock));
		if (ret)
			break;
	}

	__RT(pthread_mutex_unlock(&b->lock));

	return ret;
}

int smokey_barrier_timedwait(struct smokey_barrier *b, struct timespec *ts)
{
	int ret = 0;
	
	__RT(pthread_mutex_lock(&b->lock));

	while (!b->signaled) {
		ret = __RT(pthread_cond_timedwait(&b->barrier,
						  &b->lock, ts));
		if (ret)
			break;
	}

	__RT(pthread_mutex_unlock(&b->lock));

	return ret;
}

void smokey_barrier_release(struct smokey_barrier *b)
{
	__RT(pthread_mutex_lock(&b->lock));
	b->signaled = 1;
	__RT(pthread_cond_broadcast(&b->barrier));
	__RT(pthread_mutex_unlock(&b->lock));
}

int smokey_fork_exec(const char *path, const char *arg)
{
	int wstatus = 0;
	pid_t pid;

	pid = do_fork();
	switch (pid) {
	case -1:
		error(1, errno, "fork/vfork");
	case 0:
		execlp(path, arg, NULL);
		error(1, errno, "execl %s", path);
	default:
		waitpid(pid, &wstatus, 0);
	}

	if WIFEXITED(wstatus)
		return WEXITSTATUS(wstatus);

	if WIFSIGNALED(wstatus)
		fprintf(stderr, "%s %s\n",
			strsignal(WTERMSIG(wstatus)),
			WCOREDUMP(wstatus) ? "(core dumped)" : "");
	return 1;

}

#define SMOKEY_MOD_NUM       32
static char *smokey_modules[SMOKEY_MOD_NUM];

int smokey_modprobe(const char *name, bool silent)
{
	char buffer[128];
	int err, len, i, midx = -1;
	FILE *fp;

	if (!name)
		return -EINVAL;

	fp = fopen("/proc/modules", "r");
	if (fp == NULL)
		return -errno;

	len = strlen(name);

	while (fgets(buffer, sizeof(buffer), fp)) {
		if (strncmp(buffer, name, len) == 0 &&
		    len < sizeof(buffer) && buffer[len] == ' ') {
			smokey_trace("%s module already loaded", name);
			fclose(fp);
			return 0;
		}
	}

	fclose(fp);

	for (i = 0; i < SMOKEY_MOD_NUM; i++) {
		if (!smokey_modules[i]) {
			midx = i;
			break;
		}
	}

	if (midx < 0)
		return -EFAULT;

	smokey_trace("%s module not there: modprobing", name);

	err = smokey_check_errno(
		snprintf(buffer, sizeof(buffer), "modprobe %s %s", name,
			 silent ? "2>/dev/null" : ""));
	if (err < 0)
		return err;

	err = smokey_check_errno(system(buffer));
	if (err < 0)
		return err;

	if (!WIFEXITED(err) || WEXITSTATUS(err) != 0) {
		if (!silent)
			smokey_warning("%s: abnormal exit", buffer);
		return -EINVAL;
	}

	smokey_modules[midx] = strdup(name);
	return err;
}

int smokey_rmmod(const char *name)
{
	char buffer[128];
	int i, midx = -1, err;

	if (!name)
		return -EINVAL;

	for (i = 0; i < SMOKEY_MOD_NUM; i++) {
		if (smokey_modules[i] && !strcmp(smokey_modules[i], name)) {
			midx = i;
			break;
		}
	}

	if (midx < 0) {
		smokey_trace("%s module was there on entry, keeping it", name);
		return 0;
	}

	smokey_trace("unloading %s module", name);

	err = smokey_check_errno(
		snprintf(buffer, sizeof(buffer), "rmmod %s", name));
	if (err < 0)
		return err;

	err = smokey_check_errno(system(buffer));
	if (err < 0)
		return err;

	if (!WIFEXITED(err) || WEXITSTATUS(err) != 0) {
		smokey_warning("%s: abnormal exit", buffer);
		return -EINVAL;
	}

	free(smokey_modules[midx]);
	smokey_modules[midx] = NULL;

	return err;
}