// 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.

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif // HAVE_CONFIG_H

#include <sys/types.h>
#include <pwd.h>
#include "config_file.h"
#include "monitored_device.h"
#include "api/sysfs.h"

#include <json-c/json.h>

#ifdef LOG
#undef LOG
#endif
#define LOG(format, ...) \
log_printf("cfg: " format, ##__VA_ARGS__)

#define CFG_TRY_FILE(__f) \
do { \
	canon = canonicalize_file_name(__f); \
	if (canon) { \
 \
		if (!cmd_path_is_symlink(__f)) { \
			size_t len = strnlen(canon, \
					sizeof(c->cfgfile) - 1); \
			memcpy(c->cfgfile, \
				canon, \
				len); \
			c->cfgfile[len] = '\0'; \
			free(canon); \
			return 0; \
		} \
 \
		free(canon); \
	} \
} while (0)

int cfg_find_config_file(struct fpgad_config *c)
{
	char path[PATH_MAX];
	char *e;
	char *canon = NULL;
	uid_t uid;
	size_t len;

	uid = geteuid();

	e = getenv("FPGAD_CONFIG_FILE");
	if (e) {
		// try $FPGAD_CONFIG_FILE
		len = strnlen(e, sizeof(path) - 1);
		memcpy(path, e, len);
		path[len] = '\0';

		CFG_TRY_FILE(path);
	}

	if (!uid) {
		CFG_TRY_FILE("/var/lib/opae/fpgad.cfg");
	} else {
		struct passwd *passwd;

		passwd = getpwuid(uid);

		// try $HOME/.opae/fpgad.cfg
		snprintf(path, sizeof(path),
			     "%s/.opae/fpgad.cfg", passwd->pw_dir);

		CFG_TRY_FILE(path);
	}

	CFG_TRY_FILE("/etc/opae/fpgad.cfg");

	return 1; // not found
}

STATIC char *cfg_read_file(const char *file)
{
	FILE *fp;
	size_t len;
	char *buf;

	fp = fopen(file, "r");
	if (!fp) {
		LOG("fopen failed.\n");
		return NULL;
	}

	if (fseek(fp, 0, SEEK_END)) {
		LOG("fseek failed.\n");
		fclose(fp);
		return NULL;
	}

	len = (size_t)ftell(fp);
	++len; // for \0

	if (len == 1) {
		LOG("%s is empty.\n", file);
		fclose(fp);
		return NULL;
	}

	if (fseek(fp, 0, SEEK_SET)) {
		LOG("fseek failed.\n");
		fclose(fp);
		return NULL;
	}

	buf = (char *)malloc(len);
	if (!buf) {
		LOG("malloc failed.\n");
		fclose(fp);
		return NULL;
	}

	if ((fread(buf, 1, len - 1, fp) != len - 1) ||
	    ferror(fp)) {
		LOG("fread failed.\n");
		fclose(fp);
		free(buf);
		return NULL;
	}

	fclose(fp);
	buf[len - 1] = '\0';

	return buf;
}

typedef struct _cfg_vendor_device_id {
	uint16_t vendor_id;
	uint16_t device_id;
	struct _cfg_vendor_device_id *next;
} cfg_vendor_device_id;

typedef struct _cfg_plugin_configuration {
	char *configuration;
	bool enabled;
	char *library;
	cfg_vendor_device_id *devices;
	struct _cfg_plugin_configuration *next;
} cfg_plugin_configuration;

STATIC cfg_vendor_device_id *alloc_device(uint16_t vendor_id,
					  uint16_t device_id)
{
	cfg_vendor_device_id *p;

	p = (cfg_vendor_device_id *)malloc(sizeof(cfg_vendor_device_id));
	if (p) {
		p->vendor_id = vendor_id;
		p->device_id = device_id;
		p->next = NULL;
	}

	return p;
}

STATIC cfg_plugin_configuration *alloc_configuration(char *configuration,
						     bool enabled,
						     char *library,
						     cfg_vendor_device_id *devs)
{
	cfg_plugin_configuration *p;

	p = (cfg_plugin_configuration *)
		malloc(sizeof(cfg_plugin_configuration));
	if (p) {
		p->configuration = configuration;
		p->enabled = enabled;
		p->library = library;
		p->devices = devs;
		p->next = NULL;
	}

	return p;
}

STATIC cfg_vendor_device_id *
cfg_process_plugin_devices(const char *name,
			   json_object *j_devices)
{
	int i;
	int devs;
	cfg_vendor_device_id *head = NULL;
	cfg_vendor_device_id *id = NULL;
	uint16_t vendor_id;
	uint16_t device_id;
	const char *s;
	char *endptr;

	if (!json_object_is_type(j_devices, json_type_array)) {
		LOG("'devices' JSON object not array.\n");
		return NULL;
	}

	devs = json_object_array_length(j_devices);
	for (i = 0 ; i < devs ; ++i) {
		json_object *j_dev = json_object_array_get_idx(j_devices, i);
		json_object *j_vid;
		json_object *j_did;

		if (!json_object_is_type(j_dev, json_type_array)) {
			LOG("%s 'devices' entry %d not array.\n",
				name, i);
			goto out_free;
		}

		if (json_object_array_length(j_dev) != 2) {
			LOG("%s 'devices' entry %d not array[2].\n",
				name, i);
			goto out_free;
		}

		j_vid = json_object_array_get_idx(j_dev, 0);
		if (json_object_is_type(j_vid, json_type_string)) {
			s = json_object_get_string(j_vid);
			endptr = NULL;

			vendor_id = (uint16_t)strtoul(s, &endptr, 0);
			if (*endptr != '\0') {
				LOG("%s malformed Vendor ID at devices[%d]\n",
					name, i);
				goto out_free;
			}

		} else if (json_object_is_type(j_vid, json_type_int)) {
			vendor_id = (uint16_t)json_object_get_int(j_vid);
		} else {
			LOG("%s invalid Vendor ID at devices[%d]\n",
				name, i);
			goto out_free;
		}

		j_did = json_object_array_get_idx(j_dev, 1);
		if (json_object_is_type(j_did, json_type_string)) {
			s = json_object_get_string(j_did);
			endptr = NULL;

			device_id = (uint16_t)strtoul(s, &endptr, 0);
			if (*endptr != '\0') {
				LOG("%s malformed Device ID at devices[%d]\n",
					name, i);
				goto out_free;
			}

		} else if (json_object_is_type(j_did, json_type_int)) {
			device_id = (uint16_t)json_object_get_int(j_did);
		} else {
			LOG("%s invalid Device ID at devices[%d]\n",
				name, i);
			goto out_free;
		}

		if (!head) {
			head = alloc_device(vendor_id, device_id);
			if (!head) {
				LOG("malloc failed.\n");
				goto out_free;
			}

			id = head;
		} else {
			id->next = alloc_device(vendor_id, device_id);
			if (!id->next) {
				LOG("malloc failed.\n");
				goto out_free;
			}

			id = id->next;
		}
	}

	return head;

out_free:
	for (id = head ; id ; ) {
		cfg_vendor_device_id *trash = id;
		id = id->next;
		free(trash);
	}
	return NULL;
}

STATIC int cfg_process_plugin(const char *name,
			      json_object *j_configurations,
			      cfg_plugin_configuration **list)
{
	json_object *j_cfg_plugin = NULL;
	json_object *j_cfg_plugin_configuration = NULL;
	json_object *j_enabled = NULL;
	json_object *j_plugin = NULL;
	json_object *j_devices = NULL;
	char *configuration = NULL;
	bool enabled = false;
	char *plugin = NULL;
	cfg_plugin_configuration *c = NULL;

	if (!json_object_object_get_ex(j_configurations,
				       name,
				       &j_cfg_plugin)) {
		LOG("couldn't find configurations section"
		    " for %s.\n", name);
		return 1;
	}

	if (!json_object_object_get_ex(j_cfg_plugin,
				       "configuration",
				       &j_cfg_plugin_configuration)) {
		LOG("couldn't find %s configuration section.\n", name);
		return 1;
	}

	configuration = (char *)json_object_to_json_string_ext(
				j_cfg_plugin_configuration,
				JSON_C_TO_STRING_PLAIN);
	if (!configuration) {
		LOG("failed to parse configuration for %s.\n", name);
		return 1;
	}

	configuration = cstr_dup(configuration);
	if (!configuration) {
		LOG("cstr_dup failed.\n");
		return 1;
	}

	if (!json_object_object_get_ex(j_cfg_plugin,
				       "enabled",
				       &j_enabled)) {
		LOG("couldn't find enabled key"
		    " for %s.\n", name);
		goto out_free;
	}

	if (!json_object_is_type(j_enabled, json_type_boolean)) {
		LOG("enabled key for %s not boolean.\n", name);
		goto out_free;
	}

	enabled = json_object_get_boolean(j_enabled);

	if (!json_object_object_get_ex(j_cfg_plugin,
				       "plugin",
				       &j_plugin)) {
		LOG("couldn't find plugin key"
		    " for %s.\n", name);
		goto out_free;
	}

	if (!json_object_is_type(j_plugin, json_type_string)) {
		LOG("plugin key for %s not string.\n", name);
		goto out_free;
	}

	plugin = cstr_dup(json_object_get_string(j_plugin));
	if (!plugin) {
		LOG("cstr_dup failed.\n");
		goto out_free;
	}

	if (!json_object_object_get_ex(j_cfg_plugin,
				       "devices",
				       &j_devices)) {
		LOG("couldn't find devices key"
		    " for %s.\n", name);
		goto out_free;
	}

	if (!(*list)) { // list is empty
		c = alloc_configuration(configuration,
					enabled,
					plugin,
					NULL);
		if (!c) {
			LOG("malloc failed.\n");
			goto out_free;
		}

		*list = c;
	} else {
		for (c = *list ; c->next ; c = c->next)
		/* find the end of the list */ ;

		c->next = alloc_configuration(configuration,
					      enabled,
					      plugin,
					      NULL);
		if (!c->next) {
			LOG("malloc failed.\n");
			goto out_free;
		}

		c = c->next;
	}

	c->devices = cfg_process_plugin_devices(name, j_devices);

	return 0;

out_free:
	if (configuration)
		free(configuration);
	if (plugin)
		free(plugin);
	if (c)
		free(c);
	return 1;
}

STATIC fpgad_supported_device *
cfg_json_to_supported(cfg_plugin_configuration *configurations)
{
	cfg_plugin_configuration *c;
	cfg_vendor_device_id *d;
	size_t num_devices = 0;
	fpgad_supported_device *supported;
	int i;

	// find the number of devices
	for (c = configurations ; c ; c = c->next) {
		if (!c->enabled) // skip it
			continue;
		for (d = c->devices ; d ; d = d->next) {
			++num_devices;
		}
	}

	++num_devices; // +1 for NULL terminator

	supported = calloc(num_devices, sizeof(fpgad_supported_device));
	if (!supported) {
		LOG("calloc failed.\n");
		return NULL;
	}

	i = 0;
	for (c = configurations ; c ; c = c->next) {
		if (!c->enabled) // skip it
			continue;
		for (d = c->devices ; d ; d = d->next) {
			fpgad_supported_device *dev = &supported[i++];

			dev->vendor_id = d->vendor_id;
			dev->device_id = d->device_id;
			dev->library_path = cstr_dup(c->library);
			dev->config = cstr_dup(c->configuration);
		}
	}

	for (c = configurations ; c ; ) {
		cfg_plugin_configuration *ctrash = c;

		for (d = c->devices ; d ; ) {
			cfg_vendor_device_id *dtrash = d;
			d = d->next;
			free(dtrash);
		}

		c = c->next;

		if (ctrash->configuration)
			free(ctrash->configuration);
		if (ctrash->library)
			free(ctrash->library);
		free(ctrash);
	}

	return supported;
}

STATIC bool cfg_verify_supported_devices(fpgad_supported_device *d)
{
	while (d->library_path) {
		char *sub = NULL;

		if (d->library_path[0] == '/') {
			LOG("plugin library paths may not "
			    "be absolute paths: %s\n", d->library_path);
			return false;
		}

		if (cmd_path_is_symlink(d->library_path)) {
			LOG("plugin library paths may not "
			    "contain links: %s\n", d->library_path);
			return false;
		}

		sub = strstr((char *)d->library_path, "..");
		if (sub) {
			LOG("plugin library paths may not "
			    "contain .. : %s\n", d->library_path);
			return false;
		}

		++d;
	}

	return true;
}

int cfg_load_config(struct fpgad_config *c)
{
	char *cfg_buf;
	json_object *root = NULL;
	json_object *j_configurations = NULL;
	json_object *j_plugins = NULL;
	enum json_tokener_error j_err = json_tokener_success;
	int res = 1;
	int num_plugins;
	int i;
	cfg_plugin_configuration *configurations = NULL;

	cfg_buf = cfg_read_file(c->cfgfile);
	if (!cfg_buf)
		return res;

	root = json_tokener_parse_verbose(cfg_buf, &j_err);
	if (!root) {
		LOG("error parsing %s: %s\n",
		    c->cfgfile,
		    json_tokener_error_desc(j_err));
		goto out_free;
	}

	if (!json_object_object_get_ex(root,
				       "configurations",
				       &j_configurations)) {
		LOG("failed to find configurations section in %s.\n",
		    c->cfgfile);
		goto out_put;
	}

	if (!json_object_object_get_ex(root, "plugins", &j_plugins)) {
		LOG("failed to find plugins section in %s.\n", c->cfgfile);
		goto out_put;
	}

	if (!json_object_is_type(j_plugins, json_type_array)) {
		LOG("'plugins' JSON object not array.\n");
		goto out_put;
	}

	num_plugins = json_object_array_length(j_plugins);
	for (i = 0 ; i < num_plugins ; ++i) {
		json_object *j_plugin;
		const char *plugin_name;

		j_plugin = json_object_array_get_idx(j_plugins, i);
		plugin_name = json_object_get_string(j_plugin);

		if (cfg_process_plugin(plugin_name,
				       j_configurations,
				       &configurations))
			goto out_put;
	}

	if (!configurations) {
		LOG("no configurations found in %s.\n", c->cfgfile);
		goto out_put;
	}

	c->supported_devices = cfg_json_to_supported(configurations);

	if (c->supported_devices) {

		if (cfg_verify_supported_devices(c->supported_devices)) {
			res = 0;
		} else {
			fpgad_supported_device *trash = c->supported_devices;

			LOG("invalid configuration file\n");

			while (trash->library_path) {
				free((void *)trash->library_path);
				if (trash->config)
					free((void *)trash->config);

				++trash;
			}

			free(c->supported_devices);
			c->supported_devices = NULL;
		}

	}

out_put:
	json_object_put(root);
out_free:
	free(cfg_buf);
	return res;
}