rspamd/contrib/librdns/punycode.c

/*
 * Copyright (c) 2014, Vsevolod Stakhov
 * Copyright (c) 2004, 2006, 2007, 2008 Kungliga Tekniska Högskolan
 * (Royal Institute of Technology, Stockholm, Sweden).
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of the Institute 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 INSTITUTE 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 INSTITUTE 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.
 */

#include "dns_private.h"
static const unsigned event_loop = 36;
static const unsigned t_min = 1;
static const unsigned t_max = 26;
static const unsigned skew = 38;
static const unsigned damp = 700;
static const unsigned initial_n = 128;
static const unsigned initial_bias = 72;
/* Punycode utility */
static unsigned int
digit (unsigned n)
{
	static const char ascii[] = "abcdefghijklmnopqrstuvwxyz0123456789";
	return ascii[n];
}

static unsigned int
adapt (unsigned int delta, unsigned int numpoints, int first)
{
	unsigned int k;

	if (first) {
		delta = delta / damp;
	}
	else {
		delta /= 2;
	}
	delta += delta / numpoints;
	k = 0;
	while (delta > ((event_loop - t_min) * t_max) / 2) {
		delta /= event_loop - t_min;
		k += event_loop;
	}
	return k + (((event_loop - t_min + 1) * delta) / (delta + skew));
}

/**
 * Convert an UCS4 string to a puny-coded DNS label string suitable
 * when combined with delimiters and other labels for DNS lookup.
 *
 * @param in an UCS4 string to convert
 * @param in_len the length of in.
 * @param out the resulting puny-coded string. The string is not NULL
 * terminated.
 * @param out_len before processing out_len should be the length of
 * the out variable, after processing it will be the length of the out
 * string.
 *
 * @return returns 0 on success, an wind error code otherwise
 */

bool
rdns_punycode_label_toascii (const uint32_t *in, size_t in_len, char *out,
		size_t *out_len)
{
	unsigned int n = initial_n;
	unsigned int delta = 0;
	unsigned int bias = initial_bias;
	unsigned int h = 0;
	unsigned int b;
	unsigned int i;
	unsigned int o = 0;
	unsigned int m;

	for (i = 0; i < in_len; ++i) {
		if (in[i] < 0x80) {
			++h;
			if (o >= *out_len) {
				return false;
			}
			out[o++] = in[i];
		}
	}
	b = h;
	if (b > 0) {
		if (o >= *out_len) {
			return false;
		}
		out[o++] = 0x2D;
	}
	/* is this string punycoded */
	if (h < in_len) {
		if (o + 4 >= *out_len) {
			return false;
		}
		memmove (out + 4, out, o);
		memcpy (out, "xn--", 4);
		o += 4;
	}

	while (h < in_len) {
		m = (unsigned int) -1;
		for (i = 0; i < in_len; ++i) {

			if (in[i] < m && in[i] >= n) {
				m = in[i];
			}
		}
		delta += (m - n) * (h + 1);
		n = m;
		for (i = 0; i < in_len; ++i) {
			if (in[i] < n) {
				++delta;
			}
			else if (in[i] == n) {
				unsigned int q = delta;
				unsigned int k;
				for (k = event_loop;; k += event_loop) {
					unsigned int t;
					if (k <= bias) {
						t = t_min;
					}
					else if (k >= bias + t_max) {
						t = t_max;
					}
					else {
						t = k - bias;
					}
					if (q < t) {
						break;
					}
					if (o >= *out_len) {
						return -1;
					}
					out[o++] = digit (t + ((q - t) % (event_loop - t)));
					q = (q - t) / (event_loop - t);
				}
				if (o >= *out_len) {
					return -1;
				}
				out[o++] = digit (q);
				/* output */
				bias = adapt (delta, h + 1, h == b);
				delta = 0;
				++h;
			}
		}
		++delta;
		++n;
	}

	*out_len = o;
	return true;
}

static int
utf8toutf32 (const unsigned char **pp, uint32_t *out, size_t *remain)
{
	const unsigned char *p = *pp;
	unsigned c = *p;
	size_t reduce;

	if (c & 0x80) {
		if ((c & 0xE0) == 0xC0 && *remain >= 2) {
			const unsigned c2 = *++p;
			reduce = 2;
			if ((c2 & 0xC0) == 0x80) {
				*out = ((c & 0x1F) << 6) | (c2 & 0x3F);
			}
			else {
				return -1;
			}
		}
		else if ((c & 0xF0) == 0xE0 && *remain >= 3) {
			const unsigned c2 = *++p;
			if ((c2 & 0xC0) == 0x80) {
				const unsigned c3 = *++p;
				reduce = 3;
				if ((c3 & 0xC0) == 0x80) {
					*out = ((c & 0x0F) << 12) | ((c2 & 0x3F) << 6)
							| (c3 & 0x3F);
				}
				else {
					return -1;
				}
			}
			else {
				return -1;
			}
		}
		else if ((c & 0xF8) == 0xF0 && *remain >= 4) {
			const unsigned c2 = *++p;
			if ((c2 & 0xC0) == 0x80) {
				const unsigned c3 = *++p;
				if ((c3 & 0xC0) == 0x80) {
					const unsigned c4 = *++p;
					reduce = 4;
					if ((c4 & 0xC0) == 0x80) {
						*out = ((c & 0x07) << 18) | ((c2 & 0x3F) << 12)
								| ((c3 & 0x3F) << 6) | (c4 & 0x3F);
					}
					else {
						return -1;
					}
				}
				else {
					return -1;
				}
			}
			else {
				return -1;
			}
		}
		else {
			return -1;
		}
	}
	else {
		*out = c;
		reduce = 1;
	}

	*pp = ++p;
	*remain -= reduce;

	return 0;
}

/**
 * Convert an UTF-8 string to an UCS4 string.
 *
 * @param in an UTF-8 string to convert.
 * @param out the resulting UCS4 string
 * @param out_len before processing out_len should be the length of
 * the out variable, after processing it will be the length of the out
 * string.
 *
 * @return returns 0 on success, an -1 otherwise
 * @ingroup wind
 */

int
rdns_utf8_to_ucs4 (const char *in, size_t in_len, uint32_t **out, size_t *out_len)
{
	const unsigned char *p;
	size_t remain = in_len, olen = 0;
	int ret;
	uint32_t *res;

	p = (const unsigned char *)in;
	while (remain > 0) {
		uint32_t u;

		ret = utf8toutf32 (&p, &u, &remain);
		if (ret != 0) {
			return ret;
		}

		olen ++;
	}
	res = malloc (olen * sizeof (uint32_t));
	if (res == NULL) {
		return -1;
	}

	p = (const unsigned char *)in;
	remain = in_len;
	olen = 0;
	while (remain > 0) {
		uint32_t u;

		(void)utf8toutf32 (&p, &u, &remain);
		res[olen++] = u;
	}

	*out_len = olen;
	*out = res;
	return 0;
}