/*
 * Copyright (C) 2013 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 <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/timerfd.h>
#include <sys/un.h>
#include <signal.h>
#include <stdio.h>
#include <limits.h>
#include <memory.h>
#include <malloc.h>
#include <getopt.h>
#include <string.h>
#include <error.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <pwd.h>
#include <boilerplate/list.h>
#include <boilerplate/hash.h>
#include "../internal.h"
#include "sysregfs.h"

#define note(fmt, args...)					\
	do {							\
  		if (!daemonize)					\
			printf("sysregd: " fmt "\n", ##args);	\
	} while (0)

static char *rootdir;

static int sockfd;

static char *sysroot;

static int daemonize;

static int linger;

static int shared;

static int anon;

struct client {
	char *mountpt;
	int sockfd;
	struct pvholder next;
};

static DEFINE_PRIVATE_LIST(client_list);

static void usage(void)
{
	fprintf(stderr, "usage: sysregd --root=<dir>     set registry root directory\n");
	fprintf(stderr, "               [--shared]       share registry between different users\n");
	fprintf(stderr, "               [--anon]         mount registry for anonymous session\n");
	fprintf(stderr, "               [--daemonize]    run in the background\n");
	fprintf(stderr, "               [--linger]       disable timed exit on idleness\n");
}

static const struct option options[] = {
	{
#define help_opt	0
		.name = "help",
		.has_arg = no_argument,
	},
	{
#define daemonize_opt	1
		.name = "daemonize",
		.has_arg = no_argument,
		.flag = &daemonize,
		.val = 1,
	},
	{
#define root_opt	2
		.name = "root",
		.has_arg = required_argument,
	},
	{
#define linger_opt	3
		.name = "linger",
		.has_arg = no_argument,
		.flag = &linger,
		.val = 1,
	},
	{
#define shared_opt	4
		.name = "shared",
		.has_arg = no_argument,
		.flag = &shared,
		.val = 1,
	},
	{
#define anon_opt	5
		.name = "anon",
		.has_arg = no_argument,
		.flag = &anon,
		.val = 1,
	},
	{ /* Sentinel */ },
};

static int create_directory_recursive(const char *dir) /* absolute path */
{
	char *s, *p;
	int ret;

	ret = chdir("/");
	if (ret)	/* That should better work... */
		error(1, errno, "chdir(\"/\")");

	s = strdup(dir);
	if (s == NULL)
		return -ENOMEM;

	p = strtok(s + 1, "/");
	while (p) {
		if (*p == '\0')
			goto next;
		ret = access(p, R_OK|W_OK|X_OK);
		if (ret) {
			ret = mkdir(p, 0755);
			if (ret && errno != EEXIST)
				return -errno;
		}
		ret = chdir(p);
		if (ret)
			return -errno;
	next:
		p = strtok(NULL, "/");
	}

	if (shared) {
		ret = chmod(dir, 0775 | S_ISGID);
		if (ret)
			return -errno;
	}

	free(s);

	return chdir(rootdir) ? -errno : 0; /* Back to rootdir */
}

static void create_rootdir(void)
{
	int ret;

	if (*rootdir != '/')
		error(1, EINVAL, "absolute root directory path required");

	ret = create_directory_recursive(rootdir);
	if (ret)
		error(1, -ret, "create_directory_recursive(\"%s\")", rootdir);
}

/*
 * Attempt to bind a local domain socket to some address in the
 * abstract namespace, for allowing clients to register. This way, we
 * won't have to suffer socket node left overs, which are a pain to
 * deal with racelessly.
 *
 * The address is a hash of the root directory we have been told to
 * maintain.
 */
static void bind_socket(void)
{
	struct sockaddr_un sun;
	unsigned int hash;
	socklen_t addrlen;
	int ret;

	sockfd = __STD(socket(AF_UNIX, SOCK_SEQPACKET, 0));
	if (sockfd < 0)
		error(1, errno, "bind_socket/socket");

	memset(&sun, 0, sizeof(sun));
	sun.sun_family = AF_UNIX;
	hash = __hash_key(rootdir, strlen(rootdir), 0);
	snprintf(sun.sun_path, sizeof(sun.sun_path), "X%X-xenomai", hash);
	addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(sun.sun_path);
	sun.sun_path[0] = '\0';
	ret = __STD(bind(sockfd, (struct sockaddr *)&sun, addrlen));
	if (ret) {
		if (errno == EADDRINUSE)
			exit(0);
		error(1, errno, "bind_socket/bind");
	}

	ret = __STD(listen(sockfd, SOMAXCONN));
	if (ret)
		error(1, errno, "bind_socket/listen");
}

static int register_client(int s)
{
	struct ucred ucred;
	struct client *c;
	socklen_t optlen;
	char *mountpt;
	int ret;

	optlen = sizeof(ucred);
	ret = __STD(getsockopt(s, SOL_SOCKET, SO_PEERCRED, &ucred, &optlen));
	if (ret)
		return -errno;

	c = malloc(sizeof(*c));
	if (c == NULL)
		return -ENOMEM;

	/*
	 * The registry mount point for a client will be
	 * <rootdir>/pid.
	 */
	ret = asprintf(&mountpt, "%s/%d", rootdir, ucred.pid);
	if (ret < 0) {
		ret = -ENOMEM;
		goto fail_nopath;
	}

	ret = create_directory_recursive(mountpt);
	if (ret) {
		note("failed creating mount point %s", mountpt);
		goto fail;
	}

	note("created mount point %s", mountpt);

	/* Send the mount point back to the client. */
	ret = __STD(send(s, mountpt, strlen(mountpt) + 1, 0));
	if (ret < 0)
		goto fail;

	c->mountpt = mountpt;
	c->sockfd = s;
	pvlist_append(&c->next, &client_list);

	return 0;
fail:
	free(mountpt);
fail_nopath:
	free(c);

	return ret;
}

static void unmount(const char *path)
{
	char *cmd, *cmdpath;
	int flags, ret;

	/*
	 * Silence stderr while we run the shell command - it may complain
	 * about an already unmounted path.
	 */
	flags = fcntl(2, F_GETFD);
	if (flags >= 0)
		fcntl(2, F_SETFD, flags | FD_CLOEXEC);

	cmdpath = lookup_command("fusermount");
	if (cmdpath) {
		ret = asprintf(&cmd, "%s -uzq %s", cmdpath, path);
		free(cmdpath);
		if (ret < 0)
			return;

		ret = system(cmd);
		free(cmd);
		if (ret != -1 && WIFEXITED(ret) && WEXITSTATUS(ret) == 0)
			return;
	}

	cmdpath = lookup_command("umount");
	if (cmdpath == NULL)
		return;

	ret = asprintf(&cmd, "%s -l %s", cmdpath, path);
	free(cmdpath);
	if (ret < 0)
		return;

	ret = system(cmd);
	free(cmd);
	(void)ret;
}

static void unregister_client(int s)
{
	struct client *c;

	pvlist_for_each_entry(c, &client_list, next) {
		if (c->sockfd == s) {
			pvlist_remove(&c->next);
			note("deleting mount point %s", c->mountpt);
			unmount(c->mountpt);
			rmdir(c->mountpt);
			free(c->mountpt);
			free(c);
			return;
		}
	}
}

static void delete_system_fs(void)
{
	note("unmounting %s", sysroot);
	unmount(sysroot);
	rmdir(sysroot);
	rmdir(rootdir);
}

static void handle_requests(void)
{
	int ret, s, tmfd = -1;
	struct itimerspec its;
	fd_set refset, set;
	uint64_t exp;
	char c;

	FD_ZERO(&refset);
	FD_SET(sockfd, &refset);

	if (!linger) {
		tmfd = __STD(timerfd_create(CLOCK_MONOTONIC, 0));
		if (tmfd < 0)
			error(1, errno, "handle_requests/timerfd_create");
		/* Silently exit after 30s being idle. */
		its.it_value.tv_sec = 30;
		its.it_value.tv_nsec = 0;
		its.it_interval.tv_sec = 30;
		its.it_interval.tv_nsec = 0;
		__STD(timerfd_settime(tmfd, 0, &its, NULL));
		FD_SET(tmfd, &refset);
	}

	for (;;) {
		set = refset;
		ret = __STD(select(FD_SETSIZE, &set, NULL, NULL, NULL));
		if (ret < 0)
			error(1, errno, "handle_requests/select");
		if (FD_ISSET(sockfd, &set)) {
			s = __STD(accept(sockfd, NULL, 0));
			if (s < 0)
				error(1, errno, "handle_requests/accept");
			ret = register_client(s);
			if (ret) {
				__STD(close(s));
				continue;
			}
			FD_SET(s, &refset);
			if (tmfd != -1) {
				if (anon) {
					FD_CLR(tmfd, &refset);
					__STD(close(tmfd));
					tmfd = -1;
				} else
					__STD(timerfd_settime(tmfd, 0, &its, NULL));
			}
		}
		if (tmfd != -1 && FD_ISSET(tmfd, &set)) {
			ret = __STD(read(tmfd, &exp, sizeof(exp)));
			(void)ret;
			if (pvlist_empty(&client_list))
				exit(0);
		}
		for (s = sockfd + 1; s < FD_SETSIZE; s++) {
			if (!FD_ISSET(s, &set) || s == tmfd)
				continue;
			ret = __STD(recv(s, &c, sizeof(c), 0));
			if (ret <= 0) {
				unregister_client(s);
				__STD(close(s));
				FD_CLR(s, &refset);
				if (anon && pvlist_empty(&client_list)) {
					if (daemonize) {
						note("unlinking session %s",
						     __copperplate_setup_data.session_label);
						heapobj_unlink_session(__copperplate_setup_data.session_label);
					}
					exit(0);
				}
			}
		}
	}
}

static void cleanup_handler(int sig)
{
	delete_system_fs();
	_exit(1);
}

#ifdef CONFIG_XENO_COBALT

#include "cobalt/internal.h"

/*
 * Bootstrapping Cobalt is something which is normally done through
 * xenomai_bootstrap(), as available from lib/xenomai/bootstrap.o for
 * normal applications. But sysregd is a peculiar one, and we need to
 * drive the init sequence specifically for it.
 */
static inline int bootstrap_core(void)
{
	return cobalt_init();
}

#else

static inline int bootstrap_core(void)
{
	return 0;
}

#endif

static void create_system_fs(const char *arg0, const char *rootdir, int flags)
{
	struct sysreg_fsfile *f;
	struct sysreg_fsdir *d;
	struct sigaction sa;
	const char *session;
	char *mountpt;
	int ret;

	session = strrchr(rootdir, '/');
	if (session++ == NULL)
		error(1, EINVAL, "root directory %s", rootdir);

	ret = asprintf(&mountpt, "%s/system", rootdir);
	if (ret < 0)
		error(1, ENOMEM, "malloc");

	ret = create_directory_recursive(mountpt);
	if (ret) {
		/*
		 * Before giving up, try to cleanup a left over, in
		 * case a former sysregd instance died ungracefully.
		 * Receiving ENOTCONN when creating the /system root
		 * is the sign that we may be attempting to walk a
		 * stale tree.
		 */
		if (ret == -ENOTCONN) {
			unmount(mountpt);
			ret = create_directory_recursive(mountpt);
			if (ret == 0)
				goto bootstrap;
		}
		error(1, -ret, "create_directory_recursive(\"%s\")", mountpt);
	}

bootstrap:
	atexit(delete_system_fs);

	ret = bootstrap_core();
	if (ret)
		error(1, -ret, "cannot bootstrap core interface");

	__copperplate_setup_data.session_label = session;
	__copperplate_setup_data.registry_root = rootdir;
	sysroot = mountpt;
	copperplate_bootstrap_internal(arg0, mountpt, flags);

	note("mounted system fs at %s", mountpt);

	memset(&sa, 0, sizeof(sa));
	sa.sa_handler = cleanup_handler;
	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);
	sa.sa_handler = SIG_IGN;
	sigaction(SIGHUP, &sa, NULL);

	for (d = sysreg_dirs; d->path != NULL; d++)
		registry_add_dir(d->path);

	for (f = sysreg_files; f->path != NULL; f++) {
		registry_init_file_obstack(&f->fsobj, &f->ops);
		ret = registry_add_file(&f->fsobj, f->mode, f->path);
		if (ret)
			error(1, -ret, "failed to register %s", f->path);
	}
}

int main(int argc, char *const *argv)
{
	int lindex, opt, ret, flags = 0;
	struct sched_param schedp;
	struct sigaction sa;

	for (;;) {
		lindex = -1;
		opt = getopt_long_only(argc, argv, "", options, &lindex);
		if (opt == EOF)
			break;
		switch (lindex) {
		case help_opt:
			usage();
			return 0;
		case daemonize_opt:
		case linger_opt:
			break;
		case shared_opt:
			flags |= REGISTRY_SHARED;
			break;
		case anon_opt:
			flags |= REGISTRY_ANON;
			break;
		case root_opt:
			rootdir = optarg;
			break;
		default:
			usage();
			exit(1);
		}
	}

	if (rootdir == NULL)
		error(1, EINVAL, "--root must be given");

	/* Force SCHED_OTHER. */
	schedp.sched_priority = 0;
	__STD(pthread_setschedparam(pthread_self(), SCHED_OTHER, &schedp));

	memset(&sa, 0, sizeof(sa));
	sa.sa_handler = SIG_IGN;
	sigaction(SIGPIPE, &sa, NULL);
	sa.sa_handler = SIG_DFL;
	sigaction(SIGCHLD, &sa, NULL);

	if (daemonize) {
		ret = daemon(1, 1);
		if (ret)
			error(1, errno, "cannot daemonize");
	}

	create_rootdir();
	bind_socket();
	create_system_fs(argv[0], rootdir, flags);
	handle_requests();

	return 0;
}