/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * bridged - bridging control daemon.
 */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <syslog.h>
#include <locale.h>
#include <stropts.h>

#include "global.h"

boolean_t debugging;
uint32_t tablemax;
const char *instance_name = "default";

struct pollfd *fdarray;

dladm_handle_t dlhandle;

boolean_t shutting_down;

static pthread_t sighand;

/*
 * engine_lock is held while the main loop is busy calling librstp functions.
 * Door threads take the lock to protect the library from reentrancy.
 */
static pthread_mutex_t engine_lock = PTHREAD_MUTEX_INITIALIZER;

/*
 * These wrapper functions allow the other components in the daemon to remain
 * ignorant of pthreads details.
 */
int
lock_engine(void)
{
	return (pthread_mutex_lock(&engine_lock));
}

void
unlock_engine(void)
{
	(void) pthread_mutex_unlock(&engine_lock);
}

/*
 * Utility function for STREAMS ioctls.
 */
ssize_t
strioctl(int fd, int cmd, void *buf, size_t buflen)
{
	int retv;
	struct strioctl ic;

	ic.ic_cmd = cmd;
	ic.ic_timout = 0;
	ic.ic_dp = buf;
	ic.ic_len = buflen;
	if ((retv = ioctl(fd, I_STR, &ic)) != 0)
		return (retv);
	else
		return (ic.ic_len);
}

static void
daemonize(void)
{
	pid_t pid;

	/*
	 * A little bit of magic here.  By the first fork+setsid, we
	 * disconnect from our current controlling terminal and become
	 * a session group leader.  By forking again without calling
	 * setsid again, we make certain that we are not the session
	 * group leader and can never reacquire a controlling terminal.
	 */
	if ((pid = fork()) == (pid_t)-1) {
		syslog(LOG_ERR, "fork 1 failed");
		exit(EXIT_FAILURE);
	}
	if (pid != 0) {
		(void) wait(NULL);
		_exit(EXIT_SUCCESS);
	}
	if (setsid() == (pid_t)-1) {
		syslog(LOG_ERR, "setsid");
		exit(EXIT_FAILURE);
	}
	if ((pid = fork()) == (pid_t)-1) {
		syslog(LOG_ERR, "fork 2 failed");
		exit(EXIT_FAILURE);
	}
	if (pid != 0)
		_exit(EXIT_SUCCESS);
	(void) chdir("/");
	(void) umask(022);
}

static void *
sighandler(void *arg)
{
	sigset_t sigset;
	int sig;
	int sigfd = (int)(uintptr_t)arg;

	(void) sigfillset(&sigset);

	for (;;) {
		sig = sigwait(&sigset);
		switch (sig) {
		case SIGHUP:
			(void) write(sigfd, "", 1);
			break;

		default:
			if (debugging)
				syslog(LOG_NOTICE, "%s signal, shutting down",
				    strsignal(sig));
			shutting_down = B_TRUE;
			break;
		}

		/* if we're shutting down, exit this thread */
		if (shutting_down)
			return (NULL);
	}
}

static void
init_signalhandling(void)
{
	pthread_attr_t attr;
	int err;
	sigset_t new;
	int fildes[2];

	if ((fdarray = malloc(FDOFFSET * sizeof (struct pollfd))) == NULL) {
		syslog(LOG_ERR, "unable to allocate fdarray: %m");
		exit(EXIT_FAILURE);
	}
	if (pipe(fildes) != 0) {
		syslog(LOG_ERR, "unable to create signal pipe: %m");
		exit(EXIT_FAILURE);
	}
	fdarray[0].fd = fildes[0];
	fdarray[0].events = POLLIN;
	assert(control_fd != -1);
	fdarray[1].fd = control_fd;
	fdarray[1].events = POLLIN;

	(void) sigfillset(&new);
	(void) pthread_sigmask(SIG_BLOCK, &new, NULL);
	(void) pthread_attr_init(&attr);
	(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	err = pthread_create(&sighand, &attr, sighandler,
	    (void *)(uintptr_t)fildes[1]);
	if (err != 0) {
		syslog(LOG_ERR, "cannot create signal handling thread: %s",
		    strerror(err));
		exit(EXIT_FAILURE);
	}
	(void) pthread_attr_destroy(&attr);
}

int
main(int argc, char **argv)
{
	dladm_status_t status;
	char buf[DLADM_STRSIZE];

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	shutting_down = B_FALSE;
	openlog("bridged", LOG_PID | LOG_NDELAY, LOG_DAEMON);

	if (argc != 2) {
		syslog(LOG_ERR, "instance name is required");
		exit(EXIT_FAILURE);
	}

	instance_name = argv[1];

	if ((status = dladm_open(&dlhandle)) != DLADM_STATUS_OK) {
		syslog(LOG_ERR, "%s: unable to open datalink control: %s",
		    instance_name, dladm_status2str(status, buf));
		exit(EXIT_FAILURE);
	}

	status = dladm_bridge_get_privprop(instance_name, &debugging,
	    &tablemax);
	if (status != DLADM_STATUS_OK) {
		syslog(LOG_ERR, "%s: unable to read properties: %s",
		    instance_name, dladm_status2str(status, buf));
		exit(EXIT_FAILURE);
	}

	/* Get the properties once so that we have the right initial values */
	rstp_init();

	open_bridge_control();

	daemonize();

	init_signalhandling();
	init_door();

	if (debugging)
		syslog(LOG_INFO, "bridged started: instance %s", instance_name);

	event_loop();
	(void) pthread_cancel(sighand);
	(void) pthread_join(sighand, NULL);

	return (0);
}