usr.lib/bridged/main.c

/*
 * 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);
}