// Copyright(c) 2019-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 <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <limits.h>
#include <fcntl.h>
#include <opae/log.h>

#include "bits_utils.h"

fpga_result opae_bitstream_get_json_string(json_object *parent,
					   const char *name,
					   char **value)
{
	json_object *obj = NULL;
	const char *s;
	size_t len;
	char *p;

	if (!json_object_object_get_ex(parent,
				       name,
				       &obj)) {
		return FPGA_EXCEPTION;
	}

	if (!json_object_is_type(obj, json_type_string)) {
		OPAE_ERR("metadata: \"%s\" key not string", name);
		return FPGA_EXCEPTION;
	}

	s = json_object_get_string(obj);

	len = strlen(s);

	*value = malloc(len + 1);
	if (!*value) {
		OPAE_ERR("malloc failed");
		return FPGA_NO_MEMORY;
	}

	memcpy(*value, s, len);
	p = *value;
	p[len] = '\0';

	return FPGA_OK;
}

fpga_result opae_bitstream_get_json_int(json_object *parent,
					const char *name,
					int *value)
{
	json_object *obj = NULL;

	if (!json_object_object_get_ex(parent,
				       name,
				       &obj)) {
		return FPGA_EXCEPTION;
	}

	if (!json_object_is_type(obj, json_type_int)) {
		return FPGA_EXCEPTION;
	}

	*value = json_object_get_int(obj);
	return FPGA_OK;
}

fpga_result opae_bitstream_get_json_double(json_object *parent,
					   const char *name,
					   double *value)
{
	json_object *obj = NULL;

	if (!json_object_object_get_ex(parent,
				       name,
				       &obj)) {
		return FPGA_EXCEPTION;
	}

	if (!json_object_is_type(obj, json_type_double)) {
		return FPGA_EXCEPTION;
	}

	*value = json_object_get_double(obj);
	return FPGA_OK;
}

STATIC bool opae_bitstream_path_invalid_chars(const char *path,
					      size_t len)
{
	while (*path) {
		int ch = *path;

		// check for non-printable chars
		if (!isprint(ch))
			return true;

		// check for URL encoding
		if ((ch == '%') &&
		    (len >= 3) &&
		    (isxdigit(*(path+1)) && isxdigit(*(path+2))))
			return true;

		++path;
		--len;
	}

	return false;
}

STATIC bool opae_bitstream_path_not_file(const char *path)
{
	struct stat sb;

	if (stat(path, &sb) < 0)
		return true; // can't determine

	if (!S_ISREG(sb.st_mode))
		return true;

	return false;
}

STATIC bool opae_bitstream_path_contains_dotdot(const char *path,
						size_t len)
{
	if (len >= 3) {
		// check for ../ at the start of the path.
		if ((*path == '.') &&
		    (*(path + 1) == '.') &&
		    (*(path + 2) == '/'))
			return true;
	} else if (len == 2) {
		// check for ".."
		if ((*path == '.') &&
		    (*(path + 1) == '.'))
			return true;
	}

	while (*path) {

		if (len >= 4) {
			// check for /../
			if ((*path == '/') &&
			    (*(path + 1) == '.') &&
			    (*(path + 2) == '.') &&
			    (*(path + 3) == '/'))
				return true;
		} else if (len == 3) {
			// check for /.. at the end
			if ((*path == '/') &&
			    (*(path + 1) == '.') &&
			    (*(path + 2) == '.'))
				return true;
		}

		++path;
		--len;
	}

	return false;
}

STATIC bool opae_bitstream_path_contains_symlink(const char *path,
						 size_t len)
{
	char component[PATH_MAX] = { 0, };
	struct stat stat_buf;
	char *pslash;

	memcpy(component, path, len);
	component[len] = '\0';

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

		pslash = realpath(path, component);

		// If the result of conversion through realpath() is different
		// than the original path, then the original must have
		// contained a symlink.
		if (strcmp(component, path)) {
			return true;
		}

	} else {
		// relative path

		pslash = strrchr(component, '/');

		while (pslash) {

			if (fstatat(AT_FDCWD, component,
				    &stat_buf, AT_SYMLINK_NOFOLLOW)) {
				OPAE_ERR("fstatat failed.");
				return true;
			}

			if (S_ISLNK(stat_buf.st_mode))
				return true;

			*pslash = '\0';
			pslash = strrchr(component, '/');
		}

		if (fstatat(AT_FDCWD, component,
			    &stat_buf, AT_SYMLINK_NOFOLLOW)) {
			OPAE_ERR("fstatat failed.");
			return true;
		}

		if (S_ISLNK(stat_buf.st_mode))
			return true;

	}

	return false;
}

bool opae_bitstream_path_is_valid(const char *path,
				  uint32_t flags)
{
	size_t len;

	// check for NULL / empty string
	if (!path || (*path == '\0'))
		return false;

	len = strlen(path);

	if (opae_bitstream_path_invalid_chars(path, len))
		return false;

	if (opae_bitstream_path_not_file(path))
		return false;

	if ((flags & OPAE_BITSTREAM_PATH_NO_PARENT) &&
	    opae_bitstream_path_contains_dotdot(path, len))
		return false;

	if ((flags & OPAE_BITSTREAM_PATH_NO_SYMLINK) &&
	    opae_bitstream_path_contains_symlink(path, len))
		return false;

	return true;
}