/*

 * iSCSI Administration Utility

 *

 * Copyright (C) 2004 Dmitry Yusupov, Alex Aizman

 * Copyright (C) 2006 Mike Christie

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

 * Copyright (C) 2011 Dell Inc.

 * 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 <errno.h>

#include <getopt.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <signal.h>

#include <time.h>

#include <sys/stat.h>

#include <inttypes.h>

#include <libopeniscsiusr/libopeniscsiusr.h>

#include "initiator.h"

#include "discovery.h"

#include "log.h"

#include "mgmt_ipc.h"

#include "idbm.h"

#include "iscsi_util.h"

#include "transport.h"

#include "version.h"

#include "iscsi_sysfs.h"

#include "list.h"

#include "iscsi_settings.h"

#include "fw_context.h"

#include "iface.h"

#include "session_info.h"

#include "host.h"

#include "sysdeps.h"

#include "idbm_fields.h"

#include "session_mgmt.h"

#include "iscsid_req.h"

#include <libisns/isns-proto.h>

#include "iscsi_err.h"

#include "iscsi_ipc.h"

#include "iscsi_timer.h"

#include "flashnode.h"

#define _good(rc, rc_val, out) \

	do { \

		rc_val = rc; \

		if (rc_val != LIBISCSI_OK) \

			goto out; \

	} while(0)

static char program_name[] = "iscsiadm";

static char config_file[TARGET_NAME_MAXLEN];

extern struct iscsi_ipc *ipc;

enum iscsiadm_mode {

	MODE_DISCOVERY,

	MODE_DISCOVERYDB,

	MODE_NODE,

	MODE_SESSION,

	MODE_HOST,

	MODE_IFACE,

	MODE_FW,

	MODE_PING,

	MODE_CHAP,

	MODE_FLASHNODE,

	MODE_HOST_STATS

};

enum iscsiadm_op {

	OP_NOOP			= 0x0,

	OP_NEW			= 0x1,

	OP_DELETE		= 0x2,

	OP_UPDATE		= 0x4,

	OP_SHOW			= 0x8,

	OP_NONPERSISTENT	= 0x10,

	OP_APPLY		= 0x20,

	OP_APPLY_ALL		= 0x40,

	OP_LOGIN		= 0x80,

	OP_LOGOUT		= 0x100

};

enum _print_node_tree_mode {

	_PRINT_MODE_IFACE,

	_PRINT_MODE_NODE,

};

static struct option const long_options[] =

{

	{"mode", required_argument, NULL, 'm'},

	{"portal", required_argument, NULL, 'p'},

	{"targetname", required_argument, NULL, 'T'},

	{"interface", required_argument, NULL, 'I'},

	{"op", required_argument, NULL, 'o'},

	{"type", required_argument, NULL, 't'},

	{"name", required_argument, NULL, 'n'},

	{"value", required_argument, NULL, 'v'},

	{"host", required_argument, NULL, 'H'},

	{"sid", required_argument, NULL, 'r'},

	{"rescan", no_argument, NULL, 'R'},

	{"print", required_argument, NULL, 'P'},

	{"discover", no_argument, NULL, 'D'},

	{"login", no_argument, NULL, 'l'},

	{"loginall", required_argument, NULL, 'L'},

	{"logout", no_argument, NULL, 'u'},

	{"logoutall", required_argument, NULL, 'U'},

	{"stats", no_argument, NULL, 's'},

	{"killiscsid", required_argument, NULL, 'k'},

	{"debug", required_argument, NULL, 'd'},

	{"show", no_argument, NULL, 'S'},

	{"version", no_argument, NULL, 'V'},

	{"help", no_argument, NULL, 'h'},

	{"submode", required_argument, NULL, 'C'},

	{"ip", required_argument, NULL, 'a'},

	{"packetsize", required_argument, NULL, 'b'},

	{"count", required_argument, NULL, 'c'},

	{"interval", required_argument, NULL, 'i'},

	{"index", required_argument, NULL, 'x'},

	{"portal_type", optional_argument, NULL, 'A'},

	{"no_wait", no_argument, NULL, 'W'},

	{NULL, 0, NULL, 0},

};

static char *short_options = "RlDVhm:a:b:c:C:p:P:T:H:i:I:U:k:L:d:r:n:v:o:sSt:ux:A:W";

static void usage(int status)

{

	if (status != 0)

		fprintf(stderr, "Try `%s --help' for more information.\n",

			program_name);

	else {

		printf("\

iscsiadm -m discoverydb [-hV] [-d debug_level] [-P printlevel] [-t type -p ip:port -I ifaceN ... [-Dl]] | [[-p ip:port -t type] \

[-o operation] [-n name] [-v value] [-lD]] \n\

iscsiadm -m discovery [-hV] [-d debug_level] [-P printlevel] [-t type -p ip:port -I ifaceN ... [-l]] | [[-p ip:port] [-l | -D]] \n\

iscsiadm -m node [-hV] [-d debug_level] [-P printlevel] [-L all,manual,automatic,onboot] [-W] [-U all,manual,automatic,onboot] [-S] [[-T targetname -p ip:port -I ifaceN] [-l | -u | -R | -s]] \

[[-o  operation ] [-n name] [-v value]]\n\

iscsiadm -m session [-hV] [-d debug_level] [-P  printlevel] [-r sessionid | sysfsdir [-R | -u | -s] [-o operation] [-n name] [-v value]]\n\

iscsiadm -m iface [-hV] [-d debug_level] [-P printlevel] [-I ifacename | -H hostno|MAC] [[-o  operation ] [-n name] [-v value]] [-C ping [-a ip] [-b packetsize] [-c count] [-i interval]]\n\

iscsiadm -m fw [-d debug_level] [-l]\n\

iscsiadm -m host [-P printlevel] [-H hostno|MAC] [[-C chap [-x chap_tbl_idx]] | [-C flashnode [-A portal_type] [-x flashnode_idx]] | [-C stats]] [[-o operation] [-n name] [-v value]] \n\

iscsiadm -k priority\n");

	}

	exit(status);

}

static int

str_to_op(char *str)

{

	int op;

	if (!strcmp("new", str))

		op = OP_NEW;

	else if (!strcmp("delete", str))

		op = OP_DELETE;

	else if (!strcmp("update", str))

		op = OP_UPDATE;

	else if (!strcmp("show", str))

		op = OP_SHOW;

	else if (!strcmp("nonpersistent", str))

		op = OP_NONPERSISTENT;

	else if (!strcmp("apply", str))

		op = OP_APPLY;

	else if (!strcmp("applyall", str))

		op = OP_APPLY_ALL;

	else if (!strcmp("login", str))

		op = OP_LOGIN;

	else if (!strcmp("logout", str))

		op = OP_LOGOUT;

	else

		op = OP_NOOP;

	return op;

}

static int

str_to_mode(char *str)

{

	int mode;

	if (!strcmp("discovery", str))

		mode = MODE_DISCOVERY;

	else if (!strcmp("discoverydb", str))

		mode = MODE_DISCOVERYDB;

	else if (!strcmp("node", str))

		mode = MODE_NODE;

	else if (!strcmp("session", str))

		mode = MODE_SESSION;

	else if (!strcmp("iface", str))

		mode = MODE_IFACE;

	else if (!strcmp("fw", str))

		mode = MODE_FW;

	else if (!strcmp("host", str))

		mode = MODE_HOST;

	else

		mode = -1;

	return mode;

}

static int

str_to_submode(char *str)

{

	int sub_mode;

	if (!strcmp("ping", str))

		sub_mode = MODE_PING;

	else if (!strcmp("chap", str))

		sub_mode = MODE_CHAP;

	else if (!strcmp("flashnode", str))

		sub_mode = MODE_FLASHNODE;

	else if (!strcmp("stats", str))

		sub_mode = MODE_HOST_STATS;

	else

		sub_mode = -1;

	return sub_mode;

}

static int

str_to_type(char *str)

{

	int type;

	if (!strcmp("sendtargets", str) ||

	    !strcmp("st", str))

		type = DISCOVERY_TYPE_SENDTARGETS;

	else if (!strcmp("slp", str))

		type = DISCOVERY_TYPE_SLP;

	else if (!strcmp("isns", str))

		type = DISCOVERY_TYPE_ISNS;

	else if (!strcmp("fw", str))

		type = DISCOVERY_TYPE_FW;

	else

		type = -1;

	return type;

}

static int

str_to_portal_type(char *str)

{

	int ptype;

	if (!strcmp("ipv4", str))

		ptype = IPV4;

	else if (!strcmp("ipv6", str))

		ptype = IPV6;

	else

		ptype = -1;

	return ptype;

}

static void kill_iscsid(int priority, int tmo)

{

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

	int rc;

	/*

	 * We only support SIGTERM like stoppage of iscsid for now.

	 * In the future we can do something where we try go finish

	 * up operations like login, error handling, etc, before

	 * iscsid is stopped, and we can add different values to indicate

	 * that the user wants iscsid to log out existing sessions before

	 * exiting.

	 */

	if (priority != 0) {

		log_error("Invalid iscsid priority %d. Priority must be 0.",

			  priority);

		return;

	}

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

	req.command = MGMT_IPC_IMMEDIATE_STOP;

	rc = iscsid_exec_req(&req, &rsp, 0, tmo);

	if (rc) {

		iscsi_err_print_msg(rc);

		log_error("Could not stop iscsid. Trying sending iscsid "

			  "SIGTERM or SIGKILL signals manually");

	}

}

static int

match_startup_mode(node_rec_t *rec, char *mode)

{

	if ((!strcmp(mode, "automatic") &&

	    rec->startup == ISCSI_STARTUP_AUTOMATIC) ||

	    (!strcmp(mode, "onboot") &&

	    rec->startup == ISCSI_STARTUP_ONBOOT) ||

	    (!strcmp(mode, "manual") &&

	    rec->startup == ISCSI_STARTUP_MANUAL) ||

	    !strcmp(mode, "all"))

		return 0;

	/* support conn or session startup params */

	if ((!strcmp(mode, "automatic") &&

	    rec->conn[0].startup == ISCSI_STARTUP_AUTOMATIC) ||

	    (!strcmp(mode, "onboot") &&

	    rec->conn[0].startup == ISCSI_STARTUP_ONBOOT) ||

	    (!strcmp(mode, "manual") &&

	    rec->conn[0].startup == ISCSI_STARTUP_MANUAL) ||

	    !strcmp(mode, "all"))

		return 0;

	return -1;

}

static int

for_each_session(struct node_rec *rec, iscsi_sysfs_session_op_fn *fn,

		 int in_parallel)

{

	int err, num_found = 0;

	if (rec && rec->session.info) {

		num_found = 1;

		err = fn(rec, rec->session.info);

	} else {

		err = iscsi_sysfs_for_each_session(rec, &num_found, fn,

						   in_parallel);

	}

	if (err)

		log_error("Could not execute operation on all sessions: %s",

			  iscsi_err_to_str(err));

	else if (!num_found) {

		log_error("No session found.");

		err = ISCSI_ERR_NO_OBJS_FOUND;

	}

	return err;

}

static int link_recs(void *data, struct node_rec *rec)

{

	struct list_head *list = data;

	struct node_rec *rec_copy;

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

	if (!rec_copy)

		return ISCSI_ERR_NOMEM;

	memcpy(rec_copy, rec, sizeof(*rec_copy));

	INIT_LIST_HEAD(&rec_copy->list);

	list_add_tail(&rec_copy->list, list);

	return 0;

}

static int

__logout_by_startup(void *data, struct list_head *list,

		    struct session_info *info)

{

	char *mode = data;

	node_rec_t rec;

	memset(&rec, 0, sizeof(node_rec_t));

	if (idbm_rec_read(&rec, info->targetname, info->tpgt,

			  info->persistent_address,

			  info->persistent_port, &info->iface, false)) {

		/*

		 * this is due to a HW driver or some other driver

		 * not hooked in

		 */

		log_debug(7, "could not read data for [%s,%s.%d]",

			  info->targetname, info->persistent_address,

			  info->persistent_port);

		return -1;

	}

	/* multiple drivers could be connected to the same portal */

	if (strcmp(rec.iface.transport_name, info->iface.transport_name))

		return -1;

	/*

	 * we always skip on boot because if the user killed this on

	 * they would not be able to do anything

	 */

	if (rec.startup == ISCSI_STARTUP_ONBOOT)

		return -1;

	if (rec.disc_type == DISCOVERY_TYPE_FW)

		return -1;

	if (match_startup_mode(&rec, mode))

		return -1;

	return iscsi_logout_portal(info, list);

}

static int

logout_by_startup(char *mode)

{

	int nr_found;

	int rc;

	if (!mode || !(!strcmp(mode, "automatic") || !strcmp(mode, "all") ||

	    !strcmp(mode,"manual"))) {

		log_error("Invalid logoutall option %s.", mode);

		usage(ISCSI_ERR_INVAL);

		return ISCSI_ERR_INVAL;

	}

	rc = iscsi_logout_portals(mode, &nr_found, 1, __logout_by_startup);

	if (rc == ISCSI_ERR_NO_OBJS_FOUND)

		log_error("No matching sessions found");

	return rc;

}

struct startup_data {

	char *mode;

	struct list_head all_logins;

	struct list_head leading_logins;

};

static int link_startup_recs(void *data, struct node_rec *rec)

{

	struct startup_data *startup = data;

	struct node_rec *rec_copy;

	if (match_startup_mode(rec, startup->mode))

		return -1;

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

	if (!rec_copy)

		return ISCSI_ERR_NOMEM;

	memcpy(rec_copy, rec, sizeof(*rec_copy));

	INIT_LIST_HEAD(&rec_copy->list);

	if (rec_copy->leading_login)

		list_add_tail(&rec_copy->list, &startup->leading_logins);

	else

		list_add_tail(&rec_copy->list, &startup->all_logins);

	return 0;

}

static int

__do_leading_login(void *data, struct list_head *list, struct node_rec *rec)

{

	struct iface_rec *pattern_iface = data;

	int nr_found;

	log_debug(1, "doing leading login using iface: %s", pattern_iface->name);

	/* Skip any records that do not match the pattern iface */

	if (!iface_match(pattern_iface, &rec->iface))

		return -1;

	/*

	 * If there is an existing session that matcthes the target,

	 * the leading login is complete.

	 */

	if (iscsi_sysfs_for_each_session(rec, &nr_found, iscsi_match_target, 0)) {

		log_debug(1, "Skipping %s: Already a session for that target",

			  rec->name);

		return -1;

	}

	/* No existing session: Attempt a login. */

	return iscsi_login_portal(NULL, list, rec);

}

static int

login_by_startup(char *mode, bool wait)

{

	int nr_found = 0, err, rc;

	struct startup_data startup;

	if (!mode || !(!strcmp(mode, "automatic") || !strcmp(mode, "all") ||

		       !strcmp(mode,"manual") || !strcmp(mode, "onboot"))) {

		log_error("Invalid loginall option %s.", mode);

		usage(ISCSI_ERR_INVAL);

		return ISCSI_ERR_INVAL;

	}

	/*

	 * Filter all node records that match the given 'mode' into 2 lists:

	 * Those with leading_login enabled, and those without.

	 */

	startup.mode = mode;

	INIT_LIST_HEAD(&startup.all_logins);

	INIT_LIST_HEAD(&startup.leading_logins);

	err = idbm_for_each_rec(&nr_found, &startup, link_startup_recs, false);

	if (err && (!list_empty(&startup.all_logins) ||

		    !list_empty(&startup.leading_logins)))

		/* log msg and try to log into what we found */

		log_error("Could not read all records: %s",

			  iscsi_err_to_str(err));

	else if (list_empty(&startup.all_logins) &&

		 list_empty(&startup.leading_logins)) {

		if (err) {

			log_error("Could not read node DB: %s.",

				  iscsi_err_to_str(err));

		} else {

			log_error("No records found");

			err = ISCSI_ERR_NO_OBJS_FOUND;

		}

		return err;

	}

	rc = err;

	if (!list_empty(&startup.all_logins)) {

		log_debug(1, "Logging into normal (non-leading-login) portals");

		/* Login all regular (non-leading-login) portals first */

		err = iscsi_login_portals(NULL, &nr_found, wait,

				&startup.all_logins, iscsi_login_portal);

		if (err)

			log_error("Could not log into all portals");

		if (err && !rc)

			rc = err;

	}

	if (!list_empty(&startup.leading_logins)) {

		/*

		 * For each iface in turn, try to login all portals on that

		 * iface that do not already have a session present.

		 */

		struct iface_rec *pattern_iface, *tmp_iface;

		struct node_rec *rec, *tmp_rec;

		LIST_HEAD(iface_list);

		int missed_leading_login = 0;

		log_debug(1, "Logging into leading-login portals");

		iface_link_ifaces(&iface_list);

		list_for_each_entry_safe(pattern_iface, tmp_iface, &iface_list,

					 list) {

			log_debug(1, "Establishing leading-logins via iface %s",

				  pattern_iface->name);

			err = iscsi_login_portals_safe(pattern_iface, &nr_found,

						       1,

						       &startup.leading_logins,

						       __do_leading_login);

			if (err)

				log_error("Could not log into all portals on "

					  "%s, trying next interface",

					  pattern_iface->name);

			/*

			 * Note: We always try all iface records in case there

			 * are targets that are associated with only a subset

			 * of iface records.  __do_leading_login already

			 * prevents duplicate sessions if an iface has succeeded

			 * for a particular target.

			 */

		}

		/*

		 * Double-check that all leading-login portals have at least

		 * one session

		 */

		list_for_each_entry_safe(rec, tmp_rec, &startup.leading_logins,

					 list) {

			if (!iscsi_sysfs_for_each_session(rec, &nr_found,

							  iscsi_match_target, 0))

				missed_leading_login++;

			/*

			 * Cleanup the list, since 'iscsi_login_portals_safe'

			 * does not

			 */

			list_del(&rec->list);

			free(rec);

		}

		if (missed_leading_login) {

			log_error("Could not login all leading-login portals");

			if (!rc)

				rc = ISCSI_ERR_FATAL_LOGIN;

		}

	}

	return rc;

}

/**

 * iscsi_logout_matched_portal - logout of targets matching the rec info

 * @data: record to session with

 * @list: list to add logout rec to

 * @info: session to match with rec

 */

static int iscsi_logout_matched_portal(void *data, struct list_head *list,

				       struct session_info *info)

{

	struct node_rec *pattern_rec = data;

	struct iscsi_transport *t;

	uint32_t host_no;

	int rc = 0;

	t = iscsi_sysfs_get_transport_by_sid(info->sid);

	if (!t)

		return -1;

	if (!iscsi_match_session(pattern_rec, info))

		return -1;

	host_no = iscsi_sysfs_get_host_no_from_sid(info->sid, &rc);

	if (rc) {

		log_error("could not get host_no for session%d: %s.",

			  info->sid, iscsi_err_to_str(rc));

		return -1;

	}

	if (!iscsi_sysfs_session_user_created(info->sid))

		rc = iscsi_logout_flashnode_sid(t, host_no, info->sid);

	else

		rc = iscsi_logout_portal(info, list);

	return rc;

}

static int rec_match_fn(void *data, node_rec_t *rec)

{

	struct rec_op_data *op_data = data;

	if (!__iscsi_match_session(op_data->match_rec, rec->name,

				   rec->conn[0].address, rec->conn[0].port,

				   &rec->iface, rec->session.sid))

		return -1;

	return op_data->fn(op_data->data, rec);

}

static int __for_each_matched_rec(int verbose, struct node_rec *rec,

				  void *data, idbm_iface_op_fn *fn)

{

	struct rec_op_data op_data;

	int nr_found = 0, rc;

	memset(&op_data, 0, sizeof(struct rec_op_data));

	op_data.data = data;

	op_data.match_rec = rec;

	op_data.fn = fn;

	rc = idbm_for_each_rec(&nr_found, &op_data, rec_match_fn, true);

	if (rc) {

		if (verbose)

			log_error("Could not execute operation on all "

				  "records: %s", iscsi_err_to_str(rc));

	} else if (!nr_found) {

		if (verbose)

			log_error("No records found");

		rc = ISCSI_ERR_NO_OBJS_FOUND;

	}

	return rc;

}

static int for_each_matched_rec(struct node_rec *rec, void *data,

			        idbm_iface_op_fn *fn)

{

	return __for_each_matched_rec(1, rec, data, fn);

}

static int login_portals(struct node_rec *pattern_rec, bool wait)

{

	LIST_HEAD(rec_list);

	int nr_found, rc, err;

	err = for_each_matched_rec(pattern_rec, &rec_list, link_recs);

	if (err == ISCSI_ERR_NO_OBJS_FOUND)

		return err;

	else if (err && list_empty(&rec_list))

		return err;

	rc = err;

	/* if there is an err but some recs then try to login to what we have */

	err = iscsi_login_portals(pattern_rec, &nr_found, wait ? 1 : 0, &rec_list,

				  iscsi_login_portal);

	if (err)

		log_error("Could not log into all portals");

	if (err && !rc)

		rc = err;

	return rc;

}

static void print_node_flat(struct iscsi_node *node)

{

		printf("%s,%" PRIu16 " %s\n",

		       iscsi_node_portal_get(node),

		       iscsi_node_tpgt_get(node),

		       iscsi_node_target_name_get(node));

}

static void print_nodes_tree(struct iscsi_node **nodes, uint32_t node_count,

			     enum _print_node_tree_mode print_mode)

{

	unsigned int i;

	struct iscsi_node *cur_node = NULL;

	struct iscsi_node *prev_node = NULL;

	const char *prefix = NULL;

	if (print_mode == _PRINT_MODE_IFACE)

		prefix = "\t";

	else

		prefix = "";

	// According to libopeniscsiusr document, nodes are sorted. There

	// is no need to create hash table for this.

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

		cur_node = nodes[i];

		/*

		 * Print the target line if this is our first pass, or

		 * if if it does not match the prevous target. Always print

		 * the Portal line. The original code seemed to want to

		 * suppres duplicates here, as well, but it evidently

		 * didn't work that way, so let's not regress output format

		 */

		if (!prev_node || strcmp(iscsi_node_target_name_get(prev_node),

					 iscsi_node_target_name_get(cur_node)))

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

			       iscsi_node_target_name_get(cur_node));

		printf("%s\tPortal: %s,%d\n", prefix,

		       iscsi_node_portal_get(cur_node),

		       iscsi_node_tpgt_get(cur_node));

		if (print_mode == _PRINT_MODE_NODE)

			printf("\t\tIface Name: %s\n",

			       iscsi_node_iface_name_get(cur_node));

		prev_node = cur_node;

	}

}

static int print_nodes(struct iscsi_context *ctx, int info_level)

{

	struct iscsi_node **nodes = NULL;

	uint32_t node_count = 0;

	uint32_t i = 0;

	int rc = 0;

	if ((info_level != 0) && (info_level != -1) && (info_level != 1)) {

		log_error("Invalid info level %d. Try 0 or 1.", info_level);

		rc = ISCSI_ERR_INVAL;

		goto out;

	}

	rc = iscsi_nodes_get(ctx, &nodes, &node_count);

	if (rc != LIBISCSI_OK)

		goto out;

	if (!node_count) {

		log_error("No records found");

		rc = ISCSI_ERR_NO_OBJS_FOUND;

		goto out;

	}

	if (info_level == 1)

		print_nodes_tree(nodes, node_count, _PRINT_MODE_NODE);

	else

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

			print_node_flat(nodes[i]);

out:

	iscsi_nodes_free(nodes, node_count);

	return rc;

}

static int print_nodes_config(struct iscsi_context *ctx, bool show_secret,

			      const char *target_name, const char *address,

			      int32_t port, const char *iface_name)

{

	int rc = 0;

	struct iscsi_node **nodes = NULL;

	struct iscsi_node *node = NULL;

	uint32_t node_count = 0;

	uint32_t i = 0;

	bool match = false;

	bool has_match = false;

	rc = iscsi_nodes_get(ctx, &nodes, &node_count);

	if (rc != LIBISCSI_OK)

		return rc;

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

		node = nodes[i];

		match = true;

		if ((target_name != NULL) &&

		    (strlen(target_name) != 0) &&

		    (strcmp(target_name,

			    iscsi_node_target_name_get(node)) != 0))

			match = false;

		if ((address != NULL) &&

		    (strlen(address) != 0) &&

		    (strcmp(address, iscsi_node_conn_address_get(node)) != 0))

			match = false;

		if ((port != -1) && (port != (int32_t)iscsi_node_conn_port_get(node)))

			match = false;

		if ((iface_name != NULL) &&

		    (strlen(iface_name) != 0) &&

		    (strcmp(iface_name, iscsi_node_iface_name_get(node)) != 0))

			match = false;

		if (match == true) {

			iscsi_node_print_config(node, show_secret);

			has_match = true;

		}

	}

	iscsi_nodes_free(nodes, node_count);

	if (has_match == false) {

		log_error("No records found");

		rc = ISCSI_ERR_NO_OBJS_FOUND;

	}

	return rc;

}

static char *get_config_file(void)

{

	int rc;

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

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

	req.command = MGMT_IPC_CONFIG_FILE;

	rc = iscsid_exec_req(&req, &rsp, 1, ISCSID_REQ_TIMEOUT);

	if (rc)

		return NULL;

	if (rsp.u.config.var[0] != '\0') {

		strcpy(config_file, rsp.u.config.var);

		return config_file;

	}

	return NULL;

}

static int rescan_portal(void *data, struct session_info *info)

{

	int host_no, err;

	if (!iscsi_match_session(data, info))

		return -1;

	printf("Rescanning session [sid: %d, target: %s, portal: "

		"%s,%d]\n", info->sid, info->targetname,

		info->persistent_address, info->port);

	host_no = iscsi_sysfs_get_host_no_from_sid(info->sid, &err;;

	if (err) {

		log_error("Could not rescan session sid %d.", info->sid);

		return err;

	}

	/* rescan each device to pick up size changes */

	iscsi_sysfs_for_each_device(NULL, host_no, info->sid,

				    iscsi_sysfs_rescan_device);

	/* now scan for new devices */

	iscsi_sysfs_scan_host(host_no, 0, 1);

	return 0;

}

static int

session_stats(void *data, struct session_info *info)

{

	int rc, i;

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

	if (!iscsi_match_session(data, info))

		return -1;

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

	req.command = MGMT_IPC_SESSION_STATS;

	req.u.session.sid = info->sid;

	rc = iscsid_exec_req(&req, &rsp, 1, info->iscsid_req_tmo);

	if (rc)

		return rc;