35 files changed, 11998 insertions, 49 deletions

diff --git a/plugins/Makefile.am b/plugins/Makefile.am
index 0ddf9bd..34a7da8 100644
--- a/plugins/Makefile.am
+++ b/plugins/Makefile.am
@@ -38,7 +38,9 @@ check_tcp_programs = check_ftp check_imap check_nntp check_pop \
 EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \
         check_swap check_fping check_ldap check_game check_dig \
         check_nagios check_by_ssh check_dns check_nt check_ide_smart    \
-        check_procs check_mysql_query check_apt check_dbi
+        check_procs check_mysql_query check_apt check_dbi check_curl
+
+SUBDIRS = @PICOHTTPPARSER_DIR@ @URIPARSER_DIR@
 
 EXTRA_DIST = t tests
 
@@ -69,6 +71,9 @@ test-debug:
 
 check_apt_LDADD = $(BASEOBJS)
 check_cluster_LDADD = $(BASEOBJS)
+check_curl_CFLAGS = $(AM_CFLAGS) $(LIBCURLCFLAGS) -Ipicohttpparser -Iuriparser
+check_curl_CPPFLAGS = $(AM_CPPFLAGS) $(LIBCURLINCLUDE) -Ipicohttpparser -Iuriparser
+check_curl_LDADD = $(NETLIBS) $(LIBCURLLIBS) $(SSLOBJS) picohttpparser/libpicohttpparser.a uriparser/liburiparser.a
 check_dbi_LDADD = $(NETLIBS) $(DBILIBS)
 check_dig_LDADD = $(NETLIBS)
 check_disk_LDADD = $(BASEOBJS)
@@ -89,7 +94,7 @@ check_mysql_query_CFLAGS = $(AM_CFLAGS) $(MYSQLCFLAGS)
 check_mysql_query_CPPFLAGS = $(AM_CPPFLAGS) $(MYSQLINCLUDE)
 check_mysql_query_LDADD = $(NETLIBS) $(MYSQLLIBS)
 check_nagios_LDADD = $(BASEOBJS)
-check_nt_LDADD = $(NETLIBS) 
+check_nt_LDADD = $(NETLIBS)
 check_ntp_LDADD = $(NETLIBS) $(MATHLIBS)
 check_ntp_peer_LDADD = $(NETLIBS) $(MATHLIBS)
 check_nwstat_LDADD = $(NETLIBS)
diff --git a/plugins/check_curl.c b/plugins/check_curl.c
new file mode 100644
index 0000000..2f58305
--- /dev/null
+++ b/plugins/check_curl.c
@@ -0,0 +1,2256 @@
+/*****************************************************************************
+*
+* Monitoring check_curl plugin
+*
+* License: GPL
+* Copyright (c) 1999-2017 Monitoring Plugins Development Team
+*
+* Description:
+*
+* This file contains the check_curl plugin
+*
+* This plugin tests the HTTP service on the specified host. It can test
+* normal (http) and secure (https) servers, follow redirects, search for
+* strings and regular expressions, check connection times, and report on
+* certificate expiration times.
+*
+* This plugin uses functions from the curl library, see
+* http://curl.haxx.se
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+*
+*****************************************************************************/
+const char *progname = "check_curl";
+
+const char *copyright = "2006-2017";
+const char *email = "devel@monitoring-plugins.org";
+
+#include <ctype.h>
+
+#include "common.h"
+#include "utils.h"
+
+#ifndef LIBCURL_PROTOCOL_HTTP
+#error libcurl compiled without HTTP support, compiling check_curl plugin does not makes a lot of sense
+#endif
+
+#include "curl/curl.h"
+#include "curl/easy.h"
+
+#include "picohttpparser.h"
+
+#include "uriparser/Uri.h"
+
+#include <arpa/inet.h>
+
+#define MAKE_LIBCURL_VERSION(major, minor, patch) ((major)*0x10000 + (minor)*0x100 + (patch))
+
+#define DEFAULT_BUFFER_SIZE 2048
+#define DEFAULT_SERVER_URL "/"
+#define HTTP_EXPECT "HTTP/1."
+#define DEFAULT_MAX_REDIRS 15
+#define INET_ADDR_MAX_SIZE INET6_ADDRSTRLEN
+enum {
+  MAX_IPV4_HOSTLENGTH = 255,
+  HTTP_PORT = 80,
+  HTTPS_PORT = 443,
+  MAX_PORT = 65535
+};
+
+enum {
+  STICKY_NONE = 0,
+  STICKY_HOST = 1,
+  STICKY_PORT = 2
+};
+
+enum {
+  FOLLOW_HTTP_CURL = 0,
+  FOLLOW_LIBCURL = 1
+};
+
+/* for buffers for header and body */
+typedef struct {
+  char *buf;
+  size_t buflen;
+  size_t bufsize;
+} curlhelp_write_curlbuf;
+
+/* for buffering the data sent in PUT */
+typedef struct {
+  char *buf;
+  size_t buflen;
+  off_t pos;
+} curlhelp_read_curlbuf;
+
+/* for parsing the HTTP status line */
+typedef struct {
+  int http_major;   /* major version of the protocol, always 1 (HTTP/0.9
+                     * never reached the big internet most likely) */
+  int http_minor;   /* minor version of the protocol, usually 0 or 1 */
+  int http_code;    /* HTTP return code as in RFC 2145 */
+  int http_subcode; /* Microsoft IIS extension, HTTP subcodes, see
+                     * http://support.microsoft.com/kb/318380/en-us */
+  const char *msg;  /* the human readable message */
+  char *first_line; /* a copy of the first line */
+} curlhelp_statusline;
+
+/* to know the underlying SSL library used by libcurl */
+typedef enum curlhelp_ssl_library {
+  CURLHELP_SSL_LIBRARY_UNKNOWN,
+  CURLHELP_SSL_LIBRARY_OPENSSL,
+  CURLHELP_SSL_LIBRARY_LIBRESSL,
+  CURLHELP_SSL_LIBRARY_GNUTLS,
+  CURLHELP_SSL_LIBRARY_NSS
+} curlhelp_ssl_library;
+
+enum {
+  REGS = 2,
+  MAX_RE_SIZE = 256
+};
+#include "regex.h"
+regex_t preg;
+regmatch_t pmatch[REGS];
+char regexp[MAX_RE_SIZE];
+int cflags = REG_NOSUB | REG_EXTENDED | REG_NEWLINE;
+int errcode;
+int invert_regex = 0;
+
+char *server_address;
+char *host_name;
+char *server_url = DEFAULT_SERVER_URL;
+char server_ip[DEFAULT_BUFFER_SIZE];
+struct curl_slist *server_ips = NULL;
+unsigned short server_port = HTTP_PORT;
+int virtual_port = 0;
+int host_name_length;
+char output_header_search[30] = "";
+char output_string_search[30] = "";
+char *warning_thresholds = NULL;
+char *critical_thresholds = NULL;
+int days_till_exp_warn, days_till_exp_crit;
+thresholds *thlds;
+char user_agent[DEFAULT_BUFFER_SIZE];
+int verbose = 0;
+int show_extended_perfdata = FALSE;
+int min_page_len = 0;
+int max_page_len = 0;
+int redir_depth = 0;
+int max_depth = DEFAULT_MAX_REDIRS;
+char *http_method = NULL;
+char *http_post_data = NULL;
+char *http_content_type = NULL;
+CURL *curl;
+struct curl_slist *header_list = NULL;
+curlhelp_write_curlbuf body_buf;
+curlhelp_write_curlbuf header_buf;
+curlhelp_statusline status_line;
+curlhelp_read_curlbuf put_buf;
+char http_header[DEFAULT_BUFFER_SIZE];
+long code;
+long socket_timeout = DEFAULT_SOCKET_TIMEOUT;
+double total_time;
+double time_connect;
+double time_appconnect;
+double time_headers;
+double time_firstbyte;
+char errbuf[CURL_ERROR_SIZE+1];
+CURLcode res;
+char url[DEFAULT_BUFFER_SIZE];
+char msg[DEFAULT_BUFFER_SIZE];
+char perfstring[DEFAULT_BUFFER_SIZE];
+char header_expect[MAX_INPUT_BUFFER] = "";
+char string_expect[MAX_INPUT_BUFFER] = "";
+char server_expect[MAX_INPUT_BUFFER] = HTTP_EXPECT;
+int server_expect_yn = 0;
+char user_auth[MAX_INPUT_BUFFER] = "";
+char proxy_auth[MAX_INPUT_BUFFER] = "";
+char **http_opt_headers;
+int http_opt_headers_count = 0;
+int display_html = FALSE;
+int onredirect = STATE_OK;
+int followmethod = FOLLOW_HTTP_CURL;
+int followsticky = STICKY_NONE;
+int use_ssl = FALSE;
+int use_sni = TRUE;
+int check_cert = FALSE;
+typedef union {
+  struct curl_slist* to_info;
+  struct curl_certinfo* to_certinfo;
+} cert_ptr_union;
+cert_ptr_union cert_ptr;
+int ssl_version = CURL_SSLVERSION_DEFAULT;
+char *client_cert = NULL;
+char *client_privkey = NULL;
+char *ca_cert = NULL;
+int is_openssl_callback = FALSE;
+#if defined(HAVE_SSL) && defined(USE_OPENSSL)
+X509 *cert = NULL;
+#endif /* defined(HAVE_SSL) && defined(USE_OPENSSL) */
+int no_body = FALSE;
+int maximum_age = -1;
+int address_family = AF_UNSPEC;
+curlhelp_ssl_library ssl_library = CURLHELP_SSL_LIBRARY_UNKNOWN;
+
+int process_arguments (int, char**);
+void handle_curl_option_return_code (CURLcode res, const char* option);
+int check_http (void);
+void redir (curlhelp_write_curlbuf*);
+void print_help (void);
+void print_usage (void);
+void print_curl_version (void);
+int curlhelp_initwritebuffer (curlhelp_write_curlbuf*);
+int curlhelp_buffer_write_callback (void*, size_t , size_t , void*);
+void curlhelp_freewritebuffer (curlhelp_write_curlbuf*);
+int curlhelp_initreadbuffer (curlhelp_read_curlbuf *, const char *, size_t);
+int curlhelp_buffer_read_callback (void *, size_t , size_t , void *);
+void curlhelp_freereadbuffer (curlhelp_read_curlbuf *);
+curlhelp_ssl_library curlhelp_get_ssl_library (CURL*);
+const char* curlhelp_get_ssl_library_string (curlhelp_ssl_library);
+int net_noopenssl_check_certificate (cert_ptr_union*, int, int);
+
+int curlhelp_parse_statusline (const char*, curlhelp_statusline *);
+void curlhelp_free_statusline (curlhelp_statusline *);
+char *perfd_time_ssl (double microsec);
+char *get_header_value (const struct phr_header* headers, const size_t nof_headers, const char* header);
+int check_document_dates (const curlhelp_write_curlbuf *, char (*msg)[DEFAULT_BUFFER_SIZE]);
+int get_content_length (const curlhelp_write_curlbuf* header_buf, const curlhelp_write_curlbuf* body_buf);
+
+#if defined(HAVE_SSL) && defined(USE_OPENSSL)
+int np_net_ssl_check_certificate(X509 *certificate, int days_till_exp_warn, int days_till_exp_crit);
+#endif /* defined(HAVE_SSL) && defined(USE_OPENSSL) */
+
+void remove_newlines (char *);
+void test_file (char *);
+
+int
+main (int argc, char **argv)
+{
+  int result = STATE_UNKNOWN;
+
+  setlocale (LC_ALL, "");
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
+
+  /* Parse extra opts if any */
+  argv = np_extra_opts (&argc, argv, progname);
+
+  /* set defaults */
+  snprintf( user_agent, DEFAULT_BUFFER_SIZE, "%s/v%s (monitoring-plugins %s)",
+    progname, NP_VERSION, VERSION);
+
+  /* parse arguments */
+  if (process_arguments (argc, argv) == ERROR)
+    usage4 (_("Could not parse arguments"));
+
+  if (display_html == TRUE)
+    printf ("<A HREF=\"%s://%s:%d%s\" target=\"_blank\">",
+      use_ssl ? "https" : "http", host_name ? host_name : server_address,
+      server_port, server_url);
+
+  result = check_http ();
+  return result;
+}
+
+#ifdef HAVE_SSL
+#ifdef USE_OPENSSL
+
+int verify_callback(int preverify_ok, X509_STORE_CTX *x509_ctx)
+{
+  /* TODO: we get all certificates of the chain, so which ones
+   * should we test?
+   * TODO: is the last certificate always the server certificate?
+   */
+  cert = X509_STORE_CTX_get_current_cert(x509_ctx);
+  return 1;
+}
+
+CURLcode sslctxfun(CURL *curl, SSL_CTX *sslctx, void *parm)
+{
+  SSL_CTX_set_verify(sslctx, SSL_VERIFY_PEER, verify_callback);
+
+  return CURLE_OK;
+}
+
+#endif /* USE_OPENSSL */
+#endif /* HAVE_SSL */
+
+/* Checks if the server 'reply' is one of the expected 'statuscodes' */
+static int
+expected_statuscode (const char *reply, const char *statuscodes)
+{
+  char *expected, *code;
+  int result = 0;
+
+  if ((expected = strdup (statuscodes)) == NULL)
+    die (STATE_UNKNOWN, _("HTTP UNKNOWN - Memory allocation error\n"));
+
+  for (code = strtok (expected, ","); code != NULL; code = strtok (NULL, ","))
+    if (strstr (reply, code) != NULL) {
+      result = 1;
+      break;
+    }
+
+  free (expected);
+  return result;
+}
+
+void
+handle_curl_option_return_code (CURLcode res, const char* option)
+{
+  if (res != CURLE_OK) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, _("Error while setting cURL option '%s': cURL returned %d - %s"),
+      option, res, curl_easy_strerror(res));
+    die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
+  }
+}
+
+int
+check_http (void)
+{
+  int result = STATE_OK;
+  int page_len = 0;
+  int i;
+  char *force_host_header = NULL;
+
+  /* initialize curl */
+  if (curl_global_init (CURL_GLOBAL_DEFAULT) != CURLE_OK)
+    die (STATE_UNKNOWN, "HTTP UNKNOWN - curl_global_init failed\n");
+
+  if ((curl = curl_easy_init()) == NULL)
+    die (STATE_UNKNOWN, "HTTP UNKNOWN - curl_easy_init failed\n");
+
+  if (verbose >= 1)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_VERBOSE, TRUE), "CURLOPT_VERBOSE");
+
+  /* print everything on stdout like check_http would do */
+  handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_STDERR, stdout), "CURLOPT_STDERR");
+
+  /* initialize buffer for body of the answer */
+  if (curlhelp_initwritebuffer(&body_buf) < 0)
+    die (STATE_UNKNOWN, "HTTP CRITICAL - out of memory allocating buffer for body\n");
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)curlhelp_buffer_write_callback), "CURLOPT_WRITEFUNCTION");
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEDATA, (void *)&body_buf), "CURLOPT_WRITEDATA");
+
+  /* initialize buffer for header of the answer */
+  if (curlhelp_initwritebuffer( &header_buf ) < 0)
+    die (STATE_UNKNOWN, "HTTP CRITICAL - out of memory allocating buffer for header\n" );
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)curlhelp_buffer_write_callback), "CURLOPT_HEADERFUNCTION");
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEHEADER, (void *)&header_buf), "CURLOPT_WRITEHEADER");
+
+  /* set the error buffer */
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, errbuf), "CURLOPT_ERRORBUFFER");
+
+  /* set timeouts */
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, socket_timeout), "CURLOPT_CONNECTTIMEOUT");
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_TIMEOUT, socket_timeout), "CURLOPT_TIMEOUT");
+
+  /* compose URL: must be the host_name, only if not given take the IP address. */
+  snprintf (url, DEFAULT_BUFFER_SIZE, "%s://%s%s", use_ssl ? "https" : "http",
+    host_name ? host_name : server_address, server_url);
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_URL, url), "CURLOPT_URL");
+
+  /* cURL does certificate checking with this host_name (and not the virtual host?
+   * So we force CURLOPT_RESOLVE to make sure the resolver pickes the right IP
+   * for this hostname. */
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 21, 3)
+  if (host_name && strcmp (host_name, server_address)) {
+    snprintf (server_ip, DEFAULT_BUFFER_SIZE, "%s:%d:%s", host_name, server_port, server_address);
+    server_ips = curl_slist_append (server_ips, server_ip);
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_RESOLVE, server_ips), "CURLOPT_RESOLVE");
+  }
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 21, 3) */
+
+  /* extract proxy information for legacy proxy https requests */
+  if (!strcmp(http_method, "CONNECT") || strstr(server_url, "http") == server_url) {
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXY, server_address), "CURLOPT_PROXY");
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXYPORT, (long)server_port), "CURLOPT_PROXYPORT");
+    if (verbose>=2)
+      printf ("* curl CURLOPT_PROXY: %s:%d\n", server_address, server_port);
+    http_method = "GET";
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_URL, server_url), "CURLOPT_URL");
+    virtual_port = use_ssl ? HTTPS_PORT : HTTP_PORT;
+  } else {
+    /* set port */
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PORT, server_port), "CURLOPT_PORT");
+  }
+
+  /* set HTTP method */
+  if (http_method) {
+    if (!strcmp(http_method, "POST"))
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_POST, 1), "CURLOPT_POST");
+    else if (!strcmp(http_method, "PUT"))
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_UPLOAD, 1), "CURLOPT_UPLOAD");
+    else
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, http_method), "CURLOPT_CUSTOMREQUEST");
+  }
+
+  /* set hostname (virtual hosts) */
+  if(host_name != NULL) {
+    if((virtual_port != HTTP_PORT && !use_ssl) || (virtual_port != HTTPS_PORT && use_ssl)) {
+      snprintf(http_header, DEFAULT_BUFFER_SIZE, "Host: %s:%d", host_name, virtual_port);
+    } else {
+      snprintf(http_header, DEFAULT_BUFFER_SIZE, "Host: %s", host_name);
+    }
+    header_list = curl_slist_append (header_list, http_header);
+  }
+
+  /* always close connection, be nice to servers */
+  snprintf (http_header, DEFAULT_BUFFER_SIZE, "Connection: close");
+  header_list = curl_slist_append (header_list, http_header);
+
+  /* check if Host header is explicitly set in options */
+  if (http_opt_headers_count) {
+    for (i = 0; i < http_opt_headers_count ; i++) {
+      if (strncmp(http_opt_headers[i], "Host:", 5) == 0) {
+        force_host_header = http_opt_headers[i];
+      }
+    }
+  }
+
+  /* attach additional headers supplied by the user */
+  /* optionally send any other header tag */
+  if (http_opt_headers_count) {
+    for (i = 0; i < http_opt_headers_count ; i++) {
+      if (force_host_header != http_opt_headers[i]) {
+        header_list = curl_slist_append (header_list, http_opt_headers[i]);
+      }
+    }
+    /* This cannot be free'd here because a redirection will then try to access this and segfault */
+    /* Covered in a testcase in tests/check_http.t */
+    /* free(http_opt_headers); */
+  }
+
+  /* set HTTP headers */
+  handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_HTTPHEADER, header_list ), "CURLOPT_HTTPHEADER");
+
+#ifdef LIBCURL_FEATURE_SSL
+
+  /* set SSL version, warn about unsecure or unsupported versions */
+  if (use_ssl) {
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLVERSION, ssl_version), "CURLOPT_SSLVERSION");
+  }
+
+  /* client certificate and key to present to server (SSL) */
+  if (client_cert)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLCERT, client_cert), "CURLOPT_SSLCERT");
+  if (client_privkey)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLKEY, client_privkey), "CURLOPT_SSLKEY");
+  if (ca_cert) {
+    /* per default if we have a CA verify both the peer and the
+     * hostname in the certificate, can be switched off later */
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CAINFO, ca_cert), "CURLOPT_CAINFO");
+    handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_SSL_VERIFYPEER, 1), "CURLOPT_SSL_VERIFYPEER");
+    handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_SSL_VERIFYHOST, 2), "CURLOPT_SSL_VERIFYHOST");
+  } else {
+    /* backward-compatible behaviour, be tolerant in checks
+     * TODO: depending on more options have aspects we want
+     * to be less tolerant about ssl verfications
+     */
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0), "CURLOPT_SSL_VERIFYPEER");
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0), "CURLOPT_SSL_VERIFYHOST");
+  }
+
+  /* detect SSL library used by libcurl */
+  ssl_library = curlhelp_get_ssl_library (curl);
+
+  /* try hard to get a stack of certificates to verify against */
+  if (check_cert)
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1)
+    /* inform curl to report back certificates */
+    switch (ssl_library) {
+      case CURLHELP_SSL_LIBRARY_OPENSSL:
+      case CURLHELP_SSL_LIBRARY_LIBRESSL:
+        /* set callback to extract certificate with OpenSSL context function (works with
+         * OpenSSL-style libraries only!) */
+#ifdef USE_OPENSSL
+        /* libcurl and monitoring plugins built with OpenSSL, good */
+        handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun), "CURLOPT_SSL_CTX_FUNCTION");
+        is_openssl_callback = TRUE;
+#else /* USE_OPENSSL */
+#endif /* USE_OPENSSL */
+        /* libcurl is built with OpenSSL, monitoring plugins, so falling
+         * back to manually extracting certificate information */
+        handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO");
+        break;
+
+      case CURLHELP_SSL_LIBRARY_NSS:
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
+        /* NSS: support for CERTINFO is implemented since 7.34.0 */
+        handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO");
+#else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
+        die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (libcurl linked with SSL library '%s' is too old)\n", curlhelp_get_ssl_library_string (ssl_library));
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
+        break;
+
+      case CURLHELP_SSL_LIBRARY_GNUTLS:
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0)
+        /* GnuTLS: support for CERTINFO is implemented since 7.42.0 */
+        handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO");
+#else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) */
+        die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (libcurl linked with SSL library '%s' is too old)\n", curlhelp_get_ssl_library_string (ssl_library));
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) */
+        break;
+
+      case CURLHELP_SSL_LIBRARY_UNKNOWN:
+      default:
+        die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (unknown SSL library '%s', must implement first)\n", curlhelp_get_ssl_library_string (ssl_library));
+        break;
+    }
+#else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) */
+    /* old libcurl, our only hope is OpenSSL, otherwise we are out of luck */
+    if (ssl_library == CURLHELP_SSL_LIBRARY_OPENSSL || ssl_library == CURLHELP_SSL_LIBRARY_LIBRESSL)
+      handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun), "CURLOPT_SSL_CTX_FUNCTION");
+    else
+      die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (no CURLOPT_SSL_CTX_FUNCTION, no OpenSSL library or libcurl too old and has no CURLOPT_CERTINFO)\n");
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) */
+
+#endif /* LIBCURL_FEATURE_SSL */
+
+  /* set default or user-given user agent identification */
+  handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_USERAGENT, user_agent), "CURLOPT_USERAGENT");
+
+  /* proxy-authentication */
+  if (strcmp(proxy_auth, ""))
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXYUSERPWD, proxy_auth), "CURLOPT_PROXYUSERPWD");
+
+  /* authentication */
+  if (strcmp(user_auth, ""))
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_USERPWD, user_auth), "CURLOPT_USERPWD");
+
+  /* TODO: parameter auth method, bitfield of following methods:
+   * CURLAUTH_BASIC (default)
+   * CURLAUTH_DIGEST
+   * CURLAUTH_DIGEST_IE
+   * CURLAUTH_NEGOTIATE
+   * CURLAUTH_NTLM
+   * CURLAUTH_NTLM_WB
+   *
+   * convenience tokens for typical sets of methods:
+   * CURLAUTH_ANYSAFE: most secure, without BASIC
+   * or CURLAUTH_ANY: most secure, even BASIC if necessary
+   *
+   * handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_DIGEST ), "CURLOPT_HTTPAUTH");
+   */
+
+  /* handle redirections */
+  if (onredirect == STATE_DEPENDENT) {
+    if( followmethod == FOLLOW_LIBCURL ) {
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_FOLLOWLOCATION, 1), "CURLOPT_FOLLOWLOCATION");
+
+      /* default -1 is infinite, not good, could lead to zombie plugins!
+         Setting it to one bigger than maximal limit to handle errors nicely below
+       */
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_MAXREDIRS, max_depth+1), "CURLOPT_MAXREDIRS");
+
+      /* for now allow only http and https (we are a http(s) check plugin in the end) */
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 4)
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS), "CURLOPT_REDIRECT_PROTOCOLS");
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 4) */
+
+      /* TODO: handle the following aspects of redirection, make them
+       * command line options too later:
+        CURLOPT_POSTREDIR: method switch
+        CURLINFO_REDIRECT_URL: custom redirect option
+        CURLOPT_REDIRECT_PROTOCOLS: allow people to step outside safe protocols
+        CURLINFO_REDIRECT_COUNT: get the number of redirects, print it, maybe a range option here is nice like for expected page size?
+      */
+    } else {
+      /* old style redirection is handled below */
+    }
+  }
+
+  /* no-body */
+  if (no_body)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_NOBODY, 1), "CURLOPT_NOBODY");
+
+  /* IPv4 or IPv6 forced DNS resolution */
+  if (address_family == AF_UNSPEC)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_WHATEVER)");
+  else if (address_family == AF_INET)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_V4)");
+#if defined (USE_IPV6) && defined (LIBCURL_FEATURE_IPV6)
+  else if (address_family == AF_INET6)
+    handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_V6)");
+#endif
+
+  /* either send http POST data (any data, not only POST)*/
+  if (!strcmp(http_method, "POST") ||!strcmp(http_method, "PUT")) {
+    /* set content of payload for POST and PUT */
+    if (http_content_type) {
+      snprintf (http_header, DEFAULT_BUFFER_SIZE, "Content-Type: %s", http_content_type);
+      header_list = curl_slist_append (header_list, http_header);
+    }
+    /* NULL indicates "HTTP Continue" in libcurl, provide an empty string
+     * in case of no POST/PUT data */
+    if (!http_post_data)
+      http_post_data = "";
+    if (!strcmp(http_method, "POST")) {
+      /* POST method, set payload with CURLOPT_POSTFIELDS */
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_POSTFIELDS, http_post_data), "CURLOPT_POSTFIELDS");
+    } else if (!strcmp(http_method, "PUT")) {
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_READFUNCTION, (curl_read_callback)curlhelp_buffer_read_callback), "CURLOPT_READFUNCTION");
+      curlhelp_initreadbuffer (&put_buf, http_post_data, strlen (http_post_data));
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_READDATA, (void *)&put_buf), "CURLOPT_READDATA");
+      handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_INFILESIZE, (curl_off_t)strlen (http_post_data)), "CURLOPT_INFILESIZE");
+    }
+  }
+
+  /* do the request */
+  res = curl_easy_perform(curl);
+
+  if (verbose>=2 && http_post_data)
+    printf ("**** REQUEST CONTENT ****\n%s\n", http_post_data);
+
+  /* free header and server IP resolve lists, we don't need it anymore */
+  curl_slist_free_all (header_list); header_list = NULL;
+  curl_slist_free_all (server_ips); server_ips = NULL;
+
+  /* Curl errors, result in critical Nagios state */
+  if (res != CURLE_OK) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host on port %d: cURL returned %d - %s"),
+      server_port, res, curl_easy_strerror(res));
+    die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
+  }
+
+  /* certificate checks */
+#ifdef LIBCURL_FEATURE_SSL
+  if (use_ssl == TRUE) {
+    if (check_cert == TRUE) {
+      if (is_openssl_callback) {
+#ifdef USE_OPENSSL
+        /* check certificate with OpenSSL functions, curl has been built against OpenSSL
+         * and we actually have OpenSSL in the monitoring tools
+         */
+        result = np_net_ssl_check_certificate(cert, days_till_exp_warn, days_till_exp_crit);
+        return result;
+#else /* USE_OPENSSL */
+        die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates - OpenSSL callback used and not linked against OpenSSL\n");
+#endif /* USE_OPENSSL */
+      } else {
+        int i;
+        struct curl_slist *slist;
+
+        cert_ptr.to_info = NULL;
+        res = curl_easy_getinfo (curl, CURLINFO_CERTINFO, &cert_ptr.to_info);
+        if (!res && cert_ptr.to_info) {
+#ifdef USE_OPENSSL
+          /* We have no OpenSSL in libcurl, but we can use OpenSSL for X509 cert parsing
+           * We only check the first certificate and assume it's the one of the server
+           */
+          const char* raw_cert = NULL;
+          for (i = 0; i < cert_ptr.to_certinfo->num_of_certs; i++) {
+            for (slist = cert_ptr.to_certinfo->certinfo[i]; slist; slist = slist->next) {
+              if (verbose >= 2)
+                printf ("%d ** %s\n", i, slist->data);
+              if (strncmp (slist->data, "Cert:", 5) == 0) {
+                raw_cert = &slist->data[5];
+                goto GOT_FIRST_CERT;
+              }
+            }
+          }
+GOT_FIRST_CERT:
+          if (!raw_cert) {
+            snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot retrieve certificates from CERTINFO information - certificate data was empty"));
+            die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
+          }
+          BIO* cert_BIO = BIO_new (BIO_s_mem());
+          BIO_write (cert_BIO, raw_cert, strlen(raw_cert));
+          cert = PEM_read_bio_X509 (cert_BIO, NULL, NULL, NULL);
+          if (!cert) {
+            snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot read certificate from CERTINFO information - BIO error"));
+            die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
+          }
+          BIO_free (cert_BIO);
+          result = np_net_ssl_check_certificate(cert, days_till_exp_warn, days_till_exp_crit);
+          return result;
+#else /* USE_OPENSSL */
+          /* We assume we don't have OpenSSL and np_net_ssl_check_certificate at our disposal,
+           * so we use the libcurl CURLINFO data
+           */
+          result = net_noopenssl_check_certificate(&cert_ptr, days_till_exp_warn, days_till_exp_crit);
+          return result;
+#endif /* USE_OPENSSL */
+        } else {
+          snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot retrieve certificates - cURL returned %d - %s"),
+            res, curl_easy_strerror(res));
+          die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
+        }
+      }
+    }
+  }
+#endif /* LIBCURL_FEATURE_SSL */
+
+  /* we got the data and we executed the request in a given time, so we can append
+   * performance data to the answer always
+   */
+  handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_TOTAL_TIME, &total_time), "CURLINFO_TOTAL_TIME");
+  if(show_extended_perfdata) {
+    handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &time_connect), "CURLINFO_CONNECT_TIME");
+    handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_APPCONNECT_TIME, &time_appconnect), "CURLINFO_APPCONNECT_TIME");
+    handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME, &time_headers), "CURLINFO_PRETRANSFER_TIME");
+    handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_STARTTRANSFER_TIME, &time_firstbyte), "CURLINFO_STARTTRANSFER_TIME");
+    snprintf(perfstring, DEFAULT_BUFFER_SIZE, "time=%.6gs;%.6g;%.6g;; size=%dB;;; time_connect=%.6gs;;;; %s time_headers=%.6gs;;;; time_firstbyte=%.6gs;;;; time_transfer=%.6gs;;;;",
+      total_time,
+      warning_thresholds != NULL ? (double)thlds->warning->end : 0.0,
+      critical_thresholds != NULL ? (double)thlds->critical->end : 0.0,
+      (int)body_buf.buflen,
+      time_connect,
+      use_ssl == TRUE ? perfd_time_ssl(time_appconnect-time_connect) : "",
+      (time_headers - time_appconnect),
+      (time_firstbyte - time_headers),
+      (total_time-time_firstbyte)
+      );
+  } else {
+    snprintf(perfstring, DEFAULT_BUFFER_SIZE, "time=%.6gs;%.6g;%.6g;; size=%dB;;;",
+      total_time,
+      warning_thresholds != NULL ? (double)thlds->warning->end : 0.0,
+      critical_thresholds != NULL ? (double)thlds->critical->end : 0.0,
+      (int)body_buf.buflen);
+  }
+
+  /* return a CRITICAL status if we couldn't read any data */
+  if (strlen(header_buf.buf) == 0 && strlen(body_buf.buf) == 0)
+    die (STATE_CRITICAL, _("HTTP CRITICAL - No header received from host\n"));
+
+  /* get status line of answer, check sanity of HTTP code */
+  if (curlhelp_parse_statusline (header_buf.buf, &status_line) < 0) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, "Unparseable status line in %.3g seconds response time|%s\n",
+      total_time, perfstring);
+    die (STATE_CRITICAL, "HTTP CRITICAL HTTP/1.x %ld unknown - %s", code, msg);
+  }
+
+  /* get result code from cURL */
+  handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &code), "CURLINFO_RESPONSE_CODE");
+  if (verbose>=2)
+    printf ("* curl CURLINFO_RESPONSE_CODE is %ld\n", code);
+
+  /* print status line, header, body if verbose */
+  if (verbose >= 2) {
+    printf ("**** HEADER ****\n%s\n**** CONTENT ****\n%s\n", header_buf.buf,
+                (no_body ? "  [[ skipped ]]" : body_buf.buf));
+  }
+
+  /* make sure the status line matches the response we are looking for */
+  if (!expected_statuscode(status_line.first_line, server_expect)) {
+    /* TODO: fix first_line being cut off */
+    if (server_port == HTTP_PORT)
+      snprintf(msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host: %s\n"), status_line.first_line);
+    else
+      snprintf(msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host on port %d: %s\n"), server_port, status_line.first_line);
+    die (STATE_CRITICAL, "HTTP CRITICAL - %s", msg);
+  }
+
+  /* TODO: implement -d header tests */
+  if( server_expect_yn  )  {
+    snprintf(msg, DEFAULT_BUFFER_SIZE, _("Status line output matched \"%s\" - "), server_expect);
+    if (verbose)
+      printf ("%s\n",msg);
+    result = STATE_OK;
+  }
+  else {
+    /* illegal return codes result in a critical state */
+    if (code >= 600 || code < 100) {
+      die (STATE_CRITICAL, _("HTTP CRITICAL: Invalid Status (%d, %.40s)\n"), status_line.http_code, status_line.msg);
+    /* server errors result in a critical state */
+        } else if (code >= 500) {
+      result = STATE_CRITICAL;
+        /* client errors result in a warning state */
+    } else if (code >= 400) {
+      result = STATE_WARNING;
+    /* check redirected page if specified */
+    } else if (code >= 300) {
+      if (onredirect == STATE_DEPENDENT) {
+        if( followmethod == FOLLOW_LIBCURL ) {
+          code = status_line.http_code;
+        } else {
+          /* old check_http style redirection, if we come
+           * back here, we are in the same status as with
+           * the libcurl method
+           */
+          redir (&header_buf);
+        }
+      } else {
+        /* this is a specific code in the command line to
+         * be returned when a redirection is encoutered
+         */
+      }
+      result = max_state_alt (onredirect, result);
+    /* all other codes are considered ok */
+    } else {
+      result = STATE_OK;
+    }
+  }
+
+  /* libcurl redirection internally, handle error states here */
+  if( followmethod == FOLLOW_LIBCURL ) {
+    handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_REDIRECT_COUNT, &redir_depth), "CURLINFO_REDIRECT_COUNT");
+    if (verbose >= 2)
+      printf(_("* curl LIBINFO_REDIRECT_COUNT is %d\n"), redir_depth);
+    if (redir_depth > max_depth) {
+      snprintf (msg, DEFAULT_BUFFER_SIZE, "maximum redirection depth %d exceeded in libcurl",
+        max_depth);
+      die (STATE_WARNING, "HTTP WARNING - %s", msg);
+    }
+  }
+
+  /* check status codes, set exit status accordingly */
+  if( status_line.http_code != code ) {
+    die (STATE_CRITICAL, _("HTTP CRITICAL HTTP/%d.%d %d %s - different HTTP codes (cUrl has %ld)\n"),
+      status_line.http_major, status_line.http_minor,
+      status_line.http_code, status_line.msg, code);
+  }
+
+  if (maximum_age >= 0) {
+    result = max_state_alt(check_document_dates(&header_buf, &msg), result);
+  }
+
+  /* Page and Header content checks go here */
+
+  if (strlen (header_expect)) {
+    if (!strstr (header_buf.buf, header_expect)) {
+      strncpy(&output_header_search[0],header_expect,sizeof(output_header_search));
+      if(output_header_search[sizeof(output_header_search)-1]!='\0') {
+        bcopy("...",&output_header_search[sizeof(output_header_search)-4],4);
+      }
+      snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sheader '%s' not found on '%s://%s:%d%s', "), msg, output_header_search, use_ssl ? "https" : "http", host_name ? host_name : server_address, server_port, server_url);
+      result = STATE_CRITICAL;
+    }
+  }
+
+  if (strlen (string_expect)) {
+    if (!strstr (body_buf.buf, string_expect)) {
+      strncpy(&output_string_search[0],string_expect,sizeof(output_string_search));
+      if(output_string_search[sizeof(output_string_search)-1]!='\0') {
+        bcopy("...",&output_string_search[sizeof(output_string_search)-4],4);
+      }
+      snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sstring '%s' not found on '%s://%s:%d%s', "), msg, output_string_search, use_ssl ? "https" : "http", host_name ? host_name : server_address, server_port, server_url);
+      result = STATE_CRITICAL;
+    }
+  }
+
+  if (strlen (regexp)) {
+    errcode = regexec (&preg, body_buf.buf, REGS, pmatch, 0);
+    if ((errcode == 0 && invert_regex == 0) || (errcode == REG_NOMATCH && invert_regex == 1)) {
+      /* OK - No-op to avoid changing the logic around it */
+      result = max_state_alt(STATE_OK, result);
+    }
+    else if ((errcode == REG_NOMATCH && invert_regex == 0) || (errcode == 0 && invert_regex == 1)) {
+      if (invert_regex == 0)
+        snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spattern not found, "), msg);
+      else
+        snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spattern found, "), msg);
+      result = STATE_CRITICAL;
+    }
+    else {
+      /* FIXME: Shouldn't that be UNKNOWN? */
+      regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
+      snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sExecute Error: %s, "), msg, errbuf);
+      result = STATE_CRITICAL;
+    }
+  }
+
+  /* make sure the page is of an appropriate size
+   * TODO: as far I can tell check_http gets the full size of header and
+   * if -N is not given header+body. Does this make sense?
+   *
+   * TODO: check_http.c had a get_length function, the question is really
+   * here what to use? the raw data size of the header_buf, the value of
+   * Content-Length, both and warn if they differ? Should the length be
+   * header+body or only body?
+   *
+   * One possible policy:
+   * - use header_buf.buflen (warning, if it mismatches to the Content-Length value
+   * - if -N (nobody) is given, use Content-Length only and hope the server set
+   *   the value correcly
+   */
+  page_len = get_content_length(&header_buf, &body_buf);
+  if ((max_page_len > 0) && (page_len > max_page_len)) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spage size %d too large, "), msg, page_len);
+    result = max_state_alt(STATE_WARNING, result);
+  } else if ((min_page_len > 0) && (page_len < min_page_len)) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spage size %d too small, "), msg, page_len);
+    result = max_state_alt(STATE_WARNING, result);
+  }
+
+  /* -w, -c: check warning and critical level */
+  result = max_state_alt(get_status(total_time, thlds), result);
+
+  /* Cut-off trailing characters */
+  if(msg[strlen(msg)-2] == ',')
+    msg[strlen(msg)-2] = '\0';
+  else
+    msg[strlen(msg)-3] = '\0';
+
+  /* TODO: separate _() msg and status code: die (result, "HTTP %s: %s\n", state_text(result), msg); */
+  die (result, "HTTP %s: HTTP/%d.%d %d %s%s%s - %d bytes in %.3f second response time %s|%s\n",
+    state_text(result), status_line.http_major, status_line.http_minor,
+    status_line.http_code, status_line.msg,
+    strlen(msg) > 0 ? " - " : "",
+    msg, page_len, total_time,
+    (display_html ? "</A>" : ""),
+    perfstring);
+
+  /* proper cleanup after die? */
+  curlhelp_free_statusline(&status_line);
+  curl_easy_cleanup (curl);
+  curl_global_cleanup ();
+  curlhelp_freewritebuffer (&body_buf);
+  curlhelp_freewritebuffer (&header_buf);
+  if (!strcmp (http_method, "PUT")) {
+    curlhelp_freereadbuffer (&put_buf);
+  }
+
+  return result;
+}
+
+int
+uri_strcmp (const UriTextRangeA range, const char* s)
+{
+  if (!range.first) return -1;
+  if (range.afterLast - range.first < strlen (s)) return -1;
+  return strncmp (s, range.first, min( range.afterLast - range.first, strlen (s)));
+}
+
+char*
+uri_string (const UriTextRangeA range, char* buf, size_t buflen)
+{
+  if (!range.first) return "(null)";
+  strncpy (buf, range.first, max (buflen, range.afterLast - range.first));
+  buf[max (buflen, range.afterLast - range.first)] = '\0';
+  buf[range.afterLast - range.first] = '\0';
+  return buf;
+}
+
+void
+redir (curlhelp_write_curlbuf* header_buf)
+{
+  char *location = NULL;
+  curlhelp_statusline status_line;
+  struct phr_header headers[255];
+  size_t nof_headers = 255;
+  size_t msglen;
+  char buf[DEFAULT_BUFFER_SIZE];
+  char ipstr[INET_ADDR_MAX_SIZE];
+  int new_port;
+  char *new_host;
+  char *new_url;
+
+  int res = phr_parse_response (header_buf->buf, header_buf->buflen,
+    &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen,
+    headers, &nof_headers, 0);
+
+  location = get_header_value (headers, nof_headers, "location");
+
+  if (verbose >= 2)
+    printf(_("* Seen redirect location %s\n"), location);
+
+  if (++redir_depth > max_depth)
+    die (STATE_WARNING,
+         _("HTTP WARNING - maximum redirection depth %d exceeded - %s%s\n"),
+         max_depth, location, (display_html ? "</A>" : ""));
+
+  UriParserStateA state;
+  UriUriA uri;
+  state.uri = &uri;
+  if (uriParseUriA (&state, location) != URI_SUCCESS) {
+    if (state.errorCode == URI_ERROR_SYNTAX) {
+      die (STATE_UNKNOWN,
+           _("HTTP UNKNOWN - Could not parse redirect location '%s'%s\n"),
+           location, (display_html ? "</A>" : ""));
+    } else if (state.errorCode == URI_ERROR_MALLOC) {
+      die (STATE_UNKNOWN, _("HTTP UNKNOWN - Could not allocate URL\n"));
+    }
+  }
+
+  if (verbose >= 2) {
+    printf (_("** scheme: %s\n"),
+      uri_string (uri.scheme, buf, DEFAULT_BUFFER_SIZE));
+    printf (_("** host: %s\n"),
+      uri_string (uri.hostText, buf, DEFAULT_BUFFER_SIZE));
+    printf (_("** port: %s\n"),
+      uri_string (uri.portText, buf, DEFAULT_BUFFER_SIZE));
+    if (uri.hostData.ip4) {
+      inet_ntop (AF_INET, uri.hostData.ip4->data, ipstr, sizeof (ipstr));
+      printf (_("** IPv4: %s\n"), ipstr);
+    }
+    if (uri.hostData.ip6) {
+      inet_ntop (AF_INET, uri.hostData.ip6->data, ipstr, sizeof (ipstr));
+      printf (_("** IPv6: %s\n"), ipstr);
+    }
+    if (uri.pathHead) {
+      printf (_("** path: "));
+      const UriPathSegmentA* p = uri.pathHead;
+      for (; p; p = p->next) {
+        printf ("/%s", uri_string (p->text, buf, DEFAULT_BUFFER_SIZE));
+      }
+      puts ("");
+    }
+    if (uri.query.first) {
+      printf (_("** query: %s\n"),
+      uri_string (uri.query, buf, DEFAULT_BUFFER_SIZE));
+    }
+    if (uri.fragment.first) {
+      printf (_("** fragment: %s\n"),
+      uri_string (uri.fragment, buf, DEFAULT_BUFFER_SIZE));
+    }
+  }
+
+  use_ssl = !uri_strcmp (uri.scheme, "https");
+
+  /* we do a sloppy test here only, because uriparser would have failed
+   * above, if the port would be invalid, we just check for MAX_PORT
+   */
+  if (uri.portText.first) {
+    new_port = atoi (uri_string (uri.portText, buf, DEFAULT_BUFFER_SIZE));
+  } else {
+    new_port = HTTP_PORT;
+    if (use_ssl)
+      new_port = HTTPS_PORT;
+  }
+  if (new_port > MAX_PORT)
+    die (STATE_UNKNOWN,
+         _("HTTP UNKNOWN - Redirection to port above %d - %s%s\n"),
+         MAX_PORT, location, display_html ? "</A>" : "");
+
+  /* by RFC 7231 relative URLs in Location should be taken relative to
+   * the original URL, so wy try to form a new absolute URL here
+   */
+  if (!uri.scheme.first && !uri.hostText.first) {
+    /* TODO: implement */
+    die (STATE_UNKNOWN, _("HTTP UNKNOWN - non-absolute location, not implemented yet!\n"));
+    new_host = strdup (host_name ? host_name : server_address);
+  } else {
+    new_host = strdup (uri_string (uri.hostText, buf, DEFAULT_BUFFER_SIZE));
+  }
+
+  /* compose new path */
+  /* TODO: handle fragments and query part of URL */
+  new_url = (char *)calloc( 1, DEFAULT_BUFFER_SIZE);
+  if (uri.pathHead) {
+    const UriPathSegmentA* p = uri.pathHead;
+    for (; p; p = p->next) {
+      strncat (new_url, "/", DEFAULT_BUFFER_SIZE);
+      strncat (new_url, uri_string (p->text, buf, DEFAULT_BUFFER_SIZE), DEFAULT_BUFFER_SIZE);
+    }
+  }
+
+  if (server_port==new_port &&
+      !strncmp(server_address, new_host, MAX_IPV4_HOSTLENGTH) &&
+      (host_name && !strncmp(host_name, new_host, MAX_IPV4_HOSTLENGTH)) &&
+      !strcmp(server_url, new_url))
+    die (STATE_WARNING,
+         _("HTTP WARNING - redirection creates an infinite loop - %s://%s:%d%s%s\n"),
+         use_ssl ? "https" : "http", new_host, new_port, new_url, (display_html ? "</A>" : ""));
+
+  /* set new values for redirected request */
+
+  if (!(followsticky & STICKY_HOST)) {
+    free (server_address);
+    server_address = strndup (new_host, MAX_IPV4_HOSTLENGTH);
+  }
+  if (!(followsticky & STICKY_PORT)) {
+    server_port = (unsigned short)new_port;
+  }
+
+  free (host_name);
+  host_name = strndup (new_host, MAX_IPV4_HOSTLENGTH);
+
+  /* reset virtual port */
+  virtual_port = server_port;
+
+  free(new_host);
+  free (server_url);
+  server_url = new_url;
+
+  uriFreeUriMembersA (&uri);
+
+  if (verbose)
+    printf (_("Redirection to %s://%s:%d%s\n"), use_ssl ? "https" : "http",
+            host_name ? host_name : server_address, server_port, server_url);
+
+  /* TODO: the hash component MUST be taken from the original URL and
+   * attached to the URL in Location
+   */
+
+  check_http ();
+}
+
+#if 0
+
+int main(int argc, char *argv[]) {
+
+        for (; i < argc; i++) {
+
+                }
+                printf("\n");
+#endif
+
+/* check whether a file exists */
+void
+test_file (char *path)
+{
+  if (access(path, R_OK) == 0)
+    return;
+  usage2 (_("file does not exist or is not readable"), path);
+}
+
+int
+process_arguments (int argc, char **argv)
+{
+  char *p;
+  int c = 1;
+  char *temp;
+
+  enum {
+    INVERT_REGEX = CHAR_MAX + 1,
+    SNI_OPTION,
+    CA_CERT_OPTION
+  };
+
+  int option = 0;
+  int got_plus = 0;
+  static struct option longopts[] = {
+    STD_LONG_OPTS,
+    {"link", no_argument, 0, 'L'},
+    {"nohtml", no_argument, 0, 'n'},
+    {"ssl", optional_argument, 0, 'S'},
+    {"sni", no_argument, 0, SNI_OPTION},
+    {"post", required_argument, 0, 'P'},
+    {"method", required_argument, 0, 'j'},
+    {"IP-address", required_argument, 0, 'I'},
+    {"url", required_argument, 0, 'u'},
+    {"port", required_argument, 0, 'p'},
+    {"authorization", required_argument, 0, 'a'},
+    {"proxy-authorization", required_argument, 0, 'b'},
+    {"header-string", required_argument, 0, 'd'},
+    {"string", required_argument, 0, 's'},
+    {"expect", required_argument, 0, 'e'},
+    {"regex", required_argument, 0, 'r'},
+    {"ereg", required_argument, 0, 'r'},
+    {"eregi", required_argument, 0, 'R'},
+    {"linespan", no_argument, 0, 'l'},
+    {"onredirect", required_argument, 0, 'f'},
+    {"certificate", required_argument, 0, 'C'},
+    {"client-cert", required_argument, 0, 'J'},
+    {"private-key", required_argument, 0, 'K'},
+    {"ca-cert", required_argument, 0, CA_CERT_OPTION},
+    {"useragent", required_argument, 0, 'A'},
+    {"header", required_argument, 0, 'k'},
+    {"no-body", no_argument, 0, 'N'},
+    {"max-age", required_argument, 0, 'M'},
+    {"content-type", required_argument, 0, 'T'},
+    {"pagesize", required_argument, 0, 'm'},
+    {"invert-regex", no_argument, NULL, INVERT_REGEX},
+    {"use-ipv4", no_argument, 0, '4'},
+    {"use-ipv6", no_argument, 0, '6'},
+    {"extended-perfdata", no_argument, 0, 'E'},
+    {0, 0, 0, 0}
+  };
+
+  if (argc < 2)
+    return ERROR;
+
+  /* support check_http compatible arguments */
+  for (c = 1; c < argc; c++) {
+    if (strcmp ("-to", argv[c]) == 0)
+      strcpy (argv[c], "-t");
+    if (strcmp ("-hn", argv[c]) == 0)
+      strcpy (argv[c], "-H");
+    if (strcmp ("-wt", argv[c]) == 0)
+      strcpy (argv[c], "-w");
+    if (strcmp ("-ct", argv[c]) == 0)
+      strcpy (argv[c], "-c");
+    if (strcmp ("-nohtml", argv[c]) == 0)
+      strcpy (argv[c], "-n");
+  }
+
+  while (1) {
+    c = getopt_long (argc, argv, "Vvh46t:c:w:A:k:H:P:j:T:I:a:b:d:e:p:s:R:r:u:f:C:J:K:nlLS::m:M:NE", longopts, &option);
+    if (c == -1 || c == EOF || c == 1)
+      break;
+
+    switch (c) {
+    case 'h':
+      print_help();
+      exit(STATE_UNKNOWN);
+      break;
+    case 'V':
+      print_revision(progname, NP_VERSION);
+      print_curl_version();
+      exit(STATE_UNKNOWN);
+      break;
+    case 'v':
+      verbose++;
+      break;
+    case 't': /* timeout period */
+      if (!is_intnonneg (optarg))
+        usage2 (_("Timeout interval must be a positive integer"), optarg);
+      else
+        socket_timeout = (int)strtol (optarg, NULL, 10);
+      break;
+    case 'c': /* critical time threshold */
+      critical_thresholds = optarg;
+      break;
+    case 'w': /* warning time threshold */
+      warning_thresholds = optarg;
+      break;
+    case 'H': /* virtual host */
+      host_name = strdup (optarg);
+      if (host_name[0] == '[') {
+        if ((p = strstr (host_name, "]:")) != NULL) { /* [IPv6]:port */
+          virtual_port = atoi (p + 2);
+          /* cut off the port */
+          host_name_length = strlen (host_name) - strlen (p) - 1;
+          free (host_name);
+          host_name = strndup (optarg, host_name_length);
+          }
+      } else if ((p = strchr (host_name, ':')) != NULL
+                 && strchr (++p, ':') == NULL) { /* IPv4:port or host:port */
+          virtual_port = atoi (p);
+          /* cut off the port */
+          host_name_length = strlen (host_name) - strlen (p) - 1;
+          free (host_name);
+          host_name = strndup (optarg, host_name_length);
+        }
+      break;
+    case 'I': /* internet address */
+      server_address = strdup (optarg);
+      break;
+    case 'u': /* URL path */
+      server_url = strdup (optarg);
+      break;
+    case 'p': /* Server port */
+      if (!is_intnonneg (optarg))
+        usage2 (_("Invalid port number, expecting a non-negative number"), optarg);
+      else {
+        if( strtol(optarg, NULL, 10) > MAX_PORT)
+          usage2 (_("Invalid port number, supplied port number is too big"), optarg);
+        server_port = (unsigned short)strtol(optarg, NULL, 10);
+      }
+      break;
+    case 'a': /* authorization info */
+      strncpy (user_auth, optarg, MAX_INPUT_BUFFER - 1);
+      user_auth[MAX_INPUT_BUFFER - 1] = 0;
+      break;
+    case 'b': /* proxy-authorization info */
+      strncpy (proxy_auth, optarg, MAX_INPUT_BUFFER - 1);
+      proxy_auth[MAX_INPUT_BUFFER - 1] = 0;
+      break;
+    case 'P': /* HTTP POST data in URL encoded format; ignored if settings already */
+      if (! http_post_data)
+        http_post_data = strdup (optarg);
+      if (! http_method)
+        http_method = strdup("POST");
+      break;
+    case 'j': /* Set HTTP method */
+      if (http_method)
+        free(http_method);
+      http_method = strdup (optarg);
+      break;
+    case 'A': /* useragent */
+      strncpy (user_agent, optarg, DEFAULT_BUFFER_SIZE);
+      user_agent[DEFAULT_BUFFER_SIZE-1] = '\0';
+      break;
+    case 'k': /* Additional headers */
+      if (http_opt_headers_count == 0)
+        http_opt_headers = malloc (sizeof (char *) * (++http_opt_headers_count));
+      else
+        http_opt_headers = realloc (http_opt_headers, sizeof (char *) * (++http_opt_headers_count));
+      http_opt_headers[http_opt_headers_count - 1] = optarg;
+      break;
+    case 'L': /* show html link */
+      display_html = TRUE;
+      break;
+    case 'n': /* do not show html link */
+      display_html = FALSE;
+      break;
+    case 'C': /* Check SSL cert validity */
+#ifdef LIBCURL_FEATURE_SSL
+      if ((temp=strchr(optarg,','))!=NULL) {
+        *temp='\0';
+        if (!is_intnonneg (optarg))
+          usage2 (_("Invalid certificate expiration period"), optarg);
+        days_till_exp_warn = atoi(optarg);
+        *temp=',';
+        temp++;
+        if (!is_intnonneg (temp))
+          usage2 (_("Invalid certificate expiration period"), temp);
+        days_till_exp_crit = atoi (temp);
+      }
+      else {
+        days_till_exp_crit=0;
+        if (!is_intnonneg (optarg))
+          usage2 (_("Invalid certificate expiration period"), optarg);
+        days_till_exp_warn = atoi (optarg);
+      }
+      check_cert = TRUE;
+      goto enable_ssl;
+#endif
+    case 'J': /* use client certificate */
+#ifdef LIBCURL_FEATURE_SSL
+      test_file(optarg);
+      client_cert = optarg;
+      goto enable_ssl;
+#endif
+    case 'K': /* use client private key */
+#ifdef LIBCURL_FEATURE_SSL
+      test_file(optarg);
+      client_privkey = optarg;
+      goto enable_ssl;
+#endif
+#ifdef LIBCURL_FEATURE_SSL
+    case CA_CERT_OPTION: /* use CA chain file */
+      test_file(optarg);
+      ca_cert = optarg;
+      goto enable_ssl;
+#endif
+    case 'S': /* use SSL */
+#ifdef LIBCURL_FEATURE_SSL
+    enable_ssl:
+      use_ssl = TRUE;
+      /* ssl_version initialized to CURL_SSLVERSION_TLSv1_0 as a default.
+       * Only set if it's non-zero.  This helps when we include multiple
+       * parameters, like -S and -C combinations */
+      ssl_version = CURL_SSLVERSION_TLSv1_0;
+      if (c=='S' && optarg != NULL) {
+        char *plus_ptr = strchr(optarg, '+');
+        if (plus_ptr) {
+          got_plus = 1;
+          *plus_ptr = '\0';
+        }
+
+        if (optarg[0] == '2')
+          ssl_version = CURL_SSLVERSION_SSLv2;
+        else if (optarg[0] == '3')
+          ssl_version = CURL_SSLVERSION_SSLv3;
+        else if (!strcmp (optarg, "1") || !strcmp (optarg, "1.0"))
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
+          ssl_version = CURL_SSLVERSION_TLSv1_0;
+#else
+          ssl_version = CURL_SSLVERSION_DEFAULT;
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
+        else if (!strcmp (optarg, "1.1"))
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
+          ssl_version = CURL_SSLVERSION_TLSv1_1;
+#else
+          ssl_version = CURL_SSLVERSION_DEFAULT;
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
+        else if (!strcmp (optarg, "1.2"))
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
+          ssl_version = CURL_SSLVERSION_TLSv1_2;
+#else
+          ssl_version = CURL_SSLVERSION_DEFAULT;
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
+        else if (!strcmp (optarg, "1.3"))
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 52, 0)
+          ssl_version = CURL_SSLVERSION_TLSv1_3;
+#else
+          ssl_version = CURL_SSLVERSION_DEFAULT;
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 52, 0) */
+        else
+          usage4 (_("Invalid option - Valid SSL/TLS versions: 2, 3, 1, 1.1, 1.2 (with optional '+' suffix)"));
+      }
+#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 54, 0)
+      if (got_plus) {
+        switch (ssl_version) {
+          case CURL_SSLVERSION_TLSv1_3:
+            ssl_version |= CURL_SSLVERSION_MAX_TLSv1_3;
+            break;
+          case CURL_SSLVERSION_TLSv1_2:
+          case CURL_SSLVERSION_TLSv1_1:
+          case CURL_SSLVERSION_TLSv1_0:
+            ssl_version |= CURL_SSLVERSION_MAX_DEFAULT;
+            break;
+        }
+      } else {
+        switch (ssl_version) {
+          case CURL_SSLVERSION_TLSv1_3:
+            ssl_version |= CURL_SSLVERSION_MAX_TLSv1_3;
+            break;
+          case CURL_SSLVERSION_TLSv1_2:
+            ssl_version |= CURL_SSLVERSION_MAX_TLSv1_2;
+            break;
+          case CURL_SSLVERSION_TLSv1_1:
+            ssl_version |= CURL_SSLVERSION_MAX_TLSv1_1;
+            break;
+          case CURL_SSLVERSION_TLSv1_0:
+            ssl_version |= CURL_SSLVERSION_MAX_TLSv1_0;
+            break;
+        }
+      }
+#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 54, 0) */
+      if (verbose >= 2)
+        printf(_("* Set SSL/TLS version to %d\n"), ssl_version);
+      if (server_port == HTTP_PORT)
+        server_port = HTTPS_PORT;
+      break;
+#else /* LIBCURL_FEATURE_SSL */
+      /* -C -J and -K fall through to here without SSL */
+      usage4 (_("Invalid option - SSL is not available"));
+      break;
+    case SNI_OPTION: /* --sni is parsed, but ignored, the default is TRUE with libcurl */
+      use_sni = TRUE;
+      break;
+#endif /* LIBCURL_FEATURE_SSL */
+    case 'f': /* onredirect */
+      if (!strcmp (optarg, "ok"))
+        onredirect = STATE_OK;
+      else if (!strcmp (optarg, "warning"))
+        onredirect = STATE_WARNING;
+      else if (!strcmp (optarg, "critical"))
+        onredirect = STATE_CRITICAL;
+      else if (!strcmp (optarg, "unknown"))
+        onredirect = STATE_UNKNOWN;
+      else if (!strcmp (optarg, "follow"))
+        onredirect = STATE_DEPENDENT;
+      else if (!strcmp (optarg, "stickyport"))
+        onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_HOST|STICKY_PORT;
+      else if (!strcmp (optarg, "sticky"))
+        onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_HOST;
+      else if (!strcmp (optarg, "follow"))
+        onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_NONE;
+      else if (!strcmp (optarg, "curl"))
+        onredirect = STATE_DEPENDENT, followmethod = FOLLOW_LIBCURL;
+      else usage2 (_("Invalid onredirect option"), optarg);
+      if (verbose >= 2)
+        printf(_("* Following redirects set to %s\n"), state_text(onredirect));
+      break;
+    case 'd': /* string or substring */
+      strncpy (header_expect, optarg, MAX_INPUT_BUFFER - 1);
+      header_expect[MAX_INPUT_BUFFER - 1] = 0;
+      break;
+    case 's': /* string or substring */
+      strncpy (string_expect, optarg, MAX_INPUT_BUFFER - 1);
+      string_expect[MAX_INPUT_BUFFER - 1] = 0;
+      break;
+    case 'e': /* string or substring */
+      strncpy (server_expect, optarg, MAX_INPUT_BUFFER - 1);
+      server_expect[MAX_INPUT_BUFFER - 1] = 0;
+      server_expect_yn = 1;
+      break;
+    case 'T': /* Content-type */
+      http_content_type = strdup (optarg);
+     break;
+    case 'l': /* linespan */
+      cflags &= ~REG_NEWLINE;
+      break;
+    case 'R': /* regex */
+      cflags |= REG_ICASE;
+    case 'r': /* regex */
+      strncpy (regexp, optarg, MAX_RE_SIZE - 1);
+      regexp[MAX_RE_SIZE - 1] = 0;
+      errcode = regcomp (&preg, regexp, cflags);
+      if (errcode != 0) {
+        (void) regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
+        printf (_("Could Not Compile Regular Expression: %s"), errbuf);
+        return ERROR;
+      }
+      break;
+    case INVERT_REGEX:
+      invert_regex = 1;
+      break;
+    case '4':
+      address_family = AF_INET;
+      break;
+    case '6':
+#if defined (USE_IPV6) && defined (LIBCURL_FEATURE_IPV6)
+      address_family = AF_INET6;
+#else
+      usage4 (_("IPv6 support not available"));
+#endif
+      break;
+    case 'm': /* min_page_length */
+      {
+      char *tmp;
+      if (strchr(optarg, ':') != (char *)NULL) {
+        /* range, so get two values, min:max */
+        tmp = strtok(optarg, ":");
+        if (tmp == NULL) {
+          printf("Bad format: try \"-m min:max\"\n");
+          exit (STATE_WARNING);
+        } else
+          min_page_len = atoi(tmp);
+
+        tmp = strtok(NULL, ":");
+        if (tmp == NULL) {
+          printf("Bad format: try \"-m min:max\"\n");
+          exit (STATE_WARNING);
+        } else
+          max_page_len = atoi(tmp);
+      } else
+        min_page_len = atoi (optarg);
+      break;
+      }
+    case 'N': /* no-body */
+      no_body = TRUE;
+      break;
+    case 'M': /* max-age */
+    {
+      int L = strlen(optarg);
+      if (L && optarg[L-1] == 'm')
+        maximum_age = atoi (optarg) * 60;
+      else if (L && optarg[L-1] == 'h')
+        maximum_age = atoi (optarg) * 60 * 60;
+      else if (L && optarg[L-1] == 'd')
+        maximum_age = atoi (optarg) * 60 * 60 * 24;
+      else if (L && (optarg[L-1] == 's' ||
+                     isdigit (optarg[L-1])))
+        maximum_age = atoi (optarg);
+      else {
+        fprintf (stderr, "unparsable max-age: %s\n", optarg);
+        exit (STATE_WARNING);
+      }
+      if (verbose >= 2)
+        printf ("* Maximal age of document set to %d seconds\n", maximum_age);
+    }
+    break;
+    case 'E': /* show extended perfdata */
+      show_extended_perfdata = TRUE;
+      break;
+    case '?':
+      /* print short usage statement if args not parsable */
+      usage5 ();
+      break;
+    }
+  }
+
+  c = optind;
+
+  if (server_address == NULL && c < argc)
+    server_address = strdup (argv[c++]);
+
+  if (host_name == NULL && c < argc)
+    host_name = strdup (argv[c++]);
+
+  if (server_address == NULL) {
+    if (host_name == NULL)
+      usage4 (_("You must specify a server address or host name"));
+    else
+      server_address = strdup (host_name);
+  }
+
+  set_thresholds(&thlds, warning_thresholds, critical_thresholds);
+
+  if (critical_thresholds && thlds->critical->end>(double)socket_timeout)
+    socket_timeout = (int)thlds->critical->end + 1;
+  if (verbose >= 2)
+    printf ("* Socket timeout set to %ld seconds\n", socket_timeout);
+
+  if (http_method == NULL)
+    http_method = strdup ("GET");
+
+  if (client_cert && !client_privkey)
+    usage4 (_("If you use a client certificate you must also specify a private key file"));
+
+  if (virtual_port == 0)
+    virtual_port = server_port;
+
+  return TRUE;
+}
+
+void
+print_help (void)
+{
+  print_revision (progname, NP_VERSION);
+
+  printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
+  printf (COPYRIGHT, copyright, email);
+
+  printf ("%s\n", _("This plugin tests the HTTP service on the specified host. It can test"));
+  printf ("%s\n", _("normal (http) and secure (https) servers, follow redirects, search for"));
+  printf ("%s\n", _("strings and regular expressions, check connection times, and report on"));
+  printf ("%s\n", _("certificate expiration times."));
+  printf ("\n");
+  printf ("%s\n", _("It makes use of libcurl to do so. It tries to be as compatible to check_http"));
+  printf ("%s\n", _("as possible."));
+
+  printf ("\n\n");
+
+  print_usage ();
+
+  printf (_("NOTE: One or both of -H and -I must be specified"));
+
+  printf ("\n");
+
+  printf (UT_HELP_VRSN);
+  printf (UT_EXTRA_OPTS);
+
+  printf (" %s\n", "-H, --hostname=ADDRESS");
+  printf ("    %s\n", _("Host name argument for servers using host headers (virtual host)"));
+  printf ("    %s\n", _("Append a port to include it in the header (eg: example.com:5000)"));
+  printf (" %s\n", "-I, --IP-address=ADDRESS");
+  printf ("    %s\n", _("IP address or name (use numeric address if possible to bypass DNS lookup)."));
+  printf (" %s\n", "-p, --port=INTEGER");
+  printf ("    %s", _("Port number (default: "));
+  printf ("%d)\n", HTTP_PORT);
+
+  printf (UT_IPv46);
+
+#ifdef LIBCURL_FEATURE_SSL
+  printf (" %s\n", "-S, --ssl=VERSION[+]");
+  printf ("    %s\n", _("Connect via SSL. Port defaults to 443. VERSION is optional, and prevents"));
+  printf ("    %s\n", _("auto-negotiation (2 = SSLv2, 3 = SSLv3, 1 = TLSv1, 1.1 = TLSv1.1,"));
+  printf ("    %s\n", _("1.2 = TLSv1.2). With a '+' suffix, newer versions are also accepted."));
+  printf ("    %s\n", _("Note: SSLv2 and SSLv3 are deprecated and are usually disabled in libcurl"));
+  printf (" %s\n", "--sni");
+  printf ("    %s\n", _("Enable SSL/TLS hostname extension support (SNI)"));
+#if LIBCURL_VERSION_NUM >= 0x071801
+  printf ("    %s\n", _("Note: --sni is the default in libcurl as SSLv2 and SSLV3 are deprecated and"));
+  printf ("    %s\n", _("      SNI only really works since TLSv1.0"));
+#else
+  printf ("    %s\n", _("Note: SNI is not supported in libcurl before 7.18.1"));
+#endif
+  printf (" %s\n", "-C, --certificate=INTEGER[,INTEGER]");
+  printf ("    %s\n", _("Minimum number of days a certificate has to be valid. Port defaults to 443"));
+  printf ("    %s\n", _("(when this option is used the URL is not checked.)"));
+  printf (" %s\n", "-J, --client-cert=FILE");
+  printf ("   %s\n", _("Name of file that contains the client certificate (PEM format)"));
+  printf ("   %s\n", _("to be used in establishing the SSL session"));
+  printf (" %s\n", "-K, --private-key=FILE");
+  printf ("   %s\n", _("Name of file containing the private key (PEM format)"));
+  printf ("   %s\n", _("matching the client certificate"));
+  printf (" %s\n", "--ca-cert=FILE");
+  printf ("   %s\n", _("CA certificate file to verify peer against"));
+#endif
+
+  printf (" %s\n", "-e, --expect=STRING");
+  printf ("    %s\n", _("Comma-delimited list of strings, at least one of them is expected in"));
+  printf ("    %s", _("the first (status) line of the server response (default: "));
+  printf ("%s)\n", HTTP_EXPECT);
+  printf ("    %s\n", _("If specified skips all other status line logic (ex: 3xx, 4xx, 5xx processing)"));
+  printf (" %s\n", "-d, --header-string=STRING");
+  printf ("    %s\n", _("String to expect in the response headers"));
+  printf (" %s\n", "-s, --string=STRING");
+  printf ("    %s\n", _("String to expect in the content"));
+  printf (" %s\n", "-u, --url=PATH");
+  printf ("    %s\n", _("URL to GET or POST (default: /)"));
+  printf (" %s\n", "-P, --post=STRING");
+  printf ("    %s\n", _("URL encoded http POST data"));
+  printf (" %s\n", "-j, --method=STRING  (for example: HEAD, OPTIONS, TRACE, PUT, DELETE, CONNECT)");
+  printf ("    %s\n", _("Set HTTP method."));
+  printf (" %s\n", "-N, --no-body");
+  printf ("    %s\n", _("Don't wait for document body: stop reading after headers."));
+  printf ("    %s\n", _("(Note that this still does an HTTP GET or POST, not a HEAD.)"));
+  printf (" %s\n", "-M, --max-age=SECONDS");
+  printf ("    %s\n", _("Warn if document is more than SECONDS old. the number can also be of"));
+  printf ("    %s\n", _("the form \"10m\" for minutes, \"10h\" for hours, or \"10d\" for days."));
+  printf (" %s\n", "-T, --content-type=STRING");
+  printf ("    %s\n", _("specify Content-Type header media type when POSTing\n"));
+  printf (" %s\n", "-l, --linespan");
+  printf ("    %s\n", _("Allow regex to span newlines (must precede -r or -R)"));
+  printf (" %s\n", "-r, --regex, --ereg=STRING");
+  printf ("    %s\n", _("Search page for regex STRING"));
+  printf (" %s\n", "-R, --eregi=STRING");
+  printf ("    %s\n", _("Search page for case-insensitive regex STRING"));
+  printf (" %s\n", "--invert-regex");
+  printf ("    %s\n", _("Return CRITICAL if found, OK if not\n"));
+  printf (" %s\n", "-a, --authorization=AUTH_PAIR");
+  printf ("    %s\n", _("Username:password on sites with basic authentication"));
+  printf (" %s\n", "-b, --proxy-authorization=AUTH_PAIR");
+  printf ("    %s\n", _("Username:password on proxy-servers with basic authentication"));
+  printf (" %s\n", "-A, --useragent=STRING");
+  printf ("    %s\n", _("String to be sent in http header as \"User Agent\""));
+  printf (" %s\n", "-k, --header=STRING");
+  printf ("    %s\n", _("Any other tags to be sent in http header. Use multiple times for additional headers"));
+  printf (" %s\n", "-E, --extended-perfdata");
+  printf ("    %s\n", _("Print additional performance data"));
+  printf (" %s\n", "-L, --link");
+  printf ("    %s\n", _("Wrap output in HTML link (obsoleted by urlize)"));
+  printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport|curl>");
+  printf ("    %s\n", _("How to handle redirected pages. sticky is like follow but stick to the"));
+  printf ("    %s\n", _("specified IP address. stickyport also ensures port stays the same."));
+  printf ("    %s\n", _("follow uses the old redirection algorithm of check_http."));
+  printf ("    %s\n", _("curl uses CURL_FOLLOWLOCATION built into libcurl."));
+  printf (" %s\n", "-m, --pagesize=INTEGER<:INTEGER>");
+  printf ("    %s\n", _("Minimum page size required (bytes) : Maximum page size required (bytes)"));
+
+  printf (UT_WARN_CRIT);
+
+  printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
+
+  printf (UT_VERBOSE);
+
+  printf ("\n");
+  printf ("%s\n", _("Notes:"));
+  printf (" %s\n", _("This plugin will attempt to open an HTTP connection with the host."));
+  printf (" %s\n", _("Successful connects return STATE_OK, refusals and timeouts return STATE_CRITICAL"));
+  printf (" %s\n", _("other errors return STATE_UNKNOWN.  Successful connects, but incorrect response"));
+  printf (" %s\n", _("messages from the host result in STATE_WARNING return values.  If you are"));
+  printf (" %s\n", _("checking a virtual server that uses 'host headers' you must supply the FQDN"));
+  printf (" %s\n", _("(fully qualified domain name) as the [host_name] argument."));
+
+#ifdef LIBCURL_FEATURE_SSL
+  printf ("\n");
+  printf (" %s\n", _("This plugin can also check whether an SSL enabled web server is able to"));
+  printf (" %s\n", _("serve content (optionally within a specified time) or whether the X509 "));
+  printf (" %s\n", _("certificate is still valid for the specified number of days."));
+  printf ("\n");
+  printf (" %s\n", _("Please note that this plugin does not check if the presented server"));
+  printf (" %s\n", _("certificate matches the hostname of the server, or if the certificate"));
+  printf (" %s\n", _("has a valid chain of trust to one of the locally installed CAs."));
+  printf ("\n");
+  printf ("%s\n", _("Examples:"));
+  printf (" %s\n\n", "CHECK CONTENT: check_curl -w 5 -c 10 --ssl -H www.verisign.com");
+  printf (" %s\n", _("When the 'www.verisign.com' server returns its content within 5 seconds,"));
+  printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds"));
+  printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,"));
+  printf (" %s\n", _("a STATE_CRITICAL will be returned."));
+  printf ("\n");
+  printf (" %s\n\n", "CHECK CERTIFICATE: check_curl -H www.verisign.com -C 14");
+  printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 14 days,"));
+  printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than"));
+  printf (" %s\n", _("14 days, a STATE_WARNING is returned. A STATE_CRITICAL will be returned when"));
+  printf (" %s\n\n", _("the certificate is expired."));
+  printf ("\n");
+  printf (" %s\n\n", "CHECK CERTIFICATE: check_curl -H www.verisign.com -C 30,14");
+  printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 30 days,"));
+  printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than"));
+  printf (" %s\n", _("30 days, but more than 14 days, a STATE_WARNING is returned."));
+  printf (" %s\n", _("A STATE_CRITICAL will be returned when certificate expires in less than 14 days"));
+#endif
+
+  printf ("\n %s\n", "CHECK WEBSERVER CONTENT VIA PROXY:");
+  printf (" %s\n", _("It is recommended to use an environment proxy like:"));
+  printf (" %s\n", _("http_proxy=http://192.168.100.35:3128 ./check_curl -H www.monitoring-plugins.org"));
+  printf (" %s\n", _("legacy proxy requests in check_http style still work:"));
+  printf (" %s\n", _("check_curl -I 192.168.100.35 -p 3128 -u http://www.monitoring-plugins.org/ -H www.monitoring-plugins.org"));
+
+#ifdef LIBCURL_FEATURE_SSL
+  printf ("\n %s\n", "CHECK SSL WEBSERVER CONTENT VIA PROXY USING HTTP 1.1 CONNECT: ");
+  printf (" %s\n", _("It is recommended to use an environment proxy like:"));
+  printf (" %s\n", _("https_proxy=http://192.168.100.35:3128 ./check_curl -H www.verisign.com -S"));
+  printf (" %s\n", _("legacy proxy requests in check_http style still work:"));
+  printf (" %s\n", _("check_curl -I 192.168.100.35 -p 3128 -u https://www.verisign.com/ -S -j CONNECT -H www.verisign.com "));
+  printf (" %s\n", _("all these options are needed: -I <proxy> -p <proxy-port> -u <check-url> -S(sl) -j CONNECT -H <webserver>"));
+  printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds"));
+  printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,"));
+  printf (" %s\n", _("a STATE_CRITICAL will be returned."));
+
+#endif
+
+  printf (UT_SUPPORT);
+
+}
+
+
+
+void
+print_usage (void)
+{
+  printf ("%s\n", _("Usage:"));
+  printf (" %s -H <vhost> | -I <IP-address> [-u <uri>] [-p <port>]\n",progname);
+  printf ("       [-J <client certificate file>] [-K <private key>] [--ca-cert <CA certificate file>]\n");
+  printf ("       [-w <warn time>] [-c <critical time>] [-t <timeout>] [-L] [-E] [-a auth]\n");
+  printf ("       [-b proxy_auth] [-f <ok|warning|critcal|follow|sticky|stickyport|curl>]\n");
+  printf ("       [-e <expect>] [-d string] [-s string] [-l] [-r <regex> | -R <case-insensitive regex>]\n");
+  printf ("       [-P string] [-m <min_pg_size>:<max_pg_size>] [-4|-6] [-N] [-M <age>]\n");
+  printf ("       [-A string] [-k string] [-S <version>] [--sni] [-C <warn_age>[,<crit_age>]]\n");
+  printf ("       [-T <content-type>] [-j method]\n");
+  printf ("\n");
+  printf ("%s\n", _("WARNING: check_curl is experimental. Please use"));
+  printf ("%s\n\n", _("check_http if you need a stable version."));
+}
+
+void
+print_curl_version (void)
+{
+  printf( "%s\n", curl_version());
+}
+
+int
+curlhelp_initwritebuffer (curlhelp_write_curlbuf *buf)
+{
+  buf->bufsize = DEFAULT_BUFFER_SIZE;
+  buf->buflen = 0;
+  buf->buf = (char *)malloc ((size_t)buf->bufsize);
+  if (buf->buf == NULL) return -1;
+  return 0;
+}
+
+int
+curlhelp_buffer_write_callback (void *buffer, size_t size, size_t nmemb, void *stream)
+{
+  curlhelp_write_curlbuf *buf = (curlhelp_write_curlbuf *)stream;
+
+  while (buf->bufsize < buf->buflen + size * nmemb + 1) {
+    buf->bufsize *= buf->bufsize * 2;
+    buf->buf = (char *)realloc (buf->buf, buf->bufsize);
+    if (buf->buf == NULL) return -1;
+  }
+
+  memcpy (buf->buf + buf->buflen, buffer, size * nmemb);
+  buf->buflen += size * nmemb;
+  buf->buf[buf->buflen] = '\0';
+
+  return (int)(size * nmemb);
+}
+
+int
+curlhelp_buffer_read_callback (void *buffer, size_t size, size_t nmemb, void *stream)
+{
+  curlhelp_read_curlbuf *buf = (curlhelp_read_curlbuf *)stream;
+
+  size_t n = min (nmemb * size, buf->buflen - buf->pos);
+
+  memcpy (buffer, buf->buf + buf->pos, n);
+  buf->pos += n;
+
+  return (int)n;
+}
+
+void
+curlhelp_freewritebuffer (curlhelp_write_curlbuf *buf)
+{
+  free (buf->buf);
+  buf->buf = NULL;
+}
+
+int
+curlhelp_initreadbuffer (curlhelp_read_curlbuf *buf, const char *data, size_t datalen)
+{
+  buf->buflen = datalen;
+  buf->buf = (char *)malloc ((size_t)buf->buflen);
+  if (buf->buf == NULL) return -1;
+  memcpy (buf->buf, data, datalen);
+  buf->pos = 0;
+  return 0;
+}
+
+void
+curlhelp_freereadbuffer (curlhelp_read_curlbuf *buf)
+{
+  free (buf->buf);
+  buf->buf = NULL;
+}
+
+/* TODO: where to put this, it's actually part of sstrings2 (logically)?
+ */
+const char*
+strrstr2(const char *haystack, const char *needle)
+{
+  int counter;
+  size_t len;
+  const char *prev_pos;
+  const char *pos;
+
+  if (haystack == NULL || needle == NULL)
+    return NULL;
+
+  if (haystack[0] == '\0' || needle[0] == '\0')
+    return NULL;
+
+  counter = 0;
+  prev_pos = NULL;
+  pos = haystack;
+  len = strlen (needle);
+  for (;;) {
+    pos = strstr (pos, needle);
+    if (pos == NULL) {
+      if (counter == 0)
+        return NULL;
+      else
+        return prev_pos;
+    }
+    counter++;
+    prev_pos = pos;
+    pos += len;
+    if (*pos == '\0') return prev_pos;
+  }
+}
+
+int
+curlhelp_parse_statusline (const char *buf, curlhelp_statusline *status_line)
+{
+  char *first_line_end;
+  char *p;
+  size_t first_line_len;
+  char *pp;
+  const char *start;
+  char *first_line_buf;
+
+  /* find last start of a new header */
+  start = strrstr2 (buf, "\r\nHTTP");
+  if (start != NULL) {
+    start += 2;
+    buf = start;
+  }
+
+  first_line_end = strstr(buf, "\r\n");
+  if (first_line_end == NULL) return -1;
+
+  first_line_len = (size_t)(first_line_end - buf);
+  status_line->first_line = (char *)malloc (first_line_len + 1);
+  if (status_line->first_line == NULL) return -1;
+  memcpy (status_line->first_line, buf, first_line_len);
+  status_line->first_line[first_line_len] = '\0';
+  first_line_buf = strdup( status_line->first_line );
+
+  /* protocol and version: "HTTP/x.x" SP */
+
+  p = strtok(first_line_buf, "/");
+  if( p == NULL ) { free( first_line_buf ); return -1; }
+  if( strcmp( p, "HTTP" ) != 0 ) { free( first_line_buf ); return -1; }
+
+  p = strtok( NULL, "." );
+  if( p == NULL ) { free( first_line_buf ); return -1; }
+  status_line->http_major = (int)strtol( p, &pp, 10 );
+  if( *pp != '\0' ) { free( first_line_buf ); return -1; }
+
+  p = strtok( NULL, " " );
+  if( p == NULL ) { free( first_line_buf ); return -1; }
+  status_line->http_minor = (int)strtol( p, &pp, 10 );
+  if( *pp != '\0' ) { free( first_line_buf ); return -1; }
+
+  /* status code: "404" or "404.1", then SP */
+
+  p = strtok( NULL, " ." );
+  if( p == NULL ) { free( first_line_buf ); return -1; }
+  if( strchr( p, '.' ) != NULL ) {
+    char *ppp;
+    ppp = strtok( p, "." );
+    status_line->http_code = (int)strtol( ppp, &pp, 10 );
+    if( *pp != '\0' ) { free( first_line_buf ); return -1; }
+
+    ppp = strtok( NULL, "" );
+    status_line->http_subcode = (int)strtol( ppp, &pp, 10 );
+    if( *pp != '\0' ) { free( first_line_buf ); return -1; }
+  } else {
+    status_line->http_code = (int)strtol( p, &pp, 10 );
+    status_line->http_subcode = -1;
+    if( *pp != '\0' ) { free( first_line_buf ); return -1; }
+  }
+
+  /* Human readable message: "Not Found" CRLF */
+
+  free( first_line_buf );
+  p = strtok( NULL, "" );
+  if( p == NULL ) { free( status_line->first_line ); return -1; }
+  status_line->msg = status_line->first_line + ( p - first_line_buf );
+
+  return 0;
+}
+
+void
+curlhelp_free_statusline (curlhelp_statusline *status_line)
+{
+  free (status_line->first_line);
+}
+
+void
+remove_newlines (char *s)
+{
+  char *p;
+
+  for (p = s; *p != '\0'; p++)
+    if (*p == '\r' || *p == '\n')
+      *p = ' ';
+}
+
+char *
+perfd_time_ssl (double elapsed_time_ssl)
+{
+  return fperfdata ("time_ssl", elapsed_time_ssl, "s", FALSE, 0, FALSE, 0, FALSE, 0, FALSE, 0);
+}
+
+char *
+get_header_value (const struct phr_header* headers, const size_t nof_headers, const char* header)
+{
+  int i;
+  for( i = 0; i < nof_headers; i++ ) {
+    if( strncasecmp( header, headers[i].name, max( headers[i].name_len, 4 ) ) == 0 ) {
+      return strndup( headers[i].value, headers[i].value_len );
+    }
+  }
+  return NULL;
+}
+
+int
+check_document_dates (const curlhelp_write_curlbuf *header_buf, char (*msg)[DEFAULT_BUFFER_SIZE])
+{
+  char *server_date = NULL;
+  char *document_date = NULL;
+  int date_result = STATE_OK;
+  curlhelp_statusline status_line;
+  struct phr_header headers[255];
+  size_t nof_headers = 255;
+  size_t msglen;
+
+  int res = phr_parse_response (header_buf->buf, header_buf->buflen,
+    &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen,
+    headers, &nof_headers, 0);
+
+  server_date = get_header_value (headers, nof_headers, "date");
+  document_date = get_header_value (headers, nof_headers, "last-modified");
+
+  if (!server_date || !*server_date) {
+    snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sServer date unknown, "), *msg);
+    date_result = max_state_alt(STATE_UNKNOWN, date_result);
+  } else if (!document_date || !*document_date) {
+    snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument modification date unknown, "), *msg);
+    date_result = max_state_alt(STATE_CRITICAL, date_result);
+  } else {
+    time_t srv_data = curl_getdate (server_date, NULL);
+    time_t doc_data = curl_getdate (document_date, NULL);
+    if (verbose >= 2)
+      printf ("* server date: '%s' (%d), doc_date: '%s' (%d)\n", server_date, (int)srv_data, document_date, (int)doc_data);
+    if (srv_data <= 0) {
+      snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sServer date \"%100s\" unparsable, "), *msg, server_date);
+      date_result = max_state_alt(STATE_CRITICAL, date_result);
+    } else if (doc_data <= 0) {
+      snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument date \"%100s\" unparsable, "), *msg, document_date);
+      date_result = max_state_alt(STATE_CRITICAL, date_result);
+    } else if (doc_data > srv_data + 30) {
+      snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument is %d seconds in the future, "), *msg, (int)doc_data - (int)srv_data);
+      date_result = max_state_alt(STATE_CRITICAL, date_result);
+    } else if (doc_data < srv_data - maximum_age) {
+      int n = (srv_data - doc_data);
+      if (n > (60 * 60 * 24 * 2)) {
+        snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sLast modified %.1f days ago, "), *msg, ((float) n) / (60 * 60 * 24));
+        date_result = max_state_alt(STATE_CRITICAL, date_result);
+      } else {
+        snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sLast modified %d:%02d:%02d ago, "), *msg, n / (60 * 60), (n / 60) % 60, n % 60);
+        date_result = max_state_alt(STATE_CRITICAL, date_result);
+      }
+    }
+  }
+
+  if (server_date) free (server_date);
+  if (document_date) free (document_date);
+
+  return date_result;
+}
+
+
+int
+get_content_length (const curlhelp_write_curlbuf* header_buf, const curlhelp_write_curlbuf* body_buf)
+{
+  const char *s;
+  int content_length = 0;
+  char *copy;
+  struct phr_header headers[255];
+  size_t nof_headers = 255;
+  size_t msglen;
+  char *content_length_s = NULL;
+  curlhelp_statusline status_line;
+
+  int res = phr_parse_response (header_buf->buf, header_buf->buflen,
+    &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen,
+    headers, &nof_headers, 0);
+
+  content_length_s = get_header_value (headers, nof_headers, "content-length");
+  if (!content_length_s) {
+    return header_buf->buflen + body_buf->buflen;
+  }
+  content_length_s += strspn (content_length_s, " \t");
+  content_length = atoi (content_length_s);
+  if (content_length != body_buf->buflen) {
+    /* TODO: should we warn if the actual and the reported body length don't match? */
+  }
+
+  if (content_length_s) free (content_length_s);
+
+  return header_buf->buflen + body_buf->buflen;
+}
+
+/* TODO: is there a better way in libcurl to check for the SSL library? */
+curlhelp_ssl_library
+curlhelp_get_ssl_library (CURL* curl)
+{
+  curl_version_info_data* version_data;
+  char *ssl_version;
+  char *library;
+  curlhelp_ssl_library ssl_library = CURLHELP_SSL_LIBRARY_UNKNOWN;
+
+  version_data = curl_version_info (CURLVERSION_NOW);
+  if (version_data == NULL) return CURLHELP_SSL_LIBRARY_UNKNOWN;
+
+  ssl_version = strdup (version_data->ssl_version);
+  if (ssl_version == NULL ) return CURLHELP_SSL_LIBRARY_UNKNOWN;
+
+  library = strtok (ssl_version, "/");
+  if (library == NULL) return CURLHELP_SSL_LIBRARY_UNKNOWN;
+
+  if (strcmp (library, "OpenSSL") == 0)
+    ssl_library = CURLHELP_SSL_LIBRARY_OPENSSL;
+  else if (strcmp (library, "LibreSSL") == 0)
+    ssl_library = CURLHELP_SSL_LIBRARY_LIBRESSL;
+  else if (strcmp (library, "GnuTLS") == 0)
+    ssl_library = CURLHELP_SSL_LIBRARY_GNUTLS;
+  else if (strcmp (library, "NSS") == 0)
+    ssl_library = CURLHELP_SSL_LIBRARY_NSS;
+
+  if (verbose >= 2)
+    printf ("* SSL library string is : %s %s (%d)\n", version_data->ssl_version, library, ssl_library);
+
+  free (ssl_version);
+
+  return ssl_library;
+}
+
+const char*
+curlhelp_get_ssl_library_string (curlhelp_ssl_library ssl_library)
+{
+  switch (ssl_library) {
+    case CURLHELP_SSL_LIBRARY_OPENSSL:
+      return "OpenSSL";
+    case CURLHELP_SSL_LIBRARY_LIBRESSL:
+      return "LibreSSL";
+    case CURLHELP_SSL_LIBRARY_GNUTLS:
+      return "GnuTLS";
+    case CURLHELP_SSL_LIBRARY_NSS:
+      return "NSS";
+    case CURLHELP_SSL_LIBRARY_UNKNOWN:
+    default:
+      return "unknown";
+  }
+}
+
+#ifdef LIBCURL_FEATURE_SSL
+#ifndef USE_OPENSSL
+time_t
+parse_cert_date (const char *s)
+{
+  struct tm tm;
+  time_t date;
+
+  if (!s) return -1;
+
+  strptime (s, "%Y-%m-%d %H:%M:%S GMT", &tm);
+  date = mktime (&tm);
+
+  return date;
+}
+
+/* TODO: this needs cleanup in the sslutils.c, maybe we the #else case to
+ * OpenSSL could be this function
+ */
+int
+net_noopenssl_check_certificate (cert_ptr_union* cert_ptr, int days_till_exp_warn, int days_till_exp_crit)
+{
+  int i;
+  struct curl_slist* slist;
+  int cname_found = 0;
+  char* start_date_str = NULL;
+  char* end_date_str = NULL;
+  time_t start_date;
+  time_t end_date;
+        char *tz;
+        float time_left;
+        int days_left;
+        int time_remaining;
+        char timestamp[50] = "";
+        int status = STATE_UNKNOWN;
+
+  if (verbose >= 2)
+    printf ("**** REQUEST CERTIFICATES ****\n");
+
+  for (i = 0; i < cert_ptr->to_certinfo->num_of_certs; i++) {
+    for (slist = cert_ptr->to_certinfo->certinfo[i]; slist; slist = slist->next) {
+      /* find first common name in subject, TODO: check alternative subjects for
+       * multi-host certificate, check wildcards
+       */
+      if (strncasecmp (slist->data, "Subject:", 8) == 0) {
+        char* p = strstr (slist->data, "CN=");
+        if (p != NULL) {
+          if (strncmp (host_name, p+3, strlen (host_name)) == 0) {
+            cname_found = 1;
+          }
+        }
+      } else if (strncasecmp (slist->data, "Start Date:", 11) == 0) {
+        start_date_str = &slist->data[11];
+      } else if (strncasecmp (slist->data, "Expire Date:", 12) == 0) {
+        end_date_str = &slist->data[12];
+      } else if (strncasecmp (slist->data, "Cert:", 5) == 0) {
+        goto HAVE_FIRST_CERT;
+      }
+      if (verbose >= 2)
+        printf ("%d ** %s\n", i, slist->data);
+    }
+  }
+HAVE_FIRST_CERT:
+
+  if (verbose >= 2)
+    printf ("**** REQUEST CERTIFICATES ****\n");
+
+  if (!cname_found) {
+                printf("%s\n",_("CRITICAL - Cannot retrieve certificate subject."));
+                return STATE_CRITICAL;
+  }
+
+  start_date = parse_cert_date (start_date_str);
+  if (start_date <= 0) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, _("WARNING - Unparsable 'Start Date' in certificate: '%s'"),
+      start_date_str);
+    puts (msg);
+    return STATE_WARNING;
+  }
+
+  end_date = parse_cert_date (end_date_str);
+  if (end_date <= 0) {
+    snprintf (msg, DEFAULT_BUFFER_SIZE, _("WARNING - Unparsable 'Expire Date' in certificate: '%s'"),
+      start_date_str);
+    puts (msg);
+    return STATE_WARNING;
+  }
+
+  time_left = difftime (end_date, time(NULL));
+        days_left = time_left / 86400;
+        tz = getenv("TZ");
+        setenv("TZ", "GMT", 1);
+        tzset();
+        strftime(timestamp, 50, "%c %z", localtime(&end_date));
+        if (tz)
+                setenv("TZ", tz, 1);
+        else
+                unsetenv("TZ");
+        tzset();
+
+        if (days_left > 0 && days_left <= days_till_exp_warn) {
+                printf (_("%s - Certificate '%s' expires in %d day(s) (%s).\n"), (days_left>days_till_exp_crit)?"WARNING":"CRITICAL", host_name, days_left, timestamp);
+                if (days_left > days_till_exp_crit)
+                        status = STATE_WARNING;
+                else
+                        status = STATE_CRITICAL;
+        } else if (days_left == 0 && time_left > 0) {
+                if (time_left >= 3600)
+                        time_remaining = (int) time_left / 3600;
+                else
+                        time_remaining = (int) time_left / 60;
+
+                printf (_("%s - Certificate '%s' expires in %u %s (%s)\n"),
+                        (days_left>days_till_exp_crit) ? "WARNING" : "CRITICAL", host_name, time_remaining,
+                        time_left >= 3600 ? "hours" : "minutes", timestamp);
+
+                if ( days_left > days_till_exp_crit)
+                        status = STATE_WARNING;
+                else
+                        status = STATE_CRITICAL;
+        } else if (time_left < 0) {
+                printf(_("CRITICAL - Certificate '%s' expired on %s.\n"), host_name, timestamp);
+                status=STATE_CRITICAL;
+        } else if (days_left == 0) {
+                printf (_("%s - Certificate '%s' just expired (%s).\n"), (days_left>days_till_exp_crit)?"WARNING":"CRITICAL", host_name, timestamp);
+                if (days_left > days_till_exp_crit)
+                        status = STATE_WARNING;
+                else
+                        status = STATE_CRITICAL;
+        } else {
+                printf(_("OK - Certificate '%s' will expire on %s.\n"), host_name, timestamp);
+                status = STATE_OK;
+        }
+        return status;
+}
+#endif /* USE_OPENSSL */
+#endif /* LIBCURL_FEATURE_SSL */
diff --git a/plugins/picohttpparser/Makefile.am b/plugins/picohttpparser/Makefile.am
new file mode 100644
index 0000000..5a61027
--- /dev/null
+++ b/plugins/picohttpparser/Makefile.am
@@ -0,0 +1,3 @@
+noinst_LIBRARIES = libpicohttpparser.a
+
+libpicohttpparser_a_SOURCES = picohttpparser.c
diff --git a/plugins/picohttpparser/picohttpparser.c b/plugins/picohttpparser/picohttpparser.c
new file mode 100644
index 0000000..6a2d872
--- /dev/null
+++ b/plugins/picohttpparser/picohttpparser.c
@@ -0,0 +1,620 @@
+/*
+ * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase,
+ *                         Shigeo Mitsunari
+ *
+ * The software is licensed under either the MIT License (below) or the Perl
+ * license.
+ *
+ * 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.
+ */
+
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+#ifdef __SSE4_2__
+#ifdef _MSC_VER
+#include <nmmintrin.h>
+#else
+#include <x86intrin.h>
+#endif
+#endif
+#include "picohttpparser.h"
+
+/* $Id: a707070d11d499609f99d09f97535642cec910a8 $ */
+
+#if __GNUC__ >= 3
+#define likely(x) __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+#define likely(x) (x)
+#define unlikely(x) (x)
+#endif
+
+#ifdef _MSC_VER
+#define ALIGNED(n) _declspec(align(n))
+#else
+#define ALIGNED(n) __attribute__((aligned(n)))
+#endif
+
+#define IS_PRINTABLE_ASCII(c) ((unsigned char)(c)-040u < 0137u)
+
+#define CHECK_EOF()                                                                                                                \
+    if (buf == buf_end) {                                                                                                          \
+        *ret = -2;                                                                                                                 \
+        return NULL;                                                                                                               \
+    }
+
+#define EXPECT_CHAR_NO_CHECK(ch)                                                                                                   \
+    if (*buf++ != ch) {                                                                                                            \
+        *ret = -1;                                                                                                                 \
+        return NULL;                                                                                                               \
+    }
+
+#define EXPECT_CHAR(ch)                                                                                                            \
+    CHECK_EOF();                                                                                                                   \
+    EXPECT_CHAR_NO_CHECK(ch);
+
+#define ADVANCE_TOKEN(tok, toklen)                                                                                                 \
+    do {                                                                                                                           \
+        const char *tok_start = buf;                                                                                               \
+        static const char ALIGNED(16) ranges2[] = "\000\040\177\177";                                                              \
+        int found2;                                                                                                                \
+        buf = findchar_fast(buf, buf_end, ranges2, sizeof(ranges2) - 1, &found2);                                                  \
+        if (!found2) {                                                                                                             \
+            CHECK_EOF();                                                                                                           \
+        }                                                                                                                          \
+        while (1) {                                                                                                                \
+            if (*buf == ' ') {                                                                                                     \
+                break;                                                                                                             \
+            } else if (unlikely(!IS_PRINTABLE_ASCII(*buf))) {                                                                      \
+                if ((unsigned char)*buf < '\040' || *buf == '\177') {                                                              \
+                    *ret = -1;                                                                                                     \
+                    return NULL;                                                                                                   \
+                }                                                                                                                  \
+            }                                                                                                                      \
+            ++buf;                                                                                                                 \
+            CHECK_EOF();                                                                                                           \
+        }                                                                                                                          \
+        tok = tok_start;                                                                                                           \
+        toklen = buf - tok_start;                                                                                                  \
+    } while (0)
+
+static const char *token_char_map = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\1\0\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0"
+                                    "\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1"
+                                    "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+
+static const char *findchar_fast(const char *buf, const char *buf_end, const char *ranges, size_t ranges_size, int *found)
+{
+    *found = 0;
+#if __SSE4_2__
+    if (likely(buf_end - buf >= 16)) {
+        __m128i ranges16 = _mm_loadu_si128((const __m128i *)ranges);
+
+        size_t left = (buf_end - buf) & ~15;
+        do {
+            __m128i b16 = _mm_loadu_si128((const __m128i *)buf);
+            int r = _mm_cmpestri(ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS);
+            if (unlikely(r != 16)) {
+                buf += r;
+                *found = 1;
+                break;
+            }
+            buf += 16;
+            left -= 16;
+        } while (likely(left != 0));
+    }
+#else
+    /* suppress unused parameter warning */
+    (void)buf_end;
+    (void)ranges;
+    (void)ranges_size;
+#endif
+    return buf;
+}
+
+static const char *get_token_to_eol(const char *buf, const char *buf_end, const char **token, size_t *token_len, int *ret)
+{
+    const char *token_start = buf;
+
+#ifdef __SSE4_2__
+    static const char ranges1[] = "\0\010"
+                                  /* allow HT */
+                                  "\012\037"
+                                  /* allow SP and up to but not including DEL */
+                                  "\177\177"
+        /* allow chars w. MSB set */
+        ;
+    int found;
+    buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
+    if (found)
+        goto FOUND_CTL;
+#else
+    /* find non-printable char within the next 8 bytes, this is the hottest code; manually inlined */
+    while (likely(buf_end - buf >= 8)) {
+#define DOIT()                                                                                                                     \
+    do {                                                                                                                           \
+        if (unlikely(!IS_PRINTABLE_ASCII(*buf)))                                                                                   \
+            goto NonPrintable;                                                                                                     \
+        ++buf;                                                                                                                     \
+    } while (0)
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+#undef DOIT
+        continue;
+    NonPrintable:
+        if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
+            goto FOUND_CTL;
+        }
+        ++buf;
+    }
+#endif
+    for (;; ++buf) {
+        CHECK_EOF();
+        if (unlikely(!IS_PRINTABLE_ASCII(*buf))) {
+            if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
+                goto FOUND_CTL;
+            }
+        }
+    }
+FOUND_CTL:
+    if (likely(*buf == '\015')) {
+        ++buf;
+        EXPECT_CHAR('\012');
+        *token_len = buf - 2 - token_start;
+    } else if (*buf == '\012') {
+        *token_len = buf - token_start;
+        ++buf;
+    } else {
+        *ret = -1;
+        return NULL;
+    }
+    *token = token_start;
+
+    return buf;
+}
+
+static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret)
+{
+    int ret_cnt = 0;
+    buf = last_len < 3 ? buf : buf + last_len - 3;
+
+    while (1) {
+        CHECK_EOF();
+        if (*buf == '\015') {
+            ++buf;
+            CHECK_EOF();
+            EXPECT_CHAR('\012');
+            ++ret_cnt;
+        } else if (*buf == '\012') {
+            ++buf;
+            ++ret_cnt;
+        } else {
+            ++buf;
+            ret_cnt = 0;
+        }
+        if (ret_cnt == 2) {
+            return buf;
+        }
+    }
+
+    *ret = -2;
+    return NULL;
+}
+
+#define PARSE_INT(valp_, mul_)                                                                                                     \
+    if (*buf < '0' || '9' < *buf) {                                                                                                \
+        buf++;                                                                                                                     \
+        *ret = -1;                                                                                                                 \
+        return NULL;                                                                                                               \
+    }                                                                                                                              \
+    *(valp_) = (mul_) * (*buf++ - '0');
+
+#define PARSE_INT_3(valp_)                                                                                                         \
+    do {                                                                                                                           \
+        int res_ = 0;                                                                                                              \
+        PARSE_INT(&res_, 100)                                                                                                      \
+        *valp_ = res_;                                                                                                             \
+        PARSE_INT(&res_, 10)                                                                                                       \
+        *valp_ += res_;                                                                                                            \
+        PARSE_INT(&res_, 1)                                                                                                        \
+        *valp_ += res_;                                                                                                            \
+    } while (0)
+
+/* returned pointer is always within [buf, buf_end), or null */
+static const char *parse_http_version(const char *buf, const char *buf_end, int *minor_version, int *ret)
+{
+    /* we want at least [HTTP/1.<two chars>] to try to parse */
+    if (buf_end - buf < 9) {
+        *ret = -2;
+        return NULL;
+    }
+    EXPECT_CHAR_NO_CHECK('H');
+    EXPECT_CHAR_NO_CHECK('T');
+    EXPECT_CHAR_NO_CHECK('T');
+    EXPECT_CHAR_NO_CHECK('P');
+    EXPECT_CHAR_NO_CHECK('/');
+    EXPECT_CHAR_NO_CHECK('1');
+    EXPECT_CHAR_NO_CHECK('.');
+    PARSE_INT(minor_version, 1);
+    return buf;
+}
+
+static const char *parse_headers(const char *buf, const char *buf_end, struct phr_header *headers, size_t *num_headers,
+                                 size_t max_headers, int *ret)
+{
+    for (;; ++*num_headers) {
+        CHECK_EOF();
+        if (*buf == '\015') {
+            ++buf;
+            EXPECT_CHAR('\012');
+            break;
+        } else if (*buf == '\012') {
+            ++buf;
+            break;
+        }
+        if (*num_headers == max_headers) {
+            *ret = -1;
+            return NULL;
+        }
+        if (!(*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) {
+            /* parsing name, but do not discard SP before colon, see
+             * http://www.mozilla.org/security/announce/2006/mfsa2006-33.html */
+            headers[*num_headers].name = buf;
+            static const char ALIGNED(16) ranges1[] = "\x00 "  /* control chars and up to SP */
+                                                      "\"\""   /* 0x22 */
+                                                      "()"     /* 0x28,0x29 */
+                                                      ",,"     /* 0x2c */
+                                                      "//"     /* 0x2f */
+                                                      ":@"     /* 0x3a-0x40 */
+                                                      "[]"     /* 0x5b-0x5d */
+                                                      "{\377"; /* 0x7b-0xff */
+            int found;
+            buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
+            if (!found) {
+                CHECK_EOF();
+            }
+            while (1) {
+                if (*buf == ':') {
+                    break;
+                } else if (!token_char_map[(unsigned char)*buf]) {
+                    *ret = -1;
+                    return NULL;
+                }
+                ++buf;
+                CHECK_EOF();
+            }
+            if ((headers[*num_headers].name_len = buf - headers[*num_headers].name) == 0) {
+                *ret = -1;
+                return NULL;
+            }
+            ++buf;
+            for (;; ++buf) {
+                CHECK_EOF();
+                if (!(*buf == ' ' || *buf == '\t')) {
+                    break;
+                }
+            }
+        } else {
+            headers[*num_headers].name = NULL;
+            headers[*num_headers].name_len = 0;
+        }
+        if ((buf = get_token_to_eol(buf, buf_end, &headers[*num_headers].value, &headers[*num_headers].value_len, ret)) == NULL) {
+            return NULL;
+        }
+    }
+    return buf;
+}
+
+static const char *parse_request(const char *buf, const char *buf_end, const char **method, size_t *method_len, const char **path,
+                                 size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers,
+                                 size_t max_headers, int *ret)
+{
+    /* skip first empty line (some clients add CRLF after POST content) */
+    CHECK_EOF();
+    if (*buf == '\015') {
+        ++buf;
+        EXPECT_CHAR('\012');
+    } else if (*buf == '\012') {
+        ++buf;
+    }
+
+    /* parse request line */
+    ADVANCE_TOKEN(*method, *method_len);
+    ++buf;
+    ADVANCE_TOKEN(*path, *path_len);
+    ++buf;
+    if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
+        return NULL;
+    }
+    if (*buf == '\015') {
+        ++buf;
+        EXPECT_CHAR('\012');
+    } else if (*buf == '\012') {
+        ++buf;
+    } else {
+        *ret = -1;
+        return NULL;
+    }
+
+    return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
+}
+
+int phr_parse_request(const char *buf_start, size_t len, const char **method, size_t *method_len, const char **path,
+                      size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len)
+{
+    const char *buf = buf_start, *buf_end = buf_start + len;
+    size_t max_headers = *num_headers;
+    int r;
+
+    *method = NULL;
+    *method_len = 0;
+    *path = NULL;
+    *path_len = 0;
+    *minor_version = -1;
+    *num_headers = 0;
+
+    /* if last_len != 0, check if the request is complete (a fast countermeasure
+       againt slowloris */
+    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
+        return r;
+    }
+
+    if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers,
+                             &r)) == NULL) {
+        return r;
+    }
+
+    return (int)(buf - buf_start);
+}
+
+static const char *parse_response(const char *buf, const char *buf_end, int *minor_version, int *status, const char **msg,
+                                  size_t *msg_len, struct phr_header *headers, size_t *num_headers, size_t max_headers, int *ret)
+{
+    /* parse "HTTP/1.x" */
+    if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
+        return NULL;
+    }
+    /* skip space */
+    if (*buf++ != ' ') {
+        *ret = -1;
+        return NULL;
+    }
+    /* parse status code, we want at least [:digit:][:digit:][:digit:]<other char> to try to parse */
+    if (buf_end - buf < 4) {
+        *ret = -2;
+        return NULL;
+    }
+    PARSE_INT_3(status);
+
+    /* skip space */
+    if (*buf++ != ' ') {
+        *ret = -1;
+        return NULL;
+    }
+    /* get message */
+    if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) {
+        return NULL;
+    }
+
+    return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
+}
+
+int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
+                       struct phr_header *headers, size_t *num_headers, size_t last_len)
+{
+    const char *buf = buf_start, *buf_end = buf + len;
+    size_t max_headers = *num_headers;
+    int r;
+
+    *minor_version = -1;
+    *status = 0;
+    *msg = NULL;
+    *msg_len = 0;
+    *num_headers = 0;
+
+    /* if last_len != 0, check if the response is complete (a fast countermeasure
+       against slowloris */
+    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
+        return r;
+    }
+
+    if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len, headers, num_headers, max_headers, &r)) == NULL) {
+        return r;
+    }
+
+    return (int)(buf - buf_start);
+}
+
+int phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len)
+{
+    const char *buf = buf_start, *buf_end = buf + len;
+    size_t max_headers = *num_headers;
+    int r;
+
+    *num_headers = 0;
+
+    /* if last_len != 0, check if the response is complete (a fast countermeasure
+       against slowloris */
+    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
+        return r;
+    }
+
+    if ((buf = parse_headers(buf, buf_end, headers, num_headers, max_headers, &r)) == NULL) {
+        return r;
+    }
+
+    return (int)(buf - buf_start);
+}
+
+enum {
+    CHUNKED_IN_CHUNK_SIZE,
+    CHUNKED_IN_CHUNK_EXT,
+    CHUNKED_IN_CHUNK_DATA,
+    CHUNKED_IN_CHUNK_CRLF,
+    CHUNKED_IN_TRAILERS_LINE_HEAD,
+    CHUNKED_IN_TRAILERS_LINE_MIDDLE
+};
+
+static int decode_hex(int ch)
+{
+    if ('0' <= ch && ch <= '9') {
+        return ch - '0';
+    } else if ('A' <= ch && ch <= 'F') {
+        return ch - 'A' + 0xa;
+    } else if ('a' <= ch && ch <= 'f') {
+        return ch - 'a' + 0xa;
+    } else {
+        return -1;
+    }
+}
+
+ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *_bufsz)
+{
+    size_t dst = 0, src = 0, bufsz = *_bufsz;
+    ssize_t ret = -2; /* incomplete */
+
+    while (1) {
+        switch (decoder->_state) {
+        case CHUNKED_IN_CHUNK_SIZE:
+            for (;; ++src) {
+                int v;
+                if (src == bufsz)
+                    goto Exit;
+                if ((v = decode_hex(buf[src])) == -1) {
+                    if (decoder->_hex_count == 0) {
+                        ret = -1;
+                        goto Exit;
+                    }
+                    break;
+                }
+                if (decoder->_hex_count == sizeof(size_t) * 2) {
+                    ret = -1;
+                    goto Exit;
+                }
+                decoder->bytes_left_in_chunk = decoder->bytes_left_in_chunk * 16 + v;
+                ++decoder->_hex_count;
+            }
+            decoder->_hex_count = 0;
+            decoder->_state = CHUNKED_IN_CHUNK_EXT;
+        /* fallthru */
+        case CHUNKED_IN_CHUNK_EXT:
+            /* RFC 7230 A.2 "Line folding in chunk extensions is disallowed" */
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] == '\012')
+                    break;
+            }
+            ++src;
+            if (decoder->bytes_left_in_chunk == 0) {
+                if (decoder->consume_trailer) {
+                    decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
+                    break;
+                } else {
+                    goto Complete;
+                }
+            }
+            decoder->_state = CHUNKED_IN_CHUNK_DATA;
+        /* fallthru */
+        case CHUNKED_IN_CHUNK_DATA: {
+            size_t avail = bufsz - src;
+            if (avail < decoder->bytes_left_in_chunk) {
+                if (dst != src)
+                    memmove(buf + dst, buf + src, avail);
+                src += avail;
+                dst += avail;
+                decoder->bytes_left_in_chunk -= avail;
+                goto Exit;
+            }
+            if (dst != src)
+                memmove(buf + dst, buf + src, decoder->bytes_left_in_chunk);
+            src += decoder->bytes_left_in_chunk;
+            dst += decoder->bytes_left_in_chunk;
+            decoder->bytes_left_in_chunk = 0;
+            decoder->_state = CHUNKED_IN_CHUNK_CRLF;
+        }
+        /* fallthru */
+        case CHUNKED_IN_CHUNK_CRLF:
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] != '\015')
+                    break;
+            }
+            if (buf[src] != '\012') {
+                ret = -1;
+                goto Exit;
+            }
+            ++src;
+            decoder->_state = CHUNKED_IN_CHUNK_SIZE;
+            break;
+        case CHUNKED_IN_TRAILERS_LINE_HEAD:
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] != '\015')
+                    break;
+            }
+            if (buf[src++] == '\012')
+                goto Complete;
+            decoder->_state = CHUNKED_IN_TRAILERS_LINE_MIDDLE;
+        /* fallthru */
+        case CHUNKED_IN_TRAILERS_LINE_MIDDLE:
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] == '\012')
+                    break;
+            }
+            ++src;
+            decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
+            break;
+        default:
+            assert(!"decoder is corrupt");
+        }
+    }
+
+Complete:
+    ret = bufsz - src;
+Exit:
+    if (dst != src)
+        memmove(buf + dst, buf + src, bufsz - src);
+    *_bufsz = dst;
+    return ret;
+}
+
+int phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder)
+{
+    return decoder->_state == CHUNKED_IN_CHUNK_DATA;
+}
+
+#undef CHECK_EOF
+#undef EXPECT_CHAR
+#undef ADVANCE_TOKEN
diff --git a/plugins/picohttpparser/picohttpparser.h b/plugins/picohttpparser/picohttpparser.h
new file mode 100644
index 0000000..a8fad71
--- /dev/null
+++ b/plugins/picohttpparser/picohttpparser.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase,
+ *                         Shigeo Mitsunari
+ *
+ * The software is licensed under either the MIT License (below) or the Perl
+ * license.
+ *
+ * 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.
+ */
+
+#ifndef picohttpparser_h
+#define picohttpparser_h
+
+#include <sys/types.h>
+
+#ifdef _MSC_VER
+#define ssize_t intptr_t
+#endif
+
+/* $Id: 67fd3ee74103ada60258d8a16e868f483abcca87 $ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* contains name and value of a header (name == NULL if is a continuing line
+ * of a multiline header */
+struct phr_header {
+    const char *name;
+    size_t name_len;
+    const char *value;
+    size_t value_len;
+};
+
+/* returns number of bytes consumed if successful, -2 if request is partial,
+ * -1 if failed */
+int phr_parse_request(const char *buf, size_t len, const char **method, size_t *method_len, const char **path, size_t *path_len,
+                      int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len);
+
+/* ditto */
+int phr_parse_response(const char *_buf, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
+                       struct phr_header *headers, size_t *num_headers, size_t last_len);
+
+/* ditto */
+int phr_parse_headers(const char *buf, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len);
+
+/* should be zero-filled before start */
+struct phr_chunked_decoder {
+    size_t bytes_left_in_chunk; /* number of bytes left in current chunk */
+    char consume_trailer;       /* if trailing headers should be consumed */
+    char _hex_count;
+    char _state;
+};
+
+/* the function rewrites the buffer given as (buf, bufsz) removing the chunked-
+ * encoding headers.  When the function returns without an error, bufsz is
+ * updated to the length of the decoded data available.  Applications should
+ * repeatedly call the function while it returns -2 (incomplete) every time
+ * supplying newly arrived data.  If the end of the chunked-encoded data is
+ * found, the function returns a non-negative number indicating the number of
+ * octets left undecoded at the tail of the supplied buffer.  Returns -1 on
+ * error.
+ */
+ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *bufsz);
+
+/* returns if the chunked decoder is in middle of chunked data */
+int phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/plugins/sslutils.c b/plugins/sslutils.c
index e38947e..14f6579 100644
--- a/plugins/sslutils.c
+++ b/plugins/sslutils.c
@@ -1,29 +1,29 @@
 /*****************************************************************************
-* 
+*
 * Monitoring Plugins SSL utilities
-* 
+*
 * License: GPL
 * Copyright (c) 2005-2010 Monitoring Plugins Development Team
-* 
+*
 * Description:
-* 
+*
 * This file contains common functions for plugins that require SSL.
-* 
+*
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
-* 
+*
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
-* 
+*
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
-* 
-* 
+*
+*
 *****************************************************************************/
 
 #define MAX_CN_LENGTH 256
@@ -193,12 +193,22 @@ int np_net_ssl_read(void *buf, int num) {
 
 int np_net_ssl_check_cert(int days_till_exp_warn, int days_till_exp_crit){
 #  ifdef USE_OPENSSL
-        X509 *certificate=NULL;
+        X509 *certificate = NULL;
+        certificate=SSL_get_peer_certificate(s);
+        return(np_net_ssl_check_certificate(certificate, days_till_exp_warn, days_till_exp_crit));
+#  else /* ifndef USE_OPENSSL */
+        printf("%s\n", _("WARNING - Plugin does not support checking certificates."));
+        return STATE_WARNING;
+#  endif /* USE_OPENSSL */
+}
+
+int np_net_ssl_check_certificate(X509 *certificate, int days_till_exp_warn, int days_till_exp_crit){
+#  ifdef USE_OPENSSL
         X509_NAME *subj=NULL;
         char timestamp[50] = "";
         char cn[MAX_CN_LENGTH]= "";
         char *tz;
-        
+
         int cnlen =-1;
         int status=STATE_UNKNOWN;
 
@@ -210,7 +220,6 @@ int np_net_ssl_check_cert(int days_till_exp_warn, int days_till_exp_crit){
         int time_remaining;
         time_t tm_t;
 
-        certificate=SSL_get_peer_certificate(s);
         if (!certificate) {
                 printf("%s\n",_("CRITICAL - Cannot retrieve server certificate."));
                 return STATE_CRITICAL;
diff --git a/plugins/t/check_curl.t b/plugins/t/check_curl.t
new file mode 100644
index 0000000..e67fafb
--- /dev/null
+++ b/plugins/t/check_curl.t
@@ -0,0 +1,204 @@
+#! /usr/bin/perl -w -I ..
+#
+# HyperText Transfer Protocol (HTTP) Test via check_http
+#
+#
+
+use strict;
+use Test::More;
+use POSIX qw/mktime strftime/;
+use NPTest;
+
+plan tests => 49;
+
+my $successOutput = '/OK.*HTTP.*second/';
+
+my $res;
+my $plugin = 'check_http';
+$plugin    = 'check_curl' if $0 =~ m/check_curl/mx;
+
+my $host_tcp_http      = getTestParameter( "NP_HOST_TCP_HTTP",
+                "A host providing the HTTP Service (a web server)",
+                "localhost" );
+
+my $host_tls_http      = getTestParameter( "host_tls_http",      "NP_HOST_TLS_HTTP",      "localhost",
+                                           "A host providing the HTTPS Service (a tls web server)" );
+
+my $host_tls_cert      = getTestParameter( "host_tls_cert",      "NP_HOST_TLS_CERT",      "localhost",
+                                           "the common name of the certificate." );
+
+
+my $host_nonresponsive = getTestParameter( "NP_HOST_NONRESPONSIVE",
+                "The hostname of system not responsive to network requests",
+                "10.0.0.1" );
+
+my $hostname_invalid   = getTestParameter( "NP_HOSTNAME_INVALID",
+                "An invalid (not known to DNS) hostname",
+                "nosuchhost");
+
+my $internet_access = getTestParameter( "NP_INTERNET_ACCESS",
+                "Is this system directly connected to the internet?",
+                "yes");
+
+my $host_tcp_http2  = getTestParameter( "NP_HOST_TCP_HTTP2",
+            "A host providing an index page containing the string 'monitoring'",
+            "test.monitoring-plugins.org" );
+
+my $faketime = -x '/usr/bin/faketime' ? 1 : 0;
+
+
+$res = NPTest->testCmd(
+        "./$plugin $host_tcp_http -wt 300 -ct 600"
+        );
+cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" );
+like( $res->output, $successOutput, "Output OK" );
+
+$res = NPTest->testCmd(
+        "./$plugin $host_tcp_http -wt 300 -ct 600 -v -v -v -k 'bob:there' -k 'carl:frown'"
+        );
+like( $res->output, '/bob:there\r\ncarl:frown\r\n/', "Got headers with multiple -k options" );
+
+$res = NPTest->testCmd(
+        "./$plugin $host_nonresponsive -wt 1 -ct 2 -t 3"
+        );
+cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" );
+# was CRITICAL only, but both check_curl and check_http print HTTP CRITICAL (puzzle?!)
+cmp_ok( $res->output, 'eq', "HTTP CRITICAL - Invalid HTTP response received from host on port 80: cURL returned 28 - Timeout was reached", "Output OK");
+
+$res = NPTest->testCmd(
+        "./$plugin $hostname_invalid -wt 1 -ct 2"
+        );
+cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" );
+# The first part of the message comes from the OS catalogue, so cannot check this.
+# On Debian, it is Name or service not known, on Darwin, it is No address associated with nodename
+# Is also possible to get a socket timeout if DNS is not responding fast enough
+# cURL gives us consistent strings from it's own 'lib/strerror.c'
+like( $res->output, "/cURL returned 6 - Couldn't resolve host name/", "Output OK");
+
+# host header checks
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http");
+like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" );
+
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http -p 80");
+like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" );
+
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80");
+like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
+
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80");
+like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
+
+SKIP: {
+        skip "No internet access", 3 if $internet_access eq "no";
+
+        $res = NPTest->testCmd("./$plugin -v -H $host_tls_http -S");
+        like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" );
+
+        $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:8080 -S -p 443");
+        like( $res->output, '/^Host: '.$host_tls_http.':8080\s*$/ms', "Host Header OK" );
+
+        $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:443 -S -p 443");
+        like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" );
+};
+
+SKIP: {
+        skip "No host serving monitoring in index file", 7 unless $host_tcp_http2;
+
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring'" );
+        cmp_ok( $res->return_code, "==", 0, "Got a reference to 'monitoring'");
+
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing'" );
+        cmp_ok( $res->return_code, "==", 2, "Not got 'mONiTORing'");
+        like ( $res->output, "/pattern not found/", "Error message says 'pattern not found'");
+
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -R 'mONiTORing'" );
+        cmp_ok( $res->return_code, "==", 0, "But case insensitive doesn't mind 'mONiTORing'");
+
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring' --invert-regex" );
+        cmp_ok( $res->return_code, "==", 2, "Invert results work when found");
+        like ( $res->output, "/pattern found/", "Error message says 'pattern found'");
+
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" );
+        cmp_ok( $res->return_code, "==", 0, "And also when not found");
+}
+SKIP: {
+        skip "No internet access", 16 if $internet_access eq "no";
+
+        $res = NPTest->testCmd(
+                "./$plugin --ssl $host_tls_http"
+                );
+        cmp_ok( $res->return_code, '==', 0, "Can read https for $host_tls_http" );
+
+        $res = NPTest->testCmd( "./$plugin -C 1 --ssl $host_tls_http" );
+        cmp_ok( $res->return_code, '==', 0, "Checking certificate for $host_tls_http");
+        like  ( $res->output, "/Certificate '$host_tls_cert' will expire on/", "Output OK" );
+        my $saved_cert_output = $res->output;
+
+        $res = NPTest->testCmd( "./$plugin -C 8000,1 --ssl $host_tls_http" );
+        cmp_ok( $res->return_code, '==', 1, "Checking certificate for $host_tls_http");
+        like  ( $res->output, qr/WARNING - Certificate '$host_tls_cert' expires in \d+ day/, "Output Warning" );
+
+        $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" );
+        is( $res->return_code, 0, "Old syntax for cert checking okay" );
+        is( $res->output, $saved_cert_output, "Same output as new syntax" );
+
+        $res = NPTest->testCmd( "./$plugin -H $host_tls_http -C 1" );
+        is( $res->return_code, 0, "Updated syntax for cert checking okay" );
+        is( $res->output, $saved_cert_output, "Same output as new syntax" );
+
+        $res = NPTest->testCmd( "./$plugin -C 1 $host_tls_http" );
+        cmp_ok( $res->output, 'eq', $saved_cert_output, "--ssl option automatically added");
+
+        $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" );
+        cmp_ok( $res->output, 'eq', $saved_cert_output, "Old syntax for cert checking still works");
+
+        # run some certificate checks with faketime
+        SKIP: {
+                skip "No faketime binary found", 12 if !$faketime;
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./$plugin -C 1 $host_tls_http");
+                like($res->output, qr/OK - Certificate '$host_tls_cert' will expire on/, "Catch cert output");
+                is( $res->return_code, 0, "Catch cert output exit code" );
+                my($mon,$day,$hour,$min,$sec,$year) = ($res->output =~ /(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+)/);
+                if(!defined $year) {
+                    die("parsing date failed from: ".$res->output);
+                }
+                my $months = {'Jan' => 0, 'Feb' => 1, 'Mar' => 2, 'Apr' => 3, 'May' => 4, 'Jun' => 5, 'Jul' => 6, 'Aug' => 7, 'Sep' => 8, 'Oct' => 9, 'Nov' => 10, 'Dec' => 11};
+                my $ts   = mktime($sec, $min, $hour, $day, $months->{$mon}, $year-1900);
+                my $time = strftime("%Y-%m-%d %H:%M:%S", localtime($ts));
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./$plugin -C 1 $host_tls_http");
+                like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' just expired/, "Output on expire date");
+                is( $res->return_code, 2, "Output on expire date" );
+
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-1))."' ./$plugin -C 1 $host_tls_http");
+                like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 0 minutes/, "cert expires in 1 second output");
+                is( $res->return_code, 2, "cert expires in 1 second exit code" );
+
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-120))."' ./$plugin -C 1 $host_tls_http");
+                like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 minutes/, "cert expires in 2 minutes output");
+                is( $res->return_code, 2, "cert expires in 2 minutes exit code" );
+
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-7200))."' ./$plugin -C 1 $host_tls_http");
+                like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 hours/, "cert expires in 2 hours output");
+                is( $res->return_code, 2, "cert expires in 2 hours exit code" );
+
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./$plugin -C 1 $host_tls_http");
+                like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expired on/, "Certificate expired output");
+                is( $res->return_code, 2, "Certificate expired exit code" );
+        };
+
+        $res = NPTest->testCmd( "./$plugin --ssl $host_tls_http -E" );
+        like  ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' );
+        like  ( $res->output, '/time_ssl=[\d\.]+/', 'Extended Performance Data SSL Output OK' );
+
+        $res = NPTest->testCmd(
+                "./$plugin --ssl -H www.e-paycobalt.com"
+                );
+        cmp_ok( $res->return_code, "==", 0, "Can read https for www.e-paycobalt.com (uses AES certificate)" );
+
+
+        $res = NPTest->testCmd( "./$plugin -H www.mozilla.com -u /firefox -f follow" );
+        is( $res->return_code, 0, "Redirection based on location is okay");
+
+        $res = NPTest->testCmd( "./$plugin -H www.mozilla.com --extended-perfdata" );
+        like  ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' );
+}
diff --git a/plugins/t/check_http.t b/plugins/t/check_http.t
index 8bd484a..281fa36 100644
--- a/plugins/t/check_http.t
+++ b/plugins/t/check_http.t
@@ -14,6 +14,8 @@ plan tests => 49;
 my $successOutput = '/OK.*HTTP.*second/';
 
 my $res;
+my $plugin = 'check_http';
+$plugin    = 'check_curl' if $0 =~ m/check_curl/mx;
 
 my $host_tcp_http      = getTestParameter( "NP_HOST_TCP_HTTP",
                 "A host providing the HTTP Service (a web server)",
@@ -46,24 +48,24 @@ my $faketime = -x '/usr/bin/faketime' ? 1 : 0;
 
 
 $res = NPTest->testCmd(
-        "./check_http $host_tcp_http -wt 300 -ct 600"
+        "./$plugin $host_tcp_http -wt 300 -ct 600"
         );
 cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" );
 like( $res->output, $successOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "./check_http $host_tcp_http -wt 300 -ct 600 -v -v -v -k 'bob:there' -k 'carl:frown'"
+        "./$plugin $host_tcp_http -wt 300 -ct 600 -v -v -v -k 'bob:there' -k 'carl:frown'"
         );
 like( $res->output, '/bob:there\r\ncarl:frown\r\n/', "Got headers with multiple -k options" );
 
 $res = NPTest->testCmd(
-        "./check_http $host_nonresponsive -wt 1 -ct 2 -t 3"
+        "./$plugin $host_nonresponsive -wt 1 -ct 2 -t 3"
         );
 cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" );
 cmp_ok( $res->output, 'eq', "CRITICAL - Socket timeout after 3 seconds", "Output OK");
 
 $res = NPTest->testCmd(
-        "./check_http $hostname_invalid -wt 1 -ct 2"
+        "./$plugin $hostname_invalid -wt 1 -ct 2"
         );
 cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" );
 # The first part of the message comes from the OS catalogue, so cannot check this.
@@ -72,86 +74,86 @@ cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" );
 like( $res->output, "/Unable to open TCP socket|Socket timeout after/", "Output OK");
 
 # host header checks
-$res = NPTest->testCmd("./check_http -v -H $host_tcp_http");
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http");
 like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" );
 
-$res = NPTest->testCmd("./check_http -v -H $host_tcp_http -p 80");
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http -p 80");
 like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" );
 
-$res = NPTest->testCmd("./check_http -v -H $host_tcp_http:8080 -p 80");
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80");
 like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
 
-$res = NPTest->testCmd("./check_http -v -H $host_tcp_http:8080 -p 80");
+$res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80");
 like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
 
 SKIP: {
         skip "No internet access", 3 if $internet_access eq "no";
 
-        $res = NPTest->testCmd("./check_http -v -H $host_tls_http -S");
+        $res = NPTest->testCmd("./$plugin -v -H $host_tls_http -S");
         like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" );
 
-        $res = NPTest->testCmd("./check_http -v -H $host_tls_http:8080 -S -p 443");
+        $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:8080 -S -p 443");
         like( $res->output, '/^Host: '.$host_tls_http.':8080\s*$/ms', "Host Header OK" );
 
-        $res = NPTest->testCmd("./check_http -v -H $host_tls_http:443 -S -p 443");
+        $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:443 -S -p 443");
         like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" );
 };
 
 SKIP: {
         skip "No host serving monitoring in index file", 7 unless $host_tcp_http2;
 
-        $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'monitoring'" );
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring'" );
         cmp_ok( $res->return_code, "==", 0, "Got a reference to 'monitoring'");
 
-        $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'mONiTORing'" );
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing'" );
         cmp_ok( $res->return_code, "==", 2, "Not got 'mONiTORing'");
         like ( $res->output, "/pattern not found/", "Error message says 'pattern not found'");
 
-        $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -R 'mONiTORing'" );
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -R 'mONiTORing'" );
         cmp_ok( $res->return_code, "==", 0, "But case insensitive doesn't mind 'mONiTORing'");
 
-        $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'monitoring' --invert-regex" );
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring' --invert-regex" );
         cmp_ok( $res->return_code, "==", 2, "Invert results work when found");
         like ( $res->output, "/pattern found/", "Error message says 'pattern found'");
 
-        $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" );
+        $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" );
         cmp_ok( $res->return_code, "==", 0, "And also when not found");
 }
 SKIP: {
         skip "No internet access", 16 if $internet_access eq "no";
 
         $res = NPTest->testCmd(
-                "./check_http --ssl $host_tls_http"
+                "./$plugin --ssl $host_tls_http"
                 );
         cmp_ok( $res->return_code, '==', 0, "Can read https for $host_tls_http" );
 
-        $res = NPTest->testCmd( "./check_http -C 1 --ssl $host_tls_http" );
+        $res = NPTest->testCmd( "./$plugin -C 1 --ssl $host_tls_http" );
         cmp_ok( $res->return_code, '==', 0, "Checking certificate for $host_tls_http");
         like  ( $res->output, "/Certificate '$host_tls_cert' will expire on/", "Output OK" );
         my $saved_cert_output = $res->output;
 
-        $res = NPTest->testCmd( "./check_http -C 8000,1 --ssl $host_tls_http" );
+        $res = NPTest->testCmd( "./$plugin -C 8000,1 --ssl $host_tls_http" );
         cmp_ok( $res->return_code, '==', 1, "Checking certificate for $host_tls_http");
         like  ( $res->output, qr/WARNING - Certificate '$host_tls_cert' expires in \d+ day/, "Output Warning" );
 
-        $res = NPTest->testCmd( "./check_http $host_tls_http -C 1" );
+        $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" );
         is( $res->return_code, 0, "Old syntax for cert checking okay" );
         is( $res->output, $saved_cert_output, "Same output as new syntax" );
 
-        $res = NPTest->testCmd( "./check_http -H $host_tls_http -C 1" );
+        $res = NPTest->testCmd( "./$plugin -H $host_tls_http -C 1" );
         is( $res->return_code, 0, "Updated syntax for cert checking okay" );
         is( $res->output, $saved_cert_output, "Same output as new syntax" );
 
-        $res = NPTest->testCmd( "./check_http -C 1 $host_tls_http" );
+        $res = NPTest->testCmd( "./$plugin -C 1 $host_tls_http" );
         cmp_ok( $res->output, 'eq', $saved_cert_output, "--ssl option automatically added");
 
-        $res = NPTest->testCmd( "./check_http $host_tls_http -C 1" );
+        $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" );
         cmp_ok( $res->output, 'eq', $saved_cert_output, "Old syntax for cert checking still works");
 
         # run some certificate checks with faketime
         SKIP: {
                 skip "No faketime binary found", 12 if !$faketime;
-                $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./check_http -C 1 $host_tls_http");
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./$plugin -C 1 $host_tls_http");
                 like($res->output, qr/OK - Certificate '$host_tls_cert' will expire on/, "Catch cert output");
                 is( $res->return_code, 0, "Catch cert output exit code" );
                 my($mon,$day,$hour,$min,$sec,$year) = ($res->output =~ /(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+)/);
@@ -161,40 +163,40 @@ SKIP: {
                 my $months = {'Jan' => 0, 'Feb' => 1, 'Mar' => 2, 'Apr' => 3, 'May' => 4, 'Jun' => 5, 'Jul' => 6, 'Aug' => 7, 'Sep' => 8, 'Oct' => 9, 'Nov' => 10, 'Dec' => 11};
                 my $ts   = mktime($sec, $min, $hour, $day, $months->{$mon}, $year-1900);
                 my $time = strftime("%Y-%m-%d %H:%M:%S", localtime($ts));
-                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_http -C 1 $host_tls_http");
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./$plugin -C 1 $host_tls_http");
                 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' just expired/, "Output on expire date");
                 is( $res->return_code, 2, "Output on expire date" );
 
-                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-1))."' ./check_http -C 1 $host_tls_http");
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-1))."' ./$plugin -C 1 $host_tls_http");
                 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 0 minutes/, "cert expires in 1 second output");
                 is( $res->return_code, 2, "cert expires in 1 second exit code" );
 
-                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-120))."' ./check_http -C 1 $host_tls_http");
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-120))."' ./$plugin -C 1 $host_tls_http");
                 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 minutes/, "cert expires in 2 minutes output");
                 is( $res->return_code, 2, "cert expires in 2 minutes exit code" );
 
-                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-7200))."' ./check_http -C 1 $host_tls_http");
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-7200))."' ./$plugin -C 1 $host_tls_http");
                 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 hours/, "cert expires in 2 hours output");
                 is( $res->return_code, 2, "cert expires in 2 hours exit code" );
 
-                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_http -C 1 $host_tls_http");
+                $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./$plugin -C 1 $host_tls_http");
                 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expired on/, "Certificate expired output");
                 is( $res->return_code, 2, "Certificate expired exit code" );
         };
 
-        $res = NPTest->testCmd( "./check_http --ssl $host_tls_http -E" );
+        $res = NPTest->testCmd( "./$plugin --ssl $host_tls_http -E" );
         like  ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' );
         like  ( $res->output, '/time_ssl=[\d\.]+/', 'Extended Performance Data SSL Output OK' );
 
         $res = NPTest->testCmd(
-                "./check_http --ssl -H www.e-paycobalt.com"
+                "./$plugin --ssl -H www.e-paycobalt.com"
                 );
         cmp_ok( $res->return_code, "==", 0, "Can read https for www.e-paycobalt.com (uses AES certificate)" );
 
 
-        $res = NPTest->testCmd( "./check_http -H www.mozilla.com -u /firefox -f follow" );
+        $res = NPTest->testCmd( "./$plugin -H www.mozilla.com -u /firefox -f follow" );
         is( $res->return_code, 0, "Redirection based on location is okay");
 
-        $res = NPTest->testCmd( "./check_http -H www.mozilla.com --extended-perfdata" );
+        $res = NPTest->testCmd( "./$plugin -H www.mozilla.com --extended-perfdata" );
         like  ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' );
 }
diff --git a/plugins/tests/check_curl.t b/plugins/tests/check_curl.t
new file mode 100755
index 0000000..28dacd0
--- /dev/null
+++ b/plugins/tests/check_curl.t
@@ -0,0 +1,455 @@
+#! /usr/bin/perl -w -I ..
+#
+# Test check_http by having an actual HTTP server running
+#
+# To create the https server certificate:
+# openssl req -new -x509 -keyout server-key.pem -out server-cert.pem -days 3650 -nodes
+# Country Name (2 letter code) [AU]:UK
+# State or Province Name (full name) [Some-State]:Derbyshire
+# Locality Name (eg, city) []:Belper
+# Organization Name (eg, company) [Internet Widgits Pty Ltd]:Monitoring Plugins
+# Organizational Unit Name (eg, section) []:
+# Common Name (eg, YOUR name) []:Ton Voon
+# Email Address []:tonvoon@mac.com
+
+use strict;
+use Test::More;
+use NPTest;
+use FindBin qw($Bin);
+
+$ENV{'LC_TIME'} = "C";
+
+my $common_tests = 70;
+my $virtual_port_tests = 8;
+my $ssl_only_tests = 8;
+# Check that all dependent modules are available
+eval "use HTTP::Daemon 6.01;";
+plan skip_all => 'HTTP::Daemon >= 6.01 required' if $@;
+eval {
+        require HTTP::Status;
+        require HTTP::Response;
+};
+
+my $plugin = 'check_http';
+$plugin    = 'check_curl' if $0 =~ m/check_curl/mx;
+
+if ($@) {
+        plan skip_all => "Missing required module for test: $@";
+} else {
+        if (-x "./$plugin") {
+                plan tests => $common_tests * 2 + $ssl_only_tests + $virtual_port_tests;
+        } else {
+                plan skip_all => "No $plugin compiled";
+        }
+}
+
+my $servers = { http => 0 };    # HTTP::Daemon should always be available
+eval { require HTTP::Daemon::SSL };
+if ($@) {
+        diag "Cannot load HTTP::Daemon::SSL: $@";
+} else {
+        $servers->{https} = 0;
+}
+
+# set a fixed version, so the header size doesn't vary
+$HTTP::Daemon::VERSION = "1.00";
+
+my $port_http = 50000 + int(rand(1000));
+my $port_https = $port_http + 1;
+my $port_https_expired = $port_http + 2;
+
+# This array keeps sockets around for implementing timeouts
+my @persist;
+
+# Start up all servers
+my @pids;
+my $pid = fork();
+if ($pid) {
+        # Parent
+        push @pids, $pid;
+        if (exists $servers->{https}) {
+                # Fork a normal HTTPS server
+                $pid = fork();
+                if ($pid) {
+                        # Parent
+                        push @pids, $pid;
+                        # Fork an expired cert server
+                        $pid = fork();
+                        if ($pid) {
+                                push @pids, $pid;
+                        } else {
+                                my $d = HTTP::Daemon::SSL->new(
+                                        LocalPort => $port_https_expired,
+                                        LocalAddr => "127.0.0.1",
+                                        SSL_cert_file => "$Bin/certs/expired-cert.pem",
+                                        SSL_key_file => "$Bin/certs/expired-key.pem",
+                                ) || die;
+                                print "Please contact https expired at: <URL:", $d->url, ">\n";
+                                run_server( $d );
+                                exit;
+                        }
+                } else {
+                        my $d = HTTP::Daemon::SSL->new(
+                                LocalPort => $port_https,
+                                LocalAddr => "127.0.0.1",
+                                SSL_cert_file => "$Bin/certs/server-cert.pem",
+                                SSL_key_file => "$Bin/certs/server-key.pem",
+                        ) || die;
+                        print "Please contact https at: <URL:", $d->url, ">\n";
+                        run_server( $d );
+                        exit;
+                }
+        }
+        # give our webservers some time to startup
+        sleep(1);
+} else {
+        # Child
+        #print "child\n";
+        my $d = HTTP::Daemon->new(
+                LocalPort => $port_http,
+                LocalAddr => "127.0.0.1",
+        ) || die;
+        print "Please contact http at: <URL:", $d->url, ">\n";
+        run_server( $d );
+        exit;
+}
+
+# Run the same server on http and https
+sub run_server {
+        my $d = shift;
+        MAINLOOP: while (my $c = $d->accept ) {
+                while (my $r = $c->get_request) {
+                        if ($r->method eq "GET" and $r->url->path =~ m^/statuscode/(\d+)^) {
+                                $c->send_basic_header($1);
+                                $c->send_crlf;
+                        } elsif ($r->method eq "GET" and $r->url->path =~ m^/file/(.*)^) {
+                                $c->send_basic_header;
+                                $c->send_crlf;
+                                $c->send_file_response("$Bin/var/$1");
+                        } elsif ($r->method eq "GET" and $r->url->path eq "/slow") {
+                                $c->send_basic_header;
+                                $c->send_crlf;
+                                sleep 1;
+                                $c->send_response("slow");
+                        } elsif ($r->url->path eq "/method") {
+                                if ($r->method eq "DELETE") {
+                                        $c->send_error(HTTP::Status->RC_METHOD_NOT_ALLOWED);
+                                } elsif ($r->method eq "foo") {
+                                        $c->send_error(HTTP::Status->RC_NOT_IMPLEMENTED);
+                                } else {
+                                        $c->send_status_line(200, $r->method);
+                                }
+                        } elsif ($r->url->path eq "/postdata") {
+                                $c->send_basic_header;
+                                $c->send_crlf;
+                                $c->send_response($r->method.":".$r->content);
+                        } elsif ($r->url->path eq "/redirect") {
+                                $c->send_redirect( "/redirect2" );
+                        } elsif ($r->url->path eq "/redir_external") {
+                                $c->send_redirect(($d->isa('HTTP::Daemon::SSL') ? "https" : "http") . "://169.254.169.254/redirect2" );
+                        } elsif ($r->url->path eq "/redirect2") {
+                                $c->send_basic_header;
+                                $c->send_crlf;
+                                $c->send_response(HTTP::Response->new( 200, 'OK', undef, 'redirected' ));
+                        } elsif ($r->url->path eq "/redir_timeout") {
+                                $c->send_redirect( "/timeout" );
+                        } elsif ($r->url->path eq "/timeout") {
+                                # Keep $c from being destroyed, but prevent severe leaks
+                                unshift @persist, $c;
+                                delete($persist[1000]);
+                                next MAINLOOP;
+                        } elsif ($r->url->path eq "/header_check") {
+                                $c->send_basic_header;
+                                $c->send_header('foo');
+                                $c->send_crlf;
+                        } elsif ($r->url->path eq "/virtual_port") {
+                                # return sent Host header
+                                $c->send_basic_header;
+                                $c->send_crlf;
+                                $c->send_response(HTTP::Response->new( 200, 'OK', undef, $r->header ('Host')));
+                        } else {
+                                $c->send_error(HTTP::Status->RC_FORBIDDEN);
+                        }
+                        $c->close;
+                }
+        }
+}
+
+END {
+        foreach my $pid (@pids) {
+                if ($pid) { print "Killing $pid\n"; kill "INT", $pid }
+        }
+};
+
+if ($ARGV[0] && $ARGV[0] eq "-d") {
+        while (1) {
+                sleep 100;
+        }
+}
+
+my $result;
+my $command = "./$plugin -H 127.0.0.1";
+
+run_common_tests( { command => "$command -p $port_http" } );
+SKIP: {
+        skip "HTTP::Daemon::SSL not installed", $common_tests + $ssl_only_tests if ! exists $servers->{https};
+        run_common_tests( { command => "$command -p $port_https", ssl => 1 } );
+
+        $result = NPTest->testCmd( "$command -p $port_https -S -C 14" );
+        is( $result->return_code, 0, "$command -p $port_https -S -C 14" );
+        is( $result->output, 'OK - Certificate \'Ton Voon\' will expire on Sun Mar  3 21:41:28 2019 +0000.', "output ok" );
+
+        $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" );
+        is( $result->return_code, 1, "$command -p $port_https -S -C 14000" );
+        like( $result->output, '/WARNING - Certificate \'Ton Voon\' expires in \d+ day\(s\) \(Sun Mar  3 21:41:28 2019 \+0000\)./', "output ok" );
+
+        # Expired cert tests
+        $result = NPTest->testCmd( "$command -p $port_https -S -C 13960,14000" );
+        is( $result->return_code, 2, "$command -p $port_https -S -C 13960,14000" );
+        like( $result->output, '/CRITICAL - Certificate \'Ton Voon\' expires in \d+ day\(s\) \(Sun Mar  3 21:41:28 2019 \+0000\)./', "output ok" );
+
+        $result = NPTest->testCmd( "$command -p $port_https_expired -S -C 7" );
+        is( $result->return_code, 2, "$command -p $port_https_expired -S -C 7" );
+        is( $result->output,
+                'CRITICAL - Certificate \'Ton Voon\' expired on Thu Mar  5 00:13:16 2009 +0000.',
+                "output ok" );
+
+}
+
+my $cmd;
+# check virtual port behaviour
+#
+# http without virtual port
+$cmd = "$command -p $port_http -u /virtual_port -r ^127.0.0.1:$port_http\$";
+$result = NPTest->testCmd( $cmd );
+is( $result->return_code, 0, $cmd);
+like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+# http with virtual port
+$cmd = "$command:80 -p $port_http -u /virtual_port -r ^127.0.0.1\$";
+$result = NPTest->testCmd( $cmd );
+is( $result->return_code, 0, $cmd);
+like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+SKIP: {
+        skip "HTTP::Daemon::SSL not installed", 4 if ! exists $servers->{https};
+        # https without virtual port
+        $cmd = "$command -p $port_https --ssl -u /virtual_port -r ^127.0.0.1:$port_https\$";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        # https with virtual port
+        $cmd = "$command:443 -p $port_https --ssl -u /virtual_port -r ^127.0.0.1\$";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+}
+
+
+sub run_common_tests {
+        my ($opts) = @_;
+        my $command = $opts->{command};
+        if ($opts->{ssl}) {
+                $command .= " --ssl";
+        }
+
+        $result = NPTest->testCmd( "$command -u /file/root" );
+        is( $result->return_code, 0, "/file/root");
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 274 bytes in [\d\.]+ second/', "Output correct" );
+
+        $result = NPTest->testCmd( "$command -u /file/root -s Root" );
+        is( $result->return_code, 0, "/file/root search for string");
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 274 bytes in [\d\.]+ second/', "Output correct" );
+
+        $result = NPTest->testCmd( "$command -u /file/root -s NonRoot" );
+        is( $result->return_code, 2, "Missing string check");
+        like( $result->output, qr%^HTTP CRITICAL: HTTP/1\.1 200 OK - string 'NonRoot' not found on 'https?://127\.0\.0\.1:\d+/file/root'%, "Shows search string and location");
+
+        $result = NPTest->testCmd( "$command -u /file/root -s NonRootWithOver30charsAndMoreFunThanAWetFish" );
+        is( $result->return_code, 2, "Missing string check");
+        like( $result->output, qr%HTTP CRITICAL: HTTP/1\.1 200 OK - string 'NonRootWithOver30charsAndM...' not found on 'https?://127\.0\.0\.1:\d+/file/root'%, "Shows search string and location");
+
+        $result = NPTest->testCmd( "$command -u /header_check -d foo" );
+        is( $result->return_code, 0, "header_check search for string");
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 96 bytes in [\d\.]+ second/', "Output correct" );
+
+        $result = NPTest->testCmd( "$command -u /header_check -d bar" );
+        is( $result->return_code, 2, "Missing header string check");
+        like( $result->output, qr%^HTTP CRITICAL: HTTP/1\.1 200 OK - header 'bar' not found on 'https?://127\.0\.0\.1:\d+/header_check'%, "Shows search string and location");
+
+        my $cmd;
+        $cmd = "$command -u /slow";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, "$cmd");
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+        $result->output =~ /in ([\d\.]+) second/;
+        cmp_ok( $1, ">", 1, "Time is > 1 second" );
+
+        $cmd = "$command -u /statuscode/200";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/200 -e 200";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - Status line output matched "200" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/201";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - \d+ bytes in [\d\.]+ second /', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/201 -e 201";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - Status line output matched "201" - \d+ bytes in [\d\.]+ second /', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/201 -e 200";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 2, $cmd);
+        like( $result->output, '/^HTTP CRITICAL - Invalid HTTP response received from host on port \d+: HTTP/1.1 201 Created/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/200 -e 200,201,202";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - Status line output matched "200,201,202" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/201 -e 200,201,202";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - Status line output matched "200,201,202" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /statuscode/203 -e 200,201,202";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 2, $cmd);
+        like( $result->output, '/^HTTP CRITICAL - Invalid HTTP response received from host on port (\d+): HTTP/1.1 203 Non-Authoritative Information/', "Output correct: ".$result->output );
+
+        $cmd = "$command -j HEAD -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 HEAD - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -j POST -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 POST - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -j GET -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 GET - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 GET - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -P foo -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 POST - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -j DELETE -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 1, $cmd);
+        like( $result->output, '/^HTTP WARNING: HTTP/1.1 405 Method Not Allowed/', "Output correct: ".$result->output );
+
+        $cmd = "$command -j foo -u /method";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 2, $cmd);
+        like( $result->output, '/^HTTP CRITICAL: HTTP/1.1 501 Not Implemented/', "Output correct: ".$result->output );
+
+        $cmd = "$command -P stufftoinclude -u /postdata -s POST:stufftoinclude";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -j PUT -P stufftoinclude -u /postdata -s PUT:stufftoinclude";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        # To confirm that the free doesn't segfault
+        $cmd = "$command -P stufftoinclude -j PUT -u /postdata -s PUT:stufftoinclude";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /redirect";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 301 Moved Permanently - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -f follow -u /redirect";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -u /redirect -k 'follow: me'";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 301 Moved Permanently - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -f follow -u /redirect -k 'follow: me'";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -f sticky -u /redirect -k 'follow: me'";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+        $cmd = "$command -f stickyport -u /redirect -k 'follow: me'";
+        $result = NPTest->testCmd( $cmd );
+        is( $result->return_code, 0, $cmd);
+        like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
+
+  # These tests may block
+        print "ALRM\n";
+
+        # stickyport - on full urlS port is set back to 80 otherwise
+        $cmd = "$command -f stickyport -u /redir_external -t 5 -s redirected";
+        eval {
+                local $SIG{ALRM} = sub { die "alarm\n" };
+                alarm(2);
+                $result = NPTest->testCmd( $cmd );
+                alarm(0);       };
+        isnt( $@, "alarm\n", $cmd );
+        is( $result->return_code, 0, $cmd );
+
+        # Let's hope there won't be any web server on :80 returning "redirected"!
+        $cmd = "$command -f sticky -u /redir_external -t 5 -s redirected";
+        eval {
+                local $SIG{ALRM} = sub { die "alarm\n" };
+                alarm(2);
+                $result = NPTest->testCmd( $cmd );
+                alarm(0); };
+        isnt( $@, "alarm\n", $cmd );
+        isnt( $result->return_code, 0, $cmd );
+
+        # Test an external address - timeout
+        SKIP: {
+                skip "This doesn't seem to work all the time", 1 unless ($ENV{HTTP_EXTERNAL});
+                $cmd = "$command -f follow -u /redir_external -t 5";
+                eval {
+                        $result = NPTest->testCmd( $cmd, 2 );
+                };
+                like( $@, "/timeout in command: $cmd/", $cmd );
+        }
+
+        $cmd = "$command -u /timeout -t 5";
+        eval {
+                $result = NPTest->testCmd( $cmd, 2 );
+        };
+        like( $@, "/timeout in command: $cmd/", $cmd );
+
+        $cmd = "$command -f follow -u /redir_timeout -t 2";
+        eval {
+                $result = NPTest->testCmd( $cmd, 5 );
+        };
+        is( $@, "", $cmd );
+
+}
diff --git a/plugins/tests/check_http.t b/plugins/tests/check_http.t
index d6d31de..c9e6595 100755
--- a/plugins/tests/check_http.t
+++ b/plugins/tests/check_http.t
@@ -30,13 +30,16 @@ eval {
         require HTTP::Response;
 };
 
+my $plugin = 'check_http';
+$plugin    = 'check_curl' if $0 =~ m/check_curl/mx;
+
 if ($@) {
         plan skip_all => "Missing required module for test: $@";
 } else {
         if (-x "./check_http") {
                 plan tests => $common_tests * 2 + $ssl_only_tests + $virtual_port_tests;
         } else {
-                plan skip_all => "No check_http compiled";
+                plan skip_all => "No $plugin compiled";
         }
 }
 
@@ -185,7 +188,7 @@ if ($ARGV[0] && $ARGV[0] eq "-d") {
 }
 
 my $result;
-my $command = "./check_http -H 127.0.0.1";
+my $command = "./$plugin -H 127.0.0.1";
 
 run_common_tests( { command => "$command -p $port_http" } );
 SKIP: {
diff --git a/plugins/uriparser/Makefile.am b/plugins/uriparser/Makefile.am
new file mode 100644
index 0000000..703e6c5
--- /dev/null
+++ b/plugins/uriparser/Makefile.am
@@ -0,0 +1,11 @@
+noinst_LIBRARIES = liburiparser.a
+
+liburiparser_a_SOURCES = UriCommon.c UriCompare.c \
+        UriEscape.c UriFile.c UriIp4.c \
+        UriIp4Base.c UriNormalize.c \
+        UriNormalizeBase.c UriParse.c \
+        UriParseBase.c UriQuery.c \
+        UriRecompose.c UriResolve.c \
+        UriShorten.c
+
+liburiparser_a_CFLAGS = $(AM_CFLAGS) -I..
diff --git a/plugins/uriparser/Uri.h b/plugins/uriparser/Uri.h
new file mode 100644
index 0000000..4a18580
--- /dev/null
+++ b/plugins/uriparser/Uri.h
@@ -0,0 +1,777 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file Uri.h
+ * Holds the RFC 3986 %URI parser interface.
+ * NOTE: This header includes itself twice.
+ */
+
+#if (defined(URI_PASS_ANSI) && !defined(URI_H_ANSI)) \
+        || (defined(URI_PASS_UNICODE) && !defined(URI_H_UNICODE)) \
+        || (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* What encodings are enabled? */
+#include "UriDefsConfig.h"
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "Uri.h"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "Uri.h"
+#  undef URI_PASS_UNICODE
+# endif
+/* Only one pass for each encoding */
+#elif (defined(URI_PASS_ANSI) && !defined(URI_H_ANSI) \
+        && defined(URI_ENABLE_ANSI)) || (defined(URI_PASS_UNICODE) \
+        && !defined(URI_H_UNICODE) && defined(URI_ENABLE_UNICODE))
+# ifdef URI_PASS_ANSI
+#  define URI_H_ANSI 1
+#  include "UriDefsAnsi.h"
+# else
+#  define URI_H_UNICODE 1
+#  include "UriDefsUnicode.h"
+# endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#ifndef URI_DOXYGEN
+# include "UriBase.h"
+#endif
+
+
+
+/**
+ * Specifies a range of characters within a string.
+ * The range includes all characters from <c>first</c>
+ * to one before <c>afterLast</c>. So if both are
+ * non-NULL the difference is the length of the text range.
+ *
+ * @see UriUriA
+ * @see UriPathSegmentA
+ * @see UriHostDataA
+ * @since 0.3.0
+ */
+typedef struct URI_TYPE(TextRangeStruct) {
+        const URI_CHAR * first; /**< Pointer to first character */
+        const URI_CHAR * afterLast; /**< Pointer to character after the last one still in */
+} URI_TYPE(TextRange); /**< @copydoc UriTextRangeStructA */
+
+
+
+/**
+ * Represents a path segment within a %URI path.
+ * More precisely it is a node in a linked
+ * list of path segments.
+ *
+ * @see UriUriA
+ * @since 0.3.0
+ */
+typedef struct URI_TYPE(PathSegmentStruct) {
+        URI_TYPE(TextRange) text; /**< Path segment name */
+        struct URI_TYPE(PathSegmentStruct) * next; /**< Pointer to the next path segment in the list, can be NULL if last already */
+
+        void * reserved; /**< Reserved to the parser */
+} URI_TYPE(PathSegment); /**< @copydoc UriPathSegmentStructA */
+
+
+
+/**
+ * Holds structured host information.
+ * This is either a IPv4, IPv6, plain
+ * text for IPvFuture or all zero for
+ * a registered name.
+ *
+ * @see UriUriA
+ * @since 0.3.0
+ */
+typedef struct URI_TYPE(HostDataStruct) {
+        UriIp4 * ip4; /**< IPv4 address */
+        UriIp6 * ip6; /**< IPv6 address */
+        URI_TYPE(TextRange) ipFuture; /**< IPvFuture address */
+} URI_TYPE(HostData); /**< @copydoc UriHostDataStructA */
+
+
+
+/**
+ * Represents an RFC 3986 %URI.
+ * Missing components can be {NULL, NULL} ranges.
+ *
+ * @see uriParseUriA
+ * @see uriFreeUriMembersA
+ * @see UriParserStateA
+ * @since 0.3.0
+ */
+typedef struct URI_TYPE(UriStruct) {
+        URI_TYPE(TextRange) scheme; /**< Scheme (e.g. "http") */
+        URI_TYPE(TextRange) userInfo; /**< User info (e.g. "user:pass") */
+        URI_TYPE(TextRange) hostText; /**< Host text (set for all hosts, excluding square brackets) */
+        URI_TYPE(HostData) hostData; /**< Structured host type specific data */
+        URI_TYPE(TextRange) portText; /**< Port (e.g. "80") */
+        URI_TYPE(PathSegment) * pathHead; /**< Head of a linked list of path segments */
+        URI_TYPE(PathSegment) * pathTail; /**< Tail of the list behind pathHead */
+        URI_TYPE(TextRange) query; /**< Query without leading "?" */
+        URI_TYPE(TextRange) fragment; /**< Query without leading "#" */
+        UriBool absolutePath; /**< Absolute path flag, distincting "a" and "/a" */
+        UriBool owner; /**< Memory owner flag */
+
+        void * reserved; /**< Reserved to the parser */
+} URI_TYPE(Uri); /**< @copydoc UriUriStructA */
+
+
+
+/**
+ * Represents a state of the %URI parser.
+ * Missing components can be NULL to reflect
+ * a components absence.
+ *
+ * @see uriFreeUriMembersA
+ * @since 0.3.0
+ */
+typedef struct URI_TYPE(ParserStateStruct) {
+        URI_TYPE(Uri) * uri; /**< Plug in the %URI structure to be filled while parsing here */
+        int errorCode; /**< Code identifying the occured error */
+        const URI_CHAR * errorPos; /**< Pointer to position in case of a syntax error */
+
+        void * reserved; /**< Reserved to the parser */
+} URI_TYPE(ParserState); /**< @copydoc UriParserStateStructA */
+
+
+
+/**
+ * Represents a query element.
+ * More precisely it is a node in a linked
+ * list of query elements.
+ *
+ * @since 0.7.0
+ */
+typedef struct URI_TYPE(QueryListStruct) {
+        const URI_CHAR * key; /**< Key of the query element */
+        const URI_CHAR * value; /**< Value of the query element, can be NULL */
+
+        struct URI_TYPE(QueryListStruct) * next; /**< Pointer to the next key/value pair in the list, can be NULL if last already */
+} URI_TYPE(QueryList); /**< @copydoc UriQueryListStructA */
+
+
+
+/**
+ * Parses a RFC 3986 URI.
+ *
+ * @param state       <b>INOUT</b>: Parser state with set output %URI, must not be NULL
+ * @param first       <b>IN</b>: Pointer to the first character to parse, must not be NULL
+ * @param afterLast   <b>IN</b>: Pointer to the character after the last to parse, must not be NULL
+ * @return            0 on success, error code otherwise
+ *
+ * @see uriParseUriA
+ * @see uriToStringA
+ * @since 0.3.0
+ */
+int URI_FUNC(ParseUriEx)(URI_TYPE(ParserState) * state,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+
+
+
+/**
+ * Parses a RFC 3986 %URI.
+ *
+ * @param state   <b>INOUT</b>: Parser state with set output %URI, must not be NULL
+ * @param text    <b>IN</b>: Text to parse, must not be NULL
+ * @return        0 on success, error code otherwise
+ *
+ * @see uriParseUriExA
+ * @see uriToStringA
+ * @since 0.3.0
+ */
+int URI_FUNC(ParseUri)(URI_TYPE(ParserState) * state,
+                const URI_CHAR * text);
+
+
+
+/**
+ * Frees all memory associated with the members
+ * of the %URI structure. Note that the structure
+ * itself is not freed, only its members.
+ *
+ * @param uri   <b>INOUT</b>: %URI structure whose members should be freed
+ *
+ * @since 0.3.0
+ */
+void URI_FUNC(FreeUriMembers)(URI_TYPE(Uri) * uri);
+
+
+
+/**
+ * Percent-encodes all unreserved characters from the input string and
+ * writes the encoded version to the output string.
+ * Be sure to allocate <b>3 times</b> the space of the input buffer for
+ * the output buffer for <c>normalizeBreaks == URI_FALSE</c> and <b>6 times</b>
+ * the space for <c>normalizeBreaks == URI_TRUE</c>
+ * (since e.g. "\x0d" becomes "%0D%0A" in that case)
+ *
+ * @param inFirst           <b>IN</b>: Pointer to first character of the input text
+ * @param inAfterLast       <b>IN</b>: Pointer after the last character of the input text
+ * @param out               <b>OUT</b>: Encoded text destination
+ * @param spaceToPlus       <b>IN</b>: Wether to convert ' ' to '+' or not
+ * @param normalizeBreaks   <b>IN</b>: Wether to convert CR and LF to CR-LF or not.
+ * @return                  Position of terminator in output string
+ *
+ * @see uriEscapeA
+ * @see uriUnescapeInPlaceExA
+ * @since 0.5.2
+ */
+URI_CHAR * URI_FUNC(EscapeEx)(const URI_CHAR * inFirst,
+                const URI_CHAR * inAfterLast, URI_CHAR * out,
+                UriBool spaceToPlus, UriBool normalizeBreaks);
+
+
+
+/**
+ * Percent-encodes all unreserved characters from the input string and
+ * writes the encoded version to the output string.
+ * Be sure to allocate <b>3 times</b> the space of the input buffer for
+ * the output buffer for <c>normalizeBreaks == URI_FALSE</c> and <b>6 times</b>
+ * the space for <c>normalizeBreaks == URI_TRUE</c>
+ * (since e.g. "\x0d" becomes "%0D%0A" in that case)
+ *
+ * @param in                <b>IN</b>: Text source
+ * @param out               <b>OUT</b>: Encoded text destination
+ * @param spaceToPlus       <b>IN</b>: Wether to convert ' ' to '+' or not
+ * @param normalizeBreaks   <b>IN</b>: Wether to convert CR and LF to CR-LF or not.
+ * @return                  Position of terminator in output string
+ *
+ * @see uriEscapeExA
+ * @see uriUnescapeInPlaceA
+ * @since 0.5.0
+ */
+URI_CHAR * URI_FUNC(Escape)(const URI_CHAR * in, URI_CHAR * out,
+                UriBool spaceToPlus, UriBool normalizeBreaks);
+
+
+
+/**
+ * Unescapes percent-encoded groups in a given string.
+ * E.g. "%20" will become " ". Unescaping is done in place.
+ * The return value will be point to the new position
+ * of the terminating zero. Use this value to get the new
+ * length of the string. NULL is only returned if <c>inout</c>
+ * is NULL.
+ *
+ * @param inout             <b>INOUT</b>: Text to unescape/decode
+ * @param plusToSpace       <b>IN</b>: Whether to convert '+' to ' ' or not
+ * @param breakConversion   <b>IN</b>: Line break conversion mode
+ * @return                  Pointer to new position of the terminating zero
+ *
+ * @see uriUnescapeInPlaceA
+ * @see uriEscapeExA
+ * @since 0.5.0
+ */
+const URI_CHAR * URI_FUNC(UnescapeInPlaceEx)(URI_CHAR * inout,
+                UriBool plusToSpace, UriBreakConversion breakConversion);
+
+
+
+/**
+ * Unescapes percent-encoded groups in a given string.
+ * E.g. "%20" will become " ". Unescaping is done in place.
+ * The return value will be point to the new position
+ * of the terminating zero. Use this value to get the new
+ * length of the string. NULL is only returned if <c>inout</c>
+ * is NULL.
+ *
+ * NOTE: '+' is not decoded to ' ' and line breaks are not converted.
+ * Use the more advanced UnescapeInPlaceEx for that features instead.
+ *
+ * @param inout   <b>INOUT</b>: Text to unescape/decode
+ * @return        Pointer to new position of the terminating zero
+ *
+ * @see uriUnescapeInPlaceExA
+ * @see uriEscapeA
+ * @since 0.3.0
+ */
+const URI_CHAR * URI_FUNC(UnescapeInPlace)(URI_CHAR * inout);
+
+
+
+/**
+ * Performs reference resolution as described in
+ * <a href="http://tools.ietf.org/html/rfc3986#section-5.2.2">section 5.2.2 of RFC 3986</a>.
+ * NOTE: On success you have to call uriFreeUriMembersA on \p absoluteDest manually later.
+ *
+ * @param absoluteDest     <b>OUT</b>: Result %URI
+ * @param relativeSource   <b>IN</b>: Reference to resolve
+ * @param absoluteBase     <b>IN</b>: Base %URI to apply
+ * @return                 Error code or 0 on success
+ *
+ * @see uriRemoveBaseUriA, uriAddBaseUriExA
+ * @since 0.4.0
+ */
+int URI_FUNC(AddBaseUri)(URI_TYPE(Uri) * absoluteDest,
+                const URI_TYPE(Uri) * relativeSource,
+                const URI_TYPE(Uri) * absoluteBase);
+
+
+
+/**
+ * Performs reference resolution as described in
+ * <a href="http://tools.ietf.org/html/rfc3986#section-5.2.2">section 5.2.2 of RFC 3986</a>.
+ * NOTE: On success you have to call uriFreeUriMembersA on \p absoluteDest manually later.
+ *
+ * @param absoluteDest     <b>OUT</b>: Result %URI
+ * @param relativeSource   <b>IN</b>: Reference to resolve
+ * @param absoluteBase     <b>IN</b>: Base %URI to apply
+ * @param options          <b>IN</b>: Configuration to apply
+ * @return                 Error code or 0 on success
+ *
+ * @see uriRemoveBaseUriA, uriAddBaseUriA
+ * @since 0.8.1
+ */
+int URI_FUNC(AddBaseUriEx)(URI_TYPE(Uri) * absoluteDest,
+                const URI_TYPE(Uri) * relativeSource,
+                const URI_TYPE(Uri) * absoluteBase,
+                UriResolutionOptions options);
+
+
+
+/**
+ * Tries to make a relative %URI (a reference) from an
+ * absolute %URI and a given base %URI. This can only work if
+ * the absolute %URI shares scheme and authority with
+ * the base %URI. If it does not the result will still be
+ * an absolute URI (with scheme part if necessary).
+ * NOTE: On success you have to call uriFreeUriMembersA on
+ * \p dest manually later.
+ *
+ * @param dest             <b>OUT</b>: Result %URI
+ * @param absoluteSource   <b>IN</b>: Absolute %URI to make relative
+ * @param absoluteBase     <b>IN</b>: Base %URI
+ * @param domainRootMode   <b>IN</b>: Create %URI with path relative to domain root
+ * @return                 Error code or 0 on success
+ *
+ * @see uriAddBaseUriA, uriAddBaseUriExA
+ * @since 0.5.2
+ */
+int URI_FUNC(RemoveBaseUri)(URI_TYPE(Uri) * dest,
+                const URI_TYPE(Uri) * absoluteSource,
+                const URI_TYPE(Uri) * absoluteBase,
+                UriBool domainRootMode);
+
+
+
+/**
+ * Checks two URIs for equivalence. Comparison is done
+ * the naive way, without prior normalization.
+ * NOTE: Two <c>NULL</c> URIs are equal as well.
+ *
+ * @param a   <b>IN</b>: First %URI
+ * @param b   <b>IN</b>: Second %URI
+ * @return    <c>URI_TRUE</c> when equal, <c>URI_FAlSE</c> else
+ *
+ * @since 0.4.0
+ */
+UriBool URI_FUNC(EqualsUri)(const URI_TYPE(Uri) * a, const URI_TYPE(Uri) * b);
+
+
+
+/**
+ * Calculates the number of characters needed to store the
+ * string representation of the given %URI excluding the
+ * terminator.
+ *
+ * @param uri             <b>IN</b>: %URI to measure
+ * @param charsRequired   <b>OUT</b>: Length of the string representation in characters <b>excluding</b> terminator
+ * @return                Error code or 0 on success
+ *
+ * @see uriToStringA
+ * @since 0.5.0
+ */
+int URI_FUNC(ToStringCharsRequired)(const URI_TYPE(Uri) * uri,
+                int * charsRequired);
+
+
+
+/**
+ * Converts a %URI structure back to text as described in
+ * <a href="http://tools.ietf.org/html/rfc3986#section-5.3">section 5.3 of RFC 3986</a>.
+ *
+ * @param dest           <b>OUT</b>: Output destination
+ * @param uri            <b>IN</b>: %URI to convert
+ * @param maxChars       <b>IN</b>: Maximum number of characters to copy <b>including</b> terminator
+ * @param charsWritten   <b>OUT</b>: Number of characters written, can be lower than maxChars even if the %URI is too long!
+ * @return               Error code or 0 on success
+ *
+ * @see uriToStringCharsRequiredA
+ * @since 0.4.0
+ */
+int URI_FUNC(ToString)(URI_CHAR * dest, const URI_TYPE(Uri) * uri, int maxChars, int * charsWritten);
+
+
+
+/**
+ * Determines the components of a %URI that are not normalized.
+ *
+ * @param uri   <b>IN</b>: %URI to check
+ * @return      Normalization job mask
+ *
+ * @see uriNormalizeSyntaxA
+ * @since 0.5.0
+ */
+unsigned int URI_FUNC(NormalizeSyntaxMaskRequired)(const URI_TYPE(Uri) * uri);
+
+
+
+/**
+ * Normalizes a %URI using a normalization mask.
+ * The normalization mask decides what components are normalized.
+ *
+ * NOTE: If necessary the %URI becomes owner of all memory
+ * behind the text pointed to. Text is duplicated in that case.
+ *
+ * @param uri    <b>INOUT</b>: %URI to normalize
+ * @param mask   <b>IN</b>: Normalization mask
+ * @return       Error code or 0 on success
+ *
+ * @see uriNormalizeSyntaxA
+ * @see uriNormalizeSyntaxMaskRequiredA
+ * @since 0.5.0
+ */
+int URI_FUNC(NormalizeSyntaxEx)(URI_TYPE(Uri) * uri, unsigned int mask);
+
+
+
+/**
+ * Normalizes all components of a %URI.
+ *
+ * NOTE: If necessary the %URI becomes owner of all memory
+ * behind the text pointed to. Text is duplicated in that case.
+ *
+ * @param uri   <b>INOUT</b>: %URI to normalize
+ * @return      Error code or 0 on success
+ *
+ * @see uriNormalizeSyntaxExA
+ * @see uriNormalizeSyntaxMaskRequiredA
+ * @since 0.5.0
+ */
+int URI_FUNC(NormalizeSyntax)(URI_TYPE(Uri) * uri);
+
+
+
+/**
+ * Converts a Unix filename to a %URI string.
+ * The destination buffer must be large enough to hold 7 + 3 * len(filename) + 1
+ * characters in case of an absolute filename or 3 * len(filename) + 1 in case
+ * of a relative filename.
+ *
+ * EXAMPLE
+ *   Input:  "/bin/bash"
+ *   Output: "file:///bin/bash"
+ *
+ * @param filename     <b>IN</b>: Unix filename to convert
+ * @param uriString    <b>OUT</b>: Destination to write %URI string to
+ * @return             Error code or 0 on success
+ *
+ * @see uriUriStringToUnixFilenameA
+ * @see uriWindowsFilenameToUriStringA
+ * @since 0.5.2
+ */
+int URI_FUNC(UnixFilenameToUriString)(const URI_CHAR * filename,
+                URI_CHAR * uriString);
+
+
+
+/**
+ * Converts a Windows filename to a %URI string.
+ * The destination buffer must be large enough to hold 8 + 3 * len(filename) + 1
+ * characters in case of an absolute filename or 3 * len(filename) + 1 in case
+ * of a relative filename.
+ *
+ * EXAMPLE
+ *   Input:  "E:\\Documents and Settings"
+ *   Output: "file:///E:/Documents%20and%20Settings"
+ *
+ * @param filename     <b>IN</b>: Windows filename to convert
+ * @param uriString    <b>OUT</b>: Destination to write %URI string to
+ * @return             Error code or 0 on success
+ *
+ * @see uriUriStringToWindowsFilenameA
+ * @see uriUnixFilenameToUriStringA
+ * @since 0.5.2
+ */
+int URI_FUNC(WindowsFilenameToUriString)(const URI_CHAR * filename,
+                URI_CHAR * uriString);
+
+
+
+/**
+ * Extracts a Unix filename from a %URI string.
+ * The destination buffer must be large enough to hold len(uriString) + 1 - 7
+ * characters in case of an absolute %URI or len(uriString) + 1 in case
+ * of a relative %URI.
+ *
+ * @param uriString    <b>IN</b>: %URI string to convert
+ * @param filename     <b>OUT</b>: Destination to write filename to
+ * @return             Error code or 0 on success
+ *
+ * @see uriUnixFilenameToUriStringA
+ * @see uriUriStringToWindowsFilenameA
+ * @since 0.5.2
+ */
+int URI_FUNC(UriStringToUnixFilename)(const URI_CHAR * uriString,
+                URI_CHAR * filename);
+
+
+
+/**
+ * Extracts a Windows filename from a %URI string.
+ * The destination buffer must be large enough to hold len(uriString) + 1 - 8
+ * characters in case of an absolute %URI or len(uriString) + 1 in case
+ * of a relative %URI.
+ *
+ * @param uriString    <b>IN</b>: %URI string to convert
+ * @param filename     <b>OUT</b>: Destination to write filename to
+ * @return             Error code or 0 on success
+ *
+ * @see uriWindowsFilenameToUriStringA
+ * @see uriUriStringToUnixFilenameA
+ * @since 0.5.2
+ */
+int URI_FUNC(UriStringToWindowsFilename)(const URI_CHAR * uriString,
+                URI_CHAR * filename);
+
+
+
+/**
+ * Calculates the number of characters needed to store the
+ * string representation of the given query list excluding the
+ * terminator. It is assumed that line breaks are will be
+ * normalized to "%0D%0A".
+ *
+ * @param queryList         <b>IN</b>: Query list to measure
+ * @param charsRequired     <b>OUT</b>: Length of the string representation in characters <b>excluding</b> terminator
+ * @return                  Error code or 0 on success
+ *
+ * @see uriComposeQueryCharsRequiredExA
+ * @see uriComposeQueryA
+ * @since 0.7.0
+ */
+int URI_FUNC(ComposeQueryCharsRequired)(const URI_TYPE(QueryList) * queryList,
+                int * charsRequired);
+
+
+
+/**
+ * Calculates the number of characters needed to store the
+ * string representation of the given query list excluding the
+ * terminator.
+ *
+ * @param queryList         <b>IN</b>: Query list to measure
+ * @param charsRequired     <b>OUT</b>: Length of the string representation in characters <b>excluding</b> terminator
+ * @param spaceToPlus       <b>IN</b>: Wether to convert ' ' to '+' or not
+ * @param normalizeBreaks   <b>IN</b>: Wether to convert CR and LF to CR-LF or not.
+ * @return                  Error code or 0 on success
+ *
+ * @see uriComposeQueryCharsRequiredA
+ * @see uriComposeQueryExA
+ * @since 0.7.0
+ */
+int URI_FUNC(ComposeQueryCharsRequiredEx)(const URI_TYPE(QueryList) * queryList,
+                int * charsRequired, UriBool spaceToPlus, UriBool normalizeBreaks);
+
+
+
+/**
+ * Converts a query list structure back to a query string.
+ * The composed string does not start with '?',
+ * on the way ' ' is converted to '+' and line breaks are
+ * normalized to "%0D%0A".
+ *
+ * @param dest              <b>OUT</b>: Output destination
+ * @param queryList         <b>IN</b>: Query list to convert
+ * @param maxChars          <b>IN</b>: Maximum number of characters to copy <b>including</b> terminator
+ * @param charsWritten      <b>OUT</b>: Number of characters written, can be lower than maxChars even if the query list is too long!
+ * @return                  Error code or 0 on success
+ *
+ * @see uriComposeQueryExA
+ * @see uriComposeQueryMallocA
+ * @see uriComposeQueryCharsRequiredA
+ * @see uriDissectQueryMallocA
+ * @since 0.7.0
+ */
+int URI_FUNC(ComposeQuery)(URI_CHAR * dest,
+                const URI_TYPE(QueryList) * queryList, int maxChars, int * charsWritten);
+
+
+
+/**
+ * Converts a query list structure back to a query string.
+ * The composed string does not start with '?'.
+ *
+ * @param dest              <b>OUT</b>: Output destination
+ * @param queryList         <b>IN</b>: Query list to convert
+ * @param maxChars          <b>IN</b>: Maximum number of characters to copy <b>including</b> terminator
+ * @param charsWritten      <b>OUT</b>: Number of characters written, can be lower than maxChars even if the query list is too long!
+ * @param spaceToPlus       <b>IN</b>: Wether to convert ' ' to '+' or not
+ * @param normalizeBreaks   <b>IN</b>: Wether to convert CR and LF to CR-LF or not.
+ * @return                  Error code or 0 on success
+ *
+ * @see uriComposeQueryA
+ * @see uriComposeQueryMallocExA
+ * @see uriComposeQueryCharsRequiredExA
+ * @see uriDissectQueryMallocExA
+ * @since 0.7.0
+ */
+int URI_FUNC(ComposeQueryEx)(URI_CHAR * dest,
+                const URI_TYPE(QueryList) * queryList, int maxChars, int * charsWritten,
+                UriBool spaceToPlus, UriBool normalizeBreaks);
+
+
+
+/**
+ * Converts a query list structure back to a query string.
+ * Memory for this string is allocated internally.
+ * The composed string does not start with '?',
+ * on the way ' ' is converted to '+' and line breaks are
+ * normalized to "%0D%0A".
+ *
+ * @param dest              <b>OUT</b>: Output destination
+ * @param queryList         <b>IN</b>: Query list to convert
+ * @return                  Error code or 0 on success
+ *
+ * @see uriComposeQueryMallocExA
+ * @see uriComposeQueryA
+ * @see uriDissectQueryMallocA
+ * @since 0.7.0
+ */
+int URI_FUNC(ComposeQueryMalloc)(URI_CHAR ** dest,
+                const URI_TYPE(QueryList) * queryList);
+
+
+
+/**
+ * Converts a query list structure back to a query string.
+ * Memory for this string is allocated internally.
+ * The composed string does not start with '?'.
+ *
+ * @param dest              <b>OUT</b>: Output destination
+ * @param queryList         <b>IN</b>: Query list to convert
+ * @param spaceToPlus       <b>IN</b>: Wether to convert ' ' to '+' or not
+ * @param normalizeBreaks   <b>IN</b>: Wether to convert CR and LF to CR-LF or not.
+ * @return                  Error code or 0 on success
+ *
+ * @see uriComposeQueryMallocA
+ * @see uriComposeQueryExA
+ * @see uriDissectQueryMallocExA
+ * @since 0.7.0
+ */
+int URI_FUNC(ComposeQueryMallocEx)(URI_CHAR ** dest,
+                const URI_TYPE(QueryList) * queryList,
+                UriBool spaceToPlus, UriBool normalizeBreaks);
+
+
+
+/**
+ * Constructs a query list from the raw query string of a given URI.
+ * On the way '+' is converted back to ' ', line breaks are not modified.
+ *
+ * @param dest              <b>OUT</b>: Output destination
+ * @param itemCount         <b>OUT</b>: Number of items found, can be NULL
+ * @param first             <b>IN</b>: Pointer to first character <b>after</b> '?'
+ * @param afterLast         <b>IN</b>: Pointer to character after the last one still in
+ * @return                  Error code or 0 on success
+ *
+ * @see uriDissectQueryMallocExA
+ * @see uriComposeQueryA
+ * @see uriFreeQueryListA
+ * @since 0.7.0
+ */
+int URI_FUNC(DissectQueryMalloc)(URI_TYPE(QueryList) ** dest, int * itemCount,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+
+
+
+/**
+ * Constructs a query list from the raw query string of a given URI.
+ *
+ * @param dest              <b>OUT</b>: Output destination
+ * @param itemCount         <b>OUT</b>: Number of items found, can be NULL
+ * @param first             <b>IN</b>: Pointer to first character <b>after</b> '?'
+ * @param afterLast         <b>IN</b>: Pointer to character after the last one still in
+ * @param plusToSpace       <b>IN</b>: Whether to convert '+' to ' ' or not
+ * @param breakConversion   <b>IN</b>: Line break conversion mode
+ * @return                  Error code or 0 on success
+ *
+ * @see uriDissectQueryMallocA
+ * @see uriComposeQueryExA
+ * @see uriFreeQueryListA
+ * @since 0.7.0
+ */
+int URI_FUNC(DissectQueryMallocEx)(URI_TYPE(QueryList) ** dest, int * itemCount,
+                const URI_CHAR * first, const URI_CHAR * afterLast,
+                UriBool plusToSpace, UriBreakConversion breakConversion);
+
+
+
+/**
+ * Frees all memory associated with the given query list.
+ * The structure itself is freed as well.
+ *
+ * @param queryList   <b>INOUT</b>: Query list to free
+ *
+ * @since 0.7.0
+ */
+void URI_FUNC(FreeQueryList)(URI_TYPE(QueryList) * queryList);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif
+#endif
diff --git a/plugins/uriparser/UriBase.h b/plugins/uriparser/UriBase.h
new file mode 100644
index 0000000..bc63b05
--- /dev/null
+++ b/plugins/uriparser/UriBase.h
@@ -0,0 +1,197 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriBase.h
+ * Holds definitions independent of the encoding pass.
+ */
+
+#ifndef URI_BASE_H
+#define URI_BASE_H 1
+
+
+
+/* Version helper macro */
+#define URI_ANSI_TO_UNICODE(x) L##x
+
+
+
+/* Version */
+#define URI_VER_MAJOR           0
+#define URI_VER_MINOR           8
+#define URI_VER_RELEASE         4
+#define URI_VER_SUFFIX_ANSI     ""
+#define URI_VER_SUFFIX_UNICODE  URI_ANSI_TO_UNICODE(URI_VER_SUFFIX_ANSI)
+
+
+
+/* More version helper macros */
+#define URI_INT_TO_ANSI_HELPER(x) #x
+#define URI_INT_TO_ANSI(x) URI_INT_TO_ANSI_HELPER(x)
+
+#define URI_INT_TO_UNICODE_HELPER(x) URI_ANSI_TO_UNICODE(#x)
+#define URI_INT_TO_UNICODE(x) URI_INT_TO_UNICODE_HELPER(x)
+
+#define URI_VER_ANSI_HELPER(ma, mi, r, s) \
+        URI_INT_TO_ANSI(ma) "." \
+        URI_INT_TO_ANSI(mi) "." \
+        URI_INT_TO_ANSI(r) \
+        s
+
+#define URI_VER_UNICODE_HELPER(ma, mi, r, s) \
+        URI_INT_TO_UNICODE(ma) L"." \
+        URI_INT_TO_UNICODE(mi) L"." \
+        URI_INT_TO_UNICODE(r) \
+        s
+
+
+
+/* Full version strings */
+#define URI_VER_ANSI     URI_VER_ANSI_HELPER(URI_VER_MAJOR, URI_VER_MINOR, URI_VER_RELEASE, URI_VER_SUFFIX_ANSI)
+#define URI_VER_UNICODE  URI_VER_UNICODE_HELPER(URI_VER_MAJOR, URI_VER_MINOR, URI_VER_RELEASE, URI_VER_SUFFIX_UNICODE)
+
+
+
+/* Unused parameter macro */
+#ifdef __GNUC__
+# define URI_UNUSED(x) unused_##x __attribute__((unused))
+#else
+# define URI_UNUSED(x) x
+#endif
+
+
+
+typedef int UriBool; /**< Boolean type */
+
+#define URI_TRUE     1
+#define URI_FALSE    0
+
+
+
+/* Shared errors */
+#define URI_SUCCESS                        0
+#define URI_ERROR_SYNTAX                   1 /* Parsed text violates expected format */
+#define URI_ERROR_NULL                     2 /* One of the params passed was NULL
+                                                although it mustn't be */
+#define URI_ERROR_MALLOC                   3 /* Requested memory could not be allocated */
+#define URI_ERROR_OUTPUT_TOO_LARGE         4 /* Some output is to large for the receiving buffer */
+#define URI_ERROR_NOT_IMPLEMENTED          8 /* The called function is not implemented yet */
+#define URI_ERROR_RANGE_INVALID            9 /* The parameters passed contained invalid ranges */
+
+
+/* Errors specific to ToString */
+#define URI_ERROR_TOSTRING_TOO_LONG        URI_ERROR_OUTPUT_TOO_LARGE /* Deprecated, test for URI_ERROR_OUTPUT_TOO_LARGE instead */
+
+/* Errors specific to AddBaseUri */
+#define URI_ERROR_ADDBASE_REL_BASE         5 /* Given base is not absolute */
+
+/* Errors specific to RemoveBaseUri */
+#define URI_ERROR_REMOVEBASE_REL_BASE      6 /* Given base is not absolute */
+#define URI_ERROR_REMOVEBASE_REL_SOURCE    7 /* Given base is not absolute */
+
+
+
+#ifndef URI_DOXYGEN
+# include <stdio.h> /* For NULL, snprintf */
+# include <ctype.h> /* For wchar_t */
+# include <string.h> /* For strlen, memset, memcpy */
+# include <stdlib.h> /* For malloc */
+#endif /* URI_DOXYGEN */
+
+
+
+/**
+ * Holds an IPv4 address.
+ */
+typedef struct UriIp4Struct {
+        unsigned char data[4]; /**< Each octet in one byte */
+} UriIp4; /**< @copydoc UriIp4Struct */
+
+
+
+/**
+ * Holds an IPv6 address.
+ */
+typedef struct UriIp6Struct {
+        unsigned char data[16]; /**< Each quad in two bytes */
+} UriIp6; /**< @copydoc UriIp6Struct */
+
+
+
+/**
+ * Specifies a line break conversion mode.
+ */
+typedef enum UriBreakConversionEnum {
+        URI_BR_TO_LF, /**< Convert to Unix line breaks ("\\x0a") */
+        URI_BR_TO_CRLF, /**< Convert to Windows line breaks ("\\x0d\\x0a") */
+        URI_BR_TO_CR, /**< Convert to Macintosh line breaks ("\\x0d") */
+        URI_BR_TO_UNIX = URI_BR_TO_LF, /**< @copydoc UriBreakConversionEnum::URI_BR_TO_LF */
+        URI_BR_TO_WINDOWS = URI_BR_TO_CRLF, /**< @copydoc UriBreakConversionEnum::URI_BR_TO_CRLF */
+        URI_BR_TO_MAC = URI_BR_TO_CR, /**< @copydoc UriBreakConversionEnum::URI_BR_TO_CR */
+        URI_BR_DONT_TOUCH /**< Copy line breaks unmodified */
+} UriBreakConversion; /**< @copydoc UriBreakConversionEnum */
+
+
+
+/**
+ * Specifies which component of a %URI has to be normalized.
+ */
+typedef enum UriNormalizationMaskEnum {
+        URI_NORMALIZED = 0, /**< Do not normalize anything */
+        URI_NORMALIZE_SCHEME = 1 << 0, /**< Normalize scheme (fix uppercase letters) */
+        URI_NORMALIZE_USER_INFO = 1 << 1, /**< Normalize user info (fix uppercase percent-encodings) */
+        URI_NORMALIZE_HOST = 1 << 2, /**< Normalize host (fix uppercase letters) */
+        URI_NORMALIZE_PATH = 1 << 3, /**< Normalize path (fix uppercase percent-encodings and redundant dot segments) */
+        URI_NORMALIZE_QUERY = 1 << 4, /**< Normalize query (fix uppercase percent-encodings) */
+        URI_NORMALIZE_FRAGMENT = 1 << 5 /**< Normalize fragment (fix uppercase percent-encodings) */
+} UriNormalizationMask; /**< @copydoc UriNormalizationMaskEnum */
+
+
+
+/**
+ * Specifies how to resolve %URI references.
+ */
+typedef enum UriResolutionOptionsEnum {
+        URI_RESOLVE_STRICTLY = 0, /**< Full RFC conformance */
+        URI_RESOLVE_IDENTICAL_SCHEME_COMPAT = 1 << 0 /**< Treat %URI to resolve with identical scheme as having no scheme */
+} UriResolutionOptions; /**< @copydoc UriResolutionOptionsEnum */
+
+
+
+#endif /* URI_BASE_H */
diff --git a/plugins/uriparser/UriCommon.c b/plugins/uriparser/UriCommon.c
new file mode 100644
index 0000000..37d6b39
--- /dev/null
+++ b/plugins/uriparser/UriCommon.c
@@ -0,0 +1,567 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriCommon.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriCommon.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriCommon.h"
+#endif
+
+
+
+/*extern*/ const URI_CHAR * const URI_FUNC(SafeToPointTo) = _UT("X");
+/*extern*/ const URI_CHAR * const URI_FUNC(ConstPwd) = _UT(".");
+/*extern*/ const URI_CHAR * const URI_FUNC(ConstParent) = _UT("..");
+
+
+
+void URI_FUNC(ResetUri)(URI_TYPE(Uri) * uri) {
+        memset(uri, 0, sizeof(URI_TYPE(Uri)));
+}
+
+
+
+/* Compares two text ranges for equal text content */
+int URI_FUNC(CompareRange)(
+                const URI_TYPE(TextRange) * a,
+                const URI_TYPE(TextRange) * b) {
+        int diff;
+
+        /* NOTE: Both NULL means equal! */
+        if ((a == NULL) || (b == NULL)) {
+                return ((a == NULL) ? 0 : 1) - ((b == NULL) ? 0 : 1);
+        }
+
+        /* NOTE: Both NULL means equal! */
+        if ((a->first == NULL) || (b->first == NULL)) {
+                return ((a->first == NULL) ? 0 : 1) - ((b->first == NULL) ? 0 : 1);
+        }
+
+        diff = ((int)(a->afterLast - a->first) - (int)(b->afterLast - b->first));
+        if (diff > 0) {
+                return 1;
+        } else if (diff < 0) {
+                return -1;
+        }
+
+        diff = URI_STRNCMP(a->first, b->first, (a->afterLast - a->first));
+
+        if (diff > 0) {
+                return 1;
+        } else if (diff < 0) {
+                return -1;
+        }
+
+        return diff;
+}
+
+
+
+/* Properly removes "." and ".." path segments */
+UriBool URI_FUNC(RemoveDotSegments)(URI_TYPE(Uri) * uri,
+                UriBool relative) {
+        if (uri == NULL) {
+                return URI_TRUE;
+        }
+        return URI_FUNC(RemoveDotSegmentsEx)(uri, relative, uri->owner);
+}
+
+
+
+UriBool URI_FUNC(RemoveDotSegmentsEx)(URI_TYPE(Uri) * uri,
+        UriBool relative, UriBool pathOwned) {
+        URI_TYPE(PathSegment) * walker;
+        if ((uri == NULL) || (uri->pathHead == NULL)) {
+                return URI_TRUE;
+        }
+
+        walker = uri->pathHead;
+        walker->reserved = NULL; /* Prev pointer */
+        do {
+                UriBool removeSegment = URI_FALSE;
+                int len = (int)(walker->text.afterLast - walker->text.first);
+                switch (len) {
+                case 1:
+                        if ((walker->text.first)[0] == _UT('.')) {
+                                /* "." segment -> remove if not essential */
+                                URI_TYPE(PathSegment) * const prev = walker->reserved;
+                                URI_TYPE(PathSegment) * const nextBackup = walker->next;
+
+                                /* Is this dot segment essential? */
+                                removeSegment = URI_TRUE;
+                                if (relative && (walker == uri->pathHead) && (walker->next != NULL)) {
+                                        const URI_CHAR * ch = walker->next->text.first;
+                                        for (; ch < walker->next->text.afterLast; ch++) {
+                                                if (*ch == _UT(':')) {
+                                                        removeSegment = URI_FALSE;
+                                                        break;
+                                                }
+                                        }
+                                }
+
+                                if (removeSegment) {
+                                        /* Last segment? */
+                                        if (walker->next != NULL) {
+                                                /* Not last segment */
+                                                walker->next->reserved = prev;
+
+                                                if (prev == NULL) {
+                                                        /* First but not last segment */
+                                                        uri->pathHead = walker->next;
+                                                } else {
+                                                        /* Middle segment */
+                                                        prev->next = walker->next;
+                                                }
+
+                                                if (pathOwned && (walker->text.first != walker->text.afterLast)) {
+                                                        free((URI_CHAR *)walker->text.first);
+                                                }
+                                                free(walker);
+                                        } else {
+                                                /* Last segment */
+                                                if (pathOwned && (walker->text.first != walker->text.afterLast)) {
+                                                        free((URI_CHAR *)walker->text.first);
+                                                }
+
+                                                if (prev == NULL) {
+                                                        /* Last and first */
+                                                        if (URI_FUNC(IsHostSet)(uri)) {
+                                                                /* Replace "." with empty segment to represent trailing slash */
+                                                                walker->text.first = URI_FUNC(SafeToPointTo);
+                                                                walker->text.afterLast = URI_FUNC(SafeToPointTo);
+                                                        } else {
+                                                                free(walker);
+
+                                                                uri->pathHead = NULL;
+                                                                uri->pathTail = NULL;
+                                                        }
+                                                } else {
+                                                        /* Last but not first, replace "." with empty segment to represent trailing slash */
+                                                        walker->text.first = URI_FUNC(SafeToPointTo);
+                                                        walker->text.afterLast = URI_FUNC(SafeToPointTo);
+                                                }
+                                        }
+
+                                        walker = nextBackup;
+                                }
+                        }
+                        break;
+
+                case 2:
+                        if (((walker->text.first)[0] == _UT('.'))
+                                        && ((walker->text.first)[1] == _UT('.'))) {
+                                /* Path ".." -> remove this and the previous segment */
+                                URI_TYPE(PathSegment) * const prev = walker->reserved;
+                                URI_TYPE(PathSegment) * prevPrev;
+                                URI_TYPE(PathSegment) * const nextBackup = walker->next;
+
+                                removeSegment = URI_TRUE;
+                                if (relative) {
+                                        if (prev == NULL) {
+                                                removeSegment = URI_FALSE;
+                                        } else if ((prev != NULL)
+                                                        && ((prev->text.afterLast - prev->text.first) == 2)
+                                                        && ((prev->text.first)[0] == _UT('.'))
+                                                        && ((prev->text.first)[1] == _UT('.'))) {
+                                                removeSegment = URI_FALSE;
+                                        }
+                                }
+
+                                if (removeSegment) {
+                                        if (prev != NULL) {
+                                                /* Not first segment */
+                                                prevPrev = prev->reserved;
+                                                if (prevPrev != NULL) {
+                                                        /* Not even prev is the first one */
+                                                        prevPrev->next = walker->next;
+                                                        if (walker->next != NULL) {
+                                                                walker->next->reserved = prevPrev;
+                                                        } else {
+                                                                /* Last segment -> insert "" segment to represent trailing slash, update tail */
+                                                                URI_TYPE(PathSegment) * const segment = malloc(1 * sizeof(URI_TYPE(PathSegment)));
+                                                                if (segment == NULL) {
+                                                                        if (pathOwned && (walker->text.first != walker->text.afterLast)) {
+                                                                                free((URI_CHAR *)walker->text.first);
+                                                                        }
+                                                                        free(walker);
+
+                                                                        if (pathOwned && (prev->text.first != prev->text.afterLast)) {
+                                                                                free((URI_CHAR *)prev->text.first);
+                                                                        }
+                                                                        free(prev);
+
+                                                                        return URI_FALSE; /* Raises malloc error */
+                                                                }
+                                                                memset(segment, 0, sizeof(URI_TYPE(PathSegment)));
+                                                                segment->text.first = URI_FUNC(SafeToPointTo);
+                                                                segment->text.afterLast = URI_FUNC(SafeToPointTo);
+                                                                prevPrev->next = segment;
+                                                                uri->pathTail = segment;
+                                                        }
+
+                                                        if (pathOwned && (walker->text.first != walker->text.afterLast)) {
+                                                                free((URI_CHAR *)walker->text.first);
+                                                        }
+                                                        free(walker);
+
+                                                        if (pathOwned && (prev->text.first != prev->text.afterLast)) {
+                                                                free((URI_CHAR *)prev->text.first);
+                                                        }
+                                                        free(prev);
+
+                                                        walker = nextBackup;
+                                                } else {
+                                                        /* Prev is the first segment */
+                                                        if (walker->next != NULL) {
+                                                                uri->pathHead = walker->next;
+                                                                walker->next->reserved = NULL;
+
+                                                                if (pathOwned && (walker->text.first != walker->text.afterLast)) {
+                                                                        free((URI_CHAR *)walker->text.first);
+                                                                }
+                                                                free(walker);
+                                                        } else {
+                                                                /* Re-use segment for "" path segment to represent trailing slash, update tail */
+                                                                URI_TYPE(PathSegment) * const segment = walker;
+                                                                if (pathOwned && (segment->text.first != segment->text.afterLast)) {
+                                                                        free((URI_CHAR *)segment->text.first);
+                                                                }
+                                                                segment->text.first = URI_FUNC(SafeToPointTo);
+                                                                segment->text.afterLast = URI_FUNC(SafeToPointTo);
+                                                                uri->pathHead = segment;
+                                                                uri->pathTail = segment;
+                                                        }
+
+                                                        if (pathOwned && (prev->text.first != prev->text.afterLast)) {
+                                                                free((URI_CHAR *)prev->text.first);
+                                                        }
+                                                        free(prev);
+
+                                                        walker = nextBackup;
+                                                }
+                                        } else {
+                                                URI_TYPE(PathSegment) * const anotherNextBackup = walker->next;
+                                                /* First segment -> update head pointer */
+                                                uri->pathHead = walker->next;
+                                                if (walker->next != NULL) {
+                                                        walker->next->reserved = NULL;
+                                                } else {
+                                                        /* Last segment -> update tail */
+                                                        uri->pathTail = NULL;
+                                                }
+
+                                                if (pathOwned && (walker->text.first != walker->text.afterLast)) {
+                                                        free((URI_CHAR *)walker->text.first);
+                                                }
+                                                free(walker);
+
+                                                walker = anotherNextBackup;
+                                        }
+                                }
+                        }
+                        break;
+
+                }
+
+                if (!removeSegment) {
+                        if (walker->next != NULL) {
+                                walker->next->reserved = walker;
+                        } else {
+                                /* Last segment -> update tail */
+                                uri->pathTail = walker;
+                        }
+                        walker = walker->next;
+                }
+        } while (walker != NULL);
+
+        return URI_TRUE;
+}
+
+
+
+/* Properly removes "." and ".." path segments */
+UriBool URI_FUNC(RemoveDotSegmentsAbsolute)(URI_TYPE(Uri) * uri) {
+        const UriBool ABSOLUTE = URI_FALSE;
+        return URI_FUNC(RemoveDotSegments)(uri, ABSOLUTE);
+}
+
+
+
+unsigned char URI_FUNC(HexdigToInt)(URI_CHAR hexdig) {
+        switch (hexdig) {
+        case _UT('0'):
+        case _UT('1'):
+        case _UT('2'):
+        case _UT('3'):
+        case _UT('4'):
+        case _UT('5'):
+        case _UT('6'):
+        case _UT('7'):
+        case _UT('8'):
+        case _UT('9'):
+                return (unsigned char)(9 + hexdig - _UT('9'));
+
+        case _UT('a'):
+        case _UT('b'):
+        case _UT('c'):
+        case _UT('d'):
+        case _UT('e'):
+        case _UT('f'):
+                return (unsigned char)(15 + hexdig - _UT('f'));
+
+        case _UT('A'):
+        case _UT('B'):
+        case _UT('C'):
+        case _UT('D'):
+        case _UT('E'):
+        case _UT('F'):
+                return (unsigned char)(15 + hexdig - _UT('F'));
+
+        default:
+                return 0;
+        }
+}
+
+
+
+URI_CHAR URI_FUNC(HexToLetter)(unsigned int value) {
+        /* Uppercase recommended in section 2.1. of RFC 3986 *
+         * http://tools.ietf.org/html/rfc3986#section-2.1    */
+        return URI_FUNC(HexToLetterEx)(value, URI_TRUE);
+}
+
+
+
+URI_CHAR URI_FUNC(HexToLetterEx)(unsigned int value, UriBool uppercase) {
+        switch (value) {
+        case  0: return _UT('0');
+        case  1: return _UT('1');
+        case  2: return _UT('2');
+        case  3: return _UT('3');
+        case  4: return _UT('4');
+        case  5: return _UT('5');
+        case  6: return _UT('6');
+        case  7: return _UT('7');
+        case  8: return _UT('8');
+        case  9: return _UT('9');
+
+        case 10: return (uppercase == URI_TRUE) ? _UT('A') : _UT('a');
+        case 11: return (uppercase == URI_TRUE) ? _UT('B') : _UT('b');
+        case 12: return (uppercase == URI_TRUE) ? _UT('C') : _UT('c');
+        case 13: return (uppercase == URI_TRUE) ? _UT('D') : _UT('d');
+        case 14: return (uppercase == URI_TRUE) ? _UT('E') : _UT('e');
+        default: return (uppercase == URI_TRUE) ? _UT('F') : _UT('f');
+        }
+}
+
+
+
+/* Checks if a URI has the host component set. */
+UriBool URI_FUNC(IsHostSet)(const URI_TYPE(Uri) * uri) {
+        return (uri != NULL)
+                        && ((uri->hostText.first != NULL)
+                                || (uri->hostData.ip4 != NULL)
+                                || (uri->hostData.ip6 != NULL)
+                                || (uri->hostData.ipFuture.first != NULL)
+                        );
+}
+
+
+
+/* Copies the path segment list from one URI to another. */
+UriBool URI_FUNC(CopyPath)(URI_TYPE(Uri) * dest,
+                const URI_TYPE(Uri) * source) {
+        if (source->pathHead == NULL) {
+                /* No path component */
+                dest->pathHead = NULL;
+                dest->pathTail = NULL;
+        } else {
+                /* Copy list but not the text contained */
+                URI_TYPE(PathSegment) * sourceWalker = source->pathHead;
+                URI_TYPE(PathSegment) * destPrev = NULL;
+                do {
+                        URI_TYPE(PathSegment) * cur = malloc(sizeof(URI_TYPE(PathSegment)));
+                        if (cur == NULL) {
+                                /* Fix broken list */
+                                if (destPrev != NULL) {
+                                        destPrev->next = NULL;
+                                }
+                                return URI_FALSE; /* Raises malloc error */
+                        }
+
+                        /* From this functions usage we know that *
+                         * the dest URI cannot be uri->owner      */
+                        cur->text = sourceWalker->text;
+                        if (destPrev == NULL) {
+                                /* First segment ever */
+                                dest->pathHead = cur;
+                        } else {
+                                destPrev->next = cur;
+                        }
+                        destPrev = cur;
+                        sourceWalker = sourceWalker->next;
+                } while (sourceWalker != NULL);
+                dest->pathTail = destPrev;
+                dest->pathTail->next = NULL;
+        }
+
+        dest->absolutePath = source->absolutePath;
+        return URI_TRUE;
+}
+
+
+
+/* Copies the authority part of an URI over to another. */
+UriBool URI_FUNC(CopyAuthority)(URI_TYPE(Uri) * dest,
+                const URI_TYPE(Uri) * source) {
+        /* From this functions usage we know that *
+         * the dest URI cannot be uri->owner      */
+
+        /* Copy userInfo */
+        dest->userInfo = source->userInfo;
+
+        /* Copy hostText */
+        dest->hostText = source->hostText;
+
+        /* Copy hostData */
+        if (source->hostData.ip4 != NULL) {
+                dest->hostData.ip4 = malloc(sizeof(UriIp4));
+                if (dest->hostData.ip4 == NULL) {
+                        return URI_FALSE; /* Raises malloc error */
+                }
+                *(dest->hostData.ip4) = *(source->hostData.ip4);
+                dest->hostData.ip6 = NULL;
+                dest->hostData.ipFuture.first = NULL;
+                dest->hostData.ipFuture.afterLast = NULL;
+        } else if (source->hostData.ip6 != NULL) {
+                dest->hostData.ip4 = NULL;
+                dest->hostData.ip6 = malloc(sizeof(UriIp6));
+                if (dest->hostData.ip6 == NULL) {
+                        return URI_FALSE; /* Raises malloc error */
+                }
+                *(dest->hostData.ip6) = *(source->hostData.ip6);
+                dest->hostData.ipFuture.first = NULL;
+                dest->hostData.ipFuture.afterLast = NULL;
+        } else {
+                dest->hostData.ip4 = NULL;
+                dest->hostData.ip6 = NULL;
+                dest->hostData.ipFuture = source->hostData.ipFuture;
+        }
+
+        /* Copy portText */
+        dest->portText = source->portText;
+
+        return URI_TRUE;
+}
+
+
+
+UriBool URI_FUNC(FixAmbiguity)(URI_TYPE(Uri) * uri) {
+        URI_TYPE(PathSegment) * segment;
+
+        if (    /* Case 1: absolute path, empty first segment */
+                        (uri->absolutePath
+                        && (uri->pathHead != NULL)
+                        && (uri->pathHead->text.afterLast == uri->pathHead->text.first))
+
+                        /* Case 2: relative path, empty first and second segment */
+                        || (!uri->absolutePath
+                        && (uri->pathHead != NULL)
+                        && (uri->pathHead->next != NULL)
+                        && (uri->pathHead->text.afterLast == uri->pathHead->text.first)
+                        && (uri->pathHead->next->text.afterLast == uri->pathHead->next->text.first))) {
+                /* NOOP */
+        } else {
+                return URI_TRUE;
+        }
+
+        segment = malloc(1 * sizeof(URI_TYPE(PathSegment)));
+        if (segment == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+
+        /* Insert "." segment in front */
+        segment->next = uri->pathHead;
+        segment->text.first = URI_FUNC(ConstPwd);
+        segment->text.afterLast = URI_FUNC(ConstPwd) + 1;
+        uri->pathHead = segment;
+        return URI_TRUE;
+}
+
+
+
+void URI_FUNC(FixEmptyTrailSegment)(URI_TYPE(Uri) * uri) {
+        /* Fix path if only one empty segment */
+        if (!uri->absolutePath
+                        && !URI_FUNC(IsHostSet)(uri)
+                        && (uri->pathHead != NULL)
+                        && (uri->pathHead->next == NULL)
+                        && (uri->pathHead->text.first == uri->pathHead->text.afterLast)) {
+                free(uri->pathHead);
+                uri->pathHead = NULL;
+                uri->pathTail = NULL;
+        }
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriCommon.h b/plugins/uriparser/UriCommon.h
new file mode 100644
index 0000000..f6bc2cc
--- /dev/null
+++ b/plugins/uriparser/UriCommon.h
@@ -0,0 +1,104 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if (defined(URI_PASS_ANSI) && !defined(URI_COMMON_H_ANSI)) \
+        || (defined(URI_PASS_UNICODE) && !defined(URI_COMMON_H_UNICODE)) \
+        || (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriCommon.h"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriCommon.h"
+#  undef URI_PASS_UNICODE
+# endif
+/* Only one pass for each encoding */
+#elif (defined(URI_PASS_ANSI) && !defined(URI_COMMON_H_ANSI) \
+        && defined(URI_ENABLE_ANSI)) || (defined(URI_PASS_UNICODE) \
+        && !defined(URI_COMMON_H_UNICODE) && defined(URI_ENABLE_UNICODE))
+# ifdef URI_PASS_ANSI
+#  define URI_COMMON_H_ANSI 1
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  define URI_COMMON_H_UNICODE 1
+#  include <uriparser/UriDefsUnicode.h>
+# endif
+
+
+
+/* Used to point to from empty path segments.
+ * X.first and X.afterLast must be the same non-NULL value then. */
+extern const URI_CHAR * const URI_FUNC(SafeToPointTo);
+extern const URI_CHAR * const URI_FUNC(ConstPwd);
+extern const URI_CHAR * const URI_FUNC(ConstParent);
+
+
+
+void URI_FUNC(ResetUri)(URI_TYPE(Uri) * uri);
+
+int URI_FUNC(CompareRange)(
+                const URI_TYPE(TextRange) * a,
+                const URI_TYPE(TextRange) * b);
+
+UriBool URI_FUNC(RemoveDotSegmentsAbsolute)(URI_TYPE(Uri) * uri);
+UriBool URI_FUNC(RemoveDotSegments)(URI_TYPE(Uri) * uri, UriBool relative);
+UriBool URI_FUNC(RemoveDotSegmentsEx)(URI_TYPE(Uri) * uri,
+        UriBool relative, UriBool pathOwned);
+
+unsigned char URI_FUNC(HexdigToInt)(URI_CHAR hexdig);
+URI_CHAR URI_FUNC(HexToLetter)(unsigned int value);
+URI_CHAR URI_FUNC(HexToLetterEx)(unsigned int value, UriBool uppercase);
+
+UriBool URI_FUNC(IsHostSet)(const URI_TYPE(Uri) * uri);
+
+UriBool URI_FUNC(CopyPath)(URI_TYPE(Uri) * dest, const URI_TYPE(Uri) * source);
+UriBool URI_FUNC(CopyAuthority)(URI_TYPE(Uri) * dest, const URI_TYPE(Uri) * source);
+
+UriBool URI_FUNC(FixAmbiguity)(URI_TYPE(Uri) * uri);
+void URI_FUNC(FixEmptyTrailSegment)(URI_TYPE(Uri) * uri);
+
+
+#endif
+#endif
diff --git a/plugins/uriparser/UriCompare.c b/plugins/uriparser/UriCompare.c
new file mode 100644
index 0000000..6896f64
--- /dev/null
+++ b/plugins/uriparser/UriCompare.c
@@ -0,0 +1,168 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriCompare.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriCompare.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include <uriparser/UriIp4.h>
+# include "UriCommon.h"
+#endif
+
+
+
+UriBool URI_FUNC(EqualsUri)(const URI_TYPE(Uri) * a,
+                const URI_TYPE(Uri) * b) {
+        /* NOTE: Both NULL means equal! */
+        if ((a == NULL) || (b == NULL)) {
+                return ((a == NULL) && (b == NULL)) ? URI_TRUE : URI_FALSE;
+        }
+
+        /* scheme */
+        if (URI_FUNC(CompareRange)(&(a->scheme), &(b->scheme))) {
+                return URI_FALSE;
+        }
+
+        /* absolutePath */
+        if ((a->scheme.first == NULL)&& (a->absolutePath != b->absolutePath)) {
+                return URI_FALSE;
+        }
+
+        /* userInfo */
+        if (URI_FUNC(CompareRange)(&(a->userInfo), &(b->userInfo))) {
+                return URI_FALSE;
+        }
+
+        /* Host */
+        if (((a->hostData.ip4 == NULL) != (b->hostData.ip4 == NULL))
+                        || ((a->hostData.ip6 == NULL) != (b->hostData.ip6 == NULL))
+                        || ((a->hostData.ipFuture.first == NULL)
+                                != (b->hostData.ipFuture.first == NULL))) {
+                return URI_FALSE;
+        }
+
+        if (a->hostData.ip4 != NULL) {
+                if (memcmp(a->hostData.ip4->data, b->hostData.ip4->data, 4)) {
+                        return URI_FALSE;
+                }
+        }
+
+        if (a->hostData.ip6 != NULL) {
+                if (memcmp(a->hostData.ip6->data, b->hostData.ip6->data, 16)) {
+                        return URI_FALSE;
+                }
+        }
+
+        if (a->hostData.ipFuture.first != NULL) {
+                if (URI_FUNC(CompareRange)(&(a->hostData.ipFuture), &(b->hostData.ipFuture))) {
+                        return URI_FALSE;
+                }
+        }
+
+        if ((a->hostData.ip4 == NULL)
+                        && (a->hostData.ip6 == NULL)
+                        && (a->hostData.ipFuture.first == NULL)) {
+                if (URI_FUNC(CompareRange)(&(a->hostText), &(b->hostText))) {
+                        return URI_FALSE;
+                }
+        }
+
+        /* portText */
+        if (URI_FUNC(CompareRange)(&(a->portText), &(b->portText))) {
+                return URI_FALSE;
+        }
+
+        /* Path */
+        if ((a->pathHead == NULL) != (b->pathHead == NULL)) {
+                return URI_FALSE;
+        }
+
+        if (a->pathHead != NULL) {
+                URI_TYPE(PathSegment) * walkA = a->pathHead;
+                URI_TYPE(PathSegment) * walkB = b->pathHead;
+                do {
+                        if (URI_FUNC(CompareRange)(&(walkA->text), &(walkB->text))) {
+                                return URI_FALSE;
+                        }
+                        if ((walkA->next == NULL) != (walkB->next == NULL)) {
+                                return URI_FALSE;
+                        }
+                        walkA = walkA->next;
+                        walkB = walkB->next;
+                } while (walkA != NULL);
+        }
+
+        /* query */
+        if (URI_FUNC(CompareRange)(&(a->query), &(b->query))) {
+                return URI_FALSE;
+        }
+
+        /* fragment */
+        if (URI_FUNC(CompareRange)(&(a->fragment), &(b->fragment))) {
+                return URI_FALSE;
+        }
+
+        return URI_TRUE; /* Equal*/
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriDefsAnsi.h b/plugins/uriparser/UriDefsAnsi.h
new file mode 100644
index 0000000..deaefaa
--- /dev/null
+++ b/plugins/uriparser/UriDefsAnsi.h
@@ -0,0 +1,82 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriDefsAnsi.h
+ * Holds definitions for the ANSI pass.
+ * NOTE: This header is included N times, not once.
+ */
+
+/* Allow multi inclusion */
+#include "UriDefsConfig.h"
+
+
+
+#undef URI_CHAR
+#define URI_CHAR char
+
+#undef _UT
+#define _UT(x) x
+
+
+
+#undef URI_FUNC
+#define URI_FUNC(x) uri##x##A
+
+#undef URI_TYPE
+#define URI_TYPE(x) Uri##x##A
+
+
+
+#undef URI_STRLEN
+#define URI_STRLEN strlen
+#undef URI_STRCPY
+#define URI_STRCPY strcpy
+#undef URI_STRCMP
+#define URI_STRCMP strcmp
+#undef URI_STRNCMP
+#define URI_STRNCMP strncmp
+
+/* TODO Remove on next source-compatibility break */
+#undef URI_SNPRINTF
+#if (defined(__WIN32__) || defined(_WIN32) || defined(WIN32))
+# define URI_SNPRINTF _snprintf
+#else
+# define URI_SNPRINTF snprintf
+#endif
diff --git a/plugins/uriparser/UriDefsConfig.h b/plugins/uriparser/UriDefsConfig.h
new file mode 100644
index 0000000..d87ccb6
--- /dev/null
+++ b/plugins/uriparser/UriDefsConfig.h
@@ -0,0 +1,101 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriDefsConfig.h
+ * Adjusts the internal configuration after processing external definitions.
+ */
+
+#ifndef URI_DEFS_CONFIG_H
+#define URI_DEFS_CONFIG_H 1
+
+
+
+/* Deny external overriding */
+#undef URI_ENABLE_ANSI      /* Internal for !URI_NO_ANSI */
+#undef URI_ENABLE_UNICODE   /* Internal for !URI_NO_UNICODE */
+
+
+
+/* Encoding */
+#ifdef URI_NO_ANSI
+# ifdef URI_NO_UNICODE
+/* No encoding at all */
+#  error URI_NO_ANSI and URI_NO_UNICODE cannot go together.
+# else
+/* Unicode only */
+#  define URI_ENABLE_UNICODE  1
+# endif
+#else
+# ifdef URI_NO_UNICODE
+/* ANSI only */
+#  define URI_ENABLE_ANSI     1
+# else
+/* Both ANSI and Unicode */
+#  define URI_ENABLE_ANSI     1
+#  define URI_ENABLE_UNICODE  1
+# endif
+#endif
+
+
+
+/* Function inlining, not ANSI/ISO C! */
+#if (defined(URI_DOXYGEN) || defined(URI_SIZEDOWN))
+# define URI_INLINE
+#elif defined(__INTEL_COMPILER)
+/* Intel C/C++ */
+/* http://predef.sourceforge.net/precomp.html#sec20 */
+/* http://www.intel.com/support/performancetools/c/windows/sb/CS-007751.htm#2 */
+# define URI_INLINE __force_inline
+#elif defined(_MSC_VER)
+/* Microsoft Visual C++ */
+/* http://predef.sourceforge.net/precomp.html#sec32 */
+/* http://msdn2.microsoft.com/en-us/library/ms882281.aspx */
+# define URI_INLINE __forceinline
+#elif (__STDC_VERSION__ >= 199901L)
+/* C99, "inline" is a keyword */
+# define URI_INLINE inline
+#else
+/* No inlining */
+# define URI_INLINE
+#endif
+
+
+
+#endif /* URI_DEFS_CONFIG_H */
diff --git a/plugins/uriparser/UriDefsUnicode.h b/plugins/uriparser/UriDefsUnicode.h
new file mode 100644
index 0000000..fa4befc
--- /dev/null
+++ b/plugins/uriparser/UriDefsUnicode.h
@@ -0,0 +1,82 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriDefsUnicode.h
+ * Holds definitions for the Unicode pass.
+ * NOTE: This header is included N times, not once.
+ */
+
+/* Allow multi inclusion */
+#include "UriDefsConfig.h"
+
+
+
+#undef URI_CHAR
+#define URI_CHAR wchar_t
+
+#undef _UT
+#define _UT(x) L##x
+
+
+
+#undef URI_FUNC
+#define URI_FUNC(x) uri##x##W
+
+#undef URI_TYPE
+#define URI_TYPE(x) Uri##x##W
+
+
+
+#undef URI_STRLEN
+#define URI_STRLEN wcslen
+#undef URI_STRCPY
+#define URI_STRCPY wcscpy
+#undef URI_STRCMP
+#define URI_STRCMP wcscmp
+#undef URI_STRNCMP
+#define URI_STRNCMP wcsncmp
+
+/* TODO Remove on next source-compatibility break */
+#undef URI_SNPRINTF
+#if (defined(__WIN32__) || defined(_WIN32) || defined(WIN32))
+# define URI_SNPRINTF _snwprintf
+#else
+# define URI_SNPRINTF swprintf
+#endif
diff --git a/plugins/uriparser/UriEscape.c b/plugins/uriparser/UriEscape.c
new file mode 100644
index 0000000..79ee3a6
--- /dev/null
+++ b/plugins/uriparser/UriEscape.c
@@ -0,0 +1,453 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriEscape.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriEscape.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriCommon.h"
+#endif
+
+
+
+URI_CHAR * URI_FUNC(Escape)(const URI_CHAR * in, URI_CHAR * out,
+                UriBool spaceToPlus, UriBool normalizeBreaks) {
+        return URI_FUNC(EscapeEx)(in, NULL, out, spaceToPlus, normalizeBreaks);
+}
+
+
+
+URI_CHAR * URI_FUNC(EscapeEx)(const URI_CHAR * inFirst,
+                const URI_CHAR * inAfterLast, URI_CHAR * out,
+                UriBool spaceToPlus, UriBool normalizeBreaks) {
+        const URI_CHAR * read = inFirst;
+        URI_CHAR * write = out;
+        UriBool prevWasCr = URI_FALSE;
+        if ((out == NULL) || (inFirst == out)) {
+                return NULL;
+        } else if (inFirst == NULL) {
+                if (out != NULL) {
+                        out[0] = _UT('\0');
+                }
+                return out;
+        }
+
+        for (;;) {
+                if ((inAfterLast != NULL) && (read >= inAfterLast)) {
+                        write[0] = _UT('\0');
+                        return write;
+                }
+
+                switch (read[0]) {
+                case _UT('\0'):
+                        write[0] = _UT('\0');
+                        return write;
+
+                case _UT(' '):
+                        if (spaceToPlus) {
+                                write[0] = _UT('+');
+                                write++;
+                        } else {
+                                write[0] = _UT('%');
+                                write[1] = _UT('2');
+                                write[2] = _UT('0');
+                                write += 3;
+                        }
+                        prevWasCr = URI_FALSE;
+                        break;
+
+                case _UT('a'): /* ALPHA */
+                case _UT('A'):
+                case _UT('b'):
+                case _UT('B'):
+                case _UT('c'):
+                case _UT('C'):
+                case _UT('d'):
+                case _UT('D'):
+                case _UT('e'):
+                case _UT('E'):
+                case _UT('f'):
+                case _UT('F'):
+                case _UT('g'):
+                case _UT('G'):
+                case _UT('h'):
+                case _UT('H'):
+                case _UT('i'):
+                case _UT('I'):
+                case _UT('j'):
+                case _UT('J'):
+                case _UT('k'):
+                case _UT('K'):
+                case _UT('l'):
+                case _UT('L'):
+                case _UT('m'):
+                case _UT('M'):
+                case _UT('n'):
+                case _UT('N'):
+                case _UT('o'):
+                case _UT('O'):
+                case _UT('p'):
+                case _UT('P'):
+                case _UT('q'):
+                case _UT('Q'):
+                case _UT('r'):
+                case _UT('R'):
+                case _UT('s'):
+                case _UT('S'):
+                case _UT('t'):
+                case _UT('T'):
+                case _UT('u'):
+                case _UT('U'):
+                case _UT('v'):
+                case _UT('V'):
+                case _UT('w'):
+                case _UT('W'):
+                case _UT('x'):
+                case _UT('X'):
+                case _UT('y'):
+                case _UT('Y'):
+                case _UT('z'):
+                case _UT('Z'):
+                case _UT('0'): /* DIGIT */
+                case _UT('1'):
+                case _UT('2'):
+                case _UT('3'):
+                case _UT('4'):
+                case _UT('5'):
+                case _UT('6'):
+                case _UT('7'):
+                case _UT('8'):
+                case _UT('9'):
+                case _UT('-'): /* "-" / "." / "_" / "~" */
+                case _UT('.'):
+                case _UT('_'):
+                case _UT('~'):
+                        /* Copy unmodified */
+                        write[0] = read[0];
+                        write++;
+
+                        prevWasCr = URI_FALSE;
+                        break;
+
+                case _UT('\x0a'):
+                        if (normalizeBreaks) {
+                                if (!prevWasCr) {
+                                        write[0] = _UT('%');
+                                        write[1] = _UT('0');
+                                        write[2] = _UT('D');
+                                        write[3] = _UT('%');
+                                        write[4] = _UT('0');
+                                        write[5] = _UT('A');
+                                        write += 6;
+                                }
+                        } else {
+                                write[0] = _UT('%');
+                                write[1] = _UT('0');
+                                write[2] = _UT('A');
+                                write += 3;
+                        }
+                        prevWasCr = URI_FALSE;
+                        break;
+
+                case _UT('\x0d'):
+                        if (normalizeBreaks) {
+                                write[0] = _UT('%');
+                                write[1] = _UT('0');
+                                write[2] = _UT('D');
+                                write[3] = _UT('%');
+                                write[4] = _UT('0');
+                                write[5] = _UT('A');
+                                write += 6;
+                        } else {
+                                write[0] = _UT('%');
+                                write[1] = _UT('0');
+                                write[2] = _UT('D');
+                                write += 3;
+                        }
+                        prevWasCr = URI_TRUE;
+                        break;
+
+                default:
+                        /* Percent encode */
+                        {
+                                const unsigned char code = (unsigned char)read[0];
+                                write[0] = _UT('%');
+                                write[1] = URI_FUNC(HexToLetter)(code >> 4);
+                                write[2] = URI_FUNC(HexToLetter)(code & 0x0f);
+                                write += 3;
+                        }
+                        prevWasCr = URI_FALSE;
+                        break;
+                }
+
+                read++;
+        }
+}
+
+
+
+const URI_CHAR * URI_FUNC(UnescapeInPlace)(URI_CHAR * inout) {
+        return URI_FUNC(UnescapeInPlaceEx)(inout, URI_FALSE, URI_BR_DONT_TOUCH);
+}
+
+
+
+const URI_CHAR * URI_FUNC(UnescapeInPlaceEx)(URI_CHAR * inout,
+                UriBool plusToSpace, UriBreakConversion breakConversion) {
+        URI_CHAR * read = inout;
+        URI_CHAR * write = inout;
+        UriBool prevWasCr = URI_FALSE;
+
+        if (inout == NULL) {
+                return NULL;
+        }
+
+        for (;;) {
+                switch (read[0]) {
+                case _UT('\0'):
+                        if (read > write) {
+                                write[0] = _UT('\0');
+                        }
+                        return write;
+
+                case _UT('%'):
+                        switch (read[1]) {
+                        case _UT('0'):
+                        case _UT('1'):
+                        case _UT('2'):
+                        case _UT('3'):
+                        case _UT('4'):
+                        case _UT('5'):
+                        case _UT('6'):
+                        case _UT('7'):
+                        case _UT('8'):
+                        case _UT('9'):
+                        case _UT('a'):
+                        case _UT('b'):
+                        case _UT('c'):
+                        case _UT('d'):
+                        case _UT('e'):
+                        case _UT('f'):
+                        case _UT('A'):
+                        case _UT('B'):
+                        case _UT('C'):
+                        case _UT('D'):
+                        case _UT('E'):
+                        case _UT('F'):
+                                switch (read[2]) {
+                                case _UT('0'):
+                                case _UT('1'):
+                                case _UT('2'):
+                                case _UT('3'):
+                                case _UT('4'):
+                                case _UT('5'):
+                                case _UT('6'):
+                                case _UT('7'):
+                                case _UT('8'):
+                                case _UT('9'):
+                                case _UT('a'):
+                                case _UT('b'):
+                                case _UT('c'):
+                                case _UT('d'):
+                                case _UT('e'):
+                                case _UT('f'):
+                                case _UT('A'):
+                                case _UT('B'):
+                                case _UT('C'):
+                                case _UT('D'):
+                                case _UT('E'):
+                                case _UT('F'):
+                                        {
+                                                /* Percent group found */
+                                                const unsigned char left = URI_FUNC(HexdigToInt)(read[1]);
+                                                const unsigned char right = URI_FUNC(HexdigToInt)(read[2]);
+                                                const int code = 16 * left + right;
+                                                switch (code) {
+                                                case 10:
+                                                        switch (breakConversion) {
+                                                        case URI_BR_TO_LF:
+                                                                if (!prevWasCr) {
+                                                                        write[0] = (URI_CHAR)10;
+                                                                        write++;
+                                                                }
+                                                                break;
+
+                                                        case URI_BR_TO_CRLF:
+                                                                if (!prevWasCr) {
+                                                                        write[0] = (URI_CHAR)13;
+                                                                        write[1] = (URI_CHAR)10;
+                                                                        write += 2;
+                                                                }
+                                                                break;
+
+                                                        case URI_BR_TO_CR:
+                                                                if (!prevWasCr) {
+                                                                        write[0] = (URI_CHAR)13;
+                                                                        write++;
+                                                                }
+                                                                break;
+
+                                                        case URI_BR_DONT_TOUCH:
+                                                        default:
+                                                                write[0] = (URI_CHAR)10;
+                                                                write++;
+
+                                                        }
+                                                        prevWasCr = URI_FALSE;
+                                                        break;
+
+                                                case 13:
+                                                        switch (breakConversion) {
+                                                        case URI_BR_TO_LF:
+                                                                write[0] = (URI_CHAR)10;
+                                                                write++;
+                                                                break;
+
+                                                        case URI_BR_TO_CRLF:
+                                                                write[0] = (URI_CHAR)13;
+                                                                write[1] = (URI_CHAR)10;
+                                                                write += 2;
+                                                                break;
+
+                                                        case URI_BR_TO_CR:
+                                                                write[0] = (URI_CHAR)13;
+                                                                write++;
+                                                                break;
+
+                                                        case URI_BR_DONT_TOUCH:
+                                                        default:
+                                                                write[0] = (URI_CHAR)13;
+                                                                write++;
+
+                                                        }
+                                                        prevWasCr = URI_TRUE;
+                                                        break;
+
+                                                default:
+                                                        write[0] = (URI_CHAR)(code);
+                                                        write++;
+
+                                                        prevWasCr = URI_FALSE;
+
+                                                }
+                                                read += 3;
+                                        }
+                                        break;
+
+                                default:
+                                        /* Copy two chars unmodified and */
+                                        /* look at this char again */
+                                        if (read > write) {
+                                                write[0] = read[0];
+                                                write[1] = read[1];
+                                        }
+                                        read += 2;
+                                        write += 2;
+
+                                        prevWasCr = URI_FALSE;
+                                }
+                                break;
+
+                        default:
+                                /* Copy one char unmodified and */
+                                /* look at this char again */
+                                if (read > write) {
+                                        write[0] = read[0];
+                                }
+                                read++;
+                                write++;
+
+                                prevWasCr = URI_FALSE;
+                        }
+                        break;
+
+                case _UT('+'):
+                        if (plusToSpace) {
+                                /* Convert '+' to ' ' */
+                                write[0] = _UT(' ');
+                        } else {
+                                /* Copy one char unmodified */
+                                if (read > write) {
+                                        write[0] = read[0];
+                                }
+                        }
+                        read++;
+                        write++;
+
+                        prevWasCr = URI_FALSE;
+                        break;
+
+                default:
+                        /* Copy one char unmodified */
+                        if (read > write) {
+                                write[0] = read[0];
+                        }
+                        read++;
+                        write++;
+
+                        prevWasCr = URI_FALSE;
+                }
+        }
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriFile.c b/plugins/uriparser/UriFile.c
new file mode 100644
index 0000000..9cf788f
--- /dev/null
+++ b/plugins/uriparser/UriFile.c
@@ -0,0 +1,226 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriFile.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriFile.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+#endif
+
+
+
+static URI_INLINE int URI_FUNC(FilenameToUriString)(const URI_CHAR * filename,
+                URI_CHAR * uriString, UriBool fromUnix) {
+        const URI_CHAR * input = filename;
+        const URI_CHAR * lastSep = input - 1;
+        UriBool firstSegment = URI_TRUE;
+        URI_CHAR * output = uriString;
+        UriBool absolute;
+        UriBool is_windows_network;
+
+        if ((filename == NULL) || (uriString == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        is_windows_network = (filename[0] == _UT('\\')) && (filename[1] == _UT('\\'));
+        absolute = fromUnix
+                        ? (filename[0] == _UT('/'))
+                        : ((filename[0] != _UT('\0')) && (filename[1] == _UT(':'))
+                                || is_windows_network);
+
+        if (absolute) {
+                const URI_CHAR * const prefix = fromUnix
+                                ? _UT("file://")
+                                : is_windows_network
+                                        ? _UT("file:")
+                                        : _UT("file:///");
+                const int prefixLen = URI_STRLEN(prefix);
+
+                /* Copy prefix */
+                memcpy(uriString, prefix, prefixLen * sizeof(URI_CHAR));
+                output += prefixLen;
+        }
+
+        /* Copy and escape on the fly */
+        for (;;) {
+                if ((input[0] == _UT('\0'))
+                                || (fromUnix && input[0] == _UT('/'))
+                                || (!fromUnix && input[0] == _UT('\\'))) {
+                        /* Copy text after last seperator */
+                        if (lastSep + 1 < input) {
+                                if (!fromUnix && absolute && (firstSegment == URI_TRUE)) {
+                                        /* Quick hack to not convert "C:" to "C%3A" */
+                                        const int charsToCopy = (int)(input - (lastSep + 1));
+                                        memcpy(output, lastSep + 1, charsToCopy * sizeof(URI_CHAR));
+                                        output += charsToCopy;
+                                } else {
+                                        output = URI_FUNC(EscapeEx)(lastSep + 1, input, output,
+                                                        URI_FALSE, URI_FALSE);
+                                }
+                        }
+                        firstSegment = URI_FALSE;
+                }
+
+                if (input[0] == _UT('\0')) {
+                        output[0] = _UT('\0');
+                        break;
+                } else if (fromUnix && (input[0] == _UT('/'))) {
+                        /* Copy separators unmodified */
+                        output[0] = _UT('/');
+                        output++;
+                        lastSep = input;
+                } else if (!fromUnix && (input[0] == _UT('\\'))) {
+                        /* Convert backslashes to forward slashes */
+                        output[0] = _UT('/');
+                        output++;
+                        lastSep = input;
+                }
+                input++;
+        }
+
+        return URI_SUCCESS;
+}
+
+
+
+static URI_INLINE int URI_FUNC(UriStringToFilename)(const URI_CHAR * uriString,
+                URI_CHAR * filename, UriBool toUnix) {
+        if ((uriString == NULL) || (filename == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        {
+                const UriBool file_two_slashes =
+                                URI_STRNCMP(uriString, _UT("file://"), URI_STRLEN(_UT("file://"))) == 0;
+                const UriBool file_three_slashes = file_two_slashes
+                                && (URI_STRNCMP(uriString, _UT("file:///"), URI_STRLEN(_UT("file:///"))) == 0);
+
+                const size_t charsToSkip = file_two_slashes
+                                ? file_three_slashes
+                                        ? toUnix
+                                                /* file:///bin/bash */
+                                                ? URI_STRLEN(_UT("file://"))
+                                                /* file:///E:/Documents%20and%20Settings */
+                                                : URI_STRLEN(_UT("file:///"))
+                                        /* file://Server01/Letter.txt */
+                                        : URI_STRLEN(_UT("file://"))
+                                : 0;
+                const size_t charsToCopy = URI_STRLEN(uriString + charsToSkip) + 1;
+
+                const UriBool is_windows_network_with_authority =
+                                (toUnix == URI_FALSE)
+                                && file_two_slashes
+                                && ! file_three_slashes;
+
+                URI_CHAR * const unescape_target = is_windows_network_with_authority
+                                ? (filename + 2)
+                                : filename;
+
+                if (is_windows_network_with_authority) {
+                        filename[0] = '\\';
+                        filename[1] = '\\';
+                }
+
+                memcpy(unescape_target, uriString + charsToSkip, charsToCopy * sizeof(URI_CHAR));
+                URI_FUNC(UnescapeInPlaceEx)(filename, URI_FALSE, URI_BR_DONT_TOUCH);
+        }
+
+        /* Convert forward slashes to backslashes */
+        if (!toUnix) {
+                URI_CHAR * walker = filename;
+                while (walker[0] != _UT('\0')) {
+                        if (walker[0] == _UT('/')) {
+                                walker[0] = _UT('\\');
+                        }
+                        walker++;
+                }
+        }
+
+        return URI_SUCCESS;
+}
+
+
+
+int URI_FUNC(UnixFilenameToUriString)(const URI_CHAR * filename, URI_CHAR * uriString) {
+        return URI_FUNC(FilenameToUriString)(filename, uriString, URI_TRUE);
+}
+
+
+
+int URI_FUNC(WindowsFilenameToUriString)(const URI_CHAR * filename, URI_CHAR * uriString) {
+        return URI_FUNC(FilenameToUriString)(filename, uriString, URI_FALSE);
+}
+
+
+
+int URI_FUNC(UriStringToUnixFilename)(const URI_CHAR * uriString, URI_CHAR * filename) {
+        return URI_FUNC(UriStringToFilename)(uriString, filename, URI_TRUE);
+}
+
+
+
+int URI_FUNC(UriStringToWindowsFilename)(const URI_CHAR * uriString, URI_CHAR * filename) {
+        return URI_FUNC(UriStringToFilename)(uriString, filename, URI_FALSE);
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriIp4.c b/plugins/uriparser/UriIp4.c
new file mode 100644
index 0000000..c00910b
--- /dev/null
+++ b/plugins/uriparser/UriIp4.c
@@ -0,0 +1,329 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriIp4.c
+ * Holds the IPv4 parser implementation.
+ * NOTE: This source file includes itself twice.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriIp4.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriIp4.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/UriIp4.h>
+# include "UriIp4Base.h"
+# include <uriparser/UriBase.h>
+#endif
+
+
+
+/* Prototypes */
+static const URI_CHAR * URI_FUNC(ParseDecOctet)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseDecOctetOne)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseDecOctetTwo)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseDecOctetThree)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseDecOctetFour)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+
+
+
+/*
+ * [ipFourAddress]->[decOctet]<.>[decOctet]<.>[decOctet]<.>[decOctet]
+ */
+int URI_FUNC(ParseIpFourAddress)(unsigned char * octetOutput,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        const URI_CHAR * after;
+        UriIp4Parser parser;
+
+        /* Essential checks */
+        if ((octetOutput == NULL) || (first == NULL)
+                        || (afterLast <= first)) {
+                return URI_ERROR_SYNTAX;
+        }
+
+        /* Reset parser */
+        parser.stackCount = 0;
+
+        /* Octet #1 */
+        after = URI_FUNC(ParseDecOctet)(&parser, first, afterLast);
+        if ((after == NULL) || (after >= afterLast) || (*after != _UT('.'))) {
+                return URI_ERROR_SYNTAX;
+        }
+        uriStackToOctet(&parser, octetOutput);
+
+        /* Octet #2 */
+        after = URI_FUNC(ParseDecOctet)(&parser, after + 1, afterLast);
+        if ((after == NULL) || (after >= afterLast) || (*after != _UT('.'))) {
+                return URI_ERROR_SYNTAX;
+        }
+        uriStackToOctet(&parser, octetOutput + 1);
+
+        /* Octet #3 */
+        after = URI_FUNC(ParseDecOctet)(&parser, after + 1, afterLast);
+        if ((after == NULL) || (after >= afterLast) || (*after != _UT('.'))) {
+                return URI_ERROR_SYNTAX;
+        }
+        uriStackToOctet(&parser, octetOutput + 2);
+
+        /* Octet #4 */
+        after = URI_FUNC(ParseDecOctet)(&parser, after + 1, afterLast);
+        if (after != afterLast) {
+                return URI_ERROR_SYNTAX;
+        }
+        uriStackToOctet(&parser, octetOutput + 3);
+
+        return URI_SUCCESS;
+}
+
+
+
+/*
+ * [decOctet]-><0>
+ * [decOctet]-><1>[decOctetOne]
+ * [decOctet]-><2>[decOctetTwo]
+ * [decOctet]-><3>[decOctetThree]
+ * [decOctet]-><4>[decOctetThree]
+ * [decOctet]-><5>[decOctetThree]
+ * [decOctet]-><6>[decOctetThree]
+ * [decOctet]-><7>[decOctetThree]
+ * [decOctet]-><8>[decOctetThree]
+ * [decOctet]-><9>[decOctetThree]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctet)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('0'):
+                uriPushToStack(parser, 0);
+                return first + 1;
+
+        case _UT('1'):
+                uriPushToStack(parser, 1);
+                return (const URI_CHAR *)URI_FUNC(ParseDecOctetOne)(parser, first + 1, afterLast);
+
+        case _UT('2'):
+                uriPushToStack(parser, 2);
+                return (const URI_CHAR *)URI_FUNC(ParseDecOctetTwo)(parser, first + 1, afterLast);
+
+        case _UT('3'):
+        case _UT('4'):
+        case _UT('5'):
+        case _UT('6'):
+        case _UT('7'):
+        case _UT('8'):
+        case _UT('9'):
+                uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
+                return (const URI_CHAR *)URI_FUNC(ParseDecOctetThree)(parser, first + 1, afterLast);
+
+        default:
+                return NULL;
+        }
+}
+
+
+
+/*
+ * [decOctetOne]-><NULL>
+ * [decOctetOne]->[DIGIT][decOctetThree]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctetOne)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('0'):
+        case _UT('1'):
+        case _UT('2'):
+        case _UT('3'):
+        case _UT('4'):
+        case _UT('5'):
+        case _UT('6'):
+        case _UT('7'):
+        case _UT('8'):
+        case _UT('9'):
+                uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
+                return (const URI_CHAR *)URI_FUNC(ParseDecOctetThree)(parser, first + 1, afterLast);
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [decOctetTwo]-><NULL>
+ * [decOctetTwo]-><0>[decOctetThree]
+ * [decOctetTwo]-><1>[decOctetThree]
+ * [decOctetTwo]-><2>[decOctetThree]
+ * [decOctetTwo]-><3>[decOctetThree]
+ * [decOctetTwo]-><4>[decOctetThree]
+ * [decOctetTwo]-><5>[decOctetFour]
+ * [decOctetTwo]-><6>
+ * [decOctetTwo]-><7>
+ * [decOctetTwo]-><8>
+ * [decOctetTwo]-><9>
+*/
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctetTwo)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('0'):
+        case _UT('1'):
+        case _UT('2'):
+        case _UT('3'):
+        case _UT('4'):
+                uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
+                return (const URI_CHAR *)URI_FUNC(ParseDecOctetThree)(parser, first + 1, afterLast);
+
+        case _UT('5'):
+                uriPushToStack(parser, 5);
+                return (const URI_CHAR *)URI_FUNC(ParseDecOctetFour)(parser, first + 1, afterLast);
+
+        case _UT('6'):
+        case _UT('7'):
+        case _UT('8'):
+        case _UT('9'):
+                uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
+                return first + 1;
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [decOctetThree]-><NULL>
+ * [decOctetThree]->[DIGIT]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctetThree)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('0'):
+        case _UT('1'):
+        case _UT('2'):
+        case _UT('3'):
+        case _UT('4'):
+        case _UT('5'):
+        case _UT('6'):
+        case _UT('7'):
+        case _UT('8'):
+        case _UT('9'):
+                uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
+                return first + 1;
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [decOctetFour]-><NULL>
+ * [decOctetFour]-><0>
+ * [decOctetFour]-><1>
+ * [decOctetFour]-><2>
+ * [decOctetFour]-><3>
+ * [decOctetFour]-><4>
+ * [decOctetFour]-><5>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctetFour)(UriIp4Parser * parser,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('0'):
+        case _UT('1'):
+        case _UT('2'):
+        case _UT('3'):
+        case _UT('4'):
+        case _UT('5'):
+                uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
+                return first + 1;
+
+        default:
+                return first;
+        }
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriIp4.h b/plugins/uriparser/UriIp4.h
new file mode 100644
index 0000000..885a35c
--- /dev/null
+++ b/plugins/uriparser/UriIp4.h
@@ -0,0 +1,92 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriIp4.h
+ * Holds the IPv4 parser interface.
+ * NOTE: This header includes itself twice.
+ */
+
+#if (defined(URI_PASS_ANSI) && !defined(URI_IP4_TWICE_H_ANSI)) \
+        || (defined(URI_PASS_UNICODE) && !defined(URI_IP4_TWICE_H_UNICODE)) \
+        || (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* What encodings are enabled? */
+#include "UriDefsConfig.h"
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriIp4.h"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriIp4.h"
+#  undef URI_PASS_UNICODE
+# endif
+/* Only one pass for each encoding */
+#elif (defined(URI_PASS_ANSI) && !defined(URI_IP4_TWICE_H_ANSI) \
+        && defined(URI_ENABLE_ANSI)) || (defined(URI_PASS_UNICODE) \
+        && !defined(URI_IP4_TWICE_H_UNICODE) && defined(URI_ENABLE_UNICODE))
+# ifdef URI_PASS_ANSI
+#  define URI_IP4_TWICE_H_ANSI 1
+#  include "UriDefsAnsi.h"
+# else
+#  define URI_IP4_TWICE_H_UNICODE 1
+#  include "UriDefsUnicode.h"
+#  include <wchar.h>
+# endif
+
+
+
+/**
+ * Converts a IPv4 text representation into four bytes.
+ *
+ * @param octetOutput  Output destination
+ * @param first        First character of IPv4 text to parse
+ * @param afterLast    Position to stop parsing at
+ * @return Error code or 0 on success
+ */
+int URI_FUNC(ParseIpFourAddress)(unsigned char * octetOutput,
+                const URI_CHAR * first, const URI_CHAR * afterLast);
+
+
+
+#endif
+#endif
diff --git a/plugins/uriparser/UriIp4Base.c b/plugins/uriparser/UriIp4Base.c
new file mode 100644
index 0000000..5cd298f
--- /dev/null
+++ b/plugins/uriparser/UriIp4Base.c
@@ -0,0 +1,96 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriIp4Base.c
+ * Holds code independent of the encoding pass.
+ */
+
+#ifndef URI_DOXYGEN
+# include "UriIp4Base.h"
+#endif
+
+
+
+void uriStackToOctet(UriIp4Parser * parser, unsigned char * octet) {
+        switch (parser->stackCount) {
+        case 1:
+                *octet = parser->stackOne;
+                break;
+
+        case 2:
+                *octet = parser->stackOne * 10
+                                + parser->stackTwo;
+                break;
+
+        case 3:
+                *octet = parser->stackOne * 100
+                                + parser->stackTwo * 10
+                                + parser->stackThree;
+                break;
+
+        default:
+                ;
+        }
+        parser->stackCount = 0;
+}
+
+
+
+void uriPushToStack(UriIp4Parser * parser, unsigned char digit) {
+        switch (parser->stackCount) {
+        case 0:
+                parser->stackOne = digit;
+                parser->stackCount = 1;
+                break;
+
+        case 1:
+                parser->stackTwo = digit;
+                parser->stackCount = 2;
+                break;
+
+        case 2:
+                parser->stackThree = digit;
+                parser->stackCount = 3;
+                break;
+
+        default:
+                ;
+        }
+}
diff --git a/plugins/uriparser/UriIp4Base.h b/plugins/uriparser/UriIp4Base.h
new file mode 100644
index 0000000..23b838e
--- /dev/null
+++ b/plugins/uriparser/UriIp4Base.h
@@ -0,0 +1,59 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef URI_IP4_BASE_H
+#define URI_IP4_BASE_H 1
+
+
+
+typedef struct UriIp4ParserStruct {
+        unsigned char stackCount;
+        unsigned char stackOne;
+        unsigned char stackTwo;
+        unsigned char stackThree;
+} UriIp4Parser;
+
+
+
+void uriPushToStack(UriIp4Parser * parser, unsigned char digit);
+void uriStackToOctet(UriIp4Parser * parser, unsigned char * octet);
+
+
+
+#endif /* URI_IP4_BASE_H */
diff --git a/plugins/uriparser/UriNormalize.c b/plugins/uriparser/UriNormalize.c
new file mode 100644
index 0000000..49db9ff
--- /dev/null
+++ b/plugins/uriparser/UriNormalize.c
@@ -0,0 +1,728 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriNormalize.c
+ * Holds the RFC 3986 %URI normalization implementation.
+ * NOTE: This source file includes itself twice.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriNormalize.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriNormalize.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriNormalizeBase.h"
+# include "UriCommon.h"
+#endif
+
+
+
+static int URI_FUNC(NormalizeSyntaxEngine)(URI_TYPE(Uri) * uri, unsigned int inMask,
+                unsigned int * outMask);
+
+static UriBool URI_FUNC(MakeRangeOwner)(unsigned int * doneMask,
+                unsigned int maskTest, URI_TYPE(TextRange) * range);
+static UriBool URI_FUNC(MakeOwner)(URI_TYPE(Uri) * uri,
+                unsigned int * doneMask);
+
+static void URI_FUNC(FixPercentEncodingInplace)(const URI_CHAR * first,
+                const URI_CHAR ** afterLast);
+static UriBool URI_FUNC(FixPercentEncodingMalloc)(const URI_CHAR ** first,
+                const URI_CHAR ** afterLast);
+static void URI_FUNC(FixPercentEncodingEngine)(
+                const URI_CHAR * inFirst, const URI_CHAR * inAfterLast,
+                const URI_CHAR * outFirst, const URI_CHAR ** outAfterLast);
+
+static UriBool URI_FUNC(ContainsUppercaseLetters)(const URI_CHAR * first,
+                const URI_CHAR * afterLast);
+static UriBool URI_FUNC(ContainsUglyPercentEncoding)(const URI_CHAR * first,
+                const URI_CHAR * afterLast);
+
+static void URI_FUNC(LowercaseInplace)(const URI_CHAR * first,
+                const URI_CHAR * afterLast);
+static UriBool URI_FUNC(LowercaseMalloc)(const URI_CHAR ** first,
+                const URI_CHAR ** afterLast);
+
+static void URI_FUNC(PreventLeakage)(URI_TYPE(Uri) * uri,
+                unsigned int revertMask);
+
+
+
+static URI_INLINE void URI_FUNC(PreventLeakage)(URI_TYPE(Uri) * uri,
+                unsigned int revertMask) {
+        if (revertMask & URI_NORMALIZE_SCHEME) {
+                free((URI_CHAR *)uri->scheme.first);
+                uri->scheme.first = NULL;
+                uri->scheme.afterLast = NULL;
+        }
+
+        if (revertMask & URI_NORMALIZE_USER_INFO) {
+                free((URI_CHAR *)uri->userInfo.first);
+                uri->userInfo.first = NULL;
+                uri->userInfo.afterLast = NULL;
+        }
+
+        if (revertMask & URI_NORMALIZE_HOST) {
+                if (uri->hostData.ipFuture.first != NULL) {
+                        /* IPvFuture */
+                        free((URI_CHAR *)uri->hostData.ipFuture.first);
+                        uri->hostData.ipFuture.first = NULL;
+                        uri->hostData.ipFuture.afterLast = NULL;
+                        uri->hostText.first = NULL;
+                        uri->hostText.afterLast = NULL;
+                } else if ((uri->hostText.first != NULL)
+                                && (uri->hostData.ip4 == NULL)
+                                && (uri->hostData.ip6 == NULL)) {
+                        /* Regname */
+                        free((URI_CHAR *)uri->hostText.first);
+                        uri->hostText.first = NULL;
+                        uri->hostText.afterLast = NULL;
+                }
+        }
+
+        /* NOTE: Port cannot happen! */
+
+        if (revertMask & URI_NORMALIZE_PATH) {
+                URI_TYPE(PathSegment) * walker = uri->pathHead;
+                while (walker != NULL) {
+                        URI_TYPE(PathSegment) * const next = walker->next;
+                        if (walker->text.afterLast > walker->text.first) {
+                                free((URI_CHAR *)walker->text.first);
+                        }
+                        free(walker);
+                        walker = next;
+                }
+                uri->pathHead = NULL;
+                uri->pathTail = NULL;
+        }
+
+        if (revertMask & URI_NORMALIZE_QUERY) {
+                free((URI_CHAR *)uri->query.first);
+                uri->query.first = NULL;
+                uri->query.afterLast = NULL;
+        }
+
+        if (revertMask & URI_NORMALIZE_FRAGMENT) {
+                free((URI_CHAR *)uri->fragment.first);
+                uri->fragment.first = NULL;
+                uri->fragment.afterLast = NULL;
+        }
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(ContainsUppercaseLetters)(const URI_CHAR * first,
+                const URI_CHAR * afterLast) {
+        if ((first != NULL) && (afterLast != NULL) && (afterLast > first)) {
+                const URI_CHAR * i = first;
+                for (; i < afterLast; i++) {
+                        /* 6.2.2.1 Case Normalization: uppercase letters in scheme or host */
+                        if ((*i >= _UT('A')) && (*i <= _UT('Z'))) {
+                                return URI_TRUE;
+                        }
+                }
+        }
+        return URI_FALSE;
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(ContainsUglyPercentEncoding)(const URI_CHAR * first,
+                const URI_CHAR * afterLast) {
+        if ((first != NULL) && (afterLast != NULL) && (afterLast > first)) {
+                const URI_CHAR * i = first;
+                for (; i + 2 < afterLast; i++) {
+                        if (i[0] == _UT('%')) {
+                                /* 6.2.2.1 Case Normalization: *
+                                 * lowercase percent-encodings */
+                                if (((i[1] >= _UT('a')) && (i[1] <= _UT('f')))
+                                                || ((i[2] >= _UT('a')) && (i[2] <= _UT('f')))) {
+                                        return URI_TRUE;
+                                } else {
+                                        /* 6.2.2.2 Percent-Encoding Normalization: *
+                                         * percent-encoded unreserved characters   */
+                                        const unsigned char left = URI_FUNC(HexdigToInt)(i[1]);
+                                        const unsigned char right = URI_FUNC(HexdigToInt)(i[2]);
+                                        const int code = 16 * left + right;
+                                        if (uriIsUnreserved(code)) {
+                                                return URI_TRUE;
+                                        }
+                                }
+                        }
+                }
+        }
+        return URI_FALSE;
+}
+
+
+
+static URI_INLINE void URI_FUNC(LowercaseInplace)(const URI_CHAR * first,
+                const URI_CHAR * afterLast) {
+        if ((first != NULL) && (afterLast != NULL) && (afterLast > first)) {
+                URI_CHAR * i = (URI_CHAR *)first;
+                const int lowerUpperDiff = (_UT('a') - _UT('A'));
+                for (; i < afterLast; i++) {
+                        if ((*i >= _UT('A')) && (*i <=_UT('Z'))) {
+                                *i = (URI_CHAR)(*i + lowerUpperDiff);
+                        }
+                }
+        }
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(LowercaseMalloc)(const URI_CHAR ** first,
+                const URI_CHAR ** afterLast) {
+        int lenInChars;
+        const int lowerUpperDiff = (_UT('a') - _UT('A'));
+        URI_CHAR * buffer;
+        int i = 0;
+
+        if ((first == NULL) || (afterLast == NULL) || (*first == NULL)
+                        || (*afterLast == NULL)) {
+                return URI_FALSE;
+        }
+
+        lenInChars = (int)(*afterLast - *first);
+        if (lenInChars == 0) {
+                return URI_TRUE;
+        } else if (lenInChars < 0) {
+                return URI_FALSE;
+        }
+
+        buffer = malloc(lenInChars * sizeof(URI_CHAR));
+        if (buffer == NULL) {
+                return URI_FALSE;
+        }
+
+        for (; i < lenInChars; i++) {
+                if (((*first)[i] >= _UT('A')) && ((*first)[i] <=_UT('Z'))) {
+                        buffer[i] = (URI_CHAR)((*first)[i] + lowerUpperDiff);
+                } else {
+                        buffer[i] = (*first)[i];
+                }
+        }
+
+        *first = buffer;
+        *afterLast = buffer + lenInChars;
+        return URI_TRUE;
+}
+
+
+
+/* NOTE: Implementation must stay inplace-compatible */
+static URI_INLINE void URI_FUNC(FixPercentEncodingEngine)(
+                const URI_CHAR * inFirst, const URI_CHAR * inAfterLast,
+                const URI_CHAR * outFirst, const URI_CHAR ** outAfterLast) {
+        URI_CHAR * write = (URI_CHAR *)outFirst;
+        const int lenInChars = (int)(inAfterLast - inFirst);
+        int i = 0;
+
+        /* All but last two */
+        for (; i + 2 < lenInChars; i++) {
+                if (inFirst[i] != _UT('%')) {
+                        write[0] = inFirst[i];
+                        write++;
+                } else {
+                        /* 6.2.2.2 Percent-Encoding Normalization: *
+                         * percent-encoded unreserved characters   */
+                        const URI_CHAR one = inFirst[i + 1];
+                        const URI_CHAR two = inFirst[i + 2];
+                        const unsigned char left = URI_FUNC(HexdigToInt)(one);
+                        const unsigned char right = URI_FUNC(HexdigToInt)(two);
+                        const int code = 16 * left + right;
+                        if (uriIsUnreserved(code)) {
+                                write[0] = (URI_CHAR)(code);
+                                write++;
+                        } else {
+                                /* 6.2.2.1 Case Normalization: *
+                                 * lowercase percent-encodings */
+                                write[0] = _UT('%');
+                                write[1] = URI_FUNC(HexToLetter)(left);
+                                write[2] = URI_FUNC(HexToLetter)(right);
+                                write += 3;
+                        }
+
+                        i += 2; /* For the two chars of the percent group we just ate */
+                }
+        }
+
+        /* Last two */
+        for (; i < lenInChars; i++) {
+                write[0] = inFirst[i];
+                write++;
+        }
+
+        *outAfterLast = write;
+}
+
+
+
+static URI_INLINE void URI_FUNC(FixPercentEncodingInplace)(const URI_CHAR * first,
+                const URI_CHAR ** afterLast) {
+        /* Death checks */
+        if ((first == NULL) || (afterLast == NULL) || (*afterLast == NULL)) {
+                return;
+        }
+
+        /* Fix inplace */
+        URI_FUNC(FixPercentEncodingEngine)(first, *afterLast, first, afterLast);
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(FixPercentEncodingMalloc)(const URI_CHAR ** first,
+                const URI_CHAR ** afterLast) {
+        int lenInChars;
+        URI_CHAR * buffer;
+
+        /* Death checks */
+        if ((first == NULL) || (afterLast == NULL)
+                        || (*first == NULL) || (*afterLast == NULL)) {
+                return URI_FALSE;
+        }
+
+        /* Old text length */
+        lenInChars = (int)(*afterLast - *first);
+        if (lenInChars == 0) {
+                return URI_TRUE;
+        } else if (lenInChars < 0) {
+                return URI_FALSE;
+        }
+
+        /* New buffer */
+        buffer = malloc(lenInChars * sizeof(URI_CHAR));
+        if (buffer == NULL) {
+                return URI_FALSE;
+        }
+
+        /* Fix on copy */
+        URI_FUNC(FixPercentEncodingEngine)(*first, *afterLast, buffer, afterLast);
+        *first = buffer;
+        return URI_TRUE;
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(MakeRangeOwner)(unsigned int * doneMask,
+                unsigned int maskTest, URI_TYPE(TextRange) * range) {
+        if (((*doneMask & maskTest) == 0)
+                        && (range->first != NULL)
+                        && (range->afterLast != NULL)
+                        && (range->afterLast > range->first)) {
+                const int lenInChars = (int)(range->afterLast - range->first);
+                const int lenInBytes = lenInChars * sizeof(URI_CHAR);
+                URI_CHAR * dup = malloc(lenInBytes);
+                if (dup == NULL) {
+                        return URI_FALSE; /* Raises malloc error */
+                }
+                memcpy(dup, range->first, lenInBytes);
+                range->first = dup;
+                range->afterLast = dup + lenInChars;
+                *doneMask |= maskTest;
+        }
+        return URI_TRUE;
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(MakeOwner)(URI_TYPE(Uri) * uri,
+                unsigned int * doneMask) {
+        URI_TYPE(PathSegment) * walker = uri->pathHead;
+        if (!URI_FUNC(MakeRangeOwner)(doneMask, URI_NORMALIZE_SCHEME,
+                                &(uri->scheme))
+                        || !URI_FUNC(MakeRangeOwner)(doneMask, URI_NORMALIZE_USER_INFO,
+                                &(uri->userInfo))
+                        || !URI_FUNC(MakeRangeOwner)(doneMask, URI_NORMALIZE_QUERY,
+                                &(uri->query))
+                        || !URI_FUNC(MakeRangeOwner)(doneMask, URI_NORMALIZE_FRAGMENT,
+                                &(uri->fragment))) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+
+        /* Host */
+        if ((*doneMask & URI_NORMALIZE_HOST) == 0) {
+                if ((uri->hostData.ip4 == NULL)
+                                && (uri->hostData.ip6 == NULL)) {
+                        if (uri->hostData.ipFuture.first != NULL) {
+                                /* IPvFuture */
+                                if (!URI_FUNC(MakeRangeOwner)(doneMask, URI_NORMALIZE_HOST,
+                                                &(uri->hostData.ipFuture))) {
+                                        return URI_FALSE; /* Raises malloc error */
+                                }
+                                uri->hostText.first = uri->hostData.ipFuture.first;
+                                uri->hostText.afterLast = uri->hostData.ipFuture.afterLast;
+                        } else if (uri->hostText.first != NULL) {
+                                /* Regname */
+                                if (!URI_FUNC(MakeRangeOwner)(doneMask, URI_NORMALIZE_HOST,
+                                                &(uri->hostText))) {
+                                        return URI_FALSE; /* Raises malloc error */
+                                }
+                        }
+                }
+        }
+
+        /* Path */
+        if ((*doneMask & URI_NORMALIZE_PATH) == 0) {
+                while (walker != NULL) {
+                        if (!URI_FUNC(MakeRangeOwner)(doneMask, 0, &(walker->text))) {
+                                /* Free allocations done so far and kill path */
+
+                                /* Kill path to one before walker (if any) */
+                                URI_TYPE(PathSegment) * ranger = uri->pathHead;
+                                while (ranger != walker) {
+                                        URI_TYPE(PathSegment) * const next = ranger->next;
+                                        if ((ranger->text.first != NULL)
+                                                        && (ranger->text.afterLast != NULL)
+                                                        && (ranger->text.afterLast > ranger->text.first)) {
+                                                free((URI_CHAR *)ranger->text.first);
+                                                free(ranger);
+                                        }
+                                        ranger = next;
+                                }
+
+                                /* Kill path from walker */
+                                while (walker != NULL) {
+                                        URI_TYPE(PathSegment) * const next = walker->next;
+                                        free(walker);
+                                        walker = next;
+                                }
+
+                                uri->pathHead = NULL;
+                                uri->pathTail = NULL;
+                                return URI_FALSE; /* Raises malloc error */
+                        }
+                        walker = walker->next;
+                }
+                *doneMask |= URI_NORMALIZE_PATH;
+        }
+
+        /* Port text, must come last so we don't have to undo that one if it fails. *
+         * Otherwise we would need and extra enum flag for it although the port      *
+         * cannot go unnormalized...                                                */
+        if (!URI_FUNC(MakeRangeOwner)(doneMask, 0, &(uri->portText))) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+
+        return URI_TRUE;
+}
+
+
+
+unsigned int URI_FUNC(NormalizeSyntaxMaskRequired)(const URI_TYPE(Uri) * uri) {
+        unsigned int res;
+#if defined(__GNUC__) && ((__GNUC__ > 4) \
+        || ((__GNUC__ == 4) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 2)))
+    /* Slower code that fixes a warning, not sure if this is a smart idea */
+        URI_TYPE(Uri) writeableClone;
+        memcpy(&writeableClone, uri, 1 * sizeof(URI_TYPE(Uri)));
+        URI_FUNC(NormalizeSyntaxEngine)(&writeableClone, 0, &res);
+#else
+        URI_FUNC(NormalizeSyntaxEngine)((URI_TYPE(Uri) *)uri, 0, &res);
+#endif
+        return res;
+}
+
+
+
+int URI_FUNC(NormalizeSyntaxEx)(URI_TYPE(Uri) * uri, unsigned int mask) {
+        return URI_FUNC(NormalizeSyntaxEngine)(uri, mask, NULL);
+}
+
+
+
+int URI_FUNC(NormalizeSyntax)(URI_TYPE(Uri) * uri) {
+        return URI_FUNC(NormalizeSyntaxEx)(uri, (unsigned int)-1);
+}
+
+
+
+static URI_INLINE int URI_FUNC(NormalizeSyntaxEngine)(URI_TYPE(Uri) * uri, unsigned int inMask, unsigned int * outMask) {
+        unsigned int doneMask = URI_NORMALIZED;
+        if (uri == NULL) {
+                if (outMask != NULL) {
+                        *outMask = URI_NORMALIZED;
+                        return URI_SUCCESS;
+                } else {
+                        return URI_ERROR_NULL;
+                }
+        }
+
+        if (outMask != NULL) {
+                /* Reset mask */
+                *outMask = URI_NORMALIZED;
+        } else if (inMask == URI_NORMALIZED) {
+                /* Nothing to do */
+                return URI_SUCCESS;
+        }
+
+        /* Scheme, host */
+        if (outMask != NULL) {
+                const UriBool normalizeScheme = URI_FUNC(ContainsUppercaseLetters)(
+                                uri->scheme.first, uri->scheme.afterLast);
+                const UriBool normalizeHostCase = URI_FUNC(ContainsUppercaseLetters)(
+                        uri->hostText.first, uri->hostText.afterLast);
+                if (normalizeScheme) {
+                        *outMask |= URI_NORMALIZE_SCHEME;
+                }
+
+                if (normalizeHostCase) {
+                        *outMask |= URI_NORMALIZE_HOST;
+                } else {
+                        const UriBool normalizeHostPrecent = URI_FUNC(ContainsUglyPercentEncoding)(
+                                        uri->hostText.first, uri->hostText.afterLast);
+                        if (normalizeHostPrecent) {
+                                *outMask |= URI_NORMALIZE_HOST;
+                        }
+                }
+        } else {
+                /* Scheme */
+                if ((inMask & URI_NORMALIZE_SCHEME) && (uri->scheme.first != NULL)) {
+                        if (uri->owner) {
+                                URI_FUNC(LowercaseInplace)(uri->scheme.first, uri->scheme.afterLast);
+                        } else {
+                                if (!URI_FUNC(LowercaseMalloc)(&(uri->scheme.first), &(uri->scheme.afterLast))) {
+                                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                                        return URI_ERROR_MALLOC;
+                                }
+                                doneMask |= URI_NORMALIZE_SCHEME;
+                        }
+                }
+
+                /* Host */
+                if (inMask & URI_NORMALIZE_HOST) {
+                        if (uri->hostData.ipFuture.first != NULL) {
+                                /* IPvFuture */
+                                if (uri->owner) {
+                                        URI_FUNC(LowercaseInplace)(uri->hostData.ipFuture.first,
+                                                        uri->hostData.ipFuture.afterLast);
+                                } else {
+                                        if (!URI_FUNC(LowercaseMalloc)(&(uri->hostData.ipFuture.first),
+                                                        &(uri->hostData.ipFuture.afterLast))) {
+                                                URI_FUNC(PreventLeakage)(uri, doneMask);
+                                                return URI_ERROR_MALLOC;
+                                        }
+                                        doneMask |= URI_NORMALIZE_HOST;
+                                }
+                                uri->hostText.first = uri->hostData.ipFuture.first;
+                                uri->hostText.afterLast = uri->hostData.ipFuture.afterLast;
+                        } else if ((uri->hostText.first != NULL)
+                                        && (uri->hostData.ip4 == NULL)
+                                        && (uri->hostData.ip6 == NULL)) {
+                                /* Regname */
+                                if (uri->owner) {
+                                        URI_FUNC(FixPercentEncodingInplace)(uri->hostText.first,
+                                                        &(uri->hostText.afterLast));
+                                } else {
+                                        if (!URI_FUNC(FixPercentEncodingMalloc)(
+                                                        &(uri->hostText.first),
+                                                        &(uri->hostText.afterLast))) {
+                                                URI_FUNC(PreventLeakage)(uri, doneMask);
+                                                return URI_ERROR_MALLOC;
+                                        }
+                                        doneMask |= URI_NORMALIZE_HOST;
+                                }
+
+                                URI_FUNC(LowercaseInplace)(uri->hostText.first,
+                                                uri->hostText.afterLast);
+                        }
+                }
+        }
+
+        /* User info */
+        if (outMask != NULL) {
+                const UriBool normalizeUserInfo = URI_FUNC(ContainsUglyPercentEncoding)(
+                        uri->userInfo.first, uri->userInfo.afterLast);
+                if (normalizeUserInfo) {
+                        *outMask |= URI_NORMALIZE_USER_INFO;
+                }
+        } else {
+                if ((inMask & URI_NORMALIZE_USER_INFO) && (uri->userInfo.first != NULL)) {
+                        if (uri->owner) {
+                                URI_FUNC(FixPercentEncodingInplace)(uri->userInfo.first, &(uri->userInfo.afterLast));
+                        } else {
+                                if (!URI_FUNC(FixPercentEncodingMalloc)(&(uri->userInfo.first),
+                                                &(uri->userInfo.afterLast))) {
+                                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                                        return URI_ERROR_MALLOC;
+                                }
+                                doneMask |= URI_NORMALIZE_USER_INFO;
+                        }
+                }
+        }
+
+        /* Path */
+        if (outMask != NULL) {
+                const URI_TYPE(PathSegment) * walker = uri->pathHead;
+                while (walker != NULL) {
+                        const URI_CHAR * const first = walker->text.first;
+                        const URI_CHAR * const afterLast = walker->text.afterLast;
+                        if ((first != NULL)
+                                        && (afterLast != NULL)
+                                        && (afterLast > first)
+                                        && (
+                                                (((afterLast - first) == 1)
+                                                        && (first[0] == _UT('.')))
+                                                ||
+                                                (((afterLast - first) == 2)
+                                                        && (first[0] == _UT('.'))
+                                                        && (first[1] == _UT('.')))
+                                                ||
+                                                URI_FUNC(ContainsUglyPercentEncoding)(first, afterLast)
+                                        )) {
+                                *outMask |= URI_NORMALIZE_PATH;
+                                break;
+                        }
+                        walker = walker->next;
+                }
+        } else if (inMask & URI_NORMALIZE_PATH) {
+                URI_TYPE(PathSegment) * walker;
+                const UriBool relative = ((uri->scheme.first == NULL)
+                                && !uri->absolutePath) ? URI_TRUE : URI_FALSE;
+
+                /* Fix percent-encoding for each segment */
+                walker = uri->pathHead;
+                if (uri->owner) {
+                        while (walker != NULL) {
+                                URI_FUNC(FixPercentEncodingInplace)(walker->text.first, &(walker->text.afterLast));
+                                walker = walker->next;
+                        }
+                } else {
+                        while (walker != NULL) {
+                                if (!URI_FUNC(FixPercentEncodingMalloc)(&(walker->text.first),
+                                                &(walker->text.afterLast))) {
+                                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                                        return URI_ERROR_MALLOC;
+                                }
+                                walker = walker->next;
+                        }
+                        doneMask |= URI_NORMALIZE_PATH;
+                }
+
+                /* 6.2.2.3 Path Segment Normalization */
+                if (!URI_FUNC(RemoveDotSegmentsEx)(uri, relative,
+                                (uri->owner == URI_TRUE)
+                                || ((doneMask & URI_NORMALIZE_PATH) != 0)
+                                )) {
+                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                        return URI_ERROR_MALLOC;
+                }
+                URI_FUNC(FixEmptyTrailSegment)(uri);
+        }
+
+        /* Query, fragment */
+        if (outMask != NULL) {
+                const UriBool normalizeQuery = URI_FUNC(ContainsUglyPercentEncoding)(
+                                uri->query.first, uri->query.afterLast);
+                const UriBool normalizeFragment = URI_FUNC(ContainsUglyPercentEncoding)(
+                                uri->fragment.first, uri->fragment.afterLast);
+                if (normalizeQuery) {
+                        *outMask |= URI_NORMALIZE_QUERY;
+                }
+
+                if (normalizeFragment) {
+                        *outMask |= URI_NORMALIZE_FRAGMENT;
+                }
+        } else {
+                /* Query */
+                if ((inMask & URI_NORMALIZE_QUERY) && (uri->query.first != NULL)) {
+                        if (uri->owner) {
+                                URI_FUNC(FixPercentEncodingInplace)(uri->query.first, &(uri->query.afterLast));
+                        } else {
+                                if (!URI_FUNC(FixPercentEncodingMalloc)(&(uri->query.first),
+                                                &(uri->query.afterLast))) {
+                                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                                        return URI_ERROR_MALLOC;
+                                }
+                                doneMask |= URI_NORMALIZE_QUERY;
+                        }
+                }
+
+                /* Fragment */
+                if ((inMask & URI_NORMALIZE_FRAGMENT) && (uri->fragment.first != NULL)) {
+                        if (uri->owner) {
+                                URI_FUNC(FixPercentEncodingInplace)(uri->fragment.first, &(uri->fragment.afterLast));
+                        } else {
+                                if (!URI_FUNC(FixPercentEncodingMalloc)(&(uri->fragment.first),
+                                                &(uri->fragment.afterLast))) {
+                                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                                        return URI_ERROR_MALLOC;
+                                }
+                                doneMask |= URI_NORMALIZE_FRAGMENT;
+                        }
+                }
+        }
+
+        /* Dup all not duped yet */
+        if ((outMask == NULL) && !uri->owner) {
+                if (!URI_FUNC(MakeOwner)(uri, &doneMask)) {
+                        URI_FUNC(PreventLeakage)(uri, doneMask);
+                        return URI_ERROR_MALLOC;
+                }
+                uri->owner = URI_TRUE;
+        }
+
+        return URI_SUCCESS;
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriNormalizeBase.c b/plugins/uriparser/UriNormalizeBase.c
new file mode 100644
index 0000000..bac5888
--- /dev/null
+++ b/plugins/uriparser/UriNormalizeBase.c
@@ -0,0 +1,119 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef URI_DOXYGEN
+# include "UriNormalizeBase.h"
+#endif
+
+
+
+UriBool uriIsUnreserved(int code) {
+        switch (code) {
+        case L'a': /* ALPHA */
+        case L'A':
+        case L'b':
+        case L'B':
+        case L'c':
+        case L'C':
+        case L'd':
+        case L'D':
+        case L'e':
+        case L'E':
+        case L'f':
+        case L'F':
+        case L'g':
+        case L'G':
+        case L'h':
+        case L'H':
+        case L'i':
+        case L'I':
+        case L'j':
+        case L'J':
+        case L'k':
+        case L'K':
+        case L'l':
+        case L'L':
+        case L'm':
+        case L'M':
+        case L'n':
+        case L'N':
+        case L'o':
+        case L'O':
+        case L'p':
+        case L'P':
+        case L'q':
+        case L'Q':
+        case L'r':
+        case L'R':
+        case L's':
+        case L'S':
+        case L't':
+        case L'T':
+        case L'u':
+        case L'U':
+        case L'v':
+        case L'V':
+        case L'w':
+        case L'W':
+        case L'x':
+        case L'X':
+        case L'y':
+        case L'Y':
+        case L'z':
+        case L'Z':
+        case L'0': /* DIGIT */
+        case L'1':
+        case L'2':
+        case L'3':
+        case L'4':
+        case L'5':
+        case L'6':
+        case L'7':
+        case L'8':
+        case L'9':
+        case L'-': /* "-" / "." / "_" / "~" */
+        case L'.':
+        case L'_':
+        case L'~':
+                return URI_TRUE;
+
+        default:
+                return URI_FALSE;
+        }
+}
diff --git a/plugins/uriparser/UriNormalizeBase.h b/plugins/uriparser/UriNormalizeBase.h
new file mode 100644
index 0000000..9f3abd5
--- /dev/null
+++ b/plugins/uriparser/UriNormalizeBase.h
@@ -0,0 +1,53 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef URI_NORMALIZE_BASE_H
+#define URI_NORMALIZE_BASE_H 1
+
+
+
+#include <uriparser/UriBase.h>
+
+
+
+UriBool uriIsUnreserved(int code);
+
+
+
+#endif /* URI_NORMALIZE_BASE_H */
diff --git a/plugins/uriparser/UriParse.c b/plugins/uriparser/UriParse.c
new file mode 100644
index 0000000..e3cdc68
--- /dev/null
+++ b/plugins/uriparser/UriParse.c
@@ -0,0 +1,2241 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file UriParse.c
+ * Holds the RFC 3986 %URI parsing implementation.
+ * NOTE: This source file includes itself twice.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriParse.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriParse.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include <uriparser/UriIp4.h>
+# include "UriCommon.h"
+# include "UriParseBase.h"
+#endif
+
+
+
+#define URI_SET_DIGIT \
+             _UT('0'): \
+        case _UT('1'): \
+        case _UT('2'): \
+        case _UT('3'): \
+        case _UT('4'): \
+        case _UT('5'): \
+        case _UT('6'): \
+        case _UT('7'): \
+        case _UT('8'): \
+        case _UT('9')
+
+#define URI_SET_HEX_LETTER_UPPER \
+             _UT('A'): \
+        case _UT('B'): \
+        case _UT('C'): \
+        case _UT('D'): \
+        case _UT('E'): \
+        case _UT('F')
+
+#define URI_SET_HEX_LETTER_LOWER \
+             _UT('a'): \
+        case _UT('b'): \
+        case _UT('c'): \
+        case _UT('d'): \
+        case _UT('e'): \
+        case _UT('f')
+
+#define URI_SET_HEXDIG \
+        URI_SET_DIGIT: \
+        case URI_SET_HEX_LETTER_UPPER: \
+        case URI_SET_HEX_LETTER_LOWER
+
+#define URI_SET_ALPHA \
+        URI_SET_HEX_LETTER_UPPER: \
+        case URI_SET_HEX_LETTER_LOWER: \
+        case _UT('g'): \
+        case _UT('G'): \
+        case _UT('h'): \
+        case _UT('H'): \
+        case _UT('i'): \
+        case _UT('I'): \
+        case _UT('j'): \
+        case _UT('J'): \
+        case _UT('k'): \
+        case _UT('K'): \
+        case _UT('l'): \
+        case _UT('L'): \
+        case _UT('m'): \
+        case _UT('M'): \
+        case _UT('n'): \
+        case _UT('N'): \
+        case _UT('o'): \
+        case _UT('O'): \
+        case _UT('p'): \
+        case _UT('P'): \
+        case _UT('q'): \
+        case _UT('Q'): \
+        case _UT('r'): \
+        case _UT('R'): \
+        case _UT('s'): \
+        case _UT('S'): \
+        case _UT('t'): \
+        case _UT('T'): \
+        case _UT('u'): \
+        case _UT('U'): \
+        case _UT('v'): \
+        case _UT('V'): \
+        case _UT('w'): \
+        case _UT('W'): \
+        case _UT('x'): \
+        case _UT('X'): \
+        case _UT('y'): \
+        case _UT('Y'): \
+        case _UT('z'): \
+        case _UT('Z')
+
+
+
+static const URI_CHAR * URI_FUNC(ParseAuthority)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseAuthorityTwo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseHexZero)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseHierPart)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseIpFutLoop)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseIpFutStopGo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseIpLit2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseIPv6address2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseMustBeSegmentNzNc)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseOwnHost)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseOwnHost2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseOwnHostUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseOwnHostUserInfoNz)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseOwnPortUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseOwnUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePartHelperTwo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePathAbsEmpty)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePathAbsNoLeadSlash)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePathRootless)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePchar)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePctEncoded)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePctSubUnres)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParsePort)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseQueryFrag)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseSegment)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseSegmentNz)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseSegmentNzNcOrScheme2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseUriReference)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseUriTail)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseUriTailTwo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+static const URI_CHAR * URI_FUNC(ParseZeroMoreSlashSegs)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+
+static UriBool URI_FUNC(OnExitOwnHost2)(URI_TYPE(ParserState) * state, const URI_CHAR * first);
+static UriBool URI_FUNC(OnExitOwnHostUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first);
+static UriBool URI_FUNC(OnExitOwnPortUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first);
+static UriBool URI_FUNC(OnExitSegmentNzNcOrScheme2)(URI_TYPE(ParserState) * state, const URI_CHAR * first);
+static void URI_FUNC(OnExitPartHelperTwo)(URI_TYPE(ParserState) * state);
+
+static void URI_FUNC(ResetParserState)(URI_TYPE(ParserState) * state);
+
+static UriBool URI_FUNC(PushPathSegment)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast);
+
+static void URI_FUNC(StopSyntax)(URI_TYPE(ParserState) * state, const URI_CHAR * errorPos);
+static void URI_FUNC(StopMalloc)(URI_TYPE(ParserState) * state);
+
+
+
+static URI_INLINE void URI_FUNC(StopSyntax)(URI_TYPE(ParserState) * state,
+                const URI_CHAR * errorPos) {
+        URI_FUNC(FreeUriMembers)(state->uri);
+        state->errorPos = errorPos;
+        state->errorCode = URI_ERROR_SYNTAX;
+}
+
+
+
+static URI_INLINE void URI_FUNC(StopMalloc)(URI_TYPE(ParserState) * state) {
+        URI_FUNC(FreeUriMembers)(state->uri);
+        state->errorPos = NULL;
+        state->errorCode = URI_ERROR_MALLOC;
+}
+
+
+
+/*
+ * [authority]-><[>[ipLit2][authorityTwo]
+ * [authority]->[ownHostUserInfoNz]
+ * [authority]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseAuthority)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                /* "" regname host */
+                state->uri->hostText.first = URI_FUNC(SafeToPointTo);
+                state->uri->hostText.afterLast = URI_FUNC(SafeToPointTo);
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('['):
+                {
+                        const URI_CHAR * const afterIpLit2
+                                        = URI_FUNC(ParseIpLit2)(state, first + 1, afterLast);
+                        if (afterIpLit2 == NULL) {
+                                return NULL;
+                        }
+                        state->uri->hostText.first = first + 1; /* HOST BEGIN */
+                        return URI_FUNC(ParseAuthorityTwo)(state, afterIpLit2, afterLast);
+                }
+
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                state->uri->userInfo.first = first; /* USERINFO BEGIN */
+                return URI_FUNC(ParseOwnHostUserInfoNz)(state, first, afterLast);
+
+        default:
+                /* "" regname host */
+                state->uri->hostText.first = URI_FUNC(SafeToPointTo);
+                state->uri->hostText.afterLast = URI_FUNC(SafeToPointTo);
+                return first;
+        }
+}
+
+
+
+/*
+ * [authorityTwo]-><:>[port]
+ * [authorityTwo]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseAuthorityTwo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT(':'):
+                {
+                        const URI_CHAR * const afterPort = URI_FUNC(ParsePort)(state, first + 1, afterLast);
+                        if (afterPort == NULL) {
+                                return NULL;
+                        }
+                        state->uri->portText.first = first + 1; /* PORT BEGIN */
+                        state->uri->portText.afterLast = afterPort; /* PORT END */
+                        return afterPort;
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [hexZero]->[HEXDIG][hexZero]
+ * [hexZero]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParseHexZero)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case URI_SET_HEXDIG:
+                return URI_FUNC(ParseHexZero)(state, first + 1, afterLast);
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [hierPart]->[pathRootless]
+ * [hierPart]-></>[partHelperTwo]
+ * [hierPart]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseHierPart)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return URI_FUNC(ParsePathRootless)(state, first, afterLast);
+
+        case _UT('/'):
+                return URI_FUNC(ParsePartHelperTwo)(state, first + 1, afterLast);
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [ipFutLoop]->[subDelims][ipFutStopGo]
+ * [ipFutLoop]->[unreserved][ipFutStopGo]
+ * [ipFutLoop]-><:>[ipFutStopGo]
+ */
+static const URI_CHAR * URI_FUNC(ParseIpFutLoop)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return URI_FUNC(ParseIpFutStopGo)(state, first + 1, afterLast);
+
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+}
+
+
+
+/*
+ * [ipFutStopGo]->[ipFutLoop]
+ * [ipFutStopGo]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParseIpFutStopGo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return URI_FUNC(ParseIpFutLoop)(state, first, afterLast);
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [ipFuture]-><v>[HEXDIG][hexZero]<.>[ipFutLoop]
+ */
+static const URI_CHAR * URI_FUNC(ParseIpFuture)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        /*
+        First character has already been
+        checked before entering this rule.
+
+        switch (*first) {
+        case _UT('v'):
+        */
+                if (first + 1 >= afterLast) {
+                        URI_FUNC(StopSyntax)(state, first + 1);
+                        return NULL;
+                }
+
+                switch (first[1]) {
+                case URI_SET_HEXDIG:
+                        {
+                                const URI_CHAR * afterIpFutLoop;
+                                const URI_CHAR * const afterHexZero
+                                                = URI_FUNC(ParseHexZero)(state, first + 2, afterLast);
+                                if (afterHexZero == NULL) {
+                                        return NULL;
+                                }
+                                if ((afterHexZero >= afterLast)
+                                                || (*afterHexZero != _UT('.'))) {
+                                        URI_FUNC(StopSyntax)(state, afterHexZero);
+                                        return NULL;
+                                }
+                                state->uri->hostText.first = first; /* HOST BEGIN */
+                                state->uri->hostData.ipFuture.first = first; /* IPFUTURE BEGIN */
+                                afterIpFutLoop = URI_FUNC(ParseIpFutLoop)(state, afterHexZero + 1, afterLast);
+                                if (afterIpFutLoop == NULL) {
+                                        return NULL;
+                                }
+                                state->uri->hostText.afterLast = afterIpFutLoop; /* HOST END */
+                                state->uri->hostData.ipFuture.afterLast = afterIpFutLoop; /* IPFUTURE END */
+                                return afterIpFutLoop;
+                        }
+
+                default:
+                        URI_FUNC(StopSyntax)(state, first + 1);
+                        return NULL;
+                }
+
+        /*
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+        */
+}
+
+
+
+/*
+ * [ipLit2]->[ipFuture]<]>
+ * [ipLit2]->[IPv6address2]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseIpLit2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('v'):
+                {
+                        const URI_CHAR * const afterIpFuture
+                                        = URI_FUNC(ParseIpFuture)(state, first, afterLast);
+                        if (afterIpFuture == NULL) {
+                                return NULL;
+                        }
+                        if ((afterIpFuture >= afterLast)
+                                        || (*afterIpFuture != _UT(']'))) {
+                                URI_FUNC(StopSyntax)(state, first);
+                                return NULL;
+                        }
+                        return afterIpFuture + 1;
+                }
+
+        case _UT(':'):
+        case _UT(']'):
+        case URI_SET_HEXDIG:
+                state->uri->hostData.ip6 = malloc(1 * sizeof(UriIp6)); /* Freed when stopping on parse error */
+                if (state->uri->hostData.ip6 == NULL) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return URI_FUNC(ParseIPv6address2)(state, first, afterLast);
+
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+}
+
+
+
+/*
+ * [IPv6address2]->..<]>
+ */
+static const URI_CHAR * URI_FUNC(ParseIPv6address2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        int zipperEver = 0;
+        int quadsDone = 0;
+        int digitCount = 0;
+        unsigned char digitHistory[4];
+        int ip4OctetsDone = 0;
+
+        unsigned char quadsAfterZipper[14];
+        int quadsAfterZipperCount = 0;
+
+
+        for (;;) {
+                if (first >= afterLast) {
+                        URI_FUNC(StopSyntax)(state, first);
+                        return NULL;
+                }
+
+                /* Inside IPv4 part? */
+                if (ip4OctetsDone > 0) {
+                        /* Eat rest of IPv4 address */
+                        for (;;) {
+                                switch (*first) {
+                                case URI_SET_DIGIT:
+                                        if (digitCount == 4) {
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        }
+                                        digitHistory[digitCount++] = (unsigned char)(9 + *first - _UT('9'));
+                                        break;
+
+                                case _UT('.'):
+                                        if ((ip4OctetsDone == 4) /* NOTE! */
+                                                        || (digitCount == 0)
+                                                        || (digitCount == 4)) {
+                                                /* Invalid digit or octet count */
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        } else if ((digitCount > 1)
+                                                        && (digitHistory[0] == 0)) {
+                                                /* Leading zero */
+                                                URI_FUNC(StopSyntax)(state, first - digitCount);
+                                                return NULL;
+                                        } else if ((digitCount > 2)
+                                                        && (digitHistory[1] == 0)) {
+                                                /* Leading zero */
+                                                URI_FUNC(StopSyntax)(state, first - digitCount + 1);
+                                                return NULL;
+                                        } else if ((digitCount == 3)
+                                                        && (100 * digitHistory[0]
+                                                                + 10 * digitHistory[1]
+                                                                + digitHistory[2] > 255)) {
+                                                /* Octet value too large */
+                                                if (digitHistory[0] > 2) {
+                                                        URI_FUNC(StopSyntax)(state, first - 3);
+                                                } else if (digitHistory[1] > 5) {
+                                                        URI_FUNC(StopSyntax)(state, first - 2);
+                                                } else {
+                                                        URI_FUNC(StopSyntax)(state, first - 1);
+                                                }
+                                                return NULL;
+                                        }
+
+                                        /* Copy IPv4 octet */
+                                        state->uri->hostData.ip6->data[16 - 4 + ip4OctetsDone] = uriGetOctetValue(digitHistory, digitCount);
+                                        digitCount = 0;
+                                        ip4OctetsDone++;
+                                        break;
+
+                                case _UT(']'):
+                                        if ((ip4OctetsDone != 3) /* NOTE! */
+                                                        || (digitCount == 0)
+                                                        || (digitCount == 4)) {
+                                                /* Invalid digit or octet count */
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        } else if ((digitCount > 1)
+                                                        && (digitHistory[0] == 0)) {
+                                                /* Leading zero */
+                                                URI_FUNC(StopSyntax)(state, first - digitCount);
+                                                return NULL;
+                                        } else if ((digitCount > 2)
+                                                        && (digitHistory[1] == 0)) {
+                                                /* Leading zero */
+                                                URI_FUNC(StopSyntax)(state, first - digitCount + 1);
+                                                return NULL;
+                                        } else if ((digitCount == 3)
+                                                        && (100 * digitHistory[0]
+                                                                + 10 * digitHistory[1]
+                                                                + digitHistory[2] > 255)) {
+                                                /* Octet value too large */
+                                                if (digitHistory[0] > 2) {
+                                                        URI_FUNC(StopSyntax)(state, first - 3);
+                                                } else if (digitHistory[1] > 5) {
+                                                        URI_FUNC(StopSyntax)(state, first - 2);
+                                                } else {
+                                                        URI_FUNC(StopSyntax)(state, first - 1);
+                                                }
+                                                return NULL;
+                                        }
+
+                                        state->uri->hostText.afterLast = first; /* HOST END */
+
+                                        /* Copy missing quads right before IPv4 */
+                                        memcpy(state->uri->hostData.ip6->data + 16 - 4 - 2 * quadsAfterZipperCount,
+                                                                quadsAfterZipper, 2 * quadsAfterZipperCount);
+
+                                        /* Copy last IPv4 octet */
+                                        state->uri->hostData.ip6->data[16 - 4 + 3] = uriGetOctetValue(digitHistory, digitCount);
+
+                                        return first + 1;
+
+                                default:
+                                        URI_FUNC(StopSyntax)(state, first);
+                                        return NULL;
+                                }
+                                first++;
+                        }
+                } else {
+                        /* Eat while no dot in sight */
+                        int letterAmong = 0;
+                        int walking = 1;
+                        do {
+                                switch (*first) {
+                                case URI_SET_HEX_LETTER_LOWER:
+                                        letterAmong = 1;
+                                        if (digitCount == 4) {
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        }
+                                        digitHistory[digitCount] = (unsigned char)(15 + *first - _UT('f'));
+                                        digitCount++;
+                                        break;
+
+                                case URI_SET_HEX_LETTER_UPPER:
+                                        letterAmong = 1;
+                                        if (digitCount == 4) {
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        }
+                                        digitHistory[digitCount] = (unsigned char)(15 + *first - _UT('F'));
+                                        digitCount++;
+                                        break;
+
+                                case URI_SET_DIGIT:
+                                        if (digitCount == 4) {
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        }
+                                        digitHistory[digitCount] = (unsigned char)(9 + *first - _UT('9'));
+                                        digitCount++;
+                                        break;
+
+                                case _UT(':'):
+                                        {
+                                                int setZipper = 0;
+
+                                                if (digitCount > 0) {
+                                                        if (zipperEver) {
+                                                                uriWriteQuadToDoubleByte(digitHistory, digitCount, quadsAfterZipper + 2 * quadsAfterZipperCount);
+                                                                quadsAfterZipperCount++;
+                                                        } else {
+                                                                uriWriteQuadToDoubleByte(digitHistory, digitCount, state->uri->hostData.ip6->data + 2 * quadsDone);
+                                                        }
+                                                        quadsDone++;
+                                                        digitCount = 0;
+                                                }
+                                                letterAmong = 0;
+
+                                                /* Too many quads? */
+                                                if (quadsDone >= 8 - zipperEver) {
+                                                        URI_FUNC(StopSyntax)(state, first);
+                                                        return NULL;
+                                                }
+
+                                                /* "::"? */
+                                                if (first + 1 >= afterLast) {
+                                                        URI_FUNC(StopSyntax)(state, first + 1);
+                                                        return NULL;
+                                                }
+                                                if (first[1] == _UT(':')) {
+                                                        const int resetOffset = 2 * (quadsDone + (digitCount > 0));
+
+                                                        first++;
+                                                        if (zipperEver) {
+                                                                URI_FUNC(StopSyntax)(state, first);
+                                                                return NULL; /* "::.+::" */
+                                                        }
+
+                                                        /* Zero everything after zipper */
+                                                        memset(state->uri->hostData.ip6->data + resetOffset, 0, 16 - resetOffset);
+                                                        setZipper = 1;
+
+                                                        /* ":::+"? */
+                                                        if (first + 1 >= afterLast) {
+                                                                URI_FUNC(StopSyntax)(state, first + 1);
+                                                                return NULL; /* No ']' yet */
+                                                        }
+                                                        if (first[1] == _UT(':')) {
+                                                                URI_FUNC(StopSyntax)(state, first + 1);
+                                                                return NULL; /* ":::+ "*/
+                                                        }
+                                                }
+
+                                                if (setZipper) {
+                                                        zipperEver = 1;
+                                                }
+                                        }
+                                        break;
+
+                                case _UT('.'):
+                                        if ((quadsDone > 6) /* NOTE */
+                                                        || (!zipperEver && (quadsDone < 6))
+                                                        || letterAmong
+                                                        || (digitCount == 0)
+                                                        || (digitCount == 4)) {
+                                                /* Invalid octet before */
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        } else if ((digitCount > 1)
+                                                        && (digitHistory[0] == 0)) {
+                                                /* Leading zero */
+                                                URI_FUNC(StopSyntax)(state, first - digitCount);
+                                                return NULL;
+                                        } else if ((digitCount > 2)
+                                                        && (digitHistory[1] == 0)) {
+                                                /* Leading zero */
+                                                URI_FUNC(StopSyntax)(state, first - digitCount + 1);
+                                                return NULL;
+                                        } else if ((digitCount == 3)
+                                                        && (100 * digitHistory[0]
+                                                                + 10 * digitHistory[1]
+                                                                + digitHistory[2] > 255)) {
+                                                /* Octet value too large */
+                                                if (digitHistory[0] > 2) {
+                                                        URI_FUNC(StopSyntax)(state, first - 3);
+                                                } else if (digitHistory[1] > 5) {
+                                                        URI_FUNC(StopSyntax)(state, first - 2);
+                                                } else {
+                                                        URI_FUNC(StopSyntax)(state, first - 1);
+                                                }
+                                                return NULL;
+                                        }
+
+                                        /* Copy first IPv4 octet */
+                                        state->uri->hostData.ip6->data[16 - 4] = uriGetOctetValue(digitHistory, digitCount);
+                                        digitCount = 0;
+
+                                        /* Switch over to IPv4 loop */
+                                        ip4OctetsDone = 1;
+                                        walking = 0;
+                                        break;
+
+                                case _UT(']'):
+                                        /* Too little quads? */
+                                        if (!zipperEver && !((quadsDone == 7) && (digitCount > 0))) {
+                                                URI_FUNC(StopSyntax)(state, first);
+                                                return NULL;
+                                        }
+
+                                        if (digitCount > 0) {
+                                                if (zipperEver) {
+                                                        uriWriteQuadToDoubleByte(digitHistory, digitCount, quadsAfterZipper + 2 * quadsAfterZipperCount);
+                                                        quadsAfterZipperCount++;
+                                                } else {
+                                                        uriWriteQuadToDoubleByte(digitHistory, digitCount, state->uri->hostData.ip6->data + 2 * quadsDone);
+                                                }
+                                                /*
+                                                quadsDone++;
+                                                digitCount = 0;
+                                                */
+                                        }
+
+                                        /* Copy missing quads to the end */
+                                        memcpy(state->uri->hostData.ip6->data + 16 - 2 * quadsAfterZipperCount,
+                                                                quadsAfterZipper, 2 * quadsAfterZipperCount);
+
+                                        state->uri->hostText.afterLast = first; /* HOST END */
+                                        return first + 1; /* Fine */
+
+                                default:
+                                        URI_FUNC(StopSyntax)(state, first);
+                                        return NULL;
+                                }
+                                first++;
+
+                                if (first >= afterLast) {
+                                        URI_FUNC(StopSyntax)(state, first);
+                                        return NULL; /* No ']' yet */
+                                }
+                        } while (walking);
+                }
+        }
+}
+
+
+
+/*
+ * [mustBeSegmentNzNc]->[pctEncoded][mustBeSegmentNzNc]
+ * [mustBeSegmentNzNc]->[subDelims][mustBeSegmentNzNc]
+ * [mustBeSegmentNzNc]->[unreserved][mustBeSegmentNzNc]
+ * [mustBeSegmentNzNc]->[uriTail] // can take <NULL>
+ * [mustBeSegmentNzNc]-></>[segment][zeroMoreSlashSegs][uriTail]
+ * [mustBeSegmentNzNc]-><@>[mustBeSegmentNzNc]
+ */
+static const URI_CHAR * URI_FUNC(ParseMustBeSegmentNzNc)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                if (!URI_FUNC(PushPathSegment)(state, state->uri->scheme.first, first)) { /* SEGMENT BOTH */
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                state->uri->scheme.first = NULL; /* Not a scheme, reset */
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('%'):
+                {
+                        const URI_CHAR * const afterPctEncoded
+                                        = URI_FUNC(ParsePctEncoded)(state, first, afterLast);
+                        if (afterPctEncoded == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseMustBeSegmentNzNc)(state, afterPctEncoded, afterLast);
+                }
+
+        case _UT('@'):
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('+'):
+        case _UT('='):
+        case _UT('-'):
+        case _UT('.'):
+        case _UT('_'):
+        case _UT('~'):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return URI_FUNC(ParseMustBeSegmentNzNc)(state, first + 1, afterLast);
+
+        case _UT('/'):
+                {
+                        const URI_CHAR * afterZeroMoreSlashSegs;
+                        const URI_CHAR * afterSegment;
+                        if (!URI_FUNC(PushPathSegment)(state, state->uri->scheme.first, first)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        state->uri->scheme.first = NULL; /* Not a scheme, reset */
+                        afterSegment = URI_FUNC(ParseSegment)(state, first + 1, afterLast);
+                        if (afterSegment == NULL) {
+                                return NULL;
+                        }
+                        if (!URI_FUNC(PushPathSegment)(state, first + 1, afterSegment)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        afterZeroMoreSlashSegs
+                                        = URI_FUNC(ParseZeroMoreSlashSegs)(state, afterSegment, afterLast);
+                        if (afterZeroMoreSlashSegs == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseUriTail)(state, afterZeroMoreSlashSegs, afterLast);
+                }
+
+        default:
+                if (!URI_FUNC(PushPathSegment)(state, state->uri->scheme.first, first)) { /* SEGMENT BOTH */
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                state->uri->scheme.first = NULL; /* Not a scheme, reset */
+                return URI_FUNC(ParseUriTail)(state, first, afterLast);
+        }
+}
+
+
+
+/*
+ * [ownHost]-><[>[ipLit2][authorityTwo]
+ * [ownHost]->[ownHost2] // can take <NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseOwnHost)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('['):
+                {
+                        const URI_CHAR * const afterIpLit2
+                                        = URI_FUNC(ParseIpLit2)(state, first + 1, afterLast);
+                        if (afterIpLit2 == NULL) {
+                                return NULL;
+                        }
+                        state->uri->hostText.first = first + 1; /* HOST BEGIN */
+                        return URI_FUNC(ParseAuthorityTwo)(state, afterIpLit2, afterLast);
+                }
+
+        default:
+                return URI_FUNC(ParseOwnHost2)(state, first, afterLast);
+        }
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(OnExitOwnHost2)(URI_TYPE(ParserState) * state, const URI_CHAR * first) {
+        state->uri->hostText.afterLast = first; /* HOST END */
+
+        /* Valid IPv4 or just a regname? */
+        state->uri->hostData.ip4 = malloc(1 * sizeof(UriIp4)); /* Freed when stopping on parse error */
+        if (state->uri->hostData.ip4 == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+        if (URI_FUNC(ParseIpFourAddress)(state->uri->hostData.ip4->data,
+                        state->uri->hostText.first, state->uri->hostText.afterLast)) {
+                /* Not IPv4 */
+                free(state->uri->hostData.ip4);
+                state->uri->hostData.ip4 = NULL;
+        }
+        return URI_TRUE; /* Success */
+}
+
+
+
+/*
+ * [ownHost2]->[authorityTwo] // can take <NULL>
+ * [ownHost2]->[pctSubUnres][ownHost2]
+ */
+static const URI_CHAR * URI_FUNC(ParseOwnHost2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                if (!URI_FUNC(OnExitOwnHost2)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                {
+                        const URI_CHAR * const afterPctSubUnres
+                                        = URI_FUNC(ParsePctSubUnres)(state, first, afterLast);
+                        if (afterPctSubUnres == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseOwnHost2)(state, afterPctSubUnres, afterLast);
+                }
+
+        default:
+                if (!URI_FUNC(OnExitOwnHost2)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return URI_FUNC(ParseAuthorityTwo)(state, first, afterLast);
+        }
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(OnExitOwnHostUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first) {
+        state->uri->hostText.first = state->uri->userInfo.first; /* Host instead of userInfo, update */
+        state->uri->userInfo.first = NULL; /* Not a userInfo, reset */
+        state->uri->hostText.afterLast = first; /* HOST END */
+
+        /* Valid IPv4 or just a regname? */
+        state->uri->hostData.ip4 = malloc(1 * sizeof(UriIp4)); /* Freed when stopping on parse error */
+        if (state->uri->hostData.ip4 == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+        if (URI_FUNC(ParseIpFourAddress)(state->uri->hostData.ip4->data,
+                        state->uri->hostText.first, state->uri->hostText.afterLast)) {
+                /* Not IPv4 */
+                free(state->uri->hostData.ip4);
+                state->uri->hostData.ip4 = NULL;
+        }
+        return URI_TRUE; /* Success */
+}
+
+
+
+/*
+ * [ownHostUserInfo]->[ownHostUserInfoNz]
+ * [ownHostUserInfo]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseOwnHostUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                if (!URI_FUNC(OnExitOwnHostUserInfo)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return URI_FUNC(ParseOwnHostUserInfoNz)(state, first, afterLast);
+
+        default:
+                if (!URI_FUNC(OnExitOwnHostUserInfo)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return first;
+        }
+}
+
+
+
+/*
+ * [ownHostUserInfoNz]->[pctSubUnres][ownHostUserInfo]
+ * [ownHostUserInfoNz]-><:>[ownPortUserInfo]
+ * [ownHostUserInfoNz]-><@>[ownHost]
+ */
+static const URI_CHAR * URI_FUNC(ParseOwnHostUserInfoNz)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                {
+                        const URI_CHAR * const afterPctSubUnres
+                                        = URI_FUNC(ParsePctSubUnres)(state, first, afterLast);
+                        if (afterPctSubUnres == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseOwnHostUserInfo)(state, afterPctSubUnres, afterLast);
+                }
+
+        case _UT(':'):
+                state->uri->hostText.afterLast = first; /* HOST END */
+                state->uri->portText.first = first + 1; /* PORT BEGIN */
+                return URI_FUNC(ParseOwnPortUserInfo)(state, first + 1, afterLast);
+
+        case _UT('@'):
+                state->uri->userInfo.afterLast = first; /* USERINFO END */
+                state->uri->hostText.first = first + 1; /* HOST BEGIN */
+                return URI_FUNC(ParseOwnHost)(state, first + 1, afterLast);
+
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(OnExitOwnPortUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first) {
+        state->uri->hostText.first = state->uri->userInfo.first; /* Host instead of userInfo, update */
+        state->uri->userInfo.first = NULL; /* Not a userInfo, reset */
+        state->uri->portText.afterLast = first; /* PORT END */
+
+        /* Valid IPv4 or just a regname? */
+        state->uri->hostData.ip4 = malloc(1 * sizeof(UriIp4)); /* Freed when stopping on parse error */
+        if (state->uri->hostData.ip4 == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+        if (URI_FUNC(ParseIpFourAddress)(state->uri->hostData.ip4->data,
+                        state->uri->hostText.first, state->uri->hostText.afterLast)) {
+                /* Not IPv4 */
+                free(state->uri->hostData.ip4);
+                state->uri->hostData.ip4 = NULL;
+        }
+        return URI_TRUE; /* Success */
+}
+
+
+
+/*
+ * [ownPortUserInfo]->[ALPHA][ownUserInfo]
+ * [ownPortUserInfo]->[DIGIT][ownPortUserInfo]
+ * [ownPortUserInfo]-><.>[ownUserInfo]
+ * [ownPortUserInfo]-><_>[ownUserInfo]
+ * [ownPortUserInfo]-><~>[ownUserInfo]
+ * [ownPortUserInfo]-><->[ownUserInfo]
+ * [ownPortUserInfo]->[subDelims][ownUserInfo]
+ * [ownPortUserInfo]->[pctEncoded][ownUserInfo]
+ * [ownPortUserInfo]-><:>[ownUserInfo]
+ * [ownPortUserInfo]-><@>[ownHost]
+ * [ownPortUserInfo]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParseOwnPortUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                if (!URI_FUNC(OnExitOwnPortUserInfo)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return afterLast;
+        }
+
+        switch (*first) {
+        /* begin sub-delims */
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('\''):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('*'):
+        case _UT('+'):
+        case _UT(','):
+        case _UT(';'):
+        case _UT('='):
+        /* end sub-delims */
+        /* begin unreserved (except alpha and digit) */
+        case _UT('-'):
+        case _UT('.'):
+        case _UT('_'):
+        case _UT('~'):
+        /* end unreserved (except alpha and digit) */
+        case _UT(':'):
+        case URI_SET_ALPHA:
+                state->uri->hostText.afterLast = NULL; /* Not a host, reset */
+                state->uri->portText.first = NULL; /* Not a port, reset */
+                return URI_FUNC(ParseOwnUserInfo)(state, first + 1, afterLast);
+
+        case URI_SET_DIGIT:
+                return URI_FUNC(ParseOwnPortUserInfo)(state, first + 1, afterLast);
+
+        case _UT('%'):
+                state->uri->portText.first = NULL; /* Not a port, reset */
+                {
+                        const URI_CHAR * const afterPct
+                                        = URI_FUNC(ParsePctEncoded)(state, first, afterLast);
+                        if (afterPct == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseOwnUserInfo)(state, afterPct, afterLast);
+                }
+
+        case _UT('@'):
+                state->uri->hostText.afterLast = NULL; /* Not a host, reset */
+                state->uri->portText.first = NULL; /* Not a port, reset */
+                state->uri->userInfo.afterLast = first; /* USERINFO END */
+                state->uri->hostText.first = first + 1; /* HOST BEGIN */
+                return URI_FUNC(ParseOwnHost)(state, first + 1, afterLast);
+
+        default:
+                if (!URI_FUNC(OnExitOwnPortUserInfo)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return first;
+        }
+}
+
+
+
+/*
+ * [ownUserInfo]->[pctSubUnres][ownUserInfo]
+ * [ownUserInfo]-><:>[ownUserInfo]
+ * [ownUserInfo]-><@>[ownHost]
+ */
+static const URI_CHAR * URI_FUNC(ParseOwnUserInfo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                {
+                        const URI_CHAR * const afterPctSubUnres
+                                        = URI_FUNC(ParsePctSubUnres)(state, first, afterLast);
+                        if (afterPctSubUnres == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseOwnUserInfo)(state, afterPctSubUnres, afterLast);
+                }
+
+        case _UT(':'):
+                return URI_FUNC(ParseOwnUserInfo)(state, first + 1, afterLast);
+
+        case _UT('@'):
+                /* SURE */
+                state->uri->userInfo.afterLast = first; /* USERINFO END */
+                state->uri->hostText.first = first + 1; /* HOST BEGIN */
+                return URI_FUNC(ParseOwnHost)(state, first + 1, afterLast);
+
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+}
+
+
+
+static URI_INLINE void URI_FUNC(OnExitPartHelperTwo)(URI_TYPE(ParserState) * state) {
+        state->uri->absolutePath = URI_TRUE;
+}
+
+
+
+/*
+ * [partHelperTwo]->[pathAbsNoLeadSlash] // can take <NULL>
+ * [partHelperTwo]-></>[authority][pathAbsEmpty]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParsePartHelperTwo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(OnExitPartHelperTwo)(state);
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('/'):
+                {
+                        const URI_CHAR * const afterAuthority
+                                        = URI_FUNC(ParseAuthority)(state, first + 1, afterLast);
+                        const URI_CHAR * afterPathAbsEmpty;
+                        if (afterAuthority == NULL) {
+                                return NULL;
+                        }
+                        afterPathAbsEmpty = URI_FUNC(ParsePathAbsEmpty)(state, afterAuthority, afterLast);
+
+                        URI_FUNC(FixEmptyTrailSegment)(state->uri);
+
+                        return afterPathAbsEmpty;
+                }
+
+        default:
+                URI_FUNC(OnExitPartHelperTwo)(state);
+                return URI_FUNC(ParsePathAbsNoLeadSlash)(state, first, afterLast);
+        }
+}
+
+
+
+/*
+ * [pathAbsEmpty]-></>[segment][pathAbsEmpty]
+ * [pathAbsEmpty]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParsePathAbsEmpty)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('/'):
+                {
+                        const URI_CHAR * const afterSegment
+                                        = URI_FUNC(ParseSegment)(state, first + 1, afterLast);
+                        if (afterSegment == NULL) {
+                                return NULL;
+                        }
+                        if (!URI_FUNC(PushPathSegment)(state, first + 1, afterSegment)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        return URI_FUNC(ParsePathAbsEmpty)(state, afterSegment, afterLast);
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [pathAbsNoLeadSlash]->[segmentNz][zeroMoreSlashSegs]
+ * [pathAbsNoLeadSlash]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParsePathAbsNoLeadSlash)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                {
+                        const URI_CHAR * const afterSegmentNz
+                                        = URI_FUNC(ParseSegmentNz)(state, first, afterLast);
+                        if (afterSegmentNz == NULL) {
+                                return NULL;
+                        }
+                        if (!URI_FUNC(PushPathSegment)(state, first, afterSegmentNz)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseZeroMoreSlashSegs)(state, afterSegmentNz, afterLast);
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [pathRootless]->[segmentNz][zeroMoreSlashSegs]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParsePathRootless)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        const URI_CHAR * const afterSegmentNz
+                        = URI_FUNC(ParseSegmentNz)(state, first, afterLast);
+        if (afterSegmentNz == NULL) {
+                return NULL;
+        } else {
+                if (!URI_FUNC(PushPathSegment)(state, first, afterSegmentNz)) { /* SEGMENT BOTH */
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+        }
+        return URI_FUNC(ParseZeroMoreSlashSegs)(state, afterSegmentNz, afterLast);
+}
+
+
+
+/*
+ * [pchar]->[pctEncoded]
+ * [pchar]->[subDelims]
+ * [pchar]->[unreserved]
+ * [pchar]-><:>
+ * [pchar]-><@>
+ */
+static const URI_CHAR * URI_FUNC(ParsePchar)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('%'):
+                return URI_FUNC(ParsePctEncoded)(state, first, afterLast);
+
+        case _UT(':'):
+        case _UT('@'):
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('+'):
+        case _UT('='):
+        case _UT('-'):
+        case _UT('.'):
+        case _UT('_'):
+        case _UT('~'):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return first + 1;
+
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+}
+
+
+
+/*
+ * [pctEncoded]-><%>[HEXDIG][HEXDIG]
+ */
+static const URI_CHAR * URI_FUNC(ParsePctEncoded)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        /*
+        First character has already been
+        checked before entering this rule.
+
+        switch (*first) {
+        case _UT('%'):
+        */
+                if (first + 1 >= afterLast) {
+                        URI_FUNC(StopSyntax)(state, first + 1);
+                        return NULL;
+                }
+
+                switch (first[1]) {
+                case URI_SET_HEXDIG:
+                        if (first + 2 >= afterLast) {
+                                URI_FUNC(StopSyntax)(state, first + 2);
+                                return NULL;
+                        }
+
+                        switch (first[2]) {
+                        case URI_SET_HEXDIG:
+                                return first + 3;
+
+                        default:
+                                URI_FUNC(StopSyntax)(state, first + 2);
+                                return NULL;
+                        }
+
+                default:
+                        URI_FUNC(StopSyntax)(state, first + 1);
+                        return NULL;
+                }
+
+        /*
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+        */
+}
+
+
+
+/*
+ * [pctSubUnres]->[pctEncoded]
+ * [pctSubUnres]->[subDelims]
+ * [pctSubUnres]->[unreserved]
+ */
+static const URI_CHAR * URI_FUNC(ParsePctSubUnres)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+
+        switch (*first) {
+        case _UT('%'):
+                return URI_FUNC(ParsePctEncoded)(state, first, afterLast);
+
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('+'):
+        case _UT('='):
+        case _UT('-'):
+        case _UT('.'):
+        case _UT('_'):
+        case _UT('~'):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                return first + 1;
+
+        default:
+                URI_FUNC(StopSyntax)(state, first);
+                return NULL;
+        }
+}
+
+
+
+/*
+ * [port]->[DIGIT][port]
+ * [port]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParsePort)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case URI_SET_DIGIT:
+                return URI_FUNC(ParsePort)(state, first + 1, afterLast);
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [queryFrag]->[pchar][queryFrag]
+ * [queryFrag]-></>[queryFrag]
+ * [queryFrag]-><?>[queryFrag]
+ * [queryFrag]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParseQueryFrag)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                {
+                        const URI_CHAR * const afterPchar
+                                        = URI_FUNC(ParsePchar)(state, first, afterLast);
+                        if (afterPchar == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseQueryFrag)(state, afterPchar, afterLast);
+                }
+
+        case _UT('/'):
+        case _UT('?'):
+                return URI_FUNC(ParseQueryFrag)(state, first + 1, afterLast);
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [segment]->[pchar][segment]
+ * [segment]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParseSegment)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('%'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('-'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT('.'):
+        case _UT(':'):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('\''):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('+'):
+        case _UT('='):
+        case URI_SET_DIGIT:
+        case URI_SET_ALPHA:
+                {
+                        const URI_CHAR * const afterPchar
+                                        = URI_FUNC(ParsePchar)(state, first, afterLast);
+                        if (afterPchar == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseSegment)(state, afterPchar, afterLast);
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [segmentNz]->[pchar][segment]
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseSegmentNz)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        const URI_CHAR * const afterPchar
+                        = URI_FUNC(ParsePchar)(state, first, afterLast);
+        if (afterPchar == NULL) {
+                return NULL;
+        }
+        return URI_FUNC(ParseSegment)(state, afterPchar, afterLast);
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(OnExitSegmentNzNcOrScheme2)(URI_TYPE(ParserState) * state, const URI_CHAR * first) {
+        if (!URI_FUNC(PushPathSegment)(state, state->uri->scheme.first, first)) { /* SEGMENT BOTH */
+                return URI_FALSE; /* Raises malloc error*/
+        }
+        state->uri->scheme.first = NULL; /* Not a scheme, reset */
+        return URI_TRUE; /* Success */
+}
+
+
+
+/*
+ * [segmentNzNcOrScheme2]->[ALPHA][segmentNzNcOrScheme2]
+ * [segmentNzNcOrScheme2]->[DIGIT][segmentNzNcOrScheme2]
+ * [segmentNzNcOrScheme2]->[pctEncoded][mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]->[uriTail] // can take <NULL>
+ * [segmentNzNcOrScheme2]-><!>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><$>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><&>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><(>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><)>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><*>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><,>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><.>[segmentNzNcOrScheme2]
+ * [segmentNzNcOrScheme2]-></>[segment][zeroMoreSlashSegs][uriTail]
+ * [segmentNzNcOrScheme2]-><:>[hierPart][uriTail]
+ * [segmentNzNcOrScheme2]-><;>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><@>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><_>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><~>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><+>[segmentNzNcOrScheme2]
+ * [segmentNzNcOrScheme2]-><=>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><'>[mustBeSegmentNzNc]
+ * [segmentNzNcOrScheme2]-><->[segmentNzNcOrScheme2]
+ */
+static const URI_CHAR * URI_FUNC(ParseSegmentNzNcOrScheme2)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                if (!URI_FUNC(OnExitSegmentNzNcOrScheme2)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('.'):
+        case _UT('+'):
+        case _UT('-'):
+        case URI_SET_ALPHA:
+        case URI_SET_DIGIT:
+                return URI_FUNC(ParseSegmentNzNcOrScheme2)(state, first + 1, afterLast);
+
+        case _UT('%'):
+                {
+                        const URI_CHAR * const afterPctEncoded
+                                        = URI_FUNC(ParsePctEncoded)(state, first, afterLast);
+                        if (afterPctEncoded == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseMustBeSegmentNzNc)(state, afterPctEncoded, afterLast);
+                }
+
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT(';'):
+        case _UT('@'):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('='):
+        case _UT('\''):
+                return URI_FUNC(ParseMustBeSegmentNzNc)(state, first + 1, afterLast);
+
+        case _UT('/'):
+                {
+                        const URI_CHAR * afterZeroMoreSlashSegs;
+                        const URI_CHAR * const afterSegment
+                                        = URI_FUNC(ParseSegment)(state, first + 1, afterLast);
+                        if (afterSegment == NULL) {
+                                return NULL;
+                        }
+                        if (!URI_FUNC(PushPathSegment)(state, state->uri->scheme.first, first)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        state->uri->scheme.first = NULL; /* Not a scheme, reset */
+                        if (!URI_FUNC(PushPathSegment)(state, first + 1, afterSegment)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        afterZeroMoreSlashSegs
+                                        = URI_FUNC(ParseZeroMoreSlashSegs)(state, afterSegment, afterLast);
+                        if (afterZeroMoreSlashSegs == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseUriTail)(state, afterZeroMoreSlashSegs, afterLast);
+                }
+
+        case _UT(':'):
+                {
+                        const URI_CHAR * const afterHierPart
+                                        = URI_FUNC(ParseHierPart)(state, first + 1, afterLast);
+                        state->uri->scheme.afterLast = first; /* SCHEME END */
+                        if (afterHierPart == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseUriTail)(state, afterHierPart, afterLast);
+                }
+
+        default:
+                if (!URI_FUNC(OnExitSegmentNzNcOrScheme2)(state, first)) {
+                        URI_FUNC(StopMalloc)(state);
+                        return NULL;
+                }
+                return URI_FUNC(ParseUriTail)(state, first, afterLast);
+        }
+}
+
+
+
+/*
+ * [uriReference]->[ALPHA][segmentNzNcOrScheme2]
+ * [uriReference]->[DIGIT][mustBeSegmentNzNc]
+ * [uriReference]->[pctEncoded][mustBeSegmentNzNc]
+ * [uriReference]->[subDelims][mustBeSegmentNzNc]
+ * [uriReference]->[uriTail] // can take <NULL>
+ * [uriReference]-><.>[mustBeSegmentNzNc]
+ * [uriReference]-></>[partHelperTwo][uriTail]
+ * [uriReference]-><@>[mustBeSegmentNzNc]
+ * [uriReference]-><_>[mustBeSegmentNzNc]
+ * [uriReference]-><~>[mustBeSegmentNzNc]
+ * [uriReference]-><->[mustBeSegmentNzNc]
+ */
+static const URI_CHAR * URI_FUNC(ParseUriReference)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case URI_SET_ALPHA:
+                state->uri->scheme.first = first; /* SCHEME BEGIN */
+                return URI_FUNC(ParseSegmentNzNcOrScheme2)(state, first + 1, afterLast);
+
+        case URI_SET_DIGIT:
+        case _UT('!'):
+        case _UT('$'):
+        case _UT('&'):
+        case _UT('('):
+        case _UT(')'):
+        case _UT('*'):
+        case _UT(','):
+        case _UT(';'):
+        case _UT('\''):
+        case _UT('+'):
+        case _UT('='):
+        case _UT('.'):
+        case _UT('_'):
+        case _UT('~'):
+        case _UT('-'):
+        case _UT('@'):
+                state->uri->scheme.first = first; /* SEGMENT BEGIN, ABUSE SCHEME POINTER */
+                return URI_FUNC(ParseMustBeSegmentNzNc)(state, first + 1, afterLast);
+
+        case _UT('%'):
+                {
+                        const URI_CHAR * const afterPctEncoded
+                                        = URI_FUNC(ParsePctEncoded)(state, first, afterLast);
+                        if (afterPctEncoded == NULL) {
+                                return NULL;
+                        }
+                        state->uri->scheme.first = first; /* SEGMENT BEGIN, ABUSE SCHEME POINTER */
+                        return URI_FUNC(ParseMustBeSegmentNzNc)(state, afterPctEncoded, afterLast);
+                }
+
+        case _UT('/'):
+                {
+                        const URI_CHAR * const afterPartHelperTwo
+                                        = URI_FUNC(ParsePartHelperTwo)(state, first + 1, afterLast);
+                        if (afterPartHelperTwo == NULL) {
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseUriTail)(state, afterPartHelperTwo, afterLast);
+                }
+
+        default:
+                return URI_FUNC(ParseUriTail)(state, first, afterLast);
+        }
+}
+
+
+
+/*
+ * [uriTail]-><#>[queryFrag]
+ * [uriTail]-><?>[queryFrag][uriTailTwo]
+ * [uriTail]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseUriTail)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('#'):
+                {
+                        const URI_CHAR * const afterQueryFrag = URI_FUNC(ParseQueryFrag)(state, first + 1, afterLast);
+                        if (afterQueryFrag == NULL) {
+                                return NULL;
+                        }
+                        state->uri->fragment.first = first + 1; /* FRAGMENT BEGIN */
+                        state->uri->fragment.afterLast = afterQueryFrag; /* FRAGMENT END */
+                        return afterQueryFrag;
+                }
+
+        case _UT('?'):
+                {
+                        const URI_CHAR * const afterQueryFrag
+                                        = URI_FUNC(ParseQueryFrag)(state, first + 1, afterLast);
+                        if (afterQueryFrag == NULL) {
+                                return NULL;
+                        }
+                        state->uri->query.first = first + 1; /* QUERY BEGIN */
+                        state->uri->query.afterLast = afterQueryFrag; /* QUERY END */
+                        return URI_FUNC(ParseUriTailTwo)(state, afterQueryFrag, afterLast);
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [uriTailTwo]-><#>[queryFrag]
+ * [uriTailTwo]-><NULL>
+ */
+static URI_INLINE const URI_CHAR * URI_FUNC(ParseUriTailTwo)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('#'):
+                {
+                        const URI_CHAR * const afterQueryFrag = URI_FUNC(ParseQueryFrag)(state, first + 1, afterLast);
+                        if (afterQueryFrag == NULL) {
+                                return NULL;
+                        }
+                        state->uri->fragment.first = first + 1; /* FRAGMENT BEGIN */
+                        state->uri->fragment.afterLast = afterQueryFrag; /* FRAGMENT END */
+                        return afterQueryFrag;
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+/*
+ * [zeroMoreSlashSegs]-></>[segment][zeroMoreSlashSegs]
+ * [zeroMoreSlashSegs]-><NULL>
+ */
+static const URI_CHAR * URI_FUNC(ParseZeroMoreSlashSegs)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        if (first >= afterLast) {
+                return afterLast;
+        }
+
+        switch (*first) {
+        case _UT('/'):
+                {
+                        const URI_CHAR * const afterSegment
+                                        = URI_FUNC(ParseSegment)(state, first + 1, afterLast);
+                        if (afterSegment == NULL) {
+                                return NULL;
+                        }
+                        if (!URI_FUNC(PushPathSegment)(state, first + 1, afterSegment)) { /* SEGMENT BOTH */
+                                URI_FUNC(StopMalloc)(state);
+                                return NULL;
+                        }
+                        return URI_FUNC(ParseZeroMoreSlashSegs)(state, afterSegment, afterLast);
+                }
+
+        default:
+                return first;
+        }
+}
+
+
+
+static URI_INLINE void URI_FUNC(ResetParserState)(URI_TYPE(ParserState) * state) {
+        URI_TYPE(Uri) * const uriBackup = state->uri;
+        memset(state, 0, sizeof(URI_TYPE(ParserState)));
+        state->uri = uriBackup;
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(PushPathSegment)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        URI_TYPE(PathSegment) * segment = malloc(1 * sizeof(URI_TYPE(PathSegment)));
+        if (segment == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+        memset(segment, 0, sizeof(URI_TYPE(PathSegment)));
+        if (first == afterLast) {
+                segment->text.first = URI_FUNC(SafeToPointTo);
+                segment->text.afterLast = URI_FUNC(SafeToPointTo);
+        } else {
+                segment->text.first = first;
+                segment->text.afterLast = afterLast;
+        }
+
+        /* First segment ever? */
+        if (state->uri->pathHead == NULL) {
+                /* First segment ever, set head and tail */
+                state->uri->pathHead = segment;
+                state->uri->pathTail = segment;
+        } else {
+                /* Append, update tail */
+                state->uri->pathTail->next = segment;
+                state->uri->pathTail = segment;
+        }
+
+        return URI_TRUE; /* Success */
+}
+
+
+
+int URI_FUNC(ParseUriEx)(URI_TYPE(ParserState) * state, const URI_CHAR * first, const URI_CHAR * afterLast) {
+        const URI_CHAR * afterUriReference;
+        URI_TYPE(Uri) * uri;
+
+        /* Check params */
+        if ((state == NULL) || (first == NULL) || (afterLast == NULL)) {
+                return URI_ERROR_NULL;
+        }
+        uri = state->uri;
+
+        /* Init parser */
+        URI_FUNC(ResetParserState)(state);
+        URI_FUNC(ResetUri)(uri);
+
+        /* Parse */
+        afterUriReference = URI_FUNC(ParseUriReference)(state, first, afterLast);
+        if (afterUriReference == NULL) {
+                return state->errorCode;
+        }
+        if (afterUriReference != afterLast) {
+                URI_FUNC(StopSyntax)(state, afterUriReference);
+                return state->errorCode;
+        }
+        return URI_SUCCESS;
+}
+
+
+
+int URI_FUNC(ParseUri)(URI_TYPE(ParserState) * state, const URI_CHAR * text) {
+        if ((state == NULL) || (text == NULL)) {
+                return URI_ERROR_NULL;
+        }
+        return URI_FUNC(ParseUriEx)(state, text, text + URI_STRLEN(text));
+}
+
+
+
+void URI_FUNC(FreeUriMembers)(URI_TYPE(Uri) * uri) {
+        if (uri == NULL) {
+                return;
+        }
+
+        if (uri->owner) {
+                /* Scheme */
+                if (uri->scheme.first != NULL) {
+                        if (uri->scheme.first != uri->scheme.afterLast) {
+                                free((URI_CHAR *)uri->scheme.first);
+                        }
+                        uri->scheme.first = NULL;
+                        uri->scheme.afterLast = NULL;
+                }
+
+                /* User info */
+                if (uri->userInfo.first != NULL) {
+                        if (uri->userInfo.first != uri->userInfo.afterLast) {
+                                free((URI_CHAR *)uri->userInfo.first);
+                        }
+                        uri->userInfo.first = NULL;
+                        uri->userInfo.afterLast = NULL;
+                }
+
+                /* Host data - IPvFuture */
+                if (uri->hostData.ipFuture.first != NULL) {
+                        if (uri->hostData.ipFuture.first != uri->hostData.ipFuture.afterLast) {
+                                free((URI_CHAR *)uri->hostData.ipFuture.first);
+                        }
+                        uri->hostData.ipFuture.first = NULL;
+                        uri->hostData.ipFuture.afterLast = NULL;
+                        uri->hostText.first = NULL;
+                        uri->hostText.afterLast = NULL;
+                }
+
+                /* Host text (if regname, after IPvFuture!) */
+                if ((uri->hostText.first != NULL)
+                                && (uri->hostData.ip4 == NULL)
+                                && (uri->hostData.ip6 == NULL)) {
+                        /* Real regname */
+                        if (uri->hostText.first != uri->hostText.afterLast) {
+                                free((URI_CHAR *)uri->hostText.first);
+                        }
+                        uri->hostText.first = NULL;
+                        uri->hostText.afterLast = NULL;
+                }
+        }
+
+        /* Host data - IPv4 */
+        if (uri->hostData.ip4 != NULL) {
+                free(uri->hostData.ip4);
+                uri->hostData.ip4 = NULL;
+        }
+
+        /* Host data - IPv6 */
+        if (uri->hostData.ip6 != NULL) {
+                free(uri->hostData.ip6);
+                uri->hostData.ip6 = NULL;
+        }
+
+        /* Port text */
+        if (uri->owner && (uri->portText.first != NULL)) {
+                if (uri->portText.first != uri->portText.afterLast) {
+                        free((URI_CHAR *)uri->portText.first);
+                }
+                uri->portText.first = NULL;
+                uri->portText.afterLast = NULL;
+        }
+
+        /* Path */
+        if (uri->pathHead != NULL) {
+                URI_TYPE(PathSegment) * segWalk = uri->pathHead;
+                while (segWalk != NULL) {
+                        URI_TYPE(PathSegment) * const next = segWalk->next;
+                        if (uri->owner && (segWalk->text.first != NULL)
+                                        && (segWalk->text.first < segWalk->text.afterLast)) {
+                                free((URI_CHAR *)segWalk->text.first);
+                        }
+                        free(segWalk);
+                        segWalk = next;
+                }
+                uri->pathHead = NULL;
+                uri->pathTail = NULL;
+        }
+
+        if (uri->owner) {
+                /* Query */
+                if (uri->query.first != NULL) {
+                        if (uri->query.first != uri->query.afterLast) {
+                                free((URI_CHAR *)uri->query.first);
+                        }
+                        uri->query.first = NULL;
+                        uri->query.afterLast = NULL;
+                }
+
+                /* Fragment */
+                if (uri->fragment.first != NULL) {
+                        if (uri->fragment.first != uri->fragment.afterLast) {
+                                free((URI_CHAR *)uri->fragment.first);
+                        }
+                        uri->fragment.first = NULL;
+                        uri->fragment.afterLast = NULL;
+                }
+        }
+}
+
+
+
+UriBool URI_FUNC(_TESTING_ONLY_ParseIpSix)(const URI_CHAR * text) {
+        URI_TYPE(Uri) uri;
+        URI_TYPE(ParserState) parser;
+        const URI_CHAR * const afterIpSix = text + URI_STRLEN(text);
+        const URI_CHAR * res;
+
+        URI_FUNC(ResetParserState)(&parser);
+        URI_FUNC(ResetUri)(&uri);
+        parser.uri = &uri;
+        parser.uri->hostData.ip6 = malloc(1 * sizeof(UriIp6));
+        res = URI_FUNC(ParseIPv6address2)(&parser, text, afterIpSix);
+        URI_FUNC(FreeUriMembers)(&uri);
+        return res == afterIpSix ? URI_TRUE : URI_FALSE;
+}
+
+
+
+UriBool URI_FUNC(_TESTING_ONLY_ParseIpFour)(const URI_CHAR * text) {
+        unsigned char octets[4];
+        int res = URI_FUNC(ParseIpFourAddress)(octets, text, text + URI_STRLEN(text));
+        return (res == URI_SUCCESS) ? URI_TRUE : URI_FALSE;
+}
+
+
+
+#undef URI_SET_DIGIT
+#undef URI_SET_HEX_LETTER_UPPER
+#undef URI_SET_HEX_LETTER_LOWER
+#undef URI_SET_HEXDIG
+#undef URI_SET_ALPHA
+
+
+
+#endif
diff --git a/plugins/uriparser/UriParseBase.c b/plugins/uriparser/UriParseBase.c
new file mode 100644
index 0000000..75e4761
--- /dev/null
+++ b/plugins/uriparser/UriParseBase.c
@@ -0,0 +1,90 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef URI_DOXYGEN
+# include "UriParseBase.h"
+#endif
+
+
+
+void uriWriteQuadToDoubleByte(const unsigned char * hexDigits, int digitCount, unsigned char * output) {
+        switch (digitCount) {
+        case 1:
+                /* 0x___? -> \x00 \x0? */
+                output[0] = 0;
+                output[1] = hexDigits[0];
+                break;
+
+        case 2:
+                /* 0x__?? -> \0xx \x?? */
+                output[0] = 0;
+                output[1] = 16 * hexDigits[0] + hexDigits[1];
+                break;
+
+        case 3:
+                /* 0x_??? -> \0x? \x?? */
+                output[0] = hexDigits[0];
+                output[1] = 16 * hexDigits[1] + hexDigits[2];
+                break;
+
+        case 4:
+                /* 0x???? -> \0?? \x?? */
+                output[0] = 16 * hexDigits[0] + hexDigits[1];
+                output[1] = 16 * hexDigits[2] + hexDigits[3];
+                break;
+
+        }
+}
+
+
+
+unsigned char uriGetOctetValue(const unsigned char * digits, int digitCount) {
+        switch (digitCount) {
+        case 1:
+                return digits[0];
+
+        case 2:
+                return 10 * digits[0] + digits[1];
+
+        case 3:
+        default:
+                return 100 * digits[0] + 10 * digits[1] + digits[2];
+
+        }
+}
diff --git a/plugins/uriparser/UriParseBase.h b/plugins/uriparser/UriParseBase.h
new file mode 100644
index 0000000..dea5c81
--- /dev/null
+++ b/plugins/uriparser/UriParseBase.h
@@ -0,0 +1,55 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef URI_PARSE_BASE_H
+#define URI_PARSE_BASE_H 1
+
+
+
+#include <uriparser/UriBase.h>
+
+
+
+void uriWriteQuadToDoubleByte(const unsigned char * hexDigits, int digitCount,
+                unsigned char * output);
+unsigned char uriGetOctetValue(const unsigned char * digits, int digitCount);
+
+
+
+#endif /* URI_PARSE_BASE_H */
diff --git a/plugins/uriparser/UriQuery.c b/plugins/uriparser/UriQuery.c
new file mode 100644
index 0000000..7adb073
--- /dev/null
+++ b/plugins/uriparser/UriQuery.c
@@ -0,0 +1,460 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriQuery.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriQuery.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriCommon.h"
+#endif
+
+
+
+static int URI_FUNC(ComposeQueryEngine)(URI_CHAR * dest,
+                const URI_TYPE(QueryList) * queryList,
+                int maxChars, int * charsWritten, int * charsRequired,
+                UriBool spaceToPlus, UriBool normalizeBreaks);
+
+static UriBool URI_FUNC(AppendQueryItem)(URI_TYPE(QueryList) ** prevNext,
+                int * itemCount, const URI_CHAR * keyFirst, const URI_CHAR * keyAfter,
+                const URI_CHAR * valueFirst, const URI_CHAR * valueAfter,
+                UriBool plusToSpace, UriBreakConversion breakConversion);
+
+
+
+int URI_FUNC(ComposeQueryCharsRequired)(const URI_TYPE(QueryList) * queryList,
+                int * charsRequired) {
+        const UriBool spaceToPlus = URI_TRUE;
+        const UriBool normalizeBreaks = URI_TRUE;
+
+        return URI_FUNC(ComposeQueryCharsRequiredEx)(queryList, charsRequired,
+                        spaceToPlus, normalizeBreaks);
+}
+
+
+
+int URI_FUNC(ComposeQueryCharsRequiredEx)(const URI_TYPE(QueryList) * queryList,
+                int * charsRequired, UriBool spaceToPlus, UriBool normalizeBreaks) {
+        if ((queryList == NULL) || (charsRequired == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        return URI_FUNC(ComposeQueryEngine)(NULL, queryList, 0, NULL,
+                        charsRequired, spaceToPlus, normalizeBreaks);
+}
+
+
+
+int URI_FUNC(ComposeQuery)(URI_CHAR * dest,
+                                                   const URI_TYPE(QueryList) * queryList, int maxChars, int * charsWritten) {
+        const UriBool spaceToPlus = URI_TRUE;
+        const UriBool normalizeBreaks = URI_TRUE;
+
+        return URI_FUNC(ComposeQueryEx)(dest, queryList, maxChars, charsWritten,
+                        spaceToPlus, normalizeBreaks);
+}
+
+
+
+int URI_FUNC(ComposeQueryEx)(URI_CHAR * dest,
+                const URI_TYPE(QueryList) * queryList, int maxChars, int * charsWritten,
+                UriBool spaceToPlus, UriBool normalizeBreaks) {
+        if ((dest == NULL) || (queryList == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        if (maxChars < 1) {
+                return URI_ERROR_OUTPUT_TOO_LARGE;
+        }
+
+        return URI_FUNC(ComposeQueryEngine)(dest, queryList, maxChars,
+                        charsWritten, NULL, spaceToPlus, normalizeBreaks);
+}
+
+
+
+int URI_FUNC(ComposeQueryMalloc)(URI_CHAR ** dest,
+                const URI_TYPE(QueryList) * queryList) {
+        const UriBool spaceToPlus = URI_TRUE;
+        const UriBool normalizeBreaks = URI_TRUE;
+
+        return URI_FUNC(ComposeQueryMallocEx)(dest, queryList,
+                        spaceToPlus, normalizeBreaks);
+}
+
+
+
+int URI_FUNC(ComposeQueryMallocEx)(URI_CHAR ** dest,
+                const URI_TYPE(QueryList) * queryList,
+                UriBool spaceToPlus, UriBool normalizeBreaks) {
+        int charsRequired;
+        int res;
+        URI_CHAR * queryString;
+
+        if (dest == NULL) {
+                return URI_ERROR_NULL;
+        }
+
+        /* Calculate space */
+        res = URI_FUNC(ComposeQueryCharsRequiredEx)(queryList, &charsRequired,
+                        spaceToPlus, normalizeBreaks);
+        if (res != URI_SUCCESS) {
+                return res;
+        }
+        charsRequired++;
+
+        /* Allocate space */
+        queryString = malloc(charsRequired * sizeof(URI_CHAR));
+        if (queryString == NULL) {
+                return URI_ERROR_MALLOC;
+        }
+
+        /* Put query in */
+        res = URI_FUNC(ComposeQueryEx)(queryString, queryList, charsRequired,
+                        NULL, spaceToPlus, normalizeBreaks);
+        if (res != URI_SUCCESS) {
+                free(queryString);
+                return res;
+        }
+
+        *dest = queryString;
+        return URI_SUCCESS;
+}
+
+
+
+int URI_FUNC(ComposeQueryEngine)(URI_CHAR * dest,
+                const URI_TYPE(QueryList) * queryList,
+                int maxChars, int * charsWritten, int * charsRequired,
+                UriBool spaceToPlus, UriBool normalizeBreaks) {
+        UriBool firstItem = URI_TRUE;
+        int ampersandLen = 0;
+        URI_CHAR * write = dest;
+
+        /* Subtract terminator */
+        if (dest == NULL) {
+                *charsRequired = 0;
+        } else {
+                maxChars--;
+        }
+                        
+        while (queryList != NULL) {
+                const URI_CHAR * const key = queryList->key;
+                const URI_CHAR * const value = queryList->value;
+                const int worstCase = (normalizeBreaks == URI_TRUE ? 6 : 3);
+                const int keyLen = (key == NULL) ? 0 : (int)URI_STRLEN(key);
+                const int keyRequiredChars = worstCase * keyLen;
+                const int valueLen = (value == NULL) ? 0 : (int)URI_STRLEN(value);
+                const int valueRequiredChars = worstCase * valueLen;
+
+                if (dest == NULL) {
+                        if (firstItem == URI_TRUE) {
+                                ampersandLen = 1;
+                                firstItem = URI_FALSE;
+                        }
+
+                        (*charsRequired) += ampersandLen + keyRequiredChars + ((value == NULL)
+                                                ? 0
+                                                : 1 + valueRequiredChars);
+                } else {
+                        URI_CHAR * afterKey;
+
+                        if ((write - dest) + ampersandLen + keyRequiredChars > maxChars) {
+                                return URI_ERROR_OUTPUT_TOO_LARGE;
+                        }
+
+                        /* Copy key */
+                        if (firstItem == URI_TRUE) {
+                                firstItem = URI_FALSE;
+                        } else {
+                                write[0] = _UT('&');
+                                write++;
+                        }
+                        afterKey = URI_FUNC(EscapeEx)(key, key + keyLen,
+                                        write, spaceToPlus, normalizeBreaks);
+                        write += (afterKey - write);
+
+                        if (value != NULL) {
+                                URI_CHAR * afterValue;
+
+                                if ((write - dest) + 1 + valueRequiredChars > maxChars) {
+                                        return URI_ERROR_OUTPUT_TOO_LARGE;
+                                }
+
+                                /* Copy value */
+                                write[0] = _UT('=');
+                                write++;
+                                afterValue = URI_FUNC(EscapeEx)(value, value + valueLen,
+                                                write, spaceToPlus, normalizeBreaks);
+                                write += (afterValue - write);
+                        }
+                }
+
+                queryList = queryList->next;
+        }
+
+        if (dest != NULL) {
+                write[0] = _UT('\0');
+                if (charsWritten != NULL) {
+                        *charsWritten = (int)(write - dest) + 1; /* .. for terminator */
+                }
+        }
+
+        return URI_SUCCESS;
+}
+
+
+
+UriBool URI_FUNC(AppendQueryItem)(URI_TYPE(QueryList) ** prevNext,
+                int * itemCount, const URI_CHAR * keyFirst, const URI_CHAR * keyAfter,
+                const URI_CHAR * valueFirst, const URI_CHAR * valueAfter,
+                UriBool plusToSpace, UriBreakConversion breakConversion) {
+        const int keyLen = (int)(keyAfter - keyFirst);
+        const int valueLen = (int)(valueAfter - valueFirst);
+        URI_CHAR * key;
+        URI_CHAR * value;
+
+        if ((prevNext == NULL) || (itemCount == NULL)
+                        || (keyFirst == NULL) || (keyAfter == NULL)
+                        || (keyFirst > keyAfter) || (valueFirst > valueAfter)
+                        || ((keyFirst == keyAfter)
+                                && (valueFirst == NULL) && (valueAfter == NULL))) {
+                return URI_TRUE;
+        }
+
+        /* Append new empty item */
+        *prevNext = malloc(1 * sizeof(URI_TYPE(QueryList)));
+        if (*prevNext == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+        (*prevNext)->next = NULL;
+
+
+        /* Fill key */
+        key = malloc((keyLen + 1) * sizeof(URI_CHAR));
+        if (key == NULL) {
+                free(*prevNext);
+                *prevNext = NULL;
+                return URI_FALSE; /* Raises malloc error */
+        }
+
+        key[keyLen] = _UT('\0');
+        if (keyLen > 0) {
+                /* Copy 1:1 */
+                memcpy(key, keyFirst, keyLen * sizeof(URI_CHAR));
+
+                /* Unescape */
+                URI_FUNC(UnescapeInPlaceEx)(key, plusToSpace, breakConversion);
+        }
+        (*prevNext)->key = key;
+
+
+        /* Fill value */
+        if (valueFirst != NULL) {
+                value = malloc((valueLen + 1) * sizeof(URI_CHAR));
+                if (value == NULL) {
+                        free(key);
+                        free(*prevNext);
+                        *prevNext = NULL;
+                        return URI_FALSE; /* Raises malloc error */
+                }
+
+                value[valueLen] = _UT('\0');
+                if (valueLen > 0) {
+                        /* Copy 1:1 */
+                        memcpy(value, valueFirst, valueLen * sizeof(URI_CHAR));
+
+                        /* Unescape */
+                        URI_FUNC(UnescapeInPlaceEx)(value, plusToSpace, breakConversion);
+                }
+                (*prevNext)->value = value;
+        } else {
+                value = NULL;
+        }
+        (*prevNext)->value = value;
+
+        (*itemCount)++;
+        return URI_TRUE;
+}
+
+
+
+void URI_FUNC(FreeQueryList)(URI_TYPE(QueryList) * queryList) {
+        while (queryList != NULL) {
+                URI_TYPE(QueryList) * nextBackup = queryList->next;
+                free((URI_CHAR *)queryList->key); /* const cast */
+                free((URI_CHAR *)queryList->value); /* const cast */
+                free(queryList);
+                queryList = nextBackup;
+        }
+}
+
+
+
+int URI_FUNC(DissectQueryMalloc)(URI_TYPE(QueryList) ** dest, int * itemCount,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        const UriBool plusToSpace = URI_TRUE;
+        const UriBreakConversion breakConversion = URI_BR_DONT_TOUCH;
+
+        return URI_FUNC(DissectQueryMallocEx)(dest, itemCount, first, afterLast,
+                        plusToSpace, breakConversion);
+}
+
+
+
+int URI_FUNC(DissectQueryMallocEx)(URI_TYPE(QueryList) ** dest, int * itemCount,
+                const URI_CHAR * first, const URI_CHAR * afterLast,
+                UriBool plusToSpace, UriBreakConversion breakConversion) {
+        const URI_CHAR * walk = first;
+        const URI_CHAR * keyFirst = first;
+        const URI_CHAR * keyAfter = NULL;
+        const URI_CHAR * valueFirst = NULL;
+        const URI_CHAR * valueAfter = NULL;
+        URI_TYPE(QueryList) ** prevNext = dest;
+        int nullCounter;
+        int * itemsAppended = (itemCount == NULL) ? &nullCounter : itemCount;
+
+        if ((dest == NULL) || (first == NULL) || (afterLast == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        if (first > afterLast) {
+                return URI_ERROR_RANGE_INVALID;
+        }
+
+        *dest = NULL;
+        *itemsAppended = 0;
+
+        /* Parse query string */
+        for (; walk < afterLast; walk++) {
+                switch (*walk) {
+                case _UT('&'):
+                        if (valueFirst != NULL) {
+                                valueAfter = walk;
+                        } else {
+                                keyAfter = walk;
+                        }
+
+                        if (URI_FUNC(AppendQueryItem)(prevNext, itemsAppended,
+                                        keyFirst, keyAfter, valueFirst, valueAfter,
+                                        plusToSpace, breakConversion)
+                                        == URI_FALSE) {
+                                /* Free list we built */
+                                *itemsAppended = 0;
+                                URI_FUNC(FreeQueryList)(*dest);
+                                return URI_ERROR_MALLOC;
+                        }
+
+                        /* Make future items children of the current */
+                        if ((prevNext != NULL) && (*prevNext != NULL)) {
+                                prevNext = &((*prevNext)->next);
+                        }
+
+                        if (walk + 1 < afterLast) {
+                                keyFirst = walk + 1;
+                        } else {
+                                keyFirst = NULL;
+                        }
+                        keyAfter = NULL;
+                        valueFirst = NULL;
+                        valueAfter = NULL;
+                        break;
+
+                case _UT('='):
+                        /* NOTE: WE treat the first '=' as a separator, */
+                        /*       all following go into the value part   */
+                        if (keyAfter == NULL) {
+                                keyAfter = walk;
+                                if (walk + 1 <= afterLast) {
+                                        valueFirst = walk + 1;
+                                        valueAfter = walk + 1;
+                                }
+                        }
+                        break;
+
+                default:
+                        break;
+                }
+        }
+
+        if (valueFirst != NULL) {
+                /* Must be key/value pair */
+                valueAfter = walk;
+        } else {
+                /* Must be key only */
+                keyAfter = walk;
+        }
+
+        if (URI_FUNC(AppendQueryItem)(prevNext, itemsAppended, keyFirst, keyAfter,
+                        valueFirst, valueAfter, plusToSpace, breakConversion)
+                        == URI_FALSE) {
+                /* Free list we built */
+                *itemsAppended = 0;
+                URI_FUNC(FreeQueryList)(*dest);
+                return URI_ERROR_MALLOC;
+        }
+
+        return URI_SUCCESS;
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriRecompose.c b/plugins/uriparser/UriRecompose.c
new file mode 100644
index 0000000..09daee0
--- /dev/null
+++ b/plugins/uriparser/UriRecompose.c
@@ -0,0 +1,577 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriRecompose.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriRecompose.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriCommon.h"
+#endif
+
+
+
+static int URI_FUNC(ToStringEngine)(URI_CHAR * dest, const URI_TYPE(Uri) * uri,
+                int maxChars, int * charsWritten, int * charsRequired);
+
+
+
+int URI_FUNC(ToStringCharsRequired)(const URI_TYPE(Uri) * uri,
+                int * charsRequired) {
+        const int MAX_CHARS = ((unsigned int)-1) >> 1;
+        return URI_FUNC(ToStringEngine)(NULL, uri, MAX_CHARS, NULL, charsRequired);
+}
+
+
+
+int URI_FUNC(ToString)(URI_CHAR * dest, const URI_TYPE(Uri) * uri,
+                int maxChars, int * charsWritten) {
+        return URI_FUNC(ToStringEngine)(dest, uri, maxChars, charsWritten, NULL);
+}
+
+
+
+static URI_INLINE int URI_FUNC(ToStringEngine)(URI_CHAR * dest,
+                const URI_TYPE(Uri) * uri, int maxChars, int * charsWritten,
+                int * charsRequired) {
+        int written = 0;
+        if ((uri == NULL) || ((dest == NULL) && (charsRequired == NULL))) {
+                if (charsWritten != NULL) {
+                        *charsWritten = 0;
+                }
+                return URI_ERROR_NULL;
+        }
+
+        if (maxChars < 1) {
+                if (charsWritten != NULL) {
+                        *charsWritten = 0;
+                }
+                return URI_ERROR_TOSTRING_TOO_LONG;
+        }
+        maxChars--; /* So we don't have to substract 1 for '\0' all the time */
+
+        /* [01/19]      result = "" */
+                                if (dest != NULL) {
+                                        dest[0] = _UT('\0');
+                                } else {
+                                        (*charsRequired) = 0;
+                                }
+        /* [02/19]      if defined(scheme) then */
+                                if (uri->scheme.first != NULL) {
+        /* [03/19]              append scheme to result; */
+                                        const int charsToWrite
+                                                        = (int)(uri->scheme.afterLast - uri->scheme.first);
+                                        if (dest != NULL) {
+                                                if (written + charsToWrite <= maxChars) {
+                                                        memcpy(dest + written, uri->scheme.first,
+                                                                        charsToWrite * sizeof(URI_CHAR));
+                                                        written += charsToWrite;
+                                                } else {
+                                                        dest[0] = _UT('\0');
+                                                        if (charsWritten != NULL) {
+                                                                *charsWritten = 0;
+                                                        }
+                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                }
+                                        } else {
+                                                (*charsRequired) += charsToWrite;
+                                        }
+        /* [04/19]              append ":" to result; */
+                                        if (dest != NULL) {
+                                                if (written + 1 <= maxChars) {
+                                                        memcpy(dest + written, _UT(":"),
+                                                                        1 * sizeof(URI_CHAR));
+                                                        written += 1;
+                                                } else {
+                                                        dest[0] = _UT('\0');
+                                                        if (charsWritten != NULL) {
+                                                                *charsWritten = 0;
+                                                        }
+                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                }
+                                        } else {
+                                                (*charsRequired) += 1;
+                                        }
+        /* [05/19]      endif; */
+                                }
+        /* [06/19]      if defined(authority) then */
+                                if (URI_FUNC(IsHostSet)(uri)) {
+        /* [07/19]              append "//" to result; */
+                                        if (dest != NULL) {
+                                                if (written + 2 <= maxChars) {
+                                                        memcpy(dest + written, _UT("//"),
+                                                                        2 * sizeof(URI_CHAR));
+                                                        written += 2;
+                                                } else {
+                                                        dest[0] = _UT('\0');
+                                                        if (charsWritten != NULL) {
+                                                                *charsWritten = 0;
+                                                        }
+                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                }
+                                        } else {
+                                                (*charsRequired) += 2;
+                                        }
+        /* [08/19]              append authority to result; */
+                                        /* UserInfo */
+                                        if (uri->userInfo.first != NULL) {
+                                                const int charsToWrite = (int)(uri->userInfo.afterLast - uri->userInfo.first);
+                                                if (dest != NULL) {
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, uri->userInfo.first,
+                                                                                charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+
+                                                        if (written + 1 <= maxChars) {
+                                                                memcpy(dest + written, _UT("@"),
+                                                                                1 * sizeof(URI_CHAR));
+                                                                written += 1;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += charsToWrite + 1;
+                                                }
+                                        }
+
+                                        /* Host */
+                                        if (uri->hostData.ip4 != NULL) {
+                                                /* IPv4 */
+                                                int i = 0;
+                                                for (; i < 4; i++) {
+                                                        const unsigned char value = uri->hostData.ip4->data[i];
+                                                        const int charsToWrite = (value > 99) ? 3 : ((value > 9) ? 2 : 1);
+                                                        if (dest != NULL) {
+                                                                if (written + charsToWrite <= maxChars) {
+                                                                        URI_CHAR text[4];
+                                                                        if (value > 99) {
+                                                                                text[0] = _UT('0') + (value / 100);
+                                                                                text[1] = _UT('0') + ((value % 100) / 10);
+                                                                                text[2] = _UT('0') + (value % 10);
+                                                                        } else if (value > 9)  {
+                                                                                text[0] = _UT('0') + (value / 10);
+                                                                                text[1] = _UT('0') + (value % 10);
+                                                                        } else {
+                                                                                text[0] = _UT('0') + value;
+                                                                        }
+                                                                        text[charsToWrite] = _UT('\0');
+                                                                        memcpy(dest + written, text, charsToWrite * sizeof(URI_CHAR));
+                                                                        written += charsToWrite;
+                                                                } else {
+                                                                        dest[0] = _UT('\0');
+                                                                        if (charsWritten != NULL) {
+                                                                                *charsWritten = 0;
+                                                                        }
+                                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                                }
+                                                                if (i < 3) {
+                                                                        if (written + 1 <= maxChars) {
+                                                                                memcpy(dest + written, _UT("."),
+                                                                                                1 * sizeof(URI_CHAR));
+                                                                                written += 1;
+                                                                        } else {
+                                                                                dest[0] = _UT('\0');
+                                                                                if (charsWritten != NULL) {
+                                                                                        *charsWritten = 0;
+                                                                                }
+                                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                                        }
+                                                                }
+                                                        } else {
+                                                                (*charsRequired) += charsToWrite + 1;
+                                                        }
+                                                }
+                                        } else if (uri->hostData.ip6 != NULL) {
+                                                /* IPv6 */
+                                                int i = 0;
+                                                if (dest != NULL) {
+                                                        if (written + 1 <= maxChars) {
+                                                                memcpy(dest + written, _UT("["),
+                                                                                1 * sizeof(URI_CHAR));
+                                                                written += 1;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += 1;
+                                                }
+
+                                                for (; i < 16; i++) {
+                                                        const unsigned char value = uri->hostData.ip6->data[i];
+                                                        if (dest != NULL) {
+                                                                if (written + 2 <= maxChars) {
+                                                                        URI_CHAR text[3];
+                                                                        text[0] = URI_FUNC(HexToLetterEx)(value / 16, URI_FALSE);
+                                                                        text[1] = URI_FUNC(HexToLetterEx)(value % 16, URI_FALSE);
+                                                                        text[2] = _UT('\0');
+                                                                        memcpy(dest + written, text, 2 * sizeof(URI_CHAR));
+                                                                        written += 2;
+                                                                } else {
+                                                                        dest[0] = _UT('\0');
+                                                                        if (charsWritten != NULL) {
+                                                                                *charsWritten = 0;
+                                                                        }
+                                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                                }
+                                                        } else {
+                                                                (*charsRequired) += 2;
+                                                        }
+                                                        if (((i & 1) == 1) && (i < 15)) {
+                                                                if (dest != NULL) {
+                                                                        if (written + 1 <= maxChars) {
+                                                                                memcpy(dest + written, _UT(":"),
+                                                                                                1 * sizeof(URI_CHAR));
+                                                                                written += 1;
+                                                                        } else {
+                                                                                dest[0] = _UT('\0');
+                                                                                if (charsWritten != NULL) {
+                                                                                        *charsWritten = 0;
+                                                                                }
+                                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                                        }
+                                                                } else {
+                                                                        (*charsRequired) += 1;
+                                                                }
+                                                        }
+                                                }
+
+                                                if (dest != NULL) {
+                                                        if (written + 1 <= maxChars) {
+                                                                memcpy(dest + written, _UT("]"),
+                                                                                1 * sizeof(URI_CHAR));
+                                                                written += 1;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += 1;
+                                                }
+                                        } else if (uri->hostData.ipFuture.first != NULL) {
+                                                /* IPvFuture */
+                                                const int charsToWrite = (int)(uri->hostData.ipFuture.afterLast
+                                                                - uri->hostData.ipFuture.first);
+                                                if (dest != NULL) {
+                                                        if (written + 1 <= maxChars) {
+                                                                memcpy(dest + written, _UT("["),
+                                                                                1 * sizeof(URI_CHAR));
+                                                                written += 1;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, uri->hostData.ipFuture.first, charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+
+                                                        if (written + 1 <= maxChars) {
+                                                                memcpy(dest + written, _UT("]"),
+                                                                                1 * sizeof(URI_CHAR));
+                                                                written += 1;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += 1 + charsToWrite + 1;
+                                                }
+                                        } else if (uri->hostText.first != NULL) {
+                                                /* Regname */
+                                                const int charsToWrite = (int)(uri->hostText.afterLast - uri->hostText.first);
+                                                if (dest != NULL) {
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, uri->hostText.first,
+                                                                                charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += charsToWrite;
+                                                }
+                                        }
+
+                                        /* Port */
+                                        if (uri->portText.first != NULL) {
+                                                const int charsToWrite = (int)(uri->portText.afterLast - uri->portText.first);
+                                                if (dest != NULL) {
+                                                        /* Leading ':' */
+                                                        if (written + 1 <= maxChars) {
+                                                                        memcpy(dest + written, _UT(":"),
+                                                                                        1 * sizeof(URI_CHAR));
+                                                                        written += 1;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+
+                                                        /* Port number */
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, uri->portText.first,
+                                                                                charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += 1 + charsToWrite;
+                                                }
+                                        }
+        /* [09/19]      endif; */
+                                }
+        /* [10/19]      append path to result; */
+                                /* Slash needed here? */
+                                if (uri->absolutePath || ((uri->pathHead != NULL)
+                                                && URI_FUNC(IsHostSet)(uri))) {
+                                        if (dest != NULL) {
+                                                if (written + 1 <= maxChars) {
+                                                        memcpy(dest + written, _UT("/"),
+                                                                        1 * sizeof(URI_CHAR));
+                                                        written += 1;
+                                                } else {
+                                                        dest[0] = _UT('\0');
+                                                        if (charsWritten != NULL) {
+                                                                *charsWritten = 0;
+                                                        }
+                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                }
+                                        } else {
+                                                (*charsRequired) += 1;
+                                        }
+                                }
+
+                                if (uri->pathHead != NULL) {
+                                        URI_TYPE(PathSegment) * walker = uri->pathHead;
+                                        do {
+                                                const int charsToWrite = (int)(walker->text.afterLast - walker->text.first);
+                                                if (dest != NULL) {
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, walker->text.first,
+                                                                                charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += charsToWrite;
+                                                }
+
+                                                /* Not last segment -> append slash */
+                                                if (walker->next != NULL) {
+                                                        if (dest != NULL) {
+                                                                if (written + 1 <= maxChars) {
+                                                                        memcpy(dest + written, _UT("/"),
+                                                                                        1 * sizeof(URI_CHAR));
+                                                                        written += 1;
+                                                                } else {
+                                                                        dest[0] = _UT('\0');
+                                                                        if (charsWritten != NULL) {
+                                                                                *charsWritten = 0;
+                                                                        }
+                                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                                }
+                                                        } else {
+                                                                (*charsRequired) += 1;
+                                                        }
+                                                }
+
+                                                walker = walker->next;
+                                        } while (walker != NULL);
+                                }
+        /* [11/19]      if defined(query) then */
+                                if (uri->query.first != NULL) {
+        /* [12/19]              append "?" to result; */
+                                        if (dest != NULL) {
+                                                if (written + 1 <= maxChars) {
+                                                        memcpy(dest + written, _UT("?"),
+                                                                        1 * sizeof(URI_CHAR));
+                                                        written += 1;
+                                                } else {
+                                                        dest[0] = _UT('\0');
+                                                        if (charsWritten != NULL) {
+                                                                *charsWritten = 0;
+                                                        }
+                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                }
+                                        } else {
+                                                (*charsRequired) += 1;
+                                        }
+        /* [13/19]              append query to result; */
+                                        {
+                                                const int charsToWrite
+                                                                = (int)(uri->query.afterLast - uri->query.first);
+                                                if (dest != NULL) {
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, uri->query.first,
+                                                                                charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += charsToWrite;
+                                                }
+                                        }
+        /* [14/19]      endif; */
+                                }
+        /* [15/19]      if defined(fragment) then */
+                                if (uri->fragment.first != NULL) {
+        /* [16/19]              append "#" to result; */
+                                        if (dest != NULL) {
+                                                if (written + 1 <= maxChars) {
+                                                        memcpy(dest + written, _UT("#"),
+                                                                        1 * sizeof(URI_CHAR));
+                                                        written += 1;
+                                                } else {
+                                                        dest[0] = _UT('\0');
+                                                        if (charsWritten != NULL) {
+                                                                *charsWritten = 0;
+                                                        }
+                                                        return URI_ERROR_TOSTRING_TOO_LONG;
+                                                }
+                                        } else {
+                                                (*charsRequired) += 1;
+                                        }
+        /* [17/19]              append fragment to result; */
+                                        {
+                                                const int charsToWrite
+                                                                = (int)(uri->fragment.afterLast - uri->fragment.first);
+                                                if (dest != NULL) {
+                                                        if (written + charsToWrite <= maxChars) {
+                                                                memcpy(dest + written, uri->fragment.first,
+                                                                                charsToWrite * sizeof(URI_CHAR));
+                                                                written += charsToWrite;
+                                                        } else {
+                                                                dest[0] = _UT('\0');
+                                                                if (charsWritten != NULL) {
+                                                                        *charsWritten = 0;
+                                                                }
+                                                                return URI_ERROR_TOSTRING_TOO_LONG;
+                                                        }
+                                                } else {
+                                                        (*charsRequired) += charsToWrite;
+                                                }
+                                        }
+        /* [18/19]      endif; */
+                                }
+        /* [19/19]      return result; */
+                                if (dest != NULL) {
+                                        dest[written++] = _UT('\0');
+                                        if (charsWritten != NULL) {
+                                                *charsWritten = written;
+                                        }
+                                }
+                                return URI_SUCCESS;
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriResolve.c b/plugins/uriparser/UriResolve.c
new file mode 100644
index 0000000..3660b6b
--- /dev/null
+++ b/plugins/uriparser/UriResolve.c
@@ -0,0 +1,316 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriResolve.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriResolve.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriCommon.h"
+#endif
+
+
+
+/* Appends a relative URI to an absolute. The last path segment of
+ * the absolute URI is replaced. */
+static URI_INLINE UriBool URI_FUNC(MergePath)(URI_TYPE(Uri) * absWork,
+                const URI_TYPE(Uri) * relAppend) {
+        URI_TYPE(PathSegment) * sourceWalker;
+        URI_TYPE(PathSegment) * destPrev;
+        if (relAppend->pathHead == NULL) {
+                return URI_TRUE;
+        }
+
+        /* Replace last segment ("" if trailing slash) with first of append chain */
+        if (absWork->pathHead == NULL) {
+                URI_TYPE(PathSegment) * const dup = malloc(sizeof(URI_TYPE(PathSegment)));
+                if (dup == NULL) {
+                        return URI_FALSE; /* Raises malloc error */
+                }
+                dup->next = NULL;
+                absWork->pathHead = dup;
+                absWork->pathTail = dup;
+        }
+        absWork->pathTail->text.first = relAppend->pathHead->text.first;
+        absWork->pathTail->text.afterLast = relAppend->pathHead->text.afterLast;
+
+        /* Append all the others */
+        sourceWalker = relAppend->pathHead->next;
+        if (sourceWalker == NULL) {
+                return URI_TRUE;
+        }
+        destPrev = absWork->pathTail;
+
+        for (;;) {
+                URI_TYPE(PathSegment) * const dup = malloc(sizeof(URI_TYPE(PathSegment)));
+                if (dup == NULL) {
+                        destPrev->next = NULL;
+                        absWork->pathTail = destPrev;
+                        return URI_FALSE; /* Raises malloc error */
+                }
+                dup->text = sourceWalker->text;
+                destPrev->next = dup;
+
+                if (sourceWalker->next == NULL) {
+                        absWork->pathTail = dup;
+                        absWork->pathTail->next = NULL;
+                        break;
+                }
+                destPrev = dup;
+                sourceWalker = sourceWalker->next;
+        }
+
+        return URI_TRUE;
+}
+
+
+static int URI_FUNC(ResolveAbsolutePathFlag)(URI_TYPE(Uri) * absWork) {
+        if (absWork == NULL) {
+                return URI_ERROR_NULL;
+        }
+
+        if (URI_FUNC(IsHostSet)(absWork) && absWork->absolutePath) {
+                /* Empty segment needed, instead? */
+                if (absWork->pathHead == NULL) {
+                        URI_TYPE(PathSegment) * const segment = malloc(sizeof(URI_TYPE(PathSegment)));
+                        if (segment == NULL) {
+                                return URI_ERROR_MALLOC;
+                        }
+                        segment->text.first = URI_FUNC(SafeToPointTo);
+                        segment->text.afterLast = URI_FUNC(SafeToPointTo);
+                        segment->next = NULL;
+
+                        absWork->pathHead = segment;
+                        absWork->pathTail = segment;
+                }
+
+                absWork->absolutePath = URI_FALSE;
+        }
+
+        return URI_SUCCESS;
+}
+
+
+static int URI_FUNC(AddBaseUriImpl)(URI_TYPE(Uri) * absDest,
+                const URI_TYPE(Uri) * relSource,
+                const URI_TYPE(Uri) * absBase,
+                UriResolutionOptions options) {
+        if (absDest == NULL) {
+                return URI_ERROR_NULL;
+        }
+        URI_FUNC(ResetUri)(absDest);
+
+        if ((relSource == NULL) || (absBase == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        /* absBase absolute? */
+        if (absBase->scheme.first == NULL) {
+                return URI_ERROR_ADDBASE_REL_BASE;
+        }
+
+        /* [00/32]      -- A non-strict parser may ignore a scheme in the reference */
+        /* [00/32]      -- if it is identical to the base URI's scheme. */
+        /* [00/32]      if ((not strict) and (R.scheme == Base.scheme)) then */
+        UriBool relSourceHasScheme = (relSource->scheme.first != NULL) ? URI_TRUE : URI_FALSE;
+        if ((options & URI_RESOLVE_IDENTICAL_SCHEME_COMPAT)
+                        && (absBase->scheme.first != NULL)
+                        && (relSource->scheme.first != NULL)
+                        && (0 == URI_FUNC(CompareRange)(&(absBase->scheme), &(relSource->scheme)))) {
+        /* [00/32]              undefine(R.scheme); */
+                relSourceHasScheme = URI_FALSE;
+        /* [00/32]      endif; */
+        }
+
+        /* [01/32]      if defined(R.scheme) then */
+                                if (relSourceHasScheme) {
+        /* [02/32]              T.scheme = R.scheme; */
+                                        absDest->scheme = relSource->scheme;
+        /* [03/32]              T.authority = R.authority; */
+                                        if (!URI_FUNC(CopyAuthority)(absDest, relSource)) {
+                                                return URI_ERROR_MALLOC;
+                                        }
+        /* [04/32]              T.path = remove_dot_segments(R.path); */
+                                        if (!URI_FUNC(CopyPath)(absDest, relSource)) {
+                                                return URI_ERROR_MALLOC;
+                                        }
+                                        if (!URI_FUNC(RemoveDotSegmentsAbsolute)(absDest)) {
+                                                return URI_ERROR_MALLOC;
+                                        }
+        /* [05/32]              T.query = R.query; */
+                                        absDest->query = relSource->query;
+        /* [06/32]      else */
+                                } else {
+        /* [07/32]              if defined(R.authority) then */
+                                        if (URI_FUNC(IsHostSet)(relSource)) {
+        /* [08/32]                      T.authority = R.authority; */
+                                                if (!URI_FUNC(CopyAuthority)(absDest, relSource)) {
+                                                        return URI_ERROR_MALLOC;
+                                                }
+        /* [09/32]                      T.path = remove_dot_segments(R.path); */
+                                                if (!URI_FUNC(CopyPath)(absDest, relSource)) {
+                                                        return URI_ERROR_MALLOC;
+                                                }
+                                                if (!URI_FUNC(RemoveDotSegmentsAbsolute)(absDest)) {
+                                                        return URI_ERROR_MALLOC;
+                                                }
+        /* [10/32]                      T.query = R.query; */
+                                                absDest->query = relSource->query;
+        /* [11/32]              else */
+                                        } else {
+        /* [28/32]                      T.authority = Base.authority; */
+                                                if (!URI_FUNC(CopyAuthority)(absDest, absBase)) {
+                                                        return URI_ERROR_MALLOC;
+                                                }
+        /* [12/32]                      if (R.path == "") then */
+                                                if (relSource->pathHead == NULL && !relSource->absolutePath) {
+        /* [13/32]                              T.path = Base.path; */
+                                                        if (!URI_FUNC(CopyPath)(absDest, absBase)) {
+                                                                return URI_ERROR_MALLOC;
+                                                        }
+        /* [14/32]                              if defined(R.query) then */
+                                                        if (relSource->query.first != NULL) {
+        /* [15/32]                                      T.query = R.query; */
+                                                                absDest->query = relSource->query;
+        /* [16/32]                              else */
+                                                        } else {
+        /* [17/32]                                      T.query = Base.query; */
+                                                                absDest->query = absBase->query;
+        /* [18/32]                              endif; */
+                                                        }
+        /* [19/32]                      else */
+                                                } else {
+        /* [20/32]                              if (R.path starts-with "/") then */
+                                                        if (relSource->absolutePath) {
+                                                                int res;
+        /* [21/32]                                      T.path = remove_dot_segments(R.path); */
+                                                                if (!URI_FUNC(CopyPath)(absDest, relSource)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+                                                                res = URI_FUNC(ResolveAbsolutePathFlag)(absDest);
+                                                                if (res != URI_SUCCESS) {
+                                                                        return res;
+                                                                }
+                                                                if (!URI_FUNC(RemoveDotSegmentsAbsolute)(absDest)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+        /* [22/32]                              else */
+                                                        } else {
+        /* [23/32]                                      T.path = merge(Base.path, R.path); */
+                                                                if (!URI_FUNC(CopyPath)(absDest, absBase)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+                                                                if (!URI_FUNC(MergePath)(absDest, relSource)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+        /* [24/32]                                      T.path = remove_dot_segments(T.path); */
+                                                                if (!URI_FUNC(RemoveDotSegmentsAbsolute)(absDest)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+
+                                                                if (!URI_FUNC(FixAmbiguity)(absDest)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+        /* [25/32]                              endif; */
+                                                        }
+        /* [26/32]                              T.query = R.query; */
+                                                        absDest->query = relSource->query;
+        /* [27/32]                      endif; */
+                                                }
+                                                URI_FUNC(FixEmptyTrailSegment)(absDest);
+        /* [29/32]              endif; */
+                                        }
+        /* [30/32]              T.scheme = Base.scheme; */
+                                        absDest->scheme = absBase->scheme;
+        /* [31/32]      endif; */
+                                }
+        /* [32/32]      T.fragment = R.fragment; */
+                                absDest->fragment = relSource->fragment;
+
+        return URI_SUCCESS;
+
+}
+
+
+
+int URI_FUNC(AddBaseUri)(URI_TYPE(Uri) * absDest,
+                const URI_TYPE(Uri) * relSource, const URI_TYPE(Uri) * absBase) {
+        const int res = URI_FUNC(AddBaseUriImpl)(absDest, relSource, absBase, URI_RESOLVE_STRICTLY);
+        if ((res != URI_SUCCESS) && (absDest != NULL)) {
+                URI_FUNC(FreeUriMembers)(absDest);
+        }
+        return res;
+}
+
+
+
+int URI_FUNC(AddBaseUriEx)(URI_TYPE(Uri) * absDest,
+                const URI_TYPE(Uri) * relSource, const URI_TYPE(Uri) * absBase,
+                UriResolutionOptions options) {
+        const int res = URI_FUNC(AddBaseUriImpl)(absDest, relSource, absBase, options);
+        if ((res != URI_SUCCESS) && (absDest != NULL)) {
+                URI_FUNC(FreeUriMembers)(absDest);
+        }
+        return res;
+}
+
+
+
+#endif
diff --git a/plugins/uriparser/UriShorten.c b/plugins/uriparser/UriShorten.c
new file mode 100644
index 0000000..c839ae5
--- /dev/null
+++ b/plugins/uriparser/UriShorten.c
@@ -0,0 +1,320 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
+ * Copyright (C) 2007, Sebastian Pipping <webmaster@hartwork.org>
+ * All rights reserved.
+ *
+ * Redistribution  and use in source and binary forms, with or without
+ * modification,  are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions   of  source  code  must  retain  the   above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer.
+ *
+ *     * Redistributions  in  binary  form must  reproduce  the  above
+ *       copyright  notice, this list of conditions and the  following
+ *       disclaimer   in  the  documentation  and/or  other  materials
+ *       provided with the distribution.
+ *
+ *     * Neither  the name of the <ORGANIZATION> nor the names of  its
+ *       contributors  may  be  used to endorse  or  promote  products
+ *       derived  from  this software without specific  prior  written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
+ * LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
+ * FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
+ * (INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriShorten.c"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriShorten.c"
+#  undef URI_PASS_UNICODE
+# endif
+#else
+# ifdef URI_PASS_ANSI
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  include <uriparser/UriDefsUnicode.h>
+#  include <wchar.h>
+# endif
+
+
+
+#ifndef URI_DOXYGEN
+# include <uriparser/Uri.h>
+# include "UriCommon.h"
+#endif
+
+
+
+static URI_INLINE UriBool URI_FUNC(AppendSegment)(URI_TYPE(Uri) * uri,
+                const URI_CHAR * first, const URI_CHAR * afterLast) {
+        /* Create segment */
+        URI_TYPE(PathSegment) * segment = malloc(1 * sizeof(URI_TYPE(PathSegment)));
+        if (segment == NULL) {
+                return URI_FALSE; /* Raises malloc error */
+        }
+        segment->next = NULL;
+        segment->text.first = first;
+        segment->text.afterLast = afterLast;
+
+        /* Put into chain */
+        if (uri->pathTail == NULL) {
+                uri->pathHead = segment;
+        } else {
+                uri->pathTail->next = segment;
+        }
+        uri->pathTail = segment;
+
+        return URI_TRUE;
+}
+
+
+
+static URI_INLINE UriBool URI_FUNC(EqualsAuthority)(const URI_TYPE(Uri) * first,
+                const URI_TYPE(Uri) * second) {
+        /* IPv4 */
+        if (first->hostData.ip4 != NULL) {
+                return ((second->hostData.ip4 != NULL)
+                                && !memcmp(first->hostData.ip4->data,
+                                        second->hostData.ip4->data, 4)) ? URI_TRUE : URI_FALSE;
+        }
+
+        /* IPv6 */
+        if (first->hostData.ip6 != NULL) {
+                return ((second->hostData.ip6 != NULL)
+                                && !memcmp(first->hostData.ip6->data,
+                                        second->hostData.ip6->data, 16)) ? URI_TRUE : URI_FALSE;
+        }
+
+        /* IPvFuture */
+        if (first->hostData.ipFuture.first != NULL) {
+                return ((second->hostData.ipFuture.first != NULL)
+                                && !URI_STRNCMP(first->hostData.ipFuture.first,
+                                        second->hostData.ipFuture.first,
+                                        first->hostData.ipFuture.afterLast
+                                        - first->hostData.ipFuture.first))
+                                                ? URI_TRUE : URI_FALSE;
+        }
+
+        if (first->hostText.first != NULL) {
+                return ((second->hostText.first != NULL)
+                                && !URI_STRNCMP(first->hostText.first,
+                                        second->hostText.first,
+                                        first->hostText.afterLast
+                                        - first->hostText.first)) ? URI_TRUE : URI_FALSE;
+        }
+
+        return (second->hostText.first == NULL);
+}
+
+
+
+int URI_FUNC(RemoveBaseUriImpl)(URI_TYPE(Uri) * dest,
+                const URI_TYPE(Uri) * absSource,
+                const URI_TYPE(Uri) * absBase,
+                UriBool domainRootMode) {
+        if (dest == NULL) {
+                return URI_ERROR_NULL;
+        }
+        URI_FUNC(ResetUri)(dest);
+
+        if ((absSource == NULL) || (absBase == NULL)) {
+                return URI_ERROR_NULL;
+        }
+
+        /* absBase absolute? */
+        if (absBase->scheme.first == NULL) {
+                return URI_ERROR_REMOVEBASE_REL_BASE;
+        }
+
+        /* absSource absolute? */
+        if (absSource->scheme.first == NULL) {
+                return URI_ERROR_REMOVEBASE_REL_SOURCE;
+        }
+
+        /* [01/50]      if (A.scheme != Base.scheme) then */
+                                if (URI_STRNCMP(absSource->scheme.first, absBase->scheme.first,
+                                                absSource->scheme.afterLast - absSource->scheme.first)) {
+        /* [02/50]         T.scheme    = A.scheme; */
+                                        dest->scheme = absSource->scheme;
+        /* [03/50]         T.authority = A.authority; */
+                                        if (!URI_FUNC(CopyAuthority)(dest, absSource)) {
+                                                return URI_ERROR_MALLOC;
+                                        }
+        /* [04/50]         T.path      = A.path; */
+                                        if (!URI_FUNC(CopyPath)(dest, absSource)) {
+                                                return URI_ERROR_MALLOC;
+                                        }
+        /* [05/50]      else */
+                                } else {
+        /* [06/50]         undef(T.scheme); */
+                                        /* NOOP */
+        /* [07/50]         if (A.authority != Base.authority) then */
+                                        if (!URI_FUNC(EqualsAuthority)(absSource, absBase)) {
+        /* [08/50]            T.authority = A.authority; */
+                                                if (!URI_FUNC(CopyAuthority)(dest, absSource)) {
+                                                        return URI_ERROR_MALLOC;
+                                                }
+        /* [09/50]            T.path      = A.path; */
+                                                if (!URI_FUNC(CopyPath)(dest, absSource)) {
+                                                        return URI_ERROR_MALLOC;
+                                                }
+        /* [10/50]         else */
+                                        } else {
+        /* [11/50]            if domainRootMode then */
+                                                if (domainRootMode == URI_TRUE) {
+        /* [12/50]               undef(T.authority); */
+                                                        /* NOOP */
+        /* [13/50]               if (first(A.path) == "") then */
+                                                        /* GROUPED */
+        /* [14/50]                  T.path   = "/." + A.path; */
+                                                                /* GROUPED */
+        /* [15/50]               else */
+                                                                /* GROUPED */
+        /* [16/50]                  T.path   = A.path; */
+                                                                /* GROUPED */
+        /* [17/50]               endif; */
+                                                        if (!URI_FUNC(CopyPath)(dest, absSource)) {
+                                                                return URI_ERROR_MALLOC;
+                                                        }
+                                                        dest->absolutePath = URI_TRUE;
+
+                                                        if (!URI_FUNC(FixAmbiguity)(dest)) {
+                                                                return URI_ERROR_MALLOC;
+                                                        }
+        /* [18/50]            else */
+                                                } else {
+                                                        const URI_TYPE(PathSegment) * sourceSeg = absSource->pathHead;
+                                                        const URI_TYPE(PathSegment) * baseSeg = absBase->pathHead;
+        /* [19/50]               bool pathNaked = true; */
+                                                        UriBool pathNaked = URI_TRUE;
+        /* [20/50]               undef(last(Base.path)); */
+                                                        /* NOOP */
+        /* [21/50]               T.path = ""; */
+                                                        dest->absolutePath = URI_FALSE;
+        /* [22/50]               while (first(A.path) == first(Base.path)) do */
+                                                        while ((sourceSeg != NULL) && (baseSeg != NULL)
+                                                                        && !URI_STRNCMP(sourceSeg->text.first, baseSeg->text.first,
+                                                                        sourceSeg->text.afterLast - sourceSeg->text.first)
+                                                                        && !((sourceSeg->text.first == sourceSeg->text.afterLast)
+                                                                                && ((sourceSeg->next == NULL) != (baseSeg->next == NULL)))) {
+        /* [23/50]                  A.path++; */
+                                                                sourceSeg = sourceSeg->next;
+        /* [24/50]                  Base.path++; */
+                                                                baseSeg = baseSeg->next;
+        /* [25/50]               endwhile; */
+                                                        }
+        /* [26/50]               while defined(first(Base.path)) do */
+                                                        while ((baseSeg != NULL) && (baseSeg->next != NULL)) {
+        /* [27/50]                  Base.path++; */
+                                                                baseSeg = baseSeg->next;
+        /* [28/50]                  T.path += "../"; */
+                                                                if (!URI_FUNC(AppendSegment)(dest, URI_FUNC(ConstParent),
+                                                                                URI_FUNC(ConstParent) + 2)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+        /* [29/50]                  pathNaked = false; */
+                                                                pathNaked = URI_FALSE;
+        /* [30/50]               endwhile; */
+                                                        }
+        /* [31/50]               while defined(first(A.path)) do */
+                                                        while (sourceSeg != NULL) {
+        /* [32/50]                  if pathNaked then */
+                                                                if (pathNaked == URI_TRUE) {
+        /* [33/50]                     if (first(A.path) contains ":") then */
+                                                                        UriBool containsColon = URI_FALSE;
+                                                                        const URI_CHAR * ch = sourceSeg->text.first;
+                                                                        for (; ch < sourceSeg->text.afterLast; ch++) {
+                                                                                if (*ch == _UT(':')) {
+                                                                                        containsColon = URI_TRUE;
+                                                                                        break;
+                                                                                }
+                                                                        }
+
+                                                                        if (containsColon) {
+        /* [34/50]                        T.path += "./"; */
+                                                                                if (!URI_FUNC(AppendSegment)(dest, URI_FUNC(ConstPwd),
+                                                                                                URI_FUNC(ConstPwd) + 1)) {
+                                                                                        return URI_ERROR_MALLOC;
+                                                                                }
+        /* [35/50]                     elseif (first(A.path) == "") then */
+                                                                        } else if (sourceSeg->text.first == sourceSeg->text.afterLast) {
+        /* [36/50]                        T.path += "/."; */
+                                                                                if (!URI_FUNC(AppendSegment)(dest, URI_FUNC(ConstPwd),
+                                                                                                URI_FUNC(ConstPwd) + 1)) {
+                                                                                        return URI_ERROR_MALLOC;
+                                                                                }
+        /* [37/50]                     endif; */
+                                                                        }
+        /* [38/50]                  endif; */
+                                                                }
+        /* [39/50]                  T.path += first(A.path); */
+                                                                if (!URI_FUNC(AppendSegment)(dest, sourceSeg->text.first,
+                                                                                sourceSeg->text.afterLast)) {
+                                                                        return URI_ERROR_MALLOC;
+                                                                }
+        /* [40/50]                  pathNaked = false; */
+                                                                pathNaked = URI_FALSE;
+        /* [41/50]                  A.path++; */
+                                                                sourceSeg = sourceSeg->next;
+        /* [42/50]                  if defined(first(A.path)) then */
+                                                                /* NOOP */
+        /* [43/50]                     T.path += + "/"; */
+                                                                /* NOOP */
+        /* [44/50]                  endif; */
+                                                                /* NOOP */
+        /* [45/50]               endwhile; */
+                                                        }
+        /* [46/50]            endif; */
+                                                }
+        /* [47/50]         endif; */
+                                        }
+        /* [48/50]      endif; */
+                                }
+        /* [49/50]      T.query     = A.query; */
+                                dest->query = absSource->query;
+        /* [50/50]      T.fragment  = A.fragment; */
+                                dest->fragment = absSource->fragment;
+
+        return URI_SUCCESS;
+}
+
+
+
+int URI_FUNC(RemoveBaseUri)(URI_TYPE(Uri) * dest,
+                const URI_TYPE(Uri) * absSource,
+                const URI_TYPE(Uri) * absBase,
+                UriBool domainRootMode) {
+        const int res = URI_FUNC(RemoveBaseUriImpl)(dest, absSource,
+                        absBase, domainRootMode);
+        if ((res != URI_SUCCESS) && (dest != NULL)) {
+                URI_FUNC(FreeUriMembers)(dest);
+        }
+        return res;
+}
+
+
+
+#endif