8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / dcs / sparc / sun4u / dcs_ses.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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * This file is a module that provides an interface to managing
 * concurrent sessions executed in either a separate thread or a
 * separate process. Threads are used only if the compile time flag
 * DCS_MULTI_THREAD is set. Otherwise, a new process is forked for
 * each session.
 *
 * Multiple processes are used to enable full Internationalization
 * support. This support requires that each session is able to set
 * its own locale for use in reporting errors to the user. Currently,
 * this is not possible using multiple threads because the locale
 * can not be set for an individual thread. For this reason, multiple
 * processes are supported until proper locale support is provided
 * for multiple threads.
 *
 * When Solaris supports a different locale in each thread, all
 * code used to enable using multiple processes should be removed.
 * To simplify this process, all references to DCS_MULTI_THREAD can
 * be found in this file.
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <syslog.h>
#include <locale.h>
#include <sys/socket.h>

#ifdef DCS_MULTI_THREAD
#include <thread.h>
#include <pthread.h>
#else /* DCS_MULTI_THREAD */
#include <sys/types.h>
#include <sys/wait.h>
#endif /* DCS_MULTI_THREAD */

#include "dcs.h"
#include "rdr_messages.h"
#include "rdr_param_types.h"


#define DCS_DEFAULT_LOCALE              "C"


/* session allocation/deallocation functions */
static int ses_alloc(void);
static int ses_free(void);

/* handler functions */
static void *ses_handler(void *arg);
#ifndef DCS_MULTI_THREAD
static void exit_handler(int sig, siginfo_t *info, void *context);
#endif /* !DCS_MULTI_THREAD */

/* session accounting functions */
#ifdef DCS_MULTI_THREAD
static void ses_thr_exit(void);
#endif /* DCS_MULTI_THREAD */


/*
 * Global structure that holds all relevant information
 * about the current session. If multiple threads are
 * used, the thread specific data mechanism is used. This
 * requires a data key to access the thread's private
 * session information.
 */
#ifdef DCS_MULTI_THREAD
thread_key_t    ses_key = THR_ONCE_KEY;
#else /* DCS_MULTI_THREAD */
session_t       *ses;
#endif /* DCS_MULTI_THREAD */


/*
 * Information about the current number of active sessions.
 * If multiple threads are used, synchronization objects
 * are required.
 */
static ulong_t sessions = 0;

#ifdef DCS_MULTI_THREAD
static mutex_t  sessions_lock = DEFAULTMUTEX;
static cond_t   sessions_cv   = DEFAULTCV;
#endif /* DCS_MULTI_THREAD */


/*
 * ses_start:
 *
 * Start the session handler. If multiple threads are used, create a new
 * thread that runs the ses_handler() function. If multiple processes
 * are used, fork a new process and call ses_handler().
 */
int
ses_start(int fd)
{
#ifdef DCS_MULTI_THREAD

        int     thr_err;


        mutex_lock(&sessions_lock);
        sessions++;
        mutex_unlock(&sessions_lock);

        thr_err = thr_create(NULL, 0, ses_handler, (void *)fd,
            THR_DETACHED | THR_NEW_LWP, NULL);

        return ((thr_err) ? -1 : 0);

#else /* DCS_MULTI_THREAD */

        int     pid;


        pid = fork();

        if (pid == -1) {
                (void) rdr_close(fd);
                return (-1);
        }

        /*
         * Parent:
         */
        if (pid) {
                /* close the child's fd */
                (void) close(fd);

                sessions++;

                return (0);
        }

        /*
         * Child:
         */
        ses_handler((void *)fd);

        /*
         * Prevent return to parent's loop
         */
        exit(0);

        /* NOTREACHED */

#endif /* DCS_MULTI_THREAD */
}


/*
 * ses_close:
 *
 * Initiate the closure of a session by sending an RDR_SES_END message
 * to the client. It does not attempt to close the network connection.
 */
int
ses_close(int err_code)
{
        session_t       *sp;
        cfga_params_t   req_data;
        rdr_msg_hdr_t   req_hdr;
        int             snd_status;
        static char     *op_name = "session close";


        /* get the current session information */
        if ((sp = curr_ses()) == NULL) {
                ses_close(DCS_ERROR);
                return (-1);
        }

        /* check if already sent session end */
        if (sp->state == DCS_SES_END) {
                return (0);
        }

        /* prepare header information */
        init_msg(&req_hdr);
        req_hdr.message_opcode = RDR_SES_END;
        req_hdr.data_type = RDR_REQUEST;
        req_hdr.status = err_code;

        /* no operation specific data */
        (void) memset(&req_data, 0, sizeof (req_data));

        PRINT_MSG_DBG(DCS_SEND, &req_hdr);

        /* send the message */
        snd_status = rdr_snd_msg(sp->fd, &req_hdr, &req_data, DCS_SND_TIMEOUT);

        if (snd_status == RDR_ABORTED) {
                abort_handler();
        }

        if (snd_status != RDR_OK) {
                dcs_log_msg(LOG_ERR, DCS_OP_REPLY_ERR, op_name);
        }

        /*
         * Setting the session state to DCS_SES_END will
         * cause the session handler to terminate the
         * network connection. This should happen whether
         * or not the session end message that was just
         * sent was received successfully.
         */
        sp->state = DCS_SES_END;
        return (0);
}


/*
 * ses_abort:
 *
 * Attempt to abort an active session. If multiple threads are used,
 * the parameter represents a thread_t identifier. If multiple
 * processes are used, the parameter represents a pid. In either
 * case, use this identifier to send a SIGINT signal to the approprate
 * session.
 */
int
ses_abort(long ses_id)
{
        DCS_DBG(DBG_SES, "killing session %d", ses_id);

#ifdef DCS_MULTI_THREAD

        if (thr_kill(ses_id, SIGINT) != 0) {
                /*
                 * If the thread cannot be found, we will assume
                 * that the session was able to exit normally. In
                 * this case, there is no error since the desired
                 * result has already been achieved.
                 */
                if (errno == ESRCH) {
                        return (0);
                }
                return (-1);
        }

#else /* DCS_MULTI_THREAD */

        if (kill(ses_id, SIGINT) == -1) {
                /*
                 * If the process cannot be found, we will assume
                 * that the session was able to exit normally. In
                 * this case, there is no error since the desired
                 * result has already been achieved.
                 */
                if (errno == ESRCH) {
                        return (0);
                }
                return (-1);
        }

#endif /* DCS_MULTI_THREAD */

        return (0);
}


/*
 * ses_abort_enable:
 *
 * Enter a mode where the current session can be aborted. This mode
 * will persist until ses_abort_disable() is called.
 *
 * A signal handler for SIGINT must be installed prior to calling this
 * function. If this is not the case, and multiple threads are used,
 * the default handler for SIGINT will cause the entire process to
 * exit, rather than just the current session. If multiple processes
 * are used, the default handler for SIGINT will not affect the main
 * process, but it will prevent both sides from gracefully closing
 * the session.
 */
void
ses_abort_enable(void)
{
        sigset_t        unblock_set;


        /* unblock SIGINT */
        sigemptyset(&unblock_set);
        sigaddset(&unblock_set, SIGINT);
        (void) sigprocmask(SIG_UNBLOCK, &unblock_set, NULL);
}


/*
 * ses_abort_disable:
 *
 * Exit the mode where the current session can be aborted. This
 * will leave the mode entered by ses_abort_enable().
 */
void
ses_abort_disable(void)
{
        sigset_t        block_set;


        /* block SIGINT */
        sigemptyset(&block_set);
        sigaddset(&block_set, SIGINT);
        (void) sigprocmask(SIG_BLOCK, &block_set, NULL);
}


/*
 * ses_setlocale:
 *
 * Set the locale for the current session. Currently, if multiple threads
 * are used, the 'C' locale is specified for all cases. Once there is support
 * for setting a thread specific locale, the requested locale will be used.
 * If multiple processes are used, an attempt is made to set the locale of
 * the process to the locale passed in as a parameter.
 */
int
ses_setlocale(char *locale)
{
        char    *new_locale;

        /* sanity check */
        if (locale == NULL) {
                locale = DCS_DEFAULT_LOCALE;
        }

#ifdef DCS_MULTI_THREAD

        /*
         * Reserved for setting the locale on a per thread
         * basis. Currently there is no Solaris support for
         * this, so use the default locale.
         */
        new_locale = setlocale(LC_ALL, DCS_DEFAULT_LOCALE);

#else /* DCS_MULTI_THREAD */

        new_locale = setlocale(LC_ALL, locale);

#endif /* DCS_MULTI_THREAD */

        if ((new_locale == NULL) || (strcmp(new_locale, locale) != 0)) {
                /* silently fall back to C locale */
                new_locale = setlocale(LC_ALL, DCS_DEFAULT_LOCALE);
        }

        DCS_DBG(DBG_SES, "using '%s' locale", new_locale);

        return (0);
}


/*
 * ses_init_signals:
 *
 * Initialize the set of signals to be blocked. It is assumed that the
 * mask parameter initially contains all signals. If multiple threads
 * are used, this is the correct behavior and the mask is not altered.
 * If multiple processes are used, session accounting is performed in
 * a SIGCHLD handler and so SIGCHLD must not be blocked. The action of
 * initializing this handler is also performed in this function.
 */
/* ARGSUSED */
void
ses_init_signals(sigset_t *mask)
{
#ifndef DCS_MULTI_THREAD

        struct sigaction        act;


        /* unblock SIGCHLD */
        (void) sigdelset(mask, SIGCHLD);

        /*
         * Establish a handler for SIGCHLD
         */
        (void) memset(&act, 0, sizeof (act));
        act.sa_sigaction = exit_handler;
        act.sa_flags = SA_SIGINFO;

        (void) sigaction(SIGCHLD, &act, NULL);

#endif /* !DCS_MULTI_THREAD */
}


/*
 * ses_sleep:
 *
 * Sleep for a specified amount of time, but don't prevent the
 * session from being aborted.
 */
void
ses_sleep(int sec)
{
        ses_abort_enable();
        sleep(sec);
        ses_abort_disable();
}


/*
 * ses_wait:
 *
 * Wait for the number of active sessions to drop below the maximum
 * allowed number of active sessions. If multiple threads are used,
 * the thread waits on a condition variable until a child thread
 * signals that it is going to exit. If multiple processes are used,
 * the process waits until at least one child process exits.
 */
static void
ses_wait(void)
{
#ifdef DCS_MULTI_THREAD

        mutex_lock(&sessions_lock);

        while (sessions >= max_sessions) {
                cond_wait(&sessions_cv, &sessions_lock);
        }

        mutex_unlock(&sessions_lock);

#else /* DCS_MULTI_THREAD */

        if (sessions >= max_sessions) {
                (void) wait(NULL);
        }

#endif /* DCS_MULTI_THREAD */
}


/*
 * ses_poll:
 *
 * Poll on the file descriptors passed in as a parameter. Before polling,
 * a check is performed to see if the number of active sessions is less
 * than the maximum number of active sessions allowed. If the limit for
 * active sessions is reached, the poll will be delayed until at least
 * one session exits.
 */
int
ses_poll(struct pollfd fds[], nfds_t nfds, int timeout)
{
        int     err;


        ses_wait();

        err = poll(fds, nfds, timeout);

        return (err);
}


/*
 * curr_ses:
 *
 * Return a pointer to the global session information. If multiple threads
 * are being used, this will point to a thread specific instance of a
 * session structure.
 */
session_t *
curr_ses(void)
{
#ifdef DCS_MULTI_THREAD

        return (pthread_getspecific(ses_key));

#else /* DCS_MULTI_THREAD */

        return (ses);

#endif /* DCS_MULTI_THREAD */
}


/*
 * curr_ses_id:
 *
 * Return the session identifier. This is either the thread_t identifier
 * of the thread, or the pid of the process.
 */
long
curr_ses_id(void)
{
#ifdef DCS_MULTI_THREAD

        return (thr_self());

#else /* DCS_MULTI_THREAD */

        return (getpid());

#endif /* DCS_MULTI_THREAD */
}


/*
 * ses_handler:
 *
 * Handle initialization and processing of a session. Initializes a session
 * and enters a loop which waits for requests. When a request comes in, it
 * is dispatched. When the session is terminated, the loop exits and the
 * session is cleaned up.
 */
static void *
ses_handler(void *arg)
{
        session_t               *sp;
        rdr_msg_hdr_t           op_hdr;
        cfga_params_t           op_data;
        int                     rcv_status;
        sigset_t                block_set;
        struct sigaction        act;

        static char *dcs_state_str[] = {
                "unknown state",
                "DCS_CONNECTED",
                "DCS_SES_REQ",
                "DCS_SES_ESTBL",
                "DCS_CONF_PENDING",
                "DCS_CONF_DONE",
                "DCS_SES_END"
        };


        if (ses_alloc() == -1) {
                (void) rdr_close((int)arg);
                return ((void *)-1);
        }

        if ((sp = curr_ses()) == NULL) {
                ses_close(DCS_ERROR);
                return (NULL);
        }

        /* initialize session information */
        memset(sp, 0, sizeof (session_t));
        sp->state = DCS_CONNECTED;
        sp->random_resp = lrand48();
        sp->fd = (int)arg;
        sp->id = curr_ses_id();

        /* initially, block all signals and cancels */
        (void) sigfillset(&block_set);
        (void) sigprocmask(SIG_BLOCK, &block_set, NULL);

        /* set the abort handler for this session */
        (void) memset(&act, 0, sizeof (act));
        act.sa_handler = abort_handler;
        (void) sigaction(SIGINT, &act, NULL);

        DCS_DBG(DBG_SES, "session handler starting...");

        /*
         * Process all requests in the session until the
         * session is terminated
         */
        for (;;) {

                DCS_DBG(DBG_STATE, "session state: %s",
                    dcs_state_str[sp->state]);

                if (sp->state == DCS_SES_END) {
                        break;
                }

                (void) memset(&op_hdr, 0, sizeof (op_hdr));
                (void) memset(&op_data, 0, sizeof (op_data));

                rcv_status = rdr_rcv_msg(sp->fd, &op_hdr, &op_data,
                    DCS_RCV_TIMEOUT);

                if (rcv_status != RDR_OK) {

                        switch (rcv_status) {

                        case RDR_TIMEOUT:
                                DCS_DBG(DBG_SES, "receive timed out");
                                break;

                        case RDR_DISCONNECT:
                                dcs_log_msg(LOG_NOTICE, DCS_DISCONNECT);
                                break;

                        case RDR_ABORTED:
                                dcs_log_msg(LOG_INFO, DCS_SES_ABORTED);
                                break;

                        case RDR_MSG_INVAL:
                                /*
                                 * Only log invalid messages if a session has
                                 * already been established. Logging invalid
                                 * session request messages could flood syslog.
                                 */
                                if (sp->state != DCS_CONNECTED) {
                                        dcs_log_msg(LOG_WARNING, DCS_MSG_INVAL);
                                } else {
                                        DCS_DBG(DBG_SES, "received an invalid "
                                            "message");
                                }

                                break;

                        default:
                                dcs_log_msg(LOG_ERR, DCS_RECEIVE_ERR);
                                break;
                        }

                        /*
                         * We encountered an unrecoverable error,
                         * so exit this session handler.
                         */
                        break;

                } else {
                        /* handle the message */
                        dcs_dispatch_message(&op_hdr, &op_data);
                        rdr_cleanup_params(op_hdr.message_opcode, &op_data);
                }
        }

        DCS_DBG(DBG_SES, "connection closed");

        /* clean up */
        (void) rdr_close(sp->fd);
        (void) ses_free();

#ifdef DCS_MULTI_THREAD
        ses_thr_exit();
#endif /* DCS_MULTI_THREAD */

        return (0);
}


/*
 * abort_handler:
 *
 * Handle a request to abort a session. This function should be installed
 * as the signal handler for SIGINT. It sends a message to the client
 * indicating that the session was aborted, and that the operation failed
 * as a result. The session then terminates, and the thread or process
 * handling the session exits.
 */
void
abort_handler(void)
{
        session_t       *sp;
        rdr_msg_hdr_t   op_hdr;
        cfga_params_t   op_data;


        /* get the current session information */
        if ((sp = curr_ses()) == NULL) {
                ses_close(DCS_ERROR);
#ifdef DCS_MULTI_THREAD
                ses_thr_exit();
                thr_exit(0);
#else /* DCS_MULTI_THREAD */
                exit(0);
#endif /* DCS_MULTI_THREAD */
        }

        DCS_DBG(DBG_MSG, "abort_handler()");

        /* prepare header information */
        init_msg(&op_hdr);
        op_hdr.message_opcode = sp->curr_msg.hdr->message_opcode;
        op_hdr.data_type = RDR_REPLY;
        op_hdr.status = DCS_SES_ABORTED;

        /* no operation specific data */
        (void) memset(&op_data, 0, sizeof (op_data));

        PRINT_MSG_DBG(DCS_SEND, &op_hdr);

        (void) rdr_snd_msg(sp->fd, &op_hdr, &op_data, DCS_SND_TIMEOUT);

        DCS_DBG(DBG_INFO, "abort_handler: connection closed");

        /* clean up */
        rdr_cleanup_params(op_hdr.message_opcode, sp->curr_msg.params);
        (void) rdr_close(sp->fd);
        (void) ses_free();

        dcs_log_msg(LOG_INFO, DCS_SES_ABORTED);

#ifdef DCS_MULTI_THREAD
        ses_thr_exit();
        thr_exit(0);
#else /* DCS_MULTI_THREAD */
        exit(0);
#endif /* DCS_MULTI_THREAD */
}


#ifndef DCS_MULTI_THREAD

/*
 * exit_handler:
 *
 * If multiple processes are used, this function is used to record
 * the fact that a child process has exited. In order to make sure
 * that all zombie processes are released, a waitpid() is performed
 * for the child that has exited.
 */
/* ARGSUSED */
static void
exit_handler(int sig, siginfo_t *info, void *context)
{
        sessions--;

        if (info != NULL) {
                (void) waitpid(info->si_pid, NULL, 0);
        }
}

#endif /* !DCS_MULTI_THREAD */


/*
 * ses_alloc:
 *
 * Allocate the memory required for the global session structure.
 * If multiple threads are used, create a thread specific data
 * key. This will only occur the first time that this function
 * gets called.
 */
static int
ses_alloc(void)
{
        session_t       *sp;

#ifdef DCS_MULTI_THREAD

        int             thr_err;

        thr_err = thr_keycreate_once(&ses_key, NULL);
        if (thr_err)
                return (-1);

#endif /* DCS_MULTI_THREAD */

        DCS_DBG(DBG_SES, "allocating session memory");

        sp = (session_t *)malloc(sizeof (session_t));

        if (!sp) {
                dcs_log_msg(LOG_ERR, DCS_INT_ERR, "malloc", strerror(errno));
                return (-1);
        }

#ifdef DCS_MULTI_THREAD

        thr_err = thr_setspecific(ses_key, sp);

        return ((thr_err) ? -1 : 0);

#else /* DCS_MULTI_THREAD */

        /* make the data global */
        ses = sp;

        return (0);

#endif /* DCS_MULTI_THREAD */
}


/*
 * ses_free:
 *
 * Deallocate the memory associated with the global session structure.
 */
static int
ses_free(void)
{
        session_t       *sp;


        DCS_DBG(DBG_SES, "freeing session memory");

        if ((sp = curr_ses()) == NULL) {
                ses_close(DCS_ERROR);
                return (-1);
        }

        if (sp) {
                (void) free((void *)sp);
        }

        return (0);
}


#ifdef DCS_MULTI_THREAD

/*
 * ses_thr_exit:
 *
 * If multiple threads are used, this function is used to record the
 * fact that a child thread has exited. In addition, the condition
 * variable is signaled so that the main thread can wakeup and begin
 * accepting connections again.
 */
static void
ses_thr_exit()
{
        mutex_lock(&sessions_lock);

        sessions--;

        cond_signal(&sessions_cv);

        mutex_unlock(&sessions_lock);
}

#endif /* DCS_MULTI_THREAD */