/*

 * iSCSI Session Management and Slow-path Control

 *

 * 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 <sys/time.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/resource.h>

#include <unistd.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <dirent.h>

#include <fcntl.h>

#include "initiator.h"

#include "transport.h"

#include "iscsid.h"

#include "iscsi_if.h"

#include "mgmt_ipc.h"

#include "event_poll.h"

#include "iscsi_ipc.h"

#include "idbm.h"

#include "log.h"

#include "iscsi_util.h"

#include "scsi.h"

#include "iscsi_sysfs.h"

#include "iscsi_settings.h"

#include "iface.h"

#include "host.h"

#include "sysdeps.h"

#include "iscsi_err.h"

#include "kern_err_table.h"

#define ISCSI_CONN_ERR_REOPEN_DELAY	3

#define ISCSI_INTERNAL_ERR_REOPEN_DELAY	5

#define PROC_DIR "/proc"

struct login_task_retry_info {

	actor_t retry_actor;

	queue_task_t *qtask;

	node_rec_t *rec;

	int retry_count;

};

static void iscsi_login_timedout(void *data);

static int iscsi_sched_ev_context(struct iscsi_ev_context *ev_context,

				  struct iscsi_conn *conn, unsigned long tmo,

				  int event);

static int queue_session_login_task_retry(struct login_task_retry_info *info,

					  node_rec_t *rec, queue_task_t *qtask);

static int iscsi_ev_context_alloc(iscsi_conn_t *conn)

{

	int i;

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

		conn->context_pool[i] = calloc(1,

					   sizeof(struct iscsi_ev_context) +

					   ipc->ctldev_bufmax);

		if (!conn->context_pool[i]) {

			int j;

			for (j = 0; j < i; j++)

				free(conn->context_pool[j]);

			return ENOMEM;

		}

		conn->context_pool[i]->conn = conn;

	}

	return 0;

}

static void iscsi_ev_context_free(iscsi_conn_t *conn)

{

	int i;

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

		if (!conn->context_pool[i])

			continue;

		if (conn->context_pool[i]->allocated)

			/* missing flush on shutdown */

			log_error("BUG: context_pool leak %p",

				  conn->context_pool[i]);

		free(conn->context_pool[i]);

	}

}

static struct iscsi_ev_context *

iscsi_ev_context_get(iscsi_conn_t *conn, int ev_size)

{

	struct iscsi_ev_context *ev_context;

	int i;

	if (ev_size > ipc->ctldev_bufmax)

		return NULL;

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

		if (!conn->context_pool[i])

			continue;

		if (!conn->context_pool[i]->allocated) {

			ev_context = conn->context_pool[i];

			memset(&ev_context->actor, 0,

				sizeof(struct actor));

			ev_context->allocated = 1;

			/* some callers abuse this pointer */

			ev_context->data = (void *)ev_context +

					sizeof(struct iscsi_ev_context);

			log_debug(7, "get ev context %p",

				  &ev_context->actor);

			return ev_context;

		}

	}

	return NULL;

}

static void iscsi_ev_context_put(struct iscsi_ev_context *ev_context)

{

	log_debug(7, "put ev context %p", &ev_context->actor);

	ev_context->allocated = 0;

}

static void session_online_devs(int host_no, int sid)

{

	iscsi_sysfs_for_each_device(NULL, host_no, sid,

				    iscsi_sysfs_set_device_online);

}

static conn_login_status_e

__login_response_status(iscsi_conn_t *conn,

		      enum iscsi_login_status login_status)

{

	switch (login_status) {

	case LOGIN_OK:

		/* check the status class and detail */

		return CONN_LOGIN_SUCCESS;

	case LOGIN_REDIRECT:

		return CONN_LOGIN_IMM_REDIRECT_RETRY;

	case LOGIN_IO_ERROR:

	case LOGIN_REDIRECTION_FAILED:

		return CONN_LOGIN_RETRY;

	default:

		log_error("Login error (Login status %d) on conn %d", conn->id,

			  login_status);

		break;

	}

	return CONN_LOGIN_FAILED;

}

static conn_login_status_e

__check_iscsi_status_class(iscsi_session_t *session, int cid,

			uint8_t status_class, uint8_t status_detail)

{

	iscsi_conn_t *conn = &session->conn[cid];

	switch (status_class) {

	case ISCSI_STATUS_CLS_SUCCESS:

		return CONN_LOGIN_SUCCESS;

	case ISCSI_STATUS_CLS_REDIRECT:

		switch (status_detail) {

		case ISCSI_LOGIN_STATUS_TGT_MOVED_TEMP:

			return CONN_LOGIN_IMM_RETRY;

		case ISCSI_LOGIN_STATUS_TGT_MOVED_PERM:

			/*

			 * for a permanent redirect, we need to update the

			 * failback address

			 */

			memset(&conn->failback_saddr, 0,

				sizeof(struct sockaddr_storage));

			conn->failback_saddr = conn->saddr;

                        return CONN_LOGIN_IMM_REDIRECT_RETRY;

		default:

			log_error("conn %d login rejected: redirection "

			        "type 0x%x not supported",

				conn->id, status_detail);

			return CONN_LOGIN_RETRY;

		}

	case ISCSI_STATUS_CLS_INITIATOR_ERR:

		switch (status_detail) {

		case ISCSI_LOGIN_STATUS_AUTH_FAILED:

			log_error("session %d login rejected: Initiator "

			       "failed authentication with target",

				session->id);

			return CONN_LOGIN_AUTH_FAILED;

		case ISCSI_LOGIN_STATUS_TGT_FORBIDDEN:

			log_error("conn %d login rejected: initiator "

			       "failed authorization with target", conn->id);

			return CONN_LOGIN_AUTH_FAILED;

		case ISCSI_LOGIN_STATUS_TGT_NOT_FOUND:

			log_error("conn %d login rejected: initiator "

			       "error - target not found (%02x/%02x)",

			       conn->id, status_class, status_detail);

			return CONN_LOGIN_FAILED;

		case ISCSI_LOGIN_STATUS_NO_VERSION:

			/*

			 * FIXME: if we handle multiple protocol versions,

			 * before we log an error, try the other supported

			 * versions.

			 */

			log_error("conn %d login rejected: incompatible "

			       "version (%02x/%02x), non-retryable, "

			       "giving up", conn->id, status_class,

			       status_detail);

			return CONN_LOGIN_FAILED;

		default:

			log_error("conn %d login rejected: initiator "

			       "error (%02x/%02x)", conn->id, status_class,

			       status_detail);

			return CONN_LOGIN_FAILED;

		}

	case ISCSI_STATUS_CLS_TARGET_ERR:

		log_error("conn %d login rejected: target error "

		       "(%02x/%02x)", conn->id, status_class, status_detail);

		/*

		 * We have no idea what the problem is. But spec says initiator

		 * may retry later.

		 */

		 return CONN_LOGIN_RETRY;

	default:

		log_error("conn %d login response with unknown status "

		       "class 0x%x, detail 0x%x", conn->id, status_class,

		       status_detail);

		break;

	}

	return CONN_LOGIN_FAILED;

}

static int

__session_conn_create(iscsi_session_t *session, int cid)

{

	iscsi_conn_t *conn = &session->conn[cid];

	conn_rec_t *conn_rec = &session->nrec.conn[cid];

	node_rec_t *rec = &session->nrec;

	int err;

	if (iscsi_ev_context_alloc(conn)) {

		log_error("cannot allocate context_pool for conn cid %d", cid);

		return ISCSI_ERR_NOMEM;

	}

	/* set session reconnection retry max */

	session->reopen_max = rec->session.reopen_max;

	conn->state = ISCSI_CONN_STATE_FREE;

	conn->session = session;

	actor_init(&conn->login_timer, iscsi_login_timedout, NULL);

	/*

	 * TODO: we must export the socket_fd/transport_eph from sysfs

	 * so if iscsid is resyncing up we can pick that up and cleanup up

	 * the old connection. Right now we leak a connection.

	 * We can also probably merge these two fields.

	 */

	conn->socket_fd = -1;

	conn->transport_ep_handle = -1;

	/* connection's timeouts */

	conn->id = cid;

	conn->logout_timeout = conn_rec->timeo.logout_timeout;

	if (!conn->logout_timeout) {

		log_error("Invalid timeo.logout_timeout. Must be greater "

			  "than zero. Using default %d.",

			  DEF_LOGOUT_TIMEO);

		conn->logout_timeout = DEF_LOGOUT_TIMEO;

	}

	conn->login_timeout = conn_rec->timeo.login_timeout;

	if (!conn->login_timeout) {

		log_error("Invalid timeo.login_timeout. Must be greater "

			  "than zero. Using default %d.",

			  DEF_LOGIN_TIMEO);

		conn->login_timeout = DEF_LOGIN_TIMEO;

	}

	conn->auth_timeout = conn_rec->timeo.auth_timeout;

	/* noop-out setting */

	conn->noop_out_interval = conn_rec->timeo.noop_out_interval;

	conn->noop_out_timeout = conn_rec->timeo.noop_out_timeout;

	if (conn->noop_out_interval && !conn->noop_out_timeout) {

		log_error("Invalid timeo.noop_out_timeout. Must be greater "

			  "than zero. Using default %d.",

			  DEF_NOOP_OUT_TIMEO);

		conn->noop_out_timeout = DEF_NOOP_OUT_TIMEO;

	}

	if (conn->noop_out_timeout && !conn->noop_out_interval) {

		log_error("Invalid timeo.noop_out_interval. Must be greater "

			  "than zero. Using default %d.",

			  DEF_NOOP_OUT_INTERVAL);

		conn->noop_out_interval = DEF_NOOP_OUT_INTERVAL;

	}

	iscsi_copy_operational_params(conn, &session->nrec.session.iscsi,

				      &conn_rec->iscsi);

	/* TCP options */

	conn->tcp_window_size = conn_rec->tcp.window_size;

	/* FIXME: type_of_service */

	/* resolve the string address to an IP address */

	err = iscsi_setup_portal(conn, conn_rec->address, conn_rec->port);

	if (err)

		return err;

	return 0;

}

static void

session_release(iscsi_session_t *session)

{

	log_debug(2, "Releasing session %p", session);

	if (session->target_alias)

		free(session->target_alias);

	iscsi_ev_context_free(&session->conn[0]);

	free(session);

}

static iscsi_session_t*

__session_create(node_rec_t *rec, struct iscsi_transport *t, int *rc)

{

	iscsi_session_t *session;

	int hostno;

	*rc = 0;

	session = calloc(1, sizeof (*session));

	if (session == NULL) {

		log_debug(1, "can not allocate memory for session");

		*rc = ISCSI_ERR_NOMEM;

		return NULL;

	}

	log_debug(2, "Allocted session %p", session);

	INIT_LIST_HEAD(&session->list);

	session->t = t;

	session->reopen_qtask.mgmt_ipc_fd = -1;

	session->id = -1;

	session->use_ipc = 1;

	/* save node record. we might need it for redirection */

	memcpy(&session->nrec, rec, sizeof(node_rec_t));

	session->portal_group_tag = rec->tpgt;

	session->type = ISCSI_SESSION_TYPE_NORMAL;

	session->r_stage = R_STAGE_NO_CHANGE;

	strlcpy(session->target_name, rec->name, TARGET_NAME_MAXLEN);

	if (strlen(session->nrec.iface.iname))

		session->initiator_name = session->nrec.iface.iname;

	else if (dconfig->initiator_name)

		session->initiator_name = dconfig->initiator_name;

	else {

		log_error("No initiator name set. Cannot create session.");

		*rc = ISCSI_ERR_INVAL;

		goto free_session;

	}

	if (strlen(session->nrec.iface.alias))

		session->initiator_alias = session->nrec.iface.alias;

	else

		session->initiator_alias = dconfig->initiator_alias;

	/* session's eh parameters */

	session->replacement_timeout = rec->session.timeo.replacement_timeout;

	session->fast_abort = rec->session.iscsi.FastAbort;

	session->abort_timeout = rec->session.err_timeo.abort_timeout;

	session->lu_reset_timeout = rec->session.err_timeo.lu_reset_timeout;

	session->tgt_reset_timeout = rec->session.err_timeo.tgt_reset_timeout;

	session->host_reset_timeout = rec->session.err_timeo.host_reset_timeout;

	/* OUI and uniqifying number */

	session->isid[0] = DRIVER_ISID_0;

	session->isid[1] = DRIVER_ISID_1;

	session->isid[2] = DRIVER_ISID_2;

	session->isid[3] = 0;

	session->isid[4] = 0;

	session->isid[5] = 0;

	/* setup authentication variables for the session*/

	iscsi_setup_authentication(session, &rec->session.auth);

	iscsi_session_init_params(session);

        if (t->template->bind_ep_required) {

                hostno = iscsi_sysfs_get_host_no_from_hwinfo(&rec->iface, rc);

                if (!*rc) {

                        /*

                         * if the netdev or mac was set, then we are going to want

                         * to want to bind the all the conns/eps to a specific host

                         * if offload is used.

                         */

                        session->conn[0].bind_ep = 1;

                        session->hostno = hostno;

                } else if (*rc == ISCSI_ERR_HOST_NOT_FOUND) {

                        goto free_session;	

                } else {

                         *rc = 0;

                }

        }

	/* reset session reopen count */

	session->reopen_cnt = 0;

	list_add_tail(&session->list, &t->sessions);

	return session;

free_session:

	free(session);

	return NULL;

}

static void iscsi_flush_context_pool(struct iscsi_session *session)

{

	struct iscsi_ev_context *ev_context;

	struct iscsi_conn *conn = &session->conn[0];

	int i;

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

		ev_context = conn->context_pool[i];

		if (!ev_context)

			continue;

		if (ev_context->allocated) {

			actor_delete(&(conn->context_pool[i]->actor));

			iscsi_ev_context_put(ev_context);

		}

	}

}

static void

__session_destroy(iscsi_session_t *session)

{

	log_debug(1, "destroying session");

	list_del(&session->list);

	iscsi_flush_context_pool(session);

	session_release(session);

}

static void

conn_delete_timers(iscsi_conn_t *conn)

{

	actor_delete(&conn->login_timer);

	actor_delete(&conn->nop_out_timer);

}

static int 

session_conn_shutdown(iscsi_conn_t *conn, queue_task_t *qtask,

		      int err)

{

	iscsi_session_t *session = conn->session;

	log_debug(2, "disconnect conn");

	/* this will check for a valid interconnect connection */

	if (session->t->template->ep_disconnect)

		session->t->template->ep_disconnect(conn);

	if (session->id == -1)

		goto cleanup;

	if (!iscsi_sysfs_session_has_leadconn(session->id))

		goto cleanup;

	if (conn->state == ISCSI_CONN_STATE_IN_LOGIN ||

	    conn->state == ISCSI_CONN_STATE_IN_LOGOUT ||

	    conn->state == ISCSI_CONN_STATE_LOGGED_IN) {

		log_debug(2, "stop conn (conn state %d)", conn->state);

		if (ipc->stop_conn(session->t->handle, session->id,

				   conn->id, STOP_CONN_TERM)) {

			log_error("can't stop connection %d:%d (%d)",

				  session->id, conn->id, errno);

			return ISCSI_ERR_INTERNAL;

		}

	}

	log_debug(2, "kdestroy conn");

	if (ipc->destroy_conn(session->t->handle, session->id,

		conn->id)) {

		log_error("can not safely destroy connection %d", conn->id);

		return ISCSI_ERR_INTERNAL;

	}

cleanup:

	if (session->id != -1) {

		log_debug(2, "kdestroy session %u", session->id);

		session->r_stage = R_STAGE_SESSION_DESTOYED;

		if (ipc->destroy_session(session->t->handle, session->id)) {

			log_error("can not safely destroy session %d",

				  session->id);

			return ISCSI_ERR_INTERNAL;

		}

	}

	log_warning("Connection%d:%d to [target: %s, portal: %s,%d] "

		    "through [iface: %s] is shutdown.",

		    session->id, conn->id, session->nrec.name,

		    session->nrec.conn[conn->id].address,

		    session->nrec.conn[conn->id].port,

		    session->nrec.iface.name);

	mgmt_ipc_write_rsp(qtask, err);

	conn_delete_timers(conn);

	__session_destroy(session);

	return ISCSI_SUCCESS;

}

static void

queue_delayed_reopen(queue_task_t *qtask, int delay)

{

	iscsi_conn_t *conn = qtask->conn;

	log_debug(4, "Requeue reopen attempt in %d secs", delay);

	/*

 	 * iscsi_login_eh can handle the login resched as

 	 * if it were login time out

 	 */

	actor_timer_mod(&conn->login_timer, delay, qtask);

}

static int iscsi_conn_connect(struct iscsi_conn *conn, queue_task_t *qtask)

{

	struct iscsi_ev_context *ev_context;

	int rc;

	ev_context = iscsi_ev_context_get(conn, 0);

	if (!ev_context) {

		/* while reopening the recv pool should be full */

		log_error("BUG: __session_conn_reopen could not get conn "

			  "context for recv.");

		return ENOMEM;

	}

	ev_context->data = qtask;

	rc = conn->session->t->template->ep_connect(conn, 1);

	if (rc < 0 && errno != EINPROGRESS) {

		char serv[NI_MAXSERV];

		getnameinfo((struct sockaddr *) &conn->saddr,

			    sizeof(conn->saddr),

			    conn->host, sizeof(conn->host), serv, sizeof(serv),

			    NI_NUMERICHOST|NI_NUMERICSERV);

		log_error("cannot make a connection to %s:%s (%d,%d)",

			  conn->host, serv, rc, errno);

		iscsi_ev_context_put(ev_context);

		return ENOTCONN;

	}

	iscsi_sched_ev_context(ev_context, conn, 0, EV_CONN_POLL);

	log_debug(3, "Setting login timer %p timeout %d", &conn->login_timer,

		  conn->login_timeout);

	actor_timer_mod(&conn->login_timer, conn->login_timeout, qtask);

	return 0;

}

static void

__session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop,

		      int redirected)

{

	iscsi_session_t *session = conn->session;

	uint32_t delay;

	log_debug(1, "re-opening session %d (reopen_cnt %d)", session->id,

			session->reopen_cnt);

	qtask->conn = conn;

	/* flush stale polls or errors queued */

	iscsi_flush_context_pool(session);

	conn_delete_timers(conn);

	conn->state = ISCSI_CONN_STATE_XPT_WAIT;

	conn->session->t->template->ep_disconnect(conn);

	if (do_stop) {

		/* state: ISCSI_CONN_STATE_CLEANUP_WAIT */

		if (ipc->stop_conn(session->t->handle, session->id,

				   conn->id, do_stop)) {

			log_error("can't stop connection %d:%d (%d)",

				  session->id, conn->id, errno);

			delay = ISCSI_INTERNAL_ERR_REOPEN_DELAY;

			goto queue_reopen;

		}

		log_debug(3, "connection %d:%d is stopped for recovery",

			  session->id, conn->id);

	}

	if (!redirected) {

		delay = session->def_time2wait;

		session->def_time2wait = 0;

		if (delay)

			goto queue_reopen;

	}

	if (!redirected)

		session->reopen_cnt++;

	/* uIP will needs to be re-triggered on the connection re-open */

	if (iscsi_set_net_config(conn->session->t, conn->session,

				 &conn->session->nrec.iface) != 0)

		goto queue_reopen;

	if (iscsi_conn_connect(conn, qtask)) {

		delay = ISCSI_CONN_ERR_REOPEN_DELAY;

		goto queue_reopen;

	}

	return;

queue_reopen:

	log_debug(4, "Waiting %u seconds before trying to reconnect.", delay);

	queue_delayed_reopen(qtask, delay);

}

static void

session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop)

{

	/*

	 * If we were temporarily redirected, we need to fall back to

	 * the original address to see where the target will send us

	 * for the retry

	 */

	memset(&conn->saddr, 0, sizeof(struct sockaddr_storage));

	conn->saddr = conn->failback_saddr;

	__session_conn_reopen(conn, qtask, do_stop, 0);

}

static int iscsi_retry_initial_login(struct iscsi_conn *conn)

{

	int initial_login_retry_max;

	struct timeval now, timeout, fail_time;

	initial_login_retry_max =

			conn->session->nrec.session.initial_login_retry_max;

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

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

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

	timeout.tv_sec = initial_login_retry_max * conn->login_timeout;

	if (gettimeofday(&now, NULL)) {

		log_error("Could not get time of day. Dropping down to "

			  "max retry check.");

		return initial_login_retry_max > conn->session->reopen_cnt;

	}

	timeradd(&conn->initial_connect_time, &timeout, &fail_time);

	/*

	 * if we have been trying for login_retry_max * login_timeout

	 * then it is time to give up

	 */

	if (timercmp(&now, &fail_time, >)) {

		log_debug(1, "Giving up on initial login attempt after "

			  "%u seconds.",

			  initial_login_retry_max * conn->login_timeout);

		return 0;

	}

	return 1;

}

static int iscsi_login_is_fatal_err(int err)

{

	if (err == ISCSI_ERR_LOGIN_AUTH_FAILED ||

	    err == ISCSI_ERR_FATAL_LOGIN)

		return 1;

	return 0;

}

static void iscsi_login_eh(struct iscsi_conn *conn, struct queue_task *qtask,

			   int err)

{

	struct iscsi_session *session = conn->session;

	log_debug(3, "iscsi_login_eh");

	/*

	 * Flush polls and other events

	 */

	iscsi_flush_context_pool(conn->session);

	switch (conn->state) {

	case ISCSI_CONN_STATE_XPT_WAIT:

		switch (session->r_stage) {

		case R_STAGE_NO_CHANGE:

			log_debug(6, "login failed ISCSI_CONN_STATE_XPT_WAIT/"

				  "R_STAGE_NO_CHANGE");

			/* timeout during initial connect.

			 * clean connection. write ipc rsp or retry */

			if (iscsi_login_is_fatal_err(err) ||

			    !iscsi_retry_initial_login(conn))

				session_conn_shutdown(conn, qtask, err);

			else {

				session->reopen_cnt++;

				session->t->template->ep_disconnect(conn);

				if (iscsi_conn_connect(conn, qtask))

					queue_delayed_reopen(qtask,

						ISCSI_CONN_ERR_REOPEN_DELAY);

			}

			break;

		case R_STAGE_SESSION_REDIRECT:

			log_debug(6, "login failed ISCSI_CONN_STATE_XPT_WAIT/"

				  "R_STAGE_SESSION_REDIRECT");

			/* timeout during initial redirect connect

			 * clean connection. write ipc rsp or retry */

			if (iscsi_login_is_fatal_err(err) ||

			    !iscsi_retry_initial_login(conn))

				session_conn_shutdown(conn, qtask, err);

			else

				session_conn_reopen(conn, qtask, 0);

			break;

		case R_STAGE_SESSION_REOPEN:

			log_debug(6, "login failed ISCSI_CONN_STATE_XPT_WAIT/"

				  "R_STAGE_SESSION_REOPEN (reopen_cnt=%d, reopen_max=%d)",

				  session->reopen_cnt, session->reopen_max);

			if (session->reopen_max &&

			    (session->reopen_cnt > session->reopen_max)) {

				log_info("Giving up on session %d after %d retries", 

						session->id, session->reopen_max);

				session_conn_shutdown(conn, qtask, err);

				break;

			}

			/* timeout during reopen connect. try again */

			session_conn_reopen(conn, qtask, 0);

			break;

		case R_STAGE_SESSION_CLEANUP:

			session_conn_shutdown(conn, qtask, err);

			break;

		default:

			break;

		}

		break;

	case ISCSI_CONN_STATE_IN_LOGIN:

		switch (session->r_stage) {

		case R_STAGE_NO_CHANGE:

		case R_STAGE_SESSION_REDIRECT:

			log_debug(6, "login failed ISCSI_CONN_STATE_IN_LOGIN/"

				  "R_STAGE_NO_CHANGE %d",

				  session->reopen_cnt);

			/*

			 * send pdu timeout during initial connect or

			 * initial redirected connect. Clean connection

			 * and write rsp or retry.

			 */

			if (iscsi_login_is_fatal_err(err) ||

			    !iscsi_retry_initial_login(conn))

				session_conn_shutdown(conn, qtask, err);

			else

				session_conn_reopen(conn, qtask,

						    STOP_CONN_RECOVER);

			break;

		case R_STAGE_SESSION_REOPEN:

			log_debug(6, "login failed ISCSI_CONN_STATE_IN_LOGIN/"

				  "R_STAGE_SESSION_REOPEN %d",

				  session->reopen_cnt);

			session_conn_reopen(conn, qtask, STOP_CONN_RECOVER);

			break;

		case R_STAGE_SESSION_CLEANUP:

			session_conn_shutdown(conn, qtask,

					      ISCSI_ERR_PDU_TIMEOUT);

			break;

		default:

			break;

		}

		break;

	default:

		log_error("Ignoring login error %d in conn state %d.",

			  err, conn->state);

		break;

	}

}

static void

__conn_error_handle(iscsi_session_t *session, iscsi_conn_t *conn)

{

	int i;

	/*

	 * if we got an error while trying to logout for the user then

	 * just cleanup and return to the user.

	 */

	if (conn->logout_qtask) {

		session_conn_shutdown(conn, conn->logout_qtask, ISCSI_SUCCESS);

		return;

	}

	switch (conn->state) {

	case ISCSI_CONN_STATE_IN_LOGOUT:

		/* logout was from eh - fall down to cleanup */

	case ISCSI_CONN_STATE_LOGGED_IN:

		/* mark failed connection */

		conn->state = ISCSI_CONN_STATE_CLEANUP_WAIT;

		if (session->erl > 0) {

			/* check if we still have some logged in connections */

			for (i=0; i

				if (session->conn[i].state ==

				    ISCSI_CONN_STATE_LOGGED_IN)

					break;

			}

			if (i != ISCSI_CONN_MAX) {

				/* FIXME: re-assign leading connection

				 *        for ERL>0 */

			}

			break;

		}

		/* mark all connections as failed */

		for (i=0; i

			if (session->conn[i].state ==

			    ISCSI_CONN_STATE_LOGGED_IN)

				session->conn[i].state =

						ISCSI_CONN_STATE_CLEANUP_WAIT;

		}

		session->r_stage = R_STAGE_SESSION_REOPEN;

		break;

	case ISCSI_CONN_STATE_IN_LOGIN:

		if (session->r_stage == R_STAGE_SESSION_REOPEN) {

			queue_task_t *qtask;

			if (session->notify_qtask)

				qtask = session->notify_qtask;

			else

				qtask = &session->reopen_qtask;

			iscsi_login_eh(conn, qtask, ISCSI_ERR_TRANS);

			return;

		}

		log_debug(1, "ignoring conn error in login. "

			  "let it timeout");

		return;

	case ISCSI_CONN_STATE_XPT_WAIT:

		log_debug(1, "ignoring conn error in XPT_WAIT. "

			  "let connection fail on its own");

		return;

	case ISCSI_CONN_STATE_CLEANUP_WAIT:

		log_debug(1, "ignoring conn error in CLEANUP_WAIT. "

			  "let connection stop");

		return;

	default:

		log_debug(8, "invalid state %d", conn->state);

		return;

	}

	if (session->r_stage == R_STAGE_SESSION_REOPEN) {

		session_conn_reopen(conn, &session->reopen_qtask,

				    STOP_CONN_RECOVER);

		return;

	}

}

static void session_conn_error(void *data)

{

	struct iscsi_ev_context *ev_context = data;

	enum iscsi_err error = *(enum iscsi_err *)ev_context->data;

	iscsi_conn_t *conn = ev_context->conn;

	iscsi_session_t *session = conn->session;