/*
 * 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);
	}
}