/*

 * Copyright(c) 2014-2018 Tim Ruehsen

 *

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

 *

 * This file is part of libpsl.

 *

 * Public Suffix List routines

 *

 * Changelog

 * 19.03.2014  Tim Ruehsen  created from libmget/cookie.c

 *

 */

#if HAVE_CONFIG_H

# include <config.h>

#endif

#if defined(__GNUC__) && defined(__GNUC_MINOR__)

#       define _GCC_VERSION_AT_LEAST(major, minor) ((__GNUC__ > (major)) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))

#else

#       define _GCC_VERSION_AT_LEAST(major, minor) 0

#endif

#if _GCC_VERSION_AT_LEAST(2,95)

#  define _UNUSED __attribute__ ((unused))

#else

#  define _UNUSED

#endif

#if ENABLE_NLS != 0

#	include <libintl.h>

#	define _(STRING) gettext(STRING)

#else

#	define _(STRING) STRING

#	define ngettext(STRING1,STRING2,N) STRING2

#endif

#include <sys/types.h>

#include <sys/stat.h>

#ifdef _WIN32

/* This is for Windows Vista and later, for inet_pton() */

# define _WIN32_WINNT 0x0600

# include <winsock2.h>

# include <ws2tcpip.h>

#else

# include <sys/socket.h>

# include <netinet/in.h>

# include <unistd.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include <errno.h>

#include <limits.h> /* for UINT_MAX */

#ifndef _WIN32

# include <langinfo.h>

# include <arpa/inet.h>

#endif

#ifdef HAVE_ALLOCA_H

#	include <alloca.h>

#endif

#ifdef WITH_LIBICU

#	include <unicode/uversion.h>

#	include <unicode/ustring.h>

#	include <unicode/uidna.h>

#	include <unicode/ucnv.h>

#elif defined(WITH_LIBIDN2)

#	include <iconv.h>

#	include <idn2.h>

#	include <unicase.h>

#	include <unistr.h>

#elif defined(WITH_LIBIDN)

#	include <iconv.h>

#	include <stringprep.h>

#	include <idna.h>

#	include <unicase.h>

#	include <unistr.h>

#endif

#ifndef WINICONV_CONST

#  define WINICONV_CONST

#endif

#include <libpsl.h>

/**

 * SECTION:libpsl

 * @short_description: Public Suffix List library functions

 * @title: libpsl

 * @stability: Stable

 * @include: libpsl.h

 *

 * [Public Suffix List](https://publicsuffix.org/) library functions.

 *

 */

#define countof(a) (sizeof(a)/sizeof(*(a)))

#define _PSL_FLAG_EXCEPTION (1<<0)

#define _PSL_FLAG_WILDCARD  (1<<1)

#define _PSL_FLAG_ICANN     (1<<2) /* entry of ICANN section */

#define _PSL_FLAG_PRIVATE   (1<<3) /* entry of PRIVATE section */

#define _PSL_FLAG_PLAIN     (1<<4) /* just used for PSL syntax checking */

typedef struct {

	char

		label_buf[48];

	const char *

		label;

	unsigned short

		length;

	unsigned char

		nlabels, /* number of labels */

		flags;

} _psl_entry_t;

/* stripped down version libmget vector routines */

typedef struct {

	int

		(*cmp)(const _psl_entry_t **, const _psl_entry_t **); /* comparison function */

	_psl_entry_t

		**entry; /* pointer to array of pointers to elements */

	int

		max,     /* allocated elements */

		cur;     /* number of elements in use */

} _psl_vector_t;

struct _psl_ctx_st {

	_psl_vector_t

		*suffixes;

	unsigned char

		*dafsa;

	size_t

		dafsa_size;

	int

		nsuffixes,

		nexceptions,

		nwildcards;

	unsigned

		utf8 : 1; /* 1: data contains UTF-8 + punycode encoded rules */

};

/* include the PSL data generated by psl-make-dafsa */

#if defined(BUILTIN_GENERATOR_LIBICU) || defined(BUILTIN_GENERATOR_LIBIDN2) || defined(BUILTIN_GENERATOR_LIBIDN)

#include "suffixes_dafsa.c"

#else

static const unsigned char kDafsa[] = "";

static time_t _psl_file_time = 0;

static int _psl_nsuffixes = 0;

static int _psl_nexceptions = 0;

static int _psl_nwildcards = 0;

static const char _psl_sha1_checksum[] = "";

static const char _psl_filename[] = "";

#endif

/* references to these PSLs will result in lookups to built-in data */

static const psl_ctx_t

	_builtin_psl;

#ifdef PSL_DISTFILE

static const char _psl_dist_filename[] = PSL_DISTFILE;

#else

static const char _psl_dist_filename[] = "";

#endif

static _psl_vector_t *_vector_alloc(int max, int (*cmp)(const _psl_entry_t **, const _psl_entry_t **))

{

	_psl_vector_t *v;

	if (!(v = calloc(1, sizeof(_psl_vector_t))))

		return NULL;

	if (!(v->entry = malloc(max * sizeof(_psl_entry_t *)))) {

		free(v);

		return NULL;

	}

	v->max = max;

	v->cmp = cmp;

	return v;

}

static void _vector_free(_psl_vector_t **v)

{

	if (v && *v) {

		if ((*v)->entry) {

			int it;

			for (it = 0; it < (*v)->cur; it++)

				free((*v)->entry[it]);

			free((*v)->entry);

		}

		free(*v);

	}

}

static _psl_entry_t *_vector_get(const _psl_vector_t *v, int pos)

{

	if (pos < 0 || !v || pos >= v->cur) return NULL;

	return v->entry[pos];

}

/* the entries must be sorted by */

static int _vector_find(const _psl_vector_t *v, const _psl_entry_t *elem)

{

	if (v) {

		int l, r, m;

		int res;

		/* binary search for element (exact match) */

		for (l = 0, r = v->cur - 1; l <= r;) {

			m = (l + r) / 2;

			if ((res = v->cmp(&elem, (const _psl_entry_t **)&(v->entry[m]))) > 0) l = m + 1;

			else if (res < 0) r = m - 1;

			else return m;

		}

	}

	return -1; /* not found */

}

static int _vector_add(_psl_vector_t *v, const _psl_entry_t *elem)

{

	if (v) {

		void *elemp;

		if (!(elemp = malloc(sizeof(_psl_entry_t))))

			return -1;

		memcpy(elemp, elem, sizeof(_psl_entry_t));

		if (v->max == v->cur) {

			void *m = realloc(v->entry, (v->max *= 2) * sizeof(_psl_entry_t *));

			if (m)

				v->entry = m;

			else {

				free(elemp);

				return -1;

			}

		}

		v->entry[v->cur++] = elemp;

		return v->cur - 1;

	}

	return -1;

}

static void _vector_sort(_psl_vector_t *v)

{

	if (v && v->cmp)

		qsort(v->entry, v->cur, sizeof(_psl_vector_t **), (int(*)(const void *, const void *))v->cmp);

}

/* by this kind of sorting, we can easily see if a domain matches or not */

static int _suffix_compare(const _psl_entry_t *s1, const _psl_entry_t *s2)

{

	int n;

	if ((n = s2->nlabels - s1->nlabels))

		return n; /* most labels first */

	if ((n = s1->length - s2->length))

		return n;  /* shorter rules first */

	return strcmp(s1->label ? s1->label : s1->label_buf, s2->label ? s2->label : s2->label_buf);

}

/* needed to sort array of pointers, given to qsort() */

static int _suffix_compare_array(const _psl_entry_t **s1, const _psl_entry_t **s2)

{

	return _suffix_compare(*s1, *s2);

}

static int _suffix_init(_psl_entry_t *suffix, const char *rule, size_t length)

{

	const char *src;

	char *dst;

	suffix->label = suffix->label_buf;

	if (length >= sizeof(suffix->label_buf) - 1) {

		suffix->nlabels = 0;

		/* fprintf(stderr, _("Suffix rule too long (%zd, ignored): %s\n"), length, rule); */

		return -1;

	}

	suffix->length = (unsigned char)length;

	suffix->nlabels = 1;

	for (dst = suffix->label_buf, src = rule; *src;) {

		if (*src == '.')

			suffix->nlabels++;

		*dst++ = *src++;

	}

	*dst = 0;

	return 0;

}

#if !defined(WITH_LIBIDN) && !defined(WITH_LIBIDN2) && !defined(WITH_LIBICU)

/*

 * When configured without runtime IDNA support (./configure --disable-runtime), we need a pure ASCII

 * representation of non-ASCII characters in labels as found in UTF-8 domain names.

 * This is because the current DAFSA format used may only hold character values [21..127].

 *

  Code copied from http://www.nicemice.net/idn/punycode-spec.gz on

  2011-01-04 with SHA-1 a966a8017f6be579d74a50a226accc7607c40133

  labeled punycode-spec 1.0.3 (2006-Mar-24-Thu).  It is modified for

  libpsl by Tim Rühsen.  License on the original code:

  punycode-spec 1.0.3 (2006-Mar-23-Thu)

  http://www.nicemice.net/idn/

  Adam M. Costello

  http://www.nicemice.net/amc/

  B. Disclaimer and license

    Regarding this entire document or any portion of it (including

    the pseudocode and C code), the author makes no guarantees and

    is not responsible for any damage resulting from its use.  The

    author grants irrevocable permission to anyone to use, modify,

    and distribute it in any way that does not diminish the rights

    of anyone else to use, modify, and distribute it, provided that

    redistributed derivative works do not contain misleading author or

    version information.  Derivative works need not be licensed under

    similar terms.

  C. Punycode sample implementation

  punycode-sample.c 2.0.0 (2004-Mar-21-Sun)

  http://www.nicemice.net/idn/

  Adam M. Costello

  http://www.nicemice.net/amc/

  This is ANSI C code (C89) implementing Punycode 1.0.x.

 */

enum punycode_status {

	punycode_success = 0,

	punycode_bad_input = 1, /* Input is invalid.                       */

	punycode_big_output = 2, /* Output would exceed the space provided. */

	punycode_overflow = 3 /* Wider integers needed to process input. */

};

#ifdef PUNYCODE_UINT

	typedef PUNYCODE_UINT punycode_uint;

#elif UINT_MAX >= (1 << 26) - 1

	typedef unsigned int punycode_uint;

#else

	typedef unsigned long punycode_uint;

#endif

/*** Bootstring parameters for Punycode ***/

enum {

	base = 36, tmin = 1, tmax = 26, skew = 38, damp = 700,

	initial_bias = 72, initial_n = 0x80, delimiter = 0x2D

};

static char encode_digit(punycode_uint d)

{

	return d + 22 + 75 * (d < 26);

	/*  0..25 map to ASCII a..z or A..Z */

	/* 26..35 map to ASCII 0..9         */

}

#define flagged(bcp) ((punycode_uint)(bcp) - 65 < 26)

static const punycode_uint maxint = -1;

static punycode_uint adapt(punycode_uint delta, punycode_uint numpoints, int firsttime)

{

	punycode_uint k;

	delta = firsttime ? delta / damp : delta >> 1;

	/* delta >> 1 is a faster way of doing delta / 2 */

	delta += delta / numpoints;

	for (k = 0; delta > ((base - tmin) * tmax) / 2; k += base) {

		delta /= base - tmin;

	}

	return k + (base - tmin + 1) * delta / (delta + skew);

}

static enum punycode_status punycode_encode(

	size_t input_length_orig,

	const punycode_uint input[],

	size_t *output_length,

	char output[])

{

	punycode_uint input_length, n, delta, h, b, bias, j, m, q, k, t;

	size_t out, max_out;

	/* The Punycode spec assumes that the input length is the same type */

	/* of integer as a code point, so we need to convert the size_t to  */

	/* a punycode_uint, which could overflow.                           */

	if (input_length_orig > maxint)

		return punycode_overflow;

	input_length = (punycode_uint) input_length_orig;

	/* Initialize the state: */

	n = initial_n;

	delta = 0;

	out = 0;

	max_out = *output_length;

	bias = initial_bias;

	/* Handle the basic code points: */

	for (j = 0; j < input_length; ++j) {

		if (input[j] < 0x80) {

			if (max_out - out < 2)

				return punycode_big_output;

			output[out++] = (char) input[j];

		}

		/* else if (input[j] < n) return punycode_bad_input; */

		/* (not needed for Punycode with unsigned code points) */

	}

	h = b = (punycode_uint) out;

	/* cannot overflow because out <= input_length <= maxint */

	/* h is the number of code points that have been handled, b is the  */

	/* number of basic code points, and out is the number of ASCII code */

	/* points that have been output.                                    */

	if (b > 0)

		output[out++] = delimiter;

	/* Main encoding loop: */

	while (h < input_length) {

		/* All non-basic code points < n have been     */

		/* handled already.  Find the next larger one: */

		for (m = maxint, j = 0; j < input_length; ++j) {

			/* if (basic(input[j])) continue; */

			/* (not needed for Punycode) */

			if (input[j] >= n && input[j] < m)

				m = input[j];

		}

		/* Increase delta enough to advance the decoder's    */

		/* <n,i> state to <m,0>, but guard against overflow: */

		if (m - n > (maxint - delta) / (h + 1))

			return punycode_overflow;

		delta += (m - n) * (h + 1);

		n = m;

		for (j = 0; j < input_length; ++j) {

			/* Punycode does not need to check whether input[j] is basic: */

			if (input[j] < n /* || basic(input[j]) */) {

				if (++delta == 0)

					return punycode_overflow;

			}

			if (input[j] == n) {

				/* Represent delta as a generalized variable-length integer: */

				for (q = delta, k = base;; k += base) {

					if (out >= max_out)

						return punycode_big_output;

					t = k <= bias /* + tmin */ ? tmin : /* +tmin not needed */

						k >= bias + tmax ? tmax : k - bias;

					if (q < t)

						break;

					output[out++] = encode_digit(t + (q - t) % (base - t));

					q = (q - t) / (base - t);

				}

				output[out++] = encode_digit(q);

				bias = adapt(delta, h + 1, h == b);

				delta = 0;

				++h;

			}

		}

		++delta, ++n;

	}

	*output_length = out;

	return punycode_success;

}

static ssize_t _utf8_to_utf32(const char *in, size_t inlen, punycode_uint *out, size_t outlen)

{

	size_t n = 0;

	const unsigned char *s = (void *)in;

	const unsigned char *e = (void *)(in + inlen);

	if (!outlen)

		return -1;

	outlen--;

	while (n < outlen) {

		size_t inleft = e - s;

		if (inleft >= 1 && (*s & 0x80) == 0) { /* 0xxxxxxx ASCII char */

			out[n++] = *s;

			s++;

		} else if (inleft >= 2 && (*s & 0xE0) == 0xC0) /* 110xxxxx 10xxxxxx */ {

			if ((s[1] & 0xC0) != 0x80)

				return -1;

			out[n++] = ((*s & 0x1F) << 6) | (s[1] & 0x3F);

			s += 2;

		} else if (inleft >= 3 && (*s & 0xF0) == 0xE0) /* 1110xxxx 10xxxxxx 10xxxxxx */ {

			if ((s[1] & 0xC0) != 0x80 || (s[2] & 0xC0) != 0x80)

				return -1;

			out[n++] = ((*s & 0x0F) << 12) | ((s[1] & 0x3F) << 6) | (s[2] & 0x3F);

			s += 3;

		} else if (inleft >= 4 && (*s & 0xF8) == 0xF0) /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ {

			if ((s[1] & 0xC0) != 0x80 || (s[2] & 0xC0) != 0x80 || (s[3] & 0xC0) != 0x80)

				return -1;

			out[n++] = ((*s & 0x07) << 18) | ((s[1] & 0x3F) << 12) | ((s[1] & 0x3F) << 6) | (s[2] & 0x3F);

			s += 4;

		} else if (!inleft) {

			break;

		} else

			return -1;

	}

	return n;

}

static int _mem_is_ascii(const char *s, size_t n)

{

	for (; n; n--) /* 'while(n--)' generates unsigned integer overflow on n = 0 */

		if (*((unsigned char *)s++) >= 128)

			return 0;

	return 1;

}

static int _domain_to_punycode(const char *domain, char *out, size_t outsize)

{

	size_t outlen = 0, labellen;

	punycode_uint input[256];

	const char *label, *e;

	for (e = label = domain; e; label = e + 1) {

		e = strchr(label, '.');

		labellen = e ? (size_t) (e - label) : strlen(label);

		/* printf("s=%s inlen=%zd\n", label, labellen); */

		if (_mem_is_ascii(label, labellen)) {

			if (outlen + labellen + (e != NULL) >= outsize)

				return 1;

			/* printf("outlen=%zd labellen=%zd\n", outlen, labellen); */

			memcpy(out + outlen, label, labellen);

			outlen += labellen;

		} else {

			ssize_t inputlen = 0;

			if (outlen + labellen + (e != NULL) + 4 >= outsize)

				return 1;

			if ((inputlen = _utf8_to_utf32(label, labellen, input, countof(input))) < 0)

				return 1;

			memcpy(out + outlen, "xn--", 4);

			outlen += 4;

			labellen = outsize - outlen;

			/* printf("n=%zd space_left=%zd\n", n, labellen); */

			if (punycode_encode(inputlen, input, &labellen, out + outlen))

				return 1;

			outlen += labellen;

		}

		if (e)

			out[outlen++] = '.';

		out[outlen] = 0;

	}

	return 0;

}

#endif

static int _isspace_ascii(const char c)

{

	return c == ' ' || c == '\t' || c == '\r' || c == '\n';

}

static int _str_is_ascii(const char *s)

{

	while (*s && *((unsigned char *)s) < 128) s++;

	return !*s;

}

#if defined(WITH_LIBIDN)

/*

 * Work around a libidn <= 1.30 vulnerability.

 *

 * The function checks for a valid UTF-8 character sequence before

 * passing it to idna_to_ascii_8z().

 *

 * [1] https://lists.gnu.org/archive/html/help-libidn/2015-05/msg00002.html

 * [2] https://lists.gnu.org/archive/html/bug-wget/2015-06/msg00002.html

 * [3] https://curl.haxx.se/mail/lib-2015-06/0143.html

 */

static int _utf8_is_valid(const char *utf8)

{

	const unsigned char *s = (const unsigned char *) utf8;

	while (*s) {

		if ((*s & 0x80) == 0) /* 0xxxxxxx ASCII char */

			s++;

		else if ((*s & 0xE0) == 0xC0) /* 110xxxxx 10xxxxxx */ {

			if ((s[1] & 0xC0) != 0x80)

				return 0;

			s += 2;

		} else if ((*s & 0xF0) == 0xE0) /* 1110xxxx 10xxxxxx 10xxxxxx */ {

			if ((s[1] & 0xC0) != 0x80 || (s[2] & 0xC0) != 0x80)

				return 0;

			s += 3;

		} else if ((*s & 0xF8) == 0xF0) /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ {

			if ((s[1] & 0xC0) != 0x80 || (s[2] & 0xC0) != 0x80 || (s[3] & 0xC0) != 0x80)

				return 0;

			s += 4;

		} else

			return 0;

	}

	return 1;

}

#endif

typedef void *_psl_idna_t;

static _psl_idna_t *_psl_idna_open(void)

{

#if defined(WITH_LIBICU)

	UErrorCode status = 0;

	return (void *)uidna_openUTS46(UIDNA_USE_STD3_RULES | UIDNA_NONTRANSITIONAL_TO_ASCII, &status);

#endif

	return NULL;

}

static void _psl_idna_close(_psl_idna_t *idna _UNUSED)

{

#if defined(WITH_LIBICU)

	if (idna)

		uidna_close((UIDNA *)idna);

#endif

}

static int _psl_idna_toASCII(_psl_idna_t *idna _UNUSED, const char *utf8, char **ascii)

{

	int ret = -1;

#if defined(WITH_LIBICU)

	/* IDNA2008 UTS#46 punycode conversion */

	if (idna) {

		char lookupname_buf[128] = "", *lookupname = lookupname_buf;

		UErrorCode status = 0;

		UIDNAInfo info = UIDNA_INFO_INITIALIZER;

		UChar utf16_dst[128], utf16_src_buf[128];

		UChar *utf16_src = utf16_src_buf;

		int32_t utf16_src_length, bytes_written;

		int32_t utf16_dst_length;

		u_strFromUTF8(utf16_src, countof(utf16_src_buf), &utf16_src_length, utf8, -1, &status);

		if (!U_SUCCESS(status)) goto cleanup; /* UTF-8 to UTF-16 conversion failed */

		if (utf16_src_length >= (int) countof(utf16_src_buf)) {

			utf16_src = malloc((utf16_src_length + 1) * sizeof(UChar));

			if (!utf16_src) goto cleanup;

			u_strFromUTF8(utf16_src, utf16_src_length, NULL, utf8, -1, &status);

			if (!U_SUCCESS(status)) goto cleanup; /* UTF-8 to UTF-16 conversion failed */

			utf16_src[utf16_src_length] = 0; /* u_strFromUTF8() doesn't 0-terminate if dest is filled up */

		}

		utf16_dst_length = uidna_nameToASCII((UIDNA *)idna, utf16_src, utf16_src_length, utf16_dst, countof(utf16_dst), &info, &status);

		if (!U_SUCCESS(status)) goto cleanup; /* to ASCII conversion failed */

		u_strToUTF8(lookupname, sizeof(lookupname_buf), &bytes_written, utf16_dst, utf16_dst_length, &status);

		if (!U_SUCCESS(status)) goto cleanup; /* UTF-16 to UTF-8 conversion failed */

		if (bytes_written >= (int) sizeof(lookupname_buf)) {

			lookupname = malloc(bytes_written + 1);

			if (!lookupname) goto cleanup;

			u_strToUTF8(lookupname, bytes_written, NULL, utf16_dst, utf16_dst_length, &status);

			if (!U_SUCCESS(status)) goto cleanup; /* UTF-16 to UTF-8 conversion failed */

			lookupname[bytes_written] = 0; /* u_strToUTF8() doesn't 0-terminate if dest is filled up */

		} else {

			if (!(lookupname = strdup(lookupname)))

				goto cleanup;

		}

		if (ascii) {

			*ascii = lookupname;

			lookupname = NULL;

		}

		ret = 0;

cleanup:

		if (lookupname != lookupname_buf)

			free(lookupname);

		if (utf16_src != utf16_src_buf)

			free(utf16_src);

	}

#elif defined(WITH_LIBIDN2)

#if IDN2_VERSION_NUMBER >= 0x00140000

	int rc;

	/* IDN2_TRANSITIONAL automatically converts to lowercase

	 * IDN2_NFC_INPUT converts to NFC before toASCII conversion

	 * Since IDN2_TRANSITIONAL implicitly does NFC conversion, we don't need

	 * the additional IDN2_NFC_INPUT. But just for the unlikely case that the linked

	 * library is not matching the headers when building and it doesn't support TR46,

	 * we provide IDN2_NFC_INPUT. */

	if ((rc = idn2_lookup_u8((uint8_t *)utf8, (uint8_t **)ascii, IDN2_NFC_INPUT | IDN2_NONTRANSITIONAL)) == IDN2_OK)

		ret = 0;

	/* else

		fprintf(stderr, "toASCII(%s) failed (%d): %s\n", lower, rc, idn2_strerror(rc)); */

#else

	int rc;

	uint8_t *lower;

	size_t len = u8_strlen((uint8_t *)utf8) + 1;

	/* we need a conversion to lowercase */

	if (!(lower = u8_tolower((uint8_t *)utf8, len, 0, UNINORM_NFKC, NULL, &len))) {

		/* fprintf(stderr, "u8_tolower(%s) failed (%d)\n", utf8, errno); */

		return -1;

	}

	if ((rc = idn2_lookup_u8(lower, (uint8_t **)ascii, 0)) == IDN2_OK) {

		ret = 0;

	} /* else

		fprintf(stderr, "toASCII(%s) failed (%d): %s\n", lower, rc, idn2_strerror(rc)); */

	free(lower);

#endif

#elif defined(WITH_LIBIDN)

	int rc;

	if (!_utf8_is_valid(utf8)) {

		/* fprintf(_(stderr, "Invalid UTF-8 sequence not converted: '%s'\n"), utf8); */

		return -1;

	}

	/* idna_to_ascii_8z() automatically converts UTF-8 to lowercase */

	if ((rc = idna_to_ascii_8z(utf8, ascii, IDNA_USE_STD3_ASCII_RULES)) == IDNA_SUCCESS) {

		ret = 0;

	} /* else

		fprintf(_(stderr, "toASCII failed (%d): %s\n"), rc, idna_strerror(rc)); */

#else

	char lookupname[128];

	if (_domain_to_punycode(utf8, lookupname, sizeof(lookupname)) == 0) {

		if (ascii)

			if ((*ascii = strdup(lookupname)))

				ret = 0;

	}

#endif

	return ret;

}

static void _add_punycode_if_needed(_psl_idna_t *idna, _psl_vector_t *v, _psl_entry_t *e)

{

	char *lookupname;

	if (_str_is_ascii(e->label_buf))

		return;

	if (_psl_idna_toASCII(idna, e->label_buf, &lookupname) == 0) {

		if (strcmp(e->label_buf, lookupname)) {

			_psl_entry_t suffix, *suffixp;

			/* fprintf(stderr, "toASCII '%s' -> '%s'\n", e->label_buf, lookupname); */

			if (_suffix_init(&suffix, lookupname, strlen(lookupname)) == 0) {

				suffix.flags = e->flags;

				if ((suffixp = _vector_get(v, _vector_add(v, &suffix))))

					suffixp->label = suffixp->label_buf; /* set label to changed address */

			}

		} /* else ignore */

		free(lookupname);

	}

}

/* prototypes */

int LookupStringInFixedSet(const unsigned char* graph, size_t length, const char* key, size_t key_length);

int GetUtfMode(const unsigned char *graph, size_t length);

static int _psl_is_public_suffix(const psl_ctx_t *psl, const char *domain, int type)

{

	_psl_entry_t suffix;

	const char *p;

	char *punycode = NULL;

	int need_conversion = 0;

	/* this function should be called without leading dots, just make sure */

	if (*domain == '.')

		domain++;

	suffix.nlabels = 1;

	for (p = domain; *p; p++) {

		if (*p == '.')

			suffix.nlabels++;

		else if (*((unsigned char *)p) >= 128)

			need_conversion = 1; /* in case domain is non-ascii we need a toASCII conversion */

	}

	if (suffix.nlabels == 1) {

		/* TLD, this is the prevailing '*' match. If type excludes the '*' rule, continue.

		 */

		if (!(type & PSL_TYPE_NO_STAR_RULE))

			return 1;

	}

	type &= ~PSL_TYPE_NO_STAR_RULE;

	if (psl->utf8 || psl == &_builtin_psl)

		need_conversion = 0;

#if defined(WITH_LIBIDN) || defined(WITH_LIBIDN2) || defined(WITH_LIBICU)

	if (psl == &_builtin_psl)

		need_conversion = 0;

#endif

	if (need_conversion) {

		_psl_idna_t *idna = _psl_idna_open();

		if (_psl_idna_toASCII(idna, domain, &punycode) == 0) {

			suffix.label = punycode;

			suffix.length = strlen(punycode);

		} else {

			/* fallback */

			suffix.label = domain;

			suffix.length = p - suffix.label;

		}

		_psl_idna_close(idna);

	} else {

		suffix.label = domain;

		suffix.length = p - suffix.label;