/*

 * iSCSI Initiator Daemon

 *

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

#include <fcntl.h>

#include <getopt.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <signal.h>

#include <grp.h>

#include <sys/mman.h>

#include <sys/utsname.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/stat.h>

#ifndef	NO_SYSTEMD

#include <systemd/sd-daemon.h>

#endif

#include "iscsid.h"

#include "mgmt_ipc.h"

#include "event_poll.h"

#include "iscsi_ipc.h"

#include "log.h"

#include "iscsi_util.h"

#include "initiator.h"

#include "transport.h"

#include "idbm.h"

#include "version.h"

#include "iscsi_sysfs.h"

#include "iface.h"

#include "session_info.h"

#include "sysdeps.h"

#include "discoveryd.h"

#include "iscsid_req.h"

#include "iscsi_err.h"

/* global config info */

struct iscsi_daemon_config daemon_config;

struct iscsi_daemon_config *dconfig = &daemon_config;

static char program_name[] = "iscsid";

static pid_t log_pid;

static gid_t gid;

static int daemonize = 1;

static int mgmt_ipc_fd;

static int sessions_to_recover = 0;

static struct option const long_options[] = {

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

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

	{"foreground", no_argument, NULL, 'f'},

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

	{"uid", required_argument, NULL, 'u'},

	{"gid", required_argument, NULL, 'g'},

	{"no-pid-file", no_argument, NULL, 'n'},

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

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

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

	{NULL, 0, NULL, 0},

};

static void usage(int status)

{

	if (status != 0)

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

			program_name);

	else {

		printf("Usage: %s [OPTION]\n", program_name);

		printf("\

Open-iSCSI initiator daemon.\n\

  -c, --config=[path]     Execute in the config file (" CONFIG_FILE ").\n\

  -i, --initiatorname=[path]     read initiatorname from file (" INITIATOR_NAME_FILE ").\n\

  -f, --foreground        make the program run in the foreground\n\

  -d, --debug debuglevel  print debugging information\n\

  -u, --uid=uid           run as uid, default is current user\n\

  -g, --gid=gid           run as gid, default is current user group\n\

  -n, --no-pid-file       do not use a pid file\n\

  -p, --pid=pidfile       use pid file (default " PID_FILE ").\n\

  -h, --help              display this help and exit\n\

  -v, --version           display version and exit\n\

");

	}

	exit(status);

}

static void

setup_rec_from_negotiated_values(node_rec_t *rec, struct session_info *info)

{

	struct iscsi_session_operational_config session_conf;

	struct iscsi_conn_operational_config conn_conf;

	struct iscsi_auth_config auth_conf;

	idbm_node_setup_from_conf(rec);

	strlcpy(rec->name, info->targetname, TARGET_NAME_MAXLEN);

	rec->conn[0].port = info->persistent_port;

	strlcpy(rec->conn[0].address, info->persistent_address, NI_MAXHOST);

	rec->tpgt = info->tpgt;

	iscsi_sysfs_get_negotiated_session_conf(info->sid, &session_conf);

	iscsi_sysfs_get_negotiated_conn_conf(info->sid, &conn_conf);

	iscsi_sysfs_get_auth_conf(info->sid, &auth_conf);

	if (strlen(auth_conf.username))

		strcpy(rec->session.auth.username, auth_conf.username);

	if (strlen(auth_conf.username_in))

		strcpy(rec->session.auth.username_in, auth_conf.username_in);

	if (strlen((char *)auth_conf.password)) {

		strcpy((char *)rec->session.auth.password,

			(char *)auth_conf.password);

		rec->session.auth.password_length = auth_conf.password_length;

	}

	if (strlen((char *)auth_conf.password_in)) {

		strcpy((char *)rec->session.auth.password_in,

			(char *)auth_conf.password_in);

		rec->session.auth.password_in_length =

						auth_conf.password_in_length;

	}

	if (is_valid_operational_value(conn_conf.HeaderDigest)) {

		if (conn_conf.HeaderDigest)

			rec->conn[0].iscsi.HeaderDigest =

						CONFIG_DIGEST_PREFER_ON;

		else

			rec->conn[0].iscsi.HeaderDigest =

						CONFIG_DIGEST_PREFER_OFF;

	}

	if (is_valid_operational_value(conn_conf.DataDigest)) {

		if (conn_conf.DataDigest)

			rec->conn[0].iscsi.DataDigest = CONFIG_DIGEST_PREFER_ON;

		else

			rec->conn[0].iscsi.DataDigest =

						CONFIG_DIGEST_PREFER_OFF;

	}

	if (is_valid_operational_value(conn_conf.MaxRecvDataSegmentLength))

		rec->conn[0].iscsi.MaxRecvDataSegmentLength =

					conn_conf.MaxRecvDataSegmentLength;

	if (is_valid_operational_value(conn_conf.MaxXmitDataSegmentLength))

		 rec->conn[0].iscsi.MaxXmitDataSegmentLength =

					conn_conf.MaxXmitDataSegmentLength;

	if (is_valid_operational_value(session_conf.FirstBurstLength))

		rec->session.iscsi.FirstBurstLength =

					session_conf.FirstBurstLength;

	if (is_valid_operational_value(session_conf.MaxBurstLength))

		rec->session.iscsi.MaxBurstLength =

					session_conf.MaxBurstLength;

	if (is_valid_operational_value(session_conf.ImmediateData)) {

		if (session_conf.ImmediateData)

			rec->session.iscsi.ImmediateData = 1;

		else

			rec->session.iscsi.ImmediateData = 0;

	}

	if (is_valid_operational_value(session_conf.InitialR2T)) {

		if (session_conf.InitialR2T)

			rec->session.iscsi.InitialR2T = 0;

		else

			rec->session.iscsi.InitialR2T = 1;

	}

}

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

{

	node_rec_t rec, sysfsrec;

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

	struct iscsi_transport *t;

	int rc, retries = 0;

	log_debug(7, "sync session [%d][%s,%s.%d][%s]", info->sid,

		  info->targetname, info->persistent_address,

		  info->port, info->iface.hwaddress);

	t = iscsi_sysfs_get_transport_by_sid(info->sid);

	if (!t)

		return 0;

	/*

	 * Just rescan the device in case this is the first startup.

	 * (TODO: should do this async and check for state).

	 */

	if (t->caps & CAP_FW_DB) {

		uint32_t host_no;

		int err;

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

		if (err) {

			log_error("Could not get host no from sid %u. Can not "

				  "sync session: %s", info->sid,

				  iscsi_err_to_str(err));

			return 0;

		}

		iscsi_sysfs_scan_host(host_no, 0, idbm_session_autoscan(NULL));

		return 0;

	}

	if (!iscsi_sysfs_session_user_created(info->sid))

		return 0;

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

	/*

	 * We might get the local ip address for software. We do not

	 * want to try and bind a session by ip though.

	 */

	if (!t->template->set_host_ip)

		memset(info->iface.ipaddress, 0, sizeof(info->iface.ipaddress));

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

			  info->persistent_address, info->persistent_port,

			  &info->iface, false)) {

		log_warning("Could not read data from db. Using default and "

			    "currently negotiated values");

		setup_rec_from_negotiated_values(&rec, info);

		iface_copy(&rec.iface, &info->iface);

	} else {

		/*

		 * we have a valid record and iface so lets merge

		 * the values from them and sysfs to try and get

		 * the most uptodate values.

		 *

		 * Currenlty that means we will use the CHAP, target, portal

		 * and iface values from sysfs and use timer, queue depth,

		 * and segment length values from the record.

		 */

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

		setup_rec_from_negotiated_values(&sysfsrec, info);

		/*

		 * target, portal and iface values have to be the same

		 * or we would not have found the record, so just copy

		 * CHAP settings.

		 */

		memcpy(&rec.session.auth, &sysfsrec.session.auth,

		      sizeof(struct iscsi_auth_config));

	}

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

	if (!iscsi_match_session(&rec, info))

		return -1;

	/*

	 * We use the initiator name from sysfs because

	 * the session could have come from our db or ibft or some other

	 * app.

	 */

	strcpy(rec.iface.iname, info->iface.iname);

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

	req.command = MGMT_IPC_SESSION_SYNC;

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

	memcpy(&req.u.session.rec, &rec, sizeof(node_rec_t));

retry:

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

	if (rc == ISCSI_ERR_ISCSID_NOTCONN && retries < 30) {

		retries++;

		sleep(1);

		goto retry;

	}

	return 0;

}

static char *iscsid_get_config_file(void)

{

	return daemon_config.config_file;

}

static void iscsid_shutdown(void)

{

	pid_t pid;

	killpg(gid, SIGTERM);

	while ((pid = waitpid(0, NULL, 0) > 0))

		log_debug(7, "cleaned up pid %d", pid);

	log_warning("iscsid shutting down.");

	if (daemonize && log_pid >= 0) {

		log_debug(1, "daemon stopping");

		log_close(log_pid);

	}

}

static void catch_signal(int signo)

{

	log_debug(1, "pid %d caught signal %d", getpid(), signo);

	/* In foreground mode, treat SIGINT like SIGTERM */

	if (!daemonize && signo == SIGINT)

		signo = SIGTERM;

	switch (signo) {

	case SIGTERM:

		event_loop_exit(NULL);

		break;

	default:

		break;

	}

}

static void missing_iname_warn(char *initiatorname_file)

{

	log_error("Warning: InitiatorName file %s does not exist or does not "

		  "contain a properly formatted InitiatorName. If using "

		  "software iscsi (iscsi_tcp or ib_iser) or partial offload "

		  "(bnx2i or cxgbi iscsi), you may not be able to log "

		  "into or discover targets. Please create a file %s that "

		  "contains a sting with the format: InitiatorName="

		  "iqn.yyyy-mm.<reversed domain name>[:identifier].\n\n"

		  "Example: InitiatorName=iqn.2001-04.com.redhat:fc6.\n"

		  "If using hardware iscsi like qla4xxx this message can be "

		  "ignored.", initiatorname_file, initiatorname_file);

}

/* called right before we enter the event loop */

static void set_state_to_ready(void)

{

#ifndef	NO_SYSTEMD

	if (sessions_to_recover)

		sd_notify(0, "READY=1\n"

				"RELOADING=1\n"

				"STATUS=Syncing existing session(s)\n");

	else

		sd_notify(0, "READY=1\n"

				"STATUS=Ready to process requests\n");

#endif

}

/* called when recovery process has been reaped */

static void set_state_done_reloading(void)

{

#ifndef	NO_SYSTEMD

	sessions_to_recover = 0;

	sd_notifyf(0, "READY=1\n"

			"STATUS=Ready to process requests\n");

#endif

}

int main(int argc, char *argv[])

{

	struct utsname host_info; /* will use to compound initiator alias */

	char *config_file = CONFIG_FILE;

	char *initiatorname_file = INITIATOR_NAME_FILE;

	char *pid_file = PID_FILE;

	char *safe_logout;

	int ch, longindex;

	uid_t uid = 0;

	struct sigaction sa_old;

	struct sigaction sa_new;

	int control_fd;

	pid_t pid;

	while ((ch = getopt_long(argc, argv, "c:i:fd:nu:g:p:vh", long_options,

				 &longindex)) >= 0) {

		switch (ch) {

		case 'c':

			config_file = optarg;

			break;

		case 'i':

			initiatorname_file = optarg;

			break;

		case 'f':

			daemonize = 0;

			break;

		case 'd':

			log_level = atoi(optarg);

			break;

		case 'u':

			uid = strtoul(optarg, NULL, 10);

			break;

		case 'g':

			gid = strtoul(optarg, NULL, 10);

			break;

		case 'n':

			pid_file = NULL;

			break;

		case 'p':

			pid_file = optarg;

			break;

		case 'v':

			printf("%s version %s\n", program_name,

				ISCSI_VERSION_STR);

			exit(0);

		case 'h':

			usage(0);

			break;

		default:

			usage(1);

			break;

		}

	}

	/* initialize logger */

	log_pid = log_init(program_name, DEFAULT_AREA_SIZE,

		      daemonize ? log_do_log_daemon : log_do_log_std, NULL);

	if (log_pid < 0)

		exit(ISCSI_ERR);

	/* do not allow ctrl-c for now... */

	sa_new.sa_handler = catch_signal;

	sigemptyset(&sa_new.sa_mask);

	sa_new.sa_flags = 0;

	sigaction(SIGINT, &sa_new, &sa_old );

	sigaction(SIGPIPE, &sa_new, &sa_old );

	sigaction(SIGTERM, &sa_new, &sa_old );

	sysfs_init();

	if (idbm_init(iscsid_get_config_file)) {

		log_close(log_pid);

		exit(ISCSI_ERR);

	}

	umask(0177);

	mgmt_ipc_fd = -1;

	control_fd = -1;

	daemon_config.initiator_name = NULL;

	daemon_config.initiator_alias = NULL;

	if ((mgmt_ipc_fd = mgmt_ipc_listen()) < 0) {

		log_close(log_pid);

		exit(ISCSI_ERR);

	}

	if (daemonize) {

		char buf[64];

		int fd = -1;

		if (pid_file) {

			fd = open(pid_file, O_WRONLY|O_CREAT, 0644);

			if (fd < 0) {

				log_error("Unable to create pid file");

				log_close(log_pid);

				exit(ISCSI_ERR);

			}

		}

		pid = fork();

		if (pid < 0) {

			log_error("Starting daemon failed");

			log_close(log_pid);

			exit(ISCSI_ERR);

		} else if (pid) {

			log_info("iSCSI daemon with pid=%d started!", pid);

			exit(0);

		}

		if (chdir("/") < 0)

			log_debug(1, "Unable to chdir to /");

		if (fd > 0) {

			if (lockf(fd, F_TLOCK, 0) < 0) {

				log_error("Unable to lock pid file");

				log_close(log_pid);

				exit(ISCSI_ERR);

			}

			if (ftruncate(fd, 0) < 0) {

				log_error("Unable to truncate pid file");

				log_close(log_pid);

				exit(ISCSI_ERR);

			}

			sprintf(buf, "%d\n", getpid());

			if (write(fd, buf, strlen(buf)) < 0) {

				log_error("Unable to write pid file");

				log_close(log_pid);

				exit(ISCSI_ERR);

			}

			close(fd);

		}

		if ((control_fd = ipc->ctldev_open()) < 0) {

			log_close(log_pid);

			exit(ISCSI_ERR);

		}

		daemon_init();

	} else {

		if ((control_fd = ipc->ctldev_open()) < 0) {

			log_close(log_pid);

			exit(1);

		}

	}

	if (gid && setgid(gid) < 0) {

		log_error("Unable to setgid to %d", gid);

		log_close(log_pid);

		exit(ISCSI_ERR);

	}

	if ((geteuid() == 0) && (getgroups(0, NULL))) {

		if (setgroups(0, NULL) != 0) {

			log_error("Unable to drop supplementary group ids");

			log_close(log_pid);

			exit(ISCSI_ERR);

		}

	}

	if (uid && setuid(uid) < 0) {

		log_error("Unable to setuid to %d", uid);

		log_close(log_pid);

		exit(ISCSI_ERR);

	}

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

	daemon_config.pid_file = pid_file;

	daemon_config.config_file = config_file;

	daemon_config.initiator_name = cfg_get_string_param(initiatorname_file,

							    "InitiatorName");

	if (daemon_config.initiator_name == NULL)

		missing_iname_warn(initiatorname_file);

	/* optional InitiatorAlias */

	daemon_config.initiator_alias =

				cfg_get_string_param(initiatorname_file,

						     "InitiatorAlias");

	if (!daemon_config.initiator_alias) {

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

		if (uname(&host_info) >= 0) {

			daemon_config.initiator_alias =

				strdup(host_info.nodename);

		}

	}

	log_debug(1, "InitiatorName=%s", daemon_config.initiator_name ?

		 daemon_config.initiator_name : "NOT SET");

	log_debug(1, "InitiatorAlias=%s", daemon_config.initiator_alias);

	safe_logout = cfg_get_string_param(config_file, "iscsid.safe_logout");

	if (safe_logout && !strcmp(safe_logout, "Yes"))

		daemon_config.safe_logout = 1;

	free(safe_logout);

	/* see if we have any stale sessions to recover */

	sessions_to_recover = iscsi_sysfs_count_sessions();

	if (sessions_to_recover) {

		/*

		 * recover stale sessions in the background

		 */

		pid = fork();

		if (pid == 0) {

			int nr_found; /* not used */

			/* child */

			/* TODO - test with async support enabled */

			iscsi_sysfs_for_each_session(NULL, &nr_found, sync_session, 0);

			exit(0);

		} else if (pid < 0) {

			log_error("Fork failed error %d: existing sessions"

				  " will not be synced", errno);

		} else {

			/* parent */

			log_debug(8, "forked child (pid=%d) to recover %d session(s)",

					(int)pid, sessions_to_recover);

			reap_track_reload_process(pid, set_state_done_reloading);

		}

	}

	iscsi_initiator_init();

	increase_max_files();

	discoveryd_start(daemon_config.initiator_name);

	/* oom-killer will not kill us at the night... */

	if (oom_adjust())

		log_debug(1, "can not adjust oom-killer's pardon");

	/* we don't want our active sessions to be paged out... */

	if (mlockall(MCL_CURRENT | MCL_FUTURE)) {

		log_error("failed to mlockall, exiting...");

		log_close(log_pid);

		exit(ISCSI_ERR);

	}

	set_state_to_ready();

	event_loop(ipc, control_fd, mgmt_ipc_fd);

	idbm_terminate();

	sysfs_cleanup();

	ipc->ctldev_close();

	mgmt_ipc_close(mgmt_ipc_fd);

	if (daemon_config.initiator_name)

		free(daemon_config.initiator_name);

	if (daemon_config.initiator_alias)

		free(daemon_config.initiator_alias);

	free_initiator();

	iscsid_shutdown();

	return 0;

}