/*

 * Copyright (C) 2016  J. Ali Harlow <ali@juiblex.co.uk>

 *

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

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include "config.h"

#undef DEBUG

#include <stdlib.h>

#include <string.h>

#include "razor.h"

#include "types/types.h"

#include "razor-internal.h"

#include "uri.h"

/*

 * Following RFC 3986 § 3.

 * Note that we don't validate queries or fragments.

 */

#define strdup0(s)			((s) ? strdup(s) : NULL)

#define string_str(str)			((char *)(str)->data)

#define string_init(str)		do { \

						char *_p; \

						array_init(str); \

						_p = array_add(str, 1); \

						*_p = '\0'; \

					} while(0)

#define string_append_len(str, s, len)	do { \

						char *_p; \

						_p = array_add(str, len); \

						_p--; \

						strncpy(_p, s, len); \

						_p[(len)] = '\0'; \

					} while(0)

#define string_append(str, s)		string_append_len(str, s, strlen(s))

#define string_truncate_at(str, s)	do { \

						int _len; \

						_len = (s) - \

						       (char *)(str)->data; \

						*(s) = '\0'; \

						(str)->size = _len + 1; \

					} while(0)

static const char *skip_uri_scheme(const char *uri)

{

	/*

	 * RFC 3986 defines scheme as:

	 *	scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

	 */

	if (*uri >= 'a' && *uri <= 'z' || *uri >= 'A' && *uri <= 'Z') {

		do {

		    uri++;

		} while (is_alnum(*uri) || *uri == '+' || *uri == '-' ||

			 *uri == '.');

		if (*uri == ':')

			return uri;

	}

	return NULL;

}

static char *razor_strndup(const char *s, size_t n)

{

	char *result;

	if (memchr(s, '\0', n))

		result = strdup(s);

	else {

		result = malloc(n + 1);

		memcpy(result, s, n);

		result[n] = '\0';

	}

	return result;

}

#if 0

/*

 * Return the (possibly decoded) pchar or 0 on end-of-string or -1 on error

 */

static int pchar_get_char_validated(const char *p)

{

	int c;

	if (p[0]=='\0')

		c = 0;

	else if (p[0]=='%') {

		if (xdigit_value(p[1]) < 0)

			return -1;

		c = xdigit_value(p[1]) * 16;

		if (xdigit_value(p[2]) < 0)

			return -1;

		c += xdigit_value(p[2]);

	} else if (p[0] >= 'a' && p[0] <= 'z' || p[0] >= 'A' && p[0] <= 'Z' || 

		   p[0] >= '0' && p[0] <= '9' ||

		   strchr("-._~!$&'()*+,;=:@", p[0]))

		c = p[0];

	else

		c = -1;

	return c;

}

#endif

/*

 * Verify the percent encoding. All '%' characters must be followed by

 * exactly two hexadecimal digits.

 */

static int pct_encoding_validate(const char *s)

{

	while (*s) {

		if (*s == '%') {

			if (xdigit_value(s[1]) < 0 || xdigit_value(s[2]) < 0)

				return -1;

			s += 2;

		}

		s++;

	}

	return 0;

}

static char *pct_encoding_normalize(char *s)

{

	char *retval, *p;

	int c;

	if (!s)

		return NULL;

	p = retval = malloc(strlen(s) + 1);

	while (*s) {

		if (*s == '%') {

			c = pchar_get_char(s);

			if (is_unreserved(c))

				*p++ = c;

			else {

				*p++ = '%';

				*p++ = "0123456789ABCDEF"[c/16];

				*p++ = "0123456789ABCDEF"[c%16];

			}

			pchar_next_char(s);

		} else

			*p++ = *s++;

	}

	*p++ = '\0';

	return realloc(retval, p - retval);

}

static int validate_userinfo(const char *userinfo, struct razor_error **error)

{

	const char *s;

	for (s = userinfo; *s; s++) {

		if (!is_unreserved(*s) && *s != '%' && !is_sub_delim(*s)

		    && *s != ':') {

			razor_set_error(error, RAZOR_GENERAL_ERROR,

					RAZOR_GENERAL_ERROR_BAD_URI, userinfo,

					"Invalid URI userinfo");

			return -1;

		}

	}

	return 0;

}

static int validate_reg_name(const char *reg_name)

{

	const char *s;

	for (s = reg_name; *s; s++) {

		if (!is_unreserved(*s) && *s != '%' && !is_sub_delim(*s))

			return -1;

	}

	return 0;

}

static int validate_ipv4address(const char *s, int length)

{

	int count = 0, digits, octet;

	for (;;) {

		if (!length)

			return -1;

		if (*s == '0') {

			digits = 1;

			octet = 0;

		} else {

			if (*s < '1' || *s > '9')

				return -1;

			octet = *s - '0';

			for (digits = 1; digits < length; digits++) {

				if (s[digits] >= '0' && s[digits] <= '9') {

					octet *= 10;

					octet += s[digits] - '0';

					if (octet > 255)

						return -1;

				} else

					break;

			}

		}

		s += digits;

		length -= digits;

		if (++count == 4)

			break;

		if (length < 1 || *s != '.')

			return -1;

		s++;

		length--;

	}

	return length ? -1 : 0;

}

static int count_ipv6_pieces(const char **s, int *length)

{

	int count, digits;

	for (digits = 0; digits < 4 && digits < *length; digits++) {

		if (!is_xdigit((*s)[digits]))

			break;

	}

	if (!digits)

		return 0;

	(*s) += digits;

	(*length) -= digits;

	count = 1;

	if (*length && **s == ':') {

		(*s)++;

		(*length)--;

		count += count_ipv6_pieces(s, length);

		if (count == 1) {

			(*s)--;

			(*length)++;

		}

	}

	return count;

}

static int validate_ip_literal(const char *ip_literal, int length)

{

	const char *s, *dot;

	int len, no_pieces, elide;

	if (length >= 4 && ip_literal[0] == 'v') {

		/* IPvFuture */

		dot = strchr(ip_literal + 2, '.');

		if (!dot || dot >= ip_literal + length)

			return -1;

		for (s = ip_literal + 1; s < dot; s++) {

			if (!is_xdigit(*s))

				return -1;

		}

		for (s = dot + 1; s < ip_literal + length; s++) {

			if (!is_unreserved(*s) && !is_sub_delim(*s) && *s != ':')

				return -1;

		}

	} else {

		/* IPv6address */

		s = ip_literal;

		len = length;

		no_pieces = count_ipv6_pieces(&s, &len);

		if (len > 1 && s[0] == ':' && s[1] == ':') {

			s += 2;

			len -= 2;

			elide = 1;

			no_pieces += count_ipv6_pieces(&s, &len);

		} else

			elide = 0;

		if (!validate_ipv4address(s, len))

			no_pieces += 2;

		else if (len)

			return -1;

		if (no_pieces > 8 || no_pieces == 8 && elide || no_pieces < 1)

			return -1;

	}

	return 0;

}

static int validate_host(const char *host, struct razor_error **error)

{

	int retval;

	if (host[0] == '[' && host[strlen(host) - 1] == ']')

		retval = validate_ip_literal(host + 1, strlen(host) - 2);

	else {

		retval = validate_ipv4address(host, strlen(host));

		if (retval < 0)

			retval = validate_reg_name(host);

	}

	if (retval)

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, host,

				"Invalid URI host");

	return retval;

}

static char *strdown(char *s)

{

	while (*s) {

		if (*s >= 'A' && *s <= 'Z') {

			*s -= 'A';

			*s += 'a';

		}

		s++;

	}

	return s;

}

static int razor_uri_parse_authority(struct razor_uri *ru,

				     const char *authority, int length,

				     struct razor_error **error)

{

	const char *s, *auth = authority;

	char *userinfo, *port, *host;

	s = strchr(auth, '@');

	if (s && s < auth + length) {

		userinfo = razor_strndup(auth, s - auth);

		s++;

		length -= s - auth;

		auth = s;

		if (validate_userinfo(userinfo, error)) {

			free(userinfo);

			return -1;

		}

	} else

		userinfo = NULL;

	s = strchr(auth, ':');

	if (s && s < auth + length) {

		s++;

		port = razor_strndup(s, length - (s - auth));

		s--;

		length = s - auth;

		if (strspn(port, "0123456789") != strlen(port)) {

			razor_set_error(error, RAZOR_GENERAL_ERROR,

					RAZOR_GENERAL_ERROR_BAD_URI, port,

					"Invalid URI port");

			free(userinfo);

			free(port);

			return -1;

		}

	} else

		port = NULL;

	host = razor_strndup(auth, length);

	if (validate_host(host, error)) {

		free(userinfo);

		free(port);

		free(host);

		return -1;

	}

	ru->userinfo = userinfo;

	ru->port = port;

	ru->host = host;

	return 0;

}

/*

 * Parse either a hier-part or a relative-part

 */

static int razor_uri_parse_part(struct razor_uri *ru, const char *part,

				int relative_part, struct razor_error **error)

{

	const char *s, *hp = part;

	char *path, *p;

	int noscheme = 0;

	if (hp[0] == '/' && hp[1] == '/') {

		hp += 2;

		s = strpbrk(hp, "/?#");

		if (!s)

			s = hp + strlen(hp);

		if (razor_uri_parse_authority(ru, hp, s - hp, error) < 0)

			return -1;

		hp = s;

	} else {

		ru->userinfo = NULL;

		ru->host = NULL;

		ru->port = NULL;

	}

	if (!*hp) {

		/* path-empty */

		ru->path = strdup("");

		return 0;

	} else if (*hp == '/') {

		/* path-absolute */

		p = path = malloc(strlen(hp) + 1);

		*p++ = '/';

		hp++;

		if (!*hp) {

			*p++ = '\0';

			ru->path = realloc(path, p - path);

			return 0;

		}

	} else if (!ru->host) {

		/* path-rootless or path-noscheme */

		noscheme = relative_part;

		p = path = malloc(strlen(hp) + 1);

	} else {

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, part,

				relative_part ? "Invalid URI relative part" :

				"Invalid URI hierarchical part");

		return -1;

	}

	if (!is_pchar(*hp) || noscheme && *hp == ':') {

		free(path);

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, part,

				"Invalid character in URI path");

		return -1;

	}

	*p++ = *hp++;

	while (*hp) {

		if (*hp == '/')

			noscheme = 0;

		else if (!is_pchar(*hp) || noscheme && *hp == ':') {

			free(path);

			razor_set_error(error, RAZOR_GENERAL_ERROR,

					RAZOR_GENERAL_ERROR_BAD_URI, part,

					"Invalid character in URI path");

			return -1;

		}

		*p++ = *hp++;

	}

	*p++ = '\0';

	ru->path = realloc(path, p - path);

	return 0;

}

void razor_uri_destroy(struct razor_uri *ru)

{

	free(ru->scheme);

	free(ru->userinfo);

	free(ru->host);

	free(ru->port);

	free(ru->path);

	free(ru->query);

	free(ru->fragment);

}

int razor_uri_parse_uri(struct razor_uri *ru, const char *uri, int absolute,

			struct razor_error **error)

{

	int r;

	const char *s;

	char *hier_part;

	if (pct_encoding_validate(uri) < 0) {

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, uri,

				"Invalid percent encoding");

		return -1;

	}

	memset(ru, 0, sizeof(*ru));

	s = skip_uri_scheme(uri);

	if (!s) {

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, uri,

				"Invalid URI scheme");

		return -1;

	}

	ru->scheme = razor_strndup(uri, s - uri);

	uri = s + 1;

	s = strchr(uri, '?');

	if (!s)

		s = strchr(uri, '#');

	if (!s)

		s = uri + strlen(uri);

	hier_part = razor_strndup(uri, s - uri);

	uri = s;

	r = razor_uri_parse_part(ru, hier_part, 0, error);

	free(hier_part);

	if (r) {

		razor_uri_destroy(ru);

		return -1;

	}

	if (*uri != '?')

		ru->query = NULL;

	else {

		uri++;

		s = strchr(uri, '#');

		if (!s)

			s = uri + strlen(uri);

		ru->query = razor_strndup(uri, s - uri);

		uri = s;

	}

	if (*uri != '#')

		ru->fragment = NULL;

	else if (absolute) {

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, uri,

				"Fragments are not allowed in absolute URIs");

		razor_uri_destroy(ru);

		return -1;

	} else {

		uri++;

		ru->fragment = strdup(uri);

	}

	return 0;

}

int razor_uri_parse_relative_ref(struct razor_uri *ru, const char *uri,

				 struct razor_error **error)

{

	int r;

	const char *s;

	char *relative_part;

	if (pct_encoding_validate(uri) < 0) {

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_BAD_URI, uri,

				"Invalid percent encoding");

		return -1;

	}

	memset(ru, 0, sizeof(*ru));

	s = strchr(uri, '?');

	if (!s)

		s = strchr(uri, '#');

	if (!s)

		s = uri + strlen(uri);

	relative_part = razor_strndup(uri, s - uri);

	uri = s;

	r = razor_uri_parse_part(ru, relative_part, 1, error);

	free(relative_part);

	if (r)

		return -1;

	if (*uri == '?') {

		uri++;

		s = strchr(uri, '#');

		if (!s)

			s = uri + strlen(uri);

		ru->query = razor_strndup(uri, s - uri);

		uri = s;

	} else

		ru->query = NULL;

	if (*uri == '#') {

		uri++;

		ru->fragment = strdup(uri);

	} else

		ru->fragment = NULL;

	return 0;

}

int razor_uri_parse(struct razor_uri *ru, const char *uri,

		    struct razor_error **error)

{

	struct razor_error *tmp_error = NULL;

	int r;

	r = razor_uri_parse_uri(ru, uri, 0, &tmp_error);

	if (r < 0) {

		r = razor_uri_parse_relative_ref(ru, uri, NULL);

		if (r < 0)

			razor_propagate_error(error, tmp_error, NULL);

		else

			razor_error_free(tmp_error);

	}

	return r;

}

/*

 * Following RFC 3986 § 5.2.4

 */

static char *remove_dot_segments(const char *path)

{

	struct array output;

	char *input, *in, *s, *t;

	const char *step;

#ifdef DEBUG

	fprintf(stderr, "STEP   OUTPUT BUFFER         INPUT BUFFER\n");

#endif

	input = strdup(path);

	in = input;

	string_init(&output);

#ifdef DEBUG

	fprintf(stderr, " 1 :   %-21s %s\n", string_str(&output), in);

#endif

	while (*in) {

		if (str_has_prefix(in, "../")) {

			step = "2A";

			in += 3;

		} else if (str_has_prefix(in, "./")) {

			step = "2A";

			in += 2;

		} else if (str_has_prefix(in, "/./")) {

			step = "2B";

			in += 2;

		} else if (!strcmp(in, "/.")) {

			step = "2B";

			in++;

			*in = '/';

		} else if (str_has_prefix(in, "/../")) {

			step = "2C";

			in += 3;

			s = strrchr(string_str(&output), '/');

			if (!s)

				s = string_str(&output);

			string_truncate_at(&output, s);

		} else if (!strcmp(in, "/..")) {

			step = "2C";

			in += 2;

			*in = '/';

			s = strrchr(string_str(&output), '/');

			if (!s)

				s = string_str(&output);

			string_truncate_at(&output, s);

		} else if (!strcmp(in, ".") || !strcmp(in, "..")) {

			step = "2D";

			in += strlen(in);

		} else {

			step = "2E";

			t = strchr(in + 1, '/');

			if (!t)

				t = in + strlen(in);

			string_append_len(&output, in, t - in);

			in = t;

		}

#ifdef DEBUG

		fprintf(stderr, " %s:   %-21s %s\n", step, string_str(&output),

			in);

#endif

	}

	free(input);

	return string_str(&output);

}

/*

 * Following RFC 3986 § 6.2.2

 */

void razor_uri_normalize(struct razor_uri *ru)

{

	char *s;

	strdown(ru->scheme);

	if (ru->host)

		strdown(ru->host);

	s = pct_encoding_normalize(ru->userinfo);

	free(ru->userinfo);

	ru->userinfo = s;

	s = pct_encoding_normalize(ru->host);

	free(ru->host);

	ru->host = s;

	s = pct_encoding_normalize(ru->path);

	free(ru->path);

	ru->path = s;

	s = pct_encoding_normalize(ru->query);

	free(ru->query);

	ru->query = s;

	s = pct_encoding_normalize(ru->fragment);

	free(ru->fragment);

	ru->fragment = s;

	s = remove_dot_segments(ru->path);

	free(ru->path);

	ru->path = s;

}

char *razor_uri_get_authority(const struct razor_uri *ru)

{

	char *result, *r;

	int len = 1;

	if (ru->host) {

		if (ru->userinfo)

			len += strlen(ru->userinfo) + 1;

		len += strlen(ru->host);

		if (ru->port)

			len += strlen(ru->port) + 1;

	} else

		return NULL;

	r = result = malloc(len);

	if (ru->userinfo) {

		strcpy(r, ru->userinfo);

		r += strlen(r);

		*r++ = '@';

	}

	strcpy(r, ru->host);

	r += strlen(r);

	if (ru->port) {

		*r++ = ':';

		strcpy(r, ru->port);

	}

	return result;

}

/*

 * Following RFC 3986 § 5.3

 */

char *razor_uri_recompose(const struct razor_uri *ru)

{

	char *authority, *result, *r;

	int len = 1;

	authority = razor_uri_get_authority(ru);

	if (ru->scheme)

		len += strlen(ru->scheme) + 1;

	if (authority)

		len += strlen(authority) + 2;

	len += strlen(ru->path);

	if (ru->query)

		len += strlen(ru->query) + 1;

	if (ru->fragment)

		len += strlen(ru->fragment) + 1;

	r = result = malloc(len);

	if (ru->scheme) {

		strcpy(r, ru->scheme);

		r += strlen(r);

		*r++ = ':';

	}

	if (authority) {

		*r++ = '/';

		*r++ = '/';

		strcpy(r, authority);

		free(authority);

		r += strlen(r);

	}

	strcpy(r, ru->path);

	r += strlen(r);

	if (ru->query) {

		*r++ = '?';

		strcpy(r, ru->query);

		r += strlen(r);

	}

	if (ru->fragment) {

		*r++ = '#';

		strcpy(r, ru->fragment);

	}

	return result;

}

/*

 * Following RFC 3986 § 5.2.3

 */

static char *merge_paths(const struct razor_uri *base,const struct razor_uri *R)

{

	char *s, *t, *path;

	if (base->host && !*base->path)

		path = razor_concat("/", R->path, NULL);

	else {

		s = strrchr(base->path, '/');

		if (s) {

			t = razor_strndup(base->path, s + 1 - base->path);

			path = razor_concat(t, R->path, NULL);

			free(t);

		} else

			path = strdup(R->path);

	}

	return path;

}

/*

 * Following RFC 3986 § 5.2

 */

void razor_uri_resolve(struct razor_uri *T, const struct razor_uri *base,

		       const struct razor_uri *R)

{

	char *s;

	if (R->scheme) {

		T->scheme = strdup(R->scheme);

		T->userinfo = strdup0(R->userinfo);

		T->host = strdup0(R->host);

		T->port = strdup0(R->port);

		T->path = remove_dot_segments(R->path);

		T->query = strdup0(R->query);

	} else {

		if (R->host) {

			T->userinfo = strdup0(R->userinfo);

			T->host = strdup0(R->host);

			T->port = strdup0(R->port);

			T->path = remove_dot_segments(R->path);

			T->query = strdup0(R->query);

		} else {

			if (!*R->path) {

				T->path = strdup(base->path);

				if (R->query)

					T->query = strdup(R->query);

				else

					T->query = strdup0(base->query);

			} else {

				if (*R->path == '/')

					T->path = remove_dot_segments(R->path);

				else {

					s = merge_paths(base, R);

					T->path = remove_dot_segments(s);

					free(s);

				}

				T->query = strdup0(R->query);

			}

			T->userinfo = strdup0(base->userinfo);

			T->host = strdup0(base->host);

			T->port = strdup0(base->port);

		}

		T->scheme = strdup(base->scheme);

	}

	T->fragment = strdup0(R->fragment);

}

/*

 * This differs from razor_uri_resolve() both in the types of its arguments

 * and in the fact that it takes a root URI rather than a base URI. The base

 * URI is determined by appending a slash to the root URI (if it doesn't

 * already end in a slash). Finally, uri can be explicitly marked as either

 * relative (ie., a relative-ref) or not (ie., a URI). This is important as

 * otherwise "c:/xxx" could be interpreted as a URI in the "c" scheme.

 */

char *razor_resolve_uri_root(const char *root_uri, const char *uri,

			     int is_relative, struct razor_error **error)

{

	int r;

        char *base_uri, *s, *result;

	struct razor_uri ru, base, file;

	if (!root_uri || !*root_uri)

		root_uri = "file:/";

	if (root_uri[strlen(root_uri) - 1] == '/')

		base_uri = strdup(root_uri);

	else

		base_uri = razor_concat(root_uri, "/", NULL);

	r = razor_uri_parse_uri(&base, base_uri, 1, error);

	free(base_uri);

	if (r)

		return NULL;

	if (is_relative > 0) {

		/*

		 * We can't use razor_uri_parse_relative_ref() to parse

		 * uri in case it starts with a segment that includes a

		 * colon. Thus we use this kludge.

		 */

		s = razor_concat("scheme:", uri, NULL);

		r = razor_uri_parse_uri(&file, s, 0, error);

		free(s);

		if (!r) {

			free(file.scheme);

			file.scheme = NULL;

		}

	}

	else if (!is_relative)

		r = razor_uri_parse_uri(&file, uri, 0, error);

	else

		r = razor_uri_parse(&file, uri, error);

	if (r) {

		razor_uri_destroy(&base);

		return NULL;

	}

	razor_uri_resolve(&ru, &base, &file);

	razor_uri_destroy(&base);

	razor_uri_destroy(&file);

	result = razor_uri_recompose(&ru);

	razor_uri_destroy(&ru);

	return result;

}