Adding upstream version 1:2.3.19.1+dfsg1.upstream/1%2.3.19.1+dfsg1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 358 insertions, 0 deletions

diff --git a/src/lib/strescape.c b/src/lib/strescape.c
new file mode 100644
index 0000000..bfa4473
--- /dev/null
+++ b/src/lib/strescape.c
@@ -0,0 +1,358 @@
+/* Copyright (c) 2003-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "str.h"
+#include "strescape.h"
+
+const char *str_nescape(const void *str, size_t len)
+{
+	string_t *dest = t_str_new(len*2);
+	str_append_escaped(dest, str, len);
+	return str_c(dest);
+}
+
+void str_append_escaped(string_t *dest, const void *src, size_t src_size)
+{
+	const unsigned char *pstart = src, *p = src, *pend = pstart + src_size;
+	/* see if we need to quote it */
+	for (; p < pend; p++) {
+		if (IS_ESCAPED_CHAR(*p))
+			break;
+	}
+
+	/* quote */
+	str_append_data(dest, pstart, (size_t)(p - pstart));
+
+	for (; p < pend; p++) {
+		if (IS_ESCAPED_CHAR(*p))
+			str_append_c(dest, '\\');
+		str_append_data(dest, p, 1);
+	}
+}
+
+void str_append_unescaped(string_t *dest, const void *src, size_t src_size)
+{
+	const unsigned char *src_c = src;
+	size_t start = 0, i = 0;
+
+	while (i < src_size) {
+		for (; i < src_size; i++) {
+			if (src_c[i] == '\\')
+				break;
+		}
+
+		str_append_data(dest, src_c + start, i-start);
+
+		if (i < src_size) {
+			if (++i == src_size)
+				break;
+			str_append_c(dest, src_c[i++]);
+		}
+		start = i;
+	}
+}
+
+char *str_unescape(char *str)
+{
+	/* @UNSAFE */
+	char *dest, *start = str;
+
+	while (*str != '\\') {
+		if (*str == '\0')
+			return start;
+		str++;
+	}
+
+	for (dest = str; *str != '\0'; str++) {
+		if (*str == '\\') {
+			str++;
+			if (*str == '\0')
+				break;
+		}
+
+		*dest++ = *str;
+	}
+
+	*dest = '\0';
+	return start;
+}
+
+int str_unescape_next(const char **str, const char **unescaped_r)
+{
+	const char *p;
+	char *escaped;
+	bool esc_found = FALSE;
+
+	for (p = *str; *p != '\0'; p++) {
+		if (*p == '"')
+			break;
+		else if (*p == '\\') {
+			if (p[1] == '\0')
+				return -1;
+			esc_found = TRUE;
+			p++;
+		}
+	}
+	if (*p != '"')
+		return -1;
+	escaped = p_strdup_until(unsafe_data_stack_pool, *str, p);
+	*str = p+1;
+	*unescaped_r = !esc_found ? escaped : str_unescape(escaped);
+	return 0;
+}
+
+void str_append_tabescaped_n(string_t *dest, const unsigned char *src, size_t src_size)
+{
+	size_t prev_pos = 0;
+	char esc[2] = { '\001', '\0' };
+
+	for (size_t i = 0; i < src_size; i++) {
+		switch (src[i]) {
+		case '\000':
+			esc[1] = '0';
+			break;
+		case '\001':
+			esc[1] = '1';
+			break;
+		case '\t':
+			esc[1] = 't';
+			break;
+		case '\r':
+			esc[1] = 'r';
+			break;
+		case '\n':
+			esc[1] = 'n';
+			break;
+		default:
+			continue;
+		}
+		str_append_data(dest, src + prev_pos, i - prev_pos);
+		str_append_data(dest, esc, 2);
+		prev_pos = i + 1;
+	}
+	str_append_data(dest, src + prev_pos, src_size - prev_pos);
+}
+
+void str_append_tabescaped(string_t *dest, const char *src)
+{
+	size_t pos, prev_pos = 0;
+	char esc[2] = { '\001', '\0' };
+
+	for (;;) {
+		pos = prev_pos + strcspn(src + prev_pos, "\001\t\r\n");
+		str_append_data(dest, src + prev_pos, pos - prev_pos);
+		prev_pos = pos + 1;
+
+		switch (src[pos]) {
+		case '\000':
+			/* end of src string reached */
+			return;
+		case '\001':
+			esc[1] = '1';
+			break;
+		case '\t':
+			esc[1] = 't';
+			break;
+		case '\r':
+			esc[1] = 'r';
+			break;
+		case '\n':
+			esc[1] = 'n';
+			break;
+		default:
+			i_unreached();
+		}
+		str_append_data(dest, esc, 2);
+	}
+}
+
+
+const char *str_tabescape(const char *str)
+{
+	string_t *tmp;
+	const char *p;
+
+	if ((p = strpbrk(str, "\001\t\r\n")) != NULL) {
+		tmp = t_str_new(128);
+		str_append_data(tmp, str, p-str);
+		str_append_tabescaped(tmp, p);
+		return str_c(tmp);
+	}
+	return str;
+}
+
+void str_append_tabunescaped(string_t *dest, const void *src, size_t src_size)
+{
+	const unsigned char *src_c = src;
+	size_t start = 0, i = 0;
+
+	while (i < src_size) {
+		for (; i < src_size; i++) {
+			if (src_c[i] == '\001')
+				break;
+		}
+
+		str_append_data(dest, src_c + start, i-start);
+
+		if (i < src_size) {
+			i++;
+			if (i < src_size) {
+				switch (src_c[i]) {
+				case '0':
+					str_append_c(dest, '\000');
+					break;
+				case '1':
+					str_append_c(dest, '\001');
+					break;
+				case 't':
+					str_append_c(dest, '\t');
+					break;
+				case 'r':
+					str_append_c(dest, '\r');
+					break;
+				case 'n':
+					str_append_c(dest, '\n');
+					break;
+				default:
+					str_append_c(dest, src_c[i]);
+					break;
+				}
+				i++;
+			}
+		}
+		start = i;
+	}
+}
+
+static char *str_tabunescape_from(char *str, char *src)
+{
+	/* @UNSAFE */
+	char *dest, *p;
+
+	dest = src;
+	for (;;) {
+		switch (src[1]) {
+		case '\0':
+			/* truncated input */
+			*dest = '\0';
+			return str;
+		case '0':
+			*dest++ = '\000';
+			break;
+		case '1':
+			*dest++ = '\001';
+			break;
+		case 't':
+			*dest++ = '\t';
+			break;
+		case 'r':
+			*dest++ = '\r';
+			break;
+		case 'n':
+			*dest++ = '\n';
+			break;
+		default:
+			*dest++ = src[1];
+			break;
+		}
+		src += 2;
+
+		p = strchr(src, '\001');
+		if (p == NULL) {
+			memmove(dest, src, strlen(src)+1);
+			break;
+		}
+
+		size_t copy_len = p - src;
+		memmove(dest, src, copy_len);
+		dest += copy_len;
+		src = p;
+	}
+	return str;
+}
+
+char *str_tabunescape(char *str)
+{
+	char *src = strchr(str, '\001');
+	if (src == NULL) {
+		/* no unescaping needed */
+		return str;
+	}
+	return str_tabunescape_from(str, src);
+}
+
+const char *t_str_tabunescape(const char *str)
+{
+	const char *p;
+
+	p = strchr(str, '\001');
+	if (p == NULL)
+		return str;
+
+	char *dest = t_strdup_noconst(str);
+	return str_tabunescape_from(dest, dest + (p - str));
+}
+
+static char **p_strsplit_tabescaped_inplace(pool_t pool, char *data)
+{
+	/* @UNSAFE */
+	char **array;
+	unsigned int count, new_alloc_count, alloc_count;
+
+	if (*data == '\0')
+		return p_new(pool, char *, 1);
+
+	alloc_count = 32;
+	array = pool == unsafe_data_stack_pool ?
+		t_malloc_no0(sizeof(char *) * alloc_count) :
+		p_malloc(pool, sizeof(char *) * alloc_count);
+
+	array[0] = data; count = 1;
+	char *need_unescape = NULL;
+	while ((data = strpbrk(data, "\t\001")) != NULL) {
+		/* separator or escape char found */
+		if (*data == '\001') {
+			if (need_unescape == NULL)
+				need_unescape = data;
+			data++;
+			continue;
+		}
+		if (count+1 >= alloc_count) {
+			new_alloc_count = nearest_power(alloc_count+1);
+			array = p_realloc(pool, array,
+					  sizeof(char *) * alloc_count,
+					  sizeof(char *) *
+					  new_alloc_count);
+			alloc_count = new_alloc_count;
+		}
+		*data++ = '\0';
+		if (need_unescape != NULL) {
+			str_tabunescape_from(array[count-1], need_unescape);
+			need_unescape = NULL;
+		}
+		array[count++] = data;
+	}
+	if (need_unescape != NULL)
+		str_tabunescape_from(array[count-1], need_unescape);
+	i_assert(count < alloc_count);
+	array[count] = NULL;
+
+	return array;
+}
+
+const char *const *t_strsplit_tabescaped_inplace(char *data)
+{
+	char *const *escaped =
+		p_strsplit_tabescaped_inplace(unsafe_data_stack_pool, data);
+	return (const char *const *)escaped;
+}
+
+char **p_strsplit_tabescaped(pool_t pool, const char *str)
+{
+	return p_strsplit_tabescaped_inplace(pool, p_strdup(pool, str));
+}
+
+const char *const *t_strsplit_tabescaped(const char *str)
+{
+	return t_strsplit_tabescaped_inplace(t_strdup_noconst(str));
+}