/*
 * Copyright (C) 2017-2018 Red Hat, Inc.
 *
 * 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 3 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Gris Ge <fge@redhat.com>
 */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE			/* For NI_MAXHOST */
#endif

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <dirent.h>
#include <string.h>
#include <net/if.h>
#include <assert.h>
#include <inttypes.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <stdbool.h>
#include <libkmod.h>
#include <limits.h>

#include "libopeniscsiusr/libopeniscsiusr.h"
#include "misc.h"
#include "sysfs.h"
#include "iface.h"
#include "context.h"
#include "idbm.h"
#include "default.h"

#define ISCSIUIO_PATH		"/sbin/iscsiuio"

struct _iscsi_net_drv {
	const char *net_driver_name;		// Ethernet driver.
	const char *iscsi_driver_name;		// iSCSI offload driver.
	const char *transport_name;		// iSCSI transport name.
};

static struct _iscsi_net_drv _ISCSI_NET_DRVS[] = {
	{"cxgb3", "cxgb3i", "cxgb3i"},
	{"cxgb4", "cxgb4i", "cxgb4i"},
	{"bnx2", "bnx2i" , "bnx2i"},
	{"bnx2x", "bnx2i", "bnx2i"},
};

const struct iscsi_iface _DEFAULT_IFACES[] = {
	{
		.name = "default",
		.transport_name	= "tcp",
	},
	{
		.name		= "iser",
		.transport_name	= "iser",
	},
};

static int _load_kernel_module(struct iscsi_context *ctx, const char *drv_name);
static int _iface_conf_write(struct iscsi_context *ctx,
			     struct iscsi_iface *iface);
static int _fill_hw_iface_from_sys(struct iscsi_context *ctx,
				   struct iscsi_iface *iface,
				   const char *iface_kern_id);

_iscsi_getter_func_gen(iscsi_iface, hwaddress, const char *);
_iscsi_getter_func_gen(iscsi_iface, transport_name, const char *);
_iscsi_getter_func_gen(iscsi_iface, ipaddress, const char *);
_iscsi_getter_func_gen(iscsi_iface, netdev, const char *);
_iscsi_getter_func_gen(iscsi_iface, iname, const char *);
_iscsi_getter_func_gen(iscsi_iface, port_state, const char *);
_iscsi_getter_func_gen(iscsi_iface, port_speed, const char *);
_iscsi_getter_func_gen(iscsi_iface, name, const char *);

int _iscsi_iface_get_from_sysfs(struct iscsi_context *ctx, uint32_t host_id,
				uint32_t sid, char *iface_kern_id,
				struct iscsi_iface **iface)
{
	int rc = LIBISCSI_OK;
	char *sysfs_se_dir_path = NULL;
	char *sysfs_sh_dir_path = NULL;
	char *sysfs_scsi_host_dir_path = NULL;
	char proc_name[ISCSI_TRANSPORT_NAME_MAXLEN];
	struct iscsi_iface **ifaces = NULL;
	uint32_t iface_count = 0;
	uint32_t i = 0;
	struct iscsi_iface *tmp_iface = NULL;
	bool bound_by_hwaddr = false;
	bool bound_by_netdev = false;
	bool matched = false;

	assert(ctx != NULL);
	assert(iface != NULL);

	*iface = NULL;

	if (sid != 0) {
		_good(_asprintf(&sysfs_se_dir_path, "%s/session%" PRIu32,
			        _ISCSI_SYS_SESSION_DIR, sid), rc, out);
	}

	_good(_asprintf(&sysfs_sh_dir_path, "%s/host%" PRIu32,
		        _ISCSI_SYS_HOST_DIR, host_id),rc, out);

	_good(_asprintf(&sysfs_scsi_host_dir_path, "%s/host%" PRIu32,
		 _SCSI_SYS_HOST_DIR, host_id), rc, out);

	*iface = (struct iscsi_iface *) calloc(1, sizeof(struct iscsi_iface));
	_alloc_null_check(ctx, *iface, rc, out);

	_good(_sysfs_prop_get_str(ctx, sysfs_scsi_host_dir_path, "proc_name",
				  proc_name, sizeof(proc_name) / sizeof(char),
				  NULL /* raise error if failed */),
	      rc, out);

	if (strncmp(proc_name, "iscsi_", strlen("iscsi_")) == 0)
		_strncpy((*iface)->transport_name, proc_name + strlen("iscsi_"),
			 sizeof((*iface)->transport_name) / sizeof(char));
	else
		_strncpy((*iface)->transport_name, proc_name,
			sizeof((*iface)->transport_name) / sizeof(char));

	_good(_sysfs_prop_get_str(ctx, sysfs_sh_dir_path, "hwaddress",
				  (*iface)->hwaddress,
				  sizeof((*iface)->hwaddress) / sizeof(char),
				  DEFAULT_HWADDRESS),
	      rc, out);
	if (strcmp((*iface)->hwaddress, DEFAULT_HWADDRESS) != 0)
		bound_by_hwaddr = true;

	_good(_sysfs_prop_get_str(ctx, sysfs_sh_dir_path, "netdev",
				  (*iface)->netdev,
				  sizeof((*iface)->netdev) / sizeof(char),
				  DEFAULT_NETDEV),
	      rc, out);
	if (strcmp((*iface)->netdev, DEFAULT_NETDEV) != 0)
		bound_by_netdev = true;

	if (sysfs_se_dir_path)
		_sysfs_prop_get_str(ctx, sysfs_se_dir_path, "initiatorname",
				    (*iface)->iname,
				    sizeof((*iface)->iname) / sizeof(char), "");
	if (strcmp((*iface)->iname, "") == 0)
		_good(_sysfs_prop_get_str(ctx, sysfs_sh_dir_path,
					  "initiatorname", (*iface)->iname,
					  sizeof((*iface)->iname) /
					  sizeof(char), ""),
		      rc, out);

	_good(_sysfs_prop_get_str(ctx, sysfs_sh_dir_path, "port_state",
				  (*iface)->port_state,
				  sizeof((*iface)->port_state) / sizeof(char),
				  "unknown"),
	      rc, out);

	if (strcmp((*iface)->port_state, "Unknown!") == 0)
		_strncpy((*iface)->port_state, "unknown",
			 sizeof((*iface)->port_state) / sizeof(char));

	_good(_sysfs_prop_get_str(ctx, sysfs_sh_dir_path, "port_speed",
				  (*iface)->port_speed,
				  sizeof((*iface)->port_speed) / sizeof(char),
				  "unknown"),
	      rc, out);

	if (strncmp((*iface)->port_speed, "Unknown", strlen("Unknown")) == 0)
		_strncpy((*iface)->port_speed, "unknown",
			 sizeof((*iface)->port_speed) / sizeof(char));

	if (sysfs_se_dir_path != NULL)
	    _sysfs_prop_get_str(ctx, sysfs_se_dir_path, "ifacename",
				(*iface)->name,
				sizeof((*iface)->name)/sizeof(char), "");

	if (iface_kern_id != NULL) {
		_good(_fill_hw_iface_from_sys(ctx, *iface, iface_kern_id),
		      rc, out);
	} else {
		_good(_sysfs_prop_get_str(ctx, sysfs_sh_dir_path, "ipaddress",
					(*iface)->ipaddress,
					sizeof((*iface)->ipaddress) /
					sizeof(char), DEFAULT_IPADDRESS),
		      rc, out);
		/* bnx2i does not create
		 * /sys/class/iscsi_iface/<iface_kernl_id>
		 * We need to use transport_name.hwaddress as iface name.
		 */
		_debug(ctx, "HAHA: hwaddress %s", (*iface)->hwaddress);
		if (bound_by_hwaddr)
			snprintf((*iface)->name,
				 sizeof((*iface)->name)/sizeof(char),
				 "%s.%s", (*iface)->transport_name,
				 (*iface)->hwaddress);
	}

	if (strcmp((*iface)->name, "") == 0) {
		/*
		 * Before 2.0.870, we only could bind by netdeivce or hwaddress,
		 * so we did a simple reverse lookup to go from sysfs info to
		 * the iface name. After 2.0.870 we added a lot of options to
		 * the iface binding so we added the ifacename to the kernel.
		 *
		 * Below codes are for older kernels that do not export the
		 * ifacename.  If the user was doing iscsi_tcp session binding
		 * we will find the iface by matching net info.
		 */

		_good(iscsi_ifaces_get(ctx, &ifaces, &iface_count), rc, out);

		for (i = 0; i < iface_count; ++i) {
			tmp_iface = ifaces[i];
			if ((bound_by_hwaddr == true) &&
			    (strcmp(tmp_iface->hwaddress, (*iface)->hwaddress)
			     == 0)) {
				_strncpy((*iface)->name, tmp_iface->name,
					 sizeof((*iface)->name)/sizeof(char));
				matched = true;
				break;
			}
			if ((bound_by_netdev == true) &&
			    (strcmp(tmp_iface->netdev, (*iface)->netdev)
			     == 0)) {
				_strncpy((*iface)->name, tmp_iface->name,
					 sizeof((*iface)->name)/sizeof(char));
				matched = true;
				break;
			}
		}
		if (!matched)
			_strncpy((*iface)->name, DEFAULT_IFACENAME,
				 sizeof((*iface)->name) / sizeof(char));
	}

out:
	if (rc != LIBISCSI_OK) {
		iscsi_iface_free(*iface);
		*iface = NULL;
	}
	free(sysfs_se_dir_path);
	free(sysfs_sh_dir_path);
	free(sysfs_scsi_host_dir_path);
	iscsi_ifaces_free(ifaces, iface_count);
	return rc;
}

/* create all ifaces for a host from sysfs */
int _iscsi_ifaces_get_from_sysfs(struct iscsi_context *ctx, uint32_t host_id,
				 struct iscsi_iface ***ifaces, uint32_t *iface_count)
{
	int rc = LIBISCSI_OK;
	char **iface_kern_ids = NULL;
	uint32_t i = 0;

	assert(ctx != NULL);
	assert(ifaces != NULL);

	*ifaces = NULL;
	*iface_count = 0;

	_good(_iscsi_iface_kern_ids_of_host_id(ctx, host_id, &iface_kern_ids, iface_count),
	      rc, out);
	if (*iface_count > 0) {
		*ifaces = (struct iscsi_iface **) calloc(*iface_count,
							 sizeof(struct iscsi_iface *));
		_alloc_null_check(ctx, *ifaces, rc, out);
		for (i = 0; i < *iface_count; i++) {
			_good(_iscsi_iface_get_from_sysfs(ctx, host_id, 0,
					iface_kern_ids[i], &(*ifaces)[i]), rc, out);
		}
	} else {
		/* if there's no iface exported in sysfs,
		 * we should still be able to create one record per host */
		*ifaces = (struct iscsi_iface **) calloc(1, sizeof(struct iscsi_iface *));
		_alloc_null_check(ctx, *ifaces, rc, out);
		*iface_count = 1;
		_good(_iscsi_iface_get_from_sysfs(ctx, host_id, 0, NULL, &(*ifaces)[0]), rc, out);
	}
out:
	if (iface_kern_ids != NULL) {
		for (i = 0; i < *iface_count; i++) {
			free(iface_kern_ids[i]);
		}
		free(iface_kern_ids);
	}
	if (rc != LIBISCSI_OK) {
		iscsi_ifaces_free(*ifaces, *iface_count);
		*ifaces = NULL;
		*iface_count = 0;
	}
	return rc;
}

int iscsi_default_iface_setup(struct iscsi_context *ctx)
{
	int rc = LIBISCSI_OK;
	char strerr_buff[_STRERR_BUFF_LEN];
	int errno_save = 0;
	struct _eth_if **eifs = NULL;
	uint32_t eif_count = 0;
	uint32_t i = 0;
	uint32_t n = 0;
	size_t j = 0;
	struct _iscsi_net_drv *ind = NULL;
	uint32_t *hids = NULL;
	uint32_t hid_count = 0;
	struct iscsi_iface **ifaces = NULL;
	uint32_t iface_count = 0;
	char *path = NULL;

	assert(ctx != NULL);

	_good(_idbm_lock(ctx), rc, out);

	if ((access(IFACE_CONFIG_DIR, F_OK) != 0) &&
	    (mkdir(IFACE_CONFIG_DIR, 0660) != 0)) {
		errno_save = errno;
		_idbm_unlock(ctx);
		_error(ctx, "Could not make %s folder(%d %s). "
		       "HW/OFFLOAD iscsi may not be supported.",
		       IFACE_CONFIG_DIR, errno_save,
		       _strerror(errno_save, strerr_buff));
		if (errno_save == EACCES)
			return LIBISCSI_ERR_ACCESS;
		return LIBISCSI_ERR_BUG;
	}
	_idbm_unlock(ctx);

	/* Load kernel driver for iSCSI offload cards, like cxgb3i */
	_good(_eth_ifs_get(ctx, &eifs, &eif_count), rc, out);

	for (i = 0; i < eif_count; ++i) {
		for (j = 0;
		     j < sizeof(_ISCSI_NET_DRVS)/sizeof(struct _iscsi_net_drv);
		     ++j) {
			ind = &(_ISCSI_NET_DRVS[j]);
			if ((ind->net_driver_name == NULL) ||
			    (strcmp(eifs[i]->driver_name,
				   ind->net_driver_name) != 0))
				continue;
			/*
			* iSCSI hardware offload for bnx2{,x} is only supported
			* if the iscsiuio executable is available.
			*/
			if ((strcmp(eifs[i]->driver_name, "bnx2x") == 0) ||
			    (strcmp(eifs[i]->driver_name, "bnx2") == 0)) {
				if (access(ISCSIUIO_PATH, F_OK) != 0) {
					_debug(ctx, "iSCSI offload on %s(%s) "
					       "via %s is not supported due to "
					       "missing %s", eifs[i]->if_name,
					       eifs[i]->driver_name,
					       ind->iscsi_driver_name,
					       ISCSIUIO_PATH);
					continue;
				}
			}

			if (_iscsi_transport_is_loaded(ind->transport_name))
				continue;

			_debug(ctx, "Loading kernel module %s for iSCSI "
			       "offload on %s(%s)", ind->iscsi_driver_name,
			       eifs[i]->if_name, eifs[i]->driver_name);
			_good(_load_kernel_module(ctx, ind->iscsi_driver_name),
			      rc, out);
		}
	}

	_good(_iscsi_hids_get(ctx, &hids, &hid_count), rc, out);
	for (i = 0; i < hid_count; ++i) {
		/* Create /etc/iscsi/ifaces/<iface_name> file if not found
		 */
		_good(_iscsi_ifaces_get_from_sysfs(ctx, hids[i], &ifaces, &iface_count),
			rc, out);
		for (n = 0; n < iface_count; n++) {
			if ( ! iscsi_is_default_iface(ifaces[n])) {
				_good(_asprintf(&path, "%s/%s", IFACE_CONFIG_DIR,
						ifaces[n]->name), rc, out);
				if (access(path, F_OK) != 0)
					rc = _iface_conf_write(ctx, ifaces[n]);
				free(path);
				path = NULL;
			}
			iscsi_iface_free(ifaces[n]);
			ifaces[n] = NULL;
			if (rc != LIBISCSI_OK)
				goto out;
		}
		free(ifaces);
		ifaces = NULL;
	}

out:
	if (ifaces != NULL) {
		for (i = 0; i < iface_count; i++)
			free(ifaces[i]);
		free(ifaces);
	}
	_eth_ifs_free(eifs, eif_count);
	free(path);
	free(hids);
	return rc;
}

static int _load_kernel_module(struct iscsi_context *ctx, const char *drv_name)
{
	struct kmod_ctx *kctx = NULL;
	struct kmod_module *mod = NULL;
	int rc = LIBISCSI_OK;

	kctx = kmod_new(NULL, NULL);
	_alloc_null_check(ctx, kctx, rc, out);

	kmod_load_resources(kctx);

	if (kmod_module_new_from_name(kctx, drv_name, &mod)) {
		_error(ctx, "Failed to load module %s.", drv_name);
		rc = LIBISCSI_ERR_TRANS_NOT_FOUND;
		goto out;
	}

	if (kmod_module_probe_insert_module(mod, KMOD_PROBE_APPLY_BLACKLIST,
					    NULL, NULL, NULL, NULL)) {
		_error(ctx, "Could not insert module %s. Kmod error %d",
		       drv_name, rc);
		rc = LIBISCSI_ERR_TRANS_NOT_FOUND;
	}
	kmod_module_unref(mod);

out:
	if (kctx != NULL)
		kmod_unref(kctx);
	return rc;
}

static int _iface_conf_write(struct iscsi_context *ctx,
			     struct iscsi_iface *iface)
{
	char *conf_path = NULL;
	char strerr_buff[_STRERR_BUFF_LEN];
	int errno_save = 0;
	FILE *f = NULL;
	int rc = 0;

	if (iscsi_is_default_iface(iface)) {
		_error(ctx, "iface %s is not a special interface and "
		       "is not stored in %s", iface->name, IFACE_CONFIG_DIR);
		return LIBISCSI_ERR_INVAL;
	}

	_good(_idbm_lock(ctx), rc, out);

	_good(_asprintf(&conf_path, "%s/%s", IFACE_CONFIG_DIR,
			iface->name), rc, out);
	_debug(ctx, "Creating iSCSI interface configuration file '%s' "
	       "using kernel information", conf_path);
	f = fopen(conf_path, "w");
	errno_save = errno;
	if (!f) {
		_error(ctx, "Failed to open %s using write mode: %d %s",
		       conf_path, errno_save,
		       _strerror(errno_save, strerr_buff));
		rc = LIBISCSI_ERR_IDBM;
		goto out;
	}

	_idbm_iface_print(iface, f);

	_idbm_unlock(ctx);

out:
	free(conf_path);
	if (f != NULL)
		fclose(f);
	return rc;
}

// mimic of iscsi_sysfs_read_iface() in iscsi_sysfs.c.
static int _fill_hw_iface_from_sys(struct iscsi_context *ctx,
				   struct iscsi_iface *iface,
				   const char *iface_kern_id)
{
	int rc = LIBISCSI_OK;
	char *sysfs_iface_dir_path = NULL;
	uint32_t tmp_host_no = 0;
	uint32_t iface_num = 0;
	int iface_type = 0;

	assert(ctx != NULL);
	assert(iface != NULL);
	assert(iface_kern_id != NULL);

	_good(_asprintf(&sysfs_iface_dir_path, "%s/%s", _ISCSI_SYS_IFACE_DIR,
			iface_kern_id), rc, out);

	_good(_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				  "ipaddress",
				  iface->ipaddress,
				  sizeof(iface->ipaddress) /
				  sizeof(char), DEFAULT_IPADDRESS),
		      rc, out);

	if (strncmp(iface_kern_id, "ipv4", strlen("ipv4")) == 0) {
		iface->is_ipv6 = false;
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "bootproto", iface->bootproto,
				    sizeof(iface->bootproto) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "gateway",
				    iface->gateway,
				    sizeof(iface->gateway) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "subnet",
				    iface->subnet_mask,
				    sizeof(iface->subnet_mask) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_alt_client_id_en",
				    iface->dhcp_alt_client_id,
				    sizeof(iface->dhcp_alt_client_id) /
				    sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_alt_client_id",
				    iface->dhcp_alt_client_id,
				    sizeof(iface->dhcp_alt_client_id) /
				    sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_dns_address_en", iface->dhcp_dns,
				    sizeof(iface->dhcp_dns) / sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_learn_iqn_en", iface->dhcp_learn_iqn,
				    sizeof(iface->dhcp_learn_iqn) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_req_vendor_id_en",
				    iface->dhcp_req_vendor_id_state,
				    sizeof(iface->dhcp_req_vendor_id_state) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_use_vendor_id_en",
				    iface->dhcp_vendor_id_state,
				    sizeof(iface->dhcp_vendor_id_state) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_vendor_id", iface->dhcp_vendor_id,
				    sizeof(iface->dhcp_vendor_id) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "dhcp_slp_da_info_en", iface->dhcp_slp_da,
				    sizeof(iface->dhcp_slp_da) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "fragment_disable", iface->fragmentation,
				    sizeof(iface->fragmentation) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "grat_arp_en", iface->gratuitous_arp,
				    sizeof(iface->gratuitous_arp) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "incoming_forwarding_en",
				    iface->incoming_forwarding,
				    sizeof(iface->incoming_forwarding) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "tos_en",
				    iface->tos_state, sizeof(iface->tos_state) /
				    sizeof(char), "");
		_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "tos",
				   &iface->tos, 0, true);
		_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "ttl",
				   &iface->ttl, 0, true);
	} else {
		iface->is_ipv6 = true;
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "ipaddr_autocfg",
				    iface->ipv6_autocfg,
				    sizeof(iface->ipv6_autocfg) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "link_local_addr", iface->ipv6_linklocal,
				    sizeof(iface->ipv6_linklocal) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "link_local_autocfg",
				    iface->linklocal_autocfg,
				    sizeof(iface->linklocal_autocfg) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "router_addr", iface->ipv6_router,
				    sizeof(iface->ipv6_router) / sizeof(char),
				    "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "router_state", iface->router_autocfg,
				    sizeof(iface->router_autocfg) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
				    "grat_neighbor_adv_en",
				    iface->gratuitous_neighbor_adv,
				    sizeof(iface->gratuitous_neighbor_adv) /
				    sizeof(char), "");
		_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "mld_en",
				    iface->mld, sizeof(iface->mld) /
				    sizeof(char), "");
		_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path,
				   "dup_addr_detect_cnt",
				   &iface->dup_addr_detect_cnt, 0, true);
		_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "hop_limit",
				   &iface->hop_limit, 0, true);
		_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path,
				    "flow_label", &iface->flow_label, 0, true);
		_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path,
				    "nd_reachable_tmo",
				    &iface->nd_reachable_tmo, 0, true);
		_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path, "nd_rexmit_time",
				    &iface->nd_rexmit_time, 0, true);
		_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path, "nd_stale_tmo",
				    &iface->nd_stale_tmo, 0, true);
		_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path,
				    "router_adv_link_mtu",
				    &iface->router_adv_link_mtu, 0, true);
		_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path, "traffic_class",
				    &iface->traffic_class, 0, true);
	}

	_sysfs_prop_get_u16(ctx, sysfs_iface_dir_path, "port", &iface->port, 0,
			    true);
	_sysfs_prop_get_u16(ctx, sysfs_iface_dir_path, "mtu", &iface->mtu, 0,
			    true);
	_sysfs_prop_get_u16(ctx, sysfs_iface_dir_path, "vlan_id",
			    &iface->vlan_id, UINT16_MAX, true);
	_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "vlan_priority",
			    &iface->vlan_priority, UINT8_MAX, true);
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "vlan_enabled",
			    iface->vlan_state, sizeof(iface->vlan_state) /
			    sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "enabled", iface->state,
			    sizeof(iface->state) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "delayed_ack_en",
			    iface->delayed_ack,
			    sizeof(iface->delayed_ack) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "tcp_nagle_disable",
			    iface->nagle, sizeof(iface->nagle) / sizeof(char),
			    "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "tcp_wsf_disable",
			    iface->tcp_wsf_state,
			    sizeof(iface->tcp_wsf_state) / sizeof(char), "");
	_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "tcp_wsf",
			   &iface->tcp_wsf, 0, true);
	_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "tcp_timer_scale",
			   &iface->tcp_timer_scale, 0, true);
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "tcp_timestamp_en",
			    iface->tcp_timestamp,
			    sizeof(iface->tcp_timestamp) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "redirect_en",
			    iface->redirect,
			    sizeof(iface->redirect) / sizeof(char), "");
	_sysfs_prop_get_u16(ctx, sysfs_iface_dir_path, "def_taskmgmt_tmo",
			    &iface->def_task_mgmt_tmo, 0, true);
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "header_digest",
			    iface->header_digest,
			    sizeof(iface->header_digest) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "data_digest",
			    iface->data_digest,
			    sizeof(iface->data_digest) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "immediate_data",
			    iface->immediate_data,
			    sizeof(iface->immediate_data) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "initial_r2t",
			    iface->initial_r2t,
			    sizeof(iface->initial_r2t) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "data_seq_in_order",
			    iface->data_seq_inorder,
			    sizeof(iface->data_seq_inorder) / sizeof(char),
			    "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "data_pdu_in_order",
			    iface->data_pdu_inorder,
			    sizeof(iface->data_pdu_inorder) / sizeof(char), "");
	_sysfs_prop_get_u8(ctx, sysfs_iface_dir_path, "erl", &iface->erl, 0,
			    true);
	_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path, "max_recv_dlength",
			    &iface->max_recv_dlength, 0, true);
	_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path, "first_burst_len",
			    &iface->first_burst_len, 0, true);
	_sysfs_prop_get_u16(ctx, sysfs_iface_dir_path, "max_outstanding_r2t",
			    &iface->max_out_r2t, 0, true);
	_sysfs_prop_get_u32(ctx, sysfs_iface_dir_path, "max_burst_len",
			    &iface->max_burst_len, 0, true);
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "chap_auth",
			    iface->chap_auth,
			    sizeof(iface->chap_auth) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "bidi_chap",
			    iface->bidi_chap,
			    sizeof(iface->bidi_chap) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path, "strict_login_comp_en",
			    iface->strict_login_comp,
			    sizeof(iface->strict_login_comp) / sizeof(char),
			    "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
			    "discovery_auth_optional",
			    iface->discovery_auth,
			    sizeof(iface->discovery_auth) / sizeof(char), "");
	_sysfs_prop_get_str(ctx, sysfs_iface_dir_path,
			    "discovery_logout",
			    iface->discovery_logout,
			    sizeof(iface->discovery_logout) / sizeof(char), "");

	if (sscanf(iface_kern_id, "ipv%d-iface-%" SCNu32 "-%" SCNu32,
		   &iface_type, &tmp_host_no, &iface_num) == 3)
		iface->iface_num = iface_num;

	snprintf(iface->name, sizeof(iface->name)/sizeof(char),
		 "%s.%s.%s.%u", iface->transport_name,
		 iface->hwaddress, iface->is_ipv6 ?  "ipv6" : "ipv4",
		 iface->iface_num);

out:
	free(sysfs_iface_dir_path);
	return rc;
}

int iscsi_ifaces_get(struct iscsi_context *ctx, struct iscsi_iface ***ifaces,
		     uint32_t *iface_count)
{
	int rc = LIBISCSI_OK;
	struct dirent **namelist = NULL;
	int n = 0;
	size_t i = 0;
	struct iscsi_iface *iface = NULL;
	int j = 0;
	uint32_t real_iface_count = 0;

	assert(ctx != NULL);
	assert(ifaces != NULL);
	assert(iface_count != NULL);

	*ifaces = NULL;
	*iface_count = 0;

	_good(_idbm_lock(ctx), rc, out);

	_good(_scandir(ctx, IFACE_CONFIG_DIR, &namelist, &n), rc, out);
	_debug(ctx, "Got %d iface from %s folder", n, IFACE_CONFIG_DIR);
	*iface_count = (n + sizeof(_DEFAULT_IFACES)/sizeof(struct iscsi_iface))
		& UINT32_MAX;
	*ifaces = (struct iscsi_iface **) calloc(*iface_count,
						sizeof(struct iscsi_iface *));
	_alloc_null_check(ctx, *ifaces, rc, out);

	for (j = 0; j < n; ++j) {
		_good(_idbm_iface_get(ctx, namelist[j]->d_name, &iface),
		      rc, out);
		if (iface != NULL) {
			(*ifaces)[real_iface_count++] = iface;
		}
	}

	for (i = 0; i < sizeof(_DEFAULT_IFACES)/sizeof(struct iscsi_iface);
	     ++i) {
		iface = calloc(1, sizeof(struct iscsi_iface));
		_alloc_null_check(ctx, iface, rc, out);
		(*ifaces)[real_iface_count++] = iface;
		memcpy(iface, &_DEFAULT_IFACES[i], sizeof(struct iscsi_iface));
	}

	*iface_count = real_iface_count;

out:
	_scandir_free(namelist, n);
	_idbm_unlock(ctx);
	if (rc != LIBISCSI_OK) {
		iscsi_ifaces_free(*ifaces, *iface_count);
		*ifaces = NULL;
		*iface_count = 0;
	}
	return rc;
}

void iscsi_ifaces_free(struct iscsi_iface **ifaces, uint32_t iface_count)
{
	uint32_t i = 0;

	if ((ifaces == NULL) || (iface_count == 0))
		return;

	for (i = 0; i < iface_count; ++i)
		iscsi_iface_free(ifaces[i]);
	free (ifaces);
}

static bool _iface_is_bound_by_hwaddr(struct iscsi_iface *iface)
{
	if (iface && strlen(iface->hwaddress) &&
	    strcmp(iface->hwaddress, DEFAULT_HWADDRESS))
		return true;
	return false;
}

static bool _iface_is_bound_by_netdev(struct iscsi_iface *iface)
{
	if (iface && strlen(iface->netdev) &&
	   strcmp(iface->netdev, DEFAULT_NETDEV))
		return true;
	return false;
}

bool _iface_is_valid(struct iscsi_iface *iface)
{
	if (!iface)
		return false;

	if (strlen(iface->name) == 0)
		return false;

	if (strlen(iface->transport_name) == 0)
		return false;

	if (_iface_is_bound_by_hwaddr(iface))
		return true;

	if (_iface_is_bound_by_netdev(iface))
		return true;

	/* bound by transport name */
	return true;
}

bool iscsi_is_default_iface(struct iscsi_iface *iface)
{
	size_t i = 0;
	for (; i < sizeof(_DEFAULT_IFACES)/sizeof(struct iscsi_iface); ++i) {
		if (strcmp(iface->name, _DEFAULT_IFACES[i].name) == 0)
			return true;
	}
	return false;
}

const char *iscsi_iface_dump_config(struct iscsi_iface *iface)
{
	FILE *f = NULL;
	char *buff = NULL;

	assert(iface != NULL);

	buff = calloc(1, IDBM_DUMP_SIZE);
	if (buff == NULL)
		return NULL;

	f = fmemopen(buff, IDBM_DUMP_SIZE - 1, "w");
	if (f == NULL) {
		free(buff);
		return NULL;
	}

	_idbm_iface_print(iface, f);

	fclose(f);

	return buff;
}

void iscsi_iface_print_config(struct iscsi_iface *iface)
{
	assert(iface != NULL);
	_idbm_iface_print(iface, stdout);
}

int iscsi_iface_get(struct iscsi_context *ctx, const char *iface_name,
		    struct iscsi_iface **iface)
{
	int rc = LIBISCSI_OK;
	assert(ctx != NULL);
	assert(iface_name != NULL);
	assert(strlen(iface_name) != 0);
	assert(iface != NULL);

	*iface = NULL;

	size_t i = 0;
	for (; i < sizeof(_DEFAULT_IFACES)/sizeof(struct iscsi_iface); ++i) {
		if (strcmp(iface_name, _DEFAULT_IFACES[i].name) == 0) {
			*iface = calloc(1, sizeof(struct iscsi_iface));
			_alloc_null_check(ctx, *iface, rc, out);
			memcpy(*iface, &_DEFAULT_IFACES[i],
			       sizeof(struct iscsi_iface));
			goto out;
		}
	}

	rc = _idbm_lock(ctx);
	if (rc != LIBISCSI_OK)
		return rc;

	rc = _idbm_iface_get(ctx, iface_name, iface);
	if (*iface == NULL)
		rc = LIBISCSI_ERR_IDBM;

	_idbm_unlock(ctx);

out:
	return rc;
}

void iscsi_iface_free(struct iscsi_iface *iface)
{
	free(iface);
}