/*

 * iSCSI Netlink/Linux Interface

 *

 * Copyright (C) 2004 Dmitry Yusupov, Alex Aizman

 * Copyright (C) 2006 Mike Christie

 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.

 * maintained by open-iscsi@googlegroups.com

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published

 * by the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * General Public License for more details.

 *

 * See the file COPYING included with this distribution for more details.

 */

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <stdint.h>

#include <errno.h>

#include <time.h>

#include <inttypes.h>

#include <asm/types.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <poll.h>

#include <linux/netlink.h>

#include "types.h"

#include "iscsi_if.h"

#include "log.h"

#include "iscsi_ipc.h"

#include "initiator.h"

#include "iscsi_sysfs.h"

#include "transport.h"

#include "iscsi_netlink.h"

#include "iscsi_err.h"

#include "iscsi_timer.h"

static int ctrl_fd;

static struct sockaddr_nl src_addr, dest_addr;

static void *xmitbuf = NULL;

static int xmitlen = 0;

static void *recvbuf = NULL;

static int recvlen = 0;

static void *nlm_sendbuf;

static void *nlm_recvbuf;

static void *pdu_sendbuf;

static void *setparam_buf;

static struct iscsi_ipc_ev_clbk *ipc_ev_clbk;

static int ctldev_handle(void);

#define NLM_BUF_DEFAULT_MAX (NLMSG_SPACE(ISCSI_DEF_MAX_RECV_SEG_LEN +	\

					sizeof(struct iscsi_uevent) +	\

					sizeof(struct iscsi_hdr)))

#define PDU_SENDBUF_DEFAULT_MAX	(ISCSI_DEF_MAX_RECV_SEG_LEN +		\

					sizeof(struct iscsi_uevent) +	\

					sizeof(struct iscsi_hdr))

#define NLM_SETPARAM_DEFAULT_MAX (NI_MAXHOST + 1 + sizeof(struct iscsi_uevent))

struct iscsi_ping_event {

	uint32_t host_no;

	uint32_t pid;

	int32_t status;

	int active;

};

struct iscsi_ping_event ping_event;

struct nlattr *iscsi_nla_alloc(uint16_t type, uint16_t len)

{

	struct nlattr *attr;

	attr = calloc(1, ISCSI_NLA_TOTAL_LEN(len));

	if (!attr)

		return NULL; 

	attr->nla_len = ISCSI_NLA_LEN(len);

	attr->nla_type = type;

	return attr;

}

static int

kread(char *data, int count)

{

	log_debug(7, "in %s %u %u %p %p", __FUNCTION__, recvlen, count,

		  data, recvbuf);

	memcpy(data, recvbuf + recvlen, count);

	recvlen += count;

	return count;

}

static int

nl_read(int ctrl_fd, char *data, int size, int flags)

{

	int rc;

	struct iovec iov;

	struct msghdr msg;

	log_debug(7, "in %s", __FUNCTION__);

	iov.iov_base = data;

	iov.iov_len = size;

	memset(&msg, 0, sizeof(msg));

	msg.msg_name= (void*)&src_addr;

	msg.msg_namelen = sizeof(src_addr);

	msg.msg_iov = &iov;

	msg.msg_iovlen = 1;

	rc = recvmsg(ctrl_fd, &msg, flags);

	return rc;

}

static int

nlpayload_read(int ctrl_fd, char *data, int count, int flags)

{

	int rc;

	struct iovec iov;

	struct msghdr msg;

	log_debug(7, "in %s", __FUNCTION__);

	iov.iov_base = nlm_recvbuf;

	iov.iov_len = NLMSG_SPACE(count);

	if (iov.iov_len > NLM_BUF_DEFAULT_MAX) {

		log_error("Cannot read %zu bytes. nlm_recvbuf too small.",

			  iov.iov_len);

		return -1;

	}

	memset(iov.iov_base, 0, iov.iov_len);

	memset(&msg, 0, sizeof(msg));

	msg.msg_name= (void*)&src_addr;

	msg.msg_namelen = sizeof(src_addr);

	msg.msg_iov = &iov;

	msg.msg_iovlen = 1;

	/*

	 * Netlink recvmsg call path:

	 *

	 *  - transport api callback

	 *  - iscsi_control_conn_error (should succeed)

	 *  - iscsi_unicast_skb (must succeed)

	 *  - netlink_unicast (must succeed)

	 *  - netlink_data_ready (must succeed)

	 *  - netlink_sendskb (must succeed)

	 *  - netlink_recvmsg (must succeed)

	 *  - sock_recvmsg (must succeed)

	 *  - sys_recvmsg (must succeed)

	 *  - sys_socketcall (must succeed)

	 *  - syscall_call (must succeed)

	 *

	 *  Note1: "must succeed" means succeed unless bug in daemon.

	 *        It also means - no sleep and memory allocation on

	 *        the path.

	 *

	 *  Note2: "should succeed" means will succeed in most of cases

	 *        because of mempool preallocation.

	 *

	 *  FIXME: if "Note2" than interface should generate iSCSI error

	 *        level 0 on its own. Interface must always succeed on this.

	 */

	rc = recvmsg(ctrl_fd, &msg, flags);

	if (data)

		memcpy(data, NLMSG_DATA(iov.iov_base), count);

	return rc;

}

static int

kwritev(enum iscsi_uevent_e type, struct iovec *iovp, int count)

{

	int i, rc;

	struct nlmsghdr *nlh;

	struct msghdr msg;

	int datalen = 0;

	log_debug(7, "in %s", __FUNCTION__);

	for (i = 0; i < count; i++) {

		datalen += iovp[i].iov_len;

	}

	if (xmitbuf && type != ISCSI_UEVENT_SEND_PDU) {

		for (i = 0; i < count; i++) {

			memcpy(xmitbuf + xmitlen,

			       iovp[i].iov_base, iovp[i].iov_len);

			xmitlen += iovp[i].iov_len;

		}

		return datalen;

	}

	nlh = nlm_sendbuf;

	memset(nlh, 0, NLMSG_SPACE(0));

	datalen = 0;

	for (i = 1; i < count; i++)

		datalen += iovp[i].iov_len;

	nlh->nlmsg_len = datalen + sizeof(*nlh);

	nlh->nlmsg_pid = getpid();

	nlh->nlmsg_flags = 0;

	nlh->nlmsg_type = type;

	iovp[0].iov_base = (void *)nlh;

	iovp[0].iov_len = sizeof(*nlh);

	memset(&msg, 0, sizeof(msg));

	msg.msg_name= (void*)&dest_addr;

	msg.msg_namelen = sizeof(dest_addr);

	msg.msg_iov = iovp;

	msg.msg_iovlen = count;

	do {

		/*

		 * Netlink down call path:

		 *

		 *  - transport api call

		 *  - iscsi_if_recv_msg (must succeed)

		 *  - iscsi_if_rx (must succeed)

		 *  - netlink_data_ready (must succeed)

		 *  - netlink_sendskb (must succeed)

		 *  - netlink_sendmsg (alloc_skb() might fail)

		 *  - sock_sendmsg (must succeed)

		 *  - sys_sendmsg (must succeed)

		 *  - sys_socketcall (must succeed)

		 *  - syscall_call (must succeed)

		 *

		 *  Note1: "must succeed" means succeed unless bug in daemon.

		 *        It also means - no sleep and memory allocation on

		 *        the path.

		 *

		 *  Note2: netlink_sendmsg() might fail because of OOM. Since

		 *         we are in user-space, we will sleep until we succeed.

		 */

		rc = sendmsg(ctrl_fd, &msg, 0);

		if (rc == -ENOMEM) {

			log_debug(1, "sendmsg: alloc_skb() failed");

			sleep(1);

		} else if (rc < 0) {

			log_error("sendmsg: bug? ctrl_fd %d", ctrl_fd);

			exit(rc);

		}

	} while (rc < 0);

	return rc;

}

/*

 * __kipc_call() should never block. Therefore

 * Netlink's xmit logic is serialized. This means we do not allocate on

 * xmit path. Instead we reuse nlm_sendbuf buffer.

 *

 * Transport must assure non-blocking operations for:

 *

 *	- session_create()

 *	- conn_create()

 *	- conn_bind()

 *	_ set_param()

 *	- conn_start()

 *	- conn_stop()

 *

 * Its OK to block for cleanup for short period of time in operatations for:

 *

 *	- conn_destroy()

 *	- session_destroy()

 *

 * FIXME: interface needs to be extended to allow longer blocking on

 *        cleanup. (Dima)

 */

static int

__kipc_call(struct iovec *iovp, int count)

{

	int rc, iferr;

	struct iscsi_uevent *ev = iovp[1].iov_base;

	enum iscsi_uevent_e type = ev->type;

	log_debug(7, "in %s", __FUNCTION__);

	rc = kwritev(type, iovp, count);

	do {

		if ((rc = nlpayload_read(ctrl_fd, (void*)ev,

					 sizeof(*ev), MSG_PEEK)) < 0) {

			return rc;

		}

		if (ev->type != type) {

			log_debug(1, "expecting event %d, got %d, handling...",

				  type, ev->type);

			if (ev->type == ISCSI_KEVENT_IF_ERROR) {

				if ((rc = nlpayload_read(ctrl_fd, (void*)ev,

							 sizeof(*ev), 0)) < 0) {

					return rc;

				}

				/*

				 * iferror is u32, but the kernel returns

				 * negative errno values for errors.

				 */

				iferr = ev->iferror;

				if (iferr == -ENOSYS)

					/* not fatal so let caller handle log */

					log_debug(1, "Received iferror %d: %s.",

						  iferr, strerror(-iferr));

				else if (iferr < 0)

					log_error("Received iferror %d: %s.",

						   iferr, strerror(-iferr));

				else

					log_error("Received iferror %d.",

						   iferr);

				return ev->iferror;

			}

			/*

			 * receive and queue async. event which as of

			 * today could be:

			 *	- CONN_ERROR

			 *	- RECV_PDU

			 */

			ctldev_handle();

		} else if (ev->type == ISCSI_UEVENT_GET_STATS) {

			/* kget_stats() will read */

			return 0;

		} else if (ev->type == ISCSI_UEVENT_GET_CHAP) {

			/* kget_chap() will read */

			return 0;

		} else if (ev->type == ISCSI_UEVENT_GET_HOST_STATS) {

			/* kget_host_stats() will read */

			return 0;

		} else {

			if ((rc = nlpayload_read(ctrl_fd, (void*)ev,

						 sizeof(*ev), 0)) < 0) {

				return rc;

			}

			break;

		}

	} while (ev->type != type);

	return rc;

}

static int

ksendtargets(uint64_t transport_handle, uint32_t host_no, struct sockaddr *addr)

{

	int rc, addrlen;

	struct iscsi_uevent *ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(setparam_buf, 0, NLM_SETPARAM_DEFAULT_MAX);

	ev = (struct iscsi_uevent *)setparam_buf;

	ev->type = ISCSI_UEVENT_TGT_DSCVR;

	ev->transport_handle = transport_handle;

	ev->u.tgt_dscvr.type = ISCSI_TGT_DSCVR_SEND_TARGETS;

	ev->u.tgt_dscvr.host_no = host_no;

	if (addr->sa_family == PF_INET)

		addrlen = sizeof(struct sockaddr_in);

	else if (addr->sa_family == PF_INET6)

		addrlen = sizeof(struct sockaddr_in6);

	else {

		log_error("%s unknown addr family %d",

			  __FUNCTION__, addr->sa_family);

		return -EINVAL;

	}

	memcpy(setparam_buf + sizeof(*ev), addr, addrlen);

	iov[1].iov_base = ev;

	iov[1].iov_len = sizeof(*ev) + addrlen;

	rc = __kipc_call(iov, 2);

	if (rc < 0) {

		log_error("sendtargets failed rc%d", rc);

		return rc;

	}

	return 0;

}

static int

kcreate_session(uint64_t transport_handle, uint64_t ep_handle,

		uint32_t initial_cmdsn, uint16_t cmds_max, uint16_t qdepth,

		uint32_t *out_sid, uint32_t *hostno)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	if (ep_handle == 0) {

		ev.type = ISCSI_UEVENT_CREATE_SESSION;

		ev.transport_handle = transport_handle;

		ev.u.c_session.initial_cmdsn = initial_cmdsn;

		ev.u.c_session.cmds_max = cmds_max;

		ev.u.c_session.queue_depth = qdepth;

	} else {

		ev.type = ISCSI_UEVENT_CREATE_BOUND_SESSION;

		ev.transport_handle = transport_handle;

		ev.u.c_bound_session.initial_cmdsn = initial_cmdsn;

		ev.u.c_bound_session.cmds_max = cmds_max;

		ev.u.c_bound_session.queue_depth = qdepth;

		ev.u.c_bound_session.ep_handle = ep_handle;

	}

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	*hostno = ev.r.c_session_ret.host_no;

	*out_sid = ev.r.c_session_ret.sid;

	return 0;

}

static int

kdestroy_session(uint64_t transport_handle, uint32_t sid)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_DESTROY_SESSION;

	ev.transport_handle = transport_handle;

	ev.u.d_session.sid = sid;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	return 0;

}

static int

kunbind_session(uint64_t transport_handle, uint32_t sid)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_UNBIND_SESSION;

	ev.transport_handle = transport_handle;

	ev.u.d_session.sid = sid;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	return 0;

}

static int

kcreate_conn(uint64_t transport_handle, uint32_t sid,

	    uint32_t cid, uint32_t *out_cid)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_CREATE_CONN;

	ev.transport_handle = transport_handle;

	ev.u.c_conn.cid = cid;

	ev.u.c_conn.sid = sid;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0) {

		log_debug(7, "returned %d", rc);

		return rc;

	}

	if ((int)ev.r.c_conn_ret.cid == -1)

		return -EIO;

	*out_cid = ev.r.c_conn_ret.cid;

	return 0;

}

static int

kdestroy_conn(uint64_t transport_handle, uint32_t sid, uint32_t cid)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_DESTROY_CONN;

	ev.transport_handle = transport_handle;

	ev.u.d_conn.sid = sid;

	ev.u.d_conn.cid = cid;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	return 0;

}

static int

kbind_conn(uint64_t transport_handle, uint32_t sid, uint32_t cid,

	  uint64_t transport_eph, int is_leading, int *retcode)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_BIND_CONN;

	ev.transport_handle = transport_handle;

	ev.u.b_conn.sid = sid;

	ev.u.b_conn.cid = cid;

	ev.u.b_conn.transport_eph = transport_eph;

	ev.u.b_conn.is_leading = is_leading;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	*retcode = ev.r.retcode;

	return 0;

}

static void

ksend_pdu_begin(uint64_t transport_handle, uint32_t sid, uint32_t cid,

			int hdr_size, int data_size)

{

	struct iscsi_uevent *ev;

	int total_xmitlen = sizeof(*ev) + hdr_size + data_size;

	log_debug(7, "in %s", __FUNCTION__);

	if (xmitbuf) {

		log_error("send's begin state machine bug?");

		exit(-EIO);

	}

	if (total_xmitlen > (int)PDU_SENDBUF_DEFAULT_MAX) {

		log_error("BUG: Cannot send %d bytes.", total_xmitlen);

		exit(-EINVAL);

	}

	xmitbuf = pdu_sendbuf;

	memset(xmitbuf, 0, total_xmitlen);

	xmitlen = sizeof(*ev);

	ev = xmitbuf;

	memset(ev, 0, sizeof(*ev));

	ev->type = ISCSI_UEVENT_SEND_PDU;

	ev->transport_handle = transport_handle;

	ev->u.send_pdu.sid = sid;

	ev->u.send_pdu.cid = cid;

	ev->u.send_pdu.hdr_size = hdr_size;

	ev->u.send_pdu.data_size = data_size;

	log_debug(3, "send PDU began for hdr %d bytes and data %d bytes",

		hdr_size, data_size);

}

static int

ksend_pdu_end(__attribute__((unused))uint64_t transport_handle,

	      uint32_t sid, uint32_t cid, int *retcode)

{

	int rc;

	struct iscsi_uevent *ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	if (!xmitbuf) {

		log_error("send's end state machine bug?");

		exit(-EIO);

	}

	ev = xmitbuf;

	if (ev->u.send_pdu.sid != sid || ev->u.send_pdu.cid != cid) {

		log_error("send's end state machine corruption?");

		exit(-EIO);

	}

	iov[1].iov_base = xmitbuf;

	iov[1].iov_len = xmitlen;

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		goto err;

	if (ev->r.retcode) {

		*retcode = ev->r.retcode;

		goto err;

	}

	if (ev->type != ISCSI_UEVENT_SEND_PDU) {

		log_error("bad event: bug on send_pdu_end?");

		exit(-EIO);

	}

	log_debug(3, "send PDU finished for conn %d:%d",

		  sid, cid);

	xmitbuf = NULL;

	return 0;

err:

	xmitbuf = NULL;

	xmitlen = 0;

	return rc;

}

static int

kset_host_param(uint64_t transport_handle, uint32_t host_no,

		enum iscsi_host_param param, void *value, int type)

{

	struct iscsi_uevent *ev;

	char *param_str;

	int rc, len;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(setparam_buf, 0, NLM_SETPARAM_DEFAULT_MAX);

	ev = (struct iscsi_uevent *)setparam_buf;

	ev->type = ISCSI_UEVENT_SET_HOST_PARAM;

	ev->transport_handle = transport_handle;

	ev->u.set_host_param.host_no = host_no;

	ev->u.set_host_param.param = param;

	param_str = setparam_buf + sizeof(*ev);

	switch (type) {

	case ISCSI_INT:

		sprintf(param_str, "%d", *((int *)value));

		break;

	case ISCSI_STRING:

		if (!strlen(value))

			return 0;

		sprintf(param_str, "%s", (char *)value);

		break;

	default:

		log_error("invalid type %d", type);

		return -EINVAL;

	}

	ev->u.set_host_param.len = len = strlen(param_str) + 1;

	iov[1].iov_base = ev;

	iov[1].iov_len = sizeof(*ev) + len;

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	return 0;

}

static int

kset_param(uint64_t transport_handle, uint32_t sid, uint32_t cid,

	   enum iscsi_param param, void *value, int type)

{

	struct iscsi_uevent *ev;

	char *param_str;

	int rc, len;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(setparam_buf, 0, NLM_SETPARAM_DEFAULT_MAX);

	ev = (struct iscsi_uevent *)setparam_buf;

	ev->type = ISCSI_UEVENT_SET_PARAM;

	ev->transport_handle = transport_handle;

	ev->u.set_param.sid = sid;

	ev->u.set_param.cid = cid;

	ev->u.set_param.param = param;

	param_str = setparam_buf + sizeof(*ev);

	switch (type) {

	case ISCSI_INT:

		sprintf(param_str, "%d", *((int *)value));

		break;

	case ISCSI_UINT:

		sprintf(param_str, "%u", *((unsigned int *)value));

		break;

	case ISCSI_STRING:

		if (!strlen(value))

			return 0;

		sprintf(param_str, "%s", (char *)value);

		break;

	default:

		log_error("invalid type %d", type);

		return -EINVAL;

	}

	ev->u.set_param.len = len = strlen(param_str) + 1;

	iov[1].iov_base = ev;

	iov[1].iov_len = sizeof(*ev) + len;

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	return 0;

}

static int

kstop_conn(uint64_t transport_handle, uint32_t sid, uint32_t cid, int flag)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_STOP_CONN;

	ev.transport_handle = transport_handle;

	ev.u.stop_conn.sid = sid;

	ev.u.stop_conn.cid = cid;

	ev.u.stop_conn.flag = flag;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	return 0;

}

static int

kstart_conn(uint64_t transport_handle, uint32_t sid, uint32_t cid,

	    int *retcode)

{

	int rc;

	struct iscsi_uevent ev;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(&ev, 0, sizeof(struct iscsi_uevent));

	ev.type = ISCSI_UEVENT_START_CONN;

	ev.transport_handle = transport_handle;

	ev.u.start_conn.sid = sid;

	ev.u.start_conn.cid = cid;

	iov[1].iov_base = &ev;

	iov[1].iov_len = sizeof(ev);

	rc = __kipc_call(iov, 2);

	if (rc < 0)

		return rc;

	*retcode = ev.r.retcode;

	return 0;

}

static int

krecv_pdu_begin(struct iscsi_conn *conn)

{

	int rc;

	log_debug(7, "in %s", __FUNCTION__);

	if (recvbuf) {

		log_error("recv's begin state machine bug?");

		return -EIO;

	}

	if (!conn->recv_context) {

		rc = ipc->ctldev_handle();

		if (rc == -ENXIO)

			/* event for some other conn */

			return -EAGAIN;

		else if (rc < 0)

			/* fatal handling error or conn error */

			return rc;

		/*

		 * Session create/destroy event for another conn

		 */

		if (!conn->recv_context)

			return -EAGAIN;

	}

	recvbuf = conn->recv_context->data + sizeof(struct iscsi_uevent);

	recvlen = 0;

	log_debug(3, "recv PDU began, pdu handle %p", recvbuf);

	return 0;

}

static int

krecv_pdu_end(struct iscsi_conn *conn)

{

	log_debug(7, "in %s", __FUNCTION__);

	if (!recvbuf) {

		log_error("recv's end state machine bug?");

		return -EIO;

	}

	log_debug(3, "recv PDU finished for pdu handle 0x%p",

		  recvbuf);

	ipc_ev_clbk->put_ev_context(conn->recv_context);

	conn->recv_context = NULL;

	recvbuf = NULL;

	return 0;

}

int

ktransport_ep_connect(iscsi_conn_t *conn, int non_blocking)

{

	int rc, addrlen;

	struct iscsi_uevent *ev;

	struct sockaddr *dst_addr = (struct sockaddr *)&conn->saddr;

	struct iovec iov[2];

	log_debug(7, "in %s", __FUNCTION__);

	memset(setparam_buf, 0, NLM_SETPARAM_DEFAULT_MAX);

	ev = (struct iscsi_uevent *)setparam_buf;

	ev->transport_handle = conn->session->t->handle;

	if (conn->bind_ep) {

		ev->type = ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST;

		ev->u.ep_connect_through_host.non_blocking = non_blocking;

		ev->u.ep_connect_through_host.host_no = conn->session->hostno;

	} else {

		ev->type = ISCSI_UEVENT_TRANSPORT_EP_CONNECT;

		ev->u.ep_connect.non_blocking = non_blocking;

	}

	if (dst_addr->sa_family == PF_INET)

		addrlen = sizeof(struct sockaddr_in);

	else if (dst_addr->sa_family == PF_INET6)

		addrlen = sizeof(struct sockaddr_in6);

	else {

		log_error("%s unknown addr family %d",

			 __FUNCTION__, dst_addr->sa_family);

		return -EINVAL;

	}

	memcpy(setparam_buf + sizeof(*ev), dst_addr, addrlen);