/*
 * 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 2000 by Cisco Systems, Inc.  All rights reserved.
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * iSCSI Software Initiator
 */

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/stat.h>
#include <sys/pathname.h>
#include <sys/door.h>
#include <sys/kmem.h>
#include <sys/socket.h>
#include <sys/fs/snode.h>
#include <netinet/in.h>

#include <sys/scsi/adapters/iscsi_door.h>
#include "iscsi.h"

#define ISCSI_DOOR_MAX_SEMA_VALUE       16

static boolean_t        iscsi_door_init = B_FALSE;
static ksema_t          iscsi_door_sema;
static krwlock_t        iscsi_door_lock;
static door_handle_t    iscsi_door_handle;

typedef struct _mybuffer {
        size_t          signature;
        size_t          size;
} mybuffer_t;

/*
 * iscsi_door_ini
 *
 * This function initializes the variables needed to handle the door upcall.
 */
boolean_t
iscsi_door_ini(void)
{
        ASSERT(!iscsi_door_init);
        if (!iscsi_door_init) {
                rw_init(
                    &iscsi_door_lock,
                    NULL,
                    RW_DRIVER,
                    NULL);

                sema_init(
                    &iscsi_door_sema,
                    ISCSI_DOOR_MAX_SEMA_VALUE,
                    NULL,
                    SEMA_DRIVER,
                    NULL);

                iscsi_door_handle = NULL;
                iscsi_door_init = B_TRUE;
                return (B_TRUE);
        }
        return (B_FALSE);
}

/*
 * iscsi_door_term
 *
 * This function releases the resources allocated to handle the door
 * upcall.  It disconnects from the door if currently connected.
 */
boolean_t
iscsi_door_term(void)
{
        ASSERT(iscsi_door_init);
        if (iscsi_door_init) {
                iscsi_door_init = B_FALSE;
                iscsi_door_unbind();
                rw_destroy(&iscsi_door_lock);
                sema_destroy(&iscsi_door_sema);
                return (B_TRUE);
        }
        return (B_FALSE);
}

/*
 * iscsi_door_bind
 *
 * This function tries to connect the iscsi_door.  If it succeeds
 * it keeps the vnode.
 */
boolean_t
iscsi_door_bind(
        int             did
)
{
        door_handle_t   new_handle;

        new_handle = door_ki_lookup(did);
        if (new_handle == NULL) {
                /* The lookup failed. */
                return (B_FALSE);
        }

        /* The new handle is stored.  If we had one, it is released. */
        rw_enter(&iscsi_door_lock, RW_WRITER);
        if (iscsi_door_handle != NULL) {
                door_ki_rele(iscsi_door_handle);
        }
        iscsi_door_handle = new_handle;
        rw_exit(&iscsi_door_lock);

        return (B_TRUE);
}

/*
 * iscsi_door_unbind
 *
 * This function releases the current door handle.
 */
void
iscsi_door_unbind(void)
{
        rw_enter(&iscsi_door_lock, RW_WRITER);
        if (iscsi_door_handle != NULL) {
                door_ki_rele(iscsi_door_handle);
                iscsi_door_handle = NULL;
        }
        rw_exit(&iscsi_door_lock);
}

/*
 * iscsi_door_upcall
 *
 * This function tries to call the iscsi_door.
 */
static
boolean_t
iscsi_door_upcall(door_arg_t *arg)
{
        int     error;

        /*
         * This semaphore limits the number of simultaneous calls
         * to the door.
         */
        sema_p(&iscsi_door_sema);
        /*
         * The mutex protecting the iscsi_door_handle is entered.
         */
        rw_enter(&iscsi_door_lock, RW_READER);

        if (iscsi_door_handle == NULL) {
                /* There's no door handle. */
                rw_exit(&iscsi_door_lock);
                sema_v(&iscsi_door_sema);
                return (B_FALSE);
        }
        error = door_ki_upcall(iscsi_door_handle, arg);

        rw_exit(&iscsi_door_lock);
        sema_v(&iscsi_door_sema);

        if (error != 0) {
                return (B_FALSE);
        } else {
                return (B_TRUE);
        }
}

/*
 * kfreehostent
 *
 * This function frees the memory returned by kgetipnodebyname.
 */
void
kfreehostent(
        struct hostent          *hptr
)
{
        mybuffer_t              *buffer;

        ASSERT(hptr != NULL);
        if (hptr) {
                buffer = (mybuffer_t *)((char *)hptr - sizeof (mybuffer_t));
                ASSERT(buffer->signature == ISCSI_DOOR_REQ_SIGNATURE);
                if (buffer->signature == ISCSI_DOOR_REQ_SIGNATURE) {
                        kmem_free((void *)buffer, buffer->size);
                        return;
                }
        }
        /* A message should be logged here. */
}

/*
 * kgetipnodebyname
 *
 * This function builds a request that will be sent to the iscsi_door.
 * The iSCSI door after receiving the request calls getipnodebyaddr().
 * for more information on the input, output parameter and return value,
 * consult the man page for getipnodebyname().
 *
 * Before calling the iscsi door this function tries to do the conversion
 * locally.  If a name resolution is needed the iscsi door is called.
 *
 * There's some limitations to the information returned by this function.
 * Only one address of the address list returned by getipnodebyname() is
 * returned.  The other parameters of the structure should be ignored.
 */
struct hostent *
kgetipnodebyname(
        const char      *name,
        int             af,
        int             flags,
        int             *error_num
)
{
        door_arg_t              arg;
        mybuffer_t              *buffer;
        size_t                  msg_size = ISCSI_DOOR_MAX_DATA_SIZE;
        size_t                  hostent_size = ISCSI_DOOR_MAX_DATA_SIZE;
        size_t                  buffer_size;
        getipnodebyname_req_t   *req;
        getipnodebyname_cnf_t   *cnf;
        struct hostent          *hptr;


        buffer_size = msg_size + hostent_size + sizeof (mybuffer_t);
        buffer = (mybuffer_t *)kmem_zalloc(buffer_size, KM_SLEEP);

        if (buffer) {

                /*
                 * The buffer was successfully allocated.
                 *
                 *        Buffer
                 *
                 * +--------------------+ <--- buffer
                 * |    mybuffer_t      |
                 * +--------------------+ <--- hptr
                 * |                    |
                 * |                    |
                 * |    hostent_size    |
                 * |                    |
                 * |                    |
                 * |                    |
                 * +--------------------+ <--- req, cnf
                 * |                    |
                 * |                    |
                 * |                    |
                 * |    msg_size        |
                 * |                    |
                 * |                    |
                 * |                    |
                 * +--------------------+
                 */
                buffer->signature = ISCSI_DOOR_REQ_SIGNATURE;
                buffer->size = buffer_size;

                hptr = (struct hostent *)((char *)buffer + sizeof (mybuffer_t));
                req = (getipnodebyname_req_t *)((char *)hptr + hostent_size);
                cnf = (getipnodebyname_cnf_t *)((char *)hptr + hostent_size);

                hostent_size -= sizeof (struct hostent);

                /*
                 * We try first locally.  If the conversion cannot be done
                 * by inet_pton the door is called.
                 * The cnf address is used as output buffer.
                 * inet_pton returns '1' if the conversion was successful.
                 */
                switch (af) {
                case AF_INET:
                        hptr->h_length = sizeof (struct in_addr);
                        break;
                case AF_INET6:
                        hptr->h_length = sizeof (struct in6_addr);
                        break;
                default:
                        kfreehostent(hptr);
                        *error_num = NO_RECOVERY;
                        return (NULL);
                }
                if ((msg_size < hptr->h_length) ||
                    (hostent_size < sizeof (char *))) {
                        kfreehostent(hptr);
                        *error_num = NO_RECOVERY;
                        return (NULL);
                }
                if (inet_pton(af, (char *)name, cnf) == 1) {
                        /*
                         * inet_pton converted the string successfully.
                         */
                        hptr->h_addrtype = af;
                        hptr->h_addr_list = (char **)((char *)hptr +
                            sizeof (struct hostent));
                        *hptr->h_addr_list = (char *)cnf;
                        return (hptr);
                }

                /*
                 * The name couldn't ne converted by inet_pton.  The door is
                 * called.
                 */

                /* Header initialization. */
                req->hdr.signature = ISCSI_DOOR_REQ_SIGNATURE;
                req->hdr.version = ISCSI_DOOR_REQ_VERSION_1;
                req->hdr.opcode = ISCSI_DOOR_GETIPNODEBYNAME_REQ;

                /* Body initialization. */
                req->name_length = strlen(name);
                if (req->name_length >
                    (msg_size - sizeof (getipnodebyname_req_t) - 1)) {
                        kfreehostent(hptr);
                        *error_num = NO_RECOVERY;
                        return (NULL);
                }

                req->name_offset = sizeof (getipnodebyname_req_t);
                req->af = af;
                req->flags = flags;
                bcopy(
                    name,
                    ((char *)req + req->name_offset),
                    req->name_length);

                /* Door argument initialization. */
                arg.data_ptr = (char *)req;
                arg.data_size = msg_size;
                arg.desc_num = 0;
                arg.desc_ptr = NULL;
                arg.rbuf = (char *)cnf;
                arg.rsize = msg_size;

                if (iscsi_door_upcall(&arg) == B_FALSE) {
                        /* The door call failed */
                        kfreehostent(hptr);
                        *error_num = NO_RECOVERY;
                        return (NULL);
                }

                /*
                 * The door call itself was successful.  The value returned
                 * in arg.rbuf should be cnf, but we never know.
                 */
                cnf = (getipnodebyname_cnf_t *)arg.rbuf;

                if ((cnf == NULL) ||
                    (arg.rsize < sizeof (getipnodebyname_cnf_t)) ||
                    (cnf->hdr.signature != ISCSI_DOOR_REQ_SIGNATURE) ||
                    (cnf->hdr.version != ISCSI_DOOR_REQ_VERSION_1) ||
                    (cnf->hdr.opcode != ISCSI_DOOR_GETIPNODEBYNAME_CNF) ||
                    ((cnf->hdr.status != ISCSI_DOOR_STATUS_SUCCESS) &&
                    (cnf->hdr.status != ISCSI_DOOR_STATUS_MORE))) {
                        /* The door didn't like the request */
                        kfreehostent(hptr);
                        *error_num = NO_RECOVERY;
                        return (NULL);
                }

                if (cnf->h_addr_list_length == 0) {
                        kfreehostent(hptr);
                        *error_num = HOST_NOT_FOUND;
                        return (NULL);
                }

                hptr->h_addrtype = cnf->h_addrtype;
                hptr->h_length = cnf->h_addrlen;
                hptr->h_addr_list = (char **)((char *)hptr +
                    sizeof (struct hostent));
                *hptr->h_addr_list = ((char *)cnf + cnf->h_addr_list_offset);
                return (hptr);
        } else {
                *error_num = NO_RECOVERY;
                return (NULL);
        }
}