// Copyright(c) 2018-2020, Intel Corporation

//

// Redistribution  and  use  in source  and  binary  forms,  with  or  without

// modification, are permitted provided that the following conditions are met:

//

// * Redistributions of  source code  must retain the  above copyright notice,

//   this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above copyright notice,

//   this list of conditions and the following disclaimer in the documentation

//   and/or other materials provided with the distribution.

// * Neither the name  of Intel Corporation  nor the names of its contributors

//   may be used to  endorse or promote  products derived  from this  software

//   without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE

// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE

// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR

// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF

// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS

// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN

// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)

// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

#define _GNU_SOURCE

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif // HAVE_CONFIG_H

#include <getopt.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <pwd.h>

#include "command_line.h"

#include "config_file.h"

#include "monitored_device.h"

#ifdef LOG

#undef LOG

#endif

#define LOG(format, ...) \

log_printf("args: " format, ##__VA_ARGS__)

extern fpgad_supported_device default_supported_devices_table[];

#define OPT_STR ":hdl:p:s:n:c:v"

STATIC struct option longopts[] = {

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

	{ "daemon",         no_argument,       NULL, 'd' },

	{ "logfile",        required_argument, NULL, 'l' },

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

	{ "socket",         required_argument, NULL, 's' },

	{ "null-bitstream", required_argument, NULL, 'n' },

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

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

	{ 0, 0, 0, 0 }

};

#define DEFAULT_DIR_ROOT      "/var/lib/opae"

#define DEFAULT_DIR_ROOT_SIZE 13

#define DEFAULT_LOG           "fpgad.log"

#define DEFAULT_PID           "fpgad.pid"

#define DEFAULT_CFG           "fpgad.cfg"

void cmd_show_help(FILE *fptr)

{

	fprintf(fptr, "Usage: fpgad <options>\n");

	fprintf(fptr, "\n");

	fprintf(fptr, "\t-d,--daemon                 run as daemon process.\n");

	fprintf(fptr, "\t-l,--logfile <file>         the log file for daemon mode [%s].\n", DEFAULT_LOG);

	fprintf(fptr, "\t-p,--pidfile <file>         the pid file for daemon mode [%s].\n", DEFAULT_PID);

	fprintf(fptr, "\t-s,--socket <sock>          the unix domain socket [/tmp/fpga_event_socket].\n");

	fprintf(fptr, "\t-n,--null-bitstream <file>  NULL bitstream (for AP6 handling, may be\n"

		      "\t                            given multiple times).\n");

	fprintf(fptr, "\t-c,--config <file>          the configuration file [%s].\n", DEFAULT_CFG);

	fprintf(fptr, "\t-v,--version                display the version and exit.\n");

}

STATIC bool cmd_register_null_gbs(struct fpgad_config *c, char *null_gbs_path)

{

	char *canon_path = NULL;

	if (c->num_null_gbs < (sizeof(c->null_gbs) / sizeof(c->null_gbs[0]))) {

		canon_path = canonicalize_file_name(null_gbs_path);

		if (canon_path) {

			memset(&c->null_gbs[c->num_null_gbs], 0,

				 sizeof(opae_bitstream_info));

			if (opae_load_bitstream(canon_path,

						&c->null_gbs[c->num_null_gbs])) {

				LOG("failed to load NULL GBS \"%s\"\n", canon_path);

				opae_unload_bitstream(&c->null_gbs[c->num_null_gbs]);

				free(canon_path);

				return false;

			}

			c->num_null_gbs++;

			LOG("registering NULL bitstream \"%s\"\n", canon_path);

		} else {

			LOG("error with NULL GBS argument: %s\n", strerror(errno));

			return false;

		}

	} else {

		LOG("maximum number of NULL bitstreams exceeded. Ignoring -n option.\n");

	}

	return true;

}

int cmd_parse_args(struct fpgad_config *c, int argc, char *argv[])

{

	int getopt_ret;

	int option_index;

	size_t len;

	while (-1 != (getopt_ret = getopt_long(argc, argv, OPT_STR, longopts, &option_index))) {

		const char *tmp_optarg = optarg;

		if (optarg && ('=' == *tmp_optarg))

			++tmp_optarg;

		if (!optarg && (optind < argc) &&

			(NULL != argv[optind]) &&

			('-' != argv[optind][0]))

			tmp_optarg = argv[optind++];

		switch (getopt_ret) {

		case 'h':

			cmd_show_help(stdout);

			return -2;

			break;

		case 'd':

			c->daemon = 1;

			LOG("daemon requested\n");

			break;

		case 'l':

			if (tmp_optarg) {

				len = strnlen(tmp_optarg, PATH_MAX - 1);

				memcpy(c->logfile, tmp_optarg, len);

				c->logfile[len] = '\0';

			} else {

				LOG("missing logfile parameter.\n");

				return 1;

			}

			break;

		case 'p':

			if (tmp_optarg) {

				len = strnlen(tmp_optarg, PATH_MAX - 1);

				memcpy(c->pidfile, tmp_optarg, len);

				c->pidfile[len] = '\0';

			} else {

				LOG("missing pidfile parameter.\n");

				return 1;

			}

			break;

		case 'n':

			if (tmp_optarg) {

				if (!cmd_register_null_gbs(c, (char *)tmp_optarg)) {

					LOG("invalid null gbs path: \"%s\"\n", tmp_optarg);

					return 1;

				}

			} else {

				LOG("missing bitstream parameter.\n");

				return 1;

			}

			break;

		case 's':

			if (tmp_optarg) {

				c->api_socket = tmp_optarg;

				LOG("daemon socket is %s\n", c->api_socket);

			} else {

				LOG("missing socket parameter.\n");

				return 1;

			}

			break;

		case 'c':

			if (tmp_optarg) {

				len = strnlen(tmp_optarg, PATH_MAX - 1);

				memcpy(c->cfgfile, tmp_optarg, len);

				c->cfgfile[len] = '\0';

			} else {

				LOG("missing cfgfile parameter.\n");

				return 1;

			}

			break;

		case 'v':

			fprintf(stdout, "fpgad %s %s%s\n",

					OPAE_VERSION,

					OPAE_GIT_COMMIT_HASH,

					OPAE_GIT_SRC_TREE_DIRTY ? "*":"");

			return -2;

			break;

		case ':':

			LOG("Missing option argument.\n");

			return 1;

		case '?':

			LOG("Invalid command option.\n");

			return 1;

		default:

			LOG("Invalid command option.\n");

			return 1;

		}

	}

	return 0;

}

int cmd_canonicalize_paths(struct fpgad_config *c)

{

	char *sub;

	bool def;

	mode_t mode;

	struct stat stat_buf;

	bool search = true;

	char buf[PATH_MAX];

	char *canon_path;

	uid_t uid;

	size_t len;

	uid = geteuid();

	if (!uid) {

		// If we're being run as root, then use DEFAULT_DIR_ROOT

		// as the working directory.

		memcpy(c->directory, DEFAULT_DIR_ROOT, sizeof(DEFAULT_DIR_ROOT));

		c->directory[sizeof(DEFAULT_DIR_ROOT)] = '\0';

		mode = 0755;

		c->filemode = 0026;

	} else {

		// We're not root. Try to use ${HOME}/.opae

		struct passwd *passwd;

		passwd = getpwuid(uid);

		canon_path = canonicalize_file_name(passwd->pw_dir);

		if (canon_path) {

			snprintf(c->directory, sizeof(c->directory),

					"%s/.opae", canon_path);

			free(canon_path);

		} else {

			// ${HOME} not found or invalid - use current dir.

			if (getcwd(buf, sizeof(buf))) {

				if (snprintf(c->directory, sizeof(c->directory),

					     "%s/.opae", buf) < 0) {

					len = strnlen("./.opae",

						sizeof(c->directory) - 1);

					memcpy(c->directory, "./.opae", len);

					c->directory[len] = '\0';

				}

			} else {

				// Current directory not found - use /

				len = strnlen("/.opae", sizeof(c->directory) - 1);

				memcpy(c->directory, "/.opae", len);

				c->directory[len] = '\0';

			}

		}

		mode = 0775;

		c->filemode = 0022;

	}

	if (cmd_path_is_symlink(c->directory)) {

		LOG("Aborting - working directory contains a link: %s\n.",

		    c->directory);

		return 1;

	}

	LOG("daemon working directory is %s\n", c->directory);

	// Create the directory if it doesn't exist.

	if (lstat(c->directory, &stat_buf) && (errno == ENOENT)) {

		if (mkdir(c->directory, mode)) {

			LOG("mkdir failed\n");

			return 1;

		}

	}

	// Verify logfile and pidfile do not contain ".."

	// nor "/".

	def = false;

	sub = strstr(c->logfile, "..");

	if (sub)

		def = true;

	sub = strstr(c->logfile, "/");

	if (sub)

		def = true;

	if (def || (c->logfile[0] == '\0')) {

		if (snprintf(c->logfile, sizeof(c->logfile),

			     "%s/%s", c->directory, DEFAULT_LOG) < 0) {

			len = strnlen("./" DEFAULT_LOG,

					sizeof(c->logfile) - 1);

			memcpy(c->logfile, "./" DEFAULT_LOG, len);

			c->logfile[len] = '\0';

		}

	} else {

		len = strnlen(c->logfile, sizeof(buf) - 1);

		memcpy(buf, c->logfile, len);

		buf[len] = '\0';

		if (snprintf(c->logfile, sizeof(c->logfile),

			     "%s/%s", c->directory, buf) < 0) {

			len = strnlen("./" DEFAULT_LOG,

					sizeof(c->logfile) - 1);

			memcpy(c->logfile, "./" DEFAULT_LOG, len);

			c->logfile[len] = '\0';

		}

	}

	if (cmd_path_is_symlink(c->logfile)) {

		LOG("Aborting - log file path contains a link: %s\n.",

		    c->logfile);

		return 1;

	}

	LOG("daemon log file is %s\n", c->logfile);

	def = false;

	sub = strstr(c->pidfile, "..");

	if (sub)

		def = true;

	sub = strstr(c->pidfile, "/");

	if (sub)

		def = true;

	if (def || (c->pidfile[0] == '\0')) {

		if (snprintf(c->pidfile, sizeof(c->pidfile),

			     "%s/%s", c->directory, DEFAULT_PID) < 0) {

			len = strnlen("./" DEFAULT_PID,

					sizeof(c->pidfile) - 1);

			memcpy(c->pidfile, "./" DEFAULT_PID, len);

			c->pidfile[len] = '\0';

		}

	} else {

		len = strnlen(c->pidfile, sizeof(buf) - 1);

		memcpy(buf, c->pidfile, len);

		buf[len] = '\0';

		if (snprintf(c->pidfile, sizeof(c->pidfile),

			     "%s/%s", c->directory, buf) < 0) {

			len = strnlen("./" DEFAULT_PID,

					sizeof(c->pidfile) - 1);

			memcpy(c->pidfile, "./" DEFAULT_PID, len);

			c->pidfile[len] = '\0';

		}

	}

	if (cmd_path_is_symlink(c->pidfile)) {

		LOG("Aborting - pid file path contains a link: %s\n.",

		    c->pidfile);

		return 1;

	}

	LOG("daemon pid file is %s\n", c->pidfile);

	// Verify cfgfile doesn't contain ".."

	def = false;

	sub = strstr(c->cfgfile, "..");

	if (sub)

		def = true;

	if (def || (c->cfgfile[0] == '\0')) {

		search = true;

	} else {

		canon_path = canonicalize_file_name(c->cfgfile);

		if (canon_path) {

			if (!cmd_path_is_symlink(c->cfgfile)) {

				len = strnlen(canon_path,

					      sizeof(c->cfgfile) - 1);

				memcpy(c->cfgfile,

					  canon_path,

					  len);

				c->cfgfile[len] = '\0';

				if (!cfg_load_config(c)) {

					LOG("daemon cfg file is %s\n",

					    c->cfgfile);

					search = false; // found and loaded it

				}

			}

			free(canon_path);

		}

	}

	if (search) {

		c->cfgfile[0] = '\0';

		if (cfg_find_config_file(c))

			LOG("failed to find config file.\n");

		else {

			if (cfg_load_config(c))

				LOG("failed to load config file %s\n",

				    c->cfgfile);

			else

				LOG("daemon cfg file is %s\n", c->cfgfile);

		}

	}

	if (!c->supported_devices) {

		LOG("using default configuration.\n");

		c->cfgfile[0] = '\0';

		c->supported_devices = default_supported_devices_table;

	}

	return 0;

}

void cmd_destroy(struct fpgad_config *c)

{

	unsigned i;

	if (c->daemon)

		unlink(c->pidfile);

	for (i = 0 ; i < c->num_null_gbs ; ++i) {

		if (c->null_gbs[i].filename)

			free((char *)c->null_gbs[i].filename);

		opae_unload_bitstream(&c->null_gbs[i]);

	}

	c->num_null_gbs = 0;

	if (c->supported_devices &&

	    (c->supported_devices != default_supported_devices_table)) {

		for (i = 0 ; c->supported_devices[i].library_path ; ++i) {

			fpgad_supported_device *d = &c->supported_devices[i];

			if (d->library_path)

				free((void *)d->library_path);

			if (d->config)

				free((void *)d->config);

		}

		free(c->supported_devices);

	}

	c->supported_devices = NULL;

}

bool cmd_path_is_symlink(const char *path)

{

	char component[PATH_MAX];

	struct stat stat_buf;

	size_t len;

	char *pslash;

	len = strnlen(path, PATH_MAX - 1);

	if (!len) // empty path

		return false;

	memcpy(component, path, len);

	component[len] = '\0';

	if (component[0] == '/') {

		// absolute path

		pslash = realpath(path, component);

		if (strcmp(component, path))

			return true;

	} else {

		// relative path

		pslash = strrchr(component, '/');

		while (pslash) {

			if (fstatat(AT_FDCWD, component,

				    &stat_buf, AT_SYMLINK_NOFOLLOW)) {

				return false;

			}

			if (S_ISLNK(stat_buf.st_mode))

				return true;

			*pslash = '\0';

			pslash = strrchr(component, '/');

		}

		if (fstatat(AT_FDCWD, component,

			    &stat_buf, AT_SYMLINK_NOFOLLOW)) {

			return false;

		}

		if (S_ISLNK(stat_buf.st_mode))

			return true;

	}

	return false;

}