/*      $NetBSD: iscsid_main.c,v 1.12 2019/02/04 08:21:12 mrg Exp $     */

/*-
 * Copyright (c) 2005,2006,2011 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Wasabi Systems, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "iscsid_globals.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/sysctl.h>

#include <ctype.h>
#include <err.h>
#include <fcntl.h>
#include <syslog.h>
#include <util.h>

#define DEVICE    "/dev/iscsi0"

/* -------------------------------------------------------------------------- */

list_head_t list[NUM_DAEMON_LISTS];     /* the lists this daemon keeps */

pthread_mutex_t sesslist_lock;  /* session list lock */
pthread_t main_thread;          /* main thread handle */
pthread_t event_thread;         /* event thread handle */

int driver = -1;                /* the driver's file desc */
int client_sock;                /* the client communication socket */

int debug_level;                /* How much info to display */
int debugging;

/*
   To avoid memory fragmentation (and speed things up a bit), we use the
   static bufs unless the request or response exceeds the buffer size
   (which it normally shouldn't, assuming we don't have thousands
   of list entries).
*/
static uint8_t req_buf[REQ_BUFFER_SIZE];        /* default buffer for requests */
static uint8_t rsp_buf[RSP_BUFFER_SIZE];        /* default buffer for responses */

/* -------------------------------------------------------------------------- */

static void __dead
usage(void) 
{
        fprintf(stderr, "Usage: %s [-d <lvl>] [-n]\n", getprogname());
        exit(EXIT_FAILURE);
}

/*
 * create_node_name:
 *    Create and set default node name.
 *
 *    Returns 0 on success, else an error code.
 */

static int
create_node_name(void)
{
        iscsi_set_node_name_parameters_t snp;
        uint32_t hid = 0;
        size_t siz;
        int mib[2];
        int total;
        unsigned char *s;

        (void) memset(&snp, 0x0, sizeof(snp));
        mib[0] = CTL_KERN;
        mib[1] = KERN_HOSTID;
        siz = sizeof(hid);
        sysctl(mib, 2, &hid, &siz, NULL, 0);
        mib[1] = KERN_HOSTNAME;
        siz = ISCSI_STRING_LENGTH - 45;
        sysctl(mib, 2, snp.InitiatorAlias, &siz, NULL, 0);

        DEB(3, ("Host Name: <%s>, Host ID: %u", snp.InitiatorAlias, hid));
        if (!snp.InitiatorAlias[0]) {
                printf("Warning: iSCSI Node Name not set (No Host Name)!\n");
                return ISCSID_STATUS_NO_INITIATOR_NAME;
        }
        for (s = snp.InitiatorAlias; *s; s++)
                if (!isalnum((unsigned char) *s) && *s != '-' && *s != '.' && *s != ':')
                        *s = '-';
        total = snprintf((char *)snp.InitiatorName, sizeof(snp.InitiatorName),
                "iqn.1994-04.org.netbsd:iscsi.%s:%u", snp.InitiatorAlias, hid);
        if ((size_t)total > sizeof(snp.InitiatorName)) {
                printf("Warning: iSCSI Node InitiatorName too long to set InitiatorAlias!\n");
                return ISCSID_STATUS_NO_INITIATOR_NAME;
        }

        ioctl(driver, ISCSI_SET_NODE_NAME, &snp);
        return snp.status;
}


/*
 * init_daemon:
 *    Open driver, create communication socket.
 *
 *    Returns:    <0 on error
 */

static int
init_daemon(void)
{
        int sock, i;
        struct sockaddr_un name;
        iscsid_request_t req;

        if ((driver = open(DEVICE, O_RDONLY)) < 0) {
                perror("opening " DEVICE);
                return -1;
        }

        sock = socket(AF_UNIX, SOCK_DGRAM, 0);
        if (sock < 0) {
                perror("opening datagram socket");
                return -1;
        }

        name.sun_family = AF_UNIX;
        strlcpy(name.sun_path, ISCSID_SOCK_NAME, sizeof(name.sun_path));

        req.request = ISCSID_DAEMON_TEST;
        req.parameter_length = 0;

        i = sendto(sock, &req, sizeof(req), 0, (struct sockaddr *)(void *)&name,
                                (socklen_t)sizeof(struct sockaddr_un));
        if (i == sizeof(req)) {
                printf("Daemon already loaded!\n");
                close(sock);
                return -1;
        }

        unlink(ISCSID_SOCK_NAME);
        if (bind(sock, (struct sockaddr *)(void *)&name, (socklen_t)sizeof(struct sockaddr_un))) {
                perror("binding name to socket");
                return -1;
        }

        for (i = 0; i < NUM_DAEMON_LISTS; i++) {
                TAILQ_INIT(&list[i].list);
                list[i].num_entries = 0;
        }

        if ((i = pthread_mutex_init(&sesslist_lock, NULL)) != 0) {
                printf("Mutex init failed (%d)\n", i);
                close(sock);
                return -1;
        }

        if (!register_event_handler()) {
                printf("Couldn't register event handler\n");
                close(sock);
                unlink(ISCSID_SOCK_NAME);
                pthread_mutex_destroy(&sesslist_lock);
                return -1;
        }

        create_node_name();

        return sock;
}


/*
 * make_rsp:
 *    Allocate a response buffer if the static buffer is insufficient, set
 *    the response parameter length.
 *
 *    Parameter:
 *          len         Response parameter size (not counting header)
 *          prsp        Pointer to address of response buffer
 *          prsp_temp   Will be set to TRUE if buffer was allocated, FALSE
 *                      for static buffer.
 *
 *    Returns:    Pointer to response buffer, NULL if allocation failed.
 */

iscsid_response_t *
make_rsp(size_t len, iscsid_response_t ** prsp, int *prsp_temp)
{
        iscsid_response_t *rsp;

        if ((len + sizeof(iscsid_response_t)) > RSP_BUFFER_SIZE) {
                if ((rsp = calloc(1, len)) == NULL) {
                        (*prsp)->status = ISCSID_STATUS_NO_RESOURCES;
                        return NULL;
                }
                *prsp_temp = TRUE;
                *prsp = rsp;
        } else
                rsp = *prsp;

        memset (rsp, 0, len + sizeof(iscsid_response_t));
        rsp->parameter_length = (uint32_t)len;
        return rsp;
}


/*
 * process_message:
 *    minimal parameter check and dispatch for the daemon functions.
 *
 *    Parameter:
 *          req         The request
 *          prsp        Pointer to address of response buffer
 *          prsp_temp   Will be set to TRUE if buffer was allocated, FALSE
 *                      for static buffer.
 */

static void
process_message(iscsid_request_t *req, iscsid_response_t **prsp, int *prsp_temp)
{
        iscsid_response_t *rsp;
        void *p = req->parameter;

        *prsp_temp = FALSE;
        *prsp = rsp = (iscsid_response_t *)(void *)rsp_buf;
        rsp->parameter_length = 0;
        rsp->status = ISCSID_STATUS_SUCCESS;

        switch (req->request) {
        case ISCSID_ADD_TARGET:
                if (req->parameter_length < sizeof(iscsid_add_target_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                add_target((iscsid_add_target_req_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_ADD_PORTAL:
                if (req->parameter_length != sizeof(iscsid_add_portal_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                add_portal((iscsid_add_portal_req_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_SET_TARGET_OPTIONS:
                if (req->parameter_length != sizeof(iscsid_get_set_target_options_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = set_target_options((iscsid_get_set_target_options_t *)p);
                break;

        case ISCSID_GET_TARGET_OPTIONS:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = ISCSID_STATUS_NOTIMPL;
                break;

        case ISCSID_SET_TARGET_AUTHENTICATION:
                if (req->parameter_length !=
                        sizeof(iscsid_set_target_authentication_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = set_target_auth((iscsid_set_target_authentication_req_t *)p);
                break;

        case ISCSID_SLP_FIND_TARGETS:
                rsp->status = ISCSID_STATUS_NOTIMPL;
                break;

        case ISCSID_REFRESH_TARGETS:
                if (req->parameter_length < sizeof(iscsid_refresh_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = refresh_targets((iscsid_refresh_req_t *)p);
                break;

        case ISCSID_REMOVE_TARGET:
                if (req->parameter_length != sizeof(iscsid_list_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = remove_target((iscsid_list_id_t *)p);
                break;

        case ISCSID_SEARCH_LIST:
                if (req->parameter_length != sizeof(iscsid_search_list_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                search_list((iscsid_search_list_req_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_GET_LIST:
                if (req->parameter_length != sizeof(iscsid_get_list_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_list((iscsid_get_list_req_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_GET_TARGET_INFO:
                if (req->parameter_length != sizeof(iscsid_list_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_target_info((iscsid_list_id_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_GET_PORTAL_INFO:
                if (req->parameter_length != sizeof(iscsid_list_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_portal_info((iscsid_list_id_t *)p, prsp, prsp_temp);
                break;

#ifndef ISCSI_MINIMAL
        case ISCSID_ADD_ISNS_SERVER:
                if (req->parameter_length != sizeof(iscsid_add_isns_server_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                add_isns_server((iscsid_add_isns_server_req_t *)p,
                                                prsp, prsp_temp);
                break;

        case ISCSID_GET_ISNS_SERVER:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_isns_server((iscsid_sym_id_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_SLP_FIND_ISNS_SERVERS:
                rsp->status = ISCSID_STATUS_NOTIMPL;
                break;

        case ISCSID_REMOVE_ISNS_SERVER:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = remove_isns_server((iscsid_sym_id_t *)p);
                break;
#endif

        case ISCSID_ADD_INITIATOR_PORTAL:
                if (req->parameter_length != sizeof(iscsid_add_initiator_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                add_initiator_portal((iscsid_add_initiator_req_t *)p,
                                                        prsp, prsp_temp);
                break;

        case ISCSID_GET_INITIATOR_PORTAL:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_initiator_portal((iscsid_sym_id_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_REMOVE_INITIATOR_PORTAL:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = remove_initiator_portal((iscsid_sym_id_t *)p);
                break;

        case ISCSID_LOGIN:
                if (req->parameter_length != sizeof(iscsid_login_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                log_in((iscsid_login_req_t *)p, rsp);
                break;

        case ISCSID_ADD_CONNECTION:
                if (req->parameter_length != sizeof(iscsid_login_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                add_connection((iscsid_login_req_t *)p, rsp);
                break;

        case ISCSID_LOGOUT:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = log_out((iscsid_sym_id_t *)p);
                break;

        case ISCSID_REMOVE_CONNECTION:
                if (req->parameter_length != sizeof(iscsid_remove_connection_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = remove_connection((iscsid_remove_connection_req_t *)p);
                break;

        case ISCSID_GET_SESSION_LIST:
                get_session_list(prsp, prsp_temp);
                break;

        case ISCSID_GET_CONNECTION_LIST:
                if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_connection_list((iscsid_sym_id_t *)p, prsp, prsp_temp);
                break;

        case ISCSID_GET_CONNECTION_INFO:
                if (req->parameter_length != sizeof(iscsid_get_connection_info_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                get_connection_info((iscsid_get_connection_info_req_t *)p,
                                                        prsp, prsp_temp);
                break;

        case ISCSID_SET_NODE_NAME:
                if (req->parameter_length != sizeof(iscsid_set_node_name_req_t)) {
                        rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
                        break;
                }
                rsp->status = set_node_name((iscsid_set_node_name_req_t *)p);
                break;

        case ISCSID_GET_VERSION:
                get_version(prsp, prsp_temp);
                break;

        default:
                rsp->status = ISCSID_STATUS_INVALID_REQUEST;
                break;
        }
}

void
iscsid_log(const char *fmt, ...)
{
        va_list ap;
        va_start(ap, fmt);
        vsyslog(LOG_INFO, fmt, ap);
        va_end(ap);
}

/*
 * exit_daemon:
 *    Deregister the event handler, deregister isns servers, then exit program.
 */

static void __dead
exit_daemon(void)
{
        LOCK_SESSIONS;
        deregister_event_handler();

#ifndef ISCSI_MINIMAL
        dereg_all_isns_servers();
#endif
        exit(0);
}

static void
handler_exit(void)
{
        pthread_kill(main_thread, SIGINT);
}

static void
sighandler(int sig)
{
}

/*
 * main:
 *    init, go daemon, then loop reading requests, processing them,
 *    and sending responses.
 *    Stops on receiving a terminate message (no response to that one is sent),
 *    or when an error occurs reading or writing the socket.
 *
 *    Parameter:  argc, argv currently ignored.
 */

int
/*ARGSUSED*/
main(int argc, char **argv)
{
        int req_temp, rsp_temp, c;
        ssize_t ret;
        size_t len;
        struct sockaddr_un from;
        socklen_t fromlen;
        iscsid_request_t *req;
        iscsid_response_t *rsp;
        char *p;
        struct sigaction sa;

        while ((c = getopt(argc, argv, "Dd:")) != -1)
                switch (c) {
                case 'D':
                        debugging++;
                        break;
                case 'd':
                        debug_level=(int)strtol(optarg, &p, 10);
                        if (*p)
                                errx(EXIT_FAILURE, "illegal log level -- %s",
                                    optarg);
                        break;
                default:
                        usage();
                }

        openlog("iscsid", (debugging ? LOG_PERROR : 0) | LOG_PID, LOG_DAEMON);

        client_sock = init_daemon();
        if (client_sock < 0)
                exit(1);

        DEBOUT(("iSCSI daemon loaded"));

        if (!debugging) {
                if (daemon(0, 1) < 0)
                        err(EXIT_FAILURE, "daemon() failed");
                pidfile(NULL);
        }

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

        main_thread = pthread_self();
        ret = pthread_create(&event_thread, NULL, event_handler, handler_exit);
        if (ret) {
                printf("Thread creation failed (%zd)\n", ret);
                close(client_sock);
                unlink(ISCSID_SOCK_NAME);
                deregister_event_handler();
                pthread_mutex_destroy(&sesslist_lock);
                return -1;
        }

    /* ---------------------------------------------------------------------- */

        for (;;) {

                /* First, get size of request */
                req = (iscsid_request_t *)(void *)req_buf;
                fromlen = sizeof(from);
                len = sizeof(iscsid_request_t);

                do {
                        ret = recvfrom(client_sock, req, len, MSG_PEEK |
                            MSG_WAITALL, (struct sockaddr *) &from,
                            &fromlen);
                } while (ret == -1 && errno == EAGAIN);

                if ((size_t)ret != len) {
                        DEBOUT(("Receiving from socket: %s",strerror(errno)));
                        break;
                }
                DEB(2, ("Request %d, parlen %d",
                                req->request, req->parameter_length));

                len += req->parameter_length;

                /* now that we know the size, get the buffer for it */
                req_temp = (len > REQ_BUFFER_SIZE);

                if (req_temp) {
                        req = malloc(len);
                        if (!req) {
                                printf("Can't alloc %zu bytes\n", len);
                                break;
                        }
                }
                /* read the complete request */
                fromlen = sizeof(from);
                ret = recvfrom(client_sock, req, len, MSG_WAITALL,
                                                (struct sockaddr *)(void *)&from, &fromlen);
                if ((size_t)ret != len) {
                        DEB(2, ("Error receiving from socket!"));
                        if (req_temp)
                                free(req);
                        continue;
                }
                /* terminate? then go die. */
                if (req->request == ISCSID_DAEMON_TERMINATE)
                        break;

                /* No reply required to test message */
                if (req->request == ISCSID_DAEMON_TEST) {
                        if (req_temp)
                                free(req);
                        DEB(2, ("Test message!"));
                        continue;
                }
                /* no return path? then we can't send a reply, */
                /* so don't process the command */
                if (!from.sun_path[0]) {
                        if (req_temp)
                                free(req);
                        DEB(2, ("No Return Address!"));
                        continue;
                }
                /* process the request */
                process_message(req, &rsp, &rsp_temp);
                if (rsp == NULL) {
                        if (req_temp)
                                free(req);
                        DEB(2, ("Invalid message!"));
                        continue;
                }

                DEB(2, ("Sending reply: status %d, len %d",
                                rsp->status, rsp->parameter_length));

                /* send the response */
                len = sizeof(iscsid_response_t) + rsp->parameter_length;
                ret = sendto(client_sock, rsp, len, 0,
                                        (struct sockaddr *)(void *)&from, fromlen);
                if (len != (size_t)ret) {
                        DEB(2, ("Error sending reply!"));
                }
                /* free temp buffers if we needed them */
                if (req_temp)
                        free(req);
                if (rsp_temp)
                        free(rsp);
        }

        pthread_join(event_thread, NULL);

        DEBOUT(("Exiting daemon"));

        exit_daemon();

        /* we never get here */
        return 0;
}