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, 245 insertions, 0 deletions

diff --git a/src/lib/hash-format.c b/src/lib/hash-format.c
new file mode 100644
index 0000000..41ed495
--- /dev/null
+++ b/src/lib/hash-format.c
@@ -0,0 +1,245 @@
+/* Copyright (c) 2010-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "base64.h"
+#include "hex-binary.h"
+#include "str.h"
+#include "hash-method.h"
+#include "hash-format.h"
+
+enum hash_encoding {
+	HASH_ENCODING_HEX,
+	HASH_ENCODING_HEX_SHORT,
+	HASH_ENCODING_BASE64
+};
+
+struct hash_format_list {
+	struct hash_format_list *next;
+
+	const struct hash_method *method;
+	void *context;
+	unsigned int bits;
+	enum hash_encoding encoding;
+};
+
+struct hash_format {
+	pool_t pool;
+	const char *str;
+
+	struct hash_format_list *list, **pos;
+	unsigned char *digest;
+};
+
+static int
+hash_format_parse(const char *str, unsigned int *idxp,
+		  const struct hash_method **method_r,
+		  unsigned int *bits_r, const char **error_r)
+{
+	const char *name, *end, *bitsp;
+	unsigned int bits, i = *idxp;
+
+	/* we should have "hash_name}" or "hash_name:bits}" */
+	end = strchr(str+i, '}');
+	if (end == NULL) {
+		*error_r = "Missing '}'";
+		return -1;
+	}
+	*idxp = end - str;
+	name = t_strdup_until(str+i, end);
+
+	bitsp = strchr(name, ':');
+	if (bitsp != NULL)
+		name = t_strdup_until(name, bitsp++);
+
+	*method_r = hash_method_lookup(name);
+	if (*method_r == NULL) {
+		*error_r = t_strconcat("Unknown hash method: ", name, NULL);
+		return -1;
+	}
+
+	bits = (*method_r)->digest_size * 8;
+	if (bitsp != NULL) {
+		if (str_to_uint(bitsp, &bits) < 0 ||
+		    bits == 0 || bits > (*method_r)->digest_size*8) {
+			*error_r = t_strconcat("Invalid :bits number: ",
+					       bitsp, NULL);
+			return -1;
+		}
+		if ((bits % 8) != 0) {
+			*error_r = t_strconcat(
+				"Currently :bits must be divisible by 8: ",
+				bitsp, NULL);
+			return -1;
+		}
+	}
+	*bits_r = bits;
+	return 0;
+}
+
+static int
+hash_format_string_analyze(struct hash_format *format, const char *str,
+			   const char **error_r)
+{
+	struct hash_format_list *list;
+	unsigned int i;
+
+	for (i = 0; str[i] != '\0'; i++) {
+		if (str[i] != '%')
+			continue;
+		i++;
+
+		list = p_new(format->pool, struct hash_format_list, 1);
+		list->encoding = HASH_ENCODING_HEX;
+		*format->pos = list;
+		format->pos = &list->next;
+
+		if (str[i] == 'B') {
+			list->encoding = HASH_ENCODING_BASE64;
+			i++;
+		} else if (str[i] == 'X') {
+			list->encoding = HASH_ENCODING_HEX_SHORT;
+			i++;
+		}
+		if (str[i++] != '{') {
+			*error_r = "No '{' after '%'";
+			return -1;
+		}
+		if (hash_format_parse(str, &i, &list->method,
+				      &list->bits, error_r) < 0)
+			return -1;
+		list->context = p_malloc(format->pool,
+					 list->method->context_size);
+		list->method->init(list->context);
+	}
+	return 0;
+}
+
+int hash_format_init(const char *format_string, struct hash_format **format_r,
+		     const char **error_r)
+{
+	struct hash_format *format;
+	pool_t pool;
+	int ret;
+
+	pool = pool_alloconly_create("hash format", 1024);
+	format = p_new(pool, struct hash_format, 1);
+	format->pool = pool;
+	format->str = p_strdup(pool, format_string);
+	format->pos = &format->list;
+	T_BEGIN {
+		ret = hash_format_string_analyze(format, format_string,
+						 error_r);
+		if (ret < 0)
+			*error_r = p_strdup(format->pool, *error_r);
+	} T_END;
+	if (ret < 0) {
+		*error_r = t_strdup(*error_r);
+		pool_unref(&pool);
+		return -1;
+	}
+	*format_r = format;
+	return 0;
+}
+
+void hash_format_loop(struct hash_format *format,
+		      const void *data, size_t size)
+{
+	struct hash_format_list *list;
+
+	for (list = format->list; list != NULL; list = list->next)
+		list->method->loop(list->context, data, size);
+}
+
+void hash_format_reset(struct hash_format *format)
+{
+	struct hash_format_list *list;
+
+	for (list = format->list; list != NULL; list = list->next) {
+		memset(list->context, 0, list->method->context_size);
+		list->method->init(list->context);
+	}
+}
+
+static void
+hash_format_digest(string_t *dest, const struct hash_format_list *list,
+		   const unsigned char *digest)
+{
+	unsigned int i, orig_len, size = list->bits / 8;
+	
+	i_assert(list->bits % 8 == 0);
+
+	switch (list->encoding) {
+	case HASH_ENCODING_HEX:
+		binary_to_hex_append(dest, digest, size);
+		break;
+	case HASH_ENCODING_HEX_SHORT:
+		orig_len = str_len(dest);
+		binary_to_hex_append(dest, digest, size);
+		/* drop leading zeros, except if it's the only one */
+		for (i = orig_len; i < str_len(dest); i++) {
+			if (str_data(dest)[i] != '0')
+				break;
+		}
+		if (i == str_len(dest)) i--;
+		str_delete(dest, orig_len, i-orig_len);
+		break;
+	case HASH_ENCODING_BASE64:
+		orig_len = str_len(dest);
+		base64_encode(digest, size, dest);
+		/* drop trailing '=' chars */
+		while (str_len(dest) > orig_len &&
+		       str_data(dest)[str_len(dest)-1] == '=')
+			str_truncate(dest, str_len(dest)-1);
+		break;
+	}
+}
+
+void hash_format_write(struct hash_format *format, string_t *dest)
+{
+	struct hash_format_list *list;
+	const char *p;
+	unsigned int i, max_digest_size = 0;
+
+	for (list = format->list; list != NULL; list = list->next) {
+		if (max_digest_size < list->method->digest_size)
+			max_digest_size = list->method->digest_size;
+	}
+	if (format->digest == NULL)
+		format->digest = p_malloc(format->pool, max_digest_size);
+
+	list = format->list;
+	for (i = 0; format->str[i] != '\0'; i++) {
+		if (format->str[i] != '%') {
+			str_append_c(dest, format->str[i]);
+			continue;
+		}
+
+		/* we already verified that the string is ok */
+		i_assert(list != NULL);
+		list->method->result(list->context, format->digest);
+		hash_format_digest(dest, list, format->digest);
+		list = list->next;
+
+		p = strchr(format->str+i, '}');
+		i_assert(p != NULL);
+		i = p - format->str;
+	}
+}
+
+void hash_format_deinit(struct hash_format **_format, string_t *dest)
+{
+	struct hash_format *format = *_format;
+
+	*_format = NULL;
+
+	hash_format_write(format, dest);
+	pool_unref(&format->pool);
+}
+
+void hash_format_deinit_free(struct hash_format **_format)
+{
+	struct hash_format *format = *_format;
+
+	*_format = NULL;
+	pool_unref(&format->pool);
+}