#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <stdint.h>

#include <inttypes.h>

#include <libopeniscsiusr/libopeniscsiusr.h>

#include "list.h"

#include "log.h"

#include "iscsi_sysfs.h"

#include "version.h"

#include "iscsi_settings.h"

#include "mgmt_ipc.h"

#include "session_info.h"

#include "transport.h"

#include "initiator.h"

#include "iface.h"

#include "iscsid_req.h"

#include "iscsi_err.h"

static int session_info_print_flat(struct iscsi_session *se);

int session_info_create_list(void *data, struct session_info *info)

{

	struct session_link_info *link_info = data;

	struct list_head *list = link_info->list;

	struct session_info *new, *curr, *match = NULL;

	if (link_info->match_fn && !link_info->match_fn(link_info->data, info))

		return -1;

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

	if (!new)

		return ISCSI_ERR_NOMEM;

	memcpy(new, info, sizeof(*new));

	INIT_LIST_HEAD(&new->list);

	if (list_empty(list)) {

		list_add_tail(&new->list, list);

		return 0;

	}

	list_for_each_entry(curr, list, list) {

		if (!strcmp(curr->targetname, info->targetname)) {

			match = curr;

			if (!strcmp(curr->address, info->address)) {

				match = curr;

				if (curr->port == info->port) {

					match = curr;

					break;

				}

			}

		}

	}

	list_add_tail(&new->list, match ? match->list.next : list);

	return 0;

}

void session_info_free_list(struct list_head *list)

{

	struct session_info *curr, *tmp;

	list_for_each_entry_safe(curr, tmp, list, list) {

		list_del(&curr->list);

		free(curr);

	}

}

static char *get_iscsi_node_type(uint32_t sid)

{

	int pid = iscsi_sysfs_session_user_created((int) sid);

	if (!pid)

		return "flash";

	else

		return "non-flash";

}

static int session_info_print_flat(struct iscsi_session *se)

{

	uint32_t sid = 0;

	struct iscsi_transport *t = NULL;

	sid = iscsi_session_sid_get(se);

	t = iscsi_sysfs_get_transport_by_sid((int) sid);

	if (strchr(iscsi_session_persistent_address_get(se), '.'))

		printf("%s: [%" PRIu32 "] %s:%" PRIi32 ",%"PRIi32 " %s (%s)\n",

			t ? t->name : UNKNOWN_VALUE,

			sid, iscsi_session_persistent_address_get(se),

			iscsi_session_persistent_port_get(se),

			iscsi_session_tpgt_get(se),

			iscsi_session_target_name_get(se),

			get_iscsi_node_type(sid));

	else

		printf("%s: [%" PRIu32 "] [%s]:%" PRIi32 ",%" PRIi32

		       " %s (%s)\n",

			t ? t->name : UNKNOWN_VALUE,

			sid, iscsi_session_persistent_address_get(se),

			iscsi_session_persistent_port_get(se),

			iscsi_session_tpgt_get(se),

			iscsi_session_target_name_get(se),

			get_iscsi_node_type(sid));

	return 0;

}

static int print_iscsi_state(int sid, char *prefix, int tmo)

{

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

	int err;

	char *state = NULL;

	char state_buff[SCSI_MAX_STATE_VALUE];

	static char *conn_state[] = {

		"FREE",

		"TRANSPORT WAIT",

		"IN LOGIN",

		"LOGGED IN",

		"IN LOGOUT",

		"LOGOUT REQUESTED",

		"CLEANUP WAIT",

	};

	static char *session_state[] = {

		"NO CHANGE",

		"CLEANUP",

		"REOPEN",

		"REDIRECT",

	};

	memset(&req, 0, sizeof(iscsiadm_req_t));

	req.command = MGMT_IPC_SESSION_INFO;

	req.u.session.sid = sid;

	err = iscsid_exec_req(&req, &rsp, 1, tmo);

	/*

	 * for drivers like qla4xxx, iscsid does not display

	 * anything here since it does not know about it.

	 */

	if (!err && rsp.u.session_state.conn_state >= 0 &&

	    rsp.u.session_state.conn_state <= ISCSI_CONN_STATE_CLEANUP_WAIT)

		state = conn_state[rsp.u.session_state.conn_state];

	printf("%s\t\tiSCSI Connection State: %s\n", prefix,

	       state ? state : "Unknown");

	state = NULL;

	memset(state_buff, 0, SCSI_MAX_STATE_VALUE);

	if (!iscsi_sysfs_get_session_state(state_buff, sid))

		printf("%s\t\tiSCSI Session State: %s\n", prefix, state_buff);

	else

		printf("%s\t\tiSCSI Session State: Unknown\n", prefix);

	if (!err && rsp.u.session_state.session_state >= 0 &&

	   rsp.u.session_state.session_state <= R_STAGE_SESSION_REDIRECT)

		state = session_state[rsp.u.session_state.session_state];

	printf("%s\t\tInternal iscsid Session State: %s\n", prefix,

	       state ? state : "Unknown");

	return 0;

}

static void print_iscsi_params(int sid, char *prefix)

{

	struct iscsi_session_operational_config session_conf;

	struct iscsi_conn_operational_config conn_conf;

	iscsi_sysfs_get_negotiated_session_conf(sid, &session_conf);

	iscsi_sysfs_get_negotiated_conn_conf(sid, &conn_conf);

	printf("%s\t\t************************\n", prefix);

	printf("%s\t\tNegotiated iSCSI params:\n", prefix);

	printf("%s\t\t************************\n", prefix);

	if (is_valid_operational_value(conn_conf.HeaderDigest))

		printf("%s\t\tHeaderDigest: %s\n", prefix,

			conn_conf.HeaderDigest ? "CRC32C" : "None");

	if (is_valid_operational_value(conn_conf.DataDigest))

		printf("%s\t\tDataDigest: %s\n", prefix,

			conn_conf.DataDigest ? "CRC32C" : "None");

	if (is_valid_operational_value(conn_conf.MaxRecvDataSegmentLength))

		printf("%s\t\tMaxRecvDataSegmentLength: %d\n", prefix,

			conn_conf.MaxRecvDataSegmentLength);

	if (is_valid_operational_value(conn_conf.MaxXmitDataSegmentLength))

		printf("%s\t\tMaxXmitDataSegmentLength: %d\n", prefix,

			conn_conf.MaxXmitDataSegmentLength);

	if (is_valid_operational_value(session_conf.FirstBurstLength))

		printf("%s\t\tFirstBurstLength: %d\n", prefix,

			session_conf.FirstBurstLength);

	if (is_valid_operational_value(session_conf.MaxBurstLength))

		printf("%s\t\tMaxBurstLength: %d\n", prefix,

			session_conf.MaxBurstLength);

	if (is_valid_operational_value(session_conf.ImmediateData))

		printf("%s\t\tImmediateData: %s\n", prefix,

			session_conf.ImmediateData ? "Yes" : "No");

	if (is_valid_operational_value(session_conf.InitialR2T))

		printf("%s\t\tInitialR2T: %s\n", prefix,

			session_conf.InitialR2T ? "Yes" : "No");

	if (is_valid_operational_value(session_conf.MaxOutstandingR2T))

		printf("%s\t\tMaxOutstandingR2T: %d\n", prefix,

			session_conf.MaxOutstandingR2T);

}

static void print_scsi_device_info(void *data, int host_no, int target, int lun)

{

	char *prefix = data;

	char *blockdev, state[SCSI_MAX_STATE_VALUE];

	printf("%s\t\tscsi%d Channel 00 Id %d Lun: %d\n", prefix, host_no,

	       target, lun);

	blockdev = iscsi_sysfs_get_blockdev_from_lun(host_no, target, lun);

	if (blockdev) {

		printf("%s\t\t\tAttached scsi disk %s\t\t", prefix, blockdev);

		free(blockdev);

		if (!iscsi_sysfs_get_device_state(state, host_no, target, lun))

			printf("State: %s\n", state);

		else

			printf("State: Unknown\n");

	}

}

static int print_scsi_state(int sid, char *prefix, unsigned int flags)

{

	int host_no = -1, err = 0;

	char state[SCSI_MAX_STATE_VALUE];

	printf("%s\t\t************************\n", prefix);

	printf("%s\t\tAttached SCSI devices:\n", prefix);

	printf("%s\t\t************************\n", prefix);

	host_no = iscsi_sysfs_get_host_no_from_sid(sid, &err;;

	if (err) {

		printf("%s\t\tUnavailable\n", prefix);

		return err;

	}

	if (flags & SESSION_INFO_HOST_DEVS) {

		printf("%s\t\tHost Number: %d\t", prefix, host_no);

		if (!iscsi_sysfs_get_host_state(state, host_no))

			printf("State: %s\n", state);

		else

			printf("State: Unknown\n");

	}

	if (flags & SESSION_INFO_SCSI_DEVS)

		iscsi_sysfs_for_each_device(prefix, host_no, sid,

					    print_scsi_device_info);

	return 0;

}

void session_info_print_tree(struct iscsi_session **ses, uint32_t se_count,

			     char *prefix, unsigned int flags, int do_show)

{

	struct iscsi_session *curr = NULL;

	struct iscsi_session *prev = NULL;

	const char *curr_targetname = NULL;

	const char *curr_address = NULL;

	const char *persistent_address = NULL;

	const char *prev_targetname = NULL;

	const char *prev_address = NULL;

	int32_t curr_port = 0;

	int32_t prev_port = 0;

	uint32_t i = 0;

	uint32_t sid = 0;

	char *new_prefix = NULL;

	int32_t tgt_reset_tmo = -1;

	int32_t lu_reset_tmo = -1;

	int32_t abort_tmo = -1;

	const char *pass = NULL;

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

		curr = ses[i];

		curr_targetname = iscsi_session_target_name_get(curr);

		sid = iscsi_session_sid_get(curr);

		if (prev != NULL)

			prev_targetname = iscsi_session_target_name_get(prev);

		else

			prev_targetname = NULL;

		if (! ((prev_targetname != NULL) &&

		       (curr_targetname != NULL) &&

		       (strcmp(prev_targetname, curr_targetname) == 0))) {

			printf("%sTarget: %s (%s)\n", prefix, curr_targetname,

				get_iscsi_node_type(sid));

			prev = NULL;

		}

		curr_address = iscsi_session_address_get(curr);

		curr_port = iscsi_session_port_get(curr);

		if (prev != NULL) {

			prev_address = iscsi_session_address_get(prev);

			prev_port = iscsi_session_port_get(prev);

		} else {

			prev_address = NULL;

			prev_port = 0;

		}

		if (! ((prev_address != NULL) &&

		       (curr_address != NULL) &&

		       (prev_port != 0) &&

		       (curr_port != 0) &&

		       (strcmp(prev_address, curr_address) == 0) &&

		       (curr_port == prev_port))) {

			if (strchr(curr_address, '.'))

				printf("%s\tCurrent Portal: %s:%" PRIi32

				       ",%" PRIi32 "\n",

				       prefix, curr_address, curr_port,

				       iscsi_session_tpgt_get(curr));

			else

				printf("%s\tCurrent Portal: [%s]:%" PRIi32

				       ",%" PRIi32 "\n",

				       prefix, curr_address, curr_port,

				       iscsi_session_tpgt_get(curr));

			persistent_address =

				iscsi_session_persistent_address_get(curr);

			if (strchr(persistent_address, '.'))

				printf("%s\tPersistent Portal: %s:%" PRIi32

				       ",%" PRIi32 "\n",

				       prefix, persistent_address,

				       iscsi_session_persistent_port_get(curr),

				       iscsi_session_tpgt_get(curr));

			else

				printf("%s\tPersistent Portal: [%s]:%" PRIi32

				       ",%" PRIi32 "\n",

				       prefix, persistent_address,

				       iscsi_session_persistent_port_get(curr),

				       iscsi_session_tpgt_get(curr));

		} else

			printf("\n");

		if (flags & SESSION_INFO_IFACE) {

			printf("%s\t\t**********\n", prefix);

			printf("%s\t\tInterface:\n", prefix);

			printf("%s\t\t**********\n", prefix);

			new_prefix = calloc(1, 1 + strlen(prefix) +

					    strlen("\t\t"));

			if (new_prefix == NULL) {

				printf("Could not print interface info. "

					"Out of Memory.\n");

				return;

			} else {

				sprintf(new_prefix, "%s%s", prefix, "\t\t");

				iface_print(iscsi_session_iface_get(curr),

					    new_prefix);

			}

			free(new_prefix);

		}

		if (flags & SESSION_INFO_ISCSI_STATE) {

			printf("%s\t\tSID: %" PRIu32 "\n", prefix, sid);

			print_iscsi_state((int) sid, prefix, -1 /* tmo */);

			/* TODO(Gris Ge): It seems in the whole project,

			 *		  tmo is always -1, correct?

			 */

		}

		if (flags & SESSION_INFO_ISCSI_TIM) {

			printf("%s\t\t*********\n", prefix);

			printf("%s\t\tTimeouts:\n", prefix);

			printf("%s\t\t*********\n", prefix);

			printf("%s\t\tRecovery Timeout: %" PRIi32 "\n", prefix,

			       iscsi_session_recovery_tmo_get(curr));

			tgt_reset_tmo = iscsi_session_tgt_reset_tmo_get(curr);

			lu_reset_tmo = iscsi_session_lu_reset_tmo_get(curr);

			abort_tmo = iscsi_session_abort_tmo_get(curr);

			if (tgt_reset_tmo >= 0)

				printf("%s\t\tTarget Reset Timeout: %" PRIi32

				       "\n", prefix, tgt_reset_tmo);

			else

				printf("%s\t\tTarget Reset Timeout: %s\n",

					prefix, UNKNOWN_VALUE);

			if (lu_reset_tmo >= 0)

				printf("%s\t\tLUN Reset Timeout: %" PRIi32 "\n",

				       prefix, lu_reset_tmo);

			else

				printf("%s\t\tLUN Reset Timeout: %s\n", prefix,

					UNKNOWN_VALUE);

			if (abort_tmo >= 0)

				printf("%s\t\tAbort Timeout: %" PRIi32 "\n",

				       prefix, abort_tmo);

			else

				printf("%s\t\tAbort Timeout: %s\n", prefix,

					UNKNOWN_VALUE);

		}

		if (flags & SESSION_INFO_ISCSI_AUTH) {

			printf("%s\t\t*****\n", prefix);

			printf("%s\t\tCHAP:\n", prefix);

			printf("%s\t\t*****\n", prefix);

			printf("%s\t\tusername: %s\n", prefix,

			       strlen(iscsi_session_username_get(curr)) ?

			       iscsi_session_username_get(curr) :

			       UNKNOWN_VALUE);

			if (!do_show)

				printf("%s\t\tpassword: %s\n", prefix,

					"********");

			else {

				pass = iscsi_session_password_get(curr);

				printf("%s\t\tpassword: %s\n", prefix,

				       strlen(pass) ?  pass : UNKNOWN_VALUE);

			}

			printf("%s\t\tusername_in: %s\n", prefix,

			       strlen(iscsi_session_username_in_get(curr)) ?

			       iscsi_session_username_in_get(curr) :

			       UNKNOWN_VALUE);

			if (!do_show)

				printf("%s\t\tpassword_in: %s\n", prefix,

					"********");

			else {

				pass = iscsi_session_password_in_get(curr);

				printf("%s\t\tpassword: %s\n", prefix,

				       strlen(pass) ?  pass : UNKNOWN_VALUE);

			}

		}

		if (flags & SESSION_INFO_ISCSI_PARAMS)

			print_iscsi_params((int) sid, prefix);

		if (flags & (SESSION_INFO_SCSI_DEVS | SESSION_INFO_HOST_DEVS))

			print_scsi_state((int) sid, prefix, flags);

		prev = curr;

	}

}

int session_info_print(int info_level, struct iscsi_session **ses,

		       uint32_t se_count, int do_show)

{

	int err = 0;

	char *version;

	unsigned int flags = 0;

	uint32_t i = 0;

	switch (info_level) {

	case 0:

	case -1:

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

			err = session_info_print_flat(ses[i]);

			if (err != 0)

				break;

		}

		break;

	case 3:

		version = iscsi_sysfs_get_iscsi_kernel_version();

		if (version) {

			printf("iSCSI Transport Class version %s\n",

				version);

			printf("version %s\n", ISCSI_VERSION_STR);

			free(version);

		}

		flags |= (SESSION_INFO_SCSI_DEVS | SESSION_INFO_HOST_DEVS);

		/* fall through */

	case 2:

		flags |= (SESSION_INFO_ISCSI_PARAMS | SESSION_INFO_ISCSI_TIM

				| SESSION_INFO_ISCSI_AUTH);

		/* fall through */

	case 1:

		flags |= (SESSION_INFO_ISCSI_STATE | SESSION_INFO_IFACE);

		session_info_print_tree(ses, se_count, "", flags, do_show);

		break;

	default:

		log_error("Invalid info level %d. Try 0 - 3.", info_level);

		return ISCSI_ERR_INVAL;

	}

	if (err) {

		log_error("Can not get list of active sessions (%d)", err);

		return err;

	}

	return 0;

}