/*      $NetBSD: iscsic_main.c,v 1.6 2015/05/30 15:57:32 joerg 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 <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/un.h>

#include "iscsic_globals.h"

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>

#define DEVICE    "/dev/iscsi0"

#define ISCSICTL_VERSION        "20110805"

/*
 *-------- Table of commands and the associated handler function -------------
*/

static command_t cmds[] = {
        {"version", get_version},
        {"add_target", add_target},
        {"add_portal", add_portal},
        {"remove_target", remove_target},
        {"slp_find_targets", slp_find_targets},
        {"refresh_targets", refresh_targets},
        {"list_targets", list_targets},
        {"add_send_target", add_send_target},
        {"remove_send_target", remove_send_target},
        {"list_send_targets", list_send_targets},
        {"add_isns_server", add_isns_server},
        {"remove_isns_server", remove_isns_server},
        {"find_isns_servers", find_isns_servers},
        {"list_isns_servers", list_isns_servers},
        {"refresh_isns", refresh_isns},
        {"login", login},
        {"logout", logout},
        {"add_connection", add_connection},
        {"remove_connection", remove_connection},
        {"inquiry", inquiry},
        {"read_capacity", read_capacity},
        {"report_luns", report_luns},
        {"test_unit_ready", test_unit_ready},
        {"add_initiator", add_initiator},
        {"remove_initiator", remove_initiator},
        {"list_initiators", list_initiators},
        {"list_sessions", list_sessions},
        {"set_node_name", set_node_name},
        {NULL, NULL}
};


/*
 *-------- Table of error codes and the associated message text -------------
*/

typedef struct {
        unsigned         code;
        const char      *str;
} status_msg_t;

static status_msg_t status_msg[] = {
        {ISCSI_STATUS_LIST_EMPTY, "The list is empty"},
        {ISCSI_STATUS_DUPLICATE_NAME, "The specified name is not unique"},
        {ISCSI_STATUS_GENERAL_ERROR, "A non-specific error occurred"},
        {ISCSI_STATUS_LOGIN_FAILED, "The login failed"},
        {ISCSI_STATUS_CONNECTION_FAILED, "The attempt to establish a connection failed"},
        {ISCSI_STATUS_AUTHENTICATION_FAILED, "Authentication negotiation failed"},
        {ISCSI_STATUS_NO_RESOURCES, "Could not allocate resources (e.g. memory)"},
        {ISCSI_STATUS_MAXED_CONNECTIONS, "Maximum number of connections exceeded"},
        {ISCSI_STATUS_INVALID_SESSION_ID, "Session ID not found"},
        {ISCSI_STATUS_INVALID_CONNECTION_ID, "Connection ID not found"},
        {ISCSI_STATUS_INVALID_SOCKET, "Specified socket is invalid"},
        {ISCSI_STATUS_NOTIMPL, "Feature not implemented"},
        {ISCSI_STATUS_CHECK_CONDITION, "Target reported CHECK CONDITION"},
        {ISCSI_STATUS_TARGET_BUSY, "Target reported BUSY"},
        {ISCSI_STATUS_TARGET_ERROR, "Target reported other error"},
        {ISCSI_STATUS_TARGET_FAILURE, "Command Response was Target Failure"},
        {ISCSI_STATUS_TARGET_DROP, "Target dropped connection"},
        {ISCSI_STATUS_SOCKET_ERROR, "Communication failure"},
        {ISCSI_STATUS_PARAMETER_MISSING, "A required ioctl parameter is missing"},
        {ISCSI_STATUS_PARAMETER_INVALID, "A parameter is malformed (string too long etc.)"},
        {ISCSI_STATUS_MAP_FAILED, "Mapping the LUNs failed"},
        {ISCSI_STATUS_NO_INITIATOR_NAME, "Initiator name not set"},
        {ISCSI_STATUS_NEGOTIATION_ERROR, "Negotiation failure (invalid key or value)"},
        {ISCSI_STATUS_TIMEOUT, "Command timed out (at iSCSI level)"},
        {ISCSI_STATUS_PROTOCOL_ERROR, "Internal Error (Protocol error reject)"},
        {ISCSI_STATUS_PDU_ERROR, "Internal Error (Invalid PDU field reject)"},
        {ISCSI_STATUS_CMD_NOT_SUPPORTED, "Target does not support iSCSI command"},
        {ISCSI_STATUS_DRIVER_UNLOAD, "Driver is unloading"},
        {ISCSI_STATUS_LOGOUT, "Session was logged out"},
        {ISCSI_STATUS_PDUS_LOST, "Excessive PDU loss"},
        {ISCSI_STATUS_INVALID_EVENT_ID, "Invalid Event ID"},
        {ISCSI_STATUS_EVENT_DEREGISTERED, "Wait for event cancelled by deregistration"},
        {ISCSI_STATUS_EVENT_WAITING, "Already waiting for event"},
        {ISCSI_STATUS_TASK_NOT_FOUND, "Task Management: task not found"},
        {ISCSI_STATUS_LUN_NOT_FOUND, "Task Management: LUN not found"},
        {ISCSI_STATUS_TASK_ALLEGIANT, "Task Management: Task still allegiant"},
        {ISCSI_STATUS_CANT_REASSIGN, "Task Management: Task reassignment not supported"},
        {ISCSI_STATUS_FUNCTION_UNSUPPORTED, "Task Management: Function unsupported"},
        {ISCSI_STATUS_FUNCTION_NOT_AUTHORIZED, "Task Management: Function not authorized"},
        {ISCSI_STATUS_FUNCTION_REJECTED, "Task Management: Function rejected"},
        {ISCSI_STATUS_UNKNOWN_REASON, "Task Management: Unknown reason code"},
        {ISCSI_STATUS_DUPLICATE_ID, "Duplicate ID"},
        {ISCSI_STATUS_INVALID_ID, "ID not found"},
        {ISCSI_STATUS_TARGET_LOGOUT, "Target requested logout"},
        {ISCSI_STATUS_LOGOUT_CID_NOT_FOUND, "Logout error: Connection ID not found"},
        {ISCSI_STATUS_LOGOUT_RECOVERY_NS, "Logout error: Recovery not supported"},
        {ISCSI_STATUS_LOGOUT_ERROR, "Logout error: Unknown reason"},

        {ISCSID_STATUS_LIST_EMPTY, "The list is empty"},
        {ISCSID_STATUS_DUPLICATE_NAME, "The specified name is not unique"},
        {ISCSID_STATUS_GENERAL_ERROR, "A non-specific error occurred"},
        {ISCSID_STATUS_CONNECT_ERROR, "Failed to connect to target"},
        {ISCSID_STATUS_NO_RESOURCES, "Could not allocate resources (e.g. memory)"},
        {ISCSID_STATUS_INVALID_SESSION_ID, "Session ID not found"},
        {ISCSID_STATUS_INVALID_CONNECTION_ID, "Connection ID not found"},
        {ISCSID_STATUS_NOTIMPL, "Feature not implemented"},
        {ISCSID_STATUS_SOCKET_ERROR, "Failed to create socket"},
        {ISCSID_STATUS_PARAMETER_MISSING, "A required parameter is missing"},
        {ISCSID_STATUS_PARAMETER_INVALID, "Request parameter is invalid"},
        {ISCSID_STATUS_NO_INITIATOR_NAME, "Initiator name was not set"},
        {ISCSID_STATUS_TIMEOUT, "Request timed out"},
        {ISCSID_STATUS_DRIVER_NOT_LOADED, "iSCSI Driver not loaded"},
        {ISCSID_STATUS_INVALID_REQUEST, "Unknown request code"},
        {ISCSID_STATUS_INVALID_PORTAL_ID, "Portal ID not found"},
        {ISCSID_STATUS_INVALID_TARGET_ID, "Target ID not found"},
        {ISCSID_STATUS_NOT_FOUND, "Requested item not found"},
        {ISCSID_STATUS_HOST_NOT_FOUND, "Target address not found"},
        {ISCSID_STATUS_HOST_TRY_AGAIN, "Target address retrieval failed, try again later"},
        {ISCSID_STATUS_HOST_ERROR, "Target address invalid"},
        {ISCSID_STATUS_NO_TARGETS_FOUND, "No targets found"},
        {ISCSID_STATUS_INVALID_ISNS_ID, "iSNS ID not found"},
        {ISCSID_STATUS_ISNS_ERROR, "Problem connecting to iSNS"},
        {ISCSID_STATUS_ISNS_SERVER_ERROR, "iSNS server returned garbage"},
        {ISCSID_STATUS_DUPLICATE_ENTRY, "The entry already exists"},
        {ISCSID_STATUS_INVALID_INITIATOR_ID, "Initiator ID not found"},
        {ISCSID_STATUS_INITIATOR_BIND_ERROR, "Bind to initiator portal failed"},

        {0, NULL}
};

/* -------------------------------------------------------------------------- */
/* local variables */

static struct sockaddr_un       daemon_name;    /* daemon socket name */

static char                     sockdir[MAXPATHLEN]; /* where myname lives */
static struct sockaddr_un       myname;         /* my socket name */
static int                      sock;           /* the socket */

static char *cmdname;                   /* pointer to command name for error msgs */

/* global variables */

uint8_t buf[BUF_SIZE];                  /* buffer for daemon comm and driver I/O */

int driver;                                             /* driver handle */

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

#define progname  getprogname()


/*
 * bye:
 *    Cleanup and exit. Does not return.
*/

__dead static void
bye(void)
{
        close(sock);
        (void) unlink(myname.sun_path);
        (void) rmdir(sockdir);
        exit(EXIT_FAILURE);
}


/*
 * arg_error:
 *    Display error message about an invalid argument, exit.
 *
 *    Parameters:
 *       argp        Argument value
 *       fmt         Error message
 *       ...         additional output arguments
 *
 *    Does not return.
*/

void
arg_error(char *argp, const char *fmt, ...)
{
        va_list args;
        char    lbuf[BUF_SIZE];

        va_start(args, fmt);
        vsnprintf(lbuf, sizeof(lbuf), fmt, args);
        fprintf(stderr, "%s: %s: Invalid option at or near '%s': %s\n",
                progname, cmdname, argp, lbuf);
        bye();
}


/*
 * arg_missing:
 *    Display error message about a missing argument, exit.
 *
 *    Parameters:
 *       arg      Argument name
 *
 *    Does not return.
 */

void
arg_missing(const char *arg)
{
        warnx("%s: Missing argument: %s", cmdname, arg);
        bye();
}


/*
 * io_error:
 *    Display error message about an I/O error (includes system error code)
 *
 *    Parameters:
 *       fmt         format string
 *       ...         additional output arguments
 *
 *    Does not return.
 */

void
io_error(const char *fmt, ...)
{
        va_list args;
        char    lbuf[BUF_SIZE];

        va_start(args, fmt);
        vsnprintf(lbuf, sizeof(lbuf), fmt, args);
        fprintf(stderr, "%s: %s: %s: %s\n",
                progname, cmdname, lbuf, strerror(errno));
        bye();
}


/*
 * gen_error:
 *    Display general error message.
 *
 *    Parameters:
 *       fmt         format string
 *       ...         additional output arguments
 *
 *    Does not return.
 */

void
gen_error(const char *fmt, ...)
{
        va_list args;
        char    lbuf[BUF_SIZE];

        va_start(args, fmt);
        vsnprintf(lbuf, sizeof(lbuf), fmt, args);
        fprintf(stderr, "%s: %s: %s\n", progname, cmdname, lbuf);
        bye();
}


/*
 * check_extra_args:
 *    Display error message & exit if there is an unrecognized argument.
 *
 *    Parameters:
 *       argc     Argument count
 *       argv     Argument value array.
 *
 *    Does not return if an extra arg is found.
 */

void
check_extra_args(int argc, char **argv)
{
        int i;

        for (i = 0; i < argc; i++)
                if (argv[i] != NULL) {
                        warnx("%s: Unrecognized argument '%s'", cmdname, argv[i]);
                        bye();
                }
}


/*
 * status_error:
 *    Display error message for status returned by daemon or driver, exit.
 *
 *    Parameters:
 *          n     Status code.
 *
 *    Does not return.
 */

void
status_error(unsigned n)
{
        int i;

        for (i = 0; status_msg[i].code; i++)
                if (status_msg[i].code == n)
                        break;

        if (status_msg[i].code)
                warnx("%s: %s", cmdname, status_msg[i].str);
        else
                warnx("%s: Undefined error code %d", cmdname, n);

        bye();
}


/*
 * status_error_slist:
 *    Display error message for status returned by daemon or driver, but
 *        replace a "list is empty" code by an "ID not found" code, exit.
 *
 *    Parameters:
 *          n     Status code.
 *
 *    Does not return.
 */

void
status_error_slist(unsigned n)
{
        if (n == ISCSI_STATUS_LIST_EMPTY || n == ISCSID_STATUS_LIST_EMPTY)
                n = ISCSI_STATUS_INVALID_ID;
        status_error (n);
}


/*
 * get_response:
 *    Read the response from the daemon.
 *
 *    Parameters:
 *          temp  If TRUE, the response is dynamically allocated (so it is not
 *                overwritten by further requests or responses).
 *
 *    Returns:
 *          Pointer to the response.
 *
 *    Notes:
 *       This routine allocates an extra integer to mark whether the returned
 *       buffer is dynamic or static. This marker is one int before the
 *       returned pointer.
 */

iscsid_response_t *
get_response(int temp)
{
        ssize_t ret;
        size_t len;
        iscsid_response_t *rsp;
        int *pbuf;

        pbuf = (int *)(void *)buf;
        rsp = (iscsid_response_t *)(void *)&pbuf[1];
        *pbuf = 0;

        /* get size of response */
        len = sizeof(iscsid_response_t);
        ret = recv(sock, rsp, len, MSG_PEEK | MSG_WAITALL);
        if ((size_t)ret != len)
                io_error("Receiving daemon data");

        len += rsp->parameter_length;

        /*
           if a temp buffer has been requested, or if the response is too large
           to fit into the static buffer, alloc a temp buffer.
         */

        temp = temp || (len > (int)(sizeof(buf) - sizeof(int)));

        if (temp) {
                if (NULL == (pbuf = (int *) malloc(len + sizeof(int))))
                        gen_error("Can't allocate response buffer (%zu bytes)",
                                len + sizeof(int));

                rsp = (iscsid_response_t *)(void *)&pbuf[1];
                *pbuf = 1;
        }
        /* get the complete response */

        ret = recv(sock, rsp, len, MSG_WAITALL);
        if ((size_t)ret != len)
                io_error("Receiving daemon data");

        return rsp;
}


/*
 * free_response:
 *    If the response buffer was dynamically allocated, free it.
 *
 *    Parameters:
 *          rsp   The response buffer.
 *                The dynamic allocation marker is the int preceding
 *                this address.
 */

void
free_response(iscsid_response_t * rsp)
{
        int *pbuf;

        pbuf = ((int *)(void *)rsp) - 1;
        if (*pbuf)
                free(pbuf);
}


/*
 * send_request:
 *    Send a request to the daemon.
 *
 *    Parameters:
 *          request  The request code.
 *          par_len  The parameter length.
 *          par      The parameter.
 */

void
send_request(unsigned request, size_t par_len, void *par)
{
        iscsid_request_t *req;
        size_t len;
        ssize_t ret;
        int req_temp;

        len = sizeof(iscsid_request_t) + par_len;

        /* alloc buffer if static one is too small to hold request */
        req_temp = len > sizeof(buf);

        if (req_temp) {
                req = malloc(len);
                if (req == NULL)
                        gen_error("Out of memory allocating %zu bytes\n", len);
        } else
                req = (iscsid_request_t *)(void *)buf;

        /* setup request */
        req->request = request;
        req->parameter_length = (uint32_t)par_len;
        if (par_len)
                memcpy(req->parameter, par, par_len);

        /* and send it out */
        ret = sendto(sock, req, len, 0, (struct sockaddr *)(void *)&daemon_name,
                                 (socklen_t)sizeof(struct sockaddr_un));
        if ((size_t)ret != len) {
                io_error("Sending daemon message");
        }
        if (req_temp)
                free(req);
}


/*
 * main:
 *    check command, init driver handle and socket, dispatch command.
 *
 *    Parameter:  argc, argv - passed on to commands with offset of 2, so
 *                argv [0] is first argument after command verb.
 *
 *    Returns:
 *          Whatever the command handler returns, which is currently always 0.
 */

int
main(int argc, char **argv)
{
        command_t       *c;
        int              res;
        int              i;

        (void) snprintf(sockdir, sizeof(sockdir), "/tmp/iscsictl.XXXXXX");
        while ((i = getopt(argc, argv, "d:")) != -1) {
                switch(i) {
                case 'd':
                        (void) snprintf(sockdir, sizeof(sockdir), "%s", optarg);
                        break;
                default:
                        break;
                }
        }
        if (argc - optind  < 1) {
                errx(EXIT_FAILURE, "Usage: %s <command> <options>, see manual for details.",
                        progname);
        }

        cmdname = argv[optind];

        for (c = cmds; c->cmd != NULL; c++) {
                if (strcmp(c->cmd, cmdname) == 0) {
                        break;
                }
        }
        if (c->cmd == NULL) {
                errx(EXIT_FAILURE, "Unknown command: '%s'", cmdname);
        }
        if ((driver = open(DEVICE, O_RDONLY)) < 0)
                err(EXIT_FAILURE, "Opening " DEVICE);

        sock = socket(AF_UNIX, SOCK_DGRAM, 0);
        if (sock < 0)
                err(EXIT_FAILURE, "opening datagram socket");

        /* bind socket to unique name */
        if (mkdtemp(sockdir) == NULL) {
                errx(EXIT_FAILURE, "can't create iscsictl dir '%s'", sockdir);
        }
        myname.sun_family = AF_UNIX;
        (void) snprintf(myname.sun_path, sizeof(myname.sun_path), "%s/socket", sockdir);
        if (bind(sock, (struct sockaddr *)(void *)&myname,
            (socklen_t)sizeof(struct sockaddr_un)) < 0) {
                io_error("Binding name to datagram socket");
        }
        daemon_name.sun_family = AF_UNIX;
        strlcpy(daemon_name.sun_path, ISCSID_SOCK_NAME,
                sizeof(daemon_name.sun_path));

        /* dispatch command */
        res = (*c->proc)(argc - optind - 1, &argv[optind + 1]);

        /* cleanup */
        close(sock);
        unlink(myname.sun_path);
        rmdir(sockdir);

        return res;
}