/*
 *  Copyright (C) 2004 - 2005 FUJITA Tomonori <tomof@acm.org>
 *  Copyright (C) 2007 - 2018 Vladislav Bolkhovitin
 *  Copyright (C) 2007 - 2018 Western Digital Corporation
 *
 *  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.
 *
 *  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.
 */

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "iscsid.h"

#define CTL_DEVICE	"iscsi-scst-ctl"

int kernel_open(void)
{
	int ctlfd = -1;
	int err;
	struct iscsi_kern_register_info reg;

	ctlfd = create_and_open_dev(CTL_DEVICE, 0);
	if (ctlfd < 0)
		goto out;

	memset(&reg, 0, sizeof(reg));
	reg.version = (uintptr_t)ISCSI_SCST_INTERFACE_VERSION;

	err = ioctl(ctlfd, REGISTER_USERD, &reg);
	if (err != 0) {
		err = -errno;
		log_error("Unable to register: %s. Incompatible version of the "
			"kernel module?\n", strerror(errno));
		goto out_close;
	} else {
		log_debug(0, "max_data_seg_len %d, max_queued_cmds %d",
			reg.max_data_seg_len, reg.max_queued_cmds);
		iscsi_init_params.max_data_seg_len = reg.max_data_seg_len;
		iscsi_init_params.max_queued_cmds = reg.max_queued_cmds;
	}

out:
	return ctlfd;

out_close:
	close(ctlfd);

	ctlfd = err;
	goto out;
}

int kernel_target_create(struct target *target, u32 *tid, u32 cookie)
{
	int err, i, j;
	struct iscsi_kern_target_info info;
	struct iscsi_attr *user;
	struct iscsi_attr *portal;
	struct iscsi_kern_attr *kern_attrs;

	memset(&info, 0, sizeof(info));
	strlcpy(info.name, target->name, sizeof(info.name));
	info.tid = (tid != NULL) ? *tid : 0;
	info.cookie = cookie;

	info.attrs_num = 2;

	for (j = 0; j < session_key_last; j++) {
		if (session_keys[j].show_in_sysfs)
			info.attrs_num++;
	}
	for (j = 0; j < target_key_last; j++) {
		if (target_keys[j].show_in_sysfs)
			info.attrs_num++;
	}
	list_for_each_entry(user, &target->target_in_accounts, ulist) {
		info.attrs_num++;
	}
	list_for_each_entry(user, &target->target_out_accounts, ulist) {
		info.attrs_num++;
	}
	list_for_each_entry(portal, &target->allowed_portals, ulist) {
		info.attrs_num++;
	}

	kern_attrs = calloc(info.attrs_num, sizeof(*kern_attrs));
	if (kern_attrs == NULL) {
		err = -ENOMEM;
		goto out;
	}
	info.attrs_ptr = (unsigned long)kern_attrs;

	i = 0;

	kern_attrs[i].mode = 0644;
	strlcpy(kern_attrs[i].name, ISCSI_PER_PORTAL_ACL_ATTR_NAME,
		sizeof(ISCSI_PER_PORTAL_ACL_ATTR_NAME));
	i++;

	kern_attrs[i].mode = 0644;
	strlcpy(kern_attrs[i].name, ISCSI_TARGET_REDIRECTION_ATTR_NAME,
		sizeof(ISCSI_TARGET_REDIRECTION_ATTR_NAME));
	i++;

	for (j = 0; j < session_key_last; j++) {
		if (!session_keys[j].show_in_sysfs)
			continue;
		kern_attrs[i].mode = 0644;
		strlcpy(kern_attrs[i].name, session_keys[j].name,
			sizeof(kern_attrs[i].name));
		i++;
	}
	for (j = 0; j < target_key_last; j++) {
		if (!target_keys[j].show_in_sysfs)
			continue;
		kern_attrs[i].mode = 0644;
		strlcpy(kern_attrs[i].name, target_keys[j].name,
			sizeof(kern_attrs[i].name));
		i++;
	}
	list_for_each_entry(user, &target->target_in_accounts, ulist) {
		kern_attrs[i].mode = user->sysfs_mode;
		strlcpy(kern_attrs[i].name, user->sysfs_name,
			sizeof(kern_attrs[i].name));
		i++;
	}
	list_for_each_entry(user, &target->target_out_accounts, ulist) {
		kern_attrs[i].mode = user->sysfs_mode;
		strlcpy(kern_attrs[i].name, user->sysfs_name,
			sizeof(kern_attrs[i].name));
		i++;
	}
	list_for_each_entry(portal, &target->allowed_portals, ulist) {
		kern_attrs[i].mode = portal->sysfs_mode;
		strlcpy(kern_attrs[i].name, portal->sysfs_name,
			sizeof(kern_attrs[i].name));
		i++;
	}

	log_debug(1, "Adding target %s (attrs_num %d)", target->name,
		info.attrs_num);

	if ((err = ioctl(ctrl_fd, ADD_TARGET, &info)) < 0) {
		err = -errno;
		log_error("Can't create target %s: %s\n", target->name,
			strerror(errno));
	} else {
		target->tid = err;
		if (tid != NULL)
			*tid = err;
		err = 0;
	}

	free(kern_attrs);

out:
	return err;
}

int kernel_target_destroy(u32 tid, u32 cookie)
{
	struct iscsi_kern_target_info info;
	int res;

	memset(&info, 0, sizeof(info));
	info.tid = tid;
	info.cookie = cookie;

	res = ioctl(ctrl_fd, DEL_TARGET, &info);
	if (res < 0) {
		res = -errno;
		log_error("Can't destroy target %s %u\n", strerror(errno), tid);
	}

	return res;
}


int kernel_attr_add(struct target *target, const char *name, u32 mode,
	u32 cookie)
{
	struct iscsi_kern_attr_info info;
	int res;

	memset(&info, 0, sizeof(info));
	if (target != NULL)
		info.tid = target->tid;
	info.cookie = cookie;

	info.attr.mode = mode;
	strlcpy(info.attr.name, name, sizeof(info.attr.name));

	res = ioctl(ctrl_fd, ISCSI_ATTR_ADD, &info);
	if (res < 0)
		res = -errno;

	return res;
}

int kernel_attr_del(struct target *target, const char *name, u32 cookie)
{
	struct iscsi_kern_attr_info info;
	int res;

	memset(&info, 0, sizeof(info));
	if (target != NULL)
		info.tid = target->tid;
	info.cookie = cookie;

	strlcpy(info.attr.name, name, sizeof(info.attr.name));

	res = ioctl(ctrl_fd, ISCSI_ATTR_DEL, &info);
	if (res < 0)
		res = -errno;

	return res;
}

int kernel_user_add(struct target *target, struct iscsi_attr *user, u32 cookie)
{
	return kernel_attr_add(target, user->sysfs_name, 0600, cookie);
}

int kernel_user_del(struct target *target, struct iscsi_attr *user, u32 cookie)
{
	return kernel_attr_del(target, user->sysfs_name, cookie);
}


int kernel_initiator_allowed(u32 tid, const char *full_initiator_name)
{
	int err;
	struct iscsi_kern_initiator_info info;

	memset(&info, 0, sizeof(info));
	info.tid = tid;
	strlcpy(info.full_initiator_name, full_initiator_name, sizeof(info.full_initiator_name));

	if ((err = ioctl(ctrl_fd, ISCSI_INITIATOR_ALLOWED, &info)) < 0) {
		err = -errno;
		log_error("Can't find out initiator %s permissions (%s, "
			  "tid %u", full_initiator_name, strerror(errno), tid);
	}

	return err;
}

int kernel_conn_destroy(u32 tid, u64 sid, u32 cid)
{
	int err;
	struct iscsi_kern_conn_info info;

	info.tid = tid;
	info.sid = sid;
	info.cid = cid;

	if ((err = ioctl(ctrl_fd, DEL_CONN, &info)) < 0) {
		err = -errno;
		log_debug(2, "Can't destroy conn (%s, tid %u, sid 0x%"
			  PRIx64 ", cid %u\n", strerror(errno), tid, sid, cid);
	}

	return err;
}

int kernel_params_get(u32 tid, u64 sid, int type, struct iscsi_param *params)
{
	int err, i;
	struct iscsi_kern_params_info info;

	if (sid == 0) {
		log_error("kernel_params_get(): sid must be not %d", 0);
		err = -EINVAL;
		goto out;
	}

	memset(&info, 0, sizeof(info));
	info.tid = tid;
	info.sid = sid;
	info.params_type = type;

	if ((err = ioctl(ctrl_fd, ISCSI_PARAM_GET, &info)) < 0) {
		err = -errno;
		log_debug(1, "Can't get session params for session 0x%" PRIx64
			" (tid %u, err %d): %s\n", sid, tid, err, strerror(errno));
	}

	if (type == key_session)
		for (i = 0; i < session_key_last; i++)
			params[i].val = info.session_params[i];
	else
		for (i = 0; i < target_key_last; i++)
			params[i].val = info.target_params[i];

out:
	return err;
}

int kernel_params_set(u32 tid, u64 sid, int type, u32 partial,
	const struct iscsi_param *params)
{
	int i, err;
	struct iscsi_kern_params_info info;

	if (sid == 0) {
		log_error("kernel_params_set(): sid must be not %d", 0);
		err = -EINVAL;
		goto out;
	}

	memset(&info, 0, sizeof(info));
	info.tid = tid;
	info.sid = sid;
	info.params_type = type;
	info.partial = partial;

	if (info.params_type == key_session)
		for (i = 0; i < session_key_last; i++)
			info.session_params[i] = params[i].val;
	else
		for (i = 0; i < target_key_last; i++)
			info.target_params[i] = params[i].val;

	if ((err = ioctl(ctrl_fd, ISCSI_PARAM_SET, &info)) < 0) {
		err = -errno;
		log_error("Can't set session params for session 0x%" PRIx64
			" (tid %u, type %d, partial %d, err %d): %s\n", sid,
			tid, type, partial, err, strerror(errno));
	}

out:
	return err;
}

int kernel_session_create(struct connection *conn)
{
	struct iscsi_kern_session_info info;
	int res, i;
	struct target *target;

	target = target_find_by_id(conn->tid);
	if (target == NULL) {
		log_error("Target %d not found", conn->tid);
		res = -EINVAL;
		goto out;
	}

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

	info.tid = conn->tid;
	info.sid = conn->sess->sid.id64;
	info.exp_cmd_sn = conn->exp_cmd_sn;
	strlcpy(info.initiator_name, conn->sess->initiator, sizeof(info.initiator_name));


	iscsi_make_full_initiator_name(target->per_portal_acl,
		conn->sess->initiator, conn->target_portal,
		info.full_initiator_name, sizeof(info.full_initiator_name));

	for (i = 0; i < session_key_last; i++)
		info.session_params[i] = conn->session_params[i].val;

	for (i = 0; i < target_key_last; i++)
		info.target_params[i] = target->target_params[i];

	res = ioctl(ctrl_fd, ADD_SESSION, &info);
	if (res < 0) {
		res = -errno;
		log_error("Can't create sess 0x%" PRIx64 " (tid %d, "
			"initiator %s): %s\n", conn->sess->sid.id64, conn->tid,
			conn->sess->initiator, strerror(errno));
	}

out:
	return res;
}

int kernel_session_destroy(u32 tid, u64 sid)
{
	struct iscsi_kern_session_info info;
	int res;

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

	info.tid = tid;
	info.sid = sid;

	res = ioctl(ctrl_fd, DEL_SESSION, &info);
	if (res < 0) {
		res = -errno;
		log_debug(2, "Can't destroy sess 0x%" PRIx64 " (tid %d): %s\n",
			sid, tid, strerror(errno));
	}

	return res;
}

int kernel_conn_create(u32 tid, u64 sid, u32 cid, u32 stat_sn, u32 exp_stat_sn,
	int fd)
{
	struct iscsi_kern_conn_info info;
	int res;

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

	info.tid = tid;
	info.sid = sid;
	info.cid = cid;
	info.stat_sn = stat_sn;
	info.exp_stat_sn = exp_stat_sn;
	info.fd = fd;

	res = ioctl(ctrl_fd, ADD_CONN, &info);
	if (res < 0) {
		res = -errno;
		log_error("Can't create conn %x (sess 0x%" PRIx64 ", tid %d): %s\n",
			cid, sid, tid, strerror(errno));
	}

	return res;
}