/*
 * 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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <errno.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/stat.h>
#include <sys/sdt.h>
#include <signal.h>
#include <fcntl.h>
#include <libnvpair.h>
#include <libstmf.h>
#include <door.h>
#include <pthread.h>
#include <libscf.h>
#include <locale.h>
#include <sys/stmf_ioctl.h>
#include <sys/pppt_ioctl.h>
#include <libstmfproxy.h>

#define PPPT_NODE       "/devices/pseudo/pppt@0:pppt"
#define USAGE   "Usage: %s [-d][-f][-n nodeid] nodename\n" \
                "Note: nodename must be the same on both nodes\n"


/*
 * static functions
 */
static void daemonInit(void);
static void killHandler();
static int postMsg(uint_t nelem, uchar_t *aluaMsg);


/*
 * globals
 */
void *t_handle;                 /* transport handle */
char aluaNode[256];             /* one of the two alua peers */
char myNode[256];               /* this hostname */
int log_debug = 0;
int fore_ground = 0;
int proxy_hdl;
pt_ops_t *pt_ops;
pthread_mutex_t send_mutex = PTHREAD_MUTEX_INITIALIZER;

/*
 * killHandler
 *
 * Terminates this process on SIGQUIT, SIGINT, SIGTERM
 */
/* ARGSUSED */
static void
killHandler(int sig)
{
        exit(0);
}

/*
 * doorHandler
 *
 * Recieve data from the local proxy port provider and relay
 * it to the peer node.
 */
/* ARGSUSED */
void
doorHandler(
        void            *cookie,
        char            *args,
        size_t          alen,
        door_desc_t     *ddp,
        uint_t          ndid)
{
        uint32_t result = 0;

        if (ddp != NULL || ndid != 0) {
                syslog(LOG_DAEMON|LOG_WARNING,
                    "descriptor passed to door %p %d", ddp, ndid);
                result = EINVAL;
        }

        if (args == NULL || alen == 0) {
                syslog(LOG_DAEMON|LOG_WARNING,
                    "empty message passed to door %p %d", args, alen);
                result = EFAULT;
        }

        if (result == 0)
                result = postMsg((uint_t)alen, (uchar_t *)args);
        (void) door_return((char *)&result, sizeof (result), NULL, 0);

        syslog(LOG_DAEMON|LOG_WARNING, "door_return FAILED %d", errno);
        exit(errno);
}

static int
postMsg(uint_t nelem, uchar_t *aluaMsg)
{
        uint32_t buflen;
        uchar_t *buf;
        int ret = 0;
        int ns;

        if (t_handle == NULL) {
                syslog(LOG_DAEMON|LOG_WARNING,
                    "postMsg() no transport handle");
                exit(1);
        }

        buf = malloc(nelem + sizeof (buflen));

        buflen = htonl(nelem);  /* length in network byte order */
        bcopy(&buflen, buf, sizeof (buflen));
        bcopy(aluaMsg, buf + sizeof (buflen), nelem);

        (void) pthread_mutex_lock(&send_mutex);
        ns = pt_ops->stmf_proxy_send(t_handle, buf, nelem + sizeof (buflen));
        (void) pthread_mutex_unlock(&send_mutex);
        if (ns != nelem + sizeof (buflen)) {
                ret = errno;
                if (ret == 0)
                        ret = ENOTTY;   /* something bogus */
                syslog(LOG_DAEMON|LOG_CRIT, "send() call failed: %d", ret);
        }
        free(buf);
        return (ret);
}

/*
 * Multi-thread the data path from the peer node to the local
 * proxy port provider. During discover, there can be a large
 * burst of messages from the peer node proportional to the number
 * of LUs. Multiple threads allow these messages to be processed
 * simultaneously.
 */
typedef struct pppt_drv_queue {
        struct pppt_drv_queue   *next;
        uint32_t                buflen;
        uchar_t                 *buf;
} pppt_drv_queue_t;

pppt_drv_queue_t *pq_head = NULL;
pthread_mutex_t pq_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t pq_cond = PTHREAD_COND_INITIALIZER;
int pq_num_threads = 0;
int pq_avail_threads = 0;

/*ARGSUSED*/
void *
push_to_drv(void *arg)
{
        pppt_drv_queue_t        *pq;
        int rc;

        (void) pthread_mutex_lock(&pq_mutex);
        pq_num_threads++;
        (void) pthread_mutex_unlock(&pq_mutex);
        for (;;) {
                (void) pthread_mutex_lock(&pq_mutex);
                while (pq_head == NULL) {
                        pq_avail_threads++;
                        (void) pthread_cond_wait(&pq_cond, &pq_mutex);
                        pq_avail_threads--;
                }
                pq = pq_head;
                pq_head = pq->next;
                pq->next = NULL;
                (void) pthread_mutex_unlock(&pq_mutex);
                /* Relay the message to the local kernel */
                rc = stmfPostProxyMsg(proxy_hdl, (void *)pq->buf, pq->buflen);
                if (rc != STMF_STATUS_SUCCESS) {
                        /* XXX die ? */
                        syslog(LOG_DAEMON|LOG_CRIT, "ioctl failed - %d", errno);
                }
                free(pq->buf);
                free(pq);
        }
        /*NOTREACHED*/
        return (NULL);
}

/*
 * Receive data from peer and queue it up for the proxy driver.
 */
int message_count = 0;
static void
relay_peer_msg()
{
        uint32_t                buflen;
        pppt_drv_queue_t        *pq, *tmpq;
        pthread_t               tid;
        int                     rc;


        /* first receive the length of the message */
        if ((pt_ops->stmf_proxy_recv(t_handle, (uchar_t *)&buflen,
            sizeof (buflen))) != sizeof (buflen)) {
                syslog(LOG_DAEMON|LOG_WARNING, "recv() call failed: %d",
                    errno);
                exit(1);
        }

        pq = malloc(sizeof (*pq));
        pq->next = NULL;
        pq->buflen = ntohl(buflen);
        pq->buf = malloc(pq->buflen+4);
        if (log_debug) {
                syslog(LOG_DAEMON|LOG_DEBUG,
                    "recvMsg: size of buffer - %d", (int)pq->buflen);
        }

        if ((pt_ops->stmf_proxy_recv(t_handle, pq->buf, pq->buflen)) !=
            pq->buflen) {
                syslog(LOG_DAEMON|LOG_WARNING, "recv() call failed: %d",
                    errno);
                exit(1);
        }

        /* Eat the first message from peer */
        if (message_count++ == 0) {
                *(pq->buf+pq->buflen) = 0;
                free(pq->buf);
                free(pq);
                return;
        }

        /* Queue the message to the driver */
        (void) pthread_mutex_lock(&pq_mutex);
        if (pq_head == NULL) {
                pq_head = pq;
        } else {
                /* add to the tail */
                tmpq = pq_head;
                while (tmpq->next != NULL)
                        tmpq = tmpq->next;
                tmpq->next = pq;
        }

        /* Make sure there is a thread to service this message */
        if (pq_avail_threads) {
                /* wake an available thread */
                (void) pthread_cond_signal(&pq_cond);
                (void) pthread_mutex_unlock(&pq_mutex);
        } else {
                /* no threads available, create a new thread */
                (void) pthread_mutex_unlock(&pq_mutex);
                rc = pthread_create(&tid, NULL, push_to_drv, NULL);
                if (rc != 0) {
                        syslog(LOG_DAEMON|LOG_WARNING,
                            "pthread_create() call failed: %d", rc);
                        if (pq_num_threads == 0) {
                                /* never created a thread */
                                exit(rc);
                        }
                }
        }
}

/*
 * Initialization for a daemon process
 */
static void
daemonInit(void)
{
        pid_t   pid;
        int     devnull;

        if (fore_ground)
                return;

        if ((pid = fork()) < 0) {
                syslog(LOG_DAEMON|LOG_CRIT, "Could not fork(). Exiting");
                exit(1);
        } else if (pid != 0) {
                /*
                 * XXX
                 * Simple approach for now - let the service go online.
                 * Later, set-up a pipe to the child and wait until the
                 * child indicates service is setup.
                 */
                exit(SMF_EXIT_OK);
        }

        (void) setsid();

        (void) chdir("/");

        (void) umask(0);


        devnull = open("/dev/null", O_RDWR);
        if (devnull < 0) {
                syslog(LOG_DAEMON|LOG_CRIT,
                    "Failed to open /dev/null. Exiting");
                exit(1);
        }

        (void) dup2(devnull, STDIN_FILENO);
        (void) dup2(devnull, STDOUT_FILENO);
        (void) dup2(devnull, STDERR_FILENO);
        (void) close(devnull);
}

void
daemon_fini(int rc)
{
        /*
         * XXX inform the parent about the service state
         * For now, just exit on error.
         */
        if (rc != 0)
                exit(rc);
}

static int
open_proxy_driver()
{
        int drv_door_fd;
        int stmf_ret;

        /*
         * Create communication channel for the driver.
         */
        if ((drv_door_fd = door_create(doorHandler, NULL, 0)) < 0) {
                perror("door_create");
                syslog(LOG_DAEMON|LOG_DEBUG,
                    "could not create door: errno %d", errno);
                return (SMF_EXIT_ERR_FATAL);
        }

        stmf_ret = stmfInitProxyDoor(&proxy_hdl, drv_door_fd);
        if (stmf_ret != STMF_STATUS_SUCCESS) {
                perror("pppt ioctl: door install");
                syslog(LOG_DAEMON|LOG_DEBUG,
                    "could not install door: errno %d", errno);
                return (SMF_EXIT_ERR_FATAL);
        }

        return (SMF_EXIT_OK);
}

/*
 * daemon entry
 *
 * parse arguments
 * create resources to talk to child
 * if !foreground
 *    daemonize, run as child
 * open proxy driver
 * install door in proxy driver
 * create socket
 * if server-side
 *     bind socket
 * if !foreground
 *    inform parent things aok
 * if parent
 *    exit(SMF_EXIT_OK)
 * if server-side
 *    accept
 * if client-side
 *    connect
 * send hello
 * recv hello
 * loop on recieve
 * XXX anyway to check in envp that we are started by SMF?
 */
int
main(int argc, char *argv[])
{
        struct  sockaddr_in sin;
        int     rc;
        struct sigaction        act;
        sigset_t                sigmask;
        int     c;
        int     node = 0;
        int     node_override = 0;
        int     server_node = 0;
        int     server_match = 0;
        extern char *optarg;
        int stmf_ret;

        (void) setlocale(LC_ALL, "");
        openlog("stmfproxy", LOG_PID, LOG_DAEMON);
        (void) setlogmask(LOG_UPTO(LOG_INFO));

        while ((c = getopt(argc, argv, "dfn:")) != -1) {
                switch (c) {
                        case 'd':
                                (void) setlogmask(LOG_UPTO(LOG_DEBUG));
                                log_debug = 1;
                                break;
                        case 'f':
                                fore_ground = 1;
                                break;
                        case 'n':
                                node_override = 1;
                                node = atoi(optarg);
                                break;
                        default:
                                /*
                                 * Should never happen from smf
                                 */
                                (void) fprintf(stderr, USAGE, argv[0]);
                                exit(SMF_EXIT_ERR_CONFIG);
                                break;
                }
        }
        /*
         * After the options, only the server argument should remain.
         */
        if (optind != argc-1) {
                (void) fprintf(stderr, USAGE, argv[0]);
                exit(SMF_EXIT_ERR_CONFIG);
        }
        (void) strcpy(aluaNode, argv[optind]);
        syslog(LOG_DAEMON|LOG_DEBUG, "aluaNode %s", aluaNode);
        if (gethostname(myNode, 255)) {
                perror("gethostname");
                exit(1);
        }
        if ((inet_aton(aluaNode, &sin.sin_addr)) == 0) {
                /*
                 * Not ipaddr, try hostname match.
                 */
                server_match = (strcmp(aluaNode, myNode)) ? 0 : 1;
        } else {
                /*
                 * see if this is our ip address
                 */
                (void) fprintf(stderr, "Sorry, cannot use ip adress format\n");
        }
        if (server_match) {
                server_node = 1;
                if (!node_override)
                        node = 1;
        }


        /*
         * Allow SIGQUIT, SIGINT and SIGTERM signals to terminate us
         */
        act.sa_handler = killHandler;
        (void) sigemptyset(&act.sa_mask);
        act.sa_flags = 0;

        /* Install the signal handler */
        (void) sigaction(SIGQUIT, &act, NULL);
        (void) sigaction(SIGINT, &act, NULL);
        (void) sigaction(SIGTERM, &act, NULL);
        (void) sigaction(SIGHUP, &act, NULL);

        /* block all signals */
        (void) sigfillset(&sigmask);

        /* unblock SIGQUIT, SIGINT, SIGTERM */
        (void) sigdelset(&sigmask, SIGQUIT);
        (void) sigdelset(&sigmask, SIGINT);
        (void) sigdelset(&sigmask, SIGTERM);
        (void) sigdelset(&sigmask, SIGHUP);

        (void) sigprocmask(SIG_SETMASK, &sigmask, NULL);

        /* time to go backstage */
        daemonInit();

        if ((rc = open_proxy_driver()) != 0)
                daemon_fini(rc);

        if ((rc = stmf_proxy_transport_init("sockets", &pt_ops)) != 0)
                daemon_fini(rc);

        /*
         * Establish connection
         *
         * At this point, the parent has exited and the service
         * is online. But there are no real proxy services until
         * this connect call succeeds. That could take a long time if
         * the peer node is down.
         */
        t_handle = pt_ops->stmf_proxy_connect(server_node, aluaNode);
        if (t_handle == NULL) {
                syslog(LOG_DAEMON|LOG_WARNING,
                    "socket() call failed: %d", errno);
                exit(1);
        }

        /* The first message is a greeting */
        (void) postMsg((uint_t)strlen(myNode)+1, (uchar_t *)myNode);
        /* Read the greeting from peer node */
        relay_peer_msg();
        /*
         * Set the alua state in stmf. No need to keep
         * the device open since the proxy driver has a reference.
         */
        stmf_ret = stmfSetAluaState(B_TRUE, node);
        if (stmf_ret != STMF_STATUS_SUCCESS) {
                syslog(LOG_DAEMON|LOG_CRIT, "stmf ioctl failed - %x", stmf_ret);
                exit(1);
        }

        /* service is online */
        daemon_fini(0);

        /*
         * Loop relaying data from the peer daemon to the local kernel.
         * Data coming from the local kernel is handled asynchronously
         * by the door server.
         */
        for (;;) { /* loop forever */
                relay_peer_msg();
        }
}