///////////////////////////////////////////////////////////////////////////////////////////////
/// This is free and unencumbered software released into the public domain.                 ///
///                                                                                         ///
/// Anyone is free to copy, modify, publish, use, compile, sell, or                         ///
/// distribute this software, either in source code form or as a compiled                   ///
/// binary, for any purpose, commercial or non-commercial, and by any                       ///
/// means.                                                                                  ///
///                                                                                         ///
/// In jurisdictions that recognize copyright laws, the author or authors                   ///
/// of this software dedicate any and all copyright interest in the                         ///
/// software to the public domain. We make this dedication for the benefit                  ///
/// of the public at large and to the detriment of our heirs and                            ///
/// successors. We intend this dedication to be an overt act of                             ///
/// relinquishment in perpetuity of all present and future rights to this                   ///
/// software under copyright law.                                                           ///
///                                                                                         ///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,                         ///
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                      ///
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.                  ///
/// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR                       ///
/// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,                   ///
/// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR                   ///
/// OTHER DEALINGS IN THE SOFTWARE.                                                         ///
///                                                                                         ///
/// For more information, please refer to <https://unlicense.org>                           ///
///                                                                                         ///
/// NOTE: Some code was adapted from BearSSL. That code uses the MIT license.               ///
///////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////
/// HEADERS                                                                                 ///
///////////////////////////////////////////////////////////////////////////////////////////////

// TODO: Clean up these headers
#include <time.h>
#include <poll.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <stdarg.h>
#include <limits.h>
#include <signal.h> // sig_atomic_t
#include <dirent.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/resource.h>
#include <arpa/inet.h>
#include "log.h"
#include "http.h"
#include "tinytemplate.h"

///////////////////////////////////////////////////////////////////////////////////////////////
/// CONFIGURATION                                                                           ///
///////////////////////////////////////////////////////////////////////////////////////////////

#ifndef HTTPS
#define HTTPS 0
#endif

#define INPUT_BUFFER_LIMIT_MB   1

///////////////////////////////////////////////////////////////////////////////////////////////
/// OPTIONAL HEADERS                                                                        ///
///////////////////////////////////////////////////////////////////////////////////////////////

#if HTTPS
#include <bearssl.h>
#endif

///////////////////////////////////////////////////////////////////////////////////////////////
/// TYPES & DEFINITIONS                                                                     ///
///////////////////////////////////////////////////////////////////////////////////////////////

#if HTTPS
typedef struct {
	int type;  // BR_KEYTYPE_RSA or BR_KEYTYPE_EC
	union {
		br_rsa_private_key rsa;
		br_ec_private_key ec;
	};
} PrivateKey;

typedef struct {
	br_x509_certificate *items;
	int count;
	int capacity;
} CertArray;

typedef struct {
	int code;
	string name;
	string comment;
} BearSSLErrorInfo;
#endif

typedef struct {
	char  *data;
	size_t head;
	size_t size;
	size_t capacity;
} ByteQueue;

struct Connection {
	int fd;
	ByteQueue input;
	ByteQueue output;
	uint32_t ipaddr;
	int served_count;
	bool https;
	bool closing;
	bool keep_alive;
	uint64_t creation_time;
	uint64_t start_time;
#if HTTPS
	br_ssl_server_context https_context;
	char https_buffer[BR_SSL_BUFSIZE_BIDI];
#endif
};

///////////////////////////////////////////////////////////////////////////////////////////////
/// FORWARD DECLARATIONS                                                                    ///
///////////////////////////////////////////////////////////////////////////////////////////////

static bool url_parse2(string str, size_t *i, url_t *url);
static bool url_parse(string str, url_t *url);
static bool url_parse_ipv6(string str, uint16_t out[8]);
static bool url_parse_ipv4(string str, uint32_t *out);

static void     byte_queue_init(ByteQueue *q);
static void     byte_queue_free(ByteQueue *q);
static size_t   byte_queue_size(ByteQueue *q);
static bool     byte_queue_ensure_min_free_space(ByteQueue *q, size_t num);
static string   byte_queue_start_write(ByteQueue *q);
static void     byte_queue_end_write(ByteQueue *q, size_t num);
static string   byte_queue_start_read(ByteQueue *q);
static void     byte_queue_end_read(ByteQueue *q, size_t num);
static bool     byte_queue_write(ByteQueue *q, string src);
static void     byte_queue_patch(ByteQueue *q, size_t offset, char *src, size_t len);

#if HTTPS
static bool load_private_key_from_file(string file, PrivateKey *pkey);
static void free_private_key(PrivateKey *pkey);
static bool load_certs_from_file(string file, CertArray *array);
static void free_certs(CertArray *array);
static BearSSLErrorInfo get_bearssl_error_info(int code);
#endif

static bool set_blocking(int fd, bool blocking);
static bool read_from_socket(int fd, ByteQueue *queue);
static bool write_to_socket(int fd, ByteQueue *queue);
static int  create_listening_socket(string addr, int port);

///////////////////////////////////////////////////////////////////////////////////////////////
/// GLOBALS                                                                                 ///
///////////////////////////////////////////////////////////////////////////////////////////////

static volatile sig_atomic_t stop = 0;

static Connection *conns;
static int num_conns = 0;
static int max_conns = 0;

static struct pollfd *pollarray;

static uint64_t now;
static uint64_t real_now;

static int insecure_fd;
static int secure_fd;

static bool show_io;
static bool show_requests;
static bool access_log;
static int keep_alive_max_requests;
static int connection_timeout_sec;
static int closing_timeout_sec;
static int request_timeout_sec;
static int log_flush_timeout_sec;
static void (*respond_callback)(Request, ResponseBuilder*);

#if HTTPS
static PrivateKey pkey;
static CertArray certs;
#endif

///////////////////////////////////////////////////////////////////////////////////////////////
/// REQUEST PARSER                                                                          ///
///////////////////////////////////////////////////////////////////////////////////////////////

// TODO: Make sure every string in request is reasonaly long
static int parse_request_head(string str, Request *request)
{
	char  *src = str.data;
    size_t len = str.size;

	size_t cur;
	if (len > 2
		&& src[0] == 'G'
		&& src[1] == 'E'
		&& src[2] == 'T') {
		request->method = M_GET;
		cur = 3;
	} else if (len > 3
		&& src[0] == 'H'
		&& src[1] == 'E'
		&& src[2] == 'A'
		&& src[3] == 'D') {
		request->method = M_HEAD;
		cur = 4;
	} else if (len > 3
		&& src[0] == 'P'
		&& src[1] == 'O'
		&& src[2] == 'S'
		&& src[3] == 'T') {
		request->method = M_POST;
		cur = 4;
	} else if (len > 2
		&& src[0] == 'P'
		&& src[1] == 'U'
		&& src[2] == 'T') {
		request->method = M_PUT;
		cur = 3;
	} else if (len > 5
		&& src[0] == 'D'
		&& src[1] == 'E'
		&& src[2] == 'L'
		&& src[3] == 'E'
		&& src[4] == 'T'
		&& src[5] == 'E') {
		request->method = M_DELETE;
		cur = 6;
	} else if (len > 6
		&& src[0] == 'C'
		&& src[1] == 'O'
		&& src[2] == 'N'
		&& src[3] == 'N'
		&& src[4] == 'E'
		&& src[5] == 'C'
		&& src[6] == 'T') {
		request->method = M_CONNECT;
		cur = 7;
	} else if (len > 6
		&& src[0] == 'O'
		&& src[1] == 'P'
		&& src[2] == 'T'
		&& src[3] == 'I'
		&& src[4] == 'O'
		&& src[5] == 'N'
		&& src[6] == 'S') {
		request->method = M_OPTIONS;
		cur = 7;
	} else if (len > 4
		&& src[0] == 'T'
		&& src[1] == 'R'
		&& src[2] == 'A'
		&& src[3] == 'C'
		&& src[4] == 'E') {
		request->method = M_TRACE;
		cur = 5;
	} else if (len > 4
		&& src[0] == 'P'
		&& src[1] == 'A'
		&& src[2] == 'T'
		&& src[3] == 'C'
		&& src[4] == 'H') {
		request->method = M_PATCH;
		cur = 5;
	} else {
		return P_BADMETHOD;
	}

	if (cur == len || src[cur] != ' ')
		return P_INCOMPLETE;
	cur++;

	if (!url_parse2(str, &cur, &request->url))
		return P_BADURL;

	if (cur == len || src[cur] != ' ')
		return P_INCOMPLETE;
	cur++;

	if (cur+4 >= len
		|| src[cur+0] != 'H'
		|| src[cur+1] != 'T'
		|| src[cur+2] != 'T'
		|| src[cur+3] != 'P'
		|| src[cur+4] != '/'
		|| !is_digit(src[cur+5]))
		return P_BADVERSION;
	cur += 5;
	request->major = src[cur] - '0';
	cur++;

	if (cur < len && src[cur] == '.') {
		cur++;
		if (cur == len || !is_digit(src[cur]))
			return P_BADVERSION;
		request->minor = src[cur] - '0';
		cur++;
	} else {
		request->minor = 0;
	}

	if (cur+1 >= len
		|| src[cur+0] != '\r'
		|| src[cur+1] != '\n')
		return P_INCOMPLETE;
	cur += 2;

	request->nheaders = 0;
	while (cur+1 >= len
		|| src[cur+0] != '\r'
		|| src[cur+1] != '\n') {
		
		string name;
		string value;

		size_t start = cur;

		// TODO: More robust
		while (cur < len && src[cur] != ':')
			cur++;

		name.data = src + start;
		name.size = cur - start;

		if (cur == len)
			return P_BADHEADER;
		cur++; // :

		// TODO: More robust
		start = cur;
		while (cur < len && src[cur] != '\r')
			cur++;
		value.data = src + start;
		value.size = cur - start;

		cur++; // \r
		if (cur == len || src[cur] != '\n')
			return P_BADHEADER;
		cur++; // \n

		if (request->nheaders < MAX_HEADERS) {
			request->headers[request->nheaders].name = name;
			request->headers[request->nheaders].value = value;
			request->nheaders++;
		}
	}
	// cur here points to the \r in \r\n
	request->content = NULLSTR;
	return P_OK;
}

static bool find_header(Request *request, string name, string *value)
{
	for (int i = 0; i < request->nheaders; i++)
		if (string_match_case_insensitive(request->headers[i].name, name)) {
			*value = request->headers[i].value;
			return true;
		}
	return false;
}

static string get_status_string(int status)
{
	switch(status)
	{
		case 100: return LIT("Continue");
		case 101: return LIT("Switching Protocols");
		case 102: return LIT("Processing");

		case 200: return LIT("OK");
		case 201: return LIT("Created");
		case 202: return LIT("Accepted");
		case 203: return LIT("Non-Authoritative Information");
		case 204: return LIT("No Content");
		case 205: return LIT("Reset Content");
		case 206: return LIT("Partial Content");
		case 207: return LIT("Multi-Status");
		case 208: return LIT("Already Reported");

		case 300: return LIT("Multiple Choices");
		case 301: return LIT("Moved Permanently");
		case 302: return LIT("Found");
		case 303: return LIT("See Other");
		case 304: return LIT("Not Modified");
		case 305: return LIT("Use Proxy");
		case 306: return LIT("Switch Proxy");
		case 307: return LIT("Temporary Redirect");
		case 308: return LIT("Permanent Redirect");

		case 400: return LIT("Bad Request");
		case 401: return LIT("Unauthorized");
		case 402: return LIT("Payment Required");
		case 403: return LIT("Forbidden");
		case 404: return LIT("Not Found");
		case 405: return LIT("Method Not Allowed");
		case 406: return LIT("Not Acceptable");
		case 407: return LIT("Proxy Authentication Required");
		case 408: return LIT("Request Timeout");
		case 409: return LIT("Conflict");
		case 410: return LIT("Gone");
		case 411: return LIT("Length Required");
		case 412: return LIT("Precondition Failed");
		case 413: return LIT("Request Entity Too Large");
		case 414: return LIT("Request-URI Too Long");
		case 415: return LIT("Unsupported Media Type");
		case 416: return LIT("Requested Range Not Satisfiable");
		case 417: return LIT("Expectation Failed");
		case 418: return LIT("I'm a teapot");
		case 420: return LIT("Enhance your calm");
		case 422: return LIT("Unprocessable Entity");
		case 426: return LIT("Upgrade Required");
		case 429: return LIT("Too many requests");
		case 431: return LIT("Request Header Fields Too Large");
		case 449: return LIT("Retry With");
		case 451: return LIT("Unavailable For Legal Reasons");

		case 500: return LIT("Internal Server Error");
		case 501: return LIT("Not Implemented");
		case 502: return LIT("Bad Gateway");
		case 503: return LIT("Service Unavailable");
		case 504: return LIT("Gateway Timeout");
		case 505: return LIT("HTTP Version Not Supported");
		case 509: return LIT("Bandwidth Limit Exceeded");
	}
	return LIT("???");
}

static size_t parse_content_length(string s)
{
	char  *src = s.data;
	size_t len = s.size;

	size_t cur = 0;
	while (cur < len && is_space(src[cur]))
		cur++;

	if (cur == len || !is_digit(src[cur]))
		return -1;

	size_t x = 0;
	do {
		int d = src[cur] - '0';
		if (x > (SIZE_MAX - d) / 10)
			return -1;
		x = x * 10 + d;
		cur++;
	} while (cur < len && is_digit(src[cur]));

	while (cur < len && is_space(src[cur]))
		cur++;

	if (cur != len)
		return -1;

	return x;
}

static int find_and_parse_transfer_encoding(Request *request)
{
	string value;
	if (!find_header(request, LIT("Transfer-Encoding"), &value))
		return 0;

	int res = 0;
	char  *src = value.data;
	size_t len = value.size;
	size_t cur = 0;
	for (;;) {

		while (cur < len && (is_space(src[cur]) || src[cur] == ','))
			cur++;

		if (cur+6 < len
			&& src[cur+0] == 'c'
			&& src[cur+1] == 'h'
			&& src[cur+2] == 'u'
			&& src[cur+3] == 'n'
			&& src[cur+4] == 'k'
			&& src[cur+5] == 'e'
			&& src[cur+6] == 'd') {
			cur += 7;
			res |= T_CHUNKED;
		} else if (cur+7 < len
			&& src[cur+0] == 'c'
			&& src[cur+1] == 'o'
			&& src[cur+2] == 'm'
			&& src[cur+3] == 'p'
			&& src[cur+4] == 'r'
			&& src[cur+5] == 'e'
			&& src[cur+6] == 's'
			&& src[cur+7] == 's') {
			cur += 8;
			res |= T_COMPRESS;
		} else if (cur+6 < len
			&& src[cur+0] == 'd'
			&& src[cur+1] == 'e'
			&& src[cur+2] == 'f'
			&& src[cur+3] == 'l'
			&& src[cur+4] == 'a'
			&& src[cur+5] == 't'
			&& src[cur+6] == 'e') {
			cur += 7;
			res |= T_DEFLATE;
		} else if (cur+3 < len
			&& src[cur+0] == 'g'
			&& src[cur+1] == 'z'
			&& src[cur+2] == 'i'
			&& src[cur+3] == 'p') {
			cur += 4;
			res |= T_GZIP;
		} else {
			return -1;
		}
	}
	return res;
}

static void response_builder_init(ResponseBuilder *b, Connection *conn)
{
	b->state = R_STATUS;
	b->conn = conn;
	b->failed = false;
	b->keep_alive = true;
	b->content_length_offset = -1;
	b->content_offset = -1;
}

void status_line(ResponseBuilder *b, int status)
{
	if (b->state != R_STATUS)
		log_fatal(LIT("Appending status line twice\n"));
	if (!b->failed) {
		char buf[1<<10];
		string status_string = get_status_string(status);
		int num = snprintf(buf, sizeof(buf), "HTTP/1.1 %d %.*s\r\n", status, (int) status_string.size, status_string.data);
		assert(num > 0 && num < SIZEOF(buf));
		if (!byte_queue_write(&b->conn->output, (string) {buf, num}))
			b->failed = true;
	}
	b->state = R_HEADER;
}

void add_header(ResponseBuilder *b, string header)
{
	if (b->state != R_HEADER) {
		if (b->state == R_STATUS)
			log_fatal(LIT("Didn't write status line before headers\n"));
		else
			log_fatal(LIT("Can't add headers after content\n"));
	}
	if (b->failed)
		return;
	if (!byte_queue_write(&b->conn->output, header) ||
		!byte_queue_write(&b->conn->output, LIT("\r\n"))) {
		b->failed = true;
		return;
	}
}

void add_header_f(ResponseBuilder *b, const char *fmt, ...)
{
	char buffer[1<<10];

	va_list args;
	va_start(args, fmt);
	int num = vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	if (num < 0 || num >= (int) sizeof(buffer)) {
		b->failed = true;
		return;
	}

	buffer[num] = '\0';

	add_header(b, (string) {buffer, num});
}

static bool should_keep_alive(Connection *conn);

static void append_special_headers(ResponseBuilder *b)
{
	if (should_keep_alive(b->conn))
		add_header(b, LIT("Connection: Keep-Alive"));
	else {
		add_header(b, LIT("Connection: Close"));
		b->conn->closing = true;
		b->conn->start_time = now;
	}

	b->content_length_offset = byte_queue_size(&b->conn->output) + sizeof("Content-Length: ") - 1;
	add_header(b, LIT("Content-Length:          "));
	if (!byte_queue_write(&b->conn->output, LIT("\r\n")))
		b->failed = true;
	b->content_offset = byte_queue_size(&b->conn->output);
}

void append_content_s(ResponseBuilder *b, string str)
{
	if (b->state == R_HEADER) {
		append_special_headers(b);
		b->state = R_CONTENT;
	}
	if (b->state != R_CONTENT)
		log_fatal(LIT("Invalid response builder state\n"));

	if (b->failed)
		return;

	if (!byte_queue_write(&b->conn->output, str)) {
		b->failed = true;
		return;
	}
}

string append_content_start(ResponseBuilder *b, size_t cap)
{
	if (b->state == R_HEADER) {
		append_special_headers(b);
		b->state = R_CONTENT;
	}
	if (b->state != R_CONTENT)
		log_fatal(LIT("Invalid response builder state\n"));

	if (b->failed)
		return NULLSTR;

	if (!byte_queue_ensure_min_free_space(&b->conn->output, cap)) {
		b->failed = true;
		return NULLSTR;
	}
	return byte_queue_start_write(&b->conn->output);
}

void append_content_end(ResponseBuilder *b, size_t num)
{
	byte_queue_end_write(&b->conn->output, num);
}

void append_content_f(ResponseBuilder *b, const char *fmt, ...)
{
	size_t cap = 128;

	for (;;) {

		string dst = append_content_start(b, cap);
		if (dst.size == 0)
			return;

		va_list args;
		va_start(args, fmt);

		int num = vsnprintf(dst.data, dst.size, fmt, args);
		assert(num >= 0);

		va_end(args);

		if ((size_t) num < cap) {
			append_content_end(b, num);
			break;
		}

		cap *= 2;
	}
}

bool append_file(ResponseBuilder *b, string file)
{
	char copy[1<<12];
	if (file.size >= sizeof(copy))
		return false;
	memcpy(copy, file.data, file.size);
	copy[file.size] = '\0';

	struct stat buf;
	if (stat(copy, &buf))
		return false;

	if (!S_ISREG(buf.st_mode))
		return false;

	int fd;
	do
		fd = open(copy, O_RDONLY);
	while (fd < 0 && errno == EINTR);

	if (fd < 0)
		return true;

	string dst = append_content_start(b, (size_t) buf.st_size);
	if (dst.size == 0) {
		close(fd);
		return false;
	}
	assert(dst.size >= (size_t) buf.st_size);

	size_t copied = 0;
	while (copied < (size_t) buf.st_size) {
		int num = read(fd, dst.data + copied, (size_t) buf.st_size - copied);
		if (num <= 0) {
			if (num < 0)
				return false;
			break;
		}
		copied += num;
	}

	append_content_end(b, copied);
	close(fd);
	return true;
}

static void response_builder_complete(ResponseBuilder *b)
{
	if (b->state == R_COMPLETE)
		return;

	if (b->failed)
		return;

	if (b->state == R_HEADER) {
		append_special_headers(b);
		if (b->failed) return;
	} else {
		if (b->state != R_CONTENT)
			log_fatal(LIT("Invalid response builder state\n"));
	}
	size_t current_offset = byte_queue_size(&b->conn->output);
	size_t content_length = current_offset - b->content_offset;

	if (content_length > 1<<30) {
		// Content larger than 1GB
		b->failed = true;
		return;
	}
	int content_length_int = (int) content_length;

	char content_length_string[128];
	int n = snprintf(content_length_string, sizeof(content_length_string), "%d", content_length_int);
	assert(n >= 1 && n <= 9);

	byte_queue_patch(&b->conn->output, b->content_length_offset, content_length_string, n);

	b->state = R_COMPLETE;
}

static bool should_keep_alive(Connection *conn)
{
	// Don't keep alive if the peer doesn't want to
	if (conn->keep_alive == false)
		return false;

	// Don't keep alive if the request is too old
	if (now - conn->creation_time > (uint64_t) connection_timeout_sec * 1000)
		return false;

	// Don't keep alive if we served a lot of requests to this connection
	if (conn->served_count > keep_alive_max_requests)
		return false;

	// Don't keep alive if the server is more than 70% full
	if (num_conns > 0.7 * max_conns)
		return false;

	return true;
}

static uint64_t deadline_of(Connection *conn)
{
	return conn->start_time + (conn->closing ? closing_timeout_sec : request_timeout_sec) * 1000;
}

static bool respond_to_available_requests(Connection *conn)
{
	bool remove = false;

	int pipeline_count = 0;
	while (!remove) { /* Respond loop start */

		string src = byte_queue_start_read(&conn->input);

		// Look for the \r\n\r\n
		size_t j = 0;
		while (j+3 < src.size && (src.data[j] != '\r' || src.data[j+1] != '\n' || src.data[j+2] != '\r' || src.data[j+3] != '\n'))
			j++;
		if (j+3 >= src.size)
			break; // No \r\n\r\n

		size_t head_length = j+4;

		if (show_requests) {
			print_bytes(LIT(""), (string) {src.data, head_length});
			log_data(LIT("\n"));
		}

		// Found! We got the request head

		Request request;
		int res = parse_request_head((string) {src.data, head_length}, &request);

		if (access_log) {
			// Log access
			time_t real_now_in_secs = real_now / 1000;
			struct tm timeinfo;
			localtime_r(&real_now_in_secs, &timeinfo);
			char timebuf[128];
			size_t timelen = strftime(timebuf, sizeof(timebuf), "%Y/%m/%d %H:%M:%S", &timeinfo);
			if (timelen == 0)
				log_fatal(LIT("Couldn't format time for access log"));
			timebuf[timelen] = '\0';

			char ipbuf[INET_ADDRSTRLEN];
			const char *ipstr = inet_ntop(AF_INET, &conn->ipaddr, ipbuf, sizeof(ipbuf));
			if (ipstr == NULL)
				log_fatal(LIT("Couldn't format IP address for access log"));

			if (res == P_OK) {
				string user_agent;
				if (!find_header(&request, LIT("User-Agent"), &user_agent))
					user_agent = LIT("No User-Agent");
				else
					user_agent = trim(user_agent);
				log_format("%s - %s - %.*s - %.*s\n", timebuf, ipstr,
					(int) request.url.path.size, request.url.path.data,
					(int) user_agent.size, user_agent.data);
			} else {
				log_format("%s - %s - Bad request\n", timebuf, ipstr);
			}
		}

		if (res != P_OK) {
			// Invalid HTTP request
			byte_queue_write(&conn->output, LIT(
				"HTTP/1.1 400 Bad Request\r\n"
				"Connection: Close\r\n"
				"\r\n"));
			conn->closing = true;
			conn->start_time = now;
			break;
		}

		string content_length_header;
		size_t content_length;
		if (!find_header(&request, LIT("Content-Length"), &content_length_header)) {

			if (find_and_parse_transfer_encoding(&request) & T_CHUNKED) {
				// Content-Length missing
				byte_queue_write(&conn->output, LIT(
					"HTTP/1.1 411 Length Required\r\n"
					"Connection: Close\r\n"
					"\r\n"));
				conn->closing = true;
				conn->start_time = now;
				log_data(LIT("Content-Length missing\n"));
				break;
			} else
				content_length = 0;

		} else {
			content_length = parse_content_length(content_length_header);
			if (content_length == (size_t) -1) {
				// Invalid Content-Length
				byte_queue_write(&conn->output, LIT(
					"HTTP/1.1 400 Bad Request\r\n"
					"Connection: Close\r\n"
					"\r\n"));
				conn->closing = true;
				conn->start_time = now;
				log_data(LIT("Invalid Content-Length\n"));
				break;
			}
		}

		if (content_length > 1<<20) {
			// Request too large
			byte_queue_write(&conn->output, LIT(
				"HTTP/1.1 413 Content Too Large\r\n"
				"Connection: Close\r\n"
				"\r\n"));
			conn->closing = true;
			conn->start_time = now;
			log_data(LIT("Request too large\n"));
			break;
		}

		size_t request_length = head_length + content_length;
		if (src.size < request_length)
			break; // Request wasn't completely received yet
		request.content.data = src.data + head_length;
		request.content.size = content_length;

		// Reset the request timer
		conn->start_time = now;

		conn->keep_alive = true;
		string keep_alive_header;
		if (find_header(&request, LIT("Connection"), &keep_alive_header)) {
			if (string_match_case_insensitive(trim(keep_alive_header), LIT("Close")))
				conn->keep_alive = false;
		}
		// Respond
		ResponseBuilder builder;
		response_builder_init(&builder, conn);
		assert(respond_callback);
		respond_callback(request, &builder);
		response_builder_complete(&builder);
		if (builder.failed)
			remove = true;
		else {
			conn->served_count++;
			byte_queue_end_read(&conn->input, request_length);
			if (!conn->keep_alive) {
				conn->closing = true;
				conn->start_time = now;
			}

			pipeline_count++;
			if (pipeline_count == 10) {
				// TODO: We should send a response to the client instead of dropping it
				log_data(LIT("Pipeline limit reached\n"));
				remove = true;
				break;
			}
		}
	}

	return remove;
}

void build_poll_array(struct pollfd *pollarray, int *timeout)
{
	pollarray[0].fd = insecure_fd;
	pollarray[0].events = (num_conns < max_conns ? POLLIN : 0);
	pollarray[0].revents = 0;

#if HTTPS
	pollarray[1].fd = secure_fd;
	pollarray[1].events = (num_conns < max_conns ? POLLIN : 0);
	pollarray[1].revents = 0;
#else
	pollarray[1].fd = -1;
	pollarray[1].events = 0;
	pollarray[1].revents = 0;
#endif

	Connection *oldest = NULL;

	for (int i = 0; i < max_conns; i++) {

		Connection *conn = &conns[i];

		int events = 0;

		if (conn->fd == -1) {
			pollarray[i+2].fd = -1;
			pollarray[i+2].events = 0;
			pollarray[i+2].revents = 0;
			continue;
		}

		if (conn->https) {
#if HTTPS
			int state = br_ssl_engine_current_state(&conn->https_context.eng);
			if (state & BR_SSL_SENDREC) events |= POLLOUT;
			if (state & BR_SSL_RECVREC) events |= POLLIN;
#endif
		} else {
			if (byte_queue_size(&conn->output) > 0)
				events |= POLLOUT;
			if (!conn->closing)
				events |= POLLIN;
		}

		pollarray[i+2].fd = conn->fd;
		pollarray[i+2].events = events;
		pollarray[i+2].revents = 0;

		if (oldest == NULL || deadline_of(oldest) > deadline_of(conn)) oldest = conn;
	}

	if (oldest == NULL)
		*timeout = -1;
	else {
		if (deadline_of(oldest) < now)
			*timeout = 0;
		else
			*timeout = deadline_of(oldest) - now;
	}
}

void init_connection(Connection *conn, int fd, uint32_t ipaddr, bool https)
{
	byte_queue_init(&conn->input);
	byte_queue_init(&conn->output);
	conn->fd = fd;
	conn->ipaddr = ipaddr;
	conn->closing = false;
	conn->https = https;
	conn->served_count = 0;
	conn->creation_time = now;
	conn->start_time = now;
#if HTTPS
	if (https) {
		if (pkey.type == BR_KEYTYPE_RSA)
			br_ssl_server_init_full_rsa(&conn->https_context, certs.items, certs.count, &pkey.rsa);
		else {
			assert(pkey.type == BR_KEYTYPE_EC);
			unsigned issuer_key_type = BR_KEYTYPE_RSA; // Not sure if this or BR_KEYTYPE_EC
			br_ssl_server_init_full_ec(&conn->https_context, certs.items, certs.count, issuer_key_type, &pkey.ec);
		}
		br_ssl_engine_set_versions(&conn->https_context.eng, BR_TLS10, BR_TLS12);
		br_ssl_engine_set_buffer(&conn->https_context.eng, conn->https_buffer, sizeof(conn->https_buffer), 1);
		br_ssl_server_reset(&conn->https_context);
	}
#endif
}

void free_connection(Connection *conn)
{
	assert(conn->fd != -1);
	close(conn->fd);
	byte_queue_free(&conn->input);
	byte_queue_free(&conn->output);
	conn->fd = -1;
	conn->start_time = -1;
	conn->closing = false;
	conn->creation_time = 0;
}

bool accept_connection(int listen_fd, bool https)
{
	// Look for a connection structure
	int index = 0;
	while (index < max_conns && conns[index].fd != -1)
		index++;
	if (index == max_conns)
		return false; // Stop listening for incoming connections

	struct sockaddr_in accepted_addr;
	socklen_t accepted_addrlen = sizeof(accepted_addr);
	int accepted_fd = accept(listen_fd, (struct sockaddr*) &accepted_addr, &accepted_addrlen);
	if (accepted_fd < 0) {
		if (errno == EINTR)
			return true;
		if (errno == EAGAIN || errno == EWOULDBLOCK)
			return false;
		log_perror(LIT("accept"));
		return false;
	}
	uint32_t ipaddr = (uint32_t) accepted_addr.sin_addr.s_addr;

	if (!set_blocking(accepted_fd, false)) {
		log_perror(LIT("fcntl"));
		close(accepted_fd);
		return true;
	}

	Connection *conn = &conns[index];
	init_connection(conn, accepted_fd, ipaddr, https);

	assert(num_conns < max_conns);
	num_conns++;

	return true;
}

// Returns true iff the connection should be dropped
bool update_connection_http(Connection *conn, struct pollfd *polldata)
{
	// POLLIN
	if ((!conn->closing) && (polldata->revents & (POLLIN | POLLHUP | POLLERR))) {

		if (read_from_socket(conn->fd, &conn->input))
			return true;
		if (respond_to_available_requests(conn))
			return true;
	}

	// POLLOUT
	if (polldata->revents & POLLOUT) {
		if (write_to_socket(conn->fd, &conn->output))
			return true;
		if (byte_queue_size(&conn->output) == 0 && conn->closing)
			return true;
	}

	return false; // Don't close
}

#if HTTPS
// Returns true iff the connection should be dropped
bool update_connection_https(Connection *conn, struct pollfd *polldata)
{
	br_ssl_engine_context *cc = &conn->https_context.eng;
	bool flushed = false;

	for (;;) {

		int state = br_ssl_engine_current_state(cc);

		if (state & BR_SSL_CLOSED) {
			// Engine is finished, no more I/O (until next reset).
			int error = br_ssl_engine_last_error(cc);
			if (error != BR_ERR_OK) {
				BearSSLErrorInfo error_info = get_bearssl_error_info(error);
				log_format("SSL failure: %.*s (%.*s)\n",
					(int) error_info.name.size, error_info.name.data,
					(int) error_info.comment.size, error_info.comment.data);
			}

			return true;
		}

		if ((state & BR_SSL_SENDREC) && (polldata->revents & POLLOUT)) {
			// Engine has some bytes to send to the peer
			size_t len;
			unsigned char *buf = br_ssl_engine_sendrec_buf(cc, &len);
			size_t copied = 0;
			while (copied < len) {
				int num = send(conn->fd, buf + copied, len - copied, 0);
				if (num < 0) {
					if (errno == EINTR)
						continue;
					if (errno == EAGAIN || errno == EWOULDBLOCK) {
						polldata->revents &= ~POLLOUT;
						break;
					}
					log_perror(LIT("send"));
					return true;
				}
				// TODO: Handle num=0
				copied += (size_t) num;
			}
			br_ssl_engine_sendrec_ack(cc, copied);
			flushed = false;
		}

		if ((state & BR_SSL_RECVAPP)) {
			// Engine has obtained some application data from the 
			// peer, that should be read by the caller.
			size_t len;
			unsigned char *buf = br_ssl_engine_recvapp_buf(cc, &len);
			if (!byte_queue_ensure_min_free_space(&conn->input, len))
				return true;
			string dst = byte_queue_start_write(&conn->input);
			assert(dst.size >= len);
			memcpy(dst.data, buf, len);

			if (show_io)
				print_bytes(LIT("> "), (string) {dst.data, len});

			byte_queue_end_write(&conn->input, len);
			br_ssl_engine_recvapp_ack(cc, len);
			if (respond_to_available_requests(conn))
				return true;
			flushed = false;
		}

		if ((state & BR_SSL_RECVREC) && (polldata->revents & POLLIN)) {
			// Engine expects some bytes from the peer
			size_t len;
			unsigned char *buf = br_ssl_engine_recvrec_buf(cc, &len);
			size_t copied = 0;
			while (copied < len) {
				int num = recv(conn->fd, buf + copied, len - copied, 0);
				if (num < 0) {
					if (errno == EINTR)
						continue;
					if (errno == EAGAIN || errno == EWOULDBLOCK) {
						polldata->revents &= ~POLLIN;
						break;
					}
					log_perror(LIT("recv"));
					return true;
				}
				if (num == 0) {
					return true;
				}
				// TODO: Handle num=0
				copied += (size_t) num;
			}
			br_ssl_engine_recvrec_ack(cc, copied);
			flushed = false;
		}

		if ((state & BR_SSL_SENDAPP) && byte_queue_size(&conn->output) > 0) {
			// Engine may receive application data to send (or flush).
			size_t len;
			unsigned char *buf = br_ssl_engine_sendapp_buf(cc, &len);
			string src = byte_queue_start_read(&conn->output);
			size_t copy = MIN(len, src.size);
			memcpy(buf, src.data, copy);

			if (show_io)
				print_bytes(LIT("< "), (string) {src.data, copy});

			byte_queue_end_read(&conn->output, copy);
			br_ssl_engine_sendapp_ack(cc, copy);
			br_ssl_engine_flush(cc, 0); // TODO: Is this the right time to call it?
			flushed = false;
		}

		if (flushed) break;
		br_ssl_engine_flush(cc, 0);
		flushed = true;
	}

	int state = br_ssl_engine_current_state(cc);
	if ((state & BR_SSL_SENDREC) == 0 && conn->closing && byte_queue_size(&conn->output) == 0)
		return true;

	return false; // Don't remove
}
#endif

bool update_connection(Connection *conn, struct pollfd *polldata)
{
	bool ok;

#if HTTPS
	if (conn->https)
		ok = update_connection_https(conn, polldata);
	else
#endif
		ok = update_connection_http(conn, polldata);

	return ok;
}

void http_stop(void)
{
	stop = 1;
}

HTTPConfig http_default_config(void)
{
	return (HTTPConfig) {
		.http_port = 8080,
		.http_addr = LIT("127.0.0.1"),
		.https_port = 8081,
		.https_addr = LIT("127.0.0.1"),
		.cert_file = NULLSTR,
		.privkey_file = NULLSTR,
		.access_log = true,
		.show_io = false,
		.show_requests = false,
		.max_connections = 512,
		.keep_alive_max_requests = 1000,
		.connection_timeout_sec = 60,
		.closing_timeout_sec = 2,
		.request_timeout_sec = 5,
		.log_flush_timeout_sec = 3,
		.respond = NULL,
	};
}

void http_init(HTTPConfig config)
{
	show_io                 = config.show_io;
	show_requests           = config.show_requests;
	access_log              = config.access_log;
	keep_alive_max_requests = config.keep_alive_max_requests;
	connection_timeout_sec  = config.connection_timeout_sec;
	closing_timeout_sec     = config.closing_timeout_sec;
	request_timeout_sec     = config.request_timeout_sec;
	log_flush_timeout_sec   = config.log_flush_timeout_sec;
	respond_callback        = config.respond;

	{
		struct rlimit file_desc_limit;
		if (getrlimit(RLIMIT_NOFILE, &file_desc_limit))
			log_fatal(LIT("Couldn't query RLIMIT_NOFILE\n"));

		max_conns = config.max_connections;
		num_conns = 0;
		if ((size_t) max_conns+2 > file_desc_limit.rlim_cur)
			log_fatal(LIT("max_connections+2 is higher than the rlimit\n"));

		conns = mymalloc(max_conns * sizeof(Connection));
		if (conns == NULL)
			log_fatal(LIT("Out of memory"));

		for (int i = 0; i < max_conns; i++) {
			conns[i].fd = -1;
			byte_queue_init(&conns[i].input);
			byte_queue_init(&conns[i].output);
		}

		pollarray = mymalloc((max_conns+2) * sizeof(struct pollfd));
		if (pollarray == NULL)
			log_fatal(LIT("Out of memory"));

		DEBUG("Connection array created\n");
	}

	// Create plain text listener
	{
		string   http_addr = config.http_addr;
		uint32_t http_port = config.http_port;
		insecure_fd = create_listening_socket(http_addr, http_port);
		if (insecure_fd < 0)
			log_fatal(LIT("Couldn't bind\n"));
		log_format("Listening on %.*s:%d\n", (int) http_addr.size, http_addr.data, http_port);
		DEBUG("HTTP started\n");
	}

	// Create secure listener
	{
		secure_fd = -1;
#if HTTPS
		string   https_addr = config.https_addr;
		uint32_t https_port = config.https_port;
		string   https_cert_file = config.cert_file;
		string   https_key_file  = config.privkey_file;

		secure_fd = create_listening_socket(https_addr, https_port);
		if (secure_fd < 0)
			log_fatal(LIT("Couldn't bind\n"));
		log_format("Listening on %.*s:%d\n", (int) https_addr.size, https_addr.data, https_port);

		// Load certificate
		if (!load_certs_from_file(https_cert_file, &certs))
			log_fatal(LIT("Couldn't load certificates\n"));
		DEBUG("Certificates loaded\n");

		// Load private key
		if (!load_private_key_from_file(https_key_file, &pkey))
			log_fatal(LIT("Couldn't load private key\n"));
		DEBUG("Private key loaded\n");

		DEBUG("HTTPS started\n");
#endif
	}
}

void http_loop(void)
{
	uint64_t last_log_time = 0;
	while (!stop) {

		int timeout;
		build_poll_array(pollarray, &timeout);

		if (!log_empty()) {
			int log_timeout = (last_log_time + log_flush_timeout_sec * 1000) - now;
			if (timeout < 0)
				timeout = log_timeout;
			else
				timeout = MIN(log_timeout, timeout);
		}

		int ret = poll(pollarray, max_conns+2, timeout);
		if (ret < 0) {
			if (errno == EINTR)
				break; // TODO: Should this be continue?
			log_perror(LIT("poll"));
			exit(-1);
		}

		now = get_monotonic_time_ms();
		real_now = get_real_time_ms();

		if (pollarray[0].revents & POLLIN)
			while (accept_connection(insecure_fd, false));

#if HTTPS
		if (pollarray[1].revents & POLLIN)
			while (accept_connection(secure_fd, true));
#endif

		for (int i = 0; i < max_conns; i++) {

			Connection *conn = &conns[i];
			if (conn->fd == -1)
				continue;

			struct pollfd *polldata = &pollarray[i+2];
			bool remove = false;

			if (now >= deadline_of(conn)) {

				assert(!remove);

				if (conn->closing) {
					// Closing timeout
					remove = true;
					log_data(LIT("Closing timeout\n"));
				} else {
					// Request timeout
					if (byte_queue_size(&conn->input) == 0) {
						// Connection was idle, so just close it
						remove = true;
						log_data(LIT("Idle connection timeout\n"));
					} else {
						byte_queue_write(&conn->output, LIT(
							"HTTP/1.1 408 Request Timeout\r\n"
							"Connection: Close\r\n"
							"\r\n"));
						conn->closing = true;
						conn->start_time = now;
						log_data(LIT("Request timeout\n"));
					}
				}
			}

			if (!remove)
				remove = update_connection(conn, polldata);

			if (remove) {
				free_connection(conn);
				num_conns--;
			}
		}

		if (now - last_log_time > (uint64_t) log_flush_timeout_sec * 1000) {
			log_flush();
			last_log_time = now;
		}

	} /* main loop end */
}

void http_free(void)
{
	{
#if HTTPS
		free_private_key(&pkey);
		free_certs(&certs);
		close(secure_fd);
#endif

		close(insecure_fd);

		for (int i = 0; i < max_conns; i++) {
			if (conns[i].fd != -1) {
				close(conns[i].fd);
				byte_queue_free(&conns[i].input);
				byte_queue_free(&conns[i].output);
			}
		}
		myfree(conns, max_conns * sizeof(Connection));
		myfree(pollarray, (max_conns+2) * sizeof(struct pollfd));
	}
}

#define PATH_SEP '/'

int split_path_components(string src, string *stack, int limit, bool allow_ddots)
{
	size_t cur = 0;

	// Skip the first slash
	if (cur < src.size && src.data[cur] == PATH_SEP)
		cur++;

	int depth = 0;
	while (cur < src.size) {

		if (depth == limit)
			return -1;

		size_t start = cur;
		while (cur < src.size && (is_pcomp(src.data[cur]) || (allow_ddots && src.data[cur] == ':')))
			cur++;

		string comp = substr(src, start, cur);

		if (comp.size == 0)
			return -1; // We consider paths with empty components invalid

		if (streq(comp, LIT(".."))) {
			if (depth == 0)
				return -1;
			depth--;
		} else {
			if (!streq(comp, LIT(".")))
				stack[depth++] = comp;
		}

		if (cur == src.size)
			break;

		if (src.data[cur] != PATH_SEP)
			return -1;
		cur++;
	}

	return depth;
}

/*
 * Sanitize a path string removing ./ and ../
 * components. The final path has an initial
 * / but not final.
 */
size_t sanitize_path(string src, char *mem, size_t max)
{
	#define MAX_COMPS 64

	string stack[MAX_COMPS];
	int depth;

	depth = split_path_components(src, stack, MAX_COMPS, false);
	if (depth < 0)
		return -1;

	/*
	 * Count how many output bytes are required
	 */
	size_t req = depth;
	for (int i = 0; i < depth; i++)
		req += stack[i].size;
	if (req >= max)
		return -1; // Buffer too small

	/*
	 * Copy the sanitized path into the output
	 * buffer.
	 */
	size_t n = 0;
	for (int i = 0; i < depth; i++) {
		mem[n++] = PATH_SEP;
		memcpy(mem + n, stack[i].data, stack[i].size);
		n += stack[i].size;
	}
	mem[n] = '\0';
	return n;
}

int match_path_format(string path, char *fmt, ...)
{
	#define LIMIT 32
	string p_stack[LIMIT];
	string f_stack[LIMIT];
	int p_depth;
	int f_depth;

	p_depth = split_path_components(path,     p_stack, LIMIT, false);
	f_depth = split_path_components(STR(fmt), f_stack, LIMIT, true);

	if (p_depth < 0 || f_depth < 0)
		return -1; // Error

	if (p_depth != f_depth)
		return 1; // No match

	va_list args;
	va_start(args, fmt);

	for (int i = 0; i < f_depth; i++) {

		assert(f_stack[i].size > 0);
		assert(p_stack[i].size > 0);

		if (f_stack[i].data[0] == ':') {
			if (f_stack[i].size != 2) {
				va_end(args);
				return -1; // Invalid format
			}
			switch (f_stack[i].data[1]) {
				
				case 's':
				{
					string *sl = va_arg(args, string*);
					*sl = p_stack[i];
				}
				break;
				
				case 'n':
				{
					uint32_t n = 0;
					size_t cur = 0;
					while (cur < p_stack[i].size && is_digit(p_stack[i].data[cur])) {
						int d = p_stack[i].data[cur] - '0';
						if (n > (UINT32_MAX - d) / 10) {
							va_end(args);
							return -1; // Overflow
						}
						n = n * 10 + d;
						cur++;
					}
					if (cur != p_stack[i].size) {
						va_end(args);
						return -1; // Component isn't a number
					}
					uint32_t *p = va_arg(args, uint32_t*);
					*p = n;
				}
				break;

				default:
				va_end(args);
				return -1; // Invalid formt
			}
		} else {
			if (f_stack[i].size != p_stack[i].size) {
				va_end(args);
				return 1; // No match
			}
			if (memcmp(f_stack[i].data, p_stack[i].data, f_stack[i].size)) {
				va_end(args);
				return 1; // No match
			}
		}
	}

	va_end(args);
	return 0; // Match
}

struct {
	string mime;
	string ext;
} mime_table[] = {
	{LIT("text/javascript"),  LIT(".js")},
	{LIT("text/javascript"),  LIT(".javascript")},
	{LIT("text/html"),        LIT(".html")},
	{LIT("text/html"),        LIT(".htm")},
	{LIT("image/gif"),        LIT(".gif")},
	{LIT("image/jpeg"),       LIT(".jpg")},
	{LIT("image/jpeg"),       LIT(".jpeg")},
	{LIT("image/svg+xml"),    LIT(".svg")},
	{LIT("video/mp4"),        LIT(".mp4")},
	{LIT("video/mpeg"),       LIT(".mpeg")},
	{LIT("font/ttf"),         LIT(".ttf")},
	{LIT("font/woff"),        LIT(".woff")},
	{LIT("font/woff2"),       LIT(".woff2")},
	{LIT("text/plain"),       LIT(".txt")},
	{LIT("audio/wav"),        LIT(".wav")},
	{LIT("application/x-7z-compressed"), LIT(".7z")},
	{LIT("application/zip"),  LIT(".zip")},
	{LIT("application/xml"),  LIT(".xml")},
	{LIT("application/json"), LIT(".json")},
	{NULLSTR, NULLSTR},
};

string mimetype_from_filename(string name)
{
	for (size_t i = 0; i < COUNTOF(mime_table); i++)
		if (endswith(mime_table[i].ext, name))
			return mime_table[i].mime;
	return NULLSTR;
}

bool serve_file_or_dir(ResponseBuilder *b, string prefix, string docroot,
	string reqpath, string mime, bool enable_dir_listing)
{
	// Sanitize the request path
	char pathmem[1<<10];
	string path;
	{
		size_t len = sanitize_path(reqpath, pathmem, sizeof(pathmem));
		if (len >= sizeof(pathmem)) {
			status_line(b, 500);
			return true;
		}
		path = (string) {pathmem, len};
		path.data[path.size] = '\0';
	}

	// Only handle this request if the prefix matches
	if (!startswith(prefix, path))
		return false;

	// Remove the matched prefix and put the docroot in its place
	{
		if (docroot.size + path.size - prefix.size >= sizeof(pathmem)) {
			status_line(b, 500);
			return true;
		}
		memmove(pathmem + docroot.size, pathmem + prefix.size, path.size - prefix.size);
		memcpy(pathmem, docroot.data, docroot.size);
		path.size -= prefix.size;
		path.size += docroot.size;
		path.data[path.size] = '\0';
	}

	struct stat buf;
	if (stat(path.data, &buf)) {
		if (errno == ENOENT)
			return false;
		status_line(b, 500);
		return true;
	}

	if (S_ISREG(buf.st_mode)) {

		int fd;
		do
			fd = open(path.data, O_RDONLY);
		while (fd < 0 && errno == EINTR);

		if (fd < 0) {
			status_line(b, 500);
			close(fd);
			return true;
		}

		status_line(b, 200);

		if (mime.size == 0) mime = mimetype_from_filename(path);
		if (mime.size > 0) add_header_f(b, "Content-Type: %.*s", (int) mime.size, mime.data);

		string dst = append_content_start(b, (size_t) buf.st_size);
		if (dst.size == 0) {
			status_line(b, 500);
			close(fd);
			return true;
		}
		assert(dst.size >= (size_t) buf.st_size);

		size_t copied = 0;
		while (copied < (size_t) buf.st_size) {
			int num = read(fd, dst.data + copied, (size_t) buf.st_size - copied);
			if (num <= 0) {
				if (num < 0)
					log_format("Failed reading from '%.*s'\n", (int) path.size, path.data);
				break;
			}
			copied += num;
		}

		append_content_end(b, copied);
		close(fd);
		return true;
	}

	if (enable_dir_listing && S_ISDIR(buf.st_mode)) {

		DIR *d = opendir(path.data);
		if (d == NULL) {
			status_line(b, 500);
			return true;
		}

		status_line(b, 200);
		append_content_s(b, LIT(
			"<html>\n"
			"    <head>\n"
			"    </head>\n"
			"    <body>\n"
			"        <ul>\n"
			"            <li><a href=\"\">(parent)</a></li>")); // TODO: Add links

		struct dirent *dir;
		while ((dir = readdir(d))) {
			if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
				continue;
			append_content_f(b, "<li><a href=\"\">%s</a></li>\n", dir->d_name); // TODO: Add links
		}

		append_content_s(b, LIT(
			"        </ul>\n"
			"    </body>\n"
			"</html>\n"));
		closedir(d);
		return true;
	}

	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// BYTE QUEUE                                                                              ///
///////////////////////////////////////////////////////////////////////////////////////////////

void byte_queue_init(ByteQueue *q)
{
	q->data = NULL;
	q->head = 0;
	q->size = 0;
	q->capacity = 0;
}

void byte_queue_free(ByteQueue *q)
{
	myfree(q->data, q->capacity);
	byte_queue_init(q);
}

bool byte_queue_ensure_min_free_space(ByteQueue *q, size_t num)
{
	size_t total_free_space = q->capacity - q->size;
	size_t free_space_after_data = q->capacity - q->size - q->head;

	if (free_space_after_data < num) {
		if (total_free_space < num) {
			// Resize required

			size_t capacity = MAX(2 * q->capacity, q->size + num);

			char *data = mymalloc(capacity);
			if (!data) return false;

			if (q->size > 0)
				memcpy(data, q->data + q->head, q->size);

			myfree(q->data, q->capacity);

			q->data = data;
			q->head = 0;
			q->capacity = capacity;

		} else {
			// Move required
			memmove(q->data, q->data + q->head, q->size);
			q->head = 0;
		}
	}

	return true;
}

string byte_queue_start_write(ByteQueue *q)
{
	if (q->data == NULL)
		return NULLSTR;
	return (string) {
		.data = q->data     + (q->head + q->size),
		.size = q->capacity - (q->head + q->size),
	};
}

void byte_queue_end_write(ByteQueue *q, size_t num)
{
	q->size += num;
}

string byte_queue_start_read(ByteQueue *q)
{
	if (q->data == NULL)
		return NULLSTR;
	return (string) {
		.data = q->data + q->head,
		.size = q->size,
	};
}

size_t byte_queue_size(ByteQueue *q)
{
	return q->size;
}

void byte_queue_end_read(ByteQueue *q, size_t num)
{
	q->head += num;
	q->size -= num;
}

bool byte_queue_write(ByteQueue *q, string src)
{
	if (!byte_queue_ensure_min_free_space(q, src.size))
		return false;
	string dst = byte_queue_start_write(q);
	assert(dst.size >= src.size);
	memcpy(dst.data, src.data, src.size);
	byte_queue_end_write(q, src.size);
	return true;
}

void byte_queue_patch(ByteQueue *q, size_t offset, char *src, size_t len)
{
	// TODO: Safety checks
	memcpy(q->data + q->head + offset, src, len);
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// SOCKET UTILITIES                                                                        ///
///////////////////////////////////////////////////////////////////////////////////////////////

void print_bytes(string prefix, string str)
{
	char  *src = str.data;
	size_t len = str.size;

	bool line_start = true;

	size_t i = 0;
	while (i < len) {

		size_t substr_offset = i;
		while (i < len && src[i] != '\r' && src[i] != '\n')
			i++;
		size_t substr_length = i - substr_offset;

		if (line_start) {
			log_data(prefix);
			line_start = false;
		}

		log_data((string) { src + substr_offset, substr_length });

		if (i < len) {
			if (src[i] == '\r')
				log_data(LIT("\\r"));
			else {
				log_data(LIT("\\n\n"));
				line_start = true;
			}
			i++;
		}
	}

	if (!line_start)
		log_data(LIT("\n"));
}

bool read_from_socket(int fd, ByteQueue *queue)
{
	bool remove = false;

	for (;;) {

		if (!byte_queue_ensure_min_free_space(queue, 512)) {
			remove = true;
			break;
		}

		string dst = byte_queue_start_write(queue);

		int num = recv(fd, dst.data, dst.size, 0);
		if (num < 0) {
			if (errno == EINTR)
				continue;
			if (errno == EAGAIN || errno == EWOULDBLOCK)
				break;
			log_perror(LIT("recv"));
			remove = true;
			break;
		}
		if (num == 0) {
			remove = true;
			break;
		}

		if (show_io)
			print_bytes(LIT("> "), (string) {dst.data, num});

		byte_queue_end_write(queue, (size_t) num);

		// Input buffer can't go over 20Mb
		if (byte_queue_size(queue) > (size_t) INPUT_BUFFER_LIMIT_MB * 1024 * 1024) {
			remove = true;
			break;
		}
	}

	return remove;
}

bool write_to_socket(int fd, ByteQueue *queue)
{
	bool remove = false;
	for (;;) {

		string src = byte_queue_start_read(queue);
		if (src.size == 0) break;

		int num = send(fd, src.data, src.size, 0);
		if (num < 0) {
			if (errno == EINTR)
				continue;
			if (errno == EAGAIN || errno == EWOULDBLOCK)
				break;
			log_perror(LIT("send"));
			remove = true;
			break;
		}

		if (show_io)
			print_bytes(LIT("< "), (string) {src.data, num});

		byte_queue_end_read(queue, (size_t) num);
	}

	return remove;
}

int create_listening_socket(string addr, int port)
{
	int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (listen_fd < 0) {
		log_perror(LIT("socket"));
		return -1;
	}

	if (!set_blocking(listen_fd, false)) {
		log_perror(LIT("fcntl"));
		return -1;
	}

	int one = 1;
	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, (char*) &one, sizeof(one));

	struct in_addr addr2;
	if (addr.size == 0)
		addr2.s_addr = htonl(INADDR_ANY);
	else {
		assert(addr.data);
		char addr_copy[INET_ADDRSTRLEN];
		if (addr.size >= SIZEOF(addr_copy))
			log_fatal(LIT("Invalid IP address (too long)\n"));
		memcpy(addr_copy, addr.data, addr.size);
		addr_copy[addr.size] = '\0';
		int res = inet_pton(AF_INET, addr_copy, &addr2);
		if (res == 0) log_fatal(LIT("Invalid IP address (too long)\n"));
		if (res != 1) log_fatal(LIT("Could not parse IP address (internal error)\n"));
	}

	struct sockaddr_in addr3;
	addr3.sin_family = AF_INET;
	addr3.sin_port = htons(port);
	addr3.sin_addr = addr2;
	if (bind(listen_fd, (struct sockaddr*) &addr3, sizeof(addr3))) {
		log_perror(LIT("bind"));
		return -1;
	}

	if (listen(listen_fd, 32)) {
		log_perror(LIT("listen"));
		return -1;
	}

	return listen_fd;
}

bool set_blocking(int fd, bool blocking)
{
	int flags = fcntl(fd, F_GETFL, 0);

	if (flags == -1)
		return false;

	if (blocking)
		flags &= ~O_NONBLOCK;
	else
		flags |= O_NONBLOCK;

	if (fcntl(fd, F_SETFL, flags))
		return false;

	return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// URI PARSER                                                                              ///
///////////////////////////////////////////////////////////////////////////////////////////////

static bool is_lower_alpha(char c)
{
	return c >= 'a' && c <= 'z';
}

static bool is_upper_alpha(char c)
{
	return c >= 'A' && c <= 'Z';
}

static bool is_hex_digit(char c)
{
	return is_digit(c) 
		|| (c >= 'a' && c <= 'f')
		|| (c >= 'A' && c <= 'F');
}

static bool is_unreserved(char c)
{
	return is_alpha(c) || is_digit(c) 
		|| c == '-' || c == '.' 
		|| c == '_' || c == '~';
}

static bool is_subdelim(char c)
{
	return c == '!' || c == '$' 
		|| c == '&' || c == '\'' 
		|| c == '(' || c == ')' 
		|| c == '*' || c == '+' 
		|| c == ',' || c == ';' 
		|| c == '=';
}

static bool is_pchar(char c)
{
	return is_unreserved(c) 
		|| is_subdelim(c) 
		|| c == ':' || c == '@';
}

static bool is_schema_first(char c)
{
	return is_alpha(c);
}

static bool is_schema(char c)
{
	return is_alpha(c) 
		|| is_digit(c) 
		|| c == '+' 
		|| c == '-'
		|| c == '.';
}

// Symbol: parse_schema 
//   Parse the schema of an url, if there is one.
//
// Arguments:
//          (in) src: The source string.
//
//               len: The number of bytes pointed by [src].
//
//      (in/out)   i: Offset from where the parsing should
//                    start. When the function returns, its
//                    value is incremented by the number of
//                    parsed bytes (therefore pointing to the
//                    first non-parsed byte). If the url in
//                    the source has no schema, it's value
//                    is left unchanged.
//
//      (out) schema: Non zero-terminated string containing
//                    the parsed schema. If the url didn't
//                    have a schema, it's set to NULL.
//
//  (out) schema_len: Length of the parsed schema, or 0 if
//                    there wasn't one.
//
// Returns:
//   - [i] is incremented by the number of parsed bytes.
//
//   - [schema] points to the schema string (or NULL if
//     there wasn't one).
//
//   - [schema_len] is the length of the string pointed
//     by [schema], or 0 if there was no schema.
//
// Notes:
//   - This function can never fail.
//
static void parse_schema(string str, size_t *i, string *schema)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t peek = *i; // Local cursor

	bool no_schema;
	size_t schema_off;
	size_t schema_end;

	// If there is a schema, set [no_schema] to
	// [false], [schema_off] to the start of
	// the schema substring (relative to [src])
	// and [schema_end] to its end.
	{
		if (peek == len || !is_schema_first(src[peek]))
			// The first character can't be the start
			// of a schema.
			no_schema = true;
		else {
			// The current character is a valid start
			// for a schema. We'll assume it is until
			// proven otherwise.

			// Keep track of the current posizion, then
			// consume all characters that compose the
			// schema.
			schema_off = peek;
			do
				peek++;
			while (peek < len && is_schema(src[peek]));
			schema_end = peek;

			// If the character following the schema
			// isn't a ':', it wasn't a schema after
			// all.
			if (peek == len || src[peek] != ':')
				no_schema = true;
			else {
				no_schema = false;
				peek++; // Skip the ':'
			}
		}
	}

	// Update the output parameters.
	if (no_schema)
		*schema = NULLSTR;
		// Don't unpdate [i]
	else {
		*schema = substr(str, schema_off, schema_end);
		*i = peek; // Commit changes.
	}
}

static bool is_username(char c)
{
	return is_unreserved(c) || is_subdelim(c);
}

static bool is_username_first(char c)
{
	return is_username(c);
}

static bool is_password(char c)
{
	return is_username(c);
}

static bool is_password_first(char c)
{
	return is_password(c);
}

// Symbol: parse_userinfo
//   Parse the userinfo component of an URL,
//   if there is one.
//
//   The userinfo component is a subcomponent
//   of the authority. It contains a username
//   and, optionally, a password:
//
//     http://username@example.com
//     http://username:password@example.com
//
//   This functions parses the portion that
//   goes from the byte following "//" to 
//   the '@'.
//
// Arguments:
//         (in) src: The source string.
//
//              len: The number of bytes pointed by [src]
//
//       (in/out) i: Offset from where the parsing should
//                   start. When the function returns, its
//                   value is incremented by the number of
//                   parsed bytes (therefore pointing to the
//                   first non-parsed byte). If the url in
//                   the source has no userinfo, it's value
//                   is left unchanged.
//
//   (out) userinfo: The result of the parsing. 
// 
// Returns:
//   - [i] is incremented by the number of parsed bytes.
//
//   - [userinfo] contains the parsed username and
//     password. These strings are not zero-terminated.
//     If there was no userinfo component, then
//     [userinfo.username] and [userinfo.password] are
//     NULL and [userinfo.username_len] and
//     [userinfo.password_len] are 0. If the username
//     is specified but the password isn't, then only
//     [userinfo.password] is NULL and 
//     [userinfo.password_len] is 0.
//
// Notes:
//   - This function can never fail.
//
static void
parse_userinfo(string str, size_t *i, url_userinfo *userinfo)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t peek = *i; // Local cursor

	bool no_username;
	bool no_password;
	size_t username_off;
	size_t username_end;
	size_t password_off;
	size_t password_len;

	// If the userinfo subcomponent is present,
	// set [no_username] to false, [username_off]
	// to the offset of the username relative to 
	// [src] and [username_end] to its end. 
	// If the password was also specified, do the
	// same.  
	{
		if (peek == len || !is_username_first(src[peek])) {
			// The first character can't be the first
			// of an username, therefore there's no
			// userinfo subcomponent.
			no_username = true;
			no_password = true;
		} else {

			// The first character is a valid start
			// for an username, therefore we'll assume
			// that there's a userinfo subcomponent
			// until proven otherwise.

			// Scan the username while keeping track
			// of it's offset and length.
			username_off = peek;
			do
				peek++;
			while (peek < len && is_username(src[peek]));
			username_end = peek;
			
			// If the username is followed by a ':' and
			// a valid password character, we also expect 
			// a password.
			if (peek+1 < len && src[peek] == ':' && is_password_first(src[peek+1])) {
				
				peek++; // Skip the ':'
				
				// Scan the password while keeping track
				// of it's offset and length.
				password_off = peek;
				do
					peek++;
				while (peek < len && is_password(src[peek]));
				password_len = peek;

				if (peek == len || src[peek] != '@') {
					// If the password isn't followed by a '@',
					// then this wasn't a userinfo subcomponent
					// after all.
					no_username = true;
					no_password = true;
				} else {
					// All done. 
					no_username = false;
					no_password = false;
					peek++; // Skip the '@'
				}

			} else if (peek == len || src[peek] != '@') {
				// Since no password was specified, if the 
				// username isn't followed by a '@', then 
				// this wasn't a userinfo subcomponent after 
				// all.
				no_username = true;
				no_password = true;
			} else {
				// All done.
				no_username = false;
				no_password = true;
				peek++; // Skip the '@'
			}
		}
	}

	// Update the output parameters.
	if (no_username) {
		assert(no_password);
		userinfo->username = NULLSTR;
		userinfo->password = NULLSTR;
		// Don't update [i]
	} else {		
		userinfo->username = substr(str, username_off, username_end);
		userinfo->password = no_password ? NULLSTR : substr(str, password_off, password_len);
		*i = peek; // Commit changes.
	}
}

static bool
parse_ipv4_byte(string str, size_t *i, uint8_t *out)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t peek = *i;

	// If the cursor refers to a digit, then
	// there's a byte to parse.
	bool start_with_digit = (peek < len && is_digit(src[peek]));

	if (start_with_digit) {

		uint8_t byte = 0;

		// TODO: Don't allow arbitrary sequence of
		//       0s at the start.
		do {
			int d = src[peek] - '0';
			if (byte > (UINT8_MAX - d) / 10)
				break; // Overflow! This digit isn't part of the byte.
			byte = byte * 10 + d;
			peek++;
		} while (peek < len && is_digit(src[peek]));

		*i = peek;
		*out = byte;
	}

	return start_with_digit;
}

static uint32_t pack(uint8_t *bytes)
{
	return
		((uint32_t) bytes[0] << 24) |
		((uint32_t) bytes[1] << 16) |
		((uint32_t) bytes[2] <<  8) |
		((uint32_t) bytes[3] <<  0);
}

static bool parse_ipv4(string str, size_t *i, uint32_t *ipv4)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t peek = *i;
	uint8_t unpacked_ipv4[4];

	for (int u = 0; u < 3; u++) {

		if (!parse_ipv4_byte(str, &peek, unpacked_ipv4 + u))
			return false;

		if (peek == len || src[peek] != '.')
			return false;

		peek++; // Skip the dot
	}
	if (!parse_ipv4_byte(str, &peek, unpacked_ipv4 + 3))
		return false;

	*ipv4 = pack(unpacked_ipv4);
	*i = peek;
	return true;
}

static int hex_digit_to_int(char c)
{
	assert(is_hex_digit(c));

	if (is_lower_alpha(c))
		return c - 'a' + 10;

	if (is_upper_alpha(c))
		return c - 'A' + 10;

	assert(is_digit(c));
	return c - '0';
}

static bool parse_ipv6_word(string str, size_t *i, uint16_t *out)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t peek = *i;

	// If there's at least one hex digit at the
	// current position, then we can parse a word
	// for sure.
	bool start_with_hex_digit = (peek < len && is_hex_digit(src[peek]));

	if (start_with_hex_digit) {

		uint16_t word = 0;

		// TODO: Don't allow arbitrary sequence of
		//       0s at the start.
		do {
			
			int d = hex_digit_to_int(src[peek]);
			if (word > (UINT16_MAX - d) / 16)
				break; // Overflow! This hex digit isn't part of the word.
			
			word = word * 16 + d;
			
			peek++;

		} while (peek < len && is_hex_digit(src[peek]));

		*i = peek;
		*out = word;
	}

	return start_with_hex_digit;
}

static bool parse_ipv6(string str, size_t *i, uint16_t ipv6[static 8])
{
	char  *src = str.data;
	size_t len = str.size;

	size_t k = *i;

	uint16_t tail[8];
	size_t head_count = 0;
	size_t tail_count = 0;

	if (k+1 < len && src[k] == ':' && src[k+1] == ':')
		k += 2;
	else {
		while (1) {

			uint16_t word;
			if (!parse_ipv6_word(str, &k, &word))
				return false;

			ipv6[head_count++] = word;
			
			if (head_count == 8)
				break;
			
			if (k == len || src[k] != ':')
				return false;
			k++; // Skip the ':'

			if (k < len && src[k] == ':') {
				k++;
				break;
			}
		}
	}

	if (head_count + tail_count < 8) {
		while (k < len && is_hex_digit(src[k])) {

			// We know the current character is a
			// hex digit, therefore [parse_ipv6_word]
			// won't fail.
			uint16_t word;
			(void) parse_ipv6_word(str, &k, &word);

			tail[tail_count++] = word;
			
			if (head_count + tail_count == 7)
				break;
			
			if (k == len || src[k] != ':')
				break;
			k++; // Skip the ':'
		}
	}

	for (size_t p = 0; p < 8 - head_count - tail_count; p++)
		ipv6[head_count + p] = 0;

	for (size_t p = 0; p < tail_count; p++)
		ipv6[8 - tail_count + p] = tail[p];

	*i = k;
	return true;
}

static void parse_port(string str, size_t *i, bool *no_port, uint16_t *port)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t k = *i;

	if (k+1 < len && src[k] == ':' && is_digit(src[k+1])) {

		k++; // Skip the ':'
		
		uint16_t p = 0;
		do {
			int d = src[k] - '0';
			if (p > (UINT16_MAX - d) / 10)
				break;
			p = p * 10 + d;
			k++;
		} while (k < len && is_digit(src[k]));
		
		*port = p;
		*no_port = false;
	} else {
		*port = 0;
		*no_port = true;
	}

	*i = k;
}

static bool is_hostname(char c)
{
	return is_unreserved(c) || is_subdelim(c);
}

static bool is_hostname_first(char c)
{
	return is_hostname(c);
}

static bool parse_host(string str, size_t *i, url_host *host)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t k = *i;
	if (k == len)
		return false;

	if (src[k] == '[') {

		k++; // Skip the '['
		
		// IPv6
		if (!parse_ipv6(str, &k, host->ipv6))
			return false;

		if (k == len || src[k] != ']')
			return false;
		k++; // Skip the ']'

		host->mode = URL_HOSTMODE_IPV6;

	} else {

		uint32_t ipv4;
		bool  is_ipv4;

		if (is_digit(src[k]))
			is_ipv4 = parse_ipv4(str, &k, &ipv4);
		else
			is_ipv4 = false;

		if (is_ipv4) {
			host->ipv4 = ipv4;
			host->mode = URL_HOSTMODE_IPV4;
		} else {

			if (!is_hostname_first(src[k]))
				return false;

			size_t name_off = k;
			do 
				k++;
			while (k < len && is_hostname(src[k]));
			size_t name_end = k;

			host->mode = URL_HOSTMODE_NAME;
			host->name = substr(str, name_off, name_end);
		}
	}

	uint16_t port;
	bool  no_port;
	parse_port(str, &k, &no_port, &port);
	host->port = port;
	host->no_port = no_port;
	*i = k;
	return true;
}

static bool parse_path(string str, size_t *i, string *path)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t k = *i;

	size_t path_off;

	path_off = k;

	if (k < len && src[k] == '/') 
		k++;
	else {
		if (k == len || !is_pchar(src[k]))
			return false;
	}

	while (k < len && is_pchar(src[k])) {
		do
			k++;
		while (k < len && is_pchar(src[k]));
		if (k == len || src[k] != '/')
			break;
		k++; // Skip the '/'
	}

	*i = k;
	*path = substr(str, path_off, k);

	return true;
}

static bool is_query(char c)
{
	return is_pchar(c) || c == '/' || c == '?';
}

static void parse_query(string str, size_t *i, string *query)
{
	char  *src = str.data;
	size_t len = str.size;

	bool no_query;
	size_t query_off;
	size_t query_end;

	size_t peek = *i;
	if (peek < len && src[peek] == '?') {
		peek++; // Skip the '?'
		query_off = peek;
		while (peek < len && is_query(src[peek]))
			peek++;
		query_end = peek;
		no_query = false;
	} else {
		query_off = 0;
		query_end = 0;
		no_query = true;
	}

	if (no_query)
		*query = NULLSTR;
	else {
		*i = peek;
		*query = substr(str, query_off, query_end);
	}
}

static bool is_fragment(char c)
{
	return is_pchar(c) || c == '/';
}

static void parse_fragment(string str, size_t *i, string *fragment)
{
	char  *src = str.data;
	size_t len = str.size;

	bool no_fragment;
	size_t fragment_off;
	size_t fragment_end;

	size_t peek = *i;
	if (peek < len && src[peek] == '#') {
		peek++; // Skip the '#'
		fragment_off = peek;
		while (peek < len && is_fragment(src[peek]))
			peek++;
		fragment_end = peek;
		no_fragment = false;
	} else {
		fragment_off = 0;
		fragment_end = 0;
		no_fragment = true;
	}

	if (no_fragment)
		*fragment = NULLSTR;
	else {
		*i = peek;
		*fragment = substr(str, fragment_off, fragment_end);
	}
}

static bool follows_authority(string str, size_t i)
{
	return i+1 < str.size 
		&& str.data[i] == '/' 
		&& str.data[i+1] == '/';
}

static bool url_parse2(string str, size_t *i, url_t *url)
{
	char  *src = str.data;
	size_t len = str.size;

	size_t maybe;
	if (i == NULL) {
		maybe = 0;
		i = &maybe;
	}

	parse_schema(str, i, &url->schema);

	if (follows_authority(str, *i)) {

		*i += 2; // Skip the "//"
		
		parse_userinfo(str, i, &url->userinfo);

		if (!parse_host(str, i, &url->host))
			return false;

		if (*i < len && src[*i] == '/') {
			/* absolute path */

			// The parsing of the path can't fail 
			// because we already know there's at
			// leat a '/' for it.
			(void) parse_path(str, i, &url->path);
		} else
			url->path = NULLSTR;

	} else {

		url->host.mode = URL_HOSTMODE_NAME;
		url->host.name = NULLSTR;
		url->host.no_port = true;
		url->host.port = 0;

		url->userinfo.username = NULLSTR;
		url->userinfo.password = NULLSTR;

		// TODO: Since there was no authority,
		//       the path is non optional.

		if (*i == len || src[*i] == '?' || src[*i] == '#')
			return false; // Missing path

		if (!parse_path(str, i, &url->path))
			return false;
	}

	parse_query(str, i, &url->query);
	parse_fragment(str, i, &url->fragment);

	return true;
}

static bool url_parse(string str, url_t *url)
{
	size_t i = 0;
	bool result = url_parse2(str, &i, url);
	return result && i == str.size;
}

static bool url_parse_ipv4(string str, uint32_t *out)
{
	size_t i = 0;
	return parse_ipv4(str, &i, out);
}

static bool url_parse_ipv6(string str, uint16_t out[8])
{
	size_t i = 0;
	return parse_ipv6(str, &i, out);
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// URI PARSER                                                                              ///
///////////////////////////////////////////////////////////////////////////////////////////////

static bool hex_to_num(char x, int *n)
{
	// TODO: This is inefficient
	if      (x >= 'A' && x <= 'F') *n = x - 'A';
	else if (x >= 'a' && x <= 'f') *n = x - 'a';
	else if (x >= '0' && x <= '9') *n = x - '0';
	else return false;
	return true;
}

static size_t skip_any_valid_chars_not_percent_encoded(string src, size_t cur)
{
	while (cur < src.size
		&& src.data[cur] != '=' // Start of the value
		&& src.data[cur] != '&' // End of the parameter (no value)
		&& src.data[cur] != '%' // The name is percent encoded
		&& src.data[cur] != '+' // Also percent encoded
		&& is_print(src.data[cur])) // Query stirng contains invalid chracters
		cur++;
	return cur;
}

// This function is like the "parse" version but doesn't
// return the decoded string.
static bool skip_percent_encoded_substr(string src, size_t *cur_)
{
	size_t cur = *cur_;
	cur = skip_any_valid_chars_not_percent_encoded(src, cur);
	while (cur < src.size && (src.data[cur] == '+' || src.data[cur] == '%')) {
		if (src.data[cur] == '+')
			cur++;
		else {
			int u, v;
			if (cur+2 >= src.size
				|| !hex_to_num(src.data[cur+1], &u)
				|| !hex_to_num(src.data[cur+2], &v))
				return false; // Invalid percent encoding
			cur += 3;
		}
		cur = skip_any_valid_chars_not_percent_encoded(src, cur);
	}
	*cur_ = cur;
	return true;
}

// Percent decodes the source string until a query string
// separator ('=', '&') or an invalid character. The resulting
// slice (out) may point into the source string or the
// destination buffer (dst). It only returns false if copying
// was required and the buffer was too small.
static bool parse_percent_encoded_substr(string src, string dst, size_t *cur_, string *out)
{
	size_t cur = *cur_;
	size_t start = cur;

	cur = skip_any_valid_chars_not_percent_encoded(src, cur);

	// Use secondary pointer so the key to avoid pointing
	// into the source buffer. If we found something to
	// decode (eg a %xx token) we'll need to copy the key
	// into the destination buffer and make this pointer
	// refer to that.
	*out = substr(src, start, cur);

	// If the name is percent encoded, copying into
	// a seprate buffer to decode it is necessary
	if (cur < src.size && (src.data[cur] == '%' || src.data[cur] == '+')) {

		// Copy what was already scanned into the
		// output buffer.
		if (out->size > dst.size)
			return -1; // Output buffer is too small
		memcpy(dst.data, out->data, out->size);

		size_t copied = out->size;
		do {

			assert(cur < src.size);

			if (src.data[cur] == '+') {

				if (copied == dst.size) return false; // Output buffer is too small
				dst.data[copied++] = ' ';
				cur++;

			} else {

				// We know there is a '%' at this point
				int u, v;
				if (cur+2 >= src.size
					|| !hex_to_num(src.data[cur+1], &u)
					|| !hex_to_num(src.data[cur+2], &v))
					return false; // Invalid percent encoding
				cur += 3;

				assert(u >= 0 && u < 16);
				assert(v >= 0 && v < 16);
				uint8_t byte = (u << 4) | v;

				if (copied == dst.size) return false; // Output buffer is too small
				dst.data[copied++] = (char) byte;
			}

			// Skip all plain characters and memcopy them at once

			start = cur;
			cur = skip_any_valid_chars_not_percent_encoded(src, cur);

			if (copied + cur - start > dst.size) return false; // Buffer is too small
			memcpy(dst.data + copied, src.data + start, cur - start);
			copied += cur - start;

		} while (cur < src.size && (src.data[cur] == '%' || src.data[cur] == '+'));

		out->data = dst.data;
		out->size = copied;
	}

	*cur_ = cur;
	return true;
}

bool get_query_string_param(string str, string key, string dst, string *out)
{
	assert(key.size);

	size_t cur = 0;
	if (cur < str.size && str.data[cur] == '?')
		cur++;

	while (cur < str.size) {

		string key2;
		if (!parse_percent_encoded_substr(str, dst, &cur, &key2))
			return false; // Buffer too small

		if (cur < str.size && !is_print(str.data[cur]))
			return false; // Invalid query string

		if (key2.size == key.size && !memcmp(key2.data, key.data, key2.size)) {
			if (cur < str.size && str.data[cur] == '=') {
				cur++; // =
				if (!parse_percent_encoded_substr(str, dst, &cur, out))
					return false;
			} else {
				out->data = "";
				out->size = 0;
			}
			return true;
		} else {
			if (cur < str.size && str.data[cur] == '=') {
				cur++; // =
				if (!skip_percent_encoded_substr(str, &cur))
					return false;
			}
		}

		if (cur < str.size && str.data[cur] != '&')
			return false;
		cur++; // &
	}
	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// COOKIE PARSER                                                                           ///
///////////////////////////////////////////////////////////////////////////////////////////////

static bool is_cookie_name(char c)
{
	return (c >= 'a' && c <= 'z')
		|| (c >= 'A' && c <= 'Z')
		|| (c >= '0' && c <= '9')
		|| c == '_' || c == '-';
}

static bool is_cookie_value(char c)
{
	return (c >= 'a' && c <= 'z')
		|| (c >= 'A' && c <= 'Z')
		|| (c >= '0' && c <= '9')
		|| c == '_' || c == '-';
}

bool get_cookie(Request *request, string name, string *out)
{
	string value;
	if (!find_header(request, LIT("Cookie"), &value))
		return false;

	char  *src = value.data;
	size_t len = value.size;
	size_t cur = 0;
	while (cur < len) {
		
		size_t start;

		while (cur < len && is_space(src[cur]))
			cur++;
		
		if (cur == len)
			break;
		
		if (!is_cookie_name(src[cur]))
			return false;

		start = cur;
		do
			cur++;
		while (cur < len && is_cookie_name(src[cur]));
		string cookie_name = substr(value, start, cur);

		while (cur < len && is_space(src[cur]))
			cur++;
		
		if (cur == len || src[cur] != '=')
			return false;
		cur++;

		while (cur < len && is_space(src[cur]))
			cur++;
		
		if (!is_cookie_value(src[cur]))
			return false;

		start = cur;
		do
			cur++;
		while (cur < len && is_cookie_value(src[cur]));
		string cookie_value = substr(value, start, cur);

		while (cur < len && is_space(src[cur]))
			cur++;
		
		if (cur < len) {
			if (src[cur] != ';')
				return false;
			cur++;
		}

		if (streq(cookie_name, name)) {
			*out = cookie_value;
			return true;
		}
	}

	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// CERTIFICATE AND PRIVATE KEY PARSING (Adapted from BearSSL)                              ///
///////////////////////////////////////////////////////////////////////////////////////////////
/// Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>                                     ///
///                                                                                         ///
/// Permission is hereby granted, free of charge, to any person obtaining                   ///
/// a copy of this software and associated documentation files (the                         ///
/// "Software"), to deal in the Software without restriction, including                     ///
/// without limitation the rights to use, copy, modify, merge, publish,                     ///
/// distribute, sublicense, and/or sell copies of the Software, and to                      ///
/// permit persons to whom the Software is furnished to do so, subject to                   ///
/// the following conditions:                                                               ///
///                                                                                         ///
/// The above copyright notice and this permission notice shall be                          ///
/// included in all copies or substantial portions of the Software.                         ///
///                                                                                         ///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,                         ///
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                      ///
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                                   ///
/// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS                     ///
/// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN                      ///
/// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN                       ///
/// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE                        ///
/// SOFTWARE.                                                                               ///
///////////////////////////////////////////////////////////////////////////////////////////////

#if HTTPS
BearSSLErrorInfo bearssl_error_table[] = {
	{ BR_ERR_BAD_PARAM,                LIT("BR_ERR_BAD_PARAM"),                LIT("Caller-provided parameter is incorrect.") },
	{ BR_ERR_BAD_STATE,                LIT("BR_ERR_BAD_STATE"),                LIT("Operation requested by the caller cannot be applied with the current context state (e.g. reading data while outgoing data is waiting to be sent).") },
	{ BR_ERR_UNSUPPORTED_VERSION,      LIT("BR_ERR_UNSUPPORTED_VERSION"),      LIT("Incoming protocol or record version is unsupported.") },
	{ BR_ERR_BAD_VERSION,              LIT("BR_ERR_BAD_VERSION"),              LIT("Incoming record version does not match the expected version.") },
	{ BR_ERR_BAD_LENGTH,               LIT("BR_ERR_BAD_LENGTH"),               LIT("Incoming record length is invalid.") },
	{ BR_ERR_TOO_LARGE,                LIT("BR_ERR_TOO_LARGE"),                LIT("Incoming record is too large to be processed, or buffer is too small for the handshake message to send.") },
	{ BR_ERR_BAD_MAC,                  LIT("BR_ERR_BAD_MAC"),                  LIT("Decryption found an invalid padding, or the record MAC is not correct.") },
	{ BR_ERR_NO_RANDOM,                LIT("BR_ERR_NO_RANDOM"),                LIT("No initial entropy was provided, and none can be obtained from the OS.") },
	{ BR_ERR_UNKNOWN_TYPE,             LIT("BR_ERR_UNKNOWN_TYPE"),             LIT("Incoming record type is unknown.") },
	{ BR_ERR_UNEXPECTED,               LIT("BR_ERR_UNEXPECTED"),               LIT("Incoming record or message has wrong type with regards to the current engine state.") },
	{ BR_ERR_BAD_CCS,                  LIT("BR_ERR_BAD_CCS"),                  LIT("ChangeCipherSpec message from the peer has invalid contents.") },
	{ BR_ERR_BAD_ALERT,                LIT("BR_ERR_BAD_ALERT"),                LIT("Alert message from the peer has invalid contents (odd length).") },
	{ BR_ERR_BAD_HANDSHAKE,            LIT("BR_ERR_BAD_HANDSHAKE"),            LIT("Incoming handshake message decoding failed.") },
	{ BR_ERR_OVERSIZED_ID,             LIT("BR_ERR_OVERSIZED_ID"),             LIT("ServerHello contains a session ID which is larger than 32 bytes.") },
	{ BR_ERR_BAD_CIPHER_SUITE,         LIT("BR_ERR_BAD_CIPHER_SUITE"),         LIT("Server wants to use a cipher suite that we did not claim to support. This is also reported if we tried to advertise a cipher suite that we do not support.") },
	{ BR_ERR_BAD_COMPRESSION,          LIT("BR_ERR_BAD_COMPRESSION"),          LIT("Server wants to use a compression that we did not claim to support.") },
	{ BR_ERR_BAD_FRAGLEN,              LIT("BR_ERR_BAD_FRAGLEN"),              LIT("Server's max fragment length does not match client's.") },
	{ BR_ERR_BAD_SECRENEG,             LIT("BR_ERR_BAD_SECRENEG"),             LIT("Secure renegotiation failed.") },
	{ BR_ERR_EXTRA_EXTENSION,          LIT("BR_ERR_EXTRA_EXTENSION"),          LIT("Server sent an extension type that we did not announce, or used the same extension type several times in a single ServerHello.") },
	{ BR_ERR_BAD_SNI,                  LIT("BR_ERR_BAD_SNI"),                  LIT("Invalid Server Name Indication contents (when used by the server, this extension shall be empty).") },
	{ BR_ERR_BAD_HELLO_DONE,           LIT("BR_ERR_BAD_HELLO_DONE"),           LIT("Invalid ServerHelloDone from the server (length is not 0).") },
	{ BR_ERR_LIMIT_EXCEEDED,           LIT("BR_ERR_LIMIT_EXCEEDED"),           LIT("Internal limit exceeded (e.g. server's public key is too large).") },
	{ BR_ERR_BAD_FINISHED,             LIT("BR_ERR_BAD_FINISHED"),             LIT("Finished message from peer does not match the expected value.") },
	{ BR_ERR_RESUME_MISMATCH,          LIT("BR_ERR_RESUME_MISMATCH"),          LIT("Session resumption attempt with distinct version or cipher suite.") },
	{ BR_ERR_INVALID_ALGORITHM,        LIT("BR_ERR_INVALID_ALGORITHM"),        LIT("Unsupported or invalid algorithm (ECDHE curve, signature algorithm, hash function).") },
	{ BR_ERR_BAD_SIGNATURE,            LIT("BR_ERR_BAD_SIGNATURE"),            LIT("Invalid signature in ServerKeyExchange or CertificateVerify message.") },
	{ BR_ERR_WRONG_KEY_USAGE,          LIT("BR_ERR_WRONG_KEY_USAGE"),          LIT("Peer's public key does not have the proper type or is not allowed for the requested operation.") },
	{ BR_ERR_NO_CLIENT_AUTH,           LIT("BR_ERR_NO_CLIENT_AUTH"),           LIT("Client did not send a certificate upon request, or the client certificate could not be validated.") },
	{ BR_ERR_IO,                       LIT("BR_ERR_IO"),                       LIT("I/O error or premature close on transport stream.") },
	{ BR_ERR_X509_INVALID_VALUE,       LIT("BR_ERR_X509_INVALID_VALUE"),       LIT("Invalid value in an ASN.1 structure.") },
	{ BR_ERR_X509_TRUNCATED,           LIT("BR_ERR_X509_TRUNCATED"),           LIT("Truncated certificate or other ASN.1 object.") },
	{ BR_ERR_X509_EMPTY_CHAIN,         LIT("BR_ERR_X509_EMPTY_CHAIN"),         LIT("Empty certificate chain (no certificate at all).") },
	{ BR_ERR_X509_INNER_TRUNC,         LIT("BR_ERR_X509_INNER_TRUNC"),         LIT("Decoding error: inner element extends beyond outer element size.") },
	{ BR_ERR_X509_BAD_TAG_CLASS,       LIT("BR_ERR_X509_BAD_TAG_CLASS"),       LIT("Decoding error: unsupported tag class (application or private).") },
	{ BR_ERR_X509_BAD_TAG_VALUE,       LIT("BR_ERR_X509_BAD_TAG_VALUE"),       LIT("Decoding error: unsupported tag value.") },
	{ BR_ERR_X509_INDEFINITE_LENGTH,   LIT("BR_ERR_X509_INDEFINITE_LENGTH"),   LIT("Decoding error: indefinite length.") },
	{ BR_ERR_X509_EXTRA_ELEMENT,       LIT("BR_ERR_X509_EXTRA_ELEMENT"),       LIT("Decoding error: extraneous element.") },
	{ BR_ERR_X509_UNEXPECTED,          LIT("BR_ERR_X509_UNEXPECTED"),          LIT("Decoding error: unexpected element.") },
	{ BR_ERR_X509_NOT_CONSTRUCTED,     LIT("BR_ERR_X509_NOT_CONSTRUCTED"),     LIT("Decoding error: expected constructed element, but is primitive.") },
	{ BR_ERR_X509_NOT_PRIMITIVE,       LIT("BR_ERR_X509_NOT_PRIMITIVE"),       LIT("Decoding error: expected primitive element, but is constructed.") },
	{ BR_ERR_X509_PARTIAL_BYTE,        LIT("BR_ERR_X509_PARTIAL_BYTE"),        LIT("Decoding error: BIT STRING length is not multiple of 8.") },
	{ BR_ERR_X509_BAD_BOOLEAN,         LIT("BR_ERR_X509_BAD_BOOLEAN"),         LIT("Decoding error: BOOLEAN value has invalid length.") },
	{ BR_ERR_X509_OVERFLOW,            LIT("BR_ERR_X509_OVERFLOW"),            LIT("Decoding error: value is off-limits.") },
	{ BR_ERR_X509_BAD_DN,              LIT("BR_ERR_X509_BAD_DN"),              LIT("Invalid distinguished name.") },
	{ BR_ERR_X509_BAD_TIME,            LIT("BR_ERR_X509_BAD_TIME"),            LIT("Invalid date/time representation.") },
	{ BR_ERR_X509_UNSUPPORTED,         LIT("BR_ERR_X509_UNSUPPORTED"),         LIT("Certificate contains unsupported features that cannot be ignored.") },
	{ BR_ERR_X509_LIMIT_EXCEEDED,      LIT("BR_ERR_X509_LIMIT_EXCEEDED"),      LIT("Key or signature size exceeds internal limits.") },
	{ BR_ERR_X509_WRONG_KEY_TYPE,      LIT("BR_ERR_X509_WRONG_KEY_TYPE"),      LIT("Key type does not match that which was expected.") },
	{ BR_ERR_X509_BAD_SIGNATURE,       LIT("BR_ERR_X509_BAD_SIGNATURE"),       LIT("Signature is invalid.") },
	{ BR_ERR_X509_TIME_UNKNOWN,        LIT("BR_ERR_X509_TIME_UNKNOWN"),        LIT("Validation time is unknown.") },
	{ BR_ERR_X509_EXPIRED,             LIT("BR_ERR_X509_EXPIRED"),             LIT("Certificate is expired or not yet valid.") },
	{ BR_ERR_X509_DN_MISMATCH,         LIT("BR_ERR_X509_DN_MISMATCH"),         LIT("Issuer/Subject DN mismatch in the chain.") },
	{ BR_ERR_X509_BAD_SERVER_NAME,     LIT("BR_ERR_X509_BAD_SERVER_NAME"),     LIT("Expected server name was not found in the chain.") },
	{ BR_ERR_X509_CRITICAL_EXTENSION,  LIT("BR_ERR_X509_CRITICAL_EXTENSION"),  LIT("Unknown critical extension in certificate.") },
	{ BR_ERR_X509_NOT_CA,              LIT("BR_ERR_X509_NOT_CA"),              LIT("Not a CA, or path length constraint violation.") },
	{ BR_ERR_X509_FORBIDDEN_KEY_USAGE, LIT("BR_ERR_X509_FORBIDDEN_KEY_USAGE"), LIT("Key Usage extension prohibits intended usage.") },
	{ BR_ERR_X509_WEAK_PUBLIC_KEY,     LIT("BR_ERR_X509_WEAK_PUBLIC_KEY"),     LIT("Public key found in certificate is too small.") },
	{ BR_ERR_X509_NOT_TRUSTED,         LIT("BR_ERR_X509_NOT_TRUSTED"),         LIT("Chain could not be linked to a trust anchor.") },
};

static BearSSLErrorInfo get_bearssl_error_info(int code)
{
	for (int i = 0; i < COUNTOF(bearssl_error_table); i++)
		if (bearssl_error_table[i].code == code)
			return bearssl_error_table[i];
	BearSSLErrorInfo fallback;
	fallback.code = code;
	fallback.name = LIT("Unknown");
	fallback.comment = LIT(":/");
	return fallback;
}

typedef struct {
	string name;
	string content;
} PemObject;

typedef struct {

	bool   failed;

	char  *buffer;
	size_t buffer_count;
	size_t buffer_capacity;

} PemDecodeContext;

static int is_ign(int c)
{
	if (c == 0) {
		return 0;
	}
	if (c <= 32 || c == '-' || c == '_' || c == '.'
		|| c == '/' || c == '+' || c == ':')
	{
		return 1;
	}
	return 0;
}

// Get next non-ignored character, normalised:
//    ASCII letters are converted to lowercase
//    control characters, space, '-', '_', '.', '/', '+' and ':' are ignored
// A terminating zero is returned as 0.
static char next_char(string *s)
{
	size_t i = 0;
	while (i < s->size && is_ign(s->data[i]))
		i++;

	char c;
	if (i == s->size)
		c = '\0';
	else {
		c = s->data[i++];
		assert(c != '\0');
	}

	s->data += i;
	s->size -= i;
	return to_lower(c);
}

static bool eqstr__(string a, string b)
{
	for (;;) {
		char c1 = next_char(&a);
		char c2 = next_char(&b);
		if (c1 != c2) return false;
		if (c1 == 0)  return true;
	}
}

static void append_bytes(void *userptr, const void *str, size_t len)
{
	PemDecodeContext *context = userptr;

	if (context->failed)
		return;

	if (context->buffer_capacity - context->buffer_count < len) {

		size_t newcap = MAX(2 * context->buffer_capacity, context->buffer_count + len);
		void  *newstr = mymalloc(newcap);
		if (newstr == NULL) {
			context->failed = true;
			return;
		}

		if (context->buffer) {
			memcpy(newstr, context->buffer, context->buffer_count);
			myfree(context->buffer, context->buffer_capacity);
		}
		context->buffer = newstr;
		context->buffer_capacity = newcap;
	}

	memcpy(context->buffer + context->buffer_count, str, len);
	context->buffer_count += len;
}

typedef struct {
	PemObject *items;
	int count;
	int capacity;
} PemArray;

static bool append_pem(PemArray *arr, PemObject obj)
{
	if (arr->count == arr->capacity) {
		int newcap = MAX(2 * arr->capacity, 4);
		PemObject *newitems = mymalloc(newcap * sizeof(PemObject));
		if (newitems == NULL)
			return false;
		if (arr->count)
			memcpy(arr->items, newitems, arr->count * sizeof(PemObject));
		myfree(arr->items, arr->capacity * sizeof(PemObject));
		arr->items = newitems;
		arr->capacity = newcap;
	}

	arr->items[arr->count++] = obj;
	return true;
}

static void free_pem_array(PemArray *arr)
{
	for (int i = 0; i < arr->count; i++) {

		string name = arr->items[i].name;
		myfree(name.data, name.size);

		string content = arr->items[i].content;
		if (content.data)
			myfree(content.data, content.size);
	}
	myfree(arr->items, arr->capacity * sizeof(PemObject));
}

static bool decode_pem(string src, PemArray *array)
{
	br_pem_decoder_context context;
	br_pem_decoder_init(&context);

	PemDecodeContext context2;
	context2.failed = false;
	context2.buffer = NULL;
	context2.buffer_count = 0;
	context2.buffer_capacity = 0;

	array->items = NULL;
	array->count = 0;
	array->capacity = 0;

	PemObject po;
	po.name = NULLSTR;
	po.content = NULLSTR;

	bool inside_object = false;
	bool extra_newline = true;
	while (src.size > 0) {

		size_t n = br_pem_decoder_push(&context, src.data, src.size);
		src.data += n;
		src.size -= n;

		switch (br_pem_decoder_event(&context)) {
			case BR_PEM_BEGIN_OBJ:
			{
				const char *name = br_pem_decoder_name(&context);
				size_t name_len = strlen(name);

				po.name.data = mymalloc(name_len);
				po.name.size = name_len;

				if (po.name.data == NULL) {
					myfree(context2.buffer, context2.buffer_capacity);
					free_pem_array(array);
					return false;
				}
				memcpy(po.name.data, name, name_len);

				br_pem_decoder_setdest(&context, append_bytes, &context2);
				inside_object = true;
			}
			break;

			case BR_PEM_END_OBJ:
			if (inside_object) {

				void *copy = mymalloc(context2.buffer_count);
				if (copy == NULL) {
					myfree(po.name.data, po.name.size);
					myfree(context2.buffer, context2.buffer_capacity);
					free_pem_array(array);
					return false;
				}
				memcpy(copy, context2.buffer, context2.buffer_count);

				po.content.data = copy;
				po.content.size = context2.buffer_count;

				if (!append_pem(array, po)) {
					myfree(po.name.data, po.name.size);
					myfree(context2.buffer, context2.buffer_capacity);
					free_pem_array(array);
					return false;
				}

				po.name = NULLSTR;
				po.content = NULLSTR;

				context2.buffer_count = 0;
				inside_object = false;
			}
			break;

			case BR_PEM_ERROR:
			myfree(po.name.data, po.name.size);
			myfree(context2.buffer, context2.buffer_capacity);
			free_pem_array(array);
			log_data(LIT("Invalid PEM"));
			return false;
		}

		if (src.size == 0 && extra_newline) {
			src.data = "\n";
			src.size = 1;
			extra_newline = false;
		}
	}

	if (context2.buffer)
		myfree(context2.buffer, context2.buffer_capacity);

	if (context2.failed) {
		myfree(po.name.data, po.name.size);
		free_pem_array(array);
		return false;
	}
	if (inside_object) {
		myfree(po.name.data, po.name.size);
		free_pem_array(array);
		log_data(LIT("Unfinished PEM"));
		return false;
	}

	return true;
}

static int looks_like_DER(string content)
{
	int fb;
	size_t dlen;

	if (content.size < 2) {
		return 0;
	}
	if (*content.data ++ != 0x30) {
		return 0;
	}
	fb = *content.data ++;
	content.size -= 2;
	if (fb < 0x80) {
		return (size_t)fb == content.size;
	} else if (fb == 0x80) {
		return 0;
	} else {
		fb -= 0x80;
		if (content.size < (size_t)fb + 2) {
			return 0;
		}
		content.size -= (size_t)fb;
		dlen = 0;
		while (fb -- > 0) {
			if (dlen > (content.size >> 8)) {
				return 0;
			}
			dlen = (dlen << 8) + (size_t)*content.data ++;
		}
		return dlen == content.size;
	}
}

static bool decode_key(string src, PrivateKey *pkey)
{
	br_skey_decoder_context context;
	br_skey_decoder_init(&context);
	br_skey_decoder_push(&context, src.data, src.size);

	int err = br_skey_decoder_last_error(&context);
	if (err) {
		BearSSLErrorInfo error_info = get_bearssl_error_info(err);
		log_format("Error decoding key: %.*s: (code=%d, %.*s)\n", 
			(int) error_info.name.size, error_info.name.data, err,
			(int) error_info.comment.size, error_info.comment.data);
		return false;
	}

	switch (br_skey_decoder_key_type(&context)) {

		const br_rsa_private_key *rsa_key;
		const br_ec_private_key *ec_key;

		case BR_KEYTYPE_RSA:
		{
			rsa_key = br_skey_decoder_get_rsa(&context);

			unsigned char *mem = mymalloc(rsa_key->plen + rsa_key->qlen + rsa_key->dplen + rsa_key->dqlen + rsa_key->iqlen);
			if (mem == NULL) return false;

			pkey->type = BR_KEYTYPE_RSA;
			pkey->rsa.n_bitlen = rsa_key->n_bitlen;

			pkey->rsa.p  = mem;
			pkey->rsa.q  = mem + rsa_key->plen;
			pkey->rsa.dp = mem + rsa_key->plen + rsa_key->qlen;
			pkey->rsa.dq = mem + rsa_key->plen + rsa_key->qlen + rsa_key->dplen;
			pkey->rsa.iq = mem + rsa_key->plen + rsa_key->qlen + rsa_key->dplen + rsa_key->dqlen;

			memcpy(pkey->rsa.p, rsa_key->p, rsa_key->plen);
			memcpy(pkey->rsa.q, rsa_key->q, rsa_key->qlen);
			memcpy(pkey->rsa.dp, rsa_key->dp, rsa_key->dplen);
			memcpy(pkey->rsa.dq, rsa_key->dq, rsa_key->dqlen);
			memcpy(pkey->rsa.iq, rsa_key->iq, rsa_key->iqlen);

			pkey->rsa.plen = rsa_key->plen;
			pkey->rsa.qlen = rsa_key->qlen;
			pkey->rsa.dplen = rsa_key->dplen;
			pkey->rsa.dqlen = rsa_key->dqlen;
			pkey->rsa.iqlen = rsa_key->iqlen;
		}
		break;

		case BR_KEYTYPE_EC:
		{
			ec_key = br_skey_decoder_get_ec(&context);
			pkey->type = BR_KEYTYPE_EC;
			pkey->ec.curve = ec_key->curve;
			pkey->ec.x = mymalloc(ec_key->xlen);
			if (pkey->ec.x == NULL)
				return false;
			memcpy(pkey->ec.x, ec_key->x, ec_key->xlen);
			pkey->ec.xlen = ec_key->xlen;
		}
		break;
	
		default:
		log_format("Unknown key type: %d\n", br_skey_decoder_key_type(&context));
		return false;
	}

	return true;
}

static bool load_private_key_from_file(string file, PrivateKey *pkey)
{
	string file_contents;
	if (!load_file_contents(file, &file_contents))
		return false;

	DEBUG("loading key: file contents loaded\n");

	bool ok;
	if (looks_like_DER(file_contents)) {
		DEBUG("loading key: detected DER file\n");
		ok = decode_key(file_contents, pkey);
	} else {

		DEBUG("loading key: detected PEM file\n");

		PemArray pem_array;
		if (!decode_pem(file_contents, &pem_array)) {
			myfree(file_contents.data, file_contents.size);
			return false;
		}

		bool found = false;
		bool decoded = false;
		for (int i = 0; i < pem_array.count; i++)
			if (eqstr__(pem_array.items[i].name, LIT("RSA PRIVATE KEY"))
				|| eqstr__(pem_array.items[i].name, LIT("EC PRIVATE KEY"))
				|| eqstr__(pem_array.items[i].name, LIT("PRIVATE KEY"))) {

				DEBUG("loading key: found key in PEM file\n");

				if (decode_key(pem_array.items[i].content, pkey))
					decoded = true;

				found = true;
				break;
			}

		ok = false;
		if (!found)
			log_data(LIT("Missing private key in file\n"));
		else {
			if (!decoded)
				log_data(LIT("Couldn't decode key\n"));
			else
				ok = true;
		}
		free_pem_array(&pem_array);
	}

	myfree(file_contents.data, file_contents.size);
	return ok;
}

static void free_private_key(PrivateKey *pkey)
{
	switch (pkey->type) {
	
		case BR_KEYTYPE_RSA:
		myfree(pkey->rsa.p, pkey->rsa.plen + pkey->rsa.qlen + pkey->rsa.dplen + pkey->rsa.dqlen + pkey->rsa.iqlen);
		break;

		case BR_KEYTYPE_EC:
		myfree(pkey->ec.x, pkey->ec.xlen);
		break;
	}
}

static bool append_cert(CertArray *arr, br_x509_certificate cert)
{
	if (arr->count == arr->capacity) {
		int newcap = MAX(2 * arr->capacity, 4);
		br_x509_certificate *newitems = mymalloc(newcap * sizeof(br_x509_certificate));
		if (newitems == NULL)
			return false;
		if (arr->count)
			memcpy(arr->items, newitems, arr->count * sizeof(br_x509_certificate));
		myfree(arr->items, arr->capacity * sizeof(br_x509_certificate));
		arr->items = newitems;
		arr->capacity = newcap;
	}

	arr->items[arr->count++] = cert;
	return true;
}

static bool load_certs_from_file(string file, CertArray *array)
{
	string file_contents;
	if (!load_file_contents(file, &file_contents))
		return false;
	
	DEBUG("loading certs: file contents loaded\n");

	array->items = NULL;
	array->count = 0;
	array->capacity = 0;

	if (looks_like_DER(file_contents)) {

		DEBUG("loading certs: detected DER file\n");

		br_x509_certificate xc = {
			(unsigned char*) file_contents.data,
			file_contents.size,
		};
		if (!append_cert(array, xc)) {
			myfree(file_contents.data, file_contents.size);
			return false;
		}

		DEBUG("loading certs: DER file parsed\n");

	} else {

		DEBUG("loading certs: detected PEM file\n");

		PemArray pem_array;
		if (!decode_pem(file_contents, &pem_array)) {
			myfree(file_contents.data, file_contents.size);
			return false;
		}

		DEBUG("loading certs: PEM file parsed (%d entries)\n", pem_array.count);

		for (int i = 0; i < pem_array.count; i++) {

			PemObject po = pem_array.items[i];

			if (eqstr__(po.name, LIT("CERTIFICATE")) || eqstr__(po.name, LIT("X509 CERTIFICATE"))) {

				DEBUG("loading certs: found certificate in PEM file\n");

				br_x509_certificate xc = { (unsigned char*) po.content.data, po.content.size };

				if (!append_cert(array, xc)) {
					free_pem_array(&pem_array);
					free_certs(array);
					myfree(file_contents.data, file_contents.size);
					return false;
				}

				pem_array.items[i].content = NULLSTR;
			} else {
				DEBUG("loading certs: ignoring entry [%.*s] in PEM file\n", (int) po.name.size, po.name.data);
			}
		}

		DEBUG("loading certs: finished loading certificates from PEM file\n");

		if (array->count == 0) {
			free_pem_array(&pem_array);
			free_certs(array);
			myfree(file_contents.data, file_contents.size);
			log_data(LIT("No certificates in file\n"));
			return false;
		}

		free_pem_array(&pem_array);
		myfree(file_contents.data, file_contents.size);
	}

	DEBUG("loading certs: certificate loaded\n");
	return true;
}

static void free_certs(CertArray *array)
{
	for (int i = 0; i < array->count; i++) {
		br_x509_certificate item = array->items[i];
		myfree(item.data, item.data_len);
	}
	myfree(array->items, array->capacity * sizeof(br_x509_certificate));
}
#endif /* HTTPS */